rqlparser.java

这是外国一个开源推理机

    case RANGE:
    case CLASSVAR:
      rq = class_query();
                         {if (true) return rq;}
      break;
    default:
      jj_la1[24] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public ClassQuery subClassOf() throws ParseException {
        ClassQuery cq;
        Token t = null;
    jj_consume_token(SUBCLASSOF);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case CIRCUMFLEX:
      t = jj_consume_token(CIRCUMFLEX);
      break;
    default:
      jj_la1[25] = jj_gen;
      ;
    }
    jj_consume_token(LPAREN);
    cq = ext_class_query();
    jj_consume_token(RPAREN);
          {if (true) return new SubClassOf(cq, (t == null));}
    throw new Error("Missing return statement in function");
  }

  final public ClassQuery superClassOf() throws ParseException {
        ClassQuery cq;
        Token t = null;
    jj_consume_token(SUPERCLASSOF);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case CIRCUMFLEX:
      t = jj_consume_token(CIRCUMFLEX);
      break;
    default:
      jj_la1[26] = jj_gen;
      ;
    }
    jj_consume_token(LPAREN);
    cq = ext_class_query();
    jj_consume_token(RPAREN);
          {if (true) return new SuperClassOf(cq, (t == null));}
    throw new Error("Missing return statement in function");
  }

  final public RdfsClass rdfs_class() throws ParseException {
    jj_consume_token(CLASS);
                  {if (true) return new RdfsClass();}
    throw new Error("Missing return statement in function");
  }

  final public ClassQuery domain() throws ParseException {
        PropertyQuery pq;
    jj_consume_token(DOMAIN);
    jj_consume_token(LPAREN);
    pq = ext_property_query();
    jj_consume_token(RPAREN);
          {if (true) return new Domain(pq);}
    throw new Error("Missing return statement in function");
  }

  final public ClassQuery range() throws ParseException {
        PropertyQuery pq;
    jj_consume_token(RANGE);
    jj_consume_token(LPAREN);
    pq = ext_property_query();
    jj_consume_token(RPAREN);
          {if (true) return new Range(pq);}
    throw new Error("Missing return statement in function");
  }

/*-------------------------------------------------+
| PROPERTY QUERIES                                 |
+-------------------------------------------------*/

/* Extended property query = property_query + schemavar + uri */
  final public PropertyQuery ext_property_query() throws ParseException {
        PropertyQuery result;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case URI:
      result = uri();
                         {if (true) return result;}
      break;
    case PROPERTY:
    case SUBPROPERTYOF:
    case SUPERPROPERTYOF:
    case PROPERTYVAR:
      result = property_query();
                                    {if (true) return result;}
      break;
    default:
      jj_la1[27] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public PropertyQuery property_query() throws ParseException {
        ResourceQuery result;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case SUBPROPERTYOF:
      result = subPropertyOf();
      result = array_selection(result);
          {if (true) return (PropertyQuery)result;}
      break;
    case SUPERPROPERTYOF:
      result = superPropertyOf();
      result = array_selection(result);
          {if (true) return (PropertyQuery)result;}
      break;
    case PROPERTYVAR:
      result = propertyvar();
          {if (true) return (PropertyQuery)result;}
      break;
    case PROPERTY:
      result = rdf_property();
      result = array_selection(result);
          {if (true) return (PropertyQuery)result;}
      break;
    default:
      jj_la1[28] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public PropertyQuery subPropertyOf() throws ParseException {
        PropertyQuery pq;
        Token t = null;
    jj_consume_token(SUBPROPERTYOF);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case CIRCUMFLEX:
      t = jj_consume_token(CIRCUMFLEX);
      break;
    default:
      jj_la1[29] = jj_gen;
      ;
    }
    jj_consume_token(LPAREN);
    pq = ext_property_query();
    jj_consume_token(RPAREN);
          {if (true) return new SubPropertyOf(pq, (t == null));}
    throw new Error("Missing return statement in function");
  }

  final public PropertyQuery superPropertyOf() throws ParseException {
        PropertyQuery pq;
        Token t = null;
    jj_consume_token(SUPERPROPERTYOF);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case CIRCUMFLEX:
      t = jj_consume_token(CIRCUMFLEX);
      break;
    default:
      jj_la1[30] = jj_gen;
      ;
    }
    jj_consume_token(LPAREN);
    pq = ext_property_query();
    jj_consume_token(RPAREN);
          {if (true) return new SuperPropertyOf(pq, (t == null));}
    throw new Error("Missing return statement in function");
  }

  final public RdfProperty rdf_property() throws ParseException {
    jj_consume_token(PROPERTY);
                     {if (true) return new RdfProperty();}
    throw new Error("Missing return statement in function");
  }

/*-------------------------------------------------+
| RESOURCE QUERIES                                 |
+-------------------------------------------------*/

// Only used within boolean_query
  final public ResourceQuery resource_query() throws ParseException {
        ResourceQuery r;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case URI:
      r = uri();
                    {if (true) return r;}
      break;
    case CIRCUMFLEX:
    case IDENTIFIER:
      r = data_query();
                                              {if (true) return r;}
      break;
    case CLASS:
    case TYPEOF:
    case SUBCLASSOF:
    case SUPERCLASSOF:
    case DOMAIN:
    case RANGE:
    case CLASSVAR:
      r = class_query();
                                               {if (true) return r;}
      break;
    case PROPERTY:
    case SUBPROPERTYOF:
    case SUPERPROPERTYOF:
    case PROPERTYVAR:
      r = property_query();
                                                  {if (true) return r;}
      break;
    case SELECT:
      r = sfw_query();
                          {if (true) return r;}
      break;
    case INTEGER_LITERAL:
    case REAL_LITERAL:
    case QUOTED_STRING:
    case QUOTED_CHAR:
      r = constant();
                         {if (true) return r;}
      break;
    default:
      jj_la1[31] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public ResourceQuery array_selection(ResourceQuery subject) throws ParseException {
        Token startIdx = null;
        Token endIdx = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LBRACKET:
      jj_consume_token(LBRACKET);
      startIdx = jj_consume_token(INTEGER_LITERAL);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COLON:
        jj_consume_token(COLON);
        endIdx = jj_consume_token(INTEGER_LITERAL);
        break;
      default:
        jj_la1[32] = jj_gen;
        ;
      }
      jj_consume_token(RBRACKET);
      break;
    default:
      jj_la1[33] = jj_gen;
      ;
    }
                if (startIdx != null) {
                        int idx1, idx2;

                        idx1 = Integer.parseInt(startIdx.image);

                        if (endIdx == null) {
                                idx2 = idx1;
                        } else {
                                idx2 = Integer.parseInt(endIdx.image);
                        }

                        subject = new ArraySelection(subject, idx1, idx2);
                }

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

  final public SetQuery set_query() throws ParseException {
        ResourceQuery arg1;
        ResourceQuery arg2;
        Token setOp;
    jj_consume_token(LPAREN);
    arg1 = sfw_query();
    jj_consume_token(RPAREN);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case UNION:
      setOp = jj_consume_token(UNION);
      break;
    case INTERSECT:
      setOp = jj_consume_token(INTERSECT);
      break;
    case MINUS:
      setOp = jj_consume_token(MINUS);
      break;
    default:
      jj_la1[34] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
          clearVars();
    jj_consume_token(LPAREN);
    arg2 = sfw_query();
    jj_consume_token(RPAREN);
            if (setOp.image.equals("union")) {
                {if (true) return new Union((SfwQuery)arg1, (SfwQuery)arg2);}
            }
            else if (setOp.image.equals("intersect")) {
                {if (true) return new Intersect((SfwQuery)arg1, (SfwQuery)arg2);}
            }
            else {
                {if (true) return new Minus((SfwQuery)arg1, (SfwQuery)arg2);}
            }
    throw new Error("Missing return statement in function");
  }

/*-------------------------------------------------+
| BOOLEAN QUERIES                                  |
+-------------------------------------------------*/
  final public BooleanQuery boolean_query() throws ParseException {
        BooleanQuery result;
    result = or_expression();
                                   {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public BooleanQuery or_expression() throws ParseException {
        BooleanQuery arg1;
        BooleanQuery arg2 = null;
    arg1 = and_expression();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case OR:
      jj_consume_token(OR);
      arg2 = or_expression();
      break;
    default:
      jj_la1[35] = jj_gen;
      ;
    }
                if (arg2 == null) {
                        {if (true) return arg1;}
                }
                else {
                        {if (true) return new Or(arg1, arg2);}
                }
    throw new Error("Missing return statement in function");
  }

  final public BooleanQuery and_expression() throws ParseException {
        BooleanQuery arg1;
        BooleanQuery arg2 = null;
    arg1 = and_part();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AND:
      jj_consume_token(AND);
      arg2 = and_expression();
      break;
    default:
      jj_la1[36] = jj_gen;
      ;
    }
                if (arg2 == null) {
                        {if (true) return arg1;}
                }
                else {
                        {if (true) return new And(arg1, arg2);}
                }
    throw new Error("Missing return statement in function");
  }

  final public BooleanQuery and_part() throws ParseException {
        BooleanQuery bq;
        ResourceQuery rq;