parser.java

来自「mysql集群」· Java 代码 · 共 1,787 行 · 第 1/4 页

      ASTFunNode jjtn004 = new ASTFunNode(JJTFUNNODE);
      boolean jjtc004 = true;
      jjtree.openNodeScope(jjtn004);
        try {
          jj_consume_token(GE);
          PostfixExpression();
        jjtree.closeNodeScope(jjtn004,  2);
        jjtc004 = false;
        jjtn004.setFunction(tokenImage[GE], new ComparativeGE());
        } 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);
      }
        }
        break;
      default:
        jj_la1[6] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
  }

  final public void PostfixExpression() throws ParseException {
    AdditiveExpression();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IS_NULL:
    case IS_NOT_NULL:
    case IN:
    case BETWEEN:
    case LIKE:
    case NOT_LIKE:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IS_NOT_NULL:
            ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
        try {
          jj_consume_token(IS_NOT_NULL);
                  jjtree.closeNodeScope(jjtn001,  1);
                  jjtc001 = false;
                  jjtn001.setFunction(tokenImage[IS_NOT_NULL], new ComparativeIsNotNull());
        } finally {
            if (jjtc001) {
              jjtree.closeNodeScope(jjtn001,  1);
            }
        }
        break;
      case IS_NULL:
            ASTFunNode jjtn002 = new ASTFunNode(JJTFUNNODE);
            boolean jjtc002 = true;
            jjtree.openNodeScope(jjtn002);
        try {
          jj_consume_token(IS_NULL);
                  jjtree.closeNodeScope(jjtn002,  1);
                  jjtc002 = false;
                  jjtn002.setFunction(tokenImage[IS_NULL], new ComparativeIsNull());
        } finally {
            if (jjtc002) {
              jjtree.closeNodeScope(jjtn002,  1);
            }
        }
        break;
      case IN:
            ASTFunNode jjtn003 = new ASTFunNode(JJTFUNNODE);
            boolean jjtc003 = true;
            jjtree.openNodeScope(jjtn003);
        try {
          jj_consume_token(IN);
          Array();
                  jjtree.closeNodeScope(jjtn003,  2);
                  jjtc003 = false;
                  jjtn003.setFunction(tokenImage[IN], new In());
        } 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);
            }
        }
        break;
      case BETWEEN:
            ASTFunNode jjtn004 = new ASTFunNode(JJTFUNNODE);
            boolean jjtc004 = true;
            jjtree.openNodeScope(jjtn004);
        try {
          jj_consume_token(BETWEEN);
          AdditiveExpression();
          jj_consume_token(AND);
          AdditiveExpression();
                  jjtree.closeNodeScope(jjtn004,  3);
                  jjtc004 = false;
                  jjtn004.setFunction(tokenImage[BETWEEN], new Between());
        } 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,  3);
            }
        }
        break;
      case LIKE:
            ASTFunNode jjtn005 = new ASTFunNode(JJTFUNNODE);
            boolean jjtc005 = true;
            jjtree.openNodeScope(jjtn005);
        try {
          jj_consume_token(LIKE);
          AdditiveExpression();
                  jjtree.closeNodeScope(jjtn005,  2);
                  jjtc005 = false;
                  jjtn005.setFunction(tokenImage[LIKE], new Like());
        } 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);
            }
        }
        break;
      case NOT_LIKE:
            ASTFunNode jjtn006 = new ASTFunNode(JJTFUNNODE);
            boolean jjtc006 = true;
            jjtree.openNodeScope(jjtn006);
        try {
          jj_consume_token(NOT_LIKE);
          AdditiveExpression();
                  jjtree.closeNodeScope(jjtn006,  2);
                  jjtc006 = false;
                  jjtn006.setFunction(tokenImage[NOT_LIKE], new NotLike());
        } 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);
            }
        }
        break;
      default:
        jj_la1[7] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    default:
      jj_la1[8] = jj_gen;
      ;
    }
  }

  final public void AdditiveExpression() throws ParseException {
    MultiplicativeExpression();
    label_5:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CONCAT:
      case PLUS:
      case MINUS:
        ;
        break;
      default:
        jj_la1[9] = jj_gen;
        break label_5;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CONCAT:
      ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
      boolean jjtc001 = true;
      jjtree.openNodeScope(jjtn001);
        try {
          jj_consume_token(CONCAT);
          MultiplicativeExpression();
        jjtree.closeNodeScope(jjtn001,  2);
        jjtc001 = false;
        jjtn001.setFunction(tokenImage[CONCAT], new Concat());
        } 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);
      }
        }
        break;
      case PLUS:
      ASTFunNode jjtn002 = new ASTFunNode(JJTFUNNODE);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
        try {
          jj_consume_token(PLUS);
          MultiplicativeExpression();
        jjtree.closeNodeScope(jjtn002,  2);
        jjtc002 = false;
        jjtn002.setFunction(tokenImage[PLUS], new Add());
        } 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);
      }
        }
        break;
      case MINUS:
      ASTFunNode jjtn003 = new ASTFunNode(JJTFUNNODE);
      boolean jjtc003 = true;
      jjtree.openNodeScope(jjtn003);
        try {
          jj_consume_token(MINUS);
          MultiplicativeExpression();
        jjtree.closeNodeScope(jjtn003,  2);
        jjtc003 = false;
        jjtn003.setFunction(tokenImage[MINUS], new Subtract());
        } 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);
      }
        }
        break;
      default:
        jj_la1[10] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
  }

  final public void MultiplicativeExpression() throws ParseException {
    UnaryExpression();
    label_6:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MUL:
      case DIV:
      case DIV2:
      case MOD:
        ;
        break;
      default:
        jj_la1[11] = jj_gen;
        break label_6;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MUL:
      ASTFunNode jjtn001 = new ASTFunNode(JJTFUNNODE);
      boolean jjtc001 = true;
      jjtree.openNodeScope(jjtn001);
        try {
          jj_consume_token(MUL);
          UnaryExpression();
        jjtree.closeNodeScope(jjtn001,  2);
        jjtc001 = false;
        jjtn001.setFunction(tokenImage[MUL], new Multiply());
        } 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);
      }
        }
        break;
      case DIV:
      ASTFunNode jjtn002 = new ASTFunNode(JJTFUNNODE);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
        try {
          jj_consume_token(DIV);
          UnaryExpression();
        jjtree.closeNodeScope(jjtn002,  2);
        jjtc002 = false;
        jjtn002.setFunction(tokenImage[DIV], new Divide());
        } 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);
      }
        }
        break;
      case DIV2:
      ASTFunNode jjtn003 = new ASTFunNode(JJTFUNNODE);
      boolean jjtc003 = true;
      jjtree.openNodeScope(jjtn003);
        try {
          jj_consume_token(DIV2);
          UnaryExpression();
        jjtree.closeNodeScope(jjtn003,  2);
        jjtc003 = false;
        jjtn003.setFunction(tokenImage[DIV2], new Divide());
        } 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);
      }
        }
        break;
      case MOD:
      ASTFunNode jjtn004 = new ASTFunNode(JJTFUNNODE);
      boolean jjtc004 = true;
      jjtree.openNodeScope(jjtn004);
        try {
          jj_consume_token(MOD);
          UnaryExpression();
        jjtree.closeNodeScope(jjtn004,  2);
        jjtc004 = false;
        jjtn004.setFunction(tokenImage[MOD], new Modulus());
        } catch (Throwable jjte004) {
      if (jjtc004) {
        jjtree.clearNodeScope(jjtn004);
        jjtc004 = false;
      } else {
        jjtree.popNode();
      }