ifc-expressions 2.3.0 → 3.0.0-beta.2

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

@@ -1,37 +1,33 @@
-// Generated from IfcExpression.g4 by ANTLR 4.13.0
-// noinspection ES6UnusedImports,JSUnusedGlobalSymbols,JSUnusedLocalSymbols
-import { ATN, ATNDeserializer, DFA, FailedPredicateException, RecognitionException, NoViableAltException, Parser, ParserATNSimulator, ParserRuleContext, PredictionContextCache, Token } from 'antlr4';
-class IfcExpressionParser extends Parser {
+import * as antlr from "antlr4ng";
+export 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 FailedPredicateException(this, predicate, message);
+        return new antlr.FailedPredicateException(this, predicate, message);
     }
     constructor(input) {
         super(input);
-        this._interp = new ParserATNSimulator(this, IfcExpressionParser._ATN, IfcExpressionParser.DecisionsToDFA, new 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 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;
@@ -40,295 +36,330 @@ class IfcExpressionParser extends 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 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 !== 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 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 antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        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 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;
@@ -337,38 +368,36 @@ class IfcExpressionParser extends Parser {
         finally {
             this.exitRule();
         }
-        return localctx;
+        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 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;
@@ -377,41 +406,39 @@ class IfcExpressionParser extends 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 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;
@@ -420,36 +447,34 @@ class IfcExpressionParser extends 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 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;
@@ -458,41 +483,39 @@ class IfcExpressionParser extends 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 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;
@@ -501,54 +524,52 @@ class IfcExpressionParser extends 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 NoViableAltException(this);
+                    throw new antlr.NoViableAltException(this);
             }
         }
         catch (re) {
-            if (re instanceof 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;
@@ -557,32 +578,30 @@ class IfcExpressionParser extends 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 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;
@@ -591,24 +610,22 @@ class IfcExpressionParser extends 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 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;
@@ -617,24 +634,22 @@ class IfcExpressionParser extends 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 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;
@@ -643,24 +658,22 @@ class IfcExpressionParser extends 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 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;
@@ -669,26 +682,24 @@ class IfcExpressionParser extends 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 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;
@@ -697,38 +708,41 @@ class IfcExpressionParser extends 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 ATNDeserializer().deserialize(IfcExpressionParser._serializedATN);
+            IfcExpressionParser.__ATN = new antlr.ATNDeserializer().deserialize(IfcExpressionParser._serializedATN);
         }
         return IfcExpressionParser.__ATN;
     }
+    get vocabulary() {
+        return IfcExpressionParser.vocabulary;
+    }
 }
 IfcExpressionParser.T__0 = 1;
 IfcExpressionParser.T__1 = 2;
@@ -754,96 +768,86 @@ IfcExpressionParser.WS = 21;
 IfcExpressionParser.NEWLINE = 22;
 IfcExpressionParser.BOOLEAN_BINARY_OP = 23;
 IfcExpressionParser.CMP_OP = 24;
-IfcExpressionParser.EOF = 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, 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 DFA(ds, index));
-export default IfcExpressionParser;
-export class ExprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+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.vocabulary = new antlr.Vocabulary(IfcExpressionParser.literalNames, IfcExpressionParser.symbolicNames, []);
+IfcExpressionParser.decisionsToDFA = IfcExpressionParser._ATN.decisionToState.map((ds, index) => new antlr.DFA(ds, index));
+export 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);
@@ -861,7 +865,6 @@ export class ExprContext extends ParserRuleContext {
             listener.exitExpr(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitExpr) {
             return visitor.visitExpr(this);
@@ -871,10 +874,9 @@ export class ExprContext extends ParserRuleContext {
         }
     }
 }
-export class SingleExprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export class SingleExprContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     get ruleIndex() {
         return IfcExpressionParser.RULE_singleExpr;
@@ -883,214 +885,189 @@ export class SingleExprContext extends ParserRuleContext {
         super.copyFrom(ctx);
     }
 }
-export class SEComparisonContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export class SEUnaryMultipleMinusContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, 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);
+    singleExpr() {
+        return this.getRuleContext(0, SingleExprContext);
     }
     enterRule(listener) {
-        if (listener.enterSEComparison) {
-            listener.enterSEComparison(this);
+        if (listener.enterSEUnaryMultipleMinus) {
+            listener.enterSEUnaryMultipleMinus(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEComparison) {
-            listener.exitSEComparison(this);
+        if (listener.exitSEUnaryMultipleMinus) {
+            listener.exitSEUnaryMultipleMinus(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEComparison) {
-            return visitor.visitSEComparison(this);
+        if (visitor.visitSEUnaryMultipleMinus) {
+            return visitor.visitSEUnaryMultipleMinus(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-export class SELiteralContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export class SEParenthesisContext 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.enterSEParenthesis) {
+            listener.enterSEParenthesis(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSELiteral) {
-            listener.exitSELiteral(this);
+        if (listener.exitSEParenthesis) {
+            listener.exitSEParenthesis(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSELiteral) {
-            return visitor.visitSELiteral(this);
+        if (visitor.visitSEParenthesis) {
+            return visitor.visitSEParenthesis(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-export class SEParenthesisContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export class SEUnaryMinusContext extends SingleExprContext {
+    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) {
-            listener.enterSEParenthesis(this);
+        if (listener.enterSEUnaryMinus) {
+            listener.enterSEUnaryMinus(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEParenthesis) {
-            listener.exitSEParenthesis(this);
+        if (listener.exitSEUnaryMinus) {
+            listener.exitSEUnaryMinus(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEParenthesis) {
-            return visitor.visitSEParenthesis(this);
+        if (visitor.visitSEUnaryMinus) {
+            return visitor.visitSEUnaryMinus(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-export class SEMulDivContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export 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.enterSEMulDiv) {
-            listener.enterSEMulDiv(this);
+        if (listener.enterSENot) {
+            listener.enterSENot(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEMulDiv) {
-            listener.exitSEMulDiv(this);
+        if (listener.exitSENot) {
+            listener.exitSENot(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEMulDiv) {
-            return visitor.visitSEMulDiv(this);
+        if (visitor.visitSENot) {
+            return visitor.visitSENot(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-export class SEPowerContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export 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);
+    variableRef() {
+        return this.getRuleContext(0, VariableRefContext);
     }
     enterRule(listener) {
-        if (listener.enterSEPower) {
-            listener.enterSEPower(this);
+        if (listener.enterSEVariableRef) {
+            listener.enterSEVariableRef(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEPower) {
-            listener.exitSEPower(this);
+        if (listener.exitSEVariableRef) {
+            listener.exitSEVariableRef(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEPower) {
-            return visitor.visitSEPower(this);
+        if (visitor.visitSEVariableRef) {
+            return visitor.visitSEVariableRef(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-export class SEBooleanBinaryOpContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export class SEFunctionCallContext 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);
+    functionCall() {
+        return this.getRuleContext(0, FunctionCallContext);
     }
     enterRule(listener) {
-        if (listener.enterSEBooleanBinaryOp) {
-            listener.enterSEBooleanBinaryOp(this);
+        if (listener.enterSEFunctionCall) {
+            listener.enterSEFunctionCall(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEBooleanBinaryOp) {
-            listener.exitSEBooleanBinaryOp(this);
+        if (listener.exitSEFunctionCall) {
+            listener.exitSEFunctionCall(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEBooleanBinaryOp) {
-            return visitor.visitSEBooleanBinaryOp(this);
+        if (visitor.visitSEFunctionCall) {
+            return visitor.visitSEFunctionCall(this);
         }
         else {
             return visitor.visitChildren(this);
         }
     }
 }
-export class SEFunctionCallContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export class SELiteralContext extends SingleExprContext {
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
     }
-    functionCall() {
-        return this.getTypedRuleContext(FunctionCallContext, 0);
+    literal() {
+        return this.getRuleContext(0, LiteralContext);
     }
     enterRule(listener) {
-        if (listener.enterSEFunctionCall) {
-            listener.enterSEFunctionCall(this);
+        if (listener.enterSELiteral) {
+            listener.enterSELiteral(this);
         }
     }
     exitRule(listener) {
-        if (listener.exitSEFunctionCall) {
-            listener.exitSEFunctionCall(this);
+        if (listener.exitSELiteral) {
+            listener.exitSELiteral(this);
         }
     }
-    // @Override
     accept(visitor) {
-        if (visitor.visitSEFunctionCall) {
-            return visitor.visitSEFunctionCall(this);
+        if (visitor.visitSELiteral) {
+            return visitor.visitSELiteral(this);
         }
         else {
             return visitor.visitChildren(this);
@@ -1098,12 +1075,12 @@ export class SEFunctionCallContext extends SingleExprContext {
     }
 }
 export 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) {
@@ -1115,7 +1092,6 @@ export class SEArrayExprContext extends SingleExprContext {
             listener.exitSEArrayExpr(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitSEArrayExpr) {
             return visitor.visitSEArrayExpr(this);
@@ -1125,143 +1101,156 @@ export class SEArrayExprContext extends SingleExprContext {
         }
     }
 }
-export class SENotContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export 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);
         }
     }
 }
-export class SEVariableRefContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export 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);
         }
     }
 }
-export class SEUnaryMultipleMinusContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export 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);
         }
     }
 }
-export class SEUnaryMinusContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export 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);
         }
     }
 }
-export class SEAddSubContext extends SingleExprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
+export 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);
@@ -1269,15 +1258,15 @@ export class SEAddSubContext extends SingleExprContext {
     }
 }
 export 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) {
@@ -1289,7 +1278,6 @@ export class SEMethodCallContext extends SingleExprContext {
             listener.exitSEMethodCall(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitSEMethodCall) {
             return visitor.visitSEMethodCall(this);
@@ -1299,10 +1287,9 @@ export class SEMethodCallContext extends SingleExprContext {
         }
     }
 }
-export class MethodCallChainContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export class MethodCallChainContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     get ruleIndex() {
         return IfcExpressionParser.RULE_methodCallChain;
@@ -1312,18 +1299,18 @@ export class MethodCallChainContext extends ParserRuleContext {
     }
 }
 export 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) {
@@ -1335,7 +1322,6 @@ export class MethodCallChainInnerContext extends MethodCallChainContext {
             listener.exitMethodCallChainInner(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitMethodCallChainInner) {
             return visitor.visitMethodCallChainInner(this);
@@ -1346,15 +1332,15 @@ export class MethodCallChainInnerContext extends MethodCallChainContext {
     }
 }
 export 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) {
@@ -1366,7 +1352,6 @@ export class MethodCallChainEndContext extends MethodCallChainContext {
             listener.exitMethodCallChainEnd(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitMethodCallChainEnd) {
             return visitor.visitMethodCallChainEnd(this);
@@ -1376,16 +1361,80 @@ export class MethodCallChainEndContext extends MethodCallChainContext {
         }
     }
 }
-export class FunctionCallContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export class MethodAccessorContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return IfcExpressionParser.RULE_methodAccessor;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+export 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);
+        }
+    }
+}
+export 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);
+        }
+    }
+}
+export 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;
@@ -1400,7 +1449,6 @@ export class FunctionCallContext extends ParserRuleContext {
             listener.exitFunctionCall(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitFunctionCall) {
             return visitor.visitFunctionCall(this);
@@ -1410,16 +1458,15 @@ export class FunctionCallContext extends ParserRuleContext {
         }
     }
 }
-export class ExprListContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export 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;
@@ -1434,7 +1481,6 @@ export class ExprListContext extends ParserRuleContext {
             listener.exitExprList(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitExprList) {
             return visitor.visitExprList(this);
@@ -1444,13 +1490,12 @@ export class ExprListContext extends ParserRuleContext {
         }
     }
 }
-export class ArrayExprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export 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;
@@ -1465,7 +1510,6 @@ export class ArrayExprContext extends ParserRuleContext {
             listener.exitArrayExpr(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitArrayExpr) {
             return visitor.visitArrayExpr(this);
@@ -1475,16 +1519,15 @@ export class ArrayExprContext extends ParserRuleContext {
         }
     }
 }
-export class ArrayElementListContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export 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;
@@ -1499,7 +1542,6 @@ export class ArrayElementListContext extends ParserRuleContext {
             listener.exitArrayElementList(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitArrayElementList) {
             return visitor.visitArrayElementList(this);
@@ -1509,22 +1551,21 @@ export class ArrayElementListContext extends ParserRuleContext {
         }
     }
 }
-export class LiteralContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export 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;
@@ -1539,7 +1580,6 @@ export class LiteralContext extends ParserRuleContext {
             listener.exitLiteral(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitLiteral) {
             return visitor.visitLiteral(this);
@@ -1549,10 +1589,9 @@ export class LiteralContext extends ParserRuleContext {
         }
     }
 }
-export class NumLiteralContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export class NumLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     INT() {
         return this.getToken(IfcExpressionParser.INT, 0);
@@ -1573,7 +1612,6 @@ export class NumLiteralContext extends ParserRuleContext {
             listener.exitNumLiteral(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitNumLiteral) {
             return visitor.visitNumLiteral(this);
@@ -1583,10 +1621,9 @@ export class NumLiteralContext extends ParserRuleContext {
         }
     }
 }
-export class StringLiteralContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export class StringLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     QUOTED_STRING() {
         return this.getToken(IfcExpressionParser.QUOTED_STRING, 0);
@@ -1604,7 +1641,6 @@ export class StringLiteralContext extends ParserRuleContext {
             listener.exitStringLiteral(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitStringLiteral) {
             return visitor.visitStringLiteral(this);
@@ -1614,10 +1650,9 @@ export class StringLiteralContext extends ParserRuleContext {
         }
     }
 }
-export class BooleanLiteralContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export class BooleanLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     BOOLEAN() {
         return this.getToken(IfcExpressionParser.BOOLEAN, 0);
@@ -1635,7 +1670,6 @@ export class BooleanLiteralContext extends ParserRuleContext {
             listener.exitBooleanLiteral(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitBooleanLiteral) {
             return visitor.visitBooleanLiteral(this);
@@ -1645,10 +1679,9 @@ export class BooleanLiteralContext extends ParserRuleContext {
         }
     }
 }
-export class LogicalLiteralContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export class LogicalLiteralContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     LOGICAL_UNKNOWN() {
         return this.getToken(IfcExpressionParser.LOGICAL_UNKNOWN, 0);
@@ -1666,7 +1699,6 @@ export class LogicalLiteralContext extends ParserRuleContext {
             listener.exitLogicalLiteral(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitLogicalLiteral) {
             return visitor.visitLogicalLiteral(this);
@@ -1676,10 +1708,9 @@ export class LogicalLiteralContext extends ParserRuleContext {
         }
     }
 }
-export class VariableRefContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
+export class VariableRefContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
         super(parent, invokingState);
-        this.parser = parser;
     }
     IDENTIFIER() {
         return this.getToken(IfcExpressionParser.IDENTIFIER, 0);
@@ -1697,7 +1728,6 @@ export class VariableRefContext extends ParserRuleContext {
             listener.exitVariableRef(this);
         }
     }
-    // @Override
     accept(visitor) {
         if (visitor.visitVariableRef) {
             return visitor.visitVariableRef(this);