Menu
▾
▴
[DL-Learner SVN] SF.net SVN: dl-learner: [527] trunk/src/dl-learner/org/dllearner/parser
|
From: <jen...@us...> - 2008-02-08 08:59:37
|
Revision: 527
http://dl-learner.svn.sourceforge.net/dl-learner/?rev=527&view=rev
Author: jenslehmann
Date: 2008-02-08 00:59:26 -0800 (Fri, 08 Feb 2008)
Log Message:
-----------
added JavaCC Prolog parser
Modified Paths:
--------------
trunk/src/dl-learner/org/dllearner/parser/package.html
Added Paths:
-----------
trunk/src/dl-learner/org/dllearner/parser/PrologParser.java
trunk/src/dl-learner/org/dllearner/parser/PrologParserConstants.java
trunk/src/dl-learner/org/dllearner/parser/PrologParserTokenManager.java
trunk/src/dl-learner/org/dllearner/parser/prolog.jj
Added: trunk/src/dl-learner/org/dllearner/parser/PrologParser.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/parser/PrologParser.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/parser/PrologParser.java 2008-02-08 08:59:26 UTC (rev 527)
@@ -0,0 +1,773 @@
+/* Generated By:JavaCC: Do not edit this line. PrologParser.java */
+package org.dllearner.parser;
+
+public @SuppressWarnings("all") class PrologParser implements PrologParserConstants {
+ public PrologParser() {
+ this(new java.io.StringReader(""));
+ }
+
+ public org.dllearner.prolog.Term parseTerm(String src) throws ParseException {
+ reinitToString(src);
+ return term();
+ }
+
+ public java.util.ArrayList parseTermList(String src) throws ParseException {
+ reinitToString(src);
+ return termList();
+ }
+
+ public org.dllearner.prolog.Atom parseAtom(String src) throws ParseException {
+ reinitToString(src);
+ return atom();
+ }
+
+ public org.dllearner.prolog.Clause parseClause(String src) throws ParseException {
+ reinitToString(src);
+ return clause();
+ }
+
+ public org.dllearner.prolog.Program parseProgram(String src) throws ParseException {
+ reinitToString(src);
+ return program();
+ }
+
+ private void reinitToString(String src) {
+ ReInit(new java.io.StringReader(src));
+ }
+
+//////////////////////////////////////////////////////////////////////////////////////////
+ final public org.dllearner.prolog.Program program() throws ParseException {
+ org.dllearner.prolog.Program p = new org.dllearner.prolog.Program();
+ org.dllearner.prolog.Clause c;
+ label_1:
+ while (true) {
+ c = clause();
+ p.addClause(c);
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IDENTIFIER:
+ ;
+ break;
+ default:
+ jj_la1[0] = jj_gen;
+ break label_1;
+ }
+ }
+ jj_consume_token(0);
+ {if (true) return p;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public org.dllearner.prolog.Clause clause() throws ParseException {
+ org.dllearner.prolog.Atom head;
+ org.dllearner.prolog.Body body = null;
+ head = atom();
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case 18:
+ jj_consume_token(18);
+ body = body();
+ break;
+ default:
+ jj_la1[1] = jj_gen;
+ ;
+ }
+ jj_consume_token(19);
+ {if (true) return new org.dllearner.prolog.Clause(head, body);}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public org.dllearner.prolog.Body body() throws ParseException {
+ org.dllearner.prolog.Literal l;
+ org.dllearner.prolog.Body b = new org.dllearner.prolog.Body();
+ l = literal();
+ b.addLiteral(l);
+ label_2:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case 20:
+ ;
+ break;
+ default:
+ jj_la1[2] = jj_gen;
+ break label_2;
+ }
+ jj_consume_token(20);
+ l = literal();
+ b.addLiteral(l);
+ }
+ {if (true) return b;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public org.dllearner.prolog.Atom atom() throws ParseException {
+ Token atom;
+ java.util.ArrayList arguments = new java.util.ArrayList() ;
+ atom = jj_consume_token(IDENTIFIER);
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case 21:
+ jj_consume_token(21);
+ arguments = termList();
+ jj_consume_token(22);
+ break;
+ default:
+ jj_la1[3] = jj_gen;
+ ;
+ }
+ {if (true) return new org.dllearner.prolog.Atom(atom.image, arguments);}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public org.dllearner.prolog.Literal literal() throws ParseException {
+ org.dllearner.prolog.Atom a;
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IDENTIFIER:
+ a = atom();
+ {if (true) return new org.dllearner.prolog.Literal(a, true);}
+ break;
+ case NOT:
+ jj_consume_token(NOT);
+ a = atom();
+ {if (true) return new org.dllearner.prolog.Literal(a, false);}
+ break;
+ default:
+ jj_la1[4] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final public org.dllearner.prolog.Term term() throws ParseException {
+ Token v;
+ String o;
+ Token f;
+ java.util.ArrayList arguments = null;
+ org.dllearner.prolog.Term t1, t2;
+ if (jj_2_1(2147483647)) {
+ o = prefixOp();
+ t2 = simpleTerm();
+ {if (true) return new org.dllearner.prolog.Function(o, t2);}
+ } else if (jj_2_2(2147483647)) {
+ t1 = simpleTerm();
+ o = infixOp();
+ t2 = simpleTerm();
+ {if (true) return new org.dllearner.prolog.Function(t1, o, t2);}
+ } else if (jj_2_3(2147483647)) {
+ t1 = simpleTerm();
+ o = postfixOp();
+ {if (true) return new org.dllearner.prolog.Function(t1, o);}
+ } else if (jj_2_4(2147483647)) {
+ t1 = simpleTerm();
+ {if (true) return t1;}
+ } else {
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final public org.dllearner.prolog.Term simpleTerm() throws ParseException {
+ Token v;
+ String o;
+ Token f;
+ java.util.ArrayList arguments = null;
+ org.dllearner.prolog.Term l;
+ if (jj_2_5(2)) {
+ f = jj_consume_token(IDENTIFIER);
+ jj_consume_token(21);
+ arguments = termList();
+ jj_consume_token(22);
+ {if (true) return new org.dllearner.prolog.Function(f.image, arguments);}
+ } else if (jj_2_6(2)) {
+ f = jj_consume_token(IDENTIFIER);
+ {if (true) return new org.dllearner.prolog.PrologConstant(f.image);}
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case VAR:
+ v = jj_consume_token(VAR);
+ {if (true) return new org.dllearner.prolog.Variable(v.image);}
+ break;
+ case NUMBER:
+ v = jj_consume_token(NUMBER);
+ {if (true) return new org.dllearner.prolog.Number(v.image);}
+ break;
+ case STRINGCONSTANT:
+ v = jj_consume_token(STRINGCONSTANT);
+ {if (true) return new org.dllearner.prolog.StringConstant(v.image);}
+ break;
+ case 23:
+ case 24:
+ l = list();
+ {if (true) return l;}
+ break;
+ default:
+ jj_la1[5] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final public String prefixOp() throws ParseException {
+ Token f;
+ f = jj_consume_token(OPERATOR);
+ {if (true) return f.image;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public String infixOp() throws ParseException {
+ Token f;
+ f = jj_consume_token(OPERATOR);
+ {if (true) return f.image;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public String postfixOp() throws ParseException {
+ Token f;
+ f = jj_consume_token(OPERATOR);
+ {if (true) return f.image;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public java.util.ArrayList termList() throws ParseException {
+ org.dllearner.prolog.Term t;
+ java.util.ArrayList l = new java.util.ArrayList();
+ t = term();
+ l.add(t);
+ label_3:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case 20:
+ ;
+ break;
+ default:
+ jj_la1[6] = jj_gen;
+ break label_3;
+ }
+ jj_consume_token(20);
+ t = term();
+ l.add(t);
+ }
+ {if (true) return l;}
+ throw new Error("Missing return statement in function");
+ }
+
+ final public org.dllearner.prolog.List list() throws ParseException {
+ java.util.ArrayList content = null;
+ org.dllearner.prolog.Term head;
+ org.dllearner.prolog.List l;
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case 23:
+ jj_consume_token(23);
+ {if (true) return new org.dllearner.prolog.List();}
+ break;
+ default:
+ jj_la1[7] = jj_gen;
+ if (jj_2_7(3)) {
+ jj_consume_token(24);
+ head = term();
+ jj_consume_token(25);
+ {if (true) return new org.dllearner.prolog.List(head, null);}
+ } else if (jj_2_8(3)) {
+ jj_consume_token(24);
+ head = term();
+ jj_consume_token(26);
+ l = list();
+ jj_consume_token(25);
+ {if (true) return new org.dllearner.prolog.List(head, l);}
+ } else {
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final private boolean jj_2_1(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_1(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(0, xla); }
+ }
+
+ final private boolean jj_2_2(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_2(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(1, xla); }
+ }
+
+ final private boolean jj_2_3(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_3(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(2, xla); }
+ }
+
+ final private boolean jj_2_4(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_4(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(3, xla); }
+ }
+
+ final private boolean jj_2_5(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_5(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(4, xla); }
+ }
+
+ final private boolean jj_2_6(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_6(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(5, xla); }
+ }
+
+ final private boolean jj_2_7(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_7(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(6, xla); }
+ }
+
+ final private boolean jj_2_8(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_8(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(7, xla); }
+ }
+
+ final private boolean jj_3R_4() {
+ if (jj_scan_token(OPERATOR)) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_12() {
+ if (jj_3R_14()) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_11() {
+ if (jj_scan_token(STRINGCONSTANT)) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_10() {
+ if (jj_scan_token(NUMBER)) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_9() {
+ if (jj_scan_token(VAR)) return true;
+ return false;
+ }
+
+ final private boolean jj_3_6() {
+ if (jj_scan_token(IDENTIFIER)) return true;
+ return false;
+ }
+
+ final private boolean jj_3_8() {
+ if (jj_scan_token(24)) return true;
+ if (jj_3R_8()) return true;
+ if (jj_scan_token(26)) return true;
+ if (jj_3R_14()) return true;
+ if (jj_scan_token(25)) return true;
+ return false;
+ }
+
+ final private boolean jj_3_5() {
+ if (jj_scan_token(IDENTIFIER)) return true;
+ if (jj_scan_token(21)) return true;
+ if (jj_3R_13()) return true;
+ if (jj_scan_token(22)) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_5() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3_5()) {
+ jj_scanpos = xsp;
+ if (jj_3_6()) {
+ jj_scanpos = xsp;
+ if (jj_3R_9()) {
+ jj_scanpos = xsp;
+ if (jj_3R_10()) {
+ jj_scanpos = xsp;
+ if (jj_3R_11()) {
+ jj_scanpos = xsp;
+ if (jj_3R_12()) return true;
+ }
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ final private boolean jj_3_7() {
+ if (jj_scan_token(24)) return true;
+ if (jj_3R_8()) return true;
+ if (jj_scan_token(25)) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_16() {
+ if (jj_scan_token(23)) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_14() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_16()) {
+ jj_scanpos = xsp;
+ if (jj_3_7()) {
+ jj_scanpos = xsp;
+ if (jj_3_8()) return true;
+ }
+ }
+ return false;
+ }
+
+ final private boolean jj_3_4() {
+ if (jj_3R_5()) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_15() {
+ if (jj_scan_token(20)) return true;
+ if (jj_3R_8()) return true;
+ return false;
+ }
+
+ final private boolean jj_3_3() {
+ if (jj_3R_5()) return true;
+ if (jj_3R_7()) return true;
+ return false;
+ }
+
+ final private boolean jj_3_2() {
+ if (jj_3R_5()) return true;
+ if (jj_3R_6()) return true;
+ if (jj_3R_5()) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_13() {
+ if (jj_3R_8()) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_15()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ final private boolean jj_3_1() {
+ if (jj_3R_4()) return true;
+ if (jj_3R_5()) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_8() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3_1()) {
+ jj_scanpos = xsp;
+ if (jj_3_2()) {
+ jj_scanpos = xsp;
+ if (jj_3_3()) {
+ jj_scanpos = xsp;
+ if (jj_3_4()) return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ final private boolean jj_3R_7() {
+ if (jj_scan_token(OPERATOR)) return true;
+ return false;
+ }
+
+ final private boolean jj_3R_6() {
+ if (jj_scan_token(OPERATOR)) return true;
+ return false;
+ }
+
+ public PrologParserTokenManager token_source;
+ SimpleCharStream jj_input_stream;
+ public Token token, jj_nt;
+ private int jj_ntk;
+ private Token jj_scanpos, jj_lastpos;
+ private int jj_la;
+ public boolean lookingAhead = false;
+ private boolean jj_semLA;
+ private int jj_gen;
+ final private int[] jj_la1 = new int[8];
+ static private int[] jj_la1_0;
+ static {
+ jj_la1_0();
+ }
+ private static void jj_la1_0() {
+ jj_la1_0 = new int[] {0x1000,0x40000,0x100000,0x200000,0x1080,0x1800d00,0x100000,0x800000,};
+ }
+ final private JJCalls[] jj_2_rtns = new JJCalls[8];
+ private boolean jj_rescan = false;
+ private int jj_gc = 0;
+
+ public PrologParser(java.io.InputStream stream) {
+ this(stream, null);
+ }
+ public PrologParser(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 PrologParserTokenManager(jj_input_stream);
+ token = new Token();
+ jj_ntk = -1;
+ jj_gen = 0;
+ for (int i = 0; i < 8; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ public void ReInit(java.io.InputStream stream) {
+ ReInit(stream, null);
+ }
+ 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 < 8; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ public PrologParser(java.io.Reader stream) {
+ jj_input_stream = new SimpleCharStream(stream, 1, 1);
+ token_source = new PrologParserTokenManager(jj_input_stream);
+ token = new Token();
+ jj_ntk = -1;
+ jj_gen = 0;
+ for (int i = 0; i < 8; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ 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 < 8; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ public PrologParser(PrologParserTokenManager tm) {
+ token_source = tm;
+ token = new Token();
+ jj_ntk = -1;
+ jj_gen = 0;
+ for (int i = 0; i < 8; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ public void ReInit(PrologParserTokenManager tm) {
+ token_source = tm;
+ token = new Token();
+ jj_ntk = -1;
+ jj_gen = 0;
+ for (int i = 0; i < 8; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ final 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++;
+ if (++jj_gc > 100) {
+ jj_gc = 0;
+ for (int i = 0; i < jj_2_rtns.length; i++) {
+ JJCalls c = jj_2_rtns[i];
+ while (c != null) {
+ if (c.gen < jj_gen) c.first = null;
+ c = c.next;
+ }
+ }
+ }
+ return token;
+ }
+ token = oldToken;
+ jj_kind = kind;
+ throw generateParseException();
+ }
+
+ static private final class LookaheadSuccess extends java.lang.Error { }
+ final private LookaheadSuccess jj_ls = new LookaheadSuccess();
+ final private boolean jj_scan_token(int kind) {
+ if (jj_scanpos == jj_lastpos) {
+ jj_la--;
+ if (jj_scanpos.next == null) {
+ jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
+ } else {
+ jj_lastpos = jj_scanpos = jj_scanpos.next;
+ }
+ } else {
+ jj_scanpos = jj_scanpos.next;
+ }
+ if (jj_rescan) {
+ int i = 0; Token tok = token;
+ while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
+ if (tok != null) jj_add_error_token(kind, i);
+ }
+ if (jj_scanpos.kind != kind) return true;
+ if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
+ return false;
+ }
+
+ 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;
+ }
+
+ final public Token getToken(int index) {
+ Token t = lookingAhead ? jj_scanpos : token;
+ for (int i = 0; i < index; i++) {
+ if (t.next != null) t = t.next;
+ else t = t.next = token_source.getNextToken();
+ }
+ return t;
+ }
+
+ final 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.Vector<int[]> jj_expentries = new java.util.Vector<int[]>();
+ private int[] jj_expentry;
+ private int jj_kind = -1;
+ private int[] jj_lasttokens = new int[100];
+ private int jj_endpos;
+
+ private void jj_add_error_token(int kind, int pos) {
+ if (pos >= 100) return;
+ if (pos == jj_endpos + 1) {
+ jj_lasttokens[jj_endpos++] = kind;
+ } else if (jj_endpos != 0) {
+ jj_expentry = new int[jj_endpos];
+ for (int i = 0; i < jj_endpos; i++) {
+ jj_expentry[i] = jj_lasttokens[i];
+ }
+ boolean exists = false;
+ for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
+ int[] oldentry = (int[])(e.nextElement());
+ if (oldentry.length == jj_expentry.length) {
+ exists = true;
+ for (int i = 0; i < jj_expentry.length; i++) {
+ if (oldentry[i] != jj_expentry[i]) {
+ exists = false;
+ break;
+ }
+ }
+ if (exists) break;
+ }
+ }
+ if (!exists) jj_expentries.addElement(jj_expentry);
+ if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
+ }
+ }
+
+ public ParseException generateParseException() {
+ jj_expentries.removeAllElements();
+ boolean[] la1tokens = new boolean[27];
+ if (jj_kind >= 0) {
+ la1tokens[jj_kind] = true;
+ jj_kind = -1;
+ }
+ for (int i = 0; i < 8; 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;
+ }
+ }
+ }
+ }
+ for (int i = 0; i < 27; i++) {
+ if (la1tokens[i]) {
+ jj_expentry = new int[1];
+ jj_expentry[0] = i;
+ jj_expentries.addElement(jj_expentry);
+ }
+ }
+ jj_endpos = 0;
+ jj_rescan_token();
+ jj_add_error_token(0, 0);
+ int[][] exptokseq = new int[jj_expentries.size()][];
+ for (int i = 0; i < jj_expentries.size(); i++) {
+ exptokseq[i] = jj_expentries.elementAt(i);
+ }
+ return new ParseException(token, exptokseq, tokenImage);
+ }
+
+ final public void enable_tracing() {
+ }
+
+ final public void disable_tracing() {
+ }
+
+ final private void jj_rescan_token() {
+ jj_rescan = true;
+ for (int i = 0; i < 8; i++) {
+ try {
+ JJCalls p = jj_2_rtns[i];
+ do {
+ if (p.gen > jj_gen) {
+ jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
+ switch (i) {
+ case 0: jj_3_1(); break;
+ case 1: jj_3_2(); break;
+ case 2: jj_3_3(); break;
+ case 3: jj_3_4(); break;
+ case 4: jj_3_5(); break;
+ case 5: jj_3_6(); break;
+ case 6: jj_3_7(); break;
+ case 7: jj_3_8(); break;
+ }
+ }
+ p = p.next;
+ } while (p != null);
+ } catch(LookaheadSuccess ls) { }
+ }
+ jj_rescan = false;
+ }
+
+ final private void jj_save(int index, int xla) {
+ JJCalls p = jj_2_rtns[index];
+ while (p.gen > jj_gen) {
+ if (p.next == null) { p = p.next = new JJCalls(); break; }
+ p = p.next;
+ }
+ p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
+ }
+
+ static final class JJCalls {
+ int gen;
+ Token first;
+ int arg;
+ JJCalls next;
+ }
+
+}
Added: trunk/src/dl-learner/org/dllearner/parser/PrologParserConstants.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/parser/PrologParserConstants.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/parser/PrologParserConstants.java 2008-02-08 08:59:26 UTC (rev 527)
@@ -0,0 +1,52 @@
+/* Generated By:JavaCC: Do not edit this line. PrologParserConstants.java */
+package org.dllearner.parser;
+
+public @SuppressWarnings("all") interface PrologParserConstants {
+
+ int EOF = 0;
+ int SINGLE_LINE_COMMENT = 6;
+ int NOT = 7;
+ int NUMBER = 8;
+ int DIGIT = 9;
+ int STRINGCONSTANT = 10;
+ int VAR = 11;
+ int IDENTIFIER = 12;
+ int OPERATOR = 13;
+ int ANYCHAR = 14;
+ int LOCASE = 15;
+ int HICASE = 16;
+ int SPECIALCHAR = 17;
+
+ int DEFAULT = 0;
+
+ String[] tokenImage = {
+ "<EOF>",
+ "\" \"",
+ "\"\\t\"",
+ "\"\\n\"",
+ "\"\\r\"",
+ "\"\\f\"",
+ "<SINGLE_LINE_COMMENT>",
+ "\"not\"",
+ "<NUMBER>",
+ "<DIGIT>",
+ "<STRINGCONSTANT>",
+ "<VAR>",
+ "<IDENTIFIER>",
+ "<OPERATOR>",
+ "<ANYCHAR>",
+ "<LOCASE>",
+ "<HICASE>",
+ "<SPECIALCHAR>",
+ "\":-\"",
+ "\".\"",
+ "\",\"",
+ "\"(\"",
+ "\")\"",
+ "\"[]\"",
+ "\"[\"",
+ "\"]\"",
+ "\"|\"",
+ };
+
+}
Added: trunk/src/dl-learner/org/dllearner/parser/PrologParserTokenManager.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/parser/PrologParserTokenManager.java (rev 0)
+++ trunk/src/dl-learner/org/dllearner/parser/PrologParserTokenManager.java 2008-02-08 08:59:26 UTC (rev 527)
@@ -0,0 +1,578 @@
+/* Generated By:JavaCC: Do not edit this line. PrologParserTokenManager.java */
+package org.dllearner.parser;
+
+public @SuppressWarnings("all") class PrologParserTokenManager implements PrologParserConstants
+{
+ public java.io.PrintStream debugStream = System.out;
+ public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
+private final int jjStopStringLiteralDfa_0(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x80L) != 0L)
+ {
+ jjmatchedKind = 12;
+ return 18;
+ }
+ return -1;
+ case 1:
+ if ((active0 & 0x80L) != 0L)
+ {
+ jjmatchedKind = 12;
+ jjmatchedPos = 1;
+ return 18;
+ }
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_0(int pos, long active0)
+{
+ return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
+}
+private final int jjStopAtPos(int pos, int kind)
+{
+ jjmatchedKind = kind;
+ jjmatchedPos = pos;
+ return pos + 1;
+}
+private final int jjStartNfaWithStates_0(int pos, int kind, int state)
+{
+ jjmatchedKind = kind;
+ jjmatchedPos = pos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return pos + 1; }
+ return jjMoveNfa_0(state, pos + 1);
+}
+private final int jjMoveStringLiteralDfa0_0()
+{
+ switch(curChar)
+ {
+ case 40:
+ return jjStopAtPos(0, 21);
+ case 41:
+ return jjStopAtPos(0, 22);
+ case 44:
+ return jjStopAtPos(0, 20);
+ case 46:
+ return jjStopAtPos(0, 19);
+ case 58:
+ return jjMoveStringLiteralDfa1_0(0x40000L);
+ case 91:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_0(0x800000L);
+ case 93:
+ return jjStopAtPos(0, 25);
+ case 110:
+ return jjMoveStringLiteralDfa1_0(0x80L);
+ case 124:
+ return jjStopAtPos(0, 26);
+ default :
+ return jjMoveNfa_0(0, 0);
+ }
+}
+private final int jjMoveStringLiteralDfa1_0(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_0(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 45:
+ if ((active0 & 0x40000L) != 0L)
+ return jjStopAtPos(1, 18);
+ break;
+ case 93:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStopAtPos(1, 23);
+ break;
+ case 111:
+ return jjMoveStringLiteralDfa2_0(active0, 0x80L);
+ default :
+ break;
+ }
+ return jjStartNfa_0(0, active0);
+}
+private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_0(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_0(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 116:
+ if ((active0 & 0x80L) != 0L)
+ return jjStartNfaWithStates_0(2, 7, 18);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_0(1, active0);
+}
+private final void jjCheckNAdd(int state)
+{
+ if (jjrounds[state] != jjround)
+ {
+ jjstateSet[jjnewStateCnt++] = state;
+ jjrounds[state] = jjround;
+ }
+}
+private final void jjAddStates(int start, int end)
+{
+ do {
+ jjstateSet[jjnewStateCnt++] = jjnextStates[start];
+ } while (start++ != end);
+}
+private final void jjCheckNAddTwoStates(int state1, int state2)
+{
+ jjCheckNAdd(state1);
+ jjCheckNAdd(state2);
+}
+private final void jjCheckNAddStates(int start, int end)
+{
+ do {
+ jjCheckNAdd(jjnextStates[start]);
+ } while (start++ != end);
+}
+private final void jjCheckNAddStates(int start)
+{
+ jjCheckNAdd(jjnextStates[start]);
+ jjCheckNAdd(jjnextStates[start + 1]);
+}
+static final long[] jjbitVec0 = {
+ 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+private final int jjMoveNfa_0(int startState, int curPos)
+{
+ int[] nextStates;
+ int startsAt = 0;
+ jjnewStateCnt = 18;
+ int i = 1;
+ jjstateSet[0] = startState;
+ int j, kind = 0x7fffffff;
+ for (;;)
+ {
+ if (++jjround == 0x7fffffff)
+ ReInitRounds();
+ if (curChar < 64)
+ {
+ long l = 1L << curChar;
+ MatchLoop: do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 18:
+ if ((0x53ff2c0000000000L & l) != 0L)
+ {
+ if (kind > 13)
+ kind = 13;
+ jjCheckNAdd(17);
+ }
+ if ((0x3ff000000000000L & l) != 0L)
+ {
+ if (kind > 12)
+ kind = 12;
+ jjCheckNAdd(15);
+ }
+ break;
+ case 0:
+ if ((0x3ff000000000000L & l) != 0L)
+ {
+ if (kind > 8)
+ kind = 8;
+ jjCheckNAdd(5);
+ }
+ else if ((0x50002c0000000000L & l) != 0L)
+ {
+ if (kind > 13)
+ kind = 13;
+ jjCheckNAdd(17);
+ }
+ else if (curChar == 34)
+ jjCheckNAddTwoStates(10, 11);
+ else if (curChar == 39)
+ jjCheckNAddTwoStates(7, 8);
+ else if (curChar == 37)
+ jjCheckNAddStates(0, 2);
+ break;
+ case 1:
+ if ((0xffffffffffffdbffL & l) != 0L)
+ jjCheckNAddStates(0, 2);
+ break;
+ case 2:
+ if ((0x2400L & l) != 0L && kind > 6)
+ kind = 6;
+ break;
+ case 3:
+ if (curChar == 10 && kind > 6)
+ kind = 6;
+ break;
+ case 4:
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 3;
+ break;
+ case 5:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 8)
+ kind = 8;
+ jjCheckNAdd(5);
+ break;
+ case 6:
+ if (curChar == 39)
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 7:
+ if ((0xffffff7fffffdbffL & l) != 0L)
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 8:
+ if (curChar == 39 && kind > 10)
+ kind = 10;
+ break;
+ case 9:
+ if (curChar == 34)
+ jjCheckNAddTwoStates(10, 11);
+ break;
+ case 10:
+ if ((0xffffff7fffffdbffL & l) != 0L)
+ jjCheckNAddTwoStates(10, 11);
+ break;
+ case 11:
+ if (curChar == 34 && kind > 10)
+ kind = 10;
+ break;
+ case 13:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 11)
+ kind = 11;
+ jjstateSet[jjnewStateCnt++] = 13;
+ break;
+ case 15:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 12)
+ kind = 12;
+ jjCheckNAdd(15);
+ break;
+ case 16:
+ if ((0x50002c0000000000L & l) == 0L)
+ break;
+ if (kind > 13)
+ kind = 13;
+ jjCheckNAdd(17);
+ break;
+ case 17:
+ if ((0x53ff2c0000000000L & l) == 0L)
+ break;
+ if (kind > 13)
+ kind = 13;
+ jjCheckNAdd(17);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ MatchLoop: do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 18:
+ if ((0x7fffffec7fffffeL & l) != 0L)
+ {
+ if (kind > 13)
+ kind = 13;
+ jjCheckNAdd(17);
+ }
+ if ((0x7fffffe87fffffeL & l) != 0L)
+ {
+ if (kind > 12)
+ kind = 12;
+ jjCheckNAdd(15);
+ }
+ break;
+ case 0:
+ if ((0x7fffffe40000000L & l) != 0L)
+ {
+ if (kind > 13)
+ kind = 13;
+ jjCheckNAdd(17);
+ }
+ else if ((0x87fffffeL & l) != 0L)
+ {
+ if (kind > 11)
+ kind = 11;
+ jjCheckNAdd(13);
+ }
+ if ((0x7fffffe00000000L & l) != 0L)
+ {
+ if (kind > 12)
+ kind = 12;
+ jjCheckNAdd(15);
+ }
+ break;
+ case 1:
+ jjAddStates(0, 2);
+ break;
+ case 7:
+ if ((0xffffffffefffffffL & l) != 0L)
+ jjAddStates(3, 4);
+ break;
+ case 10:
+ if ((0xffffffffefffffffL & l) != 0L)
+ jjAddStates(5, 6);
+ break;
+ case 12:
+ if ((0x87fffffeL & l) == 0L)
+ break;
+ if (kind > 11)
+ kind = 11;
+ jjCheckNAdd(13);
+ break;
+ case 13:
+ if ((0x7fffffe87fffffeL & l) == 0L)
+ break;
+ if (kind > 11)
+ kind = 11;
+ jjCheckNAdd(13);
+ break;
+ case 14:
+ if ((0x7fffffe00000000L & l) == 0L)
+ break;
+ if (kind > 12)
+ kind = 12;
+ jjCheckNAdd(15);
+ break;
+ case 15:
+ if ((0x7fffffe87fffffeL & l) == 0L)
+ break;
+ if (kind > 12)
+ kind = 12;
+ jjCheckNAdd(15);
+ break;
+ case 16:
+ if ((0x7fffffe40000000L & l) == 0L)
+ break;
+ if (kind > 13)
+ kind = 13;
+ jjCheckNAdd(17);
+ break;
+ case 17:
+ if ((0x7fffffec7fffffeL & l) == 0L)
+ break;
+ if (kind > 13)
+ kind = 13;
+ jjCheckNAdd(17);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int i2 = (curChar & 0xff) >> 6;
+ long l2 = 1L << (curChar & 077);
+ MatchLoop: do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 1:
+ if ((jjbitVec0[i2] & l2) != 0L)
+ jjAddStates(0, 2);
+ break;
+ case 7:
+ if ((jjbitVec0[i2] & l2) != 0L)
+ jjAddStates(3, 4);
+ break;
+ case 10:
+ if ((jjbitVec0[i2] & l2) != 0L)
+ jjAddStates(5, 6);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 18 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+static final int[] jjnextStates = {
+ 1, 2, 4, 7, 8, 10, 11,
+};
+public static final String[] jjstrLiteralImages = {
+"", null, null, null, null, null, null, "\156\157\164", null, null, null, null,
+null, null, null, null, null, null, "\72\55", "\56", "\54", "\50", "\51",
+"\133\135", "\133", "\135", "\174", };
+public static final String[] lexStateNames = {
+ "DEFAULT",
+};
+static final long[] jjtoToken = {
+ 0x7fc3d81L,
+};
+static final long[] jjtoSkip = {
+ 0x7eL,
+};
+static final long[] jjtoSpecial = {
+ 0x40L,
+};
+protected SimpleCharStream input_stream;
+private final int[] jjrounds = new int[18];
+private final int[] jjstateSet = new int[36];
+protected char curChar;
+public PrologParserTokenManager(SimpleCharStream stream){
+ if (SimpleCharStream.staticFlag)
+ throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
+ input_stream = stream;
+}
+public PrologParserTokenManager(SimpleCharStream stream, int lexState){
+ this(stream);
+ SwitchTo(lexState);
+}
+public void ReInit(SimpleCharStream stream)
+{
+ jjmatchedPos = jjnewStateCnt = 0;
+ curLexState = defaultLexState;
+ input_stream = stream;
+ ReInitRounds();
+}
+private final void ReInitRounds()
+{
+ int i;
+ jjround = 0x80000001;
+ for (i = 18; i-- > 0;)
+ jjrounds[i] = 0x80000000;
+}
+public void ReInit(SimpleCharStream stream, int lexState)
+{
+ ReInit(stream);
+ SwitchTo(lexState);
+}
+public void SwitchTo(int lexState)
+{
+ if (lexState >= 1 || lexState < 0)
+ throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
+ else
+ curLexState = lexState;
+}
+
+protected Token jjFillToken()
+{
+ Token t = Token.newToken(jjmatchedKind);
+ t.kind = jjmatchedKind;
+ String im = jjstrLiteralImages[jjmatchedKind];
+ t.image = (im == null) ? input_stream.GetImage() : im;
+ t.beginLine = input_stream.getBeginLine();
+ t.beginColumn = input_stream.getBeginColumn();
+ t.endLine = input_stream.getEndLine();
+ t.endColumn = input_stream.getEndColumn();
+ return t;
+}
+
+int curLexState = 0;
+int defaultLexState = 0;
+int jjnewStateCnt;
+int jjround;
+int jjmatchedPos;
+int jjmatchedKind;
+
+public Token getNextToken()
+{
+ int kind;
+ Token specialToken = null;
+ Token matchedToken;
+ int curPos = 0;
+
+ EOFLoop :
+ for (;;)
+ {
+ try
+ {
+ curChar = input_stream.BeginToken();
+ }
+ catch(java.io.IOException e)
+ {
+ jjmatchedKind = 0;
+ matchedToken = jjFillToken();
+ matchedToken.specialToken = specialToken;
+ return matchedToken;
+ }
+
+ try { input_stream.backup(0);
+ while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
+ curChar = input_stream.BeginToken();
+ }
+ catch (java.io.IOException e1) { continue EOFLoop; }
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_0();
+ if (jjmatchedKind != 0x7fffffff)
+ {
+ if (jjmatchedPos + 1 < curPos)
+ input_stream.backup(curPos - jjmatchedPos - 1);
+ if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+ {
+ matchedToken = jjFillToken();
+ matchedToken.specialToken = specialToken;
+ return matchedToken;
+ }
+ else
+ {
+ if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+ {
+ matchedToken = jjFillToken();
+ if (specialToken == null)
+ specialToken = matchedToken;
+ else
+ {
+ matchedToken.specialToken = specialToken;
+ specialToken = (specialToken.next = matchedToken);
+ }
+ }
+ continue EOFLoop;
+ }
+ }
+ int error_line = input_stream.getEndLine();
+ int error_column = input_stream.getEndColumn();
+ String error_after = null;
+ boolean EOFSeen = false;
+ try { input_stream.readChar(); input_stream.backup(1); }
+ catch (java.io.IOException e1) {
+ EOFSeen = true;
+ error_after = curPos <= 1 ? "" : input_stream.GetImage();
+ if (curChar == '\n' || curChar == '\r') {
+ error_line++;
+ error_column = 0;
+ }
+ else
+ error_column++;
+ }
+ if (!EOFSeen) {
+ input_stream.backup(1);
+ error_after = curPos <= 1 ? "" : input_stream.GetImage();
+ }
+ throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
+ }
+}
+
+}
Modified: trunk/src/dl-learner/org/dllearner/parser/package.html
===================================================================
--- trunk/src/dl-learner/org/dllearner/parser/package.html 2008-02-08 08:57:28 UTC (rev 526)
+++ trunk/src/dl-learner/org/dllearner/parser/package.html 2008-02-08 08:59:26 UTC (rev 527)
@@ -2,6 +2,6 @@
<html>
<head></head>
<body bgcolor="white">
-<p>DL-Learner configuration file parser.</p>
+<p>DL-Learner parsers. Contains a conf file parser, a KB file parser and a Prolog parser. All generated by JavaCC.</p>
</body>
</html>
\ No newline at end of file
Added: trunk/src/dl-learner/org/dllearner/parser/prolog.jj
===================================================================
--- trunk/src/dl-learner/org/dllearner/parser/prolog.jj (rev 0)
+++ trunk/src/dl-learner/org/dllearner/parser/prolog.jj 2008-02-08 08:59:26 UTC (rev 527)
@@ -0,0 +1,212 @@
+/**
+ * Copyright (C) 2007-2008, Jens Lehmann
+ *
+ * This file is part of DL-Learner.
+ *
+ * DL-Learner is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * DL-Learner is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * @author Sebastian Bader
+ *
+ */
+
+options {
+ LOOKAHEAD = 1;
+ STATIC = false;
+}
+
+PARSER_BEGIN(PrologParser)
+
+package org.dllearner.parser;
+
+public class PrologParser {
+ public PrologParser() {
+ this(new java.io.StringReader(""));
+ }
+
+ public org.dllearner.prolog.Term parseTerm(String src) throws ParseException {
+ reinitToString(src);
+ return term();
+ }
+
+ public java.util.ArrayList parseTermList(String src) throws ParseException {
+ reinitToString(src);
+ return termList();
+ }
+
+ public org.dllearner.prolog.Atom parseAtom(String src) throws ParseException {
+ reinitToString(src);
+ return atom();
+ }
+
+ public org.dllearner.prolog.Clause parseClause(String src) throws ParseException {
+ reinitToString(src);
+ return clause();
+ }
+
+ public org.dllearner.prolog.Program parseProgram(String src) throws ParseException {
+ reinitToString(src);
+ return program();
+ }
+
+ private void reinitToString(String src) {
+ ReInit(new java.io.StringReader(src));
+ }
+}
+
+PARSER_END(PrologParser)
+
+SKIP : { /* WHITE SPACE */
+ " " | "\t" | "\n" | "\r" | "\f"
+}
+
+SPECIAL_TOKEN : { /* COMMENTS */
+ <SINGLE_LINE_COMMENT: "%" (~["\n","\r"])* ("\n"|"\r"|"\r\n")>
+}
+
+TOKEN : /* RESERVED WORDS AND LITERALS */
+{
+ < NOT: "not" >
+}
+
+TOKEN : /* constants */
+{
+ < NUMBER: (<DIGIT>)+>
+ | < #DIGIT: ["0" - "9"] >
+ | < STRINGCONSTANT: ("'" (~["'","\\","\n","\r"])* "'" | "\"" (~["'","\\","\n","\r"])* "\"" ) >
+}
+
+TOKEN : /* Function names */
+{
+ < VAR: ((<HICASE> | "_" ) (<ANYCHAR>)* ) >
+ | < IDENTIFIER: (<LOCASE>) (<ANYCHAR>)* >
+ | < OPERATOR: (<LOCASE> | <SPECIALCHAR>) (<ANYCHAR> | <SPECIALCHAR>)* >
+ | < #ANYCHAR: (<LOCASE> | <HICASE> | <DIGIT> | "_" ) >
+ | < #LOCASE: ["a"-"z"] >
+ | < #HICASE: ["A"-"Z"] >
+ | < #SPECIALCHAR: "-" | "+" | "*" | "<" | ">" | "^" >
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+org.dllearner.prolog.Program program() : {
+ org.dllearner.prolog.Program p = new org.dllearner.prolog.Program();
+ org.dllearner.prolog.Clause c;
+}{
+ ( c = clause() { p.addClause(c); } )+ <EOF> { return p; }
+}
+
+org.dllearner.prolog.Clause clause() : {
+ org.dllearner.prolog.Atom head;
+ org.dllearner.prolog.Body body = null;
+}{
+ head = atom() [ ":-" body = body() ] "." { return new org.dllearner.prolog.Clause(head, body); }
+}
+
+
+org.dllearner.prolog.Body body() : {
+ org.dllearner.prolog.Literal l;
+ org.dllearner.prolog.Body b = new org.dllearner.prolog.Body();
+}{
+ l = literal() { b.addLiteral(l); }
+ ( "," l = literal() { b.addLiteral(l); } )*
+ { return b; }
+}
+
+org.dllearner.prolog.Atom atom() : {
+ Token atom;
+ java.util.ArrayList arguments = new java.util.ArrayList() ;
+}{
+ atom = <IDENTIFIER> [ "(" arguments = termList() ")" ] { return new org.dllearner.prolog.Atom(atom.image, arguments); }
+}
+
+org.dllearner.prolog.Literal literal() : {
+ org.dllearner.prolog.Atom a;
+}{
+ a = atom() { return new org.dllearner.prolog.Literal(a, true); }
+ | <NOT> a = atom() { return new org.dllearner.prolog.Literal(a, false); }
+}
+
+
+org.dllearner.prolog.Term term() : {
+ Token v;
+ String o;
+ Token f;
+ java.util.ArrayList arguments = null;
+ org.dllearner.prolog.Term t1, t2;
+}{
+ LOOKAHEAD(2147483647) o = prefixOp() t2 = simpleTerm() { return new org.dllearner.prolog.Function(o, t2); }
+ | LOOKAHEAD(2147483647) t1 = simpleTerm() o = infixOp() t2 = simpleTerm() { return new org.dllearner.prolog.Function(t1, o, t2); }
+ | LOOKAHEAD(2147483647) t1 = simpleTerm() o = postfixOp() { return new org.dllearner.prolog.Function(t1, o); }
+ | LOOKAHEAD(2147483647) t1 = simpleTerm() { return t1; }
+}
+
+
+org.dllearner.prolog.Term simpleTerm() : {
+ Token v;
+ String o;
+ Token f;
+ java.util.ArrayList arguments = null;
+ org.dllearner.prolog.Term l;
+}{
+ LOOKAHEAD(2) f = <IDENTIFIER> "(" arguments = termList() ")" { return new org.dllearner.prolog.Function(f.image, arguments); }
+ | LOOKAHEAD(2) f = <IDENTIFIER> { return new org.dllearner.prolog.PrologConstant(f.image); }
+ | v = <VAR> { return new org.dllearner.prolog.Variable(v.image); }
+ | v = <NUMBER> { return new org.dllearner.prolog.Number(v.image); }
+ | v = <STRINGCONSTANT> { return new org.dllearner.prolog.StringConstant(v.image); }
+ | l = list() { return l; }
+}
+
+
+String prefixOp() : {
+ Token f;
+}{
+ f = <OPERATOR> { return f.image; }
+}
+
+
+String infixOp() : {
+ Token f;
+}{
+ f = <OPERATOR> { return f.image; }
+}
+
+
+String postfixOp() : {
+ Token f;
+}{
+ f = <OPERATOR> { return f.image; }
+}
+
+
+java.util.ArrayList termList() : {
+ org.dllearner.prolog.Term t;
+ java.util.ArrayList l = new java.util.ArrayList();
+}{
+ t = term() { l.add(t); }
+ ( "," t = term() { l.add(t); } )*
+ { return l; }
+}
+
+org.dllearner.prolog.List list() : {
+ java.util.ArrayList content = null;
+ org.dllearner.prolog.Term head;
+ org.dllearner.prolog.List l;
+}{
+ "[]" { return new org.dllearner.prolog.List(); }
+ | LOOKAHEAD(3) "[" head = term() "]" { return new org.dllearner.prolog.List(head, null); }
+ | LOOKAHEAD(3) "[" head = term() "|" l = list() "]" { return new org.dllearner.prolog.List(head, l); }
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
