![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to predicates.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / pascal / pdx / sym|
Return to predicates.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / pascal / pdx / sym |
1.1 root 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.