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