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