pythongrammar25.java

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

      jj_consume_token(AT);
      dotted_name();
    } 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);
    }
    }
  }

//parameters: '(' [varargslist] ')'
  final public void parameters() throws ParseException {
    jj_consume_token(LPAREN);
           this.findTokenAndAdd("(");
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LPAREN:
    case MULTIPLY:
    case POWER:
    case AS:
    case NAME:
      varargslist();
      break;
    default:
      jj_la1[9] = jj_gen;
      ;
    }
    jj_consume_token(RPAREN);
           this.findTokenAndAdd(")");
  }

//varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' ('**'|'*' '*') NAME] | ('**'|'*' '*') NAME) | fpdef ['=' test] (',' fpdef ['=' test])* [',']
  final public void varargslist() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LPAREN:
    case AS:
    case NAME:
      defaultarg();
      label_8:
      while (true) {
        if (jj_2_2(2)) {
          ;
        } else {
          break label_8;
        }
                                this.addSpecialToken(",");
        jj_consume_token(COMMA);
        defaultarg();
      }
      if (jj_2_3(3)) {
                       this.addSpecialToken(",");
        jj_consume_token(COMMA);
        ExtraArgList();
      } else {
        ;
      }
      if (jj_2_4(2)) {
                       this.addSpecialToken(",");
        jj_consume_token(COMMA);
        ExtraKeywordList();
      } else {
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
          this.addSpecialToken(",");
        jj_consume_token(COMMA);
        break;
      default:
        jj_la1[10] = jj_gen;
        ;
      }
      break;
    case MULTIPLY:
    case POWER:
      if (jj_2_5(2)) {
        ExtraArgList();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
                                        this.addSpecialToken(",");
          jj_consume_token(COMMA);
          ExtraKeywordList();
          break;
        default:
          jj_la1[11] = jj_gen;
          ;
        }
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case MULTIPLY:
        case POWER:
          ExtraKeywordList();
          break;
        default:
          jj_la1[12] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      break;
    default:
      jj_la1[13] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void ExtraArgList() throws ParseException {
                      /*@bgen(jjtree) ExtraArgList */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTEXTRAARGLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(MULTIPLY);
              this.addSpecialToken("*", STRATEGY_BEFORE_NEXT);
      Name();
    } 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 ExtraKeywordList() throws ParseException {
                          /*@bgen(jjtree) ExtraKeywordList */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTEXTRAKEYWORDLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case POWER:
        jj_consume_token(POWER);
           this.addSpecialToken("**", STRATEGY_BEFORE_NEXT);
        break;
      case MULTIPLY:
        jj_consume_token(MULTIPLY);
                                                                          this.addSpecialToken("*", STRATEGY_BEFORE_NEXT);
                                                                                                                            this.addSpecialToken("*", STRATEGY_BEFORE_NEXT);
        jj_consume_token(MULTIPLY);
        break;
      default:
        jj_la1[14] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      Name();
    } 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 defaultarg() throws ParseException {
                    /*@bgen(jjtree) defaultarg */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTDEFAULTARG);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      fpdef();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQUAL:
        jj_consume_token(EQUAL);
        test();
        break;
      default:
        jj_la1[15] = jj_gen;
        ;
      }
    } 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);
    }
    }
  }

//fpdef: NAME | '(' fplist ')'
  final public void fpdef() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AS:
    case NAME:
      Name();
      break;
    case LPAREN:
      jj_consume_token(LPAREN);
                      this.addSpecialToken("(",STRATEGY_BEFORE_NEXT);
      fplist();
      jj_consume_token(RPAREN);
                                                                                            this.findTokenAndAdd(")");
      break;
    default:
      jj_la1[16] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

//fplist: fpdef (',' fpdef)* [',']
  final public void fplist() throws ParseException {
                       /*@bgen(jjtree) tuple */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTTUPLE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      fpdef();
      label_9:
      while (true) {
        if (jj_2_6(2)) {
          ;
        } else {
          break label_9;
        }
                         this.addSpecialToken(",");
        jj_consume_token(COMMA);
        fpdef();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
                                                                         this.addSpecialToken(",");
        jj_consume_token(COMMA);
        break;
      default:
        jj_la1[17] = jj_gen;
        ;
      }
    } 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);
    }
    }
  }

//stmt: simple_stmt | compound_stmt
  final public void stmt() throws ParseException {
    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();
      break;
    default:
      jj_la1[18] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

//simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
  final public void simple_stmt() throws ParseException {
    small_stmt();
    label_10:
    while (true) {
      if (jj_2_7(2)) {
        ;
      } else {
        break label_10;
      }
      jj_consume_token(SEMICOLON);
      small_stmt();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case SEMICOLON:
      jj_consume_token(SEMICOLON);
      break;
    default:
      jj_la1[19] = jj_gen;
      ;
    }
    jj_consume_token(NEWLINE);
  }

//small_stmt: expr_stmt | print_stmt  | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | exec_stmt | assert_stmt
  final public void small_stmt() throws ParseException {
                          SimpleNode simpleNode;
    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 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:
      expr_stmt();
      break;
    case PRINT:
      print_stmt();
      break;
    case DEL:
      del_stmt();
      break;
    case PASS:
      pass_stmt();