Annotation of freem/src/mref.c, revision 1.1
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: }
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