Annotation of freem/src/mref.c, revision 1.4
1.1 snw 1: /*
1.4 ! snw 2: * $Id$
1.1 snw 3: * supporting functions for handling freem_ref_t structures
4: *
5: *
1.3 snw 6: * Author: Serena Willis <snw@coherent-logic.com>
1.1 snw 7: * Copyright (C) 1998 MUG Deutschland
1.4 ! snw 8: * Copyright (C) 2020, 2025 Coherent Logic Development LLC
1.1 snw 9: *
10: *
11: * This file is part of FreeM.
12: *
13: * FreeM is free software: you can redistribute it and/or modify
14: * it under the terms of the GNU Affero Public License as published by
15: * the Free Software Foundation, either version 3 of the License, or
16: * (at your option) any later version.
17: *
18: * FreeM is distributed in the hope that it will be useful,
19: * but WITHOUT ANY WARRANTY; without even the implied warranty of
20: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21: * GNU Affero Public License for more details.
22: *
23: * You should have received a copy of the GNU Affero Public License
24: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
25: *
1.4 ! snw 26: * $Log$
! 27: *
! 28: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
! 29: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 30: **/
31:
32: #include <stdio.h>
33: #include <stdlib.h>
34: #include <string.h>
35: #include <mpsdef0.h>
36:
37: #include "freem.h"
38:
39: #define MREF_CHECK(ref,index,type) if (ref->status != MREF_ST_INIT || index > 255 || index < 0) return (type) NULL
1.2 snw 40: #define MREF_CHECK_EXIT(ref,index,type) if (ref->status != MREF_ST_INIT || index > 255 || index < 0) exit (type) NULL
1.1 snw 41:
42: extern short g_numeric (char *str);
43:
44: freem_ref_t *mref_init (freem_ref_t *ref, short ref_type, char *name)
45: {
46: if (strlen (name) > 255) {
47: ref->status = MREF_ST_ERR;
48: return ref;
49: }
50:
51: ref->reftype = ref_type;
52: ref->status = MREF_ST_INIT;
53: strncpy (ref->name, name, 255);
54: ref->subscript_count = 0;
55:
56: return ref;
57: }
58:
59: char *mref_get_name (freem_ref_t *ref)
60: {
61: MREF_CHECK (ref, 0, char *);
62:
63: return ref->name;
64: }
65:
66: char *mref_get_subscript (freem_ref_t *ref, int index)
67: {
68: /* ref must be initialized, and index within range */
69: MREF_CHECK (ref, index, char *);
70:
71: return ref->subscripts[index];
72: }
73:
74: freem_ref_t *mref_set_subscript (freem_ref_t *ref, int index, char *value)
75: {
76: MREF_CHECK (ref, index, freem_ref_t *);
77:
78: if (ref->subscript_count == 0 && index == 0) ref->subscript_count = 1;
79:
80: if (ref->subscript_count < (index + 1)) {
81: ref->subscript_count = index + 1;
82: }
83:
84: strncpy (ref->subscripts[index], value, 255);
85:
86: return ref;
87: }
88:
89: void mref_to_internal_prealloc (char *res, freem_ref_t *ref)
90: {
91: register int i;
92:
1.2 snw 93: /* MREF_CHECK (ref, 0, char *); */
1.1 snw 94:
95: strncpy (res, ref->name, STRLEN - 1);
96:
97: for (i = 0; i < ref->subscript_count; i++) {
98: strncat (res, "\202", STRLEN - 1);
99: strncat (res, ref->subscripts[i], STRLEN - 1);
100: }
101:
102: strncat (res, "\201", STRLEN - 1);
103: stcnv_c2m (res);
104:
105: }
106:
107: char *mref_to_internal (freem_ref_t *ref)
108: {
109:
110: char *tmp = (char *) malloc (STRLEN * sizeof(char));
111: register int i;
112:
113: MREF_CHECK (ref, 0, char *);
114:
115: strncpy (tmp, ref->name, STRLEN - 1);
116:
117: for (i = 0; i < ref->subscript_count; i++) {
118: strncat (tmp, "\202", STRLEN - 1);
119: strncat (tmp, ref->subscripts[i], STRLEN - 1);
120: }
121:
122: strncat (tmp, "\201", STRLEN - 1);
123: stcnv_c2m (tmp);
124:
125: return tmp;
126: }
127:
128: /* convert a DELIM-delimited, EOL-terminated key to a freem_ref_t* */
129: freem_ref_t *internal_to_mref (freem_ref_t *ref, char *key)
130: {
131: register int i;
132: register int j;
133: char *ptr = key;
134: char ch;
135: char *nam = (char *) malloc (STRLEN * sizeof(char));
136: char *tmp = (char *) malloc (STRLEN * sizeof(char));
137:
138: MREF_CHECK (ref, 0, freem_ref_t *);
139:
140: /* shunt the name into ref->name */
141: i = 0;
142: while ((ch = *(ptr++)) != DELIM && ch != EOL) {
143: nam[i++] = ch;
144: }
145:
146: nam[i] = '\0';
147:
148: if (nam[0] == '^') {
149:
150: if (nam[1] == '$') {
151: ref->reftype = MREF_RT_SSVN;
152: }
153: else {
154: ref->reftype = MREF_RT_GLOBAL;
155: }
156:
157: }
158: else {
159: ref->reftype = MREF_RT_LOCAL;
160: }
161:
162: strncpy (ref->name, nam, 256);
163:
164: /* if no subscripts, return the ref */
165: if (*(ptr - 1) == EOL) {
166: ref->subscript_count = 0;
167:
168: free (nam);
169: free (tmp);
170:
171: return ref;
172: }
173:
174:
175: /* grab the subscripts */
176: i = 0;
177: j = 0;
178: while ((ch = *(ptr++)) != EOL) {
179:
180: switch (ch) {
181:
182: case '\001':
183: break;
184: case DELIM:
185:
186: tmp[j] = '\0';
187:
188: mref_set_subscript (ref, i++, tmp);
189: ref->subscript_count++;
190:
191: j = 0;
192: tmp[j] = '\0';
193:
194: break;
195:
196:
197: default:
198: tmp[j++] = ch;
199:
200: }
201:
202: }
203:
204: tmp[j] = '\0';
205:
206: /* grab the last one */
207: mref_set_subscript (ref, i, tmp);
208:
209: free (nam);
210: free (tmp);
211:
212: return ref;
213:
214: }
215:
216: void mref_to_external (freem_ref_t *ref, char *buf)
217: {
218: register int i;
219: register int j;
220: short is_numeric = FALSE;
221: short is_ref = FALSE;
222: char *t_buf = (char *) malloc (STRLEN * sizeof (char));
223: NULLPTRCHK(t_buf,"mref_to_external");
224:
225: strcpy (buf, ref->name);
226:
227: if (ref->subscript_count) {
228:
229: strcat (buf, "(");
230:
231:
232: for (i = 0; i < ref->subscript_count; i++) {
233:
234: if (ref->subscripts[i][0] == '.') {
235: is_ref = TRUE;
236: }
237: else {
238: is_ref = FALSE;
239: }
240:
241: strcpy (t_buf, ref->subscripts[i]);
242:
243: for (j = 0; j < strlen (t_buf); j++) {
244: if (t_buf[j] == '\001') t_buf[j] = '\201';
245: }
246:
247: stcnv_c2m (t_buf);
248:
249: is_numeric = numeric (t_buf);
250:
251:
252: if (!is_numeric && !is_ref) strcat (buf, "\"");
253:
254: for (j = 0; j < strlen (ref->subscripts[i]); j++) {
255: if (ref->subscripts[i][j] == '\001') ref->subscripts[i][j] = '\201';
256: }
257: strcat (buf, ref->subscripts[i]);
258: if (!is_numeric && !is_ref) strcat (buf, "\"");
259:
260: if (i < (ref->subscript_count - 1)) {
261: strcat (buf, ",");
262: }
263:
264: }
265: stcnv_m2c (buf);
266:
267: strcat (buf, ")");
268:
269: }
270:
271: free (t_buf);
272: return;
273:
274: }
275:
276: /* returns TRUE if b is a descendant of a */
277: short mref_is_descendant(freem_ref_t *a, freem_ref_t *b)
278: {
279: register int i;
280:
281: //printf ("checking if %s is a descendant of %s\r\n", b->name, a->name);
282: //printf ("a: %d b: %d\r\n", a->subscript_count, b->subscript_count);
283:
284: if (a->subscript_count > b->subscript_count) return FALSE;
285: if ((strcmp (a->name, b->name) == 0) && (a->subscript_count == 0)) return TRUE;
286:
287:
288: for (i = 0; i < a->subscript_count; i++) {
289:
290: //printf("\ta[%d] = '%s'\r\n\tb[%d] = '%s'\r\n", i, a->subscripts[i], i, b->subscripts[i]);
291:
292: if (strcmp (b->subscripts[i], a->subscripts[i]) != 0 ) {
293: //printf ("not descendant [%d]\r\n", strcmp (b->subscripts[i], a->subscripts[i]));
294: return FALSE;
295: }
296: }
297:
298: //printf ("is descendant\r\n");
299:
300: return TRUE;
301: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mref.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src