# 2.11BSD#431 - /usr/src/ucb/PORT/pascal/pdx/sym/predicates.c

##### Functions

    compatible        X
    isambiguous       X
    isblock           X
    isbuiltin         X
    isparam           X
    isvariable        X
    isvarparam        X
    should_print      X

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

#### Defined functions

compatible defined in line 89; used 5 times

- in /usr/src/ucb/PORT/pascal/pdx/sym/tree.c line 133-134(2), 262-264(2), 338

isambiguous defined in line 161; never used
isblock defined in line 65; used 4 times

- in /usr/src/ucb/PORT/pascal/pdx/sym/attributes.c line 46
- in /usr/src/ucb/PORT/pascal/pdx/sym/tree.c line 116, 289
- in /usr/src/ucb/PORT/pascal/pdx/sym/which.c line 71

isbuiltin defined in line 76; used 2 times

- in /usr/src/ucb/PORT/pascal/pdx/sym/tree.c line 116
- in /usr/src/ucb/PORT/pascal/pdx/sym/which.c line 36

isparam defined in line 26; used 2 times

- in /usr/src/ucb/PORT/pascal/pdx/sym/printdecl.c line 51
- in /usr/src/ucb/PORT/pascal/pdx/sym/which.c line 75

isvariable defined in line 54; used 2 times

- in line 94-97(2)

isvarparam defined in line 43; never used
should_print defined in line 137; never used

#### Defined variables

sccsid defined in line 8; never used

Last modified: 1985-06-06 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 753 |