RuleParserImpl.java

/* Generated By:JavaCC: Do not edit this line. RuleParserImpl.java */
package org.apache.stanbol.rules.manager.parse;

import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringReader;
import java.net.URI;
import java.net.URISyntaxException;

import org.apache.clerezza.commons.rdf.IRI;
import org.apache.stanbol.rules.base.api.Rule;
import org.apache.stanbol.rules.base.api.RuleAtom;
import org.apache.stanbol.rules.base.api.util.AtomList;
import org.apache.stanbol.rules.manager.KB;
import org.apache.stanbol.rules.manager.RuleImpl;
import org.apache.stanbol.rules.manager.atoms.ClassAtom;
import org.apache.stanbol.rules.manager.atoms.ComparisonAtom;
import org.apache.stanbol.rules.manager.atoms.ConcatAtom;
import org.apache.stanbol.rules.manager.atoms.CreateLabelAtom;
import org.apache.stanbol.rules.manager.atoms.DatavaluedPropertyAtom;
import org.apache.stanbol.rules.manager.atoms.DifferentAtom;
import org.apache.stanbol.rules.manager.atoms.DivisionAtom;
import org.apache.stanbol.rules.manager.atoms.EndsWithAtom;
import org.apache.stanbol.rules.manager.atoms.ExpressionAtom;
import org.apache.stanbol.rules.manager.atoms.GreaterEqualThanAtom;
import org.apache.stanbol.rules.manager.atoms.GreaterThanAtom;
import org.apache.stanbol.rules.manager.atoms.IObjectAtom;
import org.apache.stanbol.rules.manager.atoms.IndividualPropertyAtom;
import org.apache.stanbol.rules.manager.atoms.IsBlankAtom;
import org.apache.stanbol.rules.manager.atoms.LengthAtom;
import org.apache.stanbol.rules.manager.atoms.LessEqualThanAtom;
import org.apache.stanbol.rules.manager.atoms.LessThanAtom;
import org.apache.stanbol.rules.manager.atoms.LetAtom;
import org.apache.stanbol.rules.manager.atoms.LocalNameAtom;
import org.apache.stanbol.rules.manager.atoms.LowerCaseAtom;
import org.apache.stanbol.rules.manager.atoms.MultiplicationAtom;
import org.apache.stanbol.rules.manager.atoms.NamespaceAtom;
import org.apache.stanbol.rules.manager.atoms.NewIRIAtom;
import org.apache.stanbol.rules.manager.atoms.NewLiteralAtom;
import org.apache.stanbol.rules.manager.atoms.NotAtom;
import org.apache.stanbol.rules.manager.atoms.NumberAtom;
import org.apache.stanbol.rules.manager.atoms.NumericFunctionAtom;
import org.apache.stanbol.rules.manager.atoms.NumericVariableAtom;
import org.apache.stanbol.rules.manager.atoms.PropStringAtom;
import org.apache.stanbol.rules.manager.atoms.ResourceAtom;
import org.apache.stanbol.rules.manager.atoms.RuleBlankNode;
import org.apache.stanbol.rules.manager.atoms.SameAtom;
import org.apache.stanbol.rules.manager.atoms.StartsWithAtom;
import org.apache.stanbol.rules.manager.atoms.StrAtom;
import org.apache.stanbol.rules.manager.atoms.StringAtom;
import org.apache.stanbol.rules.manager.atoms.StringFunctionAtom;
import org.apache.stanbol.rules.manager.atoms.StringVariableAtom;
import org.apache.stanbol.rules.manager.atoms.SubstringAtom;
import org.apache.stanbol.rules.manager.atoms.SubtractionAtom;
import org.apache.stanbol.rules.manager.atoms.SumAtom;
import org.apache.stanbol.rules.manager.atoms.TypedLiteralAtom;
import org.apache.stanbol.rules.manager.atoms.UnionAtom;
import org.apache.stanbol.rules.manager.atoms.UpperCaseAtom;
import org.apache.stanbol.rules.manager.atoms.VariableAtom;

import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Resource;

/**
*
* @author anuzzolese 
* 
*/

@SuppressWarnings("unused")

public class RuleParserImpl implements RuleParserImplConstants {

  static KB kb;

  public static KB parse( String namespace, String inString ) {
  {
        kb = new KB(namespace);
        Reader reader = new StringReader( inString ) ;
    RuleParserImpl parser = new RuleParserImpl(reader);
    StringBuffer buffer = new StringBuffer() ;
        try {
                parser.start( ) ;
        } catch( TokenMgrError e ) {
                throw new IllegalStateException(e) ;
        } catch( ParseException e ) {
                throw new IllegalStateException(e) ;
        }
        return kb ; }
  }

  public static KB parse( String namespace, InputStream inStream ) {

                kb = new KB(namespace);
                Reader reader = new InputStreamReader(inStream);
                RuleParserImpl parser = new RuleParserImpl(reader);
                try {
                        parser.start();
                } catch (TokenMgrError e) {
                        throw new IllegalStateException(e);
                } catch (ParseException e) {
                        throw new IllegalStateException(e);
                }
                return kb;
        }


        private static URI getSWRLArgument(String argument){
                Resource rdfNode = null;
                String[] argumentComposition = argument.split(":");
                if(argumentComposition.length == 2){
                        String prefix = argumentComposition[0];
                        String resourceName = argumentComposition[1];

                        String namespaceURI = kb.getPrefixURI(prefix);
                        rdfNode = ModelFactory.createDefaultModel().createResource(namespaceURI+resourceName);
                        try {
                                                        return new URI(rdfNode.getURI());
                                                } catch (URISyntaxException e) {
                                                        // TODO Auto-generated catch block
                                                        e.printStackTrace();
                                                }

                }

                return null;
        }

        private static URI getSWRLVariable(String argument){
                Resource variableResource = null;
                String variableString = argument.substring(1);


                variableResource = ModelFactory.createDefaultModel().createResource(kb.getPrefixURI("var")+variableString);



                try {
                                        return new URI(variableResource.getURI());
                                } catch (URISyntaxException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                        return null;
                                }
        }

  final public void start() throws ParseException {
    expression();
    expressionCont();
  }

  final public void expressionCont() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AND:
      jj_consume_token(AND);
      expression();
      break;
    default:
      jj_la1[0] = jj_gen;

    }
  }

  final public void expression() throws ParseException {
 Rule rule;
    prefix();
    expressionCont();
  }

  final public void prefix() throws ParseException {
 String nsPrefix; Object obj; Rule rule;
    nsPrefix = getVariable();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case EQUAL:
      obj = equality();
                                           String prefixURI = (String)obj;
                                                                                   prefixURI = prefixURI.substring(1, prefixURI.length()-1);
                                                                                   kb.addPrefix(nsPrefix, prefixURI);
      break;
    case LQUAD:
      obj = rule();
                                                                         AtomList[] atoms = (AtomList[]) obj;
                                                                                         String ruleStorePrefix = kb.getPrefixURI("rmi2");
                                                                                         ruleStorePrefix = ruleStorePrefix.substring(0, ruleStorePrefix.length());

                                                                                         if(atoms.length == 1){
                                                            AtomList body = atoms[0];
                                                            if(body.size() == 1){
                                                                    // FIXME it previously managed SPARQL code injection.
                                                            }

                                                     }
                                                 else{
                                                         rule = new RuleImpl(new IRI(ruleStorePrefix+nsPrefix), nsPrefix, atoms[0], atoms[1]);
                                                         kb.addRule(rule);
                                                }
      break;
    default:
      jj_la1[1] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public String equality() throws ParseException {
 String nsURI;
    jj_consume_token(EQUAL);
    nsURI = getURI();
          {if (true) return nsURI;}
    throw new Error("Missing return statement in function");
  }

  final public AtomList[] rule() throws ParseException {
 AtomList[] ruleAtoms;
    jj_consume_token(LQUAD);
    ruleAtoms = ruleDefinition();
    jj_consume_token(RQUAD);
     {if (true) return ruleAtoms;}
    throw new Error("Missing return statement in function");
  }

  final public AtomList[] ruleDefinition() throws ParseException {
 AtomList body; AtomList head; Token t;
    body = atomList();
    jj_consume_token(LARROW);
    head = atomList();
          {if (true) return new AtomList[]{body, head};}
    throw new Error("Missing return statement in function");
  }

  final public AtomList atomList() throws ParseException {
 AtomList atomList = new AtomList(); RuleAtom kReSAtom;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case SAME:
    case DIFFERENT:
    case LESSTHAN:
    case GREATERTHAN:
    case IS:
    case NEW_IRI:
    case NEW_LITERAL:
    case STARTS_WITH:
    case ENDS_WITH:
    case LET:
    case HAS:
    case VALUES:
    case NOT:
    case UNION:
    case IS_BLANK:
      kReSAtom = atom();
      atomList = atomListRest();
          atomList.addToHead(kReSAtom); {if (true) return atomList;}
      break;
    default:
      jj_la1[2] = jj_gen;

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

  final public AtomList atomListRest() throws ParseException {
 AtomList atomList = new AtomList(); RuleAtom kReSAtom;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AND:
      jj_consume_token(AND);
      atomList = atomList();
          {if (true) return atomList;}
      break;
    default:
      jj_la1[3] = jj_gen;

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

  final public RuleAtom atom() throws ParseException {
 RuleAtom ruleAtom;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IS:
      ruleAtom = classAtom();
                         {if (true) return ruleAtom;}
      break;
    case HAS:
      ruleAtom = individualPropertyAtom();
                                      {if (true) return ruleAtom;}
      break;
    case VALUES:
      ruleAtom = datavaluedPropertyAtom();
                                      {if (true) return ruleAtom;}
      break;
    case LET:
      ruleAtom = letAtom();
                       {if (true) return ruleAtom;}
      break;
    case NEW_IRI:
      ruleAtom = newIRIAtom();
                          {if (true) return ruleAtom;}
      break;
    case NEW_LITERAL:
      ruleAtom = newLiteralAtom();
                              {if (true) return ruleAtom;}
      break;
    case SAME:
    case DIFFERENT:
    case LESSTHAN:
    case GREATERTHAN:
    case STARTS_WITH:
    case ENDS_WITH:
    case NOT:
    case IS_BLANK:
      ruleAtom = comparisonAtom();
                              {if (true) return ruleAtom;}
      break;
    case UNION:
      ruleAtom = unionAtom();
                         {if (true) return ruleAtom;}
      break;
    default:
      jj_la1[4] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public RuleAtom unionAtom() throws ParseException {
 AtomList atomList1; AtomList atomList2;
    jj_consume_token(UNION);
    jj_consume_token(LPAR);
    atomList1 = atomList();
    jj_consume_token(COMMA);
    atomList2 = atomList();
    jj_consume_token(RPAR);
          {if (true) return new UnionAtom(atomList1, atomList2);}
    throw new Error("Missing return statement in function");
  }

  final public StringFunctionAtom createLabelAtom() throws ParseException {
 StringFunctionAtom stringFunctionAtom;
    jj_consume_token(CREATE_LABEL);
    jj_consume_token(LPAR);
    stringFunctionAtom = stringFunctionAtom();
    jj_consume_token(RPAR);
          {if (true) return new CreateLabelAtom(stringFunctionAtom);}
    throw new Error("Missing return statement in function");
  }

  final public StringFunctionAtom propStringAtom() throws ParseException {
 StringFunctionAtom stringFunctionAtom1; StringFunctionAtom stringFunctionAtom2;
    jj_consume_token(PROP);
    jj_consume_token(LPAR);
    stringFunctionAtom1 = stringFunctionAtom();
    jj_consume_token(COMMA);
    stringFunctionAtom2 = stringFunctionAtom();
    jj_consume_token(RPAR);
          {if (true) return new PropStringAtom(stringFunctionAtom1, stringFunctionAtom2);}
    throw new Error("Missing return statement in function");
  }

  final public ComparisonAtom endsWithAtom() throws ParseException {
 RuleAtom ruleAtom; StringFunctionAtom arg; StringFunctionAtom stringFunctionAtom;
    jj_consume_token(ENDS_WITH);
    jj_consume_token(LPAR);
    arg = stringFunctionAtom();
    jj_consume_token(COMMA);
    stringFunctionAtom = stringFunctionAtom();
    jj_consume_token(RPAR);
         {if (true) return new EndsWithAtom(arg, stringFunctionAtom);}
    throw new Error("Missing return statement in function");
  }

  final public ComparisonAtom startsWithAtom() throws ParseException {
 RuleAtom ruleAtom; StringFunctionAtom arg; StringFunctionAtom stringFunctionAtom;
    jj_consume_token(STARTS_WITH);
    jj_consume_token(LPAR);
    arg = stringFunctionAtom();
    jj_consume_token(COMMA);
    stringFunctionAtom = stringFunctionAtom();
    jj_consume_token(RPAR);
         {if (true) return new StartsWithAtom(arg, stringFunctionAtom);}
    throw new Error("Missing return statement in function");
  }

  final public StringFunctionAtom stringFunctionAtom() throws ParseException {
 Object obj; StringFunctionAtom stringFunctionAtom;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case CONCAT:
      stringFunctionAtom = concatAtom();
      break;
    case UPPERCASE:
      stringFunctionAtom = upperCaseAtom();
      break;
    case LOWERCASE:
      stringFunctionAtom = lowerCaseAtom();
      break;
    case SUBSTRING:
      stringFunctionAtom = substringAtom();
      break;
    case NAMESPACE:
      stringFunctionAtom = namespaceAtom();
      break;
    case LOCALNAME:
      stringFunctionAtom = localnameAtom();
      break;
    case STR:
      stringFunctionAtom = strAtom();
      break;
    case STRING:
      stringFunctionAtom = stringAtom();
      break;
    case PROP:
      stringFunctionAtom = propStringAtom();
      break;
    case CREATE_LABEL:
      stringFunctionAtom = createLabelAtom();
      break;
    case VARIABLE:
      stringFunctionAtom = stringVariable();
      break;
    default:
      jj_la1[5] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
         {if (true) return stringFunctionAtom;}
    throw new Error("Missing return statement in function");
  }

  final public StrAtom strAtom() throws ParseException {
 IObjectAtom uri;
    jj_consume_token(STR);
    jj_consume_token(LPAR);
    uri = iObject();
    jj_consume_token(RPAR);
         {if (true) return new StrAtom(uri);}
    throw new Error("Missing return statement in function");
  }

  final public NamespaceAtom namespaceAtom() throws ParseException {
 IObjectAtom uri;
    jj_consume_token(NAMESPACE);
    jj_consume_token(LPAR);
    uri = iObject();
    jj_consume_token(RPAR);
         {if (true) return new NamespaceAtom(uri);}
    throw new Error("Missing return statement in function");
  }

  final public LocalNameAtom localnameAtom() throws ParseException {
 IObjectAtom uri;
    jj_consume_token(LOCALNAME);
    jj_consume_token(LPAR);
    uri = iObject();
    jj_consume_token(RPAR);
         {if (true) return new LocalNameAtom(uri);}
    throw new Error("Missing return statement in function");
  }

  final public StringAtom stringAtom() throws ParseException {
 String obj;
    obj = getStringValue();
                                 {if (true) return new StringAtom(obj);}
    throw new Error("Missing return statement in function");
  }

  final public ConcatAtom concatAtom() throws ParseException {
 StringFunctionAtom arg1; StringFunctionAtom arg2;
    jj_consume_token(CONCAT);
    jj_consume_token(LPAR);
    arg1 = stringFunctionAtom();
    jj_consume_token(COMMA);
    arg2 = stringFunctionAtom();
    jj_consume_token(RPAR);
          {if (true) return new ConcatAtom(arg1, arg2);}
    throw new Error("Missing return statement in function");
  }

  final public UpperCaseAtom upperCaseAtom() throws ParseException {
 StringFunctionAtom arg;
    jj_consume_token(UPPERCASE);
    jj_consume_token(LPAR);
    arg = stringFunctionAtom();
    jj_consume_token(RPAR);
          {if (true) return new UpperCaseAtom(arg);}
    throw new Error("Missing return statement in function");
  }

  final public LowerCaseAtom lowerCaseAtom() throws ParseException {
 StringFunctionAtom arg;
    jj_consume_token(LOWERCASE);
    jj_consume_token(LPAR);
    arg = stringFunctionAtom();
    jj_consume_token(RPAR);
          {if (true) return new LowerCaseAtom(arg);}
    throw new Error("Missing return statement in function");
  }

  final public SubstringAtom substringAtom() throws ParseException {
 StringFunctionAtom arg; NumericFunctionAtom start; NumericFunctionAtom length;
    jj_consume_token(SUBSTRING);
    jj_consume_token(LPAR);
    arg = stringFunctionAtom();
    jj_consume_token(COMMA);
    start = numericFunctionAtom();
    jj_consume_token(COMMA);
    length = numericFunctionAtom();
    jj_consume_token(RPAR);
          {if (true) return new SubstringAtom(arg, start, length);}
    throw new Error("Missing return statement in function");
  }

  final public ExpressionAtom expressionAtom() throws ParseException {
 ExpressionAtom expressionAtom;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case SUBSTRING:
    case UPPERCASE:
    case LOWERCASE:
    case CONCAT:
    case NAMESPACE:
    case LOCALNAME:
    case STR:
    case CREATE_LABEL:
    case PROP:
    case VARIABLE:
    case STRING:
      expressionAtom = stringFunctionAtom();
      break;
    case LENGTH:
    case PLUS:
    case MINUS:
    case NUM:
      expressionAtom = numericFunctionAtom();
      break;
    default:
      jj_la1[6] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    {if (true) return expressionAtom;}
    throw new Error("Missing return statement in function");
  }

  final public NumericFunctionAtom numericFunctionAtom() throws ParseException {
 NumericFunctionAtom numericFunctionAtom;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PLUS:
      numericFunctionAtom = sumAtom();
      break;
    case MINUS:
      numericFunctionAtom = subtractionAtom();
      break;
    case LENGTH:
      numericFunctionAtom = lengthAtom();
      break;
    case NUM:
      numericFunctionAtom = numberAtom();
      break;
    case VARIABLE:
      numericFunctionAtom = numericVariable();
      break;
    default:
      jj_la1[7] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
         {if (true) return numericFunctionAtom;}
    throw new Error("Missing return statement in function");
  }

  final public LengthAtom lengthAtom() throws ParseException {
 StringFunctionAtom stringFunctionAtom;
    jj_consume_token(LENGTH);
    jj_consume_token(LPAR);
    stringFunctionAtom = stringFunctionAtom();
    jj_consume_token(RPAR);
         {if (true) return new LengthAtom(stringFunctionAtom);}
    throw new Error("Missing return statement in function");
  }

  final public SumAtom sumAtom() throws ParseException {
 NumericFunctionAtom numericFunctionAtom1; NumericFunctionAtom numericFunctionAtom2;
    jj_consume_token(PLUS);
    jj_consume_token(LPAR);
    numericFunctionAtom1 = numericFunctionAtom();
    jj_consume_token(COMMA);
    numericFunctionAtom2 = numericFunctionAtom();
    jj_consume_token(RPAR);
         {if (true) return new SumAtom(numericFunctionAtom1, numericFunctionAtom2);}
    throw new Error("Missing return statement in function");
  }

  final public SubtractionAtom subtractionAtom() throws ParseException {
 NumericFunctionAtom numericFunctionAtom1; NumericFunctionAtom numericFunctionAtom2;
    jj_consume_token(MINUS);
    jj_consume_token(LPAR);
    numericFunctionAtom1 = numericFunctionAtom();
    jj_consume_token(COMMA);
    numericFunctionAtom2 = numericFunctionAtom();
    jj_consume_token(RPAR);
         {if (true) return new SubtractionAtom(numericFunctionAtom1, numericFunctionAtom2);}
    throw new Error("Missing return statement in function");
  }

  final public MultiplicationAtom multiplicationAtom() throws ParseException {
 NumericFunctionAtom numericFunctionAtom1; NumericFunctionAtom numericFunctionAtom2;
    jj_consume_token(MULTIPLIED);
    jj_consume_token(LPAR);
    numericFunctionAtom1 = numericFunctionAtom();
    jj_consume_token(COMMA);
    numericFunctionAtom2 = numericFunctionAtom();
    jj_consume_token(RPAR);
         {if (true) return new MultiplicationAtom(numericFunctionAtom1, numericFunctionAtom2);}
    throw new Error("Missing return statement in function");
  }

  final public DivisionAtom divisionAtom() throws ParseException {
 NumericFunctionAtom numericFunctionAtom1; NumericFunctionAtom numericFunctionAtom2;
    jj_consume_token(DIVIDED);
    jj_consume_token(LPAR);
    numericFunctionAtom1 = numericFunctionAtom();
    jj_consume_token(COMMA);
    numericFunctionAtom2 = numericFunctionAtom();
    jj_consume_token(RPAR);
         {if (true) return new DivisionAtom(numericFunctionAtom1, numericFunctionAtom2);}
    throw new Error("Missing return statement in function");
  }

  final public NumericFunctionAtom numberAtom() throws ParseException {
 Token t;
    t = jj_consume_token(NUM);
          {if (true) return new NumberAtom(t.image);}
    throw new Error("Missing return statement in function");
  }

  final public ClassAtom classAtom() throws ParseException {
 IObjectAtom uri1; IObjectAtom uri2;
    jj_consume_token(IS);
    jj_consume_token(LPAR);
    uri1 = iObject();
    jj_consume_token(COMMA);
    uri2 = iObject();
    jj_consume_token(RPAR);
          {if (true) return new ClassAtom(uri1, uri2);}
    throw new Error("Missing return statement in function");
  }

  final public NewIRIAtom newIRIAtom() throws ParseException {
 IObjectAtom arg1; StringFunctionAtom arg2;
    jj_consume_token(NEW_IRI);
    jj_consume_token(LPAR);
    arg1 = iObject();
    jj_consume_token(COMMA);
    arg2 = stringFunctionAtom();
    jj_consume_token(RPAR);
          {if (true) return new NewIRIAtom(arg1, arg2);}
    throw new Error("Missing return statement in function");
  }

  final public NewLiteralAtom newLiteralAtom() throws ParseException {
 IObjectAtom arg1; StringFunctionAtom arg2;
    jj_consume_token(NEW_LITERAL);
    jj_consume_token(LPAR);
    arg1 = iObject();
    jj_consume_token(COMMA);
    arg2 = stringFunctionAtom();
    jj_consume_token(RPAR);
          {if (true) return new NewLiteralAtom(arg1, arg2);}
    throw new Error("Missing return statement in function");
  }

  final public LetAtom letAtom() throws ParseException {
 IObjectAtom uri1; StringFunctionAtom fun;
    jj_consume_token(LET);
    jj_consume_token(LPAR);
    uri1 = iObject();
    jj_consume_token(COMMA);
    fun = stringFunctionAtom();
    jj_consume_token(RPAR);
          {if (true) return new LetAtom(uri1, fun);}
    throw new Error("Missing return statement in function");
  }

  final public IndividualPropertyAtom individualPropertyAtom() throws ParseException {
 IObjectAtom uri1; IObjectAtom uri2; IObjectAtom uri3;
    jj_consume_token(HAS);
    jj_consume_token(LPAR);
    uri1 = iObject();
    jj_consume_token(COMMA);
    uri2 = iObject();
    jj_consume_token(COMMA);
    uri3 = iObject();
    jj_consume_token(RPAR);
          {if (true) return new IndividualPropertyAtom(uri1, uri2, uri3);}
    throw new Error("Missing return statement in function");
  }

  final public DatavaluedPropertyAtom datavaluedPropertyAtom() throws ParseException {
 IObjectAtom uri1; IObjectAtom uri2; RuleAtom obj;
    jj_consume_token(VALUES);
    jj_consume_token(LPAR);
    uri1 = iObject();
    jj_consume_token(COMMA);
    uri2 = iObject();
    jj_consume_token(COMMA);
    obj = dObject();
    jj_consume_token(RPAR);
           {if (true) return new DatavaluedPropertyAtom(uri1, uri2, obj);}
    throw new Error("Missing return statement in function");
  }

  final public SameAtom sameAsAtom() throws ParseException {
 ExpressionAtom expressionAtom1; ExpressionAtom expressionAtom2;
    jj_consume_token(SAME);
    jj_consume_token(LPAR);
    expressionAtom1 = expressionAtom();
    jj_consume_token(COMMA);
    expressionAtom2 = expressionAtom();
    jj_consume_token(RPAR);
          {if (true) return new SameAtom(expressionAtom1, expressionAtom2);}
    throw new Error("Missing return statement in function");
  }

  final public LessThanAtom lessThanAtom() throws ParseException {
 ExpressionAtom obj1; ExpressionAtom obj2;
    jj_consume_token(LESSTHAN);
    jj_consume_token(LPAR);
    obj1 = expressionAtom();
    jj_consume_token(COMMA);
    obj2 = expressionAtom();
    jj_consume_token(RPAR);
          {if (true) return new LessThanAtom(obj1, obj2);}
    throw new Error("Missing return statement in function");
  }

  final public LessEqualThanAtom lessEqualThanAtom() throws ParseException {
 ExpressionAtom obj1; ExpressionAtom obj2;
    jj_consume_token(LESSEQUALTHAN);
    jj_consume_token(LPAR);
    obj1 = expressionAtom();
    jj_consume_token(COMMA);
    obj2 = expressionAtom();
    jj_consume_token(RPAR);
          {if (true) return new LessEqualThanAtom(obj1, obj2);}
    throw new Error("Missing return statement in function");
  }

  final public GreaterThanAtom greaterThanAtom() throws ParseException {
 ExpressionAtom obj1; ExpressionAtom obj2;
    jj_consume_token(GREATERTHAN);
    jj_consume_token(LPAR);
    obj1 = expressionAtom();
    jj_consume_token(COMMA);
    obj2 = expressionAtom();
    jj_consume_token(RPAR);
          {if (true) return new GreaterThanAtom(obj1, obj2);}
    throw new Error("Missing return statement in function");
  }

  final public GreaterEqualThanAtom greaterEqualThanAtom() throws ParseException {
 ExpressionAtom obj1; ExpressionAtom obj2;
    jj_consume_token(GREATEREQUALTHAN);
    jj_consume_token(LPAR);
    obj1 = expressionAtom();
    jj_consume_token(COMMA);
    obj2 = expressionAtom();
    jj_consume_token(RPAR);
          {if (true) return new GreaterEqualThanAtom(obj1, obj2);}
    throw new Error("Missing return statement in function");
  }

  final public DifferentAtom differentFromAtom() throws ParseException {
 ExpressionAtom expressionAtom1; ExpressionAtom expressionAtom2;
    jj_consume_token(DIFFERENT);
    jj_consume_token(LPAR);
    expressionAtom1 = expressionAtom();
    jj_consume_token(COMMA);
    expressionAtom2 = expressionAtom();
    jj_consume_token(RPAR);
          {if (true) return new DifferentAtom(expressionAtom1, expressionAtom2);}
    throw new Error("Missing return statement in function");
  }

  final public IObjectAtom reference() throws ParseException {
  String uri1;
  Token colon;
  String uri3;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case URI:
      uri1 = getURI();
                         uri1 = uri1.substring(1, uri1.length()-1);
                                                try {
                                                  {if (true) return new ResourceAtom(new URI(uri1));}
                                                        } catch (URISyntaxException e) {
                                                                e.printStackTrace();
                                                        }
      break;
    case VAR:
      uri1 = getVariable();
      colon = jj_consume_token(COLON);
      uri3 = getVariable();
                                                                  {if (true) return new ResourceAtom(getSWRLArgument(uri1+colon.image+uri3));}
      break;
    default:
      jj_la1[8] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public IObjectAtom varReference() throws ParseException {
  String uri1;
  Token colon;
  String uri3;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case URI:
      uri1 = getURI();
                         try {
                                                                                                                        {if (true) return new ResourceAtom(new URI(uri1));}
                                                                                                                } catch (URISyntaxException e) {
                                                                                                                        e.printStackTrace();
                                                                                                                }
      break;
    case VAR:
      uri1 = getVariable();
      colon = jj_consume_token(COLON);
      uri3 = getVariable();
                                                                  {if (true) return new ResourceAtom(getSWRLArgument(uri1+colon.image+uri3));}
      break;
    default:
      jj_la1[9] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public String getURI() throws ParseException {
        Token t;
    t = jj_consume_token(URI);
                      {if (true) return t.image;}
    throw new Error("Missing return statement in function");
  }

  final public String getVariable() throws ParseException {
        Token t;
    t = jj_consume_token(VAR);
                      {if (true) return t.image;}
    throw new Error("Missing return statement in function");
  }

  final public String getStringValue() throws ParseException {
        Token t;
    t = jj_consume_token(STRING);
                         {if (true) return t.image;}
    throw new Error("Missing return statement in function");
  }

  final public StringAtom getString() throws ParseException {
        Token t;
    t = jj_consume_token(STRING);
                         {if (true) return new StringAtom(t.image);}
    throw new Error("Missing return statement in function");
  }

  final public NumberAtom getInt() throws ParseException {
        Token t;
    t = jj_consume_token(NUM);
                    {if (true) return new NumberAtom(t.image);}
    throw new Error("Missing return statement in function");
  }

  final public Object uObject() throws ParseException {
  Object obj;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case NOTEX:
    case VARIABLE:
    case BNODE:
      obj = variable();
      break;
    case VAR:
    case URI:
      obj = reference();
      break;
    case STRING:
      obj = getString();
      break;
    case NUM:
      obj = getInt();
      break;
    default:
      jj_la1[10] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
         {if (true) return obj;}
    throw new Error("Missing return statement in function");
  }

  final public IObjectAtom iObject() throws ParseException {
  IObjectAtom uri;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case NOTEX:
    case VARIABLE:
    case BNODE:
      uri = variable();
                          {if (true) return uri;}
      break;
    case VAR:
    case URI:
      uri = reference();
                                                            {if (true) return uri;}
      break;
    default:
      jj_la1[11] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public RuleAtom dObject() throws ParseException {
  RuleAtom variable;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case NUM:
    case STRING:
      variable = literal();
      break;
    case NOTEX:
    case VARIABLE:
    case BNODE:
      variable = variable();
      break;
    default:
      jj_la1[12] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
                                                    {if (true) return variable;}
    throw new Error("Missing return statement in function");
  }

  final public ExpressionAtom literal() throws ParseException {
  ExpressionAtom literal; IObjectAtom typedLiteral;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STRING:
      literal = getString();
      typedLiteral = typedLiteral();
      break;
    case NUM:
      literal = getInt();
      typedLiteral = typedLiteral();
      break;
    default:
      jj_la1[13] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
                if(typedLiteral != null){
                        {if (true) return new TypedLiteralAtom(literal, typedLiteral);}
                }
                else{
                        {if (true) return literal;}
                }
    throw new Error("Missing return statement in function");
  }

  final public IObjectAtom typedLiteral() throws ParseException {
  IObjectAtom type = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case APOX:
      jj_consume_token(APOX);
      jj_consume_token(APOX);
      type = reference();
      break;
    default:
      jj_la1[14] = jj_gen;

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

  final public IObjectAtom variable() throws ParseException {
  Token t; String var;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case NOTEX:
      jj_consume_token(NOTEX);
      jj_consume_token(LPAR);
      t = jj_consume_token(VARIABLE);
      jj_consume_token(RPAR);
                                                      var=t.image; var=kb.getPrefixURI("var") + var.substring(1);
                                                                                                                try{
                                                                                                                        {if (true) return new VariableAtom(new URI(var), true);}
                                                                                                                } catch (URISyntaxException e) {
                                                                                                                        e.printStackTrace();
                                                                                                                        {if (true) return null;}
                                                                                                                }
      break;
    case VARIABLE:
      t = jj_consume_token(VARIABLE);
          var=t.image; var=kb.getPrefixURI("var") + var.substring(1);
                                                                                                                try{
                                                                                                                        {if (true) return new VariableAtom(new URI(var), false);}
                                                                                                                } catch (URISyntaxException e) {
                                                                                                                        e.printStackTrace();
                                                                                                                        {if (true) return null;}
                                                                                                                }
      break;
    case BNODE:
      t = jj_consume_token(BNODE);
          var=t.image;  {if (true) return new RuleBlankNode(var);}
      break;
    default:
      jj_la1[15] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public ComparisonAtom notAtom() throws ParseException {
  ComparisonAtom comparisonAtom;
    jj_consume_token(NOT);
    jj_consume_token(LPAR);
    comparisonAtom = comparisonAtom();
    jj_consume_token(RPAR);
         {if (true) return new NotAtom(comparisonAtom);}
    throw new Error("Missing return statement in function");
  }

  final public ComparisonAtom isBlankAtom() throws ParseException {
  IObjectAtom uriRes;
    jj_consume_token(IS_BLANK);
    jj_consume_token(LPAR);
    uriRes = iObject();
    jj_consume_token(RPAR);
         {if (true) return new IsBlankAtom(uriRes);}
    throw new Error("Missing return statement in function");
  }

  final public ComparisonAtom comparisonAtom() throws ParseException {
  ComparisonAtom comparisonAtom;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case SAME:
      comparisonAtom = sameAsAtom();
      break;
    case LESSTHAN:
      comparisonAtom = lessThanAtom();
      break;
    case GREATERTHAN:
      comparisonAtom = greaterThanAtom();
      break;
    case DIFFERENT:
      comparisonAtom = differentFromAtom();
      break;
    case NOT:
      comparisonAtom = notAtom();
      break;
    case STARTS_WITH:
      comparisonAtom = startsWithAtom();
      break;
    case ENDS_WITH:
      comparisonAtom = endsWithAtom();
      break;
    case IS_BLANK:
      comparisonAtom = isBlankAtom();
      break;
    default:
      jj_la1[16] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
         {if (true) return comparisonAtom;}
    throw new Error("Missing return statement in function");
  }

  final public NumericVariableAtom numericVariable() throws ParseException {
  Token t; String var;
    t = jj_consume_token(VARIABLE);
          var=t.image; var=kb.getPrefixURI("var") + var.substring(1);
                                                                                                                try{
                                                                                                                        {if (true) return new NumericVariableAtom(new URI(var), false);}
                                                                                                                } catch (URISyntaxException e) {
                                                                                                                        e.printStackTrace();
                                                                                                                        {if (true) return null;}
                                                                                                                }
    throw new Error("Missing return statement in function");
  }

  final public StringVariableAtom stringVariable() throws ParseException {
  Token t; String var;
    t = jj_consume_token(VARIABLE);
          var=t.image; var=kb.getPrefixURI("var") + var.substring(1);
                                                                                                                try{
                                                                                                                        {if (true) return new StringVariableAtom(new URI(var), false);}
                                                                                                                } catch (URISyntaxException e) {
                                                                                                                        e.printStackTrace();
                                                                                                                        {if (true) return null;}
                                                                                                                }
    throw new Error("Missing return statement in function");
  }

  /** Generated Token Manager. */
  public RuleParserImplTokenManager token_source;
  SimpleCharStream jj_input_stream;
  /** Current token. */
  public Token token;
  /** Next token. */
  public Token jj_nt;
  private int jj_ntk;
  private int jj_gen;
  final private int[] jj_la1 = new int[17];
  static private int[] jj_la1_0;
  static private int[] jj_la1_1;
  static {
      jj_la1_init_0();
      jj_la1_init_1();
   }
   private static void jj_la1_init_0() {
      jj_la1_0 = new int[] {0x800,0x400,0xdc39e000,0x800,0xdc39e000,0x23800000,0x23c00000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc01e000,};
   }
   private static void jj_la1_init_1() {
      jj_la1_1 = new int[] {0x0,0x20000,0x2420,0x0,0x2420,0xa019c0,0xa819c6,0x280006,0x500000,0x500000,0x1f80001,0x1700001,0x1a80001,0x880000,0x200,0x1200001,0x2020,};
   }

  /** Constructor with InputStream. */
  public RuleParserImpl(java.io.InputStream stream) {
     this(stream, null);
  }
  /** Constructor with InputStream and supplied encoding */
  public RuleParserImpl(java.io.InputStream stream, String encoding) {
    try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    token_source = new RuleParserImplTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 17; i++) jj_la1[i] = -1;
  }

  /** Reinitialise. */
  public void ReInit(java.io.InputStream stream) {
     ReInit(stream, null);
  }
  /** Reinitialise. */
  public void ReInit(java.io.InputStream stream, String encoding) {
    try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 17; i++) jj_la1[i] = -1;
  }

  /** Constructor. */
  public RuleParserImpl(java.io.Reader stream) {
    jj_input_stream = new SimpleCharStream(stream, 1, 1);
    token_source = new RuleParserImplTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 17; i++) jj_la1[i] = -1;
  }

  /** Reinitialise. */
  public void ReInit(java.io.Reader stream) {
    jj_input_stream.ReInit(stream, 1, 1);
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 17; i++) jj_la1[i] = -1;
  }

  /** Constructor with generated Token Manager. */
  public RuleParserImpl(RuleParserImplTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 17; i++) jj_la1[i] = -1;
  }

  /** Reinitialise. */
  public void ReInit(RuleParserImplTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 17; i++) jj_la1[i] = -1;
  }

  private Token jj_consume_token(int kind) throws ParseException {
    Token oldToken;
    if ((oldToken = token).next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    if (token.kind == kind) {
      jj_gen++;
      return token;
    }
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }


/** Get the next Token. */
  final public Token getNextToken() {
    if (token.next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    jj_gen++;
    return token;
  }

/** Get the specific Token. */
  final public Token getToken(int index) {
    Token t = token;
    for (int i = 0; i < index; i++) {
      if (t.next != null) t = t.next;
      else t = t.next = token_source.getNextToken();
    }
    return t;
  }

  private int jj_ntk() {
    if ((jj_nt=token.next) == null)
      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    else
      return (jj_ntk = jj_nt.kind);
  }

  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
  private int[] jj_expentry;
  private int jj_kind = -1;

  /** Generate ParseException. */
  public ParseException generateParseException() {
    jj_expentries.clear();
    boolean[] la1tokens = new boolean[57];
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 17; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
        }
      }
    }
    for (int i = 0; i < 57; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;
        jj_expentries.add(jj_expentry);
      }
    }
    int[][] exptokseq = new int[jj_expentries.size()][];
    for (int i = 0; i < jj_expentries.size(); i++) {
      exptokseq[i] = jj_expentries.get(i);
    }
    return new ParseException(token, exptokseq, tokenImage);
  }

  /** Enable tracing. */
  final public void enable_tracing() {
  }

  /** Disable tracing. */
  final public void disable_tracing() {
  }

}