parser.c

SRI international 发布的OAA框架软件

AST* root = (AST*)malloc(sizeof(AST));
#endif
memset(root, 0, sizeof(AST));
currentBuf = stringbuffer_new(str, len);
parser_DEBUG = debug;
parser_error = FALSE;
zzerr = parser_errorWriter;
zzmode(START);
ANTLRf(startOneOnly(&root), currentBuf_read);
stringbuffer_delete(currentBuf);
parser_DEBUG = oldDebug;
return root;
}

ICLTerm* parser_getTermFromString(char* str, size_t len) {
return parser_getTermFromStringReal(str, len, FALSE);
}

ICLTerm* parser_getTermFromStringDebug(char* str, size_t len) {
return parser_getTermFromStringReal(str, len, TRUE);
}

ICLTerm* parser_getTermFromStringReal(char* str, size_t len, int debug) {
AST* root = getASTFromString(str, len, debug);
AST* treeTerm = zzchild(root);
ICLTerm* result = NULL;
int parsedOkay = FALSE;
if(parser_error) {
parser_error = FALSE;
parser_freeTree(root);
zzfree_ast(root);
icl_Free(result);
return NULL;
}
parsedOkay = astToTerm(treeTerm, &result, debug);
if(parser_error) {
parser_error = FALSE;
parser_freeTree(root);
zzfree_ast(root);
icl_Free(result);
return NULL;
}
if(parsedOkay == TRUE) {
zzfree_ast(root);
return result;
}
else {
parser_freeTree(root);
zzfree_ast(root);
return NULL;
}
}

int parser_getNetTermFromBuf(ICLTerm** result, stringbuffer_t* buf) {
#ifdef NORMAL_GC
AST* root = (AST*)GC_debug_malloc(sizeof(AST), __FILE__, __LINE__);
#else
AST* root = (AST*)malloc(sizeof(AST));
#endif
int parsedOkay = FALSE;
*result = NULL;
memset(root, 0, sizeof(AST));
currentBuf = buf;
parser_error = FALSE;
zzerr = parser_errorWriter;
zzmode(START);
ANTLRf(startNet(&root), currentBuf_read);
if(parser_error) {
parser_freeTree(root);
zzfree_ast(root);
icl_Free(*result);
*result = NULL;
if(parser_DEBUG) {
printf("parser_getNetTermFromBuf parser_error\n");
}
return FALSE;
}
parsedOkay = astToTerm(zzchild(root), result, FALSE);
if(parser_error) {
parser_freeTree(root);
zzfree_ast(root);
icl_Free(*result);
*result = NULL;
if(parser_DEBUG) {
printf("parser_getNetTermFromBuf parser_error\n");
}
return FALSE;
}
if(parsedOkay == TRUE) {
zzfree_ast(root);
return TRUE;
}
else {
parser_freeTree(root);
zzfree_ast(root);
if(parser_DEBUG) {
printf("parser_getNetTermFromBuf didn't parse okay\n");
}
return FALSE;
}
}

/*
int main(int argc, char* argv[]) {
AST* root;
while(1) {
zzmode(START);
ANTLR(startNet(&root), stdin);
printf("Printing AST: \n");
zzpre_ast(zzchild(root), printAst, before, after);
}
}
*/

void
#ifdef __USE_PROTOS
startOneOnly(AST**_root)
#else
startOneOnly(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  structure(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==DOT) ) {
      zzmatch(DOT);  zzCONSUME;
    }
    else {
      if ( (LA(1)==1) ) {
      }
      else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  if(parser_DEBUG) printf("completed structure for startOneOnly\n");
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x1);
  }
}

void
#ifdef __USE_PROTOS
startNet(AST**_root)
#else
startNet(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==DOT) ) {
      zzmatch(DOT);  zzCONSUME;
    }
    else {
      if ( (LA(1)==TERM_LITERAL) ) {
      }
      else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  netstruct(zzSTR); zzlink(_root, &_sibling, &_tail);
  if(parser_DEBUG) printf("completed netstruct for startNet\n");
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x2);
  }
}

void
#ifdef __USE_PROTOS
netstruct(AST**_root)
#else
netstruct(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  zzmatch(TERM_LITERAL); zzsubroot(_root, &_sibling, &_tail);
  (*_root)->type = STRUCT; if(parser_DEBUG) printf("netstruct\n");
 zzCONSUME;

  zzmatch(LPAREN);  zzCONSUME;
  nonEmptyExpressionList(zzSTR); zzlink(_root, &_sibling, &_tail);
  zzmatch(RPAREN); 
  zzEXIT(zztasp1); return;
 zzCONSUME;

  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x4);
  }
}

void
#ifdef __USE_PROTOS
structure(AST**_root)
#else
structure(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  semiExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (LA(1)==TURNSTILE)
 ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        zzmatch(TURNSTILE); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("struct\n");
      semiExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x8);
  }
}

void
#ifdef __USE_PROTOS
semiExpression(AST**_root)
#else
semiExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  backslashExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (LA(1)==SEMI) ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        zzmatch(SEMI); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("semiExpression\n");
      backslashExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x10);
  }
}

void
#ifdef __USE_PROTOS
backslashExpression(AST**_root)
#else
backslashExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  equalsExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (LA(1)==BACKSLASH) ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        zzmatch(BACKSLASH); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("backslashExpression\n");
      equalsExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x20);
  }
}

void
#ifdef __USE_PROTOS
equalsExpression(AST**_root)
#else
equalsExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  colonExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (LA(1)==EQUAL) ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        zzmatch(EQUAL); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("equalsExpression\n");
      colonExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x40);
  }
}

void
#ifdef __USE_PROTOS
colonExpression(AST**_root)
#else
colonExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  plusMinusExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (setwd1[LA(1)]&0x80) ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        if ( (LA(1)==COLON)
 ) {
          zzmatch(COLON); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        }
        else {
          if ( (LA(1)==DBL_COLON) ) {
            zzmatch(DBL_COLON); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
          }
          else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
        }
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("colonExpr\n");
      plusMinusExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd2, 0x1);
  }
}

void
#ifdef __USE_PROTOS
plusMinusExpression(AST**_root)
#else
plusMinusExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  multiplicativeExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (setwd2[LA(1)]&0x2) ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        if ( (LA(1)==PLUS) ) {
          zzmatch(PLUS); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        }
        else {
          if ( (LA(1)==MINUS) ) {
            zzmatch(MINUS); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
          }
          else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
        }
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("plusMinusExpression\n");
      multiplicativeExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd2, 0x4);
  }
}

void
#ifdef __USE_PROTOS
multiplicativeExpression(AST**_root)
#else
multiplicativeExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  unaryExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (setwd2[LA(1)]&0x8)
 ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        if ( (LA(1)==STAR) ) {
          zzmatch(STAR); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        }
        else {
          if ( (LA(1)==DIV) ) {
            zzmatch(DIV); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
          }
          else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
        }
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("multiplicativeExpr\n");
      unaryExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd2, 0x10);
  }
}

void
#ifdef __USE_PROTOS
unaryExpression(AST**_root)
#else
unaryExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  if ( (setwd2[LA(1)]&0x20) && (LA(2)==LPAREN) && !(
 LA(1)==BANG && LA(2)==1
|| LA(1)==SEMI && LA(2)==1
|| LA(1)==STRING_LITERAL && LA(2)==1
|| LA(1)==STAR && LA(2)==1
|| LA(1)==PLUS && LA(2)==1
|| LA(1)==MINUS && LA(2)==1
|| LA(1)==DIV && LA(2)==1
|| LA(1)==EQUAL && LA(2)==1
|| LA(1)==TURNSTILE && LA(2)==1
|| LA(1)==IDENT && LA(2)==1
|| LA(1)==SPECIAL_CHAR_LITERAL && LA(2)==1
) ) {
    normalStruct(zzSTR); zzlink(_root, &_sibling, &_tail);
  }
  else {
    if ( (LA(1)==ICLDATAQ_LITERAL) && (LA(2)==LPAREN) && !( LA(1)==ICLDATAQ_LITERAL && LA(2)==1) ) {
      icldataqStruct(zzSTR); zzlink(_root, &_sibling, &_tail);
    }
    else {
      if ( (setwd2[LA(1)]&0x40) && 
(setwd2[LA(2)]&0x80) ) {
        unaryExpressionNotPlusMinus(zzSTR); zzlink(_root, &_sibling, &_tail);
      }
      else {zzFAIL(2,zzerr6,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd3, 0x1);
  }
}

void
#ifdef __USE_PROTOS
normalStruct(AST**_root)
#else
normalStruct(_root)
AST **_root;
#endif