pythongrammar.java

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

      break;
    case EXEC:
      exec_stmt();
      break;
    case ASSERT:
      assert_stmt();
      break;
    default:
      jj_la1[18] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

//expr_stmt: testlist (augassign testlist | ('=' testlist)*)
  final public void expr_stmt() throws ParseException {
    SmartTestList();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PLUSEQ:
      jj_consume_token(PLUSEQ);
               SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_PLUS);
               boolean jjtc001 = true;
               jjtree.openNodeScope(jjtn001);
               jjtreeOpenNodeScope(jjtn001);
      try {
        SmartTestList();
      } 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,  2);
                 jjtreeCloseNodeScope(jjtn001);
               }
      }
      break;
    case MINUSEQ:
      jj_consume_token(MINUSEQ);
                SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_MINUS);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
                jjtreeOpenNodeScope(jjtn002);
      try {
        SmartTestList();
      } 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,  2);
                  jjtreeCloseNodeScope(jjtn002);
                }
      }
      break;
    case MULTIPLYEQ:
      jj_consume_token(MULTIPLYEQ);
                   SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_MULTIPLY);
                   boolean jjtc003 = true;
                   jjtree.openNodeScope(jjtn003);
                   jjtreeOpenNodeScope(jjtn003);
      try {
        SmartTestList();
      } catch (Throwable jjte003) {
                   if (jjtc003) {
                     jjtree.clearNodeScope(jjtn003);
                     jjtc003 = false;
                   } else {
                     jjtree.popNode();
                   }
                   if (jjte003 instanceof RuntimeException) {
                     {if (true) throw (RuntimeException)jjte003;}
                   }
                   if (jjte003 instanceof ParseException) {
                     {if (true) throw (ParseException)jjte003;}
                   }
                   {if (true) throw (Error)jjte003;}
      } finally {
                   if (jjtc003) {
                     jjtree.closeNodeScope(jjtn003,  2);
                     jjtreeCloseNodeScope(jjtn003);
                   }
      }
      break;
    case DIVIDEEQ:
      jj_consume_token(DIVIDEEQ);
                 SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_DIVIDE);
                 boolean jjtc004 = true;
                 jjtree.openNodeScope(jjtn004);
                 jjtreeOpenNodeScope(jjtn004);
      try {
        SmartTestList();
      } catch (Throwable jjte004) {
                 if (jjtc004) {
                   jjtree.clearNodeScope(jjtn004);
                   jjtc004 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte004 instanceof RuntimeException) {
                   {if (true) throw (RuntimeException)jjte004;}
                 }
                 if (jjte004 instanceof ParseException) {
                   {if (true) throw (ParseException)jjte004;}
                 }
                 {if (true) throw (Error)jjte004;}
      } finally {
                 if (jjtc004) {
                   jjtree.closeNodeScope(jjtn004,  2);
                   jjtreeCloseNodeScope(jjtn004);
                 }
      }
      break;
    case FLOORDIVIDEEQ:
      jj_consume_token(FLOORDIVIDEEQ);
                      SimpleNode jjtn005 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_FLOORDIVIDE);
                      boolean jjtc005 = true;
                      jjtree.openNodeScope(jjtn005);
                      jjtreeOpenNodeScope(jjtn005);
      try {
        SmartTestList();
      } catch (Throwable jjte005) {
                      if (jjtc005) {
                        jjtree.clearNodeScope(jjtn005);
                        jjtc005 = false;
                      } else {
                        jjtree.popNode();
                      }
                      if (jjte005 instanceof RuntimeException) {
                        {if (true) throw (RuntimeException)jjte005;}
                      }
                      if (jjte005 instanceof ParseException) {
                        {if (true) throw (ParseException)jjte005;}
                      }
                      {if (true) throw (Error)jjte005;}
      } finally {
                      if (jjtc005) {
                        jjtree.closeNodeScope(jjtn005,  2);
                        jjtreeCloseNodeScope(jjtn005);
                      }
      }
      break;
    case MODULOEQ:
      jj_consume_token(MODULOEQ);
                 SimpleNode jjtn006 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_MODULO);
                 boolean jjtc006 = true;
                 jjtree.openNodeScope(jjtn006);
                 jjtreeOpenNodeScope(jjtn006);
      try {
        SmartTestList();
      } catch (Throwable jjte006) {
                 if (jjtc006) {
                   jjtree.clearNodeScope(jjtn006);
                   jjtc006 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte006 instanceof RuntimeException) {
                   {if (true) throw (RuntimeException)jjte006;}
                 }
                 if (jjte006 instanceof ParseException) {
                   {if (true) throw (ParseException)jjte006;}
                 }
                 {if (true) throw (Error)jjte006;}
      } finally {
                 if (jjtc006) {
                   jjtree.closeNodeScope(jjtn006,  2);
                   jjtreeCloseNodeScope(jjtn006);
                 }
      }
      break;
    case ANDEQ:
      jj_consume_token(ANDEQ);
              SimpleNode jjtn007 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_AND);
              boolean jjtc007 = true;
              jjtree.openNodeScope(jjtn007);
              jjtreeOpenNodeScope(jjtn007);
      try {
        SmartTestList();
      } catch (Throwable jjte007) {
              if (jjtc007) {
                jjtree.clearNodeScope(jjtn007);
                jjtc007 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte007 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte007;}
              }
              if (jjte007 instanceof ParseException) {
                {if (true) throw (ParseException)jjte007;}
              }
              {if (true) throw (Error)jjte007;}
      } finally {
              if (jjtc007) {
                jjtree.closeNodeScope(jjtn007,  2);
                jjtreeCloseNodeScope(jjtn007);
              }
      }
      break;
    case OREQ:
      jj_consume_token(OREQ);
             SimpleNode jjtn008 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_OR);
             boolean jjtc008 = true;
             jjtree.openNodeScope(jjtn008);
             jjtreeOpenNodeScope(jjtn008);
      try {
        SmartTestList();
      } catch (Throwable jjte008) {
             if (jjtc008) {
               jjtree.clearNodeScope(jjtn008);
               jjtc008 = false;
             } else {
               jjtree.popNode();
             }
             if (jjte008 instanceof RuntimeException) {
               {if (true) throw (RuntimeException)jjte008;}
             }
             if (jjte008 instanceof ParseException) {
               {if (true) throw (ParseException)jjte008;}
             }
             {if (true) throw (Error)jjte008;}
      } finally {
             if (jjtc008) {
               jjtree.closeNodeScope(jjtn008,  2);
               jjtreeCloseNodeScope(jjtn008);
             }
      }
      break;
    case XOREQ:
      jj_consume_token(XOREQ);
              SimpleNode jjtn009 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_XOR);
              boolean jjtc009 = true;
              jjtree.openNodeScope(jjtn009);
              jjtreeOpenNodeScope(jjtn009);
      try {
        SmartTestList();
      } catch (Throwable jjte009) {
              if (jjtc009) {
                jjtree.clearNodeScope(jjtn009);
                jjtc009 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte009 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte009;}
              }
              if (jjte009 instanceof ParseException) {
                {if (true) throw (ParseException)jjte009;}
              }
              {if (true) throw (Error)jjte009;}
      } finally {
              if (jjtc009) {
                jjtree.closeNodeScope(jjtn009,  2);
                jjtreeCloseNodeScope(jjtn009);
              }
      }
      break;
    case LSHIFTEQ:
      jj_consume_token(LSHIFTEQ);
                 SimpleNode jjtn010 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_LSHIFT);
                 boolean jjtc010 = true;
                 jjtree.openNodeScope(jjtn010);
                 jjtreeOpenNodeScope(jjtn010);
      try {
        SmartTestList();
      } catch (Throwable jjte010) {
                 if (jjtc010) {
                   jjtree.clearNodeScope(jjtn010);
                   jjtc010 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte010 instanceof RuntimeException) {
                   {if (true) throw (RuntimeException)jjte010;}
                 }
                 if (jjte010 instanceof ParseException) {
                   {if (true) throw (ParseException)jjte010;}
                 }
                 {if (true) throw (Error)jjte010;}
      } finally {
                 if (jjtc010) {
                   jjtree.closeNodeScope(jjtn010,  2);
                   jjtreeCloseNodeScope(jjtn010);
                 }
      }
      break;
    case RSHIFTEQ:
      jj_consume_token(RSHIFTEQ);
                 SimpleNode jjtn011 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_RSHIFT);
                 boolean jjtc011 = true;
                 jjtree.openNodeScope(jjtn011);
                 jjtreeOpenNodeScope(jjtn011);
      try {
        SmartTestList();
      } catch (Throwable jjte011) {
                 if (jjtc011) {
                   jjtree.clearNodeScope(jjtn011);
                   jjtc011 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte011 instanceof RuntimeException) {
                   {if (true) throw (RuntimeException)jjte011;}
                 }
                 if (jjte011 instanceof ParseException) {
                   {if (true) throw (ParseException)jjte011;}
                 }
                 {if (true) throw (Error)jjte011;}
      } finally {
                 if (jjtc011) {
                   jjtree.closeNodeScope(jjtn011,  2);
                   jjtreeCloseNodeScope(jjtn011);
                 }
      }
      break;
    case POWEREQ:
      jj_consume_token(POWEREQ);
                SimpleNode jjtn012 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_POWER);
                boolean jjtc012 = true;
                jjtree.openNodeScope(jjtn012);
                jjtreeOpenNodeScope(jjtn012);
      try {
        SmartTestList();
      } catch (Throwable jjte012) {
                if (jjtc012) {
                  jjtree.clearNodeScope(jjtn012);
                  jjtc012 = false;
                } else {
                  jjtree.popNode();
                }
                if (jjte012 instanceof RuntimeException) {
                  {if (true) throw (RuntimeException)jjte012;}
                }
                if (jjte012 instanceof ParseException) {
                  {if (true) throw (ParseException)jjte012;}
                }
                {if (true) throw (Error)jjte012;}
      } finally {
                if (jjtc012) {
                  jjtree.closeNodeScope(jjtn012,  2);
                  jjtreeCloseNodeScope(jjtn012);
                }
      }
      break;
    default:
      jj_la1[20] = jj_gen;
      SimpleNode jjtn013 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEXPR_STMT);
      boolean jjtc013 = true;
      jjtree.openNodeScope(jjtn013);
      jjtreeOpenNodeScope(jjtn013);
      try {
        label_9:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case EQUAL:
            ;
            break;
          default:
            jj_la1[19] = jj_gen;
            break label_9;
          }
          jj_consume_token(EQUAL);
          SmartTestList();
        }
      } catch (Throwable jjte013) {
      if (jjtc013) {
        jjtree.clearNodeScope(jjtn013);
        jjtc013 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte013 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte013;}
      }
      if (jjte013 instanceof ParseException) {
        {if (true) throw (ParseException)jjte013;}
      }
      {if (true) throw (Error)jjte013;}
      } finally {
      if (jjtc013) {
        jjtree.closeNodeScope(jjtn013,  jjtree . nodeArity ( ) + 1);
        jjtreeCloseNodeScope(jjtn013);
      }
      }
    }
  }

//print_stmt: 'print' (test ',')* [test] | 'print' '>>' test (, test)+ [,]
  final public void print_stmt() throws ParseException {
    if (jj_2_10(2)) {
      jj_consume_token(PRINT);
      jj_consume_token(RSHIFT);
                                    SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPRINTEXT_STMT);
                                    boolean jjtc001 = true;
                                    jjtree.openNodeScope(jjtn001);
                                    jjtreeOpenNodeScope(jjtn001);
      try {
        test();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          label_10:
          while (true) {
            jj_consume_token(COMMA);
            test();
            if (jj_2_8(2)) {
              ;
            } else {
              break label_10;
            }
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            Comma();
            break;
          default:
            jj_la1[21] = jj_gen;
            ;
          }
          break;
        default:
          jj_la1[22] = 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);
                                    }