1 files changed, 423 insertions, 0 deletions
diff --git a/Tools/CCode/Source/Pccts/antlr/dumpnode.c b/Tools/CCode/Source/Pccts/antlr/dumpnode.c
new file mode 100644
index 0000000000..2a34c6fcd5
--- /dev/null
+++ b/Tools/CCode/Source/Pccts/antlr/dumpnode.c
@@ -0,0 +1,423 @@
+#include <stdio.h>
+#include <ctype.h>
+
+#include "set.h"
+#include "syn.h"
+#include "hash.h"
+#include "generic.h"
+
+#ifdef __USE_PROTOS
+void dumpset1(set s)
+#else
+void dumpset1(s)
+  set   s;
+#endif
+{
+  if (set_nil(s)) {
+    fprintf(stderr,"{}");
+  } else {
+    s_fprT(stderr,s);
+  };
+}
+
+#ifdef __USE_PROTOS
+void dumpset(set s)
+#else
+void dumpset(s)
+  set   s;
+#endif
+{
+  dumpset1(s);
+  fprintf(stderr,"\n");
+}
+
+#ifdef __USE_PROTOS
+int isEndRule(Node * p)
+#else
+int isEndRule(p)
+  Node *    p;
+#endif
+{
+  int       result=0;
+  if ( p->ntype == nJunction &&
+       ( (Junction *) p)->jtype == EndRule) {
+    result=1;
+  };
+  return result;
+}
+
+#ifdef __USE_PROTOS
+void dumppred1(int depth,Predicate *p)
+#else
+void dumppred1(depth,p)
+  int           depth;
+  Predicate     *p;
+#endif
+{
+  int       i;
+  int       k;
+
+  for (i=0; i<depth ; i++) {
+    fprintf(stderr,"  ");
+  };
+  if (p->expr == PRED_AND_LIST ||
+      p->expr == PRED_OR_LIST) {
+    fprintf(stderr," %s", (p->expr == NULL ? "null expr" : p->expr));
+    if (p->inverted) fprintf(stderr," predicate inverted !");
+    if (p->redundant) {
+      fprintf(stderr," Redundant!");
+    };
+    if (p->isConst) fprintf(stderr," const %d !",p->constValue);
+    fprintf(stderr,"\n");
+  } else {
+    fprintf(stderr,"predicate k=%d",p->k);
+    k=set_int(p->completionSet);
+    if (k >= 0) {
+      fprintf(stderr," Incomplete Set=%d !",k);
+    };
+    k=set_int(p->completionTree);
+    if (k >= 0) {
+      fprintf(stderr," Incomplete Tree=%d !",k);
+    };
+    if (p->redundant) {
+      fprintf(stderr," Redundant!");
+    };
+    fprintf(stderr," \"%s\" (%x)", (p->expr == NULL ? "null expr" : p->expr) ,p);
+    if (p->source != NULL) {
+       fprintf(stderr,"line %d",p->source->line);
+    };
+    if (p->inverted) fprintf(stderr," predicate inverted !");
+    fprintf(stderr,"\n");
+    for (i=0; i<depth ; i++) {
+      fprintf(stderr,"  ");
+    };
+    fprintf(stderr,"scontext: ");
+    dumpset(p->scontext[1]);
+    for (i=0; i<depth ; i++) {
+      fprintf(stderr,"  ");
+    };
+    fprintf(stderr,"tcontext: ");
+    preorder(p->tcontext);
+    fprintf(stderr,"\n");
+  };
+  fprintf(stderr,"\n");
+  if (p->down != NULL) {
+    dumppred1(depth+1,p->down);
+  };
+  if (p->right != NULL) {
+    dumppred1(depth,p->right);
+  };
+}
+
+#ifdef __USE_PROTOS
+void dumppred(Predicate *p)
+#else
+void dumppred(p)
+  Predicate     *p;
+#endif
+{
+  fprintf(stderr,"---------------------------------\n");
+  dumppred1(0,p);
+  fprintf(stderr,"\n");
+}
+
+#ifdef __USE_PROTOS
+void dumppredtree(Predicate *p)
+#else
+void dumppredtree(p)
+  Predicate     *p;
+#endif
+{
+  fprintf(stderr,"predicate k=%d \"%s\" line %d\n",p->k,p->expr,p->source->line);
+  dumpset(p->scontext[1]);
+}
+
+#ifdef __USE_PROTOS
+void dumppredexpr(Predicate *p)
+#else
+void dumppredexpr(p)
+  Predicate     *p;
+#endif
+{
+  fprintf(stderr,"    pred expr \"%s\"\n",p->expr);
+}
+
+#ifdef __USE_PROTOS
+void dt(Tree *t)
+#else
+void dt(t)
+  Tree  *t;
+#endif
+{
+  MR_dumpTreeF(stderr,0,t,5);
+}
+
+#ifdef __USE_PROTOS
+void d(Node * p)
+#else
+void d(p)
+  Node *    p;
+#endif
+{
+
+  Junction      *j;
+  RuleRefNode   *r;
+  TokNode       *t;
+  ActionNode    *a;
+
+  if (p==NULL) {
+    fprintf(stderr,"dumpNode: Node is NULL");
+    return;
+  };
+
+  switch (p->ntype) {
+    case nJunction :
+      j = (Junction *) p;
+      fprintf(stderr, "Junction (#%d in rule %s line %d) ",j->seq,j->rname,j->line);
+      if (j->guess) fprintf(stderr,"guess block ");
+      switch (j->jtype ) {
+        case aSubBlk :
+          fprintf(stderr,"aSubBlk");
+          break;
+        case aOptBlk :
+          fprintf(stderr,"aOptBlk");
+          break;
+        case aLoopBegin :
+          fprintf(stderr,"aLoopBeginBlk");
+          break;
+        case aLoopBlk :
+          fprintf(stderr,"aLoopBlk");
+          break;
+        case aPlusBlk :
+          fprintf(stderr,"aPlusBlk");
+          break;
+        case EndBlk :
+          fprintf(stderr,"EndBlk");
+          break;
+        case RuleBlk :
+          fprintf(stderr,"RuleBlk");
+          break;
+        case Generic :
+          fprintf(stderr,"Generic");
+          break;
+        case EndRule :
+          fprintf(stderr,"EndRule");
+          break;
+      };
+      if (j->halt) fprintf(stderr,"  halt!");
+      if (j->p1) fprintf(stderr," p1 valid");
+      if (j->p2) {
+        if (j->p2->ntype == nJunction) {
+           fprintf(stderr," (p2=#%d)",( (Junction *) j->p2)->seq);
+        } else {
+           fprintf(stderr," (p2 valid)");
+        };
+      };
+	  if (j->ignore) fprintf(stderr, " ignore/plus-block-bypass");
+      if (j->fset != NULL && set_deg(*j->fset) != 0) {
+         fprintf(stderr,"\nfset:\n");
+         dumpset(*j->fset);
+      };
+      if (j->ftree != NULL) {
+         fprintf(stderr,"\nftree:\n");
+         preorder(j->ftree);
+      };
+      fprintf(stderr,"\n");
+      break;
+    case nRuleRef :
+       r = (RuleRefNode *) p;
+       fprintf(stderr, "RuleRefNode (in rule %s line %d) to rule %s\n", r->rname,r->line,r->text);
+       break;
+    case nToken :
+       t = (TokNode *) p;
+       fprintf(stderr, "TokNode (in rule %s line %d) token %s\n",t->rname,t->line,TerminalString(t->token));
+       break;
+    case nAction :
+       a =(ActionNode *) p;
+       if (a->is_predicate) {
+         fprintf(stderr, "Predicate (in rule %s line %d) %s",a->rname,a->line,a->action);
+         if (a->inverted) fprintf(stderr," action inverted !");
+         if (a->guardpred != NULL) {
+           fprintf(stderr," guarded");
+           dumppredexpr(a->guardpred);
+           if (a->ampersandPred) {
+             fprintf(stderr," \"&&\" style");
+           } else {
+             fprintf(stderr," \"=>\" style");
+           };
+         };
+         if (a->predEntry != NULL) fprintf(stderr," predEntry \"%s\" ",a->predEntry->str);
+         fprintf(stderr,"\n");
+       } else if (a->init_action) {
+         fprintf(stderr, "Init-Action (in rule %s line %d) %s\n",a->rname,a->line,a->action);
+       } else {
+         fprintf(stderr, "Action (in rule %s line %d) %s\n",a->rname,a->line,a->action);
+       };
+       break;
+   };
+}
+
+#ifdef __USE_PROTOS
+Node * dp1(Node * p)
+#else
+Node * dp1(p)
+  Node *    p;
+#endif
+{
+  Node  *result=NULL;
+
+  if (p->ntype == nJunction) {
+    result=( (Junction *) p )->p1;
+    d(result);
+  } else {
+    fprintf(stderr,"dp1: Not a Junction node");
+  };
+  return result;
+}
+
+#ifdef __USE_PROTOS
+Node * dp2(Node * p)
+#else
+Node * dp2(p)
+  Node *    p;
+#endif
+{
+  Node  *result=NULL;
+
+  if (p->ntype == nJunction) {
+    result=( (Junction *) p )->p2;
+    d(result);
+  } else {
+    fprintf(stderr,"dp2: Not a Junction node");
+  };
+  return result;
+}
+
+#ifdef __USE_PROTOS
+Node * dn(Node * p)
+#else
+Node * dn(p)
+  Node *    p;
+#endif
+
+{
+  Node  *result=NULL;
+
+  if (p->ntype == nRuleRef) {
+    result=( (RuleRefNode *)p )->next;
+  } else if (p->ntype == nAction) {
+    result=( (ActionNode *)p )->next;
+  } else if (p->ntype == nToken) {
+    result=( (TokNode *)p )->next;
+  } else {
+    fprintf(stderr,"No next field: Neither a RuleRefNode, ActionNode, nor TokNode");
+  };
+  if (result != NULL) d(result);
+  return result;
+}
+
+#ifdef __USE_PROTOS
+void df(Node * p)
+#else
+void df(p)
+  Node *    p;
+#endif
+{
+  int       count=0;
+  Node      *next;
+
+  fprintf(stderr,"\n#%d ",++count);
+  d(p);
+
+  for (next=p; next != NULL && !isEndRule(next) ; ) {
+    fprintf(stderr,"#%d ",++count);
+    if (next->ntype == nJunction) {
+      next=dp1(next);
+    } else {
+      next=dn(next);
+    };
+  };
+}
+
+#ifdef __USE_PROTOS
+Node * dfn(Node * p,int target)
+#else
+Node * dfn(p,target)
+  Node *    p;
+  int       target;
+#endif
+{
+  Node      *result=NULL;
+  int       count=0;
+  Node      *next;
+
+  fprintf(stderr,"#%d ",++count);
+  d(p);
+
+  for (next=p; next != NULL && !isEndRule(next) ; ) {
+    fprintf(stderr,"#%d ",++count);
+    if (next->ntype == nJunction) {
+      next=dp1(next);
+    } else {
+      next=dn(next);
+    };
+    if (count == target) {
+      result=next;
+      break;
+    };
+  };
+  return result;
+}
+
+
+static int findnodeMatch;
+
+#ifdef __USE_PROTOS
+Junction *findnode1(Node *n)
+#else
+Junction *findnode1(n)
+  Node  *n;
+#endif
+{
+   Node         *next;
+   Junction     *j;
+   Junction     *match;
+
+   if (n == NULL) return NULL;
+   if (n->ntype == nJunction) {
+     j=(Junction *) n;
+     if (j->seq == findnodeMatch) return j;
+     if (j->jtype == EndRule) return NULL;
+     if (j->jtype != RuleBlk && j->jtype != EndBlk) {
+       if (j->p2 != NULL && !j->ignore) {
+          match=findnode1(j->p2);
+          if (match != NULL) return match;
+       };
+     };
+   };
+   next=MR_advance(n);
+   return findnode1(next);
+}
+
+#ifdef __USE_PROTOS
+Junction *findnode(int match)
+#else
+Junction *findnode(match)
+  int   match;
+#endif
+{
+  Junction  *j;
+  Junction  *result=NULL;
+
+  findnodeMatch=match;
+
+  for (j=SynDiag; j != NULL; j=(Junction *)j->p2) {
+    require (j->ntype == nJunction && j->jtype == RuleBlk,"Not a rule block");
+    result=findnode1( (Node *) j);
+    if (result != NULL) break;
+  };
+  if (result != NULL) {
+    d( (Node *) result);
+  };
+  return result;
+}