Return to symtab.c CVS log

Up to [Research Unix] / researchv10no / cmd / pic

Annotation of researchv10no/cmd/pic/symtab.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <stdlib.h>
                      3: #include <ctype.h>
                      4: #include <string.h>
                      5: #include "pic.h"
                      6: #include "y.tab.h"
                      7: 
                      8: YYSTYPE getvar(char *s)        /* return value of variable s (usually pointer) */
                      9: {
                     10:        struct symtab *p;
                     11:        static YYSTYPE bug;
                     12: 
                     13:        p = lookup(s);
                     14:        if (p == NULL) {
                     15:                if (islower(s[0]))
                     16:                        ERROR "no such variable as %s", s WARNING;
                     17:                else
                     18:                        ERROR "no such place as %s", s WARNING;
                     19:                return(bug);
                     20:        }
                     21:        return(p->s_val);
                     22: }
                     23: 
                     24: double getfval(char *s)        /* return float value of variable s */
                     25: {
                     26:        YYSTYPE y;
                     27: 
                     28:        y = getvar(s);
                     29:        return y.f;
                     30: }
                     31: 
                     32: void setfval(char *s, double f)        /* set variable s to f */
                     33: {
                     34:        struct symtab *p;
                     35: 
                     36:        if ((p = lookup(s)) != NULL)
                     37:                p->s_val.f = f;
                     38: }
                     39: 
                     40: struct symtab *makevar(char *s, int t, YYSTYPE v)      /* make variable named s in table */
                     41:                /* assumes s is static or from tostring */
                     42: {
                     43:        struct symtab *p;
                     44: 
                     45:        for (p = stack[nstack].p_symtab; p != NULL; p = p->s_next)
                     46:                if (strcmp(s, p->s_name) == 0)
                     47:                        break;
                     48:        if (p == NULL) {        /* it's a new one */
                     49:                p = (struct symtab *) malloc(sizeof(struct symtab));
                     50:                if (p == NULL)
                     51:                        ERROR "out of symtab space with %s", s FATAL;
                     52:                p->s_next = stack[nstack].p_symtab;
                     53:                stack[nstack].p_symtab = p;     /* stick it at front */
                     54:        }
                     55:        p->s_name = s;
                     56:        p->s_type = t;
                     57:        p->s_val = v;
                     58:        return(p);
                     59: }
                     60: 
                     61: struct symtab *lookup(char *s) /* find s in symtab */
                     62: {
                     63:        int i;
                     64:        struct symtab *p;
                     65: 
                     66:        for (i = nstack; i >= 0; i--)   /* look in each active symtab */
                     67:                for (p = stack[i].p_symtab; p != NULL; p = p->s_next)
                     68:                        if (strcmp(s, p->s_name) == 0)
                     69:                                return(p);
                     70:        return(NULL);
                     71: }
                     72: 
                     73: void freesymtab(struct symtab *p)      /* free space used by symtab at p */
                     74: {
                     75:        struct symtab *q;
                     76: 
                     77:        for ( ; p != NULL; p = q) {
                     78:                q = p->s_next;
                     79:                free(p->s_name);        /* assumes done with tostring */
                     80:                free((char *)p);
                     81:        }
                     82: }
                     83: 
                     84: void freedef(char *s)  /* free definition for string s */
                     85: {
                     86:        struct symtab *p, *q, *op;
                     87: 
                     88:        for (p = op = q = stack[nstack].p_symtab; p != NULL; p = p->s_next) {
                     89:                if (strcmp(s, p->s_name) == 0) {        /* got it */
                     90:                        if (p->s_type != DEFNAME)
                     91:                                break;
                     92:                        if (p == op)    /* 1st elem */
                     93:                                stack[nstack].p_symtab = p->s_next;
                     94:                        else
                     95:                                q->s_next = p->s_next;
                     96:                        free(p->s_name);
                     97:                        free(p->s_val.p);
                     98:                        free((char *)p);
                     99:                        return;
                    100:                }
                    101:                q = p;
                    102:        }
                    103:        /* ERROR "%s is not defined at this point", s WARNING; */
                    104: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.