Return to predicates.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / pascal / pdx / sym

Annotation of 42BSD/ucb/pascal/pdx/sym/predicates.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1982 Regents of the University of California */
        !             2: 
        !             3: static char sccsid[] = "@(#)predicates.c 1.4 4/23/82";
        !             4: 
        !             5: /*
        !             6:  * The basic tests on a symbol.
        !             7:  */
        !             8: 
        !             9: #include "defs.h"
        !            10: #include "sym.h"
        !            11: #include "symtab.h"
        !            12: #include "btypes.h"
        !            13: #include "classes.h"
        !            14: #include "sym.rep"
        !            15: 
        !            16: /*
        !            17:  * Test if a symbol is a parameter.  This is true if there
        !            18:  * is a cycle from s->func to s via chain pointers.
        !            19:  */
        !            20: 
        !            21: BOOLEAN isparam(s)
        !            22: SYM *s;
        !            23: {
        !            24:     register SYM *t;
        !            25: 
        !            26:     for (t = s->func; t != NIL; t = t->chain) {
        !            27:        if (t == s) {
        !            28:            return(TRUE);
        !            29:        }
        !            30:     }
        !            31:     return(FALSE);
        !            32: }
        !            33: 
        !            34: /*
        !            35:  * Test if a symbol is a var parameter, i.e. has class REF.
        !            36:  */
        !            37: 
        !            38: BOOLEAN isvarparam(s)
        !            39: SYM *s;
        !            40: {
        !            41:     return (BOOLEAN) s->class == REF;
        !            42: }
        !            43: 
        !            44: /*
        !            45:  * Test if a symbol is a variable (actually any addressible quantity
        !            46:  * with do).
        !            47:  */
        !            48: 
        !            49: BOOLEAN isvariable(s)
        !            50: SYM *s;
        !            51: {
        !            52:     return s->class == VAR || s->class == FVAR || s->class == REF;
        !            53: }
        !            54: 
        !            55: /*
        !            56:  * Test if a symbol is a block, e.g. function, procedure, or the
        !            57:  * main program.
        !            58:  */
        !            59: 
        !            60: BOOLEAN isblock(s)
        !            61: register SYM *s;
        !            62: {
        !            63:     return(s->class == FUNC || s->class == PROC || s->class == PROG);
        !            64: }
        !            65: 
        !            66: /*
        !            67:  * Test if a symbol is builtin, that is, a predefined type or
        !            68:  * reserved word.
        !            69:  */
        !            70: 
        !            71: BOOLEAN isbuiltin(s)
        !            72: SYM *s;
        !            73: {
        !            74:     return(s->blkno == 0 && s->class != PROG && s->class != VAR);
        !            75: }
        !            76: 
        !            77: /*
        !            78:  * Compatible tests if two types are compatible.  The issue
        !            79:  * is complicated a bit by ranges.
        !            80:  *
        !            81:  * Integers and reals are not compatible since they cannot always be mixed.
        !            82:  */
        !            83: 
        !            84: BOOLEAN compatible(t1, t2)
        !            85: register SYM *t1, *t2;
        !            86: {
        !            87:     register BOOLEAN b;
        !            88: 
        !            89:     if (isvariable(t1)) {
        !            90:        t1 = t1->type;
        !            91:     }
        !            92:     if (isvariable(t2)) {
        !            93:        t2 = t2->type;
        !            94:     }
        !            95:     if (t1 == t2) {
        !            96:        b = TRUE;
        !            97:     } else {
        !            98:        t1 = rtype(t1);
        !            99:        t2 = rtype(t2);
        !           100:        if (t1->type == t2->type) {
        !           101:            if (t1->class == RANGE && t2->class == RANGE) {
        !           102:                b = TRUE;
        !           103:            } else if ((t1->class == SCAL || t1->class == CONST) &&
        !           104:              (t2->class == SCAL || t2->class == CONST)) {
        !           105:                b = TRUE;
        !           106:            } else if (t1->type == t_char &&
        !           107:              t1->class == ARRAY && t2->class == ARRAY) {
        !           108:                b = TRUE;
        !           109:            } else {
        !           110:                b = FALSE;
        !           111:            }
        !           112:     /*
        !           113:      * A kludge here for "nil".  Should be handled better.
        !           114:      * Opens a pandora's box for integer/pointer compatibility.
        !           115:      */
        !           116:        } else if ((t1->class == RANGE && t2->class == PTR) ||
        !           117:          (t2->class == RANGE && t1->class == PTR)) {
        !           118:            b = TRUE;
        !           119:        } else {
        !           120:            b = FALSE;
        !           121:        }
        !           122:     }
        !           123:     return b;
        !           124: }
        !           125: 
        !           126: /*
        !           127:  * Predicate to test if a symbol should be printed.  We don't print
        !           128:  * files, for example, simply because there's no good way to do it.
        !           129:  * The symbol must be within the given function.
        !           130:  */
        !           131: 
        !           132: BOOLEAN should_print(s, f)
        !           133: SYM *s;
        !           134: SYM *f;
        !           135: {
        !           136:     SYM *t;
        !           137: 
        !           138:     if (s->func != f || (s->class != VAR && s->class != FVAR)) {
        !           139:        return(FALSE);
        !           140:     } else if (s->chain != NIL) {
        !           141:        return(FALSE);
        !           142:     } else {
        !           143:        t = rtype(s->type);
        !           144:        if (t == NIL || t->class == FILET || t->class == SET) {
        !           145:            return(FALSE);
        !           146:        } else {
        !           147:            return(TRUE);
        !           148:        }
        !           149:     }
        !           150: }
        !           151: 
        !           152: /*
        !           153:  * Test if the name of a symbol is uniquely defined or not.
        !           154:  */
        !           155: 
        !           156: BOOLEAN isambiguous(s)
        !           157: SYM *s;
        !           158: {
        !           159:     SYM *t;
        !           160: 
        !           161:     t = st_lookup(symtab, s->symbol);
        !           162:     if (t == NIL) {
        !           163:        panic("symbol name vanished");
        !           164:     }
        !           165:     while (t != NIL && (s == t || !streq(t->symbol, s->symbol))) {
        !           166:        t = t->next_sym;
        !           167:     }
        !           168:     return t != NIL;
        !           169: }

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