pythongrammar24.java

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

          while (true) {
                             this.addSpecialToken(",");
            jj_consume_token(COMMA);
            test();
            if (jj_2_8(2)) {
              ;
            } else {
              break label_12;
            }
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            Comma();
            break;
          default:
            jj_la1[23] = jj_gen;
            ;
          }
          break;
        default:
          jj_la1[24] = jj_gen;
          ;
        }
      } catch (Throwable jjte001) {
      if (jjtc001) {
        jjtree.clearNodeScope(jjtn001);
        jjtc001 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte001 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte001;}
      }
      if (jjte001 instanceof ParseException) {
        {if (true) throw (ParseException)jjte001;}
      }
      {if (true) throw (Error)jjte001;}
      } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true);
        jjtreeCloseNodeScope(jjtn001);
      }
      }
    } else if (jj_2_11(2)) {
      jj_consume_token(PRINT);
      SimpleNode jjtn002 = jjtree.builder.openNode( JJTPRINT_STMT);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
      jjtreeOpenNodeScope(jjtn002);
      try {
        test();
        label_13:
        while (true) {
          if (jj_2_9(2)) {
            ;
          } else {
            break label_13;
          }
                           this.addSpecialToken(",");
          jj_consume_token(COMMA);
          test();
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          Comma();
          break;
        default:
          jj_la1[25] = jj_gen;
          ;
        }
      } catch (Throwable jjte002) {
      if (jjtc002) {
        jjtree.clearNodeScope(jjtn002);
        jjtc002 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte002 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte002;}
      }
      if (jjte002 instanceof ParseException) {
        {if (true) throw (ParseException)jjte002;}
      }
      {if (true) throw (Error)jjte002;}
      } finally {
      if (jjtc002) {
        jjtree.closeNodeScope(jjtn002, true);
        jjtreeCloseNodeScope(jjtn002);
      }
      }
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PRINT:
      SimpleNode jjtn003 = jjtree.builder.openNode( JJTPRINT_STMT);
      boolean jjtc003 = true;
      jjtree.openNodeScope(jjtn003);
      jjtreeOpenNodeScope(jjtn003);
        try {
          jj_consume_token(PRINT);
        } finally {
      if (jjtc003) {
        jjtree.closeNodeScope(jjtn003, true);
        jjtreeCloseNodeScope(jjtn003);
      }
        }
        break;
      default:
        jj_la1[26] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
  }

//del_stmt: 'del' exprlist
  final public void del_stmt() throws ParseException {
                  /*@bgen(jjtree) del_stmt */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTDEL_STMT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      begin_del_stmt();
      exprlist();
    } 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_del_stmt() throws ParseException {
                        /*@bgen(jjtree) begin_del_stmt */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTBEGIN_DEL_STMT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(DEL);
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtreeCloseNodeScope(jjtn000);
         this.addToPeek("del ",false);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
      jjtreeCloseNodeScope(jjtn000);
    }
    }
  }

//pass_stmt: 'pass'
  final public void pass_stmt() throws ParseException {
                   /*@bgen(jjtree) pass_stmt */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTPASS_STMT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(PASS);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
      jjtreeCloseNodeScope(jjtn000);
    }
    }
  }

//flow_stmt: break_stmt | continue_stmt | return_stmt | yield_stmt | raise_stmt
  final public void flow_stmt() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case BREAK:
      jj_consume_token(BREAK);
              SimpleNode jjtn001 = jjtree.builder.openNode( JJTBREAK_STMT);
              boolean jjtc001 = true;
              jjtree.openNodeScope(jjtn001);
              jjtreeOpenNodeScope(jjtn001);
      try {
              jjtree.closeNodeScope(jjtn001,  0);
              jjtc001 = false;
              jjtreeCloseNodeScope(jjtn001);
             addToPeek("break",true);
      } finally {
              if (jjtc001) {
                jjtree.closeNodeScope(jjtn001,  0);
                jjtreeCloseNodeScope(jjtn001);
              }
      }
      break;
    case CONTINUE:
      jj_consume_token(CONTINUE);
                  SimpleNode jjtn002 = jjtree.builder.openNode( JJTCONTINUE_STMT);
                  boolean jjtc002 = true;
                  jjtree.openNodeScope(jjtn002);
                  jjtreeOpenNodeScope(jjtn002);
      try {
                  jjtree.closeNodeScope(jjtn002,  0);
                  jjtc002 = false;
                  jjtreeCloseNodeScope(jjtn002);
                 addToPeek("continue",true);
      } finally {
                  if (jjtc002) {
                    jjtree.closeNodeScope(jjtn002,  0);
                    jjtreeCloseNodeScope(jjtn002);
                  }
      }
      break;
    case RETURN:
      return_stmt();
      break;
    case YIELD:
      yield_stmt();
      break;
    case RAISE:
      raise_stmt();
      break;
    default:
      jj_la1[27] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

//return_stmt: 'return' [testlist]
  final public void return_stmt() throws ParseException {
                     /*@bgen(jjtree) return_stmt */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTRETURN_STMT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      begin_return_stmt();
      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 136:
        SmartTestList();
        break;
      default:
        jj_la1[28] = 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);
    }
    }
  }

  final public void begin_return_stmt() throws ParseException {
                           /*@bgen(jjtree) begin_return_stmt */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTBEGIN_RETURN_STMT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(RETURN);
             jjtree.closeNodeScope(jjtn000, true);
             jjtc000 = false;
             jjtreeCloseNodeScope(jjtn000);
            this.addToPeek("return ",false);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
      jjtreeCloseNodeScope(jjtn000);
    }
    }
  }

//yield_stmt: 'yield' [testlist]
  final public void yield_stmt() throws ParseException {
                    /*@bgen(jjtree) yield_stmt */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTYIELD_STMT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(YIELD);
      SmartTestList();
                            jjtree.closeNodeScope(jjtn000, true);
                            jjtc000 = false;
                            jjtreeCloseNodeScope(jjtn000);
                           this.addToPeek("yield ",false, Yield.class);
    } 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);
    }
    }
  }

//raise_stmt: 'raise' [test [',' test [',' test]]]
  final public void raise_stmt() throws ParseException {
                    /*@bgen(jjtree) raise_stmt */
  SimpleNode jjtn000 = jjtree.builder.openNode( JJTRAISE_STMT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(RAISE);
           this.addSpecialToken("raise ", STRATEGY_BEFORE_NEXT);
      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 136:
        test();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
                                                                            this.addSpecialToken(",");
          jj_consume_token(COMMA);
          test();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
                                                                                                                         this.addSpecialToken(",");
            jj_consume_token(COMMA);
            test();
            break;
          default:
            jj_la1[29] = jj_gen;
            ;
          }
          break;
        default:
          jj_la1[30] = jj_gen;
          ;
        }
        break;
      default:
        jj_la1[31] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) t