cariboujs 2.0.7 → 2.0.9

package/clif/CLIFParser.js

@@ -0,0 +1,2440 @@
+// Generated from CLIF.g4 by ANTLR 4.13.2
+// jshint ignore: start
+import antlr4 from 'antlr4';
+import CLIFListener from './CLIFListener.js';
+import CLIFVisitor from './CLIFVisitor.js';
+
+const serializedATN = [4,1,28,229,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,
+4,2,5,7,5,2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,
+2,13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
+20,7,20,1,0,5,0,44,8,0,10,0,12,0,47,9,0,1,0,1,0,1,1,1,1,5,1,53,8,1,10,1,
+12,1,56,9,1,1,2,1,2,1,3,1,3,1,4,1,4,3,4,64,8,4,1,5,1,5,1,5,1,5,1,5,1,5,1,
+5,1,5,1,5,1,5,1,5,1,5,3,5,78,8,5,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8,
+1,8,1,8,3,8,92,8,8,1,9,1,9,3,9,96,8,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,
+1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,3,10,114,8,10,1,11,1,11,1,12,
+1,12,1,12,5,12,121,8,12,10,12,12,12,124,9,12,1,12,1,12,1,12,1,12,1,12,1,
+12,1,12,1,12,1,12,1,12,1,12,1,12,3,12,138,8,12,1,13,1,13,1,13,3,13,143,8,
+13,1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,14,1,14,3,14,155,8,14,1,14,
+1,14,1,14,5,14,160,8,14,10,14,12,14,163,9,14,1,14,1,14,1,15,1,15,1,15,1,
+15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,1,16,5,16,179,8,16,10,16,12,16,182,
+9,16,1,16,3,16,185,8,16,1,16,5,16,188,8,16,10,16,12,16,191,9,16,1,16,1,16,
+1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,3,17,206,8,17,1,17,
+3,17,209,8,17,1,18,4,18,212,8,18,11,18,12,18,213,1,19,1,19,1,19,3,19,219,
+8,19,1,20,1,20,1,20,1,20,3,20,225,8,20,1,20,1,20,1,20,0,0,21,0,2,4,6,8,10,
+12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,0,5,2,0,6,6,8,8,2,0,9,9,25,
+25,1,0,11,12,1,0,13,14,1,0,15,16,237,0,45,1,0,0,0,2,54,1,0,0,0,4,57,1,0,
+0,0,6,59,1,0,0,0,8,63,1,0,0,0,10,77,1,0,0,0,12,79,1,0,0,0,14,81,1,0,0,0,
+16,91,1,0,0,0,18,95,1,0,0,0,20,113,1,0,0,0,22,115,1,0,0,0,24,137,1,0,0,0,
+26,139,1,0,0,0,28,148,1,0,0,0,30,166,1,0,0,0,32,172,1,0,0,0,34,208,1,0,0,
+0,36,211,1,0,0,0,38,218,1,0,0,0,40,220,1,0,0,0,42,44,3,38,19,0,43,42,1,0,
+0,0,44,47,1,0,0,0,45,43,1,0,0,0,45,46,1,0,0,0,46,48,1,0,0,0,47,45,1,0,0,
+0,48,49,5,0,0,1,49,1,1,0,0,0,50,53,3,10,5,0,51,53,5,7,0,0,52,50,1,0,0,0,
+52,51,1,0,0,0,53,56,1,0,0,0,54,52,1,0,0,0,54,55,1,0,0,0,55,3,1,0,0,0,56,
+54,1,0,0,0,57,58,7,0,0,0,58,5,1,0,0,0,59,60,7,1,0,0,60,7,1,0,0,0,61,64,3,
+4,2,0,62,64,3,6,3,0,63,61,1,0,0,0,63,62,1,0,0,0,64,9,1,0,0,0,65,78,3,8,4,
+0,66,67,5,1,0,0,67,68,3,12,6,0,68,69,3,2,1,0,69,70,5,2,0,0,70,78,1,0,0,0,
+71,72,5,1,0,0,72,73,5,23,0,0,73,74,5,8,0,0,74,75,3,10,5,0,75,76,5,2,0,0,
+76,78,1,0,0,0,77,65,1,0,0,0,77,66,1,0,0,0,77,71,1,0,0,0,78,11,1,0,0,0,79,
+80,3,10,5,0,80,13,1,0,0,0,81,82,5,1,0,0,82,83,5,10,0,0,83,84,3,10,5,0,84,
+85,3,10,5,0,85,86,5,2,0,0,86,15,1,0,0,0,87,92,3,18,9,0,88,92,3,24,12,0,89,
+92,3,26,13,0,90,92,3,30,15,0,91,87,1,0,0,0,91,88,1,0,0,0,91,89,1,0,0,0,91,
+90,1,0,0,0,92,17,1,0,0,0,93,96,3,14,7,0,94,96,3,20,10,0,95,93,1,0,0,0,95,
+94,1,0,0,0,96,19,1,0,0,0,97,98,5,1,0,0,98,99,3,22,11,0,99,100,3,2,1,0,100,
+101,5,2,0,0,101,114,1,0,0,0,102,103,5,1,0,0,103,104,3,10,5,0,104,105,5,1,
+0,0,105,106,5,18,0,0,106,107,5,1,0,0,107,108,3,8,4,0,108,109,3,10,5,0,109,
+110,5,2,0,0,110,111,5,2,0,0,111,112,5,2,0,0,112,114,1,0,0,0,113,97,1,0,0,
+0,113,102,1,0,0,0,114,21,1,0,0,0,115,116,3,10,5,0,116,23,1,0,0,0,117,118,
+5,1,0,0,118,122,7,2,0,0,119,121,3,16,8,0,120,119,1,0,0,0,121,124,1,0,0,0,
+122,120,1,0,0,0,122,123,1,0,0,0,123,125,1,0,0,0,124,122,1,0,0,0,125,138,
+5,2,0,0,126,127,5,1,0,0,127,128,7,3,0,0,128,129,3,16,8,0,129,130,3,16,8,
+0,130,131,5,2,0,0,131,138,1,0,0,0,132,133,5,1,0,0,133,134,5,17,0,0,134,135,
+3,16,8,0,135,136,5,2,0,0,136,138,1,0,0,0,137,117,1,0,0,0,137,126,1,0,0,0,
+137,132,1,0,0,0,138,25,1,0,0,0,139,140,5,1,0,0,140,142,7,4,0,0,141,143,3,
+6,3,0,142,141,1,0,0,0,142,143,1,0,0,0,143,144,1,0,0,0,144,145,3,28,14,0,
+145,146,3,16,8,0,146,147,5,2,0,0,147,27,1,0,0,0,148,161,5,1,0,0,149,160,
+3,6,3,0,150,160,5,7,0,0,151,154,5,1,0,0,152,155,3,6,3,0,153,155,5,7,0,0,
+154,152,1,0,0,0,154,153,1,0,0,0,155,156,1,0,0,0,156,157,3,10,5,0,157,158,
+5,2,0,0,158,160,1,0,0,0,159,149,1,0,0,0,159,150,1,0,0,0,159,151,1,0,0,0,
+160,163,1,0,0,0,161,159,1,0,0,0,161,162,1,0,0,0,162,164,1,0,0,0,163,161,
+1,0,0,0,164,165,5,2,0,0,165,29,1,0,0,0,166,167,5,1,0,0,167,168,5,23,0,0,
+168,169,5,9,0,0,169,170,3,16,8,0,170,171,5,2,0,0,171,31,1,0,0,0,172,173,
+5,1,0,0,173,174,5,22,0,0,174,184,3,6,3,0,175,176,5,1,0,0,176,180,5,21,0,
+0,177,179,3,8,4,0,178,177,1,0,0,0,179,182,1,0,0,0,180,178,1,0,0,0,180,181,
+1,0,0,0,181,183,1,0,0,0,182,180,1,0,0,0,183,185,5,2,0,0,184,175,1,0,0,0,
+184,185,1,0,0,0,185,189,1,0,0,0,186,188,3,38,19,0,187,186,1,0,0,0,188,191,
+1,0,0,0,189,187,1,0,0,0,189,190,1,0,0,0,190,192,1,0,0,0,191,189,1,0,0,0,
+192,193,5,2,0,0,193,33,1,0,0,0,194,209,3,16,8,0,195,209,3,32,16,0,196,197,
+5,1,0,0,197,198,5,20,0,0,198,199,3,6,3,0,199,200,5,2,0,0,200,209,1,0,0,0,
+201,202,5,1,0,0,202,203,5,23,0,0,203,205,5,9,0,0,204,206,3,38,19,0,205,204,
+1,0,0,0,205,206,1,0,0,0,206,207,1,0,0,0,207,209,5,2,0,0,208,194,1,0,0,0,
+208,195,1,0,0,0,208,196,1,0,0,0,208,201,1,0,0,0,209,35,1,0,0,0,210,212,3,
+34,17,0,211,210,1,0,0,0,212,213,1,0,0,0,213,211,1,0,0,0,213,214,1,0,0,0,
+214,37,1,0,0,0,215,219,3,32,16,0,216,219,3,40,20,0,217,219,3,36,18,0,218,
+215,1,0,0,0,218,216,1,0,0,0,218,217,1,0,0,0,219,39,1,0,0,0,220,221,5,1,0,
+0,221,222,5,19,0,0,222,224,3,6,3,0,223,225,3,36,18,0,224,223,1,0,0,0,224,
+225,1,0,0,0,225,226,1,0,0,0,226,227,5,2,0,0,227,41,1,0,0,0,22,45,52,54,63,
+77,91,95,113,122,137,142,154,159,161,180,184,189,205,208,213,218,224];
+
+
+const atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
+
+const decisionsToDFA = atn.decisionToState.map( (ds, index) => new antlr4.dfa.DFA(ds, index) );
+
+const sharedContextCache = new antlr4.atn.PredictionContextCache();
+
+export default class CLIFParser extends antlr4.Parser {
+
+    static grammarFileName = "CLIF.g4";
+    static literalNames = [ null, "'('", "')'", "'''", "'\"'", "'\\'", null, 
+                            null, null, null, "'='", "'and'", "'or'", "'iff'", 
+                            "'if'", "'forall'", "'exists'", "'not'", "'cl-roleset'", 
+                            "'cl-text'", "'cl-imports'", "'cl-excludes'", 
+                            "'cl-module'", "'cl-comment'", "'cl-prefix'" ];
+    static symbolicNames = [ null, "OPEN", "CLOSE", "STRINGQUOTE", "NAMEQUOTE", 
+                             "BACKSLASH", "NUMERAL", "SEQMARK", "QUOTEDSTRING", 
+                             "ENCLOSEDNAME", "EQUAL", "AND", "OR", "IFF", 
+                             "IF", "FORALL", "EXISTS", "NOT", "CL_ROLESET", 
+                             "CL_TEXT", "CL_IMPORTS", "CL_EXCLUDES", "CL_MODULE", 
+                             "CL_COMMENT", "CL_PREFIX", "NAMECHARSEQUENCE", 
+                             "WHITE", "BLOCKCOMMENT", "LineComment" ];
+    static ruleNames = [ "start_", "termseq", "interpretedname", "interpretablename", 
+                         "name", "term", "operator_", "equation", "sentence", 
+                         "atomsent", "atom", "predicate", "boolsent", "quantsent", 
+                         "boundlist", "commentsent", "module", "phrase", 
+                         "text_", "cltext", "namedtext" ];
+
+    constructor(input) {
+        super(input);
+        this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
+        this.ruleNames = CLIFParser.ruleNames;
+        this.literalNames = CLIFParser.literalNames;
+        this.symbolicNames = CLIFParser.symbolicNames;
+    }
+
+
+
+	start_() {
+	    let localctx = new Start_Context(this, this._ctx, this.state);
+	    this.enterRule(localctx, 0, CLIFParser.RULE_start_);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 45;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===1) {
+	            this.state = 42;
+	            this.cltext();
+	            this.state = 47;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 48;
+	        this.match(CLIFParser.EOF);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	termseq() {
+	    let localctx = new TermseqContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 2, CLIFParser.RULE_termseq);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 54;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while((((_la) & ~0x1f) === 0 && ((1 << _la) & 33555394) !== 0)) {
+	            this.state = 52;
+	            this._errHandler.sync(this);
+	            switch(this._input.LA(1)) {
+	            case 1:
+	            case 6:
+	            case 8:
+	            case 9:
+	            case 25:
+	                this.state = 50;
+	                this.term();
+	                break;
+	            case 7:
+	                this.state = 51;
+	                this.match(CLIFParser.SEQMARK);
+	                break;
+	            default:
+	                throw new antlr4.error.NoViableAltException(this);
+	            }
+	            this.state = 56;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	interpretedname() {
+	    let localctx = new InterpretednameContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 4, CLIFParser.RULE_interpretedname);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 57;
+	        _la = this._input.LA(1);
+	        if(!(_la===6 || _la===8)) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	interpretablename() {
+	    let localctx = new InterpretablenameContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 6, CLIFParser.RULE_interpretablename);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 59;
+	        _la = this._input.LA(1);
+	        if(!(_la===9 || _la===25)) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	name() {
+	    let localctx = new NameContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 8, CLIFParser.RULE_name);
+	    try {
+	        this.state = 63;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 6:
+	        case 8:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 61;
+	            this.interpretedname();
+	            break;
+	        case 9:
+	        case 25:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 62;
+	            this.interpretablename();
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	term() {
+	    let localctx = new TermContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 10, CLIFParser.RULE_term);
+	    try {
+	        this.state = 77;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,4,this._ctx);
+	        switch(la_) {
+	        case 1:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 65;
+	            this.name();
+	            break;
+
+	        case 2:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 66;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 67;
+	            this.operator_();
+	            this.state = 68;
+	            this.termseq();
+	            this.state = 69;
+	            this.match(CLIFParser.CLOSE);
+	            break;
+
+	        case 3:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 71;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 72;
+	            this.match(CLIFParser.CL_COMMENT);
+	            this.state = 73;
+	            this.match(CLIFParser.QUOTEDSTRING);
+	            this.state = 74;
+	            this.term();
+	            this.state = 75;
+	            this.match(CLIFParser.CLOSE);
+	            break;
+
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	operator_() {
+	    let localctx = new Operator_Context(this, this._ctx, this.state);
+	    this.enterRule(localctx, 12, CLIFParser.RULE_operator_);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 79;
+	        this.term();
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	equation() {
+	    let localctx = new EquationContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 14, CLIFParser.RULE_equation);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 81;
+	        this.match(CLIFParser.OPEN);
+	        this.state = 82;
+	        this.match(CLIFParser.EQUAL);
+	        this.state = 83;
+	        this.term();
+	        this.state = 84;
+	        this.term();
+	        this.state = 85;
+	        this.match(CLIFParser.CLOSE);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	sentence() {
+	    let localctx = new SentenceContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 16, CLIFParser.RULE_sentence);
+	    try {
+	        this.state = 91;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,5,this._ctx);
+	        switch(la_) {
+	        case 1:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 87;
+	            this.atomsent();
+	            break;
+
+	        case 2:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 88;
+	            this.boolsent();
+	            break;
+
+	        case 3:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 89;
+	            this.quantsent();
+	            break;
+
+	        case 4:
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 90;
+	            this.commentsent();
+	            break;
+
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	atomsent() {
+	    let localctx = new AtomsentContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 18, CLIFParser.RULE_atomsent);
+	    try {
+	        this.state = 95;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,6,this._ctx);
+	        switch(la_) {
+	        case 1:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 93;
+	            this.equation();
+	            break;
+
+	        case 2:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 94;
+	            this.atom();
+	            break;
+
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	atom() {
+	    let localctx = new AtomContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 20, CLIFParser.RULE_atom);
+	    try {
+	        this.state = 113;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,7,this._ctx);
+	        switch(la_) {
+	        case 1:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 97;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 98;
+	            this.predicate();
+	            this.state = 99;
+	            this.termseq();
+	            this.state = 100;
+	            this.match(CLIFParser.CLOSE);
+	            break;
+
+	        case 2:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 102;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 103;
+	            this.term();
+	            this.state = 104;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 105;
+	            this.match(CLIFParser.CL_ROLESET);
+	            this.state = 106;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 107;
+	            this.name();
+	            this.state = 108;
+	            this.term();
+	            this.state = 109;
+	            this.match(CLIFParser.CLOSE);
+	            this.state = 110;
+	            this.match(CLIFParser.CLOSE);
+	            this.state = 111;
+	            this.match(CLIFParser.CLOSE);
+	            break;
+
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	predicate() {
+	    let localctx = new PredicateContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 22, CLIFParser.RULE_predicate);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 115;
+	        this.term();
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	boolsent() {
+	    let localctx = new BoolsentContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 24, CLIFParser.RULE_boolsent);
+	    var _la = 0;
+	    try {
+	        this.state = 137;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,9,this._ctx);
+	        switch(la_) {
+	        case 1:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 117;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 118;
+	            _la = this._input.LA(1);
+	            if(!(_la===11 || _la===12)) {
+	            this._errHandler.recoverInline(this);
+	            }
+	            else {
+	            	this._errHandler.reportMatch(this);
+	                this.consume();
+	            }
+	            this.state = 122;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            while(_la===1) {
+	                this.state = 119;
+	                this.sentence();
+	                this.state = 124;
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	            }
+	            this.state = 125;
+	            this.match(CLIFParser.CLOSE);
+	            break;
+
+	        case 2:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 126;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 127;
+	            _la = this._input.LA(1);
+	            if(!(_la===13 || _la===14)) {
+	            this._errHandler.recoverInline(this);
+	            }
+	            else {
+	            	this._errHandler.reportMatch(this);
+	                this.consume();
+	            }
+	            this.state = 128;
+	            this.sentence();
+	            this.state = 129;
+	            this.sentence();
+	            this.state = 130;
+	            this.match(CLIFParser.CLOSE);
+	            break;
+
+	        case 3:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 132;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 133;
+	            this.match(CLIFParser.NOT);
+	            this.state = 134;
+	            this.sentence();
+	            this.state = 135;
+	            this.match(CLIFParser.CLOSE);
+	            break;
+
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	quantsent() {
+	    let localctx = new QuantsentContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 26, CLIFParser.RULE_quantsent);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 139;
+	        this.match(CLIFParser.OPEN);
+	        this.state = 140;
+	        _la = this._input.LA(1);
+	        if(!(_la===15 || _la===16)) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	        this.state = 142;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(_la===9 || _la===25) {
+	            this.state = 141;
+	            this.interpretablename();
+	        }
+
+	        this.state = 144;
+	        this.boundlist();
+	        this.state = 145;
+	        this.sentence();
+	        this.state = 146;
+	        this.match(CLIFParser.CLOSE);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	boundlist() {
+	    let localctx = new BoundlistContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 28, CLIFParser.RULE_boundlist);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 148;
+	        this.match(CLIFParser.OPEN);
+	        this.state = 161;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while((((_la) & ~0x1f) === 0 && ((1 << _la) & 33555074) !== 0)) {
+	            this.state = 159;
+	            this._errHandler.sync(this);
+	            switch(this._input.LA(1)) {
+	            case 9:
+	            case 25:
+	                this.state = 149;
+	                this.interpretablename();
+	                break;
+	            case 7:
+	                this.state = 150;
+	                this.match(CLIFParser.SEQMARK);
+	                break;
+	            case 1:
+	                this.state = 151;
+	                this.match(CLIFParser.OPEN);
+	                this.state = 154;
+	                this._errHandler.sync(this);
+	                switch(this._input.LA(1)) {
+	                case 9:
+	                case 25:
+	                    this.state = 152;
+	                    this.interpretablename();
+	                    break;
+	                case 7:
+	                    this.state = 153;
+	                    this.match(CLIFParser.SEQMARK);
+	                    break;
+	                default:
+	                    throw new antlr4.error.NoViableAltException(this);
+	                }
+	                this.state = 156;
+	                this.term();
+	                this.state = 157;
+	                this.match(CLIFParser.CLOSE);
+	                break;
+	            default:
+	                throw new antlr4.error.NoViableAltException(this);
+	            }
+	            this.state = 163;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 164;
+	        this.match(CLIFParser.CLOSE);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	commentsent() {
+	    let localctx = new CommentsentContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 30, CLIFParser.RULE_commentsent);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 166;
+	        this.match(CLIFParser.OPEN);
+	        this.state = 167;
+	        this.match(CLIFParser.CL_COMMENT);
+	        this.state = 168;
+	        this.match(CLIFParser.ENCLOSEDNAME);
+	        this.state = 169;
+	        this.sentence();
+	        this.state = 170;
+	        this.match(CLIFParser.CLOSE);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	module() {
+	    let localctx = new ModuleContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 32, CLIFParser.RULE_module);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 172;
+	        this.match(CLIFParser.OPEN);
+	        this.state = 173;
+	        this.match(CLIFParser.CL_MODULE);
+	        this.state = 174;
+	        this.interpretablename();
+	        this.state = 184;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,15,this._ctx);
+	        if(la_===1) {
+	            this.state = 175;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 176;
+	            this.match(CLIFParser.CL_EXCLUDES);
+	            this.state = 180;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            while((((_la) & ~0x1f) === 0 && ((1 << _la) & 33555264) !== 0)) {
+	                this.state = 177;
+	                this.name();
+	                this.state = 182;
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	            }
+	            this.state = 183;
+	            this.match(CLIFParser.CLOSE);
+
+	        }
+	        this.state = 189;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===1) {
+	            this.state = 186;
+	            this.cltext();
+	            this.state = 191;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 192;
+	        this.match(CLIFParser.CLOSE);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	phrase() {
+	    let localctx = new PhraseContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 34, CLIFParser.RULE_phrase);
+	    var _la = 0;
+	    try {
+	        this.state = 208;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,18,this._ctx);
+	        switch(la_) {
+	        case 1:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 194;
+	            this.sentence();
+	            break;
+
+	        case 2:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 195;
+	            this.module();
+	            break;
+
+	        case 3:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 196;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 197;
+	            this.match(CLIFParser.CL_IMPORTS);
+	            this.state = 198;
+	            this.interpretablename();
+	            this.state = 199;
+	            this.match(CLIFParser.CLOSE);
+	            break;
+
+	        case 4:
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 201;
+	            this.match(CLIFParser.OPEN);
+	            this.state = 202;
+	            this.match(CLIFParser.CL_COMMENT);
+	            this.state = 203;
+	            this.match(CLIFParser.ENCLOSEDNAME);
+	            this.state = 205;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            if(_la===1) {
+	                this.state = 204;
+	                this.cltext();
+	            }
+
+	            this.state = 207;
+	            this.match(CLIFParser.CLOSE);
+	            break;
+
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	text_() {
+	    let localctx = new Text_Context(this, this._ctx, this.state);
+	    this.enterRule(localctx, 36, CLIFParser.RULE_text_);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 211; 
+	        this._errHandler.sync(this);
+	        var _alt = 1;
+	        do {
+	        	switch (_alt) {
+	        	case 1:
+	        		this.state = 210;
+	        		this.phrase();
+	        		break;
+	        	default:
+	        		throw new antlr4.error.NoViableAltException(this);
+	        	}
+	        	this.state = 213; 
+	        	this._errHandler.sync(this);
+	        	_alt = this._interp.adaptivePredict(this._input,19, this._ctx);
+	        } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER );
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	cltext() {
+	    let localctx = new CltextContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 38, CLIFParser.RULE_cltext);
+	    try {
+	        this.state = 218;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,20,this._ctx);
+	        switch(la_) {
+	        case 1:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 215;
+	            this.module();
+	            break;
+
+	        case 2:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 216;
+	            this.namedtext();
+	            break;
+
+	        case 3:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 217;
+	            this.text_();
+	            break;
+
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	namedtext() {
+	    let localctx = new NamedtextContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 40, CLIFParser.RULE_namedtext);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 220;
+	        this.match(CLIFParser.OPEN);
+	        this.state = 221;
+	        this.match(CLIFParser.CL_TEXT);
+	        this.state = 222;
+	        this.interpretablename();
+	        this.state = 224;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(_la===1) {
+	            this.state = 223;
+	            this.text_();
+	        }
+
+	        this.state = 226;
+	        this.match(CLIFParser.CLOSE);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+}
+
+CLIFParser.EOF = antlr4.Token.EOF;
+CLIFParser.OPEN = 1;
+CLIFParser.CLOSE = 2;
+CLIFParser.STRINGQUOTE = 3;
+CLIFParser.NAMEQUOTE = 4;
+CLIFParser.BACKSLASH = 5;
+CLIFParser.NUMERAL = 6;
+CLIFParser.SEQMARK = 7;
+CLIFParser.QUOTEDSTRING = 8;
+CLIFParser.ENCLOSEDNAME = 9;
+CLIFParser.EQUAL = 10;
+CLIFParser.AND = 11;
+CLIFParser.OR = 12;
+CLIFParser.IFF = 13;
+CLIFParser.IF = 14;
+CLIFParser.FORALL = 15;
+CLIFParser.EXISTS = 16;
+CLIFParser.NOT = 17;
+CLIFParser.CL_ROLESET = 18;
+CLIFParser.CL_TEXT = 19;
+CLIFParser.CL_IMPORTS = 20;
+CLIFParser.CL_EXCLUDES = 21;
+CLIFParser.CL_MODULE = 22;
+CLIFParser.CL_COMMENT = 23;
+CLIFParser.CL_PREFIX = 24;
+CLIFParser.NAMECHARSEQUENCE = 25;
+CLIFParser.WHITE = 26;
+CLIFParser.BLOCKCOMMENT = 27;
+CLIFParser.LineComment = 28;
+
+CLIFParser.RULE_start_ = 0;
+CLIFParser.RULE_termseq = 1;
+CLIFParser.RULE_interpretedname = 2;
+CLIFParser.RULE_interpretablename = 3;
+CLIFParser.RULE_name = 4;
+CLIFParser.RULE_term = 5;
+CLIFParser.RULE_operator_ = 6;
+CLIFParser.RULE_equation = 7;
+CLIFParser.RULE_sentence = 8;
+CLIFParser.RULE_atomsent = 9;
+CLIFParser.RULE_atom = 10;
+CLIFParser.RULE_predicate = 11;
+CLIFParser.RULE_boolsent = 12;
+CLIFParser.RULE_quantsent = 13;
+CLIFParser.RULE_boundlist = 14;
+CLIFParser.RULE_commentsent = 15;
+CLIFParser.RULE_module = 16;
+CLIFParser.RULE_phrase = 17;
+CLIFParser.RULE_text_ = 18;
+CLIFParser.RULE_cltext = 19;
+CLIFParser.RULE_namedtext = 20;
+
+class Start_Context extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_start_;
+    }
+
+	EOF() {
+	    return this.getToken(CLIFParser.EOF, 0);
+	};
+
+	cltext = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(CltextContext);
+	    } else {
+	        return this.getTypedRuleContext(CltextContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterStart_(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitStart_(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitStart_(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class TermseqContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_termseq;
+    }
+
+	term = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(TermContext);
+	    } else {
+	        return this.getTypedRuleContext(TermContext,i);
+	    }
+	};
+
+	SEQMARK = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(CLIFParser.SEQMARK);
+	    } else {
+	        return this.getToken(CLIFParser.SEQMARK, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterTermseq(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitTermseq(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitTermseq(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class InterpretednameContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_interpretedname;
+    }
+
+	NUMERAL() {
+	    return this.getToken(CLIFParser.NUMERAL, 0);
+	};
+
+	QUOTEDSTRING() {
+	    return this.getToken(CLIFParser.QUOTEDSTRING, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterInterpretedname(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitInterpretedname(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitInterpretedname(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class InterpretablenameContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_interpretablename;
+    }
+
+	NAMECHARSEQUENCE() {
+	    return this.getToken(CLIFParser.NAMECHARSEQUENCE, 0);
+	};
+
+	ENCLOSEDNAME() {
+	    return this.getToken(CLIFParser.ENCLOSEDNAME, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterInterpretablename(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitInterpretablename(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitInterpretablename(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class NameContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_name;
+    }
+
+	interpretedname() {
+	    return this.getTypedRuleContext(InterpretednameContext,0);
+	};
+
+	interpretablename() {
+	    return this.getTypedRuleContext(InterpretablenameContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterName(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitName(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitName(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class TermContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_term;
+    }
+
+	name() {
+	    return this.getTypedRuleContext(NameContext,0);
+	};
+
+	OPEN() {
+	    return this.getToken(CLIFParser.OPEN, 0);
+	};
+
+	operator_() {
+	    return this.getTypedRuleContext(Operator_Context,0);
+	};
+
+	termseq() {
+	    return this.getTypedRuleContext(TermseqContext,0);
+	};
+
+	CLOSE() {
+	    return this.getToken(CLIFParser.CLOSE, 0);
+	};
+
+	CL_COMMENT() {
+	    return this.getToken(CLIFParser.CL_COMMENT, 0);
+	};
+
+	QUOTEDSTRING() {
+	    return this.getToken(CLIFParser.QUOTEDSTRING, 0);
+	};
+
+	term() {
+	    return this.getTypedRuleContext(TermContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterTerm(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitTerm(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitTerm(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class Operator_Context extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_operator_;
+    }
+
+	term() {
+	    return this.getTypedRuleContext(TermContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterOperator_(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitOperator_(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitOperator_(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class EquationContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_equation;
+    }
+
+	OPEN() {
+	    return this.getToken(CLIFParser.OPEN, 0);
+	};
+
+	EQUAL() {
+	    return this.getToken(CLIFParser.EQUAL, 0);
+	};
+
+	term = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(TermContext);
+	    } else {
+	        return this.getTypedRuleContext(TermContext,i);
+	    }
+	};
+
+	CLOSE() {
+	    return this.getToken(CLIFParser.CLOSE, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterEquation(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitEquation(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitEquation(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class SentenceContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_sentence;
+    }
+
+	atomsent() {
+	    return this.getTypedRuleContext(AtomsentContext,0);
+	};
+
+	boolsent() {
+	    return this.getTypedRuleContext(BoolsentContext,0);
+	};
+
+	quantsent() {
+	    return this.getTypedRuleContext(QuantsentContext,0);
+	};
+
+	commentsent() {
+	    return this.getTypedRuleContext(CommentsentContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterSentence(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitSentence(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitSentence(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class AtomsentContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_atomsent;
+    }
+
+	equation() {
+	    return this.getTypedRuleContext(EquationContext,0);
+	};
+
+	atom() {
+	    return this.getTypedRuleContext(AtomContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterAtomsent(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitAtomsent(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitAtomsent(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class AtomContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_atom;
+    }
+
+	OPEN = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(CLIFParser.OPEN);
+	    } else {
+	        return this.getToken(CLIFParser.OPEN, i);
+	    }
+	};
+
+
+	predicate() {
+	    return this.getTypedRuleContext(PredicateContext,0);
+	};
+
+	termseq() {
+	    return this.getTypedRuleContext(TermseqContext,0);
+	};
+
+	CLOSE = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(CLIFParser.CLOSE);
+	    } else {
+	        return this.getToken(CLIFParser.CLOSE, i);
+	    }
+	};
+
+
+	term = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(TermContext);
+	    } else {
+	        return this.getTypedRuleContext(TermContext,i);
+	    }
+	};
+
+	CL_ROLESET() {
+	    return this.getToken(CLIFParser.CL_ROLESET, 0);
+	};
+
+	name() {
+	    return this.getTypedRuleContext(NameContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterAtom(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitAtom(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitAtom(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class PredicateContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_predicate;
+    }
+
+	term() {
+	    return this.getTypedRuleContext(TermContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterPredicate(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitPredicate(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitPredicate(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class BoolsentContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_boolsent;
+    }
+
+	OPEN() {
+	    return this.getToken(CLIFParser.OPEN, 0);
+	};
+
+	CLOSE() {
+	    return this.getToken(CLIFParser.CLOSE, 0);
+	};
+
+	AND() {
+	    return this.getToken(CLIFParser.AND, 0);
+	};
+
+	OR() {
+	    return this.getToken(CLIFParser.OR, 0);
+	};
+
+	sentence = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(SentenceContext);
+	    } else {
+	        return this.getTypedRuleContext(SentenceContext,i);
+	    }
+	};
+
+	IF() {
+	    return this.getToken(CLIFParser.IF, 0);
+	};
+
+	IFF() {
+	    return this.getToken(CLIFParser.IFF, 0);
+	};
+
+	NOT() {
+	    return this.getToken(CLIFParser.NOT, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterBoolsent(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitBoolsent(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitBoolsent(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class QuantsentContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_quantsent;
+    }
+
+	OPEN() {
+	    return this.getToken(CLIFParser.OPEN, 0);
+	};
+
+	boundlist() {
+	    return this.getTypedRuleContext(BoundlistContext,0);
+	};
+
+	sentence() {
+	    return this.getTypedRuleContext(SentenceContext,0);
+	};
+
+	CLOSE() {
+	    return this.getToken(CLIFParser.CLOSE, 0);
+	};
+
+	FORALL() {
+	    return this.getToken(CLIFParser.FORALL, 0);
+	};
+
+	EXISTS() {
+	    return this.getToken(CLIFParser.EXISTS, 0);
+	};
+
+	interpretablename() {
+	    return this.getTypedRuleContext(InterpretablenameContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterQuantsent(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitQuantsent(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitQuantsent(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class BoundlistContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_boundlist;
+    }
+
+	OPEN = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(CLIFParser.OPEN);
+	    } else {
+	        return this.getToken(CLIFParser.OPEN, i);
+	    }
+	};
+
+
+	CLOSE = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(CLIFParser.CLOSE);
+	    } else {
+	        return this.getToken(CLIFParser.CLOSE, i);
+	    }
+	};
+
+
+	interpretablename = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(InterpretablenameContext);
+	    } else {
+	        return this.getTypedRuleContext(InterpretablenameContext,i);
+	    }
+	};
+
+	SEQMARK = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(CLIFParser.SEQMARK);
+	    } else {
+	        return this.getToken(CLIFParser.SEQMARK, i);
+	    }
+	};
+
+
+	term = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(TermContext);
+	    } else {
+	        return this.getTypedRuleContext(TermContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterBoundlist(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitBoundlist(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitBoundlist(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class CommentsentContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_commentsent;
+    }
+
+	OPEN() {
+	    return this.getToken(CLIFParser.OPEN, 0);
+	};
+
+	CL_COMMENT() {
+	    return this.getToken(CLIFParser.CL_COMMENT, 0);
+	};
+
+	ENCLOSEDNAME() {
+	    return this.getToken(CLIFParser.ENCLOSEDNAME, 0);
+	};
+
+	sentence() {
+	    return this.getTypedRuleContext(SentenceContext,0);
+	};
+
+	CLOSE() {
+	    return this.getToken(CLIFParser.CLOSE, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterCommentsent(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitCommentsent(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitCommentsent(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ModuleContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_module;
+    }
+
+	OPEN = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(CLIFParser.OPEN);
+	    } else {
+	        return this.getToken(CLIFParser.OPEN, i);
+	    }
+	};
+
+
+	CL_MODULE() {
+	    return this.getToken(CLIFParser.CL_MODULE, 0);
+	};
+
+	interpretablename() {
+	    return this.getTypedRuleContext(InterpretablenameContext,0);
+	};
+
+	CLOSE = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(CLIFParser.CLOSE);
+	    } else {
+	        return this.getToken(CLIFParser.CLOSE, i);
+	    }
+	};
+
+
+	CL_EXCLUDES() {
+	    return this.getToken(CLIFParser.CL_EXCLUDES, 0);
+	};
+
+	cltext = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(CltextContext);
+	    } else {
+	        return this.getTypedRuleContext(CltextContext,i);
+	    }
+	};
+
+	name = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(NameContext);
+	    } else {
+	        return this.getTypedRuleContext(NameContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterModule(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitModule(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitModule(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class PhraseContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_phrase;
+    }
+
+	sentence() {
+	    return this.getTypedRuleContext(SentenceContext,0);
+	};
+
+	module() {
+	    return this.getTypedRuleContext(ModuleContext,0);
+	};
+
+	OPEN() {
+	    return this.getToken(CLIFParser.OPEN, 0);
+	};
+
+	CL_IMPORTS() {
+	    return this.getToken(CLIFParser.CL_IMPORTS, 0);
+	};
+
+	interpretablename() {
+	    return this.getTypedRuleContext(InterpretablenameContext,0);
+	};
+
+	CLOSE() {
+	    return this.getToken(CLIFParser.CLOSE, 0);
+	};
+
+	CL_COMMENT() {
+	    return this.getToken(CLIFParser.CL_COMMENT, 0);
+	};
+
+	ENCLOSEDNAME() {
+	    return this.getToken(CLIFParser.ENCLOSEDNAME, 0);
+	};
+
+	cltext() {
+	    return this.getTypedRuleContext(CltextContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterPhrase(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitPhrase(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitPhrase(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class Text_Context extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_text_;
+    }
+
+	phrase = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(PhraseContext);
+	    } else {
+	        return this.getTypedRuleContext(PhraseContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterText_(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitText_(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitText_(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class CltextContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_cltext;
+    }
+
+	module() {
+	    return this.getTypedRuleContext(ModuleContext,0);
+	};
+
+	namedtext() {
+	    return this.getTypedRuleContext(NamedtextContext,0);
+	};
+
+	text_() {
+	    return this.getTypedRuleContext(Text_Context,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterCltext(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitCltext(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitCltext(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class NamedtextContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CLIFParser.RULE_namedtext;
+    }
+
+	OPEN() {
+	    return this.getToken(CLIFParser.OPEN, 0);
+	};
+
+	CL_TEXT() {
+	    return this.getToken(CLIFParser.CL_TEXT, 0);
+	};
+
+	interpretablename() {
+	    return this.getTypedRuleContext(InterpretablenameContext,0);
+	};
+
+	CLOSE() {
+	    return this.getToken(CLIFParser.CLOSE, 0);
+	};
+
+	text_() {
+	    return this.getTypedRuleContext(Text_Context,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.enterNamedtext(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CLIFListener ) {
+	        listener.exitNamedtext(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof CLIFVisitor ) {
+	        return visitor.visitNamedtext(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+
+CLIFParser.Start_Context = Start_Context; 
+CLIFParser.TermseqContext = TermseqContext; 
+CLIFParser.InterpretednameContext = InterpretednameContext; 
+CLIFParser.InterpretablenameContext = InterpretablenameContext; 
+CLIFParser.NameContext = NameContext; 
+CLIFParser.TermContext = TermContext; 
+CLIFParser.Operator_Context = Operator_Context; 
+CLIFParser.EquationContext = EquationContext; 
+CLIFParser.SentenceContext = SentenceContext; 
+CLIFParser.AtomsentContext = AtomsentContext; 
+CLIFParser.AtomContext = AtomContext; 
+CLIFParser.PredicateContext = PredicateContext; 
+CLIFParser.BoolsentContext = BoolsentContext; 
+CLIFParser.QuantsentContext = QuantsentContext; 
+CLIFParser.BoundlistContext = BoundlistContext; 
+CLIFParser.CommentsentContext = CommentsentContext; 
+CLIFParser.ModuleContext = ModuleContext; 
+CLIFParser.PhraseContext = PhraseContext; 
+CLIFParser.Text_Context = Text_Context; 
+CLIFParser.CltextContext = CltextContext; 
+CLIFParser.NamedtextContext = NamedtextContext;