ifc-expressions 2.3.0 → 3.0.0-beta.0

package/dist/cjs/gen/parser/IfcExpressionParser.js

@@ -1,40 +1,59 @@
 "use strict";
-// Generated from IfcExpression.g4 by ANTLR 4.13.0
-// noinspection ES6UnusedImports,JSUnusedGlobalSymbols,JSUnusedLocalSymbols
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VariableRefContext = exports.LogicalLiteralContext = exports.BooleanLiteralContext = exports.StringLiteralContext = exports.NumLiteralContext = exports.LiteralContext = exports.ArrayElementListContext = exports.ArrayExprContext = exports.ExprListContext = exports.FunctionCallContext = exports.MethodCallChainEndContext = exports.MethodCallChainInnerContext = exports.MethodCallChainContext = exports.SEMethodCallContext = exports.SEAddSubContext = exports.SEUnaryMinusContext = exports.SEUnaryMultipleMinusContext = exports.SEVariableRefContext = exports.SENotContext = exports.SEArrayExprContext = exports.SEFunctionCallContext = exports.SEBooleanBinaryOpContext = exports.SEPowerContext = exports.SEMulDivContext = exports.SEParenthesisContext = exports.SELiteralContext = exports.SEComparisonContext = exports.SingleExprContext = exports.ExprContext = void 0;
-const antlr4_1 = require("antlr4");
-class IfcExpressionParser extends antlr4_1.Parser {
+exports.VariableRefContext = exports.LogicalLiteralContext = exports.BooleanLiteralContext = exports.StringLiteralContext = exports.NumLiteralContext = exports.LiteralContext = exports.ArrayElementListContext = exports.ArrayExprContext = exports.ExprListContext = exports.FunctionCallContext = exports.MethodPropertyAccessContext = exports.MethodFunctionCallContext = exports.MethodAccessorContext = exports.MethodCallChainEndContext = exports.MethodCallChainInnerContext = exports.MethodCallChainContext = exports.SEMethodCallContext = exports.SEBooleanBinaryOpContext = exports.SEComparisonContext = exports.SEAddSubContext = exports.SEMulDivContext = exports.SEPowerContext = exports.SEArrayExprContext = exports.SELiteralContext = exports.SEFunctionCallContext = exports.SEVariableRefContext = exports.SENotContext = exports.SEUnaryMinusContext = exports.SEParenthesisContext = exports.SEUnaryMultipleMinusContext = exports.SingleExprContext = exports.ExprContext = exports.IfcExpressionParser = void 0;
+const antlr = __importStar(require("antlr4ng"));
+class IfcExpressionParser extends antlr.Parser {
     get grammarFileName() { return "IfcExpression.g4"; }
     get literalNames() { return IfcExpressionParser.literalNames; }
     get symbolicNames() { return IfcExpressionParser.symbolicNames; }
     get ruleNames() { return IfcExpressionParser.ruleNames; }
     get serializedATN() { return IfcExpressionParser._serializedATN; }
     createFailedPredicateException(predicate, message) {
-        return new antlr4_1.FailedPredicateException(this, predicate, message);
+        return new antlr.FailedPredicateException(this, predicate, message);
     }
     constructor(input) {
         super(input);
-        this._interp = new antlr4_1.ParserATNSimulator(this, IfcExpressionParser._ATN, IfcExpressionParser.DecisionsToDFA, new antlr4_1.PredictionContextCache());
+        this.interpreter = new antlr.ParserATNSimulator(this, IfcExpressionParser._ATN, IfcExpressionParser.decisionsToDFA, new antlr.PredictionContextCache());
     }
-    // @RuleVersion(0)
     expr() {
-        let localctx = new ExprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 0, IfcExpressionParser.RULE_expr);
+        let localContext = new ExprContext(this.context, this.state);
+        this.enterRule(localContext, 0, IfcExpressionParser.RULE_expr);
         try {
-            this.enterOuterAlt(localctx, 1);
+            this.enterOuterAlt(localContext, 1);
             {
-                this.state = 26;
+                this.state = 28;
                 this.singleExpr(0);
-                this.state = 27;
+                this.state = 29;
                 this.match(IfcExpressionParser.EOF);
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -43,295 +62,291 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
     }
-    // @RuleVersion(0)
     singleExpr(_p) {
         if (_p === undefined) {
             _p = 0;
         }
-        let _parentctx = this._ctx;
-        let _parentState = this.state;
-        let localctx = new SingleExprContext(this, this._ctx, _parentState);
-        let _prevctx = localctx;
+        let parentContext = this.context;
+        let parentState = this.state;
+        let localContext = new SingleExprContext(this.context, parentState);
+        let previousContext = localContext;
         let _startState = 2;
-        this.enterRecursionRule(localctx, 2, IfcExpressionParser.RULE_singleExpr, _p);
+        this.enterRecursionRule(localContext, 2, IfcExpressionParser.RULE_singleExpr, _p);
         let _la;
         try {
-            let _alt;
-            this.enterOuterAlt(localctx, 1);
+            let alternative;
+            this.enterOuterAlt(localContext, 1);
             {
-                this.state = 44;
-                this._errHandler.sync(this);
-                switch (this._input.LA(1)) {
-                    case 1:
+                this.state = 46;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                    case IfcExpressionParser.T__0:
                         {
-                            localctx = new SEUnaryMultipleMinusContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 30;
+                            localContext = new SEUnaryMultipleMinusContext(localContext);
+                            this.context = localContext;
+                            previousContext = localContext;
+                            this.state = 32;
                             this.match(IfcExpressionParser.T__0);
-                            this.state = 31;
-                            localctx._sub = this.singleExpr(14);
+                            this.state = 33;
+                            localContext._sub = this.singleExpr(14);
                         }
                         break;
-                    case 2:
+                    case IfcExpressionParser.T__1:
                         {
-                            localctx = new SEParenthesisContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 32;
-                            this.match(IfcExpressionParser.T__1);
-                            this.state = 33;
-                            localctx._sub = this.singleExpr(0);
+                            localContext = new SEParenthesisContext(localContext);
+                            this.context = localContext;
+                            previousContext = localContext;
                             this.state = 34;
+                            this.match(IfcExpressionParser.T__1);
+                            this.state = 35;
+                            localContext._sub = this.singleExpr(0);
+                            this.state = 36;
                             this.match(IfcExpressionParser.T__2);
                         }
                         break;
-                    case 4:
+                    case IfcExpressionParser.T__3:
                         {
-                            localctx = new SEUnaryMinusContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 36;
+                            localContext = new SEUnaryMinusContext(localContext);
+                            this.context = localContext;
+                            previousContext = localContext;
+                            this.state = 38;
                             this.match(IfcExpressionParser.T__3);
-                            this.state = 37;
-                            localctx._sub = this.singleExpr(12);
+                            this.state = 39;
+                            localContext._sub = this.singleExpr(12);
                         }
                         break;
-                    case 9:
+                    case IfcExpressionParser.T__8:
                         {
-                            localctx = new SENotContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 38;
+                            localContext = new SENotContext(localContext);
+                            this.context = localContext;
+                            previousContext = localContext;
+                            this.state = 40;
                             this.match(IfcExpressionParser.T__8);
-                            this.state = 39;
-                            localctx._sub = this.singleExpr(6);
+                            this.state = 41;
+                            localContext._sub = this.singleExpr(6);
                         }
                         break;
-                    case 13:
+                    case IfcExpressionParser.T__12:
                         {
-                            localctx = new SEVariableRefContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 40;
-                            localctx._sub = this.variableRef();
+                            localContext = new SEVariableRefContext(localContext);
+                            this.context = localContext;
+                            previousContext = localContext;
+                            this.state = 42;
+                            localContext._sub = this.variableRef();
                         }
                         break;
-                    case 20:
+                    case IfcExpressionParser.IDENTIFIER:
                         {
-                            localctx = new SEFunctionCallContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 41;
-                            localctx._sub = this.functionCall();
+                            localContext = new SEFunctionCallContext(localContext);
+                            this.context = localContext;
+                            previousContext = localContext;
+                            this.state = 43;
+                            localContext._sub = this.functionCall();
                         }
                         break;
-                    case 14:
-                    case 15:
-                    case 16:
-                    case 17:
-                    case 19:
+                    case IfcExpressionParser.INT:
+                    case IfcExpressionParser.FLOAT:
+                    case IfcExpressionParser.BOOLEAN:
+                    case IfcExpressionParser.LOGICAL_UNKNOWN:
+                    case IfcExpressionParser.QUOTED_STRING:
                         {
-                            localctx = new SELiteralContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 42;
-                            localctx._sub = this.literal();
+                            localContext = new SELiteralContext(localContext);
+                            this.context = localContext;
+                            previousContext = localContext;
+                            this.state = 44;
+                            localContext._sub = this.literal();
                         }
                         break;
-                    case 11:
+                    case IfcExpressionParser.T__10:
                         {
-                            localctx = new SEArrayExprContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 43;
-                            localctx._sub = this.arrayExpr();
+                            localContext = new SEArrayExprContext(localContext);
+                            this.context = localContext;
+                            previousContext = localContext;
+                            this.state = 45;
+                            localContext._sub = this.arrayExpr();
                         }
                         break;
                     default:
-                        throw new antlr4_1.NoViableAltException(this);
+                        throw new antlr.NoViableAltException(this);
                 }
-                this._ctx.stop = this._input.LT(-1);
-                this.state = 65;
-                this._errHandler.sync(this);
-                _alt = this._interp.adaptivePredict(this._input, 2, this._ctx);
-                while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER) {
-                    if (_alt === 1) {
-                        if (this._parseListeners != null) {
+                this.context.stop = this.tokenStream.LT(-1);
+                this.state = 67;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        if (this.parseListeners != null) {
                             this.triggerExitRuleEvent();
                         }
-                        _prevctx = localctx;
+                        previousContext = localContext;
                         {
-                            this.state = 63;
-                            this._errHandler.sync(this);
-                            switch (this._interp.adaptivePredict(this._input, 1, this._ctx)) {
+                            this.state = 65;
+                            this.errorHandler.sync(this);
+                            switch (this.interpreter.adaptivePredict(this.tokenStream, 1, this.context)) {
                                 case 1:
                                     {
-                                        localctx = new SEPowerContext(this, new SingleExprContext(this, _parentctx, _parentState));
-                                        localctx._left = _prevctx;
-                                        this.pushNewRecursionContext(localctx, _startState, IfcExpressionParser.RULE_singleExpr);
-                                        this.state = 46;
-                                        if (!(this.precpred(this._ctx, 11))) {
-                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 11)");
-                                        }
-                                        this.state = 47;
-                                        localctx._op = this.match(IfcExpressionParser.T__4);
+                                        localContext = new SEPowerContext(new SingleExprContext(parentContext, parentState));
+                                        localContext._left = previousContext;
+                                        this.pushNewRecursionContext(localContext, _startState, IfcExpressionParser.RULE_singleExpr);
                                         this.state = 48;
-                                        localctx._right = this.singleExpr(11);
+                                        if (!(this.precpred(this.context, 11))) {
+                                            throw this.createFailedPredicateException("this.precpred(this.context, 11)");
+                                        }
+                                        this.state = 49;
+                                        localContext._op = this.match(IfcExpressionParser.T__4);
+                                        this.state = 50;
+                                        localContext._right = this.singleExpr(11);
                                     }
                                     break;
                                 case 2:
                                     {
-                                        localctx = new SEMulDivContext(this, new SingleExprContext(this, _parentctx, _parentState));
-                                        localctx._left = _prevctx;
-                                        this.pushNewRecursionContext(localctx, _startState, IfcExpressionParser.RULE_singleExpr);
-                                        this.state = 49;
-                                        if (!(this.precpred(this._ctx, 9))) {
-                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 9)");
+                                        localContext = new SEMulDivContext(new SingleExprContext(parentContext, parentState));
+                                        localContext._left = previousContext;
+                                        this.pushNewRecursionContext(localContext, _startState, IfcExpressionParser.RULE_singleExpr);
+                                        this.state = 51;
+                                        if (!(this.precpred(this.context, 9))) {
+                                            throw this.createFailedPredicateException("this.precpred(this.context, 9)");
                                         }
-                                        this.state = 50;
-                                        localctx._op = this._input.LT(1);
-                                        _la = this._input.LA(1);
+                                        this.state = 52;
+                                        localContext._op = this.tokenStream.LT(1);
+                                        _la = this.tokenStream.LA(1);
                                         if (!(_la === 6 || _la === 7)) {
-                                            localctx._op = this._errHandler.recoverInline(this);
+                                            localContext._op = this.errorHandler.recoverInline(this);
                                         }
                                         else {
-                                            this._errHandler.reportMatch(this);
+                                            this.errorHandler.reportMatch(this);
                                             this.consume();
                                         }
-                                        this.state = 51;
-                                        localctx._right = this.singleExpr(10);
+                                        this.state = 53;
+                                        localContext._right = this.singleExpr(10);
                                     }
                                     break;
                                 case 3:
                                     {
-                                        localctx = new SEAddSubContext(this, new SingleExprContext(this, _parentctx, _parentState));
-                                        localctx._left = _prevctx;
-                                        this.pushNewRecursionContext(localctx, _startState, IfcExpressionParser.RULE_singleExpr);
-                                        this.state = 52;
-                                        if (!(this.precpred(this._ctx, 8))) {
-                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 8)");
+                                        localContext = new SEAddSubContext(new SingleExprContext(parentContext, parentState));
+                                        localContext._left = previousContext;
+                                        this.pushNewRecursionContext(localContext, _startState, IfcExpressionParser.RULE_singleExpr);
+                                        this.state = 54;
+                                        if (!(this.precpred(this.context, 8))) {
+                                            throw this.createFailedPredicateException("this.precpred(this.context, 8)");
                                         }
-                                        this.state = 53;
-                                        localctx._op = this._input.LT(1);
-                                        _la = this._input.LA(1);
+                                        this.state = 55;
+                                        localContext._op = this.tokenStream.LT(1);
+                                        _la = this.tokenStream.LA(1);
                                         if (!(_la === 4 || _la === 8)) {
-                                            localctx._op = this._errHandler.recoverInline(this);
+                                            localContext._op = this.errorHandler.recoverInline(this);
                                         }
                                         else {
-                                            this._errHandler.reportMatch(this);
+                                            this.errorHandler.reportMatch(this);
                                             this.consume();
                                         }
-                                        this.state = 54;
-                                        localctx._right = this.singleExpr(9);
+                                        this.state = 56;
+                                        localContext._right = this.singleExpr(9);
                                     }
                                     break;
                                 case 4:
                                     {
-                                        localctx = new SEComparisonContext(this, new SingleExprContext(this, _parentctx, _parentState));
-                                        localctx._left = _prevctx;
-                                        this.pushNewRecursionContext(localctx, _startState, IfcExpressionParser.RULE_singleExpr);
-                                        this.state = 55;
-                                        if (!(this.precpred(this._ctx, 7))) {
-                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 7)");
+                                        localContext = new SEComparisonContext(new SingleExprContext(parentContext, parentState));
+                                        localContext._left = previousContext;
+                                        this.pushNewRecursionContext(localContext, _startState, IfcExpressionParser.RULE_singleExpr);
+                                        this.state = 57;
+                                        if (!(this.precpred(this.context, 7))) {
+                                            throw this.createFailedPredicateException("this.precpred(this.context, 7)");
                                         }
-                                        this.state = 56;
+                                        this.state = 58;
                                         this.match(IfcExpressionParser.CMP_OP);
-                                        this.state = 57;
-                                        localctx._right = this.singleExpr(8);
+                                        this.state = 59;
+                                        localContext._right = this.singleExpr(8);
                                     }
                                     break;
                                 case 5:
                                     {
-                                        localctx = new SEBooleanBinaryOpContext(this, new SingleExprContext(this, _parentctx, _parentState));
-                                        localctx._left = _prevctx;
-                                        this.pushNewRecursionContext(localctx, _startState, IfcExpressionParser.RULE_singleExpr);
-                                        this.state = 58;
-                                        if (!(this.precpred(this._ctx, 5))) {
-                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 5)");
-                                        }
-                                        this.state = 59;
-                                        localctx._op = this.match(IfcExpressionParser.BOOLEAN_BINARY_OP);
+                                        localContext = new SEBooleanBinaryOpContext(new SingleExprContext(parentContext, parentState));
+                                        localContext._left = previousContext;
+                                        this.pushNewRecursionContext(localContext, _startState, IfcExpressionParser.RULE_singleExpr);
                                         this.state = 60;
-                                        localctx._right = this.singleExpr(6);
+                                        if (!(this.precpred(this.context, 5))) {
+                                            throw this.createFailedPredicateException("this.precpred(this.context, 5)");
+                                        }
+                                        this.state = 61;
+                                        localContext._op = this.match(IfcExpressionParser.BOOLEAN_BINARY_OP);
+                                        this.state = 62;
+                                        localContext._right = this.singleExpr(6);
                                     }
                                     break;
                                 case 6:
                                     {
-                                        localctx = new SEMethodCallContext(this, new SingleExprContext(this, _parentctx, _parentState));
-                                        localctx._target = _prevctx;
-                                        this.pushNewRecursionContext(localctx, _startState, IfcExpressionParser.RULE_singleExpr);
-                                        this.state = 61;
-                                        if (!(this.precpred(this._ctx, 10))) {
-                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 10)");
+                                        localContext = new SEMethodCallContext(new SingleExprContext(parentContext, parentState));
+                                        localContext._target = previousContext;
+                                        this.pushNewRecursionContext(localContext, _startState, IfcExpressionParser.RULE_singleExpr);
+                                        this.state = 63;
+                                        if (!(this.precpred(this.context, 10))) {
+                                            throw this.createFailedPredicateException("this.precpred(this.context, 10)");
                                         }
-                                        this.state = 62;
-                                        localctx._call = this.methodCallChain();
+                                        this.state = 64;
+                                        localContext._call = this.methodCallChain();
                                     }
                                     break;
                             }
                         }
                     }
-                    this.state = 67;
-                    this._errHandler.sync(this);
-                    _alt = this._interp.adaptivePredict(this._input, 2, this._ctx);
+                    this.state = 69;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2, this.context);
                 }
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
             }
         }
         finally {
-            this.unrollRecursionContexts(_parentctx);
+            this.unrollRecursionContexts(parentContext);
         }
-        return localctx;
+        return localContext;
     }
-    // @RuleVersion(0)
     methodCallChain() {
-        let localctx = new MethodCallChainContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 4, IfcExpressionParser.RULE_methodCallChain);
+        let localContext = new MethodCallChainContext(this.context, this.state);
+        this.enterRule(localContext, 4, IfcExpressionParser.RULE_methodCallChain);
         try {
-            this.state = 74;
-            this._errHandler.sync(this);
-            switch (this._interp.adaptivePredict(this._input, 3, this._ctx)) {
+            this.state = 76;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context)) {
                 case 1:
-                    localctx = new MethodCallChainInnerContext(this, localctx);
-                    this.enterOuterAlt(localctx, 1);
+                    localContext = new MethodCallChainInnerContext(localContext);
+                    this.enterOuterAlt(localContext, 1);
                     {
-                        this.state = 68;
-                        this.match(IfcExpressionParser.DOT);
-                        this.state = 69;
-                        localctx._target = this.functionCall();
                         this.state = 70;
-                        localctx._call = this.methodCallChain();
+                        this.match(IfcExpressionParser.DOT);
+                        this.state = 71;
+                        localContext._target = this.methodAccessor();
+                        this.state = 72;
+                        localContext._call = this.methodCallChain();
                     }
                     break;
                 case 2:
-                    localctx = new MethodCallChainEndContext(this, localctx);
-                    this.enterOuterAlt(localctx, 2);
+                    localContext = new MethodCallChainEndContext(localContext);
+                    this.enterOuterAlt(localContext, 2);
                     {
-                        this.state = 72;
+                        this.state = 74;
                         this.match(IfcExpressionParser.DOT);
-                        this.state = 73;
-                        localctx._call = this.functionCall();
+                        this.state = 75;
+                        localContext._call = this.methodAccessor();
                     }
                     break;
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -340,38 +355,75 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
+    }
+    methodAccessor() {
+        let localContext = new MethodAccessorContext(this.context, this.state);
+        this.enterRule(localContext, 6, IfcExpressionParser.RULE_methodAccessor);
+        try {
+            this.state = 80;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 4, this.context)) {
+                case 1:
+                    localContext = new MethodFunctionCallContext(localContext);
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 78;
+                        this.functionCall();
+                    }
+                    break;
+                case 2:
+                    localContext = new MethodPropertyAccessContext(localContext);
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 79;
+                        this.match(IfcExpressionParser.IDENTIFIER);
+                    }
+                    break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
     }
-    // @RuleVersion(0)
     functionCall() {
-        let localctx = new FunctionCallContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 6, IfcExpressionParser.RULE_functionCall);
+        let localContext = new FunctionCallContext(this.context, this.state);
+        this.enterRule(localContext, 8, IfcExpressionParser.RULE_functionCall);
         let _la;
         try {
-            this.enterOuterAlt(localctx, 1);
+            this.enterOuterAlt(localContext, 1);
             {
-                this.state = 76;
+                this.state = 82;
                 this.match(IfcExpressionParser.IDENTIFIER);
-                this.state = 77;
+                this.state = 83;
                 this.match(IfcExpressionParser.T__1);
-                this.state = 79;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
+                this.state = 85;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
                 if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 1829398) !== 0)) {
                     {
-                        this.state = 78;
-                        localctx._sub = this.exprList();
+                        this.state = 84;
+                        localContext._sub = this.exprList();
                     }
                 }
-                this.state = 81;
+                this.state = 87;
                 this.match(IfcExpressionParser.T__2);
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -380,41 +432,39 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
     }
-    // @RuleVersion(0)
     exprList() {
-        let localctx = new ExprListContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 8, IfcExpressionParser.RULE_exprList);
+        let localContext = new ExprListContext(this.context, this.state);
+        this.enterRule(localContext, 10, IfcExpressionParser.RULE_exprList);
         try {
-            this.state = 88;
-            this._errHandler.sync(this);
-            switch (this._interp.adaptivePredict(this._input, 5, this._ctx)) {
+            this.state = 94;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 6, this.context)) {
                 case 1:
-                    this.enterOuterAlt(localctx, 1);
+                    this.enterOuterAlt(localContext, 1);
                     {
-                        this.state = 83;
+                        this.state = 89;
                         this.singleExpr(0);
                     }
                     break;
                 case 2:
-                    this.enterOuterAlt(localctx, 2);
+                    this.enterOuterAlt(localContext, 2);
                     {
-                        this.state = 84;
+                        this.state = 90;
                         this.singleExpr(0);
-                        this.state = 85;
+                        this.state = 91;
                         this.match(IfcExpressionParser.T__9);
-                        this.state = 86;
+                        this.state = 92;
                         this.exprList();
                     }
                     break;
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -423,36 +473,34 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
     }
-    // @RuleVersion(0)
     arrayExpr() {
-        let localctx = new ArrayExprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 10, IfcExpressionParser.RULE_arrayExpr);
+        let localContext = new ArrayExprContext(this.context, this.state);
+        this.enterRule(localContext, 12, IfcExpressionParser.RULE_arrayExpr);
         let _la;
         try {
-            this.enterOuterAlt(localctx, 1);
+            this.enterOuterAlt(localContext, 1);
             {
-                this.state = 90;
+                this.state = 96;
                 this.match(IfcExpressionParser.T__10);
-                this.state = 92;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
+                this.state = 98;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
                 if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 1829398) !== 0)) {
                     {
-                        this.state = 91;
-                        localctx._sub = this.arrayElementList();
+                        this.state = 97;
+                        localContext._sub = this.arrayElementList();
                     }
                 }
-                this.state = 94;
+                this.state = 100;
                 this.match(IfcExpressionParser.T__11);
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -461,41 +509,39 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
     }
-    // @RuleVersion(0)
     arrayElementList() {
-        let localctx = new ArrayElementListContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 12, IfcExpressionParser.RULE_arrayElementList);
+        let localContext = new ArrayElementListContext(this.context, this.state);
+        this.enterRule(localContext, 14, IfcExpressionParser.RULE_arrayElementList);
         try {
-            this.state = 101;
-            this._errHandler.sync(this);
-            switch (this._interp.adaptivePredict(this._input, 7, this._ctx)) {
+            this.state = 107;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 8, this.context)) {
                 case 1:
-                    this.enterOuterAlt(localctx, 1);
+                    this.enterOuterAlt(localContext, 1);
                     {
-                        this.state = 96;
+                        this.state = 102;
                         this.singleExpr(0);
                     }
                     break;
                 case 2:
-                    this.enterOuterAlt(localctx, 2);
+                    this.enterOuterAlt(localContext, 2);
                     {
-                        this.state = 97;
+                        this.state = 103;
                         this.singleExpr(0);
-                        this.state = 98;
+                        this.state = 104;
                         this.match(IfcExpressionParser.T__9);
-                        this.state = 99;
+                        this.state = 105;
                         this.arrayElementList();
                     }
                     break;
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -504,54 +550,52 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
     }
-    // @RuleVersion(0)
     literal() {
-        let localctx = new LiteralContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 14, IfcExpressionParser.RULE_literal);
+        let localContext = new LiteralContext(this.context, this.state);
+        this.enterRule(localContext, 16, IfcExpressionParser.RULE_literal);
         try {
-            this.state = 107;
-            this._errHandler.sync(this);
-            switch (this._input.LA(1)) {
-                case 14:
-                case 15:
-                    this.enterOuterAlt(localctx, 1);
+            this.state = 113;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+                case IfcExpressionParser.INT:
+                case IfcExpressionParser.FLOAT:
+                    this.enterOuterAlt(localContext, 1);
                     {
-                        this.state = 103;
+                        this.state = 109;
                         this.numLiteral();
                     }
                     break;
-                case 19:
-                    this.enterOuterAlt(localctx, 2);
+                case IfcExpressionParser.QUOTED_STRING:
+                    this.enterOuterAlt(localContext, 2);
                     {
-                        this.state = 104;
+                        this.state = 110;
                         this.stringLiteral();
                     }
                     break;
-                case 16:
-                    this.enterOuterAlt(localctx, 3);
+                case IfcExpressionParser.BOOLEAN:
+                    this.enterOuterAlt(localContext, 3);
                     {
-                        this.state = 105;
+                        this.state = 111;
                         this.booleanLiteral();
                     }
                     break;
-                case 17:
-                    this.enterOuterAlt(localctx, 4);
+                case IfcExpressionParser.LOGICAL_UNKNOWN:
+                    this.enterOuterAlt(localContext, 4);
                     {
-                        this.state = 106;
+                        this.state = 112;
                         this.logicalLiteral();
                     }
                     break;
                 default:
-                    throw new antlr4_1.NoViableAltException(this);
+                    throw new antlr.NoViableAltException(this);
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -560,32 +604,30 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
     }
-    // @RuleVersion(0)
     numLiteral() {
-        let localctx = new NumLiteralContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 16, IfcExpressionParser.RULE_numLiteral);
+        let localContext = new NumLiteralContext(this.context, this.state);
+        this.enterRule(localContext, 18, IfcExpressionParser.RULE_numLiteral);
         let _la;
         try {
-            this.enterOuterAlt(localctx, 1);
+            this.enterOuterAlt(localContext, 1);
             {
-                this.state = 109;
-                _la = this._input.LA(1);
+                this.state = 115;
+                _la = this.tokenStream.LA(1);
                 if (!(_la === 14 || _la === 15)) {
-                    this._errHandler.recoverInline(this);
+                    this.errorHandler.recoverInline(this);
                 }
                 else {
-                    this._errHandler.reportMatch(this);
+                    this.errorHandler.reportMatch(this);
                     this.consume();
                 }
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -594,24 +636,22 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
     }
-    // @RuleVersion(0)
     stringLiteral() {
-        let localctx = new StringLiteralContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 18, IfcExpressionParser.RULE_stringLiteral);
+        let localContext = new StringLiteralContext(this.context, this.state);
+        this.enterRule(localContext, 20, IfcExpressionParser.RULE_stringLiteral);
         try {
-            this.enterOuterAlt(localctx, 1);
+            this.enterOuterAlt(localContext, 1);
             {
-                this.state = 111;
+                this.state = 117;
                 this.match(IfcExpressionParser.QUOTED_STRING);
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -620,24 +660,22 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
     }
-    // @RuleVersion(0)
     booleanLiteral() {
-        let localctx = new BooleanLiteralContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 20, IfcExpressionParser.RULE_booleanLiteral);
+        let localContext = new BooleanLiteralContext(this.context, this.state);
+        this.enterRule(localContext, 22, IfcExpressionParser.RULE_booleanLiteral);
         try {
-            this.enterOuterAlt(localctx, 1);
+            this.enterOuterAlt(localContext, 1);
             {
-                this.state = 113;
+                this.state = 119;
                 this.match(IfcExpressionParser.BOOLEAN);
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -646,24 +684,22 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
     }
-    // @RuleVersion(0)
     logicalLiteral() {
-        let localctx = new LogicalLiteralContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 22, IfcExpressionParser.RULE_logicalLiteral);
+        let localContext = new LogicalLiteralContext(this.context, this.state);
+        this.enterRule(localContext, 24, IfcExpressionParser.RULE_logicalLiteral);
         try {
-            this.enterOuterAlt(localctx, 1);
+            this.enterOuterAlt(localContext, 1);
             {
-                this.state = 115;
+                this.state = 121;
                 this.match(IfcExpressionParser.LOGICAL_UNKNOWN);
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -672,26 +708,24 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
     }
-    // @RuleVersion(0)
     variableRef() {
-        let localctx = new VariableRefContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 24, IfcExpressionParser.RULE_variableRef);
+        let localContext = new VariableRefContext(this.context, this.state);
+        this.enterRule(localContext, 26, IfcExpressionParser.RULE_variableRef);
         try {
-            this.enterOuterAlt(localctx, 1);
+            this.enterOuterAlt(localContext, 1);
             {
-                this.state = 117;
+                this.state = 123;
                 this.match(IfcExpressionParser.T__12);
-                this.state = 118;
+                this.state = 124;
                 this.match(IfcExpressionParser.IDENTIFIER);
             }
         }
         catch (re) {
-            if (re instanceof antlr4_1.RecognitionException) {
-                localctx.exception = re;
-                this._errHandler.reportError(this, re);
-                this._errHandler.recover(this, re);
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
             }
             else {
                 throw re;
@@ -700,39 +734,43 @@ class IfcExpressionParser extends antlr4_1.Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        return localContext;
     }
-    sempred(localctx, ruleIndex, predIndex) {
+    sempred(localContext, ruleIndex, predIndex) {
         switch (ruleIndex) {
             case 1:
-                return this.singleExpr_sempred(localctx, predIndex);
+                return this.singleExpr_sempred(localContext, predIndex);
         }
         return true;
     }
-    singleExpr_sempred(localctx, predIndex) {
+    singleExpr_sempred(localContext, predIndex) {
         switch (predIndex) {
             case 0:
-                return this.precpred(this._ctx, 11);
+                return this.precpred(this.context, 11);
             case 1:
-                return this.precpred(this._ctx, 9);
+                return this.precpred(this.context, 9);
             case 2:
-                return this.precpred(this._ctx, 8);
+                return this.precpred(this.context, 8);
             case 3:
-                return this.precpred(this._ctx, 7);
+                return this.precpred(this.context, 7);
             case 4:
-                return this.precpred(this._ctx, 5);
+                return this.precpred(this.context, 5);
             case 5:
-                return this.precpred(this._ctx, 10);
+                return this.precpred(this.context, 10);
         }
         return true;
     }
     static get _ATN() {
         if (!IfcExpressionParser.__ATN) {
-            IfcExpressionParser.__ATN = new antlr4_1.ATNDeserializer().deserialize(IfcExpressionParser._serializedATN);
+            IfcExpressionParser.__ATN = new antlr.ATNDeserializer().deserialize(IfcExpressionParser._serializedATN);
         }
         return IfcExpressionParser.__ATN;
     }
+    get vocabulary() {
+        return IfcExpressionParser.vocabulary;
+    }
 }
+exports.IfcExpressionParser = IfcExpressionParser;
 IfcExpressionParser.T__0 = 1;
 IfcExpressionParser.T__1 = 2;
 IfcExpressionParser.T__2 = 3;
@@ -757,96 +795,86 @@ IfcExpressionParser.WS = 21;
 IfcExpressionParser.NEWLINE = 22;
 IfcExpressionParser.BOOLEAN_BINARY_OP = 23;
 IfcExpressionParser.CMP_OP = 24;
-IfcExpressionParser.EOF = antlr4_1.Token.EOF;
 IfcExpressionParser.RULE_expr = 0;
 IfcExpressionParser.RULE_singleExpr = 1;
 IfcExpressionParser.RULE_methodCallChain = 2;
-IfcExpressionParser.RULE_functionCall = 3;
-IfcExpressionParser.RULE_exprList = 4;
-IfcExpressionParser.RULE_arrayExpr = 5;
-IfcExpressionParser.RULE_arrayElementList = 6;
-IfcExpressionParser.RULE_literal = 7;
-IfcExpressionParser.RULE_numLiteral = 8;
-IfcExpressionParser.RULE_stringLiteral = 9;
-IfcExpressionParser.RULE_booleanLiteral = 10;
-IfcExpressionParser.RULE_logicalLiteral = 11;
-IfcExpressionParser.RULE_variableRef = 12;
-IfcExpressionParser.literalNames = [null, "'--'",
-    "'('", "')'",
-    "'-'", "'^'",
-    "'*'", "'/'",
-    "'+'", "'!'",
-    "','", "'['",
-    "']'", "'$'",
-    null, null,
-    null, null,
-    "'.'"];
-IfcExpressionParser.symbolicNames = [null, null,
-    null, null,
-    null, null,
-    null, null,
-    null, null,
-    null, null,
-    null, null,
-    "INT", "FLOAT",
-    "BOOLEAN",
-    "LOGICAL_UNKNOWN",
-    "DOT", "QUOTED_STRING",
-    "IDENTIFIER",
-    "WS", "NEWLINE",
-    "BOOLEAN_BINARY_OP",
-    "CMP_OP"];
-// tslint:disable:no-trailing-whitespace
+IfcExpressionParser.RULE_methodAccessor = 3;
+IfcExpressionParser.RULE_functionCall = 4;
+IfcExpressionParser.RULE_exprList = 5;
+IfcExpressionParser.RULE_arrayExpr = 6;
+IfcExpressionParser.RULE_arrayElementList = 7;
+IfcExpressionParser.RULE_literal = 8;
+IfcExpressionParser.RULE_numLiteral = 9;
+IfcExpressionParser.RULE_stringLiteral = 10;
+IfcExpressionParser.RULE_booleanLiteral = 11;
+IfcExpressionParser.RULE_logicalLiteral = 12;
+IfcExpressionParser.RULE_variableRef = 13;
+IfcExpressionParser.literalNames = [
+    null, "'--'", "'('", "')'", "'-'", "'^'", "'*'", "'/'", "'+'", "'!'",
+    "','", "'['", "']'", "'$'", null, null, null, null, "'.'"
+];
+IfcExpressionParser.symbolicNames = [
+    null, null, null, null, null, null, null, null, null, null, null,
+    null, null, null, "INT", "FLOAT", "BOOLEAN", "LOGICAL_UNKNOWN",
+    "DOT", "QUOTED_STRING", "IDENTIFIER", "WS", "NEWLINE", "BOOLEAN_BINARY_OP",
+    "CMP_OP"
+];
 IfcExpressionParser.ruleNames = [
-    "expr", "singleExpr", "methodCallChain", "functionCall", "exprList", "arrayExpr",
-    "arrayElementList", "literal", "numLiteral", "stringLiteral", "booleanLiteral",
-    "logicalLiteral", "variableRef",
+    "expr", "singleExpr", "methodCallChain", "methodAccessor", "functionCall",
+    "exprList", "arrayExpr", "arrayElementList", "literal", "numLiteral",
+    "stringLiteral", "booleanLiteral", "logicalLiteral", "variableRef",
+];
+IfcExpressionParser._serializedATN = [
+    4, 1, 24, 127, 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,
+    1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 3, 1, 47, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 66, 8, 1, 10, 1, 12, 1, 69, 9, 1, 1, 2, 1, 2, 1, 2, 1,
+    2, 1, 2, 1, 2, 3, 2, 77, 8, 2, 1, 3, 1, 3, 3, 3, 81, 8, 3, 1, 4, 1, 4, 1, 4, 3, 4, 86, 8, 4, 1,
+    4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 95, 8, 5, 1, 6, 1, 6, 3, 6, 99, 8, 6, 1, 6, 1, 6,
+    1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 108, 8, 7, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 114, 8, 8, 1, 9,
+    1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 0, 1, 2, 14, 0,
+    2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 0, 3, 1, 0, 6, 7, 2, 0, 4, 4, 8, 8, 1, 0, 14,
+    15, 134, 0, 28, 1, 0, 0, 0, 2, 46, 1, 0, 0, 0, 4, 76, 1, 0, 0, 0, 6, 80, 1, 0, 0, 0, 8, 82,
+    1, 0, 0, 0, 10, 94, 1, 0, 0, 0, 12, 96, 1, 0, 0, 0, 14, 107, 1, 0, 0, 0, 16, 113, 1, 0, 0,
+    0, 18, 115, 1, 0, 0, 0, 20, 117, 1, 0, 0, 0, 22, 119, 1, 0, 0, 0, 24, 121, 1, 0, 0, 0, 26,
+    123, 1, 0, 0, 0, 28, 29, 3, 2, 1, 0, 29, 30, 5, 0, 0, 1, 30, 1, 1, 0, 0, 0, 31, 32, 6, 1, -1,
+    0, 32, 33, 5, 1, 0, 0, 33, 47, 3, 2, 1, 14, 34, 35, 5, 2, 0, 0, 35, 36, 3, 2, 1, 0, 36, 37,
+    5, 3, 0, 0, 37, 47, 1, 0, 0, 0, 38, 39, 5, 4, 0, 0, 39, 47, 3, 2, 1, 12, 40, 41, 5, 9, 0, 0,
+    41, 47, 3, 2, 1, 6, 42, 47, 3, 26, 13, 0, 43, 47, 3, 8, 4, 0, 44, 47, 3, 16, 8, 0, 45, 47,
+    3, 12, 6, 0, 46, 31, 1, 0, 0, 0, 46, 34, 1, 0, 0, 0, 46, 38, 1, 0, 0, 0, 46, 40, 1, 0, 0, 0,
+    46, 42, 1, 0, 0, 0, 46, 43, 1, 0, 0, 0, 46, 44, 1, 0, 0, 0, 46, 45, 1, 0, 0, 0, 47, 67, 1,
+    0, 0, 0, 48, 49, 10, 11, 0, 0, 49, 50, 5, 5, 0, 0, 50, 66, 3, 2, 1, 11, 51, 52, 10, 9, 0,
+    0, 52, 53, 7, 0, 0, 0, 53, 66, 3, 2, 1, 10, 54, 55, 10, 8, 0, 0, 55, 56, 7, 1, 0, 0, 56, 66,
+    3, 2, 1, 9, 57, 58, 10, 7, 0, 0, 58, 59, 5, 24, 0, 0, 59, 66, 3, 2, 1, 8, 60, 61, 10, 5, 0,
+    0, 61, 62, 5, 23, 0, 0, 62, 66, 3, 2, 1, 6, 63, 64, 10, 10, 0, 0, 64, 66, 3, 4, 2, 0, 65,
+    48, 1, 0, 0, 0, 65, 51, 1, 0, 0, 0, 65, 54, 1, 0, 0, 0, 65, 57, 1, 0, 0, 0, 65, 60, 1, 0, 0,
+    0, 65, 63, 1, 0, 0, 0, 66, 69, 1, 0, 0, 0, 67, 65, 1, 0, 0, 0, 67, 68, 1, 0, 0, 0, 68, 3, 1,
+    0, 0, 0, 69, 67, 1, 0, 0, 0, 70, 71, 5, 18, 0, 0, 71, 72, 3, 6, 3, 0, 72, 73, 3, 4, 2, 0, 73,
+    77, 1, 0, 0, 0, 74, 75, 5, 18, 0, 0, 75, 77, 3, 6, 3, 0, 76, 70, 1, 0, 0, 0, 76, 74, 1, 0,
+    0, 0, 77, 5, 1, 0, 0, 0, 78, 81, 3, 8, 4, 0, 79, 81, 5, 20, 0, 0, 80, 78, 1, 0, 0, 0, 80, 79,
+    1, 0, 0, 0, 81, 7, 1, 0, 0, 0, 82, 83, 5, 20, 0, 0, 83, 85, 5, 2, 0, 0, 84, 86, 3, 10, 5, 0,
+    85, 84, 1, 0, 0, 0, 85, 86, 1, 0, 0, 0, 86, 87, 1, 0, 0, 0, 87, 88, 5, 3, 0, 0, 88, 9, 1, 0,
+    0, 0, 89, 95, 3, 2, 1, 0, 90, 91, 3, 2, 1, 0, 91, 92, 5, 10, 0, 0, 92, 93, 3, 10, 5, 0, 93,
+    95, 1, 0, 0, 0, 94, 89, 1, 0, 0, 0, 94, 90, 1, 0, 0, 0, 95, 11, 1, 0, 0, 0, 96, 98, 5, 11,
+    0, 0, 97, 99, 3, 14, 7, 0, 98, 97, 1, 0, 0, 0, 98, 99, 1, 0, 0, 0, 99, 100, 1, 0, 0, 0, 100,
+    101, 5, 12, 0, 0, 101, 13, 1, 0, 0, 0, 102, 108, 3, 2, 1, 0, 103, 104, 3, 2, 1, 0, 104,
+    105, 5, 10, 0, 0, 105, 106, 3, 14, 7, 0, 106, 108, 1, 0, 0, 0, 107, 102, 1, 0, 0, 0, 107,
+    103, 1, 0, 0, 0, 108, 15, 1, 0, 0, 0, 109, 114, 3, 18, 9, 0, 110, 114, 3, 20, 10, 0, 111,
+    114, 3, 22, 11, 0, 112, 114, 3, 24, 12, 0, 113, 109, 1, 0, 0, 0, 113, 110, 1, 0, 0, 0,
+    113, 111, 1, 0, 0, 0, 113, 112, 1, 0, 0, 0, 114, 17, 1, 0, 0, 0, 115, 116, 7, 2, 0, 0, 116,
+    19, 1, 0, 0, 0, 117, 118, 5, 19, 0, 0, 118, 21, 1, 0, 0, 0, 119, 120, 5, 16, 0, 0, 120,
+    23, 1, 0, 0, 0, 121, 122, 5, 17, 0, 0, 122, 25, 1, 0, 0, 0, 123, 124, 5, 13, 0, 0, 124,
+    125, 5, 20, 0, 0, 125, 27, 1, 0, 0, 0, 10, 46, 65, 67, 76, 80, 85, 94, 98, 107, 113
 ];
-IfcExpressionParser._serializedATN = [4, 1, 24, 121, 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, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 45, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 64, 8, 1, 10, 1, 12, 1, 67, 9, 1, 1, 2, 1, 2,
-    1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 75, 8, 2, 1, 3, 1, 3, 1, 3, 3, 3, 80, 8, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1,
-    4, 1, 4, 3, 4, 89, 8, 4, 1, 5, 1, 5, 3, 5, 93, 8, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 102,
-    8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 108, 8, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12,
-    1, 12, 1, 12, 1, 12, 0, 1, 2, 13, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 0, 3, 1, 0, 6, 7, 2,
-    0, 4, 4, 8, 8, 1, 0, 14, 15, 128, 0, 26, 1, 0, 0, 0, 2, 44, 1, 0, 0, 0, 4, 74, 1, 0, 0, 0, 6, 76, 1, 0,
-    0, 0, 8, 88, 1, 0, 0, 0, 10, 90, 1, 0, 0, 0, 12, 101, 1, 0, 0, 0, 14, 107, 1, 0, 0, 0, 16, 109, 1, 0,
-    0, 0, 18, 111, 1, 0, 0, 0, 20, 113, 1, 0, 0, 0, 22, 115, 1, 0, 0, 0, 24, 117, 1, 0, 0, 0, 26, 27, 3,
-    2, 1, 0, 27, 28, 5, 0, 0, 1, 28, 1, 1, 0, 0, 0, 29, 30, 6, 1, -1, 0, 30, 31, 5, 1, 0, 0, 31, 45, 3, 2,
-    1, 14, 32, 33, 5, 2, 0, 0, 33, 34, 3, 2, 1, 0, 34, 35, 5, 3, 0, 0, 35, 45, 1, 0, 0, 0, 36, 37, 5, 4,
-    0, 0, 37, 45, 3, 2, 1, 12, 38, 39, 5, 9, 0, 0, 39, 45, 3, 2, 1, 6, 40, 45, 3, 24, 12, 0, 41, 45, 3,
-    6, 3, 0, 42, 45, 3, 14, 7, 0, 43, 45, 3, 10, 5, 0, 44, 29, 1, 0, 0, 0, 44, 32, 1, 0, 0, 0, 44, 36, 1,
-    0, 0, 0, 44, 38, 1, 0, 0, 0, 44, 40, 1, 0, 0, 0, 44, 41, 1, 0, 0, 0, 44, 42, 1, 0, 0, 0, 44, 43, 1, 0,
-    0, 0, 45, 65, 1, 0, 0, 0, 46, 47, 10, 11, 0, 0, 47, 48, 5, 5, 0, 0, 48, 64, 3, 2, 1, 11, 49, 50, 10,
-    9, 0, 0, 50, 51, 7, 0, 0, 0, 51, 64, 3, 2, 1, 10, 52, 53, 10, 8, 0, 0, 53, 54, 7, 1, 0, 0, 54, 64, 3,
-    2, 1, 9, 55, 56, 10, 7, 0, 0, 56, 57, 5, 24, 0, 0, 57, 64, 3, 2, 1, 8, 58, 59, 10, 5, 0, 0, 59, 60,
-    5, 23, 0, 0, 60, 64, 3, 2, 1, 6, 61, 62, 10, 10, 0, 0, 62, 64, 3, 4, 2, 0, 63, 46, 1, 0, 0, 0, 63, 49,
-    1, 0, 0, 0, 63, 52, 1, 0, 0, 0, 63, 55, 1, 0, 0, 0, 63, 58, 1, 0, 0, 0, 63, 61, 1, 0, 0, 0, 64, 67, 1,
-    0, 0, 0, 65, 63, 1, 0, 0, 0, 65, 66, 1, 0, 0, 0, 66, 3, 1, 0, 0, 0, 67, 65, 1, 0, 0, 0, 68, 69, 5, 18,
-    0, 0, 69, 70, 3, 6, 3, 0, 70, 71, 3, 4, 2, 0, 71, 75, 1, 0, 0, 0, 72, 73, 5, 18, 0, 0, 73, 75, 3, 6,
-    3, 0, 74, 68, 1, 0, 0, 0, 74, 72, 1, 0, 0, 0, 75, 5, 1, 0, 0, 0, 76, 77, 5, 20, 0, 0, 77, 79, 5, 2, 0,
-    0, 78, 80, 3, 8, 4, 0, 79, 78, 1, 0, 0, 0, 79, 80, 1, 0, 0, 0, 80, 81, 1, 0, 0, 0, 81, 82, 5, 3, 0, 0,
-    82, 7, 1, 0, 0, 0, 83, 89, 3, 2, 1, 0, 84, 85, 3, 2, 1, 0, 85, 86, 5, 10, 0, 0, 86, 87, 3, 8, 4, 0, 87,
-    89, 1, 0, 0, 0, 88, 83, 1, 0, 0, 0, 88, 84, 1, 0, 0, 0, 89, 9, 1, 0, 0, 0, 90, 92, 5, 11, 0, 0, 91, 93,
-    3, 12, 6, 0, 92, 91, 1, 0, 0, 0, 92, 93, 1, 0, 0, 0, 93, 94, 1, 0, 0, 0, 94, 95, 5, 12, 0, 0, 95, 11,
-    1, 0, 0, 0, 96, 102, 3, 2, 1, 0, 97, 98, 3, 2, 1, 0, 98, 99, 5, 10, 0, 0, 99, 100, 3, 12, 6, 0, 100,
-    102, 1, 0, 0, 0, 101, 96, 1, 0, 0, 0, 101, 97, 1, 0, 0, 0, 102, 13, 1, 0, 0, 0, 103, 108, 3, 16, 8,
-    0, 104, 108, 3, 18, 9, 0, 105, 108, 3, 20, 10, 0, 106, 108, 3, 22, 11, 0, 107, 103, 1, 0, 0, 0,
-    107, 104, 1, 0, 0, 0, 107, 105, 1, 0, 0, 0, 107, 106, 1, 0, 0, 0, 108, 15, 1, 0, 0, 0, 109, 110,
-    7, 2, 0, 0, 110, 17, 1, 0, 0, 0, 111, 112, 5, 19, 0, 0, 112, 19, 1, 0, 0, 0, 113, 114, 5, 16, 0, 0,
-    114, 21, 1, 0, 0, 0, 115, 116, 5, 17, 0, 0, 116, 23, 1, 0, 0, 0, 117, 118, 5, 13, 0, 0, 118, 119,
-    5, 20, 0, 0, 119, 25, 1, 0, 0, 0, 9, 44, 63, 65, 74, 79, 88, 92, 101, 107];
-IfcExpressionParser.DecisionsToDFA = IfcExpressionParser._ATN.decisionToState.map((ds, index) => new antlr4_1.DFA(ds, index));
-exports.default = IfcExpressionParser;
-class ExprContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+IfcExpressionParser.vocabulary = new antlr.Vocabulary(IfcExpressionParser.literalNames, IfcExpressionParser.symbolicNames, []);
+IfcExpressionParser.decisionsToDFA = IfcExpressionParser._ATN.decisionToState.map((ds, index) => new antlr.DFA(ds, index));
+class ExprContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     singleExpr() {
-        return this.getTypedRuleContext(SingleExprContext, 0);
+        return this.getRuleContext(0, SingleExprContext);
     }
     EOF() {
         return this.getToken(IfcExpressionParser.EOF, 0);
@@ -864,7 +892,6 @@ class ExprContext extends antlr4_1.ParserRuleContext {
             listener.exitExpr(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitExpr) {
             return visitor.visitExpr(this);
@@ -875,10 +902,9 @@ class ExprContext extends antlr4_1.ParserRuleContext {
     }
 }
 exports.ExprContext = ExprContext;
-class SingleExprContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class SingleExprContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     get ruleIndex() {
         return IfcExpressionParser.RULE_singleExpr;
@@ -888,77 +914,41 @@ class SingleExprContext extends antlr4_1.ParserRuleContext {
     }
 }
 exports.SingleExprContext = SingleExprContext;
-class SEComparisonContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
-        super.copyFrom(ctx);
-    }
-    CMP_OP() {
-        return this.getToken(IfcExpressionParser.CMP_OP, 0);
-    }
-    singleExpr_list() {
-        return this.getTypedRuleContexts(SingleExprContext);
-    }
-    singleExpr(i) {
-        return this.getTypedRuleContext(SingleExprContext, i);
-    }
-    enterRule(listener) {
-        if (listener.enterSEComparison) {
-            listener.enterSEComparison(this);
-        }
-    }
-    exitRule(listener) {
-        if (listener.exitSEComparison) {
-            listener.exitSEComparison(this);
-        }
-    }
-    // @Override
-    accept(visitor) {
-        if (visitor.visitSEComparison) {
-            return visitor.visitSEComparison(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-exports.SEComparisonContext = SEComparisonContext;
-class SELiteralContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+class SEUnaryMultipleMinusContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
-    literal() {
-        return this.getTypedRuleContext(LiteralContext, 0);
+    singleExpr() {
+        return this.getRuleContext(0, SingleExprContext);
     }
     enterRule(listener) {
-        if (listener.enterSELiteral) {
-            listener.enterSELiteral(this);
+        if (listener.enterSEUnaryMultipleMinus) {
+            listener.enterSEUnaryMultipleMinus(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSELiteral) {
-            listener.exitSELiteral(this);
+        if (listener.exitSEUnaryMultipleMinus) {
+            listener.exitSEUnaryMultipleMinus(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSELiteral) {
-            return visitor.visitSELiteral(this);
+        if (visitor.visitSEUnaryMultipleMinus) {
+            return visitor.visitSEUnaryMultipleMinus(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-exports.SELiteralContext = SELiteralContext;
+exports.SEUnaryMultipleMinusContext = SEUnaryMultipleMinusContext;
 class SEParenthesisContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
     singleExpr() {
-        return this.getTypedRuleContext(SingleExprContext, 0);
+        return this.getRuleContext(0, SingleExprContext);
     }
     enterRule(listener) {
         if (listener.enterSEParenthesis) {
@@ -970,7 +960,6 @@ class SEParenthesisContext extends SingleExprContext {
             listener.exitSEParenthesis(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitSEParenthesis) {
             return visitor.visitSEParenthesis(this);
@@ -981,112 +970,97 @@ class SEParenthesisContext extends SingleExprContext {
     }
 }
 exports.SEParenthesisContext = SEParenthesisContext;
-class SEMulDivContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+class SEUnaryMinusContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
-    singleExpr_list() {
-        return this.getTypedRuleContexts(SingleExprContext);
-    }
-    singleExpr(i) {
-        return this.getTypedRuleContext(SingleExprContext, i);
+    singleExpr() {
+        return this.getRuleContext(0, SingleExprContext);
     }
     enterRule(listener) {
-        if (listener.enterSEMulDiv) {
-            listener.enterSEMulDiv(this);
+        if (listener.enterSEUnaryMinus) {
+            listener.enterSEUnaryMinus(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEMulDiv) {
-            listener.exitSEMulDiv(this);
+        if (listener.exitSEUnaryMinus) {
+            listener.exitSEUnaryMinus(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEMulDiv) {
-            return visitor.visitSEMulDiv(this);
+        if (visitor.visitSEUnaryMinus) {
+            return visitor.visitSEUnaryMinus(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-exports.SEMulDivContext = SEMulDivContext;
-class SEPowerContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+exports.SEUnaryMinusContext = SEUnaryMinusContext;
+class SENotContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
-    singleExpr_list() {
-        return this.getTypedRuleContexts(SingleExprContext);
-    }
-    singleExpr(i) {
-        return this.getTypedRuleContext(SingleExprContext, i);
+    singleExpr() {
+        return this.getRuleContext(0, SingleExprContext);
     }
     enterRule(listener) {
-        if (listener.enterSEPower) {
-            listener.enterSEPower(this);
+        if (listener.enterSENot) {
+            listener.enterSENot(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEPower) {
-            listener.exitSEPower(this);
+        if (listener.exitSENot) {
+            listener.exitSENot(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEPower) {
-            return visitor.visitSEPower(this);
+        if (visitor.visitSENot) {
+            return visitor.visitSENot(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-exports.SEPowerContext = SEPowerContext;
-class SEBooleanBinaryOpContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+exports.SENotContext = SENotContext;
+class SEVariableRefContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
-    singleExpr_list() {
-        return this.getTypedRuleContexts(SingleExprContext);
-    }
-    singleExpr(i) {
-        return this.getTypedRuleContext(SingleExprContext, i);
-    }
-    BOOLEAN_BINARY_OP() {
-        return this.getToken(IfcExpressionParser.BOOLEAN_BINARY_OP, 0);
+    variableRef() {
+        return this.getRuleContext(0, VariableRefContext);
     }
     enterRule(listener) {
-        if (listener.enterSEBooleanBinaryOp) {
-            listener.enterSEBooleanBinaryOp(this);
+        if (listener.enterSEVariableRef) {
+            listener.enterSEVariableRef(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEBooleanBinaryOp) {
-            listener.exitSEBooleanBinaryOp(this);
+        if (listener.exitSEVariableRef) {
+            listener.exitSEVariableRef(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEBooleanBinaryOp) {
-            return visitor.visitSEBooleanBinaryOp(this);
+        if (visitor.visitSEVariableRef) {
+            return visitor.visitSEVariableRef(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-exports.SEBooleanBinaryOpContext = SEBooleanBinaryOpContext;
+exports.SEVariableRefContext = SEVariableRefContext;
 class SEFunctionCallContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
     functionCall() {
-        return this.getTypedRuleContext(FunctionCallContext, 0);
+        return this.getRuleContext(0, FunctionCallContext);
     }
     enterRule(listener) {
         if (listener.enterSEFunctionCall) {
@@ -1098,7 +1072,6 @@ class SEFunctionCallContext extends SingleExprContext {
             listener.exitSEFunctionCall(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitSEFunctionCall) {
             return visitor.visitSEFunctionCall(this);
@@ -1109,13 +1082,41 @@ class SEFunctionCallContext extends SingleExprContext {
     }
 }
 exports.SEFunctionCallContext = SEFunctionCallContext;
+class SELiteralContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        super.copyFrom(ctx);
+    }
+    literal() {
+        return this.getRuleContext(0, LiteralContext);
+    }
+    enterRule(listener) {
+        if (listener.enterSELiteral) {
+            listener.enterSELiteral(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitSELiteral) {
+            listener.exitSELiteral(this);
+        }
+    }
+    accept(visitor) {
+        if (visitor.visitSELiteral) {
+            return visitor.visitSELiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.SELiteralContext = SELiteralContext;
 class SEArrayExprContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
     arrayExpr() {
-        return this.getTypedRuleContext(ArrayExprContext, 0);
+        return this.getRuleContext(0, ArrayExprContext);
     }
     enterRule(listener) {
         if (listener.enterSEArrayExpr) {
@@ -1127,7 +1128,6 @@ class SEArrayExprContext extends SingleExprContext {
             listener.exitSEArrayExpr(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitSEArrayExpr) {
             return visitor.visitSEArrayExpr(this);
@@ -1138,164 +1138,177 @@ class SEArrayExprContext extends SingleExprContext {
     }
 }
 exports.SEArrayExprContext = SEArrayExprContext;
-class SENotContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+class SEPowerContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
-    singleExpr() {
-        return this.getTypedRuleContext(SingleExprContext, 0);
+    singleExpr(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(SingleExprContext);
+        }
+        return this.getRuleContext(i, SingleExprContext);
     }
     enterRule(listener) {
-        if (listener.enterSENot) {
-            listener.enterSENot(this);
+        if (listener.enterSEPower) {
+            listener.enterSEPower(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSENot) {
-            listener.exitSENot(this);
+        if (listener.exitSEPower) {
+            listener.exitSEPower(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSENot) {
-            return visitor.visitSENot(this);
+        if (visitor.visitSEPower) {
+            return visitor.visitSEPower(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-exports.SENotContext = SENotContext;
-class SEVariableRefContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+exports.SEPowerContext = SEPowerContext;
+class SEMulDivContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
-    variableRef() {
-        return this.getTypedRuleContext(VariableRefContext, 0);
+    singleExpr(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(SingleExprContext);
+        }
+        return this.getRuleContext(i, SingleExprContext);
     }
     enterRule(listener) {
-        if (listener.enterSEVariableRef) {
-            listener.enterSEVariableRef(this);
+        if (listener.enterSEMulDiv) {
+            listener.enterSEMulDiv(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEVariableRef) {
-            listener.exitSEVariableRef(this);
+        if (listener.exitSEMulDiv) {
+            listener.exitSEMulDiv(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEVariableRef) {
-            return visitor.visitSEVariableRef(this);
+        if (visitor.visitSEMulDiv) {
+            return visitor.visitSEMulDiv(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-exports.SEVariableRefContext = SEVariableRefContext;
-class SEUnaryMultipleMinusContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+exports.SEMulDivContext = SEMulDivContext;
+class SEAddSubContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
-    singleExpr() {
-        return this.getTypedRuleContext(SingleExprContext, 0);
+    singleExpr(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(SingleExprContext);
+        }
+        return this.getRuleContext(i, SingleExprContext);
     }
     enterRule(listener) {
-        if (listener.enterSEUnaryMultipleMinus) {
-            listener.enterSEUnaryMultipleMinus(this);
+        if (listener.enterSEAddSub) {
+            listener.enterSEAddSub(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEUnaryMultipleMinus) {
-            listener.exitSEUnaryMultipleMinus(this);
+        if (listener.exitSEAddSub) {
+            listener.exitSEAddSub(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEUnaryMultipleMinus) {
-            return visitor.visitSEUnaryMultipleMinus(this);
+        if (visitor.visitSEAddSub) {
+            return visitor.visitSEAddSub(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-exports.SEUnaryMultipleMinusContext = SEUnaryMultipleMinusContext;
-class SEUnaryMinusContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+exports.SEAddSubContext = SEAddSubContext;
+class SEComparisonContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
-    singleExpr() {
-        return this.getTypedRuleContext(SingleExprContext, 0);
+    CMP_OP() {
+        return this.getToken(IfcExpressionParser.CMP_OP, 0);
+    }
+    singleExpr(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(SingleExprContext);
+        }
+        return this.getRuleContext(i, SingleExprContext);
     }
     enterRule(listener) {
-        if (listener.enterSEUnaryMinus) {
-            listener.enterSEUnaryMinus(this);
+        if (listener.enterSEComparison) {
+            listener.enterSEComparison(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEUnaryMinus) {
-            listener.exitSEUnaryMinus(this);
+        if (listener.exitSEComparison) {
+            listener.exitSEComparison(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEUnaryMinus) {
-            return visitor.visitSEUnaryMinus(this);
+        if (visitor.visitSEComparison) {
+            return visitor.visitSEComparison(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-exports.SEUnaryMinusContext = SEUnaryMinusContext;
-class SEAddSubContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+exports.SEComparisonContext = SEComparisonContext;
+class SEBooleanBinaryOpContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
-    singleExpr_list() {
-        return this.getTypedRuleContexts(SingleExprContext);
-    }
     singleExpr(i) {
-        return this.getTypedRuleContext(SingleExprContext, i);
+        if (i === undefined) {
+            return this.getRuleContexts(SingleExprContext);
+        }
+        return this.getRuleContext(i, SingleExprContext);
+    }
+    BOOLEAN_BINARY_OP() {
+        return this.getToken(IfcExpressionParser.BOOLEAN_BINARY_OP, 0);
     }
     enterRule(listener) {
-        if (listener.enterSEAddSub) {
-            listener.enterSEAddSub(this);
+        if (listener.enterSEBooleanBinaryOp) {
+            listener.enterSEBooleanBinaryOp(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEAddSub) {
-            listener.exitSEAddSub(this);
+        if (listener.exitSEBooleanBinaryOp) {
+            listener.exitSEBooleanBinaryOp(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEAddSub) {
-            return visitor.visitSEAddSub(this);
+        if (visitor.visitSEBooleanBinaryOp) {
+            return visitor.visitSEBooleanBinaryOp(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-exports.SEAddSubContext = SEAddSubContext;
+exports.SEBooleanBinaryOpContext = SEBooleanBinaryOpContext;
 class SEMethodCallContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
     singleExpr() {
-        return this.getTypedRuleContext(SingleExprContext, 0);
+        return this.getRuleContext(0, SingleExprContext);
     }
     methodCallChain() {
-        return this.getTypedRuleContext(MethodCallChainContext, 0);
+        return this.getRuleContext(0, MethodCallChainContext);
     }
     enterRule(listener) {
         if (listener.enterSEMethodCall) {
@@ -1307,7 +1320,6 @@ class SEMethodCallContext extends SingleExprContext {
             listener.exitSEMethodCall(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitSEMethodCall) {
             return visitor.visitSEMethodCall(this);
@@ -1318,10 +1330,9 @@ class SEMethodCallContext extends SingleExprContext {
     }
 }
 exports.SEMethodCallContext = SEMethodCallContext;
-class MethodCallChainContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class MethodCallChainContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     get ruleIndex() {
         return IfcExpressionParser.RULE_methodCallChain;
@@ -1332,18 +1343,18 @@ class MethodCallChainContext extends antlr4_1.ParserRuleContext {
 }
 exports.MethodCallChainContext = MethodCallChainContext;
 class MethodCallChainInnerContext extends MethodCallChainContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
     DOT() {
         return this.getToken(IfcExpressionParser.DOT, 0);
     }
-    functionCall() {
-        return this.getTypedRuleContext(FunctionCallContext, 0);
+    methodAccessor() {
+        return this.getRuleContext(0, MethodAccessorContext);
     }
     methodCallChain() {
-        return this.getTypedRuleContext(MethodCallChainContext, 0);
+        return this.getRuleContext(0, MethodCallChainContext);
     }
     enterRule(listener) {
         if (listener.enterMethodCallChainInner) {
@@ -1355,7 +1366,6 @@ class MethodCallChainInnerContext extends MethodCallChainContext {
             listener.exitMethodCallChainInner(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitMethodCallChainInner) {
             return visitor.visitMethodCallChainInner(this);
@@ -1367,15 +1377,15 @@ class MethodCallChainInnerContext extends MethodCallChainContext {
 }
 exports.MethodCallChainInnerContext = MethodCallChainInnerContext;
 class MethodCallChainEndContext extends MethodCallChainContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
     DOT() {
         return this.getToken(IfcExpressionParser.DOT, 0);
     }
-    functionCall() {
-        return this.getTypedRuleContext(FunctionCallContext, 0);
+    methodAccessor() {
+        return this.getRuleContext(0, MethodAccessorContext);
     }
     enterRule(listener) {
         if (listener.enterMethodCallChainEnd) {
@@ -1387,7 +1397,6 @@ class MethodCallChainEndContext extends MethodCallChainContext {
             listener.exitMethodCallChainEnd(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitMethodCallChainEnd) {
             return visitor.visitMethodCallChainEnd(this);
@@ -1398,16 +1407,83 @@ class MethodCallChainEndContext extends MethodCallChainContext {
     }
 }
 exports.MethodCallChainEndContext = MethodCallChainEndContext;
-class FunctionCallContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class MethodAccessorContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return IfcExpressionParser.RULE_methodAccessor;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+exports.MethodAccessorContext = MethodAccessorContext;
+class MethodFunctionCallContext extends MethodAccessorContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        super.copyFrom(ctx);
+    }
+    functionCall() {
+        return this.getRuleContext(0, FunctionCallContext);
+    }
+    enterRule(listener) {
+        if (listener.enterMethodFunctionCall) {
+            listener.enterMethodFunctionCall(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitMethodFunctionCall) {
+            listener.exitMethodFunctionCall(this);
+        }
+    }
+    accept(visitor) {
+        if (visitor.visitMethodFunctionCall) {
+            return visitor.visitMethodFunctionCall(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.MethodFunctionCallContext = MethodFunctionCallContext;
+class MethodPropertyAccessContext extends MethodAccessorContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        super.copyFrom(ctx);
+    }
+    IDENTIFIER() {
+        return this.getToken(IfcExpressionParser.IDENTIFIER, 0);
+    }
+    enterRule(listener) {
+        if (listener.enterMethodPropertyAccess) {
+            listener.enterMethodPropertyAccess(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitMethodPropertyAccess) {
+            listener.exitMethodPropertyAccess(this);
+        }
+    }
+    accept(visitor) {
+        if (visitor.visitMethodPropertyAccess) {
+            return visitor.visitMethodPropertyAccess(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.MethodPropertyAccessContext = MethodPropertyAccessContext;
+class FunctionCallContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     IDENTIFIER() {
         return this.getToken(IfcExpressionParser.IDENTIFIER, 0);
     }
     exprList() {
-        return this.getTypedRuleContext(ExprListContext, 0);
+        return this.getRuleContext(0, ExprListContext);
     }
     get ruleIndex() {
         return IfcExpressionParser.RULE_functionCall;
@@ -1422,7 +1498,6 @@ class FunctionCallContext extends antlr4_1.ParserRuleContext {
             listener.exitFunctionCall(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitFunctionCall) {
             return visitor.visitFunctionCall(this);
@@ -1433,16 +1508,15 @@ class FunctionCallContext extends antlr4_1.ParserRuleContext {
     }
 }
 exports.FunctionCallContext = FunctionCallContext;
-class ExprListContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class ExprListContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     singleExpr() {
-        return this.getTypedRuleContext(SingleExprContext, 0);
+        return this.getRuleContext(0, SingleExprContext);
     }
     exprList() {
-        return this.getTypedRuleContext(ExprListContext, 0);
+        return this.getRuleContext(0, ExprListContext);
     }
     get ruleIndex() {
         return IfcExpressionParser.RULE_exprList;
@@ -1457,7 +1531,6 @@ class ExprListContext extends antlr4_1.ParserRuleContext {
             listener.exitExprList(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitExprList) {
             return visitor.visitExprList(this);
@@ -1468,13 +1541,12 @@ class ExprListContext extends antlr4_1.ParserRuleContext {
     }
 }
 exports.ExprListContext = ExprListContext;
-class ArrayExprContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class ArrayExprContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     arrayElementList() {
-        return this.getTypedRuleContext(ArrayElementListContext, 0);
+        return this.getRuleContext(0, ArrayElementListContext);
     }
     get ruleIndex() {
         return IfcExpressionParser.RULE_arrayExpr;
@@ -1489,7 +1561,6 @@ class ArrayExprContext extends antlr4_1.ParserRuleContext {
             listener.exitArrayExpr(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitArrayExpr) {
             return visitor.visitArrayExpr(this);
@@ -1500,16 +1571,15 @@ class ArrayExprContext extends antlr4_1.ParserRuleContext {
     }
 }
 exports.ArrayExprContext = ArrayExprContext;
-class ArrayElementListContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class ArrayElementListContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     singleExpr() {
-        return this.getTypedRuleContext(SingleExprContext, 0);
+        return this.getRuleContext(0, SingleExprContext);
     }
     arrayElementList() {
-        return this.getTypedRuleContext(ArrayElementListContext, 0);
+        return this.getRuleContext(0, ArrayElementListContext);
     }
     get ruleIndex() {
         return IfcExpressionParser.RULE_arrayElementList;
@@ -1524,7 +1594,6 @@ class ArrayElementListContext extends antlr4_1.ParserRuleContext {
             listener.exitArrayElementList(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitArrayElementList) {
             return visitor.visitArrayElementList(this);
@@ -1535,22 +1604,21 @@ class ArrayElementListContext extends antlr4_1.ParserRuleContext {
     }
 }
 exports.ArrayElementListContext = ArrayElementListContext;
-class LiteralContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class LiteralContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     numLiteral() {
-        return this.getTypedRuleContext(NumLiteralContext, 0);
+        return this.getRuleContext(0, NumLiteralContext);
     }
     stringLiteral() {
-        return this.getTypedRuleContext(StringLiteralContext, 0);
+        return this.getRuleContext(0, StringLiteralContext);
     }
     booleanLiteral() {
-        return this.getTypedRuleContext(BooleanLiteralContext, 0);
+        return this.getRuleContext(0, BooleanLiteralContext);
     }
     logicalLiteral() {
-        return this.getTypedRuleContext(LogicalLiteralContext, 0);
+        return this.getRuleContext(0, LogicalLiteralContext);
     }
     get ruleIndex() {
         return IfcExpressionParser.RULE_literal;
@@ -1565,7 +1633,6 @@ class LiteralContext extends antlr4_1.ParserRuleContext {
             listener.exitLiteral(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitLiteral) {
             return visitor.visitLiteral(this);
@@ -1576,10 +1643,9 @@ class LiteralContext extends antlr4_1.ParserRuleContext {
     }
 }
 exports.LiteralContext = LiteralContext;
-class NumLiteralContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class NumLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     INT() {
         return this.getToken(IfcExpressionParser.INT, 0);
@@ -1600,7 +1666,6 @@ class NumLiteralContext extends antlr4_1.ParserRuleContext {
             listener.exitNumLiteral(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitNumLiteral) {
             return visitor.visitNumLiteral(this);
@@ -1611,10 +1676,9 @@ class NumLiteralContext extends antlr4_1.ParserRuleContext {
     }
 }
 exports.NumLiteralContext = NumLiteralContext;
-class StringLiteralContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class StringLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     QUOTED_STRING() {
         return this.getToken(IfcExpressionParser.QUOTED_STRING, 0);
@@ -1632,7 +1696,6 @@ class StringLiteralContext extends antlr4_1.ParserRuleContext {
             listener.exitStringLiteral(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitStringLiteral) {
             return visitor.visitStringLiteral(this);
@@ -1643,10 +1706,9 @@ class StringLiteralContext extends antlr4_1.ParserRuleContext {
     }
 }
 exports.StringLiteralContext = StringLiteralContext;
-class BooleanLiteralContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class BooleanLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     BOOLEAN() {
         return this.getToken(IfcExpressionParser.BOOLEAN, 0);
@@ -1664,7 +1726,6 @@ class BooleanLiteralContext extends antlr4_1.ParserRuleContext {
             listener.exitBooleanLiteral(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitBooleanLiteral) {
             return visitor.visitBooleanLiteral(this);
@@ -1675,10 +1736,9 @@ class BooleanLiteralContext extends antlr4_1.ParserRuleContext {
     }
 }
 exports.BooleanLiteralContext = BooleanLiteralContext;
-class LogicalLiteralContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class LogicalLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     LOGICAL_UNKNOWN() {
         return this.getToken(IfcExpressionParser.LOGICAL_UNKNOWN, 0);
@@ -1696,7 +1756,6 @@ class LogicalLiteralContext extends antlr4_1.ParserRuleContext {
             listener.exitLogicalLiteral(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitLogicalLiteral) {
             return visitor.visitLogicalLiteral(this);
@@ -1707,10 +1766,9 @@ class LogicalLiteralContext extends antlr4_1.ParserRuleContext {
     }
 }
 exports.LogicalLiteralContext = LogicalLiteralContext;
-class VariableRefContext extends antlr4_1.ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+class VariableRefContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     IDENTIFIER() {
         return this.getToken(IfcExpressionParser.IDENTIFIER, 0);
@@ -1728,7 +1786,6 @@ class VariableRefContext extends antlr4_1.ParserRuleContext {
             listener.exitVariableRef(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitVariableRef) {
             return visitor.visitVariableRef(this);