rdqlparser.java

这是外国一个开源推理机

    }
                        if (projection == null) {
                                // "SELECT *", take all shared variables
                                projection = new ArrayList(_sharedVars.size());
                                for (int i = 0; i < _sharedVars.size(); i++) {
                                        Var var = (Var)_sharedVars.get(i);
                                        projection.add( new ProjectionElem(var, null) );
                                }
                        }

                        if (projection.isEmpty()) {
                                {if (true) throw new ParseException("Select clause does not contain any variables.");}
                        }

                        {if (true) return new SelectQuery(projection, graphPattern);}
    throw new Error("Missing return statement in function");
  }

  final public List projection() throws ParseException {
        Var var;
        List projection;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STAR:
      jj_consume_token(STAR);
                 {if (true) return null;}
      break;
    case VAR:
          projection = new ArrayList(16);
      var = var();
                       projection.add( new ProjectionElem(var) );
      label_3:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
        case VAR:
          ;
          break;
        default:
          jj_la1[7] = jj_gen;
          break label_3;
        }
        comma_opt();
        var = var();
                                           projection.add( new ProjectionElem(var) );
      }
                        {if (true) return projection;}
      break;
    default:
      jj_la1[8] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public ProjectionElem projection_elem() throws ParseException {
        Var var;
    var = var();
                {if (true) return new ProjectionElem(var);}
    throw new Error("Missing return statement in function");
  }

  final public void triple_pattern_clause(GraphPattern graphPattern) throws ParseException {
    triple_pattern(graphPattern);
    label_4:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
      case LPAREN:
        ;
        break;
      default:
        jj_la1[9] = jj_gen;
        break label_4;
      }
      comma_opt();
      triple_pattern(graphPattern);
    }
  }

  final public void triple_pattern(GraphPattern graphPattern) throws ParseException {
        ValueExpr subject, predicate, object;
        Var subjectVar, predicateVar, objectVar;
    jj_consume_token(LPAREN);
    subject = var_or_uri();
    comma_opt();
    predicate = var_or_uri();
    comma_opt();
    object = var_or_const();
    jj_consume_token(RPAREN);
                        if (subject instanceof Var) {
                                subjectVar = (Var)subject;
                        }
                        else {
                                subjectVar = _createAnonymousVar();
                                subjectVar.setValue( subject.getValue() );
                        }

                        if (predicate instanceof Var) {
                                predicateVar = (Var)predicate;
                        }
                        else {
                                predicateVar = _createAnonymousVar();
                                predicateVar.setValue( predicate.getValue() );
                        }

                        if (object instanceof Var) {
                                objectVar = (Var)object;
                        }
                        else {
                                objectVar = _createAnonymousVar();
                                objectVar.setValue( object.getValue() );
                        }

                        graphPattern.add( new TriplePattern(subjectVar, predicateVar, objectVar) );
  }

  final public void constraint_clause(GraphPattern graphPattern) throws ParseException {
        BooleanExpr boolExpr;
    boolExpr = boolean_expr();
                                    graphPattern.addConstraint(boolExpr);
    label_5:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
      case SUCHTHAT:
        ;
        break;
      default:
        jj_la1[10] = jj_gen;
        break label_5;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        jj_consume_token(COMMA);
        break;
      case SUCHTHAT:
        jj_consume_token(SUCHTHAT);
        break;
      default:
        jj_la1[11] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      boolExpr = boolean_expr();
                                            graphPattern.addConstraint(boolExpr);
    }
  }

  final public BooleanExpr boolean_expr() throws ParseException {
        BooleanExpr result, tmpExpr;
    result = conditional_and_expr();
    label_6:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SC_OR:
        ;
        break;
      default:
        jj_la1[12] = jj_gen;
        break label_6;
      }
      jj_consume_token(SC_OR);
      tmpExpr = conditional_and_expr();
                                result = new Or(result, tmpExpr);
    }
                        {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public BooleanExpr conditional_and_expr() throws ParseException {
        BooleanExpr result, tmpExpr;
    result = boolean_elem();
    label_7:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SC_AND:
        ;
        break;
      default:
        jj_la1[13] = jj_gen;
        break label_7;
      }
      jj_consume_token(SC_AND);
      tmpExpr = boolean_elem();
                                result = new And(result, tmpExpr);
    }
                        {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public BooleanExpr boolean_elem() throws ParseException {
        ValueExpr leftValue, rightValue;
        BooleanExpr expr;
        int op;
        String pattern;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case TRUE:
      jj_consume_token(TRUE);
                {if (true) return BooleanConstant.TRUE;}
      break;
    case FALSE:
      jj_consume_token(FALSE);
                {if (true) return BooleanConstant.FALSE;}
      break;
    default:
      jj_la1[15] = jj_gen;
      if (jj_2_1(5)) {
        jj_consume_token(LPAREN);
        expr = boolean_expr();
        jj_consume_token(RPAREN);
                {if (true) return expr;}
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NOT:
          jj_consume_token(NOT);
          expr = boolean_elem();
                {if (true) return new Not(expr);}
          break;
        case PLUS:
        case MINUS:
        case LPAREN:
        case NULL:
        case TEXT_LITERAL:
        case QUOTED_URI:
        case QNAME:
        case VAR:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
          leftValue = value_expr();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case STR_EQ:
          case STR_NE:
            op = string_compare_operator();
            rightValue = value_expr();
                                {if (true) return new StringCompare(leftValue, rightValue, op);}
            break;
          case EQ:
          case NE:
          case LT:
          case LE:
          case GE:
          case GT:
            op = value_compare_operator();
            rightValue = value_expr();
                                {if (true) return new ValueCompare(leftValue, rightValue, op);}
            break;
          case STR_MATCH:
            jj_consume_token(STR_MATCH);
            pattern = string();
                                {if (true) return new Like(leftValue, new StringConstant(pattern), true);}
            break;
          case STR_NMATCH:
            jj_consume_token(STR_NMATCH);
            pattern = string();
                                {if (true) return new Not( new Like(leftValue, new StringConstant(pattern), true) );}
            break;
          default:
            jj_la1[14] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          break;
        default:
          jj_la1[16] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public int string_compare_operator() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STR_EQ:
      jj_consume_token(STR_EQ);
                   {if (true) return StringCompare.EQ;}
      break;
    case STR_NE:
      jj_consume_token(STR_NE);
                   {if (true) return StringCompare.NE;}
      break;
    default:
      jj_la1[17] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public int value_compare_operator() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case EQ:
      jj_consume_token(EQ);
               {if (true) return ValueCompare.EQ;}
      break;
    case NE:
      jj_consume_token(NE);
               {if (true) return ValueCompare.NE;}
      break;
    case LT:
      jj_consume_token(LT);
               {if (true) return ValueCompare.LT;}
      break;
    case LE:
      jj_consume_token(LE);
               {if (true) return ValueCompare.LE;}
      break;
    case GE:
      jj_consume_token(GE);
               {if (true) return ValueCompare.GE;}
      break;
    case GT:
      jj_consume_token(GT);
               {if (true) return ValueCompare.GT;}
      break;
    default:
      jj_la1[18] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public ValueExpr value_expr() throws ParseException {
        ValueExpr result;
    result = additive_expr();
                {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public ValueExpr additive_expr() throws ParseException {
        ValueExpr result, tmpExpr;
        int op;
    result = multiplicative_expr();
    label_8:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PLUS:
      case MINUS:
        ;
        break;
      default:
        jj_la1[19] = jj_gen;
        break label_8;
      }
      op = additive_operator();
      tmpExpr = multiplicative_expr();
                        result = new MathExpr(result, tmpExpr, op);
    }
                {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public int additive_operator() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PLUS:
      jj_consume_token(PLUS);
                  {if (true) return MathExpr.PLUS;}
      break;
    case MINUS:
      jj_consume_token(MINUS);
                  {if (true) return MathExpr.SUBTRACT;}
      break;
    default:
      jj_la1[20] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public ValueExpr multiplicative_expr() throws ParseException {
        ValueExpr result, tmpExpr;
        int op;
    result = unary_expr();
    label_9:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case STAR:
      case SLASH:
      case REM:
        ;
        break;
      default:
        jj_la1[21] = jj_gen;
        break label_9;
      }
      op = multiplicative_operator();
      tmpExpr = unary_expr();
                        result = new MathExpr(result, tmpExpr, op);
    }
                {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public int multiplicative_operator() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STAR:
      jj_consume_token(STAR);
                  {if (true) return MathExpr.MULTIPLY;}
      break;
    case SLASH:
      jj_consume_token(SLASH);
                  {if (true) return MathExpr.DIVIDE;}
      break;
    case REM:
      jj_consume_token(REM);
                  {if (true) return MathExpr.REMAINDER;}
      break;
    default:
      jj_la1[22] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public ValueExpr unary_expr() throws ParseException {
        ValueExpr result;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case NULL:
    case TEXT_LITERAL:
    case QUOTED_URI:
    case QNAME:
    case VAR:
    case INTEGER_LITERAL:
    case FLOATING_POINT_LITERAL:
      result = var_or_const();
                {if (true) return result;}
      break;
    case PLUS:
      jj_consume_token(PLUS);
      result = unary_expr();
                {if (true) return result;}
      break;
    case MINUS:
      jj_consume_token(MINUS);
      result = unary_expr();
                // Multiply by -1
                {if (true) return new MathExpr(
                                new LiteralExpr( new LiteralImpl("-1", XSD_INTEGER) ), // -1
                                result, MathExpr.MULTIPLY);}
      break;
    case LPAREN:
      jj_consume_token(LPAREN);
      result = unary_expr();