pythongrammar25.java

Python Development Environment (Python IDE plugin for Eclipse). Features editor, code completion, re

      case WITH:
      case AT:
      case NAME:
      case DECNUMBER:
      case HEXNUMBER:
      case OCTNUMBER:
      case FLOAT:
      case COMPLEX:
      case SINGLE_STRING:
      case SINGLE_STRING2:
      case TRIPLE_STRING:
      case TRIPLE_STRING2:
      case SINGLE_USTRING:
      case SINGLE_USTRING2:
      case TRIPLE_USTRING:
      case TRIPLE_USTRING2:
      case 137:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LPAREN:
        case LBRACE:
        case LBRACKET:
        case PLUS:
        case MINUS:
        case NOT:
        case NOT_BOOL:
        case LAMBDA:
        case PRINT:
        case PASS:
        case BREAK:
        case CONTINUE:
        case RETURN:
        case YIELD:
        case IMPORT:
        case FROM:
        case DEL:
        case RAISE:
        case GLOBAL:
        case EXEC:
        case ASSERT:
        case AS:
        case NAME:
        case DECNUMBER:
        case HEXNUMBER:
        case OCTNUMBER:
        case FLOAT:
        case COMPLEX:
        case SINGLE_STRING:
        case SINGLE_STRING2:
        case TRIPLE_STRING:
        case TRIPLE_STRING2:
        case SINGLE_USTRING:
        case SINGLE_USTRING2:
        case TRIPLE_USTRING:
        case TRIPLE_USTRING2:
        case 137:
          simple_stmt();
          break;
        case IF:
        case WHILE:
        case FOR:
        case TRY:
        case DEF:
        case CLASS:
        case WITH:
        case AT:
          compound_stmt();
          jj_consume_token(NEWLINE);
          break;
        default:
          jj_la1[0] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[1] = jj_gen;
        ;
      }
      label_2:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NEWLINE:
          ;
          break;
        default:
          jj_la1[2] = jj_gen;
          break label_2;
        }
        jj_consume_token(NEWLINE);
      }
      jj_consume_token(0);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtreeCloseNodeScope(jjtn000);
      {if (true) return (modType) jjtree.popNode();}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtreeCloseNodeScope(jjtn000);
      }
    }
    throw new Error("Missing return statement in function");
  }

//file_input: (NEWLINE | stmt)* ENDMARKER
  final public modType file_input() throws ParseException {
                       /*@bgen(jjtree) file_input */
                       SimpleNode jjtn000 = jjtree.builder.openNode( JJTFILE_INPUT);
                       boolean jjtc000 = true;
                       jjtree.openNodeScope(jjtn000);
                       jjtreeOpenNodeScope(jjtn000);token_source.single_input=false;
    try {
      label_3:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NEWLINE:
        case LPAREN:
        case LBRACE:
        case LBRACKET:
        case PLUS:
        case MINUS:
        case NOT:
        case NOT_BOOL:
        case LAMBDA:
        case IF:
        case WHILE:
        case FOR:
        case TRY:
        case DEF:
        case CLASS:
        case PRINT:
        case PASS:
        case BREAK:
        case CONTINUE:
        case RETURN:
        case YIELD:
        case IMPORT:
        case FROM:
        case DEL:
        case RAISE:
        case GLOBAL:
        case EXEC:
        case ASSERT:
        case AS:
        case WITH:
        case AT:
        case NAME:
        case DECNUMBER:
        case HEXNUMBER:
        case OCTNUMBER:
        case FLOAT:
        case COMPLEX:
        case SINGLE_STRING:
        case SINGLE_STRING2:
        case TRIPLE_STRING:
        case TRIPLE_STRING2:
        case SINGLE_USTRING:
        case SINGLE_USTRING2:
        case TRIPLE_USTRING:
        case TRIPLE_USTRING2:
        case 137:
          ;
          break;
        default:
          jj_la1[3] = jj_gen;
          break label_3;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NEWLINE:
          jj_consume_token(NEWLINE);
          break;
        case LPAREN:
        case LBRACE:
        case LBRACKET:
        case PLUS:
        case MINUS:
        case NOT:
        case NOT_BOOL:
        case LAMBDA:
        case IF:
        case WHILE:
        case FOR:
        case TRY:
        case DEF:
        case CLASS:
        case PRINT:
        case PASS:
        case BREAK:
        case CONTINUE:
        case RETURN:
        case YIELD:
        case IMPORT:
        case FROM:
        case DEL:
        case RAISE:
        case GLOBAL:
        case EXEC:
        case ASSERT:
        case AS:
        case WITH:
        case AT:
        case NAME:
        case DECNUMBER:
        case HEXNUMBER:
        case OCTNUMBER:
        case FLOAT:
        case COMPLEX:
        case SINGLE_STRING:
        case SINGLE_STRING2:
        case TRIPLE_STRING:
        case TRIPLE_STRING2:
        case SINGLE_USTRING:
        case SINGLE_USTRING2:
        case TRIPLE_USTRING:
        case TRIPLE_USTRING2:
        case 137:
          stmt();
          break;
        default:
          jj_la1[4] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jj_consume_token(0);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtreeCloseNodeScope(jjtn000);
      {if (true) return (modType) jjtree.popNode();}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtreeCloseNodeScope(jjtn000);
      }
    }
    throw new Error("Missing return statement in function");
  }

//eval_input: NEWLINE* testlist NEWLINE* ENDMARKER
  final public modType eval_input() throws ParseException {
                       /*@bgen(jjtree) eval_input */
                       SimpleNode jjtn000 = jjtree.builder.openNode( JJTEVAL_INPUT);
                       boolean jjtc000 = true;
                       jjtree.openNodeScope(jjtn000);
                       jjtreeOpenNodeScope(jjtn000);token_source.single_input=false;
    try {
      label_4:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NEWLINE:
          ;
          break;
        default:
          jj_la1[5] = jj_gen;
          break label_4;
        }
        jj_consume_token(NEWLINE);
      }
      SmartTestList();
      label_5:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NEWLINE:
          ;
          break;
        default:
          jj_la1[6] = jj_gen;
          break label_5;
        }
        jj_consume_token(NEWLINE);
      }
      jj_consume_token(0);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtreeCloseNodeScope(jjtn000);
      {if (true) return (modType) jjtree.popNode();}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtreeCloseNodeScope(jjtn000);
      }
    }
    throw new Error("Missing return statement in function");
  }

//funcdef: 'def' NAME parameters ':' suite
  final public void funcdef() throws ParseException {
                 /*@bgen(jjtree) funcdef */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTFUNCDEF);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      decorators();
      jj_consume_token(DEF);
      AnyName();
      parameters();
      jj_consume_token(COLON);
                                          this.addSpecialToken(":");
      suite();
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtreeCloseNodeScope(jjtn000);
      }
    }
  }

//@ call, name, attr ... <nl>
  final public void decorators() throws ParseException {
                    /*@bgen(jjtree) decorators */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTDECORATORS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      label_6:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case AT:
          ;
          break;
        default:
          jj_la1[7] = jj_gen;
          break label_6;
        }
        begin_decorator();
        label_7:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LPAREN:
            ;
            break;
          default:
            jj_la1[8] = jj_gen;
            break label_7;
          }
          jj_consume_token(LPAREN);
                                   this.addSpecialToken("(", STRATEGY_BEFORE_NEXT);
          insidetuporcall();
          jj_consume_token(RPAREN);
                                                                                                                  this.findTokenAndAdd(")");
        }
        jj_consume_token(NEWLINE);
      }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtreeCloseNodeScope(jjtn000);
      }
    }
  }

  final public void begin_decorator() throws ParseException {
                         /*@bgen(jjtree) begin_decorator */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTBEGIN_DECORATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {