This is an automated email from the ASF dual-hosted git repository.

aradzinski pushed a commit to branch NLPCRAFT-278
in repository https://gitbox.apache.org/repos/asf/incubator-nlpcraft.git


The following commit(s) were added to refs/heads/NLPCRAFT-278 by this push:
     new 1001938  WIP.
1001938 is described below

commit 1001938ce16f9e1a0eeda34840ef544cdb428606
Author: Aaron Radzinski <[email protected]>
AuthorDate: Thu Mar 25 01:45:17 2021 -0700

    WIP.
---
 .../nlpcraft/model/intent/compiler/antlr4/NCIdl.g4 |  13 +-
 .../model/intent/compiler/antlr4/NCIdl.interp      |   3 +-
 .../intent/compiler/antlr4/NCIdlBaseListener.java  |  12 +
 .../intent/compiler/antlr4/NCIdlListener.java      |  10 +
 .../model/intent/compiler/antlr4/NCIdlParser.java  | 834 ++++++++++++---------
 5 files changed, 508 insertions(+), 364 deletions(-)

diff --git 
a/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdl.g4
 
b/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdl.g4
index 038f193..613dfc5 100644
--- 
a/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdl.g4
+++ 
b/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdl.g4
@@ -72,8 +72,19 @@ termEq
 term: 'term' termId? termEq ((LBRACE vars? expr RBRACE) | mtdDecl) minMax?;
 mtdRef: javaFqn? POUND id;
 javaFqn
+    : javaClass
+    | javaFqn DOT javaClass
+    ;
+javaClass
     : id
-    | javaFqn DOT id
+    // We need to include keywords to make sure they don't conflict.
+    | IMPORT
+    | INTENT
+    | ORDERED
+    | FLOW
+    | META
+    | TERM
+    | FRAG
     ;
 termId: LPAR id RPAR;
 expr
diff --git 
a/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdl.interp
 
b/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdl.interp
index 459779b..f3a74b6 100644
--- 
a/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdl.interp
+++ 
b/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdl.interp
@@ -135,6 +135,7 @@ termEq
 term
 mtdRef
 javaFqn
+javaClass
 termId
 expr
 vars
@@ -149,4 +150,4 @@ id
 
 
 atn:
-[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 54, 365, 4, 2, 
9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 
4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 
14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 
20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 
25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 
31, 9, 31, 4, 32, 9, 32, 4, [...]
\ No newline at end of file
+[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 54, 377, 4, 2, 
9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 
4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 
14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 
20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 
25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 
31, 9, 31, 4, 32, 9, 32, 4, [...]
\ No newline at end of file
diff --git 
a/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlBaseListener.java
 
b/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlBaseListener.java
index 9f6e068..1101df2 100644
--- 
a/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlBaseListener.java
+++ 
b/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlBaseListener.java
@@ -328,6 +328,18 @@ public class NCIdlBaseListener implements NCIdlListener {
         *
         * <p>The default implementation does nothing.</p>
         */
+       @Override public void enterJavaClass(NCIdlParser.JavaClassContext ctx) 
{ }
+       /**
+        * {@inheritDoc}
+        *
+        * <p>The default implementation does nothing.</p>
+        */
+       @Override public void exitJavaClass(NCIdlParser.JavaClassContext ctx) { 
}
+       /**
+        * {@inheritDoc}
+        *
+        * <p>The default implementation does nothing.</p>
+        */
        @Override public void enterTermId(NCIdlParser.TermIdContext ctx) { }
        /**
         * {@inheritDoc}
diff --git 
a/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlListener.java
 
b/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlListener.java
index 7ad1ddb..d497b65 100644
--- 
a/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlListener.java
+++ 
b/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlListener.java
@@ -268,6 +268,16 @@ public interface NCIdlListener extends ParseTreeListener {
         */
        void exitJavaFqn(NCIdlParser.JavaFqnContext ctx);
        /**
+        * Enter a parse tree produced by {@link NCIdlParser#javaClass}.
+        * @param ctx the parse tree
+        */
+       void enterJavaClass(NCIdlParser.JavaClassContext ctx);
+       /**
+        * Exit a parse tree produced by {@link NCIdlParser#javaClass}.
+        * @param ctx the parse tree
+        */
+       void exitJavaClass(NCIdlParser.JavaClassContext ctx);
+       /**
         * Enter a parse tree produced by {@link NCIdlParser#termId}.
         * @param ctx the parse tree
         */
diff --git 
a/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlParser.java
 
b/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlParser.java
index 9106ee2..fe02e69 100644
--- 
a/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlParser.java
+++ 
b/nlpcraft/src/main/scala/org/apache/nlpcraft/model/intent/compiler/antlr4/NCIdlParser.java
@@ -31,17 +31,17 @@ public class NCIdlParser extends Parser {
                RULE_flowDecl = 14, RULE_metaDecl = 15, RULE_jsonObj = 16, 
RULE_jsonPair = 17, 
                RULE_jsonVal = 18, RULE_jsonArr = 19, RULE_termDecls = 20, 
RULE_termDecl = 21, 
                RULE_termEq = 22, RULE_term = 23, RULE_mtdRef = 24, 
RULE_javaFqn = 25, 
-               RULE_termId = 26, RULE_expr = 27, RULE_vars = 28, RULE_varDecl 
= 29, RULE_paramList = 30, 
-               RULE_atom = 31, RULE_qstring = 32, RULE_minMax = 33, 
RULE_minMaxShortcut = 34, 
-               RULE_minMaxRange = 35, RULE_id = 36;
+               RULE_javaClass = 26, RULE_termId = 27, RULE_expr = 28, 
RULE_vars = 29, 
+               RULE_varDecl = 30, RULE_paramList = 31, RULE_atom = 32, 
RULE_qstring = 33, 
+               RULE_minMax = 34, RULE_minMaxShortcut = 35, RULE_minMaxRange = 
36, RULE_id = 37;
        private static String[] makeRuleNames() {
                return new String[] {
                        "idl", "synonym", "alias", "idlDecls", "idlDecl", 
"imp", "frag", "fragId", 
                        "fragRef", "fragMeta", "intent", "intentId", 
"orderedDecl", "mtdDecl", 
                        "flowDecl", "metaDecl", "jsonObj", "jsonPair", 
"jsonVal", "jsonArr", 
-                       "termDecls", "termDecl", "termEq", "term", "mtdRef", 
"javaFqn", "termId", 
-                       "expr", "vars", "varDecl", "paramList", "atom", 
"qstring", "minMax", 
-                       "minMaxShortcut", "minMaxRange", "id"
+                       "termDecls", "termDecl", "termEq", "term", "mtdRef", 
"javaFqn", "javaClass", 
+                       "termId", "expr", "vars", "varDecl", "paramList", 
"atom", "qstring", 
+                       "minMax", "minMaxShortcut", "minMaxRange", "id"
                };
        }
        public static final String[] ruleNames = makeRuleNames();
@@ -143,9 +143,9 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(74);
+                       setState(76);
                        idlDecls(0);
-                       setState(75);
+                       setState(77);
                        match(EOF);
                        }
                }
@@ -194,33 +194,33 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(78);
+                       setState(80);
                        _errHandler.sync(this);
                        _la = _input.LA(1);
                        if (_la==LBR) {
                                {
-                               setState(77);
+                               setState(79);
                                alias();
                                }
                        }
 
-                       setState(80);
-                       match(LBRACE);
                        setState(82);
+                       match(LBRACE);
+                       setState(84);
                        _errHandler.sync(this);
                        switch ( 
getInterpreter().adaptivePredict(_input,1,_ctx) ) {
                        case 1:
                                {
-                               setState(81);
+                               setState(83);
                                vars(0);
                                }
                                break;
                        }
-                       setState(84);
+                       setState(86);
                        expr(0);
-                       setState(85);
+                       setState(87);
                        match(RBRACE);
-                       setState(86);
+                       setState(88);
                        match(EOF);
                        }
                }
@@ -261,11 +261,11 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(88);
+                       setState(90);
                        match(LBR);
-                       setState(89);
+                       setState(91);
                        id();
-                       setState(90);
+                       setState(92);
                        match(RBR);
                        }
                }
@@ -317,11 +317,11 @@ public class NCIdlParser extends Parser {
                        enterOuterAlt(_localctx, 1);
                        {
                        {
-                       setState(93);
+                       setState(95);
                        idlDecl();
                        }
                        _ctx.stop = _input.LT(-1);
-                       setState(99);
+                       setState(101);
                        _errHandler.sync(this);
                        _alt = getInterpreter().adaptivePredict(_input,2,_ctx);
                        while ( _alt!=2 && 
_alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
@@ -332,14 +332,14 @@ public class NCIdlParser extends Parser {
                                        {
                                        _localctx = new 
IdlDeclsContext(_parentctx, _parentState);
                                        pushNewRecursionContext(_localctx, 
_startState, RULE_idlDecls);
-                                       setState(95);
+                                       setState(97);
                                        if (!(precpred(_ctx, 1))) throw new 
FailedPredicateException(this, "precpred(_ctx, 1)");
-                                       setState(96);
+                                       setState(98);
                                        idlDecl();
                                        }
                                        } 
                                }
-                               setState(101);
+                               setState(103);
                                _errHandler.sync(this);
                                _alt = 
getInterpreter().adaptivePredict(_input,2,_ctx);
                        }
@@ -384,27 +384,27 @@ public class NCIdlParser extends Parser {
                IdlDeclContext _localctx = new IdlDeclContext(_ctx, getState());
                enterRule(_localctx, 8, RULE_idlDecl);
                try {
-                       setState(105);
+                       setState(107);
                        _errHandler.sync(this);
                        switch (_input.LA(1)) {
                        case INTENT:
                                enterOuterAlt(_localctx, 1);
                                {
-                               setState(102);
+                               setState(104);
                                intent();
                                }
                                break;
                        case FRAG:
                                enterOuterAlt(_localctx, 2);
                                {
-                               setState(103);
+                               setState(105);
                                frag();
                                }
                                break;
                        case IMPORT:
                                enterOuterAlt(_localctx, 3);
                                {
-                               setState(104);
+                               setState(106);
                                imp();
                                }
                                break;
@@ -450,13 +450,13 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(107);
+                       setState(109);
                        match(IMPORT);
-                       setState(108);
+                       setState(110);
                        match(LPAR);
-                       setState(109);
+                       setState(111);
                        qstring();
-                       setState(110);
+                       setState(112);
                        match(RPAR);
                        }
                }
@@ -498,9 +498,9 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(112);
+                       setState(114);
                        fragId();
-                       setState(113);
+                       setState(115);
                        termDecls(0);
                        }
                }
@@ -541,11 +541,11 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(115);
+                       setState(117);
                        match(FRAG);
-                       setState(116);
+                       setState(118);
                        match(ASSIGN);
-                       setState(117);
+                       setState(119);
                        id();
                        }
                }
@@ -591,23 +591,23 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(119);
+                       setState(121);
                        match(FRAG);
-                       setState(120);
+                       setState(122);
                        match(LPAR);
-                       setState(121);
-                       id();
                        setState(123);
+                       id();
+                       setState(125);
                        _errHandler.sync(this);
                        _la = _input.LA(1);
                        if (_la==COMMA) {
                                {
-                               setState(122);
+                               setState(124);
                                fragMeta();
                                }
                        }
 
-                       setState(125);
+                       setState(127);
                        match(RPAR);
                        }
                }
@@ -647,9 +647,9 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(127);
+                       setState(129);
                        match(COMMA);
-                       setState(128);
+                       setState(130);
                        jsonObj();
                        }
                }
@@ -701,39 +701,39 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(130);
-                       intentId();
                        setState(132);
+                       intentId();
+                       setState(134);
                        _errHandler.sync(this);
                        _la = _input.LA(1);
                        if (_la==ORDERED) {
                                {
-                               setState(131);
+                               setState(133);
                                orderedDecl();
                                }
                        }
 
-                       setState(135);
+                       setState(137);
                        _errHandler.sync(this);
                        _la = _input.LA(1);
                        if (_la==FLOW) {
                                {
-                               setState(134);
+                               setState(136);
                                flowDecl();
                                }
                        }
 
-                       setState(138);
+                       setState(140);
                        _errHandler.sync(this);
                        _la = _input.LA(1);
                        if (_la==META) {
                                {
-                               setState(137);
+                               setState(139);
                                metaDecl();
                                }
                        }
 
-                       setState(140);
+                       setState(142);
                        termDecls(0);
                        }
                }
@@ -774,11 +774,11 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(142);
+                       setState(144);
                        match(INTENT);
-                       setState(143);
+                       setState(145);
                        match(ASSIGN);
-                       setState(144);
+                       setState(146);
                        id();
                        }
                }
@@ -817,11 +817,11 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(146);
+                       setState(148);
                        match(ORDERED);
-                       setState(147);
+                       setState(149);
                        match(ASSIGN);
-                       setState(148);
+                       setState(150);
                        match(BOOL);
                        }
                }
@@ -864,11 +864,11 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(150);
+                       setState(152);
                        match(DIV);
-                       setState(151);
+                       setState(153);
                        mtdRef();
-                       setState(152);
+                       setState(154);
                        match(DIV);
                        }
                }
@@ -912,23 +912,23 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(154);
+                       setState(156);
                        match(FLOW);
-                       setState(155);
+                       setState(157);
                        match(ASSIGN);
-                       setState(158);
+                       setState(160);
                        _errHandler.sync(this);
                        switch (_input.LA(1)) {
                        case SQSTRING:
                        case DQSTRING:
                                {
-                               setState(156);
+                               setState(158);
                                qstring();
                                }
                                break;
                        case DIV:
                                {
-                               setState(157);
+                               setState(159);
                                mtdDecl();
                                }
                                break;
@@ -974,11 +974,11 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(160);
+                       setState(162);
                        match(META);
-                       setState(161);
+                       setState(163);
                        match(ASSIGN);
-                       setState(162);
+                       setState(164);
                        jsonObj();
                        }
                }
@@ -1025,42 +1025,42 @@ public class NCIdlParser extends Parser {
                enterRule(_localctx, 32, RULE_jsonObj);
                int _la;
                try {
-                       setState(177);
+                       setState(179);
                        _errHandler.sync(this);
                        switch ( 
getInterpreter().adaptivePredict(_input,10,_ctx) ) {
                        case 1:
                                enterOuterAlt(_localctx, 1);
                                {
-                               setState(164);
+                               setState(166);
                                match(LBRACE);
-                               setState(165);
+                               setState(167);
                                jsonPair();
-                               setState(170);
+                               setState(172);
                                _errHandler.sync(this);
                                _la = _input.LA(1);
                                while (_la==COMMA) {
                                        {
                                        {
-                                       setState(166);
+                                       setState(168);
                                        match(COMMA);
-                                       setState(167);
+                                       setState(169);
                                        jsonPair();
                                        }
                                        }
-                                       setState(172);
+                                       setState(174);
                                        _errHandler.sync(this);
                                        _la = _input.LA(1);
                                }
-                               setState(173);
+                               setState(175);
                                match(RBRACE);
                                }
                                break;
                        case 2:
                                enterOuterAlt(_localctx, 2);
                                {
-                               setState(175);
+                               setState(177);
                                match(LBRACE);
-                               setState(176);
+                               setState(178);
                                match(RBRACE);
                                }
                                break;
@@ -1105,11 +1105,11 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(179);
+                       setState(181);
                        qstring();
-                       setState(180);
+                       setState(182);
                        match(COLON);
-                       setState(181);
+                       setState(183);
                        jsonVal();
                        }
                }
@@ -1159,14 +1159,14 @@ public class NCIdlParser extends Parser {
                enterRule(_localctx, 36, RULE_jsonVal);
                int _la;
                try {
-                       setState(198);
+                       setState(200);
                        _errHandler.sync(this);
                        switch (_input.LA(1)) {
                        case SQSTRING:
                        case DQSTRING:
                                enterOuterAlt(_localctx, 1);
                                {
-                               setState(183);
+                               setState(185);
                                qstring();
                                }
                                break;
@@ -1174,34 +1174,34 @@ public class NCIdlParser extends Parser {
                        case INT:
                                enterOuterAlt(_localctx, 2);
                                {
-                               setState(185);
+                               setState(187);
                                _errHandler.sync(this);
                                _la = _input.LA(1);
                                if (_la==MINUS) {
                                        {
-                                       setState(184);
+                                       setState(186);
                                        match(MINUS);
                                        }
                                }
 
-                               setState(187);
-                               match(INT);
                                setState(189);
+                               match(INT);
+                               setState(191);
                                _errHandler.sync(this);
                                _la = _input.LA(1);
                                if (_la==REAL) {
                                        {
-                                       setState(188);
+                                       setState(190);
                                        match(REAL);
                                        }
                                }
 
-                               setState(192);
+                               setState(194);
                                _errHandler.sync(this);
                                _la = _input.LA(1);
                                if (_la==EXP) {
                                        {
-                                       setState(191);
+                                       setState(193);
                                        match(EXP);
                                        }
                                }
@@ -1211,28 +1211,28 @@ public class NCIdlParser extends Parser {
                        case LBRACE:
                                enterOuterAlt(_localctx, 3);
                                {
-                               setState(194);
+                               setState(196);
                                jsonObj();
                                }
                                break;
                        case LBR:
                                enterOuterAlt(_localctx, 4);
                                {
-                               setState(195);
+                               setState(197);
                                jsonArr();
                                }
                                break;
                        case BOOL:
                                enterOuterAlt(_localctx, 5);
                                {
-                               setState(196);
+                               setState(198);
                                match(BOOL);
                                }
                                break;
                        case NULL:
                                enterOuterAlt(_localctx, 6);
                                {
-                               setState(197);
+                               setState(199);
                                match(NULL);
                                }
                                break;
@@ -1283,42 +1283,42 @@ public class NCIdlParser extends Parser {
                enterRule(_localctx, 38, RULE_jsonArr);
                int _la;
                try {
-                       setState(213);
+                       setState(215);
                        _errHandler.sync(this);
                        switch ( 
getInterpreter().adaptivePredict(_input,16,_ctx) ) {
                        case 1:
                                enterOuterAlt(_localctx, 1);
                                {
-                               setState(200);
+                               setState(202);
                                match(LBR);
-                               setState(201);
+                               setState(203);
                                jsonVal();
-                               setState(206);
+                               setState(208);
                                _errHandler.sync(this);
                                _la = _input.LA(1);
                                while (_la==COMMA) {
                                        {
                                        {
-                                       setState(202);
+                                       setState(204);
                                        match(COMMA);
-                                       setState(203);
+                                       setState(205);
                                        jsonVal();
                                        }
                                        }
-                                       setState(208);
+                                       setState(210);
                                        _errHandler.sync(this);
                                        _la = _input.LA(1);
                                }
-                               setState(209);
+                               setState(211);
                                match(RBR);
                                }
                                break;
                        case 2:
                                enterOuterAlt(_localctx, 2);
                                {
-                               setState(211);
+                               setState(213);
                                match(LBR);
-                               setState(212);
+                               setState(214);
                                match(RBR);
                                }
                                break;
@@ -1372,11 +1372,11 @@ public class NCIdlParser extends Parser {
                        enterOuterAlt(_localctx, 1);
                        {
                        {
-                       setState(216);
+                       setState(218);
                        termDecl();
                        }
                        _ctx.stop = _input.LT(-1);
-                       setState(222);
+                       setState(224);
                        _errHandler.sync(this);
                        _alt = getInterpreter().adaptivePredict(_input,17,_ctx);
                        while ( _alt!=2 && 
_alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
@@ -1387,14 +1387,14 @@ public class NCIdlParser extends Parser {
                                        {
                                        _localctx = new 
TermDeclsContext(_parentctx, _parentState);
                                        pushNewRecursionContext(_localctx, 
_startState, RULE_termDecls);
-                                       setState(218);
+                                       setState(220);
                                        if (!(precpred(_ctx, 1))) throw new 
FailedPredicateException(this, "precpred(_ctx, 1)");
-                                       setState(219);
+                                       setState(221);
                                        termDecl();
                                        }
                                        } 
                                }
-                               setState(224);
+                               setState(226);
                                _errHandler.sync(this);
                                _alt = 
getInterpreter().adaptivePredict(_input,17,_ctx);
                        }
@@ -1436,20 +1436,20 @@ public class NCIdlParser extends Parser {
                TermDeclContext _localctx = new TermDeclContext(_ctx, 
getState());
                enterRule(_localctx, 42, RULE_termDecl);
                try {
-                       setState(227);
+                       setState(229);
                        _errHandler.sync(this);
                        switch (_input.LA(1)) {
                        case TERM:
                                enterOuterAlt(_localctx, 1);
                                {
-                               setState(225);
+                               setState(227);
                                term();
                                }
                                break;
                        case FRAG:
                                enterOuterAlt(_localctx, 2);
                                {
-                               setState(226);
+                               setState(228);
                                fragRef();
                                }
                                break;
@@ -1492,7 +1492,7 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(229);
+                       setState(231);
                        _la = _input.LA(1);
                        if ( !(_la==TILDA || _la==ASSIGN) ) {
                        _errHandler.recoverInline(this);
@@ -1558,60 +1558,60 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(231);
-                       match(TERM);
                        setState(233);
+                       match(TERM);
+                       setState(235);
                        _errHandler.sync(this);
                        _la = _input.LA(1);
                        if (_la==LPAR) {
                                {
-                               setState(232);
+                               setState(234);
                                termId();
                                }
                        }
 
-                       setState(235);
+                       setState(237);
                        termEq();
-                       setState(244);
+                       setState(246);
                        _errHandler.sync(this);
                        switch (_input.LA(1)) {
                        case LBRACE:
                                {
                                {
-                               setState(236);
-                               match(LBRACE);
                                setState(238);
+                               match(LBRACE);
+                               setState(240);
                                _errHandler.sync(this);
                                switch ( 
getInterpreter().adaptivePredict(_input,20,_ctx) ) {
                                case 1:
                                        {
-                                       setState(237);
+                                       setState(239);
                                        vars(0);
                                        }
                                        break;
                                }
-                               setState(240);
+                               setState(242);
                                expr(0);
-                               setState(241);
+                               setState(243);
                                match(RBRACE);
                                }
                                }
                                break;
                        case DIV:
                                {
-                               setState(243);
+                               setState(245);
                                mtdDecl();
                                }
                                break;
                        default:
                                throw new NoViableAltException(this);
                        }
-                       setState(247);
+                       setState(249);
                        _errHandler.sync(this);
                        switch ( 
getInterpreter().adaptivePredict(_input,22,_ctx) ) {
                        case 1:
                                {
-                               setState(246);
+                               setState(248);
                                minMax();
                                }
                                break;
@@ -1658,19 +1658,19 @@ public class NCIdlParser extends Parser {
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(250);
+                       setState(252);
                        _errHandler.sync(this);
                        _la = _input.LA(1);
-                       if (_la==FUN_NAME || _la==ID) {
+                       if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 
FUN_NAME) | (1L << IMPORT) | (1L << INTENT) | (1L << ORDERED) | (1L << FLOW) | 
(1L << META) | (1L << TERM) | (1L << FRAG) | (1L << ID))) != 0)) {
                                {
-                               setState(249);
+                               setState(251);
                                javaFqn(0);
                                }
                        }
 
-                       setState(252);
+                       setState(254);
                        match(POUND);
-                       setState(253);
+                       setState(255);
                        id();
                        }
                }
@@ -1686,8 +1686,8 @@ public class NCIdlParser extends Parser {
        }
 
        public static class JavaFqnContext extends ParserRuleContext {
-               public IdContext id() {
-                       return getRuleContext(IdContext.class,0);
+               public JavaClassContext javaClass() {
+                       return getRuleContext(JavaClassContext.class,0);
                }
                public JavaFqnContext javaFqn() {
                        return getRuleContext(JavaFqnContext.class,0);
@@ -1723,11 +1723,11 @@ public class NCIdlParser extends Parser {
                        enterOuterAlt(_localctx, 1);
                        {
                        {
-                       setState(256);
-                       id();
+                       setState(258);
+                       javaClass();
                        }
                        _ctx.stop = _input.LT(-1);
-                       setState(263);
+                       setState(265);
                        _errHandler.sync(this);
                        _alt = getInterpreter().adaptivePredict(_input,24,_ctx);
                        while ( _alt!=2 && 
_alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
@@ -1738,16 +1738,16 @@ public class NCIdlParser extends Parser {
                                        {
                                        _localctx = new 
JavaFqnContext(_parentctx, _parentState);
                                        pushNewRecursionContext(_localctx, 
_startState, RULE_javaFqn);
-                                       setState(258);
+                                       setState(260);
                                        if (!(precpred(_ctx, 1))) throw new 
FailedPredicateException(this, "precpred(_ctx, 1)");
-                                       setState(259);
+                                       setState(261);
                                        match(DOT);
-                                       setState(260);
-                                       id();
+                                       setState(262);
+                                       javaClass();
                                        }
                                        } 
                                }
-                               setState(265);
+                               setState(267);
                                _errHandler.sync(this);
                                _alt = 
getInterpreter().adaptivePredict(_input,24,_ctx);
                        }
@@ -1764,6 +1764,110 @@ public class NCIdlParser extends Parser {
                return _localctx;
        }
 
+       public static class JavaClassContext extends ParserRuleContext {
+               public IdContext id() {
+                       return getRuleContext(IdContext.class,0);
+               }
+               public TerminalNode IMPORT() { return 
getToken(NCIdlParser.IMPORT, 0); }
+               public TerminalNode INTENT() { return 
getToken(NCIdlParser.INTENT, 0); }
+               public TerminalNode ORDERED() { return 
getToken(NCIdlParser.ORDERED, 0); }
+               public TerminalNode FLOW() { return getToken(NCIdlParser.FLOW, 
0); }
+               public TerminalNode META() { return getToken(NCIdlParser.META, 
0); }
+               public TerminalNode TERM() { return getToken(NCIdlParser.TERM, 
0); }
+               public TerminalNode FRAG() { return getToken(NCIdlParser.FRAG, 
0); }
+               public JavaClassContext(ParserRuleContext parent, int 
invokingState) {
+                       super(parent, invokingState);
+               }
+               @Override public int getRuleIndex() { return RULE_javaClass; }
+               @Override
+               public void enterRule(ParseTreeListener listener) {
+                       if ( listener instanceof NCIdlListener ) 
((NCIdlListener)listener).enterJavaClass(this);
+               }
+               @Override
+               public void exitRule(ParseTreeListener listener) {
+                       if ( listener instanceof NCIdlListener ) 
((NCIdlListener)listener).exitJavaClass(this);
+               }
+       }
+
+       public final JavaClassContext javaClass() throws RecognitionException {
+               JavaClassContext _localctx = new JavaClassContext(_ctx, 
getState());
+               enterRule(_localctx, 52, RULE_javaClass);
+               try {
+                       setState(276);
+                       _errHandler.sync(this);
+                       switch (_input.LA(1)) {
+                       case FUN_NAME:
+                       case ID:
+                               enterOuterAlt(_localctx, 1);
+                               {
+                               setState(268);
+                               id();
+                               }
+                               break;
+                       case IMPORT:
+                               enterOuterAlt(_localctx, 2);
+                               {
+                               setState(269);
+                               match(IMPORT);
+                               }
+                               break;
+                       case INTENT:
+                               enterOuterAlt(_localctx, 3);
+                               {
+                               setState(270);
+                               match(INTENT);
+                               }
+                               break;
+                       case ORDERED:
+                               enterOuterAlt(_localctx, 4);
+                               {
+                               setState(271);
+                               match(ORDERED);
+                               }
+                               break;
+                       case FLOW:
+                               enterOuterAlt(_localctx, 5);
+                               {
+                               setState(272);
+                               match(FLOW);
+                               }
+                               break;
+                       case META:
+                               enterOuterAlt(_localctx, 6);
+                               {
+                               setState(273);
+                               match(META);
+                               }
+                               break;
+                       case TERM:
+                               enterOuterAlt(_localctx, 7);
+                               {
+                               setState(274);
+                               match(TERM);
+                               }
+                               break;
+                       case FRAG:
+                               enterOuterAlt(_localctx, 8);
+                               {
+                               setState(275);
+                               match(FRAG);
+                               }
+                               break;
+                       default:
+                               throw new NoViableAltException(this);
+                       }
+               }
+               catch (RecognitionException re) {
+                       _localctx.exception = re;
+                       _errHandler.reportError(this, re);
+                       _errHandler.recover(this, re);
+               }
+               finally {
+                       exitRule();
+               }
+               return _localctx;
+       }
+
        public static class TermIdContext extends ParserRuleContext {
                public TerminalNode LPAR() { return getToken(NCIdlParser.LPAR, 
0); }
                public IdContext id() {
@@ -1786,15 +1890,15 @@ public class NCIdlParser extends Parser {
 
        public final TermIdContext termId() throws RecognitionException {
                TermIdContext _localctx = new TermIdContext(_ctx, getState());
-               enterRule(_localctx, 52, RULE_termId);
+               enterRule(_localctx, 54, RULE_termId);
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(266);
+                       setState(278);
                        match(LPAR);
-                       setState(267);
+                       setState(279);
                        id();
-                       setState(268);
+                       setState(280);
                        match(RPAR);
                        }
                }
@@ -2012,14 +2116,14 @@ public class NCIdlParser extends Parser {
                int _parentState = getState();
                ExprContext _localctx = new ExprContext(_ctx, _parentState);
                ExprContext _prevctx = _localctx;
-               int _startState = 54;
-               enterRecursionRule(_localctx, 54, RULE_expr, _p);
+               int _startState = 56;
+               enterRecursionRule(_localctx, 56, RULE_expr, _p);
                int _la;
                try {
                        int _alt;
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(286);
+                       setState(298);
                        _errHandler.sync(this);
                        switch (_input.LA(1)) {
                        case NOT:
@@ -2029,7 +2133,7 @@ public class NCIdlParser extends Parser {
                                _ctx = _localctx;
                                _prevctx = _localctx;
 
-                               setState(271);
+                               setState(283);
                                ((UnaryExprContext)_localctx).op = _input.LT(1);
                                _la = _input.LA(1);
                                if ( !(_la==NOT || _la==MINUS) ) {
@@ -2040,7 +2144,7 @@ public class NCIdlParser extends Parser {
                                        _errHandler.reportMatch(this);
                                        consume();
                                }
-                               setState(272);
+                               setState(284);
                                expr(10);
                                }
                                break;
@@ -2049,11 +2153,11 @@ public class NCIdlParser extends Parser {
                                _localctx = new ParExprContext(_localctx);
                                _ctx = _localctx;
                                _prevctx = _localctx;
-                               setState(273);
+                               setState(285);
                                match(LPAR);
-                               setState(274);
+                               setState(286);
                                expr(0);
-                               setState(275);
+                               setState(287);
                                match(RPAR);
                                }
                                break;
@@ -2066,7 +2170,7 @@ public class NCIdlParser extends Parser {
                                _localctx = new AtomExprContext(_localctx);
                                _ctx = _localctx;
                                _prevctx = _localctx;
-                               setState(277);
+                               setState(289);
                                atom();
                                }
                                break;
@@ -2075,21 +2179,21 @@ public class NCIdlParser extends Parser {
                                _localctx = new CallExprContext(_localctx);
                                _ctx = _localctx;
                                _prevctx = _localctx;
-                               setState(278);
+                               setState(290);
                                match(FUN_NAME);
-                               setState(279);
+                               setState(291);
                                match(LPAR);
-                               setState(281);
+                               setState(293);
                                _errHandler.sync(this);
                                _la = _input.LA(1);
                                if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 
((1L << FUN_NAME) | (1L << SQSTRING) | (1L << DQSTRING) | (1L << BOOL) | (1L << 
NULL) | (1L << NOT) | (1L << LPAR) | (1L << MINUS) | (1L << AT) | (1L << INT))) 
!= 0)) {
                                        {
-                                       setState(280);
+                                       setState(292);
                                        paramList(0);
                                        }
                                }
 
-                               setState(283);
+                               setState(295);
                                match(RPAR);
                                }
                                break;
@@ -2098,9 +2202,9 @@ public class NCIdlParser extends Parser {
                                _localctx = new VarRefContext(_localctx);
                                _ctx = _localctx;
                                _prevctx = _localctx;
-                               setState(284);
+                               setState(296);
                                match(AT);
-                               setState(285);
+                               setState(297);
                                id();
                                }
                                break;
@@ -2108,24 +2212,24 @@ public class NCIdlParser extends Parser {
                                throw new NoViableAltException(this);
                        }
                        _ctx.stop = _input.LT(-1);
-                       setState(305);
+                       setState(317);
                        _errHandler.sync(this);
-                       _alt = getInterpreter().adaptivePredict(_input,28,_ctx);
+                       _alt = getInterpreter().adaptivePredict(_input,29,_ctx);
                        while ( _alt!=2 && 
_alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
                                if ( _alt==1 ) {
                                        if ( _parseListeners!=null ) 
triggerExitRuleEvent();
                                        _prevctx = _localctx;
                                        {
-                                       setState(303);
+                                       setState(315);
                                        _errHandler.sync(this);
-                                       switch ( 
getInterpreter().adaptivePredict(_input,27,_ctx) ) {
+                                       switch ( 
getInterpreter().adaptivePredict(_input,28,_ctx) ) {
                                        case 1:
                                                {
                                                _localctx = new 
MultDivModExprContext(new ExprContext(_parentctx, _parentState));
                                                
pushNewRecursionContext(_localctx, _startState, RULE_expr);
-                                               setState(288);
+                                               setState(300);
                                                if (!(precpred(_ctx, 8))) throw 
new FailedPredicateException(this, "precpred(_ctx, 8)");
-                                               setState(289);
+                                               setState(301);
                                                
((MultDivModExprContext)_localctx).op = _input.LT(1);
                                                _la = _input.LA(1);
                                                if ( !((((_la) & ~0x3f) == 0 && 
((1L << _la) & ((1L << MULT) | (1L << DIV) | (1L << MOD))) != 0)) ) {
@@ -2136,7 +2240,7 @@ public class NCIdlParser extends Parser {
                                                        
_errHandler.reportMatch(this);
                                                        consume();
                                                }
-                                               setState(290);
+                                               setState(302);
                                                expr(9);
                                                }
                                                break;
@@ -2144,9 +2248,9 @@ public class NCIdlParser extends Parser {
                                                {
                                                _localctx = new 
PlusMinusExprContext(new ExprContext(_parentctx, _parentState));
                                                
pushNewRecursionContext(_localctx, _startState, RULE_expr);
-                                               setState(291);
+                                               setState(303);
                                                if (!(precpred(_ctx, 7))) throw 
new FailedPredicateException(this, "precpred(_ctx, 7)");
-                                               setState(292);
+                                               setState(304);
                                                
((PlusMinusExprContext)_localctx).op = _input.LT(1);
                                                _la = _input.LA(1);
                                                if ( !(_la==MINUS || _la==PLUS) 
) {
@@ -2157,7 +2261,7 @@ public class NCIdlParser extends Parser {
                                                        
_errHandler.reportMatch(this);
                                                        consume();
                                                }
-                                               setState(293);
+                                               setState(305);
                                                expr(8);
                                                }
                                                break;
@@ -2165,9 +2269,9 @@ public class NCIdlParser extends Parser {
                                                {
                                                _localctx = new 
CompExprContext(new ExprContext(_parentctx, _parentState));
                                                
pushNewRecursionContext(_localctx, _startState, RULE_expr);
-                                               setState(294);
+                                               setState(306);
                                                if (!(precpred(_ctx, 6))) throw 
new FailedPredicateException(this, "precpred(_ctx, 6)");
-                                               setState(295);
+                                               setState(307);
                                                ((CompExprContext)_localctx).op 
= _input.LT(1);
                                                _la = _input.LA(1);
                                                if ( !((((_la) & ~0x3f) == 0 && 
((1L << _la) & ((1L << GTEQ) | (1L << LTEQ) | (1L << GT) | (1L << LT))) != 0)) 
) {
@@ -2178,7 +2282,7 @@ public class NCIdlParser extends Parser {
                                                        
_errHandler.reportMatch(this);
                                                        consume();
                                                }
-                                               setState(296);
+                                               setState(308);
                                                expr(7);
                                                }
                                                break;
@@ -2186,9 +2290,9 @@ public class NCIdlParser extends Parser {
                                                {
                                                _localctx = new 
EqNeqExprContext(new ExprContext(_parentctx, _parentState));
                                                
pushNewRecursionContext(_localctx, _startState, RULE_expr);
-                                               setState(297);
+                                               setState(309);
                                                if (!(precpred(_ctx, 5))) throw 
new FailedPredicateException(this, "precpred(_ctx, 5)");
-                                               setState(298);
+                                               setState(310);
                                                
((EqNeqExprContext)_localctx).op = _input.LT(1);
                                                _la = _input.LA(1);
                                                if ( !(_la==EQ || _la==NEQ) ) {
@@ -2199,7 +2303,7 @@ public class NCIdlParser extends Parser {
                                                        
_errHandler.reportMatch(this);
                                                        consume();
                                                }
-                                               setState(299);
+                                               setState(311);
                                                expr(6);
                                                }
                                                break;
@@ -2207,9 +2311,9 @@ public class NCIdlParser extends Parser {
                                                {
                                                _localctx = new 
AndOrExprContext(new ExprContext(_parentctx, _parentState));
                                                
pushNewRecursionContext(_localctx, _startState, RULE_expr);
-                                               setState(300);
+                                               setState(312);
                                                if (!(precpred(_ctx, 4))) throw 
new FailedPredicateException(this, "precpred(_ctx, 4)");
-                                               setState(301);
+                                               setState(313);
                                                
((AndOrExprContext)_localctx).op = _input.LT(1);
                                                _la = _input.LA(1);
                                                if ( !(_la==AND || _la==OR) ) {
@@ -2220,16 +2324,16 @@ public class NCIdlParser extends Parser {
                                                        
_errHandler.reportMatch(this);
                                                        consume();
                                                }
-                                               setState(302);
+                                               setState(314);
                                                expr(5);
                                                }
                                                break;
                                        }
                                        } 
                                }
-                               setState(307);
+                               setState(319);
                                _errHandler.sync(this);
-                               _alt = 
getInterpreter().adaptivePredict(_input,28,_ctx);
+                               _alt = 
getInterpreter().adaptivePredict(_input,29,_ctx);
                        }
                        }
                }
@@ -2274,20 +2378,20 @@ public class NCIdlParser extends Parser {
                int _parentState = getState();
                VarsContext _localctx = new VarsContext(_ctx, _parentState);
                VarsContext _prevctx = _localctx;
-               int _startState = 56;
-               enterRecursionRule(_localctx, 56, RULE_vars, _p);
+               int _startState = 58;
+               enterRecursionRule(_localctx, 58, RULE_vars, _p);
                try {
                        int _alt;
                        enterOuterAlt(_localctx, 1);
                        {
                        {
-                       setState(309);
+                       setState(321);
                        varDecl();
                        }
                        _ctx.stop = _input.LT(-1);
-                       setState(315);
+                       setState(327);
                        _errHandler.sync(this);
-                       _alt = getInterpreter().adaptivePredict(_input,29,_ctx);
+                       _alt = getInterpreter().adaptivePredict(_input,30,_ctx);
                        while ( _alt!=2 && 
_alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
                                if ( _alt==1 ) {
                                        if ( _parseListeners!=null ) 
triggerExitRuleEvent();
@@ -2296,16 +2400,16 @@ public class NCIdlParser extends Parser {
                                        {
                                        _localctx = new VarsContext(_parentctx, 
_parentState);
                                        pushNewRecursionContext(_localctx, 
_startState, RULE_vars);
-                                       setState(311);
+                                       setState(323);
                                        if (!(precpred(_ctx, 1))) throw new 
FailedPredicateException(this, "precpred(_ctx, 1)");
-                                       setState(312);
+                                       setState(324);
                                        varDecl();
                                        }
                                        } 
                                }
-                               setState(317);
+                               setState(329);
                                _errHandler.sync(this);
-                               _alt = 
getInterpreter().adaptivePredict(_input,29,_ctx);
+                               _alt = 
getInterpreter().adaptivePredict(_input,30,_ctx);
                        }
                        }
                }
@@ -2345,17 +2449,17 @@ public class NCIdlParser extends Parser {
 
        public final VarDeclContext varDecl() throws RecognitionException {
                VarDeclContext _localctx = new VarDeclContext(_ctx, getState());
-               enterRule(_localctx, 58, RULE_varDecl);
+               enterRule(_localctx, 60, RULE_varDecl);
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(318);
+                       setState(330);
                        match(AT);
-                       setState(319);
+                       setState(331);
                        id();
-                       setState(320);
+                       setState(332);
                        match(ASSIGN);
-                       setState(321);
+                       setState(333);
                        expr(0);
                        }
                }
@@ -2401,20 +2505,20 @@ public class NCIdlParser extends Parser {
                int _parentState = getState();
                ParamListContext _localctx = new ParamListContext(_ctx, 
_parentState);
                ParamListContext _prevctx = _localctx;
-               int _startState = 60;
-               enterRecursionRule(_localctx, 60, RULE_paramList, _p);
+               int _startState = 62;
+               enterRecursionRule(_localctx, 62, RULE_paramList, _p);
                try {
                        int _alt;
                        enterOuterAlt(_localctx, 1);
                        {
                        {
-                       setState(324);
+                       setState(336);
                        expr(0);
                        }
                        _ctx.stop = _input.LT(-1);
-                       setState(331);
+                       setState(343);
                        _errHandler.sync(this);
-                       _alt = getInterpreter().adaptivePredict(_input,30,_ctx);
+                       _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
                        while ( _alt!=2 && 
_alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
                                if ( _alt==1 ) {
                                        if ( _parseListeners!=null ) 
triggerExitRuleEvent();
@@ -2423,18 +2527,18 @@ public class NCIdlParser extends Parser {
                                        {
                                        _localctx = new 
ParamListContext(_parentctx, _parentState);
                                        pushNewRecursionContext(_localctx, 
_startState, RULE_paramList);
-                                       setState(326);
+                                       setState(338);
                                        if (!(precpred(_ctx, 1))) throw new 
FailedPredicateException(this, "precpred(_ctx, 1)");
-                                       setState(327);
+                                       setState(339);
                                        match(COMMA);
-                                       setState(328);
+                                       setState(340);
                                        expr(0);
                                        }
                                        } 
                                }
-                               setState(333);
+                               setState(345);
                                _errHandler.sync(this);
-                               _alt = 
getInterpreter().adaptivePredict(_input,30,_ctx);
+                               _alt = 
getInterpreter().adaptivePredict(_input,31,_ctx);
                        }
                        }
                }
@@ -2474,39 +2578,39 @@ public class NCIdlParser extends Parser {
 
        public final AtomContext atom() throws RecognitionException {
                AtomContext _localctx = new AtomContext(_ctx, getState());
-               enterRule(_localctx, 62, RULE_atom);
+               enterRule(_localctx, 64, RULE_atom);
                try {
-                       setState(344);
+                       setState(356);
                        _errHandler.sync(this);
                        switch (_input.LA(1)) {
                        case NULL:
                                enterOuterAlt(_localctx, 1);
                                {
-                               setState(334);
+                               setState(346);
                                match(NULL);
                                }
                                break;
                        case INT:
                                enterOuterAlt(_localctx, 2);
                                {
-                               setState(335);
+                               setState(347);
                                match(INT);
-                               setState(337);
+                               setState(349);
                                _errHandler.sync(this);
-                               switch ( 
getInterpreter().adaptivePredict(_input,31,_ctx) ) {
+                               switch ( 
getInterpreter().adaptivePredict(_input,32,_ctx) ) {
                                case 1:
                                        {
-                                       setState(336);
+                                       setState(348);
                                        match(REAL);
                                        }
                                        break;
                                }
-                               setState(340);
+                               setState(352);
                                _errHandler.sync(this);
-                               switch ( 
getInterpreter().adaptivePredict(_input,32,_ctx) ) {
+                               switch ( 
getInterpreter().adaptivePredict(_input,33,_ctx) ) {
                                case 1:
                                        {
-                                       setState(339);
+                                       setState(351);
                                        match(EXP);
                                        }
                                        break;
@@ -2516,7 +2620,7 @@ public class NCIdlParser extends Parser {
                        case BOOL:
                                enterOuterAlt(_localctx, 3);
                                {
-                               setState(342);
+                               setState(354);
                                match(BOOL);
                                }
                                break;
@@ -2524,7 +2628,7 @@ public class NCIdlParser extends Parser {
                        case DQSTRING:
                                enterOuterAlt(_localctx, 4);
                                {
-                               setState(343);
+                               setState(355);
                                qstring();
                                }
                                break;
@@ -2562,12 +2666,12 @@ public class NCIdlParser extends Parser {
 
        public final QstringContext qstring() throws RecognitionException {
                QstringContext _localctx = new QstringContext(_ctx, getState());
-               enterRule(_localctx, 64, RULE_qstring);
+               enterRule(_localctx, 66, RULE_qstring);
                int _la;
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(346);
+                       setState(358);
                        _la = _input.LA(1);
                        if ( !(_la==SQSTRING || _la==DQSTRING) ) {
                        _errHandler.recoverInline(this);
@@ -2613,9 +2717,9 @@ public class NCIdlParser extends Parser {
 
        public final MinMaxContext minMax() throws RecognitionException {
                MinMaxContext _localctx = new MinMaxContext(_ctx, getState());
-               enterRule(_localctx, 66, RULE_minMax);
+               enterRule(_localctx, 68, RULE_minMax);
                try {
-                       setState(350);
+                       setState(362);
                        _errHandler.sync(this);
                        switch (_input.LA(1)) {
                        case PLUS:
@@ -2623,14 +2727,14 @@ public class NCIdlParser extends Parser {
                        case MULT:
                                enterOuterAlt(_localctx, 1);
                                {
-                               setState(348);
+                               setState(360);
                                minMaxShortcut();
                                }
                                break;
                        case LBR:
                                enterOuterAlt(_localctx, 2);
                                {
-                               setState(349);
+                               setState(361);
                                minMaxRange();
                                }
                                break;
@@ -2669,12 +2773,12 @@ public class NCIdlParser extends Parser {
 
        public final MinMaxShortcutContext minMaxShortcut() throws 
RecognitionException {
                MinMaxShortcutContext _localctx = new 
MinMaxShortcutContext(_ctx, getState());
-               enterRule(_localctx, 68, RULE_minMaxShortcut);
+               enterRule(_localctx, 70, RULE_minMaxShortcut);
                int _la;
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(352);
+                       setState(364);
                        _la = _input.LA(1);
                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 
PLUS) | (1L << QUESTION) | (1L << MULT))) != 0)) ) {
                        _errHandler.recoverInline(this);
@@ -2721,19 +2825,19 @@ public class NCIdlParser extends Parser {
 
        public final MinMaxRangeContext minMaxRange() throws 
RecognitionException {
                MinMaxRangeContext _localctx = new MinMaxRangeContext(_ctx, 
getState());
-               enterRule(_localctx, 70, RULE_minMaxRange);
+               enterRule(_localctx, 72, RULE_minMaxRange);
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(354);
+                       setState(366);
                        match(LBR);
-                       setState(355);
+                       setState(367);
                        match(INT);
-                       setState(356);
+                       setState(368);
                        match(COMMA);
-                       setState(357);
+                       setState(369);
                        match(INT);
-                       setState(358);
+                       setState(370);
                        match(RBR);
                        }
                }
@@ -2767,12 +2871,12 @@ public class NCIdlParser extends Parser {
 
        public final IdContext id() throws RecognitionException {
                IdContext _localctx = new IdContext(_ctx, getState());
-               enterRule(_localctx, 72, RULE_id);
+               enterRule(_localctx, 74, RULE_id);
                int _la;
                try {
                        enterOuterAlt(_localctx, 1);
                        {
-                       setState(360);
+                       setState(372);
                        _la = _input.LA(1);
                        if ( !(_la==FUN_NAME || _la==ID) ) {
                        _errHandler.recoverInline(this);
@@ -2803,11 +2907,11 @@ public class NCIdlParser extends Parser {
                        return termDecls_sempred((TermDeclsContext)_localctx, 
predIndex);
                case 25:
                        return javaFqn_sempred((JavaFqnContext)_localctx, 
predIndex);
-               case 27:
-                       return expr_sempred((ExprContext)_localctx, predIndex);
                case 28:
+                       return expr_sempred((ExprContext)_localctx, predIndex);
+               case 29:
                        return vars_sempred((VarsContext)_localctx, predIndex);
-               case 30:
+               case 31:
                        return paramList_sempred((ParamListContext)_localctx, 
predIndex);
                }
                return true;
@@ -2864,133 +2968,139 @@ public class NCIdlParser extends Parser {
        }
 
        public static final String _serializedATN =
-               
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\66\u016d\4\2\t\2"+
+               
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\66\u0179\4\2\t\2"+
                
"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
                
"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
                
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
                "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 
\t \4!"+
-               
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\3\2\3\2\3\2\3\3\5\3Q\n\3\3\3\3\3\5"+
-               
"\3U\n\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\7\5d\n\5\f"+
-               
"\5\16\5g\13\5\3\6\3\6\3\6\5\6l\n\6\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\t"+
-               
"\3\t\3\t\3\t\3\n\3\n\3\n\3\n\5\n~\n\n\3\n\3\n\3\13\3\13\3\13\3\f\3\f\5"+
-               
"\f\u0087\n\f\3\f\5\f\u008a\n\f\3\f\5\f\u008d\n\f\3\f\3\f\3\r\3\r\3\r\3"+
-               
"\r\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\5\20\u00a1"+
-               
"\n\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u00ab\n\22\f\22\16"+
-               
"\22\u00ae\13\22\3\22\3\22\3\22\3\22\5\22\u00b4\n\22\3\23\3\23\3\23\3\23"+
-               
"\3\24\3\24\5\24\u00bc\n\24\3\24\3\24\5\24\u00c0\n\24\3\24\5\24\u00c3\n"+
-               
"\24\3\24\3\24\3\24\3\24\5\24\u00c9\n\24\3\25\3\25\3\25\3\25\7\25\u00cf"+
-               
"\n\25\f\25\16\25\u00d2\13\25\3\25\3\25\3\25\3\25\5\25\u00d8\n\25\3\26"+
-               
"\3\26\3\26\3\26\3\26\7\26\u00df\n\26\f\26\16\26\u00e2\13\26\3\27\3\27"+
-               
"\5\27\u00e6\n\27\3\30\3\30\3\31\3\31\5\31\u00ec\n\31\3\31\3\31\3\31\5"+
-               
"\31\u00f1\n\31\3\31\3\31\3\31\3\31\5\31\u00f7\n\31\3\31\5\31\u00fa\n\31"+
-               
"\3\32\5\32\u00fd\n\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33\7\33"+
-               
"\u0108\n\33\f\33\16\33\u010b\13\33\3\34\3\34\3\34\3\34\3\35\3\35\3\35"+
-               
"\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\5\35\u011c\n\35\3\35\3\35\3\35"+
-               
"\5\35\u0121\n\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35"+
-               
"\3\35\3\35\3\35\3\35\7\35\u0132\n\35\f\35\16\35\u0135\13\35\3\36\3\36"+
-               
"\3\36\3\36\3\36\7\36\u013c\n\36\f\36\16\36\u013f\13\36\3\37\3\37\3\37"+
-               "\3\37\3\37\3 \3 \3 \3 \3 \3 \7 \u014c\n \f \16 \u014f\13 
\3!\3!\3!\5!"+
-               
"\u0154\n!\3!\5!\u0157\n!\3!\3!\5!\u015b\n!\3\"\3\"\3#\3#\5#\u0161\n#\3"+
-               
"$\3$\3%\3%\3%\3%\3%\3%\3&\3&\3&\2\b\b*\648:>\'\2\4\6\b\n\f\16\20\22\24"+
-               "\26\30\32\34\36 
\"$&(*,.\60\62\64\668:<>@BDFHJ\2\f\4\2\37\37((\4\2\30"+
-               
"\30%%\3\2+-\4\2%%))\3\2\21\24\3\2\17\20\3\2\25\26\3\2\13\f\3\2)+\4\2\3"+
-               
"\3\63\63\2\u0177\2L\3\2\2\2\4P\3\2\2\2\6Z\3\2\2\2\b^\3\2\2\2\nk\3\2\2"+
-               
"\2\fm\3\2\2\2\16r\3\2\2\2\20u\3\2\2\2\22y\3\2\2\2\24\u0081\3\2\2\2\26"+
-               
"\u0084\3\2\2\2\30\u0090\3\2\2\2\32\u0094\3\2\2\2\34\u0098\3\2\2\2\36\u009c"+
-               "\3\2\2\2 
\u00a2\3\2\2\2\"\u00b3\3\2\2\2$\u00b5\3\2\2\2&\u00c8\3\2\2\2"+
-               
"(\u00d7\3\2\2\2*\u00d9\3\2\2\2,\u00e5\3\2\2\2.\u00e7\3\2\2\2\60\u00e9"+
-               
"\3\2\2\2\62\u00fc\3\2\2\2\64\u0101\3\2\2\2\66\u010c\3\2\2\28\u0120\3\2"+
-               
"\2\2:\u0136\3\2\2\2<\u0140\3\2\2\2>\u0145\3\2\2\2@\u015a\3\2\2\2B\u015c"+
-               
"\3\2\2\2D\u0160\3\2\2\2F\u0162\3\2\2\2H\u0164\3\2\2\2J\u016a\3\2\2\2L"+
-               
"M\5\b\5\2MN\7\2\2\3N\3\3\2\2\2OQ\5\6\4\2PO\3\2\2\2PQ\3\2\2\2QR\3\2\2\2"+
-               
"RT\7\33\2\2SU\5:\36\2TS\3\2\2\2TU\3\2\2\2UV\3\2\2\2VW\58\35\2WX\7\34\2"+
-               "\2XY\7\2\2\3Y\5\3\2\2\2Z[\7 
\2\2[\\\5J&\2\\]\7!\2\2]\7\3\2\2\2^_\b\5\1"+
-               
"\2_`\5\n\6\2`e\3\2\2\2ab\f\3\2\2bd\5\n\6\2ca\3\2\2\2dg\3\2\2\2ec\3\2\2"+
-               
"\2ef\3\2\2\2f\t\3\2\2\2ge\3\2\2\2hl\5\26\f\2il\5\16\b\2jl\5\f\7\2kh\3"+
-               
"\2\2\2ki\3\2\2\2kj\3\2\2\2l\13\3\2\2\2mn\7\4\2\2no\7\31\2\2op\5B\"\2p"+
-               
"q\7\32\2\2q\r\3\2\2\2rs\5\20\t\2st\5*\26\2t\17\3\2\2\2uv\7\n\2\2vw\7("+
-               
"\2\2wx\5J&\2x\21\3\2\2\2yz\7\n\2\2z{\7\31\2\2{}\5J&\2|~\5\24\13\2}|\3"+
-               
"\2\2\2}~\3\2\2\2~\177\3\2\2\2\177\u0080\7\32\2\2\u0080\23\3\2\2\2\u0081"+
-               
"\u0082\7#\2\2\u0082\u0083\5\"\22\2\u0083\25\3\2\2\2\u0084\u0086\5\30\r"+
-               
"\2\u0085\u0087\5\32\16\2\u0086\u0085\3\2\2\2\u0086\u0087\3\2\2\2\u0087"+
-               
"\u0089\3\2\2\2\u0088\u008a\5\36\20\2\u0089\u0088\3\2\2\2\u0089\u008a\3"+
-               "\2\2\2\u008a\u008c\3\2\2\2\u008b\u008d\5 
\21\2\u008c\u008b\3\2\2\2\u008c"+
-               
"\u008d\3\2\2\2\u008d\u008e\3\2\2\2\u008e\u008f\5*\26\2\u008f\27\3\2\2"+
-               
"\2\u0090\u0091\7\5\2\2\u0091\u0092\7(\2\2\u0092\u0093\5J&\2\u0093\31\3"+
-               
"\2\2\2\u0094\u0095\7\6\2\2\u0095\u0096\7(\2\2\u0096\u0097\7\r\2\2\u0097"+
-               
"\33\3\2\2\2\u0098\u0099\7,\2\2\u0099\u009a\5\62\32\2\u009a\u009b\7,\2"+
-               
"\2\u009b\35\3\2\2\2\u009c\u009d\7\7\2\2\u009d\u00a0\7(\2\2\u009e\u00a1"+
-               
"\5B\"\2\u009f\u00a1\5\34\17\2\u00a0\u009e\3\2\2\2\u00a0\u009f\3\2\2\2"+
-               
"\u00a1\37\3\2\2\2\u00a2\u00a3\7\b\2\2\u00a3\u00a4\7(\2\2\u00a4\u00a5\5"+
-               
"\"\22\2\u00a5!\3\2\2\2\u00a6\u00a7\7\33\2\2\u00a7\u00ac\5$\23\2\u00a8"+
-               
"\u00a9\7#\2\2\u00a9\u00ab\5$\23\2\u00aa\u00a8\3\2\2\2\u00ab\u00ae\3\2"+
-               
"\2\2\u00ac\u00aa\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00af\3\2\2\2\u00ae"+
-               
"\u00ac\3\2\2\2\u00af\u00b0\7\34\2\2\u00b0\u00b4\3\2\2\2\u00b1\u00b2\7"+
-               
"\33\2\2\u00b2\u00b4\7\34\2\2\u00b3\u00a6\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4"+
-               
"#\3\2\2\2\u00b5\u00b6\5B\"\2\u00b6\u00b7\7$\2\2\u00b7\u00b8\5&\24\2\u00b8"+
-               
"%\3\2\2\2\u00b9\u00c9\5B\"\2\u00ba\u00bc\7%\2\2\u00bb\u00ba\3\2\2\2\u00bb"+
-               
"\u00bc\3\2\2\2\u00bc\u00bd\3\2\2\2\u00bd\u00bf\7\60\2\2\u00be\u00c0\7"+
-               
"\61\2\2\u00bf\u00be\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\u00c2\3\2\2\2\u00c1"+
-               
"\u00c3\7\62\2\2\u00c2\u00c1\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c9\3"+
-               
"\2\2\2\u00c4\u00c9\5\"\22\2\u00c5\u00c9\5(\25\2\u00c6\u00c9\7\r\2\2\u00c7"+
-               
"\u00c9\7\16\2\2\u00c8\u00b9\3\2\2\2\u00c8\u00bb\3\2\2\2\u00c8\u00c4\3"+
-               
"\2\2\2\u00c8\u00c5\3\2\2\2\u00c8\u00c6\3\2\2\2\u00c8\u00c7\3\2\2\2\u00c9"+
-               "\'\3\2\2\2\u00ca\u00cb\7 
\2\2\u00cb\u00d0\5&\24\2\u00cc\u00cd\7#\2\2\u00cd"+
-               
"\u00cf\5&\24\2\u00ce\u00cc\3\2\2\2\u00cf\u00d2\3\2\2\2\u00d0\u00ce\3\2"+
-               
"\2\2\u00d0\u00d1\3\2\2\2\u00d1\u00d3\3\2\2\2\u00d2\u00d0\3\2\2\2\u00d3"+
-               "\u00d4\7!\2\2\u00d4\u00d8\3\2\2\2\u00d5\u00d6\7 
\2\2\u00d6\u00d8\7!\2"+
-               
"\2\u00d7\u00ca\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d8)\3\2\2\2\u00d9\u00da"+
-               
"\b\26\1\2\u00da\u00db\5,\27\2\u00db\u00e0\3\2\2\2\u00dc\u00dd\f\3\2\2"+
-               
"\u00dd\u00df\5,\27\2\u00de\u00dc\3\2\2\2\u00df\u00e2\3\2\2\2\u00e0\u00de"+
-               
"\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1+\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e3"+
-               
"\u00e6\5\60\31\2\u00e4\u00e6\5\22\n\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4"+
-               
"\3\2\2\2\u00e6-\3\2\2\2\u00e7\u00e8\t\2\2\2\u00e8/\3\2\2\2\u00e9\u00eb"+
-               
"\7\t\2\2\u00ea\u00ec\5\66\34\2\u00eb\u00ea\3\2\2\2\u00eb\u00ec\3\2\2\2"+
-               
"\u00ec\u00ed\3\2\2\2\u00ed\u00f6\5.\30\2\u00ee\u00f0\7\33\2\2\u00ef\u00f1"+
-               
"\5:\36\2\u00f0\u00ef\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2"+
-               
"\u00f3\58\35\2\u00f3\u00f4\7\34\2\2\u00f4\u00f7\3\2\2\2\u00f5\u00f7\5"+
-               
"\34\17\2\u00f6\u00ee\3\2\2\2\u00f6\u00f5\3\2\2\2\u00f7\u00f9\3\2\2\2\u00f8"+
-               
"\u00fa\5D#\2\u00f9\u00f8\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\61\3\2\2\2"+
-               
"\u00fb\u00fd\5\64\33\2\u00fc\u00fb\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u00fe"+
-               
"\3\2\2\2\u00fe\u00ff\7\"\2\2\u00ff\u0100\5J&\2\u0100\63\3\2\2\2\u0101"+
-               
"\u0102\b\33\1\2\u0102\u0103\5J&\2\u0103\u0109\3\2\2\2\u0104\u0105\f\3"+
-               
"\2\2\u0105\u0106\7&\2\2\u0106\u0108\5J&\2\u0107\u0104\3\2\2\2\u0108\u010b"+
-               
"\3\2\2\2\u0109\u0107\3\2\2\2\u0109\u010a\3\2\2\2\u010a\65\3\2\2\2\u010b"+
-               
"\u0109\3\2\2\2\u010c\u010d\7\31\2\2\u010d\u010e\5J&\2\u010e\u010f\7\32"+
-               
"\2\2\u010f\67\3\2\2\2\u0110\u0111\b\35\1\2\u0111\u0112\t\3\2\2\u0112\u0121"+
-               
"\58\35\f\u0113\u0114\7\31\2\2\u0114\u0115\58\35\2\u0115\u0116\7\32\2\2"+
-               
"\u0116\u0121\3\2\2\2\u0117\u0121\5@!\2\u0118\u0119\7\3\2\2\u0119\u011b"+
-               "\7\31\2\2\u011a\u011c\5> 
\2\u011b\u011a\3\2\2\2\u011b\u011c\3\2\2\2\u011c"+
-               
"\u011d\3\2\2\2\u011d\u0121\7\32\2\2\u011e\u011f\7.\2\2\u011f\u0121\5J"+
-               
"&\2\u0120\u0110\3\2\2\2\u0120\u0113\3\2\2\2\u0120\u0117\3\2\2\2\u0120"+
-               
"\u0118\3\2\2\2\u0120\u011e\3\2\2\2\u0121\u0133\3\2\2\2\u0122\u0123\f\n"+
-               
"\2\2\u0123\u0124\t\4\2\2\u0124\u0132\58\35\13\u0125\u0126\f\t\2\2\u0126"+
-               
"\u0127\t\5\2\2\u0127\u0132\58\35\n\u0128\u0129\f\b\2\2\u0129\u012a\t\6"+
-               
"\2\2\u012a\u0132\58\35\t\u012b\u012c\f\7\2\2\u012c\u012d\t\7\2\2\u012d"+
-               
"\u0132\58\35\b\u012e\u012f\f\6\2\2\u012f\u0130\t\b\2\2\u0130\u0132\58"+
-               
"\35\7\u0131\u0122\3\2\2\2\u0131\u0125\3\2\2\2\u0131\u0128\3\2\2\2\u0131"+
-               
"\u012b\3\2\2\2\u0131\u012e\3\2\2\2\u0132\u0135\3\2\2\2\u0133\u0131\3\2"+
-               
"\2\2\u0133\u0134\3\2\2\2\u01349\3\2\2\2\u0135\u0133\3\2\2\2\u0136\u0137"+
-               
"\b\36\1\2\u0137\u0138\5<\37\2\u0138\u013d\3\2\2\2\u0139\u013a\f\3\2\2"+
-               
"\u013a\u013c\5<\37\2\u013b\u0139\3\2\2\2\u013c\u013f\3\2\2\2\u013d\u013b"+
-               
"\3\2\2\2\u013d\u013e\3\2\2\2\u013e;\3\2\2\2\u013f\u013d\3\2\2\2\u0140"+
-               
"\u0141\7.\2\2\u0141\u0142\5J&\2\u0142\u0143\7(\2\2\u0143\u0144\58\35\2"+
-               "\u0144=\3\2\2\2\u0145\u0146\b 
\1\2\u0146\u0147\58\35\2\u0147\u014d\3\2"+
-               
"\2\2\u0148\u0149\f\3\2\2\u0149\u014a\7#\2\2\u014a\u014c\58\35\2\u014b"+
-               
"\u0148\3\2\2\2\u014c\u014f\3\2\2\2\u014d\u014b\3\2\2\2\u014d\u014e\3\2"+
-               
"\2\2\u014e?\3\2\2\2\u014f\u014d\3\2\2\2\u0150\u015b\7\16\2\2\u0151\u0153"+
-               
"\7\60\2\2\u0152\u0154\7\61\2\2\u0153\u0152\3\2\2\2\u0153\u0154\3\2\2\2"+
-               
"\u0154\u0156\3\2\2\2\u0155\u0157\7\62\2\2\u0156\u0155\3\2\2\2\u0156\u0157"+
-               
"\3\2\2\2\u0157\u015b\3\2\2\2\u0158\u015b\7\r\2\2\u0159\u015b\5B\"\2\u015a"+
-               
"\u0150\3\2\2\2\u015a\u0151\3\2\2\2\u015a\u0158\3\2\2\2\u015a\u0159\3\2"+
-               
"\2\2\u015bA\3\2\2\2\u015c\u015d\t\t\2\2\u015dC\3\2\2\2\u015e\u0161\5F"+
-               
"$\2\u015f\u0161\5H%\2\u0160\u015e\3\2\2\2\u0160\u015f\3\2\2\2\u0161E\3"+
-               "\2\2\2\u0162\u0163\t\n\2\2\u0163G\3\2\2\2\u0164\u0165\7 
\2\2\u0165\u0166"+
-               
"\7\60\2\2\u0166\u0167\7#\2\2\u0167\u0168\7\60\2\2\u0168\u0169\7!\2\2\u0169"+
-               
"I\3\2\2\2\u016a\u016b\t\13\2\2\u016bK\3\2\2\2%PTek}\u0086\u0089\u008c"+
-               
"\u00a0\u00ac\u00b3\u00bb\u00bf\u00c2\u00c8\u00d0\u00d7\u00e0\u00e5\u00eb"+
-               
"\u00f0\u00f6\u00f9\u00fc\u0109\u011b\u0120\u0131\u0133\u013d\u014d\u0153"+
-               "\u0156\u015a\u0160";
+               
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\3\2\3\2\3\2\3\3\5\3S\n\3\3"+
+               
"\3\3\3\5\3W\n\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\7"+
+               
"\5f\n\5\f\5\16\5i\13\5\3\6\3\6\3\6\5\6n\n\6\3\7\3\7\3\7\3\7\3\7\3\b\3"+
+               
"\b\3\b\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\5\n\u0080\n\n\3\n\3\n\3\13\3\13"+
+               
"\3\13\3\f\3\f\5\f\u0089\n\f\3\f\5\f\u008c\n\f\3\f\5\f\u008f\n\f\3\f\3"+
+               
"\f\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\20\3\20\3"+
+               
"\20\3\20\5\20\u00a3\n\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22"+
+               
"\u00ad\n\22\f\22\16\22\u00b0\13\22\3\22\3\22\3\22\3\22\5\22\u00b6\n\22"+
+               
"\3\23\3\23\3\23\3\23\3\24\3\24\5\24\u00be\n\24\3\24\3\24\5\24\u00c2\n"+
+               
"\24\3\24\5\24\u00c5\n\24\3\24\3\24\3\24\3\24\5\24\u00cb\n\24\3\25\3\25"+
+               
"\3\25\3\25\7\25\u00d1\n\25\f\25\16\25\u00d4\13\25\3\25\3\25\3\25\3\25"+
+               
"\5\25\u00da\n\25\3\26\3\26\3\26\3\26\3\26\7\26\u00e1\n\26\f\26\16\26\u00e4"+
+               
"\13\26\3\27\3\27\5\27\u00e8\n\27\3\30\3\30\3\31\3\31\5\31\u00ee\n\31\3"+
+               
"\31\3\31\3\31\5\31\u00f3\n\31\3\31\3\31\3\31\3\31\5\31\u00f9\n\31\3\31"+
+               
"\5\31\u00fc\n\31\3\32\5\32\u00ff\n\32\3\32\3\32\3\32\3\33\3\33\3\33\3"+
+               
"\33\3\33\3\33\7\33\u010a\n\33\f\33\16\33\u010d\13\33\3\34\3\34\3\34\3"+
+               
"\34\3\34\3\34\3\34\3\34\5\34\u0117\n\34\3\35\3\35\3\35\3\35\3\36\3\36"+
+               
"\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\5\36\u0128\n\36\3\36\3\36"+
+               
"\3\36\5\36\u012d\n\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36"+
+               
"\3\36\3\36\3\36\3\36\3\36\7\36\u013e\n\36\f\36\16\36\u0141\13\36\3\37"+
+               "\3\37\3\37\3\37\3\37\7\37\u0148\n\37\f\37\16\37\u014b\13\37\3 
\3 \3 \3"+
+               " \3 
\3!\3!\3!\3!\3!\3!\7!\u0158\n!\f!\16!\u015b\13!\3\"\3\"\3\"\5\"\u0160"+
+               
"\n\"\3\"\5\"\u0163\n\"\3\"\3\"\5\"\u0167\n\"\3#\3#\3$\3$\5$\u016d\n$\3"+
+               
"%\3%\3&\3&\3&\3&\3&\3&\3\'\3\'\3\'\2\b\b*\64:<@(\2\4\6\b\n\f\16\20\22"+
+               "\24\26\30\32\34\36 
\"$&(*,.\60\62\64\668:<>@BDFHJL\2\f\4\2\37\37((\4\2"+
+               
"\30\30%%\3\2+-\4\2%%))\3\2\21\24\3\2\17\20\3\2\25\26\3\2\13\f\3\2)+\4"+
+               
"\2\3\3\63\63\2\u0189\2N\3\2\2\2\4R\3\2\2\2\6\\\3\2\2\2\b`\3\2\2\2\nm\3"+
+               
"\2\2\2\fo\3\2\2\2\16t\3\2\2\2\20w\3\2\2\2\22{\3\2\2\2\24\u0083\3\2\2\2"+
+               
"\26\u0086\3\2\2\2\30\u0092\3\2\2\2\32\u0096\3\2\2\2\34\u009a\3\2\2\2\36"+
+               "\u009e\3\2\2\2 
\u00a4\3\2\2\2\"\u00b5\3\2\2\2$\u00b7\3\2\2\2&\u00ca\3"+
+               
"\2\2\2(\u00d9\3\2\2\2*\u00db\3\2\2\2,\u00e7\3\2\2\2.\u00e9\3\2\2\2\60"+
+               
"\u00eb\3\2\2\2\62\u00fe\3\2\2\2\64\u0103\3\2\2\2\66\u0116\3\2\2\28\u0118"+
+               
"\3\2\2\2:\u012c\3\2\2\2<\u0142\3\2\2\2>\u014c\3\2\2\2@\u0151\3\2\2\2B"+
+               
"\u0166\3\2\2\2D\u0168\3\2\2\2F\u016c\3\2\2\2H\u016e\3\2\2\2J\u0170\3\2"+
+               
"\2\2L\u0176\3\2\2\2NO\5\b\5\2OP\7\2\2\3P\3\3\2\2\2QS\5\6\4\2RQ\3\2\2\2"+
+               
"RS\3\2\2\2ST\3\2\2\2TV\7\33\2\2UW\5<\37\2VU\3\2\2\2VW\3\2\2\2WX\3\2\2"+
+               "\2XY\5:\36\2YZ\7\34\2\2Z[\7\2\2\3[\5\3\2\2\2\\]\7 
\2\2]^\5L\'\2^_\7!\2"+
+               
"\2_\7\3\2\2\2`a\b\5\1\2ab\5\n\6\2bg\3\2\2\2cd\f\3\2\2df\5\n\6\2ec\3\2"+
+               
"\2\2fi\3\2\2\2ge\3\2\2\2gh\3\2\2\2h\t\3\2\2\2ig\3\2\2\2jn\5\26\f\2kn\5"+
+               
"\16\b\2ln\5\f\7\2mj\3\2\2\2mk\3\2\2\2ml\3\2\2\2n\13\3\2\2\2op\7\4\2\2"+
+               
"pq\7\31\2\2qr\5D#\2rs\7\32\2\2s\r\3\2\2\2tu\5\20\t\2uv\5*\26\2v\17\3\2"+
+               
"\2\2wx\7\n\2\2xy\7(\2\2yz\5L\'\2z\21\3\2\2\2{|\7\n\2\2|}\7\31\2\2}\177"+
+               
"\5L\'\2~\u0080\5\24\13\2\177~\3\2\2\2\177\u0080\3\2\2\2\u0080\u0081\3"+
+               
"\2\2\2\u0081\u0082\7\32\2\2\u0082\23\3\2\2\2\u0083\u0084\7#\2\2\u0084"+
+               
"\u0085\5\"\22\2\u0085\25\3\2\2\2\u0086\u0088\5\30\r\2\u0087\u0089\5\32"+
+               
"\16\2\u0088\u0087\3\2\2\2\u0088\u0089\3\2\2\2\u0089\u008b\3\2\2\2\u008a"+
+               
"\u008c\5\36\20\2\u008b\u008a\3\2\2\2\u008b\u008c\3\2\2\2\u008c\u008e\3"+
+               "\2\2\2\u008d\u008f\5 
\21\2\u008e\u008d\3\2\2\2\u008e\u008f\3\2\2\2\u008f"+
+               
"\u0090\3\2\2\2\u0090\u0091\5*\26\2\u0091\27\3\2\2\2\u0092\u0093\7\5\2"+
+               
"\2\u0093\u0094\7(\2\2\u0094\u0095\5L\'\2\u0095\31\3\2\2\2\u0096\u0097"+
+               
"\7\6\2\2\u0097\u0098\7(\2\2\u0098\u0099\7\r\2\2\u0099\33\3\2\2\2\u009a"+
+               
"\u009b\7,\2\2\u009b\u009c\5\62\32\2\u009c\u009d\7,\2\2\u009d\35\3\2\2"+
+               
"\2\u009e\u009f\7\7\2\2\u009f\u00a2\7(\2\2\u00a0\u00a3\5D#\2\u00a1\u00a3"+
+               
"\5\34\17\2\u00a2\u00a0\3\2\2\2\u00a2\u00a1\3\2\2\2\u00a3\37\3\2\2\2\u00a4"+
+               
"\u00a5\7\b\2\2\u00a5\u00a6\7(\2\2\u00a6\u00a7\5\"\22\2\u00a7!\3\2\2\2"+
+               
"\u00a8\u00a9\7\33\2\2\u00a9\u00ae\5$\23\2\u00aa\u00ab\7#\2\2\u00ab\u00ad"+
+               
"\5$\23\2\u00ac\u00aa\3\2\2\2\u00ad\u00b0\3\2\2\2\u00ae\u00ac\3\2\2\2\u00ae"+
+               
"\u00af\3\2\2\2\u00af\u00b1\3\2\2\2\u00b0\u00ae\3\2\2\2\u00b1\u00b2\7\34"+
+               
"\2\2\u00b2\u00b6\3\2\2\2\u00b3\u00b4\7\33\2\2\u00b4\u00b6\7\34\2\2\u00b5"+
+               
"\u00a8\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b6#\3\2\2\2\u00b7\u00b8\5D#\2\u00b8"+
+               
"\u00b9\7$\2\2\u00b9\u00ba\5&\24\2\u00ba%\3\2\2\2\u00bb\u00cb\5D#\2\u00bc"+
+               
"\u00be\7%\2\2\u00bd\u00bc\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00bf\3\2"+
+               
"\2\2\u00bf\u00c1\7\60\2\2\u00c0\u00c2\7\61\2\2\u00c1\u00c0\3\2\2\2\u00c1"+
+               
"\u00c2\3\2\2\2\u00c2\u00c4\3\2\2\2\u00c3\u00c5\7\62\2\2\u00c4\u00c3\3"+
+               
"\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00cb\3\2\2\2\u00c6\u00cb\5\"\22\2\u00c7"+
+               
"\u00cb\5(\25\2\u00c8\u00cb\7\r\2\2\u00c9\u00cb\7\16\2\2\u00ca\u00bb\3"+
+               
"\2\2\2\u00ca\u00bd\3\2\2\2\u00ca\u00c6\3\2\2\2\u00ca\u00c7\3\2\2\2\u00ca"+
+               
"\u00c8\3\2\2\2\u00ca\u00c9\3\2\2\2\u00cb\'\3\2\2\2\u00cc\u00cd\7 \2\2"+
+               
"\u00cd\u00d2\5&\24\2\u00ce\u00cf\7#\2\2\u00cf\u00d1\5&\24\2\u00d0\u00ce"+
+               
"\3\2\2\2\u00d1\u00d4\3\2\2\2\u00d2\u00d0\3\2\2\2\u00d2\u00d3\3\2\2\2\u00d3"+
+               
"\u00d5\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d5\u00d6\7!\2\2\u00d6\u00da\3\2"+
+               "\2\2\u00d7\u00d8\7 
\2\2\u00d8\u00da\7!\2\2\u00d9\u00cc\3\2\2\2\u00d9\u00d7"+
+               
"\3\2\2\2\u00da)\3\2\2\2\u00db\u00dc\b\26\1\2\u00dc\u00dd\5,\27\2\u00dd"+
+               
"\u00e2\3\2\2\2\u00de\u00df\f\3\2\2\u00df\u00e1\5,\27\2\u00e0\u00de\3\2"+
+               
"\2\2\u00e1\u00e4\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3"+
+               
"+\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e5\u00e8\5\60\31\2\u00e6\u00e8\5\22\n"+
+               
"\2\u00e7\u00e5\3\2\2\2\u00e7\u00e6\3\2\2\2\u00e8-\3\2\2\2\u00e9\u00ea"+
+               
"\t\2\2\2\u00ea/\3\2\2\2\u00eb\u00ed\7\t\2\2\u00ec\u00ee\58\35\2\u00ed"+
+               
"\u00ec\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f8\5."+
+               
"\30\2\u00f0\u00f2\7\33\2\2\u00f1\u00f3\5<\37\2\u00f2\u00f1\3\2\2\2\u00f2"+
+               
"\u00f3\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4\u00f5\5:\36\2\u00f5\u00f6\7\34"+
+               
"\2\2\u00f6\u00f9\3\2\2\2\u00f7\u00f9\5\34\17\2\u00f8\u00f0\3\2\2\2\u00f8"+
+               
"\u00f7\3\2\2\2\u00f9\u00fb\3\2\2\2\u00fa\u00fc\5F$\2\u00fb\u00fa\3\2\2"+
+               
"\2\u00fb\u00fc\3\2\2\2\u00fc\61\3\2\2\2\u00fd\u00ff\5\64\33\2\u00fe\u00fd"+
+               
"\3\2\2\2\u00fe\u00ff\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0101\7\"\2\2\u0101"+
+               
"\u0102\5L\'\2\u0102\63\3\2\2\2\u0103\u0104\b\33\1\2\u0104\u0105\5\66\34"+
+               
"\2\u0105\u010b\3\2\2\2\u0106\u0107\f\3\2\2\u0107\u0108\7&\2\2\u0108\u010a"+
+               
"\5\66\34\2\u0109\u0106\3\2\2\2\u010a\u010d\3\2\2\2\u010b\u0109\3\2\2\2"+
+               
"\u010b\u010c\3\2\2\2\u010c\65\3\2\2\2\u010d\u010b\3\2\2\2\u010e\u0117"+
+               
"\5L\'\2\u010f\u0117\7\4\2\2\u0110\u0117\7\5\2\2\u0111\u0117\7\6\2\2\u0112"+
+               
"\u0117\7\7\2\2\u0113\u0117\7\b\2\2\u0114\u0117\7\t\2\2\u0115\u0117\7\n"+
+               
"\2\2\u0116\u010e\3\2\2\2\u0116\u010f\3\2\2\2\u0116\u0110\3\2\2\2\u0116"+
+               
"\u0111\3\2\2\2\u0116\u0112\3\2\2\2\u0116\u0113\3\2\2\2\u0116\u0114\3\2"+
+               
"\2\2\u0116\u0115\3\2\2\2\u0117\67\3\2\2\2\u0118\u0119\7\31\2\2\u0119\u011a"+
+               
"\5L\'\2\u011a\u011b\7\32\2\2\u011b9\3\2\2\2\u011c\u011d\b\36\1\2\u011d"+
+               
"\u011e\t\3\2\2\u011e\u012d\5:\36\f\u011f\u0120\7\31\2\2\u0120\u0121\5"+
+               
":\36\2\u0121\u0122\7\32\2\2\u0122\u012d\3\2\2\2\u0123\u012d\5B\"\2\u0124"+
+               
"\u0125\7\3\2\2\u0125\u0127\7\31\2\2\u0126\u0128\5@!\2\u0127\u0126\3\2"+
+               
"\2\2\u0127\u0128\3\2\2\2\u0128\u0129\3\2\2\2\u0129\u012d\7\32\2\2\u012a"+
+               
"\u012b\7.\2\2\u012b\u012d\5L\'\2\u012c\u011c\3\2\2\2\u012c\u011f\3\2\2"+
+               
"\2\u012c\u0123\3\2\2\2\u012c\u0124\3\2\2\2\u012c\u012a\3\2\2\2\u012d\u013f"+
+               
"\3\2\2\2\u012e\u012f\f\n\2\2\u012f\u0130\t\4\2\2\u0130\u013e\5:\36\13"+
+               
"\u0131\u0132\f\t\2\2\u0132\u0133\t\5\2\2\u0133\u013e\5:\36\n\u0134\u0135"+
+               
"\f\b\2\2\u0135\u0136\t\6\2\2\u0136\u013e\5:\36\t\u0137\u0138\f\7\2\2\u0138"+
+               
"\u0139\t\7\2\2\u0139\u013e\5:\36\b\u013a\u013b\f\6\2\2\u013b\u013c\t\b"+
+               
"\2\2\u013c\u013e\5:\36\7\u013d\u012e\3\2\2\2\u013d\u0131\3\2\2\2\u013d"+
+               
"\u0134\3\2\2\2\u013d\u0137\3\2\2\2\u013d\u013a\3\2\2\2\u013e\u0141\3\2"+
+               
"\2\2\u013f\u013d\3\2\2\2\u013f\u0140\3\2\2\2\u0140;\3\2\2\2\u0141\u013f"+
+               "\3\2\2\2\u0142\u0143\b\37\1\2\u0143\u0144\5> 
\2\u0144\u0149\3\2\2\2\u0145"+
+               "\u0146\f\3\2\2\u0146\u0148\5> 
\2\u0147\u0145\3\2\2\2\u0148\u014b\3\2\2"+
+               
"\2\u0149\u0147\3\2\2\2\u0149\u014a\3\2\2\2\u014a=\3\2\2\2\u014b\u0149"+
+               
"\3\2\2\2\u014c\u014d\7.\2\2\u014d\u014e\5L\'\2\u014e\u014f\7(\2\2\u014f"+
+               
"\u0150\5:\36\2\u0150?\3\2\2\2\u0151\u0152\b!\1\2\u0152\u0153\5:\36\2\u0153"+
+               
"\u0159\3\2\2\2\u0154\u0155\f\3\2\2\u0155\u0156\7#\2\2\u0156\u0158\5:\36"+
+               
"\2\u0157\u0154\3\2\2\2\u0158\u015b\3\2\2\2\u0159\u0157\3\2\2\2\u0159\u015a"+
+               
"\3\2\2\2\u015aA\3\2\2\2\u015b\u0159\3\2\2\2\u015c\u0167\7\16\2\2\u015d"+
+               
"\u015f\7\60\2\2\u015e\u0160\7\61\2\2\u015f\u015e\3\2\2\2\u015f\u0160\3"+
+               
"\2\2\2\u0160\u0162\3\2\2\2\u0161\u0163\7\62\2\2\u0162\u0161\3\2\2\2\u0162"+
+               
"\u0163\3\2\2\2\u0163\u0167\3\2\2\2\u0164\u0167\7\r\2\2\u0165\u0167\5D"+
+               
"#\2\u0166\u015c\3\2\2\2\u0166\u015d\3\2\2\2\u0166\u0164\3\2\2\2\u0166"+
+               
"\u0165\3\2\2\2\u0167C\3\2\2\2\u0168\u0169\t\t\2\2\u0169E\3\2\2\2\u016a"+
+               
"\u016d\5H%\2\u016b\u016d\5J&\2\u016c\u016a\3\2\2\2\u016c\u016b\3\2\2\2"+
+               
"\u016dG\3\2\2\2\u016e\u016f\t\n\2\2\u016fI\3\2\2\2\u0170\u0171\7 \2\2"+
+               
"\u0171\u0172\7\60\2\2\u0172\u0173\7#\2\2\u0173\u0174\7\60\2\2\u0174\u0175"+
+               
"\7!\2\2\u0175K\3\2\2\2\u0176\u0177\t\13\2\2\u0177M\3\2\2\2&RVgm\177\u0088"+
+               
"\u008b\u008e\u00a2\u00ae\u00b5\u00bd\u00c1\u00c4\u00ca\u00d2\u00d9\u00e2"+
+               
"\u00e7\u00ed\u00f2\u00f8\u00fb\u00fe\u010b\u0116\u0127\u012c\u013d\u013f"+
+               "\u0149\u0159\u015f\u0162\u0166\u016c";
        public static final ATN _ATN =
                new ATNDeserializer().deserialize(_serializedATN.toCharArray());
        static {

Reply via email to