antlr.c

SRI international 发布的OAA框架软件

  
			ExceptionGroup *eg;
  RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
  set toksrefd, rulesrefd;
  char *pdecl=NULL, *ret=NULL, *a; CurRetDef = CurParmDef = NULL;
  CurExGroups = NULL;
  CurElementLabels = NULL;
  CurAstLabelsInActions = NULL; /* MR27 */
  /* We want a new element label hash table for each rule */
  if ( Elabel!=NULL ) killHashTable(Elabel);
  Elabel = newHashTable();
  attribsRefdFromAction = empty;
  zzmatch(NonTerminal);
  q=NULL;
  if ( hash_get(Rname, LATEXT(1))!=NULL ) {
    err(eMsg1("duplicate rule definition: '%s'",LATEXT(1)));
    CannotContinue=TRUE;
  }
  else
  {
    q = (RuleEntry *)hash_add(Rname,
    LATEXT(1),
    (Entry *)newRuleEntry(LATEXT(1)));
    CurRule = q->str;
  }
  CurRuleNode = q;
  f = CurFile; l = zzline;
  NumRules++;
 zzCONSUME;

  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==103) ) {
      zzmatch(103);
      if ( q!=NULL ) q->noAST = TRUE;
 zzCONSUME;

    }
    else {
      if ( (setwd1[LA(1)]&0x80) ) {
      }
      else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    ;
    if ( (setwd2[LA(1)]&0x1) ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        if ( (LA(1)==104) ) {
          zzmatch(104); zzCONSUME;
        }
        else {
          if ( (LA(1)==PassAction) ) {
          }
          else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
        }
        zzEXIT(zztasp3);
        }
      }
      zzmatch(PassAction);
      pdecl = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
      require(pdecl!=NULL, "rule rule: cannot allocate param decl");
      strcpy(pdecl, LATEXT(1));
      CurParmDef = pdecl;
 zzCONSUME;

    }
    else {
      if ( (setwd2[LA(1)]&0x2) ) {
      }
      else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==105) ) {
      zzmatch(105); zzCONSUME;
      zzmatch(PassAction);
      ret = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
      require(ret!=NULL, "rule rule: cannot allocate ret type");
      strcpy(ret, LATEXT(1));
      CurRetDef = ret;
 zzCONSUME;

    }
    else {
      if ( (setwd2[LA(1)]&0x4) ) {
      }
      else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==QuotedTerm) ) {
      zzmatch(QuotedTerm);
      if ( q!=NULL ) q->egroup=mystrdup(LATEXT(1));
 zzCONSUME;

    }
    else {
      if ( (LA(1)==106) ) {
      }
      else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  
  if ( GenEClasseForRules && q!=NULL ) {
    e = newECnode;
    require(e!=NULL, "cannot allocate error class node");
    if ( q->egroup == NULL ) {a = q->str; a[0] = (char)toupper(a[0]);}
    else a = q->egroup;
    if ( Tnum( a ) == 0 )
    {
      e->tok = addTname( a );
      list_add(&eclasses, (char *)e);
      if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
      /* refers to itself */
      list_add(&(e->elist), mystrdup(q->str));
    }
    else {
      warn(eMsg1("default errclass for '%s' would conflict with token/errclass/tokclass",a));
      if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
      free((char *)e);
    }
  }
  BlkLevel++;
  if (BlkLevel >= MAX_BLK_LEVEL) fatal("Blocks nested too deeply");
  /* MR23 */    CurBlockID_array[BlkLevel] = CurBlockID;
  /* MR23 */    CurAltNum_array[BlkLevel] = CurAltNum;
  zzmatch(106);
  inAlt=1;
 zzCONSUME;

  block( &toksrefd, &rulesrefd );
  r = makeBlk(zzaArg(zztasp1,7),0, NULL /* pFirstSetSymbol */ );
  CurRuleBlk = (Junction *)r.left;
  CurRuleBlk->blockid = CurBlockID;
  CurRuleBlk->jtype = RuleBlk;
  if ( q!=NULL ) CurRuleBlk->rname = q->str;
  CurRuleBlk->file = f;
  CurRuleBlk->line = l;
  CurRuleBlk->pdecl = pdecl;
  CurRuleBlk->ret = ret;
  CurRuleBlk->lock = makelocks();
  CurRuleBlk->pred_lock = makelocks();
  CurRuleBlk->tokrefs = toksrefd;
  CurRuleBlk->rulerefs = rulesrefd;
  p = newJunction();	/* add EndRule Node */
  ((Junction *)r.right)->p1 = (Node *)p;
  r.right = (Node *) p;
  p->jtype = EndRule;
  p->lock = makelocks();
  p->pred_lock = makelocks();
  CurRuleBlk->end = p;
  if ( q!=NULL ) q->rulenum = NumRules;
  zzaArg(zztasp1,7) = r;
  
  /* MR23 */      CurBlockID_array[BlkLevel] = (-1);
  /* MR23 */      CurAltNum_array[BlkLevel] = (-1);                
  --BlkLevel;
  altFixup();leFixup();egFixup();
  zzmatch(107);
  inAlt=0;
 zzCONSUME;

  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==Action) ) {
      zzmatch(Action);
      a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
      require(a!=NULL, "rule rule: cannot allocate error action");
      strcpy(a, LATEXT(1));
      CurRuleBlk->erraction = a;
 zzCONSUME;

    }
    else {
      if ( (setwd2[LA(1)]&0x8) ) {
      }
      else {zzFAIL(1,zzerr9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (LA(1)==133) ) {
       eg  = exception_group();

      if ( eg!=NULL ) {
        list_add(&CurExGroups, (void *)eg);
        if (eg->label == NULL || *eg->label=='\0' ) q->has_rule_exception = 1;
      }
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  if ( q==NULL ) zzaArg(zztasp1,0 ).left = NULL; else zzaArg(zztasp1,0) = zzaArg(zztasp1,7);
  CurRuleBlk->exceptions = CurExGroups;
  CurRuleBlk->el_labels = CurElementLabels;
  CurRuleNode->ast_labels_in_actions = CurAstLabelsInActions;
  CurRuleNode = NULL;
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  CannotContinue=TRUE;  
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd2, 0x10);
  }
}

void
#ifdef __USE_PROTOS
laction(void)
#else
laction()
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  char *a;
  zzmatch(108); zzCONSUME;
  zzmatch(Action);
  
  a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  require(a!=NULL, "rule laction: cannot allocate action");
  strcpy(a, LATEXT(1));
  list_add(&LexActions, a);
 zzCONSUME;

  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  CannotContinue=TRUE;  
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd2, 0x20);
  }
}

void
#ifdef __USE_PROTOS
lmember(void)
#else
lmember()
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  char *a;
  zzmatch(109); zzCONSUME;
  zzmatch(Action);
  
  /* MR1 */		if (! GenCC) {
    /* MR1 */		  err("Use #lexmember only in C++ mode (to insert code in DLG class header");
    /* MR1 */	        } else {
    /* MR1 */		  a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
    /* MR1 */		  require(a!=NULL, "rule lmember: cannot allocate action");
    /* MR1 */		  strcpy(a, LATEXT(1));
    /* MR1 */		  list_add(&LexMemberActions, a);
    /* MR1 */		};
  /* MR1 */
 zzCONSUME;

  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  CannotContinue=TRUE;  
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd2, 0x40);
  }
}

void
#ifdef __USE_PROTOS
lprefix(void)
#else
lprefix()
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  char *a;
  zzmatch(110); zzCONSUME;
  zzmatch(Action);
  
  /* MR1 */		if (! GenCC) {
    /* MR1 */		  err("Use #lexprefix only in C++ mode (to insert code in DLG class header");
    /* MR1 */	        } else {
    /* MR1 */		  a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
    /* MR1 */		  require(a!=NULL, "rule lprefix: cannot allocate action");
    /* MR1 */		  strcpy(a, LATEXT(1));
    /* MR1 */		  list_add(&LexPrefixActions, a);
    /* MR1 */		};
  /* MR1 */
 zzCONSUME;

  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  CannotContinue=TRUE;  
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd2, 0x80);
  }
}

void
#ifdef __USE_PROTOS
aPred(void)
#else
aPred()
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  PredEntry     *predEntry=NULL;
  char          *name=NULL;
  Predicate     *predExpr=NULL;
  char          *predLiteral=NULL;
  int           save_file;
  int           save_line;
  int           predExprPresent=0;
  zzmatch(111);
  
  MR_usingPredNames=1;      /* will need to use -mrhoist version of genPredTree */
 zzCONSUME;

  zzmatch(TokenTerm);
  name=mystrdup(LATEXT(1));
 zzCONSUME;

  
  /* don't free - referenced in predicates */
  
            CurPredName=(char *)calloc(1,strlen(name) + 10);
  strcat(CurPredName,"#pred ");
  strcat(CurPredName,name);
  
            predEntry=(PredEntry *) hash_get(Pname,name);
  if (predEntry != NULL) {
  warnFL(eMsg1("#pred %s previously defined - ignored",name),
  FileStr[action_file],action_line);
  name=NULL;
};
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==Pred) ) {
      zzmatch(Pred);
      predLiteral=mystrdup(LATEXT(1));
      save_line=action_line;
      save_file=action_file;
 zzCONSUME;

      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        if ( (setwd3[LA(1)]&0x1) ) {
           predExpr  = predOrExpr();

          predExprPresent=1;
        }
        else {
          if ( (setwd3[LA(1)]&0x2) ) {
          }
          else {zzFAIL(1,zzerr10,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
        }
        zzEXIT(zztasp3);
        }
      }
      if (predLiteral != NULL && name != NULL) {
        
                      /*
        *  predExpr may be NULL due to syntax errors
        *    or simply omitted by the user
        */
        
                      predEntry=newPredEntry(name);
        predEntry->file=save_file;
        predEntry->line=save_line;
        predExpr=MR_predFlatten(predExpr);
        predEntry->predLiteral=predLiteral;
        if (! predExprPresent || predExpr == NULL) {
          predExpr=new_pred();
          predExpr->expr=predLiteral;
          predExpr->source=newActionNode();
          predExpr->source->action=predExpr->expr;
          predExpr->source->rname=CurPredName;
          predExpr->source->line=action_line;
          predExpr->source->file=action_file;
          predExpr->source->is_predicate=1;
          predExpr->k=predicateLookaheadDepth(predExpr->source);
        };
        predEntry->pred=predExpr;
        hash_add(Pname,name,(Entry *)predEntry);
        predExpr=NULL;
      };
      predicate_free(predExpr);
    }
    else {
      if ( (setwd3[LA(1)]&0x4) ) {
        save_line=zzline; save_file=CurFile;
         predExpr  = predOrExpr();

        if (predExpr != NULL && name != NULL) {
          predEntry=newPredEntry(name);
          predEntry->file=CurFile;
          predEntry->line=zzline;
          predExpr=MR_predFlatten(predExpr);
          predEntry->pred=predExpr;
          hash_add(Pname,name,(Entry *)predEntry);
          predExpr=NULL;
        };
        predicate_free(predExpr);
      }
      else {zzFAIL(1,zzerr11,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==107) ) {
      zzmatch(107); zzCONSUME;
    }
    else {
      if ( (setwd3[LA(1)]&0x8) ) {
      }
      else {zzFAIL(1,zzerr12,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  predicate_free(predExpr);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd3, 0x10);
  }
}

Predicate *
#ifdef __USE_PROTOS
predOrExpr(void)
#else
predOrExpr()
#endif
{
  Predicate *   _retv;
  zzRULE;
  zzBLOCK(zztasp1);
  PCCTS_PURIFY(_retv,sizeof(Predicate *  ))
  zzMake0;
  {
  Predicate     *ORnode;