gen.c

本工具提供一个词法分析器和语法分析器的集成开发环境

genPredTree( Predicate *p, Node *j, int in_and_expr, int suppress_sva )
#else
genPredTree( p, j, in_and_expr, suppress_sva)
  Predicate     *p;
  Node          *j;
  int           in_and_expr;
  int           suppress_sva;
#endif
{

    int         allHaveContext=1;
    int         noneHaveContext=1;
    Tree        *groupTree;
    Tree        *oneTree;
    Predicate   *q;
    int         identicalORcontextOptimization=0;
    int         identicalANDcontextOptimization=0;

    if (0 && !MR_usingPredNames && !MRhoisting) {
      genPredTreeOrig(p,j,in_and_expr);
      return;
    };

    MR_predContextPresent(p,&allHaveContext,&noneHaveContext);

	if ( ! noneHaveContext ) {                 /* MR10 context guards ignored when -prc off */

      _gen("(");

            /* MR10 optimize OR predicates which are all leaves */

      if (p->expr == PRED_OR_LIST && MR_allPredLeaves(p->down)) {
        groupTree=MR_compute_pred_tree_context(p);
        for (q=p->down ; q != NULL ; q=q->right) {
          oneTree=MR_compute_pred_tree_context(q);
          if (! MR_tree_equ(groupTree,oneTree)) {
            Tfree(oneTree);
            break;
          };
          Tfree(oneTree);
        };
        Tfree(groupTree);
        if (q == NULL) {
          _gen("/* MR10 individual OR gates suppressed when all predicates are leaves");
          _gen(" with identical context */\n");
          genPredTreeGate(p,in_and_expr);   /* use the parent's in_and_expr for this gate */
          identicalORcontextOptimization=1;
        } else {
          MR_distinctORcontextOpt(p,j,in_and_expr);
          return;
        };
      } else if (p->expr == PRED_AND_LIST && MR_allPredLeaves(p->down)) {

            /* MR12 optimize AND predicates which are all leaves */

        groupTree=MR_compute_pred_tree_context(p);
        for (q=p->down ; q != NULL ; q=q->right) {
          oneTree=MR_compute_pred_tree_context(q);
          if (! MR_tree_equ(groupTree,oneTree)) {
            Tfree(oneTree);
            break;
          };
          Tfree(oneTree);
        };
        Tfree(groupTree);
        if (q == NULL) {
          _gen("/* MR12 individual AND gates suppressed when all predicates are leaves");
          _gen(" with identical context */\n");
          genPredTreeGate(p,in_and_expr);   /* use the parent's in_and_expr for this gate */
          identicalANDcontextOptimization=1;
        } else {
          genPredTreeGate(p, in_and_expr);
        };
      } else {
  	    genPredTreeGate(p, in_and_expr);
      };
	}

	/* if leaf node, just gen predicate */

	if ( p->down==NULL )
	{
		genPred(p,j,suppress_sva);
		if ( ! noneHaveContext ) _gen(")");   /* MR10 context guards ignored when -prc off */
		return;
	}

	/* if AND list, do both preds (only two possible) */
    /* MR10    not any more ! */

	if ( p->expr == PRED_AND_LIST )
	{
		Predicate *list;
		_gen("(");
		list = p->down;
        for (; list != NULL; list=list->right) {
          if (identicalANDcontextOptimization) {
            genPred(list, j,suppress_sva);
          } else {
	   	    genPredTree(list, j, 1, suppress_sva);  /* in and context */
          };
          if ( list->right!=NULL ) _gen("&&");
        };
		_gen(")");
		if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
		return;
	}

	if ( p->expr == PRED_OR_LIST )
	{
		Predicate *list;
		_gen("(");
		list = p->down;
		for (; list!=NULL; list=list->right)
		{
            if (identicalORcontextOptimization) {
	          genPred(list, j,suppress_sva);
            } else {
	   	      genPredTree(list, j, 0, suppress_sva);
            };
			if ( list->right!=NULL ) _gen("||");
		}
		_gen(")");
		if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
		return;
	}

	fatal_internal("predicate tree is wacked");
}

/* [genPredTreeMainXX] */

Predicate *     /* MR10 */
#ifdef __USE_PROTOS
genPredTreeMainXX( Predicate *p, Node *j ,int in_and_expr)
#else
genPredTreeMainXX( p, j ,in_and_expr)
    Predicate   *p;
    Node        *j;
    int         in_and_expr;
#endif
{

    int     allHaveContext=1;
    int     noneHaveContext=1;

#if 0
    fprintf(stderr,"Pred before\n");
    dumppred(p);
    fprintf(stderr,"\n");
    fprintf(stderr,"Pred after\n");
    dumppred(p);
    fprintf(stderr,"\n");
#endif

    p=MR_predSimplifyALL(p);    /* MR10 */

    require (MR_predicate_context_completed(p),"predicate context is not complete");

    MR_cleanup_pred_trees(p);   /* MR10 */

    MR_predContextPresent(p,&allHaveContext,&noneHaveContext);
    if (!noneHaveContext & !allHaveContext) {
      warnFL("predicate contains elements both with and without context",
                FileStr[j->file],j->line);
    };

    if (InfoP) {
       _gen("\n#if 0\n\n");
       MR_dumpPred(p,1);
       _gen("#endif\n");
    };
	genPredTree(p,j,in_and_expr,0);
    return p;
}

Predicate *     /* MR10 */
#ifdef __USE_PROTOS
genPredTreeMain( Predicate *p, Node *j)
#else
genPredTreeMain( p, j)
    Predicate   *p;
    Node        *j;
#endif
{
  return genPredTreeMainXX(p,j,1);
}

static void
#ifdef __USE_PROTOS
genExprTreeOriginal( Tree *t, int k )
#else
genExprTreeOriginal( t, k )
Tree *t;
int k;
#endif
{
	require(t!=NULL, "genExprTreeOriginal: NULL tree");
	
	if ( t->token == ALT )
	{
		_gen("("); genExprTreeOriginal(t->down, k); _gen(")");
		if ( t->right!=NULL )
		{
			_gen("||");
			on1line++;
			if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
			_gen("("); genExprTreeOriginal(t->right, k); _gen(")");
		}
		return;
	}
	if ( t->down!=NULL ) _gen("(");
	_gen1("LA(%d)==",k);
	if ( TokenString(t->token) == NULL ) _gen1("%d", t->token)
	else _gen1("%s", TokenString(t->token));
	if ( t->down!=NULL )
	{
		_gen("&&");
		on1line++;
		if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
		_gen("("); genExprTreeOriginal(t->down, k+1); _gen(")");
	}
	if ( t->down!=NULL ) _gen(")");
	if ( t->right!=NULL )
	{
		_gen("||");
		on1line++;
		if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
		_gen("("); genExprTreeOriginal(t->right, k); _gen(")");
	}
}

#ifdef __STDC__
static void MR_LAtokenString(int k,int token)
#else
static void MR_LAtokenString(k,token)
  int   k;
  int   token;
#endif
{
    char    *ts;

    ts=TokenString(token);
    if (ts == NULL) {
      _gen2(" LA(%d)==%d",k,token);
    } else {
      _gen2(" LA(%d)==%s",k,ts);
    };
}


#ifdef __STDC__
static int MR_countLeaves(Tree *t)
#else
static int MR_countLeaves(t)
  Tree  *t;
#endif
{
  if (t == NULL) return 0;
  if (t->token == ALT) {
    return MR_countLeaves(t->down)+MR_countLeaves(t->right);
  } else {
    return 1+MR_countLeaves(t->down)+MR_countLeaves(t->right);
  };
}

#ifdef __STDC__
static void MR_genOneLine(Tree *tree,int k)
#else
static void MR_genOneLine(tree,k)
  Tree      *tree;
  int       k;
#endif
{
    if (tree == NULL) return;
    if (tree->token == ALT) {
       MR_genOneLine(tree->down,k);
    } else {
       MR_LAtokenString(k,tree->token);
       if (tree->down != NULL &&
           tree->down->right == NULL) {
          _gen(" &&");
          MR_genOneLine(tree->down,k+1);
       } else if (tree->down != NULL) {
         _gen(" && (");
         MR_genOneLine(tree->down,k+1);
         _gen(")");
       };
    };
    if (tree->right != NULL) {
      _gen(" ||");
      MR_genOneLine(tree->right,k);
    };
}

/* @@@ */

static int across;
static int depth;
static int lastkonline;

#ifdef __STDC__
static void MR_genMultiLine(Tree *tree,int k)
#else
static void MR_genMultiLine(tree,k)
  Tree  *tree;
  int   k;
#endif
{
    int     i;

    if (tree == NULL) return;
    if (tree->token == ALT) {
      MR_genMultiLine(tree,k);
    } else {
      MR_LAtokenString(k,tree->token);
      lastkonline=k;
      across++;
      if (tree->down != NULL && tree->down->right == NULL) {
        if (across > 3) {
          _gen("\n");
          across=0;
          lastkonline=0;
          for (i=0 ; i < depth+k ; i++) _gen("   ");
          _gen("&&");
        } else {
          _gen(" &&");
        };
        MR_genMultiLine(tree->down,k+1);
      } else if (tree->down != NULL) {
        _gen("\n");
        lastkonline=0;
        across=0;
        for (i=0 ; i < depth+k ; i++) _gen("   ");
        _gen("&& (");
        MR_genMultiLine(tree->down,k+1);
        _gen(")");
      };
    };
    if (tree->right != NULL) {
      if (k < lastkonline) {
        _gen("\n");
        across=0;
        lastkonline=0;
        for (i=0; i < depth+k-1 ; i++) _gen("   ");
        _gen("||");
      } else if (across > 3 ) {
        _gen("\n");
        across=0;
        lastkonline=0;
        for (i=0; i < depth+k ; i++) _gen("   ");
        _gen("||");
      } else {
        _gen(" ||");
      };
      MR_genMultiLine(tree->right,k);
    };
}

#ifdef __STDC__
static void genExprTree(Tree *tree,int k)
#else
static void genExprTree(tree,k)
  Tree  *tree;
  int   k;
#endif
{
    int     count;
    int     across;

    require (tree != NULL,"genExprTree: tree is NULL");
    require (k > 0,"genExprTree: k <= 0");

    if (0 && !MRhoisting) {   /* MR11 make new version standard */
      genExprTreeOriginal(tree,k);
    } else {
      count=MR_countLeaves(tree);
      if (count < 5) {
        MR_genOneLine(tree,k);
      } else {
        _gen("\n");
        across=0;
        depth=0;
        lastkonline=0;
        MR_genMultiLine(tree,k);
        _gen("\n");
      };
    };
}


/*
 * Generate LL(k) type expressions of the form:
 *
 *		 (LA(1) == T1 || LA(1) == T2 || ... || LA(1) == Tn) &&
 *		 (LA(2) == T1 || LA(2) == T2 || ... || LA(2) == Tn) &&
 *			.....
 *		 (LA(k) == T1 || LA(k) == T2 || ... || LA(k) == Tn)
 *
 * If GenExprSetsOpt generate:
 *
 *		(setwdi[LA(1)]&(1<<j)) && (setwdi[LA(2)]&(1<<j)) ...
 *
 * where n is set_deg(expr) and Ti is some random token and k is the last nonempty
 * set in fset <=CLL_k.
 * k=1..CLL_k where CLL_k >= 1.
 *
 * This routine is visible only to this file and cannot answer a TRANS message.
 *
 */

/*  [genExpr] */

static int
#ifdef __USE_PROTOS
genExpr( Junction *j )
#else
genExpr( j )
Junction *j;
#endif
{
	int max_k;

	/* if full LL(k) is sufficient, then don't use approximate (-ck) lookahead
	 * from CLL_k..LL_k
	 */
	{
		int limit;
		if ( j->ftree!=NULL ) limit = LL_k;
		else limit = CLL_k;
		max_k = genExprSets(j->fset, limit);
	}

	/* Do tests for real tuples from other productions that conflict with
	 * artificial tuples generated by compression (using sets of tokens
	 * rather than k-trees).
	 */
	if ( j->ftree != NULL )
	{
		_gen(" && !("); genExprTree(j->ftree, 1); _gen(")");
	}

	if ( ParseWithPredicates && j->predicate!=NULL )
	{
		Predicate *p = j->predicate;
		warn_about_using_gk_option();
		_gen("&&");
		j->predicate=genPredTreeMain(p, (Node *)j);     /* MR10 */
	}

	return max_k;
}

static int
#ifdef __USE_PROTOS
genExprSets( set *fset, int limit )
#else
genExprSets( fset, limit )
set *fset;
int limit;
#endif
{
	int k = 1;
	int max_k = 0;
	unsigned *e, *g, firstTime=1;

    if (set_nil(fset[1])) {
      _gen(" 0 /* MR13 empty set expression  - undefined rule ? infinite left recursion ? */ ");
      MR_BadExprSets++;
    };

	if ( GenExprSetsOpt )
	{
		while ( k <= limit && !set_nil(fset[k]) )   /* MR11 */
		{
			if ( set_deg(fset[k])==1 )	/* too simple for a set? */
			{
				int e;
				_gen1("(LA(%d)==",k);
				e = set_int(fset[k]);
				if ( TokenString(e) == NULL ) _gen1("%d)", e)
				else _gen1("%s)", TokenString(e));
			}
			else
			{
				NewSet();
				FillSet( fset[k] );
				_gen3("(setwd%d[LA(%d)]&0x%x)", wordnum, k, 1<<setnum);
			}
			if ( k>max_k ) max_k = k;
			if ( k == CLL_k ) break;
			k++;
			if ( k<=limit && !set_nil(fset[k]) ) _gen(" && ");  /* MR11 */
			on1line++;
			if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
		}
		return max_k;
	}

	while ( k<= limit &&  !set_nil(fset[k]) )       /* MR11 */
	{