mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-29 17:17:42 +01:00
424 lines
9.2 KiB
C
424 lines
9.2 KiB
C
#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;
|
|
}
|