开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
dumpnode.c
资源名称：pccts133.zip　[点击查看]
上传用户：itx_2006
上传日期：2007-01-06
资源大小：493k
文件大小：9k
源码类别：

编译器/解释器

开发平台：

Others

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