```   1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
2:
3: /*
4:   \$Header: b2tes.c,v 1.4 85/08/22 16:57:17 timo Exp \$
5: */
6:
7: #include "b.h"
8: #include "b1obj.h"
9: #include "b2par.h"
10: #include "b2key.h"
11: #include "b2syn.h"
12: #include "b2nod.h"
13: #include "b3err.h"
14:
15: Forward bool conjunction(), disjunction();
16: Forward parsetree right_test();
17:
18: Visible parsetree test(q) txptr q; {
19:     parsetree v;
20:     skipsp(&tx);
21:     if (!(conjunction(q, &v) || disjunction(q, &v))) v= right_test(q);
22:     return v;
23: }
24:
25: Forward bool negation(), quantification();
26: Forward parsetree tight_test();
27:
28: Hidden parsetree right_test(q) txptr q; {
29:     parsetree v;
30:     skipsp(&tx);
31:     if (!(negation(q, &v) || quantification(q, &v))) v= tight_test(q);
32:     return v;
33: }
34:
35: Hidden bool conjunction(q, v) txptr q; parsetree *v; {
36:     txptr ftx, ttx;
37:     if (find(K_AND, q, &ftx, &ttx)) {
38:         parsetree t;
39:         t= tight_test(ftx); tx= ttx;
40:         if (!conjunction(q, v)) *v= right_test(q);
41:         *v= node3(AND, t, *v);
42:         return Yes;
43:     }
44:     return No;
45: }
46:
47: Hidden bool disjunction(q, v) txptr q; parsetree *v; {
48:     txptr ftx, ttx;
49:     if (find(K_OR, q, &ftx, &ttx)) {
50:         parsetree t;
51:         t= tight_test(ftx); tx= ttx;
52:         if (!disjunction(q, v)) *v= right_test(q);
53:         *v= node3(OR, t, *v);
54:         return Yes;
55:     }
56:     return No;
57: }
58:
59: Hidden bool negation(q, v) txptr q; parsetree *v; {
60:     if (not_keyword()) {
61:         *v= node2(NOT, right_test(q));
62:         return Yes;
63:     }
64:     return No;
65: }
66:
67: Hidden bool quantification(q, v) txptr q; parsetree *v; {
68:     bool some, each;
69:     if ((some= some_keyword()) || (each= each_keyword()) || no_keyword()) {
70:         parsetree t, e; typenode type;
71:         txptr utx, vtx, ftx, ttx;
72:         req(K_HAS, ceol, &utx, &vtx);
73:         if (utx > q) {
74:             parerr(MESS(2700, "HAS follows colon"));
75:             /* as in: SOME i IN x: SHOW i HAS a */
76:             utx= tx; vtx= q;
77:         }
78:         if (find(K_IN_quant, utx, &ftx, &ttx)) {
79:             idf_cntxt= In_ranger;
80:             t= idf(ftx); tx= ttx;
81:             type= some ? SOME_IN : each ? EACH_IN : NO_IN;
82:         } else if (find(K_PARSING, utx, &ftx, &ttx)) {
83:             idf_cntxt= In_ranger;
84:             t= idf(ftx);
85:             if (nodetype(t) != COLLATERAL)
86:                 pprerr(MESS(2701, "no collateral_identifier where expected"));
87:             tx= ttx;
88:             type= some ? SOME_PARSING : each ? EACH_PARSING
89:                   : NO_PARSING;
90:         } else {
91:             parerr(MESS(2702, "neither IN nor PARSING found"));
92:             utx= tx; vtx= q; t= NilTree; type= Nonode;
93:         }
94:         e= expr(utx); tx= vtx;
95:         *v= node4(type, t, e, right_test(q));
96:         return Yes;
97:     }
98:     return No;
99: }
100:
101: Forward bool cl_test(), order_test();
102: Forward parsetree ref_or_prop();
103:
104: Hidden parsetree tight_test(q) txptr q; {
105:     parsetree v;
106:     skipsp(&tx);
107:     if (nothing(q, "test")) v= NilTree;
108:     else if (!(cl_test(q, &v) || order_test(q, &v))) {
109:         if (is_expr(Char(tx))) v= ref_or_prop(q);
110:         else {
111:             parerr(MESS(2703, "no test where expected"));
112:             v= NilTree;
113:         }
114:     }
115:     upto_test(q);
116:     return v;
117: }
118:
119: Hidden bool cl_test(q, v) txptr q; parsetree *v; {
120:     txptr tx0= tx;
121:     if (open_sign()) { /* (expr) or (test) */
122:         txptr ftx, ttx, tx1;
123:         tx1= tx;
124:         req(")", q, &ftx, &ttx); tx= ttx;
125:         skipsp(&tx);
126:         if (!Text(q)) {
127:             tx= tx1;
128:             *v= compound(ttx, test);
129:             return Yes;
130:         }
131:     }
132:     tx= tx0;
133:     return No;
134: }
135:
136: Forward typenode relop();
137:
138: Hidden bool order_test(q, v) txptr q; parsetree *v; {
139:     txptr ftx;
140:     if (findrel(q, &ftx)) {
141:         typenode r;
142:         *v= singexpr(ftx);
143:         do {
144:             r= relop();
145:             if (!findrel(q, &ftx)) ftx= q;
146:             *v= node3(r, *v, singexpr(ftx));
147:         } while (ftx < q);
148:         return Yes;
149:     }
150:     return No;
151: }
152:
153: Hidden typenode relop() {
154:     skipsp(&tx);
155:     return
156:         at_most_sign()      ? AT_MOST :
157:         unequal_sign()      ? UNEQUAL :
158:         at_least_sign()     ? AT_LEAST :
159:         equals_sign()       ? EQUAL :
160:         less_than_sign()    ? LESS_THAN :
161:         greater_than_sign() ? GREATER_THAN :
162:         /* psyserr */         Nonode;
163: }
164:
165: /* refined_test or proposition */
166:
168:
169: Hidden parsetree ref_or_prop(q) txptr q; {
170:     value t1;
171:     txptr tx0= tx;
172:     if (tag_operator(q, &t1)) {
173:         value t2;
174:         skipsp(&tx);
175:         if (!Text(q)) return node2(TAG, t1);
176:         if (tag_operator(q, &t2)) {
177:             skipsp(&tx);
178:             if (!Text(q))
179:                 return node4(MONPRD, t1, node2(TAG, t2), Vnil);
180:             release(t1); release(t2);
181:             return (tx= tx0, unp_test(q));
182:         }
183:         release(t1);
184:         if (!dya_sign()) return (tx= tx0, unp_test(q));
185:     }
187: }
188:
189: Visible bool dya_proposition= No;
190:
191: Hidden parsetree dyadic_proposition(q) txptr q; {
192:     parsetree v; value name;
193:     dya_proposition= Yes;
194:     v= singexpr(q);
195:     if (!Text(q)) /* unparsed */
196:         return v;
197:     if (!tag_operator(q, &name)) {
198:         parerr(MESS(2704, "no dyadic predicate where expected"));
199:         name= Vnil;
200:     }
201:     return node5(DYAPRD, v, name, singexpr(q), Vnil);
202: }
203:
204: Hidden Procedure upto_test(q) txptr q; {
205:     skipsp(&tx);
206:     if (Text(q)) {
207:         txptr ftx, ttx;
208:         if (find(K_AND, q, &ftx, &ttx) || find(K_OR, q, &ftx, &ttx)) {
209:             tx= ftx;
210:             parerr(MESS(2705, "cannot determine priorities; use ( and ) to resolve"));
211:         } else parerr(MESS(2706, "something unexpected following test"));
212:         tx= q;
213:     }
214: }
```

#### Defined functions

cl_test defined in line 119; used 2 times
conjunction defined in line 35; used 3 times
disjunction defined in line 47; used 3 times
dyadic_proposition defined in line 191; used 2 times
negation defined in line 59; used 2 times
order_test defined in line 138; used 2 times
quantification defined in line 67; used 2 times
ref_or_prop defined in line 169; used 2 times
relop defined in line 153; used 2 times
right_test defined in line 28; used 6 times
test defined in line 18; used 7 times
tight_test defined in line 104; used 4 times
upto_test defined in line 204; used 1 times

#### Defined variables

dya_proposition defined in line 189; used 1 times
 Last modified: 1985-08-27 Generated: 2016-12-26 Generated by src2html V0.67 page hit count: 2955