![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to symtab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / picasso|
Return to symtab.c CVS log | Up to [Research Unix] / researchv10no / cmd / picasso |
1.1 ! root 1: /* Copyright (c) 1988 AT&T */ ! 2: /* All Rights Reserved */ ! 3: ! 4: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T */ ! 5: /* The copyright notice above does not evidence any */ ! 6: /* actual or intended publication of such source code. */ ! 7: ! 8: /* @(#)picasso:symtab.c 1.0 */ ! 9: #include <ctype.h> ! 10: #include "picasso.h" ! 11: #include "y.tab.h" ! 12: ! 13: YYSTYPE getvar(s) /* return value of variable s (usually pointer) */ ! 14: char *s; ! 15: { ! 16: struct symtab *p; ! 17: static YYSTYPE bug; ! 18: ! 19: p = lookup(s); ! 20: if (p == NULL) { ! 21: if (islower(s[0])) ! 22: yyerror("no such variable as %s", s); ! 23: else ! 24: yyerror("no such place as %s", s); ! 25: return(bug); ! 26: } ! 27: if (s != p->s_name) free(s); ! 28: return(p->s_val); ! 29: } ! 30: ! 31: double getsub(s, n) ! 32: char *s; ! 33: int n; ! 34: { ! 35: struct symtab *p; ! 36: ! 37: p = lookup(s); ! 38: if (p == NULL) ! 39: fatal("array %s not declared", s); ! 40: else if (n > p->s_dim) ! 41: fatal("variable %s has dimension %d < %d", s, p->s_dim, n); ! 42: else if (p->s_dim == 0) ! 43: return p->s_val.f; ! 44: else ! 45: return p->s_val.a[n-1]; ! 46: } ! 47: ! 48: double setvar(s, n, v) ! 49: char *s; ! 50: int n; ! 51: double v; ! 52: { ! 53: struct symtab *p; ! 54: ! 55: p = lookup(s); ! 56: if (p == NULL) ! 57: fatal("array %s not declared", s); ! 58: else if (n > p->s_dim) ! 59: fatal("variable %s has dimension %d < %d", s, p->s_dim, n); ! 60: else if (p->s_dim == 0) ! 61: p->s_val.f = v; ! 62: else ! 63: p->s_val.a[n-1] = v; ! 64: if (s != p->s_name) free(s); ! 65: return v; ! 66: } ! 67: ! 68: double setsize(s, v) /* kludge: textsize = v implies textspace = v * r */ ! 69: char *s; ! 70: double v; ! 71: { ! 72: double r; ! 73: struct symtab *p, *q; ! 74: ! 75: p = lookup(s); ! 76: q = lookup("textspace"); ! 77: r = q->s_val.f/p->s_val.f; ! 78: q->s_val.f = v * r; ! 79: p->s_val.f = v; ! 80: return v; ! 81: } ! 82: ! 83: struct symtab *newvar(s, t) /* allocate variable with name s, type t */ ! 84: char *s; /* assumes s derives from a tostring */ ! 85: int t; ! 86: { ! 87: struct symtab *p; ! 88: ! 89: p = (struct symtab *) malloc(sizeof(struct symtab)); ! 90: if (p == NULL) { ! 91: yyerror("out of symtab space with %s", s); ! 92: exit(1); ! 93: } ! 94: p->s_name = s; ! 95: p->s_type = t; ! 96: p->s_dim = 0; ! 97: p->s_next = stack[nstack].p_symtab; ! 98: stack[nstack].p_symtab = p; /* stick it at front */ ! 99: return(p); ! 100: } ! 101: ! 102: struct symtab *findvar(s, t) /* make variable named s in table */ ! 103: char *s; /* will reuse local or global symbol */ ! 104: { ! 105: struct symtab *p; ! 106: ! 107: if ((p = lookup(s)) == NULL) ! 108: p = newvar(s, t); ! 109: if (s != p->s_name) free(s); ! 110: return(p); ! 111: } ! 112: ! 113: double setarray(s) ! 114: char *s; ! 115: { ! 116: struct symtab *p; ! 117: ! 118: p = findvar (s, VARNAME); ! 119: if (p->s_dim < nexpr-1) { /* existing array is too short */ ! 120: if (p->s_dim > 0) ! 121: free (p->s_val.a); ! 122: } ! 123: if ((p->s_dim = nexpr-1) > 0) { ! 124: p->s_val.a = (float *)malloc((unsigned)nexpr * sizeof(float)); ! 125: if (p->s_val.a == NULL) ! 126: fatal("out of array space with %s", p->s_name); ! 127: } ! 128: if (p->s_dim == 0) ! 129: p->s_val.f = exprlist[0]; ! 130: else ! 131: memcpy ((char *)p->s_val.a, (char *)exprlist, ! 132: nexpr * sizeof(float)); ! 133: nexpr = 0; ! 134: return exprlist[0]; ! 135: } ! 136: ! 137: double getfval(s) /* return float value of variable s */ ! 138: char *s; ! 139: { ! 140: struct symtab *p; ! 141: ! 142: if ((p = lookup(s)) == NULL) { ! 143: yyerror("%s undefined", s); ! 144: return 0.; ! 145: } ! 146: else if (p->s_dim == 0) ! 147: return p->s_val.f; ! 148: else /* should probably place all */ ! 149: return (double)*p->s_val.a; /* array values in exprlist. */ ! 150: } ! 151: ! 152: setfval(s, f) /* set variable s to f */ ! 153: char *s; ! 154: double f; ! 155: { ! 156: struct symtab *p; ! 157: ! 158: if ((p = lookup(s)) == NULL) ! 159: p = newvar(s, VARNAME); ! 160: if (p->s_dim == 0) ! 161: p->s_val.f = f; ! 162: else ! 163: *p->s_val.a = f; ! 164: } ! 165: ! 166: struct symtab *makevar(s, t, v) /* make variable named s in table */ ! 167: char *s; /* assumes s is static or from tostring */ ! 168: int t; /* if s is already defined as an array, */ ! 169: valtype v; /* only its first element is set. */ ! 170: { ! 171: struct symtab *p; ! 172: obj *o; ! 173: ! 174: for (p = stack[nstack].p_symtab; p != NULL; p = p->s_next) ! 175: if (strcmp(s, p->s_name) == 0) ! 176: break; ! 177: if (p == NULL) ! 178: p = newvar(s, t); ! 179: #if 1 ! 180: /* seems like a PLACENAME should always point to an object */ ! 181: if (t == PLACENAME) { ! 182: for (o = objhead; o->o_next != objtail; o = o->o_next) ! 183: if (o == v.o) ! 184: break; ! 185: v.o = o; ! 186: } ! 187: #endif ! 188: if (p->s_dim == 0) ! 189: p->s_val = v; ! 190: else ! 191: *p->s_val.a = v.f; ! 192: if (s != p->s_name) free(s); ! 193: return(p); ! 194: } ! 195: ! 196: struct symtab *lookup(s) /* find s in symtab */ ! 197: char *s; ! 198: { ! 199: int i; ! 200: struct symtab *p; ! 201: ! 202: for (i = nstack; i >= 0; i--) /* look in each active symtab */ ! 203: for (p = stack[i].p_symtab; p != NULL; p = p->s_next) ! 204: if (strcmp(s, p->s_name) == 0) ! 205: return(p); ! 206: return(NULL); ! 207: } ! 208: ! 209: freesymtab(p) /* free space used by symtab at p */ ! 210: struct symtab *p; ! 211: { ! 212: struct symtab *q; ! 213: ! 214: for ( ; p != NULL; p = q) { ! 215: q = p->s_next; ! 216: free(p->s_name); /* assumes done with tostring */ ! 217: if (p->s_dim) ! 218: free(p->s_val.a); ! 219: free(p); ! 220: } ! 221: } ! 222: ! 223: freedef(s) /* free definition for string s */ ! 224: char *s; ! 225: { ! 226: struct symtab *p, *q, *op; ! 227: ! 228: for (p = op = q = stack[nstack].p_symtab; p != NULL; p = p->s_next) { ! 229: if (strcmp(s, p->s_name) == 0) { /* got it */ ! 230: if (p->s_type != DEFNAME) ! 231: break; ! 232: if (p == op) /* 1st elem */ ! 233: stack[nstack].p_symtab = p->s_next; ! 234: else ! 235: q->s_next = p->s_next; ! 236: free(p->s_name); ! 237: free(p->s_val.p); ! 238: free(p); ! 239: return; ! 240: } ! 241: q = p; ! 242: } ! 243: yyerror("%s is not defined at this point", s); ! 244: } ! 245: ! 246: static int i, M; ! 247: ! 248: first_xy (xsym, ysym, xp, yp) ! 249: struct symtab *xsym, *ysym; ! 250: double *xp, *yp; ! 251: { ! 252: if ((M = xsym->s_dim) == 0) ! 253: *xp = xsym->s_val.f; ! 254: else ! 255: *xp = xsym->s_val.a[0]; ! 256: if (ysym->s_dim == 0) ! 257: *yp = ysym->s_val.f; ! 258: else ! 259: *yp = ysym->s_val.a[0]; ! 260: if (ysym->s_dim > M) ! 261: M = ysym->s_dim; ! 262: i = 0; ! 263: } ! 264: ! 265: next_xy (xsym, ysym, xp, yp) ! 266: struct symtab *xsym, *ysym; ! 267: double *xp, *yp; ! 268: { ! 269: if (++i > M) ! 270: return 0; ! 271: if (xsym->s_dim == 0) ! 272: *xp = xsym->s_val.f; ! 273: else ! 274: *xp = xsym->s_val.a[i % (xsym->s_dim+1)]; ! 275: if (ysym->s_dim == 0) ! 276: *yp = ysym->s_val.f; ! 277: else ! 278: *yp = ysym->s_val.a[i % (ysym->s_dim+1)]; ! 279: return 1; ! 280: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.