Return to symtab.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / Jpic

Annotation of researchv9/jtools/src/Jpic/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: extern char    *tostring();
                      6: 
                      7: getvar(s)      /* return value of variable s */
                      8: char *s;
                      9: {
                     10:        struct symtab *p;
                     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(0);
                     19:        }
                     20:        return(p->s_val);
                     21: }
                     22: 
                     23: struct symtab *makevar(s, t, v)        /* make variable named s in table */
                     24: char *s;                       /* assumes s is static or from tostring */
                     25: int t;
                     26: int v;
                     27: {
                     28:        int i;
                     29:        struct symtab *p;
                     30: 
                     31:        for (p = stack[nstack].p_symtab; p != NULL; p = p->s_next)
                     32:                if (strcmp(s, p->s_name) == 0)
                     33:                        break;
                     34:        if (p == NULL) {        /* it's a new one */
                     35:                p = (struct symtab *) malloc(sizeof(struct symtab));
                     36:                if (p == NULL) {
                     37:                        yyerror("out of symtab space with %s", s);
                     38:                        exit(1);
                     39:                }
                     40:                p->s_next = stack[nstack].p_symtab;
                     41:                stack[nstack].p_symtab = p;     /* stick it at front */
                     42:        }
                     43:        p->s_name = s;
                     44:        p->s_type = t;
                     45:        p->s_val = v;
                     46:        return(p);
                     47: }
                     48: 
                     49: struct symtab *lookup(s)       /* find s in symtab */
                     50: char *s;
                     51: {
                     52:        int i;
                     53:        struct symtab *p;
                     54: 
                     55:        for (i = nstack; i >= 0; i--)   /* look in each active symtab */
                     56:                for (p = stack[i].p_symtab; p != NULL; p = p->s_next)
                     57:                        if (strcmp(s, p->s_name) == 0)
                     58:                                return(p);
                     59:        return(NULL);
                     60: }
                     61: 
                     62: freesymtab(p)  /* free space used by symtab at p */
                     63: struct symtab *p;
                     64: {
                     65:        for ( ; p != NULL; p = p->s_next) {
                     66:                free(p->s_name);        /* assumes done with tostring */
                     67:                free(p);
                     68:        }
                     69: }

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