Examples of ASTPair

antlr.ASTPair
ASTPair: utility class used for manipulating a pair of ASTs representing the current AST root and current AST sibling. This exists to compensate for the lack of pointers or 'var' arguments in Java.
org.jostraca.comp.antlr.ASTPair
ASTPair: utility class used for manipulating a pair of ASTs representing the current AST root and current AST sibling. This exists to compensate for the lack of pointers or 'var' arguments in Java.

Examples of antlr.ASTPair

  }
  
  public final void superClassClause() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST superClassClause_AST = null;
    AST c_AST = null;
    Token first = LT(1);
    
    {
    switch ( LA(1)) {
    case LITERAL_extends:
    {
      match(LITERAL_extends);
      nls();
      classOrInterfaceType(false);
      c_AST = (AST)returnAST;
      nls();
      break;
    }
    case LCURLY:
    case LITERAL_implements:
    {
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    if ( inputState.guessing==0 ) {
      superClassClause_AST = (AST)currentAST.root;
      superClassClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1))).add(c_AST));
      currentAST.root = superClassClause_AST;
      currentAST.child = superClassClause_AST!=null &&superClassClause_AST.getFirstChild()!=null ?
        superClassClause_AST.getFirstChild() : superClassClause_AST;
      currentAST.advanceChildToEnd();
    }
    returnAST = superClassClause_AST;
  }

View Full Code Here

Examples of antlr.ASTPair

  }
  
  public final void implementsClause() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST implementsClause_AST = null;
    Token  i = null;
    AST i_AST = null;
    Token first = LT(1);
    
    {
    switch ( LA(1)) {
    case LITERAL_implements:
    {
      i = LT(1);
      i_AST = astFactory.create(i);
      match(LITERAL_implements);
      nls();
      classOrInterfaceType(true);
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop187:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          nls();
          classOrInterfaceType(true);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop187;
        }
        
      } while (true);
      }
      nls();
      break;
    }
    case LCURLY:
    case NLS:
    {
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    if ( inputState.guessing==0 ) {
      implementsClause_AST = (AST)currentAST.root;
      implementsClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE",first,LT(1))).add(implementsClause_AST));
      currentAST.root = implementsClause_AST;
      currentAST.child = implementsClause_AST!=null &&implementsClause_AST.getFirstChild()!=null ?
        implementsClause_AST.getFirstChild() : implementsClause_AST;
      currentAST.advanceChildToEnd();
    }
    implementsClause_AST = (AST)currentAST.root;
    returnAST = implementsClause_AST;
  }

View Full Code Here

Examples of antlr.ASTPair

  }
  
  public final void classBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST classBlock_AST = null;
    Token first = LT(1);
    
    match(LCURLY);
    {
    switch ( LA(1)) {
    case FINAL:
    case ABSTRACT:
    case STRICTFP:
    case LITERAL_static:
    case LITERAL_def:
    case IDENT:
    case LITERAL_class:
    case LITERAL_interface:
    case LITERAL_enum:
    case AT:
    case LITERAL_void:
    case LITERAL_boolean:
    case LITERAL_byte:
    case LITERAL_char:
    case LITERAL_short:
    case LITERAL_int:
    case LITERAL_float:
    case LITERAL_long:
    case LITERAL_double:
    case LITERAL_private:
    case LITERAL_public:
    case LITERAL_protected:
    case LITERAL_transient:
    case LITERAL_native:
    case LITERAL_threadsafe:
    case LITERAL_synchronized:
    case LITERAL_volatile:
    case LCURLY:
    {
      classField();
      astFactory.addASTChild(currentAST, returnAST);
      break;
    }
    case RCURLY:
    case SEMI:
    case NLS:
    {
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    {
    _loop122:
    do {
      if ((LA(1)==SEMI||LA(1)==NLS)) {
        sep();
        {
        switch ( LA(1)) {
        case FINAL:
        case ABSTRACT:
        case STRICTFP:
        case LITERAL_static:
        case LITERAL_def:
        case IDENT:
        case LITERAL_class:
        case LITERAL_interface:
        case LITERAL_enum:
        case AT:
        case LITERAL_void:
        case LITERAL_boolean:
        case LITERAL_byte:
        case LITERAL_char:
        case LITERAL_short:
        case LITERAL_int:
        case LITERAL_float:
        case LITERAL_long:
        case LITERAL_double:
        case LITERAL_private:
        case LITERAL_public:
        case LITERAL_protected:
        case LITERAL_transient:
        case LITERAL_native:
        case LITERAL_threadsafe:
        case LITERAL_synchronized:
        case LITERAL_volatile:
        case LCURLY:
        {
          classField();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case RCURLY:
        case SEMI:
        case NLS:
        {
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
      }
      else {
        break _loop122;
      }
      
    } while (true);
    }
    match(RCURLY);
    if ( inputState.guessing==0 ) {
      classBlock_AST = (AST)currentAST.root;
      classBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(classBlock_AST));
      currentAST.root = classBlock_AST;
      currentAST.child = classBlock_AST!=null &&classBlock_AST.getFirstChild()!=null ?
        classBlock_AST.getFirstChild() : classBlock_AST;
      currentAST.advanceChildToEnd();
    }
    classBlock_AST = (AST)currentAST.root;
    returnAST = classBlock_AST;
  }

View Full Code Here

Examples of antlr.ASTPair

  }
  
  public final void interfaceExtends() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST interfaceExtends_AST = null;
    Token  e = null;
    AST e_AST = null;
    Token first = LT(1);
    
    {
    switch ( LA(1)) {
    case LITERAL_extends:
    {
      e = LT(1);
      e_AST = astFactory.create(e);
      match(LITERAL_extends);
      nls();
      classOrInterfaceType(true);
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop183:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          nls();
          classOrInterfaceType(true);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop183;
        }
        
      } while (true);
      }
      nls();
      break;
    }
    case LCURLY:
    {
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    if ( inputState.guessing==0 ) {
      interfaceExtends_AST = (AST)currentAST.root;
      interfaceExtends_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1))).add(interfaceExtends_AST));
      currentAST.root = interfaceExtends_AST;
      currentAST.child = interfaceExtends_AST!=null &&interfaceExtends_AST.getFirstChild()!=null ?
        interfaceExtends_AST.getFirstChild() : interfaceExtends_AST;
      currentAST.advanceChildToEnd();
    }
    interfaceExtends_AST = (AST)currentAST.root;
    returnAST = interfaceExtends_AST;
  }

View Full Code Here

Examples of antlr.ASTPair

  }
  
  public final void interfaceBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST interfaceBlock_AST = null;
    Token first = LT(1);
    
    match(LCURLY);
    {
    switch ( LA(1)) {
    case FINAL:
    case ABSTRACT:
    case STRICTFP:
    case LITERAL_static:
    case LITERAL_def:
    case IDENT:
    case LITERAL_class:
    case LITERAL_interface:
    case LITERAL_enum:
    case AT:
    case LITERAL_void:
    case LITERAL_boolean:
    case LITERAL_byte:
    case LITERAL_char:
    case LITERAL_short:
    case LITERAL_int:
    case LITERAL_float:
    case LITERAL_long:
    case LITERAL_double:
    case LITERAL_private:
    case LITERAL_public:
    case LITERAL_protected:
    case LITERAL_transient:
    case LITERAL_native:
    case LITERAL_threadsafe:
    case LITERAL_synchronized:
    case LITERAL_volatile:
    {
      interfaceField();
      astFactory.addASTChild(currentAST, returnAST);
      break;
    }
    case RCURLY:
    case SEMI:
    case NLS:
    {
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    {
    _loop127:
    do {
      if ((LA(1)==SEMI||LA(1)==NLS)) {
        sep();
        {
        switch ( LA(1)) {
        case FINAL:
        case ABSTRACT:
        case STRICTFP:
        case LITERAL_static:
        case LITERAL_def:
        case IDENT:
        case LITERAL_class:
        case LITERAL_interface:
        case LITERAL_enum:
        case AT:
        case LITERAL_void:
        case LITERAL_boolean:
        case LITERAL_byte:
        case LITERAL_char:
        case LITERAL_short:
        case LITERAL_int:
        case LITERAL_float:
        case LITERAL_long:
        case LITERAL_double:
        case LITERAL_private:
        case LITERAL_public:
        case LITERAL_protected:
        case LITERAL_transient:
        case LITERAL_native:
        case LITERAL_threadsafe:
        case LITERAL_synchronized:
        case LITERAL_volatile:
        {
          interfaceField();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case RCURLY:
        case SEMI:
        case NLS:
        {
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
      }
      else {
        break _loop127;
      }
      
    } while (true);
    }
    match(RCURLY);
    if ( inputState.guessing==0 ) {
      interfaceBlock_AST = (AST)currentAST.root;
      interfaceBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(interfaceBlock_AST));
      currentAST.root = interfaceBlock_AST;
      currentAST.child = interfaceBlock_AST!=null &&interfaceBlock_AST.getFirstChild()!=null ?
        interfaceBlock_AST.getFirstChild() : interfaceBlock_AST;
      currentAST.advanceChildToEnd();
    }
    interfaceBlock_AST = (AST)currentAST.root;
    returnAST = interfaceBlock_AST;
  }

View Full Code Here

Examples of antlr.ASTPair

  }
  
  public final void enumBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST enumBlock_AST = null;
    Token first = LT(1);
    
    match(LCURLY);
    nls();
    {
    boolean synPredMatched136 = false;
    if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_50.member(LA(2))))) {
      int _m136 = mark();
      synPredMatched136 = true;
      inputState.guessing++;
      try {
        {
        enumConstantsStart();
        }
      }
      catch (RecognitionException pe) {
        synPredMatched136 = false;
      }
      rewind(_m136);
inputState.guessing--;
    }
    if ( synPredMatched136 ) {
      enumConstants();
      astFactory.addASTChild(currentAST, returnAST);
    }
    else if ((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2)))) {
      {
      switch ( LA(1)) {
      case FINAL:
      case ABSTRACT:
      case STRICTFP:
      case LITERAL_static:
      case LITERAL_def:
      case IDENT:
      case LITERAL_class:
      case LITERAL_interface:
      case LITERAL_enum:
      case AT:
      case LITERAL_void:
      case LITERAL_boolean:
      case LITERAL_byte:
      case LITERAL_char:
      case LITERAL_short:
      case LITERAL_int:
      case LITERAL_float:
      case LITERAL_long:
      case LITERAL_double:
      case LITERAL_private:
      case LITERAL_public:
      case LITERAL_protected:
      case LITERAL_transient:
      case LITERAL_native:
      case LITERAL_threadsafe:
      case LITERAL_synchronized:
      case LITERAL_volatile:
      case LCURLY:
      {
        classField();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case RCURLY:
      case SEMI:
      case NLS:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
    }
    else {
      throw new NoViableAltException(LT(1), getFilename());
    }
    
    }
    {
    _loop140:
    do {
      if ((LA(1)==SEMI||LA(1)==NLS)) {
        sep();
        {
        switch ( LA(1)) {
        case FINAL:
        case ABSTRACT:
        case STRICTFP:
        case LITERAL_static:
        case LITERAL_def:
        case IDENT:
        case LITERAL_class:
        case LITERAL_interface:
        case LITERAL_enum:
        case AT:
        case LITERAL_void:
        case LITERAL_boolean:
        case LITERAL_byte:
        case LITERAL_char:
        case LITERAL_short:
        case LITERAL_int:
        case LITERAL_float:
        case LITERAL_long:
        case LITERAL_double:
        case LITERAL_private:
        case LITERAL_public:
        case LITERAL_protected:
        case LITERAL_transient:
        case LITERAL_native:
        case LITERAL_threadsafe:
        case LITERAL_synchronized:
        case LITERAL_volatile:
        case LCURLY:
        {
          classField();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case RCURLY:
        case SEMI:
        case NLS:
        {
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
      }
      else {
        break _loop140;
      }
      
    } while (true);
    }
    match(RCURLY);
    if ( inputState.guessing==0 ) {
      enumBlock_AST = (AST)currentAST.root;
      enumBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(enumBlock_AST));
      currentAST.root = enumBlock_AST;
      currentAST.child = enumBlock_AST!=null &&enumBlock_AST.getFirstChild()!=null ?
        enumBlock_AST.getFirstChild() : enumBlock_AST;
      currentAST.advanceChildToEnd();
    }
    enumBlock_AST = (AST)currentAST.root;
    returnAST = enumBlock_AST;
  }

View Full Code Here

Examples of antlr.ASTPair

  }
  
  public final void annotationBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST annotationBlock_AST = null;
    Token first = LT(1);
    
    match(LCURLY);
    {
    switch ( LA(1)) {
    case FINAL:
    case ABSTRACT:
    case STRICTFP:
    case LITERAL_static:
    case LITERAL_def:
    case IDENT:
    case LITERAL_class:
    case LITERAL_interface:
    case LITERAL_enum:
    case AT:
    case LITERAL_void:
    case LITERAL_boolean:
    case LITERAL_byte:
    case LITERAL_char:
    case LITERAL_short:
    case LITERAL_int:
    case LITERAL_float:
    case LITERAL_long:
    case LITERAL_double:
    case LITERAL_private:
    case LITERAL_public:
    case LITERAL_protected:
    case LITERAL_transient:
    case LITERAL_native:
    case LITERAL_threadsafe:
    case LITERAL_synchronized:
    case LITERAL_volatile:
    {
      annotationField();
      astFactory.addASTChild(currentAST, returnAST);
      break;
    }
    case RCURLY:
    case SEMI:
    case NLS:
    {
      break;
    }
    default:
    {
      throw new NoViableAltException(LT(1), getFilename());
    }
    }
    }
    {
    _loop132:
    do {
      if ((LA(1)==SEMI||LA(1)==NLS)) {
        sep();
        {
        switch ( LA(1)) {
        case FINAL:
        case ABSTRACT:
        case STRICTFP:
        case LITERAL_static:
        case LITERAL_def:
        case IDENT:
        case LITERAL_class:
        case LITERAL_interface:
        case LITERAL_enum:
        case AT:
        case LITERAL_void:
        case LITERAL_boolean:
        case LITERAL_byte:
        case LITERAL_char:
        case LITERAL_short:
        case LITERAL_int:
        case LITERAL_float:
        case LITERAL_long:
        case LITERAL_double:
        case LITERAL_private:
        case LITERAL_public:
        case LITERAL_protected:
        case LITERAL_transient:
        case LITERAL_native:
        case LITERAL_threadsafe:
        case LITERAL_synchronized:
        case LITERAL_volatile:
        {
          annotationField();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case RCURLY:
        case SEMI:
        case NLS:
        {
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
      }
      else {
        break _loop132;
      }
      
    } while (true);
    }
    match(RCURLY);
    if ( inputState.guessing==0 ) {
      annotationBlock_AST = (AST)currentAST.root;
      annotationBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(OBJBLOCK,"OBJBLOCK",first,LT(1))).add(annotationBlock_AST));
      currentAST.root = annotationBlock_AST;
      currentAST.child = annotationBlock_AST!=null &&annotationBlock_AST.getFirstChild()!=null ?
        annotationBlock_AST.getFirstChild() : annotationBlock_AST;
      currentAST.advanceChildToEnd();
    }
    annotationBlock_AST = (AST)currentAST.root;
    returnAST = annotationBlock_AST;
  }

View Full Code Here

Examples of antlr.ASTPair

  }
  
  public final void typeParameter() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeParameter_AST = null;
    Token  id = null;
    AST id_AST = null;
    Token first = LT(1);
    
    {
    id = LT(1);
    id_AST = astFactory.create(id);
    astFactory.addASTChild(currentAST, id_AST);
    match(IDENT);
    }
    {
    if ((LA(1)==LITERAL_extends) && (LA(2)==IDENT||LA(2)==NLS)) {
      typeParameterBounds();
      astFactory.addASTChild(currentAST, returnAST);
    }
    else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_54.member(LA(2)))) {
    }
    else {
      throw new NoViableAltException(LT(1), getFilename());
    }
    
    }
    if ( inputState.guessing==0 ) {
      typeParameter_AST = (AST)currentAST.root;
      typeParameter_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_PARAMETER,"TYPE_PARAMETER",first,LT(1))).add(typeParameter_AST));
      currentAST.root = typeParameter_AST;
      currentAST.child = typeParameter_AST!=null &&typeParameter_AST.getFirstChild()!=null ?
        typeParameter_AST.getFirstChild() : typeParameter_AST;
      currentAST.advanceChildToEnd();
    }
    typeParameter_AST = (AST)currentAST.root;
    returnAST = typeParameter_AST;
  }

View Full Code Here

Examples of antlr.ASTPair

  }
  
  public final void typeParameterBounds() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeParameterBounds_AST = null;
    Token first = LT(1);
    
    match(LITERAL_extends);
    nls();
    classOrInterfaceType(true);
    astFactory.addASTChild(currentAST, returnAST);
    {
    _loop117:
    do {
      if ((LA(1)==BAND)) {
        match(BAND);
        nls();
        classOrInterfaceType(true);
        astFactory.addASTChild(currentAST, returnAST);
      }
      else {
        break _loop117;
      }
      
    } while (true);
    }
    if ( inputState.guessing==0 ) {
      typeParameterBounds_AST = (AST)currentAST.root;
      typeParameterBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_UPPER_BOUNDS,"TYPE_UPPER_BOUNDS",first,LT(1))).add(typeParameterBounds_AST));
      currentAST.root = typeParameterBounds_AST;
      currentAST.child = typeParameterBounds_AST!=null &&typeParameterBounds_AST.getFirstChild()!=null ?
        typeParameterBounds_AST.getFirstChild() : typeParameterBounds_AST;
      currentAST.advanceChildToEnd();
    }
    typeParameterBounds_AST = (AST)currentAST.root;
    returnAST = typeParameterBounds_AST;
  }

View Full Code Here

Examples of antlr.ASTPair

  }
  
  public final void classField() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST classField_AST = null;
    AST mc_AST = null;
    AST ctor_AST = null;
    AST dg_AST = null;
    AST mad_AST = null;
    AST dd_AST = null;
    AST mods_AST = null;
    AST td_AST = null;
    AST s3_AST = null;
    AST s4_AST = null;
    Token first = LT(1);
    
    boolean synPredMatched190 = false;
    if (((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2))))) {
      int _m190 = mark();
      synPredMatched190 = true;
      inputState.guessing++;
      try {
        {
        constructorStart();
        }
      }
      catch (RecognitionException pe) {
        synPredMatched190 = false;
      }
      rewind(_m190);
inputState.guessing--;
    }
    if ( synPredMatched190 ) {
      modifiersOpt();
      mc_AST = (AST)returnAST;
      constructorDefinition(mc_AST);
      ctor_AST = (AST)returnAST;
      if ( inputState.guessing==0 ) {
        classField_AST = (AST)currentAST.root;
        classField_AST = ctor_AST;
        currentAST.root = classField_AST;
        currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
          classField_AST.getFirstChild() : classField_AST;
        currentAST.advanceChildToEnd();
      }
    }
    else {
      boolean synPredMatched192 = false;
      if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))))) {
        int _m192 = mark();
        synPredMatched192 = true;
        inputState.guessing++;
        try {
          {
          genericMethodStart();
          }
        }
        catch (RecognitionException pe) {
          synPredMatched192 = false;
        }
        rewind(_m192);
inputState.guessing--;
      }
      if ( synPredMatched192 ) {
        genericMethod();
        dg_AST = (AST)returnAST;
        if ( inputState.guessing==0 ) {
          classField_AST = (AST)currentAST.root;
          classField_AST = dg_AST;
          currentAST.root = classField_AST;
          currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
            classField_AST.getFirstChild() : classField_AST;
          currentAST.advanceChildToEnd();
        }
      }
      else {
        boolean synPredMatched194 = false;
        if (((_tokenSet_12.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
          int _m194 = mark();
          synPredMatched194 = true;
          inputState.guessing++;
          try {
            {
            multipleAssignmentDeclarationStart();
            }
          }
          catch (RecognitionException pe) {
            synPredMatched194 = false;
          }
          rewind(_m194);
inputState.guessing--;
        }
        if ( synPredMatched194 ) {
          multipleAssignmentDeclaration();
          mad_AST = (AST)returnAST;
          if ( inputState.guessing==0 ) {
            classField_AST = (AST)currentAST.root;
            classField_AST = mad_AST;
            currentAST.root = classField_AST;
            currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
              classField_AST.getFirstChild() : classField_AST;
            currentAST.advanceChildToEnd();
          }
        }
        else {
          boolean synPredMatched196 = false;
          if (((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
            int _m196 = mark();
            synPredMatched196 = true;
            inputState.guessing++;
            try {
              {
              declarationStart();
              }
            }
            catch (RecognitionException pe) {
              synPredMatched196 = false;
            }
            rewind(_m196);
inputState.guessing--;
          }
          if ( synPredMatched196 ) {
            declaration();
            dd_AST = (AST)returnAST;
            if ( inputState.guessing==0 ) {
              classField_AST = (AST)currentAST.root;
              classField_AST = dd_AST;
              currentAST.root = classField_AST;
              currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
                classField_AST.getFirstChild() : classField_AST;
              currentAST.advanceChildToEnd();
            }
          }
          else {
            boolean synPredMatched198 = false;
            if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
              int _m198 = mark();
              synPredMatched198 = true;
              inputState.guessing++;
              try {
                {
                typeDeclarationStart();
                }
              }
              catch (RecognitionException pe) {
                synPredMatched198 = false;
              }
              rewind(_m198);
inputState.guessing--;
            }
            if ( synPredMatched198 ) {
              modifiersOpt();
              mods_AST = (AST)returnAST;
              {
              typeDefinitionInternal(mods_AST);
              td_AST = (AST)returnAST;
              if ( inputState.guessing==0 ) {
                classField_AST = (AST)currentAST.root;
                classField_AST = td_AST;
                currentAST.root = classField_AST;
                currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
                  classField_AST.getFirstChild() : classField_AST;
                currentAST.advanceChildToEnd();
              }
              }
            }
            else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY||LA(2)==NLS)) {
              match(LITERAL_static);
              nls();
              compoundStatement();
              s3_AST = (AST)returnAST;
              if ( inputState.guessing==0 ) {
                classField_AST = (AST)currentAST.root;
                classField_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(STATIC_INIT,"STATIC_INIT",first,LT(1))).add(s3_AST));
                currentAST.root = classField_AST;
                currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
                  classField_AST.getFirstChild() : classField_AST;
                currentAST.advanceChildToEnd();
              }
            }
            else if ((LA(1)==LCURLY)) {
              compoundStatement();
              s4_AST = (AST)returnAST;
              if ( inputState.guessing==0 ) {
                classField_AST = (AST)currentAST.root;
                classField_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(INSTANCE_INIT,"INSTANCE_INIT",first,LT(1))).add(s4_AST));
                currentAST.root = classField_AST;
                currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
                  classField_AST.getFirstChild() : classField_AST;
                currentAST.advanceChildToEnd();
              }
            }
            else {
              throw new NoViableAltException(LT(1), getFilename());
            }

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.