Annotation of freem/src/mref.c, revision 1.5
1.1 snw 1: /*
1.5 ! snw 2: * $Id: mref.c,v 1.4 2025/03/09 19:50:47 snw Exp $
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.5 ! snw 26: * $Log: mref.c,v $
! 27: * Revision 1.4 2025/03/09 19:50:47 snw
! 28: * Second phase of REUSE compliance and header reformat
! 29: *
1.4 snw 30: *
31: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
32: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 33: **/
34:
35: #include <stdio.h>
36: #include <stdlib.h>
37: #include <string.h>
38: #include <mpsdef0.h>
39:
40: #include "freem.h"
41:
42: #define MREF_CHECK(ref,index,type) if (ref->status != MREF_ST_INIT || index > 255 || index < 0) return (type) NULL
1.2 snw 43: #define MREF_CHECK_EXIT(ref,index,type) if (ref->status != MREF_ST_INIT || index > 255 || index < 0) exit (type) NULL
1.1 snw 44:
45: extern short g_numeric (char *str);
46:
47: freem_ref_t *mref_init (freem_ref_t *ref, short ref_type, char *name)
48: {
49: if (strlen (name) > 255) {
50: ref->status = MREF_ST_ERR;
51: return ref;
52: }
53:
54: ref->reftype = ref_type;
55: ref->status = MREF_ST_INIT;
56: strncpy (ref->name, name, 255);
57: ref->subscript_count = 0;
58:
59: return ref;
60: }
61:
62: char *mref_get_name (freem_ref_t *ref)
63: {
64: MREF_CHECK (ref, 0, char *);
65:
66: return ref->name;
67: }
68:
69: char *mref_get_subscript (freem_ref_t *ref, int index)
70: {
71: /* ref must be initialized, and index within range */
72: MREF_CHECK (ref, index, char *);
73:
74: return ref->subscripts[index];
75: }
76:
77: freem_ref_t *mref_set_subscript (freem_ref_t *ref, int index, char *value)
78: {
79: MREF_CHECK (ref, index, freem_ref_t *);
80:
81: if (ref->subscript_count == 0 && index == 0) ref->subscript_count = 1;
82:
83: if (ref->subscript_count < (index + 1)) {
84: ref->subscript_count = index + 1;
85: }
86:
87: strncpy (ref->subscripts[index], value, 255);
88:
89: return ref;
90: }
91:
92: void mref_to_internal_prealloc (char *res, freem_ref_t *ref)
93: {
94: register int i;
95:
1.2 snw 96: /* MREF_CHECK (ref, 0, char *); */
1.1 snw 97:
98: strncpy (res, ref->name, STRLEN - 1);
99:
100: for (i = 0; i < ref->subscript_count; i++) {
101: strncat (res, "\202", STRLEN - 1);
102: strncat (res, ref->subscripts[i], STRLEN - 1);
103: }
104:
105: strncat (res, "\201", STRLEN - 1);
106: stcnv_c2m (res);
107:
108: }
109:
110: char *mref_to_internal (freem_ref_t *ref)
111: {
112:
113: char *tmp = (char *) malloc (STRLEN * sizeof(char));
114: register int i;
115:
116: MREF_CHECK (ref, 0, char *);
117:
118: strncpy (tmp, ref->name, STRLEN - 1);
119:
120: for (i = 0; i < ref->subscript_count; i++) {
121: strncat (tmp, "\202", STRLEN - 1);
122: strncat (tmp, ref->subscripts[i], STRLEN - 1);
123: }
124:
125: strncat (tmp, "\201", STRLEN - 1);
126: stcnv_c2m (tmp);
127:
128: return tmp;
129: }
130:
131: /* convert a DELIM-delimited, EOL-terminated key to a freem_ref_t* */
132: freem_ref_t *internal_to_mref (freem_ref_t *ref, char *key)
133: {
134: register int i;
135: register int j;
136: char *ptr = key;
137: char ch;
138: char *nam = (char *) malloc (STRLEN * sizeof(char));
139: char *tmp = (char *) malloc (STRLEN * sizeof(char));
140:
141: MREF_CHECK (ref, 0, freem_ref_t *);
142:
143: /* shunt the name into ref->name */
144: i = 0;
145: while ((ch = *(ptr++)) != DELIM && ch != EOL) {
146: nam[i++] = ch;
147: }
148:
149: nam[i] = '\0';
150:
151: if (nam[0] == '^') {
152:
153: if (nam[1] == '$') {
154: ref->reftype = MREF_RT_SSVN;
155: }
156: else {
157: ref->reftype = MREF_RT_GLOBAL;
158: }
159:
160: }
161: else {
162: ref->reftype = MREF_RT_LOCAL;
163: }
164:
1.5 ! snw 165: strncpy (ref->name, nam, STRLEN);
1.1 snw 166:
167: /* if no subscripts, return the ref */
168: if (*(ptr - 1) == EOL) {
169: ref->subscript_count = 0;
170:
171: free (nam);
172: free (tmp);
173:
174: return ref;
175: }
176:
177:
178: /* grab the subscripts */
179: i = 0;
180: j = 0;
181: while ((ch = *(ptr++)) != EOL) {
182:
183: switch (ch) {
184:
185: case '\001':
186: break;
187: case DELIM:
188:
189: tmp[j] = '\0';
190:
191: mref_set_subscript (ref, i++, tmp);
192: ref->subscript_count++;
193:
194: j = 0;
195: tmp[j] = '\0';
196:
197: break;
198:
199:
200: default:
201: tmp[j++] = ch;
202:
203: }
204:
205: }
206:
207: tmp[j] = '\0';
208:
209: /* grab the last one */
210: mref_set_subscript (ref, i, tmp);
211:
212: free (nam);
213: free (tmp);
214:
215: return ref;
216:
217: }
218:
219: void mref_to_external (freem_ref_t *ref, char *buf)
220: {
221: register int i;
222: register int j;
223: short is_numeric = FALSE;
224: short is_ref = FALSE;
225: char *t_buf = (char *) malloc (STRLEN * sizeof (char));
226: NULLPTRCHK(t_buf,"mref_to_external");
227:
228: strcpy (buf, ref->name);
229:
230: if (ref->subscript_count) {
231:
232: strcat (buf, "(");
233:
234:
235: for (i = 0; i < ref->subscript_count; i++) {
236:
237: if (ref->subscripts[i][0] == '.') {
238: is_ref = TRUE;
239: }
240: else {
241: is_ref = FALSE;
242: }
243:
244: strcpy (t_buf, ref->subscripts[i]);
245:
246: for (j = 0; j < strlen (t_buf); j++) {
247: if (t_buf[j] == '\001') t_buf[j] = '\201';
248: }
249:
250: stcnv_c2m (t_buf);
251:
252: is_numeric = numeric (t_buf);
253:
254:
255: if (!is_numeric && !is_ref) strcat (buf, "\"");
256:
257: for (j = 0; j < strlen (ref->subscripts[i]); j++) {
258: if (ref->subscripts[i][j] == '\001') ref->subscripts[i][j] = '\201';
259: }
260: strcat (buf, ref->subscripts[i]);
261: if (!is_numeric && !is_ref) strcat (buf, "\"");
262:
263: if (i < (ref->subscript_count - 1)) {
264: strcat (buf, ",");
265: }
266:
267: }
268: stcnv_m2c (buf);
269:
270: strcat (buf, ")");
271:
272: }
273:
274: free (t_buf);
275: return;
276:
277: }
278:
279: /* returns TRUE if b is a descendant of a */
280: short mref_is_descendant(freem_ref_t *a, freem_ref_t *b)
281: {
282: register int i;
283:
284: //printf ("checking if %s is a descendant of %s\r\n", b->name, a->name);
285: //printf ("a: %d b: %d\r\n", a->subscript_count, b->subscript_count);
286:
287: if (a->subscript_count > b->subscript_count) return FALSE;
288: if ((strcmp (a->name, b->name) == 0) && (a->subscript_count == 0)) return TRUE;
289:
290:
291: for (i = 0; i < a->subscript_count; i++) {
292:
293: //printf("\ta[%d] = '%s'\r\n\tb[%d] = '%s'\r\n", i, a->subscripts[i], i, b->subscripts[i]);
294:
295: if (strcmp (b->subscripts[i], a->subscripts[i]) != 0 ) {
296: //printf ("not descendant [%d]\r\n", strcmp (b->subscripts[i], a->subscripts[i]));
297: return FALSE;
298: }
299: }
300:
301: //printf ("is descendant\r\n");
302:
303: return TRUE;
304: }
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