pythongrammar.java

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

          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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTFUNCDEF);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(DEF);
      AnyName();
      parameters();
      jj_consume_token(COLON);
      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);
    }
    }
  }

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

//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_6:
      while (true) {
        if (jj_2_2(2)) {
          ;
        } else {
          break label_6;
        }
        jj_consume_token(COMMA);
        defaultarg();
      }
      if (jj_2_3(3)) {
        jj_consume_token(COMMA);
        ExtraArgList();
      } else {
        ;
      }
      if (jj_2_4(2)) {
        jj_consume_token(COMMA);
        ExtraKeywordList();
      } else {
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        jj_consume_token(COMMA);
        break;
      default:
        jj_la1[8] = jj_gen;
        ;
      }
      break;
    case MULTIPLY:
    case POWER:
      if (jj_2_5(2)) {
        ExtraArgList();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          jj_consume_token(COMMA);
          ExtraKeywordList();
          break;
        default:
          jj_la1[9] = jj_gen;
          ;
        }
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case MULTIPLY:
        case POWER:
          ExtraKeywordList();
          break;
        default:
          jj_la1[10] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      break;
    default:
      jj_la1[11] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void ExtraArgList() throws ParseException {
                      /*@bgen(jjtree) ExtraArgList */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEXTRAARGLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      jj_consume_token(MULTIPLY);
      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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEXTRAKEYWORDLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtreeOpenNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case POWER:
        jj_consume_token(POWER);
        break;
      case MULTIPLY:
        jj_consume_token(MULTIPLY);
        jj_consume_token(MULTIPLY);
        break;
      default:
        jj_la1[12] = 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 = (SimpleNode)SimpleNode.jjtCreate(this, 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[13] = 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);
      fplist();
      jj_consume_token(RPAREN);
      break;
    default:
      jj_la1[14] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

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

//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 121:
      simple_stmt();
      break;
    case IF:
    case WHILE:
    case FOR:
    case TRY:
    case DEF:
    case CLASS:
      compound_stmt();
      break;
    default:
      jj_la1[16] = 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_8:
    while (true) {
      if (jj_2_7(2)) {
        ;
      } else {
        break label_8;
      }
      jj_consume_token(SEMICOLON);
      small_stmt();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case SEMICOLON:
      jj_consume_token(SEMICOLON);
      break;
    default:
      jj_la1[17] = 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 {
    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:
      expr_stmt();
      break;
    case PRINT:
      print_stmt();
      break;
    case DEL:
      del_stmt();
      break;
    case PASS:
      pass_stmt();
      break;
    case BREAK:
    case CONTINUE:
    case RETURN:
    case YIELD:
    case RAISE:
      flow_stmt();
      break;
    case IMPORT:
    case FROM:
      import_stmt();
      break;
    case GLOBAL:
      global_stmt();