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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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