You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@stanbol.apache.org by en...@apache.org on 2011/04/01 14:47:56 UTC
svn commit: r1087688 [6/19] - in /incubator/stanbol/trunk/rules: ./ base/
base/.settings/ base/src/ base/src/main/ base/src/main/java/
base/src/main/java/org/ base/src/main/java/org/apache/
base/src/main/java/org/apache/stanbol/ base/src/main/java/org/...
Added: incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleGrammar.jj
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleGrammar.jj?rev=1087688&view=auto
==============================================================================
--- incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleGrammar.jj (added)
+++ incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleGrammar.jj Fri Apr 1 12:47:48 2011
@@ -0,0 +1,771 @@
+/**
+ * JavaCC template file created by SF JavaCC plugin 1.5.17+ wizard for JavaCC 1.5.0+
+ */
+options
+{
+ JDK_VERSION = "1.6";
+ static = false;
+}
+
+PARSER_BEGIN(KReSRuleParser)
+package it.cnr.istc.semion.refactorer.rules.parser;
+
+import java.io.Reader;
+import java.io.StringReader;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Iterator;
+
+import com.hp.hpl.jena.rdf.model.ModelFactory;
+import com.hp.hpl.jena.rdf.model.Resource;
+
+
+import it.cnr.istc.semion.refactorer.rules.KReSRule;
+import it.cnr.istc.semion.refactorer.rules.KReSRuleAtom;
+import it.cnr.istc.semion.refactorer.rules.URIResource;
+import it.cnr.istc.semion.refactorer.rules.AtomList;
+import it.cnr.istc.semion.refactorer.rules.KReSKB;
+import it.cnr.istc.semion.refactorer.rules.KReSRuleImpl;
+import it.cnr.istc.semion.refactorer.rules.atoms.ClassAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.ComparisonAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.DatavaluedPropertyAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.EndsWithAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.IndividualPropertyAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.DifferentAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.KReSTypedLiteral;
+import it.cnr.istc.semion.refactorer.rules.atoms.LengthAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.NotAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.NumberAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.NumericFunctionAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.SPARQLddAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.SameAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.LessThanAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.GreaterThanAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.KReSResource;
+import it.cnr.istc.semion.refactorer.rules.atoms.KReSVariable;
+import it.cnr.istc.semion.refactorer.rules.atoms.LetAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.ConcatAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.StringAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.StringFunctionAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.SubstringAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.SubtractionAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.SumAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.NewNodeAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.KReSBlankNode;
+import it.cnr.istc.semion.refactorer.rules.atoms.UpperCaseAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.LowerCaseAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.NamespaceAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.LocalNameAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.StrAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.UnionAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.CreateLabelAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.PropStringAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.IsBlankAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.SPARQLcAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.SPARQLdAtom;
+import it.cnr.istc.semion.refactorer.rules.atoms.StartsWithAtom;
+import it.cnr.istc.semion.refactorer.rules.KReSRuleExpressiveness;
+
+public class KReSRuleParser
+{
+
+ static KReSKB kReSKB;
+
+ public static KReSKB parse( String inString ) {
+ {
+ kReSKB = new KReSKB();
+ Reader reader = new StringReader( inString ) ;
+ KReSRuleParser parser = new KReSRuleParser(reader);
+ StringBuffer buffer = new StringBuffer() ;
+ try {
+ parser.start( ) ;
+ } catch( TokenMgrError e ) {
+ throw new IllegalStateException(e) ;
+ } catch( ParseException e ) {
+ throw new IllegalStateException(e) ;
+ }
+ return kReSKB ; }
+ }
+
+
+ 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 = kReSKB.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(kReSKB.getPrefixURI("var")+variableString);
+
+
+
+ try {
+ return new URI(variableResource.getURI());
+ } catch (URISyntaxException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ return null;
+ }
+ }
+}
+
+PARSER_END(KReSRuleParser)
+
+SKIP : {" "}
+SKIP : {"\r" | "\t" | "\n"}
+
+TOKEN : /* OPERATORS */
+{
+ < LARROW : "->" >
+| < COLON : ":" >
+| < EQUAL : "=" >
+| < AND : "." >
+| < COMMA : "," >
+| < REFLEXIVE : "+" >
+| < SAME : "same" >
+| < DIFFERENT : "different" >
+| < LESSTHAN : "lt" >
+| < GREATERTHAN : "gt" >
+| < IS : "is" >
+| < NEW_NODE : "newNode" >
+| < LENGTH : "length" >
+| < SUBSTRING : "substring" >
+| < UPPERCASE : "upperCase" >
+| < LOWERCASE : "lowerCase" >
+| < STARTS_WITH : "startsWith" >
+| < ENDS_WITH : "endsWith" >
+| < LET : "let" >
+| < CONCAT : "concat" >
+| < HAS : "has" >
+| < VALUES : "values" >
+| < NOTEX : "notex" >
+| < PLUS : "sum" >
+| < MINUS : "sub" >
+| < NOT : "not" >
+| < NAMESPACE : "namespace" >
+| < LOCALNAME : "localname" >
+| < STR : "str" >
+| < APOX : "^" >
+| < UNION : "union" >
+| < CREATE_LABEL : "createLabel" >
+| < SPARQL_C : "sparql-c" >
+| < SPARQL_D : "sparql-d" >
+| < SPARQL_DD : "sparql-dd" >
+| < PROP : "prop" >
+| < IS_BLANK : "isBlank" >
+| < FORWARD_CHAIN : "!" >
+}
+
+TOKEN : /* BLOCKS */
+{
+ < LPAR : "(" >
+| < RPAR : ")" >
+| < DQUOT : "\"" >
+| < LQUAD : "[" >
+| < RQUAD : "]" >
+}
+
+TOKEN :
+{
+ < NUM : ([ "0"-"9"])+ >
+| < VAR : ([ "0"-"9","a"-"z","A"-"Z","-", "_", "."])+ >
+| < VARIABLE : "?" ([ "0"-"9","a"-"z","A"-"Z","-", "_"])+ >
+| < URI : "<" ([ "0"-"9","a"-"z","A"-"Z","-", "_", ".", "#", ":", "/", "(", ")" ])+ ">" >
+| < STRING : "\"" ([ "0"-"9","a"-"z","A"-"Z","-", "_", ".", ":", "/", "#", "\\", "?", " ", "!", "$", "%" ])+ "\"" >
+| < SPARQL_STRING : "%" ([ "0"-"9","a"-"z","A"-"Z","-", "_", ".", ":", "/", "#", "\\", "?", " ", "!", "$", "%", "{", "}", "(", ")", "\"", "<", ">", "=", "+", "\n", "\t", "&", "|", "," ])+ "%" >
+| < BNODE : "_:" ([ "0"-"9","a"-"z","A"-"Z","-", "_", "."])+ >
+}
+
+
+void start () :
+{}
+{
+ expression() expressionCont()
+}
+
+void expressionCont() :
+{}
+{
+ ( < AND > expression() ) | {}
+}
+
+void expression() :
+{KReSRule kReSRule;}
+{
+ prefix() expressionCont()
+}
+
+void prefix() :
+{String nsPrefix; Object obj;}
+{
+ nsPrefix=getVariable() (obj=equality() { String prefixURI = (String)obj;
+ prefixURI = prefixURI.substring(1, prefixURI.length()-1);
+ kReSKB.addPrefix(nsPrefix, prefixURI);
+ }
+ | obj=rule() { AtomList[] atoms = (AtomList[]) obj;
+ String varPrefix = kReSKB.getPrefixURI("var");
+ varPrefix = varPrefix.substring(0, varPrefix.length());
+
+ if(atoms.length == 1){
+ AtomList body = atoms[0];
+ if(body.size() == 1){
+ Iterator<KReSRuleAtom> it = body.iterator();
+ KReSRuleAtom atom = it.next();
+ if(atom.isSPARQLConstruct()){
+ KReSRule kReSRule = new KReSRuleImpl(varPrefix+nsPrefix, atoms[0], null, KReSRuleExpressiveness.SPARQLConstruct);
+ kReSKB.addRule(kReSRule);
+ }
+ else if(atom.isSPARQLDelete()){
+ KReSRule kReSRule = new KReSRuleImpl(varPrefix+nsPrefix, atoms[0], null, KReSRuleExpressiveness.SPARQLDelete);
+ kReSKB.addRule(kReSRule);
+ }
+ else if(atom.isSPARQLDeleteData()){
+ KReSRule kReSRule = new KReSRuleImpl(varPrefix+nsPrefix, atoms[0], null, KReSRuleExpressiveness.SPARQLDeleteData);
+ kReSKB.addRule(kReSRule);
+ }
+ }
+
+ }
+ else{
+ KReSRule kReSRule = new KReSRuleImpl(varPrefix+nsPrefix, atoms[0], atoms[1], KReSRuleExpressiveness.KReSCore);
+ kReSKB.addRule(kReSRule);
+ }
+ }
+ )
+
+|
+
+ < FORWARD_CHAIN > nsPrefix=getVariable() obj=rule() { AtomList[] atoms = (AtomList[]) obj;
+ String varPrefix = kReSKB.getPrefixURI("var");
+ varPrefix = varPrefix.substring(0, varPrefix.length());
+ KReSRule kReSRule = new KReSRuleImpl(varPrefix+nsPrefix, atoms[0], atoms[1], KReSRuleExpressiveness.ForwardChaining);
+ kReSKB.addRule(kReSRule); }
+
+| < REFLEXIVE > nsPrefix=getVariable() obj=rule() { AtomList[] kReSAtoms = (AtomList[]) obj;
+ String pref = kReSKB.getPrefixURI("var");
+ pref = pref.substring(0, pref.length());
+ KReSRule rule = new KReSRuleImpl(pref+nsPrefix, kReSAtoms[0], kReSAtoms[1], KReSRuleExpressiveness.Reflexive);
+ kReSKB.addRule(rule); }
+}
+
+
+String equality() :
+{String nsURI;}
+{
+ < EQUAL > ( nsURI=getURI() )
+ { return nsURI;}
+}
+
+
+
+AtomList[] rule() :
+{AtomList[] ruleAtoms;}
+{
+ < LQUAD > ruleAtoms=ruleDefinition() < RQUAD >
+ { return ruleAtoms; }
+
+}
+
+AtomList[] ruleDefinition():
+{AtomList body; AtomList head; Token t;}
+{
+ body=atomList() <LARROW> head=atomList()
+ { return new AtomList[]{body, head};}
+
+|
+ < SPARQL_C > < LPAR > t = < SPARQL_STRING > < RPAR >
+ {
+ KReSRuleAtom sparqlAtom = new SPARQLcAtom(t.image);
+ AtomList atomList = new AtomList();
+ atomList.addToHead(sparqlAtom);
+ return new AtomList[]{atomList};
+ }
+
+|
+ < SPARQL_D > < LPAR > t = < SPARQL_STRING > < RPAR >
+ {
+ KReSRuleAtom sparqlDAtom = new SPARQLdAtom(t.image);
+ AtomList atomDList = new AtomList();
+ atomDList.addToHead(sparqlDAtom);
+ return new AtomList[]{atomDList};
+ }
+
+|
+ < SPARQL_DD > < LPAR > t = < SPARQL_STRING > < RPAR >
+ {
+ KReSRuleAtom sparqlDDAtom = new SPARQLddAtom(t.image);
+ AtomList atomDDList = new AtomList();
+ atomDDList.addToHead(sparqlDDAtom);
+ return new AtomList[]{atomDDList};
+ }
+}
+
+AtomList atomList() :
+{AtomList atomList = new AtomList(); KReSRuleAtom kReSAtom;}
+{
+ kReSAtom=atom() atomList=atomListRest()
+ { atomList.addToHead(kReSAtom); return atomList;}
+
+ |
+ {}
+ {return atomList;}
+}
+
+
+AtomList atomListRest() :
+{AtomList atomList = new AtomList(); KReSRuleAtom kReSAtom;}
+{
+ < AND > atomList=atomList()
+ { return atomList;}
+ |
+ {}
+ {return atomList;}
+}
+
+
+KReSRuleAtom atom() :
+{KReSRuleAtom kReSRuleAtom;}
+{
+ kReSRuleAtom=classAtom() {return kReSRuleAtom;}
+| kReSRuleAtom=individualPropertyAtom() {return kReSRuleAtom;}
+| kReSRuleAtom=datavaluedPropertyAtom() {return kReSRuleAtom;}
+| kReSRuleAtom=letAtom() {return kReSRuleAtom;}
+| kReSRuleAtom=newNodeAtom() {return kReSRuleAtom;}
+| kReSRuleAtom=comparisonAtom() {return kReSRuleAtom;}
+| kReSRuleAtom=unionAtom() {return kReSRuleAtom;}
+
+}
+
+KReSRuleAtom unionAtom() :
+{AtomList atomList1; AtomList atomList2;}
+{
+ < UNION > < LPAR > atomList1 = atomList() < COMMA > atomList2 = atomList() < RPAR >
+ { return new UnionAtom(atomList1, atomList2); }
+}
+
+StringFunctionAtom createLabelAtom() :
+{StringFunctionAtom stringFunctionAtom;}
+{
+ < CREATE_LABEL > < LPAR > stringFunctionAtom = stringFunctionAtom() < RPAR >
+ { return new CreateLabelAtom(stringFunctionAtom); }
+}
+
+
+StringFunctionAtom propStringAtom() :
+{StringFunctionAtom stringFunctionAtom1; StringFunctionAtom stringFunctionAtom2;}
+{
+ < PROP > < LPAR > stringFunctionAtom1 = stringFunctionAtom() < COMMA > stringFunctionAtom2 = stringFunctionAtom() < RPAR >
+ { return new PropStringAtom(stringFunctionAtom1, stringFunctionAtom2); }
+}
+
+
+
+
+ComparisonAtom endsWithAtom() :
+{KReSRuleAtom kReSRuleAtom; StringFunctionAtom arg; StringFunctionAtom stringFunctionAtom;}
+{
+ < ENDS_WITH > < LPAR > arg=stringFunctionAtom() < COMMA > stringFunctionAtom = stringFunctionAtom()< RPAR >
+
+ {return new EndsWithAtom(arg, stringFunctionAtom);}
+}
+
+
+ComparisonAtom startsWithAtom() :
+{KReSRuleAtom kReSRuleAtom; StringFunctionAtom arg; StringFunctionAtom stringFunctionAtom;}
+{
+ < STARTS_WITH > < LPAR > arg=stringFunctionAtom() < COMMA > stringFunctionAtom = stringFunctionAtom()< RPAR >
+
+ {return new StartsWithAtom(arg, stringFunctionAtom);}
+}
+
+StringFunctionAtom stringFunctionAtom() :
+{Object obj; StringFunctionAtom stringFunctionAtom;}
+{
+ (
+ stringFunctionAtom=concatAtom()
+ | stringFunctionAtom=upperCaseAtom()
+ | stringFunctionAtom=lowerCaseAtom()
+ | stringFunctionAtom=substringAtom()
+ | stringFunctionAtom=namespaceAtom()
+ | stringFunctionAtom=localnameAtom()
+ | stringFunctionAtom=strAtom()
+ | stringFunctionAtom=stringAtom()
+ | stringFunctionAtom=propStringAtom()
+ | stringFunctionAtom=createLabelAtom()
+ )
+
+ {return stringFunctionAtom;}
+}
+
+
+StrAtom strAtom() :
+{URIResource uri;}
+{
+ < STR > < LPAR > uri = iObject() < RPAR >
+ {return new StrAtom(uri);}
+}
+
+NamespaceAtom namespaceAtom() :
+{URIResource uri;}
+{
+ < NAMESPACE > < LPAR > uri = iObject() < RPAR >
+ {return new NamespaceAtom(uri);}
+}
+
+LocalNameAtom localnameAtom() :
+{URIResource uri;}
+{
+ < LOCALNAME > < LPAR > uri = iObject() < RPAR >
+ {return new LocalNameAtom(uri);}
+}
+
+StringAtom stringAtom() :
+{Object obj; StringFunctionAtom stringFunctionAtom;}
+{
+ obj = uObject() { return new StringAtom(obj.toString()); }
+}
+
+ConcatAtom concatAtom() :
+{StringFunctionAtom arg1; StringFunctionAtom arg2;}
+{
+ < CONCAT > < LPAR > arg1=stringFunctionAtom() < COMMA > arg2=stringFunctionAtom() < RPAR >
+ { return new ConcatAtom(arg1, arg2);}
+}
+
+
+UpperCaseAtom upperCaseAtom() :
+{StringFunctionAtom arg;}
+{
+ < UPPERCASE > < LPAR > arg=stringFunctionAtom() < RPAR >
+ { return new UpperCaseAtom(arg);}
+}
+
+LowerCaseAtom lowerCaseAtom() :
+{StringFunctionAtom arg;}
+{
+ < LOWERCASE > < LPAR > arg=stringFunctionAtom() < RPAR >
+ { return new LowerCaseAtom(arg);}
+}
+
+SubstringAtom substringAtom() :
+{StringFunctionAtom arg; NumericFunctionAtom start; NumericFunctionAtom length;}
+{
+ < SUBSTRING > < LPAR > arg=stringFunctionAtom() < COMMA > start=numericFunctionAtom() < COMMA > length=numericFunctionAtom() < RPAR >
+ { return new SubstringAtom(arg, start, length);}
+}
+
+
+NumericFunctionAtom numericFunctionAtom() :
+{NumericFunctionAtom numericFunctionAtom;}
+{
+ (
+ numericFunctionAtom = sumAtom()
+ | numericFunctionAtom = subtractionAtom()
+ | numericFunctionAtom = lengthAtom()
+ | numericFunctionAtom = numberAtom()
+ )
+
+ {return numericFunctionAtom;}
+}
+
+
+LengthAtom lengthAtom() :
+{StringFunctionAtom stringFunctionAtom;}
+{
+ < LENGTH > < LPAR > stringFunctionAtom = stringFunctionAtom() < RPAR >
+ {return new LengthAtom(stringFunctionAtom);}
+}
+
+SumAtom sumAtom() :
+{NumericFunctionAtom numericFunctionAtom1; NumericFunctionAtom numericFunctionAtom2;}
+{
+
+ < PLUS > < LPAR > numericFunctionAtom1 = numericFunctionAtom() < COMMA > numericFunctionAtom2 = numericFunctionAtom() < RPAR >
+
+ {return new SumAtom(numericFunctionAtom1, numericFunctionAtom2);}
+}
+
+SubtractionAtom subtractionAtom() :
+{NumericFunctionAtom numericFunctionAtom1; NumericFunctionAtom numericFunctionAtom2;}
+{
+
+ < MINUS > < LPAR > numericFunctionAtom1 = numericFunctionAtom() < COMMA > numericFunctionAtom2 = numericFunctionAtom() < RPAR >
+
+ {return new SubtractionAtom(numericFunctionAtom1, numericFunctionAtom2);}
+}
+
+NumericFunctionAtom numberAtom() :
+{Token t;}
+{
+ (
+ t = < NUM >
+ | t = < VARIABLE >
+ )
+ { return new NumberAtom(t.image); }
+
+}
+
+
+ClassAtom classAtom() :
+{URIResource uri1; URIResource uri2;}
+{
+ < IS > < LPAR > uri1=iObject() < COMMA > uri2=iObject() < RPAR >
+ { return new ClassAtom(uri1, uri2);}
+}
+
+
+NewNodeAtom newNodeAtom() :
+{URIResource arg1; Object arg2;}
+{
+ < NEW_NODE > < LPAR > arg1=iObject() < COMMA > arg2=dObject() < RPAR >
+ { return new NewNodeAtom(arg1, arg2);}
+}
+
+LetAtom letAtom() :
+{URIResource uri1; StringFunctionAtom fun;}
+{
+ < LET > < LPAR > uri1=iObject() < COMMA > fun=stringFunctionAtom() < RPAR >
+ { return new LetAtom(uri1, fun);}
+}
+
+
+IndividualPropertyAtom individualPropertyAtom() :
+{URIResource uri1; URIResource uri2; URIResource uri3;}
+{
+ < HAS > < LPAR > uri1=iObject() < COMMA > uri2=iObject() <COMMA> uri3=iObject() < RPAR >
+ {return new IndividualPropertyAtom(uri1, uri2, uri3);}
+}
+
+
+DatavaluedPropertyAtom datavaluedPropertyAtom() :
+{URIResource uri1; URIResource uri2; Object obj;}
+{
+ < VALUES > < LPAR > uri1=iObject() < COMMA > uri2=iObject() <COMMA> obj=dObject() < RPAR >
+ { return new DatavaluedPropertyAtom(uri1, uri2, obj); }
+}
+
+
+SameAtom sameAsAtom() :
+{StringFunctionAtom stringFunctionAtom1; StringFunctionAtom stringFunctionAtom2;}
+{
+ < SAME > < LPAR > stringFunctionAtom1=stringFunctionAtom() < COMMA > stringFunctionAtom2=stringFunctionAtom() < RPAR >
+ { return new SameAtom(stringFunctionAtom1, stringFunctionAtom2); }
+}
+
+LessThanAtom lessThanAtom() :
+{Object obj1; Object obj2;}
+{
+ < LESSTHAN > < LPAR > obj1=iObject() < COMMA > obj2=iObject() < RPAR >
+ { return new LessThanAtom(obj1, obj2); }
+}
+
+GreaterThanAtom greaterThanAtom() :
+{Object obj1; Object obj2;}
+{
+ < GREATERTHAN > < LPAR > obj1=iObject() < COMMA > obj2=iObject() < RPAR >
+ { return new GreaterThanAtom(obj1, obj2); }
+}
+
+DifferentAtom differentFromAtom() :
+{StringFunctionAtom stringFunctionAtom1; StringFunctionAtom stringFunctionAtom2;}
+{
+ < DIFFERENT > < LPAR > stringFunctionAtom1=stringFunctionAtom() < COMMA > stringFunctionAtom2=stringFunctionAtom() < RPAR >
+ { return new DifferentAtom(stringFunctionAtom1, stringFunctionAtom2); }
+}
+
+URIResource reference() :
+{ String uri1;
+ Token colon;
+ String uri3; }
+{
+ uri1=getURI() { uri1 = uri1.substring(1, uri1.length()-1);
+ try {
+ return new KReSResource(new URI(uri1));
+ } catch (URISyntaxException e) {
+ e.printStackTrace();
+ } } |
+ uri1= getVariable() colon=< COLON > uri3=getVariable() { return new KReSResource(getSWRLArgument(uri1+colon.image+uri3)); }
+}
+
+
+
+URIResource varReference() :
+{ String uri1;
+ Token colon;
+ String uri3; }
+{
+ uri1=getURI() { try {
+ return new KReSResource(new URI(uri1));
+ } catch (URISyntaxException e) {
+ e.printStackTrace();
+ } } |
+ uri1= getVariable() colon=< COLON > uri3=getVariable() { return new KReSResource(getSWRLArgument(uri1+colon.image+uri3)); }
+}
+
+
+String getURI() :
+{
+ Token t;
+}
+{
+ t = < URI > { return t.image; }
+}
+
+String getVariable() :
+{
+ Token t;
+}
+{
+ t = < VAR > { return t.image; }
+}
+
+
+String getString() :
+{
+ Token t;
+}
+{
+ t = < STRING > { return t.image; }
+}
+
+Integer getInt() :
+{
+ Token t;
+}
+{
+ t=< NUM > { return Integer.valueOf(t.image); }
+}
+
+
+Object uObject() :
+{ Object obj; }
+{
+ (
+ obj = variable()
+ | obj = reference()
+ | obj = getString()
+ | obj = getInt()
+ )
+ {return obj;}
+
+}
+
+
+URIResource iObject() :
+{ URIResource uri; }
+{
+ uri = variable() {return uri;} | uri = reference() {return uri;}
+}
+
+Object dObject() :
+{ Object variable; }
+{
+
+ (variable=literal() | variable=variable()) {return variable;}
+}
+
+
+
+Object literal() :
+{ Object literal; URIResource typedLiteral;}
+{
+ (
+
+ literal=getString() typedLiteral=typedLiteral()
+ | literal=getInt() typedLiteral=typedLiteral()
+
+ )
+
+ {
+ if(typedLiteral != null){
+ return new KReSTypedLiteral(literal, typedLiteral);
+ }
+ else{
+ return literal;
+ }
+ }
+
+}
+
+URIResource typedLiteral() :
+{ URIResource type = null; }
+{
+ (
+ < APOX > < APOX > type = reference()
+ | {}
+ )
+ {return type;}
+}
+
+URIResource variable() :
+{ Token t; String var;}
+{
+ < NOTEX > < LPAR > t = < VARIABLE > < RPAR > {var=t.image; var=kReSKB.getPrefixURI("var") + var.substring(1);
+ try{
+ return new KReSVariable(new URI(var), true);
+ } catch (URISyntaxException e) {
+ e.printStackTrace();
+ return null;
+ }}
+| t = < VARIABLE >
+ { var=t.image; var=kReSKB.getPrefixURI("var") + var.substring(1);
+ try{
+ return new KReSVariable(new URI(var), false);
+ } catch (URISyntaxException e) {
+ e.printStackTrace();
+ return null;
+ } }
+| t = < BNODE >
+ { var=t.image; return new KReSBlankNode(var); }
+}
+
+ComparisonAtom notAtom() :
+{ ComparisonAtom comparisonAtom; }
+{
+ < NOT > < LPAR > comparisonAtom = comparisonAtom() < RPAR >
+ {return new NotAtom(comparisonAtom);}
+}
+
+ComparisonAtom isBlankAtom() :
+{ URIResource uriRes; }
+{
+ < IS_BLANK > < LPAR > uriRes = iObject() < RPAR >
+ {return new IsBlankAtom(uriRes);}
+}
+
+ComparisonAtom comparisonAtom() :
+{ ComparisonAtom comparisonAtom; }
+{
+ (
+ comparisonAtom = sameAsAtom()
+ | comparisonAtom = lessThanAtom()
+ | comparisonAtom = greaterThanAtom()
+ | comparisonAtom = differentFromAtom()
+ | comparisonAtom = notAtom()
+ | comparisonAtom = startsWithAtom()
+ | comparisonAtom = endsWithAtom()
+ | comparisonAtom = isBlankAtom()
+ )
+ {return comparisonAtom;}
+}
+
+
Added: incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleParserConstants.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleParserConstants.java?rev=1087688&view=auto
==============================================================================
--- incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleParserConstants.java (added)
+++ incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleParserConstants.java Fri Apr 1 12:47:48 2011
@@ -0,0 +1,176 @@
+/* Generated By:JavaCC: Do not edit this line. RuleParserConstants.java */
+package org.apache.stanbol.rules.manager.parse;
+
+
+/**
+ * Token literal values and constants.
+ * Generated by org.javacc.parser.OtherFilesGen#start()
+ */
+public interface RuleParserConstants {
+
+ /** End of File. */
+ int EOF = 0;
+ /** RegularExpression Id. */
+ int LARROW = 5;
+ /** RegularExpression Id. */
+ int COLON = 6;
+ /** RegularExpression Id. */
+ int EQUAL = 7;
+ /** RegularExpression Id. */
+ int AND = 8;
+ /** RegularExpression Id. */
+ int COMMA = 9;
+ /** RegularExpression Id. */
+ int REFLEXIVE = 10;
+ /** RegularExpression Id. */
+ int SAME = 11;
+ /** RegularExpression Id. */
+ int DIFFERENT = 12;
+ /** RegularExpression Id. */
+ int LESSTHAN = 13;
+ /** RegularExpression Id. */
+ int GREATERTHAN = 14;
+ /** RegularExpression Id. */
+ int IS = 15;
+ /** RegularExpression Id. */
+ int NEW_NODE = 16;
+ /** RegularExpression Id. */
+ int LENGTH = 17;
+ /** RegularExpression Id. */
+ int SUBSTRING = 18;
+ /** RegularExpression Id. */
+ int UPPERCASE = 19;
+ /** RegularExpression Id. */
+ int LOWERCASE = 20;
+ /** RegularExpression Id. */
+ int STARTS_WITH = 21;
+ /** RegularExpression Id. */
+ int ENDS_WITH = 22;
+ /** RegularExpression Id. */
+ int LET = 23;
+ /** RegularExpression Id. */
+ int CONCAT = 24;
+ /** RegularExpression Id. */
+ int HAS = 25;
+ /** RegularExpression Id. */
+ int VALUES = 26;
+ /** RegularExpression Id. */
+ int NOTEX = 27;
+ /** RegularExpression Id. */
+ int PLUS = 28;
+ /** RegularExpression Id. */
+ int MINUS = 29;
+ /** RegularExpression Id. */
+ int NOT = 30;
+ /** RegularExpression Id. */
+ int NAMESPACE = 31;
+ /** RegularExpression Id. */
+ int LOCALNAME = 32;
+ /** RegularExpression Id. */
+ int STR = 33;
+ /** RegularExpression Id. */
+ int APOX = 34;
+ /** RegularExpression Id. */
+ int UNION = 35;
+ /** RegularExpression Id. */
+ int CREATE_LABEL = 36;
+ /** RegularExpression Id. */
+ int SPARQL_C = 37;
+ /** RegularExpression Id. */
+ int SPARQL_D = 38;
+ /** RegularExpression Id. */
+ int SPARQL_DD = 39;
+ /** RegularExpression Id. */
+ int PROP = 40;
+ /** RegularExpression Id. */
+ int IS_BLANK = 41;
+ /** RegularExpression Id. */
+ int FORWARD_CHAIN = 42;
+ /** RegularExpression Id. */
+ int LPAR = 43;
+ /** RegularExpression Id. */
+ int RPAR = 44;
+ /** RegularExpression Id. */
+ int DQUOT = 45;
+ /** RegularExpression Id. */
+ int LQUAD = 46;
+ /** RegularExpression Id. */
+ int RQUAD = 47;
+ /** RegularExpression Id. */
+ int NUM = 48;
+ /** RegularExpression Id. */
+ int VAR = 49;
+ /** RegularExpression Id. */
+ int VARIABLE = 50;
+ /** RegularExpression Id. */
+ int URI = 51;
+ /** RegularExpression Id. */
+ int STRING = 52;
+ /** RegularExpression Id. */
+ int SPARQL_STRING = 53;
+ /** RegularExpression Id. */
+ int BNODE = 54;
+
+ /** Lexical state. */
+ int DEFAULT = 0;
+
+ /** Literal token values. */
+ String[] tokenImage = {
+ "<EOF>",
+ "\" \"",
+ "\"\\r\"",
+ "\"\\t\"",
+ "\"\\n\"",
+ "\"->\"",
+ "\":\"",
+ "\"=\"",
+ "\".\"",
+ "\",\"",
+ "\"+\"",
+ "\"same\"",
+ "\"different\"",
+ "\"lt\"",
+ "\"gt\"",
+ "\"is\"",
+ "\"newNode\"",
+ "\"length\"",
+ "\"substring\"",
+ "\"upperCase\"",
+ "\"lowerCase\"",
+ "\"startsWith\"",
+ "\"endsWith\"",
+ "\"let\"",
+ "\"concat\"",
+ "\"has\"",
+ "\"values\"",
+ "\"notex\"",
+ "\"sum\"",
+ "\"sub\"",
+ "\"not\"",
+ "\"namespace\"",
+ "\"localname\"",
+ "\"str\"",
+ "\"^\"",
+ "\"union\"",
+ "\"createLabel\"",
+ "\"sparql-c\"",
+ "\"sparql-d\"",
+ "\"sparql-dd\"",
+ "\"prop\"",
+ "\"isBlank\"",
+ "\"!\"",
+ "\"(\"",
+ "\")\"",
+ "\"\\\"\"",
+ "\"[\"",
+ "\"]\"",
+ "<NUM>",
+ "<VAR>",
+ "<VARIABLE>",
+ "<URI>",
+ "<STRING>",
+ "<SPARQL_STRING>",
+ "<BNODE>",
+ };
+
+}
Added: incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleParserImpl.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleParserImpl.java?rev=1087688&view=auto
==============================================================================
--- incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleParserImpl.java (added)
+++ incubator/stanbol/trunk/rules/manager/src/main/java/org/apache/stanbol/rules/manager/parse/RuleParserImpl.java Fri Apr 1 12:47:48 2011
@@ -0,0 +1,1232 @@
+/* Generated By:JavaCC: Do not edit this line. RuleParserImpl.java */
+package org.apache.stanbol.rules.manager.parse;
+
+import java.io.Reader;
+import java.io.StringReader;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Iterator;
+
+import org.apache.stanbol.rules.base.api.Rule;
+import org.apache.stanbol.rules.base.api.RuleAtom;
+import org.apache.stanbol.rules.base.api.RuleExpressiveness;
+import org.apache.stanbol.rules.base.api.URIResource;
+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.EndsWithAtom;
+import org.apache.stanbol.rules.manager.atoms.GreaterThanAtom;
+import org.apache.stanbol.rules.manager.atoms.IndividualPropertyAtom;
+import org.apache.stanbol.rules.manager.atoms.IsBlankAtom;
+import org.apache.stanbol.rules.manager.atoms.RuleBlankNode;
+import org.apache.stanbol.rules.manager.atoms.ResourceAtom;
+import org.apache.stanbol.rules.manager.atoms.TypedLiteralAtom;
+import org.apache.stanbol.rules.manager.atoms.VariableAtom;
+import org.apache.stanbol.rules.manager.atoms.LengthAtom;
+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.NamespaceAtom;
+import org.apache.stanbol.rules.manager.atoms.NewNodeAtom;
+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.PropStringAtom;
+import org.apache.stanbol.rules.manager.atoms.SPARQLcAtom;
+import org.apache.stanbol.rules.manager.atoms.SPARQLdAtom;
+import org.apache.stanbol.rules.manager.atoms.SPARQLddAtom;
+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.SubstringAtom;
+import org.apache.stanbol.rules.manager.atoms.SubtractionAtom;
+import org.apache.stanbol.rules.manager.atoms.SumAtom;
+import org.apache.stanbol.rules.manager.atoms.UnionAtom;
+import org.apache.stanbol.rules.manager.atoms.UpperCaseAtom;
+
+import com.hp.hpl.jena.rdf.model.ModelFactory;
+import com.hp.hpl.jena.rdf.model.Resource;
+
+
+
+
+public class RuleParserImpl implements RuleParserConstants {
+
+ static KB kReSKB;
+
+ public static KB parse( String inString ) {
+ {
+ kReSKB = new KB();
+ 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 kReSKB ; }
+ }
+
+
+ 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 = kReSKB.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(kReSKB.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 kReSRule;
+ prefix();
+ expressionCont();
+ }
+
+ final public void prefix() throws ParseException {
+ String nsPrefix; Object obj;
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case VAR:
+ 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);
+ kReSKB.addPrefix(nsPrefix, prefixURI);
+ break;
+ case LQUAD:
+ obj = rule();
+ AtomList[] atoms = (AtomList[]) obj;
+ String varPrefix = kReSKB.getPrefixURI("var");
+ varPrefix = varPrefix.substring(0, varPrefix.length());
+
+ if(atoms.length == 1){
+ AtomList body = atoms[0];
+ if(body.size() == 1){
+ Iterator<RuleAtom> it = body.iterator();
+ RuleAtom atom = it.next();
+ if(atom.isSPARQLConstruct()){
+ Rule kReSRule = new RuleImpl(varPrefix+nsPrefix, atoms[0], null, RuleExpressiveness.SPARQLConstruct);
+ kReSKB.addRule(kReSRule);
+ }
+ else if(atom.isSPARQLDelete()){
+ Rule kReSRule = new RuleImpl(varPrefix+nsPrefix, atoms[0], null, RuleExpressiveness.SPARQLDelete);
+ kReSKB.addRule(kReSRule);
+ }
+ else if(atom.isSPARQLDeleteData()){
+ Rule kReSRule = new RuleImpl(varPrefix+nsPrefix, atoms[0], null, RuleExpressiveness.SPARQLDeleteData);
+ kReSKB.addRule(kReSRule);
+ }
+ }
+
+ }
+ else{
+ Rule kReSRule = new RuleImpl(varPrefix+nsPrefix, atoms[0], atoms[1], RuleExpressiveness.KReSCore);
+ kReSKB.addRule(kReSRule);
+ }
+ break;
+ default:
+ jj_la1[1] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ break;
+ case FORWARD_CHAIN:
+ jj_consume_token(FORWARD_CHAIN);
+ nsPrefix = getVariable();
+ obj = rule();
+ AtomList[] atoms = (AtomList[]) obj;
+ String varPrefix = kReSKB.getPrefixURI("var");
+ varPrefix = varPrefix.substring(0, varPrefix.length());
+ Rule kReSRule = new RuleImpl(varPrefix+nsPrefix, atoms[0], atoms[1], RuleExpressiveness.ForwardChaining);
+ kReSKB.addRule(kReSRule);
+ break;
+ case REFLEXIVE:
+ jj_consume_token(REFLEXIVE);
+ nsPrefix = getVariable();
+ obj = rule();
+ AtomList[] kReSAtoms = (AtomList[]) obj;
+ String pref = kReSKB.getPrefixURI("var");
+ pref = pref.substring(0, pref.length());
+ Rule rule = new RuleImpl(pref+nsPrefix, kReSAtoms[0], kReSAtoms[1], RuleExpressiveness.Reflexive);
+ kReSKB.addRule(rule);
+ break;
+ default:
+ jj_la1[2] = 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;
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LARROW:
+ case SAME:
+ case DIFFERENT:
+ case LESSTHAN:
+ case GREATERTHAN:
+ case IS:
+ case NEW_NODE:
+ case STARTS_WITH:
+ case ENDS_WITH:
+ case LET:
+ case HAS:
+ case VALUES:
+ case NOT:
+ case UNION:
+ case IS_BLANK:
+ body = atomList();
+ jj_consume_token(LARROW);
+ head = atomList();
+ {if (true) return new AtomList[]{body, head};}
+ break;
+ case SPARQL_C:
+ jj_consume_token(SPARQL_C);
+ jj_consume_token(LPAR);
+ t = jj_consume_token(SPARQL_STRING);
+ jj_consume_token(RPAR);
+ RuleAtom sparqlAtom = new SPARQLcAtom(t.image);
+ AtomList atomList = new AtomList();
+ atomList.addToHead(sparqlAtom);
+ {if (true) return new AtomList[]{atomList};}
+ break;
+ case SPARQL_D:
+ jj_consume_token(SPARQL_D);
+ jj_consume_token(LPAR);
+ t = jj_consume_token(SPARQL_STRING);
+ jj_consume_token(RPAR);
+ RuleAtom sparqlDAtom = new SPARQLdAtom(t.image);
+ AtomList atomDList = new AtomList();
+ atomDList.addToHead(sparqlDAtom);
+ {if (true) return new AtomList[]{atomDList};}
+ break;
+ case SPARQL_DD:
+ jj_consume_token(SPARQL_DD);
+ jj_consume_token(LPAR);
+ t = jj_consume_token(SPARQL_STRING);
+ jj_consume_token(RPAR);
+ RuleAtom sparqlDDAtom = new SPARQLddAtom(t.image);
+ AtomList atomDDList = new AtomList();
+ atomDDList.addToHead(sparqlDDAtom);
+ {if (true) return new AtomList[]{atomDDList};}
+ break;
+ default:
+ jj_la1[3] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ 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_NODE:
+ 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[4] = 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[5] = jj_gen;
+
+ {if (true) return atomList;}
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final public RuleAtom atom() throws ParseException {
+ RuleAtom kReSRuleAtom;
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IS:
+ kReSRuleAtom = classAtom();
+ {if (true) return kReSRuleAtom;}
+ break;
+ case HAS:
+ kReSRuleAtom = individualPropertyAtom();
+ {if (true) return kReSRuleAtom;}
+ break;
+ case VALUES:
+ kReSRuleAtom = datavaluedPropertyAtom();
+ {if (true) return kReSRuleAtom;}
+ break;
+ case LET:
+ kReSRuleAtom = letAtom();
+ {if (true) return kReSRuleAtom;}
+ break;
+ case NEW_NODE:
+ kReSRuleAtom = newNodeAtom();
+ {if (true) return kReSRuleAtom;}
+ break;
+ case SAME:
+ case DIFFERENT:
+ case LESSTHAN:
+ case GREATERTHAN:
+ case STARTS_WITH:
+ case ENDS_WITH:
+ case NOT:
+ case IS_BLANK:
+ kReSRuleAtom = comparisonAtom();
+ {if (true) return kReSRuleAtom;}
+ break;
+ case UNION:
+ kReSRuleAtom = unionAtom();
+ {if (true) return kReSRuleAtom;}
+ break;
+ default:
+ jj_la1[6] = 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 kReSRuleAtom; 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 kReSRuleAtom; 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 NOTEX:
+ case NUM:
+ case VAR:
+ case VARIABLE:
+ case URI:
+ case STRING:
+ case BNODE:
+ stringFunctionAtom = stringAtom();
+ break;
+ case PROP:
+ stringFunctionAtom = propStringAtom();
+ break;
+ case CREATE_LABEL:
+ stringFunctionAtom = createLabelAtom();
+ break;
+ default:
+ jj_la1[7] = 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 {
+ URIResource 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 {
+ URIResource 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 {
+ URIResource 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 {
+ Object obj; StringFunctionAtom stringFunctionAtom;
+ obj = uObject();
+ {if (true) return new StringAtom(obj.toString());}
+ 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 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:
+ case VARIABLE:
+ numericFunctionAtom = numberAtom();
+ break;
+ default:
+ jj_la1[8] = 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 NumericFunctionAtom numberAtom() throws ParseException {
+ Token t;
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case NUM:
+ t = jj_consume_token(NUM);
+ break;
+ case VARIABLE:
+ t = jj_consume_token(VARIABLE);
+ break;
+ default:
+ jj_la1[9] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ {if (true) return new NumberAtom(t.image);}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public ClassAtom classAtom() throws ParseException {
+ URIResource uri1; URIResource 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 NewNodeAtom newNodeAtom() throws ParseException {
+ URIResource arg1; Object arg2;
+ jj_consume_token(NEW_NODE);
+ jj_consume_token(LPAR);
+ arg1 = iObject();
+ jj_consume_token(COMMA);
+ arg2 = dObject();
+ jj_consume_token(RPAR);
+ {if (true) return new NewNodeAtom(arg1, arg2);}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public LetAtom letAtom() throws ParseException {
+ URIResource 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 {
+ URIResource uri1; URIResource uri2; URIResource 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 {
+ URIResource uri1; URIResource uri2; Object 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 {
+ StringFunctionAtom stringFunctionAtom1; StringFunctionAtom stringFunctionAtom2;
+ jj_consume_token(SAME);
+ jj_consume_token(LPAR);
+ stringFunctionAtom1 = stringFunctionAtom();
+ jj_consume_token(COMMA);
+ stringFunctionAtom2 = stringFunctionAtom();
+ jj_consume_token(RPAR);
+ {if (true) return new SameAtom(stringFunctionAtom1, stringFunctionAtom2);}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public LessThanAtom lessThanAtom() throws ParseException {
+ Object obj1; Object obj2;
+ jj_consume_token(LESSTHAN);
+ jj_consume_token(LPAR);
+ obj1 = iObject();
+ jj_consume_token(COMMA);
+ obj2 = iObject();
+ jj_consume_token(RPAR);
+ {if (true) return new LessThanAtom(obj1, obj2);}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public GreaterThanAtom greaterThanAtom() throws ParseException {
+ Object obj1; Object obj2;
+ jj_consume_token(GREATERTHAN);
+ jj_consume_token(LPAR);
+ obj1 = iObject();
+ jj_consume_token(COMMA);
+ obj2 = iObject();
+ jj_consume_token(RPAR);
+ {if (true) return new GreaterThanAtom(obj1, obj2);}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public DifferentAtom differentFromAtom() throws ParseException {
+ StringFunctionAtom stringFunctionAtom1; StringFunctionAtom stringFunctionAtom2;
+ jj_consume_token(DIFFERENT);
+ jj_consume_token(LPAR);
+ stringFunctionAtom1 = stringFunctionAtom();
+ jj_consume_token(COMMA);
+ stringFunctionAtom2 = stringFunctionAtom();
+ jj_consume_token(RPAR);
+ {if (true) return new DifferentAtom(stringFunctionAtom1, stringFunctionAtom2);}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public URIResource 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[10] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final public URIResource 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[11] = 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 getString() throws ParseException {
+ Token t;
+ t = jj_consume_token(STRING);
+ {if (true) return t.image;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public Integer getInt() throws ParseException {
+ Token t;
+ t = jj_consume_token(NUM);
+ {if (true) return Integer.valueOf(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[12] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ {if (true) return obj;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public URIResource iObject() throws ParseException {
+ URIResource 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[13] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final public Object dObject() throws ParseException {
+ Object 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[14] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ {if (true) return variable;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public Object literal() throws ParseException {
+ Object literal; URIResource 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[15] = 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 URIResource typedLiteral() throws ParseException {
+ URIResource 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[16] = jj_gen;
+
+ }
+ {if (true) return type;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public URIResource 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=kReSKB.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=kReSKB.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[17] = 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 {
+ URIResource 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[18] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ {if (true) return comparisonAtom;}
+ throw new Error("Missing return statement in function");
+ }
+
+ /** Generated Token Manager. */
+ public RuleParserTokenManager 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[19];
+ 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[] {0x100,0x80,0x400,0x46e1f820,0x46e1f800,0x100,0x46e1f800,0x891c0000,0x30020000,0x0,0x0,0x0,0x8000000,0x8000000,0x8000000,0x0,0x0,0x8000000,0x40607800,};
+ }
+ private static void jj_la1_init_1() {
+ jj_la1_1 = new int[] {0x0,0x4000,0x20400,0x2e8,0x208,0x0,0x208,0x5f0113,0x50000,0x50000,0xa0000,0xa0000,0x5f0000,0x4e0000,0x550000,0x110000,0x4,0x440000,0x200,};
+ }
+
+ /** 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 RuleParserTokenManager(jj_input_stream);
+ token = new Token();
+ jj_ntk = -1;
+ jj_gen = 0;
+ for (int i = 0; i < 19; 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 < 19; i++) jj_la1[i] = -1;
+ }
+
+ /** Constructor. */
+ public RuleParserImpl(java.io.Reader stream) {
+ jj_input_stream = new SimpleCharStream(stream, 1, 1);
+ token_source = new RuleParserTokenManager(jj_input_stream);
+ token = new Token();
+ jj_ntk = -1;
+ jj_gen = 0;
+ for (int i = 0; i < 19; 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 < 19; i++) jj_la1[i] = -1;
+ }
+
+ /** Constructor with generated Token Manager. */
+ public RuleParserImpl(RuleParserTokenManager tm) {
+ token_source = tm;
+ token = new Token();
+ jj_ntk = -1;
+ jj_gen = 0;
+ for (int i = 0; i < 19; i++) jj_la1[i] = -1;
+ }
+
+ /** Reinitialise. */
+ public void ReInit(RuleParserTokenManager tm) {
+ token_source = tm;
+ token = new Token();
+ jj_ntk = -1;
+ jj_gen = 0;
+ for (int i = 0; i < 19; 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[55];
+ if (jj_kind >= 0) {
+ la1tokens[jj_kind] = true;
+ jj_kind = -1;
+ }
+ for (int i = 0; i < 19; 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 < 55; 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() {
+ }
+
+}