pythongrammar.java

无线通信的主要编程软件,是无线通信工作人员的必备工具,关天相关教程我会在后续传上.

      }
    } else if (jj_2_11(2)) {
      jj_consume_token(PRINT);
                           SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPRINT_STMT);
                           boolean jjtc002 = true;
                           jjtree.openNodeScope(jjtn002);
                           jjtreeOpenNodeScope(jjtn002);
      try {
        test();
        label_11:
        while (true) {
          if (jj_2_9(2)) {
            ;
          } else {
            break label_11;
          }
          jj_consume_token(COMMA);
          test();
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          Comma();
          break;
        default:
          jj_la1[23] = 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 = (SimpleNode)SimpleNode.jjtCreate(this, 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[24] = 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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTDEL_STMT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(DEL);
      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);
    }
    }
  }

//pass_stmt: 'pass'
  final public void pass_stmt() throws ParseException {
                   /*@bgen(jjtree) pass_stmt */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, 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:
      SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTBREAK_STMT);
      boolean jjtc001 = true;
      jjtree.openNodeScope(jjtn001);
      jjtreeOpenNodeScope(jjtn001);
      try {
        jj_consume_token(BREAK);
      } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001,  0);
        jjtreeCloseNodeScope(jjtn001);
      }
      }
      break;
    case CONTINUE:
      SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCONTINUE_STMT);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
      jjtreeOpenNodeScope(jjtn002);
      try {
        jj_consume_token(CONTINUE);
      } 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[25] = 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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTRETURN_STMT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(RETURN);
      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 121:
        SmartTestList();
        break;
      default:
        jj_la1[26] = 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);
    }
    }
  }

//yield_stmt: 'yield' [testlist]
  final public void yield_stmt() throws ParseException {
                    /*@bgen(jjtree) yield_stmt */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTYIELD_STMT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(YIELD);
      SmartTestList();
    } 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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTRAISE_STMT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(RAISE);
      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 121:
        test();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          jj_consume_token(COMMA);
          test();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            jj_consume_token(COMMA);
            test();
            break;
          default:
            jj_la1[27] = jj_gen;
            ;
          }
          break;
        default:
          jj_la1[28] = jj_gen;
          ;
        }
        break;
      default:
        jj_la1[29] = 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);
    }
    }
  }

//import_stmt: 'import' dotted_name (',' dotted_name)* | 'from' dotted_name 'import' ('*' | NAME (',' NAME)*)
  final public void import_stmt() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IMPORT:
      jj_consume_token(IMPORT);
      Import();
      break;
    case FROM:
      jj_consume_token(FROM);
      ImportFrom();
      break;
    default:
      jj_la1[30] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void Import() throws ParseException {
                /*@bgen(jjtree) Import */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIMPORT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      dotted_as_name();
      label_12:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[31] = jj_gen;
          break label_12;
        }
        jj_consume_token(COMMA);
        dotted_as_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 ImportFrom() throws ParseException {
                    /*@bgen(jjtree) ImportFrom */
                     SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIMPORTFROM);
                     boolean jjtc000 = true;
                     jjtree.openNodeScope(jjtn000);
                     jjtreeOpenNodeScope(jjtn000);String mod; String name;
    try {
      mod = dotted_name();
      jj_consume_token(IMPORT);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MULTIPLY:
        jj_consume_token(MULTIPLY);
        break;
      case OR_BOOL:
      case AND_BOOL:
      case NOT_BOOL:
      case IS:
      case IN:
      case LAMBDA:
      case IF:
      case ELSE:
      case ELIF:
      case WHILE:
      case FOR:
      case TRY:
      case EXCEPT:
      case DEF:
      case CLASS:
      case FINALLY:
      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:
        name = import_as_name();
        label_13:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[32] = jj_gen;
            break label_13;
          }
          jj_consume_token(COMMA);
          import_as_name();
        }
              jjtree.closeNodeScope(jjtn000, true);
              jjtc000 = false;
              jjtreeCloseNodeScope(jjtn000);
              if (mod.equals("__future__") && name.equals("generators"))
                token_source.generator_allowed = true;
        break;
      default:
        jj_la1[33] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {