1 #include <stdio.h>
2 #include <ctype.h>
3
4 #include "set.h"
5 #include "syn.h"
6 #include "hash.h"
7 #include "generic.h"
8
9 #ifdef __USE_PROTOS
dumpset1(set s)10 void dumpset1(set s)
11 #else
12 void dumpset1(s)
13 set s;
14 #endif
15 {
16 if (set_nil(s)) {
17 fprintf(stderr,"{}");
18 } else {
19 s_fprT(stderr,s);
20 };
21 }
22
23 #ifdef __USE_PROTOS
dumpset(set s)24 void dumpset(set s)
25 #else
26 void dumpset(s)
27 set s;
28 #endif
29 {
30 dumpset1(s);
31 fprintf(stderr,"\n");
32 }
33
34 #ifdef __USE_PROTOS
isEndRule(Node * p)35 int isEndRule(Node * p)
36 #else
37 int isEndRule(p)
38 Node * p;
39 #endif
40 {
41 int result=0;
42 if ( p->ntype == nJunction &&
43 ( (Junction *) p)->jtype == EndRule) {
44 result=1;
45 };
46 return result;
47 }
48
49 #ifdef __USE_PROTOS
dumppred1(int depth,Predicate * p)50 void dumppred1(int depth,Predicate *p)
51 #else
52 void dumppred1(depth,p)
53 int depth;
54 Predicate *p;
55 #endif
56 {
57 int i;
58 int k;
59
60 for (i=0; i<depth ; i++) {
61 fprintf(stderr," ");
62 };
63 if (p->expr == PRED_AND_LIST ||
64 p->expr == PRED_OR_LIST) {
65 fprintf(stderr," %s", (p->expr == NULL ? "null expr" : p->expr));
66 if (p->inverted) fprintf(stderr," predicate inverted !");
67 if (p->redundant) {
68 fprintf(stderr," Redundant!");
69 };
70 if (p->isConst) fprintf(stderr," const %d !",p->constValue);
71 fprintf(stderr,"\n");
72 } else {
73 fprintf(stderr,"predicate k=%d",p->k);
74 k=set_int(p->completionSet);
75 if (k >= 0) {
76 fprintf(stderr," Incomplete Set=%d !",k);
77 };
78 k=set_int(p->completionTree);
79 if (k >= 0) {
80 fprintf(stderr," Incomplete Tree=%d !",k);
81 };
82 if (p->redundant) {
83 fprintf(stderr," Redundant!");
84 };
85 fprintf(stderr," \"%s\" (%x)", (p->expr == NULL ? "null expr" : p->expr) ,p);
86 if (p->source != NULL) {
87 fprintf(stderr,"line %d",p->source->line);
88 };
89 if (p->inverted) fprintf(stderr," predicate inverted !");
90 fprintf(stderr,"\n");
91 for (i=0; i<depth ; i++) {
92 fprintf(stderr," ");
93 };
94 fprintf(stderr,"scontext: ");
95 dumpset(p->scontext[1]);
96 for (i=0; i<depth ; i++) {
97 fprintf(stderr," ");
98 };
99 fprintf(stderr,"tcontext: ");
100 preorder(p->tcontext);
101 fprintf(stderr,"\n");
102 };
103 fprintf(stderr,"\n");
104 if (p->down != NULL) {
105 dumppred1(depth+1,p->down);
106 };
107 if (p->right != NULL) {
108 dumppred1(depth,p->right);
109 };
110 }
111
112 #ifdef __USE_PROTOS
dumppred(Predicate * p)113 void dumppred(Predicate *p)
114 #else
115 void dumppred(p)
116 Predicate *p;
117 #endif
118 {
119 fprintf(stderr,"---------------------------------\n");
120 dumppred1(0,p);
121 fprintf(stderr,"\n");
122 }
123
124 #ifdef __USE_PROTOS
dumppredtree(Predicate * p)125 void dumppredtree(Predicate *p)
126 #else
127 void dumppredtree(p)
128 Predicate *p;
129 #endif
130 {
131 fprintf(stderr,"predicate k=%d \"%s\" line %d\n",p->k,p->expr,p->source->line);
132 dumpset(p->scontext[1]);
133 }
134
135 #ifdef __USE_PROTOS
dumppredexpr(Predicate * p)136 void dumppredexpr(Predicate *p)
137 #else
138 void dumppredexpr(p)
139 Predicate *p;
140 #endif
141 {
142 fprintf(stderr," pred expr \"%s\"\n",p->expr);
143 }
144
145 #ifdef __USE_PROTOS
dt(Tree * t)146 void dt(Tree *t)
147 #else
148 void dt(t)
149 Tree *t;
150 #endif
151 {
152 MR_dumpTreeF(stderr,0,t,5);
153 }
154
155 #ifdef __USE_PROTOS
d(Node * p)156 void d(Node * p)
157 #else
158 void d(p)
159 Node * p;
160 #endif
161 {
162
163 Junction *j;
164 RuleRefNode *r;
165 TokNode *t;
166 ActionNode *a;
167
168 if (p==NULL) {
169 fprintf(stderr,"dumpNode: Node is NULL");
170 return;
171 };
172
173 switch (p->ntype) {
174 case nJunction :
175 j = (Junction *) p;
176 fprintf(stderr, "Junction (#%d in rule %s line %d) ",j->seq,j->rname,j->line);
177 if (j->guess) fprintf(stderr,"guess block ");
178 switch (j->jtype ) {
179 case aSubBlk :
180 fprintf(stderr,"aSubBlk");
181 break;
182 case aOptBlk :
183 fprintf(stderr,"aOptBlk");
184 break;
185 case aLoopBegin :
186 fprintf(stderr,"aLoopBeginBlk");
187 break;
188 case aLoopBlk :
189 fprintf(stderr,"aLoopBlk");
190 break;
191 case aPlusBlk :
192 fprintf(stderr,"aPlusBlk");
193 break;
194 case EndBlk :
195 fprintf(stderr,"EndBlk");
196 break;
197 case RuleBlk :
198 fprintf(stderr,"RuleBlk");
199 break;
200 case Generic :
201 fprintf(stderr,"Generic");
202 break;
203 case EndRule :
204 fprintf(stderr,"EndRule");
205 break;
206 };
207 if (j->halt) fprintf(stderr," halt!");
208 if (j->p1) fprintf(stderr," p1 valid");
209 if (j->p2) {
210 if (j->p2->ntype == nJunction) {
211 fprintf(stderr," (p2=#%d)",( (Junction *) j->p2)->seq);
212 } else {
213 fprintf(stderr," (p2 valid)");
214 };
215 };
216 if (j->ignore) fprintf(stderr, " ignore/plus-block-bypass");
217 if (j->fset != NULL && set_deg(*j->fset) != 0) {
218 fprintf(stderr,"\nfset:\n");
219 dumpset(*j->fset);
220 };
221 if (j->ftree != NULL) {
222 fprintf(stderr,"\nftree:\n");
223 preorder(j->ftree);
224 };
225 fprintf(stderr,"\n");
226 break;
227 case nRuleRef :
228 r = (RuleRefNode *) p;
229 fprintf(stderr, "RuleRefNode (in rule %s line %d) to rule %s\n", r->rname,r->line,r->text);
230 break;
231 case nToken :
232 t = (TokNode *) p;
233 fprintf(stderr, "TokNode (in rule %s line %d) token %s\n",t->rname,t->line,TerminalString(t->token));
234 break;
235 case nAction :
236 a =(ActionNode *) p;
237 if (a->is_predicate) {
238 fprintf(stderr, "Predicate (in rule %s line %d) %s",a->rname,a->line,a->action);
239 if (a->inverted) fprintf(stderr," action inverted !");
240 if (a->guardpred != NULL) {
241 fprintf(stderr," guarded");
242 dumppredexpr(a->guardpred);
243 if (a->ampersandPred) {
244 fprintf(stderr," \"&&\" style");
245 } else {
246 fprintf(stderr," \"=>\" style");
247 };
248 };
249 if (a->predEntry != NULL) fprintf(stderr," predEntry \"%s\" ",a->predEntry->str);
250 fprintf(stderr,"\n");
251 } else if (a->init_action) {
252 fprintf(stderr, "Init-Action (in rule %s line %d) %s\n",a->rname,a->line,a->action);
253 } else {
254 fprintf(stderr, "Action (in rule %s line %d) %s\n",a->rname,a->line,a->action);
255 };
256 break;
257 };
258 }
259
260 #ifdef __USE_PROTOS
dp1(Node * p)261 Node * dp1(Node * p)
262 #else
263 Node * dp1(p)
264 Node * p;
265 #endif
266 {
267 Node *result=NULL;
268
269 if (p->ntype == nJunction) {
270 result=( (Junction *) p )->p1;
271 d(result);
272 } else {
273 fprintf(stderr,"dp1: Not a Junction node");
274 };
275 return result;
276 }
277
278 #ifdef __USE_PROTOS
dp2(Node * p)279 Node * dp2(Node * p)
280 #else
281 Node * dp2(p)
282 Node * p;
283 #endif
284 {
285 Node *result=NULL;
286
287 if (p->ntype == nJunction) {
288 result=( (Junction *) p )->p2;
289 d(result);
290 } else {
291 fprintf(stderr,"dp2: Not a Junction node");
292 };
293 return result;
294 }
295
296 #ifdef __USE_PROTOS
dn(Node * p)297 Node * dn(Node * p)
298 #else
299 Node * dn(p)
300 Node * p;
301 #endif
302
303 {
304 Node *result=NULL;
305
306 if (p->ntype == nRuleRef) {
307 result=( (RuleRefNode *)p )->next;
308 } else if (p->ntype == nAction) {
309 result=( (ActionNode *)p )->next;
310 } else if (p->ntype == nToken) {
311 result=( (TokNode *)p )->next;
312 } else {
313 fprintf(stderr,"No next field: Neither a RuleRefNode, ActionNode, nor TokNode");
314 };
315 if (result != NULL) d(result);
316 return result;
317 }
318
319 #ifdef __USE_PROTOS
df(Node * p)320 void df(Node * p)
321 #else
322 void df(p)
323 Node * p;
324 #endif
325 {
326 int count=0;
327 Node *next;
328
329 fprintf(stderr,"\n#%d ",++count);
330 d(p);
331
332 for (next=p; next != NULL && !isEndRule(next) ; ) {
333 fprintf(stderr,"#%d ",++count);
334 if (next->ntype == nJunction) {
335 next=dp1(next);
336 } else {
337 next=dn(next);
338 };
339 };
340 }
341
342 #ifdef __USE_PROTOS
dfn(Node * p,int target)343 Node * dfn(Node * p,int target)
344 #else
345 Node * dfn(p,target)
346 Node * p;
347 int target;
348 #endif
349 {
350 Node *result=NULL;
351 int count=0;
352 Node *next;
353
354 fprintf(stderr,"#%d ",++count);
355 d(p);
356
357 for (next=p; next != NULL && !isEndRule(next) ; ) {
358 fprintf(stderr,"#%d ",++count);
359 if (next->ntype == nJunction) {
360 next=dp1(next);
361 } else {
362 next=dn(next);
363 };
364 if (count == target) {
365 result=next;
366 break;
367 };
368 };
369 return result;
370 }
371
372
373 static int findnodeMatch;
374
375 #ifdef __USE_PROTOS
findnode1(Node * n)376 Junction *findnode1(Node *n)
377 #else
378 Junction *findnode1(n)
379 Node *n;
380 #endif
381 {
382 Node *next;
383 Junction *j;
384 Junction *match;
385
386 if (n == NULL) return NULL;
387 if (n->ntype == nJunction) {
388 j=(Junction *) n;
389 if (j->seq == findnodeMatch) return j;
390 if (j->jtype == EndRule) return NULL;
391 if (j->jtype != RuleBlk && j->jtype != EndBlk) {
392 if (j->p2 != NULL && !j->ignore) {
393 match=findnode1(j->p2);
394 if (match != NULL) return match;
395 };
396 };
397 };
398 next=MR_advance(n);
399 return findnode1(next);
400 }
401
402 #ifdef __USE_PROTOS
findnode(int match)403 Junction *findnode(int match)
404 #else
405 Junction *findnode(match)
406 int match;
407 #endif
408 {
409 Junction *j;
410 Junction *result=NULL;
411
412 findnodeMatch=match;
413
414 for (j=SynDiag; j != NULL; j=(Junction *)j->p2) {
415 require (j->ntype == nJunction && j->jtype == RuleBlk,"Not a rule block");
416 result=findnode1( (Node *) j);
417 if (result != NULL) break;
418 };
419 if (result != NULL) {
420 d( (Node *) result);
421 };
422 return result;
423 }
424