serqlparser.java

这是外国一个开源推理机

      throw new ParseException();
    }
  }

  final public Var edge() throws ParseException {
        Var var;
        ResourceExpr uri;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case UNDERSCORE:
    case PREFIX_NAME:
      var = var();
                        // Variables in edges are bound:
                        _unboundVars.remove(var);

                        {if (true) return var;}
      break;
    case FULL_URI:
    case QNAME:
      uri = uri();
                        var = _createAnonymousVar();
                        var.setValue(uri.getValue());
                        {if (true) return var;}
      break;
    default:
      jj_la1[35] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

// Returns a list of Var objects
  final public List node(GraphPattern graphPattern) throws ParseException {
        Var var;
        List nodeElements = new ArrayList(4);
    jj_consume_token(LBRACE);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LBRACE:
    case UNDERSCORE:
    case LITERAL:
    case FULL_URI:
    case BNODE:
    case QNAME:
    case PREFIX_NAME:
    case POS_INTEGER:
    case NEG_INTEGER:
    case DECIMAL:
      var = node_elem(graphPattern);
                                                 nodeElements.add(var);
      label_4:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[36] = jj_gen;
          break label_4;
        }
        jj_consume_token(COMMA);
        var = node_elem(graphPattern);
                                                                 nodeElements.add(var);
      }
      break;
    default:
      jj_la1[37] = jj_gen;
      ;
    }
    jj_consume_token(RBRACE);
                        // If no expressions specified, then create an anonymous variable.
                        if (nodeElements.isEmpty()) {
                                nodeElements.add( _createAnonymousVar() );
                        }

                        // Create any implicit unequalities
                        for (int i = 0; i < nodeElements.size() - 1; i++) {
                                Var var1 = (Var)nodeElements.get(i);

                                for (int j = i + 1; j < nodeElements.size(); j++) {
                                        Var var2 = (Var)nodeElements.get(j);

                                        // At least one of the variables should be unlocked
                                        // for the unequality to make any sense:
                                        if (!var1.hasValue() || !var2.hasValue()) {
                                                graphPattern.addConstraint(
                                                                new ValueCompare(var1, var2, ValueCompare.NE));
                                        }
                                }
                        }

                        {if (true) return nodeElements;}
    throw new Error("Missing return statement in function");
  }

  final public Var node_elem(GraphPattern graphPattern) throws ParseException {
        Var var;
        ValueExpr valueExpr;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case UNDERSCORE:
    case PREFIX_NAME:
      var = var();
                        // Variables in nodes are bound:
                        _unboundVars.remove(var);

                        {if (true) return var;}
      break;
    case LITERAL:
    case FULL_URI:
    case BNODE:
    case QNAME:
    case POS_INTEGER:
    case NEG_INTEGER:
    case DECIMAL:
      valueExpr = uri_bnode_or_literal();
                        var = _createAnonymousVar();
                        var.setValue(valueExpr.getValue());
                        {if (true) return var;}
      break;
    case LBRACE:
      var = reified_stat(graphPattern);
                        {if (true) return var;}
      break;
    default:
      jj_la1[38] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public Var reified_stat(GraphPattern graphPattern) throws ParseException {
        List leftNode, rightNode;
        Var edge;
    leftNode = node(graphPattern);
    edge = edge();
    rightNode = node(graphPattern);
                        Var id = _createAnonymousVar();
                        ReifiedPathElement reifiedPE = new ReifiedPathElement(id, leftNode, edge, rightNode);
                        graphPattern.addAll(reifiedPE.getTriplePatterns());
                        {if (true) return id;}
    throw new Error("Missing return statement in function");
  }

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

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

  final public BooleanExpr boolean_elem() throws ParseException {
        BooleanExpr expr;
        Query   qc;
        Var var;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LPAREN:
      jj_consume_token(LPAREN);
      expr = boolean_expr();
      jj_consume_token(RPAREN);
                                                     {if (true) return expr;}
      break;
    case TRUE:
      jj_consume_token(TRUE);
                                                     {if (true) return BooleanConstant.TRUE;}
      break;
    case FALSE:
      jj_consume_token(FALSE);
                                                     {if (true) return BooleanConstant.FALSE;}
      break;
    case NOT:
      jj_consume_token(NOT);
      expr = boolean_elem();
                                                     {if (true) return new Not(expr);}
      break;
    case UNDERSCORE:
    case NAMESPACE:
    case LABEL:
    case LANG:
    case DATATYPE:
    case LOCALNAME:
    case NULL:
    case LITERAL:
    case FULL_URI:
    case BNODE:
    case QNAME:
    case PREFIX_NAME:
    case POS_INTEGER:
    case NEG_INTEGER:
    case DECIMAL:
      expr = any_all_like_or_in();
                                                     {if (true) return expr;}
      break;
    case ISRESOURCE:
      jj_consume_token(ISRESOURCE);
      jj_consume_token(LPAREN);
      var = var();
      jj_consume_token(RPAREN);
                                                     {if (true) return new IsResource(var);}
      break;
    case ISLITERAL:
      jj_consume_token(ISLITERAL);
      jj_consume_token(LPAREN);
      var = var();
      jj_consume_token(RPAREN);
                                                     {if (true) return new IsLiteral(var);}
      break;
    case ISURI:
      jj_consume_token(ISURI);
      jj_consume_token(LPAREN);
      var = var();
      jj_consume_token(RPAREN);
                                                     {if (true) return new IsURI(var);}
      break;
    case ISBNODE:
      jj_consume_token(ISBNODE);
      jj_consume_token(LPAREN);
      var = var();
      jj_consume_token(RPAREN);
                                                     {if (true) return new IsBNode(var);}
      break;
    case EXISTS:
      jj_consume_token(EXISTS);
      jj_consume_token(LPAREN);
      qc = table_query_set();
      jj_consume_token(RPAREN);
                                                            {if (true) return new Exists(qc);}
      break;
    default:
      jj_la1[41] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public BooleanExpr any_all_like_or_in() throws ParseException {
        ValueExpr leftValue, rightValue;
        Query qc;
        int op;
        String pattern;
        boolean ignoreCase = false;
    leftValue = var_or_value();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case EQ:
    case NE:
    case LT:
    case LE:
    case GE:
    case GT:
      op = comp_op();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNDERSCORE:
      case NAMESPACE:
      case LABEL:
      case LANG:
      case DATATYPE:
      case LOCALNAME:
      case NULL:
      case LITERAL:
      case FULL_URI:
      case BNODE:
      case QNAME:
      case PREFIX_NAME:
      case POS_INTEGER:
      case NEG_INTEGER:
      case DECIMAL:
        rightValue = var_or_value();
                                        {if (true) return new ValueCompare(leftValue, rightValue, op);}
        break;
      case ANY:
        jj_consume_token(ANY);
        jj_consume_token(LPAREN);
        qc = table_query_set();
        jj_consume_token(RPAREN);
                                        {if (true) return new CompareAny(leftValue, qc, op);}
        break;
      case ALL:
        jj_consume_token(ALL);
        jj_consume_token(LPAREN);
        qc = table_query_set();
        jj_consume_token(RPAREN);
                                        {if (true) return new CompareAll(leftValue, qc, op);}
        break;
      default:
        jj_la1[42] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    case LIKE:
      jj_consume_token(LIKE);
      pattern = string();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IGNORE:
        jj_consume_token(IGNORE);
        jj_consume_token(CASE);
                                   ignoreCase = true;
        break;
      default:
        jj_la1[43] = jj_gen;
        ;
      }
                                {if (true) return new Like(leftValue, new StringConstant(pattern), ignoreCase);}
      break;
    case IN:
      jj_consume_token(IN);
      jj_consume_token(LPAREN);
      qc = table_query_set();
      jj_consume_token(RPAREN);
                                if (qc.getColumnHeaders().length != 1) {
                                        {if (true) throw new ParseException("Query argument for IN operator must have exactly one column.");}
                                }

                                {if (true) return new In(leftValue, qc);}
      break;
    default:
      jj_la1[44] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public int comp_op() 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[45] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public ValueExpr var_or_value() throws ParseException {
        ValueExpr expr;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case UNDERSCORE:
    case PREFIX_NAME:
      expr = var();
                       {if (true) return expr;}
      break;
    case NAMESPACE:
    case LABEL:
    case LANG:
    case DATATYPE:
    case LOCALNAME:
    case NULL:
    case LITERAL:
    case FULL_URI: