Return to symtab.c CVS log

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

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

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

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