From 4399ba0f40dcd6d933ed3a21ce040c8dc915f03d Mon Sep 17 00:00:00 2001 From: Mateo Date: Thu, 26 Feb 2026 12:48:53 +0100 Subject: [PATCH 01/10] Updated grammar to handle sub with scalar (as VarID) casting --- src/vtlengine/AST/Grammar/Vtl.g4 | 1 + 1 file changed, 1 insertion(+) diff --git a/src/vtlengine/AST/Grammar/Vtl.g4 b/src/vtlengine/AST/Grammar/Vtl.g4 index 7b2cbbb6d..8614aede4 100644 --- a/src/vtlengine/AST/Grammar/Vtl.g4 +++ b/src/vtlengine/AST/Grammar/Vtl.g4 @@ -369,6 +369,7 @@ subspaceClauseItem: scalarItem: constant #simpleScalar | CAST LPAREN constant COMMA (basicScalarType) (COMMA STRING_CONSTANT)? RPAREN #scalarWithCast + | CAST LPAREN varID COMMA (basicScalarType) (COMMA STRING_CONSTANT)? RPAREN #scalarVarWithCast ; /*END SUBSPACE CLAUSE*/ /*----------------------------------------------END CLAUSE EXPRESSION--------------------------------------*/ From e966ecdec0f8de09ec3b418027f5ed6643cb69d4 Mon Sep 17 00:00:00 2001 From: Mateo Date: Thu, 26 Feb 2026 12:49:48 +0100 Subject: [PATCH 02/10] Regenerated lexer and parser --- src/vtlengine/AST/Grammar/lexer.py | 923 +- src/vtlengine/AST/Grammar/parser.py | 12376 +++++++++++++------------- 2 files changed, 6412 insertions(+), 6887 deletions(-) diff --git a/src/vtlengine/AST/Grammar/lexer.py b/src/vtlengine/AST/Grammar/lexer.py index b7cf9ab69..39936829f 100644 --- a/src/vtlengine/AST/Grammar/lexer.py +++ b/src/vtlengine/AST/Grammar/lexer.py @@ -1,4 +1,4 @@ -# Generated from Vtl.g4 by ANTLR 4.9.2 +# Generated from Vtl.g4 by ANTLR 4.9.3 from antlr4 import ( Lexer as ANTLRLexer, ATNDeserializer, @@ -11,6 +11,7 @@ from typing import TextIO + def serializedATN(): with StringIO() as buf: buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u00fb") @@ -19,8 +20,8 @@ def serializedATN(): buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23") buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30") buf.write("\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36") - buf.write('\t\36\4\37\t\37\4 \t \4!\t!\4"\t"\4#\t#\4$\t$\4%\t%') - buf.write("\4&\t&\4'\t'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.") + buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%") + buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.") buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64") buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:") buf.write("\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\t") @@ -76,10 +77,10 @@ def serializedATN(): buf.write("\3\34\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36") buf.write("\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37") buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \3 \3 \3") - buf.write(' \3!\3!\3!\3!\3!\3"\3"\3"\3"\3"\3"\3#\3#\3#\3#\3') + buf.write(" \3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3") buf.write("#\3#\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3%\3") buf.write("%\3%\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3&\3&\3&\3") - buf.write("&\3&\3'\3'\3'\3'\3'\3'\3'\3'\3'\3'\3(\3(\3(") + buf.write("&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(") buf.write("\3(\3(\3(\3(\3(\3(\3(\3(\3)\3)\3)\3*\3*\3*\3*\3*\3+\3") buf.write("+\3+\3+\3+\3,\3,\3,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3-\3-\3") buf.write(".\3.\3.\3.\3.\3.\3.\3/\3/\3/\3\60\3\60\3\60\3\60\3\61") @@ -282,8 +283,8 @@ def serializedATN(): buf.write("\16\u00fc\u0951\13\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fc") buf.write("\5\u092c\u0941\u094f\2\u00fd\3\3\5\4\7\5\t\6\13\7\r\b") buf.write("\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22") - buf.write("#\23%\24'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\35") - buf.write("9\36;\37= ?!A\"C#E$G%I&K'M(O)Q*S+U,W-Y.[/]\60_\61a\62") + buf.write("#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\35") + buf.write("9\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62") buf.write("c\63e\64g\65i\66k\67m8o9q:s;u{?}@\177A\u0081B\u0083") buf.write("C\u0085D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093") buf.write("K\u0095L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1R\u00a3") @@ -321,11 +322,11 @@ def serializedATN(): buf.write("\u00f2\u01e3\2\u01e5\2\u01e7\u00f3\u01e9\u00f4\u01eb\u00f5") buf.write("\u01ed\u00f6\u01ef\u00f7\u01f1\u00f8\u01f3\u00f9\u01f5") buf.write("\u00fa\u01f7\u00fb\3\2\6\4\2C\\c|\3\2$$\7\2\60\60\62;") - buf.write('C\\aac|\5\2\13\f\16\17""\2\u0960\2\3\3\2\2\2\2\5\3\2') + buf.write("C\\aac|\5\2\13\f\16\17\"\"\2\u0960\2\3\3\2\2\2\2\5\3\2") buf.write("\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2") buf.write("\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2") buf.write("\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37") - buf.write("\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2'\3\2\2\2") + buf.write("\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2") buf.write("\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2") buf.write("\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2") buf.write("\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2") @@ -393,7 +394,7 @@ def serializedATN(): buf.write("\u0203\3\2\2\2\17\u0205\3\2\2\2\21\u0207\3\2\2\2\23\u0209") buf.write("\3\2\2\2\25\u020b\3\2\2\2\27\u020e\3\2\2\2\31\u0211\3") buf.write("\2\2\2\33\u0214\3\2\2\2\35\u0216\3\2\2\2\37\u0218\3\2") - buf.write("\2\2!\u021a\3\2\2\2#\u021c\3\2\2\2%\u021e\3\2\2\2'\u0221") + buf.write("\2\2!\u021a\3\2\2\2#\u021c\3\2\2\2%\u021e\3\2\2\2\'\u0221") buf.write("\3\2\2\2)\u0223\3\2\2\2+\u0226\3\2\2\2-\u0228\3\2\2\2") buf.write("/\u022d\3\2\2\2\61\u0230\3\2\2\2\63\u0235\3\2\2\2\65\u023a") buf.write("\3\2\2\2\67\u023f\3\2\2\29\u0245\3\2\2\2;\u024a\3\2\2") @@ -486,7 +487,7 @@ def serializedATN(): buf.write("\7>\2\2\u0212\u0213\7?\2\2\u0213\32\3\2\2\2\u0214\u0215") buf.write("\7-\2\2\u0215\34\3\2\2\2\u0216\u0217\7/\2\2\u0217\36\3") buf.write("\2\2\2\u0218\u0219\7,\2\2\u0219 \3\2\2\2\u021a\u021b\7") - buf.write('\61\2\2\u021b"\3\2\2\2\u021c\u021d\7.\2\2\u021d$\3\2') + buf.write("\61\2\2\u021b\"\3\2\2\2\u021c\u021d\7.\2\2\u021d$\3\2") buf.write("\2\2\u021e\u021f\7/\2\2\u021f\u0220\7@\2\2\u0220&\3\2") buf.write("\2\2\u0221\u0222\7<\2\2\u0222(\3\2\2\2\u0223\u0224\7<") buf.write("\2\2\u0224\u0225\7?\2\2\u0225*\3\2\2\2\u0226\u0227\7%") @@ -1118,9 +1119,10 @@ def serializedATN(): class Lexer(ANTLRLexer): + atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] LPAREN = 1 RPAREN = 2 @@ -1372,768 +1374,155 @@ class Lexer(ANTLRLexer): ML_COMMENT = 248 SL_COMMENT = 249 - channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] - modeNames = ["DEFAULT_MODE"] + modeNames = [ "DEFAULT_MODE" ] - literalNames = [ - "", - "'('", - "')'", - "'['", - "']'", - "'{'", - "'}'", - "'='", - "'<'", - "'>'", - "'>='", - "'<>'", - "'<='", - "'+'", - "'-'", - "'*'", - "'/'", - "','", - "'->'", - "':'", - "':='", - "'#'", - "'eval'", - "'if'", - "'case'", - "'then'", - "'else'", - "'using'", - "'with'", - "'current_date'", - "'datediff'", - "'dateadd'", - "'year'", - "'month'", - "'dayofmonth'", - "'dayofyear'", - "'daytoyear'", - "'daytomonth'", - "'yeartoday'", - "'monthtoday'", - "'on'", - "'drop'", - "'keep'", - "'calc'", - "'attrcalc'", - "'rename'", - "'as'", - "'and'", - "'or'", - "'xor'", - "'not'", - "'between'", - "'in'", - "'not_in'", - "'null'", - "'isnull'", - "'ex'", - "'union'", - "'diff'", - "'symdiff'", - "'intersect'", - "'random'", - "'keys'", - "'intyear'", - "'intmonth'", - "'intday'", - "'check'", - "'exists_in'", - "'to'", - "'return'", - "'imbalance'", - "'errorcode'", - "'all'", - "'aggr'", - "'errorlevel'", - "'order'", - "'by'", - "'rank'", - "'asc'", - "'desc'", - "'min'", - "'max'", - "'first'", - "'last'", - "'indexof'", - "'abs'", - "'key'", - "'ln'", - "'log'", - "'trunc'", - "'round'", - "'power'", - "'mod'", - "'length'", - "'||'", - "'trim'", - "'upper'", - "'lower'", - "'substr'", - "'sum'", - "'avg'", - "'median'", - "'count'", - "'identifier'", - "'measure'", - "'attribute'", - "'filter'", - "'merge'", - "'exp'", - "'componentRole'", - "'viral'", - "'match_characters'", - "'type'", - "'nvl'", - "'hierarchy'", - "'_'", - "'invalid'", - "'valuedomain'", - "'variable'", - "'data'", - "'structure'", - "'dataset'", - "'operator'", - "'define'", - "'<-'", - "'datapoint'", - "'hierarchical'", - "'ruleset'", - "'rule'", - "'end'", - "'alterDataset'", - "'ltrim'", - "'rtrim'", - "'instr'", - "'replace'", - "'ceil'", - "'floor'", - "'sqrt'", - "'any'", - "'setdiff'", - "'stddev_pop'", - "'stddev_samp'", - "'var_pop'", - "'var_samp'", - "'group'", - "'except'", - "'having'", - "'first_value'", - "'last_value'", - "'lag'", - "'lead'", - "'ratio_to_report'", - "'over'", - "'preceding'", - "'following'", - "'unbounded'", - "'partition'", - "'rows'", - "'range'", - "'current'", - "'valid'", - "'fill_time_series'", - "'flow_to_stock'", - "'stock_to_flow'", - "'timeshift'", - "'measures'", - "'no_measures'", - "'condition'", - "'boolean'", - "'date'", - "'time_period'", - "'number'", - "'string'", - "'time'", - "'integer'", - "'float'", - "'list'", - "'record'", - "'restrict'", - "'yyyy'", - "'mm'", - "'dd'", - "'maxLength'", - "'regexp'", - "'is'", - "'when'", - "'from'", - "'aggregates'", - "'points'", - "'point'", - "'total'", - "'partial'", - "'always'", - "'inner_join'", - "'left_join'", - "'cross_join'", - "'full_join'", - "'maps_from'", - "'maps_to'", - "'map_to'", - "'map_from'", - "'returns'", - "'pivot'", - "'customPivot'", - "'unpivot'", - "'sub'", - "'apply'", - "'conditioned'", - "'period_indicator'", - "'single'", - "'duration'", - "'time_agg'", - "'unit'", - "'Value'", - "'valuedomains'", - "'variables'", - "'input'", - "'output'", - "'cast'", - "'rule_priority'", - "'dataset_priority'", - "'default'", - "'check_datapoint'", - "'check_hierarchy'", - "'computed'", - "'non_null'", - "'non_zero'", - "'partial_null'", - "'partial_zero'", - "'always_null'", - "'always_zero'", - "'components'", - "'all_measures'", - "'scalar'", - "'component'", - "'datapoint_on_valuedomains'", - "'datapoint_on_variables'", - "'hierarchical_on_valuedomains'", - "'hierarchical_on_variables'", - "'set'", - "'language'", - "';'", - ] + literalNames = [ "", + "'('", "')'", "'['", "']'", "'{'", "'}'", "'='", "'<'", "'>'", + "'>='", "'<>'", "'<='", "'+'", "'-'", "'*'", "'/'", "','", "'->'", + "':'", "':='", "'#'", "'eval'", "'if'", "'case'", "'then'", + "'else'", "'using'", "'with'", "'current_date'", "'datediff'", + "'dateadd'", "'year'", "'month'", "'dayofmonth'", "'dayofyear'", + "'daytoyear'", "'daytomonth'", "'yeartoday'", "'monthtoday'", + "'on'", "'drop'", "'keep'", "'calc'", "'attrcalc'", "'rename'", + "'as'", "'and'", "'or'", "'xor'", "'not'", "'between'", "'in'", + "'not_in'", "'null'", "'isnull'", "'ex'", "'union'", "'diff'", + "'symdiff'", "'intersect'", "'random'", "'keys'", "'intyear'", + "'intmonth'", "'intday'", "'check'", "'exists_in'", "'to'", + "'return'", "'imbalance'", "'errorcode'", "'all'", "'aggr'", + "'errorlevel'", "'order'", "'by'", "'rank'", "'asc'", "'desc'", + "'min'", "'max'", "'first'", "'last'", "'indexof'", "'abs'", + "'key'", "'ln'", "'log'", "'trunc'", "'round'", "'power'", "'mod'", + "'length'", "'||'", "'trim'", "'upper'", "'lower'", "'substr'", + "'sum'", "'avg'", "'median'", "'count'", "'identifier'", "'measure'", + "'attribute'", "'filter'", "'merge'", "'exp'", "'componentRole'", + "'viral'", "'match_characters'", "'type'", "'nvl'", "'hierarchy'", + "'_'", "'invalid'", "'valuedomain'", "'variable'", "'data'", + "'structure'", "'dataset'", "'operator'", "'define'", "'<-'", + "'datapoint'", "'hierarchical'", "'ruleset'", "'rule'", "'end'", + "'alterDataset'", "'ltrim'", "'rtrim'", "'instr'", "'replace'", + "'ceil'", "'floor'", "'sqrt'", "'any'", "'setdiff'", "'stddev_pop'", + "'stddev_samp'", "'var_pop'", "'var_samp'", "'group'", "'except'", + "'having'", "'first_value'", "'last_value'", "'lag'", "'lead'", + "'ratio_to_report'", "'over'", "'preceding'", "'following'", + "'unbounded'", "'partition'", "'rows'", "'range'", "'current'", + "'valid'", "'fill_time_series'", "'flow_to_stock'", "'stock_to_flow'", + "'timeshift'", "'measures'", "'no_measures'", "'condition'", + "'boolean'", "'date'", "'time_period'", "'number'", "'string'", + "'time'", "'integer'", "'float'", "'list'", "'record'", "'restrict'", + "'yyyy'", "'mm'", "'dd'", "'maxLength'", "'regexp'", "'is'", + "'when'", "'from'", "'aggregates'", "'points'", "'point'", "'total'", + "'partial'", "'always'", "'inner_join'", "'left_join'", "'cross_join'", + "'full_join'", "'maps_from'", "'maps_to'", "'map_to'", "'map_from'", + "'returns'", "'pivot'", "'customPivot'", "'unpivot'", "'sub'", + "'apply'", "'conditioned'", "'period_indicator'", "'single'", + "'duration'", "'time_agg'", "'unit'", "'Value'", "'valuedomains'", + "'variables'", "'input'", "'output'", "'cast'", "'rule_priority'", + "'dataset_priority'", "'default'", "'check_datapoint'", "'check_hierarchy'", + "'computed'", "'non_null'", "'non_zero'", "'partial_null'", + "'partial_zero'", "'always_null'", "'always_zero'", "'components'", + "'all_measures'", "'scalar'", "'component'", "'datapoint_on_valuedomains'", + "'datapoint_on_variables'", "'hierarchical_on_valuedomains'", + "'hierarchical_on_variables'", "'set'", "'language'", "';'" ] - symbolicNames = [ - "", - "LPAREN", - "RPAREN", - "QLPAREN", - "QRPAREN", - "GLPAREN", - "GRPAREN", - "EQ", - "LT", - "MT", - "ME", - "NEQ", - "LE", - "PLUS", - "MINUS", - "MUL", - "DIV", - "COMMA", - "POINTER", - "COLON", - "ASSIGN", - "MEMBERSHIP", - "EVAL", - "IF", - "CASE", - "THEN", - "ELSE", - "USING", - "WITH", - "CURRENT_DATE", - "DATEDIFF", - "DATEADD", - "YEAR_OP", - "MONTH_OP", - "DAYOFMONTH", - "DAYOFYEAR", - "DAYTOYEAR", - "DAYTOMONTH", - "YEARTODAY", - "MONTHTODAY", - "ON", - "DROP", - "KEEP", - "CALC", - "ATTRCALC", - "RENAME", - "AS", - "AND", - "OR", - "XOR", - "NOT", - "BETWEEN", - "IN", - "NOT_IN", - "NULL_CONSTANT", - "ISNULL", - "EX", - "UNION", - "DIFF", - "SYMDIFF", - "INTERSECT", - "RANDOM", - "KEYS", - "INTYEAR", - "INTMONTH", - "INTDAY", - "CHECK", - "EXISTS_IN", - "TO", - "RETURN", - "IMBALANCE", - "ERRORCODE", - "ALL", - "AGGREGATE", - "ERRORLEVEL", - "ORDER", - "BY", - "RANK", - "ASC", - "DESC", - "MIN", - "MAX", - "FIRST", - "LAST", - "INDEXOF", - "ABS", - "KEY", - "LN", - "LOG", - "TRUNC", - "ROUND", - "POWER", - "MOD", - "LEN", - "CONCAT", - "TRIM", - "UCASE", - "LCASE", - "SUBSTR", - "SUM", - "AVG", - "MEDIAN", - "COUNT", - "DIMENSION", - "MEASURE", - "ATTRIBUTE", - "FILTER", - "MERGE", - "EXP", - "ROLE", - "VIRAL", - "CHARSET_MATCH", - "TYPE", - "NVL", - "HIERARCHY", - "OPTIONAL", - "INVALID", - "VALUE_DOMAIN", - "VARIABLE", - "DATA", - "STRUCTURE", - "DATASET", - "OPERATOR", - "DEFINE", - "PUT_SYMBOL", - "DATAPOINT", - "HIERARCHICAL", - "RULESET", - "RULE", - "END", - "ALTER_DATASET", - "LTRIM", - "RTRIM", - "INSTR", - "REPLACE", - "CEIL", - "FLOOR", - "SQRT", - "ANY", - "SETDIFF", - "STDDEV_POP", - "STDDEV_SAMP", - "VAR_POP", - "VAR_SAMP", - "GROUP", - "EXCEPT", - "HAVING", - "FIRST_VALUE", - "LAST_VALUE", - "LAG", - "LEAD", - "RATIO_TO_REPORT", - "OVER", - "PRECEDING", - "FOLLOWING", - "UNBOUNDED", - "PARTITION", - "ROWS", - "RANGE", - "CURRENT", - "VALID", - "FILL_TIME_SERIES", - "FLOW_TO_STOCK", - "STOCK_TO_FLOW", - "TIMESHIFT", - "MEASURES", - "NO_MEASURES", - "CONDITION", - "BOOLEAN", - "DATE", - "TIME_PERIOD", - "NUMBER", - "STRING", - "TIME", - "INTEGER", - "FLOAT", - "LIST", - "RECORD", - "RESTRICT", - "YYYY", - "MM", - "DD", - "MAX_LENGTH", - "REGEXP", - "IS", - "WHEN", - "FROM", - "AGGREGATES", - "POINTS", - "POINT", - "TOTAL", - "PARTIAL", - "ALWAYS", - "INNER_JOIN", - "LEFT_JOIN", - "CROSS_JOIN", - "FULL_JOIN", - "MAPS_FROM", - "MAPS_TO", - "MAP_TO", - "MAP_FROM", - "RETURNS", - "PIVOT", - "CUSTOMPIVOT", - "UNPIVOT", - "SUBSPACE", - "APPLY", - "CONDITIONED", - "PERIOD_INDICATOR", - "SINGLE", - "DURATION", - "TIME_AGG", - "UNIT", - "VALUE", - "VALUEDOMAINS", - "VARIABLES", - "INPUT", - "OUTPUT", - "CAST", - "RULE_PRIORITY", - "DATASET_PRIORITY", - "DEFAULT", - "CHECK_DATAPOINT", - "CHECK_HIERARCHY", - "COMPUTED", - "NON_NULL", - "NON_ZERO", - "PARTIAL_NULL", - "PARTIAL_ZERO", - "ALWAYS_NULL", - "ALWAYS_ZERO", - "COMPONENTS", - "ALL_MEASURES", - "SCALAR", - "COMPONENT", - "DATAPOINT_ON_VD", - "DATAPOINT_ON_VAR", - "HIERARCHICAL_ON_VD", - "HIERARCHICAL_ON_VAR", - "SET", - "LANGUAGE", - "INTEGER_CONSTANT", - "NUMBER_CONSTANT", - "BOOLEAN_CONSTANT", - "STRING_CONSTANT", - "IDENTIFIER", - "WS", - "EOL", - "ML_COMMENT", - "SL_COMMENT", - ] + symbolicNames = [ "", + "LPAREN", "RPAREN", "QLPAREN", "QRPAREN", "GLPAREN", "GRPAREN", + "EQ", "LT", "MT", "ME", "NEQ", "LE", "PLUS", "MINUS", "MUL", + "DIV", "COMMA", "POINTER", "COLON", "ASSIGN", "MEMBERSHIP", + "EVAL", "IF", "CASE", "THEN", "ELSE", "USING", "WITH", "CURRENT_DATE", + "DATEDIFF", "DATEADD", "YEAR_OP", "MONTH_OP", "DAYOFMONTH", + "DAYOFYEAR", "DAYTOYEAR", "DAYTOMONTH", "YEARTODAY", "MONTHTODAY", + "ON", "DROP", "KEEP", "CALC", "ATTRCALC", "RENAME", "AS", "AND", + "OR", "XOR", "NOT", "BETWEEN", "IN", "NOT_IN", "NULL_CONSTANT", + "ISNULL", "EX", "UNION", "DIFF", "SYMDIFF", "INTERSECT", "RANDOM", + "KEYS", "INTYEAR", "INTMONTH", "INTDAY", "CHECK", "EXISTS_IN", + "TO", "RETURN", "IMBALANCE", "ERRORCODE", "ALL", "AGGREGATE", + "ERRORLEVEL", "ORDER", "BY", "RANK", "ASC", "DESC", "MIN", "MAX", + "FIRST", "LAST", "INDEXOF", "ABS", "KEY", "LN", "LOG", "TRUNC", + "ROUND", "POWER", "MOD", "LEN", "CONCAT", "TRIM", "UCASE", "LCASE", + "SUBSTR", "SUM", "AVG", "MEDIAN", "COUNT", "DIMENSION", "MEASURE", + "ATTRIBUTE", "FILTER", "MERGE", "EXP", "ROLE", "VIRAL", "CHARSET_MATCH", + "TYPE", "NVL", "HIERARCHY", "OPTIONAL", "INVALID", "VALUE_DOMAIN", + "VARIABLE", "DATA", "STRUCTURE", "DATASET", "OPERATOR", "DEFINE", + "PUT_SYMBOL", "DATAPOINT", "HIERARCHICAL", "RULESET", "RULE", + "END", "ALTER_DATASET", "LTRIM", "RTRIM", "INSTR", "REPLACE", + "CEIL", "FLOOR", "SQRT", "ANY", "SETDIFF", "STDDEV_POP", "STDDEV_SAMP", + "VAR_POP", "VAR_SAMP", "GROUP", "EXCEPT", "HAVING", "FIRST_VALUE", + "LAST_VALUE", "LAG", "LEAD", "RATIO_TO_REPORT", "OVER", "PRECEDING", + "FOLLOWING", "UNBOUNDED", "PARTITION", "ROWS", "RANGE", "CURRENT", + "VALID", "FILL_TIME_SERIES", "FLOW_TO_STOCK", "STOCK_TO_FLOW", + "TIMESHIFT", "MEASURES", "NO_MEASURES", "CONDITION", "BOOLEAN", + "DATE", "TIME_PERIOD", "NUMBER", "STRING", "TIME", "INTEGER", + "FLOAT", "LIST", "RECORD", "RESTRICT", "YYYY", "MM", "DD", "MAX_LENGTH", + "REGEXP", "IS", "WHEN", "FROM", "AGGREGATES", "POINTS", "POINT", + "TOTAL", "PARTIAL", "ALWAYS", "INNER_JOIN", "LEFT_JOIN", "CROSS_JOIN", + "FULL_JOIN", "MAPS_FROM", "MAPS_TO", "MAP_TO", "MAP_FROM", "RETURNS", + "PIVOT", "CUSTOMPIVOT", "UNPIVOT", "SUBSPACE", "APPLY", "CONDITIONED", + "PERIOD_INDICATOR", "SINGLE", "DURATION", "TIME_AGG", "UNIT", + "VALUE", "VALUEDOMAINS", "VARIABLES", "INPUT", "OUTPUT", "CAST", + "RULE_PRIORITY", "DATASET_PRIORITY", "DEFAULT", "CHECK_DATAPOINT", + "CHECK_HIERARCHY", "COMPUTED", "NON_NULL", "NON_ZERO", "PARTIAL_NULL", + "PARTIAL_ZERO", "ALWAYS_NULL", "ALWAYS_ZERO", "COMPONENTS", + "ALL_MEASURES", "SCALAR", "COMPONENT", "DATAPOINT_ON_VD", "DATAPOINT_ON_VAR", + "HIERARCHICAL_ON_VD", "HIERARCHICAL_ON_VAR", "SET", "LANGUAGE", + "INTEGER_CONSTANT", "NUMBER_CONSTANT", "BOOLEAN_CONSTANT", "STRING_CONSTANT", + "IDENTIFIER", "WS", "EOL", "ML_COMMENT", "SL_COMMENT" ] - ruleNames = [ - "LPAREN", - "RPAREN", - "QLPAREN", - "QRPAREN", - "GLPAREN", - "GRPAREN", - "EQ", - "LT", - "MT", - "ME", - "NEQ", - "LE", - "PLUS", - "MINUS", - "MUL", - "DIV", - "COMMA", - "POINTER", - "COLON", - "ASSIGN", - "MEMBERSHIP", - "EVAL", - "IF", - "CASE", - "THEN", - "ELSE", - "USING", - "WITH", - "CURRENT_DATE", - "DATEDIFF", - "DATEADD", - "YEAR_OP", - "MONTH_OP", - "DAYOFMONTH", - "DAYOFYEAR", - "DAYTOYEAR", - "DAYTOMONTH", - "YEARTODAY", - "MONTHTODAY", - "ON", - "DROP", - "KEEP", - "CALC", - "ATTRCALC", - "RENAME", - "AS", - "AND", - "OR", - "XOR", - "NOT", - "BETWEEN", - "IN", - "NOT_IN", - "NULL_CONSTANT", - "ISNULL", - "EX", - "UNION", - "DIFF", - "SYMDIFF", - "INTERSECT", - "RANDOM", - "KEYS", - "INTYEAR", - "INTMONTH", - "INTDAY", - "CHECK", - "EXISTS_IN", - "TO", - "RETURN", - "IMBALANCE", - "ERRORCODE", - "ALL", - "AGGREGATE", - "ERRORLEVEL", - "ORDER", - "BY", - "RANK", - "ASC", - "DESC", - "MIN", - "MAX", - "FIRST", - "LAST", - "INDEXOF", - "ABS", - "KEY", - "LN", - "LOG", - "TRUNC", - "ROUND", - "POWER", - "MOD", - "LEN", - "CONCAT", - "TRIM", - "UCASE", - "LCASE", - "SUBSTR", - "SUM", - "AVG", - "MEDIAN", - "COUNT", - "DIMENSION", - "MEASURE", - "ATTRIBUTE", - "FILTER", - "MERGE", - "EXP", - "ROLE", - "VIRAL", - "CHARSET_MATCH", - "TYPE", - "NVL", - "HIERARCHY", - "OPTIONAL", - "INVALID", - "VALUE_DOMAIN", - "VARIABLE", - "DATA", - "STRUCTURE", - "DATASET", - "OPERATOR", - "DEFINE", - "PUT_SYMBOL", - "DATAPOINT", - "HIERARCHICAL", - "RULESET", - "RULE", - "END", - "ALTER_DATASET", - "LTRIM", - "RTRIM", - "INSTR", - "REPLACE", - "CEIL", - "FLOOR", - "SQRT", - "ANY", - "SETDIFF", - "STDDEV_POP", - "STDDEV_SAMP", - "VAR_POP", - "VAR_SAMP", - "GROUP", - "EXCEPT", - "HAVING", - "FIRST_VALUE", - "LAST_VALUE", - "LAG", - "LEAD", - "RATIO_TO_REPORT", - "OVER", - "PRECEDING", - "FOLLOWING", - "UNBOUNDED", - "PARTITION", - "ROWS", - "RANGE", - "CURRENT", - "VALID", - "FILL_TIME_SERIES", - "FLOW_TO_STOCK", - "STOCK_TO_FLOW", - "TIMESHIFT", - "MEASURES", - "NO_MEASURES", - "CONDITION", - "BOOLEAN", - "DATE", - "TIME_PERIOD", - "NUMBER", - "STRING", - "TIME", - "INTEGER", - "FLOAT", - "LIST", - "RECORD", - "RESTRICT", - "YYYY", - "MM", - "DD", - "MAX_LENGTH", - "REGEXP", - "IS", - "WHEN", - "FROM", - "AGGREGATES", - "POINTS", - "POINT", - "TOTAL", - "PARTIAL", - "ALWAYS", - "INNER_JOIN", - "LEFT_JOIN", - "CROSS_JOIN", - "FULL_JOIN", - "MAPS_FROM", - "MAPS_TO", - "MAP_TO", - "MAP_FROM", - "RETURNS", - "PIVOT", - "CUSTOMPIVOT", - "UNPIVOT", - "SUBSPACE", - "APPLY", - "CONDITIONED", - "PERIOD_INDICATOR", - "SINGLE", - "DURATION", - "TIME_AGG", - "UNIT", - "VALUE", - "VALUEDOMAINS", - "VARIABLES", - "INPUT", - "OUTPUT", - "CAST", - "RULE_PRIORITY", - "DATASET_PRIORITY", - "DEFAULT", - "CHECK_DATAPOINT", - "CHECK_HIERARCHY", - "COMPUTED", - "NON_NULL", - "NON_ZERO", - "PARTIAL_NULL", - "PARTIAL_ZERO", - "ALWAYS_NULL", - "ALWAYS_ZERO", - "COMPONENTS", - "ALL_MEASURES", - "SCALAR", - "COMPONENT", - "DATAPOINT_ON_VD", - "DATAPOINT_ON_VAR", - "HIERARCHICAL_ON_VD", - "HIERARCHICAL_ON_VAR", - "SET", - "LANGUAGE", - "LETTER", - "DIGITS0_9", - "INTEGER_CONSTANT", - "NUMBER_CONSTANT", - "BOOLEAN_CONSTANT", - "STRING_CONSTANT", - "IDENTIFIER", - "WS", - "EOL", - "ML_COMMENT", - "SL_COMMENT", - ] + ruleNames = [ "LPAREN", "RPAREN", "QLPAREN", "QRPAREN", "GLPAREN", "GRPAREN", + "EQ", "LT", "MT", "ME", "NEQ", "LE", "PLUS", "MINUS", + "MUL", "DIV", "COMMA", "POINTER", "COLON", "ASSIGN", "MEMBERSHIP", + "EVAL", "IF", "CASE", "THEN", "ELSE", "USING", "WITH", + "CURRENT_DATE", "DATEDIFF", "DATEADD", "YEAR_OP", "MONTH_OP", + "DAYOFMONTH", "DAYOFYEAR", "DAYTOYEAR", "DAYTOMONTH", + "YEARTODAY", "MONTHTODAY", "ON", "DROP", "KEEP", "CALC", + "ATTRCALC", "RENAME", "AS", "AND", "OR", "XOR", "NOT", + "BETWEEN", "IN", "NOT_IN", "NULL_CONSTANT", "ISNULL", + "EX", "UNION", "DIFF", "SYMDIFF", "INTERSECT", "RANDOM", + "KEYS", "INTYEAR", "INTMONTH", "INTDAY", "CHECK", "EXISTS_IN", + "TO", "RETURN", "IMBALANCE", "ERRORCODE", "ALL", "AGGREGATE", + "ERRORLEVEL", "ORDER", "BY", "RANK", "ASC", "DESC", "MIN", + "MAX", "FIRST", "LAST", "INDEXOF", "ABS", "KEY", "LN", + "LOG", "TRUNC", "ROUND", "POWER", "MOD", "LEN", "CONCAT", + "TRIM", "UCASE", "LCASE", "SUBSTR", "SUM", "AVG", "MEDIAN", + "COUNT", "DIMENSION", "MEASURE", "ATTRIBUTE", "FILTER", + "MERGE", "EXP", "ROLE", "VIRAL", "CHARSET_MATCH", "TYPE", + "NVL", "HIERARCHY", "OPTIONAL", "INVALID", "VALUE_DOMAIN", + "VARIABLE", "DATA", "STRUCTURE", "DATASET", "OPERATOR", + "DEFINE", "PUT_SYMBOL", "DATAPOINT", "HIERARCHICAL", "RULESET", + "RULE", "END", "ALTER_DATASET", "LTRIM", "RTRIM", "INSTR", + "REPLACE", "CEIL", "FLOOR", "SQRT", "ANY", "SETDIFF", + "STDDEV_POP", "STDDEV_SAMP", "VAR_POP", "VAR_SAMP", "GROUP", + "EXCEPT", "HAVING", "FIRST_VALUE", "LAST_VALUE", "LAG", + "LEAD", "RATIO_TO_REPORT", "OVER", "PRECEDING", "FOLLOWING", + "UNBOUNDED", "PARTITION", "ROWS", "RANGE", "CURRENT", + "VALID", "FILL_TIME_SERIES", "FLOW_TO_STOCK", "STOCK_TO_FLOW", + "TIMESHIFT", "MEASURES", "NO_MEASURES", "CONDITION", "BOOLEAN", + "DATE", "TIME_PERIOD", "NUMBER", "STRING", "TIME", "INTEGER", + "FLOAT", "LIST", "RECORD", "RESTRICT", "YYYY", "MM", "DD", + "MAX_LENGTH", "REGEXP", "IS", "WHEN", "FROM", "AGGREGATES", + "POINTS", "POINT", "TOTAL", "PARTIAL", "ALWAYS", "INNER_JOIN", + "LEFT_JOIN", "CROSS_JOIN", "FULL_JOIN", "MAPS_FROM", "MAPS_TO", + "MAP_TO", "MAP_FROM", "RETURNS", "PIVOT", "CUSTOMPIVOT", + "UNPIVOT", "SUBSPACE", "APPLY", "CONDITIONED", "PERIOD_INDICATOR", + "SINGLE", "DURATION", "TIME_AGG", "UNIT", "VALUE", "VALUEDOMAINS", + "VARIABLES", "INPUT", "OUTPUT", "CAST", "RULE_PRIORITY", + "DATASET_PRIORITY", "DEFAULT", "CHECK_DATAPOINT", "CHECK_HIERARCHY", + "COMPUTED", "NON_NULL", "NON_ZERO", "PARTIAL_NULL", "PARTIAL_ZERO", + "ALWAYS_NULL", "ALWAYS_ZERO", "COMPONENTS", "ALL_MEASURES", + "SCALAR", "COMPONENT", "DATAPOINT_ON_VD", "DATAPOINT_ON_VAR", + "HIERARCHICAL_ON_VD", "HIERARCHICAL_ON_VAR", "SET", "LANGUAGE", + "LETTER", "DIGITS0_9", "INTEGER_CONSTANT", "NUMBER_CONSTANT", + "BOOLEAN_CONSTANT", "STRING_CONSTANT", "IDENTIFIER", "WS", + "EOL", "ML_COMMENT", "SL_COMMENT" ] grammarFileName = "Vtl.g4" - def __init__(self, input=None, output: TextIO = sys.stdout): + def __init__(self, input=None, output:TextIO = sys.stdout): super().__init__(input, output) - self._interp = LexerATNSimulator( - self, self.atn, self.decisionsToDFA, PredictionContextCache() - ) + self.checkVersion("4.9.3") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) self._actions = None self._predicates = None + + diff --git a/src/vtlengine/AST/Grammar/parser.py b/src/vtlengine/AST/Grammar/parser.py index 5522db123..b6225f7d6 100644 --- a/src/vtlengine/AST/Grammar/parser.py +++ b/src/vtlengine/AST/Grammar/parser.py @@ -1,25 +1,25 @@ -# Generated from Vtl.g4 by ANTLR 4.9.2 +# Generated from Vtl.g4 by ANTLR 4.9.3 # encoding: utf-8 from antlr4 import * from antlr4 import Parser as ANTLRParser from io import StringIO import sys -from typing import TextIO, Any - -from antlr4.atn.ATN import ATN -from antlr4.tree.Tree import ParseTreeListener +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO def serializedATN(): with StringIO() as buf: buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00fb") - buf.write("\u073e\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") + buf.write("\u0749\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") buf.write("\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") buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23") buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31") buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36") - buf.write('\4\37\t\37\4 \t \4!\t!\4"\t"\4#\t#\4$\t$\4%\t%\4&\t') - buf.write("&\4'\t'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4") + buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t") + buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4") buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64") buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t") buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t") @@ -123,520 +123,521 @@ def serializedATN(): buf.write("\3!\3!\3!\3!\3!\3!\5!\u0480\n!\3!\3!\5!\u0484\n!\3!\5") buf.write("!\u0487\n!\3!\5!\u048a\n!\3!\5!\u048d\n!\3!\3!\3!\3!\3") buf.write("!\3!\5!\u0495\n!\3!\5!\u0498\n!\3!\5!\u049b\n!\3!\5!\u049e") - buf.write('\n!\3!\3!\5!\u04a2\n!\3"\3"\3"\3"\3"\3"\3"\3#\3') + buf.write("\n!\3!\3!\5!\u04a2\n!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3") buf.write("#\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3$\5$\u04ba\n$\3") buf.write("%\3%\3%\3%\3%\5%\u04c1\n%\5%\u04c3\n%\3%\3%\3&\3&\3&\3") buf.write("&\3&\3&\5&\u04cd\n&\3&\5&\u04d0\n&\3&\5&\u04d3\n&\3&\3") buf.write("&\3&\3&\3&\3&\3&\3&\3&\3&\5&\u04df\n&\5&\u04e1\n&\3&\3") buf.write("&\3&\5&\u04e6\n&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3") - buf.write("&\3&\5&\u04f6\n&\3'\3'\3'\3'\3'\3'\5'\u04fe\n'") - buf.write("\3'\5'\u0501\n'\3'\5'\u0504\n'\3'\3'\3'\3'\3") - buf.write("'\3'\3'\3'\3'\5'\u050f\n'\5'\u0511\n'\3'\3'") - buf.write("\3'\5'\u0516\n'\3'\3'\3'\3'\3'\3'\3'\3'\3'") - buf.write("\3'\5'\u0522\n'\3'\3'\3'\3'\3'\3'\3'\3'\3'") - buf.write("\3'\3'\3'\3'\3'\5'\u0532\n'\3(\3(\3(\3(\3)\3)\3") + buf.write("&\3&\5&\u04f6\n&\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u04fe\n\'") + buf.write("\3\'\5\'\u0501\n\'\3\'\5\'\u0504\n\'\3\'\3\'\3\'\3\'\3") + buf.write("\'\3\'\3\'\3\'\3\'\5\'\u050f\n\'\5\'\u0511\n\'\3\'\3\'") + buf.write("\3\'\5\'\u0516\n\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'") + buf.write("\3\'\5\'\u0522\n\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'") + buf.write("\3\'\3\'\3\'\3\'\3\'\5\'\u0532\n\'\3(\3(\3(\3(\3)\3)\3") buf.write(")\7)\u053b\n)\f)\16)\u053e\13)\3*\5*\u0541\n*\3*\3*\3") buf.write("*\3*\3+\5+\u0548\n+\3+\3+\3+\3+\3,\3,\3,\3,\5,\u0552\n") - buf.write(",\3-\3-\3-\3-\3-\3-\3-\3-\5-\u055c\n-\3-\3-\5-\u0560\n") - buf.write("-\3.\3.\3.\7.\u0565\n.\f.\16.\u0568\13.\3/\3/\3/\7/\u056d") - buf.write("\n/\f/\16/\u0570\13/\3/\3/\3/\3/\7/\u0576\n/\f/\16/\u0579") - buf.write("\13/\5/\u057b\n/\3\60\3\60\3\60\5\60\u0580\n\60\3\61\5") - buf.write("\61\u0583\n\61\3\61\3\61\3\61\5\61\u0588\n\61\3\61\5\61") - buf.write("\u058b\n\61\3\61\5\61\u058e\n\61\3\62\3\62\3\62\3\63\3") - buf.write("\63\3\63\3\63\3\63\7\63\u0598\n\63\f\63\16\63\u059b\13") - buf.write("\63\3\64\3\64\3\64\3\64\3\64\7\64\u05a2\n\64\f\64\16\64") - buf.write("\u05a5\13\64\3\65\3\65\5\65\u05a9\n\65\3\66\3\66\3\66") - buf.write("\5\66\u05ae\n\66\3\66\3\66\3\66\3\66\3\66\3\67\3\67\3") - buf.write("8\38\38\38\38\38\38\38\38\38\38\58\u05c2\n8\39\39\39\3") - buf.write("9\39\79\u05c9\n9\f9\169\u05cc\139\39\39\39\59\u05d1\n") - buf.write("9\3:\3:\3:\3;\3;\3;\3;\5;\u05da\n;\3<\3<\3<\5<\u05df\n") - buf.write("<\3=\3=\5=\u05e3\n=\3>\3>\3>\3>\3>\5>\u05ea\n>\3?\3?\3") - buf.write("?\5?\u05ef\n?\3@\3@\5@\u05f3\n@\3@\5@\u05f6\n@\3@\5@\u05f9") - buf.write("\n@\3@\5@\u05fc\n@\3A\3A\3A\3A\3A\5A\u0603\nA\3B\3B\3") - buf.write("B\3B\3B\7B\u060a\nB\fB\16B\u060d\13B\3B\3B\5B\u0611\n") - buf.write("B\3C\3C\5C\u0615\nC\3D\3D\3D\3D\3D\5D\u061c\nD\3E\3E\3") - buf.write("E\3E\3E\3E\7E\u0624\nE\fE\16E\u0627\13E\3E\3E\5E\u062b") - buf.write("\nE\3E\3E\3E\3E\3E\7E\u0632\nE\fE\16E\u0635\13E\3E\3E") - buf.write("\5E\u0639\nE\5E\u063b\nE\3F\3F\3F\3F\3F\3F\3F\3F\7F\u0645") - buf.write("\nF\fF\16F\u0648\13F\3F\3F\5F\u064c\nF\3F\5F\u064f\nF") - buf.write("\3F\3F\3F\3F\3F\3F\3F\7F\u0658\nF\fF\16F\u065b\13F\3F") - buf.write("\3F\5F\u065f\nF\3F\3F\5F\u0663\nF\5F\u0665\nF\3G\3G\3") - buf.write("H\3H\3I\3I\3I\3I\7I\u066f\nI\fI\16I\u0672\13I\3J\3J\3") - buf.write("J\5J\u0677\nJ\3K\3K\3K\7K\u067c\nK\fK\16K\u067f\13K\3") - buf.write("L\3L\5L\u0683\nL\3L\3L\3L\3L\5L\u0689\nL\3L\3L\5L\u068d") - buf.write("\nL\3L\5L\u0690\nL\3M\3M\3M\7M\u0695\nM\fM\16M\u0698\13") - buf.write("M\3N\3N\5N\u069c\nN\3N\3N\5N\u06a0\nN\3N\5N\u06a3\nN\3") - buf.write("O\3O\3O\5O\u06a8\nO\3O\3O\3O\3P\3P\3P\7P\u06b0\nP\fP\16") - buf.write("P\u06b3\13P\3Q\3Q\3Q\3Q\5Q\u06b9\nQ\3Q\3Q\5Q\u06bd\nQ") - buf.write("\3Q\3Q\7Q\u06c1\nQ\fQ\16Q\u06c4\13Q\3R\5R\u06c7\nR\3R") - buf.write("\3R\3R\3R\3R\5R\u06ce\nR\3S\3S\3T\3T\3T\3T\3T\3T\3T\3") - buf.write("T\7T\u06da\nT\fT\16T\u06dd\13T\3T\3T\5T\u06e1\nT\3U\3") - buf.write("U\3U\5U\u06e6\nU\3V\3V\5V\u06ea\nV\3W\3W\3X\3X\3Y\3Y\3") - buf.write("Y\3Y\7Y\u06f4\nY\fY\16Y\u06f7\13Y\3Z\3Z\3[\3[\3[\3\\\3") - buf.write("\\\3]\3]\3^\3^\3_\3_\3`\3`\3a\3a\3a\5a\u070b\na\3b\3b") - buf.write("\3b\3b\7b\u0711\nb\fb\16b\u0714\13b\3b\3b\3c\3c\3c\3d") - buf.write("\3d\3d\3e\3e\3f\3f\5f\u0722\nf\3g\3g\5g\u0726\ng\3h\3") - buf.write("h\3h\3h\3h\5h\u072d\nh\3i\3i\3i\3j\3j\3k\3k\3l\3l\3m\3") - buf.write("m\3n\3n\3o\3o\3o\2\4\6\bp\2\4\6\b\n\f\16\20\22\24\26\30") - buf.write('\32\34\36 "$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`b') - buf.write("dfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c") - buf.write("\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e") - buf.write("\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0") - buf.write("\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2") - buf.write("\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4") - buf.write("\u00d6\u00d8\u00da\u00dc\2'\4\2\17\20\64\64\3\2\21\22") - buf.write("\4\2\17\20``\3\2\62\63\3\2\66\67\3\2+,\4\2\u00cc\u00cc") - buf.write("\u00ce\u00ce\3\2\u00c3\u00c4\3\2\u00c5\u00c6\5\2__ac\u0085") - buf.write("\u0086\6\2WWYYnn\u0089\u008b\3\2[\\\5\2??ZZ]^\4\2JJ\u00d3") - buf.write("\u00d3\3\2\u00a4\u00a5\4\2uu\u00f6\u00f6\3\2TU\4\2==\u008d") - buf.write("\u008d\4\2JJvv\5\2RSeh\u008e\u0091\6\2RSeh\u008e\u0091") - buf.write("\u0095\u0096\3\2\u0097\u0098\3\2PQ\4\2NN\u0093\u0093\3") - buf.write("\2wx\3\2\17\20\4\2\u00f3\u00f4\u00f7\u00f7\4\2\17\17\21") - buf.write("\21\5\2JJvv\u00ea\u00ea\3\2\u00e3\u00e8\4\2{{\u00de\u00de") - buf.write("\5\2{{\u0082\u0082\u00dd\u00dd\4\2JJ\u00e2\u00e2\3\2\t") - buf.write("\16\4\288\u00f3\u00f6\5\2\u00aa\u00b0\u00d4\u00d4\u00eb") - buf.write("\u00eb\4\2JJ\u00f5\u00f5\2\u07fa\2\u00e3\3\2\2\2\4\u00f1") - buf.write("\3\2\2\2\6\u0111\3\2\2\2\b\u0154\3\2\2\2\n\u0179\3\2\2") - buf.write("\2\f\u0187\3\2\2\2\16\u0190\3\2\2\2\20\u0192\3\2\2\2\22") - buf.write("\u019b\3\2\2\2\24\u01a3\3\2\2\2\26\u01a6\3\2\2\2\30\u01af") - buf.write("\3\2\2\2\32\u01b8\3\2\2\2\34\u01bd\3\2\2\2\36\u01ca\3") - buf.write('\2\2\2 \u01df\3\2\2\2"\u0213\3\2\2\2$\u024e\3\2\2\2&') - buf.write("\u0289\3\2\2\2(\u028d\3\2\2\2*\u0291\3\2\2\2,\u02c3\3") - buf.write("\2\2\2.\u02f5\3\2\2\2\60\u030c\3\2\2\2\62\u0323\3\2\2") - buf.write("\2\64\u0345\3\2\2\2\66\u035c\3\2\2\28\u03c4\3\2\2\2:\u042c") - buf.write("\3\2\2\2<\u044b\3\2\2\2>\u044d\3\2\2\2@\u04a1\3\2\2\2") - buf.write("B\u04a3\3\2\2\2D\u04aa\3\2\2\2F\u04b9\3\2\2\2H\u04bb\3") - buf.write("\2\2\2J\u04f5\3\2\2\2L\u0531\3\2\2\2N\u0533\3\2\2\2P\u0537") - buf.write("\3\2\2\2R\u0540\3\2\2\2T\u0547\3\2\2\2V\u054d\3\2\2\2") - buf.write("X\u055f\3\2\2\2Z\u0561\3\2\2\2\\\u0569\3\2\2\2^\u057c") - buf.write("\3\2\2\2`\u0582\3\2\2\2b\u058f\3\2\2\2d\u0592\3\2\2\2") - buf.write("f\u059c\3\2\2\2h\u05a6\3\2\2\2j\u05ad\3\2\2\2l\u05b4\3") - buf.write("\2\2\2n\u05c1\3\2\2\2p\u05d0\3\2\2\2r\u05d2\3\2\2\2t\u05d5") - buf.write("\3\2\2\2v\u05de\3\2\2\2x\u05e2\3\2\2\2z\u05e9\3\2\2\2") - buf.write("|\u05ee\3\2\2\2~\u05f2\3\2\2\2\u0080\u05fd\3\2\2\2\u0082") - buf.write("\u0604\3\2\2\2\u0084\u0614\3\2\2\2\u0086\u0616\3\2\2\2") - buf.write("\u0088\u063a\3\2\2\2\u008a\u0664\3\2\2\2\u008c\u0666\3") - buf.write("\2\2\2\u008e\u0668\3\2\2\2\u0090\u066a\3\2\2\2\u0092\u0673") - buf.write("\3\2\2\2\u0094\u0678\3\2\2\2\u0096\u0682\3\2\2\2\u0098") - buf.write("\u0691\3\2\2\2\u009a\u069b\3\2\2\2\u009c\u06a4\3\2\2\2") - buf.write("\u009e\u06ac\3\2\2\2\u00a0\u06b8\3\2\2\2\u00a2\u06c6\3") - buf.write("\2\2\2\u00a4\u06cf\3\2\2\2\u00a6\u06e0\3\2\2\2\u00a8\u06e2") - buf.write("\3\2\2\2\u00aa\u06e7\3\2\2\2\u00ac\u06eb\3\2\2\2\u00ae") - buf.write("\u06ed\3\2\2\2\u00b0\u06ef\3\2\2\2\u00b2\u06f8\3\2\2\2") - buf.write("\u00b4\u06fa\3\2\2\2\u00b6\u06fd\3\2\2\2\u00b8\u06ff\3") - buf.write("\2\2\2\u00ba\u0701\3\2\2\2\u00bc\u0703\3\2\2\2\u00be\u0705") - buf.write("\3\2\2\2\u00c0\u0707\3\2\2\2\u00c2\u070c\3\2\2\2\u00c4") - buf.write("\u0717\3\2\2\2\u00c6\u071a\3\2\2\2\u00c8\u071d\3\2\2\2") - buf.write("\u00ca\u0721\3\2\2\2\u00cc\u0725\3\2\2\2\u00ce\u072c\3") - buf.write("\2\2\2\u00d0\u072e\3\2\2\2\u00d2\u0731\3\2\2\2\u00d4\u0733") - buf.write("\3\2\2\2\u00d6\u0735\3\2\2\2\u00d8\u0737\3\2\2\2\u00da") - buf.write("\u0739\3\2\2\2\u00dc\u073b\3\2\2\2\u00de\u00df\5\4\3\2") - buf.write("\u00df\u00e0\7\u00f9\2\2\u00e0\u00e2\3\2\2\2\u00e1\u00de") - buf.write("\3\2\2\2\u00e2\u00e5\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e3") - buf.write("\u00e4\3\2\2\2\u00e4\u00e6\3\2\2\2\u00e5\u00e3\3\2\2\2") - buf.write("\u00e6\u00e7\7\2\2\3\u00e7\3\3\2\2\2\u00e8\u00e9\5\u00bc") - buf.write("_\2\u00e9\u00ea\7\26\2\2\u00ea\u00eb\5\6\4\2\u00eb\u00f2") - buf.write("\3\2\2\2\u00ec\u00ed\5\u00bc_\2\u00ed\u00ee\7~\2\2\u00ee") - buf.write('\u00ef\5\6\4\2\u00ef\u00f2\3\2\2\2\u00f0\u00f2\5"\22') - buf.write("\2\u00f1\u00e8\3\2\2\2\u00f1\u00ec\3\2\2\2\u00f1\u00f0") - buf.write("\3\2\2\2\u00f2\5\3\2\2\2\u00f3\u00f4\b\4\1\2\u00f4\u00f5") - buf.write("\7\3\2\2\u00f5\u00f6\5\6\4\2\u00f6\u00f7\7\4\2\2\u00f7") - buf.write("\u0112\3\2\2\2\u00f8\u0112\5\f\7\2\u00f9\u00fa\t\2\2\2") - buf.write("\u00fa\u0112\5\6\4\r\u00fb\u00fc\7\31\2\2\u00fc\u00fd") - buf.write("\5\6\4\2\u00fd\u00fe\7\33\2\2\u00fe\u00ff\5\6\4\2\u00ff") - buf.write("\u0100\7\34\2\2\u0100\u0101\5\6\4\6\u0101\u0112\3\2\2") - buf.write("\2\u0102\u0108\7\32\2\2\u0103\u0104\7\u00bb\2\2\u0104") - buf.write("\u0105\5\6\4\2\u0105\u0106\7\33\2\2\u0106\u0107\5\6\4") - buf.write("\2\u0107\u0109\3\2\2\2\u0108\u0103\3\2\2\2\u0109\u010a") - buf.write("\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b") - buf.write("\u010c\3\2\2\2\u010c\u010d\7\34\2\2\u010d\u010e\5\6\4") - buf.write("\5\u010e\u0112\3\2\2\2\u010f\u0112\5\u00d8m\2\u0110\u0112") - buf.write("\5\u00bc_\2\u0111\u00f3\3\2\2\2\u0111\u00f8\3\2\2\2\u0111") - buf.write("\u00f9\3\2\2\2\u0111\u00fb\3\2\2\2\u0111\u0102\3\2\2\2") - buf.write("\u0111\u010f\3\2\2\2\u0111\u0110\3\2\2\2\u0112\u0133\3") - buf.write("\2\2\2\u0113\u0114\f\f\2\2\u0114\u0115\t\3\2\2\u0115\u0132") - buf.write("\5\6\4\r\u0116\u0117\f\13\2\2\u0117\u0118\t\4\2\2\u0118") - buf.write("\u0132\5\6\4\f\u0119\u011a\f\n\2\2\u011a\u011b\5\u00c8") - buf.write("e\2\u011b\u011c\5\6\4\13\u011c\u0132\3\2\2\2\u011d\u011e") - buf.write("\f\b\2\2\u011e\u011f\7\61\2\2\u011f\u0132\5\6\4\t\u0120") - buf.write("\u0121\f\7\2\2\u0121\u0122\t\5\2\2\u0122\u0132\5\6\4\b") - buf.write("\u0123\u0124\f\17\2\2\u0124\u0125\7\5\2\2\u0125\u0126") - buf.write("\5\16\b\2\u0126\u0127\7\6\2\2\u0127\u0132\3\2\2\2\u0128") - buf.write("\u0129\f\16\2\2\u0129\u012a\7\27\2\2\u012a\u0132\5\u00be") - buf.write("`\2\u012b\u012c\f\t\2\2\u012c\u012f\t\6\2\2\u012d\u0130") - buf.write("\5\u00c2b\2\u012e\u0130\5\u00d2j\2\u012f\u012d\3\2\2\2") - buf.write("\u012f\u012e\3\2\2\2\u0130\u0132\3\2\2\2\u0131\u0113\3") - buf.write("\2\2\2\u0131\u0116\3\2\2\2\u0131\u0119\3\2\2\2\u0131\u011d") - buf.write("\3\2\2\2\u0131\u0120\3\2\2\2\u0131\u0123\3\2\2\2\u0131") - buf.write("\u0128\3\2\2\2\u0131\u012b\3\2\2\2\u0132\u0135\3\2\2\2") - buf.write("\u0133\u0131\3\2\2\2\u0133\u0134\3\2\2\2\u0134\7\3\2\2") - buf.write("\2\u0135\u0133\3\2\2\2\u0136\u0137\b\5\1\2\u0137\u0138") - buf.write("\7\3\2\2\u0138\u0139\5\b\5\2\u0139\u013a\7\4\2\2\u013a") - buf.write("\u0155\3\2\2\2\u013b\u0155\5\n\6\2\u013c\u013d\t\2\2\2") - buf.write("\u013d\u0155\5\b\5\r\u013e\u013f\7\31\2\2\u013f\u0140") - buf.write("\5\b\5\2\u0140\u0141\7\33\2\2\u0141\u0142\5\b\5\2\u0142") - buf.write("\u0143\7\34\2\2\u0143\u0144\5\b\5\6\u0144\u0155\3\2\2") - buf.write("\2\u0145\u014b\7\32\2\2\u0146\u0147\7\u00bb\2\2\u0147") - buf.write("\u0148\5\b\5\2\u0148\u0149\7\33\2\2\u0149\u014a\5\b\5") - buf.write("\2\u014a\u014c\3\2\2\2\u014b\u0146\3\2\2\2\u014c\u014d") - buf.write("\3\2\2\2\u014d\u014b\3\2\2\2\u014d\u014e\3\2\2\2\u014e") - buf.write("\u014f\3\2\2\2\u014f\u0150\7\34\2\2\u0150\u0151\5\b\5") - buf.write("\5\u0151\u0155\3\2\2\2\u0152\u0155\5\u00d8m\2\u0153\u0155") - buf.write("\5\u00c0a\2\u0154\u0136\3\2\2\2\u0154\u013b\3\2\2\2\u0154") - buf.write("\u013c\3\2\2\2\u0154\u013e\3\2\2\2\u0154\u0145\3\2\2\2") - buf.write("\u0154\u0152\3\2\2\2\u0154\u0153\3\2\2\2\u0155\u016e\3") - buf.write("\2\2\2\u0156\u0157\f\f\2\2\u0157\u0158\t\3\2\2\u0158\u016d") - buf.write("\5\b\5\r\u0159\u015a\f\13\2\2\u015a\u015b\t\4\2\2\u015b") - buf.write("\u016d\5\b\5\f\u015c\u015d\f\n\2\2\u015d\u015e\5\u00c8") - buf.write("e\2\u015e\u015f\5\b\5\13\u015f\u016d\3\2\2\2\u0160\u0161") - buf.write("\f\b\2\2\u0161\u0162\7\61\2\2\u0162\u016d\5\b\5\t\u0163") - buf.write("\u0164\f\7\2\2\u0164\u0165\t\5\2\2\u0165\u016d\5\b\5\b") - buf.write("\u0166\u0167\f\t\2\2\u0167\u016a\t\6\2\2\u0168\u016b\5") - buf.write("\u00c2b\2\u0169\u016b\5\u00d2j\2\u016a\u0168\3\2\2\2\u016a") - buf.write("\u0169\3\2\2\2\u016b\u016d\3\2\2\2\u016c\u0156\3\2\2\2") - buf.write("\u016c\u0159\3\2\2\2\u016c\u015c\3\2\2\2\u016c\u0160\3") - buf.write("\2\2\2\u016c\u0163\3\2\2\2\u016c\u0166\3\2\2\2\u016d\u0170") - buf.write("\3\2\2\2\u016e\u016c\3\2\2\2\u016e\u016f\3\2\2\2\u016f") - buf.write("\t\3\2\2\2\u0170\u016e\3\2\2\2\u0171\u017a\5&\24\2\u0172") - buf.write("\u017a\5.\30\2\u0173\u017a\5\62\32\2\u0174\u017a\5\66") - buf.write("\34\2\u0175\u017a\5:\36\2\u0176\u017a\5D#\2\u0177\u017a") - buf.write("\5F$\2\u0178\u017a\5L'\2\u0179\u0171\3\2\2\2\u0179\u0172") - buf.write("\3\2\2\2\u0179\u0173\3\2\2\2\u0179\u0174\3\2\2\2\u0179") - buf.write("\u0175\3\2\2\2\u0179\u0176\3\2\2\2\u0179\u0177\3\2\2\2") - buf.write("\u0179\u0178\3\2\2\2\u017a\13\3\2\2\2\u017b\u0188\5 \21") - buf.write("\2\u017c\u0188\5$\23\2\u017d\u0188\5,\27\2\u017e\u0188") - buf.write("\5\60\31\2\u017f\u0188\5\64\33\2\u0180\u0188\58\35\2\u0181") - buf.write("\u0188\5<\37\2\u0182\u0188\5> \2\u0183\u0188\5@!\2\u0184") - buf.write('\u0188\5B"\2\u0185\u0188\5H%\2\u0186\u0188\5J&\2\u0187') - buf.write("\u017b\3\2\2\2\u0187\u017c\3\2\2\2\u0187\u017d\3\2\2\2") - buf.write("\u0187\u017e\3\2\2\2\u0187\u017f\3\2\2\2\u0187\u0180\3") - buf.write("\2\2\2\u0187\u0181\3\2\2\2\u0187\u0182\3\2\2\2\u0187\u0183") - buf.write("\3\2\2\2\u0187\u0184\3\2\2\2\u0187\u0185\3\2\2\2\u0187") - buf.write("\u0186\3\2\2\2\u0188\r\3\2\2\2\u0189\u0191\5\20\t\2\u018a") - buf.write("\u0191\5\22\n\2\u018b\u0191\5\24\13\2\u018c\u0191\5\26") - buf.write("\f\2\u018d\u0191\5\30\r\2\u018e\u0191\5\32\16\2\u018f") - buf.write("\u0191\5\36\20\2\u0190\u0189\3\2\2\2\u0190\u018a\3\2\2") - buf.write("\2\u0190\u018b\3\2\2\2\u0190\u018c\3\2\2\2\u0190\u018d") - buf.write("\3\2\2\2\u0190\u018e\3\2\2\2\u0190\u018f\3\2\2\2\u0191") - buf.write("\17\3\2\2\2\u0192\u0193\7/\2\2\u0193\u0198\5N(\2\u0194") - buf.write("\u0195\7\23\2\2\u0195\u0197\5N(\2\u0196\u0194\3\2\2\2") - buf.write("\u0197\u019a\3\2\2\2\u0198\u0196\3\2\2\2\u0198\u0199\3") - buf.write("\2\2\2\u0199\21\3\2\2\2\u019a\u0198\3\2\2\2\u019b\u019c") - buf.write("\7K\2\2\u019c\u01a1\5P)\2\u019d\u019f\5p9\2\u019e\u01a0") - buf.write("\5r:\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a2") - buf.write("\3\2\2\2\u01a1\u019d\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2") - buf.write("\23\3\2\2\2\u01a3\u01a4\7l\2\2\u01a4\u01a5\5\b\5\2\u01a5") - buf.write("\25\3\2\2\2\u01a6\u01a7\7-\2\2\u01a7\u01ac\5T+\2\u01a8") - buf.write("\u01a9\7\23\2\2\u01a9\u01ab\5T+\2\u01aa\u01a8\3\2\2\2") - buf.write("\u01ab\u01ae\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ac\u01ad\3") - buf.write("\2\2\2\u01ad\27\3\2\2\2\u01ae\u01ac\3\2\2\2\u01af\u01b0") - buf.write("\t\7\2\2\u01b0\u01b5\5\u00c0a\2\u01b1\u01b2\7\23\2\2\u01b2") - buf.write("\u01b4\5\u00c0a\2\u01b3\u01b1\3\2\2\2\u01b4\u01b7\3\2") - buf.write("\2\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\31") - buf.write("\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b8\u01b9\t\b\2\2\u01b9") - buf.write("\u01ba\5\u00c0a\2\u01ba\u01bb\7\23\2\2\u01bb\u01bc\5\u00c0") - buf.write("a\2\u01bc\33\3\2\2\2\u01bd\u01be\7\u00cd\2\2\u01be\u01bf") - buf.write("\5\u00c0a\2\u01bf\u01c0\7\23\2\2\u01c0\u01c1\5\u00c0a") - buf.write("\2\u01c1\u01c2\7\66\2\2\u01c2\u01c7\5\u00d8m\2\u01c3\u01c4") - buf.write("\7\23\2\2\u01c4\u01c6\5\u00d8m\2\u01c5\u01c3\3\2\2\2\u01c6") - buf.write("\u01c9\3\2\2\2\u01c7\u01c5\3\2\2\2\u01c7\u01c8\3\2\2\2") - buf.write("\u01c8\35\3\2\2\2\u01c9\u01c7\3\2\2\2\u01ca\u01cb\7\u00cf") - buf.write("\2\2\u01cb\u01d0\5V,\2\u01cc\u01cd\7\23\2\2\u01cd\u01cf") - buf.write("\5V,\2\u01ce\u01cc\3\2\2\2\u01cf\u01d2\3\2\2\2\u01d0\u01ce") - buf.write("\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1\37\3\2\2\2\u01d2\u01d0") - buf.write("\3\2\2\2\u01d3\u01d4\t\t\2\2\u01d4\u01d5\7\3\2\2\u01d5") - buf.write("\u01d6\5\\/\2\u01d6\u01d7\5`\61\2\u01d7\u01d8\7\4\2\2") - buf.write("\u01d8\u01e0\3\2\2\2\u01d9\u01da\t\n\2\2\u01da\u01db\7") - buf.write("\3\2\2\u01db\u01dc\5Z.\2\u01dc\u01dd\5`\61\2\u01dd\u01de") - buf.write("\7\4\2\2\u01de\u01e0\3\2\2\2\u01df\u01d3\3\2\2\2\u01df") - buf.write("\u01d9\3\2\2\2\u01e0!\3\2\2\2\u01e1\u01e2\7}\2\2\u01e2") - buf.write("\u01e3\7|\2\2\u01e3\u01e4\5\u00d4k\2\u01e4\u01ed\7\3\2") - buf.write("\2\u01e5\u01ea\5t;\2\u01e6\u01e7\7\23\2\2\u01e7\u01e9") - buf.write("\5t;\2\u01e8\u01e6\3\2\2\2\u01e9\u01ec\3\2\2\2\u01ea\u01e8") - buf.write("\3\2\2\2\u01ea\u01eb\3\2\2\2\u01eb\u01ee\3\2\2\2\u01ec") - buf.write("\u01ea\3\2\2\2\u01ed\u01e5\3\2\2\2\u01ed\u01ee\3\2\2\2") - buf.write("\u01ee\u01ef\3\2\2\2\u01ef\u01f2\7\4\2\2\u01f0\u01f1\7") - buf.write("\u00cb\2\2\u01f1\u01f3\5v<\2\u01f2\u01f0\3\2\2\2\u01f2") - buf.write("\u01f3\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f5\7\u00ba") - buf.write("\2\2\u01f5\u01f6\5\6\4\2\u01f6\u01f7\7\u0083\2\2\u01f7") - buf.write("\u01f8\7|\2\2\u01f8\u0214\3\2\2\2\u01f9\u01fa\7}\2\2\u01fa") - buf.write("\u01fb\7\177\2\2\u01fb\u01fc\7\u0081\2\2\u01fc\u01fd\5") - buf.write("\u008eH\2\u01fd\u01fe\7\3\2\2\u01fe\u01ff\5\u0090I\2\u01ff") - buf.write("\u0200\7\4\2\2\u0200\u0201\7\u00ba\2\2\u0201\u0202\5\u0094") - buf.write("K\2\u0202\u0203\7\u0083\2\2\u0203\u0204\7\177\2\2\u0204") - buf.write("\u0205\7\u0081\2\2\u0205\u0214\3\2\2\2\u0206\u0207\7}") - buf.write("\2\2\u0207\u0208\7\u0080\2\2\u0208\u0209\7\u0081\2\2\u0209") - buf.write("\u020a\5\u008eH\2\u020a\u020b\7\3\2\2\u020b\u020c\5\u009c") - buf.write("O\2\u020c\u020d\7\4\2\2\u020d\u020e\7\u00ba\2\2\u020e") - buf.write("\u020f\5\u0098M\2\u020f\u0210\7\u0083\2\2\u0210\u0211") - buf.write("\7\u0080\2\2\u0211\u0212\7\u0081\2\2\u0212\u0214\3\2\2") - buf.write("\2\u0213\u01e1\3\2\2\2\u0213\u01f9\3\2\2\2\u0213\u0206") - buf.write("\3\2\2\2\u0214#\3\2\2\2\u0215\u0216\5\u00d4k\2\u0216\u021f") - buf.write("\7\3\2\2\u0217\u021c\5*\26\2\u0218\u0219\7\23\2\2\u0219") - buf.write("\u021b\5*\26\2\u021a\u0218\3\2\2\2\u021b\u021e\3\2\2\2") - buf.write("\u021c\u021a\3\2\2\2\u021c\u021d\3\2\2\2\u021d\u0220\3") - buf.write("\2\2\2\u021e\u021c\3\2\2\2\u021f\u0217\3\2\2\2\u021f\u0220") - buf.write("\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0222\7\4\2\2\u0222") - buf.write("\u024f\3\2\2\2\u0223\u0224\7\30\2\2\u0224\u0225\7\3\2") - buf.write("\2\u0225\u0226\5\u00d6l\2\u0226\u0229\7\3\2\2\u0227\u022a") - buf.write("\5\u00bc_\2\u0228\u022a\5X-\2\u0229\u0227\3\2\2\2\u0229") - buf.write("\u0228\3\2\2\2\u0229\u022a\3\2\2\2\u022a\u0232\3\2\2\2") - buf.write("\u022b\u022e\7\23\2\2\u022c\u022f\5\u00bc_\2\u022d\u022f") - buf.write("\5X-\2\u022e\u022c\3\2\2\2\u022e\u022d\3\2\2\2\u022f\u0231") - buf.write("\3\2\2\2\u0230\u022b\3\2\2\2\u0231\u0234\3\2\2\2\u0232") - buf.write("\u0230\3\2\2\2\u0232\u0233\3\2\2\2\u0233\u0235\3\2\2\2") - buf.write("\u0234\u0232\3\2\2\2\u0235\u0238\7\4\2\2\u0236\u0237\7") - buf.write("\u00f2\2\2\u0237\u0239\7\u00f6\2\2\u0238\u0236\3\2\2\2") - buf.write("\u0238\u0239\3\2\2\2\u0239\u023c\3\2\2\2\u023a\u023b\7") - buf.write("\u00cb\2\2\u023b\u023d\5\u0084C\2\u023c\u023a\3\2\2\2") - buf.write("\u023c\u023d\3\2\2\2\u023d\u023e\3\2\2\2\u023e\u023f\7") - buf.write("\4\2\2\u023f\u024f\3\2\2\2\u0240\u0241\7\u00dc\2\2\u0241") - buf.write("\u0242\7\3\2\2\u0242\u0243\5\6\4\2\u0243\u0246\7\23\2") - buf.write("\2\u0244\u0247\5\u00dan\2\u0245\u0247\5\u008cG\2\u0246") - buf.write("\u0244\3\2\2\2\u0246\u0245\3\2\2\2\u0247\u024a\3\2\2\2") - buf.write("\u0248\u0249\7\23\2\2\u0249\u024b\7\u00f6\2\2\u024a\u0248") - buf.write("\3\2\2\2\u024a\u024b\3\2\2\2\u024b\u024c\3\2\2\2\u024c") - buf.write("\u024d\7\4\2\2\u024d\u024f\3\2\2\2\u024e\u0215\3\2\2\2") - buf.write("\u024e\u0223\3\2\2\2\u024e\u0240\3\2\2\2\u024f%\3\2\2") - buf.write("\2\u0250\u0251\5\u00d4k\2\u0251\u025a\7\3\2\2\u0252\u0257") - buf.write("\5(\25\2\u0253\u0254\7\23\2\2\u0254\u0256\5(\25\2\u0255") - buf.write("\u0253\3\2\2\2\u0256\u0259\3\2\2\2\u0257\u0255\3\2\2\2") - buf.write("\u0257\u0258\3\2\2\2\u0258\u025b\3\2\2\2\u0259\u0257\3") - buf.write("\2\2\2\u025a\u0252\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025c") - buf.write("\3\2\2\2\u025c\u025d\7\4\2\2\u025d\u028a\3\2\2\2\u025e") - buf.write("\u025f\7\u00dc\2\2\u025f\u0260\7\3\2\2\u0260\u0261\5\b") - buf.write("\5\2\u0261\u0264\7\23\2\2\u0262\u0265\5\u00dan\2\u0263") - buf.write("\u0265\5\u008cG\2\u0264\u0262\3\2\2\2\u0264\u0263\3\2") - buf.write("\2\2\u0265\u0268\3\2\2\2\u0266\u0267\7\23\2\2\u0267\u0269") - buf.write("\7\u00f6\2\2\u0268\u0266\3\2\2\2\u0268\u0269\3\2\2\2\u0269") - buf.write("\u026a\3\2\2\2\u026a\u026b\7\4\2\2\u026b\u028a\3\2\2\2") - buf.write("\u026c\u026d\7\30\2\2\u026d\u026e\7\3\2\2\u026e\u026f") - buf.write("\5\u00d6l\2\u026f\u0272\7\3\2\2\u0270\u0273\5\u00c0a\2") - buf.write("\u0271\u0273\5X-\2\u0272\u0270\3\2\2\2\u0272\u0271\3\2") - buf.write("\2\2\u0272\u0273\3\2\2\2\u0273\u027b\3\2\2\2\u0274\u0277") - buf.write("\7\23\2\2\u0275\u0278\5\u00c0a\2\u0276\u0278\5X-\2\u0277") - buf.write("\u0275\3\2\2\2\u0277\u0276\3\2\2\2\u0278\u027a\3\2\2\2") - buf.write("\u0279\u0274\3\2\2\2\u027a\u027d\3\2\2\2\u027b\u0279\3") - buf.write("\2\2\2\u027b\u027c\3\2\2\2\u027c\u027e\3\2\2\2\u027d\u027b") - buf.write("\3\2\2\2\u027e\u0281\7\4\2\2\u027f\u0280\7\u00f2\2\2\u0280") - buf.write("\u0282\7\u00f6\2\2\u0281\u027f\3\2\2\2\u0281\u0282\3\2") - buf.write("\2\2\u0282\u0285\3\2\2\2\u0283\u0284\7\u00cb\2\2\u0284") - buf.write("\u0286\5x=\2\u0285\u0283\3\2\2\2\u0285\u0286\3\2\2\2\u0286") - buf.write("\u0287\3\2\2\2\u0287\u0288\7\4\2\2\u0288\u028a\3\2\2\2") - buf.write("\u0289\u0250\3\2\2\2\u0289\u025e\3\2\2\2\u0289\u026c\3") - buf.write("\2\2\2\u028a'\3\2\2\2\u028b\u028e\5\b\5\2\u028c\u028e") - buf.write("\7u\2\2\u028d\u028b\3\2\2\2\u028d\u028c\3\2\2\2\u028e") - buf.write(")\3\2\2\2\u028f\u0292\5\6\4\2\u0290\u0292\7u\2\2\u0291") - buf.write("\u028f\3\2\2\2\u0291\u0290\3\2\2\2\u0292+\3\2\2\2\u0293") - buf.write("\u0294\t\13\2\2\u0294\u0295\7\3\2\2\u0295\u0296\5\6\4") - buf.write("\2\u0296\u0297\7\4\2\2\u0297\u02c4\3\2\2\2\u0298\u0299") - buf.write("\7d\2\2\u0299\u029a\7\3\2\2\u029a\u02a5\5\6\4\2\u029b") - buf.write("\u029c\7\23\2\2\u029c\u029d\5\u00caf\2\u029d\u029e\3\2") - buf.write("\2\2\u029e\u029f\7\23\2\2\u029f\u02a0\5\u00caf\2\u02a0") - buf.write("\u02a2\3\2\2\2\u02a1\u029b\3\2\2\2\u02a1\u02a2\3\2\2\2") - buf.write("\u02a2\u02a6\3\2\2\2\u02a3\u02a4\7\23\2\2\u02a4\u02a6") - buf.write("\5\u00caf\2\u02a5\u02a1\3\2\2\2\u02a5\u02a3\3\2\2\2\u02a6") - buf.write("\u02a7\3\2\2\2\u02a7\u02a8\7\4\2\2\u02a8\u02c4\3\2\2\2") - buf.write("\u02a9\u02aa\7\u0088\2\2\u02aa\u02ab\7\3\2\2\u02ab\u02ac") - buf.write("\5\6\4\2\u02ac\u02ad\7\23\2\2\u02ad\u02b0\5\6\4\2\u02ae") - buf.write("\u02af\7\23\2\2\u02af\u02b1\5\u00caf\2\u02b0\u02ae\3\2") - buf.write("\2\2\u02b0\u02b1\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b2\u02b3") - buf.write("\7\4\2\2\u02b3\u02c4\3\2\2\2\u02b4\u02b5\7\u0087\2\2\u02b5") - buf.write("\u02b6\7\3\2\2\u02b6\u02b7\5\6\4\2\u02b7\u02b8\7\23\2") - buf.write("\2\u02b8\u02bb\5\6\4\2\u02b9\u02ba\7\23\2\2\u02ba\u02bc") - buf.write("\5\u00caf\2\u02bb\u02b9\3\2\2\2\u02bb\u02bc\3\2\2\2\u02bc") - buf.write("\u02bf\3\2\2\2\u02bd\u02be\7\23\2\2\u02be\u02c0\5\u00ca") - buf.write("f\2\u02bf\u02bd\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0\u02c1") - buf.write("\3\2\2\2\u02c1\u02c2\7\4\2\2\u02c2\u02c4\3\2\2\2\u02c3") - buf.write("\u0293\3\2\2\2\u02c3\u0298\3\2\2\2\u02c3\u02a9\3\2\2\2") - buf.write("\u02c3\u02b4\3\2\2\2\u02c4-\3\2\2\2\u02c5\u02c6\t\13\2") - buf.write("\2\u02c6\u02c7\7\3\2\2\u02c7\u02c8\5\b\5\2\u02c8\u02c9") - buf.write("\7\4\2\2\u02c9\u02f6\3\2\2\2\u02ca\u02cb\7d\2\2\u02cb") - buf.write("\u02cc\7\3\2\2\u02cc\u02d7\5\b\5\2\u02cd\u02ce\7\23\2") - buf.write("\2\u02ce\u02cf\5\u00ccg\2\u02cf\u02d0\3\2\2\2\u02d0\u02d1") - buf.write("\7\23\2\2\u02d1\u02d2\5\u00ccg\2\u02d2\u02d4\3\2\2\2\u02d3") - buf.write("\u02cd\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4\u02d8\3\2\2\2") - buf.write("\u02d5\u02d6\7\23\2\2\u02d6\u02d8\5\u00ccg\2\u02d7\u02d3") - buf.write("\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d8\u02d9\3\2\2\2\u02d9") - buf.write("\u02da\7\4\2\2\u02da\u02f6\3\2\2\2\u02db\u02dc\7\u0088") - buf.write("\2\2\u02dc\u02dd\7\3\2\2\u02dd\u02de\5\b\5\2\u02de\u02df") - buf.write("\7\23\2\2\u02df\u02e2\5\b\5\2\u02e0\u02e1\7\23\2\2\u02e1") - buf.write("\u02e3\5\u00ccg\2\u02e2\u02e0\3\2\2\2\u02e2\u02e3\3\2") - buf.write("\2\2\u02e3\u02e4\3\2\2\2\u02e4\u02e5\7\4\2\2\u02e5\u02f6") - buf.write("\3\2\2\2\u02e6\u02e7\7\u0087\2\2\u02e7\u02e8\7\3\2\2\u02e8") - buf.write("\u02e9\5\b\5\2\u02e9\u02ea\7\23\2\2\u02ea\u02ed\5\b\5") - buf.write("\2\u02eb\u02ec\7\23\2\2\u02ec\u02ee\5\u00ccg\2\u02ed\u02eb") - buf.write("\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u02f1\3\2\2\2\u02ef") - buf.write("\u02f0\7\23\2\2\u02f0\u02f2\5\u00ccg\2\u02f1\u02ef\3\2") - buf.write("\2\2\u02f1\u02f2\3\2\2\2\u02f2\u02f3\3\2\2\2\u02f3\u02f4") - buf.write("\7\4\2\2\u02f4\u02f6\3\2\2\2\u02f5\u02c5\3\2\2\2\u02f5") - buf.write("\u02ca\3\2\2\2\u02f5\u02db\3\2\2\2\u02f5\u02e6\3\2\2\2") - buf.write("\u02f6/\3\2\2\2\u02f7\u02f8\t\f\2\2\u02f8\u02f9\7\3\2") - buf.write("\2\u02f9\u02fa\5\6\4\2\u02fa\u02fb\7\4\2\2\u02fb\u030d") - buf.write("\3\2\2\2\u02fc\u02fd\t\r\2\2\u02fd\u02fe\7\3\2\2\u02fe") - buf.write("\u0301\5\6\4\2\u02ff\u0300\7\23\2\2\u0300\u0302\5\u00ca") - buf.write("f\2\u0301\u02ff\3\2\2\2\u0301\u0302\3\2\2\2\u0302\u0303") - buf.write("\3\2\2\2\u0303\u0304\7\4\2\2\u0304\u030d\3\2\2\2\u0305") - buf.write("\u0306\t\16\2\2\u0306\u0307\7\3\2\2\u0307\u0308\5\6\4") - buf.write("\2\u0308\u0309\7\23\2\2\u0309\u030a\5\6\4\2\u030a\u030b") - buf.write("\7\4\2\2\u030b\u030d\3\2\2\2\u030c\u02f7\3\2\2\2\u030c") - buf.write("\u02fc\3\2\2\2\u030c\u0305\3\2\2\2\u030d\61\3\2\2\2\u030e") - buf.write("\u030f\t\f\2\2\u030f\u0310\7\3\2\2\u0310\u0311\5\b\5\2") - buf.write("\u0311\u0312\7\4\2\2\u0312\u0324\3\2\2\2\u0313\u0314\t") - buf.write("\r\2\2\u0314\u0315\7\3\2\2\u0315\u0318\5\b\5\2\u0316\u0317") - buf.write("\7\23\2\2\u0317\u0319\5\u00ccg\2\u0318\u0316\3\2\2\2\u0318") - buf.write("\u0319\3\2\2\2\u0319\u031a\3\2\2\2\u031a\u031b\7\4\2\2") - buf.write("\u031b\u0324\3\2\2\2\u031c\u031d\t\16\2\2\u031d\u031e") - buf.write("\7\3\2\2\u031e\u031f\5\b\5\2\u031f\u0320\7\23\2\2\u0320") - buf.write("\u0321\5\b\5\2\u0321\u0322\7\4\2\2\u0322\u0324\3\2\2\2") - buf.write("\u0323\u030e\3\2\2\2\u0323\u0313\3\2\2\2\u0323\u031c\3") - buf.write("\2\2\2\u0324\63\3\2\2\2\u0325\u0326\7\65\2\2\u0326\u0327") - buf.write("\7\3\2\2\u0327\u0328\5\6\4\2\u0328\u0329\7\23\2\2\u0329") - buf.write("\u032a\5\6\4\2\u032a\u032b\7\23\2\2\u032b\u032c\5\6\4") - buf.write("\2\u032c\u032d\7\4\2\2\u032d\u0346\3\2\2\2\u032e\u032f") - buf.write("\7q\2\2\u032f\u0330\7\3\2\2\u0330\u0331\5\6\4\2\u0331") - buf.write("\u0332\7\23\2\2\u0332\u0333\5\6\4\2\u0333\u0334\7\4\2") - buf.write("\2\u0334\u0346\3\2\2\2\u0335\u0336\79\2\2\u0336\u0337") - buf.write("\7\3\2\2\u0337\u0338\5\6\4\2\u0338\u0339\7\4\2\2\u0339") - buf.write("\u0346\3\2\2\2\u033a\u033b\7E\2\2\u033b\u033c\7\3\2\2") - buf.write("\u033c\u033d\5\6\4\2\u033d\u033e\7\23\2\2\u033e\u0341") - buf.write("\5\6\4\2\u033f\u0340\7\23\2\2\u0340\u0342\5\u00dco\2\u0341") - buf.write("\u033f\3\2\2\2\u0341\u0342\3\2\2\2\u0342\u0343\3\2\2\2") - buf.write("\u0343\u0344\7\4\2\2\u0344\u0346\3\2\2\2\u0345\u0325\3") - buf.write("\2\2\2\u0345\u032e\3\2\2\2\u0345\u0335\3\2\2\2\u0345\u033a") - buf.write("\3\2\2\2\u0346\65\3\2\2\2\u0347\u0348\7\65\2\2\u0348\u0349") - buf.write("\7\3\2\2\u0349\u034a\5\b\5\2\u034a\u034b\7\23\2\2\u034b") - buf.write("\u034c\5\b\5\2\u034c\u034d\7\23\2\2\u034d\u034e\5\b\5") - buf.write("\2\u034e\u034f\7\4\2\2\u034f\u035d\3\2\2\2\u0350\u0351") - buf.write("\7q\2\2\u0351\u0352\7\3\2\2\u0352\u0353\5\b\5\2\u0353") - buf.write("\u0354\7\23\2\2\u0354\u0355\5\b\5\2\u0355\u0356\7\4\2") - buf.write("\2\u0356\u035d\3\2\2\2\u0357\u0358\79\2\2\u0358\u0359") - buf.write("\7\3\2\2\u0359\u035a\5\b\5\2\u035a\u035b\7\4\2\2\u035b") - buf.write("\u035d\3\2\2\2\u035c\u0347\3\2\2\2\u035c\u0350\3\2\2\2") - buf.write("\u035c\u0357\3\2\2\2\u035d\67\3\2\2\2\u035e\u035f\7\u00d2") - buf.write("\2\2\u035f\u0361\7\3\2\2\u0360\u0362\5\6\4\2\u0361\u0360") - buf.write("\3\2\2\2\u0361\u0362\3\2\2\2\u0362\u0363\3\2\2\2\u0363") - buf.write("\u03c5\7\4\2\2\u0364\u0365\7\u00a3\2\2\u0365\u0366\7\3") - buf.write("\2\2\u0366\u0369\5\6\4\2\u0367\u0368\7\23\2\2\u0368\u036a") - buf.write("\t\17\2\2\u0369\u0367\3\2\2\2\u0369\u036a\3\2\2\2\u036a") - buf.write("\u036b\3\2\2\2\u036b\u036c\7\4\2\2\u036c\u03c5\3\2\2\2") - buf.write("\u036d\u036e\t\20\2\2\u036e\u036f\7\3\2\2\u036f\u0370") - buf.write("\5\6\4\2\u0370\u0371\7\4\2\2\u0371\u03c5\3\2\2\2\u0372") - buf.write("\u0373\7\u00a6\2\2\u0373\u0374\7\3\2\2\u0374\u0375\5\6") - buf.write("\4\2\u0375\u0376\7\23\2\2\u0376\u0377\5l\67\2\u0377\u0378") - buf.write("\7\4\2\2\u0378\u03c5\3\2\2\2\u0379\u037a\7\u00d5\2\2\u037a") - buf.write("\u037b\7\3\2\2\u037b\u037e\7\u00f6\2\2\u037c\u037d\7\23") - buf.write("\2\2\u037d\u037f\t\21\2\2\u037e\u037c\3\2\2\2\u037e\u037f") - buf.write("\3\2\2\2\u037f\u0382\3\2\2\2\u0380\u0381\7\23\2\2\u0381") - buf.write("\u0383\5\u00caf\2\u0382\u0380\3\2\2\2\u0382\u0383\3\2") - buf.write("\2\2\u0383\u0386\3\2\2\2\u0384\u0385\7\23\2\2\u0385\u0387") - buf.write("\t\22\2\2\u0386\u0384\3\2\2\2\u0386\u0387\3\2\2\2\u0387") - buf.write("\u0388\3\2\2\2\u0388\u03c5\7\4\2\2\u0389\u038a\7\37\2") - buf.write("\2\u038a\u038b\7\3\2\2\u038b\u03c5\7\4\2\2\u038c\u038d") - buf.write("\7 \2\2\u038d\u038e\7\3\2\2\u038e\u038f\5\6\4\2\u038f") - buf.write("\u0390\7\23\2\2\u0390\u0391\5\6\4\2\u0391\u0392\7\4\2") - buf.write("\2\u0392\u03c5\3\2\2\2\u0393\u0394\7!\2\2\u0394\u0395") - buf.write("\7\3\2\2\u0395\u0396\5\6\4\2\u0396\u0397\7\23\2\2\u0397") - buf.write("\u0398\5\6\4\2\u0398\u0399\7\23\2\2\u0399\u039a\5\6\4") - buf.write("\2\u039a\u039b\7\4\2\2\u039b\u03c5\3\2\2\2\u039c\u039d") - buf.write('\7"\2\2\u039d\u039e\7\3\2\2\u039e\u039f\5\6\4\2\u039f') - buf.write("\u03a0\7\4\2\2\u03a0\u03c5\3\2\2\2\u03a1\u03a2\7#\2\2") - buf.write("\u03a2\u03a3\7\3\2\2\u03a3\u03a4\5\6\4\2\u03a4\u03a5\7") - buf.write("\4\2\2\u03a5\u03c5\3\2\2\2\u03a6\u03a7\7$\2\2\u03a7\u03a8") - buf.write("\7\3\2\2\u03a8\u03a9\5\6\4\2\u03a9\u03aa\7\4\2\2\u03aa") - buf.write("\u03c5\3\2\2\2\u03ab\u03ac\7%\2\2\u03ac\u03ad\7\3\2\2") - buf.write("\u03ad\u03ae\5\6\4\2\u03ae\u03af\7\4\2\2\u03af\u03c5\3") - buf.write("\2\2\2\u03b0\u03b1\7&\2\2\u03b1\u03b2\7\3\2\2\u03b2\u03b3") - buf.write("\5\6\4\2\u03b3\u03b4\7\4\2\2\u03b4\u03c5\3\2\2\2\u03b5") - buf.write("\u03b6\7'\2\2\u03b6\u03b7\7\3\2\2\u03b7\u03b8\5\6\4\2") - buf.write("\u03b8\u03b9\7\4\2\2\u03b9\u03c5\3\2\2\2\u03ba\u03bb\7") - buf.write("(\2\2\u03bb\u03bc\7\3\2\2\u03bc\u03bd\5\6\4\2\u03bd\u03be") - buf.write("\7\4\2\2\u03be\u03c5\3\2\2\2\u03bf\u03c0\7)\2\2\u03c0") - buf.write("\u03c1\7\3\2\2\u03c1\u03c2\5\6\4\2\u03c2\u03c3\7\4\2\2") - buf.write("\u03c3\u03c5\3\2\2\2\u03c4\u035e\3\2\2\2\u03c4\u0364\3") - buf.write("\2\2\2\u03c4\u036d\3\2\2\2\u03c4\u0372\3\2\2\2\u03c4\u0379") - buf.write("\3\2\2\2\u03c4\u0389\3\2\2\2\u03c4\u038c\3\2\2\2\u03c4") - buf.write("\u0393\3\2\2\2\u03c4\u039c\3\2\2\2\u03c4\u03a1\3\2\2\2") - buf.write("\u03c4\u03a6\3\2\2\2\u03c4\u03ab\3\2\2\2\u03c4\u03b0\3") - buf.write("\2\2\2\u03c4\u03b5\3\2\2\2\u03c4\u03ba\3\2\2\2\u03c4\u03bf") - buf.write("\3\2\2\2\u03c59\3\2\2\2\u03c6\u03c7\7\u00d2\2\2\u03c7") - buf.write("\u03c9\7\3\2\2\u03c8\u03ca\5\b\5\2\u03c9\u03c8\3\2\2\2") - buf.write("\u03c9\u03ca\3\2\2\2\u03ca\u03cb\3\2\2\2\u03cb\u042d\7") - buf.write("\4\2\2\u03cc\u03cd\7\u00a3\2\2\u03cd\u03ce\7\3\2\2\u03ce") - buf.write("\u03d1\5\b\5\2\u03cf\u03d0\7\23\2\2\u03d0\u03d2\t\17\2") - buf.write("\2\u03d1\u03cf\3\2\2\2\u03d1\u03d2\3\2\2\2\u03d2\u03d3") - buf.write("\3\2\2\2\u03d3\u03d4\7\4\2\2\u03d4\u042d\3\2\2\2\u03d5") - buf.write("\u03d6\t\20\2\2\u03d6\u03d7\7\3\2\2\u03d7\u03d8\5\b\5") - buf.write("\2\u03d8\u03d9\7\4\2\2\u03d9\u042d\3\2\2\2\u03da\u03db") - buf.write("\7\u00a6\2\2\u03db\u03dc\7\3\2\2\u03dc\u03dd\5\b\5\2\u03dd") - buf.write("\u03de\7\23\2\2\u03de\u03df\5l\67\2\u03df\u03e0\7\4\2") - buf.write("\2\u03e0\u042d\3\2\2\2\u03e1\u03e2\7\u00d5\2\2\u03e2\u03e3") - buf.write("\7\3\2\2\u03e3\u03e6\7\u00f6\2\2\u03e4\u03e5\7\23\2\2") - buf.write("\u03e5\u03e7\t\21\2\2\u03e6\u03e4\3\2\2\2\u03e6\u03e7") - buf.write("\3\2\2\2\u03e7\u03ea\3\2\2\2\u03e8\u03e9\7\23\2\2\u03e9") - buf.write("\u03eb\5\u00ccg\2\u03ea\u03e8\3\2\2\2\u03ea\u03eb\3\2") - buf.write("\2\2\u03eb\u03ee\3\2\2\2\u03ec\u03ed\7\23\2\2\u03ed\u03ef") - buf.write("\t\22\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef") - buf.write("\u03f0\3\2\2\2\u03f0\u042d\7\4\2\2\u03f1\u03f2\7\37\2") - buf.write("\2\u03f2\u03f3\7\3\2\2\u03f3\u042d\7\4\2\2\u03f4\u03f5") - buf.write("\7 \2\2\u03f5\u03f6\7\3\2\2\u03f6\u03f7\5\b\5\2\u03f7") - buf.write("\u03f8\7\23\2\2\u03f8\u03f9\5\b\5\2\u03f9\u03fa\7\4\2") - buf.write("\2\u03fa\u042d\3\2\2\2\u03fb\u03fc\7!\2\2\u03fc\u03fd") - buf.write("\7\3\2\2\u03fd\u03fe\5\b\5\2\u03fe\u03ff\7\23\2\2\u03ff") - buf.write("\u0400\5\b\5\2\u0400\u0401\7\23\2\2\u0401\u0402\5\b\5") - buf.write("\2\u0402\u0403\7\4\2\2\u0403\u042d\3\2\2\2\u0404\u0405") - buf.write('\7"\2\2\u0405\u0406\7\3\2\2\u0406\u0407\5\b\5\2\u0407') - buf.write("\u0408\7\4\2\2\u0408\u042d\3\2\2\2\u0409\u040a\7#\2\2") - buf.write("\u040a\u040b\7\3\2\2\u040b\u040c\5\b\5\2\u040c\u040d\7") - buf.write("\4\2\2\u040d\u042d\3\2\2\2\u040e\u040f\7$\2\2\u040f\u0410") - buf.write("\7\3\2\2\u0410\u0411\5\b\5\2\u0411\u0412\7\4\2\2\u0412") - buf.write("\u042d\3\2\2\2\u0413\u0414\7%\2\2\u0414\u0415\7\3\2\2") - buf.write("\u0415\u0416\5\b\5\2\u0416\u0417\7\4\2\2\u0417\u042d\3") - buf.write("\2\2\2\u0418\u0419\7&\2\2\u0419\u041a\7\3\2\2\u041a\u041b") - buf.write("\5\b\5\2\u041b\u041c\7\4\2\2\u041c\u042d\3\2\2\2\u041d") - buf.write("\u041e\7'\2\2\u041e\u041f\7\3\2\2\u041f\u0420\5\b\5\2") - buf.write("\u0420\u0421\7\4\2\2\u0421\u042d\3\2\2\2\u0422\u0423\7") - buf.write("(\2\2\u0423\u0424\7\3\2\2\u0424\u0425\5\b\5\2\u0425\u0426") - buf.write("\7\4\2\2\u0426\u042d\3\2\2\2\u0427\u0428\7)\2\2\u0428") - buf.write("\u0429\7\3\2\2\u0429\u042a\5\b\5\2\u042a\u042b\7\4\2\2") - buf.write("\u042b\u042d\3\2\2\2\u042c\u03c6\3\2\2\2\u042c\u03cc\3") - buf.write("\2\2\2\u042c\u03d5\3\2\2\2\u042c\u03da\3\2\2\2\u042c\u03e1") - buf.write("\3\2\2\2\u042c\u03f1\3\2\2\2\u042c\u03f4\3\2\2\2\u042c") - buf.write("\u03fb\3\2\2\2\u042c\u0404\3\2\2\2\u042c\u0409\3\2\2\2") - buf.write("\u042c\u040e\3\2\2\2\u042c\u0413\3\2\2\2\u042c\u0418\3") - buf.write("\2\2\2\u042c\u041d\3\2\2\2\u042c\u0422\3\2\2\2\u042c\u0427") - buf.write("\3\2\2\2\u042d;\3\2\2\2\u042e\u042f\7;\2\2\u042f\u0430") - buf.write("\7\3\2\2\u0430\u0433\5\6\4\2\u0431\u0432\7\23\2\2\u0432") - buf.write("\u0434\5\6\4\2\u0433\u0431\3\2\2\2\u0434\u0435\3\2\2\2") - buf.write("\u0435\u0433\3\2\2\2\u0435\u0436\3\2\2\2\u0436\u0437\3") - buf.write("\2\2\2\u0437\u0438\7\4\2\2\u0438\u044c\3\2\2\2\u0439\u043a") - buf.write("\7>\2\2\u043a\u043b\7\3\2\2\u043b\u043e\5\6\4\2\u043c") - buf.write("\u043d\7\23\2\2\u043d\u043f\5\6\4\2\u043e\u043c\3\2\2") - buf.write("\2\u043f\u0440\3\2\2\2\u0440\u043e\3\2\2\2\u0440\u0441") - buf.write("\3\2\2\2\u0441\u0442\3\2\2\2\u0442\u0443\7\4\2\2\u0443") - buf.write("\u044c\3\2\2\2\u0444\u0445\t\23\2\2\u0445\u0446\7\3\2") - buf.write("\2\u0446\u0447\5\6\4\2\u0447\u0448\7\23\2\2\u0448\u0449") - buf.write("\5\6\4\2\u0449\u044a\7\4\2\2\u044a\u044c\3\2\2\2\u044b") - buf.write("\u042e\3\2\2\2\u044b\u0439\3\2\2\2\u044b\u0444\3\2\2\2") - buf.write("\u044c=\3\2\2\2\u044d\u044e\7t\2\2\u044e\u044f\7\3\2\2") - buf.write("\u044f\u0450\5\6\4\2\u0450\u0451\7\23\2\2\u0451\u0453") - buf.write("\7\u00f7\2\2\u0452\u0454\5\u00b0Y\2\u0453\u0452\3\2\2") - buf.write("\2\u0453\u0454\3\2\2\2\u0454\u0457\3\2\2\2\u0455\u0456") - buf.write("\7\u0082\2\2\u0456\u0458\5\u00c0a\2\u0457\u0455\3\2\2") - buf.write("\2\u0457\u0458\3\2\2\2\u0458\u045a\3\2\2\2\u0459\u045b") - buf.write("\5\u00aeX\2\u045a\u0459\3\2\2\2\u045a\u045b\3\2\2\2\u045b") - buf.write("\u045d\3\2\2\2\u045c\u045e\5\u00b6\\\2\u045d\u045c\3\2") - buf.write("\2\2\u045d\u045e\3\2\2\2\u045e\u0460\3\2\2\2\u045f\u0461") - buf.write("\5\u00b8]\2\u0460\u045f\3\2\2\2\u0460\u0461\3\2\2\2\u0461") - buf.write("\u0462\3\2\2\2\u0462\u0463\7\4\2\2\u0463?\3\2\2\2\u0464") - buf.write("\u0465\7\u00e0\2\2\u0465\u0466\7\3\2\2\u0466\u0467\5\6") - buf.write("\4\2\u0467\u0468\7\23\2\2\u0468\u0472\7\u00f7\2\2\u0469") - buf.write("\u046a\7\u00e9\2\2\u046a\u046f\5\u00c0a\2\u046b\u046c") - buf.write("\7\23\2\2\u046c\u046e\5\u00c0a\2\u046d\u046b\3\2\2\2\u046e") - buf.write("\u0471\3\2\2\2\u046f\u046d\3\2\2\2\u046f\u0470\3\2\2\2") - buf.write("\u0470\u0473\3\2\2\2\u0471\u046f\3\2\2\2\u0472\u0469\3") - buf.write("\2\2\2\u0472\u0473\3\2\2\2\u0473\u0475\3\2\2\2\u0474\u0476") - buf.write("\5\u00acW\2\u0475\u0474\3\2\2\2\u0475\u0476\3\2\2\2\u0476") + buf.write(",\3-\3-\3-\3-\3-\3-\3-\3-\5-\u055c\n-\3-\3-\3-\3-\3-\3") + buf.write("-\3-\3-\3-\5-\u0567\n-\3-\3-\5-\u056b\n-\3.\3.\3.\7.\u0570") + buf.write("\n.\f.\16.\u0573\13.\3/\3/\3/\7/\u0578\n/\f/\16/\u057b") + buf.write("\13/\3/\3/\3/\3/\7/\u0581\n/\f/\16/\u0584\13/\5/\u0586") + buf.write("\n/\3\60\3\60\3\60\5\60\u058b\n\60\3\61\5\61\u058e\n\61") + buf.write("\3\61\3\61\3\61\5\61\u0593\n\61\3\61\5\61\u0596\n\61\3") + buf.write("\61\5\61\u0599\n\61\3\62\3\62\3\62\3\63\3\63\3\63\3\63") + buf.write("\3\63\7\63\u05a3\n\63\f\63\16\63\u05a6\13\63\3\64\3\64") + buf.write("\3\64\3\64\3\64\7\64\u05ad\n\64\f\64\16\64\u05b0\13\64") + buf.write("\3\65\3\65\5\65\u05b4\n\65\3\66\3\66\3\66\5\66\u05b9\n") + buf.write("\66\3\66\3\66\3\66\3\66\3\66\3\67\3\67\38\38\38\38\38") + buf.write("\38\38\38\38\38\38\58\u05cd\n8\39\39\39\39\39\79\u05d4") + buf.write("\n9\f9\169\u05d7\139\39\39\39\59\u05dc\n9\3:\3:\3:\3;") + buf.write("\3;\3;\3;\5;\u05e5\n;\3<\3<\3<\5<\u05ea\n<\3=\3=\5=\u05ee") + buf.write("\n=\3>\3>\3>\3>\3>\5>\u05f5\n>\3?\3?\3?\5?\u05fa\n?\3") + buf.write("@\3@\5@\u05fe\n@\3@\5@\u0601\n@\3@\5@\u0604\n@\3@\5@\u0607") + buf.write("\n@\3A\3A\3A\3A\3A\5A\u060e\nA\3B\3B\3B\3B\3B\7B\u0615") + buf.write("\nB\fB\16B\u0618\13B\3B\3B\5B\u061c\nB\3C\3C\5C\u0620") + buf.write("\nC\3D\3D\3D\3D\3D\5D\u0627\nD\3E\3E\3E\3E\3E\3E\7E\u062f") + buf.write("\nE\fE\16E\u0632\13E\3E\3E\5E\u0636\nE\3E\3E\3E\3E\3E") + buf.write("\7E\u063d\nE\fE\16E\u0640\13E\3E\3E\5E\u0644\nE\5E\u0646") + buf.write("\nE\3F\3F\3F\3F\3F\3F\3F\3F\7F\u0650\nF\fF\16F\u0653\13") + buf.write("F\3F\3F\5F\u0657\nF\3F\5F\u065a\nF\3F\3F\3F\3F\3F\3F\3") + buf.write("F\7F\u0663\nF\fF\16F\u0666\13F\3F\3F\5F\u066a\nF\3F\3") + buf.write("F\5F\u066e\nF\5F\u0670\nF\3G\3G\3H\3H\3I\3I\3I\3I\7I\u067a") + buf.write("\nI\fI\16I\u067d\13I\3J\3J\3J\5J\u0682\nJ\3K\3K\3K\7K") + buf.write("\u0687\nK\fK\16K\u068a\13K\3L\3L\5L\u068e\nL\3L\3L\3L") + buf.write("\3L\5L\u0694\nL\3L\3L\5L\u0698\nL\3L\5L\u069b\nL\3M\3") + buf.write("M\3M\7M\u06a0\nM\fM\16M\u06a3\13M\3N\3N\5N\u06a7\nN\3") + buf.write("N\3N\5N\u06ab\nN\3N\5N\u06ae\nN\3O\3O\3O\5O\u06b3\nO\3") + buf.write("O\3O\3O\3P\3P\3P\7P\u06bb\nP\fP\16P\u06be\13P\3Q\3Q\3") + buf.write("Q\3Q\5Q\u06c4\nQ\3Q\3Q\5Q\u06c8\nQ\3Q\3Q\7Q\u06cc\nQ\f") + buf.write("Q\16Q\u06cf\13Q\3R\5R\u06d2\nR\3R\3R\3R\3R\3R\5R\u06d9") + buf.write("\nR\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\7T\u06e5\nT\fT\16T\u06e8") + buf.write("\13T\3T\3T\5T\u06ec\nT\3U\3U\3U\5U\u06f1\nU\3V\3V\5V\u06f5") + buf.write("\nV\3W\3W\3X\3X\3Y\3Y\3Y\3Y\7Y\u06ff\nY\fY\16Y\u0702\13") + buf.write("Y\3Z\3Z\3[\3[\3[\3\\\3\\\3]\3]\3^\3^\3_\3_\3`\3`\3a\3") + buf.write("a\3a\5a\u0716\na\3b\3b\3b\3b\7b\u071c\nb\fb\16b\u071f") + buf.write("\13b\3b\3b\3c\3c\3c\3d\3d\3d\3e\3e\3f\3f\5f\u072d\nf\3") + buf.write("g\3g\5g\u0731\ng\3h\3h\3h\3h\3h\5h\u0738\nh\3i\3i\3i\3") + buf.write("j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3o\3o\3o\2\4\6\bp\2\4\6\b") + buf.write("\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668") + buf.write(":<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084") + buf.write("\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096") + buf.write("\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8") + buf.write("\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba") + buf.write("\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc") + buf.write("\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\2\'\4") + buf.write("\2\17\20\64\64\3\2\21\22\4\2\17\20``\3\2\62\63\3\2\66") + buf.write("\67\3\2+,\4\2\u00cc\u00cc\u00ce\u00ce\3\2\u00c3\u00c4") + buf.write("\3\2\u00c5\u00c6\5\2__ac\u0085\u0086\6\2WWYYnn\u0089\u008b") + buf.write("\3\2[\\\5\2??ZZ]^\4\2JJ\u00d3\u00d3\3\2\u00a4\u00a5\4") + buf.write("\2uu\u00f6\u00f6\3\2TU\4\2==\u008d\u008d\4\2JJvv\5\2R") + buf.write("Seh\u008e\u0091\6\2RSeh\u008e\u0091\u0095\u0096\3\2\u0097") + buf.write("\u0098\3\2PQ\4\2NN\u0093\u0093\3\2wx\3\2\17\20\4\2\u00f3") + buf.write("\u00f4\u00f7\u00f7\4\2\17\17\21\21\5\2JJvv\u00ea\u00ea") + buf.write("\3\2\u00e3\u00e8\4\2{{\u00de\u00de\5\2{{\u0082\u0082\u00dd") + buf.write("\u00dd\4\2JJ\u00e2\u00e2\3\2\t\16\4\288\u00f3\u00f6\5") + buf.write("\2\u00aa\u00b0\u00d4\u00d4\u00eb\u00eb\4\2JJ\u00f5\u00f5") + buf.write("\2\u0807\2\u00e3\3\2\2\2\4\u00f1\3\2\2\2\6\u0111\3\2\2") + buf.write("\2\b\u0154\3\2\2\2\n\u0179\3\2\2\2\f\u0187\3\2\2\2\16") + buf.write("\u0190\3\2\2\2\20\u0192\3\2\2\2\22\u019b\3\2\2\2\24\u01a3") + buf.write("\3\2\2\2\26\u01a6\3\2\2\2\30\u01af\3\2\2\2\32\u01b8\3") + buf.write("\2\2\2\34\u01bd\3\2\2\2\36\u01ca\3\2\2\2 \u01df\3\2\2") + buf.write("\2\"\u0213\3\2\2\2$\u024e\3\2\2\2&\u0289\3\2\2\2(\u028d") + buf.write("\3\2\2\2*\u0291\3\2\2\2,\u02c3\3\2\2\2.\u02f5\3\2\2\2") + buf.write("\60\u030c\3\2\2\2\62\u0323\3\2\2\2\64\u0345\3\2\2\2\66") + buf.write("\u035c\3\2\2\28\u03c4\3\2\2\2:\u042c\3\2\2\2<\u044b\3") + buf.write("\2\2\2>\u044d\3\2\2\2@\u04a1\3\2\2\2B\u04a3\3\2\2\2D\u04aa") + buf.write("\3\2\2\2F\u04b9\3\2\2\2H\u04bb\3\2\2\2J\u04f5\3\2\2\2") + buf.write("L\u0531\3\2\2\2N\u0533\3\2\2\2P\u0537\3\2\2\2R\u0540\3") + buf.write("\2\2\2T\u0547\3\2\2\2V\u054d\3\2\2\2X\u056a\3\2\2\2Z\u056c") + buf.write("\3\2\2\2\\\u0574\3\2\2\2^\u0587\3\2\2\2`\u058d\3\2\2\2") + buf.write("b\u059a\3\2\2\2d\u059d\3\2\2\2f\u05a7\3\2\2\2h\u05b1\3") + buf.write("\2\2\2j\u05b8\3\2\2\2l\u05bf\3\2\2\2n\u05cc\3\2\2\2p\u05db") + buf.write("\3\2\2\2r\u05dd\3\2\2\2t\u05e0\3\2\2\2v\u05e9\3\2\2\2") + buf.write("x\u05ed\3\2\2\2z\u05f4\3\2\2\2|\u05f9\3\2\2\2~\u05fd\3") + buf.write("\2\2\2\u0080\u0608\3\2\2\2\u0082\u060f\3\2\2\2\u0084\u061f") + buf.write("\3\2\2\2\u0086\u0621\3\2\2\2\u0088\u0645\3\2\2\2\u008a") + buf.write("\u066f\3\2\2\2\u008c\u0671\3\2\2\2\u008e\u0673\3\2\2\2") + buf.write("\u0090\u0675\3\2\2\2\u0092\u067e\3\2\2\2\u0094\u0683\3") + buf.write("\2\2\2\u0096\u068d\3\2\2\2\u0098\u069c\3\2\2\2\u009a\u06a6") + buf.write("\3\2\2\2\u009c\u06af\3\2\2\2\u009e\u06b7\3\2\2\2\u00a0") + buf.write("\u06c3\3\2\2\2\u00a2\u06d1\3\2\2\2\u00a4\u06da\3\2\2\2") + buf.write("\u00a6\u06eb\3\2\2\2\u00a8\u06ed\3\2\2\2\u00aa\u06f2\3") + buf.write("\2\2\2\u00ac\u06f6\3\2\2\2\u00ae\u06f8\3\2\2\2\u00b0\u06fa") + buf.write("\3\2\2\2\u00b2\u0703\3\2\2\2\u00b4\u0705\3\2\2\2\u00b6") + buf.write("\u0708\3\2\2\2\u00b8\u070a\3\2\2\2\u00ba\u070c\3\2\2\2") + buf.write("\u00bc\u070e\3\2\2\2\u00be\u0710\3\2\2\2\u00c0\u0712\3") + buf.write("\2\2\2\u00c2\u0717\3\2\2\2\u00c4\u0722\3\2\2\2\u00c6\u0725") + buf.write("\3\2\2\2\u00c8\u0728\3\2\2\2\u00ca\u072c\3\2\2\2\u00cc") + buf.write("\u0730\3\2\2\2\u00ce\u0737\3\2\2\2\u00d0\u0739\3\2\2\2") + buf.write("\u00d2\u073c\3\2\2\2\u00d4\u073e\3\2\2\2\u00d6\u0740\3") + buf.write("\2\2\2\u00d8\u0742\3\2\2\2\u00da\u0744\3\2\2\2\u00dc\u0746") + buf.write("\3\2\2\2\u00de\u00df\5\4\3\2\u00df\u00e0\7\u00f9\2\2\u00e0") + buf.write("\u00e2\3\2\2\2\u00e1\u00de\3\2\2\2\u00e2\u00e5\3\2\2\2") + buf.write("\u00e3\u00e1\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\u00e6\3") + buf.write("\2\2\2\u00e5\u00e3\3\2\2\2\u00e6\u00e7\7\2\2\3\u00e7\3") + buf.write("\3\2\2\2\u00e8\u00e9\5\u00bc_\2\u00e9\u00ea\7\26\2\2\u00ea") + buf.write("\u00eb\5\6\4\2\u00eb\u00f2\3\2\2\2\u00ec\u00ed\5\u00bc") + buf.write("_\2\u00ed\u00ee\7~\2\2\u00ee\u00ef\5\6\4\2\u00ef\u00f2") + buf.write("\3\2\2\2\u00f0\u00f2\5\"\22\2\u00f1\u00e8\3\2\2\2\u00f1") + buf.write("\u00ec\3\2\2\2\u00f1\u00f0\3\2\2\2\u00f2\5\3\2\2\2\u00f3") + buf.write("\u00f4\b\4\1\2\u00f4\u00f5\7\3\2\2\u00f5\u00f6\5\6\4\2") + buf.write("\u00f6\u00f7\7\4\2\2\u00f7\u0112\3\2\2\2\u00f8\u0112\5") + buf.write("\f\7\2\u00f9\u00fa\t\2\2\2\u00fa\u0112\5\6\4\r\u00fb\u00fc") + buf.write("\7\31\2\2\u00fc\u00fd\5\6\4\2\u00fd\u00fe\7\33\2\2\u00fe") + buf.write("\u00ff\5\6\4\2\u00ff\u0100\7\34\2\2\u0100\u0101\5\6\4") + buf.write("\6\u0101\u0112\3\2\2\2\u0102\u0108\7\32\2\2\u0103\u0104") + buf.write("\7\u00bb\2\2\u0104\u0105\5\6\4\2\u0105\u0106\7\33\2\2") + buf.write("\u0106\u0107\5\6\4\2\u0107\u0109\3\2\2\2\u0108\u0103\3") + buf.write("\2\2\2\u0109\u010a\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b") + buf.write("\3\2\2\2\u010b\u010c\3\2\2\2\u010c\u010d\7\34\2\2\u010d") + buf.write("\u010e\5\6\4\5\u010e\u0112\3\2\2\2\u010f\u0112\5\u00d8") + buf.write("m\2\u0110\u0112\5\u00bc_\2\u0111\u00f3\3\2\2\2\u0111\u00f8") + buf.write("\3\2\2\2\u0111\u00f9\3\2\2\2\u0111\u00fb\3\2\2\2\u0111") + buf.write("\u0102\3\2\2\2\u0111\u010f\3\2\2\2\u0111\u0110\3\2\2\2") + buf.write("\u0112\u0133\3\2\2\2\u0113\u0114\f\f\2\2\u0114\u0115\t") + buf.write("\3\2\2\u0115\u0132\5\6\4\r\u0116\u0117\f\13\2\2\u0117") + buf.write("\u0118\t\4\2\2\u0118\u0132\5\6\4\f\u0119\u011a\f\n\2\2") + buf.write("\u011a\u011b\5\u00c8e\2\u011b\u011c\5\6\4\13\u011c\u0132") + buf.write("\3\2\2\2\u011d\u011e\f\b\2\2\u011e\u011f\7\61\2\2\u011f") + buf.write("\u0132\5\6\4\t\u0120\u0121\f\7\2\2\u0121\u0122\t\5\2\2") + buf.write("\u0122\u0132\5\6\4\b\u0123\u0124\f\17\2\2\u0124\u0125") + buf.write("\7\5\2\2\u0125\u0126\5\16\b\2\u0126\u0127\7\6\2\2\u0127") + buf.write("\u0132\3\2\2\2\u0128\u0129\f\16\2\2\u0129\u012a\7\27\2") + buf.write("\2\u012a\u0132\5\u00be`\2\u012b\u012c\f\t\2\2\u012c\u012f") + buf.write("\t\6\2\2\u012d\u0130\5\u00c2b\2\u012e\u0130\5\u00d2j\2") + buf.write("\u012f\u012d\3\2\2\2\u012f\u012e\3\2\2\2\u0130\u0132\3") + buf.write("\2\2\2\u0131\u0113\3\2\2\2\u0131\u0116\3\2\2\2\u0131\u0119") + buf.write("\3\2\2\2\u0131\u011d\3\2\2\2\u0131\u0120\3\2\2\2\u0131") + buf.write("\u0123\3\2\2\2\u0131\u0128\3\2\2\2\u0131\u012b\3\2\2\2") + buf.write("\u0132\u0135\3\2\2\2\u0133\u0131\3\2\2\2\u0133\u0134\3") + buf.write("\2\2\2\u0134\7\3\2\2\2\u0135\u0133\3\2\2\2\u0136\u0137") + buf.write("\b\5\1\2\u0137\u0138\7\3\2\2\u0138\u0139\5\b\5\2\u0139") + buf.write("\u013a\7\4\2\2\u013a\u0155\3\2\2\2\u013b\u0155\5\n\6\2") + buf.write("\u013c\u013d\t\2\2\2\u013d\u0155\5\b\5\r\u013e\u013f\7") + buf.write("\31\2\2\u013f\u0140\5\b\5\2\u0140\u0141\7\33\2\2\u0141") + buf.write("\u0142\5\b\5\2\u0142\u0143\7\34\2\2\u0143\u0144\5\b\5") + buf.write("\6\u0144\u0155\3\2\2\2\u0145\u014b\7\32\2\2\u0146\u0147") + buf.write("\7\u00bb\2\2\u0147\u0148\5\b\5\2\u0148\u0149\7\33\2\2") + buf.write("\u0149\u014a\5\b\5\2\u014a\u014c\3\2\2\2\u014b\u0146\3") + buf.write("\2\2\2\u014c\u014d\3\2\2\2\u014d\u014b\3\2\2\2\u014d\u014e") + buf.write("\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0150\7\34\2\2\u0150") + buf.write("\u0151\5\b\5\5\u0151\u0155\3\2\2\2\u0152\u0155\5\u00d8") + buf.write("m\2\u0153\u0155\5\u00c0a\2\u0154\u0136\3\2\2\2\u0154\u013b") + buf.write("\3\2\2\2\u0154\u013c\3\2\2\2\u0154\u013e\3\2\2\2\u0154") + buf.write("\u0145\3\2\2\2\u0154\u0152\3\2\2\2\u0154\u0153\3\2\2\2") + buf.write("\u0155\u016e\3\2\2\2\u0156\u0157\f\f\2\2\u0157\u0158\t") + buf.write("\3\2\2\u0158\u016d\5\b\5\r\u0159\u015a\f\13\2\2\u015a") + buf.write("\u015b\t\4\2\2\u015b\u016d\5\b\5\f\u015c\u015d\f\n\2\2") + buf.write("\u015d\u015e\5\u00c8e\2\u015e\u015f\5\b\5\13\u015f\u016d") + buf.write("\3\2\2\2\u0160\u0161\f\b\2\2\u0161\u0162\7\61\2\2\u0162") + buf.write("\u016d\5\b\5\t\u0163\u0164\f\7\2\2\u0164\u0165\t\5\2\2") + buf.write("\u0165\u016d\5\b\5\b\u0166\u0167\f\t\2\2\u0167\u016a\t") + buf.write("\6\2\2\u0168\u016b\5\u00c2b\2\u0169\u016b\5\u00d2j\2\u016a") + buf.write("\u0168\3\2\2\2\u016a\u0169\3\2\2\2\u016b\u016d\3\2\2\2") + buf.write("\u016c\u0156\3\2\2\2\u016c\u0159\3\2\2\2\u016c\u015c\3") + buf.write("\2\2\2\u016c\u0160\3\2\2\2\u016c\u0163\3\2\2\2\u016c\u0166") + buf.write("\3\2\2\2\u016d\u0170\3\2\2\2\u016e\u016c\3\2\2\2\u016e") + buf.write("\u016f\3\2\2\2\u016f\t\3\2\2\2\u0170\u016e\3\2\2\2\u0171") + buf.write("\u017a\5&\24\2\u0172\u017a\5.\30\2\u0173\u017a\5\62\32") + buf.write("\2\u0174\u017a\5\66\34\2\u0175\u017a\5:\36\2\u0176\u017a") + buf.write("\5D#\2\u0177\u017a\5F$\2\u0178\u017a\5L\'\2\u0179\u0171") + buf.write("\3\2\2\2\u0179\u0172\3\2\2\2\u0179\u0173\3\2\2\2\u0179") + buf.write("\u0174\3\2\2\2\u0179\u0175\3\2\2\2\u0179\u0176\3\2\2\2") + buf.write("\u0179\u0177\3\2\2\2\u0179\u0178\3\2\2\2\u017a\13\3\2") + buf.write("\2\2\u017b\u0188\5 \21\2\u017c\u0188\5$\23\2\u017d\u0188") + buf.write("\5,\27\2\u017e\u0188\5\60\31\2\u017f\u0188\5\64\33\2\u0180") + buf.write("\u0188\58\35\2\u0181\u0188\5<\37\2\u0182\u0188\5> \2\u0183") + buf.write("\u0188\5@!\2\u0184\u0188\5B\"\2\u0185\u0188\5H%\2\u0186") + buf.write("\u0188\5J&\2\u0187\u017b\3\2\2\2\u0187\u017c\3\2\2\2\u0187") + buf.write("\u017d\3\2\2\2\u0187\u017e\3\2\2\2\u0187\u017f\3\2\2\2") + buf.write("\u0187\u0180\3\2\2\2\u0187\u0181\3\2\2\2\u0187\u0182\3") + buf.write("\2\2\2\u0187\u0183\3\2\2\2\u0187\u0184\3\2\2\2\u0187\u0185") + buf.write("\3\2\2\2\u0187\u0186\3\2\2\2\u0188\r\3\2\2\2\u0189\u0191") + buf.write("\5\20\t\2\u018a\u0191\5\22\n\2\u018b\u0191\5\24\13\2\u018c") + buf.write("\u0191\5\26\f\2\u018d\u0191\5\30\r\2\u018e\u0191\5\32") + buf.write("\16\2\u018f\u0191\5\36\20\2\u0190\u0189\3\2\2\2\u0190") + buf.write("\u018a\3\2\2\2\u0190\u018b\3\2\2\2\u0190\u018c\3\2\2\2") + buf.write("\u0190\u018d\3\2\2\2\u0190\u018e\3\2\2\2\u0190\u018f\3") + buf.write("\2\2\2\u0191\17\3\2\2\2\u0192\u0193\7/\2\2\u0193\u0198") + buf.write("\5N(\2\u0194\u0195\7\23\2\2\u0195\u0197\5N(\2\u0196\u0194") + buf.write("\3\2\2\2\u0197\u019a\3\2\2\2\u0198\u0196\3\2\2\2\u0198") + buf.write("\u0199\3\2\2\2\u0199\21\3\2\2\2\u019a\u0198\3\2\2\2\u019b") + buf.write("\u019c\7K\2\2\u019c\u01a1\5P)\2\u019d\u019f\5p9\2\u019e") + buf.write("\u01a0\5r:\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0") + buf.write("\u01a2\3\2\2\2\u01a1\u019d\3\2\2\2\u01a1\u01a2\3\2\2\2") + buf.write("\u01a2\23\3\2\2\2\u01a3\u01a4\7l\2\2\u01a4\u01a5\5\b\5") + buf.write("\2\u01a5\25\3\2\2\2\u01a6\u01a7\7-\2\2\u01a7\u01ac\5T") + buf.write("+\2\u01a8\u01a9\7\23\2\2\u01a9\u01ab\5T+\2\u01aa\u01a8") + buf.write("\3\2\2\2\u01ab\u01ae\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ac") + buf.write("\u01ad\3\2\2\2\u01ad\27\3\2\2\2\u01ae\u01ac\3\2\2\2\u01af") + buf.write("\u01b0\t\7\2\2\u01b0\u01b5\5\u00c0a\2\u01b1\u01b2\7\23") + buf.write("\2\2\u01b2\u01b4\5\u00c0a\2\u01b3\u01b1\3\2\2\2\u01b4") + buf.write("\u01b7\3\2\2\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2") + buf.write("\u01b6\31\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b8\u01b9\t\b") + buf.write("\2\2\u01b9\u01ba\5\u00c0a\2\u01ba\u01bb\7\23\2\2\u01bb") + buf.write("\u01bc\5\u00c0a\2\u01bc\33\3\2\2\2\u01bd\u01be\7\u00cd") + buf.write("\2\2\u01be\u01bf\5\u00c0a\2\u01bf\u01c0\7\23\2\2\u01c0") + buf.write("\u01c1\5\u00c0a\2\u01c1\u01c2\7\66\2\2\u01c2\u01c7\5\u00d8") + buf.write("m\2\u01c3\u01c4\7\23\2\2\u01c4\u01c6\5\u00d8m\2\u01c5") + buf.write("\u01c3\3\2\2\2\u01c6\u01c9\3\2\2\2\u01c7\u01c5\3\2\2\2") + buf.write("\u01c7\u01c8\3\2\2\2\u01c8\35\3\2\2\2\u01c9\u01c7\3\2") + buf.write("\2\2\u01ca\u01cb\7\u00cf\2\2\u01cb\u01d0\5V,\2\u01cc\u01cd") + buf.write("\7\23\2\2\u01cd\u01cf\5V,\2\u01ce\u01cc\3\2\2\2\u01cf") + buf.write("\u01d2\3\2\2\2\u01d0\u01ce\3\2\2\2\u01d0\u01d1\3\2\2\2") + buf.write("\u01d1\37\3\2\2\2\u01d2\u01d0\3\2\2\2\u01d3\u01d4\t\t") + buf.write("\2\2\u01d4\u01d5\7\3\2\2\u01d5\u01d6\5\\/\2\u01d6\u01d7") + buf.write("\5`\61\2\u01d7\u01d8\7\4\2\2\u01d8\u01e0\3\2\2\2\u01d9") + buf.write("\u01da\t\n\2\2\u01da\u01db\7\3\2\2\u01db\u01dc\5Z.\2\u01dc") + buf.write("\u01dd\5`\61\2\u01dd\u01de\7\4\2\2\u01de\u01e0\3\2\2\2") + buf.write("\u01df\u01d3\3\2\2\2\u01df\u01d9\3\2\2\2\u01e0!\3\2\2") + buf.write("\2\u01e1\u01e2\7}\2\2\u01e2\u01e3\7|\2\2\u01e3\u01e4\5") + buf.write("\u00d4k\2\u01e4\u01ed\7\3\2\2\u01e5\u01ea\5t;\2\u01e6") + buf.write("\u01e7\7\23\2\2\u01e7\u01e9\5t;\2\u01e8\u01e6\3\2\2\2") + buf.write("\u01e9\u01ec\3\2\2\2\u01ea\u01e8\3\2\2\2\u01ea\u01eb\3") + buf.write("\2\2\2\u01eb\u01ee\3\2\2\2\u01ec\u01ea\3\2\2\2\u01ed\u01e5") + buf.write("\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee\u01ef\3\2\2\2\u01ef") + buf.write("\u01f2\7\4\2\2\u01f0\u01f1\7\u00cb\2\2\u01f1\u01f3\5v") + buf.write("<\2\u01f2\u01f0\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3\u01f4") + buf.write("\3\2\2\2\u01f4\u01f5\7\u00ba\2\2\u01f5\u01f6\5\6\4\2\u01f6") + buf.write("\u01f7\7\u0083\2\2\u01f7\u01f8\7|\2\2\u01f8\u0214\3\2") + buf.write("\2\2\u01f9\u01fa\7}\2\2\u01fa\u01fb\7\177\2\2\u01fb\u01fc") + buf.write("\7\u0081\2\2\u01fc\u01fd\5\u008eH\2\u01fd\u01fe\7\3\2") + buf.write("\2\u01fe\u01ff\5\u0090I\2\u01ff\u0200\7\4\2\2\u0200\u0201") + buf.write("\7\u00ba\2\2\u0201\u0202\5\u0094K\2\u0202\u0203\7\u0083") + buf.write("\2\2\u0203\u0204\7\177\2\2\u0204\u0205\7\u0081\2\2\u0205") + buf.write("\u0214\3\2\2\2\u0206\u0207\7}\2\2\u0207\u0208\7\u0080") + buf.write("\2\2\u0208\u0209\7\u0081\2\2\u0209\u020a\5\u008eH\2\u020a") + buf.write("\u020b\7\3\2\2\u020b\u020c\5\u009cO\2\u020c\u020d\7\4") + buf.write("\2\2\u020d\u020e\7\u00ba\2\2\u020e\u020f\5\u0098M\2\u020f") + buf.write("\u0210\7\u0083\2\2\u0210\u0211\7\u0080\2\2\u0211\u0212") + buf.write("\7\u0081\2\2\u0212\u0214\3\2\2\2\u0213\u01e1\3\2\2\2\u0213") + buf.write("\u01f9\3\2\2\2\u0213\u0206\3\2\2\2\u0214#\3\2\2\2\u0215") + buf.write("\u0216\5\u00d4k\2\u0216\u021f\7\3\2\2\u0217\u021c\5*\26") + buf.write("\2\u0218\u0219\7\23\2\2\u0219\u021b\5*\26\2\u021a\u0218") + buf.write("\3\2\2\2\u021b\u021e\3\2\2\2\u021c\u021a\3\2\2\2\u021c") + buf.write("\u021d\3\2\2\2\u021d\u0220\3\2\2\2\u021e\u021c\3\2\2\2") + buf.write("\u021f\u0217\3\2\2\2\u021f\u0220\3\2\2\2\u0220\u0221\3") + buf.write("\2\2\2\u0221\u0222\7\4\2\2\u0222\u024f\3\2\2\2\u0223\u0224") + buf.write("\7\30\2\2\u0224\u0225\7\3\2\2\u0225\u0226\5\u00d6l\2\u0226") + buf.write("\u0229\7\3\2\2\u0227\u022a\5\u00bc_\2\u0228\u022a\5X-") + buf.write("\2\u0229\u0227\3\2\2\2\u0229\u0228\3\2\2\2\u0229\u022a") + buf.write("\3\2\2\2\u022a\u0232\3\2\2\2\u022b\u022e\7\23\2\2\u022c") + buf.write("\u022f\5\u00bc_\2\u022d\u022f\5X-\2\u022e\u022c\3\2\2") + buf.write("\2\u022e\u022d\3\2\2\2\u022f\u0231\3\2\2\2\u0230\u022b") + buf.write("\3\2\2\2\u0231\u0234\3\2\2\2\u0232\u0230\3\2\2\2\u0232") + buf.write("\u0233\3\2\2\2\u0233\u0235\3\2\2\2\u0234\u0232\3\2\2\2") + buf.write("\u0235\u0238\7\4\2\2\u0236\u0237\7\u00f2\2\2\u0237\u0239") + buf.write("\7\u00f6\2\2\u0238\u0236\3\2\2\2\u0238\u0239\3\2\2\2\u0239") + buf.write("\u023c\3\2\2\2\u023a\u023b\7\u00cb\2\2\u023b\u023d\5\u0084") + buf.write("C\2\u023c\u023a\3\2\2\2\u023c\u023d\3\2\2\2\u023d\u023e") + buf.write("\3\2\2\2\u023e\u023f\7\4\2\2\u023f\u024f\3\2\2\2\u0240") + buf.write("\u0241\7\u00dc\2\2\u0241\u0242\7\3\2\2\u0242\u0243\5\6") + buf.write("\4\2\u0243\u0246\7\23\2\2\u0244\u0247\5\u00dan\2\u0245") + buf.write("\u0247\5\u008cG\2\u0246\u0244\3\2\2\2\u0246\u0245\3\2") + buf.write("\2\2\u0247\u024a\3\2\2\2\u0248\u0249\7\23\2\2\u0249\u024b") + buf.write("\7\u00f6\2\2\u024a\u0248\3\2\2\2\u024a\u024b\3\2\2\2\u024b") + buf.write("\u024c\3\2\2\2\u024c\u024d\7\4\2\2\u024d\u024f\3\2\2\2") + buf.write("\u024e\u0215\3\2\2\2\u024e\u0223\3\2\2\2\u024e\u0240\3") + buf.write("\2\2\2\u024f%\3\2\2\2\u0250\u0251\5\u00d4k\2\u0251\u025a") + buf.write("\7\3\2\2\u0252\u0257\5(\25\2\u0253\u0254\7\23\2\2\u0254") + buf.write("\u0256\5(\25\2\u0255\u0253\3\2\2\2\u0256\u0259\3\2\2\2") + buf.write("\u0257\u0255\3\2\2\2\u0257\u0258\3\2\2\2\u0258\u025b\3") + buf.write("\2\2\2\u0259\u0257\3\2\2\2\u025a\u0252\3\2\2\2\u025a\u025b") + buf.write("\3\2\2\2\u025b\u025c\3\2\2\2\u025c\u025d\7\4\2\2\u025d") + buf.write("\u028a\3\2\2\2\u025e\u025f\7\u00dc\2\2\u025f\u0260\7\3") + buf.write("\2\2\u0260\u0261\5\b\5\2\u0261\u0264\7\23\2\2\u0262\u0265") + buf.write("\5\u00dan\2\u0263\u0265\5\u008cG\2\u0264\u0262\3\2\2\2") + buf.write("\u0264\u0263\3\2\2\2\u0265\u0268\3\2\2\2\u0266\u0267\7") + buf.write("\23\2\2\u0267\u0269\7\u00f6\2\2\u0268\u0266\3\2\2\2\u0268") + buf.write("\u0269\3\2\2\2\u0269\u026a\3\2\2\2\u026a\u026b\7\4\2\2") + buf.write("\u026b\u028a\3\2\2\2\u026c\u026d\7\30\2\2\u026d\u026e") + buf.write("\7\3\2\2\u026e\u026f\5\u00d6l\2\u026f\u0272\7\3\2\2\u0270") + buf.write("\u0273\5\u00c0a\2\u0271\u0273\5X-\2\u0272\u0270\3\2\2") + buf.write("\2\u0272\u0271\3\2\2\2\u0272\u0273\3\2\2\2\u0273\u027b") + buf.write("\3\2\2\2\u0274\u0277\7\23\2\2\u0275\u0278\5\u00c0a\2\u0276") + buf.write("\u0278\5X-\2\u0277\u0275\3\2\2\2\u0277\u0276\3\2\2\2\u0278") + buf.write("\u027a\3\2\2\2\u0279\u0274\3\2\2\2\u027a\u027d\3\2\2\2") + buf.write("\u027b\u0279\3\2\2\2\u027b\u027c\3\2\2\2\u027c\u027e\3") + buf.write("\2\2\2\u027d\u027b\3\2\2\2\u027e\u0281\7\4\2\2\u027f\u0280") + buf.write("\7\u00f2\2\2\u0280\u0282\7\u00f6\2\2\u0281\u027f\3\2\2") + buf.write("\2\u0281\u0282\3\2\2\2\u0282\u0285\3\2\2\2\u0283\u0284") + buf.write("\7\u00cb\2\2\u0284\u0286\5x=\2\u0285\u0283\3\2\2\2\u0285") + buf.write("\u0286\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0288\7\4\2\2") + buf.write("\u0288\u028a\3\2\2\2\u0289\u0250\3\2\2\2\u0289\u025e\3") + buf.write("\2\2\2\u0289\u026c\3\2\2\2\u028a\'\3\2\2\2\u028b\u028e") + buf.write("\5\b\5\2\u028c\u028e\7u\2\2\u028d\u028b\3\2\2\2\u028d") + buf.write("\u028c\3\2\2\2\u028e)\3\2\2\2\u028f\u0292\5\6\4\2\u0290") + buf.write("\u0292\7u\2\2\u0291\u028f\3\2\2\2\u0291\u0290\3\2\2\2") + buf.write("\u0292+\3\2\2\2\u0293\u0294\t\13\2\2\u0294\u0295\7\3\2") + buf.write("\2\u0295\u0296\5\6\4\2\u0296\u0297\7\4\2\2\u0297\u02c4") + buf.write("\3\2\2\2\u0298\u0299\7d\2\2\u0299\u029a\7\3\2\2\u029a") + buf.write("\u02a5\5\6\4\2\u029b\u029c\7\23\2\2\u029c\u029d\5\u00ca") + buf.write("f\2\u029d\u029e\3\2\2\2\u029e\u029f\7\23\2\2\u029f\u02a0") + buf.write("\5\u00caf\2\u02a0\u02a2\3\2\2\2\u02a1\u029b\3\2\2\2\u02a1") + buf.write("\u02a2\3\2\2\2\u02a2\u02a6\3\2\2\2\u02a3\u02a4\7\23\2") + buf.write("\2\u02a4\u02a6\5\u00caf\2\u02a5\u02a1\3\2\2\2\u02a5\u02a3") + buf.write("\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7\u02a8\7\4\2\2\u02a8") + buf.write("\u02c4\3\2\2\2\u02a9\u02aa\7\u0088\2\2\u02aa\u02ab\7\3") + buf.write("\2\2\u02ab\u02ac\5\6\4\2\u02ac\u02ad\7\23\2\2\u02ad\u02b0") + buf.write("\5\6\4\2\u02ae\u02af\7\23\2\2\u02af\u02b1\5\u00caf\2\u02b0") + buf.write("\u02ae\3\2\2\2\u02b0\u02b1\3\2\2\2\u02b1\u02b2\3\2\2\2") + buf.write("\u02b2\u02b3\7\4\2\2\u02b3\u02c4\3\2\2\2\u02b4\u02b5\7") + buf.write("\u0087\2\2\u02b5\u02b6\7\3\2\2\u02b6\u02b7\5\6\4\2\u02b7") + buf.write("\u02b8\7\23\2\2\u02b8\u02bb\5\6\4\2\u02b9\u02ba\7\23\2") + buf.write("\2\u02ba\u02bc\5\u00caf\2\u02bb\u02b9\3\2\2\2\u02bb\u02bc") + buf.write("\3\2\2\2\u02bc\u02bf\3\2\2\2\u02bd\u02be\7\23\2\2\u02be") + buf.write("\u02c0\5\u00caf\2\u02bf\u02bd\3\2\2\2\u02bf\u02c0\3\2") + buf.write("\2\2\u02c0\u02c1\3\2\2\2\u02c1\u02c2\7\4\2\2\u02c2\u02c4") + buf.write("\3\2\2\2\u02c3\u0293\3\2\2\2\u02c3\u0298\3\2\2\2\u02c3") + buf.write("\u02a9\3\2\2\2\u02c3\u02b4\3\2\2\2\u02c4-\3\2\2\2\u02c5") + buf.write("\u02c6\t\13\2\2\u02c6\u02c7\7\3\2\2\u02c7\u02c8\5\b\5") + buf.write("\2\u02c8\u02c9\7\4\2\2\u02c9\u02f6\3\2\2\2\u02ca\u02cb") + buf.write("\7d\2\2\u02cb\u02cc\7\3\2\2\u02cc\u02d7\5\b\5\2\u02cd") + buf.write("\u02ce\7\23\2\2\u02ce\u02cf\5\u00ccg\2\u02cf\u02d0\3\2") + buf.write("\2\2\u02d0\u02d1\7\23\2\2\u02d1\u02d2\5\u00ccg\2\u02d2") + buf.write("\u02d4\3\2\2\2\u02d3\u02cd\3\2\2\2\u02d3\u02d4\3\2\2\2") + buf.write("\u02d4\u02d8\3\2\2\2\u02d5\u02d6\7\23\2\2\u02d6\u02d8") + buf.write("\5\u00ccg\2\u02d7\u02d3\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d8") + buf.write("\u02d9\3\2\2\2\u02d9\u02da\7\4\2\2\u02da\u02f6\3\2\2\2") + buf.write("\u02db\u02dc\7\u0088\2\2\u02dc\u02dd\7\3\2\2\u02dd\u02de") + buf.write("\5\b\5\2\u02de\u02df\7\23\2\2\u02df\u02e2\5\b\5\2\u02e0") + buf.write("\u02e1\7\23\2\2\u02e1\u02e3\5\u00ccg\2\u02e2\u02e0\3\2") + buf.write("\2\2\u02e2\u02e3\3\2\2\2\u02e3\u02e4\3\2\2\2\u02e4\u02e5") + buf.write("\7\4\2\2\u02e5\u02f6\3\2\2\2\u02e6\u02e7\7\u0087\2\2\u02e7") + buf.write("\u02e8\7\3\2\2\u02e8\u02e9\5\b\5\2\u02e9\u02ea\7\23\2") + buf.write("\2\u02ea\u02ed\5\b\5\2\u02eb\u02ec\7\23\2\2\u02ec\u02ee") + buf.write("\5\u00ccg\2\u02ed\u02eb\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee") + buf.write("\u02f1\3\2\2\2\u02ef\u02f0\7\23\2\2\u02f0\u02f2\5\u00cc") + buf.write("g\2\u02f1\u02ef\3\2\2\2\u02f1\u02f2\3\2\2\2\u02f2\u02f3") + buf.write("\3\2\2\2\u02f3\u02f4\7\4\2\2\u02f4\u02f6\3\2\2\2\u02f5") + buf.write("\u02c5\3\2\2\2\u02f5\u02ca\3\2\2\2\u02f5\u02db\3\2\2\2") + buf.write("\u02f5\u02e6\3\2\2\2\u02f6/\3\2\2\2\u02f7\u02f8\t\f\2") + buf.write("\2\u02f8\u02f9\7\3\2\2\u02f9\u02fa\5\6\4\2\u02fa\u02fb") + buf.write("\7\4\2\2\u02fb\u030d\3\2\2\2\u02fc\u02fd\t\r\2\2\u02fd") + buf.write("\u02fe\7\3\2\2\u02fe\u0301\5\6\4\2\u02ff\u0300\7\23\2") + buf.write("\2\u0300\u0302\5\u00caf\2\u0301\u02ff\3\2\2\2\u0301\u0302") + buf.write("\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u0304\7\4\2\2\u0304") + buf.write("\u030d\3\2\2\2\u0305\u0306\t\16\2\2\u0306\u0307\7\3\2") + buf.write("\2\u0307\u0308\5\6\4\2\u0308\u0309\7\23\2\2\u0309\u030a") + buf.write("\5\6\4\2\u030a\u030b\7\4\2\2\u030b\u030d\3\2\2\2\u030c") + buf.write("\u02f7\3\2\2\2\u030c\u02fc\3\2\2\2\u030c\u0305\3\2\2\2") + buf.write("\u030d\61\3\2\2\2\u030e\u030f\t\f\2\2\u030f\u0310\7\3") + buf.write("\2\2\u0310\u0311\5\b\5\2\u0311\u0312\7\4\2\2\u0312\u0324") + buf.write("\3\2\2\2\u0313\u0314\t\r\2\2\u0314\u0315\7\3\2\2\u0315") + buf.write("\u0318\5\b\5\2\u0316\u0317\7\23\2\2\u0317\u0319\5\u00cc") + buf.write("g\2\u0318\u0316\3\2\2\2\u0318\u0319\3\2\2\2\u0319\u031a") + buf.write("\3\2\2\2\u031a\u031b\7\4\2\2\u031b\u0324\3\2\2\2\u031c") + buf.write("\u031d\t\16\2\2\u031d\u031e\7\3\2\2\u031e\u031f\5\b\5") + buf.write("\2\u031f\u0320\7\23\2\2\u0320\u0321\5\b\5\2\u0321\u0322") + buf.write("\7\4\2\2\u0322\u0324\3\2\2\2\u0323\u030e\3\2\2\2\u0323") + buf.write("\u0313\3\2\2\2\u0323\u031c\3\2\2\2\u0324\63\3\2\2\2\u0325") + buf.write("\u0326\7\65\2\2\u0326\u0327\7\3\2\2\u0327\u0328\5\6\4") + buf.write("\2\u0328\u0329\7\23\2\2\u0329\u032a\5\6\4\2\u032a\u032b") + buf.write("\7\23\2\2\u032b\u032c\5\6\4\2\u032c\u032d\7\4\2\2\u032d") + buf.write("\u0346\3\2\2\2\u032e\u032f\7q\2\2\u032f\u0330\7\3\2\2") + buf.write("\u0330\u0331\5\6\4\2\u0331\u0332\7\23\2\2\u0332\u0333") + buf.write("\5\6\4\2\u0333\u0334\7\4\2\2\u0334\u0346\3\2\2\2\u0335") + buf.write("\u0336\79\2\2\u0336\u0337\7\3\2\2\u0337\u0338\5\6\4\2") + buf.write("\u0338\u0339\7\4\2\2\u0339\u0346\3\2\2\2\u033a\u033b\7") + buf.write("E\2\2\u033b\u033c\7\3\2\2\u033c\u033d\5\6\4\2\u033d\u033e") + buf.write("\7\23\2\2\u033e\u0341\5\6\4\2\u033f\u0340\7\23\2\2\u0340") + buf.write("\u0342\5\u00dco\2\u0341\u033f\3\2\2\2\u0341\u0342\3\2") + buf.write("\2\2\u0342\u0343\3\2\2\2\u0343\u0344\7\4\2\2\u0344\u0346") + buf.write("\3\2\2\2\u0345\u0325\3\2\2\2\u0345\u032e\3\2\2\2\u0345") + buf.write("\u0335\3\2\2\2\u0345\u033a\3\2\2\2\u0346\65\3\2\2\2\u0347") + buf.write("\u0348\7\65\2\2\u0348\u0349\7\3\2\2\u0349\u034a\5\b\5") + buf.write("\2\u034a\u034b\7\23\2\2\u034b\u034c\5\b\5\2\u034c\u034d") + buf.write("\7\23\2\2\u034d\u034e\5\b\5\2\u034e\u034f\7\4\2\2\u034f") + buf.write("\u035d\3\2\2\2\u0350\u0351\7q\2\2\u0351\u0352\7\3\2\2") + buf.write("\u0352\u0353\5\b\5\2\u0353\u0354\7\23\2\2\u0354\u0355") + buf.write("\5\b\5\2\u0355\u0356\7\4\2\2\u0356\u035d\3\2\2\2\u0357") + buf.write("\u0358\79\2\2\u0358\u0359\7\3\2\2\u0359\u035a\5\b\5\2") + buf.write("\u035a\u035b\7\4\2\2\u035b\u035d\3\2\2\2\u035c\u0347\3") + buf.write("\2\2\2\u035c\u0350\3\2\2\2\u035c\u0357\3\2\2\2\u035d\67") + buf.write("\3\2\2\2\u035e\u035f\7\u00d2\2\2\u035f\u0361\7\3\2\2\u0360") + buf.write("\u0362\5\6\4\2\u0361\u0360\3\2\2\2\u0361\u0362\3\2\2\2") + buf.write("\u0362\u0363\3\2\2\2\u0363\u03c5\7\4\2\2\u0364\u0365\7") + buf.write("\u00a3\2\2\u0365\u0366\7\3\2\2\u0366\u0369\5\6\4\2\u0367") + buf.write("\u0368\7\23\2\2\u0368\u036a\t\17\2\2\u0369\u0367\3\2\2") + buf.write("\2\u0369\u036a\3\2\2\2\u036a\u036b\3\2\2\2\u036b\u036c") + buf.write("\7\4\2\2\u036c\u03c5\3\2\2\2\u036d\u036e\t\20\2\2\u036e") + buf.write("\u036f\7\3\2\2\u036f\u0370\5\6\4\2\u0370\u0371\7\4\2\2") + buf.write("\u0371\u03c5\3\2\2\2\u0372\u0373\7\u00a6\2\2\u0373\u0374") + buf.write("\7\3\2\2\u0374\u0375\5\6\4\2\u0375\u0376\7\23\2\2\u0376") + buf.write("\u0377\5l\67\2\u0377\u0378\7\4\2\2\u0378\u03c5\3\2\2\2") + buf.write("\u0379\u037a\7\u00d5\2\2\u037a\u037b\7\3\2\2\u037b\u037e") + buf.write("\7\u00f6\2\2\u037c\u037d\7\23\2\2\u037d\u037f\t\21\2\2") + buf.write("\u037e\u037c\3\2\2\2\u037e\u037f\3\2\2\2\u037f\u0382\3") + buf.write("\2\2\2\u0380\u0381\7\23\2\2\u0381\u0383\5\u00caf\2\u0382") + buf.write("\u0380\3\2\2\2\u0382\u0383\3\2\2\2\u0383\u0386\3\2\2\2") + buf.write("\u0384\u0385\7\23\2\2\u0385\u0387\t\22\2\2\u0386\u0384") + buf.write("\3\2\2\2\u0386\u0387\3\2\2\2\u0387\u0388\3\2\2\2\u0388") + buf.write("\u03c5\7\4\2\2\u0389\u038a\7\37\2\2\u038a\u038b\7\3\2") + buf.write("\2\u038b\u03c5\7\4\2\2\u038c\u038d\7 \2\2\u038d\u038e") + buf.write("\7\3\2\2\u038e\u038f\5\6\4\2\u038f\u0390\7\23\2\2\u0390") + buf.write("\u0391\5\6\4\2\u0391\u0392\7\4\2\2\u0392\u03c5\3\2\2\2") + buf.write("\u0393\u0394\7!\2\2\u0394\u0395\7\3\2\2\u0395\u0396\5") + buf.write("\6\4\2\u0396\u0397\7\23\2\2\u0397\u0398\5\6\4\2\u0398") + buf.write("\u0399\7\23\2\2\u0399\u039a\5\6\4\2\u039a\u039b\7\4\2") + buf.write("\2\u039b\u03c5\3\2\2\2\u039c\u039d\7\"\2\2\u039d\u039e") + buf.write("\7\3\2\2\u039e\u039f\5\6\4\2\u039f\u03a0\7\4\2\2\u03a0") + buf.write("\u03c5\3\2\2\2\u03a1\u03a2\7#\2\2\u03a2\u03a3\7\3\2\2") + buf.write("\u03a3\u03a4\5\6\4\2\u03a4\u03a5\7\4\2\2\u03a5\u03c5\3") + buf.write("\2\2\2\u03a6\u03a7\7$\2\2\u03a7\u03a8\7\3\2\2\u03a8\u03a9") + buf.write("\5\6\4\2\u03a9\u03aa\7\4\2\2\u03aa\u03c5\3\2\2\2\u03ab") + buf.write("\u03ac\7%\2\2\u03ac\u03ad\7\3\2\2\u03ad\u03ae\5\6\4\2") + buf.write("\u03ae\u03af\7\4\2\2\u03af\u03c5\3\2\2\2\u03b0\u03b1\7") + buf.write("&\2\2\u03b1\u03b2\7\3\2\2\u03b2\u03b3\5\6\4\2\u03b3\u03b4") + buf.write("\7\4\2\2\u03b4\u03c5\3\2\2\2\u03b5\u03b6\7\'\2\2\u03b6") + buf.write("\u03b7\7\3\2\2\u03b7\u03b8\5\6\4\2\u03b8\u03b9\7\4\2\2") + buf.write("\u03b9\u03c5\3\2\2\2\u03ba\u03bb\7(\2\2\u03bb\u03bc\7") + buf.write("\3\2\2\u03bc\u03bd\5\6\4\2\u03bd\u03be\7\4\2\2\u03be\u03c5") + buf.write("\3\2\2\2\u03bf\u03c0\7)\2\2\u03c0\u03c1\7\3\2\2\u03c1") + buf.write("\u03c2\5\6\4\2\u03c2\u03c3\7\4\2\2\u03c3\u03c5\3\2\2\2") + buf.write("\u03c4\u035e\3\2\2\2\u03c4\u0364\3\2\2\2\u03c4\u036d\3") + buf.write("\2\2\2\u03c4\u0372\3\2\2\2\u03c4\u0379\3\2\2\2\u03c4\u0389") + buf.write("\3\2\2\2\u03c4\u038c\3\2\2\2\u03c4\u0393\3\2\2\2\u03c4") + buf.write("\u039c\3\2\2\2\u03c4\u03a1\3\2\2\2\u03c4\u03a6\3\2\2\2") + buf.write("\u03c4\u03ab\3\2\2\2\u03c4\u03b0\3\2\2\2\u03c4\u03b5\3") + buf.write("\2\2\2\u03c4\u03ba\3\2\2\2\u03c4\u03bf\3\2\2\2\u03c59") + buf.write("\3\2\2\2\u03c6\u03c7\7\u00d2\2\2\u03c7\u03c9\7\3\2\2\u03c8") + buf.write("\u03ca\5\b\5\2\u03c9\u03c8\3\2\2\2\u03c9\u03ca\3\2\2\2") + buf.write("\u03ca\u03cb\3\2\2\2\u03cb\u042d\7\4\2\2\u03cc\u03cd\7") + buf.write("\u00a3\2\2\u03cd\u03ce\7\3\2\2\u03ce\u03d1\5\b\5\2\u03cf") + buf.write("\u03d0\7\23\2\2\u03d0\u03d2\t\17\2\2\u03d1\u03cf\3\2\2") + buf.write("\2\u03d1\u03d2\3\2\2\2\u03d2\u03d3\3\2\2\2\u03d3\u03d4") + buf.write("\7\4\2\2\u03d4\u042d\3\2\2\2\u03d5\u03d6\t\20\2\2\u03d6") + buf.write("\u03d7\7\3\2\2\u03d7\u03d8\5\b\5\2\u03d8\u03d9\7\4\2\2") + buf.write("\u03d9\u042d\3\2\2\2\u03da\u03db\7\u00a6\2\2\u03db\u03dc") + buf.write("\7\3\2\2\u03dc\u03dd\5\b\5\2\u03dd\u03de\7\23\2\2\u03de") + buf.write("\u03df\5l\67\2\u03df\u03e0\7\4\2\2\u03e0\u042d\3\2\2\2") + buf.write("\u03e1\u03e2\7\u00d5\2\2\u03e2\u03e3\7\3\2\2\u03e3\u03e6") + buf.write("\7\u00f6\2\2\u03e4\u03e5\7\23\2\2\u03e5\u03e7\t\21\2\2") + buf.write("\u03e6\u03e4\3\2\2\2\u03e6\u03e7\3\2\2\2\u03e7\u03ea\3") + buf.write("\2\2\2\u03e8\u03e9\7\23\2\2\u03e9\u03eb\5\u00ccg\2\u03ea") + buf.write("\u03e8\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ee\3\2\2\2") + buf.write("\u03ec\u03ed\7\23\2\2\u03ed\u03ef\t\22\2\2\u03ee\u03ec") + buf.write("\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f0\3\2\2\2\u03f0") + buf.write("\u042d\7\4\2\2\u03f1\u03f2\7\37\2\2\u03f2\u03f3\7\3\2") + buf.write("\2\u03f3\u042d\7\4\2\2\u03f4\u03f5\7 \2\2\u03f5\u03f6") + buf.write("\7\3\2\2\u03f6\u03f7\5\b\5\2\u03f7\u03f8\7\23\2\2\u03f8") + buf.write("\u03f9\5\b\5\2\u03f9\u03fa\7\4\2\2\u03fa\u042d\3\2\2\2") + buf.write("\u03fb\u03fc\7!\2\2\u03fc\u03fd\7\3\2\2\u03fd\u03fe\5") + buf.write("\b\5\2\u03fe\u03ff\7\23\2\2\u03ff\u0400\5\b\5\2\u0400") + buf.write("\u0401\7\23\2\2\u0401\u0402\5\b\5\2\u0402\u0403\7\4\2") + buf.write("\2\u0403\u042d\3\2\2\2\u0404\u0405\7\"\2\2\u0405\u0406") + buf.write("\7\3\2\2\u0406\u0407\5\b\5\2\u0407\u0408\7\4\2\2\u0408") + buf.write("\u042d\3\2\2\2\u0409\u040a\7#\2\2\u040a\u040b\7\3\2\2") + buf.write("\u040b\u040c\5\b\5\2\u040c\u040d\7\4\2\2\u040d\u042d\3") + buf.write("\2\2\2\u040e\u040f\7$\2\2\u040f\u0410\7\3\2\2\u0410\u0411") + buf.write("\5\b\5\2\u0411\u0412\7\4\2\2\u0412\u042d\3\2\2\2\u0413") + buf.write("\u0414\7%\2\2\u0414\u0415\7\3\2\2\u0415\u0416\5\b\5\2") + buf.write("\u0416\u0417\7\4\2\2\u0417\u042d\3\2\2\2\u0418\u0419\7") + buf.write("&\2\2\u0419\u041a\7\3\2\2\u041a\u041b\5\b\5\2\u041b\u041c") + buf.write("\7\4\2\2\u041c\u042d\3\2\2\2\u041d\u041e\7\'\2\2\u041e") + buf.write("\u041f\7\3\2\2\u041f\u0420\5\b\5\2\u0420\u0421\7\4\2\2") + buf.write("\u0421\u042d\3\2\2\2\u0422\u0423\7(\2\2\u0423\u0424\7") + buf.write("\3\2\2\u0424\u0425\5\b\5\2\u0425\u0426\7\4\2\2\u0426\u042d") + buf.write("\3\2\2\2\u0427\u0428\7)\2\2\u0428\u0429\7\3\2\2\u0429") + buf.write("\u042a\5\b\5\2\u042a\u042b\7\4\2\2\u042b\u042d\3\2\2\2") + buf.write("\u042c\u03c6\3\2\2\2\u042c\u03cc\3\2\2\2\u042c\u03d5\3") + buf.write("\2\2\2\u042c\u03da\3\2\2\2\u042c\u03e1\3\2\2\2\u042c\u03f1") + buf.write("\3\2\2\2\u042c\u03f4\3\2\2\2\u042c\u03fb\3\2\2\2\u042c") + buf.write("\u0404\3\2\2\2\u042c\u0409\3\2\2\2\u042c\u040e\3\2\2\2") + buf.write("\u042c\u0413\3\2\2\2\u042c\u0418\3\2\2\2\u042c\u041d\3") + buf.write("\2\2\2\u042c\u0422\3\2\2\2\u042c\u0427\3\2\2\2\u042d;") + buf.write("\3\2\2\2\u042e\u042f\7;\2\2\u042f\u0430\7\3\2\2\u0430") + buf.write("\u0433\5\6\4\2\u0431\u0432\7\23\2\2\u0432\u0434\5\6\4") + buf.write("\2\u0433\u0431\3\2\2\2\u0434\u0435\3\2\2\2\u0435\u0433") + buf.write("\3\2\2\2\u0435\u0436\3\2\2\2\u0436\u0437\3\2\2\2\u0437") + buf.write("\u0438\7\4\2\2\u0438\u044c\3\2\2\2\u0439\u043a\7>\2\2") + buf.write("\u043a\u043b\7\3\2\2\u043b\u043e\5\6\4\2\u043c\u043d\7") + buf.write("\23\2\2\u043d\u043f\5\6\4\2\u043e\u043c\3\2\2\2\u043f") + buf.write("\u0440\3\2\2\2\u0440\u043e\3\2\2\2\u0440\u0441\3\2\2\2") + buf.write("\u0441\u0442\3\2\2\2\u0442\u0443\7\4\2\2\u0443\u044c\3") + buf.write("\2\2\2\u0444\u0445\t\23\2\2\u0445\u0446\7\3\2\2\u0446") + buf.write("\u0447\5\6\4\2\u0447\u0448\7\23\2\2\u0448\u0449\5\6\4") + buf.write("\2\u0449\u044a\7\4\2\2\u044a\u044c\3\2\2\2\u044b\u042e") + buf.write("\3\2\2\2\u044b\u0439\3\2\2\2\u044b\u0444\3\2\2\2\u044c") + buf.write("=\3\2\2\2\u044d\u044e\7t\2\2\u044e\u044f\7\3\2\2\u044f") + buf.write("\u0450\5\6\4\2\u0450\u0451\7\23\2\2\u0451\u0453\7\u00f7") + buf.write("\2\2\u0452\u0454\5\u00b0Y\2\u0453\u0452\3\2\2\2\u0453") + buf.write("\u0454\3\2\2\2\u0454\u0457\3\2\2\2\u0455\u0456\7\u0082") + buf.write("\2\2\u0456\u0458\5\u00c0a\2\u0457\u0455\3\2\2\2\u0457") + buf.write("\u0458\3\2\2\2\u0458\u045a\3\2\2\2\u0459\u045b\5\u00ae") + buf.write("X\2\u045a\u0459\3\2\2\2\u045a\u045b\3\2\2\2\u045b\u045d") + buf.write("\3\2\2\2\u045c\u045e\5\u00b6\\\2\u045d\u045c\3\2\2\2\u045d") + buf.write("\u045e\3\2\2\2\u045e\u0460\3\2\2\2\u045f\u0461\5\u00b8") + buf.write("]\2\u0460\u045f\3\2\2\2\u0460\u0461\3\2\2\2\u0461\u0462") + buf.write("\3\2\2\2\u0462\u0463\7\4\2\2\u0463?\3\2\2\2\u0464\u0465") + buf.write("\7\u00e0\2\2\u0465\u0466\7\3\2\2\u0466\u0467\5\6\4\2\u0467") + buf.write("\u0468\7\23\2\2\u0468\u0472\7\u00f7\2\2\u0469\u046a\7") + buf.write("\u00e9\2\2\u046a\u046f\5\u00c0a\2\u046b\u046c\7\23\2\2") + buf.write("\u046c\u046e\5\u00c0a\2\u046d\u046b\3\2\2\2\u046e\u0471") + buf.write("\3\2\2\2\u046f\u046d\3\2\2\2\u046f\u0470\3\2\2\2\u0470") + buf.write("\u0473\3\2\2\2\u0471\u046f\3\2\2\2\u0472\u0469\3\2\2\2") + buf.write("\u0472\u0473\3\2\2\2\u0473\u0475\3\2\2\2\u0474\u0476\5") + buf.write("\u00acW\2\u0475\u0474\3\2\2\2\u0475\u0476\3\2\2\2\u0476") buf.write("\u0477\3\2\2\2\u0477\u0478\7\4\2\2\u0478\u04a2\3\2\2\2") buf.write("\u0479\u047a\7\u00e1\2\2\u047a\u047b\7\3\2\2\u047b\u047c") buf.write("\5\6\4\2\u047c\u047d\7\23\2\2\u047d\u047f\7\u00f7\2\2") @@ -731,223 +732,228 @@ def serializedATN(): buf.write("\u054b\7\26\2\2\u054b\u054c\5\b\5\2\u054cU\3\2\2\2\u054d") buf.write("\u054e\5\u00c0a\2\u054e\u0551\7\t\2\2\u054f\u0552\5X-") buf.write("\2\u0550\u0552\5\u00bc_\2\u0551\u054f\3\2\2\2\u0551\u0550") - buf.write("\3\2\2\2\u0552W\3\2\2\2\u0553\u0560\5\u00d8m\2\u0554\u0555") + buf.write("\3\2\2\2\u0552W\3\2\2\2\u0553\u056b\5\u00d8m\2\u0554\u0555") buf.write("\7\u00dc\2\2\u0555\u0556\7\3\2\2\u0556\u0557\5\u00d8m") buf.write("\2\u0557\u0558\7\23\2\2\u0558\u055b\5\u00dan\2\u0559\u055a") buf.write("\7\23\2\2\u055a\u055c\7\u00f6\2\2\u055b\u0559\3\2\2\2") buf.write("\u055b\u055c\3\2\2\2\u055c\u055d\3\2\2\2\u055d\u055e\7") - buf.write("\4\2\2\u055e\u0560\3\2\2\2\u055f\u0553\3\2\2\2\u055f\u0554") - buf.write("\3\2\2\2\u0560Y\3\2\2\2\u0561\u0566\5^\60\2\u0562\u0563") - buf.write("\7\23\2\2\u0563\u0565\5^\60\2\u0564\u0562\3\2\2\2\u0565") - buf.write("\u0568\3\2\2\2\u0566\u0564\3\2\2\2\u0566\u0567\3\2\2\2") - buf.write("\u0567[\3\2\2\2\u0568\u0566\3\2\2\2\u0569\u056e\5^\60") - buf.write("\2\u056a\u056b\7\23\2\2\u056b\u056d\5^\60\2\u056c\u056a") - buf.write("\3\2\2\2\u056d\u0570\3\2\2\2\u056e\u056c\3\2\2\2\u056e") - buf.write("\u056f\3\2\2\2\u056f\u057a\3\2\2\2\u0570\u056e\3\2\2\2") - buf.write("\u0571\u0572\7\35\2\2\u0572\u0577\5\u00c0a\2\u0573\u0574") - buf.write("\7\23\2\2\u0574\u0576\5\u00c0a\2\u0575\u0573\3\2\2\2\u0576") - buf.write("\u0579\3\2\2\2\u0577\u0575\3\2\2\2\u0577\u0578\3\2\2\2") - buf.write("\u0578\u057b\3\2\2\2\u0579\u0577\3\2\2\2\u057a\u0571\3") - buf.write("\2\2\2\u057a\u057b\3\2\2\2\u057b]\3\2\2\2\u057c\u057f") - buf.write("\5\6\4\2\u057d\u057e\7\60\2\2\u057e\u0580\5\u00ba^\2\u057f") - buf.write("\u057d\3\2\2\2\u057f\u0580\3\2\2\2\u0580_\3\2\2\2\u0581") - buf.write("\u0583\5\24\13\2\u0582\u0581\3\2\2\2\u0582\u0583\3\2\2") - buf.write("\2\u0583\u0587\3\2\2\2\u0584\u0588\5\26\f\2\u0585\u0588") - buf.write("\5b\62\2\u0586\u0588\5\22\n\2\u0587\u0584\3\2\2\2\u0587") - buf.write("\u0585\3\2\2\2\u0587\u0586\3\2\2\2\u0587\u0588\3\2\2\2") - buf.write("\u0588\u058a\3\2\2\2\u0589\u058b\5\30\r\2\u058a\u0589") - buf.write("\3\2\2\2\u058a\u058b\3\2\2\2\u058b\u058d\3\2\2\2\u058c") - buf.write("\u058e\5\20\t\2\u058d\u058c\3\2\2\2\u058d\u058e\3\2\2") - buf.write("\2\u058ea\3\2\2\2\u058f\u0590\7\u00d0\2\2\u0590\u0591") - buf.write("\5\6\4\2\u0591c\3\2\2\2\u0592\u0593\7\u009e\2\2\u0593") - buf.write("\u0594\7N\2\2\u0594\u0599\5\u00c0a\2\u0595\u0596\7\23") - buf.write("\2\2\u0596\u0598\5\u00c0a\2\u0597\u0595\3\2\2\2\u0598") - buf.write("\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2") - buf.write("\u059ae\3\2\2\2\u059b\u0599\3\2\2\2\u059c\u059d\7M\2\2") - buf.write("\u059d\u059e\7N\2\2\u059e\u05a3\5h\65\2\u059f\u05a0\7") - buf.write("\23\2\2\u05a0\u05a2\5h\65\2\u05a1\u059f\3\2\2\2\u05a2") - buf.write("\u05a5\3\2\2\2\u05a3\u05a1\3\2\2\2\u05a3\u05a4\3\2\2\2") - buf.write("\u05a4g\3\2\2\2\u05a5\u05a3\3\2\2\2\u05a6\u05a8\5\u00c0") - buf.write("a\2\u05a7\u05a9\t\30\2\2\u05a8\u05a7\3\2\2\2\u05a8\u05a9") - buf.write("\3\2\2\2\u05a9i\3\2\2\2\u05aa\u05ab\7y\2\2\u05ab\u05ae") - buf.write("\7\u00be\2\2\u05ac\u05ae\7\u00a0\2\2\u05ad\u05aa\3\2\2") - buf.write("\2\u05ad\u05ac\3\2\2\2\u05ae\u05af\3\2\2\2\u05af\u05b0") - buf.write("\7\65\2\2\u05b0\u05b1\5n8\2\u05b1\u05b2\7\61\2\2\u05b2") - buf.write("\u05b3\5n8\2\u05b3k\3\2\2\2\u05b4\u05b5\7\u00f3\2\2\u05b5") - buf.write("m\3\2\2\2\u05b6\u05b7\7\u00f3\2\2\u05b7\u05c2\7\u009b") - buf.write("\2\2\u05b8\u05b9\7\u00f3\2\2\u05b9\u05c2\7\u009c\2\2\u05ba") - buf.write("\u05bb\7\u00a1\2\2\u05bb\u05bc\7y\2\2\u05bc\u05c2\7\u00bf") - buf.write("\2\2\u05bd\u05be\7\u009d\2\2\u05be\u05c2\7\u009b\2\2\u05bf") - buf.write("\u05c0\7\u009d\2\2\u05c0\u05c2\7\u009c\2\2\u05c1\u05b6") - buf.write("\3\2\2\2\u05c1\u05b8\3\2\2\2\u05c1\u05ba\3\2\2\2\u05c1") - buf.write("\u05bd\3\2\2\2\u05c1\u05bf\3\2\2\2\u05c2o\3\2\2\2\u05c3") - buf.write("\u05c4\7\u0092\2\2\u05c4\u05c5\t\31\2\2\u05c5\u05ca\5") - buf.write("\u00c0a\2\u05c6\u05c7\7\23\2\2\u05c7\u05c9\5\u00c0a\2") - buf.write("\u05c8\u05c6\3\2\2\2\u05c9\u05cc\3\2\2\2\u05ca\u05c8\3") - buf.write("\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05d1\3\2\2\2\u05cc\u05ca") - buf.write("\3\2\2\2\u05cd\u05ce\7\u0092\2\2\u05ce\u05cf\7J\2\2\u05cf") - buf.write("\u05d1\5\b\5\2\u05d0\u05c3\3\2\2\2\u05d0\u05cd\3\2\2\2") - buf.write("\u05d1q\3\2\2\2\u05d2\u05d3\7\u0094\2\2\u05d3\u05d4\5") - buf.write("\b\5\2\u05d4s\3\2\2\2\u05d5\u05d6\5\u00bc_\2\u05d6\u05d9") - buf.write("\5z>\2\u05d7\u05d8\7\u00df\2\2\u05d8\u05da\5X-\2\u05d9") - buf.write("\u05d7\3\2\2\2\u05d9\u05da\3\2\2\2\u05dau\3\2\2\2\u05db") - buf.write("\u05df\5~@\2\u05dc\u05df\5\u0082B\2\u05dd\u05df\5\u0080") - buf.write("A\2\u05de\u05db\3\2\2\2\u05de\u05dc\3\2\2\2\u05de\u05dd") - buf.write("\3\2\2\2\u05dfw\3\2\2\2\u05e0\u05e3\5\u0080A\2\u05e1\u05e3") - buf.write("\5~@\2\u05e2\u05e0\3\2\2\2\u05e2\u05e1\3\2\2\2\u05e3y") - buf.write("\3\2\2\2\u05e4\u05ea\5~@\2\u05e5\u05ea\5\u0082B\2\u05e6") - buf.write("\u05ea\5\u0086D\2\u05e7\u05ea\5|?\2\u05e8\u05ea\5\u0080") - buf.write("A\2\u05e9\u05e4\3\2\2\2\u05e9\u05e5\3\2\2\2\u05e9\u05e6") - buf.write("\3\2\2\2\u05e9\u05e7\3\2\2\2\u05e9\u05e8\3\2\2\2\u05ea") - buf.write("{\3\2\2\2\u05eb\u05ef\7\u0081\2\2\u05ec\u05ef\5\u0088") - buf.write("E\2\u05ed\u05ef\5\u008aF\2\u05ee\u05eb\3\2\2\2\u05ee\u05ec") - buf.write("\3\2\2\2\u05ee\u05ed\3\2\2\2\u05ef}\3\2\2\2\u05f0\u05f3") - buf.write("\5\u00dan\2\u05f1\u05f3\5\u008cG\2\u05f2\u05f0\3\2\2\2") - buf.write("\u05f2\u05f1\3\2\2\2\u05f3\u05f5\3\2\2\2\u05f4\u05f6\5") - buf.write("\u00a6T\2\u05f5\u05f4\3\2\2\2\u05f5\u05f6\3\2\2\2\u05f6") - buf.write("\u05fb\3\2\2\2\u05f7\u05f9\7\64\2\2\u05f8\u05f7\3\2\2") - buf.write("\2\u05f8\u05f9\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa\u05fc") - buf.write("\78\2\2\u05fb\u05f8\3\2\2\2\u05fb\u05fc\3\2\2\2\u05fc") - buf.write("\177\3\2\2\2\u05fd\u0602\5\u00ceh\2\u05fe\u05ff\7\n\2") - buf.write("\2\u05ff\u0600\5~@\2\u0600\u0601\7\13\2\2\u0601\u0603") - buf.write("\3\2\2\2\u0602\u05fe\3\2\2\2\u0602\u0603\3\2\2\2\u0603") - buf.write("\u0081\3\2\2\2\u0604\u0610\7{\2\2\u0605\u0606\7\7\2\2") - buf.write("\u0606\u060b\5\u00a8U\2\u0607\u0608\7\23\2\2\u0608\u060a") - buf.write("\5\u00a8U\2\u0609\u0607\3\2\2\2\u060a\u060d\3\2\2\2\u060b") - buf.write("\u0609\3\2\2\2\u060b\u060c\3\2\2\2\u060c\u060e\3\2\2\2") - buf.write("\u060d\u060b\3\2\2\2\u060e\u060f\7\b\2\2\u060f\u0611\3") - buf.write("\2\2\2\u0610\u0605\3\2\2\2\u0610\u0611\3\2\2\2\u0611\u0083") - buf.write("\3\2\2\2\u0612\u0615\5\u0082B\2\u0613\u0615\5~@\2\u0614") - buf.write("\u0612\3\2\2\2\u0614\u0613\3\2\2\2\u0615\u0085\3\2\2\2") - buf.write("\u0616\u061b\7\u00f1\2\2\u0617\u0618\7\n\2\2\u0618\u0619") - buf.write("\5~@\2\u0619\u061a\7\13\2\2\u061a\u061c\3\2\2\2\u061b") - buf.write("\u0617\3\2\2\2\u061b\u061c\3\2\2\2\u061c\u0087\3\2\2\2") - buf.write("\u061d\u063b\7\177\2\2\u061e\u062a\7\u00ed\2\2\u061f\u0620") - buf.write("\7\7\2\2\u0620\u0625\5\u008cG\2\u0621\u0622\7\21\2\2\u0622") - buf.write("\u0624\5\u008cG\2\u0623\u0621\3\2\2\2\u0624\u0627\3\2") - buf.write("\2\2\u0625\u0623\3\2\2\2\u0625\u0626\3\2\2\2\u0626\u0628") - buf.write("\3\2\2\2\u0627\u0625\3\2\2\2\u0628\u0629\7\b\2\2\u0629") - buf.write("\u062b\3\2\2\2\u062a\u061f\3\2\2\2\u062a\u062b\3\2\2\2") - buf.write("\u062b\u063b\3\2\2\2\u062c\u0638\7\u00ee\2\2\u062d\u062e") - buf.write("\7\7\2\2\u062e\u0633\5\u00bc_\2\u062f\u0630\7\21\2\2\u0630") - buf.write("\u0632\5\u00bc_\2\u0631\u062f\3\2\2\2\u0632\u0635\3\2") - buf.write("\2\2\u0633\u0631\3\2\2\2\u0633\u0634\3\2\2\2\u0634\u0636") - buf.write("\3\2\2\2\u0635\u0633\3\2\2\2\u0636\u0637\7\b\2\2\u0637") - buf.write("\u0639\3\2\2\2\u0638\u062d\3\2\2\2\u0638\u0639\3\2\2\2") - buf.write("\u0639\u063b\3\2\2\2\u063a\u061d\3\2\2\2\u063a\u061e\3") - buf.write("\2\2\2\u063a\u062c\3\2\2\2\u063b\u0089\3\2\2\2\u063c\u0665") - buf.write("\7\u0080\2\2\u063d\u064e\7\u00ef\2\2\u063e\u063f\7\7\2") - buf.write("\2\u063f\u064b\7\u00f7\2\2\u0640\u0641\7\3\2\2\u0641\u0646") - buf.write("\5\u008cG\2\u0642\u0643\7\21\2\2\u0643\u0645\5\u008cG") - buf.write("\2\u0644\u0642\3\2\2\2\u0645\u0648\3\2\2\2\u0646\u0644") - buf.write("\3\2\2\2\u0646\u0647\3\2\2\2\u0647\u0649\3\2\2\2\u0648") - buf.write("\u0646\3\2\2\2\u0649\u064a\7\4\2\2\u064a\u064c\3\2\2\2") - buf.write("\u064b\u0640\3\2\2\2\u064b\u064c\3\2\2\2\u064c\u064d\3") - buf.write("\2\2\2\u064d\u064f\7\b\2\2\u064e\u063e\3\2\2\2\u064e\u064f") - buf.write("\3\2\2\2\u064f\u0665\3\2\2\2\u0650\u0662\7\u00f0\2\2\u0651") - buf.write("\u0652\7\7\2\2\u0652\u065e\5\u00bc_\2\u0653\u0654\7\3") - buf.write("\2\2\u0654\u0659\5\u00bc_\2\u0655\u0656\7\21\2\2\u0656") - buf.write("\u0658\5\u00bc_\2\u0657\u0655\3\2\2\2\u0658\u065b\3\2") - buf.write("\2\2\u0659\u0657\3\2\2\2\u0659\u065a\3\2\2\2\u065a\u065c") - buf.write("\3\2\2\2\u065b\u0659\3\2\2\2\u065c\u065d\7\4\2\2\u065d") - buf.write("\u065f\3\2\2\2\u065e\u0653\3\2\2\2\u065e\u065f\3\2\2\2") - buf.write("\u065f\u0660\3\2\2\2\u0660\u0661\7\b\2\2\u0661\u0663\3") - buf.write("\2\2\2\u0662\u0651\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0665") - buf.write("\3\2\2\2\u0664\u063c\3\2\2\2\u0664\u063d\3\2\2\2\u0664") - buf.write("\u0650\3\2\2\2\u0665\u008b\3\2\2\2\u0666\u0667\7\u00f7") - buf.write("\2\2\u0667\u008d\3\2\2\2\u0668\u0669\7\u00f7\2\2\u0669") - buf.write("\u008f\3\2\2\2\u066a\u066b\t\32\2\2\u066b\u0670\5\u0092") - buf.write("J\2\u066c\u066d\7\23\2\2\u066d\u066f\5\u0092J\2\u066e") - buf.write("\u066c\3\2\2\2\u066f\u0672\3\2\2\2\u0670\u066e\3\2\2\2") - buf.write("\u0670\u0671\3\2\2\2\u0671\u0091\3\2\2\2\u0672\u0670\3") - buf.write("\2\2\2\u0673\u0676\5\u00bc_\2\u0674\u0675\7\60\2\2\u0675") - buf.write("\u0677\5\u00ba^\2\u0676\u0674\3\2\2\2\u0676\u0677\3\2") - buf.write("\2\2\u0677\u0093\3\2\2\2\u0678\u067d\5\u0096L\2\u0679") - buf.write("\u067a\7\u00f9\2\2\u067a\u067c\5\u0096L\2\u067b\u0679") - buf.write("\3\2\2\2\u067c\u067f\3\2\2\2\u067d\u067b\3\2\2\2\u067d") - buf.write("\u067e\3\2\2\2\u067e\u0095\3\2\2\2\u067f\u067d\3\2\2\2") - buf.write("\u0680\u0681\7\u00f7\2\2\u0681\u0683\7\25\2\2\u0682\u0680") - buf.write("\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u0688\3\2\2\2\u0684") - buf.write("\u0685\7\u00bb\2\2\u0685\u0686\5\b\5\2\u0686\u0687\7\33") - buf.write("\2\2\u0687\u0689\3\2\2\2\u0688\u0684\3\2\2\2\u0688\u0689") - buf.write("\3\2\2\2\u0689\u068a\3\2\2\2\u068a\u068c\5\b\5\2\u068b") - buf.write("\u068d\5\u00c4c\2\u068c\u068b\3\2\2\2\u068c\u068d\3\2") - buf.write("\2\2\u068d\u068f\3\2\2\2\u068e\u0690\5\u00c6d\2\u068f") - buf.write("\u068e\3\2\2\2\u068f\u0690\3\2\2\2\u0690\u0097\3\2\2\2") - buf.write("\u0691\u0696\5\u009aN\2\u0692\u0693\7\u00f9\2\2\u0693") - buf.write("\u0695\5\u009aN\2\u0694\u0692\3\2\2\2\u0695\u0698\3\2") - buf.write("\2\2\u0696\u0694\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u0099") - buf.write("\3\2\2\2\u0698\u0696\3\2\2\2\u0699\u069a\7\u00f7\2\2\u069a") - buf.write("\u069c\7\25\2\2\u069b\u0699\3\2\2\2\u069b\u069c\3\2\2") - buf.write("\2\u069c\u069d\3\2\2\2\u069d\u069f\5\u00a0Q\2\u069e\u06a0") - buf.write("\5\u00c4c\2\u069f\u069e\3\2\2\2\u069f\u06a0\3\2\2\2\u06a0") - buf.write("\u06a2\3\2\2\2\u06a1\u06a3\5\u00c6d\2\u06a2\u06a1\3\2") - buf.write("\2\2\u06a2\u06a3\3\2\2\2\u06a3\u009b\3\2\2\2\u06a4\u06a7") - buf.write("\t\32\2\2\u06a5\u06a6\7\u00a9\2\2\u06a6\u06a8\5\u009e") - buf.write("P\2\u06a7\u06a5\3\2\2\2\u06a7\u06a8\3\2\2\2\u06a8\u06a9") - buf.write("\3\2\2\2\u06a9\u06aa\7\u0082\2\2\u06aa\u06ab\7\u00f7\2") - buf.write("\2\u06ab\u009d\3\2\2\2\u06ac\u06b1\5\u0092J\2\u06ad\u06ae") - buf.write("\7\23\2\2\u06ae\u06b0\5\u0092J\2\u06af\u06ad\3\2\2\2\u06b0") - buf.write("\u06b3\3\2\2\2\u06b1\u06af\3\2\2\2\u06b1\u06b2\3\2\2\2") - buf.write("\u06b2\u009f\3\2\2\2\u06b3\u06b1\3\2\2\2\u06b4\u06b5\7") - buf.write("\u00bb\2\2\u06b5\u06b6\5\b\5\2\u06b6\u06b7\7\33\2\2\u06b7") - buf.write("\u06b9\3\2\2\2\u06b8\u06b4\3\2\2\2\u06b8\u06b9\3\2\2\2") - buf.write("\u06b9\u06ba\3\2\2\2\u06ba\u06bc\5\u00a4S\2\u06bb\u06bd") - buf.write("\5\u00c8e\2\u06bc\u06bb\3\2\2\2\u06bc\u06bd\3\2\2\2\u06bd") - buf.write("\u06be\3\2\2\2\u06be\u06c2\5\u00a2R\2\u06bf\u06c1\5\u00a2") - buf.write("R\2\u06c0\u06bf\3\2\2\2\u06c1\u06c4\3\2\2\2\u06c2\u06c0") - buf.write("\3\2\2\2\u06c2\u06c3\3\2\2\2\u06c3\u00a1\3\2\2\2\u06c4") - buf.write("\u06c2\3\2\2\2\u06c5\u06c7\t\33\2\2\u06c6\u06c5\3\2\2") - buf.write("\2\u06c6\u06c7\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cd") - buf.write("\5\u00a4S\2\u06c9\u06ca\7\5\2\2\u06ca\u06cb\5\b\5\2\u06cb") - buf.write("\u06cc\7\6\2\2\u06cc\u06ce\3\2\2\2\u06cd\u06c9\3\2\2\2") - buf.write("\u06cd\u06ce\3\2\2\2\u06ce\u00a3\3\2\2\2\u06cf\u06d0\t") - buf.write("\34\2\2\u06d0\u00a5\3\2\2\2\u06d1\u06d2\7\5\2\2\u06d2") - buf.write("\u06d3\5\b\5\2\u06d3\u06d4\7\6\2\2\u06d4\u06e1\3\2\2\2") - buf.write("\u06d5\u06d6\7\7\2\2\u06d6\u06db\5X-\2\u06d7\u06d8\7\23") - buf.write("\2\2\u06d8\u06da\5X-\2\u06d9\u06d7\3\2\2\2\u06da\u06dd") - buf.write("\3\2\2\2\u06db\u06d9\3\2\2\2\u06db\u06dc\3\2\2\2\u06dc") - buf.write("\u06de\3\2\2\2\u06dd\u06db\3\2\2\2\u06de\u06df\7\b\2\2") - buf.write("\u06df\u06e1\3\2\2\2\u06e0\u06d1\3\2\2\2\u06e0\u06d5\3") - buf.write("\2\2\2\u06e1\u00a7\3\2\2\2\u06e2\u06e5\5\u0080A\2\u06e3") - buf.write("\u06e6\5\u00c0a\2\u06e4\u06e6\5\u00aaV\2\u06e5\u06e3\3") - buf.write("\2\2\2\u06e5\u06e4\3\2\2\2\u06e6\u00a9\3\2\2\2\u06e7\u06e9") - buf.write("\7u\2\2\u06e8\u06ea\t\35\2\2\u06e9\u06e8\3\2\2\2\u06e9") - buf.write("\u06ea\3\2\2\2\u06ea\u00ab\3\2\2\2\u06eb\u06ec\t\36\2") - buf.write("\2\u06ec\u00ad\3\2\2\2\u06ed\u06ee\t\37\2\2\u06ee\u00af") - buf.write("\3\2\2\2\u06ef\u06f0\7\u00a9\2\2\u06f0\u06f5\5\u00c0a") - buf.write("\2\u06f1\u06f2\7\23\2\2\u06f2\u06f4\5\u00c0a\2\u06f3\u06f1") - buf.write("\3\2\2\2\u06f4\u06f7\3\2\2\2\u06f5\u06f3\3\2\2\2\u06f5") - buf.write("\u06f6\3\2\2\2\u06f6\u00b1\3\2\2\2\u06f7\u06f5\3\2\2\2") - buf.write("\u06f8\u06f9\t \2\2\u06f9\u00b3\3\2\2\2\u06fa\u06fb\7") - buf.write("H\2\2\u06fb\u06fc\5\6\4\2\u06fc\u00b5\3\2\2\2\u06fd\u06fe") - buf.write('\t!\2\2\u06fe\u00b7\3\2\2\2\u06ff\u0700\t"\2\2\u0700') - buf.write("\u00b9\3\2\2\2\u0701\u0702\7\u00f7\2\2\u0702\u00bb\3\2") - buf.write("\2\2\u0703\u0704\7\u00f7\2\2\u0704\u00bd\3\2\2\2\u0705") - buf.write("\u0706\7\u00f7\2\2\u0706\u00bf\3\2\2\2\u0707\u070a\7\u00f7") - buf.write("\2\2\u0708\u0709\7\27\2\2\u0709\u070b\7\u00f7\2\2\u070a") - buf.write("\u0708\3\2\2\2\u070a\u070b\3\2\2\2\u070b\u00c1\3\2\2\2") - buf.write("\u070c\u070d\7\7\2\2\u070d\u0712\5X-\2\u070e\u070f\7\23") - buf.write("\2\2\u070f\u0711\5X-\2\u0710\u070e\3\2\2\2\u0711\u0714") - buf.write("\3\2\2\2\u0712\u0710\3\2\2\2\u0712\u0713\3\2\2\2\u0713") - buf.write("\u0715\3\2\2\2\u0714\u0712\3\2\2\2\u0715\u0716\7\b\2\2") - buf.write("\u0716\u00c3\3\2\2\2\u0717\u0718\7I\2\2\u0718\u0719\5") - buf.write("\u00d8m\2\u0719\u00c5\3\2\2\2\u071a\u071b\7L\2\2\u071b") - buf.write("\u071c\5\u00d8m\2\u071c\u00c7\3\2\2\2\u071d\u071e\t#\2") - buf.write("\2\u071e\u00c9\3\2\2\2\u071f\u0722\5\6\4\2\u0720\u0722") - buf.write("\7u\2\2\u0721\u071f\3\2\2\2\u0721\u0720\3\2\2\2\u0722") - buf.write("\u00cb\3\2\2\2\u0723\u0726\5\b\5\2\u0724\u0726\7u\2\2") - buf.write("\u0725\u0723\3\2\2\2\u0725\u0724\3\2\2\2\u0726\u00cd\3") - buf.write("\2\2\2\u0727\u072d\7j\2\2\u0728\u072d\7\u00ec\2\2\u0729") - buf.write("\u072d\7i\2\2\u072a\u072d\7k\2\2\u072b\u072d\5\u00d0i") - buf.write("\2\u072c\u0727\3\2\2\2\u072c\u0728\3\2\2\2\u072c\u0729") - buf.write("\3\2\2\2\u072c\u072a\3\2\2\2\u072c\u072b\3\2\2\2\u072d") - buf.write("\u00cf\3\2\2\2\u072e\u072f\7p\2\2\u072f\u0730\7k\2\2\u0730") - buf.write("\u00d1\3\2\2\2\u0731\u0732\7\u00f7\2\2\u0732\u00d3\3\2") - buf.write("\2\2\u0733\u0734\7\u00f7\2\2\u0734\u00d5\3\2\2\2\u0735") - buf.write("\u0736\7\u00f7\2\2\u0736\u00d7\3\2\2\2\u0737\u0738\t$") - buf.write("\2\2\u0738\u00d9\3\2\2\2\u0739\u073a\t%\2\2\u073a\u00db") - buf.write("\3\2\2\2\u073b\u073c\t&\2\2\u073c\u00dd\3\2\2\2\u00c5") + buf.write("\4\2\2\u055e\u056b\3\2\2\2\u055f\u0560\7\u00dc\2\2\u0560") + buf.write("\u0561\7\3\2\2\u0561\u0562\5\u00bc_\2\u0562\u0563\7\23") + buf.write("\2\2\u0563\u0566\5\u00dan\2\u0564\u0565\7\23\2\2\u0565") + buf.write("\u0567\7\u00f6\2\2\u0566\u0564\3\2\2\2\u0566\u0567\3\2") + buf.write("\2\2\u0567\u0568\3\2\2\2\u0568\u0569\7\4\2\2\u0569\u056b") + buf.write("\3\2\2\2\u056a\u0553\3\2\2\2\u056a\u0554\3\2\2\2\u056a") + buf.write("\u055f\3\2\2\2\u056bY\3\2\2\2\u056c\u0571\5^\60\2\u056d") + buf.write("\u056e\7\23\2\2\u056e\u0570\5^\60\2\u056f\u056d\3\2\2") + buf.write("\2\u0570\u0573\3\2\2\2\u0571\u056f\3\2\2\2\u0571\u0572") + buf.write("\3\2\2\2\u0572[\3\2\2\2\u0573\u0571\3\2\2\2\u0574\u0579") + buf.write("\5^\60\2\u0575\u0576\7\23\2\2\u0576\u0578\5^\60\2\u0577") + buf.write("\u0575\3\2\2\2\u0578\u057b\3\2\2\2\u0579\u0577\3\2\2\2") + buf.write("\u0579\u057a\3\2\2\2\u057a\u0585\3\2\2\2\u057b\u0579\3") + buf.write("\2\2\2\u057c\u057d\7\35\2\2\u057d\u0582\5\u00c0a\2\u057e") + buf.write("\u057f\7\23\2\2\u057f\u0581\5\u00c0a\2\u0580\u057e\3\2") + buf.write("\2\2\u0581\u0584\3\2\2\2\u0582\u0580\3\2\2\2\u0582\u0583") + buf.write("\3\2\2\2\u0583\u0586\3\2\2\2\u0584\u0582\3\2\2\2\u0585") + buf.write("\u057c\3\2\2\2\u0585\u0586\3\2\2\2\u0586]\3\2\2\2\u0587") + buf.write("\u058a\5\6\4\2\u0588\u0589\7\60\2\2\u0589\u058b\5\u00ba") + buf.write("^\2\u058a\u0588\3\2\2\2\u058a\u058b\3\2\2\2\u058b_\3\2") + buf.write("\2\2\u058c\u058e\5\24\13\2\u058d\u058c\3\2\2\2\u058d\u058e") + buf.write("\3\2\2\2\u058e\u0592\3\2\2\2\u058f\u0593\5\26\f\2\u0590") + buf.write("\u0593\5b\62\2\u0591\u0593\5\22\n\2\u0592\u058f\3\2\2") + buf.write("\2\u0592\u0590\3\2\2\2\u0592\u0591\3\2\2\2\u0592\u0593") + buf.write("\3\2\2\2\u0593\u0595\3\2\2\2\u0594\u0596\5\30\r\2\u0595") + buf.write("\u0594\3\2\2\2\u0595\u0596\3\2\2\2\u0596\u0598\3\2\2\2") + buf.write("\u0597\u0599\5\20\t\2\u0598\u0597\3\2\2\2\u0598\u0599") + buf.write("\3\2\2\2\u0599a\3\2\2\2\u059a\u059b\7\u00d0\2\2\u059b") + buf.write("\u059c\5\6\4\2\u059cc\3\2\2\2\u059d\u059e\7\u009e\2\2") + buf.write("\u059e\u059f\7N\2\2\u059f\u05a4\5\u00c0a\2\u05a0\u05a1") + buf.write("\7\23\2\2\u05a1\u05a3\5\u00c0a\2\u05a2\u05a0\3\2\2\2\u05a3") + buf.write("\u05a6\3\2\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a5\3\2\2\2") + buf.write("\u05a5e\3\2\2\2\u05a6\u05a4\3\2\2\2\u05a7\u05a8\7M\2\2") + buf.write("\u05a8\u05a9\7N\2\2\u05a9\u05ae\5h\65\2\u05aa\u05ab\7") + buf.write("\23\2\2\u05ab\u05ad\5h\65\2\u05ac\u05aa\3\2\2\2\u05ad") + buf.write("\u05b0\3\2\2\2\u05ae\u05ac\3\2\2\2\u05ae\u05af\3\2\2\2") + buf.write("\u05afg\3\2\2\2\u05b0\u05ae\3\2\2\2\u05b1\u05b3\5\u00c0") + buf.write("a\2\u05b2\u05b4\t\30\2\2\u05b3\u05b2\3\2\2\2\u05b3\u05b4") + buf.write("\3\2\2\2\u05b4i\3\2\2\2\u05b5\u05b6\7y\2\2\u05b6\u05b9") + buf.write("\7\u00be\2\2\u05b7\u05b9\7\u00a0\2\2\u05b8\u05b5\3\2\2") + buf.write("\2\u05b8\u05b7\3\2\2\2\u05b9\u05ba\3\2\2\2\u05ba\u05bb") + buf.write("\7\65\2\2\u05bb\u05bc\5n8\2\u05bc\u05bd\7\61\2\2\u05bd") + buf.write("\u05be\5n8\2\u05bek\3\2\2\2\u05bf\u05c0\7\u00f3\2\2\u05c0") + buf.write("m\3\2\2\2\u05c1\u05c2\7\u00f3\2\2\u05c2\u05cd\7\u009b") + buf.write("\2\2\u05c3\u05c4\7\u00f3\2\2\u05c4\u05cd\7\u009c\2\2\u05c5") + buf.write("\u05c6\7\u00a1\2\2\u05c6\u05c7\7y\2\2\u05c7\u05cd\7\u00bf") + buf.write("\2\2\u05c8\u05c9\7\u009d\2\2\u05c9\u05cd\7\u009b\2\2\u05ca") + buf.write("\u05cb\7\u009d\2\2\u05cb\u05cd\7\u009c\2\2\u05cc\u05c1") + buf.write("\3\2\2\2\u05cc\u05c3\3\2\2\2\u05cc\u05c5\3\2\2\2\u05cc") + buf.write("\u05c8\3\2\2\2\u05cc\u05ca\3\2\2\2\u05cdo\3\2\2\2\u05ce") + buf.write("\u05cf\7\u0092\2\2\u05cf\u05d0\t\31\2\2\u05d0\u05d5\5") + buf.write("\u00c0a\2\u05d1\u05d2\7\23\2\2\u05d2\u05d4\5\u00c0a\2") + buf.write("\u05d3\u05d1\3\2\2\2\u05d4\u05d7\3\2\2\2\u05d5\u05d3\3") + buf.write("\2\2\2\u05d5\u05d6\3\2\2\2\u05d6\u05dc\3\2\2\2\u05d7\u05d5") + buf.write("\3\2\2\2\u05d8\u05d9\7\u0092\2\2\u05d9\u05da\7J\2\2\u05da") + buf.write("\u05dc\5\b\5\2\u05db\u05ce\3\2\2\2\u05db\u05d8\3\2\2\2") + buf.write("\u05dcq\3\2\2\2\u05dd\u05de\7\u0094\2\2\u05de\u05df\5") + buf.write("\b\5\2\u05dfs\3\2\2\2\u05e0\u05e1\5\u00bc_\2\u05e1\u05e4") + buf.write("\5z>\2\u05e2\u05e3\7\u00df\2\2\u05e3\u05e5\5X-\2\u05e4") + buf.write("\u05e2\3\2\2\2\u05e4\u05e5\3\2\2\2\u05e5u\3\2\2\2\u05e6") + buf.write("\u05ea\5~@\2\u05e7\u05ea\5\u0082B\2\u05e8\u05ea\5\u0080") + buf.write("A\2\u05e9\u05e6\3\2\2\2\u05e9\u05e7\3\2\2\2\u05e9\u05e8") + buf.write("\3\2\2\2\u05eaw\3\2\2\2\u05eb\u05ee\5\u0080A\2\u05ec\u05ee") + buf.write("\5~@\2\u05ed\u05eb\3\2\2\2\u05ed\u05ec\3\2\2\2\u05eey") + buf.write("\3\2\2\2\u05ef\u05f5\5~@\2\u05f0\u05f5\5\u0082B\2\u05f1") + buf.write("\u05f5\5\u0086D\2\u05f2\u05f5\5|?\2\u05f3\u05f5\5\u0080") + buf.write("A\2\u05f4\u05ef\3\2\2\2\u05f4\u05f0\3\2\2\2\u05f4\u05f1") + buf.write("\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f3\3\2\2\2\u05f5") + buf.write("{\3\2\2\2\u05f6\u05fa\7\u0081\2\2\u05f7\u05fa\5\u0088") + buf.write("E\2\u05f8\u05fa\5\u008aF\2\u05f9\u05f6\3\2\2\2\u05f9\u05f7") + buf.write("\3\2\2\2\u05f9\u05f8\3\2\2\2\u05fa}\3\2\2\2\u05fb\u05fe") + buf.write("\5\u00dan\2\u05fc\u05fe\5\u008cG\2\u05fd\u05fb\3\2\2\2") + buf.write("\u05fd\u05fc\3\2\2\2\u05fe\u0600\3\2\2\2\u05ff\u0601\5") + buf.write("\u00a6T\2\u0600\u05ff\3\2\2\2\u0600\u0601\3\2\2\2\u0601") + buf.write("\u0606\3\2\2\2\u0602\u0604\7\64\2\2\u0603\u0602\3\2\2") + buf.write("\2\u0603\u0604\3\2\2\2\u0604\u0605\3\2\2\2\u0605\u0607") + buf.write("\78\2\2\u0606\u0603\3\2\2\2\u0606\u0607\3\2\2\2\u0607") + buf.write("\177\3\2\2\2\u0608\u060d\5\u00ceh\2\u0609\u060a\7\n\2") + buf.write("\2\u060a\u060b\5~@\2\u060b\u060c\7\13\2\2\u060c\u060e") + buf.write("\3\2\2\2\u060d\u0609\3\2\2\2\u060d\u060e\3\2\2\2\u060e") + buf.write("\u0081\3\2\2\2\u060f\u061b\7{\2\2\u0610\u0611\7\7\2\2") + buf.write("\u0611\u0616\5\u00a8U\2\u0612\u0613\7\23\2\2\u0613\u0615") + buf.write("\5\u00a8U\2\u0614\u0612\3\2\2\2\u0615\u0618\3\2\2\2\u0616") + buf.write("\u0614\3\2\2\2\u0616\u0617\3\2\2\2\u0617\u0619\3\2\2\2") + buf.write("\u0618\u0616\3\2\2\2\u0619\u061a\7\b\2\2\u061a\u061c\3") + buf.write("\2\2\2\u061b\u0610\3\2\2\2\u061b\u061c\3\2\2\2\u061c\u0083") + buf.write("\3\2\2\2\u061d\u0620\5\u0082B\2\u061e\u0620\5~@\2\u061f") + buf.write("\u061d\3\2\2\2\u061f\u061e\3\2\2\2\u0620\u0085\3\2\2\2") + buf.write("\u0621\u0626\7\u00f1\2\2\u0622\u0623\7\n\2\2\u0623\u0624") + buf.write("\5~@\2\u0624\u0625\7\13\2\2\u0625\u0627\3\2\2\2\u0626") + buf.write("\u0622\3\2\2\2\u0626\u0627\3\2\2\2\u0627\u0087\3\2\2\2") + buf.write("\u0628\u0646\7\177\2\2\u0629\u0635\7\u00ed\2\2\u062a\u062b") + buf.write("\7\7\2\2\u062b\u0630\5\u008cG\2\u062c\u062d\7\21\2\2\u062d") + buf.write("\u062f\5\u008cG\2\u062e\u062c\3\2\2\2\u062f\u0632\3\2") + buf.write("\2\2\u0630\u062e\3\2\2\2\u0630\u0631\3\2\2\2\u0631\u0633") + buf.write("\3\2\2\2\u0632\u0630\3\2\2\2\u0633\u0634\7\b\2\2\u0634") + buf.write("\u0636\3\2\2\2\u0635\u062a\3\2\2\2\u0635\u0636\3\2\2\2") + buf.write("\u0636\u0646\3\2\2\2\u0637\u0643\7\u00ee\2\2\u0638\u0639") + buf.write("\7\7\2\2\u0639\u063e\5\u00bc_\2\u063a\u063b\7\21\2\2\u063b") + buf.write("\u063d\5\u00bc_\2\u063c\u063a\3\2\2\2\u063d\u0640\3\2") + buf.write("\2\2\u063e\u063c\3\2\2\2\u063e\u063f\3\2\2\2\u063f\u0641") + buf.write("\3\2\2\2\u0640\u063e\3\2\2\2\u0641\u0642\7\b\2\2\u0642") + buf.write("\u0644\3\2\2\2\u0643\u0638\3\2\2\2\u0643\u0644\3\2\2\2") + buf.write("\u0644\u0646\3\2\2\2\u0645\u0628\3\2\2\2\u0645\u0629\3") + buf.write("\2\2\2\u0645\u0637\3\2\2\2\u0646\u0089\3\2\2\2\u0647\u0670") + buf.write("\7\u0080\2\2\u0648\u0659\7\u00ef\2\2\u0649\u064a\7\7\2") + buf.write("\2\u064a\u0656\7\u00f7\2\2\u064b\u064c\7\3\2\2\u064c\u0651") + buf.write("\5\u008cG\2\u064d\u064e\7\21\2\2\u064e\u0650\5\u008cG") + buf.write("\2\u064f\u064d\3\2\2\2\u0650\u0653\3\2\2\2\u0651\u064f") + buf.write("\3\2\2\2\u0651\u0652\3\2\2\2\u0652\u0654\3\2\2\2\u0653") + buf.write("\u0651\3\2\2\2\u0654\u0655\7\4\2\2\u0655\u0657\3\2\2\2") + buf.write("\u0656\u064b\3\2\2\2\u0656\u0657\3\2\2\2\u0657\u0658\3") + buf.write("\2\2\2\u0658\u065a\7\b\2\2\u0659\u0649\3\2\2\2\u0659\u065a") + buf.write("\3\2\2\2\u065a\u0670\3\2\2\2\u065b\u066d\7\u00f0\2\2\u065c") + buf.write("\u065d\7\7\2\2\u065d\u0669\5\u00bc_\2\u065e\u065f\7\3") + buf.write("\2\2\u065f\u0664\5\u00bc_\2\u0660\u0661\7\21\2\2\u0661") + buf.write("\u0663\5\u00bc_\2\u0662\u0660\3\2\2\2\u0663\u0666\3\2") + buf.write("\2\2\u0664\u0662\3\2\2\2\u0664\u0665\3\2\2\2\u0665\u0667") + buf.write("\3\2\2\2\u0666\u0664\3\2\2\2\u0667\u0668\7\4\2\2\u0668") + buf.write("\u066a\3\2\2\2\u0669\u065e\3\2\2\2\u0669\u066a\3\2\2\2") + buf.write("\u066a\u066b\3\2\2\2\u066b\u066c\7\b\2\2\u066c\u066e\3") + buf.write("\2\2\2\u066d\u065c\3\2\2\2\u066d\u066e\3\2\2\2\u066e\u0670") + buf.write("\3\2\2\2\u066f\u0647\3\2\2\2\u066f\u0648\3\2\2\2\u066f") + buf.write("\u065b\3\2\2\2\u0670\u008b\3\2\2\2\u0671\u0672\7\u00f7") + buf.write("\2\2\u0672\u008d\3\2\2\2\u0673\u0674\7\u00f7\2\2\u0674") + buf.write("\u008f\3\2\2\2\u0675\u0676\t\32\2\2\u0676\u067b\5\u0092") + buf.write("J\2\u0677\u0678\7\23\2\2\u0678\u067a\5\u0092J\2\u0679") + buf.write("\u0677\3\2\2\2\u067a\u067d\3\2\2\2\u067b\u0679\3\2\2\2") + buf.write("\u067b\u067c\3\2\2\2\u067c\u0091\3\2\2\2\u067d\u067b\3") + buf.write("\2\2\2\u067e\u0681\5\u00bc_\2\u067f\u0680\7\60\2\2\u0680") + buf.write("\u0682\5\u00ba^\2\u0681\u067f\3\2\2\2\u0681\u0682\3\2") + buf.write("\2\2\u0682\u0093\3\2\2\2\u0683\u0688\5\u0096L\2\u0684") + buf.write("\u0685\7\u00f9\2\2\u0685\u0687\5\u0096L\2\u0686\u0684") + buf.write("\3\2\2\2\u0687\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688") + buf.write("\u0689\3\2\2\2\u0689\u0095\3\2\2\2\u068a\u0688\3\2\2\2") + buf.write("\u068b\u068c\7\u00f7\2\2\u068c\u068e\7\25\2\2\u068d\u068b") + buf.write("\3\2\2\2\u068d\u068e\3\2\2\2\u068e\u0693\3\2\2\2\u068f") + buf.write("\u0690\7\u00bb\2\2\u0690\u0691\5\b\5\2\u0691\u0692\7\33") + buf.write("\2\2\u0692\u0694\3\2\2\2\u0693\u068f\3\2\2\2\u0693\u0694") + buf.write("\3\2\2\2\u0694\u0695\3\2\2\2\u0695\u0697\5\b\5\2\u0696") + buf.write("\u0698\5\u00c4c\2\u0697\u0696\3\2\2\2\u0697\u0698\3\2") + buf.write("\2\2\u0698\u069a\3\2\2\2\u0699\u069b\5\u00c6d\2\u069a") + buf.write("\u0699\3\2\2\2\u069a\u069b\3\2\2\2\u069b\u0097\3\2\2\2") + buf.write("\u069c\u06a1\5\u009aN\2\u069d\u069e\7\u00f9\2\2\u069e") + buf.write("\u06a0\5\u009aN\2\u069f\u069d\3\2\2\2\u06a0\u06a3\3\2") + buf.write("\2\2\u06a1\u069f\3\2\2\2\u06a1\u06a2\3\2\2\2\u06a2\u0099") + buf.write("\3\2\2\2\u06a3\u06a1\3\2\2\2\u06a4\u06a5\7\u00f7\2\2\u06a5") + buf.write("\u06a7\7\25\2\2\u06a6\u06a4\3\2\2\2\u06a6\u06a7\3\2\2") + buf.write("\2\u06a7\u06a8\3\2\2\2\u06a8\u06aa\5\u00a0Q\2\u06a9\u06ab") + buf.write("\5\u00c4c\2\u06aa\u06a9\3\2\2\2\u06aa\u06ab\3\2\2\2\u06ab") + buf.write("\u06ad\3\2\2\2\u06ac\u06ae\5\u00c6d\2\u06ad\u06ac\3\2") + buf.write("\2\2\u06ad\u06ae\3\2\2\2\u06ae\u009b\3\2\2\2\u06af\u06b2") + buf.write("\t\32\2\2\u06b0\u06b1\7\u00a9\2\2\u06b1\u06b3\5\u009e") + buf.write("P\2\u06b2\u06b0\3\2\2\2\u06b2\u06b3\3\2\2\2\u06b3\u06b4") + buf.write("\3\2\2\2\u06b4\u06b5\7\u0082\2\2\u06b5\u06b6\7\u00f7\2") + buf.write("\2\u06b6\u009d\3\2\2\2\u06b7\u06bc\5\u0092J\2\u06b8\u06b9") + buf.write("\7\23\2\2\u06b9\u06bb\5\u0092J\2\u06ba\u06b8\3\2\2\2\u06bb") + buf.write("\u06be\3\2\2\2\u06bc\u06ba\3\2\2\2\u06bc\u06bd\3\2\2\2") + buf.write("\u06bd\u009f\3\2\2\2\u06be\u06bc\3\2\2\2\u06bf\u06c0\7") + buf.write("\u00bb\2\2\u06c0\u06c1\5\b\5\2\u06c1\u06c2\7\33\2\2\u06c2") + buf.write("\u06c4\3\2\2\2\u06c3\u06bf\3\2\2\2\u06c3\u06c4\3\2\2\2") + buf.write("\u06c4\u06c5\3\2\2\2\u06c5\u06c7\5\u00a4S\2\u06c6\u06c8") + buf.write("\5\u00c8e\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8") + buf.write("\u06c9\3\2\2\2\u06c9\u06cd\5\u00a2R\2\u06ca\u06cc\5\u00a2") + buf.write("R\2\u06cb\u06ca\3\2\2\2\u06cc\u06cf\3\2\2\2\u06cd\u06cb") + buf.write("\3\2\2\2\u06cd\u06ce\3\2\2\2\u06ce\u00a1\3\2\2\2\u06cf") + buf.write("\u06cd\3\2\2\2\u06d0\u06d2\t\33\2\2\u06d1\u06d0\3\2\2") + buf.write("\2\u06d1\u06d2\3\2\2\2\u06d2\u06d3\3\2\2\2\u06d3\u06d8") + buf.write("\5\u00a4S\2\u06d4\u06d5\7\5\2\2\u06d5\u06d6\5\b\5\2\u06d6") + buf.write("\u06d7\7\6\2\2\u06d7\u06d9\3\2\2\2\u06d8\u06d4\3\2\2\2") + buf.write("\u06d8\u06d9\3\2\2\2\u06d9\u00a3\3\2\2\2\u06da\u06db\t") + buf.write("\34\2\2\u06db\u00a5\3\2\2\2\u06dc\u06dd\7\5\2\2\u06dd") + buf.write("\u06de\5\b\5\2\u06de\u06df\7\6\2\2\u06df\u06ec\3\2\2\2") + buf.write("\u06e0\u06e1\7\7\2\2\u06e1\u06e6\5X-\2\u06e2\u06e3\7\23") + buf.write("\2\2\u06e3\u06e5\5X-\2\u06e4\u06e2\3\2\2\2\u06e5\u06e8") + buf.write("\3\2\2\2\u06e6\u06e4\3\2\2\2\u06e6\u06e7\3\2\2\2\u06e7") + buf.write("\u06e9\3\2\2\2\u06e8\u06e6\3\2\2\2\u06e9\u06ea\7\b\2\2") + buf.write("\u06ea\u06ec\3\2\2\2\u06eb\u06dc\3\2\2\2\u06eb\u06e0\3") + buf.write("\2\2\2\u06ec\u00a7\3\2\2\2\u06ed\u06f0\5\u0080A\2\u06ee") + buf.write("\u06f1\5\u00c0a\2\u06ef\u06f1\5\u00aaV\2\u06f0\u06ee\3") + buf.write("\2\2\2\u06f0\u06ef\3\2\2\2\u06f1\u00a9\3\2\2\2\u06f2\u06f4") + buf.write("\7u\2\2\u06f3\u06f5\t\35\2\2\u06f4\u06f3\3\2\2\2\u06f4") + buf.write("\u06f5\3\2\2\2\u06f5\u00ab\3\2\2\2\u06f6\u06f7\t\36\2") + buf.write("\2\u06f7\u00ad\3\2\2\2\u06f8\u06f9\t\37\2\2\u06f9\u00af") + buf.write("\3\2\2\2\u06fa\u06fb\7\u00a9\2\2\u06fb\u0700\5\u00c0a") + buf.write("\2\u06fc\u06fd\7\23\2\2\u06fd\u06ff\5\u00c0a\2\u06fe\u06fc") + buf.write("\3\2\2\2\u06ff\u0702\3\2\2\2\u0700\u06fe\3\2\2\2\u0700") + buf.write("\u0701\3\2\2\2\u0701\u00b1\3\2\2\2\u0702\u0700\3\2\2\2") + buf.write("\u0703\u0704\t \2\2\u0704\u00b3\3\2\2\2\u0705\u0706\7") + buf.write("H\2\2\u0706\u0707\5\6\4\2\u0707\u00b5\3\2\2\2\u0708\u0709") + buf.write("\t!\2\2\u0709\u00b7\3\2\2\2\u070a\u070b\t\"\2\2\u070b") + buf.write("\u00b9\3\2\2\2\u070c\u070d\7\u00f7\2\2\u070d\u00bb\3\2") + buf.write("\2\2\u070e\u070f\7\u00f7\2\2\u070f\u00bd\3\2\2\2\u0710") + buf.write("\u0711\7\u00f7\2\2\u0711\u00bf\3\2\2\2\u0712\u0715\7\u00f7") + buf.write("\2\2\u0713\u0714\7\27\2\2\u0714\u0716\7\u00f7\2\2\u0715") + buf.write("\u0713\3\2\2\2\u0715\u0716\3\2\2\2\u0716\u00c1\3\2\2\2") + buf.write("\u0717\u0718\7\7\2\2\u0718\u071d\5X-\2\u0719\u071a\7\23") + buf.write("\2\2\u071a\u071c\5X-\2\u071b\u0719\3\2\2\2\u071c\u071f") + buf.write("\3\2\2\2\u071d\u071b\3\2\2\2\u071d\u071e\3\2\2\2\u071e") + buf.write("\u0720\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0721\7\b\2\2") + buf.write("\u0721\u00c3\3\2\2\2\u0722\u0723\7I\2\2\u0723\u0724\5") + buf.write("\u00d8m\2\u0724\u00c5\3\2\2\2\u0725\u0726\7L\2\2\u0726") + buf.write("\u0727\5\u00d8m\2\u0727\u00c7\3\2\2\2\u0728\u0729\t#\2") + buf.write("\2\u0729\u00c9\3\2\2\2\u072a\u072d\5\6\4\2\u072b\u072d") + buf.write("\7u\2\2\u072c\u072a\3\2\2\2\u072c\u072b\3\2\2\2\u072d") + buf.write("\u00cb\3\2\2\2\u072e\u0731\5\b\5\2\u072f\u0731\7u\2\2") + buf.write("\u0730\u072e\3\2\2\2\u0730\u072f\3\2\2\2\u0731\u00cd\3") + buf.write("\2\2\2\u0732\u0738\7j\2\2\u0733\u0738\7\u00ec\2\2\u0734") + buf.write("\u0738\7i\2\2\u0735\u0738\7k\2\2\u0736\u0738\5\u00d0i") + buf.write("\2\u0737\u0732\3\2\2\2\u0737\u0733\3\2\2\2\u0737\u0734") + buf.write("\3\2\2\2\u0737\u0735\3\2\2\2\u0737\u0736\3\2\2\2\u0738") + buf.write("\u00cf\3\2\2\2\u0739\u073a\7p\2\2\u073a\u073b\7k\2\2\u073b") + buf.write("\u00d1\3\2\2\2\u073c\u073d\7\u00f7\2\2\u073d\u00d3\3\2") + buf.write("\2\2\u073e\u073f\7\u00f7\2\2\u073f\u00d5\3\2\2\2\u0740") + buf.write("\u0741\7\u00f7\2\2\u0741\u00d7\3\2\2\2\u0742\u0743\t$") + buf.write("\2\2\u0743\u00d9\3\2\2\2\u0744\u0745\t%\2\2\u0745\u00db") + buf.write("\3\2\2\2\u0746\u0747\t&\2\2\u0747\u00dd\3\2\2\2\u00c6") buf.write("\u00e3\u00f1\u010a\u0111\u012f\u0131\u0133\u014d\u0154") buf.write("\u016a\u016c\u016e\u0179\u0187\u0190\u0198\u019f\u01a1") buf.write("\u01ac\u01b5\u01c7\u01d0\u01df\u01ea\u01ed\u01f2\u0213") @@ -961,530 +967,132 @@ def serializedATN(): buf.write("\u0475\u047f\u0483\u0486\u0489\u048c\u0494\u0497\u049a") buf.write("\u049d\u04a1\u04b9\u04c0\u04c2\u04cc\u04cf\u04d2\u04de") buf.write("\u04e0\u04e5\u04f5\u04fd\u0500\u0503\u050e\u0510\u0515") - buf.write("\u0521\u0531\u053c\u0540\u0547\u0551\u055b\u055f\u0566") - buf.write("\u056e\u0577\u057a\u057f\u0582\u0587\u058a\u058d\u0599") - buf.write("\u05a3\u05a8\u05ad\u05c1\u05ca\u05d0\u05d9\u05de\u05e2") - buf.write("\u05e9\u05ee\u05f2\u05f5\u05f8\u05fb\u0602\u060b\u0610") - buf.write("\u0614\u061b\u0625\u062a\u0633\u0638\u063a\u0646\u064b") - buf.write("\u064e\u0659\u065e\u0662\u0664\u0670\u0676\u067d\u0682") - buf.write("\u0688\u068c\u068f\u0696\u069b\u069f\u06a2\u06a7\u06b1") - buf.write("\u06b8\u06bc\u06c2\u06c6\u06cd\u06db\u06e0\u06e5\u06e9") - buf.write("\u06f5\u070a\u0712\u0721\u0725\u072c") + buf.write("\u0521\u0531\u053c\u0540\u0547\u0551\u055b\u0566\u056a") + buf.write("\u0571\u0579\u0582\u0585\u058a\u058d\u0592\u0595\u0598") + buf.write("\u05a4\u05ae\u05b3\u05b8\u05cc\u05d5\u05db\u05e4\u05e9") + buf.write("\u05ed\u05f4\u05f9\u05fd\u0600\u0603\u0606\u060d\u0616") + buf.write("\u061b\u061f\u0626\u0630\u0635\u063e\u0643\u0645\u0651") + buf.write("\u0656\u0659\u0664\u0669\u066d\u066f\u067b\u0681\u0688") + buf.write("\u068d\u0693\u0697\u069a\u06a1\u06a6\u06aa\u06ad\u06b2") + buf.write("\u06bc\u06c3\u06c7\u06cd\u06d1\u06d8\u06e6\u06eb\u06f0") + buf.write("\u06f4\u0700\u0715\u071d\u072c\u0730\u0737") return buf.getvalue() class Parser(ANTLRParser): + grammarFileName = "Vtl.g4" atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] sharedContextCache = PredictionContextCache() - literalNames = [ - "", - "'('", - "')'", - "'['", - "']'", - "'{'", - "'}'", - "'='", - "'<'", - "'>'", - "'>='", - "'<>'", - "'<='", - "'+'", - "'-'", - "'*'", - "'/'", - "','", - "'->'", - "':'", - "':='", - "'#'", - "'eval'", - "'if'", - "'case'", - "'then'", - "'else'", - "'using'", - "'with'", - "'current_date'", - "'datediff'", - "'dateadd'", - "'year'", - "'month'", - "'dayofmonth'", - "'dayofyear'", - "'daytoyear'", - "'daytomonth'", - "'yeartoday'", - "'monthtoday'", - "'on'", - "'drop'", - "'keep'", - "'calc'", - "'attrcalc'", - "'rename'", - "'as'", - "'and'", - "'or'", - "'xor'", - "'not'", - "'between'", - "'in'", - "'not_in'", - "'null'", - "'isnull'", - "'ex'", - "'union'", - "'diff'", - "'symdiff'", - "'intersect'", - "'random'", - "'keys'", - "'intyear'", - "'intmonth'", - "'intday'", - "'check'", - "'exists_in'", - "'to'", - "'return'", - "'imbalance'", - "'errorcode'", - "'all'", - "'aggr'", - "'errorlevel'", - "'order'", - "'by'", - "'rank'", - "'asc'", - "'desc'", - "'min'", - "'max'", - "'first'", - "'last'", - "'indexof'", - "'abs'", - "'key'", - "'ln'", - "'log'", - "'trunc'", - "'round'", - "'power'", - "'mod'", - "'length'", - "'||'", - "'trim'", - "'upper'", - "'lower'", - "'substr'", - "'sum'", - "'avg'", - "'median'", - "'count'", - "'identifier'", - "'measure'", - "'attribute'", - "'filter'", - "'merge'", - "'exp'", - "'componentRole'", - "'viral'", - "'match_characters'", - "'type'", - "'nvl'", - "'hierarchy'", - "'_'", - "'invalid'", - "'valuedomain'", - "'variable'", - "'data'", - "'structure'", - "'dataset'", - "'operator'", - "'define'", - "'<-'", - "'datapoint'", - "'hierarchical'", - "'ruleset'", - "'rule'", - "'end'", - "'alterDataset'", - "'ltrim'", - "'rtrim'", - "'instr'", - "'replace'", - "'ceil'", - "'floor'", - "'sqrt'", - "'any'", - "'setdiff'", - "'stddev_pop'", - "'stddev_samp'", - "'var_pop'", - "'var_samp'", - "'group'", - "'except'", - "'having'", - "'first_value'", - "'last_value'", - "'lag'", - "'lead'", - "'ratio_to_report'", - "'over'", - "'preceding'", - "'following'", - "'unbounded'", - "'partition'", - "'rows'", - "'range'", - "'current'", - "'valid'", - "'fill_time_series'", - "'flow_to_stock'", - "'stock_to_flow'", - "'timeshift'", - "'measures'", - "'no_measures'", - "'condition'", - "'boolean'", - "'date'", - "'time_period'", - "'number'", - "'string'", - "'time'", - "'integer'", - "'float'", - "'list'", - "'record'", - "'restrict'", - "'yyyy'", - "'mm'", - "'dd'", - "'maxLength'", - "'regexp'", - "'is'", - "'when'", - "'from'", - "'aggregates'", - "'points'", - "'point'", - "'total'", - "'partial'", - "'always'", - "'inner_join'", - "'left_join'", - "'cross_join'", - "'full_join'", - "'maps_from'", - "'maps_to'", - "'map_to'", - "'map_from'", - "'returns'", - "'pivot'", - "'customPivot'", - "'unpivot'", - "'sub'", - "'apply'", - "'conditioned'", - "'period_indicator'", - "'single'", - "'duration'", - "'time_agg'", - "'unit'", - "'Value'", - "'valuedomains'", - "'variables'", - "'input'", - "'output'", - "'cast'", - "'rule_priority'", - "'dataset_priority'", - "'default'", - "'check_datapoint'", - "'check_hierarchy'", - "'computed'", - "'non_null'", - "'non_zero'", - "'partial_null'", - "'partial_zero'", - "'always_null'", - "'always_zero'", - "'components'", - "'all_measures'", - "'scalar'", - "'component'", - "'datapoint_on_valuedomains'", - "'datapoint_on_variables'", - "'hierarchical_on_valuedomains'", - "'hierarchical_on_variables'", - "'set'", - "'language'", - "", - "", - "", - "", - "", - "", - "';'", - ] - - symbolicNames = [ - "", - "LPAREN", - "RPAREN", - "QLPAREN", - "QRPAREN", - "GLPAREN", - "GRPAREN", - "EQ", - "LT", - "MT", - "ME", - "NEQ", - "LE", - "PLUS", - "MINUS", - "MUL", - "DIV", - "COMMA", - "POINTER", - "COLON", - "ASSIGN", - "MEMBERSHIP", - "EVAL", - "IF", - "CASE", - "THEN", - "ELSE", - "USING", - "WITH", - "CURRENT_DATE", - "DATEDIFF", - "DATEADD", - "YEAR_OP", - "MONTH_OP", - "DAYOFMONTH", - "DAYOFYEAR", - "DAYTOYEAR", - "DAYTOMONTH", - "YEARTODAY", - "MONTHTODAY", - "ON", - "DROP", - "KEEP", - "CALC", - "ATTRCALC", - "RENAME", - "AS", - "AND", - "OR", - "XOR", - "NOT", - "BETWEEN", - "IN", - "NOT_IN", - "NULL_CONSTANT", - "ISNULL", - "EX", - "UNION", - "DIFF", - "SYMDIFF", - "INTERSECT", - "RANDOM", - "KEYS", - "INTYEAR", - "INTMONTH", - "INTDAY", - "CHECK", - "EXISTS_IN", - "TO", - "RETURN", - "IMBALANCE", - "ERRORCODE", - "ALL", - "AGGREGATE", - "ERRORLEVEL", - "ORDER", - "BY", - "RANK", - "ASC", - "DESC", - "MIN", - "MAX", - "FIRST", - "LAST", - "INDEXOF", - "ABS", - "KEY", - "LN", - "LOG", - "TRUNC", - "ROUND", - "POWER", - "MOD", - "LEN", - "CONCAT", - "TRIM", - "UCASE", - "LCASE", - "SUBSTR", - "SUM", - "AVG", - "MEDIAN", - "COUNT", - "DIMENSION", - "MEASURE", - "ATTRIBUTE", - "FILTER", - "MERGE", - "EXP", - "ROLE", - "VIRAL", - "CHARSET_MATCH", - "TYPE", - "NVL", - "HIERARCHY", - "OPTIONAL", - "INVALID", - "VALUE_DOMAIN", - "VARIABLE", - "DATA", - "STRUCTURE", - "DATASET", - "OPERATOR", - "DEFINE", - "PUT_SYMBOL", - "DATAPOINT", - "HIERARCHICAL", - "RULESET", - "RULE", - "END", - "ALTER_DATASET", - "LTRIM", - "RTRIM", - "INSTR", - "REPLACE", - "CEIL", - "FLOOR", - "SQRT", - "ANY", - "SETDIFF", - "STDDEV_POP", - "STDDEV_SAMP", - "VAR_POP", - "VAR_SAMP", - "GROUP", - "EXCEPT", - "HAVING", - "FIRST_VALUE", - "LAST_VALUE", - "LAG", - "LEAD", - "RATIO_TO_REPORT", - "OVER", - "PRECEDING", - "FOLLOWING", - "UNBOUNDED", - "PARTITION", - "ROWS", - "RANGE", - "CURRENT", - "VALID", - "FILL_TIME_SERIES", - "FLOW_TO_STOCK", - "STOCK_TO_FLOW", - "TIMESHIFT", - "MEASURES", - "NO_MEASURES", - "CONDITION", - "BOOLEAN", - "DATE", - "TIME_PERIOD", - "NUMBER", - "STRING", - "TIME", - "INTEGER", - "FLOAT", - "LIST", - "RECORD", - "RESTRICT", - "YYYY", - "MM", - "DD", - "MAX_LENGTH", - "REGEXP", - "IS", - "WHEN", - "FROM", - "AGGREGATES", - "POINTS", - "POINT", - "TOTAL", - "PARTIAL", - "ALWAYS", - "INNER_JOIN", - "LEFT_JOIN", - "CROSS_JOIN", - "FULL_JOIN", - "MAPS_FROM", - "MAPS_TO", - "MAP_TO", - "MAP_FROM", - "RETURNS", - "PIVOT", - "CUSTOMPIVOT", - "UNPIVOT", - "SUBSPACE", - "APPLY", - "CONDITIONED", - "PERIOD_INDICATOR", - "SINGLE", - "DURATION", - "TIME_AGG", - "UNIT", - "VALUE", - "VALUEDOMAINS", - "VARIABLES", - "INPUT", - "OUTPUT", - "CAST", - "RULE_PRIORITY", - "DATASET_PRIORITY", - "DEFAULT", - "CHECK_DATAPOINT", - "CHECK_HIERARCHY", - "COMPUTED", - "NON_NULL", - "NON_ZERO", - "PARTIAL_NULL", - "PARTIAL_ZERO", - "ALWAYS_NULL", - "ALWAYS_ZERO", - "COMPONENTS", - "ALL_MEASURES", - "SCALAR", - "COMPONENT", - "DATAPOINT_ON_VD", - "DATAPOINT_ON_VAR", - "HIERARCHICAL_ON_VD", - "HIERARCHICAL_ON_VAR", - "SET", - "LANGUAGE", - "INTEGER_CONSTANT", - "NUMBER_CONSTANT", - "BOOLEAN_CONSTANT", - "STRING_CONSTANT", - "IDENTIFIER", - "WS", - "EOL", - "ML_COMMENT", - "SL_COMMENT", - ] + literalNames = [ "", "'('", "')'", "'['", "']'", "'{'", "'}'", + "'='", "'<'", "'>'", "'>='", "'<>'", "'<='", "'+'", + "'-'", "'*'", "'/'", "','", "'->'", "':'", "':='", + "'#'", "'eval'", "'if'", "'case'", "'then'", "'else'", + "'using'", "'with'", "'current_date'", "'datediff'", + "'dateadd'", "'year'", "'month'", "'dayofmonth'", "'dayofyear'", + "'daytoyear'", "'daytomonth'", "'yeartoday'", "'monthtoday'", + "'on'", "'drop'", "'keep'", "'calc'", "'attrcalc'", + "'rename'", "'as'", "'and'", "'or'", "'xor'", "'not'", + "'between'", "'in'", "'not_in'", "'null'", "'isnull'", + "'ex'", "'union'", "'diff'", "'symdiff'", "'intersect'", + "'random'", "'keys'", "'intyear'", "'intmonth'", "'intday'", + "'check'", "'exists_in'", "'to'", "'return'", "'imbalance'", + "'errorcode'", "'all'", "'aggr'", "'errorlevel'", "'order'", + "'by'", "'rank'", "'asc'", "'desc'", "'min'", "'max'", + "'first'", "'last'", "'indexof'", "'abs'", "'key'", + "'ln'", "'log'", "'trunc'", "'round'", "'power'", "'mod'", + "'length'", "'||'", "'trim'", "'upper'", "'lower'", + "'substr'", "'sum'", "'avg'", "'median'", "'count'", + "'identifier'", "'measure'", "'attribute'", "'filter'", + "'merge'", "'exp'", "'componentRole'", "'viral'", "'match_characters'", + "'type'", "'nvl'", "'hierarchy'", "'_'", "'invalid'", + "'valuedomain'", "'variable'", "'data'", "'structure'", + "'dataset'", "'operator'", "'define'", "'<-'", "'datapoint'", + "'hierarchical'", "'ruleset'", "'rule'", "'end'", "'alterDataset'", + "'ltrim'", "'rtrim'", "'instr'", "'replace'", "'ceil'", + "'floor'", "'sqrt'", "'any'", "'setdiff'", "'stddev_pop'", + "'stddev_samp'", "'var_pop'", "'var_samp'", "'group'", + "'except'", "'having'", "'first_value'", "'last_value'", + "'lag'", "'lead'", "'ratio_to_report'", "'over'", "'preceding'", + "'following'", "'unbounded'", "'partition'", "'rows'", + "'range'", "'current'", "'valid'", "'fill_time_series'", + "'flow_to_stock'", "'stock_to_flow'", "'timeshift'", + "'measures'", "'no_measures'", "'condition'", "'boolean'", + "'date'", "'time_period'", "'number'", "'string'", + "'time'", "'integer'", "'float'", "'list'", "'record'", + "'restrict'", "'yyyy'", "'mm'", "'dd'", "'maxLength'", + "'regexp'", "'is'", "'when'", "'from'", "'aggregates'", + "'points'", "'point'", "'total'", "'partial'", "'always'", + "'inner_join'", "'left_join'", "'cross_join'", "'full_join'", + "'maps_from'", "'maps_to'", "'map_to'", "'map_from'", + "'returns'", "'pivot'", "'customPivot'", "'unpivot'", + "'sub'", "'apply'", "'conditioned'", "'period_indicator'", + "'single'", "'duration'", "'time_agg'", "'unit'", "'Value'", + "'valuedomains'", "'variables'", "'input'", "'output'", + "'cast'", "'rule_priority'", "'dataset_priority'", + "'default'", "'check_datapoint'", "'check_hierarchy'", + "'computed'", "'non_null'", "'non_zero'", "'partial_null'", + "'partial_zero'", "'always_null'", "'always_zero'", + "'components'", "'all_measures'", "'scalar'", "'component'", + "'datapoint_on_valuedomains'", "'datapoint_on_variables'", + "'hierarchical_on_valuedomains'", "'hierarchical_on_variables'", + "'set'", "'language'", "", "", "", + "", "", "", "';'" ] + + symbolicNames = [ "", "LPAREN", "RPAREN", "QLPAREN", "QRPAREN", + "GLPAREN", "GRPAREN", "EQ", "LT", "MT", "ME", "NEQ", + "LE", "PLUS", "MINUS", "MUL", "DIV", "COMMA", "POINTER", + "COLON", "ASSIGN", "MEMBERSHIP", "EVAL", "IF", "CASE", + "THEN", "ELSE", "USING", "WITH", "CURRENT_DATE", "DATEDIFF", + "DATEADD", "YEAR_OP", "MONTH_OP", "DAYOFMONTH", "DAYOFYEAR", + "DAYTOYEAR", "DAYTOMONTH", "YEARTODAY", "MONTHTODAY", + "ON", "DROP", "KEEP", "CALC", "ATTRCALC", "RENAME", + "AS", "AND", "OR", "XOR", "NOT", "BETWEEN", "IN", + "NOT_IN", "NULL_CONSTANT", "ISNULL", "EX", "UNION", + "DIFF", "SYMDIFF", "INTERSECT", "RANDOM", "KEYS", + "INTYEAR", "INTMONTH", "INTDAY", "CHECK", "EXISTS_IN", + "TO", "RETURN", "IMBALANCE", "ERRORCODE", "ALL", "AGGREGATE", + "ERRORLEVEL", "ORDER", "BY", "RANK", "ASC", "DESC", + "MIN", "MAX", "FIRST", "LAST", "INDEXOF", "ABS", "KEY", + "LN", "LOG", "TRUNC", "ROUND", "POWER", "MOD", "LEN", + "CONCAT", "TRIM", "UCASE", "LCASE", "SUBSTR", "SUM", + "AVG", "MEDIAN", "COUNT", "DIMENSION", "MEASURE", + "ATTRIBUTE", "FILTER", "MERGE", "EXP", "ROLE", "VIRAL", + "CHARSET_MATCH", "TYPE", "NVL", "HIERARCHY", "OPTIONAL", + "INVALID", "VALUE_DOMAIN", "VARIABLE", "DATA", "STRUCTURE", + "DATASET", "OPERATOR", "DEFINE", "PUT_SYMBOL", "DATAPOINT", + "HIERARCHICAL", "RULESET", "RULE", "END", "ALTER_DATASET", + "LTRIM", "RTRIM", "INSTR", "REPLACE", "CEIL", "FLOOR", + "SQRT", "ANY", "SETDIFF", "STDDEV_POP", "STDDEV_SAMP", + "VAR_POP", "VAR_SAMP", "GROUP", "EXCEPT", "HAVING", + "FIRST_VALUE", "LAST_VALUE", "LAG", "LEAD", "RATIO_TO_REPORT", + "OVER", "PRECEDING", "FOLLOWING", "UNBOUNDED", "PARTITION", + "ROWS", "RANGE", "CURRENT", "VALID", "FILL_TIME_SERIES", + "FLOW_TO_STOCK", "STOCK_TO_FLOW", "TIMESHIFT", "MEASURES", + "NO_MEASURES", "CONDITION", "BOOLEAN", "DATE", "TIME_PERIOD", + "NUMBER", "STRING", "TIME", "INTEGER", "FLOAT", "LIST", + "RECORD", "RESTRICT", "YYYY", "MM", "DD", "MAX_LENGTH", + "REGEXP", "IS", "WHEN", "FROM", "AGGREGATES", "POINTS", + "POINT", "TOTAL", "PARTIAL", "ALWAYS", "INNER_JOIN", + "LEFT_JOIN", "CROSS_JOIN", "FULL_JOIN", "MAPS_FROM", + "MAPS_TO", "MAP_TO", "MAP_FROM", "RETURNS", "PIVOT", + "CUSTOMPIVOT", "UNPIVOT", "SUBSPACE", "APPLY", "CONDITIONED", + "PERIOD_INDICATOR", "SINGLE", "DURATION", "TIME_AGG", + "UNIT", "VALUE", "VALUEDOMAINS", "VARIABLES", "INPUT", + "OUTPUT", "CAST", "RULE_PRIORITY", "DATASET_PRIORITY", + "DEFAULT", "CHECK_DATAPOINT", "CHECK_HIERARCHY", "COMPUTED", + "NON_NULL", "NON_ZERO", "PARTIAL_NULL", "PARTIAL_ZERO", + "ALWAYS_NULL", "ALWAYS_ZERO", "COMPONENTS", "ALL_MEASURES", + "SCALAR", "COMPONENT", "DATAPOINT_ON_VD", "DATAPOINT_ON_VAR", + "HIERARCHICAL_ON_VD", "HIERARCHICAL_ON_VAR", "SET", + "LANGUAGE", "INTEGER_CONSTANT", "NUMBER_CONSTANT", + "BOOLEAN_CONSTANT", "STRING_CONSTANT", "IDENTIFIER", + "WS", "EOL", "ML_COMMENT", "SL_COMMENT" ] RULE_start = 0 RULE_statement = 1 @@ -1597,394 +1205,318 @@ class Parser(ANTLRParser): RULE_basicScalarType = 108 RULE_retainType = 109 - ruleNames = [ - "start", - "statement", - "expr", - "exprComponent", - "functionsComponents", - "functions", - "datasetClause", - "renameClause", - "aggrClause", - "filterClause", - "calcClause", - "keepOrDropClause", - "pivotOrUnpivotClause", - "customPivotClause", - "subspaceClause", - "joinOperators", - "defOperators", - "genericOperators", - "genericOperatorsComponent", - "parameterComponent", - "parameter", - "stringOperators", - "stringOperatorsComponent", - "numericOperators", - "numericOperatorsComponent", - "comparisonOperators", - "comparisonOperatorsComponent", - "timeOperators", - "timeOperatorsComponent", - "setOperators", - "hierarchyOperators", - "validationOperators", - "conditionalOperators", - "conditionalOperatorsComponent", - "aggrOperators", - "aggrOperatorsGrouping", - "anFunction", - "anFunctionComponent", - "renameClauseItem", - "aggregateClause", - "aggrFunctionClause", - "calcClauseItem", - "subspaceClauseItem", - "scalarItem", - "joinClauseWithoutUsing", - "joinClause", - "joinClauseItem", - "joinBody", - "joinApplyClause", - "partitionByClause", - "orderByClause", - "orderByItem", - "windowingClause", - "signedInteger", - "limitClauseItem", - "groupingClause", - "havingClause", - "parameterItem", - "outputParameterType", - "outputParameterTypeComponent", - "inputParameterType", - "rulesetType", - "scalarType", - "componentType", - "datasetType", - "evalDatasetType", - "scalarSetType", - "dpRuleset", - "hrRuleset", - "valueDomainName", - "rulesetID", - "rulesetSignature", - "signature", - "ruleClauseDatapoint", - "ruleItemDatapoint", - "ruleClauseHierarchical", - "ruleItemHierarchical", - "hierRuleSignature", - "valueDomainSignature", - "codeItemRelation", - "codeItemRelationClause", - "valueDomainValue", - "scalarTypeConstraint", - "compConstraint", - "multModifier", - "validationOutput", - "validationMode", - "conditionClause", - "inputMode", - "imbalanceExpr", - "inputModeHierarchy", - "outputModeHierarchy", - "alias", - "varID", - "simpleComponentId", - "componentID", - "lists", - "erCode", - "erLevel", - "comparisonOperand", - "optionalExpr", - "optionalExprComponent", - "componentRole", - "viralAttribute", - "valueDomainID", - "operatorID", - "routineName", - "constant", - "basicScalarType", - "retainType", - ] + ruleNames = [ "start", "statement", "expr", "exprComponent", "functionsComponents", + "functions", "datasetClause", "renameClause", "aggrClause", + "filterClause", "calcClause", "keepOrDropClause", "pivotOrUnpivotClause", + "customPivotClause", "subspaceClause", "joinOperators", + "defOperators", "genericOperators", "genericOperatorsComponent", + "parameterComponent", "parameter", "stringOperators", + "stringOperatorsComponent", "numericOperators", "numericOperatorsComponent", + "comparisonOperators", "comparisonOperatorsComponent", + "timeOperators", "timeOperatorsComponent", "setOperators", + "hierarchyOperators", "validationOperators", "conditionalOperators", + "conditionalOperatorsComponent", "aggrOperators", "aggrOperatorsGrouping", + "anFunction", "anFunctionComponent", "renameClauseItem", + "aggregateClause", "aggrFunctionClause", "calcClauseItem", + "subspaceClauseItem", "scalarItem", "joinClauseWithoutUsing", + "joinClause", "joinClauseItem", "joinBody", "joinApplyClause", + "partitionByClause", "orderByClause", "orderByItem", + "windowingClause", "signedInteger", "limitClauseItem", + "groupingClause", "havingClause", "parameterItem", "outputParameterType", + "outputParameterTypeComponent", "inputParameterType", + "rulesetType", "scalarType", "componentType", "datasetType", + "evalDatasetType", "scalarSetType", "dpRuleset", "hrRuleset", + "valueDomainName", "rulesetID", "rulesetSignature", "signature", + "ruleClauseDatapoint", "ruleItemDatapoint", "ruleClauseHierarchical", + "ruleItemHierarchical", "hierRuleSignature", "valueDomainSignature", + "codeItemRelation", "codeItemRelationClause", "valueDomainValue", + "scalarTypeConstraint", "compConstraint", "multModifier", + "validationOutput", "validationMode", "conditionClause", + "inputMode", "imbalanceExpr", "inputModeHierarchy", "outputModeHierarchy", + "alias", "varID", "simpleComponentId", "componentID", + "lists", "erCode", "erLevel", "comparisonOperand", "optionalExpr", + "optionalExprComponent", "componentRole", "viralAttribute", + "valueDomainID", "operatorID", "routineName", "constant", + "basicScalarType", "retainType" ] EOF = Token.EOF - LPAREN = 1 - RPAREN = 2 - QLPAREN = 3 - QRPAREN = 4 - GLPAREN = 5 - GRPAREN = 6 - EQ = 7 - LT = 8 - MT = 9 - ME = 10 - NEQ = 11 - LE = 12 - PLUS = 13 - MINUS = 14 - MUL = 15 - DIV = 16 - COMMA = 17 - POINTER = 18 - COLON = 19 - ASSIGN = 20 - MEMBERSHIP = 21 - EVAL = 22 - IF = 23 - CASE = 24 - THEN = 25 - ELSE = 26 - USING = 27 - WITH = 28 - CURRENT_DATE = 29 - DATEDIFF = 30 - DATEADD = 31 - YEAR_OP = 32 - MONTH_OP = 33 - DAYOFMONTH = 34 - DAYOFYEAR = 35 - DAYTOYEAR = 36 - DAYTOMONTH = 37 - YEARTODAY = 38 - MONTHTODAY = 39 - ON = 40 - DROP = 41 - KEEP = 42 - CALC = 43 - ATTRCALC = 44 - RENAME = 45 - AS = 46 - AND = 47 - OR = 48 - XOR = 49 - NOT = 50 - BETWEEN = 51 - IN = 52 - NOT_IN = 53 - NULL_CONSTANT = 54 - ISNULL = 55 - EX = 56 - UNION = 57 - DIFF = 58 - SYMDIFF = 59 - INTERSECT = 60 - RANDOM = 61 - KEYS = 62 - INTYEAR = 63 - INTMONTH = 64 - INTDAY = 65 - CHECK = 66 - EXISTS_IN = 67 - TO = 68 - RETURN = 69 - IMBALANCE = 70 - ERRORCODE = 71 - ALL = 72 - AGGREGATE = 73 - ERRORLEVEL = 74 - ORDER = 75 - BY = 76 - RANK = 77 - ASC = 78 - DESC = 79 - MIN = 80 - MAX = 81 - FIRST = 82 - LAST = 83 - INDEXOF = 84 - ABS = 85 - KEY = 86 - LN = 87 - LOG = 88 - TRUNC = 89 - ROUND = 90 - POWER = 91 - MOD = 92 - LEN = 93 - CONCAT = 94 - TRIM = 95 - UCASE = 96 - LCASE = 97 - SUBSTR = 98 - SUM = 99 - AVG = 100 - MEDIAN = 101 - COUNT = 102 - DIMENSION = 103 - MEASURE = 104 - ATTRIBUTE = 105 - FILTER = 106 - MERGE = 107 - EXP = 108 - ROLE = 109 - VIRAL = 110 - CHARSET_MATCH = 111 - TYPE = 112 - NVL = 113 - HIERARCHY = 114 - OPTIONAL = 115 - INVALID = 116 - VALUE_DOMAIN = 117 - VARIABLE = 118 - DATA = 119 - STRUCTURE = 120 - DATASET = 121 - OPERATOR = 122 - DEFINE = 123 - PUT_SYMBOL = 124 - DATAPOINT = 125 - HIERARCHICAL = 126 - RULESET = 127 - RULE = 128 - END = 129 - ALTER_DATASET = 130 - LTRIM = 131 - RTRIM = 132 - INSTR = 133 - REPLACE = 134 - CEIL = 135 - FLOOR = 136 - SQRT = 137 - ANY = 138 - SETDIFF = 139 - STDDEV_POP = 140 - STDDEV_SAMP = 141 - VAR_POP = 142 - VAR_SAMP = 143 - GROUP = 144 - EXCEPT = 145 - HAVING = 146 - FIRST_VALUE = 147 - LAST_VALUE = 148 - LAG = 149 - LEAD = 150 - RATIO_TO_REPORT = 151 - OVER = 152 - PRECEDING = 153 - FOLLOWING = 154 - UNBOUNDED = 155 - PARTITION = 156 - ROWS = 157 - RANGE = 158 - CURRENT = 159 - VALID = 160 - FILL_TIME_SERIES = 161 - FLOW_TO_STOCK = 162 - STOCK_TO_FLOW = 163 - TIMESHIFT = 164 - MEASURES = 165 - NO_MEASURES = 166 - CONDITION = 167 - BOOLEAN = 168 - DATE = 169 - TIME_PERIOD = 170 - NUMBER = 171 - STRING = 172 - TIME = 173 - INTEGER = 174 - FLOAT = 175 - LIST = 176 - RECORD = 177 - RESTRICT = 178 - YYYY = 179 - MM = 180 - DD = 181 - MAX_LENGTH = 182 - REGEXP = 183 - IS = 184 - WHEN = 185 - FROM = 186 - AGGREGATES = 187 - POINTS = 188 - POINT = 189 - TOTAL = 190 - PARTIAL = 191 - ALWAYS = 192 - INNER_JOIN = 193 - LEFT_JOIN = 194 - CROSS_JOIN = 195 - FULL_JOIN = 196 - MAPS_FROM = 197 - MAPS_TO = 198 - MAP_TO = 199 - MAP_FROM = 200 - RETURNS = 201 - PIVOT = 202 - CUSTOMPIVOT = 203 - UNPIVOT = 204 - SUBSPACE = 205 - APPLY = 206 - CONDITIONED = 207 - PERIOD_INDICATOR = 208 - SINGLE = 209 - DURATION = 210 - TIME_AGG = 211 - UNIT = 212 - VALUE = 213 - VALUEDOMAINS = 214 - VARIABLES = 215 - INPUT = 216 - OUTPUT = 217 - CAST = 218 - RULE_PRIORITY = 219 - DATASET_PRIORITY = 220 - DEFAULT = 221 - CHECK_DATAPOINT = 222 - CHECK_HIERARCHY = 223 - COMPUTED = 224 - NON_NULL = 225 - NON_ZERO = 226 - PARTIAL_NULL = 227 - PARTIAL_ZERO = 228 - ALWAYS_NULL = 229 - ALWAYS_ZERO = 230 - COMPONENTS = 231 - ALL_MEASURES = 232 - SCALAR = 233 - COMPONENT = 234 - DATAPOINT_ON_VD = 235 - DATAPOINT_ON_VAR = 236 - HIERARCHICAL_ON_VD = 237 - HIERARCHICAL_ON_VAR = 238 - SET = 239 - LANGUAGE = 240 - INTEGER_CONSTANT = 241 - NUMBER_CONSTANT = 242 - BOOLEAN_CONSTANT = 243 - STRING_CONSTANT = 244 - IDENTIFIER = 245 - WS = 246 - EOL = 247 - ML_COMMENT = 248 - SL_COMMENT = 249 - - def __init__(self, input: TokenStream, output: TextIO = sys.stdout): + LPAREN=1 + RPAREN=2 + QLPAREN=3 + QRPAREN=4 + GLPAREN=5 + GRPAREN=6 + EQ=7 + LT=8 + MT=9 + ME=10 + NEQ=11 + LE=12 + PLUS=13 + MINUS=14 + MUL=15 + DIV=16 + COMMA=17 + POINTER=18 + COLON=19 + ASSIGN=20 + MEMBERSHIP=21 + EVAL=22 + IF=23 + CASE=24 + THEN=25 + ELSE=26 + USING=27 + WITH=28 + CURRENT_DATE=29 + DATEDIFF=30 + DATEADD=31 + YEAR_OP=32 + MONTH_OP=33 + DAYOFMONTH=34 + DAYOFYEAR=35 + DAYTOYEAR=36 + DAYTOMONTH=37 + YEARTODAY=38 + MONTHTODAY=39 + ON=40 + DROP=41 + KEEP=42 + CALC=43 + ATTRCALC=44 + RENAME=45 + AS=46 + AND=47 + OR=48 + XOR=49 + NOT=50 + BETWEEN=51 + IN=52 + NOT_IN=53 + NULL_CONSTANT=54 + ISNULL=55 + EX=56 + UNION=57 + DIFF=58 + SYMDIFF=59 + INTERSECT=60 + RANDOM=61 + KEYS=62 + INTYEAR=63 + INTMONTH=64 + INTDAY=65 + CHECK=66 + EXISTS_IN=67 + TO=68 + RETURN=69 + IMBALANCE=70 + ERRORCODE=71 + ALL=72 + AGGREGATE=73 + ERRORLEVEL=74 + ORDER=75 + BY=76 + RANK=77 + ASC=78 + DESC=79 + MIN=80 + MAX=81 + FIRST=82 + LAST=83 + INDEXOF=84 + ABS=85 + KEY=86 + LN=87 + LOG=88 + TRUNC=89 + ROUND=90 + POWER=91 + MOD=92 + LEN=93 + CONCAT=94 + TRIM=95 + UCASE=96 + LCASE=97 + SUBSTR=98 + SUM=99 + AVG=100 + MEDIAN=101 + COUNT=102 + DIMENSION=103 + MEASURE=104 + ATTRIBUTE=105 + FILTER=106 + MERGE=107 + EXP=108 + ROLE=109 + VIRAL=110 + CHARSET_MATCH=111 + TYPE=112 + NVL=113 + HIERARCHY=114 + OPTIONAL=115 + INVALID=116 + VALUE_DOMAIN=117 + VARIABLE=118 + DATA=119 + STRUCTURE=120 + DATASET=121 + OPERATOR=122 + DEFINE=123 + PUT_SYMBOL=124 + DATAPOINT=125 + HIERARCHICAL=126 + RULESET=127 + RULE=128 + END=129 + ALTER_DATASET=130 + LTRIM=131 + RTRIM=132 + INSTR=133 + REPLACE=134 + CEIL=135 + FLOOR=136 + SQRT=137 + ANY=138 + SETDIFF=139 + STDDEV_POP=140 + STDDEV_SAMP=141 + VAR_POP=142 + VAR_SAMP=143 + GROUP=144 + EXCEPT=145 + HAVING=146 + FIRST_VALUE=147 + LAST_VALUE=148 + LAG=149 + LEAD=150 + RATIO_TO_REPORT=151 + OVER=152 + PRECEDING=153 + FOLLOWING=154 + UNBOUNDED=155 + PARTITION=156 + ROWS=157 + RANGE=158 + CURRENT=159 + VALID=160 + FILL_TIME_SERIES=161 + FLOW_TO_STOCK=162 + STOCK_TO_FLOW=163 + TIMESHIFT=164 + MEASURES=165 + NO_MEASURES=166 + CONDITION=167 + BOOLEAN=168 + DATE=169 + TIME_PERIOD=170 + NUMBER=171 + STRING=172 + TIME=173 + INTEGER=174 + FLOAT=175 + LIST=176 + RECORD=177 + RESTRICT=178 + YYYY=179 + MM=180 + DD=181 + MAX_LENGTH=182 + REGEXP=183 + IS=184 + WHEN=185 + FROM=186 + AGGREGATES=187 + POINTS=188 + POINT=189 + TOTAL=190 + PARTIAL=191 + ALWAYS=192 + INNER_JOIN=193 + LEFT_JOIN=194 + CROSS_JOIN=195 + FULL_JOIN=196 + MAPS_FROM=197 + MAPS_TO=198 + MAP_TO=199 + MAP_FROM=200 + RETURNS=201 + PIVOT=202 + CUSTOMPIVOT=203 + UNPIVOT=204 + SUBSPACE=205 + APPLY=206 + CONDITIONED=207 + PERIOD_INDICATOR=208 + SINGLE=209 + DURATION=210 + TIME_AGG=211 + UNIT=212 + VALUE=213 + VALUEDOMAINS=214 + VARIABLES=215 + INPUT=216 + OUTPUT=217 + CAST=218 + RULE_PRIORITY=219 + DATASET_PRIORITY=220 + DEFAULT=221 + CHECK_DATAPOINT=222 + CHECK_HIERARCHY=223 + COMPUTED=224 + NON_NULL=225 + NON_ZERO=226 + PARTIAL_NULL=227 + PARTIAL_ZERO=228 + ALWAYS_NULL=229 + ALWAYS_ZERO=230 + COMPONENTS=231 + ALL_MEASURES=232 + SCALAR=233 + COMPONENT=234 + DATAPOINT_ON_VD=235 + DATAPOINT_ON_VAR=236 + HIERARCHICAL_ON_VD=237 + HIERARCHICAL_ON_VAR=238 + SET=239 + LANGUAGE=240 + INTEGER_CONSTANT=241 + NUMBER_CONSTANT=242 + BOOLEAN_CONSTANT=243 + STRING_CONSTANT=244 + IDENTIFIER=245 + WS=246 + EOL=247 + ML_COMMENT=248 + SL_COMMENT=249 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): super().__init__(input, output) - self._interp = ParserATNSimulator( - self, self.atn, self.decisionsToDFA, self.sharedContextCache - ) + self.checkVersion("4.9.3") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) self._predicates = None + + + class StartContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def EOF(self): return self.getToken(Parser.EOF, 0) - def statement(self, i: int = None): + def statement(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.StatementContext) else: - return self.getTypedRuleContext(Parser.StatementContext, i) + return self.getTypedRuleContext(Parser.StatementContext,i) + - def EOL(self, i: int = None): + def EOL(self, i:int=None): if i is None: return self.getTokens(Parser.EOL) else: @@ -1993,24 +1525,34 @@ def EOL(self, i: int = None): def getRuleIndex(self): return Parser.RULE_start - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterStart"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStart" ): listener.enterStart(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitStart"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStart" ): listener.exitStart(self) - def start(self) -> Any: + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitStart" ): + return visitor.visitStart(self) + else: + return visitor.visitChildren(self) + + + + + def start(self): + localctx = Parser.StartContext(self, self._ctx, self.state) self.enterRule(localctx, 0, self.RULE_start) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 225 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.DEFINE or _la == Parser.IDENTIFIER: + while _la==Parser.DEFINE or _la==Parser.IDENTIFIER: self.state = 220 self.statement() self.state = 221 @@ -2029,92 +1571,118 @@ def start(self) -> Any: self.exitRule() return localctx + class StatementContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_statement - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class DefineExpressionContext(StatementContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.StatementContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StatementContext super().__init__(ANTLRParser) self.copyFrom(ctx) def defOperators(self): - return self.getTypedRuleContext(Parser.DefOperatorsContext, 0) + return self.getTypedRuleContext(Parser.DefOperatorsContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDefineExpression"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefineExpression" ): listener.enterDefineExpression(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDefineExpression"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefineExpression" ): listener.exitDefineExpression(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDefineExpression" ): + return visitor.visitDefineExpression(self) + else: + return visitor.visitChildren(self) + + class TemporaryAssignmentContext(StatementContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.StatementContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StatementContext super().__init__(ANTLRParser) self.copyFrom(ctx) def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext, 0) + return self.getTypedRuleContext(Parser.VarIDContext,0) def ASSIGN(self): return self.getToken(Parser.ASSIGN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTemporaryAssignment"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTemporaryAssignment" ): listener.enterTemporaryAssignment(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTemporaryAssignment"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTemporaryAssignment" ): listener.exitTemporaryAssignment(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTemporaryAssignment" ): + return visitor.visitTemporaryAssignment(self) + else: + return visitor.visitChildren(self) + + class PersistAssignmentContext(StatementContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.StatementContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StatementContext super().__init__(ANTLRParser) self.copyFrom(ctx) def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext, 0) + return self.getTypedRuleContext(Parser.VarIDContext,0) def PUT_SYMBOL(self): return self.getToken(Parser.PUT_SYMBOL, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterPersistAssignment"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPersistAssignment" ): listener.enterPersistAssignment(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitPersistAssignment"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPersistAssignment" ): listener.exitPersistAssignment(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPersistAssignment" ): + return visitor.visitPersistAssignment(self) + else: + return visitor.visitChildren(self) + + + def statement(self): + localctx = Parser.StatementContext(self, self._ctx, self.state) self.enterRule(localctx, 2, self.RULE_statement) try: self.state = 239 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 1, self._ctx) + la_ = self._interp.adaptivePredict(self._input,1,self._ctx) if la_ == 1: localctx = Parser.TemporaryAssignmentContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -2144,6 +1712,7 @@ def statement(self): self.defOperators() pass + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -2152,391 +1721,497 @@ def statement(self): self.exitRule() return localctx + class ExprContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_expr - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + class VarIdExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext, 0) + return self.getTypedRuleContext(Parser.VarIDContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterVarIdExpr"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVarIdExpr" ): listener.enterVarIdExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitVarIdExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVarIdExpr" ): listener.exitVarIdExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitVarIdExpr" ): + return visitor.visitVarIdExpr(self) + else: + return visitor.visitChildren(self) + + class MembershipExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def MEMBERSHIP(self): return self.getToken(Parser.MEMBERSHIP, 0) - def simpleComponentId(self): - return self.getTypedRuleContext(Parser.SimpleComponentIdContext, 0) + return self.getTypedRuleContext(Parser.SimpleComponentIdContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterMembershipExpr"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMembershipExpr" ): listener.enterMembershipExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitMembershipExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMembershipExpr" ): listener.exitMembershipExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitMembershipExpr" ): + return visitor.visitMembershipExpr(self) + else: + return visitor.visitChildren(self) + + class InNotInExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.op = None # Token + self.left = None # ExprContext + self.op = None # Token self.copyFrom(ctx) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def IN(self): return self.getToken(Parser.IN, 0) - def NOT_IN(self): return self.getToken(Parser.NOT_IN, 0) - def lists(self): - return self.getTypedRuleContext(Parser.ListsContext, 0) + return self.getTypedRuleContext(Parser.ListsContext,0) def valueDomainID(self): - return self.getTypedRuleContext(Parser.ValueDomainIDContext, 0) + return self.getTypedRuleContext(Parser.ValueDomainIDContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterInNotInExpr"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInNotInExpr" ): listener.enterInNotInExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitInNotInExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInNotInExpr" ): listener.exitInNotInExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInNotInExpr" ): + return visitor.visitInNotInExpr(self) + else: + return visitor.visitChildren(self) + + class BooleanExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.op = None # Token - self.right = None # ExprContext + self.left = None # ExprContext + self.op = None # Token + self.right = None # ExprContext self.copyFrom(ctx) - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) def AND(self): return self.getToken(Parser.AND, 0) - def OR(self): return self.getToken(Parser.OR, 0) - def XOR(self): return self.getToken(Parser.XOR, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterBooleanExpr"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBooleanExpr" ): listener.enterBooleanExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitBooleanExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBooleanExpr" ): listener.exitBooleanExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBooleanExpr" ): + return visitor.visitBooleanExpr(self) + else: + return visitor.visitChildren(self) + + class ComparisonExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.op = None # ComparisonOperandContext - self.right = None # ExprContext + self.left = None # ExprContext + self.op = None # ComparisonOperandContext + self.right = None # ExprContext self.copyFrom(ctx) - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) def comparisonOperand(self): - return self.getTypedRuleContext(Parser.ComparisonOperandContext, 0) + return self.getTypedRuleContext(Parser.ComparisonOperandContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterComparisonExpr"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComparisonExpr" ): listener.enterComparisonExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitComparisonExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComparisonExpr" ): listener.exitComparisonExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitComparisonExpr" ): + return visitor.visitComparisonExpr(self) + else: + return visitor.visitChildren(self) + + class UnaryExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.op = None # Token - self.right = None # ExprContext + self.op = None # Token + self.right = None # ExprContext self.copyFrom(ctx) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def PLUS(self): return self.getToken(Parser.PLUS, 0) - def MINUS(self): return self.getToken(Parser.MINUS, 0) - def NOT(self): return self.getToken(Parser.NOT, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterUnaryExpr"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnaryExpr" ): listener.enterUnaryExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitUnaryExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnaryExpr" ): listener.exitUnaryExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUnaryExpr" ): + return visitor.visitUnaryExpr(self) + else: + return visitor.visitChildren(self) + + class FunctionsExpressionContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def functions(self): - return self.getTypedRuleContext(Parser.FunctionsContext, 0) + return self.getTypedRuleContext(Parser.FunctionsContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFunctionsExpression"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunctionsExpression" ): listener.enterFunctionsExpression(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFunctionsExpression"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunctionsExpression" ): listener.exitFunctionsExpression(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFunctionsExpression" ): + return visitor.visitFunctionsExpression(self) + else: + return visitor.visitChildren(self) + + class IfExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.conditionalExpr = None # ExprContext - self.thenExpr = None # ExprContext - self.elseExpr = None # ExprContext + self.conditionalExpr = None # ExprContext + self.thenExpr = None # ExprContext + self.elseExpr = None # ExprContext self.copyFrom(ctx) def IF(self): return self.getToken(Parser.IF, 0) - def THEN(self): return self.getToken(Parser.THEN, 0) - def ELSE(self): return self.getToken(Parser.ELSE, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIfExpr"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIfExpr" ): listener.enterIfExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIfExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIfExpr" ): listener.exitIfExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIfExpr" ): + return visitor.visitIfExpr(self) + else: + return visitor.visitChildren(self) + + class ClauseExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.dataset = None # ExprContext - self.clause = None # DatasetClauseContext + self.dataset = None # ExprContext + self.clause = None # DatasetClauseContext self.copyFrom(ctx) def QLPAREN(self): return self.getToken(Parser.QLPAREN, 0) - def QRPAREN(self): return self.getToken(Parser.QRPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def datasetClause(self): - return self.getTypedRuleContext(Parser.DatasetClauseContext, 0) + return self.getTypedRuleContext(Parser.DatasetClauseContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterClauseExpr"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClauseExpr" ): listener.enterClauseExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitClauseExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClauseExpr" ): listener.exitClauseExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitClauseExpr" ): + return visitor.visitClauseExpr(self) + else: + return visitor.visitChildren(self) + + class CaseExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CASE(self): return self.getToken(Parser.CASE, 0) - def ELSE(self): return self.getToken(Parser.ELSE, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) - def WHEN(self, i: int = None): + def WHEN(self, i:int=None): if i is None: return self.getTokens(Parser.WHEN) else: return self.getToken(Parser.WHEN, i) - - def THEN(self, i: int = None): + def THEN(self, i:int=None): if i is None: return self.getTokens(Parser.THEN) else: return self.getToken(Parser.THEN, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCaseExpr"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCaseExpr" ): listener.enterCaseExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCaseExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCaseExpr" ): listener.exitCaseExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCaseExpr" ): + return visitor.visitCaseExpr(self) + else: + return visitor.visitChildren(self) + + class ArithmeticExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.op = None # Token - self.right = None # ExprContext + self.left = None # ExprContext + self.op = None # Token + self.right = None # ExprContext self.copyFrom(ctx) - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) def MUL(self): return self.getToken(Parser.MUL, 0) - def DIV(self): return self.getToken(Parser.DIV, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterArithmeticExpr"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArithmeticExpr" ): listener.enterArithmeticExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitArithmeticExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArithmeticExpr" ): listener.exitArithmeticExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitArithmeticExpr" ): + return visitor.visitArithmeticExpr(self) + else: + return visitor.visitChildren(self) + + class ParenthesisExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterParenthesisExpr"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParenthesisExpr" ): listener.enterParenthesisExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitParenthesisExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParenthesisExpr" ): listener.exitParenthesisExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitParenthesisExpr" ): + return visitor.visitParenthesisExpr(self) + else: + return visitor.visitChildren(self) + + class ConstantExprContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext, 0) + return self.getTypedRuleContext(Parser.ConstantContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterConstantExpr"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConstantExpr" ): listener.enterConstantExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitConstantExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConstantExpr" ): listener.exitConstantExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitConstantExpr" ): + return visitor.visitConstantExpr(self) + else: + return visitor.visitChildren(self) + + class ArithmeticExprOrConcatContext(ExprContext): - def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.op = None # Token - self.right = None # ExprContext + self.left = None # ExprContext + self.op = None # Token + self.right = None # ExprContext self.copyFrom(ctx) - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) def PLUS(self): return self.getToken(Parser.PLUS, 0) - def MINUS(self): return self.getToken(Parser.MINUS, 0) - def CONCAT(self): return self.getToken(Parser.CONCAT, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterArithmeticExprOrConcat"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArithmeticExprOrConcat" ): listener.enterArithmeticExprOrConcat(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitArithmeticExprOrConcat"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArithmeticExprOrConcat" ): listener.exitArithmeticExprOrConcat(self) - def expr(self, _p: int = 0): + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitArithmeticExprOrConcat" ): + return visitor.visitArithmeticExprOrConcat(self) + else: + return visitor.visitChildren(self) + + + + def expr(self, _p:int=0): _parentctx = self._ctx _parentState = self.state localctx = Parser.ExprContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 4 self.enterRecursionRule(localctx, 4, self.RULE_expr, _p) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 271 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 3, self._ctx) + la_ = self._interp.adaptivePredict(self._input,3,self._ctx) if la_ == 1: localctx = Parser.ParenthesisExprContext(self, localctx) self._ctx = localctx @@ -2565,13 +2240,7 @@ def expr(self, _p: int = 0): self.state = 247 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ((_la) & ~0x3F) == 0 - and ( - (1 << _la) & ((1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT)) - ) - != 0 - ): + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT))) != 0)): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2604,7 +2273,7 @@ def expr(self, _p: int = 0): _prevctx = localctx self.state = 256 self.match(Parser.CASE) - self.state = 262 + self.state = 262 self._errHandler.sync(self) _la = self._input.LA(1) while True: @@ -2616,10 +2285,10 @@ def expr(self, _p: int = 0): self.match(Parser.THEN) self.state = 260 self.expr(0) - self.state = 264 + self.state = 264 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la == Parser.WHEN): + if not (_la==Parser.WHEN): break self.state = 266 @@ -2644,33 +2313,31 @@ def expr(self, _p: int = 0): self.varID() pass + self._ctx.stop = self._input.LT(-1) self.state = 305 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input, 6, self._ctx) - while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: - if _alt == 1: + _alt = self._interp.adaptivePredict(self._input,6,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx self.state = 303 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 5, self._ctx) + la_ = self._interp.adaptivePredict(self._input,5,self._ctx) if la_ == 1: - localctx = Parser.ArithmeticExprContext( - self, Parser.ExprContext(self, _parentctx, _parentState) - ) + localctx = Parser.ArithmeticExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 273 if not self.precpred(self._ctx, 10): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 10)") self.state = 274 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.MUL or _la == Parser.DIV): + if not(_la==Parser.MUL or _la==Parser.DIV): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2680,20 +2347,17 @@ def expr(self, _p: int = 0): pass elif la_ == 2: - localctx = Parser.ArithmeticExprOrConcatContext( - self, Parser.ExprContext(self, _parentctx, _parentState) - ) + localctx = Parser.ArithmeticExprOrConcatContext(self, Parser.ExprContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 276 if not self.precpred(self._ctx, 9): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 9)") self.state = 277 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.PLUS or _la == Parser.MINUS or _la == Parser.CONCAT): + if not(_la==Parser.PLUS or _la==Parser.MINUS or _la==Parser.CONCAT): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2703,15 +2367,12 @@ def expr(self, _p: int = 0): pass elif la_ == 3: - localctx = Parser.ComparisonExprContext( - self, Parser.ExprContext(self, _parentctx, _parentState) - ) + localctx = Parser.ComparisonExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 279 if not self.precpred(self._ctx, 8): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 8)") self.state = 280 localctx.op = self.comparisonOperand() @@ -2720,15 +2381,12 @@ def expr(self, _p: int = 0): pass elif la_ == 4: - localctx = Parser.BooleanExprContext( - self, Parser.ExprContext(self, _parentctx, _parentState) - ) + localctx = Parser.BooleanExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 283 if not self.precpred(self._ctx, 6): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") self.state = 284 localctx.op = self.match(Parser.AND) @@ -2737,20 +2395,17 @@ def expr(self, _p: int = 0): pass elif la_ == 5: - localctx = Parser.BooleanExprContext( - self, Parser.ExprContext(self, _parentctx, _parentState) - ) + localctx = Parser.BooleanExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 286 if not self.precpred(self._ctx, 5): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") self.state = 287 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.OR or _la == Parser.XOR): + if not(_la==Parser.OR or _la==Parser.XOR): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2760,15 +2415,12 @@ def expr(self, _p: int = 0): pass elif la_ == 6: - localctx = Parser.ClauseExprContext( - self, Parser.ExprContext(self, _parentctx, _parentState) - ) + localctx = Parser.ClauseExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) localctx.dataset = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 289 if not self.precpred(self._ctx, 13): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 13)") self.state = 290 self.match(Parser.QLPAREN) @@ -2779,14 +2431,11 @@ def expr(self, _p: int = 0): pass elif la_ == 7: - localctx = Parser.MembershipExprContext( - self, Parser.ExprContext(self, _parentctx, _parentState) - ) + localctx = Parser.MembershipExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 294 if not self.precpred(self._ctx, 12): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 12)") self.state = 295 self.match(Parser.MEMBERSHIP) @@ -2795,20 +2444,17 @@ def expr(self, _p: int = 0): pass elif la_ == 8: - localctx = Parser.InNotInExprContext( - self, Parser.ExprContext(self, _parentctx, _parentState) - ) + localctx = Parser.InNotInExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 297 if not self.precpred(self._ctx, 7): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 7)") self.state = 298 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.IN or _la == Parser.NOT_IN): + if not(_la==Parser.IN or _la==Parser.NOT_IN): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2829,9 +2475,10 @@ def expr(self, _p: int = 0): pass + self.state = 307 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input, 6, self._ctx) + _alt = self._interp.adaptivePredict(self._input,6,self._ctx) except RecognitionException as re: localctx.exception = re @@ -2841,365 +2488,432 @@ def expr(self, _p: int = 0): self.unrollRecursionContexts(_parentctx) return localctx + class ExprComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_exprComponent - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + class ArithmeticExprCompContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.op = None # Token - self.right = None # ExprComponentContext + self.left = None # ExprComponentContext + self.op = None # Token + self.right = None # ExprComponentContext self.copyFrom(ctx) - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) def MUL(self): return self.getToken(Parser.MUL, 0) - def DIV(self): return self.getToken(Parser.DIV, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterArithmeticExprComp"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArithmeticExprComp" ): listener.enterArithmeticExprComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitArithmeticExprComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArithmeticExprComp" ): listener.exitArithmeticExprComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitArithmeticExprComp" ): + return visitor.visitArithmeticExprComp(self) + else: + return visitor.visitChildren(self) + + class IfExprCompContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.conditionalExpr = None # ExprComponentContext - self.thenExpr = None # ExprComponentContext - self.elseExpr = None # ExprComponentContext + self.conditionalExpr = None # ExprComponentContext + self.thenExpr = None # ExprComponentContext + self.elseExpr = None # ExprComponentContext self.copyFrom(ctx) def IF(self): return self.getToken(Parser.IF, 0) - def THEN(self): return self.getToken(Parser.THEN, 0) - def ELSE(self): return self.getToken(Parser.ELSE, 0) - - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIfExprComp"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIfExprComp" ): listener.enterIfExprComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIfExprComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIfExprComp" ): listener.exitIfExprComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIfExprComp" ): + return visitor.visitIfExprComp(self) + else: + return visitor.visitChildren(self) + + class ComparisonExprCompContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.right = None # ExprComponentContext + self.left = None # ExprComponentContext + self.right = None # ExprComponentContext self.copyFrom(ctx) def comparisonOperand(self): - return self.getTypedRuleContext(Parser.ComparisonOperandContext, 0) + return self.getTypedRuleContext(Parser.ComparisonOperandContext,0) - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterComparisonExprComp"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComparisonExprComp" ): listener.enterComparisonExprComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitComparisonExprComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComparisonExprComp" ): listener.exitComparisonExprComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitComparisonExprComp" ): + return visitor.visitComparisonExprComp(self) + else: + return visitor.visitChildren(self) + + class FunctionsExpressionCompContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def functionsComponents(self): - return self.getTypedRuleContext(Parser.FunctionsComponentsContext, 0) + return self.getTypedRuleContext(Parser.FunctionsComponentsContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFunctionsExpressionComp"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunctionsExpressionComp" ): listener.enterFunctionsExpressionComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFunctionsExpressionComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunctionsExpressionComp" ): listener.exitFunctionsExpressionComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFunctionsExpressionComp" ): + return visitor.visitFunctionsExpressionComp(self) + else: + return visitor.visitChildren(self) + + class CompIdContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext, 0) + return self.getTypedRuleContext(Parser.ComponentIDContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCompId"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCompId" ): listener.enterCompId(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCompId"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCompId" ): listener.exitCompId(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCompId" ): + return visitor.visitCompId(self) + else: + return visitor.visitChildren(self) + + class ConstantExprCompContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext, 0) + return self.getTypedRuleContext(Parser.ConstantContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterConstantExprComp"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConstantExprComp" ): listener.enterConstantExprComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitConstantExprComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConstantExprComp" ): listener.exitConstantExprComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitConstantExprComp" ): + return visitor.visitConstantExprComp(self) + else: + return visitor.visitChildren(self) + + class ArithmeticExprOrConcatCompContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.op = None # Token - self.right = None # ExprComponentContext + self.left = None # ExprComponentContext + self.op = None # Token + self.right = None # ExprComponentContext self.copyFrom(ctx) - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) def PLUS(self): return self.getToken(Parser.PLUS, 0) - def MINUS(self): return self.getToken(Parser.MINUS, 0) - def CONCAT(self): return self.getToken(Parser.CONCAT, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterArithmeticExprOrConcatComp"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArithmeticExprOrConcatComp" ): listener.enterArithmeticExprOrConcatComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitArithmeticExprOrConcatComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArithmeticExprOrConcatComp" ): listener.exitArithmeticExprOrConcatComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitArithmeticExprOrConcatComp" ): + return visitor.visitArithmeticExprOrConcatComp(self) + else: + return visitor.visitChildren(self) + + class ParenthesisExprCompContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterParenthesisExprComp"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParenthesisExprComp" ): listener.enterParenthesisExprComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitParenthesisExprComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParenthesisExprComp" ): listener.exitParenthesisExprComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitParenthesisExprComp" ): + return visitor.visitParenthesisExprComp(self) + else: + return visitor.visitChildren(self) + + class InNotInExprCompContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.op = None # Token + self.left = None # ExprComponentContext + self.op = None # Token self.copyFrom(ctx) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def IN(self): return self.getToken(Parser.IN, 0) - def NOT_IN(self): return self.getToken(Parser.NOT_IN, 0) - def lists(self): - return self.getTypedRuleContext(Parser.ListsContext, 0) + return self.getTypedRuleContext(Parser.ListsContext,0) def valueDomainID(self): - return self.getTypedRuleContext(Parser.ValueDomainIDContext, 0) + return self.getTypedRuleContext(Parser.ValueDomainIDContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterInNotInExprComp"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInNotInExprComp" ): listener.enterInNotInExprComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitInNotInExprComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInNotInExprComp" ): listener.exitInNotInExprComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInNotInExprComp" ): + return visitor.visitInNotInExprComp(self) + else: + return visitor.visitChildren(self) + + class UnaryExprCompContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.right = None # ExprComponentContext + self.op = None # Token + self.right = None # ExprComponentContext self.copyFrom(ctx) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def PLUS(self): return self.getToken(Parser.PLUS, 0) - def MINUS(self): return self.getToken(Parser.MINUS, 0) - def NOT(self): return self.getToken(Parser.NOT, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterUnaryExprComp"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnaryExprComp" ): listener.enterUnaryExprComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitUnaryExprComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnaryExprComp" ): listener.exitUnaryExprComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUnaryExprComp" ): + return visitor.visitUnaryExprComp(self) + else: + return visitor.visitChildren(self) + + class CaseExprCompContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CASE(self): return self.getToken(Parser.CASE, 0) - def ELSE(self): return self.getToken(Parser.ELSE, 0) - - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) - def WHEN(self, i: int = None): + def WHEN(self, i:int=None): if i is None: return self.getTokens(Parser.WHEN) else: return self.getToken(Parser.WHEN, i) - - def THEN(self, i: int = None): + def THEN(self, i:int=None): if i is None: return self.getTokens(Parser.THEN) else: return self.getToken(Parser.THEN, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCaseExprComp"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCaseExprComp" ): listener.enterCaseExprComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCaseExprComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCaseExprComp" ): listener.exitCaseExprComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCaseExprComp" ): + return visitor.visitCaseExprComp(self) + else: + return visitor.visitChildren(self) + + class BooleanExprCompContext(ExprComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ExprComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.op = None # Token - self.right = None # ExprComponentContext + self.left = None # ExprComponentContext + self.op = None # Token + self.right = None # ExprComponentContext self.copyFrom(ctx) - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) def AND(self): return self.getToken(Parser.AND, 0) - def OR(self): return self.getToken(Parser.OR, 0) - def XOR(self): return self.getToken(Parser.XOR, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterBooleanExprComp"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBooleanExprComp" ): listener.enterBooleanExprComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitBooleanExprComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBooleanExprComp" ): listener.exitBooleanExprComp(self) - def exprComponent(self, _p: int = 0): + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBooleanExprComp" ): + return visitor.visitBooleanExprComp(self) + else: + return visitor.visitChildren(self) + + + + def exprComponent(self, _p:int=0): _parentctx = self._ctx _parentState = self.state localctx = Parser.ExprComponentContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 6 self.enterRecursionRule(localctx, 6, self.RULE_exprComponent, _p) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 338 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 8, self._ctx) + la_ = self._interp.adaptivePredict(self._input,8,self._ctx) if la_ == 1: localctx = Parser.ParenthesisExprCompContext(self, localctx) self._ctx = localctx @@ -3228,13 +2942,7 @@ def exprComponent(self, _p: int = 0): self.state = 314 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ((_la) & ~0x3F) == 0 - and ( - (1 << _la) & ((1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT)) - ) - != 0 - ): + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT))) != 0)): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3267,7 +2975,7 @@ def exprComponent(self, _p: int = 0): _prevctx = localctx self.state = 323 self.match(Parser.CASE) - self.state = 329 + self.state = 329 self._errHandler.sync(self) _la = self._input.LA(1) while True: @@ -3279,10 +2987,10 @@ def exprComponent(self, _p: int = 0): self.match(Parser.THEN) self.state = 327 self.exprComponent(0) - self.state = 331 + self.state = 331 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la == Parser.WHEN): + if not (_la==Parser.WHEN): break self.state = 333 @@ -3307,33 +3015,31 @@ def exprComponent(self, _p: int = 0): self.componentID() pass + self._ctx.stop = self._input.LT(-1) self.state = 364 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input, 11, self._ctx) - while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: - if _alt == 1: + _alt = self._interp.adaptivePredict(self._input,11,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx self.state = 362 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 10, self._ctx) + la_ = self._interp.adaptivePredict(self._input,10,self._ctx) if la_ == 1: - localctx = Parser.ArithmeticExprCompContext( - self, Parser.ExprComponentContext(self, _parentctx, _parentState) - ) + localctx = Parser.ArithmeticExprCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 340 if not self.precpred(self._ctx, 10): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 10)") self.state = 341 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.MUL or _la == Parser.DIV): + if not(_la==Parser.MUL or _la==Parser.DIV): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3343,20 +3049,17 @@ def exprComponent(self, _p: int = 0): pass elif la_ == 2: - localctx = Parser.ArithmeticExprOrConcatCompContext( - self, Parser.ExprComponentContext(self, _parentctx, _parentState) - ) + localctx = Parser.ArithmeticExprOrConcatCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 343 if not self.precpred(self._ctx, 9): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 9)") self.state = 344 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.PLUS or _la == Parser.MINUS or _la == Parser.CONCAT): + if not(_la==Parser.PLUS or _la==Parser.MINUS or _la==Parser.CONCAT): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3366,15 +3069,12 @@ def exprComponent(self, _p: int = 0): pass elif la_ == 3: - localctx = Parser.ComparisonExprCompContext( - self, Parser.ExprComponentContext(self, _parentctx, _parentState) - ) + localctx = Parser.ComparisonExprCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 346 if not self.precpred(self._ctx, 8): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 8)") self.state = 347 self.comparisonOperand() @@ -3383,15 +3083,12 @@ def exprComponent(self, _p: int = 0): pass elif la_ == 4: - localctx = Parser.BooleanExprCompContext( - self, Parser.ExprComponentContext(self, _parentctx, _parentState) - ) + localctx = Parser.BooleanExprCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 350 if not self.precpred(self._ctx, 6): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") self.state = 351 localctx.op = self.match(Parser.AND) @@ -3400,20 +3097,17 @@ def exprComponent(self, _p: int = 0): pass elif la_ == 5: - localctx = Parser.BooleanExprCompContext( - self, Parser.ExprComponentContext(self, _parentctx, _parentState) - ) + localctx = Parser.BooleanExprCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 353 if not self.precpred(self._ctx, 5): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") self.state = 354 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.OR or _la == Parser.XOR): + if not(_la==Parser.OR or _la==Parser.XOR): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3423,20 +3117,17 @@ def exprComponent(self, _p: int = 0): pass elif la_ == 6: - localctx = Parser.InNotInExprCompContext( - self, Parser.ExprComponentContext(self, _parentctx, _parentState) - ) + localctx = Parser.InNotInExprCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 356 if not self.precpred(self._ctx, 7): from antlr4.error.Errors import FailedPredicateException - raise FailedPredicateException(self, "self.precpred(self._ctx, 7)") self.state = 357 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.IN or _la == Parser.NOT_IN): + if not(_la==Parser.IN or _la==Parser.NOT_IN): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3457,9 +3148,10 @@ def exprComponent(self, _p: int = 0): pass + self.state = 366 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input, 11, self._ctx) + _alt = self._interp.adaptivePredict(self._input,11,self._ctx) except RecognitionException as re: localctx.exception = re @@ -3469,170 +3161,233 @@ def exprComponent(self, _p: int = 0): self.unrollRecursionContexts(_parentctx) return localctx + class FunctionsComponentsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_functionsComponents - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class NumericFunctionsComponentsContext(FunctionsComponentsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsComponentsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def numericOperatorsComponent(self): - return self.getTypedRuleContext(Parser.NumericOperatorsComponentContext, 0) + return self.getTypedRuleContext(Parser.NumericOperatorsComponentContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterNumericFunctionsComponents"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNumericFunctionsComponents" ): listener.enterNumericFunctionsComponents(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitNumericFunctionsComponents"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNumericFunctionsComponents" ): listener.exitNumericFunctionsComponents(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitNumericFunctionsComponents" ): + return visitor.visitNumericFunctionsComponents(self) + else: + return visitor.visitChildren(self) + + class StringFunctionsComponentsContext(FunctionsComponentsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsComponentsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def stringOperatorsComponent(self): - return self.getTypedRuleContext(Parser.StringOperatorsComponentContext, 0) + return self.getTypedRuleContext(Parser.StringOperatorsComponentContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterStringFunctionsComponents"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStringFunctionsComponents" ): listener.enterStringFunctionsComponents(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitStringFunctionsComponents"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStringFunctionsComponents" ): listener.exitStringFunctionsComponents(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitStringFunctionsComponents" ): + return visitor.visitStringFunctionsComponents(self) + else: + return visitor.visitChildren(self) + + class ComparisonFunctionsComponentsContext(FunctionsComponentsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsComponentsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def comparisonOperatorsComponent(self): - return self.getTypedRuleContext(Parser.ComparisonOperatorsComponentContext, 0) + return self.getTypedRuleContext(Parser.ComparisonOperatorsComponentContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterComparisonFunctionsComponents"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComparisonFunctionsComponents" ): listener.enterComparisonFunctionsComponents(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitComparisonFunctionsComponents"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComparisonFunctionsComponents" ): listener.exitComparisonFunctionsComponents(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitComparisonFunctionsComponents" ): + return visitor.visitComparisonFunctionsComponents(self) + else: + return visitor.visitChildren(self) + + class TimeFunctionsComponentsContext(FunctionsComponentsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsComponentsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def timeOperatorsComponent(self): - return self.getTypedRuleContext(Parser.TimeOperatorsComponentContext, 0) + return self.getTypedRuleContext(Parser.TimeOperatorsComponentContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimeFunctionsComponents"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimeFunctionsComponents" ): listener.enterTimeFunctionsComponents(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimeFunctionsComponents"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimeFunctionsComponents" ): listener.exitTimeFunctionsComponents(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimeFunctionsComponents" ): + return visitor.visitTimeFunctionsComponents(self) + else: + return visitor.visitChildren(self) + + class GenericFunctionsComponentsContext(FunctionsComponentsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsComponentsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def genericOperatorsComponent(self): - return self.getTypedRuleContext(Parser.GenericOperatorsComponentContext, 0) + return self.getTypedRuleContext(Parser.GenericOperatorsComponentContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterGenericFunctionsComponents"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGenericFunctionsComponents" ): listener.enterGenericFunctionsComponents(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitGenericFunctionsComponents"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGenericFunctionsComponents" ): listener.exitGenericFunctionsComponents(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitGenericFunctionsComponents" ): + return visitor.visitGenericFunctionsComponents(self) + else: + return visitor.visitChildren(self) + + class AnalyticFunctionsComponentsContext(FunctionsComponentsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsComponentsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def anFunctionComponent(self): - return self.getTypedRuleContext(Parser.AnFunctionComponentContext, 0) + return self.getTypedRuleContext(Parser.AnFunctionComponentContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAnalyticFunctionsComponents"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAnalyticFunctionsComponents" ): listener.enterAnalyticFunctionsComponents(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAnalyticFunctionsComponents"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAnalyticFunctionsComponents" ): listener.exitAnalyticFunctionsComponents(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAnalyticFunctionsComponents" ): + return visitor.visitAnalyticFunctionsComponents(self) + else: + return visitor.visitChildren(self) + + class ConditionalFunctionsComponentsContext(FunctionsComponentsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsComponentsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def conditionalOperatorsComponent(self): - return self.getTypedRuleContext(Parser.ConditionalOperatorsComponentContext, 0) + return self.getTypedRuleContext(Parser.ConditionalOperatorsComponentContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterConditionalFunctionsComponents"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConditionalFunctionsComponents" ): listener.enterConditionalFunctionsComponents(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitConditionalFunctionsComponents"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConditionalFunctionsComponents" ): listener.exitConditionalFunctionsComponents(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitConditionalFunctionsComponents" ): + return visitor.visitConditionalFunctionsComponents(self) + else: + return visitor.visitChildren(self) + + class AggregateFunctionsComponentsContext(FunctionsComponentsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsComponentsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def aggrOperators(self): - return self.getTypedRuleContext(Parser.AggrOperatorsContext, 0) + return self.getTypedRuleContext(Parser.AggrOperatorsContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAggregateFunctionsComponents"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAggregateFunctionsComponents" ): listener.enterAggregateFunctionsComponents(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAggregateFunctionsComponents"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAggregateFunctionsComponents" ): listener.exitAggregateFunctionsComponents(self) - def functionsComponents(self): - localctx = Parser.FunctionsComponentsContext(self, self._ctx, self.state) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAggregateFunctionsComponents" ): + return visitor.visitAggregateFunctionsComponents(self) + else: + return visitor.visitChildren(self) + + + + def functionsComponents(self): + + localctx = Parser.FunctionsComponentsContext(self, self._ctx, self.state) self.enterRule(localctx, 8, self.RULE_functionsComponents) try: self.state = 375 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 12, self._ctx) + la_ = self._interp.adaptivePredict(self._input,12,self._ctx) if la_ == 1: localctx = Parser.GenericFunctionsComponentsContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3689,6 +3444,7 @@ def functionsComponents(self): self.anFunctionComponent() pass + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -3697,242 +3453,333 @@ def functionsComponents(self): self.exitRule() return localctx + class FunctionsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_functions - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class HierarchyFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def hierarchyOperators(self): - return self.getTypedRuleContext(Parser.HierarchyOperatorsContext, 0) + return self.getTypedRuleContext(Parser.HierarchyOperatorsContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterHierarchyFunctions"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHierarchyFunctions" ): listener.enterHierarchyFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitHierarchyFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHierarchyFunctions" ): listener.exitHierarchyFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitHierarchyFunctions" ): + return visitor.visitHierarchyFunctions(self) + else: + return visitor.visitChildren(self) + + class StringFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def stringOperators(self): - return self.getTypedRuleContext(Parser.StringOperatorsContext, 0) + return self.getTypedRuleContext(Parser.StringOperatorsContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterStringFunctions"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStringFunctions" ): listener.enterStringFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitStringFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStringFunctions" ): listener.exitStringFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitStringFunctions" ): + return visitor.visitStringFunctions(self) + else: + return visitor.visitChildren(self) + + class ValidationFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def validationOperators(self): - return self.getTypedRuleContext(Parser.ValidationOperatorsContext, 0) + return self.getTypedRuleContext(Parser.ValidationOperatorsContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterValidationFunctions"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValidationFunctions" ): listener.enterValidationFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitValidationFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValidationFunctions" ): listener.exitValidationFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitValidationFunctions" ): + return visitor.visitValidationFunctions(self) + else: + return visitor.visitChildren(self) + + class GenericFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def genericOperators(self): - return self.getTypedRuleContext(Parser.GenericOperatorsContext, 0) + return self.getTypedRuleContext(Parser.GenericOperatorsContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterGenericFunctions"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGenericFunctions" ): listener.enterGenericFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitGenericFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGenericFunctions" ): listener.exitGenericFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitGenericFunctions" ): + return visitor.visitGenericFunctions(self) + else: + return visitor.visitChildren(self) + + class ConditionalFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def conditionalOperators(self): - return self.getTypedRuleContext(Parser.ConditionalOperatorsContext, 0) + return self.getTypedRuleContext(Parser.ConditionalOperatorsContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterConditionalFunctions"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConditionalFunctions" ): listener.enterConditionalFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitConditionalFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConditionalFunctions" ): listener.exitConditionalFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitConditionalFunctions" ): + return visitor.visitConditionalFunctions(self) + else: + return visitor.visitChildren(self) + + class AggregateFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def aggrOperatorsGrouping(self): - return self.getTypedRuleContext(Parser.AggrOperatorsGroupingContext, 0) + return self.getTypedRuleContext(Parser.AggrOperatorsGroupingContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAggregateFunctions"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAggregateFunctions" ): listener.enterAggregateFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAggregateFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAggregateFunctions" ): listener.exitAggregateFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAggregateFunctions" ): + return visitor.visitAggregateFunctions(self) + else: + return visitor.visitChildren(self) + + class JoinFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def joinOperators(self): - return self.getTypedRuleContext(Parser.JoinOperatorsContext, 0) + return self.getTypedRuleContext(Parser.JoinOperatorsContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterJoinFunctions"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterJoinFunctions" ): listener.enterJoinFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitJoinFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitJoinFunctions" ): listener.exitJoinFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitJoinFunctions" ): + return visitor.visitJoinFunctions(self) + else: + return visitor.visitChildren(self) + + class ComparisonFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def comparisonOperators(self): - return self.getTypedRuleContext(Parser.ComparisonOperatorsContext, 0) + return self.getTypedRuleContext(Parser.ComparisonOperatorsContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterComparisonFunctions"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComparisonFunctions" ): listener.enterComparisonFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitComparisonFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComparisonFunctions" ): listener.exitComparisonFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitComparisonFunctions" ): + return visitor.visitComparisonFunctions(self) + else: + return visitor.visitChildren(self) + + class NumericFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def numericOperators(self): - return self.getTypedRuleContext(Parser.NumericOperatorsContext, 0) + return self.getTypedRuleContext(Parser.NumericOperatorsContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterNumericFunctions"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNumericFunctions" ): listener.enterNumericFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitNumericFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNumericFunctions" ): listener.exitNumericFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitNumericFunctions" ): + return visitor.visitNumericFunctions(self) + else: + return visitor.visitChildren(self) + + class TimeFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def timeOperators(self): - return self.getTypedRuleContext(Parser.TimeOperatorsContext, 0) + return self.getTypedRuleContext(Parser.TimeOperatorsContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimeFunctions"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimeFunctions" ): listener.enterTimeFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimeFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimeFunctions" ): listener.exitTimeFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimeFunctions" ): + return visitor.visitTimeFunctions(self) + else: + return visitor.visitChildren(self) + + class SetFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def setOperators(self): - return self.getTypedRuleContext(Parser.SetOperatorsContext, 0) + return self.getTypedRuleContext(Parser.SetOperatorsContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterSetFunctions"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSetFunctions" ): listener.enterSetFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitSetFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSetFunctions" ): listener.exitSetFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSetFunctions" ): + return visitor.visitSetFunctions(self) + else: + return visitor.visitChildren(self) + + class AnalyticFunctionsContext(FunctionsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.FunctionsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def anFunction(self): - return self.getTypedRuleContext(Parser.AnFunctionContext, 0) + return self.getTypedRuleContext(Parser.AnFunctionContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAnalyticFunctions"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAnalyticFunctions" ): listener.enterAnalyticFunctions(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAnalyticFunctions"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAnalyticFunctions" ): listener.exitAnalyticFunctions(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAnalyticFunctions" ): + return visitor.visitAnalyticFunctions(self) + else: + return visitor.visitChildren(self) + + + def functions(self): + localctx = Parser.FunctionsContext(self, self._ctx, self.state) self.enterRule(localctx, 10, self.RULE_functions) try: self.state = 389 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 13, self._ctx) + la_ = self._interp.adaptivePredict(self._input,13,self._ctx) if la_ == 1: localctx = Parser.JoinFunctionsContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -4017,6 +3864,7 @@ def functions(self): self.anFunction() pass + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -4025,46 +3873,64 @@ def functions(self): self.exitRule() return localctx + class DatasetClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def renameClause(self): - return self.getTypedRuleContext(Parser.RenameClauseContext, 0) + return self.getTypedRuleContext(Parser.RenameClauseContext,0) + def aggrClause(self): - return self.getTypedRuleContext(Parser.AggrClauseContext, 0) + return self.getTypedRuleContext(Parser.AggrClauseContext,0) + def filterClause(self): - return self.getTypedRuleContext(Parser.FilterClauseContext, 0) + return self.getTypedRuleContext(Parser.FilterClauseContext,0) + def calcClause(self): - return self.getTypedRuleContext(Parser.CalcClauseContext, 0) + return self.getTypedRuleContext(Parser.CalcClauseContext,0) + def keepOrDropClause(self): - return self.getTypedRuleContext(Parser.KeepOrDropClauseContext, 0) + return self.getTypedRuleContext(Parser.KeepOrDropClauseContext,0) + def pivotOrUnpivotClause(self): - return self.getTypedRuleContext(Parser.PivotOrUnpivotClauseContext, 0) + return self.getTypedRuleContext(Parser.PivotOrUnpivotClauseContext,0) + def subspaceClause(self): - return self.getTypedRuleContext(Parser.SubspaceClauseContext, 0) + return self.getTypedRuleContext(Parser.SubspaceClauseContext,0) + def getRuleIndex(self): return Parser.RULE_datasetClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDatasetClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDatasetClause" ): listener.enterDatasetClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDatasetClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDatasetClause" ): listener.exitDatasetClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDatasetClause" ): + return visitor.visitDatasetClause(self) + else: + return visitor.visitChildren(self) + + + + def datasetClause(self): + localctx = Parser.DatasetClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 12, self.RULE_datasetClause) try: @@ -4117,23 +3983,25 @@ def datasetClause(self): self.exitRule() return localctx + class RenameClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def RENAME(self): return self.getToken(Parser.RENAME, 0) - def renameClauseItem(self, i: int = None): + def renameClauseItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.RenameClauseItemContext) else: - return self.getTypedRuleContext(Parser.RenameClauseItemContext, i) + return self.getTypedRuleContext(Parser.RenameClauseItemContext,i) - def COMMA(self, i: int = None): + + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -4142,18 +4010,28 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_renameClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRenameClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRenameClause" ): listener.enterRenameClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRenameClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRenameClause" ): listener.exitRenameClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRenameClause" ): + return visitor.visitRenameClause(self) + else: + return visitor.visitChildren(self) + + + + def renameClause(self): + localctx = Parser.RenameClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 14, self.RULE_renameClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 400 @@ -4163,7 +4041,7 @@ def renameClause(self): self.state = 406 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 402 self.match(Parser.COMMA) self.state = 403 @@ -4180,10 +4058,11 @@ def renameClause(self): self.exitRule() return localctx + class AggrClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -4191,29 +4070,42 @@ def AGGREGATE(self): return self.getToken(Parser.AGGREGATE, 0) def aggregateClause(self): - return self.getTypedRuleContext(Parser.AggregateClauseContext, 0) + return self.getTypedRuleContext(Parser.AggregateClauseContext,0) + def groupingClause(self): - return self.getTypedRuleContext(Parser.GroupingClauseContext, 0) + return self.getTypedRuleContext(Parser.GroupingClauseContext,0) + def havingClause(self): - return self.getTypedRuleContext(Parser.HavingClauseContext, 0) + return self.getTypedRuleContext(Parser.HavingClauseContext,0) + def getRuleIndex(self): return Parser.RULE_aggrClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAggrClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAggrClause" ): listener.enterAggrClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAggrClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAggrClause" ): listener.exitAggrClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAggrClause" ): + return visitor.visitAggrClause(self) + else: + return visitor.visitChildren(self) + + + + def aggrClause(self): + localctx = Parser.AggrClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 16, self.RULE_aggrClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 409 @@ -4223,16 +4115,19 @@ def aggrClause(self): self.state = 415 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.GROUP: + if _la==Parser.GROUP: self.state = 411 self.groupingClause() self.state = 413 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.HAVING: + if _la==Parser.HAVING: self.state = 412 self.havingClause() + + + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -4241,10 +4136,11 @@ def aggrClause(self): self.exitRule() return localctx + class FilterClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -4252,20 +4148,31 @@ def FILTER(self): return self.getToken(Parser.FILTER, 0) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) + def getRuleIndex(self): return Parser.RULE_filterClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFilterClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFilterClause" ): listener.enterFilterClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFilterClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFilterClause" ): listener.exitFilterClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFilterClause" ): + return visitor.visitFilterClause(self) + else: + return visitor.visitChildren(self) + + + + def filterClause(self): + localctx = Parser.FilterClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 18, self.RULE_filterClause) try: @@ -4282,23 +4189,25 @@ def filterClause(self): self.exitRule() return localctx + class CalcClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def CALC(self): return self.getToken(Parser.CALC, 0) - def calcClauseItem(self, i: int = None): + def calcClauseItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.CalcClauseItemContext) else: - return self.getTypedRuleContext(Parser.CalcClauseItemContext, i) + return self.getTypedRuleContext(Parser.CalcClauseItemContext,i) + - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -4307,18 +4216,28 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_calcClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCalcClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCalcClause" ): listener.enterCalcClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCalcClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCalcClause" ): listener.exitCalcClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCalcClause" ): + return visitor.visitCalcClause(self) + else: + return visitor.visitChildren(self) + + + + def calcClause(self): + localctx = Parser.CalcClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 20, self.RULE_calcClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 420 @@ -4328,7 +4247,7 @@ def calcClause(self): self.state = 426 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 422 self.match(Parser.COMMA) self.state = 423 @@ -4345,19 +4264,21 @@ def calcClause(self): self.exitRule() return localctx + class KeepOrDropClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.op = None # Token + self.op = None # Token - def componentID(self, i: int = None): + def componentID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext, i) + return self.getTypedRuleContext(Parser.ComponentIDContext,i) + def KEEP(self): return self.getToken(Parser.KEEP, 0) @@ -4365,7 +4286,7 @@ def KEEP(self): def DROP(self): return self.getToken(Parser.DROP, 0) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -4374,24 +4295,34 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_keepOrDropClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterKeepOrDropClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterKeepOrDropClause" ): listener.enterKeepOrDropClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitKeepOrDropClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitKeepOrDropClause" ): listener.exitKeepOrDropClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitKeepOrDropClause" ): + return visitor.visitKeepOrDropClause(self) + else: + return visitor.visitChildren(self) + + + + def keepOrDropClause(self): + localctx = Parser.KeepOrDropClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 22, self.RULE_keepOrDropClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 429 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.DROP or _la == Parser.KEEP): + if not(_la==Parser.DROP or _la==Parser.KEEP): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4401,7 +4332,7 @@ def keepOrDropClause(self): self.state = 435 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 431 self.match(Parser.COMMA) self.state = 432 @@ -4418,24 +4349,26 @@ def keepOrDropClause(self): self.exitRule() return localctx + class PivotOrUnpivotClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.op = None # Token - self.id_ = None # ComponentIDContext - self.mea = None # ComponentIDContext + self.op = None # Token + self.id_ = None # ComponentIDContext + self.mea = None # ComponentIDContext def COMMA(self): return self.getToken(Parser.COMMA, 0) - def componentID(self, i: int = None): + def componentID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext, i) + return self.getTypedRuleContext(Parser.ComponentIDContext,i) + def PIVOT(self): return self.getToken(Parser.PIVOT, 0) @@ -4446,24 +4379,34 @@ def UNPIVOT(self): def getRuleIndex(self): return Parser.RULE_pivotOrUnpivotClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterPivotOrUnpivotClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPivotOrUnpivotClause" ): listener.enterPivotOrUnpivotClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitPivotOrUnpivotClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPivotOrUnpivotClause" ): listener.exitPivotOrUnpivotClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPivotOrUnpivotClause" ): + return visitor.visitPivotOrUnpivotClause(self) + else: + return visitor.visitChildren(self) + + + + def pivotOrUnpivotClause(self): + localctx = Parser.PivotOrUnpivotClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 24, self.RULE_pivotOrUnpivotClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 438 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.PIVOT or _la == Parser.UNPIVOT): + if not(_la==Parser.PIVOT or _la==Parser.UNPIVOT): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4482,19 +4425,20 @@ def pivotOrUnpivotClause(self): self.exitRule() return localctx + class CustomPivotClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.id_ = None # ComponentIDContext - self.mea = None # ComponentIDContext + self.id_ = None # ComponentIDContext + self.mea = None # ComponentIDContext def CUSTOMPIVOT(self): return self.getToken(Parser.CUSTOMPIVOT, 0) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -4503,33 +4447,45 @@ def COMMA(self, i: int = None): def IN(self): return self.getToken(Parser.IN, 0) - def constant(self, i: int = None): + def constant(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ConstantContext) else: - return self.getTypedRuleContext(Parser.ConstantContext, i) + return self.getTypedRuleContext(Parser.ConstantContext,i) + - def componentID(self, i: int = None): + def componentID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext, i) + return self.getTypedRuleContext(Parser.ComponentIDContext,i) + def getRuleIndex(self): return Parser.RULE_customPivotClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCustomPivotClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCustomPivotClause" ): listener.enterCustomPivotClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCustomPivotClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCustomPivotClause" ): listener.exitCustomPivotClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCustomPivotClause" ): + return visitor.visitCustomPivotClause(self) + else: + return visitor.visitChildren(self) + + + + def customPivotClause(self): + localctx = Parser.CustomPivotClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 26, self.RULE_customPivotClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 443 @@ -4547,7 +4503,7 @@ def customPivotClause(self): self.state = 453 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 449 self.match(Parser.COMMA) self.state = 450 @@ -4564,23 +4520,25 @@ def customPivotClause(self): self.exitRule() return localctx + class SubspaceClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def SUBSPACE(self): return self.getToken(Parser.SUBSPACE, 0) - def subspaceClauseItem(self, i: int = None): + def subspaceClauseItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.SubspaceClauseItemContext) else: - return self.getTypedRuleContext(Parser.SubspaceClauseItemContext, i) + return self.getTypedRuleContext(Parser.SubspaceClauseItemContext,i) - def COMMA(self, i: int = None): + + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -4589,18 +4547,28 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_subspaceClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterSubspaceClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubspaceClause" ): listener.enterSubspaceClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitSubspaceClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubspaceClause" ): listener.exitSubspaceClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSubspaceClause" ): + return visitor.visitSubspaceClause(self) + else: + return visitor.visitChildren(self) + + + + def subspaceClause(self): + localctx = Parser.SubspaceClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 28, self.RULE_subspaceClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 456 @@ -4610,7 +4578,7 @@ def subspaceClause(self): self.state = 462 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 458 self.match(Parser.COMMA) self.state = 459 @@ -4627,66 +4595,74 @@ def subspaceClause(self): self.exitRule() return localctx + class JoinOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_joinOperators - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class JoinExprContext(JoinOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.JoinOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.JoinOperatorsContext super().__init__(ANTLRParser) - self.joinKeyword = None # Token + self.joinKeyword = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def joinClause(self): - return self.getTypedRuleContext(Parser.JoinClauseContext, 0) + return self.getTypedRuleContext(Parser.JoinClauseContext,0) def joinBody(self): - return self.getTypedRuleContext(Parser.JoinBodyContext, 0) + return self.getTypedRuleContext(Parser.JoinBodyContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def INNER_JOIN(self): return self.getToken(Parser.INNER_JOIN, 0) - def LEFT_JOIN(self): return self.getToken(Parser.LEFT_JOIN, 0) - def joinClauseWithoutUsing(self): - return self.getTypedRuleContext(Parser.JoinClauseWithoutUsingContext, 0) + return self.getTypedRuleContext(Parser.JoinClauseWithoutUsingContext,0) def FULL_JOIN(self): return self.getToken(Parser.FULL_JOIN, 0) - def CROSS_JOIN(self): return self.getToken(Parser.CROSS_JOIN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterJoinExpr"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterJoinExpr" ): listener.enterJoinExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitJoinExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitJoinExpr" ): listener.exitJoinExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitJoinExpr" ): + return visitor.visitJoinExpr(self) + else: + return visitor.visitChildren(self) + + + def joinOperators(self): + localctx = Parser.JoinOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 30, self.RULE_joinOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 477 self._errHandler.sync(self) @@ -4697,7 +4673,7 @@ def joinOperators(self): self.state = 465 localctx.joinKeyword = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.INNER_JOIN or _la == Parser.LEFT_JOIN): + if not(_la==Parser.INNER_JOIN or _la==Parser.LEFT_JOIN): localctx.joinKeyword = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4717,7 +4693,7 @@ def joinOperators(self): self.state = 471 localctx.joinKeyword = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.CROSS_JOIN or _la == Parser.FULL_JOIN): + if not(_la==Parser.CROSS_JOIN or _la==Parser.FULL_JOIN): localctx.joinKeyword = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4742,189 +4718,195 @@ def joinOperators(self): self.exitRule() return localctx + class DefOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_defOperators - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class DefOperatorContext(DefOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.DefOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DefOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DEFINE(self): return self.getToken(Parser.DEFINE, 0) - - def OPERATOR(self, i: int = None): + def OPERATOR(self, i:int=None): if i is None: return self.getTokens(Parser.OPERATOR) else: return self.getToken(Parser.OPERATOR, i) - def operatorID(self): - return self.getTypedRuleContext(Parser.OperatorIDContext, 0) + return self.getTypedRuleContext(Parser.OperatorIDContext,0) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def IS(self): return self.getToken(Parser.IS, 0) - def END(self): return self.getToken(Parser.END, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) - def parameterItem(self, i: int = None): + def parameterItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ParameterItemContext) else: - return self.getTypedRuleContext(Parser.ParameterItemContext, i) + return self.getTypedRuleContext(Parser.ParameterItemContext,i) def RETURNS(self): return self.getToken(Parser.RETURNS, 0) - def outputParameterType(self): - return self.getTypedRuleContext(Parser.OutputParameterTypeContext, 0) + return self.getTypedRuleContext(Parser.OutputParameterTypeContext,0) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDefOperator"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefOperator" ): listener.enterDefOperator(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDefOperator"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefOperator" ): listener.exitDefOperator(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDefOperator" ): + return visitor.visitDefOperator(self) + else: + return visitor.visitChildren(self) + + class DefHierarchicalContext(DefOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.DefOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DefOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DEFINE(self): return self.getToken(Parser.DEFINE, 0) - - def HIERARCHICAL(self, i: int = None): + def HIERARCHICAL(self, i:int=None): if i is None: return self.getTokens(Parser.HIERARCHICAL) else: return self.getToken(Parser.HIERARCHICAL, i) - - def RULESET(self, i: int = None): + def RULESET(self, i:int=None): if i is None: return self.getTokens(Parser.RULESET) else: return self.getToken(Parser.RULESET, i) - def rulesetID(self): - return self.getTypedRuleContext(Parser.RulesetIDContext, 0) + return self.getTypedRuleContext(Parser.RulesetIDContext,0) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def hierRuleSignature(self): - return self.getTypedRuleContext(Parser.HierRuleSignatureContext, 0) + return self.getTypedRuleContext(Parser.HierRuleSignatureContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def IS(self): return self.getToken(Parser.IS, 0) - def ruleClauseHierarchical(self): - return self.getTypedRuleContext(Parser.RuleClauseHierarchicalContext, 0) + return self.getTypedRuleContext(Parser.RuleClauseHierarchicalContext,0) def END(self): return self.getToken(Parser.END, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDefHierarchical"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefHierarchical" ): listener.enterDefHierarchical(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDefHierarchical"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefHierarchical" ): listener.exitDefHierarchical(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDefHierarchical" ): + return visitor.visitDefHierarchical(self) + else: + return visitor.visitChildren(self) + + class DefDatapointRulesetContext(DefOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.DefOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DefOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DEFINE(self): return self.getToken(Parser.DEFINE, 0) - - def DATAPOINT(self, i: int = None): + def DATAPOINT(self, i:int=None): if i is None: return self.getTokens(Parser.DATAPOINT) else: return self.getToken(Parser.DATAPOINT, i) - - def RULESET(self, i: int = None): + def RULESET(self, i:int=None): if i is None: return self.getTokens(Parser.RULESET) else: return self.getToken(Parser.RULESET, i) - def rulesetID(self): - return self.getTypedRuleContext(Parser.RulesetIDContext, 0) + return self.getTypedRuleContext(Parser.RulesetIDContext,0) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def rulesetSignature(self): - return self.getTypedRuleContext(Parser.RulesetSignatureContext, 0) + return self.getTypedRuleContext(Parser.RulesetSignatureContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def IS(self): return self.getToken(Parser.IS, 0) - def ruleClauseDatapoint(self): - return self.getTypedRuleContext(Parser.RuleClauseDatapointContext, 0) + return self.getTypedRuleContext(Parser.RuleClauseDatapointContext,0) def END(self): return self.getToken(Parser.END, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDefDatapointRuleset"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefDatapointRuleset" ): listener.enterDefDatapointRuleset(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDefDatapointRuleset"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefDatapointRuleset" ): listener.exitDefDatapointRuleset(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDefDatapointRuleset" ): + return visitor.visitDefDatapointRuleset(self) + else: + return visitor.visitChildren(self) + + + def defOperators(self): + localctx = Parser.DefOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 32, self.RULE_defOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 529 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 26, self._ctx) + la_ = self._interp.adaptivePredict(self._input,26,self._ctx) if la_ == 1: localctx = Parser.DefOperatorContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -4939,13 +4921,13 @@ def defOperators(self): self.state = 491 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.IDENTIFIER: + if _la==Parser.IDENTIFIER: self.state = 483 self.parameterItem() self.state = 488 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 484 self.match(Parser.COMMA) self.state = 485 @@ -4954,17 +4936,20 @@ def defOperators(self): self._errHandler.sync(self) _la = self._input.LA(1) + + self.state = 493 self.match(Parser.RPAREN) self.state = 496 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.RETURNS: + if _la==Parser.RETURNS: self.state = 494 self.match(Parser.RETURNS) self.state = 495 self.outputParameterType() + self.state = 498 self.match(Parser.IS) @@ -5034,6 +5019,7 @@ def defOperators(self): self.match(Parser.RULESET) pass + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -5042,164 +5028,177 @@ def defOperators(self): self.exitRule() return localctx + class GenericOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_genericOperators - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class EvalAtomContext(GenericOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.GenericOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def EVAL(self): return self.getToken(Parser.EVAL, 0) - - def LPAREN(self, i: int = None): + def LPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) - def routineName(self): - return self.getTypedRuleContext(Parser.RoutineNameContext, 0) + return self.getTypedRuleContext(Parser.RoutineNameContext,0) - def RPAREN(self, i: int = None): + def RPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) - - def varID(self, i: int = None): + def varID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.VarIDContext) else: - return self.getTypedRuleContext(Parser.VarIDContext, i) + return self.getTypedRuleContext(Parser.VarIDContext,i) - def scalarItem(self, i: int = None): + def scalarItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ScalarItemContext) else: - return self.getTypedRuleContext(Parser.ScalarItemContext, i) + return self.getTypedRuleContext(Parser.ScalarItemContext,i) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def LANGUAGE(self): return self.getToken(Parser.LANGUAGE, 0) - def STRING_CONSTANT(self): return self.getToken(Parser.STRING_CONSTANT, 0) - def RETURNS(self): return self.getToken(Parser.RETURNS, 0) - def evalDatasetType(self): - return self.getTypedRuleContext(Parser.EvalDatasetTypeContext, 0) + return self.getTypedRuleContext(Parser.EvalDatasetTypeContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterEvalAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvalAtom" ): listener.enterEvalAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitEvalAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvalAtom" ): listener.exitEvalAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitEvalAtom" ): + return visitor.visitEvalAtom(self) + else: + return visitor.visitChildren(self) + + class CastExprDatasetContext(GenericOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.GenericOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CAST(self): return self.getToken(Parser.CAST, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def basicScalarType(self): - return self.getTypedRuleContext(Parser.BasicScalarTypeContext, 0) + return self.getTypedRuleContext(Parser.BasicScalarTypeContext,0) def valueDomainName(self): - return self.getTypedRuleContext(Parser.ValueDomainNameContext, 0) + return self.getTypedRuleContext(Parser.ValueDomainNameContext,0) def STRING_CONSTANT(self): return self.getToken(Parser.STRING_CONSTANT, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCastExprDataset"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCastExprDataset" ): listener.enterCastExprDataset(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCastExprDataset"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCastExprDataset" ): listener.exitCastExprDataset(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCastExprDataset" ): + return visitor.visitCastExprDataset(self) + else: + return visitor.visitChildren(self) + + class CallDatasetContext(GenericOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.GenericOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def operatorID(self): - return self.getTypedRuleContext(Parser.OperatorIDContext, 0) + return self.getTypedRuleContext(Parser.OperatorIDContext,0) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def parameter(self, i: int = None): + def parameter(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ParameterContext) else: - return self.getTypedRuleContext(Parser.ParameterContext, i) + return self.getTypedRuleContext(Parser.ParameterContext,i) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCallDataset"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallDataset" ): listener.enterCallDataset(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCallDataset"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallDataset" ): listener.exitCallDataset(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCallDataset" ): + return visitor.visitCallDataset(self) + else: + return visitor.visitChildren(self) + + + def genericOperators(self): + localctx = Parser.GenericOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 34, self.RULE_genericOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 588 self._errHandler.sync(self) @@ -5214,135 +5213,13 @@ def genericOperators(self): self.state = 541 self._errHandler.sync(self) _la = self._input.LA(1) - if ( - ( - ((_la) & ~0x3F) == 0 - and ( - (1 << _la) - & ( - (1 << Parser.LPAREN) - | (1 << Parser.PLUS) - | (1 << Parser.MINUS) - | (1 << Parser.EVAL) - | (1 << Parser.IF) - | (1 << Parser.CASE) - | (1 << Parser.CURRENT_DATE) - | (1 << Parser.DATEDIFF) - | (1 << Parser.DATEADD) - | (1 << Parser.YEAR_OP) - | (1 << Parser.MONTH_OP) - | (1 << Parser.DAYOFMONTH) - | (1 << Parser.DAYOFYEAR) - | (1 << Parser.DAYTOYEAR) - | (1 << Parser.DAYTOMONTH) - | (1 << Parser.YEARTODAY) - | (1 << Parser.MONTHTODAY) - | (1 << Parser.NOT) - | (1 << Parser.BETWEEN) - | (1 << Parser.NULL_CONSTANT) - | (1 << Parser.ISNULL) - | (1 << Parser.UNION) - | (1 << Parser.SYMDIFF) - | (1 << Parser.INTERSECT) - | (1 << Parser.RANDOM) - ) - ) - != 0 - ) - or ( - ((_la - 66) & ~0x3F) == 0 - and ( - (1 << (_la - 66)) - & ( - (1 << (Parser.CHECK - 66)) - | (1 << (Parser.EXISTS_IN - 66)) - | (1 << (Parser.MIN - 66)) - | (1 << (Parser.MAX - 66)) - | (1 << (Parser.ABS - 66)) - | (1 << (Parser.LN - 66)) - | (1 << (Parser.LOG - 66)) - | (1 << (Parser.TRUNC - 66)) - | (1 << (Parser.ROUND - 66)) - | (1 << (Parser.POWER - 66)) - | (1 << (Parser.MOD - 66)) - | (1 << (Parser.LEN - 66)) - | (1 << (Parser.TRIM - 66)) - | (1 << (Parser.UCASE - 66)) - | (1 << (Parser.LCASE - 66)) - | (1 << (Parser.SUBSTR - 66)) - | (1 << (Parser.SUM - 66)) - | (1 << (Parser.AVG - 66)) - | (1 << (Parser.MEDIAN - 66)) - | (1 << (Parser.COUNT - 66)) - | (1 << (Parser.EXP - 66)) - | (1 << (Parser.CHARSET_MATCH - 66)) - | (1 << (Parser.NVL - 66)) - | (1 << (Parser.HIERARCHY - 66)) - | (1 << (Parser.OPTIONAL - 66)) - ) - ) - != 0 - ) - or ( - ((_la - 131) & ~0x3F) == 0 - and ( - (1 << (_la - 131)) - & ( - (1 << (Parser.LTRIM - 131)) - | (1 << (Parser.RTRIM - 131)) - | (1 << (Parser.INSTR - 131)) - | (1 << (Parser.REPLACE - 131)) - | (1 << (Parser.CEIL - 131)) - | (1 << (Parser.FLOOR - 131)) - | (1 << (Parser.SQRT - 131)) - | (1 << (Parser.SETDIFF - 131)) - | (1 << (Parser.STDDEV_POP - 131)) - | (1 << (Parser.STDDEV_SAMP - 131)) - | (1 << (Parser.VAR_POP - 131)) - | (1 << (Parser.VAR_SAMP - 131)) - | (1 << (Parser.FIRST_VALUE - 131)) - | (1 << (Parser.LAST_VALUE - 131)) - | (1 << (Parser.LAG - 131)) - | (1 << (Parser.LEAD - 131)) - | (1 << (Parser.RATIO_TO_REPORT - 131)) - | (1 << (Parser.FILL_TIME_SERIES - 131)) - | (1 << (Parser.FLOW_TO_STOCK - 131)) - | (1 << (Parser.STOCK_TO_FLOW - 131)) - | (1 << (Parser.TIMESHIFT - 131)) - | (1 << (Parser.INNER_JOIN - 131)) - | (1 << (Parser.LEFT_JOIN - 131)) - ) - ) - != 0 - ) - or ( - ((_la - 195) & ~0x3F) == 0 - and ( - (1 << (_la - 195)) - & ( - (1 << (Parser.CROSS_JOIN - 195)) - | (1 << (Parser.FULL_JOIN - 195)) - | (1 << (Parser.PERIOD_INDICATOR - 195)) - | (1 << (Parser.TIME_AGG - 195)) - | (1 << (Parser.CAST - 195)) - | (1 << (Parser.CHECK_DATAPOINT - 195)) - | (1 << (Parser.CHECK_HIERARCHY - 195)) - | (1 << (Parser.INTEGER_CONSTANT - 195)) - | (1 << (Parser.NUMBER_CONSTANT - 195)) - | (1 << (Parser.BOOLEAN_CONSTANT - 195)) - | (1 << (Parser.STRING_CONSTANT - 195)) - | (1 << (Parser.IDENTIFIER - 195)) - ) - ) - != 0 - ) - ): + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CASE) | (1 << Parser.CURRENT_DATE) | (1 << Parser.DATEDIFF) | (1 << Parser.DATEADD) | (1 << Parser.YEAR_OP) | (1 << Parser.MONTH_OP) | (1 << Parser.DAYOFMONTH) | (1 << Parser.DAYOFYEAR) | (1 << Parser.DAYTOYEAR) | (1 << Parser.DAYTOMONTH) | (1 << Parser.YEARTODAY) | (1 << Parser.MONTHTODAY) | (1 << Parser.NOT) | (1 << Parser.BETWEEN) | (1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL) | (1 << Parser.UNION) | (1 << Parser.SYMDIFF) | (1 << Parser.INTERSECT) | (1 << Parser.RANDOM))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Parser.CHECK - 66)) | (1 << (Parser.EXISTS_IN - 66)) | (1 << (Parser.MIN - 66)) | (1 << (Parser.MAX - 66)) | (1 << (Parser.ABS - 66)) | (1 << (Parser.LN - 66)) | (1 << (Parser.LOG - 66)) | (1 << (Parser.TRUNC - 66)) | (1 << (Parser.ROUND - 66)) | (1 << (Parser.POWER - 66)) | (1 << (Parser.MOD - 66)) | (1 << (Parser.LEN - 66)) | (1 << (Parser.TRIM - 66)) | (1 << (Parser.UCASE - 66)) | (1 << (Parser.LCASE - 66)) | (1 << (Parser.SUBSTR - 66)) | (1 << (Parser.SUM - 66)) | (1 << (Parser.AVG - 66)) | (1 << (Parser.MEDIAN - 66)) | (1 << (Parser.COUNT - 66)) | (1 << (Parser.EXP - 66)) | (1 << (Parser.CHARSET_MATCH - 66)) | (1 << (Parser.NVL - 66)) | (1 << (Parser.HIERARCHY - 66)) | (1 << (Parser.OPTIONAL - 66)))) != 0) or ((((_la - 131)) & ~0x3f) == 0 and ((1 << (_la - 131)) & ((1 << (Parser.LTRIM - 131)) | (1 << (Parser.RTRIM - 131)) | (1 << (Parser.INSTR - 131)) | (1 << (Parser.REPLACE - 131)) | (1 << (Parser.CEIL - 131)) | (1 << (Parser.FLOOR - 131)) | (1 << (Parser.SQRT - 131)) | (1 << (Parser.SETDIFF - 131)) | (1 << (Parser.STDDEV_POP - 131)) | (1 << (Parser.STDDEV_SAMP - 131)) | (1 << (Parser.VAR_POP - 131)) | (1 << (Parser.VAR_SAMP - 131)) | (1 << (Parser.FIRST_VALUE - 131)) | (1 << (Parser.LAST_VALUE - 131)) | (1 << (Parser.LAG - 131)) | (1 << (Parser.LEAD - 131)) | (1 << (Parser.RATIO_TO_REPORT - 131)) | (1 << (Parser.FILL_TIME_SERIES - 131)) | (1 << (Parser.FLOW_TO_STOCK - 131)) | (1 << (Parser.STOCK_TO_FLOW - 131)) | (1 << (Parser.TIMESHIFT - 131)) | (1 << (Parser.INNER_JOIN - 131)) | (1 << (Parser.LEFT_JOIN - 131)))) != 0) or ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & ((1 << (Parser.CROSS_JOIN - 195)) | (1 << (Parser.FULL_JOIN - 195)) | (1 << (Parser.PERIOD_INDICATOR - 195)) | (1 << (Parser.TIME_AGG - 195)) | (1 << (Parser.CAST - 195)) | (1 << (Parser.CHECK_DATAPOINT - 195)) | (1 << (Parser.CHECK_HIERARCHY - 195)) | (1 << (Parser.INTEGER_CONSTANT - 195)) | (1 << (Parser.NUMBER_CONSTANT - 195)) | (1 << (Parser.BOOLEAN_CONSTANT - 195)) | (1 << (Parser.STRING_CONSTANT - 195)) | (1 << (Parser.IDENTIFIER - 195)))) != 0): self.state = 533 self.parameter() self.state = 538 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 534 self.match(Parser.COMMA) self.state = 535 @@ -5351,6 +5228,8 @@ def genericOperators(self): self._errHandler.sync(self) _la = self._input.LA(1) + + self.state = 543 self.match(Parser.RPAREN) pass @@ -5372,14 +5251,7 @@ def genericOperators(self): self.state = 549 self.varID() pass - elif token in [ - Parser.NULL_CONSTANT, - Parser.CAST, - Parser.INTEGER_CONSTANT, - Parser.NUMBER_CONSTANT, - Parser.BOOLEAN_CONSTANT, - Parser.STRING_CONSTANT, - ]: + elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT]: self.state = 550 self.scalarItem() pass @@ -5390,7 +5262,7 @@ def genericOperators(self): self.state = 560 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 553 self.match(Parser.COMMA) self.state = 556 @@ -5400,14 +5272,7 @@ def genericOperators(self): self.state = 554 self.varID() pass - elif token in [ - Parser.NULL_CONSTANT, - Parser.CAST, - Parser.INTEGER_CONSTANT, - Parser.NUMBER_CONSTANT, - Parser.BOOLEAN_CONSTANT, - Parser.STRING_CONSTANT, - ]: + elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT]: self.state = 555 self.scalarItem() pass @@ -5423,21 +5288,23 @@ def genericOperators(self): self.state = 566 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.LANGUAGE: + if _la==Parser.LANGUAGE: self.state = 564 self.match(Parser.LANGUAGE) self.state = 565 self.match(Parser.STRING_CONSTANT) + self.state = 570 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.RETURNS: + if _la==Parser.RETURNS: self.state = 568 self.match(Parser.RETURNS) self.state = 569 self.evalDatasetType() + self.state = 572 self.match(Parser.RPAREN) pass @@ -5455,17 +5322,7 @@ def genericOperators(self): self.state = 580 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.BOOLEAN, - Parser.DATE, - Parser.TIME_PERIOD, - Parser.NUMBER, - Parser.STRING, - Parser.TIME, - Parser.INTEGER, - Parser.DURATION, - Parser.SCALAR, - ]: + if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR]: self.state = 578 self.basicScalarType() pass @@ -5479,12 +5336,13 @@ def genericOperators(self): self.state = 584 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 582 self.match(Parser.COMMA) self.state = 583 self.match(Parser.STRING_CONSTANT) + self.state = 586 self.match(Parser.RPAREN) pass @@ -5499,164 +5357,177 @@ def genericOperators(self): self.exitRule() return localctx + class GenericOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_genericOperatorsComponent - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class EvalAtomComponentContext(GenericOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.GenericOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def EVAL(self): return self.getToken(Parser.EVAL, 0) - - def LPAREN(self, i: int = None): + def LPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) - def routineName(self): - return self.getTypedRuleContext(Parser.RoutineNameContext, 0) + return self.getTypedRuleContext(Parser.RoutineNameContext,0) - def RPAREN(self, i: int = None): + def RPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) - - def componentID(self, i: int = None): + def componentID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext, i) + return self.getTypedRuleContext(Parser.ComponentIDContext,i) - def scalarItem(self, i: int = None): + def scalarItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ScalarItemContext) else: - return self.getTypedRuleContext(Parser.ScalarItemContext, i) + return self.getTypedRuleContext(Parser.ScalarItemContext,i) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def LANGUAGE(self): return self.getToken(Parser.LANGUAGE, 0) - def STRING_CONSTANT(self): return self.getToken(Parser.STRING_CONSTANT, 0) - def RETURNS(self): return self.getToken(Parser.RETURNS, 0) - def outputParameterTypeComponent(self): - return self.getTypedRuleContext(Parser.OutputParameterTypeComponentContext, 0) + return self.getTypedRuleContext(Parser.OutputParameterTypeComponentContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterEvalAtomComponent"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvalAtomComponent" ): listener.enterEvalAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitEvalAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvalAtomComponent" ): listener.exitEvalAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitEvalAtomComponent" ): + return visitor.visitEvalAtomComponent(self) + else: + return visitor.visitChildren(self) + + class CastExprComponentContext(GenericOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.GenericOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CAST(self): return self.getToken(Parser.CAST, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def basicScalarType(self): - return self.getTypedRuleContext(Parser.BasicScalarTypeContext, 0) + return self.getTypedRuleContext(Parser.BasicScalarTypeContext,0) def valueDomainName(self): - return self.getTypedRuleContext(Parser.ValueDomainNameContext, 0) + return self.getTypedRuleContext(Parser.ValueDomainNameContext,0) def STRING_CONSTANT(self): return self.getToken(Parser.STRING_CONSTANT, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCastExprComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCastExprComponent" ): listener.enterCastExprComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCastExprComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCastExprComponent" ): listener.exitCastExprComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCastExprComponent" ): + return visitor.visitCastExprComponent(self) + else: + return visitor.visitChildren(self) + + class CallComponentContext(GenericOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.GenericOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def operatorID(self): - return self.getTypedRuleContext(Parser.OperatorIDContext, 0) + return self.getTypedRuleContext(Parser.OperatorIDContext,0) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def parameterComponent(self, i: int = None): + def parameterComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ParameterComponentContext) else: - return self.getTypedRuleContext(Parser.ParameterComponentContext, i) + return self.getTypedRuleContext(Parser.ParameterComponentContext,i) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCallComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallComponent" ): listener.enterCallComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCallComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallComponent" ): listener.exitCallComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCallComponent" ): + return visitor.visitCallComponent(self) + else: + return visitor.visitChildren(self) + + + def genericOperatorsComponent(self): + localctx = Parser.GenericOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 36, self.RULE_genericOperatorsComponent) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 647 self._errHandler.sync(self) @@ -5671,123 +5542,13 @@ def genericOperatorsComponent(self): self.state = 600 self._errHandler.sync(self) _la = self._input.LA(1) - if ( - ( - ((_la) & ~0x3F) == 0 - and ( - (1 << _la) - & ( - (1 << Parser.LPAREN) - | (1 << Parser.PLUS) - | (1 << Parser.MINUS) - | (1 << Parser.EVAL) - | (1 << Parser.IF) - | (1 << Parser.CASE) - | (1 << Parser.CURRENT_DATE) - | (1 << Parser.DATEDIFF) - | (1 << Parser.DATEADD) - | (1 << Parser.YEAR_OP) - | (1 << Parser.MONTH_OP) - | (1 << Parser.DAYOFMONTH) - | (1 << Parser.DAYOFYEAR) - | (1 << Parser.DAYTOYEAR) - | (1 << Parser.DAYTOMONTH) - | (1 << Parser.YEARTODAY) - | (1 << Parser.MONTHTODAY) - | (1 << Parser.NOT) - | (1 << Parser.BETWEEN) - | (1 << Parser.NULL_CONSTANT) - | (1 << Parser.ISNULL) - | (1 << Parser.RANDOM) - ) - ) - != 0 - ) - or ( - ((_la - 77) & ~0x3F) == 0 - and ( - (1 << (_la - 77)) - & ( - (1 << (Parser.RANK - 77)) - | (1 << (Parser.MIN - 77)) - | (1 << (Parser.MAX - 77)) - | (1 << (Parser.ABS - 77)) - | (1 << (Parser.LN - 77)) - | (1 << (Parser.LOG - 77)) - | (1 << (Parser.TRUNC - 77)) - | (1 << (Parser.ROUND - 77)) - | (1 << (Parser.POWER - 77)) - | (1 << (Parser.MOD - 77)) - | (1 << (Parser.LEN - 77)) - | (1 << (Parser.TRIM - 77)) - | (1 << (Parser.UCASE - 77)) - | (1 << (Parser.LCASE - 77)) - | (1 << (Parser.SUBSTR - 77)) - | (1 << (Parser.SUM - 77)) - | (1 << (Parser.AVG - 77)) - | (1 << (Parser.MEDIAN - 77)) - | (1 << (Parser.COUNT - 77)) - | (1 << (Parser.EXP - 77)) - | (1 << (Parser.CHARSET_MATCH - 77)) - | (1 << (Parser.NVL - 77)) - | (1 << (Parser.OPTIONAL - 77)) - | (1 << (Parser.LTRIM - 77)) - | (1 << (Parser.RTRIM - 77)) - | (1 << (Parser.INSTR - 77)) - | (1 << (Parser.REPLACE - 77)) - | (1 << (Parser.CEIL - 77)) - | (1 << (Parser.FLOOR - 77)) - | (1 << (Parser.SQRT - 77)) - | (1 << (Parser.STDDEV_POP - 77)) - ) - ) - != 0 - ) - or ( - ((_la - 141) & ~0x3F) == 0 - and ( - (1 << (_la - 141)) - & ( - (1 << (Parser.STDDEV_SAMP - 141)) - | (1 << (Parser.VAR_POP - 141)) - | (1 << (Parser.VAR_SAMP - 141)) - | (1 << (Parser.FIRST_VALUE - 141)) - | (1 << (Parser.LAST_VALUE - 141)) - | (1 << (Parser.LAG - 141)) - | (1 << (Parser.LEAD - 141)) - | (1 << (Parser.RATIO_TO_REPORT - 141)) - | (1 << (Parser.FILL_TIME_SERIES - 141)) - | (1 << (Parser.FLOW_TO_STOCK - 141)) - | (1 << (Parser.STOCK_TO_FLOW - 141)) - | (1 << (Parser.TIMESHIFT - 141)) - ) - ) - != 0 - ) - or ( - ((_la - 208) & ~0x3F) == 0 - and ( - (1 << (_la - 208)) - & ( - (1 << (Parser.PERIOD_INDICATOR - 208)) - | (1 << (Parser.TIME_AGG - 208)) - | (1 << (Parser.CAST - 208)) - | (1 << (Parser.INTEGER_CONSTANT - 208)) - | (1 << (Parser.NUMBER_CONSTANT - 208)) - | (1 << (Parser.BOOLEAN_CONSTANT - 208)) - | (1 << (Parser.STRING_CONSTANT - 208)) - | (1 << (Parser.IDENTIFIER - 208)) - ) - ) - != 0 - ) - ): + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CASE) | (1 << Parser.CURRENT_DATE) | (1 << Parser.DATEDIFF) | (1 << Parser.DATEADD) | (1 << Parser.YEAR_OP) | (1 << Parser.MONTH_OP) | (1 << Parser.DAYOFMONTH) | (1 << Parser.DAYOFYEAR) | (1 << Parser.DAYTOYEAR) | (1 << Parser.DAYTOMONTH) | (1 << Parser.YEARTODAY) | (1 << Parser.MONTHTODAY) | (1 << Parser.NOT) | (1 << Parser.BETWEEN) | (1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL) | (1 << Parser.RANDOM))) != 0) or ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & ((1 << (Parser.RANK - 77)) | (1 << (Parser.MIN - 77)) | (1 << (Parser.MAX - 77)) | (1 << (Parser.ABS - 77)) | (1 << (Parser.LN - 77)) | (1 << (Parser.LOG - 77)) | (1 << (Parser.TRUNC - 77)) | (1 << (Parser.ROUND - 77)) | (1 << (Parser.POWER - 77)) | (1 << (Parser.MOD - 77)) | (1 << (Parser.LEN - 77)) | (1 << (Parser.TRIM - 77)) | (1 << (Parser.UCASE - 77)) | (1 << (Parser.LCASE - 77)) | (1 << (Parser.SUBSTR - 77)) | (1 << (Parser.SUM - 77)) | (1 << (Parser.AVG - 77)) | (1 << (Parser.MEDIAN - 77)) | (1 << (Parser.COUNT - 77)) | (1 << (Parser.EXP - 77)) | (1 << (Parser.CHARSET_MATCH - 77)) | (1 << (Parser.NVL - 77)) | (1 << (Parser.OPTIONAL - 77)) | (1 << (Parser.LTRIM - 77)) | (1 << (Parser.RTRIM - 77)) | (1 << (Parser.INSTR - 77)) | (1 << (Parser.REPLACE - 77)) | (1 << (Parser.CEIL - 77)) | (1 << (Parser.FLOOR - 77)) | (1 << (Parser.SQRT - 77)) | (1 << (Parser.STDDEV_POP - 77)))) != 0) or ((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & ((1 << (Parser.STDDEV_SAMP - 141)) | (1 << (Parser.VAR_POP - 141)) | (1 << (Parser.VAR_SAMP - 141)) | (1 << (Parser.FIRST_VALUE - 141)) | (1 << (Parser.LAST_VALUE - 141)) | (1 << (Parser.LAG - 141)) | (1 << (Parser.LEAD - 141)) | (1 << (Parser.RATIO_TO_REPORT - 141)) | (1 << (Parser.FILL_TIME_SERIES - 141)) | (1 << (Parser.FLOW_TO_STOCK - 141)) | (1 << (Parser.STOCK_TO_FLOW - 141)) | (1 << (Parser.TIMESHIFT - 141)))) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & ((1 << (Parser.PERIOD_INDICATOR - 208)) | (1 << (Parser.TIME_AGG - 208)) | (1 << (Parser.CAST - 208)) | (1 << (Parser.INTEGER_CONSTANT - 208)) | (1 << (Parser.NUMBER_CONSTANT - 208)) | (1 << (Parser.BOOLEAN_CONSTANT - 208)) | (1 << (Parser.STRING_CONSTANT - 208)) | (1 << (Parser.IDENTIFIER - 208)))) != 0): self.state = 592 self.parameterComponent() self.state = 597 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 593 self.match(Parser.COMMA) self.state = 594 @@ -5796,6 +5557,8 @@ def genericOperatorsComponent(self): self._errHandler.sync(self) _la = self._input.LA(1) + + self.state = 602 self.match(Parser.RPAREN) pass @@ -5813,17 +5576,7 @@ def genericOperatorsComponent(self): self.state = 610 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.BOOLEAN, - Parser.DATE, - Parser.TIME_PERIOD, - Parser.NUMBER, - Parser.STRING, - Parser.TIME, - Parser.INTEGER, - Parser.DURATION, - Parser.SCALAR, - ]: + if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR]: self.state = 608 self.basicScalarType() pass @@ -5837,12 +5590,13 @@ def genericOperatorsComponent(self): self.state = 614 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 612 self.match(Parser.COMMA) self.state = 613 self.match(Parser.STRING_CONSTANT) + self.state = 616 self.match(Parser.RPAREN) pass @@ -5864,14 +5618,7 @@ def genericOperatorsComponent(self): self.state = 622 self.componentID() pass - elif token in [ - Parser.NULL_CONSTANT, - Parser.CAST, - Parser.INTEGER_CONSTANT, - Parser.NUMBER_CONSTANT, - Parser.BOOLEAN_CONSTANT, - Parser.STRING_CONSTANT, - ]: + elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT]: self.state = 623 self.scalarItem() pass @@ -5882,7 +5629,7 @@ def genericOperatorsComponent(self): self.state = 633 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 626 self.match(Parser.COMMA) self.state = 629 @@ -5892,14 +5639,7 @@ def genericOperatorsComponent(self): self.state = 627 self.componentID() pass - elif token in [ - Parser.NULL_CONSTANT, - Parser.CAST, - Parser.INTEGER_CONSTANT, - Parser.NUMBER_CONSTANT, - Parser.BOOLEAN_CONSTANT, - Parser.STRING_CONSTANT, - ]: + elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT]: self.state = 628 self.scalarItem() pass @@ -5915,21 +5655,23 @@ def genericOperatorsComponent(self): self.state = 639 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.LANGUAGE: + if _la==Parser.LANGUAGE: self.state = 637 self.match(Parser.LANGUAGE) self.state = 638 self.match(Parser.STRING_CONSTANT) + self.state = 643 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.RETURNS: + if _la==Parser.RETURNS: self.state = 641 self.match(Parser.RETURNS) self.state = 642 self.outputParameterTypeComponent() + self.state = 645 self.match(Parser.RPAREN) pass @@ -5944,15 +5686,17 @@ def genericOperatorsComponent(self): self.exitRule() return localctx + class ParameterComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) + def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) @@ -5960,95 +5704,32 @@ def OPTIONAL(self): def getRuleIndex(self): return Parser.RULE_parameterComponent - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterParameterComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParameterComponent" ): listener.enterParameterComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitParameterComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParameterComponent" ): listener.exitParameterComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitParameterComponent" ): + return visitor.visitParameterComponent(self) + else: + return visitor.visitChildren(self) + + + + def parameterComponent(self): + localctx = Parser.ParameterComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 38, self.RULE_parameterComponent) try: self.state = 651 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.LPAREN, - Parser.PLUS, - Parser.MINUS, - Parser.EVAL, - Parser.IF, - Parser.CASE, - Parser.CURRENT_DATE, - Parser.DATEDIFF, - Parser.DATEADD, - Parser.YEAR_OP, - Parser.MONTH_OP, - Parser.DAYOFMONTH, - Parser.DAYOFYEAR, - Parser.DAYTOYEAR, - Parser.DAYTOMONTH, - Parser.YEARTODAY, - Parser.MONTHTODAY, - Parser.NOT, - Parser.BETWEEN, - Parser.NULL_CONSTANT, - Parser.ISNULL, - Parser.RANDOM, - Parser.RANK, - Parser.MIN, - Parser.MAX, - Parser.ABS, - Parser.LN, - Parser.LOG, - Parser.TRUNC, - Parser.ROUND, - Parser.POWER, - Parser.MOD, - Parser.LEN, - Parser.TRIM, - Parser.UCASE, - Parser.LCASE, - Parser.SUBSTR, - Parser.SUM, - Parser.AVG, - Parser.MEDIAN, - Parser.COUNT, - Parser.EXP, - Parser.CHARSET_MATCH, - Parser.NVL, - Parser.LTRIM, - Parser.RTRIM, - Parser.INSTR, - Parser.REPLACE, - Parser.CEIL, - Parser.FLOOR, - Parser.SQRT, - Parser.STDDEV_POP, - Parser.STDDEV_SAMP, - Parser.VAR_POP, - Parser.VAR_SAMP, - Parser.FIRST_VALUE, - Parser.LAST_VALUE, - Parser.LAG, - Parser.LEAD, - Parser.RATIO_TO_REPORT, - Parser.FILL_TIME_SERIES, - Parser.FLOW_TO_STOCK, - Parser.STOCK_TO_FLOW, - Parser.TIMESHIFT, - Parser.PERIOD_INDICATOR, - Parser.TIME_AGG, - Parser.CAST, - Parser.INTEGER_CONSTANT, - Parser.NUMBER_CONSTANT, - Parser.BOOLEAN_CONSTANT, - Parser.STRING_CONSTANT, - Parser.IDENTIFIER, - ]: + if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF, Parser.CASE, Parser.CURRENT_DATE, Parser.DATEDIFF, Parser.DATEADD, Parser.YEAR_OP, Parser.MONTH_OP, Parser.DAYOFMONTH, Parser.DAYOFYEAR, Parser.DAYTOYEAR, Parser.DAYTOMONTH, Parser.YEARTODAY, Parser.MONTHTODAY, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT, Parser.ISNULL, Parser.RANDOM, Parser.RANK, Parser.MIN, Parser.MAX, Parser.ABS, Parser.LN, Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER, Parser.MOD, Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.SUBSTR, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.EXP, Parser.CHARSET_MATCH, Parser.NVL, Parser.LTRIM, Parser.RTRIM, Parser.INSTR, Parser.REPLACE, Parser.CEIL, Parser.FLOOR, Parser.SQRT, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT, Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW, Parser.TIMESHIFT, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT, Parser.IDENTIFIER]: self.enterOuterAlt(localctx, 1) self.state = 649 self.exprComponent(0) @@ -6069,15 +5750,17 @@ def parameterComponent(self): self.exitRule() return localctx + class ParameterContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) + def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) @@ -6085,107 +5768,32 @@ def OPTIONAL(self): def getRuleIndex(self): return Parser.RULE_parameter - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterParameter"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParameter" ): listener.enterParameter(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitParameter"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParameter" ): listener.exitParameter(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitParameter" ): + return visitor.visitParameter(self) + else: + return visitor.visitChildren(self) + + + + def parameter(self): + localctx = Parser.ParameterContext(self, self._ctx, self.state) self.enterRule(localctx, 40, self.RULE_parameter) try: self.state = 655 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.LPAREN, - Parser.PLUS, - Parser.MINUS, - Parser.EVAL, - Parser.IF, - Parser.CASE, - Parser.CURRENT_DATE, - Parser.DATEDIFF, - Parser.DATEADD, - Parser.YEAR_OP, - Parser.MONTH_OP, - Parser.DAYOFMONTH, - Parser.DAYOFYEAR, - Parser.DAYTOYEAR, - Parser.DAYTOMONTH, - Parser.YEARTODAY, - Parser.MONTHTODAY, - Parser.NOT, - Parser.BETWEEN, - Parser.NULL_CONSTANT, - Parser.ISNULL, - Parser.UNION, - Parser.SYMDIFF, - Parser.INTERSECT, - Parser.RANDOM, - Parser.CHECK, - Parser.EXISTS_IN, - Parser.MIN, - Parser.MAX, - Parser.ABS, - Parser.LN, - Parser.LOG, - Parser.TRUNC, - Parser.ROUND, - Parser.POWER, - Parser.MOD, - Parser.LEN, - Parser.TRIM, - Parser.UCASE, - Parser.LCASE, - Parser.SUBSTR, - Parser.SUM, - Parser.AVG, - Parser.MEDIAN, - Parser.COUNT, - Parser.EXP, - Parser.CHARSET_MATCH, - Parser.NVL, - Parser.HIERARCHY, - Parser.LTRIM, - Parser.RTRIM, - Parser.INSTR, - Parser.REPLACE, - Parser.CEIL, - Parser.FLOOR, - Parser.SQRT, - Parser.SETDIFF, - Parser.STDDEV_POP, - Parser.STDDEV_SAMP, - Parser.VAR_POP, - Parser.VAR_SAMP, - Parser.FIRST_VALUE, - Parser.LAST_VALUE, - Parser.LAG, - Parser.LEAD, - Parser.RATIO_TO_REPORT, - Parser.FILL_TIME_SERIES, - Parser.FLOW_TO_STOCK, - Parser.STOCK_TO_FLOW, - Parser.TIMESHIFT, - Parser.INNER_JOIN, - Parser.LEFT_JOIN, - Parser.CROSS_JOIN, - Parser.FULL_JOIN, - Parser.PERIOD_INDICATOR, - Parser.TIME_AGG, - Parser.CAST, - Parser.CHECK_DATAPOINT, - Parser.CHECK_HIERARCHY, - Parser.INTEGER_CONSTANT, - Parser.NUMBER_CONSTANT, - Parser.BOOLEAN_CONSTANT, - Parser.STRING_CONSTANT, - Parser.IDENTIFIER, - ]: + if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF, Parser.CASE, Parser.CURRENT_DATE, Parser.DATEDIFF, Parser.DATEADD, Parser.YEAR_OP, Parser.MONTH_OP, Parser.DAYOFMONTH, Parser.DAYOFYEAR, Parser.DAYTOYEAR, Parser.DAYTOMONTH, Parser.YEARTODAY, Parser.MONTHTODAY, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT, Parser.ISNULL, Parser.UNION, Parser.SYMDIFF, Parser.INTERSECT, Parser.RANDOM, Parser.CHECK, Parser.EXISTS_IN, Parser.MIN, Parser.MAX, Parser.ABS, Parser.LN, Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER, Parser.MOD, Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.SUBSTR, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.EXP, Parser.CHARSET_MATCH, Parser.NVL, Parser.HIERARCHY, Parser.LTRIM, Parser.RTRIM, Parser.INSTR, Parser.REPLACE, Parser.CEIL, Parser.FLOOR, Parser.SQRT, Parser.SETDIFF, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT, Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW, Parser.TIMESHIFT, Parser.INNER_JOIN, Parser.LEFT_JOIN, Parser.CROSS_JOIN, Parser.FULL_JOIN, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST, Parser.CHECK_DATAPOINT, Parser.CHECK_HIERARCHY, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT, Parser.IDENTIFIER]: self.enterOuterAlt(localctx, 1) self.state = 653 self.expr(0) @@ -6206,224 +5814,218 @@ def parameter(self): self.exitRule() return localctx + class StringOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_stringOperators - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class InstrAtomContext(StringOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.StringOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsContext super().__init__(ANTLRParser) - self.pattern = None # ExprContext - self.startParameter = None # OptionalExprContext - self.occurrenceParameter = None # OptionalExprContext + self.pattern = None # ExprContext + self.startParameter = None # OptionalExprContext + self.occurrenceParameter = None # OptionalExprContext self.copyFrom(ctx) def INSTR(self): return self.getToken(Parser.INSTR, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def optionalExpr(self, i: int = None): + def optionalExpr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.OptionalExprContext) else: - return self.getTypedRuleContext(Parser.OptionalExprContext, i) + return self.getTypedRuleContext(Parser.OptionalExprContext,i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterInstrAtom"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInstrAtom" ): listener.enterInstrAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitInstrAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInstrAtom" ): listener.exitInstrAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInstrAtom" ): + return visitor.visitInstrAtom(self) + else: + return visitor.visitChildren(self) + + class UnaryStringFunctionContext(StringOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.StringOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def TRIM(self): return self.getToken(Parser.TRIM, 0) - def LTRIM(self): return self.getToken(Parser.LTRIM, 0) - def RTRIM(self): return self.getToken(Parser.RTRIM, 0) - def UCASE(self): return self.getToken(Parser.UCASE, 0) - def LCASE(self): return self.getToken(Parser.LCASE, 0) - def LEN(self): return self.getToken(Parser.LEN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterUnaryStringFunction"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnaryStringFunction" ): listener.enterUnaryStringFunction(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitUnaryStringFunction"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnaryStringFunction" ): listener.exitUnaryStringFunction(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUnaryStringFunction" ): + return visitor.visitUnaryStringFunction(self) + else: + return visitor.visitChildren(self) + + class SubstrAtomContext(StringOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.StringOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsContext super().__init__(ANTLRParser) - self.startParameter = None # OptionalExprContext - self.endParameter = None # OptionalExprContext + self.startParameter = None # OptionalExprContext + self.endParameter = None # OptionalExprContext self.copyFrom(ctx) def SUBSTR(self): return self.getToken(Parser.SUBSTR, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - - def optionalExpr(self, i: int = None): + def optionalExpr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.OptionalExprContext) else: - return self.getTypedRuleContext(Parser.OptionalExprContext, i) + return self.getTypedRuleContext(Parser.OptionalExprContext,i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterSubstrAtom"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubstrAtom" ): listener.enterSubstrAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitSubstrAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubstrAtom" ): listener.exitSubstrAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSubstrAtom" ): + return visitor.visitSubstrAtom(self) + else: + return visitor.visitChildren(self) + + class ReplaceAtomContext(StringOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.StringOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsContext super().__init__(ANTLRParser) - self.param = None # ExprContext + self.param = None # ExprContext self.copyFrom(ctx) def REPLACE(self): return self.getToken(Parser.REPLACE, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def optionalExpr(self): - return self.getTypedRuleContext(Parser.OptionalExprContext, 0) + return self.getTypedRuleContext(Parser.OptionalExprContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterReplaceAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReplaceAtom" ): listener.enterReplaceAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitReplaceAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReplaceAtom" ): listener.exitReplaceAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitReplaceAtom" ): + return visitor.visitReplaceAtom(self) + else: + return visitor.visitChildren(self) + + + def stringOperators(self): + localctx = Parser.StringOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 42, self.RULE_stringOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 705 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.LEN, - Parser.TRIM, - Parser.UCASE, - Parser.LCASE, - Parser.LTRIM, - Parser.RTRIM, - ]: + if token in [Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.LTRIM, Parser.RTRIM]: localctx = Parser.UnaryStringFunctionContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 657 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ((_la - 93) & ~0x3F) == 0 - and ( - (1 << (_la - 93)) - & ( - (1 << (Parser.LEN - 93)) - | (1 << (Parser.TRIM - 93)) - | (1 << (Parser.UCASE - 93)) - | (1 << (Parser.LCASE - 93)) - | (1 << (Parser.LTRIM - 93)) - | (1 << (Parser.RTRIM - 93)) - ) - ) - != 0 - ): + if not(((((_la - 93)) & ~0x3f) == 0 and ((1 << (_la - 93)) & ((1 << (Parser.LEN - 93)) | (1 << (Parser.TRIM - 93)) | (1 << (Parser.UCASE - 93)) | (1 << (Parser.LCASE - 93)) | (1 << (Parser.LTRIM - 93)) | (1 << (Parser.RTRIM - 93)))) != 0)): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6446,12 +6048,12 @@ def stringOperators(self): self.expr(0) self.state = 675 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 50, self._ctx) + la_ = self._interp.adaptivePredict(self._input,50,self._ctx) if la_ == 1: self.state = 671 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 665 self.match(Parser.COMMA) self.state = 666 @@ -6462,6 +6064,7 @@ def stringOperators(self): self.state = 669 localctx.endParameter = self.optionalExpr() + pass elif la_ == 2: @@ -6471,6 +6074,7 @@ def stringOperators(self): localctx.startParameter = self.optionalExpr() pass + self.state = 677 self.match(Parser.RPAREN) pass @@ -6490,12 +6094,13 @@ def stringOperators(self): self.state = 686 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 684 self.match(Parser.COMMA) self.state = 685 self.optionalExpr() + self.state = 688 self.match(Parser.RPAREN) pass @@ -6514,22 +6119,24 @@ def stringOperators(self): localctx.pattern = self.expr(0) self.state = 697 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 52, self._ctx) + la_ = self._interp.adaptivePredict(self._input,52,self._ctx) if la_ == 1: self.state = 695 self.match(Parser.COMMA) self.state = 696 localctx.startParameter = self.optionalExpr() + self.state = 701 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 699 self.match(Parser.COMMA) self.state = 700 localctx.occurrenceParameter = self.optionalExpr() + self.state = 703 self.match(Parser.RPAREN) pass @@ -6544,224 +6151,218 @@ def stringOperators(self): self.exitRule() return localctx + class StringOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_stringOperatorsComponent - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class ReplaceAtomComponentContext(StringOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.StringOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsComponentContext super().__init__(ANTLRParser) - self.param = None # ExprComponentContext + self.param = None # ExprComponentContext self.copyFrom(ctx) def REPLACE(self): return self.getToken(Parser.REPLACE, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def optionalExprComponent(self): - return self.getTypedRuleContext(Parser.OptionalExprComponentContext, 0) + return self.getTypedRuleContext(Parser.OptionalExprComponentContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterReplaceAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReplaceAtomComponent" ): listener.enterReplaceAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitReplaceAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReplaceAtomComponent" ): listener.exitReplaceAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitReplaceAtomComponent" ): + return visitor.visitReplaceAtomComponent(self) + else: + return visitor.visitChildren(self) + + class UnaryStringFunctionComponentContext(StringOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.StringOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def TRIM(self): return self.getToken(Parser.TRIM, 0) - def LTRIM(self): return self.getToken(Parser.LTRIM, 0) - def RTRIM(self): return self.getToken(Parser.RTRIM, 0) - def UCASE(self): return self.getToken(Parser.UCASE, 0) - def LCASE(self): return self.getToken(Parser.LCASE, 0) - def LEN(self): return self.getToken(Parser.LEN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterUnaryStringFunctionComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnaryStringFunctionComponent" ): listener.enterUnaryStringFunctionComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitUnaryStringFunctionComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnaryStringFunctionComponent" ): listener.exitUnaryStringFunctionComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUnaryStringFunctionComponent" ): + return visitor.visitUnaryStringFunctionComponent(self) + else: + return visitor.visitChildren(self) + + class SubstrAtomComponentContext(StringOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.StringOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsComponentContext super().__init__(ANTLRParser) - self.startParameter = None # OptionalExprComponentContext - self.endParameter = None # OptionalExprComponentContext + self.startParameter = None # OptionalExprComponentContext + self.endParameter = None # OptionalExprComponentContext self.copyFrom(ctx) def SUBSTR(self): return self.getToken(Parser.SUBSTR, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - - def optionalExprComponent(self, i: int = None): + def optionalExprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.OptionalExprComponentContext) else: - return self.getTypedRuleContext(Parser.OptionalExprComponentContext, i) + return self.getTypedRuleContext(Parser.OptionalExprComponentContext,i) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterSubstrAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubstrAtomComponent" ): listener.enterSubstrAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitSubstrAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubstrAtomComponent" ): listener.exitSubstrAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSubstrAtomComponent" ): + return visitor.visitSubstrAtomComponent(self) + else: + return visitor.visitChildren(self) + + class InstrAtomComponentContext(StringOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.StringOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsComponentContext super().__init__(ANTLRParser) - self.pattern = None # ExprComponentContext - self.startParameter = None # OptionalExprComponentContext - self.occurrenceParameter = None # OptionalExprComponentContext + self.pattern = None # ExprComponentContext + self.startParameter = None # OptionalExprComponentContext + self.occurrenceParameter = None # OptionalExprComponentContext self.copyFrom(ctx) def INSTR(self): return self.getToken(Parser.INSTR, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def optionalExprComponent(self, i: int = None): + def optionalExprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.OptionalExprComponentContext) else: - return self.getTypedRuleContext(Parser.OptionalExprComponentContext, i) + return self.getTypedRuleContext(Parser.OptionalExprComponentContext,i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterInstrAtomComponent"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInstrAtomComponent" ): listener.enterInstrAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitInstrAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInstrAtomComponent" ): listener.exitInstrAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInstrAtomComponent" ): + return visitor.visitInstrAtomComponent(self) + else: + return visitor.visitChildren(self) + + + def stringOperatorsComponent(self): + localctx = Parser.StringOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 44, self.RULE_stringOperatorsComponent) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 755 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.LEN, - Parser.TRIM, - Parser.UCASE, - Parser.LCASE, - Parser.LTRIM, - Parser.RTRIM, - ]: + if token in [Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.LTRIM, Parser.RTRIM]: localctx = Parser.UnaryStringFunctionComponentContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 707 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ((_la - 93) & ~0x3F) == 0 - and ( - (1 << (_la - 93)) - & ( - (1 << (Parser.LEN - 93)) - | (1 << (Parser.TRIM - 93)) - | (1 << (Parser.UCASE - 93)) - | (1 << (Parser.LCASE - 93)) - | (1 << (Parser.LTRIM - 93)) - | (1 << (Parser.RTRIM - 93)) - ) - ) - != 0 - ): + if not(((((_la - 93)) & ~0x3f) == 0 and ((1 << (_la - 93)) & ((1 << (Parser.LEN - 93)) | (1 << (Parser.TRIM - 93)) | (1 << (Parser.UCASE - 93)) | (1 << (Parser.LCASE - 93)) | (1 << (Parser.LTRIM - 93)) | (1 << (Parser.RTRIM - 93)))) != 0)): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6784,12 +6385,12 @@ def stringOperatorsComponent(self): self.exprComponent(0) self.state = 725 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 56, self._ctx) + la_ = self._interp.adaptivePredict(self._input,56,self._ctx) if la_ == 1: self.state = 721 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 715 self.match(Parser.COMMA) self.state = 716 @@ -6800,6 +6401,7 @@ def stringOperatorsComponent(self): self.state = 719 localctx.endParameter = self.optionalExprComponent() + pass elif la_ == 2: @@ -6809,6 +6411,7 @@ def stringOperatorsComponent(self): localctx.startParameter = self.optionalExprComponent() pass + self.state = 727 self.match(Parser.RPAREN) pass @@ -6828,12 +6431,13 @@ def stringOperatorsComponent(self): self.state = 736 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 734 self.match(Parser.COMMA) self.state = 735 self.optionalExprComponent() + self.state = 738 self.match(Parser.RPAREN) pass @@ -6852,22 +6456,24 @@ def stringOperatorsComponent(self): localctx.pattern = self.exprComponent(0) self.state = 747 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 58, self._ctx) + la_ = self._interp.adaptivePredict(self._input,58,self._ctx) if la_ == 1: self.state = 745 self.match(Parser.COMMA) self.state = 746 localctx.startParameter = self.optionalExprComponent() + self.state = 751 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 749 self.match(Parser.COMMA) self.state = 750 localctx.occurrenceParameter = self.optionalExprComponent() + self.state = 753 self.match(Parser.RPAREN) pass @@ -6882,148 +6488,156 @@ def stringOperatorsComponent(self): self.exitRule() return localctx + class NumericOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_numericOperators - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class UnaryNumericContext(NumericOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.NumericOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def CEIL(self): return self.getToken(Parser.CEIL, 0) - def FLOOR(self): return self.getToken(Parser.FLOOR, 0) - def ABS(self): return self.getToken(Parser.ABS, 0) - def EXP(self): return self.getToken(Parser.EXP, 0) - def LN(self): return self.getToken(Parser.LN, 0) - def SQRT(self): return self.getToken(Parser.SQRT, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterUnaryNumeric"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnaryNumeric" ): listener.enterUnaryNumeric(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitUnaryNumeric"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnaryNumeric" ): listener.exitUnaryNumeric(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUnaryNumeric" ): + return visitor.visitUnaryNumeric(self) + else: + return visitor.visitChildren(self) + + class UnaryWithOptionalNumericContext(NumericOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.NumericOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def ROUND(self): return self.getToken(Parser.ROUND, 0) - def TRUNC(self): return self.getToken(Parser.TRUNC, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def optionalExpr(self): - return self.getTypedRuleContext(Parser.OptionalExprContext, 0) + return self.getTypedRuleContext(Parser.OptionalExprContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterUnaryWithOptionalNumeric"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnaryWithOptionalNumeric" ): listener.enterUnaryWithOptionalNumeric(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitUnaryWithOptionalNumeric"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnaryWithOptionalNumeric" ): listener.exitUnaryWithOptionalNumeric(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUnaryWithOptionalNumeric" ): + return visitor.visitUnaryWithOptionalNumeric(self) + else: + return visitor.visitChildren(self) + + class BinaryNumericContext(NumericOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.NumericOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token - self.left = None # ExprContext - self.right = None # ExprContext + self.op = None # Token + self.left = None # ExprContext + self.right = None # ExprContext self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) def MOD(self): return self.getToken(Parser.MOD, 0) - def POWER(self): return self.getToken(Parser.POWER, 0) - def LOG(self): return self.getToken(Parser.LOG, 0) - def RANDOM(self): return self.getToken(Parser.RANDOM, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterBinaryNumeric"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBinaryNumeric" ): listener.enterBinaryNumeric(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitBinaryNumeric"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBinaryNumeric" ): listener.exitBinaryNumeric(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBinaryNumeric" ): + return visitor.visitBinaryNumeric(self) + else: + return visitor.visitChildren(self) + + + def numericOperators(self): + localctx = Parser.NumericOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 46, self.RULE_numericOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 778 self._errHandler.sync(self) @@ -7034,21 +6648,7 @@ def numericOperators(self): self.state = 757 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ((_la - 85) & ~0x3F) == 0 - and ( - (1 << (_la - 85)) - & ( - (1 << (Parser.ABS - 85)) - | (1 << (Parser.LN - 85)) - | (1 << (Parser.EXP - 85)) - | (1 << (Parser.CEIL - 85)) - | (1 << (Parser.FLOOR - 85)) - | (1 << (Parser.SQRT - 85)) - ) - ) - != 0 - ): + if not(((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & ((1 << (Parser.ABS - 85)) | (1 << (Parser.LN - 85)) | (1 << (Parser.EXP - 85)) | (1 << (Parser.CEIL - 85)) | (1 << (Parser.FLOOR - 85)) | (1 << (Parser.SQRT - 85)))) != 0)): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -7066,7 +6666,7 @@ def numericOperators(self): self.state = 762 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.TRUNC or _la == Parser.ROUND): + if not(_la==Parser.TRUNC or _la==Parser.ROUND): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -7078,12 +6678,13 @@ def numericOperators(self): self.state = 767 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 765 self.match(Parser.COMMA) self.state = 766 self.optionalExpr() + self.state = 769 self.match(Parser.RPAREN) pass @@ -7093,19 +6694,7 @@ def numericOperators(self): self.state = 771 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ((_la - 61) & ~0x3F) == 0 - and ( - (1 << (_la - 61)) - & ( - (1 << (Parser.RANDOM - 61)) - | (1 << (Parser.LOG - 61)) - | (1 << (Parser.POWER - 61)) - | (1 << (Parser.MOD - 61)) - ) - ) - != 0 - ): + if not(((((_la - 61)) & ~0x3f) == 0 and ((1 << (_la - 61)) & ((1 << (Parser.RANDOM - 61)) | (1 << (Parser.LOG - 61)) | (1 << (Parser.POWER - 61)) | (1 << (Parser.MOD - 61)))) != 0)): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -7132,148 +6721,156 @@ def numericOperators(self): self.exitRule() return localctx + class NumericOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_numericOperatorsComponent - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class UnaryNumericComponentContext(NumericOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.NumericOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def CEIL(self): return self.getToken(Parser.CEIL, 0) - def FLOOR(self): return self.getToken(Parser.FLOOR, 0) - def ABS(self): return self.getToken(Parser.ABS, 0) - def EXP(self): return self.getToken(Parser.EXP, 0) - def LN(self): return self.getToken(Parser.LN, 0) - def SQRT(self): return self.getToken(Parser.SQRT, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterUnaryNumericComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnaryNumericComponent" ): listener.enterUnaryNumericComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitUnaryNumericComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnaryNumericComponent" ): listener.exitUnaryNumericComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUnaryNumericComponent" ): + return visitor.visitUnaryNumericComponent(self) + else: + return visitor.visitChildren(self) + + class BinaryNumericComponentContext(NumericOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.NumericOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.left = None # ExprComponentContext - self.right = None # ExprComponentContext + self.op = None # Token + self.left = None # ExprComponentContext + self.right = None # ExprComponentContext self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) def MOD(self): return self.getToken(Parser.MOD, 0) - def POWER(self): return self.getToken(Parser.POWER, 0) - def LOG(self): return self.getToken(Parser.LOG, 0) - def RANDOM(self): return self.getToken(Parser.RANDOM, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterBinaryNumericComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBinaryNumericComponent" ): listener.enterBinaryNumericComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitBinaryNumericComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBinaryNumericComponent" ): listener.exitBinaryNumericComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBinaryNumericComponent" ): + return visitor.visitBinaryNumericComponent(self) + else: + return visitor.visitChildren(self) + + class UnaryWithOptionalNumericComponentContext(NumericOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.NumericOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def ROUND(self): return self.getToken(Parser.ROUND, 0) - def TRUNC(self): return self.getToken(Parser.TRUNC, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def optionalExprComponent(self): - return self.getTypedRuleContext(Parser.OptionalExprComponentContext, 0) + return self.getTypedRuleContext(Parser.OptionalExprComponentContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterUnaryWithOptionalNumericComponent"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnaryWithOptionalNumericComponent" ): listener.enterUnaryWithOptionalNumericComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitUnaryWithOptionalNumericComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnaryWithOptionalNumericComponent" ): listener.exitUnaryWithOptionalNumericComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUnaryWithOptionalNumericComponent" ): + return visitor.visitUnaryWithOptionalNumericComponent(self) + else: + return visitor.visitChildren(self) + + + def numericOperatorsComponent(self): + localctx = Parser.NumericOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 48, self.RULE_numericOperatorsComponent) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 801 self._errHandler.sync(self) @@ -7284,21 +6881,7 @@ def numericOperatorsComponent(self): self.state = 780 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ((_la - 85) & ~0x3F) == 0 - and ( - (1 << (_la - 85)) - & ( - (1 << (Parser.ABS - 85)) - | (1 << (Parser.LN - 85)) - | (1 << (Parser.EXP - 85)) - | (1 << (Parser.CEIL - 85)) - | (1 << (Parser.FLOOR - 85)) - | (1 << (Parser.SQRT - 85)) - ) - ) - != 0 - ): + if not(((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & ((1 << (Parser.ABS - 85)) | (1 << (Parser.LN - 85)) | (1 << (Parser.EXP - 85)) | (1 << (Parser.CEIL - 85)) | (1 << (Parser.FLOOR - 85)) | (1 << (Parser.SQRT - 85)))) != 0)): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -7316,7 +6899,7 @@ def numericOperatorsComponent(self): self.state = 785 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.TRUNC or _la == Parser.ROUND): + if not(_la==Parser.TRUNC or _la==Parser.ROUND): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -7328,12 +6911,13 @@ def numericOperatorsComponent(self): self.state = 790 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 788 self.match(Parser.COMMA) self.state = 789 self.optionalExprComponent() + self.state = 792 self.match(Parser.RPAREN) pass @@ -7343,19 +6927,7 @@ def numericOperatorsComponent(self): self.state = 794 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ((_la - 61) & ~0x3F) == 0 - and ( - (1 << (_la - 61)) - & ( - (1 << (Parser.RANDOM - 61)) - | (1 << (Parser.LOG - 61)) - | (1 << (Parser.POWER - 61)) - | (1 << (Parser.MOD - 61)) - ) - ) - != 0 - ): + if not(((((_la - 61)) & ~0x3f) == 0 and ((1 << (_la - 61)) & ((1 << (Parser.RANDOM - 61)) | (1 << (Parser.LOG - 61)) | (1 << (Parser.POWER - 61)) | (1 << (Parser.MOD - 61)))) != 0)): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -7382,165 +6954,185 @@ def numericOperatorsComponent(self): self.exitRule() return localctx + class ComparisonOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_comparisonOperators - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class BetweenAtomContext(ComparisonOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ComparisonOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.from_ = None # ExprContext - self.to_ = None # ExprContext + self.op = None # ExprContext + self.from_ = None # ExprContext + self.to_ = None # ExprContext self.copyFrom(ctx) def BETWEEN(self): return self.getToken(Parser.BETWEEN, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterBetweenAtom"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBetweenAtom" ): listener.enterBetweenAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitBetweenAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBetweenAtom" ): listener.exitBetweenAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBetweenAtom" ): + return visitor.visitBetweenAtom(self) + else: + return visitor.visitChildren(self) + + class CharsetMatchAtomContext(ComparisonOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ComparisonOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.pattern = None # ExprContext + self.op = None # ExprContext + self.pattern = None # ExprContext self.copyFrom(ctx) def CHARSET_MATCH(self): return self.getToken(Parser.CHARSET_MATCH, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCharsetMatchAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCharsetMatchAtom" ): listener.enterCharsetMatchAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCharsetMatchAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCharsetMatchAtom" ): listener.exitCharsetMatchAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCharsetMatchAtom" ): + return visitor.visitCharsetMatchAtom(self) + else: + return visitor.visitChildren(self) + + class IsNullAtomContext(ComparisonOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ComparisonOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def ISNULL(self): return self.getToken(Parser.ISNULL, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIsNullAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIsNullAtom" ): listener.enterIsNullAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIsNullAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIsNullAtom" ): listener.exitIsNullAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIsNullAtom" ): + return visitor.visitIsNullAtom(self) + else: + return visitor.visitChildren(self) + + class ExistInAtomContext(ComparisonOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ComparisonOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.right = None # ExprContext + self.left = None # ExprContext + self.right = None # ExprContext self.copyFrom(ctx) def EXISTS_IN(self): return self.getToken(Parser.EXISTS_IN, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) def retainType(self): - return self.getTypedRuleContext(Parser.RetainTypeContext, 0) + return self.getTypedRuleContext(Parser.RetainTypeContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterExistInAtom"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExistInAtom" ): listener.enterExistInAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitExistInAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExistInAtom" ): listener.exitExistInAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitExistInAtom" ): + return visitor.visitExistInAtom(self) + else: + return visitor.visitChildren(self) + + + def comparisonOperators(self): + localctx = Parser.ComparisonOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 50, self.RULE_comparisonOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 835 self._errHandler.sync(self) @@ -7609,12 +7201,13 @@ def comparisonOperators(self): self.state = 831 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 829 self.match(Parser.COMMA) self.state = 830 self.retainType() + self.state = 833 self.match(Parser.RPAREN) pass @@ -7629,121 +7222,138 @@ def comparisonOperators(self): self.exitRule() return localctx + class ComparisonOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_comparisonOperatorsComponent - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class IsNullAtomComponentContext(ComparisonOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ComparisonOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def ISNULL(self): return self.getToken(Parser.ISNULL, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIsNullAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIsNullAtomComponent" ): listener.enterIsNullAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIsNullAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIsNullAtomComponent" ): listener.exitIsNullAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIsNullAtomComponent" ): + return visitor.visitIsNullAtomComponent(self) + else: + return visitor.visitChildren(self) + + class CharsetMatchAtomComponentContext(ComparisonOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ComparisonOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # ExprComponentContext - self.pattern = None # ExprComponentContext + self.op = None # ExprComponentContext + self.pattern = None # ExprComponentContext self.copyFrom(ctx) def CHARSET_MATCH(self): return self.getToken(Parser.CHARSET_MATCH, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCharsetMatchAtomComponent"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCharsetMatchAtomComponent" ): listener.enterCharsetMatchAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCharsetMatchAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCharsetMatchAtomComponent" ): listener.exitCharsetMatchAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCharsetMatchAtomComponent" ): + return visitor.visitCharsetMatchAtomComponent(self) + else: + return visitor.visitChildren(self) + + class BetweenAtomComponentContext(ComparisonOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ComparisonOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # ExprComponentContext - self.from_ = None # ExprComponentContext - self.to_ = None # ExprComponentContext + self.op = None # ExprComponentContext + self.from_ = None # ExprComponentContext + self.to_ = None # ExprComponentContext self.copyFrom(ctx) def BETWEEN(self): return self.getToken(Parser.BETWEEN, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterBetweenAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBetweenAtomComponent" ): listener.enterBetweenAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitBetweenAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBetweenAtomComponent" ): listener.exitBetweenAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBetweenAtomComponent" ): + return visitor.visitBetweenAtomComponent(self) + else: + return visitor.visitChildren(self) + + + def comparisonOperatorsComponent(self): + localctx = Parser.ComparisonOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 52, self.RULE_comparisonOperatorsComponent) try: @@ -7809,515 +7419,574 @@ def comparisonOperatorsComponent(self): self.exitRule() return localctx + class TimeOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_timeOperators - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class DayToYearAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYTOYEAR(self): return self.getToken(Parser.DAYTOYEAR, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDayToYearAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDayToYearAtom" ): listener.enterDayToYearAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDayToYearAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDayToYearAtom" ): listener.exitDayToYearAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDayToYearAtom" ): + return visitor.visitDayToYearAtom(self) + else: + return visitor.visitChildren(self) + + class YearAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def YEAR_OP(self): return self.getToken(Parser.YEAR_OP, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterYearAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterYearAtom" ): listener.enterYearAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitYearAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitYearAtom" ): listener.exitYearAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitYearAtom" ): + return visitor.visitYearAtom(self) + else: + return visitor.visitChildren(self) + + class MonthToDayAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def MONTHTODAY(self): return self.getToken(Parser.MONTHTODAY, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterMonthToDayAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMonthToDayAtom" ): listener.enterMonthToDayAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitMonthToDayAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMonthToDayAtom" ): listener.exitMonthToDayAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitMonthToDayAtom" ): + return visitor.visitMonthToDayAtom(self) + else: + return visitor.visitChildren(self) + + class DayToMonthAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYTOMONTH(self): return self.getToken(Parser.DAYTOMONTH, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDayToMonthAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDayToMonthAtom" ): listener.enterDayToMonthAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDayToMonthAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDayToMonthAtom" ): listener.exitDayToMonthAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDayToMonthAtom" ): + return visitor.visitDayToMonthAtom(self) + else: + return visitor.visitChildren(self) + + class PeriodAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def PERIOD_INDICATOR(self): return self.getToken(Parser.PERIOD_INDICATOR, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterPeriodAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPeriodAtom" ): listener.enterPeriodAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitPeriodAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPeriodAtom" ): listener.exitPeriodAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPeriodAtom" ): + return visitor.visitPeriodAtom(self) + else: + return visitor.visitChildren(self) + + class FillTimeAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def FILL_TIME_SERIES(self): return self.getToken(Parser.FILL_TIME_SERIES, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def SINGLE(self): return self.getToken(Parser.SINGLE, 0) - def ALL(self): return self.getToken(Parser.ALL, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFillTimeAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFillTimeAtom" ): listener.enterFillTimeAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFillTimeAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFillTimeAtom" ): listener.exitFillTimeAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFillTimeAtom" ): + return visitor.visitFillTimeAtom(self) + else: + return visitor.visitChildren(self) + + class MonthAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def MONTH_OP(self): return self.getToken(Parser.MONTH_OP, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterMonthAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMonthAtom" ): listener.enterMonthAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitMonthAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMonthAtom" ): listener.exitMonthAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitMonthAtom" ): + return visitor.visitMonthAtom(self) + else: + return visitor.visitChildren(self) + + class DayOfYearAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYOFYEAR(self): return self.getToken(Parser.DAYOFYEAR, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDayOfYearAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDayOfYearAtom" ): listener.enterDayOfYearAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDayOfYearAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDayOfYearAtom" ): listener.exitDayOfYearAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDayOfYearAtom" ): + return visitor.visitDayOfYearAtom(self) + else: + return visitor.visitChildren(self) + + class FlowAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def FLOW_TO_STOCK(self): return self.getToken(Parser.FLOW_TO_STOCK, 0) - def STOCK_TO_FLOW(self): return self.getToken(Parser.STOCK_TO_FLOW, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFlowAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFlowAtom" ): listener.enterFlowAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFlowAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFlowAtom" ): listener.exitFlowAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFlowAtom" ): + return visitor.visitFlowAtom(self) + else: + return visitor.visitChildren(self) + + class TimeShiftAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def TIMESHIFT(self): return self.getToken(Parser.TIMESHIFT, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def COMMA(self): return self.getToken(Parser.COMMA, 0) - def signedInteger(self): - return self.getTypedRuleContext(Parser.SignedIntegerContext, 0) + return self.getTypedRuleContext(Parser.SignedIntegerContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimeShiftAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimeShiftAtom" ): listener.enterTimeShiftAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimeShiftAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimeShiftAtom" ): listener.exitTimeShiftAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimeShiftAtom" ): + return visitor.visitTimeShiftAtom(self) + else: + return visitor.visitChildren(self) + + class TimeAggAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) - self.periodIndTo = None # Token - self.periodIndFrom = None # Token - self.op = None # OptionalExprContext + self.periodIndTo = None # Token + self.periodIndFrom = None # Token + self.op = None # OptionalExprContext self.copyFrom(ctx) def TIME_AGG(self): return self.getToken(Parser.TIME_AGG, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def STRING_CONSTANT(self, i: int = None): + def STRING_CONSTANT(self, i:int=None): if i is None: return self.getTokens(Parser.STRING_CONSTANT) else: return self.getToken(Parser.STRING_CONSTANT, i) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def optionalExpr(self): - return self.getTypedRuleContext(Parser.OptionalExprContext, 0) + return self.getTypedRuleContext(Parser.OptionalExprContext,0) def FIRST(self): return self.getToken(Parser.FIRST, 0) - def LAST(self): return self.getToken(Parser.LAST, 0) - def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimeAggAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimeAggAtom" ): listener.enterTimeAggAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimeAggAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimeAggAtom" ): listener.exitTimeAggAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimeAggAtom" ): + return visitor.visitTimeAggAtom(self) + else: + return visitor.visitChildren(self) + + class DateDiffAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) - self.dateFrom = None # ExprContext - self.dateTo = None # ExprContext + self.dateFrom = None # ExprContext + self.dateTo = None # ExprContext self.copyFrom(ctx) def DATEDIFF(self): return self.getToken(Parser.DATEDIFF, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDateDiffAtom"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDateDiffAtom" ): listener.enterDateDiffAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDateDiffAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDateDiffAtom" ): listener.exitDateDiffAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDateDiffAtom" ): + return visitor.visitDateDiffAtom(self) + else: + return visitor.visitChildren(self) + + class DateAddAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.shiftNumber = None # ExprContext - self.periodInd = None # ExprContext + self.op = None # ExprContext + self.shiftNumber = None # ExprContext + self.periodInd = None # ExprContext self.copyFrom(ctx) def DATEADD(self): return self.getToken(Parser.DATEADD, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDateAddAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDateAddAtom" ): listener.enterDateAddAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDateAddAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDateAddAtom" ): listener.exitDateAddAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDateAddAtom" ): + return visitor.visitDateAddAtom(self) + else: + return visitor.visitChildren(self) + + class YearToDayAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def YEARTODAY(self): return self.getToken(Parser.YEARTODAY, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterYearToDayAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterYearToDayAtom" ): listener.enterYearToDayAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitYearToDayAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitYearToDayAtom" ): listener.exitYearToDayAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitYearToDayAtom" ): + return visitor.visitYearToDayAtom(self) + else: + return visitor.visitChildren(self) + + class DayOfMonthAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYOFMONTH(self): return self.getToken(Parser.DAYOFMONTH, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDayOfMonthAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDayOfMonthAtom" ): listener.enterDayOfMonthAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDayOfMonthAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDayOfMonthAtom" ): listener.exitDayOfMonthAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDayOfMonthAtom" ): + return visitor.visitDayOfMonthAtom(self) + else: + return visitor.visitChildren(self) + + class CurrentDateAtomContext(TimeOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CURRENT_DATE(self): return self.getToken(Parser.CURRENT_DATE, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCurrentDateAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCurrentDateAtom" ): listener.enterCurrentDateAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCurrentDateAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCurrentDateAtom" ): listener.exitCurrentDateAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCurrentDateAtom" ): + return visitor.visitCurrentDateAtom(self) + else: + return visitor.visitChildren(self) + + + def timeOperators(self): + localctx = Parser.TimeOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 54, self.RULE_timeOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 962 self._errHandler.sync(self) @@ -8332,131 +8001,11 @@ def timeOperators(self): self.state = 863 self._errHandler.sync(self) _la = self._input.LA(1) - if ( - ( - ((_la) & ~0x3F) == 0 - and ( - (1 << _la) - & ( - (1 << Parser.LPAREN) - | (1 << Parser.PLUS) - | (1 << Parser.MINUS) - | (1 << Parser.EVAL) - | (1 << Parser.IF) - | (1 << Parser.CASE) - | (1 << Parser.CURRENT_DATE) - | (1 << Parser.DATEDIFF) - | (1 << Parser.DATEADD) - | (1 << Parser.YEAR_OP) - | (1 << Parser.MONTH_OP) - | (1 << Parser.DAYOFMONTH) - | (1 << Parser.DAYOFYEAR) - | (1 << Parser.DAYTOYEAR) - | (1 << Parser.DAYTOMONTH) - | (1 << Parser.YEARTODAY) - | (1 << Parser.MONTHTODAY) - | (1 << Parser.NOT) - | (1 << Parser.BETWEEN) - | (1 << Parser.NULL_CONSTANT) - | (1 << Parser.ISNULL) - | (1 << Parser.UNION) - | (1 << Parser.SYMDIFF) - | (1 << Parser.INTERSECT) - | (1 << Parser.RANDOM) - ) - ) - != 0 - ) - or ( - ((_la - 66) & ~0x3F) == 0 - and ( - (1 << (_la - 66)) - & ( - (1 << (Parser.CHECK - 66)) - | (1 << (Parser.EXISTS_IN - 66)) - | (1 << (Parser.MIN - 66)) - | (1 << (Parser.MAX - 66)) - | (1 << (Parser.ABS - 66)) - | (1 << (Parser.LN - 66)) - | (1 << (Parser.LOG - 66)) - | (1 << (Parser.TRUNC - 66)) - | (1 << (Parser.ROUND - 66)) - | (1 << (Parser.POWER - 66)) - | (1 << (Parser.MOD - 66)) - | (1 << (Parser.LEN - 66)) - | (1 << (Parser.TRIM - 66)) - | (1 << (Parser.UCASE - 66)) - | (1 << (Parser.LCASE - 66)) - | (1 << (Parser.SUBSTR - 66)) - | (1 << (Parser.SUM - 66)) - | (1 << (Parser.AVG - 66)) - | (1 << (Parser.MEDIAN - 66)) - | (1 << (Parser.COUNT - 66)) - | (1 << (Parser.EXP - 66)) - | (1 << (Parser.CHARSET_MATCH - 66)) - | (1 << (Parser.NVL - 66)) - | (1 << (Parser.HIERARCHY - 66)) - ) - ) - != 0 - ) - or ( - ((_la - 131) & ~0x3F) == 0 - and ( - (1 << (_la - 131)) - & ( - (1 << (Parser.LTRIM - 131)) - | (1 << (Parser.RTRIM - 131)) - | (1 << (Parser.INSTR - 131)) - | (1 << (Parser.REPLACE - 131)) - | (1 << (Parser.CEIL - 131)) - | (1 << (Parser.FLOOR - 131)) - | (1 << (Parser.SQRT - 131)) - | (1 << (Parser.SETDIFF - 131)) - | (1 << (Parser.STDDEV_POP - 131)) - | (1 << (Parser.STDDEV_SAMP - 131)) - | (1 << (Parser.VAR_POP - 131)) - | (1 << (Parser.VAR_SAMP - 131)) - | (1 << (Parser.FIRST_VALUE - 131)) - | (1 << (Parser.LAST_VALUE - 131)) - | (1 << (Parser.LAG - 131)) - | (1 << (Parser.LEAD - 131)) - | (1 << (Parser.RATIO_TO_REPORT - 131)) - | (1 << (Parser.FILL_TIME_SERIES - 131)) - | (1 << (Parser.FLOW_TO_STOCK - 131)) - | (1 << (Parser.STOCK_TO_FLOW - 131)) - | (1 << (Parser.TIMESHIFT - 131)) - | (1 << (Parser.INNER_JOIN - 131)) - | (1 << (Parser.LEFT_JOIN - 131)) - ) - ) - != 0 - ) - or ( - ((_la - 195) & ~0x3F) == 0 - and ( - (1 << (_la - 195)) - & ( - (1 << (Parser.CROSS_JOIN - 195)) - | (1 << (Parser.FULL_JOIN - 195)) - | (1 << (Parser.PERIOD_INDICATOR - 195)) - | (1 << (Parser.TIME_AGG - 195)) - | (1 << (Parser.CAST - 195)) - | (1 << (Parser.CHECK_DATAPOINT - 195)) - | (1 << (Parser.CHECK_HIERARCHY - 195)) - | (1 << (Parser.INTEGER_CONSTANT - 195)) - | (1 << (Parser.NUMBER_CONSTANT - 195)) - | (1 << (Parser.BOOLEAN_CONSTANT - 195)) - | (1 << (Parser.STRING_CONSTANT - 195)) - | (1 << (Parser.IDENTIFIER - 195)) - ) - ) - != 0 - ) - ): + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CASE) | (1 << Parser.CURRENT_DATE) | (1 << Parser.DATEDIFF) | (1 << Parser.DATEADD) | (1 << Parser.YEAR_OP) | (1 << Parser.MONTH_OP) | (1 << Parser.DAYOFMONTH) | (1 << Parser.DAYOFYEAR) | (1 << Parser.DAYTOYEAR) | (1 << Parser.DAYTOMONTH) | (1 << Parser.YEARTODAY) | (1 << Parser.MONTHTODAY) | (1 << Parser.NOT) | (1 << Parser.BETWEEN) | (1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL) | (1 << Parser.UNION) | (1 << Parser.SYMDIFF) | (1 << Parser.INTERSECT) | (1 << Parser.RANDOM))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Parser.CHECK - 66)) | (1 << (Parser.EXISTS_IN - 66)) | (1 << (Parser.MIN - 66)) | (1 << (Parser.MAX - 66)) | (1 << (Parser.ABS - 66)) | (1 << (Parser.LN - 66)) | (1 << (Parser.LOG - 66)) | (1 << (Parser.TRUNC - 66)) | (1 << (Parser.ROUND - 66)) | (1 << (Parser.POWER - 66)) | (1 << (Parser.MOD - 66)) | (1 << (Parser.LEN - 66)) | (1 << (Parser.TRIM - 66)) | (1 << (Parser.UCASE - 66)) | (1 << (Parser.LCASE - 66)) | (1 << (Parser.SUBSTR - 66)) | (1 << (Parser.SUM - 66)) | (1 << (Parser.AVG - 66)) | (1 << (Parser.MEDIAN - 66)) | (1 << (Parser.COUNT - 66)) | (1 << (Parser.EXP - 66)) | (1 << (Parser.CHARSET_MATCH - 66)) | (1 << (Parser.NVL - 66)) | (1 << (Parser.HIERARCHY - 66)))) != 0) or ((((_la - 131)) & ~0x3f) == 0 and ((1 << (_la - 131)) & ((1 << (Parser.LTRIM - 131)) | (1 << (Parser.RTRIM - 131)) | (1 << (Parser.INSTR - 131)) | (1 << (Parser.REPLACE - 131)) | (1 << (Parser.CEIL - 131)) | (1 << (Parser.FLOOR - 131)) | (1 << (Parser.SQRT - 131)) | (1 << (Parser.SETDIFF - 131)) | (1 << (Parser.STDDEV_POP - 131)) | (1 << (Parser.STDDEV_SAMP - 131)) | (1 << (Parser.VAR_POP - 131)) | (1 << (Parser.VAR_SAMP - 131)) | (1 << (Parser.FIRST_VALUE - 131)) | (1 << (Parser.LAST_VALUE - 131)) | (1 << (Parser.LAG - 131)) | (1 << (Parser.LEAD - 131)) | (1 << (Parser.RATIO_TO_REPORT - 131)) | (1 << (Parser.FILL_TIME_SERIES - 131)) | (1 << (Parser.FLOW_TO_STOCK - 131)) | (1 << (Parser.STOCK_TO_FLOW - 131)) | (1 << (Parser.TIMESHIFT - 131)) | (1 << (Parser.INNER_JOIN - 131)) | (1 << (Parser.LEFT_JOIN - 131)))) != 0) or ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & ((1 << (Parser.CROSS_JOIN - 195)) | (1 << (Parser.FULL_JOIN - 195)) | (1 << (Parser.PERIOD_INDICATOR - 195)) | (1 << (Parser.TIME_AGG - 195)) | (1 << (Parser.CAST - 195)) | (1 << (Parser.CHECK_DATAPOINT - 195)) | (1 << (Parser.CHECK_HIERARCHY - 195)) | (1 << (Parser.INTEGER_CONSTANT - 195)) | (1 << (Parser.NUMBER_CONSTANT - 195)) | (1 << (Parser.BOOLEAN_CONSTANT - 195)) | (1 << (Parser.STRING_CONSTANT - 195)) | (1 << (Parser.IDENTIFIER - 195)))) != 0): self.state = 862 self.expr(0) + self.state = 865 self.match(Parser.RPAREN) pass @@ -8472,17 +8021,18 @@ def timeOperators(self): self.state = 871 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 869 self.match(Parser.COMMA) self.state = 870 _la = self._input.LA(1) - if not (_la == Parser.ALL or _la == Parser.SINGLE): + if not(_la==Parser.ALL or _la==Parser.SINGLE): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() + self.state = 873 self.match(Parser.RPAREN) pass @@ -8492,7 +8042,7 @@ def timeOperators(self): self.state = 875 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.FLOW_TO_STOCK or _la == Parser.STOCK_TO_FLOW): + if not(_la==Parser.FLOW_TO_STOCK or _la==Parser.STOCK_TO_FLOW): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -8531,42 +8081,45 @@ def timeOperators(self): localctx.periodIndTo = self.match(Parser.STRING_CONSTANT) self.state = 892 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 70, self._ctx) + la_ = self._interp.adaptivePredict(self._input,70,self._ctx) if la_ == 1: self.state = 890 self.match(Parser.COMMA) self.state = 891 localctx.periodIndFrom = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.OPTIONAL or _la == Parser.STRING_CONSTANT): + if not(_la==Parser.OPTIONAL or _la==Parser.STRING_CONSTANT): localctx.periodIndFrom = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() + self.state = 896 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 71, self._ctx) + la_ = self._interp.adaptivePredict(self._input,71,self._ctx) if la_ == 1: self.state = 894 self.match(Parser.COMMA) self.state = 895 localctx.op = self.optionalExpr() + self.state = 900 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 898 self.match(Parser.COMMA) self.state = 899 _la = self._input.LA(1) - if not (_la == Parser.FIRST or _la == Parser.LAST): + if not(_la==Parser.FIRST or _la==Parser.LAST): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() + self.state = 902 self.match(Parser.RPAREN) pass @@ -8723,515 +8276,574 @@ def timeOperators(self): self.exitRule() return localctx + class TimeOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_timeOperatorsComponent - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class PeriodAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def PERIOD_INDICATOR(self): return self.getToken(Parser.PERIOD_INDICATOR, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterPeriodAtomComponent"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPeriodAtomComponent" ): listener.enterPeriodAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitPeriodAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPeriodAtomComponent" ): listener.exitPeriodAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPeriodAtomComponent" ): + return visitor.visitPeriodAtomComponent(self) + else: + return visitor.visitChildren(self) + + class TimeShiftAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def TIMESHIFT(self): return self.getToken(Parser.TIMESHIFT, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def COMMA(self): return self.getToken(Parser.COMMA, 0) - def signedInteger(self): - return self.getTypedRuleContext(Parser.SignedIntegerContext, 0) + return self.getTypedRuleContext(Parser.SignedIntegerContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimeShiftAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimeShiftAtomComponent" ): listener.enterTimeShiftAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimeShiftAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimeShiftAtomComponent" ): listener.exitTimeShiftAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimeShiftAtomComponent" ): + return visitor.visitTimeShiftAtomComponent(self) + else: + return visitor.visitChildren(self) + + class TimeAggAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) - self.periodIndTo = None # Token - self.periodIndFrom = None # Token - self.op = None # OptionalExprComponentContext + self.periodIndTo = None # Token + self.periodIndFrom = None # Token + self.op = None # OptionalExprComponentContext self.copyFrom(ctx) def TIME_AGG(self): return self.getToken(Parser.TIME_AGG, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def STRING_CONSTANT(self, i: int = None): + def STRING_CONSTANT(self, i:int=None): if i is None: return self.getTokens(Parser.STRING_CONSTANT) else: return self.getToken(Parser.STRING_CONSTANT, i) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def optionalExprComponent(self): - return self.getTypedRuleContext(Parser.OptionalExprComponentContext, 0) + return self.getTypedRuleContext(Parser.OptionalExprComponentContext,0) def FIRST(self): return self.getToken(Parser.FIRST, 0) - def LAST(self): return self.getToken(Parser.LAST, 0) - def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimeAggAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimeAggAtomComponent" ): listener.enterTimeAggAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimeAggAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimeAggAtomComponent" ): listener.exitTimeAggAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimeAggAtomComponent" ): + return visitor.visitTimeAggAtomComponent(self) + else: + return visitor.visitChildren(self) + + class DayToMonthAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYTOMONTH(self): return self.getToken(Parser.DAYTOMONTH, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDayToMonthAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDayToMonthAtomComponent" ): listener.enterDayToMonthAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDayToMonthAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDayToMonthAtomComponent" ): listener.exitDayToMonthAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDayToMonthAtomComponent" ): + return visitor.visitDayToMonthAtomComponent(self) + else: + return visitor.visitChildren(self) + + class DateAddAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # ExprComponentContext - self.shiftNumber = None # ExprComponentContext - self.periodInd = None # ExprComponentContext + self.op = None # ExprComponentContext + self.shiftNumber = None # ExprComponentContext + self.periodInd = None # ExprComponentContext self.copyFrom(ctx) def DATEADD(self): return self.getToken(Parser.DATEADD, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDateAddAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDateAddAtomComponent" ): listener.enterDateAddAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDateAddAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDateAddAtomComponent" ): listener.exitDateAddAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDateAddAtomComponent" ): + return visitor.visitDateAddAtomComponent(self) + else: + return visitor.visitChildren(self) + + class MonthToDayAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def MONTHTODAY(self): return self.getToken(Parser.MONTHTODAY, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterMonthToDayAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMonthToDayAtomComponent" ): listener.enterMonthToDayAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitMonthToDayAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMonthToDayAtomComponent" ): listener.exitMonthToDayAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitMonthToDayAtomComponent" ): + return visitor.visitMonthToDayAtomComponent(self) + else: + return visitor.visitChildren(self) + + class DayOfMonthAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYOFMONTH(self): return self.getToken(Parser.DAYOFMONTH, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDayOfMonthAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDayOfMonthAtomComponent" ): listener.enterDayOfMonthAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDayOfMonthAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDayOfMonthAtomComponent" ): listener.exitDayOfMonthAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDayOfMonthAtomComponent" ): + return visitor.visitDayOfMonthAtomComponent(self) + else: + return visitor.visitChildren(self) + + class DayOfYearAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYOFYEAR(self): return self.getToken(Parser.DAYOFYEAR, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDayOfYearAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDayOfYearAtomComponent" ): listener.enterDayOfYearAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDayOfYearAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDayOfYearAtomComponent" ): listener.exitDayOfYearAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDayOfYearAtomComponent" ): + return visitor.visitDayOfYearAtomComponent(self) + else: + return visitor.visitChildren(self) + + class MonthAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def MONTH_OP(self): return self.getToken(Parser.MONTH_OP, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterMonthAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMonthAtomComponent" ): listener.enterMonthAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitMonthAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMonthAtomComponent" ): listener.exitMonthAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitMonthAtomComponent" ): + return visitor.visitMonthAtomComponent(self) + else: + return visitor.visitChildren(self) + + class YearToDayAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def YEARTODAY(self): return self.getToken(Parser.YEARTODAY, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterYearToDayAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterYearToDayAtomComponent" ): listener.enterYearToDayAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitYearToDayAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitYearToDayAtomComponent" ): listener.exitYearToDayAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitYearToDayAtomComponent" ): + return visitor.visitYearToDayAtomComponent(self) + else: + return visitor.visitChildren(self) + + class FillTimeAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def FILL_TIME_SERIES(self): return self.getToken(Parser.FILL_TIME_SERIES, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def SINGLE(self): return self.getToken(Parser.SINGLE, 0) - def ALL(self): return self.getToken(Parser.ALL, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFillTimeAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFillTimeAtomComponent" ): listener.enterFillTimeAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFillTimeAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFillTimeAtomComponent" ): listener.exitFillTimeAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFillTimeAtomComponent" ): + return visitor.visitFillTimeAtomComponent(self) + else: + return visitor.visitChildren(self) + + class DayToYearAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYTOYEAR(self): return self.getToken(Parser.DAYTOYEAR, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDayToYearAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDayToYearAtomComponent" ): listener.enterDayToYearAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDayToYearAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDayToYearAtomComponent" ): listener.exitDayToYearAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDayToYearAtomComponent" ): + return visitor.visitDayToYearAtomComponent(self) + else: + return visitor.visitChildren(self) + + class CurrentDateAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CURRENT_DATE(self): return self.getToken(Parser.CURRENT_DATE, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCurrentDateAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCurrentDateAtomComponent" ): listener.enterCurrentDateAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCurrentDateAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCurrentDateAtomComponent" ): listener.exitCurrentDateAtomComponent(self) - class FlowAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCurrentDateAtomComponent" ): + return visitor.visitCurrentDateAtomComponent(self) + else: + return visitor.visitChildren(self) + + + class FlowAtomComponentContext(TimeOperatorsComponentContext): + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def FLOW_TO_STOCK(self): return self.getToken(Parser.FLOW_TO_STOCK, 0) - def STOCK_TO_FLOW(self): return self.getToken(Parser.STOCK_TO_FLOW, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFlowAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFlowAtomComponent" ): listener.enterFlowAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFlowAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFlowAtomComponent" ): listener.exitFlowAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFlowAtomComponent" ): + return visitor.visitFlowAtomComponent(self) + else: + return visitor.visitChildren(self) + + class DateDiffAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) - self.dateFrom = None # ExprComponentContext - self.dateTo = None # ExprComponentContext + self.dateFrom = None # ExprComponentContext + self.dateTo = None # ExprComponentContext self.copyFrom(ctx) def DATEDIFF(self): return self.getToken(Parser.DATEDIFF, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDateDiffAtomComponent"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDateDiffAtomComponent" ): listener.enterDateDiffAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDateDiffAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDateDiffAtomComponent" ): listener.exitDateDiffAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDateDiffAtomComponent" ): + return visitor.visitDateDiffAtomComponent(self) + else: + return visitor.visitChildren(self) + + class YearAtomComponentContext(TimeOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.TimeOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def YEAR_OP(self): return self.getToken(Parser.YEAR_OP, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterYearAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterYearAtomComponent" ): listener.enterYearAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitYearAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitYearAtomComponent" ): listener.exitYearAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitYearAtomComponent" ): + return visitor.visitYearAtomComponent(self) + else: + return visitor.visitChildren(self) + + + def timeOperatorsComponent(self): + localctx = Parser.TimeOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 56, self.RULE_timeOperatorsComponent) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1066 self._errHandler.sync(self) @@ -9246,119 +8858,11 @@ def timeOperatorsComponent(self): self.state = 967 self._errHandler.sync(self) _la = self._input.LA(1) - if ( - ( - ((_la) & ~0x3F) == 0 - and ( - (1 << _la) - & ( - (1 << Parser.LPAREN) - | (1 << Parser.PLUS) - | (1 << Parser.MINUS) - | (1 << Parser.EVAL) - | (1 << Parser.IF) - | (1 << Parser.CASE) - | (1 << Parser.CURRENT_DATE) - | (1 << Parser.DATEDIFF) - | (1 << Parser.DATEADD) - | (1 << Parser.YEAR_OP) - | (1 << Parser.MONTH_OP) - | (1 << Parser.DAYOFMONTH) - | (1 << Parser.DAYOFYEAR) - | (1 << Parser.DAYTOYEAR) - | (1 << Parser.DAYTOMONTH) - | (1 << Parser.YEARTODAY) - | (1 << Parser.MONTHTODAY) - | (1 << Parser.NOT) - | (1 << Parser.BETWEEN) - | (1 << Parser.NULL_CONSTANT) - | (1 << Parser.ISNULL) - | (1 << Parser.RANDOM) - ) - ) - != 0 - ) - or ( - ((_la - 77) & ~0x3F) == 0 - and ( - (1 << (_la - 77)) - & ( - (1 << (Parser.RANK - 77)) - | (1 << (Parser.MIN - 77)) - | (1 << (Parser.MAX - 77)) - | (1 << (Parser.ABS - 77)) - | (1 << (Parser.LN - 77)) - | (1 << (Parser.LOG - 77)) - | (1 << (Parser.TRUNC - 77)) - | (1 << (Parser.ROUND - 77)) - | (1 << (Parser.POWER - 77)) - | (1 << (Parser.MOD - 77)) - | (1 << (Parser.LEN - 77)) - | (1 << (Parser.TRIM - 77)) - | (1 << (Parser.UCASE - 77)) - | (1 << (Parser.LCASE - 77)) - | (1 << (Parser.SUBSTR - 77)) - | (1 << (Parser.SUM - 77)) - | (1 << (Parser.AVG - 77)) - | (1 << (Parser.MEDIAN - 77)) - | (1 << (Parser.COUNT - 77)) - | (1 << (Parser.EXP - 77)) - | (1 << (Parser.CHARSET_MATCH - 77)) - | (1 << (Parser.NVL - 77)) - | (1 << (Parser.LTRIM - 77)) - | (1 << (Parser.RTRIM - 77)) - | (1 << (Parser.INSTR - 77)) - | (1 << (Parser.REPLACE - 77)) - | (1 << (Parser.CEIL - 77)) - | (1 << (Parser.FLOOR - 77)) - | (1 << (Parser.SQRT - 77)) - | (1 << (Parser.STDDEV_POP - 77)) - ) - ) - != 0 - ) - or ( - ((_la - 141) & ~0x3F) == 0 - and ( - (1 << (_la - 141)) - & ( - (1 << (Parser.STDDEV_SAMP - 141)) - | (1 << (Parser.VAR_POP - 141)) - | (1 << (Parser.VAR_SAMP - 141)) - | (1 << (Parser.FIRST_VALUE - 141)) - | (1 << (Parser.LAST_VALUE - 141)) - | (1 << (Parser.LAG - 141)) - | (1 << (Parser.LEAD - 141)) - | (1 << (Parser.RATIO_TO_REPORT - 141)) - | (1 << (Parser.FILL_TIME_SERIES - 141)) - | (1 << (Parser.FLOW_TO_STOCK - 141)) - | (1 << (Parser.STOCK_TO_FLOW - 141)) - | (1 << (Parser.TIMESHIFT - 141)) - ) - ) - != 0 - ) - or ( - ((_la - 208) & ~0x3F) == 0 - and ( - (1 << (_la - 208)) - & ( - (1 << (Parser.PERIOD_INDICATOR - 208)) - | (1 << (Parser.TIME_AGG - 208)) - | (1 << (Parser.CAST - 208)) - | (1 << (Parser.INTEGER_CONSTANT - 208)) - | (1 << (Parser.NUMBER_CONSTANT - 208)) - | (1 << (Parser.BOOLEAN_CONSTANT - 208)) - | (1 << (Parser.STRING_CONSTANT - 208)) - | (1 << (Parser.IDENTIFIER - 208)) - ) - ) - != 0 - ) - ): + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CASE) | (1 << Parser.CURRENT_DATE) | (1 << Parser.DATEDIFF) | (1 << Parser.DATEADD) | (1 << Parser.YEAR_OP) | (1 << Parser.MONTH_OP) | (1 << Parser.DAYOFMONTH) | (1 << Parser.DAYOFYEAR) | (1 << Parser.DAYTOYEAR) | (1 << Parser.DAYTOMONTH) | (1 << Parser.YEARTODAY) | (1 << Parser.MONTHTODAY) | (1 << Parser.NOT) | (1 << Parser.BETWEEN) | (1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL) | (1 << Parser.RANDOM))) != 0) or ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & ((1 << (Parser.RANK - 77)) | (1 << (Parser.MIN - 77)) | (1 << (Parser.MAX - 77)) | (1 << (Parser.ABS - 77)) | (1 << (Parser.LN - 77)) | (1 << (Parser.LOG - 77)) | (1 << (Parser.TRUNC - 77)) | (1 << (Parser.ROUND - 77)) | (1 << (Parser.POWER - 77)) | (1 << (Parser.MOD - 77)) | (1 << (Parser.LEN - 77)) | (1 << (Parser.TRIM - 77)) | (1 << (Parser.UCASE - 77)) | (1 << (Parser.LCASE - 77)) | (1 << (Parser.SUBSTR - 77)) | (1 << (Parser.SUM - 77)) | (1 << (Parser.AVG - 77)) | (1 << (Parser.MEDIAN - 77)) | (1 << (Parser.COUNT - 77)) | (1 << (Parser.EXP - 77)) | (1 << (Parser.CHARSET_MATCH - 77)) | (1 << (Parser.NVL - 77)) | (1 << (Parser.LTRIM - 77)) | (1 << (Parser.RTRIM - 77)) | (1 << (Parser.INSTR - 77)) | (1 << (Parser.REPLACE - 77)) | (1 << (Parser.CEIL - 77)) | (1 << (Parser.FLOOR - 77)) | (1 << (Parser.SQRT - 77)) | (1 << (Parser.STDDEV_POP - 77)))) != 0) or ((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & ((1 << (Parser.STDDEV_SAMP - 141)) | (1 << (Parser.VAR_POP - 141)) | (1 << (Parser.VAR_SAMP - 141)) | (1 << (Parser.FIRST_VALUE - 141)) | (1 << (Parser.LAST_VALUE - 141)) | (1 << (Parser.LAG - 141)) | (1 << (Parser.LEAD - 141)) | (1 << (Parser.RATIO_TO_REPORT - 141)) | (1 << (Parser.FILL_TIME_SERIES - 141)) | (1 << (Parser.FLOW_TO_STOCK - 141)) | (1 << (Parser.STOCK_TO_FLOW - 141)) | (1 << (Parser.TIMESHIFT - 141)))) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & ((1 << (Parser.PERIOD_INDICATOR - 208)) | (1 << (Parser.TIME_AGG - 208)) | (1 << (Parser.CAST - 208)) | (1 << (Parser.INTEGER_CONSTANT - 208)) | (1 << (Parser.NUMBER_CONSTANT - 208)) | (1 << (Parser.BOOLEAN_CONSTANT - 208)) | (1 << (Parser.STRING_CONSTANT - 208)) | (1 << (Parser.IDENTIFIER - 208)))) != 0): self.state = 966 self.exprComponent(0) + self.state = 969 self.match(Parser.RPAREN) pass @@ -9374,17 +8878,18 @@ def timeOperatorsComponent(self): self.state = 975 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 973 self.match(Parser.COMMA) self.state = 974 _la = self._input.LA(1) - if not (_la == Parser.ALL or _la == Parser.SINGLE): + if not(_la==Parser.ALL or _la==Parser.SINGLE): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() + self.state = 977 self.match(Parser.RPAREN) pass @@ -9394,7 +8899,7 @@ def timeOperatorsComponent(self): self.state = 979 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.FLOW_TO_STOCK or _la == Parser.STOCK_TO_FLOW): + if not(_la==Parser.FLOW_TO_STOCK or _la==Parser.STOCK_TO_FLOW): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -9433,42 +8938,45 @@ def timeOperatorsComponent(self): localctx.periodIndTo = self.match(Parser.STRING_CONSTANT) self.state = 996 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 76, self._ctx) + la_ = self._interp.adaptivePredict(self._input,76,self._ctx) if la_ == 1: self.state = 994 self.match(Parser.COMMA) self.state = 995 localctx.periodIndFrom = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.OPTIONAL or _la == Parser.STRING_CONSTANT): + if not(_la==Parser.OPTIONAL or _la==Parser.STRING_CONSTANT): localctx.periodIndFrom = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() + self.state = 1000 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 77, self._ctx) + la_ = self._interp.adaptivePredict(self._input,77,self._ctx) if la_ == 1: self.state = 998 self.match(Parser.COMMA) self.state = 999 localctx.op = self.optionalExprComponent() + self.state = 1004 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 1002 self.match(Parser.COMMA) self.state = 1003 _la = self._input.LA(1) - if not (_la == Parser.FIRST or _la == Parser.LAST): + if not(_la==Parser.FIRST or _la==Parser.LAST): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() + self.state = 1006 self.match(Parser.RPAREN) pass @@ -9625,136 +9133,151 @@ def timeOperatorsComponent(self): self.exitRule() return localctx + class SetOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_setOperators - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class SetOrSYmDiffAtomContext(SetOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.SetOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.SetOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token - self.left = None # ExprContext - self.right = None # ExprContext + self.op = None # Token + self.left = None # ExprContext + self.right = None # ExprContext self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) def SETDIFF(self): return self.getToken(Parser.SETDIFF, 0) - def SYMDIFF(self): return self.getToken(Parser.SYMDIFF, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterSetOrSYmDiffAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSetOrSYmDiffAtom" ): listener.enterSetOrSYmDiffAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitSetOrSYmDiffAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSetOrSYmDiffAtom" ): listener.exitSetOrSYmDiffAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSetOrSYmDiffAtom" ): + return visitor.visitSetOrSYmDiffAtom(self) + else: + return visitor.visitChildren(self) + + class IntersectAtomContext(SetOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.SetOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.SetOperatorsContext super().__init__(ANTLRParser) - self.left = None # ExprContext + self.left = None # ExprContext self.copyFrom(ctx) def INTERSECT(self): return self.getToken(Parser.INTERSECT, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIntersectAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntersectAtom" ): listener.enterIntersectAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIntersectAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntersectAtom" ): listener.exitIntersectAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntersectAtom" ): + return visitor.visitIntersectAtom(self) + else: + return visitor.visitChildren(self) + + class UnionAtomContext(SetOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.SetOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.SetOperatorsContext super().__init__(ANTLRParser) - self.left = None # ExprContext + self.left = None # ExprContext self.copyFrom(ctx) def UNION(self): return self.getToken(Parser.UNION, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterUnionAtom"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnionAtom" ): listener.enterUnionAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitUnionAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnionAtom" ): listener.exitUnionAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUnionAtom" ): + return visitor.visitUnionAtom(self) + else: + return visitor.visitChildren(self) + + + def setOperators(self): + localctx = Parser.SetOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 58, self.RULE_setOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1097 self._errHandler.sync(self) @@ -9768,7 +9291,7 @@ def setOperators(self): self.match(Parser.LPAREN) self.state = 1070 localctx.left = self.expr(0) - self.state = 1073 + self.state = 1073 self._errHandler.sync(self) _la = self._input.LA(1) while True: @@ -9776,10 +9299,10 @@ def setOperators(self): self.match(Parser.COMMA) self.state = 1072 self.expr(0) - self.state = 1075 + self.state = 1075 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la == Parser.COMMA): + if not (_la==Parser.COMMA): break self.state = 1077 @@ -9794,7 +9317,7 @@ def setOperators(self): self.match(Parser.LPAREN) self.state = 1081 localctx.left = self.expr(0) - self.state = 1084 + self.state = 1084 self._errHandler.sync(self) _la = self._input.LA(1) while True: @@ -9802,10 +9325,10 @@ def setOperators(self): self.match(Parser.COMMA) self.state = 1083 self.expr(0) - self.state = 1086 + self.state = 1086 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la == Parser.COMMA): + if not (_la==Parser.COMMA): break self.state = 1088 @@ -9817,7 +9340,7 @@ def setOperators(self): self.state = 1090 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.SYMDIFF or _la == Parser.SETDIFF): + if not(_la==Parser.SYMDIFF or _la==Parser.SETDIFF): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -9844,15 +9367,16 @@ def setOperators(self): self.exitRule() return localctx + class HierarchyOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.op = None # ExprContext - self.hrName = None # Token - self.ruleComponent = None # ComponentIDContext + self.op = None # ExprContext + self.hrName = None # Token + self.ruleComponent = None # ComponentIDContext def HIERARCHY(self): return self.getToken(Parser.HIERARCHY, 0) @@ -9867,44 +9391,60 @@ def RPAREN(self): return self.getToken(Parser.RPAREN, 0) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) + def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) def conditionClause(self): - return self.getTypedRuleContext(Parser.ConditionClauseContext, 0) + return self.getTypedRuleContext(Parser.ConditionClauseContext,0) + def RULE(self): return self.getToken(Parser.RULE, 0) def validationMode(self): - return self.getTypedRuleContext(Parser.ValidationModeContext, 0) + return self.getTypedRuleContext(Parser.ValidationModeContext,0) + def inputModeHierarchy(self): - return self.getTypedRuleContext(Parser.InputModeHierarchyContext, 0) + return self.getTypedRuleContext(Parser.InputModeHierarchyContext,0) + def outputModeHierarchy(self): - return self.getTypedRuleContext(Parser.OutputModeHierarchyContext, 0) + return self.getTypedRuleContext(Parser.OutputModeHierarchyContext,0) + def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext, 0) + return self.getTypedRuleContext(Parser.ComponentIDContext,0) + def getRuleIndex(self): return Parser.RULE_hierarchyOperators - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterHierarchyOperators"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHierarchyOperators" ): listener.enterHierarchyOperators(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitHierarchyOperators"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHierarchyOperators" ): listener.exitHierarchyOperators(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitHierarchyOperators" ): + return visitor.visitHierarchyOperators(self) + else: + return visitor.visitChildren(self) + + + + def hierarchyOperators(self): + localctx = Parser.HierarchyOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 60, self.RULE_hierarchyOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1099 @@ -9920,50 +9460,45 @@ def hierarchyOperators(self): self.state = 1105 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.CONDITION: + if _la==Parser.CONDITION: self.state = 1104 self.conditionClause() + self.state = 1109 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 84, self._ctx) + la_ = self._interp.adaptivePredict(self._input,84,self._ctx) if la_ == 1: self.state = 1107 self.match(Parser.RULE) self.state = 1108 localctx.ruleComponent = self.componentID() + self.state = 1112 self._errHandler.sync(self) _la = self._input.LA(1) - if ((_la - 225) & ~0x3F) == 0 and ( - (1 << (_la - 225)) - & ( - (1 << (Parser.NON_NULL - 225)) - | (1 << (Parser.NON_ZERO - 225)) - | (1 << (Parser.PARTIAL_NULL - 225)) - | (1 << (Parser.PARTIAL_ZERO - 225)) - | (1 << (Parser.ALWAYS_NULL - 225)) - | (1 << (Parser.ALWAYS_ZERO - 225)) - ) - ) != 0: + if ((((_la - 225)) & ~0x3f) == 0 and ((1 << (_la - 225)) & ((1 << (Parser.NON_NULL - 225)) | (1 << (Parser.NON_ZERO - 225)) | (1 << (Parser.PARTIAL_NULL - 225)) | (1 << (Parser.PARTIAL_ZERO - 225)) | (1 << (Parser.ALWAYS_NULL - 225)) | (1 << (Parser.ALWAYS_ZERO - 225)))) != 0): self.state = 1111 self.validationMode() + self.state = 1115 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.DATASET or _la == Parser.RULE or _la == Parser.RULE_PRIORITY: + if _la==Parser.DATASET or _la==Parser.RULE or _la==Parser.RULE_PRIORITY: self.state = 1114 self.inputModeHierarchy() + self.state = 1118 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ALL or _la == Parser.COMPUTED: + if _la==Parser.ALL or _la==Parser.COMPUTED: self.state = 1117 self.outputModeHierarchy() + self.state = 1120 self.match(Parser.RPAREN) except RecognitionException as re: @@ -9974,172 +9509,183 @@ def hierarchyOperators(self): self.exitRule() return localctx + class ValidationOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_validationOperators - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class ValidateHRrulesetContext(ValidationOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ValidationOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ValidationOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.hrName = None # Token + self.op = None # ExprContext + self.hrName = None # Token self.copyFrom(ctx) def CHECK_HIERARCHY(self): return self.getToken(Parser.CHECK_HIERARCHY, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) - def conditionClause(self): - return self.getTypedRuleContext(Parser.ConditionClauseContext, 0) + return self.getTypedRuleContext(Parser.ConditionClauseContext,0) def RULE(self): return self.getToken(Parser.RULE, 0) - def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext, 0) + return self.getTypedRuleContext(Parser.ComponentIDContext,0) def validationMode(self): - return self.getTypedRuleContext(Parser.ValidationModeContext, 0) + return self.getTypedRuleContext(Parser.ValidationModeContext,0) def inputMode(self): - return self.getTypedRuleContext(Parser.InputModeContext, 0) + return self.getTypedRuleContext(Parser.InputModeContext,0) def validationOutput(self): - return self.getTypedRuleContext(Parser.ValidationOutputContext, 0) + return self.getTypedRuleContext(Parser.ValidationOutputContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterValidateHRruleset"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValidateHRruleset" ): listener.enterValidateHRruleset(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitValidateHRruleset"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValidateHRruleset" ): listener.exitValidateHRruleset(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitValidateHRruleset" ): + return visitor.visitValidateHRruleset(self) + else: + return visitor.visitChildren(self) + + class ValidateDPrulesetContext(ValidationOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ValidationOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ValidationOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.dpName = None # Token + self.op = None # ExprContext + self.dpName = None # Token self.copyFrom(ctx) def CHECK_DATAPOINT(self): return self.getToken(Parser.CHECK_DATAPOINT, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) - def COMPONENTS(self): return self.getToken(Parser.COMPONENTS, 0) - - def componentID(self, i: int = None): + def componentID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext, i) + return self.getTypedRuleContext(Parser.ComponentIDContext,i) def validationOutput(self): - return self.getTypedRuleContext(Parser.ValidationOutputContext, 0) + return self.getTypedRuleContext(Parser.ValidationOutputContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterValidateDPruleset"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValidateDPruleset" ): listener.enterValidateDPruleset(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitValidateDPruleset"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValidateDPruleset" ): listener.exitValidateDPruleset(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitValidateDPruleset" ): + return visitor.visitValidateDPruleset(self) + else: + return visitor.visitChildren(self) + + class ValidationSimpleContext(ValidationOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ValidationOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ValidationOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.codeErr = None # ErCodeContext - self.levelCode = None # ErLevelContext - self.output = None # Token + self.op = None # ExprContext + self.codeErr = None # ErCodeContext + self.levelCode = None # ErLevelContext + self.output = None # Token self.copyFrom(ctx) def CHECK(self): return self.getToken(Parser.CHECK, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def imbalanceExpr(self): - return self.getTypedRuleContext(Parser.ImbalanceExprContext, 0) + return self.getTypedRuleContext(Parser.ImbalanceExprContext,0) def erCode(self): - return self.getTypedRuleContext(Parser.ErCodeContext, 0) + return self.getTypedRuleContext(Parser.ErCodeContext,0) def erLevel(self): - return self.getTypedRuleContext(Parser.ErLevelContext, 0) + return self.getTypedRuleContext(Parser.ErLevelContext,0) def INVALID(self): return self.getToken(Parser.INVALID, 0) - def ALL(self): return self.getToken(Parser.ALL, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterValidationSimple"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValidationSimple" ): listener.enterValidationSimple(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitValidationSimple"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValidationSimple" ): listener.exitValidationSimple(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitValidationSimple" ): + return visitor.visitValidationSimple(self) + else: + return visitor.visitChildren(self) + + + def validationOperators(self): + localctx = Parser.ValidationOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 62, self.RULE_validationOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1183 self._errHandler.sync(self) @@ -10160,7 +9706,7 @@ def validationOperators(self): self.state = 1136 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMPONENTS: + if _la==Parser.COMPONENTS: self.state = 1127 self.match(Parser.COMPONENTS) self.state = 1128 @@ -10168,7 +9714,7 @@ def validationOperators(self): self.state = 1133 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 1129 self.match(Parser.COMMA) self.state = 1130 @@ -10177,13 +9723,16 @@ def validationOperators(self): self._errHandler.sync(self) _la = self._input.LA(1) + + self.state = 1139 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ALL or _la == Parser.INVALID or _la == Parser.ALL_MEASURES: + if _la==Parser.ALL or _la==Parser.INVALID or _la==Parser.ALL_MEASURES: self.state = 1138 self.validationOutput() + self.state = 1141 self.match(Parser.RPAREN) pass @@ -10203,50 +9752,45 @@ def validationOperators(self): self.state = 1149 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.CONDITION: + if _la==Parser.CONDITION: self.state = 1148 self.conditionClause() + self.state = 1153 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.RULE: + if _la==Parser.RULE: self.state = 1151 self.match(Parser.RULE) self.state = 1152 self.componentID() + self.state = 1156 self._errHandler.sync(self) _la = self._input.LA(1) - if ((_la - 225) & ~0x3F) == 0 and ( - (1 << (_la - 225)) - & ( - (1 << (Parser.NON_NULL - 225)) - | (1 << (Parser.NON_ZERO - 225)) - | (1 << (Parser.PARTIAL_NULL - 225)) - | (1 << (Parser.PARTIAL_ZERO - 225)) - | (1 << (Parser.ALWAYS_NULL - 225)) - | (1 << (Parser.ALWAYS_ZERO - 225)) - ) - ) != 0: + if ((((_la - 225)) & ~0x3f) == 0 and ((1 << (_la - 225)) & ((1 << (Parser.NON_NULL - 225)) | (1 << (Parser.NON_ZERO - 225)) | (1 << (Parser.PARTIAL_NULL - 225)) | (1 << (Parser.PARTIAL_ZERO - 225)) | (1 << (Parser.ALWAYS_NULL - 225)) | (1 << (Parser.ALWAYS_ZERO - 225)))) != 0): self.state = 1155 self.validationMode() + self.state = 1159 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.DATASET or _la == Parser.DATASET_PRIORITY: + if _la==Parser.DATASET or _la==Parser.DATASET_PRIORITY: self.state = 1158 self.inputMode() + self.state = 1162 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ALL or _la == Parser.INVALID or _la == Parser.ALL_MEASURES: + if _la==Parser.ALL or _la==Parser.INVALID or _la==Parser.ALL_MEASURES: self.state = 1161 self.validationOutput() + self.state = 1164 self.match(Parser.RPAREN) pass @@ -10262,37 +9806,41 @@ def validationOperators(self): self.state = 1170 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ERRORCODE: + if _la==Parser.ERRORCODE: self.state = 1169 localctx.codeErr = self.erCode() + self.state = 1173 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ERRORLEVEL: + if _la==Parser.ERRORLEVEL: self.state = 1172 localctx.levelCode = self.erLevel() + self.state = 1176 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.IMBALANCE: + if _la==Parser.IMBALANCE: self.state = 1175 self.imbalanceExpr() + self.state = 1179 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ALL or _la == Parser.INVALID: + if _la==Parser.ALL or _la==Parser.INVALID: self.state = 1178 localctx.output = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.ALL or _la == Parser.INVALID): + if not(_la==Parser.ALL or _la==Parser.INVALID): localctx.output = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() + self.state = 1181 self.match(Parser.RPAREN) pass @@ -10307,55 +9855,65 @@ def validationOperators(self): self.exitRule() return localctx + class ConditionalOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_conditionalOperators - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class NvlAtomContext(ConditionalOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ConditionalOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ConditionalOperatorsContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.right = None # ExprContext + self.left = None # ExprContext + self.right = None # ExprContext self.copyFrom(ctx) def NVL(self): return self.getToken(Parser.NVL, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def expr(self, i: int = None): + def expr(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext, i) + return self.getTypedRuleContext(Parser.ExprContext,i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterNvlAtom"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNvlAtom" ): listener.enterNvlAtom(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitNvlAtom"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNvlAtom" ): listener.exitNvlAtom(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitNvlAtom" ): + return visitor.visitNvlAtom(self) + else: + return visitor.visitChildren(self) + + + def conditionalOperators(self): + localctx = Parser.ConditionalOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 64, self.RULE_conditionalOperators) try: @@ -10381,55 +9939,65 @@ def conditionalOperators(self): self.exitRule() return localctx + class ConditionalOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_conditionalOperatorsComponent - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class NvlAtomComponentContext(ConditionalOperatorsComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ConditionalOperatorsComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ConditionalOperatorsComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.right = None # ExprComponentContext + self.left = None # ExprComponentContext + self.right = None # ExprComponentContext self.copyFrom(ctx) def NVL(self): return self.getToken(Parser.NVL, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterNvlAtomComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNvlAtomComponent" ): listener.enterNvlAtomComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitNvlAtomComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNvlAtomComponent" ): listener.exitNvlAtomComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitNvlAtomComponent" ): + return visitor.visitNvlAtomComponent(self) + else: + return visitor.visitChildren(self) + + + def conditionalOperatorsComponent(self): + localctx = Parser.ConditionalOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 66, self.RULE_conditionalOperatorsComponent) try: @@ -10455,131 +10023,119 @@ def conditionalOperatorsComponent(self): self.exitRule() return localctx + class AggrOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_aggrOperators - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class AggrCompContext(AggrOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.AggrOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AggrOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def SUM(self): return self.getToken(Parser.SUM, 0) - def AVG(self): return self.getToken(Parser.AVG, 0) - def COUNT(self): return self.getToken(Parser.COUNT, 0) - def MEDIAN(self): return self.getToken(Parser.MEDIAN, 0) - def MIN(self): return self.getToken(Parser.MIN, 0) - def MAX(self): return self.getToken(Parser.MAX, 0) - def STDDEV_POP(self): return self.getToken(Parser.STDDEV_POP, 0) - def STDDEV_SAMP(self): return self.getToken(Parser.STDDEV_SAMP, 0) - def VAR_POP(self): return self.getToken(Parser.VAR_POP, 0) - def VAR_SAMP(self): return self.getToken(Parser.VAR_SAMP, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAggrComp"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAggrComp" ): listener.enterAggrComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAggrComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAggrComp" ): listener.exitAggrComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAggrComp" ): + return visitor.visitAggrComp(self) + else: + return visitor.visitChildren(self) + + class CountAggrCompContext(AggrOperatorsContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.AggrOperatorsContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AggrOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def COUNT(self): return self.getToken(Parser.COUNT, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCountAggrComp"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCountAggrComp" ): listener.enterCountAggrComp(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCountAggrComp"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCountAggrComp" ): listener.exitCountAggrComp(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCountAggrComp" ): + return visitor.visitCountAggrComp(self) + else: + return visitor.visitChildren(self) + + + def aggrOperators(self): + localctx = Parser.AggrOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 68, self.RULE_aggrOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1207 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 101, self._ctx) + la_ = self._interp.adaptivePredict(self._input,101,self._ctx) if la_ == 1: localctx = Parser.AggrCompContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 1199 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ((_la - 80) & ~0x3F) == 0 - and ( - (1 << (_la - 80)) - & ( - (1 << (Parser.MIN - 80)) - | (1 << (Parser.MAX - 80)) - | (1 << (Parser.SUM - 80)) - | (1 << (Parser.AVG - 80)) - | (1 << (Parser.MEDIAN - 80)) - | (1 << (Parser.COUNT - 80)) - | (1 << (Parser.STDDEV_POP - 80)) - | (1 << (Parser.STDDEV_SAMP - 80)) - | (1 << (Parser.VAR_POP - 80)) - | (1 << (Parser.VAR_SAMP - 80)) - ) - ) - != 0 - ): + if not(((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (Parser.MIN - 80)) | (1 << (Parser.MAX - 80)) | (1 << (Parser.SUM - 80)) | (1 << (Parser.AVG - 80)) | (1 << (Parser.MEDIAN - 80)) | (1 << (Parser.COUNT - 80)) | (1 << (Parser.STDDEV_POP - 80)) | (1 << (Parser.STDDEV_SAMP - 80)) | (1 << (Parser.VAR_POP - 80)) | (1 << (Parser.VAR_SAMP - 80)))) != 0)): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -10603,6 +10159,7 @@ def aggrOperators(self): self.match(Parser.RPAREN) pass + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -10611,109 +10168,93 @@ def aggrOperators(self): self.exitRule() return localctx + class AggrOperatorsGroupingContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_aggrOperatorsGrouping - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class AggrDatasetContext(AggrOperatorsGroupingContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.AggrOperatorsGroupingContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AggrOperatorsGroupingContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def SUM(self): return self.getToken(Parser.SUM, 0) - def AVG(self): return self.getToken(Parser.AVG, 0) - def COUNT(self): return self.getToken(Parser.COUNT, 0) - def MEDIAN(self): return self.getToken(Parser.MEDIAN, 0) - def MIN(self): return self.getToken(Parser.MIN, 0) - def MAX(self): return self.getToken(Parser.MAX, 0) - def STDDEV_POP(self): return self.getToken(Parser.STDDEV_POP, 0) - def STDDEV_SAMP(self): return self.getToken(Parser.STDDEV_SAMP, 0) - def VAR_POP(self): return self.getToken(Parser.VAR_POP, 0) - def VAR_SAMP(self): return self.getToken(Parser.VAR_SAMP, 0) - def groupingClause(self): - return self.getTypedRuleContext(Parser.GroupingClauseContext, 0) + return self.getTypedRuleContext(Parser.GroupingClauseContext,0) def havingClause(self): - return self.getTypedRuleContext(Parser.HavingClauseContext, 0) + return self.getTypedRuleContext(Parser.HavingClauseContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAggrDataset"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAggrDataset" ): listener.enterAggrDataset(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAggrDataset"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAggrDataset" ): listener.exitAggrDataset(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAggrDataset" ): + return visitor.visitAggrDataset(self) + else: + return visitor.visitChildren(self) + + + def aggrOperatorsGrouping(self): + localctx = Parser.AggrOperatorsGroupingContext(self, self._ctx, self.state) self.enterRule(localctx, 70, self.RULE_aggrOperatorsGrouping) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = Parser.AggrDatasetContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 1209 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ((_la - 80) & ~0x3F) == 0 - and ( - (1 << (_la - 80)) - & ( - (1 << (Parser.MIN - 80)) - | (1 << (Parser.MAX - 80)) - | (1 << (Parser.SUM - 80)) - | (1 << (Parser.AVG - 80)) - | (1 << (Parser.MEDIAN - 80)) - | (1 << (Parser.COUNT - 80)) - | (1 << (Parser.STDDEV_POP - 80)) - | (1 << (Parser.STDDEV_SAMP - 80)) - | (1 << (Parser.VAR_POP - 80)) - | (1 << (Parser.VAR_SAMP - 80)) - ) - ) - != 0 - ): + if not(((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (Parser.MIN - 80)) | (1 << (Parser.MAX - 80)) | (1 << (Parser.SUM - 80)) | (1 << (Parser.AVG - 80)) | (1 << (Parser.MEDIAN - 80)) | (1 << (Parser.COUNT - 80)) | (1 << (Parser.STDDEV_POP - 80)) | (1 << (Parser.STDDEV_SAMP - 80)) | (1 << (Parser.VAR_POP - 80)) | (1 << (Parser.VAR_SAMP - 80)))) != 0)): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -10725,16 +10266,19 @@ def aggrOperatorsGrouping(self): self.state = 1216 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.GROUP: + if _la==Parser.GROUP: self.state = 1212 self.groupingClause() self.state = 1214 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.HAVING: + if _la==Parser.HAVING: self.state = 1213 self.havingClause() + + + self.state = 1218 self.match(Parser.RPAREN) except RecognitionException as re: @@ -10745,254 +10289,222 @@ def aggrOperatorsGrouping(self): self.exitRule() return localctx + class AnFunctionContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_anFunction - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class LagOrLeadAnContext(AnFunctionContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.AnFunctionContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionContext super().__init__(ANTLRParser) - self.op = None # Token - self.offset = None # SignedIntegerContext - self.defaultValue = None # ScalarItemContext - self.partition = None # PartitionByClauseContext - self.orderBy = None # OrderByClauseContext + self.op = None # Token + self.offset = None # SignedIntegerContext + self.defaultValue = None # ScalarItemContext + self.partition = None # PartitionByClauseContext + self.orderBy = None # OrderByClauseContext self.copyFrom(ctx) - def LPAREN(self, i: int = None): + def LPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def OVER(self): return self.getToken(Parser.OVER, 0) - - def RPAREN(self, i: int = None): + def RPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) - def LAG(self): return self.getToken(Parser.LAG, 0) - def LEAD(self): return self.getToken(Parser.LEAD, 0) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def orderByClause(self): - return self.getTypedRuleContext(Parser.OrderByClauseContext, 0) + return self.getTypedRuleContext(Parser.OrderByClauseContext,0) def signedInteger(self): - return self.getTypedRuleContext(Parser.SignedIntegerContext, 0) + return self.getTypedRuleContext(Parser.SignedIntegerContext,0) def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) def scalarItem(self): - return self.getTypedRuleContext(Parser.ScalarItemContext, 0) + return self.getTypedRuleContext(Parser.ScalarItemContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterLagOrLeadAn"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLagOrLeadAn" ): listener.enterLagOrLeadAn(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitLagOrLeadAn"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLagOrLeadAn" ): listener.exitLagOrLeadAn(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitLagOrLeadAn" ): + return visitor.visitLagOrLeadAn(self) + else: + return visitor.visitChildren(self) + + class RatioToReportAnContext(AnFunctionContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.AnFunctionContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionContext super().__init__(ANTLRParser) - self.op = None # Token - self.partition = None # PartitionByClauseContext + self.op = None # Token + self.partition = None # PartitionByClauseContext self.copyFrom(ctx) - def LPAREN(self, i: int = None): + def LPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def OVER(self): return self.getToken(Parser.OVER, 0) - - def RPAREN(self, i: int = None): + def RPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) - def RATIO_TO_REPORT(self): return self.getToken(Parser.RATIO_TO_REPORT, 0) - def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRatioToReportAn"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRatioToReportAn" ): listener.enterRatioToReportAn(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRatioToReportAn"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRatioToReportAn" ): listener.exitRatioToReportAn(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRatioToReportAn" ): + return visitor.visitRatioToReportAn(self) + else: + return visitor.visitChildren(self) + + class AnSimpleFunctionContext(AnFunctionContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.AnFunctionContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionContext super().__init__(ANTLRParser) - self.op = None # Token - self.partition = None # PartitionByClauseContext - self.orderBy = None # OrderByClauseContext - self.windowing = None # WindowingClauseContext + self.op = None # Token + self.partition = None # PartitionByClauseContext + self.orderBy = None # OrderByClauseContext + self.windowing = None # WindowingClauseContext self.copyFrom(ctx) - def LPAREN(self, i: int = None): + def LPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) def OVER(self): return self.getToken(Parser.OVER, 0) - - def RPAREN(self, i: int = None): + def RPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) - def SUM(self): return self.getToken(Parser.SUM, 0) - def AVG(self): return self.getToken(Parser.AVG, 0) - def COUNT(self): return self.getToken(Parser.COUNT, 0) - def MEDIAN(self): return self.getToken(Parser.MEDIAN, 0) - def MIN(self): return self.getToken(Parser.MIN, 0) - def MAX(self): return self.getToken(Parser.MAX, 0) - def STDDEV_POP(self): return self.getToken(Parser.STDDEV_POP, 0) - def STDDEV_SAMP(self): return self.getToken(Parser.STDDEV_SAMP, 0) - def VAR_POP(self): return self.getToken(Parser.VAR_POP, 0) - def VAR_SAMP(self): return self.getToken(Parser.VAR_SAMP, 0) - def FIRST_VALUE(self): return self.getToken(Parser.FIRST_VALUE, 0) - def LAST_VALUE(self): return self.getToken(Parser.LAST_VALUE, 0) - def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) def orderByClause(self): - return self.getTypedRuleContext(Parser.OrderByClauseContext, 0) + return self.getTypedRuleContext(Parser.OrderByClauseContext,0) def windowingClause(self): - return self.getTypedRuleContext(Parser.WindowingClauseContext, 0) + return self.getTypedRuleContext(Parser.WindowingClauseContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAnSimpleFunction"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAnSimpleFunction" ): listener.enterAnSimpleFunction(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAnSimpleFunction"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAnSimpleFunction" ): listener.exitAnSimpleFunction(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAnSimpleFunction" ): + return visitor.visitAnSimpleFunction(self) + else: + return visitor.visitChildren(self) + + + def anFunction(self): + localctx = Parser.AnFunctionContext(self, self._ctx, self.state) self.enterRule(localctx, 72, self.RULE_anFunction) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1267 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.MIN, - Parser.MAX, - Parser.SUM, - Parser.AVG, - Parser.MEDIAN, - Parser.COUNT, - Parser.STDDEV_POP, - Parser.STDDEV_SAMP, - Parser.VAR_POP, - Parser.VAR_SAMP, - Parser.FIRST_VALUE, - Parser.LAST_VALUE, - ]: + if token in [Parser.MIN, Parser.MAX, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE]: localctx = Parser.AnSimpleFunctionContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 1220 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ( - ((_la - 80) & ~0x3F) == 0 - and ( - (1 << (_la - 80)) - & ( - (1 << (Parser.MIN - 80)) - | (1 << (Parser.MAX - 80)) - | (1 << (Parser.SUM - 80)) - | (1 << (Parser.AVG - 80)) - | (1 << (Parser.MEDIAN - 80)) - | (1 << (Parser.COUNT - 80)) - | (1 << (Parser.STDDEV_POP - 80)) - | (1 << (Parser.STDDEV_SAMP - 80)) - | (1 << (Parser.VAR_POP - 80)) - | (1 << (Parser.VAR_SAMP - 80)) - ) - ) - != 0 - ) - or _la == Parser.FIRST_VALUE - or _la == Parser.LAST_VALUE - ): + if not(((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (Parser.MIN - 80)) | (1 << (Parser.MAX - 80)) | (1 << (Parser.SUM - 80)) | (1 << (Parser.AVG - 80)) | (1 << (Parser.MEDIAN - 80)) | (1 << (Parser.COUNT - 80)) | (1 << (Parser.STDDEV_POP - 80)) | (1 << (Parser.STDDEV_SAMP - 80)) | (1 << (Parser.VAR_POP - 80)) | (1 << (Parser.VAR_SAMP - 80)))) != 0) or _la==Parser.FIRST_VALUE or _la==Parser.LAST_VALUE): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -11009,24 +10521,27 @@ def anFunction(self): self.state = 1226 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.PARTITION: + if _la==Parser.PARTITION: self.state = 1225 localctx.partition = self.partitionByClause() + self.state = 1229 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ORDER: + if _la==Parser.ORDER: self.state = 1228 localctx.orderBy = self.orderByClause() + self.state = 1232 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.DATA or _la == Parser.RANGE: + if _la==Parser.DATA or _la==Parser.RANGE: self.state = 1231 localctx.windowing = self.windowingClause() + self.state = 1234 self.match(Parser.RPAREN) self.state = 1235 @@ -11038,7 +10553,7 @@ def anFunction(self): self.state = 1237 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.LAG or _la == Parser.LEAD): + if not(_la==Parser.LAG or _la==Parser.LEAD): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -11050,7 +10565,7 @@ def anFunction(self): self.state = 1246 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 1240 self.match(Parser.COMMA) self.state = 1241 @@ -11058,12 +10573,15 @@ def anFunction(self): self.state = 1244 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 1242 self.match(Parser.COMMA) self.state = 1243 localctx.defaultValue = self.scalarItem() + + + self.state = 1248 self.match(Parser.OVER) self.state = 1249 @@ -11072,10 +10590,11 @@ def anFunction(self): self.state = 1251 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.PARTITION: + if _la==Parser.PARTITION: self.state = 1250 localctx.partition = self.partitionByClause() + self.state = 1253 localctx.orderBy = self.orderByClause() self.state = 1255 @@ -11115,293 +10634,264 @@ def anFunction(self): self.exitRule() return localctx + class AnFunctionComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_anFunctionComponent - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class AnSimpleFunctionComponentContext(AnFunctionComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.AnFunctionComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.partition = None # PartitionByClauseContext - self.orderBy = None # OrderByClauseContext - self.windowing = None # WindowingClauseContext + self.op = None # Token + self.partition = None # PartitionByClauseContext + self.orderBy = None # OrderByClauseContext + self.windowing = None # WindowingClauseContext self.copyFrom(ctx) - def LPAREN(self, i: int = None): + def LPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def OVER(self): return self.getToken(Parser.OVER, 0) - - def RPAREN(self, i: int = None): + def RPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) - def SUM(self): return self.getToken(Parser.SUM, 0) - def AVG(self): return self.getToken(Parser.AVG, 0) - def COUNT(self): return self.getToken(Parser.COUNT, 0) - def MEDIAN(self): return self.getToken(Parser.MEDIAN, 0) - def MIN(self): return self.getToken(Parser.MIN, 0) - def MAX(self): return self.getToken(Parser.MAX, 0) - def STDDEV_POP(self): return self.getToken(Parser.STDDEV_POP, 0) - def STDDEV_SAMP(self): return self.getToken(Parser.STDDEV_SAMP, 0) - def VAR_POP(self): return self.getToken(Parser.VAR_POP, 0) - def VAR_SAMP(self): return self.getToken(Parser.VAR_SAMP, 0) - def FIRST_VALUE(self): return self.getToken(Parser.FIRST_VALUE, 0) - def LAST_VALUE(self): return self.getToken(Parser.LAST_VALUE, 0) - def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) def orderByClause(self): - return self.getTypedRuleContext(Parser.OrderByClauseContext, 0) + return self.getTypedRuleContext(Parser.OrderByClauseContext,0) def windowingClause(self): - return self.getTypedRuleContext(Parser.WindowingClauseContext, 0) + return self.getTypedRuleContext(Parser.WindowingClauseContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAnSimpleFunctionComponent"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAnSimpleFunctionComponent" ): listener.enterAnSimpleFunctionComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAnSimpleFunctionComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAnSimpleFunctionComponent" ): listener.exitAnSimpleFunctionComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAnSimpleFunctionComponent" ): + return visitor.visitAnSimpleFunctionComponent(self) + else: + return visitor.visitChildren(self) + + class LagOrLeadAnComponentContext(AnFunctionComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.AnFunctionComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.offet = None # SignedIntegerContext - self.defaultValue = None # ScalarItemContext - self.partition = None # PartitionByClauseContext - self.orderBy = None # OrderByClauseContext + self.op = None # Token + self.offet = None # SignedIntegerContext + self.defaultValue = None # ScalarItemContext + self.partition = None # PartitionByClauseContext + self.orderBy = None # OrderByClauseContext self.copyFrom(ctx) - def LPAREN(self, i: int = None): + def LPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def OVER(self): return self.getToken(Parser.OVER, 0) - - def RPAREN(self, i: int = None): + def RPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) - def LAG(self): return self.getToken(Parser.LAG, 0) - def LEAD(self): return self.getToken(Parser.LEAD, 0) - def COMMA(self): return self.getToken(Parser.COMMA, 0) - def orderByClause(self): - return self.getTypedRuleContext(Parser.OrderByClauseContext, 0) + return self.getTypedRuleContext(Parser.OrderByClauseContext,0) def signedInteger(self): - return self.getTypedRuleContext(Parser.SignedIntegerContext, 0) + return self.getTypedRuleContext(Parser.SignedIntegerContext,0) def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) def scalarItem(self): - return self.getTypedRuleContext(Parser.ScalarItemContext, 0) + return self.getTypedRuleContext(Parser.ScalarItemContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterLagOrLeadAnComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLagOrLeadAnComponent" ): listener.enterLagOrLeadAnComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitLagOrLeadAnComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLagOrLeadAnComponent" ): listener.exitLagOrLeadAnComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitLagOrLeadAnComponent" ): + return visitor.visitLagOrLeadAnComponent(self) + else: + return visitor.visitChildren(self) + + class RankAnComponentContext(AnFunctionComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.AnFunctionComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.partition = None # PartitionByClauseContext - self.orderBy = None # OrderByClauseContext + self.op = None # Token + self.partition = None # PartitionByClauseContext + self.orderBy = None # OrderByClauseContext self.copyFrom(ctx) - def LPAREN(self, i: int = None): + def LPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) - def OVER(self): return self.getToken(Parser.OVER, 0) - - def RPAREN(self, i: int = None): + def RPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) - def RANK(self): return self.getToken(Parser.RANK, 0) - def orderByClause(self): - return self.getTypedRuleContext(Parser.OrderByClauseContext, 0) + return self.getTypedRuleContext(Parser.OrderByClauseContext,0) def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRankAnComponent"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRankAnComponent" ): listener.enterRankAnComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRankAnComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRankAnComponent" ): listener.exitRankAnComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRankAnComponent" ): + return visitor.visitRankAnComponent(self) + else: + return visitor.visitChildren(self) + + class RatioToReportAnComponentContext(AnFunctionComponentContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.AnFunctionComponentContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.partition = None # PartitionByClauseContext + self.op = None # Token + self.partition = None # PartitionByClauseContext self.copyFrom(ctx) - def LPAREN(self, i: int = None): + def LPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def OVER(self): return self.getToken(Parser.OVER, 0) - - def RPAREN(self, i: int = None): + def RPAREN(self, i:int=None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) - def RATIO_TO_REPORT(self): return self.getToken(Parser.RATIO_TO_REPORT, 0) - def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRatioToReportAnComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRatioToReportAnComponent" ): listener.enterRatioToReportAnComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRatioToReportAnComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRatioToReportAnComponent" ): listener.exitRatioToReportAnComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRatioToReportAnComponent" ): + return visitor.visitRatioToReportAnComponent(self) + else: + return visitor.visitChildren(self) + + + def anFunctionComponent(self): + localctx = Parser.AnFunctionComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 74, self.RULE_anFunctionComponent) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1327 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.MIN, - Parser.MAX, - Parser.SUM, - Parser.AVG, - Parser.MEDIAN, - Parser.COUNT, - Parser.STDDEV_POP, - Parser.STDDEV_SAMP, - Parser.VAR_POP, - Parser.VAR_SAMP, - Parser.FIRST_VALUE, - Parser.LAST_VALUE, - ]: + if token in [Parser.MIN, Parser.MAX, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE]: localctx = Parser.AnSimpleFunctionComponentContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 1269 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not ( - ( - ((_la - 80) & ~0x3F) == 0 - and ( - (1 << (_la - 80)) - & ( - (1 << (Parser.MIN - 80)) - | (1 << (Parser.MAX - 80)) - | (1 << (Parser.SUM - 80)) - | (1 << (Parser.AVG - 80)) - | (1 << (Parser.MEDIAN - 80)) - | (1 << (Parser.COUNT - 80)) - | (1 << (Parser.STDDEV_POP - 80)) - | (1 << (Parser.STDDEV_SAMP - 80)) - | (1 << (Parser.VAR_POP - 80)) - | (1 << (Parser.VAR_SAMP - 80)) - ) - ) - != 0 - ) - or _la == Parser.FIRST_VALUE - or _la == Parser.LAST_VALUE - ): + if not(((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (Parser.MIN - 80)) | (1 << (Parser.MAX - 80)) | (1 << (Parser.SUM - 80)) | (1 << (Parser.AVG - 80)) | (1 << (Parser.MEDIAN - 80)) | (1 << (Parser.COUNT - 80)) | (1 << (Parser.STDDEV_POP - 80)) | (1 << (Parser.STDDEV_SAMP - 80)) | (1 << (Parser.VAR_POP - 80)) | (1 << (Parser.VAR_SAMP - 80)))) != 0) or _la==Parser.FIRST_VALUE or _la==Parser.LAST_VALUE): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -11418,24 +10908,27 @@ def anFunctionComponent(self): self.state = 1275 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.PARTITION: + if _la==Parser.PARTITION: self.state = 1274 localctx.partition = self.partitionByClause() + self.state = 1278 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ORDER: + if _la==Parser.ORDER: self.state = 1277 localctx.orderBy = self.orderByClause() + self.state = 1281 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.DATA or _la == Parser.RANGE: + if _la==Parser.DATA or _la==Parser.RANGE: self.state = 1280 localctx.windowing = self.windowingClause() + self.state = 1283 self.match(Parser.RPAREN) self.state = 1284 @@ -11447,7 +10940,7 @@ def anFunctionComponent(self): self.state = 1286 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.LAG or _la == Parser.LEAD): + if not(_la==Parser.LAG or _la==Parser.LEAD): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -11459,7 +10952,7 @@ def anFunctionComponent(self): self.state = 1294 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 1289 self.match(Parser.COMMA) self.state = 1290 @@ -11467,23 +10960,13 @@ def anFunctionComponent(self): self.state = 1292 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.NULL_CONSTANT or ( - ((_la - 218) & ~0x3F) == 0 - and ( - (1 << (_la - 218)) - & ( - (1 << (Parser.CAST - 218)) - | (1 << (Parser.INTEGER_CONSTANT - 218)) - | (1 << (Parser.NUMBER_CONSTANT - 218)) - | (1 << (Parser.BOOLEAN_CONSTANT - 218)) - | (1 << (Parser.STRING_CONSTANT - 218)) - ) - ) - != 0 - ): + if _la==Parser.NULL_CONSTANT or ((((_la - 218)) & ~0x3f) == 0 and ((1 << (_la - 218)) & ((1 << (Parser.CAST - 218)) | (1 << (Parser.INTEGER_CONSTANT - 218)) | (1 << (Parser.NUMBER_CONSTANT - 218)) | (1 << (Parser.BOOLEAN_CONSTANT - 218)) | (1 << (Parser.STRING_CONSTANT - 218)))) != 0): self.state = 1291 localctx.defaultValue = self.scalarItem() + + + self.state = 1296 self.match(Parser.OVER) self.state = 1297 @@ -11492,10 +10975,11 @@ def anFunctionComponent(self): self.state = 1299 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.PARTITION: + if _la==Parser.PARTITION: self.state = 1298 localctx.partition = self.partitionByClause() + self.state = 1301 localctx.orderBy = self.orderByClause() self.state = 1303 @@ -11518,10 +11002,11 @@ def anFunctionComponent(self): self.state = 1311 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.PARTITION: + if _la==Parser.PARTITION: self.state = 1310 localctx.partition = self.partitionByClause() + self.state = 1313 localctx.orderBy = self.orderByClause() self.state = 1315 @@ -11561,36 +11046,48 @@ def anFunctionComponent(self): self.exitRule() return localctx + class RenameClauseItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.fromName = None # ComponentIDContext - self.toName = None # ComponentIDContext + self.fromName = None # ComponentIDContext + self.toName = None # ComponentIDContext def TO(self): return self.getToken(Parser.TO, 0) - def componentID(self, i: int = None): + def componentID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext, i) + return self.getTypedRuleContext(Parser.ComponentIDContext,i) + def getRuleIndex(self): return Parser.RULE_renameClauseItem - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRenameClauseItem"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRenameClauseItem" ): listener.enterRenameClauseItem(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRenameClauseItem"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRenameClauseItem" ): listener.exitRenameClauseItem(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRenameClauseItem" ): + return visitor.visitRenameClauseItem(self) + else: + return visitor.visitChildren(self) + + + + def renameClauseItem(self): + localctx = Parser.RenameClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 76, self.RULE_renameClauseItem) try: @@ -11609,20 +11106,22 @@ def renameClauseItem(self): self.exitRule() return localctx + class AggregateClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def aggrFunctionClause(self, i: int = None): + def aggrFunctionClause(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.AggrFunctionClauseContext) else: - return self.getTypedRuleContext(Parser.AggrFunctionClauseContext, i) + return self.getTypedRuleContext(Parser.AggrFunctionClauseContext,i) + - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -11631,18 +11130,28 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_aggregateClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAggregateClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAggregateClause" ): listener.enterAggregateClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAggregateClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAggregateClause" ): listener.exitAggregateClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAggregateClause" ): + return visitor.visitAggregateClause(self) + else: + return visitor.visitChildren(self) + + + + def aggregateClause(self): + localctx = Parser.AggregateClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 78, self.RULE_aggregateClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1333 @@ -11650,7 +11159,7 @@ def aggregateClause(self): self.state = 1338 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: + while _la==Parser.COMMA: self.state = 1334 self.match(Parser.COMMA) self.state = 1335 @@ -11667,61 +11176,64 @@ def aggregateClause(self): self.exitRule() return localctx + class AggrFunctionClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext, 0) + return self.getTypedRuleContext(Parser.ComponentIDContext,0) + def ASSIGN(self): return self.getToken(Parser.ASSIGN, 0) def aggrOperators(self): - return self.getTypedRuleContext(Parser.AggrOperatorsContext, 0) + return self.getTypedRuleContext(Parser.AggrOperatorsContext,0) + def componentRole(self): - return self.getTypedRuleContext(Parser.ComponentRoleContext, 0) + return self.getTypedRuleContext(Parser.ComponentRoleContext,0) + def getRuleIndex(self): return Parser.RULE_aggrFunctionClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAggrFunctionClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAggrFunctionClause" ): listener.enterAggrFunctionClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAggrFunctionClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAggrFunctionClause" ): listener.exitAggrFunctionClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAggrFunctionClause" ): + return visitor.visitAggrFunctionClause(self) + else: + return visitor.visitChildren(self) + + + + def aggrFunctionClause(self): + localctx = Parser.AggrFunctionClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 80, self.RULE_aggrFunctionClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1342 self._errHandler.sync(self) _la = self._input.LA(1) - if ( - ((_la - 103) & ~0x3F) == 0 - and ( - (1 << (_la - 103)) - & ( - (1 << (Parser.DIMENSION - 103)) - | (1 << (Parser.MEASURE - 103)) - | (1 << (Parser.ATTRIBUTE - 103)) - | (1 << (Parser.VIRAL - 103)) - ) - ) - != 0 - ) or _la == Parser.COMPONENT: + if ((((_la - 103)) & ~0x3f) == 0 and ((1 << (_la - 103)) & ((1 << (Parser.DIMENSION - 103)) | (1 << (Parser.MEASURE - 103)) | (1 << (Parser.ATTRIBUTE - 103)) | (1 << (Parser.VIRAL - 103)))) != 0) or _la==Parser.COMPONENT: self.state = 1341 self.componentRole() + self.state = 1344 self.componentID() self.state = 1345 @@ -11736,61 +11248,64 @@ def aggrFunctionClause(self): self.exitRule() return localctx + class CalcClauseItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext, 0) + return self.getTypedRuleContext(Parser.ComponentIDContext,0) + def ASSIGN(self): return self.getToken(Parser.ASSIGN, 0) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) + def componentRole(self): - return self.getTypedRuleContext(Parser.ComponentRoleContext, 0) + return self.getTypedRuleContext(Parser.ComponentRoleContext,0) + def getRuleIndex(self): return Parser.RULE_calcClauseItem - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCalcClauseItem"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCalcClauseItem" ): listener.enterCalcClauseItem(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCalcClauseItem"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCalcClauseItem" ): listener.exitCalcClauseItem(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCalcClauseItem" ): + return visitor.visitCalcClauseItem(self) + else: + return visitor.visitChildren(self) + + + + def calcClauseItem(self): + localctx = Parser.CalcClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 82, self.RULE_calcClauseItem) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1349 self._errHandler.sync(self) _la = self._input.LA(1) - if ( - ((_la - 103) & ~0x3F) == 0 - and ( - (1 << (_la - 103)) - & ( - (1 << (Parser.DIMENSION - 103)) - | (1 << (Parser.MEASURE - 103)) - | (1 << (Parser.ATTRIBUTE - 103)) - | (1 << (Parser.VIRAL - 103)) - ) - ) - != 0 - ) or _la == Parser.COMPONENT: + if ((((_la - 103)) & ~0x3f) == 0 and ((1 << (_la - 103)) & ((1 << (Parser.DIMENSION - 103)) | (1 << (Parser.MEASURE - 103)) | (1 << (Parser.ATTRIBUTE - 103)) | (1 << (Parser.VIRAL - 103)))) != 0) or _la==Parser.COMPONENT: self.state = 1348 self.componentRole() + self.state = 1351 self.componentID() self.state = 1352 @@ -11805,37 +11320,51 @@ def calcClauseItem(self): self.exitRule() return localctx + class SubspaceClauseItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext, 0) + return self.getTypedRuleContext(Parser.ComponentIDContext,0) + def EQ(self): return self.getToken(Parser.EQ, 0) def scalarItem(self): - return self.getTypedRuleContext(Parser.ScalarItemContext, 0) + return self.getTypedRuleContext(Parser.ScalarItemContext,0) + def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext, 0) + return self.getTypedRuleContext(Parser.VarIDContext,0) + def getRuleIndex(self): return Parser.RULE_subspaceClauseItem - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterSubspaceClauseItem"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubspaceClauseItem" ): listener.enterSubspaceClauseItem(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitSubspaceClauseItem"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubspaceClauseItem" ): listener.exitSubspaceClauseItem(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSubspaceClauseItem" ): + return visitor.visitSubspaceClauseItem(self) + else: + return visitor.visitChildren(self) + + + + def subspaceClauseItem(self): + localctx = Parser.SubspaceClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 84, self.RULE_subspaceClauseItem) try: @@ -11847,14 +11376,7 @@ def subspaceClauseItem(self): self.state = 1359 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.NULL_CONSTANT, - Parser.CAST, - Parser.INTEGER_CONSTANT, - Parser.NUMBER_CONSTANT, - Parser.BOOLEAN_CONSTANT, - Parser.STRING_CONSTANT, - ]: + if token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT]: self.state = 1357 self.scalarItem() pass @@ -11873,97 +11395,149 @@ def subspaceClauseItem(self): self.exitRule() return localctx + class ScalarItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_scalarItem - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class ScalarWithCastContext(ScalarItemContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ScalarItemContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ScalarItemContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CAST(self): return self.getToken(Parser.CAST, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext, 0) + return self.getTypedRuleContext(Parser.ConstantContext,0) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def basicScalarType(self): - return self.getTypedRuleContext(Parser.BasicScalarTypeContext, 0) + return self.getTypedRuleContext(Parser.BasicScalarTypeContext,0) def STRING_CONSTANT(self): return self.getToken(Parser.STRING_CONSTANT, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterScalarWithCast"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScalarWithCast" ): listener.enterScalarWithCast(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitScalarWithCast"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScalarWithCast" ): listener.exitScalarWithCast(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitScalarWithCast" ): + return visitor.visitScalarWithCast(self) + else: + return visitor.visitChildren(self) + + class SimpleScalarContext(ScalarItemContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ScalarItemContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ScalarItemContext super().__init__(ANTLRParser) self.copyFrom(ctx) def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext, 0) + return self.getTypedRuleContext(Parser.ConstantContext,0) + - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterSimpleScalar"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSimpleScalar" ): listener.enterSimpleScalar(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitSimpleScalar"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSimpleScalar" ): listener.exitSimpleScalar(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSimpleScalar" ): + return visitor.visitSimpleScalar(self) + else: + return visitor.visitChildren(self) + + + class ScalarVarWithCastContext(ScalarItemContext): + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ScalarItemContext + super().__init__(ANTLRParser) + self.copyFrom(ctx) + + def CAST(self): + return self.getToken(Parser.CAST, 0) + def LPAREN(self): + return self.getToken(Parser.LPAREN, 0) + def varID(self): + return self.getTypedRuleContext(Parser.VarIDContext,0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(Parser.COMMA) + else: + return self.getToken(Parser.COMMA, i) + def RPAREN(self): + return self.getToken(Parser.RPAREN, 0) + def basicScalarType(self): + return self.getTypedRuleContext(Parser.BasicScalarTypeContext,0) + + def STRING_CONSTANT(self): + return self.getToken(Parser.STRING_CONSTANT, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScalarVarWithCast" ): + listener.enterScalarVarWithCast(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScalarVarWithCast" ): + listener.exitScalarVarWithCast(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitScalarVarWithCast" ): + return visitor.visitScalarVarWithCast(self) + else: + return visitor.visitChildren(self) + + + def scalarItem(self): + localctx = Parser.ScalarItemContext(self, self._ctx, self.state) self.enterRule(localctx, 86, self.RULE_scalarItem) - self._la = 0 # Token type + self._la = 0 # Token type try: - self.state = 1373 + self.state = 1384 self._errHandler.sync(self) - token = self._input.LA(1) - if token in [ - Parser.NULL_CONSTANT, - Parser.INTEGER_CONSTANT, - Parser.NUMBER_CONSTANT, - Parser.BOOLEAN_CONSTANT, - Parser.STRING_CONSTANT, - ]: + la_ = self._interp.adaptivePredict(self._input,125,self._ctx) + if la_ == 1: localctx = Parser.SimpleScalarContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 1361 self.constant() pass - elif token in [Parser.CAST]: + + elif la_ == 2: localctx = Parser.ScalarWithCastContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 1362 @@ -11980,17 +11554,45 @@ def scalarItem(self): self.state = 1369 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.COMMA: + if _la==Parser.COMMA: self.state = 1367 self.match(Parser.COMMA) self.state = 1368 self.match(Parser.STRING_CONSTANT) + self.state = 1371 self.match(Parser.RPAREN) pass - else: - raise NoViableAltException(self) + + elif la_ == 3: + localctx = Parser.ScalarVarWithCastContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1373 + self.match(Parser.CAST) + self.state = 1374 + self.match(Parser.LPAREN) + self.state = 1375 + self.varID() + self.state = 1376 + self.match(Parser.COMMA) + + self.state = 1377 + self.basicScalarType() + self.state = 1380 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==Parser.COMMA: + self.state = 1378 + self.match(Parser.COMMA) + self.state = 1379 + self.match(Parser.STRING_CONSTANT) + + + self.state = 1382 + self.match(Parser.RPAREN) + pass + except RecognitionException as re: localctx.exception = re @@ -12000,20 +11602,22 @@ def scalarItem(self): self.exitRule() return localctx + class JoinClauseWithoutUsingContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def joinClauseItem(self, i: int = None): + def joinClauseItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.JoinClauseItemContext) else: - return self.getTypedRuleContext(Parser.JoinClauseItemContext, i) + return self.getTypedRuleContext(Parser.JoinClauseItemContext,i) + - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -12022,31 +11626,41 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_joinClauseWithoutUsing - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterJoinClauseWithoutUsing"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterJoinClauseWithoutUsing" ): listener.enterJoinClauseWithoutUsing(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitJoinClauseWithoutUsing"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitJoinClauseWithoutUsing" ): listener.exitJoinClauseWithoutUsing(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitJoinClauseWithoutUsing" ): + return visitor.visitJoinClauseWithoutUsing(self) + else: + return visitor.visitChildren(self) + + + + def joinClauseWithoutUsing(self): + localctx = Parser.JoinClauseWithoutUsingContext(self, self._ctx, self.state) self.enterRule(localctx, 88, self.RULE_joinClauseWithoutUsing) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1375 + self.state = 1386 self.joinClauseItem() - self.state = 1380 + self.state = 1391 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1376 + while _la==Parser.COMMA: + self.state = 1387 self.match(Parser.COMMA) - self.state = 1377 + self.state = 1388 self.joinClauseItem() - self.state = 1382 + self.state = 1393 self._errHandler.sync(self) _la = self._input.LA(1) @@ -12058,20 +11672,22 @@ def joinClauseWithoutUsing(self): self.exitRule() return localctx + class JoinClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def joinClauseItem(self, i: int = None): + def joinClauseItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.JoinClauseItemContext) else: - return self.getTypedRuleContext(Parser.JoinClauseItemContext, i) + return self.getTypedRuleContext(Parser.JoinClauseItemContext,i) - def COMMA(self, i: int = None): + + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -12080,63 +11696,76 @@ def COMMA(self, i: int = None): def USING(self): return self.getToken(Parser.USING, 0) - def componentID(self, i: int = None): + def componentID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext, i) + return self.getTypedRuleContext(Parser.ComponentIDContext,i) + def getRuleIndex(self): return Parser.RULE_joinClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterJoinClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterJoinClause" ): listener.enterJoinClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitJoinClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitJoinClause" ): listener.exitJoinClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitJoinClause" ): + return visitor.visitJoinClause(self) + else: + return visitor.visitChildren(self) + + + + def joinClause(self): + localctx = Parser.JoinClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 90, self.RULE_joinClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1383 + self.state = 1394 self.joinClauseItem() - self.state = 1388 + self.state = 1399 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1384 + while _la==Parser.COMMA: + self.state = 1395 self.match(Parser.COMMA) - self.state = 1385 + self.state = 1396 self.joinClauseItem() - self.state = 1390 + self.state = 1401 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1400 + self.state = 1411 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.USING: - self.state = 1391 + if _la==Parser.USING: + self.state = 1402 self.match(Parser.USING) - self.state = 1392 + self.state = 1403 self.componentID() - self.state = 1397 + self.state = 1408 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1393 + while _la==Parser.COMMA: + self.state = 1404 self.match(Parser.COMMA) - self.state = 1394 + self.state = 1405 self.componentID() - self.state = 1399 + self.state = 1410 self._errHandler.sync(self) _la = self._input.LA(1) + + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -12145,50 +11774,64 @@ def joinClause(self): self.exitRule() return localctx + class JoinClauseItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) + def AS(self): return self.getToken(Parser.AS, 0) def alias(self): - return self.getTypedRuleContext(Parser.AliasContext, 0) + return self.getTypedRuleContext(Parser.AliasContext,0) + def getRuleIndex(self): return Parser.RULE_joinClauseItem - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterJoinClauseItem"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterJoinClauseItem" ): listener.enterJoinClauseItem(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitJoinClauseItem"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitJoinClauseItem" ): listener.exitJoinClauseItem(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitJoinClauseItem" ): + return visitor.visitJoinClauseItem(self) + else: + return visitor.visitChildren(self) + + + + def joinClauseItem(self): + localctx = Parser.JoinClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 92, self.RULE_joinClauseItem) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1402 + self.state = 1413 self.expr(0) - self.state = 1405 + self.state = 1416 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.AS: - self.state = 1403 + if _la==Parser.AS: + self.state = 1414 self.match(Parser.AS) - self.state = 1404 + self.state = 1415 self.alias() + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -12197,88 +11840,108 @@ def joinClauseItem(self): self.exitRule() return localctx + class JoinBodyContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def filterClause(self): - return self.getTypedRuleContext(Parser.FilterClauseContext, 0) + return self.getTypedRuleContext(Parser.FilterClauseContext,0) + def calcClause(self): - return self.getTypedRuleContext(Parser.CalcClauseContext, 0) + return self.getTypedRuleContext(Parser.CalcClauseContext,0) + def joinApplyClause(self): - return self.getTypedRuleContext(Parser.JoinApplyClauseContext, 0) + return self.getTypedRuleContext(Parser.JoinApplyClauseContext,0) + def aggrClause(self): - return self.getTypedRuleContext(Parser.AggrClauseContext, 0) + return self.getTypedRuleContext(Parser.AggrClauseContext,0) + def keepOrDropClause(self): - return self.getTypedRuleContext(Parser.KeepOrDropClauseContext, 0) + return self.getTypedRuleContext(Parser.KeepOrDropClauseContext,0) + def renameClause(self): - return self.getTypedRuleContext(Parser.RenameClauseContext, 0) + return self.getTypedRuleContext(Parser.RenameClauseContext,0) + def getRuleIndex(self): return Parser.RULE_joinBody - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterJoinBody"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterJoinBody" ): listener.enterJoinBody(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitJoinBody"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitJoinBody" ): listener.exitJoinBody(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitJoinBody" ): + return visitor.visitJoinBody(self) + else: + return visitor.visitChildren(self) + + + + def joinBody(self): + localctx = Parser.JoinBodyContext(self, self._ctx, self.state) self.enterRule(localctx, 94, self.RULE_joinBody) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1408 + self.state = 1419 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.FILTER: - self.state = 1407 + if _la==Parser.FILTER: + self.state = 1418 self.filterClause() - self.state = 1413 + + self.state = 1424 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.CALC]: - self.state = 1410 + self.state = 1421 self.calcClause() pass elif token in [Parser.APPLY]: - self.state = 1411 + self.state = 1422 self.joinApplyClause() pass elif token in [Parser.AGGREGATE]: - self.state = 1412 + self.state = 1423 self.aggrClause() pass elif token in [Parser.RPAREN, Parser.DROP, Parser.KEEP, Parser.RENAME]: pass else: pass - self.state = 1416 + self.state = 1427 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.DROP or _la == Parser.KEEP: - self.state = 1415 + if _la==Parser.DROP or _la==Parser.KEEP: + self.state = 1426 self.keepOrDropClause() - self.state = 1419 + + self.state = 1430 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.RENAME: - self.state = 1418 + if _la==Parser.RENAME: + self.state = 1429 self.renameClause() + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -12287,10 +11950,11 @@ def joinBody(self): self.exitRule() return localctx + class JoinApplyClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12298,27 +11962,38 @@ def APPLY(self): return self.getToken(Parser.APPLY, 0) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) + def getRuleIndex(self): return Parser.RULE_joinApplyClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterJoinApplyClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterJoinApplyClause" ): listener.enterJoinApplyClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitJoinApplyClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitJoinApplyClause" ): listener.exitJoinApplyClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitJoinApplyClause" ): + return visitor.visitJoinApplyClause(self) + else: + return visitor.visitChildren(self) + + + + def joinApplyClause(self): + localctx = Parser.JoinApplyClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 96, self.RULE_joinApplyClause) try: self.enterOuterAlt(localctx, 1) - self.state = 1421 + self.state = 1432 self.match(Parser.APPLY) - self.state = 1422 + self.state = 1433 self.expr(0) except RecognitionException as re: localctx.exception = re @@ -12328,10 +12003,11 @@ def joinApplyClause(self): self.exitRule() return localctx + class PartitionByClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12341,13 +12017,14 @@ def PARTITION(self): def BY(self): return self.getToken(Parser.BY, 0) - def componentID(self, i: int = None): + def componentID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext, i) + return self.getTypedRuleContext(Parser.ComponentIDContext,i) - def COMMA(self, i: int = None): + + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -12356,35 +12033,45 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_partitionByClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterPartitionByClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPartitionByClause" ): listener.enterPartitionByClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitPartitionByClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPartitionByClause" ): listener.exitPartitionByClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPartitionByClause" ): + return visitor.visitPartitionByClause(self) + else: + return visitor.visitChildren(self) + + + + def partitionByClause(self): + localctx = Parser.PartitionByClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 98, self.RULE_partitionByClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1424 + self.state = 1435 self.match(Parser.PARTITION) - self.state = 1425 + self.state = 1436 self.match(Parser.BY) - self.state = 1426 + self.state = 1437 self.componentID() - self.state = 1431 + self.state = 1442 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1427 + while _la==Parser.COMMA: + self.state = 1438 self.match(Parser.COMMA) - self.state = 1428 + self.state = 1439 self.componentID() - self.state = 1433 + self.state = 1444 self._errHandler.sync(self) _la = self._input.LA(1) @@ -12396,10 +12083,11 @@ def partitionByClause(self): self.exitRule() return localctx + class OrderByClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12409,13 +12097,14 @@ def ORDER(self): def BY(self): return self.getToken(Parser.BY, 0) - def orderByItem(self, i: int = None): + def orderByItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.OrderByItemContext) else: - return self.getTypedRuleContext(Parser.OrderByItemContext, i) + return self.getTypedRuleContext(Parser.OrderByItemContext,i) - def COMMA(self, i: int = None): + + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -12424,35 +12113,45 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_orderByClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterOrderByClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOrderByClause" ): listener.enterOrderByClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitOrderByClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOrderByClause" ): listener.exitOrderByClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOrderByClause" ): + return visitor.visitOrderByClause(self) + else: + return visitor.visitChildren(self) + + + + def orderByClause(self): + localctx = Parser.OrderByClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 100, self.RULE_orderByClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1434 + self.state = 1445 self.match(Parser.ORDER) - self.state = 1435 + self.state = 1446 self.match(Parser.BY) - self.state = 1436 + self.state = 1447 self.orderByItem() - self.state = 1441 + self.state = 1452 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1437 + while _la==Parser.COMMA: + self.state = 1448 self.match(Parser.COMMA) - self.state = 1438 + self.state = 1449 self.orderByItem() - self.state = 1443 + self.state = 1454 self._errHandler.sync(self) _la = self._input.LA(1) @@ -12464,15 +12163,17 @@ def orderByClause(self): self.exitRule() return localctx + class OrderByItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext, 0) + return self.getTypedRuleContext(Parser.ComponentIDContext,0) + def ASC(self): return self.getToken(Parser.ASC, 0) @@ -12483,34 +12184,45 @@ def DESC(self): def getRuleIndex(self): return Parser.RULE_orderByItem - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterOrderByItem"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOrderByItem" ): listener.enterOrderByItem(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitOrderByItem"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOrderByItem" ): listener.exitOrderByItem(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOrderByItem" ): + return visitor.visitOrderByItem(self) + else: + return visitor.visitChildren(self) + + + + def orderByItem(self): + localctx = Parser.OrderByItemContext(self, self._ctx, self.state) self.enterRule(localctx, 102, self.RULE_orderByItem) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1444 + self.state = 1455 self.componentID() - self.state = 1446 + self.state = 1457 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ASC or _la == Parser.DESC: - self.state = 1445 + if _la==Parser.ASC or _la==Parser.DESC: + self.state = 1456 _la = self._input.LA(1) - if not (_la == Parser.ASC or _la == Parser.DESC): + if not(_la==Parser.ASC or _la==Parser.DESC): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -12519,14 +12231,15 @@ def orderByItem(self): self.exitRule() return localctx + class WindowingClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.from_ = None # LimitClauseItemContext - self.to_ = None # LimitClauseItemContext + self.from_ = None # LimitClauseItemContext + self.to_ = None # LimitClauseItemContext def BETWEEN(self): return self.getToken(Parser.BETWEEN, 0) @@ -12534,11 +12247,12 @@ def BETWEEN(self): def AND(self): return self.getToken(Parser.AND, 0) - def limitClauseItem(self, i: int = None): + def limitClauseItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.LimitClauseItemContext) else: - return self.getTypedRuleContext(Parser.LimitClauseItemContext, i) + return self.getTypedRuleContext(Parser.LimitClauseItemContext,i) + def RANGE(self): return self.getToken(Parser.RANGE, 0) @@ -12552,42 +12266,52 @@ def POINTS(self): def getRuleIndex(self): return Parser.RULE_windowingClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterWindowingClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWindowingClause" ): listener.enterWindowingClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitWindowingClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWindowingClause" ): listener.exitWindowingClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitWindowingClause" ): + return visitor.visitWindowingClause(self) + else: + return visitor.visitChildren(self) + + + + def windowingClause(self): + localctx = Parser.WindowingClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 104, self.RULE_windowingClause) try: self.enterOuterAlt(localctx, 1) - self.state = 1451 + self.state = 1462 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.DATA]: - self.state = 1448 + self.state = 1459 self.match(Parser.DATA) - self.state = 1449 + self.state = 1460 self.match(Parser.POINTS) pass elif token in [Parser.RANGE]: - self.state = 1450 + self.state = 1461 self.match(Parser.RANGE) pass else: raise NoViableAltException(self) - self.state = 1453 + self.state = 1464 self.match(Parser.BETWEEN) - self.state = 1454 + self.state = 1465 localctx.from_ = self.limitClauseItem() - self.state = 1455 + self.state = 1466 self.match(Parser.AND) - self.state = 1456 + self.state = 1467 localctx.to_ = self.limitClauseItem() except RecognitionException as re: localctx.exception = re @@ -12597,10 +12321,11 @@ def windowingClause(self): self.exitRule() return localctx + class SignedIntegerContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12610,20 +12335,30 @@ def INTEGER_CONSTANT(self): def getRuleIndex(self): return Parser.RULE_signedInteger - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterSignedInteger"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSignedInteger" ): listener.enterSignedInteger(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitSignedInteger"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSignedInteger" ): listener.exitSignedInteger(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSignedInteger" ): + return visitor.visitSignedInteger(self) + else: + return visitor.visitChildren(self) + + + + def signedInteger(self): + localctx = Parser.SignedIntegerContext(self, self._ctx, self.state) self.enterRule(localctx, 106, self.RULE_signedInteger) try: self.enterOuterAlt(localctx, 1) - self.state = 1458 + self.state = 1469 self.match(Parser.INTEGER_CONSTANT) except RecognitionException as re: localctx.exception = re @@ -12633,10 +12368,11 @@ def signedInteger(self): self.exitRule() return localctx + class LimitClauseItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12664,63 +12400,74 @@ def UNBOUNDED(self): def getRuleIndex(self): return Parser.RULE_limitClauseItem - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterLimitClauseItem"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLimitClauseItem" ): listener.enterLimitClauseItem(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitLimitClauseItem"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLimitClauseItem" ): listener.exitLimitClauseItem(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitLimitClauseItem" ): + return visitor.visitLimitClauseItem(self) + else: + return visitor.visitChildren(self) + + + + def limitClauseItem(self): + localctx = Parser.LimitClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 108, self.RULE_limitClauseItem) try: - self.state = 1471 + self.state = 1482 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 138, self._ctx) + la_ = self._interp.adaptivePredict(self._input,139,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) - self.state = 1460 + self.state = 1471 self.match(Parser.INTEGER_CONSTANT) - self.state = 1461 + self.state = 1472 self.match(Parser.PRECEDING) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) - self.state = 1462 + self.state = 1473 self.match(Parser.INTEGER_CONSTANT) - self.state = 1463 + self.state = 1474 self.match(Parser.FOLLOWING) pass elif la_ == 3: self.enterOuterAlt(localctx, 3) - self.state = 1464 + self.state = 1475 self.match(Parser.CURRENT) - self.state = 1465 + self.state = 1476 self.match(Parser.DATA) - self.state = 1466 + self.state = 1477 self.match(Parser.POINT) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) - self.state = 1467 + self.state = 1478 self.match(Parser.UNBOUNDED) - self.state = 1468 + self.state = 1479 self.match(Parser.PRECEDING) pass elif la_ == 5: self.enterOuterAlt(localctx, 5) - self.state = 1469 + self.state = 1480 self.match(Parser.UNBOUNDED) - self.state = 1470 + self.state = 1481 self.match(Parser.FOLLOWING) pass + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -12729,112 +12476,127 @@ def limitClauseItem(self): self.exitRule() return localctx + class GroupingClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_groupingClause - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class GroupAllContext(GroupingClauseContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.GroupingClauseContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GroupingClauseContext super().__init__(ANTLRParser) self.copyFrom(ctx) def GROUP(self): return self.getToken(Parser.GROUP, 0) - def ALL(self): return self.getToken(Parser.ALL, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterGroupAll"): + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGroupAll" ): listener.enterGroupAll(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitGroupAll"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGroupAll" ): listener.exitGroupAll(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitGroupAll" ): + return visitor.visitGroupAll(self) + else: + return visitor.visitChildren(self) + + class GroupByOrExceptContext(GroupingClauseContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.GroupingClauseContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GroupingClauseContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def GROUP(self): return self.getToken(Parser.GROUP, 0) - - def componentID(self, i: int = None): + def componentID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext, i) + return self.getTypedRuleContext(Parser.ComponentIDContext,i) def BY(self): return self.getToken(Parser.BY, 0) - def EXCEPT(self): return self.getToken(Parser.EXCEPT, 0) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterGroupByOrExcept"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGroupByOrExcept" ): listener.enterGroupByOrExcept(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitGroupByOrExcept"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGroupByOrExcept" ): listener.exitGroupByOrExcept(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitGroupByOrExcept" ): + return visitor.visitGroupByOrExcept(self) + else: + return visitor.visitChildren(self) + + + def groupingClause(self): + localctx = Parser.GroupingClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 110, self.RULE_groupingClause) - self._la = 0 # Token type + self._la = 0 # Token type try: - self.state = 1486 + self.state = 1497 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 140, self._ctx) + la_ = self._interp.adaptivePredict(self._input,141,self._ctx) if la_ == 1: localctx = Parser.GroupByOrExceptContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 1473 + self.state = 1484 self.match(Parser.GROUP) - self.state = 1474 + self.state = 1485 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.BY or _la == Parser.EXCEPT): + if not(_la==Parser.BY or _la==Parser.EXCEPT): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 1475 + self.state = 1486 self.componentID() - self.state = 1480 + self.state = 1491 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1476 + while _la==Parser.COMMA: + self.state = 1487 self.match(Parser.COMMA) - self.state = 1477 + self.state = 1488 self.componentID() - self.state = 1482 + self.state = 1493 self._errHandler.sync(self) _la = self._input.LA(1) @@ -12843,14 +12605,15 @@ def groupingClause(self): elif la_ == 2: localctx = Parser.GroupAllContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 1483 + self.state = 1494 self.match(Parser.GROUP) - self.state = 1484 + self.state = 1495 self.match(Parser.ALL) - self.state = 1485 + self.state = 1496 self.exprComponent(0) pass + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -12859,10 +12622,11 @@ def groupingClause(self): self.exitRule() return localctx + class HavingClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12870,27 +12634,38 @@ def HAVING(self): return self.getToken(Parser.HAVING, 0) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) + def getRuleIndex(self): return Parser.RULE_havingClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterHavingClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHavingClause" ): listener.enterHavingClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitHavingClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHavingClause" ): listener.exitHavingClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitHavingClause" ): + return visitor.visitHavingClause(self) + else: + return visitor.visitChildren(self) + + + + def havingClause(self): + localctx = Parser.HavingClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 112, self.RULE_havingClause) try: self.enterOuterAlt(localctx, 1) - self.state = 1488 + self.state = 1499 self.match(Parser.HAVING) - self.state = 1489 + self.state = 1500 self.exprComponent(0) except RecognitionException as re: localctx.exception = re @@ -12900,55 +12675,70 @@ def havingClause(self): self.exitRule() return localctx + class ParameterItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext, 0) + return self.getTypedRuleContext(Parser.VarIDContext,0) + def inputParameterType(self): - return self.getTypedRuleContext(Parser.InputParameterTypeContext, 0) + return self.getTypedRuleContext(Parser.InputParameterTypeContext,0) + def DEFAULT(self): return self.getToken(Parser.DEFAULT, 0) def scalarItem(self): - return self.getTypedRuleContext(Parser.ScalarItemContext, 0) + return self.getTypedRuleContext(Parser.ScalarItemContext,0) + def getRuleIndex(self): return Parser.RULE_parameterItem - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterParameterItem"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParameterItem" ): listener.enterParameterItem(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitParameterItem"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParameterItem" ): listener.exitParameterItem(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitParameterItem" ): + return visitor.visitParameterItem(self) + else: + return visitor.visitChildren(self) + + + + def parameterItem(self): + localctx = Parser.ParameterItemContext(self, self._ctx, self.state) self.enterRule(localctx, 114, self.RULE_parameterItem) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1491 + self.state = 1502 self.varID() - self.state = 1492 + self.state = 1503 self.inputParameterType() - self.state = 1495 + self.state = 1506 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.DEFAULT: - self.state = 1493 + if _la==Parser.DEFAULT: + self.state = 1504 self.match(Parser.DEFAULT) - self.state = 1494 + self.state = 1505 self.scalarItem() + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -12957,70 +12747,67 @@ def parameterItem(self): self.exitRule() return localctx + class OutputParameterTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) + return self.getTypedRuleContext(Parser.ScalarTypeContext,0) + def datasetType(self): - return self.getTypedRuleContext(Parser.DatasetTypeContext, 0) + return self.getTypedRuleContext(Parser.DatasetTypeContext,0) + def componentType(self): - return self.getTypedRuleContext(Parser.ComponentTypeContext, 0) + return self.getTypedRuleContext(Parser.ComponentTypeContext,0) + def getRuleIndex(self): return Parser.RULE_outputParameterType - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterOutputParameterType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOutputParameterType" ): listener.enterOutputParameterType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitOutputParameterType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOutputParameterType" ): listener.exitOutputParameterType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOutputParameterType" ): + return visitor.visitOutputParameterType(self) + else: + return visitor.visitChildren(self) + + + + def outputParameterType(self): + localctx = Parser.OutputParameterTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 116, self.RULE_outputParameterType) try: - self.state = 1500 + self.state = 1511 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.BOOLEAN, - Parser.DATE, - Parser.TIME_PERIOD, - Parser.NUMBER, - Parser.STRING, - Parser.TIME, - Parser.INTEGER, - Parser.DURATION, - Parser.SCALAR, - Parser.IDENTIFIER, - ]: + if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR, Parser.IDENTIFIER]: self.enterOuterAlt(localctx, 1) - self.state = 1497 + self.state = 1508 self.scalarType() pass elif token in [Parser.DATASET]: self.enterOuterAlt(localctx, 2) - self.state = 1498 + self.state = 1509 self.datasetType() pass - elif token in [ - Parser.DIMENSION, - Parser.MEASURE, - Parser.ATTRIBUTE, - Parser.VIRAL, - Parser.COMPONENT, - ]: + elif token in [Parser.DIMENSION, Parser.MEASURE, Parser.ATTRIBUTE, Parser.VIRAL, Parser.COMPONENT]: self.enterOuterAlt(localctx, 3) - self.state = 1499 + self.state = 1510 self.componentType() pass else: @@ -13034,62 +12821,58 @@ def outputParameterType(self): self.exitRule() return localctx + class OutputParameterTypeComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentType(self): - return self.getTypedRuleContext(Parser.ComponentTypeContext, 0) + return self.getTypedRuleContext(Parser.ComponentTypeContext,0) + def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) + return self.getTypedRuleContext(Parser.ScalarTypeContext,0) + def getRuleIndex(self): return Parser.RULE_outputParameterTypeComponent - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterOutputParameterTypeComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOutputParameterTypeComponent" ): listener.enterOutputParameterTypeComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitOutputParameterTypeComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOutputParameterTypeComponent" ): listener.exitOutputParameterTypeComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOutputParameterTypeComponent" ): + return visitor.visitOutputParameterTypeComponent(self) + else: + return visitor.visitChildren(self) + + + + def outputParameterTypeComponent(self): + localctx = Parser.OutputParameterTypeComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 118, self.RULE_outputParameterTypeComponent) try: - self.state = 1504 + self.state = 1515 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.DIMENSION, - Parser.MEASURE, - Parser.ATTRIBUTE, - Parser.VIRAL, - Parser.COMPONENT, - ]: + if token in [Parser.DIMENSION, Parser.MEASURE, Parser.ATTRIBUTE, Parser.VIRAL, Parser.COMPONENT]: self.enterOuterAlt(localctx, 1) - self.state = 1502 + self.state = 1513 self.componentType() pass - elif token in [ - Parser.BOOLEAN, - Parser.DATE, - Parser.TIME_PERIOD, - Parser.NUMBER, - Parser.STRING, - Parser.TIME, - Parser.INTEGER, - Parser.DURATION, - Parser.SCALAR, - Parser.IDENTIFIER, - ]: + elif token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR, Parser.IDENTIFIER]: self.enterOuterAlt(localctx, 2) - self.state = 1503 + self.state = 1514 self.scalarType() pass else: @@ -13103,94 +12886,85 @@ def outputParameterTypeComponent(self): self.exitRule() return localctx + class InputParameterTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) + return self.getTypedRuleContext(Parser.ScalarTypeContext,0) + def datasetType(self): - return self.getTypedRuleContext(Parser.DatasetTypeContext, 0) + return self.getTypedRuleContext(Parser.DatasetTypeContext,0) + def scalarSetType(self): - return self.getTypedRuleContext(Parser.ScalarSetTypeContext, 0) + return self.getTypedRuleContext(Parser.ScalarSetTypeContext,0) + def rulesetType(self): - return self.getTypedRuleContext(Parser.RulesetTypeContext, 0) + return self.getTypedRuleContext(Parser.RulesetTypeContext,0) + def componentType(self): - return self.getTypedRuleContext(Parser.ComponentTypeContext, 0) + return self.getTypedRuleContext(Parser.ComponentTypeContext,0) + def getRuleIndex(self): return Parser.RULE_inputParameterType - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterInputParameterType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInputParameterType" ): listener.enterInputParameterType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitInputParameterType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInputParameterType" ): listener.exitInputParameterType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInputParameterType" ): + return visitor.visitInputParameterType(self) + else: + return visitor.visitChildren(self) + + + + def inputParameterType(self): + localctx = Parser.InputParameterTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 120, self.RULE_inputParameterType) try: - self.state = 1511 + self.state = 1522 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.BOOLEAN, - Parser.DATE, - Parser.TIME_PERIOD, - Parser.NUMBER, - Parser.STRING, - Parser.TIME, - Parser.INTEGER, - Parser.DURATION, - Parser.SCALAR, - Parser.IDENTIFIER, - ]: + if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR, Parser.IDENTIFIER]: self.enterOuterAlt(localctx, 1) - self.state = 1506 + self.state = 1517 self.scalarType() pass elif token in [Parser.DATASET]: self.enterOuterAlt(localctx, 2) - self.state = 1507 + self.state = 1518 self.datasetType() pass elif token in [Parser.SET]: self.enterOuterAlt(localctx, 3) - self.state = 1508 + self.state = 1519 self.scalarSetType() pass - elif token in [ - Parser.DATAPOINT, - Parser.HIERARCHICAL, - Parser.RULESET, - Parser.DATAPOINT_ON_VD, - Parser.DATAPOINT_ON_VAR, - Parser.HIERARCHICAL_ON_VD, - Parser.HIERARCHICAL_ON_VAR, - ]: + elif token in [Parser.DATAPOINT, Parser.HIERARCHICAL, Parser.RULESET, Parser.DATAPOINT_ON_VD, Parser.DATAPOINT_ON_VAR, Parser.HIERARCHICAL_ON_VD, Parser.HIERARCHICAL_ON_VAR]: self.enterOuterAlt(localctx, 4) - self.state = 1509 + self.state = 1520 self.rulesetType() pass - elif token in [ - Parser.DIMENSION, - Parser.MEASURE, - Parser.ATTRIBUTE, - Parser.VIRAL, - Parser.COMPONENT, - ]: + elif token in [Parser.DIMENSION, Parser.MEASURE, Parser.ATTRIBUTE, Parser.VIRAL, Parser.COMPONENT]: self.enterOuterAlt(localctx, 5) - self.state = 1510 + self.state = 1521 self.componentType() pass else: @@ -13204,10 +12978,11 @@ def inputParameterType(self): self.exitRule() return localctx + class RulesetTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -13215,46 +12990,54 @@ def RULESET(self): return self.getToken(Parser.RULESET, 0) def dpRuleset(self): - return self.getTypedRuleContext(Parser.DpRulesetContext, 0) + return self.getTypedRuleContext(Parser.DpRulesetContext,0) + def hrRuleset(self): - return self.getTypedRuleContext(Parser.HrRulesetContext, 0) + return self.getTypedRuleContext(Parser.HrRulesetContext,0) + def getRuleIndex(self): return Parser.RULE_rulesetType - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRulesetType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRulesetType" ): listener.enterRulesetType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRulesetType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRulesetType" ): listener.exitRulesetType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRulesetType" ): + return visitor.visitRulesetType(self) + else: + return visitor.visitChildren(self) + + + + def rulesetType(self): + localctx = Parser.RulesetTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 122, self.RULE_rulesetType) try: - self.state = 1516 + self.state = 1527 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.RULESET]: self.enterOuterAlt(localctx, 1) - self.state = 1513 + self.state = 1524 self.match(Parser.RULESET) pass elif token in [Parser.DATAPOINT, Parser.DATAPOINT_ON_VD, Parser.DATAPOINT_ON_VAR]: self.enterOuterAlt(localctx, 2) - self.state = 1514 + self.state = 1525 self.dpRuleset() pass - elif token in [ - Parser.HIERARCHICAL, - Parser.HIERARCHICAL_ON_VD, - Parser.HIERARCHICAL_ON_VAR, - ]: + elif token in [Parser.HIERARCHICAL, Parser.HIERARCHICAL_ON_VD, Parser.HIERARCHICAL_ON_VAR]: self.enterOuterAlt(localctx, 3) - self.state = 1515 + self.state = 1526 self.hrRuleset() pass else: @@ -13268,21 +13051,25 @@ def rulesetType(self): self.exitRule() return localctx + class ScalarTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def basicScalarType(self): - return self.getTypedRuleContext(Parser.BasicScalarTypeContext, 0) + return self.getTypedRuleContext(Parser.BasicScalarTypeContext,0) + def valueDomainName(self): - return self.getTypedRuleContext(Parser.ValueDomainNameContext, 0) + return self.getTypedRuleContext(Parser.ValueDomainNameContext,0) + def scalarTypeConstraint(self): - return self.getTypedRuleContext(Parser.ScalarTypeConstraintContext, 0) + return self.getTypedRuleContext(Parser.ScalarTypeConstraintContext,0) + def NULL_CONSTANT(self): return self.getToken(Parser.NULL_CONSTANT, 0) @@ -13293,65 +13080,68 @@ def NOT(self): def getRuleIndex(self): return Parser.RULE_scalarType - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterScalarType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScalarType" ): listener.enterScalarType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitScalarType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScalarType" ): listener.exitScalarType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitScalarType" ): + return visitor.visitScalarType(self) + else: + return visitor.visitChildren(self) + + + + def scalarType(self): + localctx = Parser.ScalarTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 124, self.RULE_scalarType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1520 + self.state = 1531 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.BOOLEAN, - Parser.DATE, - Parser.TIME_PERIOD, - Parser.NUMBER, - Parser.STRING, - Parser.TIME, - Parser.INTEGER, - Parser.DURATION, - Parser.SCALAR, - ]: - self.state = 1518 + if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR]: + self.state = 1529 self.basicScalarType() pass elif token in [Parser.IDENTIFIER]: - self.state = 1519 + self.state = 1530 self.valueDomainName() pass else: raise NoViableAltException(self) - self.state = 1523 + self.state = 1534 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.QLPAREN or _la == Parser.GLPAREN: - self.state = 1522 + if _la==Parser.QLPAREN or _la==Parser.GLPAREN: + self.state = 1533 self.scalarTypeConstraint() - self.state = 1529 + + self.state = 1540 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.NOT or _la == Parser.NULL_CONSTANT: - self.state = 1526 + if _la==Parser.NOT or _la==Parser.NULL_CONSTANT: + self.state = 1537 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.NOT: - self.state = 1525 + if _la==Parser.NOT: + self.state = 1536 self.match(Parser.NOT) - self.state = 1528 + + self.state = 1539 self.match(Parser.NULL_CONSTANT) + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -13360,21 +13150,24 @@ def scalarType(self): self.exitRule() return localctx + class ComponentTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentRole(self): - return self.getTypedRuleContext(Parser.ComponentRoleContext, 0) + return self.getTypedRuleContext(Parser.ComponentRoleContext,0) + def LT(self): return self.getToken(Parser.LT, 0) def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) + return self.getTypedRuleContext(Parser.ScalarTypeContext,0) + def MT(self): return self.getToken(Parser.MT, 0) @@ -13382,33 +13175,44 @@ def MT(self): def getRuleIndex(self): return Parser.RULE_componentType - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterComponentType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComponentType" ): listener.enterComponentType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitComponentType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComponentType" ): listener.exitComponentType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitComponentType" ): + return visitor.visitComponentType(self) + else: + return visitor.visitChildren(self) + + + + def componentType(self): + localctx = Parser.ComponentTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 126, self.RULE_componentType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1531 + self.state = 1542 self.componentRole() - self.state = 1536 + self.state = 1547 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.LT: - self.state = 1532 + if _la==Parser.LT: + self.state = 1543 self.match(Parser.LT) - self.state = 1533 + self.state = 1544 self.scalarType() - self.state = 1534 + self.state = 1545 self.match(Parser.MT) + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -13417,10 +13221,11 @@ def componentType(self): self.exitRule() return localctx + class DatasetTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -13430,16 +13235,17 @@ def DATASET(self): def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - def compConstraint(self, i: int = None): + def compConstraint(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.CompConstraintContext) else: - return self.getTypedRuleContext(Parser.CompConstraintContext, i) + return self.getTypedRuleContext(Parser.CompConstraintContext,i) + def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -13448,45 +13254,56 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_datasetType - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDatasetType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDatasetType" ): listener.enterDatasetType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDatasetType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDatasetType" ): listener.exitDatasetType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDatasetType" ): + return visitor.visitDatasetType(self) + else: + return visitor.visitChildren(self) + + + + def datasetType(self): + localctx = Parser.DatasetTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 128, self.RULE_datasetType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1538 + self.state = 1549 self.match(Parser.DATASET) - self.state = 1550 + self.state = 1561 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.GLPAREN: - self.state = 1539 + if _la==Parser.GLPAREN: + self.state = 1550 self.match(Parser.GLPAREN) - self.state = 1540 + self.state = 1551 self.compConstraint() - self.state = 1545 + self.state = 1556 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1541 + while _la==Parser.COMMA: + self.state = 1552 self.match(Parser.COMMA) - self.state = 1542 + self.state = 1553 self.compConstraint() - self.state = 1547 + self.state = 1558 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1548 + self.state = 1559 self.match(Parser.GRPAREN) + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -13495,56 +13312,58 @@ def datasetType(self): self.exitRule() return localctx + class EvalDatasetTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def datasetType(self): - return self.getTypedRuleContext(Parser.DatasetTypeContext, 0) + return self.getTypedRuleContext(Parser.DatasetTypeContext,0) + def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) + return self.getTypedRuleContext(Parser.ScalarTypeContext,0) + def getRuleIndex(self): return Parser.RULE_evalDatasetType - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterEvalDatasetType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvalDatasetType" ): listener.enterEvalDatasetType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitEvalDatasetType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvalDatasetType" ): listener.exitEvalDatasetType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitEvalDatasetType" ): + return visitor.visitEvalDatasetType(self) + else: + return visitor.visitChildren(self) + + + + def evalDatasetType(self): + localctx = Parser.EvalDatasetTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 130, self.RULE_evalDatasetType) try: - self.state = 1554 + self.state = 1565 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.DATASET]: self.enterOuterAlt(localctx, 1) - self.state = 1552 + self.state = 1563 self.datasetType() pass - elif token in [ - Parser.BOOLEAN, - Parser.DATE, - Parser.TIME_PERIOD, - Parser.NUMBER, - Parser.STRING, - Parser.TIME, - Parser.INTEGER, - Parser.DURATION, - Parser.SCALAR, - Parser.IDENTIFIER, - ]: + elif token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR, Parser.IDENTIFIER]: self.enterOuterAlt(localctx, 2) - self.state = 1553 + self.state = 1564 self.scalarType() pass else: @@ -13558,10 +13377,11 @@ def evalDatasetType(self): self.exitRule() return localctx + class ScalarSetTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -13572,7 +13392,8 @@ def LT(self): return self.getToken(Parser.LT, 0) def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) + return self.getTypedRuleContext(Parser.ScalarTypeContext,0) + def MT(self): return self.getToken(Parser.MT, 0) @@ -13580,33 +13401,44 @@ def MT(self): def getRuleIndex(self): return Parser.RULE_scalarSetType - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterScalarSetType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScalarSetType" ): listener.enterScalarSetType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitScalarSetType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScalarSetType" ): listener.exitScalarSetType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitScalarSetType" ): + return visitor.visitScalarSetType(self) + else: + return visitor.visitChildren(self) + + + + def scalarSetType(self): + localctx = Parser.ScalarSetTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 132, self.RULE_scalarSetType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1556 + self.state = 1567 self.match(Parser.SET) - self.state = 1561 + self.state = 1572 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.LT: - self.state = 1557 + if _la==Parser.LT: + self.state = 1568 self.match(Parser.LT) - self.state = 1558 + self.state = 1569 self.scalarType() - self.state = 1559 + self.state = 1570 self.match(Parser.MT) + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -13615,180 +13447,201 @@ def scalarSetType(self): self.exitRule() return localctx + class DpRulesetContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_dpRuleset - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class DataPointVdContext(DpRulesetContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.DpRulesetContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DpRulesetContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DATAPOINT_ON_VD(self): return self.getToken(Parser.DATAPOINT_ON_VD, 0) - def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - - def valueDomainName(self, i: int = None): + def valueDomainName(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ValueDomainNameContext) else: - return self.getTypedRuleContext(Parser.ValueDomainNameContext, i) + return self.getTypedRuleContext(Parser.ValueDomainNameContext,i) def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - - def MUL(self, i: int = None): + def MUL(self, i:int=None): if i is None: return self.getTokens(Parser.MUL) else: return self.getToken(Parser.MUL, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDataPointVd"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataPointVd" ): listener.enterDataPointVd(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDataPointVd"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataPointVd" ): listener.exitDataPointVd(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDataPointVd" ): + return visitor.visitDataPointVd(self) + else: + return visitor.visitChildren(self) + + class DataPointVarContext(DpRulesetContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.DpRulesetContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DpRulesetContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DATAPOINT_ON_VAR(self): return self.getToken(Parser.DATAPOINT_ON_VAR, 0) - def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - - def varID(self, i: int = None): + def varID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.VarIDContext) else: - return self.getTypedRuleContext(Parser.VarIDContext, i) + return self.getTypedRuleContext(Parser.VarIDContext,i) def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - - def MUL(self, i: int = None): + def MUL(self, i:int=None): if i is None: return self.getTokens(Parser.MUL) else: return self.getToken(Parser.MUL, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDataPointVar"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataPointVar" ): listener.enterDataPointVar(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDataPointVar"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataPointVar" ): listener.exitDataPointVar(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDataPointVar" ): + return visitor.visitDataPointVar(self) + else: + return visitor.visitChildren(self) + + class DataPointContext(DpRulesetContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.DpRulesetContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DpRulesetContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DATAPOINT(self): return self.getToken(Parser.DATAPOINT, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDataPoint"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataPoint" ): listener.enterDataPoint(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDataPoint"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataPoint" ): listener.exitDataPoint(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDataPoint" ): + return visitor.visitDataPoint(self) + else: + return visitor.visitChildren(self) + + + def dpRuleset(self): + localctx = Parser.DpRulesetContext(self, self._ctx, self.state) self.enterRule(localctx, 134, self.RULE_dpRuleset) - self._la = 0 # Token type + self._la = 0 # Token type try: - self.state = 1592 + self.state = 1603 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.DATAPOINT]: localctx = Parser.DataPointContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 1563 + self.state = 1574 self.match(Parser.DATAPOINT) pass elif token in [Parser.DATAPOINT_ON_VD]: localctx = Parser.DataPointVdContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 1564 + self.state = 1575 self.match(Parser.DATAPOINT_ON_VD) - self.state = 1576 + self.state = 1587 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.GLPAREN: - self.state = 1565 + if _la==Parser.GLPAREN: + self.state = 1576 self.match(Parser.GLPAREN) - self.state = 1566 + self.state = 1577 self.valueDomainName() - self.state = 1571 + self.state = 1582 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.MUL: - self.state = 1567 + while _la==Parser.MUL: + self.state = 1578 self.match(Parser.MUL) - self.state = 1568 + self.state = 1579 self.valueDomainName() - self.state = 1573 + self.state = 1584 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1574 + self.state = 1585 self.match(Parser.GRPAREN) + pass elif token in [Parser.DATAPOINT_ON_VAR]: localctx = Parser.DataPointVarContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 1578 + self.state = 1589 self.match(Parser.DATAPOINT_ON_VAR) - self.state = 1590 + self.state = 1601 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.GLPAREN: - self.state = 1579 + if _la==Parser.GLPAREN: + self.state = 1590 self.match(Parser.GLPAREN) - self.state = 1580 + self.state = 1591 self.varID() - self.state = 1585 + self.state = 1596 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.MUL: - self.state = 1581 + while _la==Parser.MUL: + self.state = 1592 self.match(Parser.MUL) - self.state = 1582 + self.state = 1593 self.varID() - self.state = 1587 + self.state = 1598 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1588 + self.state = 1599 self.match(Parser.GRPAREN) + pass else: raise NoViableAltException(self) @@ -13801,219 +13654,237 @@ def dpRuleset(self): self.exitRule() return localctx + class HrRulesetContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_hrRuleset - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class HrRulesetVdTypeContext(HrRulesetContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.HrRulesetContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.HrRulesetContext super().__init__(ANTLRParser) - self.vdName = None # Token + self.vdName = None # Token self.copyFrom(ctx) def HIERARCHICAL_ON_VD(self): return self.getToken(Parser.HIERARCHICAL_ON_VD, 0) - def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) - def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - - def valueDomainName(self, i: int = None): + def valueDomainName(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ValueDomainNameContext) else: - return self.getTypedRuleContext(Parser.ValueDomainNameContext, i) + return self.getTypedRuleContext(Parser.ValueDomainNameContext,i) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def MUL(self, i: int = None): + def MUL(self, i:int=None): if i is None: return self.getTokens(Parser.MUL) else: return self.getToken(Parser.MUL, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterHrRulesetVdType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHrRulesetVdType" ): listener.enterHrRulesetVdType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitHrRulesetVdType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHrRulesetVdType" ): listener.exitHrRulesetVdType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitHrRulesetVdType" ): + return visitor.visitHrRulesetVdType(self) + else: + return visitor.visitChildren(self) + + class HrRulesetVarTypeContext(HrRulesetContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.HrRulesetContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.HrRulesetContext super().__init__(ANTLRParser) - self.varName = None # VarIDContext + self.varName = None # VarIDContext self.copyFrom(ctx) def HIERARCHICAL_ON_VAR(self): return self.getToken(Parser.HIERARCHICAL_ON_VAR, 0) - def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - - def varID(self, i: int = None): + def varID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.VarIDContext) else: - return self.getTypedRuleContext(Parser.VarIDContext, i) + return self.getTypedRuleContext(Parser.VarIDContext,i) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - - def MUL(self, i: int = None): + def MUL(self, i:int=None): if i is None: return self.getTokens(Parser.MUL) else: return self.getToken(Parser.MUL, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterHrRulesetVarType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHrRulesetVarType" ): listener.enterHrRulesetVarType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitHrRulesetVarType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHrRulesetVarType" ): listener.exitHrRulesetVarType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitHrRulesetVarType" ): + return visitor.visitHrRulesetVarType(self) + else: + return visitor.visitChildren(self) + + class HrRulesetTypeContext(HrRulesetContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.HrRulesetContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.HrRulesetContext super().__init__(ANTLRParser) self.copyFrom(ctx) def HIERARCHICAL(self): return self.getToken(Parser.HIERARCHICAL, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterHrRulesetType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHrRulesetType" ): listener.enterHrRulesetType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitHrRulesetType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHrRulesetType" ): listener.exitHrRulesetType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitHrRulesetType" ): + return visitor.visitHrRulesetType(self) + else: + return visitor.visitChildren(self) + + + def hrRuleset(self): + localctx = Parser.HrRulesetContext(self, self._ctx, self.state) self.enterRule(localctx, 136, self.RULE_hrRuleset) - self._la = 0 # Token type + self._la = 0 # Token type try: - self.state = 1634 + self.state = 1645 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.HIERARCHICAL]: localctx = Parser.HrRulesetTypeContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 1594 + self.state = 1605 self.match(Parser.HIERARCHICAL) pass elif token in [Parser.HIERARCHICAL_ON_VD]: localctx = Parser.HrRulesetVdTypeContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 1595 + self.state = 1606 self.match(Parser.HIERARCHICAL_ON_VD) - self.state = 1612 + self.state = 1623 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.GLPAREN: - self.state = 1596 + if _la==Parser.GLPAREN: + self.state = 1607 self.match(Parser.GLPAREN) - self.state = 1597 + self.state = 1608 localctx.vdName = self.match(Parser.IDENTIFIER) - self.state = 1609 + self.state = 1620 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.LPAREN: - self.state = 1598 + if _la==Parser.LPAREN: + self.state = 1609 self.match(Parser.LPAREN) - self.state = 1599 + self.state = 1610 self.valueDomainName() - self.state = 1604 + self.state = 1615 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.MUL: - self.state = 1600 + while _la==Parser.MUL: + self.state = 1611 self.match(Parser.MUL) - self.state = 1601 + self.state = 1612 self.valueDomainName() - self.state = 1606 + self.state = 1617 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1607 + self.state = 1618 self.match(Parser.RPAREN) - self.state = 1611 + + self.state = 1622 self.match(Parser.GRPAREN) + pass elif token in [Parser.HIERARCHICAL_ON_VAR]: localctx = Parser.HrRulesetVarTypeContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 1614 + self.state = 1625 self.match(Parser.HIERARCHICAL_ON_VAR) - self.state = 1632 + self.state = 1643 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.GLPAREN: - self.state = 1615 + if _la==Parser.GLPAREN: + self.state = 1626 self.match(Parser.GLPAREN) - self.state = 1616 + self.state = 1627 localctx.varName = self.varID() - self.state = 1628 + self.state = 1639 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.LPAREN: - self.state = 1617 + if _la==Parser.LPAREN: + self.state = 1628 self.match(Parser.LPAREN) - self.state = 1618 + self.state = 1629 self.varID() - self.state = 1623 + self.state = 1634 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.MUL: - self.state = 1619 + while _la==Parser.MUL: + self.state = 1630 self.match(Parser.MUL) - self.state = 1620 + self.state = 1631 self.varID() - self.state = 1625 + self.state = 1636 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1626 + self.state = 1637 self.match(Parser.RPAREN) - self.state = 1630 + + self.state = 1641 self.match(Parser.GRPAREN) + pass else: raise NoViableAltException(self) @@ -14026,10 +13897,11 @@ def hrRuleset(self): self.exitRule() return localctx + class ValueDomainNameContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -14039,20 +13911,30 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_valueDomainName - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterValueDomainName"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValueDomainName" ): listener.enterValueDomainName(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitValueDomainName"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValueDomainName" ): listener.exitValueDomainName(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitValueDomainName" ): + return visitor.visitValueDomainName(self) + else: + return visitor.visitChildren(self) + + + + def valueDomainName(self): + localctx = Parser.ValueDomainNameContext(self, self._ctx, self.state) self.enterRule(localctx, 138, self.RULE_valueDomainName) try: self.enterOuterAlt(localctx, 1) - self.state = 1636 + self.state = 1647 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -14062,10 +13944,11 @@ def valueDomainName(self): self.exitRule() return localctx + class RulesetIDContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -14075,20 +13958,30 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_rulesetID - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRulesetID"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRulesetID" ): listener.enterRulesetID(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRulesetID"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRulesetID" ): listener.exitRulesetID(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRulesetID" ): + return visitor.visitRulesetID(self) + else: + return visitor.visitChildren(self) + + + + def rulesetID(self): + localctx = Parser.RulesetIDContext(self, self._ctx, self.state) self.enterRule(localctx, 140, self.RULE_rulesetID) try: self.enterOuterAlt(localctx, 1) - self.state = 1638 + self.state = 1649 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -14098,18 +13991,20 @@ def rulesetID(self): self.exitRule() return localctx + class RulesetSignatureContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def signature(self, i: int = None): + def signature(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.SignatureContext) else: - return self.getTypedRuleContext(Parser.SignatureContext, i) + return self.getTypedRuleContext(Parser.SignatureContext,i) + def VALUE_DOMAIN(self): return self.getToken(Parser.VALUE_DOMAIN, 0) @@ -14117,7 +14012,7 @@ def VALUE_DOMAIN(self): def VARIABLE(self): return self.getToken(Parser.VARIABLE, 0) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -14126,38 +14021,48 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_rulesetSignature - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRulesetSignature"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRulesetSignature" ): listener.enterRulesetSignature(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRulesetSignature"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRulesetSignature" ): listener.exitRulesetSignature(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRulesetSignature" ): + return visitor.visitRulesetSignature(self) + else: + return visitor.visitChildren(self) + + + + def rulesetSignature(self): + localctx = Parser.RulesetSignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 142, self.RULE_rulesetSignature) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1640 + self.state = 1651 _la = self._input.LA(1) - if not (_la == Parser.VALUE_DOMAIN or _la == Parser.VARIABLE): + if not(_la==Parser.VALUE_DOMAIN or _la==Parser.VARIABLE): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 1641 + self.state = 1652 self.signature() - self.state = 1646 + self.state = 1657 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1642 + while _la==Parser.COMMA: + self.state = 1653 self.match(Parser.COMMA) - self.state = 1643 + self.state = 1654 self.signature() - self.state = 1648 + self.state = 1659 self._errHandler.sync(self) _la = self._input.LA(1) @@ -14169,50 +14074,64 @@ def rulesetSignature(self): self.exitRule() return localctx + class SignatureContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext, 0) + return self.getTypedRuleContext(Parser.VarIDContext,0) + def AS(self): return self.getToken(Parser.AS, 0) def alias(self): - return self.getTypedRuleContext(Parser.AliasContext, 0) + return self.getTypedRuleContext(Parser.AliasContext,0) + def getRuleIndex(self): return Parser.RULE_signature - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterSignature"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSignature" ): listener.enterSignature(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitSignature"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSignature" ): listener.exitSignature(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSignature" ): + return visitor.visitSignature(self) + else: + return visitor.visitChildren(self) + + + + def signature(self): + localctx = Parser.SignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 144, self.RULE_signature) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1649 + self.state = 1660 self.varID() - self.state = 1652 + self.state = 1663 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.AS: - self.state = 1650 + if _la==Parser.AS: + self.state = 1661 self.match(Parser.AS) - self.state = 1651 + self.state = 1662 self.alias() + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -14221,20 +14140,22 @@ def signature(self): self.exitRule() return localctx + class RuleClauseDatapointContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def ruleItemDatapoint(self, i: int = None): + def ruleItemDatapoint(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.RuleItemDatapointContext) else: - return self.getTypedRuleContext(Parser.RuleItemDatapointContext, i) + return self.getTypedRuleContext(Parser.RuleItemDatapointContext,i) + - def EOL(self, i: int = None): + def EOL(self, i:int=None): if i is None: return self.getTokens(Parser.EOL) else: @@ -14243,31 +14164,41 @@ def EOL(self, i: int = None): def getRuleIndex(self): return Parser.RULE_ruleClauseDatapoint - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRuleClauseDatapoint"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRuleClauseDatapoint" ): listener.enterRuleClauseDatapoint(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRuleClauseDatapoint"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRuleClauseDatapoint" ): listener.exitRuleClauseDatapoint(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRuleClauseDatapoint" ): + return visitor.visitRuleClauseDatapoint(self) + else: + return visitor.visitChildren(self) + + + + def ruleClauseDatapoint(self): + localctx = Parser.RuleClauseDatapointContext(self, self._ctx, self.state) self.enterRule(localctx, 146, self.RULE_ruleClauseDatapoint) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1654 + self.state = 1665 self.ruleItemDatapoint() - self.state = 1659 + self.state = 1670 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.EOL: - self.state = 1655 + while _la==Parser.EOL: + self.state = 1666 self.match(Parser.EOL) - self.state = 1656 + self.state = 1667 self.ruleItemDatapoint() - self.state = 1661 + self.state = 1672 self._errHandler.sync(self) _la = self._input.LA(1) @@ -14279,21 +14210,23 @@ def ruleClauseDatapoint(self): self.exitRule() return localctx + class RuleItemDatapointContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.ruleName = None # Token - self.antecedentContiditon = None # ExprComponentContext - self.consequentCondition = None # ExprComponentContext + self.ruleName = None # Token + self.antecedentContiditon = None # ExprComponentContext + self.consequentCondition = None # ExprComponentContext - def exprComponent(self, i: int = None): + def exprComponent(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext, i) + return self.getTypedRuleContext(Parser.ExprComponentContext,i) + def COLON(self): return self.getToken(Parser.COLON, 0) @@ -14305,10 +14238,12 @@ def THEN(self): return self.getToken(Parser.THEN, 0) def erCode(self): - return self.getTypedRuleContext(Parser.ErCodeContext, 0) + return self.getTypedRuleContext(Parser.ErCodeContext,0) + def erLevel(self): - return self.getTypedRuleContext(Parser.ErLevelContext, 0) + return self.getTypedRuleContext(Parser.ErLevelContext,0) + def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) @@ -14316,56 +14251,70 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_ruleItemDatapoint - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRuleItemDatapoint"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRuleItemDatapoint" ): listener.enterRuleItemDatapoint(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRuleItemDatapoint"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRuleItemDatapoint" ): listener.exitRuleItemDatapoint(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRuleItemDatapoint" ): + return visitor.visitRuleItemDatapoint(self) + else: + return visitor.visitChildren(self) + + + + def ruleItemDatapoint(self): + localctx = Parser.RuleItemDatapointContext(self, self._ctx, self.state) self.enterRule(localctx, 148, self.RULE_ruleItemDatapoint) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1664 + self.state = 1675 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 170, self._ctx) + la_ = self._interp.adaptivePredict(self._input,171,self._ctx) if la_ == 1: - self.state = 1662 + self.state = 1673 localctx.ruleName = self.match(Parser.IDENTIFIER) - self.state = 1663 + self.state = 1674 self.match(Parser.COLON) - self.state = 1670 + + self.state = 1681 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.WHEN: - self.state = 1666 + if _la==Parser.WHEN: + self.state = 1677 self.match(Parser.WHEN) - self.state = 1667 + self.state = 1678 localctx.antecedentContiditon = self.exprComponent(0) - self.state = 1668 + self.state = 1679 self.match(Parser.THEN) - self.state = 1672 + + self.state = 1683 localctx.consequentCondition = self.exprComponent(0) - self.state = 1674 + self.state = 1685 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ERRORCODE: - self.state = 1673 + if _la==Parser.ERRORCODE: + self.state = 1684 self.erCode() - self.state = 1677 + + self.state = 1688 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ERRORLEVEL: - self.state = 1676 + if _la==Parser.ERRORLEVEL: + self.state = 1687 self.erLevel() + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -14374,20 +14323,22 @@ def ruleItemDatapoint(self): self.exitRule() return localctx + class RuleClauseHierarchicalContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def ruleItemHierarchical(self, i: int = None): + def ruleItemHierarchical(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.RuleItemHierarchicalContext) else: - return self.getTypedRuleContext(Parser.RuleItemHierarchicalContext, i) + return self.getTypedRuleContext(Parser.RuleItemHierarchicalContext,i) - def EOL(self, i: int = None): + + def EOL(self, i:int=None): if i is None: return self.getTokens(Parser.EOL) else: @@ -14396,31 +14347,41 @@ def EOL(self, i: int = None): def getRuleIndex(self): return Parser.RULE_ruleClauseHierarchical - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRuleClauseHierarchical"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRuleClauseHierarchical" ): listener.enterRuleClauseHierarchical(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRuleClauseHierarchical"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRuleClauseHierarchical" ): listener.exitRuleClauseHierarchical(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRuleClauseHierarchical" ): + return visitor.visitRuleClauseHierarchical(self) + else: + return visitor.visitChildren(self) + + + + def ruleClauseHierarchical(self): + localctx = Parser.RuleClauseHierarchicalContext(self, self._ctx, self.state) self.enterRule(localctx, 150, self.RULE_ruleClauseHierarchical) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1679 + self.state = 1690 self.ruleItemHierarchical() - self.state = 1684 + self.state = 1695 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.EOL: - self.state = 1680 + while _la==Parser.EOL: + self.state = 1691 self.match(Parser.EOL) - self.state = 1681 + self.state = 1692 self.ruleItemHierarchical() - self.state = 1686 + self.state = 1697 self._errHandler.sync(self) _la = self._input.LA(1) @@ -14432,25 +14393,29 @@ def ruleClauseHierarchical(self): self.exitRule() return localctx + class RuleItemHierarchicalContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.ruleName = None # Token + self.ruleName = None # Token def codeItemRelation(self): - return self.getTypedRuleContext(Parser.CodeItemRelationContext, 0) + return self.getTypedRuleContext(Parser.CodeItemRelationContext,0) + def COLON(self): return self.getToken(Parser.COLON, 0) def erCode(self): - return self.getTypedRuleContext(Parser.ErCodeContext, 0) + return self.getTypedRuleContext(Parser.ErCodeContext,0) + def erLevel(self): - return self.getTypedRuleContext(Parser.ErLevelContext, 0) + return self.getTypedRuleContext(Parser.ErLevelContext,0) + def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) @@ -14458,45 +14423,58 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_ruleItemHierarchical - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRuleItemHierarchical"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRuleItemHierarchical" ): listener.enterRuleItemHierarchical(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRuleItemHierarchical"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRuleItemHierarchical" ): listener.exitRuleItemHierarchical(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRuleItemHierarchical" ): + return visitor.visitRuleItemHierarchical(self) + else: + return visitor.visitChildren(self) + + + + def ruleItemHierarchical(self): + localctx = Parser.RuleItemHierarchicalContext(self, self._ctx, self.state) self.enterRule(localctx, 152, self.RULE_ruleItemHierarchical) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1689 + self.state = 1700 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 175, self._ctx) + la_ = self._interp.adaptivePredict(self._input,176,self._ctx) if la_ == 1: - self.state = 1687 + self.state = 1698 localctx.ruleName = self.match(Parser.IDENTIFIER) - self.state = 1688 + self.state = 1699 self.match(Parser.COLON) - self.state = 1691 + + self.state = 1702 self.codeItemRelation() - self.state = 1693 + self.state = 1704 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ERRORCODE: - self.state = 1692 + if _la==Parser.ERRORCODE: + self.state = 1703 self.erCode() - self.state = 1696 + + self.state = 1707 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.ERRORLEVEL: - self.state = 1695 + if _la==Parser.ERRORLEVEL: + self.state = 1706 self.erLevel() + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -14505,10 +14483,11 @@ def ruleItemHierarchical(self): self.exitRule() return localctx + class HierRuleSignatureContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -14528,44 +14507,56 @@ def CONDITION(self): return self.getToken(Parser.CONDITION, 0) def valueDomainSignature(self): - return self.getTypedRuleContext(Parser.ValueDomainSignatureContext, 0) + return self.getTypedRuleContext(Parser.ValueDomainSignatureContext,0) + def getRuleIndex(self): return Parser.RULE_hierRuleSignature - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterHierRuleSignature"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHierRuleSignature" ): listener.enterHierRuleSignature(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitHierRuleSignature"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHierRuleSignature" ): listener.exitHierRuleSignature(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitHierRuleSignature" ): + return visitor.visitHierRuleSignature(self) + else: + return visitor.visitChildren(self) + + + + def hierRuleSignature(self): + localctx = Parser.HierRuleSignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 154, self.RULE_hierRuleSignature) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1698 + self.state = 1709 _la = self._input.LA(1) - if not (_la == Parser.VALUE_DOMAIN or _la == Parser.VARIABLE): + if not(_la==Parser.VALUE_DOMAIN or _la==Parser.VARIABLE): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 1701 + self.state = 1712 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.CONDITION: - self.state = 1699 + if _la==Parser.CONDITION: + self.state = 1710 self.match(Parser.CONDITION) - self.state = 1700 + self.state = 1711 self.valueDomainSignature() - self.state = 1703 + + self.state = 1714 self.match(Parser.RULE) - self.state = 1704 + self.state = 1715 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -14575,20 +14566,22 @@ def hierRuleSignature(self): self.exitRule() return localctx + class ValueDomainSignatureContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def signature(self, i: int = None): + def signature(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.SignatureContext) else: - return self.getTypedRuleContext(Parser.SignatureContext, i) + return self.getTypedRuleContext(Parser.SignatureContext,i) + - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -14597,31 +14590,41 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_valueDomainSignature - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterValueDomainSignature"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValueDomainSignature" ): listener.enterValueDomainSignature(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitValueDomainSignature"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValueDomainSignature" ): listener.exitValueDomainSignature(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitValueDomainSignature" ): + return visitor.visitValueDomainSignature(self) + else: + return visitor.visitChildren(self) + + + + def valueDomainSignature(self): + localctx = Parser.ValueDomainSignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 156, self.RULE_valueDomainSignature) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1706 + self.state = 1717 self.signature() - self.state = 1711 + self.state = 1722 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1707 + while _la==Parser.COMMA: + self.state = 1718 self.match(Parser.COMMA) - self.state = 1708 + self.state = 1719 self.signature() - self.state = 1713 + self.state = 1724 self._errHandler.sync(self) _la = self._input.LA(1) @@ -14633,106 +14636,98 @@ def valueDomainSignature(self): self.exitRule() return localctx + class CodeItemRelationContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.codetemRef = None # ValueDomainValueContext + self.codetemRef = None # ValueDomainValueContext - def codeItemRelationClause(self, i: int = None): + def codeItemRelationClause(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.CodeItemRelationClauseContext) else: - return self.getTypedRuleContext(Parser.CodeItemRelationClauseContext, i) + return self.getTypedRuleContext(Parser.CodeItemRelationClauseContext,i) + def valueDomainValue(self): - return self.getTypedRuleContext(Parser.ValueDomainValueContext, 0) + return self.getTypedRuleContext(Parser.ValueDomainValueContext,0) + def WHEN(self): return self.getToken(Parser.WHEN, 0) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) + def THEN(self): return self.getToken(Parser.THEN, 0) def comparisonOperand(self): - return self.getTypedRuleContext(Parser.ComparisonOperandContext, 0) + return self.getTypedRuleContext(Parser.ComparisonOperandContext,0) + def getRuleIndex(self): return Parser.RULE_codeItemRelation - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCodeItemRelation"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCodeItemRelation" ): listener.enterCodeItemRelation(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCodeItemRelation"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCodeItemRelation" ): listener.exitCodeItemRelation(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCodeItemRelation" ): + return visitor.visitCodeItemRelation(self) + else: + return visitor.visitChildren(self) + + + + def codeItemRelation(self): + localctx = Parser.CodeItemRelationContext(self, self._ctx, self.state) self.enterRule(localctx, 158, self.RULE_codeItemRelation) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1718 + self.state = 1729 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.WHEN: - self.state = 1714 + if _la==Parser.WHEN: + self.state = 1725 self.match(Parser.WHEN) - self.state = 1715 + self.state = 1726 self.exprComponent(0) - self.state = 1716 + self.state = 1727 self.match(Parser.THEN) - self.state = 1720 + + self.state = 1731 localctx.codetemRef = self.valueDomainValue() - self.state = 1722 + self.state = 1733 self._errHandler.sync(self) _la = self._input.LA(1) - if ((_la) & ~0x3F) == 0 and ( - (1 << _la) - & ( - (1 << Parser.EQ) - | (1 << Parser.LT) - | (1 << Parser.MT) - | (1 << Parser.ME) - | (1 << Parser.NEQ) - | (1 << Parser.LE) - ) - ) != 0: - self.state = 1721 + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.EQ) | (1 << Parser.LT) | (1 << Parser.MT) | (1 << Parser.ME) | (1 << Parser.NEQ) | (1 << Parser.LE))) != 0): + self.state = 1732 self.comparisonOperand() - self.state = 1724 + + self.state = 1735 self.codeItemRelationClause() - self.state = 1728 + self.state = 1739 self._errHandler.sync(self) _la = self._input.LA(1) - while ( - _la == Parser.PLUS - or _la == Parser.MINUS - or ( - ((_la - 241) & ~0x3F) == 0 - and ( - (1 << (_la - 241)) - & ( - (1 << (Parser.INTEGER_CONSTANT - 241)) - | (1 << (Parser.NUMBER_CONSTANT - 241)) - | (1 << (Parser.IDENTIFIER - 241)) - ) - ) - != 0 - ) - ): - self.state = 1725 + while _la==Parser.PLUS or _la==Parser.MINUS or ((((_la - 241)) & ~0x3f) == 0 and ((1 << (_la - 241)) & ((1 << (Parser.INTEGER_CONSTANT - 241)) | (1 << (Parser.NUMBER_CONSTANT - 241)) | (1 << (Parser.IDENTIFIER - 241)))) != 0): + self.state = 1736 self.codeItemRelationClause() - self.state = 1730 + self.state = 1741 self._errHandler.sync(self) _la = self._input.LA(1) @@ -14744,18 +14739,20 @@ def codeItemRelation(self): self.exitRule() return localctx + class CodeItemRelationClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.opAdd = None # Token - self.rightCodeItem = None # ValueDomainValueContext - self.rightCondition = None # ExprComponentContext + self.opAdd = None # Token + self.rightCodeItem = None # ValueDomainValueContext + self.rightCondition = None # ExprComponentContext def valueDomainValue(self): - return self.getTypedRuleContext(Parser.ValueDomainValueContext, 0) + return self.getTypedRuleContext(Parser.ValueDomainValueContext,0) + def QLPAREN(self): return self.getToken(Parser.QLPAREN, 0) @@ -14764,7 +14761,8 @@ def QRPAREN(self): return self.getToken(Parser.QRPAREN, 0) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) + def PLUS(self): return self.getToken(Parser.PLUS, 0) @@ -14775,46 +14773,58 @@ def MINUS(self): def getRuleIndex(self): return Parser.RULE_codeItemRelationClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCodeItemRelationClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCodeItemRelationClause" ): listener.enterCodeItemRelationClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCodeItemRelationClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCodeItemRelationClause" ): listener.exitCodeItemRelationClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCodeItemRelationClause" ): + return visitor.visitCodeItemRelationClause(self) + else: + return visitor.visitChildren(self) + + + + def codeItemRelationClause(self): + localctx = Parser.CodeItemRelationClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 160, self.RULE_codeItemRelationClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1732 + self.state = 1743 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.PLUS or _la == Parser.MINUS: - self.state = 1731 + if _la==Parser.PLUS or _la==Parser.MINUS: + self.state = 1742 localctx.opAdd = self._input.LT(1) _la = self._input.LA(1) - if not (_la == Parser.PLUS or _la == Parser.MINUS): + if not(_la==Parser.PLUS or _la==Parser.MINUS): localctx.opAdd = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 1734 + + self.state = 1745 localctx.rightCodeItem = self.valueDomainValue() - self.state = 1739 + self.state = 1750 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.QLPAREN: - self.state = 1735 + if _la==Parser.QLPAREN: + self.state = 1746 self.match(Parser.QLPAREN) - self.state = 1736 + self.state = 1747 localctx.rightCondition = self.exprComponent(0) - self.state = 1737 + self.state = 1748 self.match(Parser.QRPAREN) + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -14823,10 +14833,11 @@ def codeItemRelationClause(self): self.exitRule() return localctx + class ValueDomainValueContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -14842,34 +14853,33 @@ def NUMBER_CONSTANT(self): def getRuleIndex(self): return Parser.RULE_valueDomainValue - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterValueDomainValue"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValueDomainValue" ): listener.enterValueDomainValue(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitValueDomainValue"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValueDomainValue" ): listener.exitValueDomainValue(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitValueDomainValue" ): + return visitor.visitValueDomainValue(self) + else: + return visitor.visitChildren(self) + + + + def valueDomainValue(self): + localctx = Parser.ValueDomainValueContext(self, self._ctx, self.state) self.enterRule(localctx, 162, self.RULE_valueDomainValue) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1741 + self.state = 1752 _la = self._input.LA(1) - if not ( - ((_la - 241) & ~0x3F) == 0 - and ( - (1 << (_la - 241)) - & ( - (1 << (Parser.INTEGER_CONSTANT - 241)) - | (1 << (Parser.NUMBER_CONSTANT - 241)) - | (1 << (Parser.IDENTIFIER - 241)) - ) - ) - != 0 - ): + if not(((((_la - 241)) & ~0x3f) == 0 and ((1 << (_la - 241)) & ((1 << (Parser.INTEGER_CONSTANT - 241)) | (1 << (Parser.NUMBER_CONSTANT - 241)) | (1 << (Parser.IDENTIFIER - 241)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -14882,114 +14892,130 @@ def valueDomainValue(self): self.exitRule() return localctx + class ScalarTypeConstraintContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser + def getRuleIndex(self): return Parser.RULE_scalarTypeConstraint - def copyFrom(self, ctx: ParserRuleContext): + + def copyFrom(self, ctx:ParserRuleContext): super().copyFrom(ctx) + + class RangeConstraintContext(ScalarTypeConstraintContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ScalarTypeConstraintContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ScalarTypeConstraintContext super().__init__(ANTLRParser) self.copyFrom(ctx) def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - - def scalarItem(self, i: int = None): + def scalarItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ScalarItemContext) else: - return self.getTypedRuleContext(Parser.ScalarItemContext, i) + return self.getTypedRuleContext(Parser.ScalarItemContext,i) def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRangeConstraint"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRangeConstraint" ): listener.enterRangeConstraint(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRangeConstraint"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRangeConstraint" ): listener.exitRangeConstraint(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRangeConstraint" ): + return visitor.visitRangeConstraint(self) + else: + return visitor.visitChildren(self) + + class ConditionConstraintContext(ScalarTypeConstraintContext): - def __init__( - self, ANTLRParser, ctx: ParserRuleContext - ): # actually a Parser.ScalarTypeConstraintContext + + def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ScalarTypeConstraintContext super().__init__(ANTLRParser) self.copyFrom(ctx) def QLPAREN(self): return self.getToken(Parser.QLPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) def QRPAREN(self): return self.getToken(Parser.QRPAREN, 0) - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterConditionConstraint"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConditionConstraint" ): listener.enterConditionConstraint(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitConditionConstraint"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConditionConstraint" ): listener.exitConditionConstraint(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitConditionConstraint" ): + return visitor.visitConditionConstraint(self) + else: + return visitor.visitChildren(self) + + + def scalarTypeConstraint(self): + localctx = Parser.ScalarTypeConstraintContext(self, self._ctx, self.state) self.enterRule(localctx, 164, self.RULE_scalarTypeConstraint) - self._la = 0 # Token type + self._la = 0 # Token type try: - self.state = 1758 + self.state = 1769 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.QLPAREN]: localctx = Parser.ConditionConstraintContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 1743 + self.state = 1754 self.match(Parser.QLPAREN) - self.state = 1744 + self.state = 1755 self.exprComponent(0) - self.state = 1745 + self.state = 1756 self.match(Parser.QRPAREN) pass elif token in [Parser.GLPAREN]: localctx = Parser.RangeConstraintContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 1747 + self.state = 1758 self.match(Parser.GLPAREN) - self.state = 1748 + self.state = 1759 self.scalarItem() - self.state = 1753 + self.state = 1764 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1749 + while _la==Parser.COMMA: + self.state = 1760 self.match(Parser.COMMA) - self.state = 1750 + self.state = 1761 self.scalarItem() - self.state = 1755 + self.state = 1766 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1756 + self.state = 1767 self.match(Parser.GRPAREN) pass else: @@ -15003,49 +15029,63 @@ def scalarTypeConstraint(self): self.exitRule() return localctx + class CompConstraintContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentType(self): - return self.getTypedRuleContext(Parser.ComponentTypeContext, 0) + return self.getTypedRuleContext(Parser.ComponentTypeContext,0) + def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext, 0) + return self.getTypedRuleContext(Parser.ComponentIDContext,0) + def multModifier(self): - return self.getTypedRuleContext(Parser.MultModifierContext, 0) + return self.getTypedRuleContext(Parser.MultModifierContext,0) + def getRuleIndex(self): return Parser.RULE_compConstraint - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterCompConstraint"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCompConstraint" ): listener.enterCompConstraint(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitCompConstraint"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCompConstraint" ): listener.exitCompConstraint(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitCompConstraint" ): + return visitor.visitCompConstraint(self) + else: + return visitor.visitChildren(self) + + + + def compConstraint(self): + localctx = Parser.CompConstraintContext(self, self._ctx, self.state) self.enterRule(localctx, 166, self.RULE_compConstraint) try: self.enterOuterAlt(localctx, 1) - self.state = 1760 + self.state = 1771 self.componentType() - self.state = 1763 + self.state = 1774 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.IDENTIFIER]: - self.state = 1761 + self.state = 1772 self.componentID() pass elif token in [Parser.OPTIONAL]: - self.state = 1762 + self.state = 1773 self.multModifier() pass else: @@ -15059,10 +15099,11 @@ def compConstraint(self): self.exitRule() return localctx + class MultModifierContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15078,34 +15119,45 @@ def MUL(self): def getRuleIndex(self): return Parser.RULE_multModifier - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterMultModifier"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMultModifier" ): listener.enterMultModifier(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitMultModifier"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMultModifier" ): listener.exitMultModifier(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitMultModifier" ): + return visitor.visitMultModifier(self) + else: + return visitor.visitChildren(self) + + + + def multModifier(self): + localctx = Parser.MultModifierContext(self, self._ctx, self.state) self.enterRule(localctx, 168, self.RULE_multModifier) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1765 + self.state = 1776 self.match(Parser.OPTIONAL) - self.state = 1767 + self.state = 1778 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == Parser.PLUS or _la == Parser.MUL: - self.state = 1766 + if _la==Parser.PLUS or _la==Parser.MUL: + self.state = 1777 _la = self._input.LA(1) - if not (_la == Parser.PLUS or _la == Parser.MUL): + if not(_la==Parser.PLUS or _la==Parser.MUL): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -15114,10 +15166,11 @@ def multModifier(self): self.exitRule() return localctx + class ValidationOutputContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15133,23 +15186,33 @@ def ALL(self): def getRuleIndex(self): return Parser.RULE_validationOutput - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterValidationOutput"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValidationOutput" ): listener.enterValidationOutput(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitValidationOutput"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValidationOutput" ): listener.exitValidationOutput(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitValidationOutput" ): + return visitor.visitValidationOutput(self) + else: + return visitor.visitChildren(self) + + + + def validationOutput(self): + localctx = Parser.ValidationOutputContext(self, self._ctx, self.state) self.enterRule(localctx, 170, self.RULE_validationOutput) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1769 + self.state = 1780 _la = self._input.LA(1) - if not (_la == Parser.ALL or _la == Parser.INVALID or _la == Parser.ALL_MEASURES): + if not(_la==Parser.ALL or _la==Parser.INVALID or _la==Parser.ALL_MEASURES): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -15162,10 +15225,11 @@ def validationOutput(self): self.exitRule() return localctx + class ValidationModeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15190,37 +15254,33 @@ def ALWAYS_ZERO(self): def getRuleIndex(self): return Parser.RULE_validationMode - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterValidationMode"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValidationMode" ): listener.enterValidationMode(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitValidationMode"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValidationMode" ): listener.exitValidationMode(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitValidationMode" ): + return visitor.visitValidationMode(self) + else: + return visitor.visitChildren(self) + + + + def validationMode(self): + localctx = Parser.ValidationModeContext(self, self._ctx, self.state) self.enterRule(localctx, 172, self.RULE_validationMode) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1771 + self.state = 1782 _la = self._input.LA(1) - if not ( - ((_la - 225) & ~0x3F) == 0 - and ( - (1 << (_la - 225)) - & ( - (1 << (Parser.NON_NULL - 225)) - | (1 << (Parser.NON_ZERO - 225)) - | (1 << (Parser.PARTIAL_NULL - 225)) - | (1 << (Parser.PARTIAL_ZERO - 225)) - | (1 << (Parser.ALWAYS_NULL - 225)) - | (1 << (Parser.ALWAYS_ZERO - 225)) - ) - ) - != 0 - ): + if not(((((_la - 225)) & ~0x3f) == 0 and ((1 << (_la - 225)) & ((1 << (Parser.NON_NULL - 225)) | (1 << (Parser.NON_ZERO - 225)) | (1 << (Parser.PARTIAL_NULL - 225)) | (1 << (Parser.PARTIAL_ZERO - 225)) | (1 << (Parser.ALWAYS_NULL - 225)) | (1 << (Parser.ALWAYS_ZERO - 225)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -15233,23 +15293,25 @@ def validationMode(self): self.exitRule() return localctx + class ConditionClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def CONDITION(self): return self.getToken(Parser.CONDITION, 0) - def componentID(self, i: int = None): + def componentID(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext, i) + return self.getTypedRuleContext(Parser.ComponentIDContext,i) + - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -15258,33 +15320,43 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_conditionClause - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterConditionClause"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConditionClause" ): listener.enterConditionClause(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitConditionClause"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConditionClause" ): listener.exitConditionClause(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitConditionClause" ): + return visitor.visitConditionClause(self) + else: + return visitor.visitChildren(self) + + + + def conditionClause(self): + localctx = Parser.ConditionClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 174, self.RULE_conditionClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1773 + self.state = 1784 self.match(Parser.CONDITION) - self.state = 1774 + self.state = 1785 self.componentID() - self.state = 1779 + self.state = 1790 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1775 + while _la==Parser.COMMA: + self.state = 1786 self.match(Parser.COMMA) - self.state = 1776 + self.state = 1787 self.componentID() - self.state = 1781 + self.state = 1792 self._errHandler.sync(self) _la = self._input.LA(1) @@ -15296,10 +15368,11 @@ def conditionClause(self): self.exitRule() return localctx + class InputModeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15312,23 +15385,33 @@ def DATASET_PRIORITY(self): def getRuleIndex(self): return Parser.RULE_inputMode - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterInputMode"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInputMode" ): listener.enterInputMode(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitInputMode"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInputMode" ): listener.exitInputMode(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInputMode" ): + return visitor.visitInputMode(self) + else: + return visitor.visitChildren(self) + + + + def inputMode(self): + localctx = Parser.InputModeContext(self, self._ctx, self.state) self.enterRule(localctx, 176, self.RULE_inputMode) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1782 + self.state = 1793 _la = self._input.LA(1) - if not (_la == Parser.DATASET or _la == Parser.DATASET_PRIORITY): + if not(_la==Parser.DATASET or _la==Parser.DATASET_PRIORITY): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -15341,10 +15424,11 @@ def inputMode(self): self.exitRule() return localctx + class ImbalanceExprContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15352,27 +15436,38 @@ def IMBALANCE(self): return self.getToken(Parser.IMBALANCE, 0) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) + def getRuleIndex(self): return Parser.RULE_imbalanceExpr - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterImbalanceExpr"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterImbalanceExpr" ): listener.enterImbalanceExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitImbalanceExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitImbalanceExpr" ): listener.exitImbalanceExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitImbalanceExpr" ): + return visitor.visitImbalanceExpr(self) + else: + return visitor.visitChildren(self) + + + + def imbalanceExpr(self): + localctx = Parser.ImbalanceExprContext(self, self._ctx, self.state) self.enterRule(localctx, 178, self.RULE_imbalanceExpr) try: self.enterOuterAlt(localctx, 1) - self.state = 1784 + self.state = 1795 self.match(Parser.IMBALANCE) - self.state = 1785 + self.state = 1796 self.expr(0) except RecognitionException as re: localctx.exception = re @@ -15382,10 +15477,11 @@ def imbalanceExpr(self): self.exitRule() return localctx + class InputModeHierarchyContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15401,23 +15497,33 @@ def RULE_PRIORITY(self): def getRuleIndex(self): return Parser.RULE_inputModeHierarchy - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterInputModeHierarchy"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInputModeHierarchy" ): listener.enterInputModeHierarchy(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitInputModeHierarchy"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInputModeHierarchy" ): listener.exitInputModeHierarchy(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInputModeHierarchy" ): + return visitor.visitInputModeHierarchy(self) + else: + return visitor.visitChildren(self) + + + + def inputModeHierarchy(self): + localctx = Parser.InputModeHierarchyContext(self, self._ctx, self.state) self.enterRule(localctx, 180, self.RULE_inputModeHierarchy) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1787 + self.state = 1798 _la = self._input.LA(1) - if not (_la == Parser.DATASET or _la == Parser.RULE or _la == Parser.RULE_PRIORITY): + if not(_la==Parser.DATASET or _la==Parser.RULE or _la==Parser.RULE_PRIORITY): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -15430,10 +15536,11 @@ def inputModeHierarchy(self): self.exitRule() return localctx + class OutputModeHierarchyContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15446,23 +15553,33 @@ def ALL(self): def getRuleIndex(self): return Parser.RULE_outputModeHierarchy - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterOutputModeHierarchy"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOutputModeHierarchy" ): listener.enterOutputModeHierarchy(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitOutputModeHierarchy"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOutputModeHierarchy" ): listener.exitOutputModeHierarchy(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOutputModeHierarchy" ): + return visitor.visitOutputModeHierarchy(self) + else: + return visitor.visitChildren(self) + + + + def outputModeHierarchy(self): + localctx = Parser.OutputModeHierarchyContext(self, self._ctx, self.state) self.enterRule(localctx, 182, self.RULE_outputModeHierarchy) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1789 + self.state = 1800 _la = self._input.LA(1) - if not (_la == Parser.ALL or _la == Parser.COMPUTED): + if not(_la==Parser.ALL or _la==Parser.COMPUTED): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -15475,10 +15592,11 @@ def outputModeHierarchy(self): self.exitRule() return localctx + class AliasContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15488,20 +15606,30 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_alias - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterAlias"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlias" ): listener.enterAlias(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitAlias"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlias" ): listener.exitAlias(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitAlias" ): + return visitor.visitAlias(self) + else: + return visitor.visitChildren(self) + + + + def alias(self): + localctx = Parser.AliasContext(self, self._ctx, self.state) self.enterRule(localctx, 184, self.RULE_alias) try: self.enterOuterAlt(localctx, 1) - self.state = 1791 + self.state = 1802 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -15511,10 +15639,11 @@ def alias(self): self.exitRule() return localctx + class VarIDContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15524,20 +15653,30 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_varID - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterVarID"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVarID" ): listener.enterVarID(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitVarID"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVarID" ): listener.exitVarID(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitVarID" ): + return visitor.visitVarID(self) + else: + return visitor.visitChildren(self) + + + + def varID(self): + localctx = Parser.VarIDContext(self, self._ctx, self.state) self.enterRule(localctx, 186, self.RULE_varID) try: self.enterOuterAlt(localctx, 1) - self.state = 1793 + self.state = 1804 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -15547,10 +15686,11 @@ def varID(self): self.exitRule() return localctx + class SimpleComponentIdContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15560,20 +15700,30 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_simpleComponentId - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterSimpleComponentId"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSimpleComponentId" ): listener.enterSimpleComponentId(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitSimpleComponentId"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSimpleComponentId" ): listener.exitSimpleComponentId(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSimpleComponentId" ): + return visitor.visitSimpleComponentId(self) + else: + return visitor.visitChildren(self) + + + + def simpleComponentId(self): + localctx = Parser.SimpleComponentIdContext(self, self._ctx, self.state) self.enterRule(localctx, 188, self.RULE_simpleComponentId) try: self.enterOuterAlt(localctx, 1) - self.state = 1795 + self.state = 1806 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -15583,14 +15733,15 @@ def simpleComponentId(self): self.exitRule() return localctx + class ComponentIDContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def IDENTIFIER(self, i: int = None): + def IDENTIFIER(self, i:int=None): if i is None: return self.getTokens(Parser.IDENTIFIER) else: @@ -15602,30 +15753,41 @@ def MEMBERSHIP(self): def getRuleIndex(self): return Parser.RULE_componentID - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterComponentID"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComponentID" ): listener.enterComponentID(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitComponentID"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComponentID" ): listener.exitComponentID(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitComponentID" ): + return visitor.visitComponentID(self) + else: + return visitor.visitChildren(self) + + + + def componentID(self): + localctx = Parser.ComponentIDContext(self, self._ctx, self.state) self.enterRule(localctx, 190, self.RULE_componentID) try: self.enterOuterAlt(localctx, 1) - self.state = 1797 + self.state = 1808 self.match(Parser.IDENTIFIER) - self.state = 1800 + self.state = 1811 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 190, self._ctx) + la_ = self._interp.adaptivePredict(self._input,191,self._ctx) if la_ == 1: - self.state = 1798 + self.state = 1809 self.match(Parser.MEMBERSHIP) - self.state = 1799 + self.state = 1810 self.match(Parser.IDENTIFIER) + except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -15634,26 +15796,28 @@ def componentID(self): self.exitRule() return localctx + class ListsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - def scalarItem(self, i: int = None): + def scalarItem(self, i:int=None): if i is None: return self.getTypedRuleContexts(Parser.ScalarItemContext) else: - return self.getTypedRuleContext(Parser.ScalarItemContext, i) + return self.getTypedRuleContext(Parser.ScalarItemContext,i) + def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - def COMMA(self, i: int = None): + def COMMA(self, i:int=None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -15662,37 +15826,47 @@ def COMMA(self, i: int = None): def getRuleIndex(self): return Parser.RULE_lists - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterLists"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLists" ): listener.enterLists(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitLists"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLists" ): listener.exitLists(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitLists" ): + return visitor.visitLists(self) + else: + return visitor.visitChildren(self) + + + + def lists(self): + localctx = Parser.ListsContext(self, self._ctx, self.state) self.enterRule(localctx, 192, self.RULE_lists) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1802 + self.state = 1813 self.match(Parser.GLPAREN) - self.state = 1803 + self.state = 1814 self.scalarItem() - self.state = 1808 + self.state = 1819 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == Parser.COMMA: - self.state = 1804 + while _la==Parser.COMMA: + self.state = 1815 self.match(Parser.COMMA) - self.state = 1805 + self.state = 1816 self.scalarItem() - self.state = 1810 + self.state = 1821 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1811 + self.state = 1822 self.match(Parser.GRPAREN) except RecognitionException as re: localctx.exception = re @@ -15702,10 +15876,11 @@ def lists(self): self.exitRule() return localctx + class ErCodeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15713,27 +15888,38 @@ def ERRORCODE(self): return self.getToken(Parser.ERRORCODE, 0) def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext, 0) + return self.getTypedRuleContext(Parser.ConstantContext,0) + def getRuleIndex(self): return Parser.RULE_erCode - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterErCode"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterErCode" ): listener.enterErCode(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitErCode"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitErCode" ): listener.exitErCode(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitErCode" ): + return visitor.visitErCode(self) + else: + return visitor.visitChildren(self) + + + + def erCode(self): + localctx = Parser.ErCodeContext(self, self._ctx, self.state) self.enterRule(localctx, 194, self.RULE_erCode) try: self.enterOuterAlt(localctx, 1) - self.state = 1813 + self.state = 1824 self.match(Parser.ERRORCODE) - self.state = 1814 + self.state = 1825 self.constant() except RecognitionException as re: localctx.exception = re @@ -15743,10 +15929,11 @@ def erCode(self): self.exitRule() return localctx + class ErLevelContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15754,27 +15941,38 @@ def ERRORLEVEL(self): return self.getToken(Parser.ERRORLEVEL, 0) def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext, 0) + return self.getTypedRuleContext(Parser.ConstantContext,0) + def getRuleIndex(self): return Parser.RULE_erLevel - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterErLevel"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterErLevel" ): listener.enterErLevel(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitErLevel"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitErLevel" ): listener.exitErLevel(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitErLevel" ): + return visitor.visitErLevel(self) + else: + return visitor.visitChildren(self) + + + + def erLevel(self): + localctx = Parser.ErLevelContext(self, self._ctx, self.state) self.enterRule(localctx, 196, self.RULE_erLevel) try: self.enterOuterAlt(localctx, 1) - self.state = 1816 + self.state = 1827 self.match(Parser.ERRORLEVEL) - self.state = 1817 + self.state = 1828 self.constant() except RecognitionException as re: localctx.exception = re @@ -15784,10 +15982,11 @@ def erLevel(self): self.exitRule() return localctx + class ComparisonOperandContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15812,37 +16011,33 @@ def NEQ(self): def getRuleIndex(self): return Parser.RULE_comparisonOperand - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterComparisonOperand"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComparisonOperand" ): listener.enterComparisonOperand(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitComparisonOperand"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComparisonOperand" ): listener.exitComparisonOperand(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitComparisonOperand" ): + return visitor.visitComparisonOperand(self) + else: + return visitor.visitChildren(self) + + + + def comparisonOperand(self): + localctx = Parser.ComparisonOperandContext(self, self._ctx, self.state) self.enterRule(localctx, 198, self.RULE_comparisonOperand) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1819 + self.state = 1830 _la = self._input.LA(1) - if not ( - ((_la) & ~0x3F) == 0 - and ( - (1 << _la) - & ( - (1 << Parser.EQ) - | (1 << Parser.LT) - | (1 << Parser.MT) - | (1 << Parser.ME) - | (1 << Parser.NEQ) - | (1 << Parser.LE) - ) - ) - != 0 - ): + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.EQ) | (1 << Parser.LT) | (1 << Parser.MT) | (1 << Parser.ME) | (1 << Parser.NEQ) | (1 << Parser.LE))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -15855,15 +16050,17 @@ def comparisonOperand(self): self.exitRule() return localctx + class OptionalExprContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def expr(self): - return self.getTypedRuleContext(Parser.ExprContext, 0) + return self.getTypedRuleContext(Parser.ExprContext,0) + def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) @@ -15871,114 +16068,39 @@ def OPTIONAL(self): def getRuleIndex(self): return Parser.RULE_optionalExpr - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterOptionalExpr"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOptionalExpr" ): listener.enterOptionalExpr(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitOptionalExpr"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOptionalExpr" ): listener.exitOptionalExpr(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOptionalExpr" ): + return visitor.visitOptionalExpr(self) + else: + return visitor.visitChildren(self) + + + + def optionalExpr(self): + localctx = Parser.OptionalExprContext(self, self._ctx, self.state) self.enterRule(localctx, 200, self.RULE_optionalExpr) try: - self.state = 1823 + self.state = 1834 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.LPAREN, - Parser.PLUS, - Parser.MINUS, - Parser.EVAL, - Parser.IF, - Parser.CASE, - Parser.CURRENT_DATE, - Parser.DATEDIFF, - Parser.DATEADD, - Parser.YEAR_OP, - Parser.MONTH_OP, - Parser.DAYOFMONTH, - Parser.DAYOFYEAR, - Parser.DAYTOYEAR, - Parser.DAYTOMONTH, - Parser.YEARTODAY, - Parser.MONTHTODAY, - Parser.NOT, - Parser.BETWEEN, - Parser.NULL_CONSTANT, - Parser.ISNULL, - Parser.UNION, - Parser.SYMDIFF, - Parser.INTERSECT, - Parser.RANDOM, - Parser.CHECK, - Parser.EXISTS_IN, - Parser.MIN, - Parser.MAX, - Parser.ABS, - Parser.LN, - Parser.LOG, - Parser.TRUNC, - Parser.ROUND, - Parser.POWER, - Parser.MOD, - Parser.LEN, - Parser.TRIM, - Parser.UCASE, - Parser.LCASE, - Parser.SUBSTR, - Parser.SUM, - Parser.AVG, - Parser.MEDIAN, - Parser.COUNT, - Parser.EXP, - Parser.CHARSET_MATCH, - Parser.NVL, - Parser.HIERARCHY, - Parser.LTRIM, - Parser.RTRIM, - Parser.INSTR, - Parser.REPLACE, - Parser.CEIL, - Parser.FLOOR, - Parser.SQRT, - Parser.SETDIFF, - Parser.STDDEV_POP, - Parser.STDDEV_SAMP, - Parser.VAR_POP, - Parser.VAR_SAMP, - Parser.FIRST_VALUE, - Parser.LAST_VALUE, - Parser.LAG, - Parser.LEAD, - Parser.RATIO_TO_REPORT, - Parser.FILL_TIME_SERIES, - Parser.FLOW_TO_STOCK, - Parser.STOCK_TO_FLOW, - Parser.TIMESHIFT, - Parser.INNER_JOIN, - Parser.LEFT_JOIN, - Parser.CROSS_JOIN, - Parser.FULL_JOIN, - Parser.PERIOD_INDICATOR, - Parser.TIME_AGG, - Parser.CAST, - Parser.CHECK_DATAPOINT, - Parser.CHECK_HIERARCHY, - Parser.INTEGER_CONSTANT, - Parser.NUMBER_CONSTANT, - Parser.BOOLEAN_CONSTANT, - Parser.STRING_CONSTANT, - Parser.IDENTIFIER, - ]: + if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF, Parser.CASE, Parser.CURRENT_DATE, Parser.DATEDIFF, Parser.DATEADD, Parser.YEAR_OP, Parser.MONTH_OP, Parser.DAYOFMONTH, Parser.DAYOFYEAR, Parser.DAYTOYEAR, Parser.DAYTOMONTH, Parser.YEARTODAY, Parser.MONTHTODAY, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT, Parser.ISNULL, Parser.UNION, Parser.SYMDIFF, Parser.INTERSECT, Parser.RANDOM, Parser.CHECK, Parser.EXISTS_IN, Parser.MIN, Parser.MAX, Parser.ABS, Parser.LN, Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER, Parser.MOD, Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.SUBSTR, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.EXP, Parser.CHARSET_MATCH, Parser.NVL, Parser.HIERARCHY, Parser.LTRIM, Parser.RTRIM, Parser.INSTR, Parser.REPLACE, Parser.CEIL, Parser.FLOOR, Parser.SQRT, Parser.SETDIFF, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT, Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW, Parser.TIMESHIFT, Parser.INNER_JOIN, Parser.LEFT_JOIN, Parser.CROSS_JOIN, Parser.FULL_JOIN, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST, Parser.CHECK_DATAPOINT, Parser.CHECK_HIERARCHY, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT, Parser.IDENTIFIER]: self.enterOuterAlt(localctx, 1) - self.state = 1821 + self.state = 1832 self.expr(0) pass elif token in [Parser.OPTIONAL]: self.enterOuterAlt(localctx, 2) - self.state = 1822 + self.state = 1833 self.match(Parser.OPTIONAL) pass else: @@ -15992,15 +16114,17 @@ def optionalExpr(self): self.exitRule() return localctx + class OptionalExprComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext, 0) + return self.getTypedRuleContext(Parser.ExprComponentContext,0) + def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) @@ -16008,102 +16132,39 @@ def OPTIONAL(self): def getRuleIndex(self): return Parser.RULE_optionalExprComponent - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterOptionalExprComponent"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOptionalExprComponent" ): listener.enterOptionalExprComponent(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitOptionalExprComponent"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOptionalExprComponent" ): listener.exitOptionalExprComponent(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOptionalExprComponent" ): + return visitor.visitOptionalExprComponent(self) + else: + return visitor.visitChildren(self) + + + + def optionalExprComponent(self): + localctx = Parser.OptionalExprComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 202, self.RULE_optionalExprComponent) try: - self.state = 1827 + self.state = 1838 self._errHandler.sync(self) token = self._input.LA(1) - if token in [ - Parser.LPAREN, - Parser.PLUS, - Parser.MINUS, - Parser.EVAL, - Parser.IF, - Parser.CASE, - Parser.CURRENT_DATE, - Parser.DATEDIFF, - Parser.DATEADD, - Parser.YEAR_OP, - Parser.MONTH_OP, - Parser.DAYOFMONTH, - Parser.DAYOFYEAR, - Parser.DAYTOYEAR, - Parser.DAYTOMONTH, - Parser.YEARTODAY, - Parser.MONTHTODAY, - Parser.NOT, - Parser.BETWEEN, - Parser.NULL_CONSTANT, - Parser.ISNULL, - Parser.RANDOM, - Parser.RANK, - Parser.MIN, - Parser.MAX, - Parser.ABS, - Parser.LN, - Parser.LOG, - Parser.TRUNC, - Parser.ROUND, - Parser.POWER, - Parser.MOD, - Parser.LEN, - Parser.TRIM, - Parser.UCASE, - Parser.LCASE, - Parser.SUBSTR, - Parser.SUM, - Parser.AVG, - Parser.MEDIAN, - Parser.COUNT, - Parser.EXP, - Parser.CHARSET_MATCH, - Parser.NVL, - Parser.LTRIM, - Parser.RTRIM, - Parser.INSTR, - Parser.REPLACE, - Parser.CEIL, - Parser.FLOOR, - Parser.SQRT, - Parser.STDDEV_POP, - Parser.STDDEV_SAMP, - Parser.VAR_POP, - Parser.VAR_SAMP, - Parser.FIRST_VALUE, - Parser.LAST_VALUE, - Parser.LAG, - Parser.LEAD, - Parser.RATIO_TO_REPORT, - Parser.FILL_TIME_SERIES, - Parser.FLOW_TO_STOCK, - Parser.STOCK_TO_FLOW, - Parser.TIMESHIFT, - Parser.PERIOD_INDICATOR, - Parser.TIME_AGG, - Parser.CAST, - Parser.INTEGER_CONSTANT, - Parser.NUMBER_CONSTANT, - Parser.BOOLEAN_CONSTANT, - Parser.STRING_CONSTANT, - Parser.IDENTIFIER, - ]: + if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF, Parser.CASE, Parser.CURRENT_DATE, Parser.DATEDIFF, Parser.DATEADD, Parser.YEAR_OP, Parser.MONTH_OP, Parser.DAYOFMONTH, Parser.DAYOFYEAR, Parser.DAYTOYEAR, Parser.DAYTOMONTH, Parser.YEARTODAY, Parser.MONTHTODAY, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT, Parser.ISNULL, Parser.RANDOM, Parser.RANK, Parser.MIN, Parser.MAX, Parser.ABS, Parser.LN, Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER, Parser.MOD, Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.SUBSTR, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.EXP, Parser.CHARSET_MATCH, Parser.NVL, Parser.LTRIM, Parser.RTRIM, Parser.INSTR, Parser.REPLACE, Parser.CEIL, Parser.FLOOR, Parser.SQRT, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT, Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW, Parser.TIMESHIFT, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT, Parser.IDENTIFIER]: self.enterOuterAlt(localctx, 1) - self.state = 1825 + self.state = 1836 self.exprComponent(0) pass elif token in [Parser.OPTIONAL]: self.enterOuterAlt(localctx, 2) - self.state = 1826 + self.state = 1837 self.match(Parser.OPTIONAL) pass else: @@ -16117,10 +16178,11 @@ def optionalExprComponent(self): self.exitRule() return localctx + class ComponentRoleContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16137,49 +16199,60 @@ def ATTRIBUTE(self): return self.getToken(Parser.ATTRIBUTE, 0) def viralAttribute(self): - return self.getTypedRuleContext(Parser.ViralAttributeContext, 0) + return self.getTypedRuleContext(Parser.ViralAttributeContext,0) + def getRuleIndex(self): return Parser.RULE_componentRole - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterComponentRole"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComponentRole" ): listener.enterComponentRole(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitComponentRole"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComponentRole" ): listener.exitComponentRole(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitComponentRole" ): + return visitor.visitComponentRole(self) + else: + return visitor.visitChildren(self) + + + + def componentRole(self): + localctx = Parser.ComponentRoleContext(self, self._ctx, self.state) self.enterRule(localctx, 204, self.RULE_componentRole) try: - self.state = 1834 + self.state = 1845 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.MEASURE]: self.enterOuterAlt(localctx, 1) - self.state = 1829 + self.state = 1840 self.match(Parser.MEASURE) pass elif token in [Parser.COMPONENT]: self.enterOuterAlt(localctx, 2) - self.state = 1830 + self.state = 1841 self.match(Parser.COMPONENT) pass elif token in [Parser.DIMENSION]: self.enterOuterAlt(localctx, 3) - self.state = 1831 + self.state = 1842 self.match(Parser.DIMENSION) pass elif token in [Parser.ATTRIBUTE]: self.enterOuterAlt(localctx, 4) - self.state = 1832 + self.state = 1843 self.match(Parser.ATTRIBUTE) pass elif token in [Parser.VIRAL]: self.enterOuterAlt(localctx, 5) - self.state = 1833 + self.state = 1844 self.viralAttribute() pass else: @@ -16193,10 +16266,11 @@ def componentRole(self): self.exitRule() return localctx + class ViralAttributeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16209,22 +16283,32 @@ def ATTRIBUTE(self): def getRuleIndex(self): return Parser.RULE_viralAttribute - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterViralAttribute"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterViralAttribute" ): listener.enterViralAttribute(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitViralAttribute"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitViralAttribute" ): listener.exitViralAttribute(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitViralAttribute" ): + return visitor.visitViralAttribute(self) + else: + return visitor.visitChildren(self) + + + + def viralAttribute(self): + localctx = Parser.ViralAttributeContext(self, self._ctx, self.state) self.enterRule(localctx, 206, self.RULE_viralAttribute) try: self.enterOuterAlt(localctx, 1) - self.state = 1836 + self.state = 1847 self.match(Parser.VIRAL) - self.state = 1837 + self.state = 1848 self.match(Parser.ATTRIBUTE) except RecognitionException as re: localctx.exception = re @@ -16234,10 +16318,11 @@ def viralAttribute(self): self.exitRule() return localctx + class ValueDomainIDContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16247,20 +16332,30 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_valueDomainID - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterValueDomainID"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValueDomainID" ): listener.enterValueDomainID(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitValueDomainID"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValueDomainID" ): listener.exitValueDomainID(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitValueDomainID" ): + return visitor.visitValueDomainID(self) + else: + return visitor.visitChildren(self) + + + + def valueDomainID(self): + localctx = Parser.ValueDomainIDContext(self, self._ctx, self.state) self.enterRule(localctx, 208, self.RULE_valueDomainID) try: self.enterOuterAlt(localctx, 1) - self.state = 1839 + self.state = 1850 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -16270,10 +16365,11 @@ def valueDomainID(self): self.exitRule() return localctx + class OperatorIDContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16283,20 +16379,30 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_operatorID - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterOperatorID"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOperatorID" ): listener.enterOperatorID(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitOperatorID"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOperatorID" ): listener.exitOperatorID(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOperatorID" ): + return visitor.visitOperatorID(self) + else: + return visitor.visitChildren(self) + + + + def operatorID(self): + localctx = Parser.OperatorIDContext(self, self._ctx, self.state) self.enterRule(localctx, 210, self.RULE_operatorID) try: self.enterOuterAlt(localctx, 1) - self.state = 1841 + self.state = 1852 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -16306,10 +16412,11 @@ def operatorID(self): self.exitRule() return localctx + class RoutineNameContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16319,20 +16426,30 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_routineName - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRoutineName"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRoutineName" ): listener.enterRoutineName(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRoutineName"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRoutineName" ): listener.exitRoutineName(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRoutineName" ): + return visitor.visitRoutineName(self) + else: + return visitor.visitChildren(self) + + + + def routineName(self): + localctx = Parser.RoutineNameContext(self, self._ctx, self.state) self.enterRule(localctx, 212, self.RULE_routineName) try: self.enterOuterAlt(localctx, 1) - self.state = 1843 + self.state = 1854 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -16342,10 +16459,11 @@ def routineName(self): self.exitRule() return localctx + class ConstantContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16367,38 +16485,33 @@ def NULL_CONSTANT(self): def getRuleIndex(self): return Parser.RULE_constant - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterConstant"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConstant" ): listener.enterConstant(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitConstant"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConstant" ): listener.exitConstant(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitConstant" ): + return visitor.visitConstant(self) + else: + return visitor.visitChildren(self) + + + + def constant(self): + localctx = Parser.ConstantContext(self, self._ctx, self.state) self.enterRule(localctx, 214, self.RULE_constant) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1845 + self.state = 1856 _la = self._input.LA(1) - if not ( - _la == Parser.NULL_CONSTANT - or ( - ((_la - 241) & ~0x3F) == 0 - and ( - (1 << (_la - 241)) - & ( - (1 << (Parser.INTEGER_CONSTANT - 241)) - | (1 << (Parser.NUMBER_CONSTANT - 241)) - | (1 << (Parser.BOOLEAN_CONSTANT - 241)) - | (1 << (Parser.STRING_CONSTANT - 241)) - ) - ) - != 0 - ) - ): + if not(_la==Parser.NULL_CONSTANT or ((((_la - 241)) & ~0x3f) == 0 and ((1 << (_la - 241)) & ((1 << (Parser.INTEGER_CONSTANT - 241)) | (1 << (Parser.NUMBER_CONSTANT - 241)) | (1 << (Parser.BOOLEAN_CONSTANT - 241)) | (1 << (Parser.STRING_CONSTANT - 241)))) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -16411,10 +16524,11 @@ def constant(self): self.exitRule() return localctx + class BasicScalarTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16448,42 +16562,33 @@ def SCALAR(self): def getRuleIndex(self): return Parser.RULE_basicScalarType - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterBasicScalarType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBasicScalarType" ): listener.enterBasicScalarType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitBasicScalarType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBasicScalarType" ): listener.exitBasicScalarType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBasicScalarType" ): + return visitor.visitBasicScalarType(self) + else: + return visitor.visitChildren(self) + + + + def basicScalarType(self): + localctx = Parser.BasicScalarTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 216, self.RULE_basicScalarType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1847 + self.state = 1858 _la = self._input.LA(1) - if not ( - ( - ((_la - 168) & ~0x3F) == 0 - and ( - (1 << (_la - 168)) - & ( - (1 << (Parser.BOOLEAN - 168)) - | (1 << (Parser.DATE - 168)) - | (1 << (Parser.TIME_PERIOD - 168)) - | (1 << (Parser.NUMBER - 168)) - | (1 << (Parser.STRING - 168)) - | (1 << (Parser.TIME - 168)) - | (1 << (Parser.INTEGER - 168)) - | (1 << (Parser.DURATION - 168)) - ) - ) - != 0 - ) - or _la == Parser.SCALAR - ): + if not(((((_la - 168)) & ~0x3f) == 0 and ((1 << (_la - 168)) & ((1 << (Parser.BOOLEAN - 168)) | (1 << (Parser.DATE - 168)) | (1 << (Parser.TIME_PERIOD - 168)) | (1 << (Parser.NUMBER - 168)) | (1 << (Parser.STRING - 168)) | (1 << (Parser.TIME - 168)) | (1 << (Parser.INTEGER - 168)) | (1 << (Parser.DURATION - 168)))) != 0) or _la==Parser.SCALAR): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -16496,10 +16601,11 @@ def basicScalarType(self): self.exitRule() return localctx + class RetainTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): + def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16512,23 +16618,33 @@ def ALL(self): def getRuleIndex(self): return Parser.RULE_retainType - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterRetainType"): + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRetainType" ): listener.enterRetainType(self) - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitRetainType"): + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRetainType" ): listener.exitRetainType(self) + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitRetainType" ): + return visitor.visitRetainType(self) + else: + return visitor.visitChildren(self) + + + + def retainType(self): + localctx = Parser.RetainTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 218, self.RULE_retainType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1849 + self.state = 1860 _la = self._input.LA(1) - if not (_la == Parser.ALL or _la == Parser.BOOLEAN_CONSTANT): + if not(_la==Parser.ALL or _la==Parser.BOOLEAN_CONSTANT): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -16541,7 +16657,9 @@ def retainType(self): self.exitRule() return localctx - def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int): + + + def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): if self._predicates == None: self._predicates = dict() self._predicates[2] = self.expr_sempred @@ -16552,46 +16670,64 @@ def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int): else: return pred(localctx, predIndex) - def expr_sempred(self, localctx: ExprContext, predIndex: int): - if predIndex == 0: - return self.precpred(self._ctx, 10) + def expr_sempred(self, localctx:ExprContext, predIndex:int): + if predIndex == 0: + return self.precpred(self._ctx, 10) + + + if predIndex == 1: + return self.precpred(self._ctx, 9) + + + if predIndex == 2: + return self.precpred(self._ctx, 8) + + + if predIndex == 3: + return self.precpred(self._ctx, 6) + + + if predIndex == 4: + return self.precpred(self._ctx, 5) + - if predIndex == 1: - return self.precpred(self._ctx, 9) + if predIndex == 5: + return self.precpred(self._ctx, 13) + - if predIndex == 2: - return self.precpred(self._ctx, 8) + if predIndex == 6: + return self.precpred(self._ctx, 12) + - if predIndex == 3: - return self.precpred(self._ctx, 6) + if predIndex == 7: + return self.precpred(self._ctx, 7) + - if predIndex == 4: - return self.precpred(self._ctx, 5) + def exprComponent_sempred(self, localctx:ExprComponentContext, predIndex:int): + if predIndex == 8: + return self.precpred(self._ctx, 10) + - if predIndex == 5: - return self.precpred(self._ctx, 13) + if predIndex == 9: + return self.precpred(self._ctx, 9) + - if predIndex == 6: - return self.precpred(self._ctx, 12) + if predIndex == 10: + return self.precpred(self._ctx, 8) + - if predIndex == 7: - return self.precpred(self._ctx, 7) + if predIndex == 11: + return self.precpred(self._ctx, 6) + - def exprComponent_sempred(self, localctx: ExprComponentContext, predIndex: int): - if predIndex == 8: - return self.precpred(self._ctx, 10) + if predIndex == 12: + return self.precpred(self._ctx, 5) + - if predIndex == 9: - return self.precpred(self._ctx, 9) + if predIndex == 13: + return self.precpred(self._ctx, 7) + - if predIndex == 10: - return self.precpred(self._ctx, 8) - if predIndex == 11: - return self.precpred(self._ctx, 6) - if predIndex == 12: - return self.precpred(self._ctx, 5) - if predIndex == 13: - return self.precpred(self._ctx, 7) From aaf1612c5d391c1d4737db17e9588009eb1cc8ff Mon Sep 17 00:00:00 2001 From: Mateo Date: Thu, 26 Feb 2026 12:51:13 +0100 Subject: [PATCH 03/10] Updated AST Constructor to handle Scalar (as VarID) casting insade sub op --- .../AST/ASTConstructorModules/Expr.py | 6 +++- .../AST/ASTConstructorModules/Terminals.py | 36 +++++++++++++++++++ 2 files changed, 41 insertions(+), 1 deletion(-) diff --git a/src/vtlengine/AST/ASTConstructorModules/Expr.py b/src/vtlengine/AST/ASTConstructorModules/Expr.py index 72bacaae9..b730017bf 100644 --- a/src/vtlengine/AST/ASTConstructorModules/Expr.py +++ b/src/vtlengine/AST/ASTConstructorModules/Expr.py @@ -1884,7 +1884,11 @@ def visitSubspaceClauseItem(self, ctx: Parser.SubspaceClauseItemContext): left_node = Terminals().visitVarID(ctx_list[0]) op_node = ctx_list[1].getSymbol().text - if isinstance(ctx_list[2], Parser.ScalarItemContext): + if isinstance(ctx_list[2], Parser.ScalarWithCastContext): + right_node = Terminals().visitScalarWithCast(ctx_list[2]) + elif isinstance(ctx_list[2], Parser.ScalarVarWithCastContext): + right_node = Terminals().visitScalarVarWithCast(ctx_list[2]) + elif isinstance(ctx_list[2], Parser.ScalarItemContext): right_node = Terminals().visitScalarItem(ctx_list[2]) else: right_node = Terminals().visitVarID(ctx_list[2]) diff --git a/src/vtlengine/AST/ASTConstructorModules/Terminals.py b/src/vtlengine/AST/ASTConstructorModules/Terminals.py index 712f0acd4..55d4878d6 100644 --- a/src/vtlengine/AST/ASTConstructorModules/Terminals.py +++ b/src/vtlengine/AST/ASTConstructorModules/Terminals.py @@ -512,6 +512,8 @@ def visitScalarItem(self, ctx: Parser.ScalarItemContext): return self.visitConstant(c) elif isinstance(c, Parser.ScalarWithCastContext): return self.visitScalarWithCast(c) + elif isinstance(c, Parser.ScalarVarWithCastContext): + return self.visitScalarVarWithCast(c) else: raise NotImplementedError @@ -549,6 +551,40 @@ def visitScalarWithCast(self, ctx: Parser.ScalarWithCastContext): # AST_ASTCONSTRUCTOR.14 raise NotImplementedError + def visitScalarVarWithCast(self, ctx: Parser.ScalarVarWithCastContext): + """ + | CAST LPAREN varID COMMA (basicScalarType) (COMMA STRING_CONSTANT)? RPAREN #scalarVarWithCast + """ # noqa E501 + ctx_list = list(ctx.getChildren()) + c = ctx_list[0] + + token = c.getSymbol() + + op = token.text + var_node = self.visitVarID(ctx_list[2]) + basic_scalar_type = [self.visitBasicScalarType(ctx_list[4])] + + param_node = ( + [ + ParamConstant( + type_="PARAM_CAST", value=ctx_list[6], **extract_token_info(ctx_list[6]) + ) + ] + if len(ctx_list) > 6 + else [] + ) + + if len(basic_scalar_type) == 1: + children_nodes = [var_node, basic_scalar_type[0]] + + return ParamOp( + op=op, children=children_nodes, params=param_node, **extract_token_info(ctx) + ) + + else: + # AST_ASTCONSTRUCTOR.14 + raise NotImplementedError + def visitScalarSetType(self, ctx: Parser.ScalarSetTypeContext): """ scalarSetType: SET ('<' scalarType '>')? ; From 9a4f6e4eeb24bb5a2cfc05eba0b29913c3205baa Mon Sep 17 00:00:00 2001 From: Mateo Date: Thu, 26 Feb 2026 12:51:31 +0100 Subject: [PATCH 04/10] Add visit method for scalarVarWithCast in VtlVisitor --- src/vtlengine/AST/VtlVisitor.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/vtlengine/AST/VtlVisitor.py b/src/vtlengine/AST/VtlVisitor.py index b937e4bfc..f08bc7f83 100644 --- a/src/vtlengine/AST/VtlVisitor.py +++ b/src/vtlengine/AST/VtlVisitor.py @@ -532,6 +532,10 @@ def visitSimpleScalar(self, ctx: Parser.SimpleScalarContext): def visitScalarWithCast(self, ctx: Parser.ScalarWithCastContext): return self.visitChildren(ctx) + # Visit a parse tree produced by Parser#scalarVarWithCast. + def visitScalarVarWithCast(self, ctx: Parser.ScalarVarWithCastContext): + return self.visitChildren(ctx) + # Visit a parse tree produced by Parser#joinClauseWithoutUsing. def visitJoinClauseWithoutUsing(self, ctx: Parser.JoinClauseWithoutUsingContext): return self.visitChildren(ctx) From b8af4c6723c18637c59a514a86920552e61ee1b3 Mon Sep 17 00:00:00 2001 From: Mateo Date: Thu, 26 Feb 2026 13:04:27 +0100 Subject: [PATCH 05/10] Added related test --- .../data/DataStructure/input/GH_539_1-1.json | 27 +++++++++++++++++++ .../data/DataStructure/input/GH_539_1-2.json | 8 ++++++ .../data/DataStructure/output/GH_539_1-1.json | 21 +++++++++++++++ tests/Cast/data/Dataset/input/GH_539_1-1.csv | 5 ++++ tests/Cast/data/Dataset/output/GH_539_1-1.csv | 3 +++ tests/Cast/data/vtl/GH_539_1.vtl | 1 + tests/Cast/test_cast.py | 13 ++++++++- 7 files changed, 77 insertions(+), 1 deletion(-) create mode 100644 tests/Cast/data/DataStructure/input/GH_539_1-1.json create mode 100644 tests/Cast/data/DataStructure/input/GH_539_1-2.json create mode 100644 tests/Cast/data/DataStructure/output/GH_539_1-1.json create mode 100644 tests/Cast/data/Dataset/input/GH_539_1-1.csv create mode 100644 tests/Cast/data/Dataset/output/GH_539_1-1.csv create mode 100644 tests/Cast/data/vtl/GH_539_1.vtl diff --git a/tests/Cast/data/DataStructure/input/GH_539_1-1.json b/tests/Cast/data/DataStructure/input/GH_539_1-1.json new file mode 100644 index 000000000..31bd21eeb --- /dev/null +++ b/tests/Cast/data/DataStructure/input/GH_539_1-1.json @@ -0,0 +1,27 @@ +{ + "datasets": [ + { + "name": "DS_1", + "DataStructure": [ + { + "name": "Id_1", + "type": "Integer", + "nullable": false, + "role": "Identifier" + }, + { + "name": "Id_2", + "type": "String", + "nullable": false, + "role": "Identifier" + }, + { + "name": "Me_1", + "type": "Integer", + "nullable": true, + "role": "Measure" + } + ] + } + ] +} \ No newline at end of file diff --git a/tests/Cast/data/DataStructure/input/GH_539_1-2.json b/tests/Cast/data/DataStructure/input/GH_539_1-2.json new file mode 100644 index 000000000..85874f742 --- /dev/null +++ b/tests/Cast/data/DataStructure/input/GH_539_1-2.json @@ -0,0 +1,8 @@ +{ + "scalars": [ + { + "name": "sc_1", + "type": "Integer" + } + ] +} \ No newline at end of file diff --git a/tests/Cast/data/DataStructure/output/GH_539_1-1.json b/tests/Cast/data/DataStructure/output/GH_539_1-1.json new file mode 100644 index 000000000..56672d9c3 --- /dev/null +++ b/tests/Cast/data/DataStructure/output/GH_539_1-1.json @@ -0,0 +1,21 @@ +{ + "datasets": [ + { + "name": "DS_r", + "DataStructure": [ + { + "name": "Id_1", + "type": "Integer", + "nullable": false, + "role": "Identifier" + }, + { + "name": "Me_1", + "type": "Integer", + "nullable": true, + "role": "Measure" + } + ] + } + ] +} \ No newline at end of file diff --git a/tests/Cast/data/Dataset/input/GH_539_1-1.csv b/tests/Cast/data/Dataset/input/GH_539_1-1.csv new file mode 100644 index 000000000..53e89f364 --- /dev/null +++ b/tests/Cast/data/Dataset/input/GH_539_1-1.csv @@ -0,0 +1,5 @@ +Id_1,Id_2,Me_1 +1,1,10 +2,1,20 +1,2,30 +2,2,40 \ No newline at end of file diff --git a/tests/Cast/data/Dataset/output/GH_539_1-1.csv b/tests/Cast/data/Dataset/output/GH_539_1-1.csv new file mode 100644 index 000000000..7677d02e0 --- /dev/null +++ b/tests/Cast/data/Dataset/output/GH_539_1-1.csv @@ -0,0 +1,3 @@ +Id_1,Me_1 +1,10 +2,20 \ No newline at end of file diff --git a/tests/Cast/data/vtl/GH_539_1.vtl b/tests/Cast/data/vtl/GH_539_1.vtl new file mode 100644 index 000000000..579153664 --- /dev/null +++ b/tests/Cast/data/vtl/GH_539_1.vtl @@ -0,0 +1 @@ +DS_r <- DS_1[sub Id_2 = cast(sc_1, string)]; \ No newline at end of file diff --git a/tests/Cast/test_cast.py b/tests/Cast/test_cast.py index 205249ba4..98a44c28e 100644 --- a/tests/Cast/test_cast.py +++ b/tests/Cast/test_cast.py @@ -65,10 +65,21 @@ def test_GH_537_1(self): """ code = "GH_537_1" number_inputs = 1 - reference_names = ["1"] + reference_names = ["1", "2"] self.BaseTest(code, number_inputs, references_names=reference_names) + def test_GH_539_1(self): + """ + Solves bug report in github issue #539: sub fails whith scalar as VarID casting + """ + code = "GH_539_1" + number_inputs = 2 + reference_names = ["1"] + scalars = {"sc_1": 1} + + self.BaseTest(code, number_inputs, references_names=reference_names, scalars=scalars) + # =========================================================================== # Comprehensive explicit cast tests (VTL 2.2) - Without mask From cbbfdeeaf0cec2a820314f06fcacf7d26de70e44 Mon Sep 17 00:00:00 2001 From: Mateo Date: Thu, 26 Feb 2026 13:17:49 +0100 Subject: [PATCH 06/10] Add semantic error for invalid sub comparison between components --- src/vtlengine/Exceptions/messages.py | 6 ++++++ src/vtlengine/Operators/Clause.py | 7 +++++++ 2 files changed, 13 insertions(+) diff --git a/src/vtlengine/Exceptions/messages.py b/src/vtlengine/Exceptions/messages.py index 573759b4d..5c06c3be1 100644 --- a/src/vtlengine/Exceptions/messages.py +++ b/src/vtlengine/Exceptions/messages.py @@ -258,6 +258,12 @@ "message": "Component {comp_name} not found in Dataset {dataset_name}.", "description": "Occurs when a referenced component is missing from the Dataset.", }, + "1-1-1-11": { + "message": "At op {op}: Sub comparison is not allowed between components. " + "Please check sub comparison in Dataset {dataset_name} is between a Component and a " + "Scalar/Constant.", + "description": "Occurs when a sub operation attempts to compare components.", + }, "1-1-1-13": { "message": "At op {op}: Component {comp_name} role must be '{role_1}', found '{role_2}'.", "description": "Raised when a Dataset component has an unexpected role for the operation.", diff --git a/src/vtlengine/Operators/Clause.py b/src/vtlengine/Operators/Clause.py index 6e56bf0cb..319615b25 100644 --- a/src/vtlengine/Operators/Clause.py +++ b/src/vtlengine/Operators/Clause.py @@ -1,3 +1,4 @@ +import re from copy import copy from typing import List, Type, Union @@ -318,6 +319,12 @@ def validate(cls, operands: List[DataComponent], dataset: Dataset) -> Dataset: raise SemanticError("1-2-10", op=cls.op) for operand in operands: if operand.name not in dataset.components: + if re.match(r"__VDC_\d+__", operand.name): + raise SemanticError( + "1-1-1-11", + op=cls.op, + dataset_name=dataset_name, + ) raise SemanticError( "1-1-1-10", op=cls.op, From a992d0f0ec2b6d4ce263e453a5ca4c3b4907f521 Mon Sep 17 00:00:00 2001 From: Mateo Date: Thu, 26 Feb 2026 13:18:11 +0100 Subject: [PATCH 07/10] Added related test --- .../data/DataStructure/input/GH_539_2-1.json | 27 +++++++++++++++++++ tests/Cast/data/vtl/GH_539_2.vtl | 1 + tests/Cast/test_cast.py | 10 +++++++ 3 files changed, 38 insertions(+) create mode 100644 tests/Cast/data/DataStructure/input/GH_539_2-1.json create mode 100644 tests/Cast/data/vtl/GH_539_2.vtl diff --git a/tests/Cast/data/DataStructure/input/GH_539_2-1.json b/tests/Cast/data/DataStructure/input/GH_539_2-1.json new file mode 100644 index 000000000..31bd21eeb --- /dev/null +++ b/tests/Cast/data/DataStructure/input/GH_539_2-1.json @@ -0,0 +1,27 @@ +{ + "datasets": [ + { + "name": "DS_1", + "DataStructure": [ + { + "name": "Id_1", + "type": "Integer", + "nullable": false, + "role": "Identifier" + }, + { + "name": "Id_2", + "type": "String", + "nullable": false, + "role": "Identifier" + }, + { + "name": "Me_1", + "type": "Integer", + "nullable": true, + "role": "Measure" + } + ] + } + ] +} \ No newline at end of file diff --git a/tests/Cast/data/vtl/GH_539_2.vtl b/tests/Cast/data/vtl/GH_539_2.vtl new file mode 100644 index 000000000..af5c381f3 --- /dev/null +++ b/tests/Cast/data/vtl/GH_539_2.vtl @@ -0,0 +1 @@ +DS_r <- DS_1[sub Id_2 = cast(Id_1, string)]; \ No newline at end of file diff --git a/tests/Cast/test_cast.py b/tests/Cast/test_cast.py index 98a44c28e..52f30d86d 100644 --- a/tests/Cast/test_cast.py +++ b/tests/Cast/test_cast.py @@ -80,6 +80,16 @@ def test_GH_539_1(self): self.BaseTest(code, number_inputs, references_names=reference_names, scalars=scalars) + def test_GH_539_2(self): + """ + Solves bug report in github issue #539: sub fails whith scalar as VarID casting + """ + code = "GH_539_2" + number_inputs = 1 + exception_code = "1-1-1-11" # sub comparison is not allowed between components + + self.NewSemanticExceptionTest(code, number_inputs, exception_code) + # =========================================================================== # Comprehensive explicit cast tests (VTL 2.2) - Without mask From 25fdfe84619c1939ccf7901cc5b5513b57e86a7a Mon Sep 17 00:00:00 2001 From: Mateo Date: Thu, 26 Feb 2026 13:20:06 +0100 Subject: [PATCH 08/10] Fixed ruff errors --- src/vtlengine/AST/Grammar/lexer.py | 920 ++- src/vtlengine/AST/Grammar/parser.py | 9675 +++++++++++++++------------ tests/Cast/test_cast.py | 2 +- 3 files changed, 6293 insertions(+), 4304 deletions(-) diff --git a/src/vtlengine/AST/Grammar/lexer.py b/src/vtlengine/AST/Grammar/lexer.py index 39936829f..87526aac9 100644 --- a/src/vtlengine/AST/Grammar/lexer.py +++ b/src/vtlengine/AST/Grammar/lexer.py @@ -11,7 +11,6 @@ from typing import TextIO - def serializedATN(): with StringIO() as buf: buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u00fb") @@ -20,8 +19,8 @@ def serializedATN(): buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23") buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30") buf.write("\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36") - buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%") - buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.") + buf.write('\t\36\4\37\t\37\4 \t \4!\t!\4"\t"\4#\t#\4$\t$\4%\t%') + buf.write("\4&\t&\4'\t'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.") buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64") buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:") buf.write("\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\t") @@ -77,10 +76,10 @@ def serializedATN(): buf.write("\3\34\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36") buf.write("\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37") buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \3 \3 \3") - buf.write(" \3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3") + buf.write(' \3!\3!\3!\3!\3!\3"\3"\3"\3"\3"\3"\3#\3#\3#\3#\3') buf.write("#\3#\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3%\3") buf.write("%\3%\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3&\3&\3&\3") - buf.write("&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(") + buf.write("&\3&\3'\3'\3'\3'\3'\3'\3'\3'\3'\3'\3(\3(\3(") buf.write("\3(\3(\3(\3(\3(\3(\3(\3(\3)\3)\3)\3*\3*\3*\3*\3*\3+\3") buf.write("+\3+\3+\3+\3,\3,\3,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3-\3-\3") buf.write(".\3.\3.\3.\3.\3.\3.\3/\3/\3/\3\60\3\60\3\60\3\60\3\61") @@ -283,8 +282,8 @@ def serializedATN(): buf.write("\16\u00fc\u0951\13\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fc") buf.write("\5\u092c\u0941\u094f\2\u00fd\3\3\5\4\7\5\t\6\13\7\r\b") buf.write("\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22") - buf.write("#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\35") - buf.write("9\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62") + buf.write("#\23%\24'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\35") + buf.write("9\36;\37= ?!A\"C#E$G%I&K'M(O)Q*S+U,W-Y.[/]\60_\61a\62") buf.write("c\63e\64g\65i\66k\67m8o9q:s;u{?}@\177A\u0081B\u0083") buf.write("C\u0085D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093") buf.write("K\u0095L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1R\u00a3") @@ -322,11 +321,11 @@ def serializedATN(): buf.write("\u00f2\u01e3\2\u01e5\2\u01e7\u00f3\u01e9\u00f4\u01eb\u00f5") buf.write("\u01ed\u00f6\u01ef\u00f7\u01f1\u00f8\u01f3\u00f9\u01f5") buf.write("\u00fa\u01f7\u00fb\3\2\6\4\2C\\c|\3\2$$\7\2\60\60\62;") - buf.write("C\\aac|\5\2\13\f\16\17\"\"\2\u0960\2\3\3\2\2\2\2\5\3\2") + buf.write('C\\aac|\5\2\13\f\16\17""\2\u0960\2\3\3\2\2\2\2\5\3\2') buf.write("\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2") buf.write("\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2") buf.write("\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37") - buf.write("\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2") + buf.write("\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2'\3\2\2\2") buf.write("\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2") buf.write("\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2") buf.write("\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2") @@ -394,7 +393,7 @@ def serializedATN(): buf.write("\u0203\3\2\2\2\17\u0205\3\2\2\2\21\u0207\3\2\2\2\23\u0209") buf.write("\3\2\2\2\25\u020b\3\2\2\2\27\u020e\3\2\2\2\31\u0211\3") buf.write("\2\2\2\33\u0214\3\2\2\2\35\u0216\3\2\2\2\37\u0218\3\2") - buf.write("\2\2!\u021a\3\2\2\2#\u021c\3\2\2\2%\u021e\3\2\2\2\'\u0221") + buf.write("\2\2!\u021a\3\2\2\2#\u021c\3\2\2\2%\u021e\3\2\2\2'\u0221") buf.write("\3\2\2\2)\u0223\3\2\2\2+\u0226\3\2\2\2-\u0228\3\2\2\2") buf.write("/\u022d\3\2\2\2\61\u0230\3\2\2\2\63\u0235\3\2\2\2\65\u023a") buf.write("\3\2\2\2\67\u023f\3\2\2\29\u0245\3\2\2\2;\u024a\3\2\2") @@ -487,7 +486,7 @@ def serializedATN(): buf.write("\7>\2\2\u0212\u0213\7?\2\2\u0213\32\3\2\2\2\u0214\u0215") buf.write("\7-\2\2\u0215\34\3\2\2\2\u0216\u0217\7/\2\2\u0217\36\3") buf.write("\2\2\2\u0218\u0219\7,\2\2\u0219 \3\2\2\2\u021a\u021b\7") - buf.write("\61\2\2\u021b\"\3\2\2\2\u021c\u021d\7.\2\2\u021d$\3\2") + buf.write('\61\2\2\u021b"\3\2\2\2\u021c\u021d\7.\2\2\u021d$\3\2') buf.write("\2\2\u021e\u021f\7/\2\2\u021f\u0220\7@\2\2\u0220&\3\2") buf.write("\2\2\u0221\u0222\7<\2\2\u0222(\3\2\2\2\u0223\u0224\7<") buf.write("\2\2\u0224\u0225\7?\2\2\u0225*\3\2\2\2\u0226\u0227\7%") @@ -1119,10 +1118,9 @@ def serializedATN(): class Lexer(ANTLRLexer): - atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] LPAREN = 1 RPAREN = 2 @@ -1374,155 +1372,769 @@ class Lexer(ANTLRLexer): ML_COMMENT = 248 SL_COMMENT = 249 - channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] - modeNames = [ "DEFAULT_MODE" ] + modeNames = ["DEFAULT_MODE"] - literalNames = [ "", - "'('", "')'", "'['", "']'", "'{'", "'}'", "'='", "'<'", "'>'", - "'>='", "'<>'", "'<='", "'+'", "'-'", "'*'", "'/'", "','", "'->'", - "':'", "':='", "'#'", "'eval'", "'if'", "'case'", "'then'", - "'else'", "'using'", "'with'", "'current_date'", "'datediff'", - "'dateadd'", "'year'", "'month'", "'dayofmonth'", "'dayofyear'", - "'daytoyear'", "'daytomonth'", "'yeartoday'", "'monthtoday'", - "'on'", "'drop'", "'keep'", "'calc'", "'attrcalc'", "'rename'", - "'as'", "'and'", "'or'", "'xor'", "'not'", "'between'", "'in'", - "'not_in'", "'null'", "'isnull'", "'ex'", "'union'", "'diff'", - "'symdiff'", "'intersect'", "'random'", "'keys'", "'intyear'", - "'intmonth'", "'intday'", "'check'", "'exists_in'", "'to'", - "'return'", "'imbalance'", "'errorcode'", "'all'", "'aggr'", - "'errorlevel'", "'order'", "'by'", "'rank'", "'asc'", "'desc'", - "'min'", "'max'", "'first'", "'last'", "'indexof'", "'abs'", - "'key'", "'ln'", "'log'", "'trunc'", "'round'", "'power'", "'mod'", - "'length'", "'||'", "'trim'", "'upper'", "'lower'", "'substr'", - "'sum'", "'avg'", "'median'", "'count'", "'identifier'", "'measure'", - "'attribute'", "'filter'", "'merge'", "'exp'", "'componentRole'", - "'viral'", "'match_characters'", "'type'", "'nvl'", "'hierarchy'", - "'_'", "'invalid'", "'valuedomain'", "'variable'", "'data'", - "'structure'", "'dataset'", "'operator'", "'define'", "'<-'", - "'datapoint'", "'hierarchical'", "'ruleset'", "'rule'", "'end'", - "'alterDataset'", "'ltrim'", "'rtrim'", "'instr'", "'replace'", - "'ceil'", "'floor'", "'sqrt'", "'any'", "'setdiff'", "'stddev_pop'", - "'stddev_samp'", "'var_pop'", "'var_samp'", "'group'", "'except'", - "'having'", "'first_value'", "'last_value'", "'lag'", "'lead'", - "'ratio_to_report'", "'over'", "'preceding'", "'following'", - "'unbounded'", "'partition'", "'rows'", "'range'", "'current'", - "'valid'", "'fill_time_series'", "'flow_to_stock'", "'stock_to_flow'", - "'timeshift'", "'measures'", "'no_measures'", "'condition'", - "'boolean'", "'date'", "'time_period'", "'number'", "'string'", - "'time'", "'integer'", "'float'", "'list'", "'record'", "'restrict'", - "'yyyy'", "'mm'", "'dd'", "'maxLength'", "'regexp'", "'is'", - "'when'", "'from'", "'aggregates'", "'points'", "'point'", "'total'", - "'partial'", "'always'", "'inner_join'", "'left_join'", "'cross_join'", - "'full_join'", "'maps_from'", "'maps_to'", "'map_to'", "'map_from'", - "'returns'", "'pivot'", "'customPivot'", "'unpivot'", "'sub'", - "'apply'", "'conditioned'", "'period_indicator'", "'single'", - "'duration'", "'time_agg'", "'unit'", "'Value'", "'valuedomains'", - "'variables'", "'input'", "'output'", "'cast'", "'rule_priority'", - "'dataset_priority'", "'default'", "'check_datapoint'", "'check_hierarchy'", - "'computed'", "'non_null'", "'non_zero'", "'partial_null'", - "'partial_zero'", "'always_null'", "'always_zero'", "'components'", - "'all_measures'", "'scalar'", "'component'", "'datapoint_on_valuedomains'", - "'datapoint_on_variables'", "'hierarchical_on_valuedomains'", - "'hierarchical_on_variables'", "'set'", "'language'", "';'" ] + literalNames = [ + "", + "'('", + "')'", + "'['", + "']'", + "'{'", + "'}'", + "'='", + "'<'", + "'>'", + "'>='", + "'<>'", + "'<='", + "'+'", + "'-'", + "'*'", + "'/'", + "','", + "'->'", + "':'", + "':='", + "'#'", + "'eval'", + "'if'", + "'case'", + "'then'", + "'else'", + "'using'", + "'with'", + "'current_date'", + "'datediff'", + "'dateadd'", + "'year'", + "'month'", + "'dayofmonth'", + "'dayofyear'", + "'daytoyear'", + "'daytomonth'", + "'yeartoday'", + "'monthtoday'", + "'on'", + "'drop'", + "'keep'", + "'calc'", + "'attrcalc'", + "'rename'", + "'as'", + "'and'", + "'or'", + "'xor'", + "'not'", + "'between'", + "'in'", + "'not_in'", + "'null'", + "'isnull'", + "'ex'", + "'union'", + "'diff'", + "'symdiff'", + "'intersect'", + "'random'", + "'keys'", + "'intyear'", + "'intmonth'", + "'intday'", + "'check'", + "'exists_in'", + "'to'", + "'return'", + "'imbalance'", + "'errorcode'", + "'all'", + "'aggr'", + "'errorlevel'", + "'order'", + "'by'", + "'rank'", + "'asc'", + "'desc'", + "'min'", + "'max'", + "'first'", + "'last'", + "'indexof'", + "'abs'", + "'key'", + "'ln'", + "'log'", + "'trunc'", + "'round'", + "'power'", + "'mod'", + "'length'", + "'||'", + "'trim'", + "'upper'", + "'lower'", + "'substr'", + "'sum'", + "'avg'", + "'median'", + "'count'", + "'identifier'", + "'measure'", + "'attribute'", + "'filter'", + "'merge'", + "'exp'", + "'componentRole'", + "'viral'", + "'match_characters'", + "'type'", + "'nvl'", + "'hierarchy'", + "'_'", + "'invalid'", + "'valuedomain'", + "'variable'", + "'data'", + "'structure'", + "'dataset'", + "'operator'", + "'define'", + "'<-'", + "'datapoint'", + "'hierarchical'", + "'ruleset'", + "'rule'", + "'end'", + "'alterDataset'", + "'ltrim'", + "'rtrim'", + "'instr'", + "'replace'", + "'ceil'", + "'floor'", + "'sqrt'", + "'any'", + "'setdiff'", + "'stddev_pop'", + "'stddev_samp'", + "'var_pop'", + "'var_samp'", + "'group'", + "'except'", + "'having'", + "'first_value'", + "'last_value'", + "'lag'", + "'lead'", + "'ratio_to_report'", + "'over'", + "'preceding'", + "'following'", + "'unbounded'", + "'partition'", + "'rows'", + "'range'", + "'current'", + "'valid'", + "'fill_time_series'", + "'flow_to_stock'", + "'stock_to_flow'", + "'timeshift'", + "'measures'", + "'no_measures'", + "'condition'", + "'boolean'", + "'date'", + "'time_period'", + "'number'", + "'string'", + "'time'", + "'integer'", + "'float'", + "'list'", + "'record'", + "'restrict'", + "'yyyy'", + "'mm'", + "'dd'", + "'maxLength'", + "'regexp'", + "'is'", + "'when'", + "'from'", + "'aggregates'", + "'points'", + "'point'", + "'total'", + "'partial'", + "'always'", + "'inner_join'", + "'left_join'", + "'cross_join'", + "'full_join'", + "'maps_from'", + "'maps_to'", + "'map_to'", + "'map_from'", + "'returns'", + "'pivot'", + "'customPivot'", + "'unpivot'", + "'sub'", + "'apply'", + "'conditioned'", + "'period_indicator'", + "'single'", + "'duration'", + "'time_agg'", + "'unit'", + "'Value'", + "'valuedomains'", + "'variables'", + "'input'", + "'output'", + "'cast'", + "'rule_priority'", + "'dataset_priority'", + "'default'", + "'check_datapoint'", + "'check_hierarchy'", + "'computed'", + "'non_null'", + "'non_zero'", + "'partial_null'", + "'partial_zero'", + "'always_null'", + "'always_zero'", + "'components'", + "'all_measures'", + "'scalar'", + "'component'", + "'datapoint_on_valuedomains'", + "'datapoint_on_variables'", + "'hierarchical_on_valuedomains'", + "'hierarchical_on_variables'", + "'set'", + "'language'", + "';'", + ] - symbolicNames = [ "", - "LPAREN", "RPAREN", "QLPAREN", "QRPAREN", "GLPAREN", "GRPAREN", - "EQ", "LT", "MT", "ME", "NEQ", "LE", "PLUS", "MINUS", "MUL", - "DIV", "COMMA", "POINTER", "COLON", "ASSIGN", "MEMBERSHIP", - "EVAL", "IF", "CASE", "THEN", "ELSE", "USING", "WITH", "CURRENT_DATE", - "DATEDIFF", "DATEADD", "YEAR_OP", "MONTH_OP", "DAYOFMONTH", - "DAYOFYEAR", "DAYTOYEAR", "DAYTOMONTH", "YEARTODAY", "MONTHTODAY", - "ON", "DROP", "KEEP", "CALC", "ATTRCALC", "RENAME", "AS", "AND", - "OR", "XOR", "NOT", "BETWEEN", "IN", "NOT_IN", "NULL_CONSTANT", - "ISNULL", "EX", "UNION", "DIFF", "SYMDIFF", "INTERSECT", "RANDOM", - "KEYS", "INTYEAR", "INTMONTH", "INTDAY", "CHECK", "EXISTS_IN", - "TO", "RETURN", "IMBALANCE", "ERRORCODE", "ALL", "AGGREGATE", - "ERRORLEVEL", "ORDER", "BY", "RANK", "ASC", "DESC", "MIN", "MAX", - "FIRST", "LAST", "INDEXOF", "ABS", "KEY", "LN", "LOG", "TRUNC", - "ROUND", "POWER", "MOD", "LEN", "CONCAT", "TRIM", "UCASE", "LCASE", - "SUBSTR", "SUM", "AVG", "MEDIAN", "COUNT", "DIMENSION", "MEASURE", - "ATTRIBUTE", "FILTER", "MERGE", "EXP", "ROLE", "VIRAL", "CHARSET_MATCH", - "TYPE", "NVL", "HIERARCHY", "OPTIONAL", "INVALID", "VALUE_DOMAIN", - "VARIABLE", "DATA", "STRUCTURE", "DATASET", "OPERATOR", "DEFINE", - "PUT_SYMBOL", "DATAPOINT", "HIERARCHICAL", "RULESET", "RULE", - "END", "ALTER_DATASET", "LTRIM", "RTRIM", "INSTR", "REPLACE", - "CEIL", "FLOOR", "SQRT", "ANY", "SETDIFF", "STDDEV_POP", "STDDEV_SAMP", - "VAR_POP", "VAR_SAMP", "GROUP", "EXCEPT", "HAVING", "FIRST_VALUE", - "LAST_VALUE", "LAG", "LEAD", "RATIO_TO_REPORT", "OVER", "PRECEDING", - "FOLLOWING", "UNBOUNDED", "PARTITION", "ROWS", "RANGE", "CURRENT", - "VALID", "FILL_TIME_SERIES", "FLOW_TO_STOCK", "STOCK_TO_FLOW", - "TIMESHIFT", "MEASURES", "NO_MEASURES", "CONDITION", "BOOLEAN", - "DATE", "TIME_PERIOD", "NUMBER", "STRING", "TIME", "INTEGER", - "FLOAT", "LIST", "RECORD", "RESTRICT", "YYYY", "MM", "DD", "MAX_LENGTH", - "REGEXP", "IS", "WHEN", "FROM", "AGGREGATES", "POINTS", "POINT", - "TOTAL", "PARTIAL", "ALWAYS", "INNER_JOIN", "LEFT_JOIN", "CROSS_JOIN", - "FULL_JOIN", "MAPS_FROM", "MAPS_TO", "MAP_TO", "MAP_FROM", "RETURNS", - "PIVOT", "CUSTOMPIVOT", "UNPIVOT", "SUBSPACE", "APPLY", "CONDITIONED", - "PERIOD_INDICATOR", "SINGLE", "DURATION", "TIME_AGG", "UNIT", - "VALUE", "VALUEDOMAINS", "VARIABLES", "INPUT", "OUTPUT", "CAST", - "RULE_PRIORITY", "DATASET_PRIORITY", "DEFAULT", "CHECK_DATAPOINT", - "CHECK_HIERARCHY", "COMPUTED", "NON_NULL", "NON_ZERO", "PARTIAL_NULL", - "PARTIAL_ZERO", "ALWAYS_NULL", "ALWAYS_ZERO", "COMPONENTS", - "ALL_MEASURES", "SCALAR", "COMPONENT", "DATAPOINT_ON_VD", "DATAPOINT_ON_VAR", - "HIERARCHICAL_ON_VD", "HIERARCHICAL_ON_VAR", "SET", "LANGUAGE", - "INTEGER_CONSTANT", "NUMBER_CONSTANT", "BOOLEAN_CONSTANT", "STRING_CONSTANT", - "IDENTIFIER", "WS", "EOL", "ML_COMMENT", "SL_COMMENT" ] + symbolicNames = [ + "", + "LPAREN", + "RPAREN", + "QLPAREN", + "QRPAREN", + "GLPAREN", + "GRPAREN", + "EQ", + "LT", + "MT", + "ME", + "NEQ", + "LE", + "PLUS", + "MINUS", + "MUL", + "DIV", + "COMMA", + "POINTER", + "COLON", + "ASSIGN", + "MEMBERSHIP", + "EVAL", + "IF", + "CASE", + "THEN", + "ELSE", + "USING", + "WITH", + "CURRENT_DATE", + "DATEDIFF", + "DATEADD", + "YEAR_OP", + "MONTH_OP", + "DAYOFMONTH", + "DAYOFYEAR", + "DAYTOYEAR", + "DAYTOMONTH", + "YEARTODAY", + "MONTHTODAY", + "ON", + "DROP", + "KEEP", + "CALC", + "ATTRCALC", + "RENAME", + "AS", + "AND", + "OR", + "XOR", + "NOT", + "BETWEEN", + "IN", + "NOT_IN", + "NULL_CONSTANT", + "ISNULL", + "EX", + "UNION", + "DIFF", + "SYMDIFF", + "INTERSECT", + "RANDOM", + "KEYS", + "INTYEAR", + "INTMONTH", + "INTDAY", + "CHECK", + "EXISTS_IN", + "TO", + "RETURN", + "IMBALANCE", + "ERRORCODE", + "ALL", + "AGGREGATE", + "ERRORLEVEL", + "ORDER", + "BY", + "RANK", + "ASC", + "DESC", + "MIN", + "MAX", + "FIRST", + "LAST", + "INDEXOF", + "ABS", + "KEY", + "LN", + "LOG", + "TRUNC", + "ROUND", + "POWER", + "MOD", + "LEN", + "CONCAT", + "TRIM", + "UCASE", + "LCASE", + "SUBSTR", + "SUM", + "AVG", + "MEDIAN", + "COUNT", + "DIMENSION", + "MEASURE", + "ATTRIBUTE", + "FILTER", + "MERGE", + "EXP", + "ROLE", + "VIRAL", + "CHARSET_MATCH", + "TYPE", + "NVL", + "HIERARCHY", + "OPTIONAL", + "INVALID", + "VALUE_DOMAIN", + "VARIABLE", + "DATA", + "STRUCTURE", + "DATASET", + "OPERATOR", + "DEFINE", + "PUT_SYMBOL", + "DATAPOINT", + "HIERARCHICAL", + "RULESET", + "RULE", + "END", + "ALTER_DATASET", + "LTRIM", + "RTRIM", + "INSTR", + "REPLACE", + "CEIL", + "FLOOR", + "SQRT", + "ANY", + "SETDIFF", + "STDDEV_POP", + "STDDEV_SAMP", + "VAR_POP", + "VAR_SAMP", + "GROUP", + "EXCEPT", + "HAVING", + "FIRST_VALUE", + "LAST_VALUE", + "LAG", + "LEAD", + "RATIO_TO_REPORT", + "OVER", + "PRECEDING", + "FOLLOWING", + "UNBOUNDED", + "PARTITION", + "ROWS", + "RANGE", + "CURRENT", + "VALID", + "FILL_TIME_SERIES", + "FLOW_TO_STOCK", + "STOCK_TO_FLOW", + "TIMESHIFT", + "MEASURES", + "NO_MEASURES", + "CONDITION", + "BOOLEAN", + "DATE", + "TIME_PERIOD", + "NUMBER", + "STRING", + "TIME", + "INTEGER", + "FLOAT", + "LIST", + "RECORD", + "RESTRICT", + "YYYY", + "MM", + "DD", + "MAX_LENGTH", + "REGEXP", + "IS", + "WHEN", + "FROM", + "AGGREGATES", + "POINTS", + "POINT", + "TOTAL", + "PARTIAL", + "ALWAYS", + "INNER_JOIN", + "LEFT_JOIN", + "CROSS_JOIN", + "FULL_JOIN", + "MAPS_FROM", + "MAPS_TO", + "MAP_TO", + "MAP_FROM", + "RETURNS", + "PIVOT", + "CUSTOMPIVOT", + "UNPIVOT", + "SUBSPACE", + "APPLY", + "CONDITIONED", + "PERIOD_INDICATOR", + "SINGLE", + "DURATION", + "TIME_AGG", + "UNIT", + "VALUE", + "VALUEDOMAINS", + "VARIABLES", + "INPUT", + "OUTPUT", + "CAST", + "RULE_PRIORITY", + "DATASET_PRIORITY", + "DEFAULT", + "CHECK_DATAPOINT", + "CHECK_HIERARCHY", + "COMPUTED", + "NON_NULL", + "NON_ZERO", + "PARTIAL_NULL", + "PARTIAL_ZERO", + "ALWAYS_NULL", + "ALWAYS_ZERO", + "COMPONENTS", + "ALL_MEASURES", + "SCALAR", + "COMPONENT", + "DATAPOINT_ON_VD", + "DATAPOINT_ON_VAR", + "HIERARCHICAL_ON_VD", + "HIERARCHICAL_ON_VAR", + "SET", + "LANGUAGE", + "INTEGER_CONSTANT", + "NUMBER_CONSTANT", + "BOOLEAN_CONSTANT", + "STRING_CONSTANT", + "IDENTIFIER", + "WS", + "EOL", + "ML_COMMENT", + "SL_COMMENT", + ] - ruleNames = [ "LPAREN", "RPAREN", "QLPAREN", "QRPAREN", "GLPAREN", "GRPAREN", - "EQ", "LT", "MT", "ME", "NEQ", "LE", "PLUS", "MINUS", - "MUL", "DIV", "COMMA", "POINTER", "COLON", "ASSIGN", "MEMBERSHIP", - "EVAL", "IF", "CASE", "THEN", "ELSE", "USING", "WITH", - "CURRENT_DATE", "DATEDIFF", "DATEADD", "YEAR_OP", "MONTH_OP", - "DAYOFMONTH", "DAYOFYEAR", "DAYTOYEAR", "DAYTOMONTH", - "YEARTODAY", "MONTHTODAY", "ON", "DROP", "KEEP", "CALC", - "ATTRCALC", "RENAME", "AS", "AND", "OR", "XOR", "NOT", - "BETWEEN", "IN", "NOT_IN", "NULL_CONSTANT", "ISNULL", - "EX", "UNION", "DIFF", "SYMDIFF", "INTERSECT", "RANDOM", - "KEYS", "INTYEAR", "INTMONTH", "INTDAY", "CHECK", "EXISTS_IN", - "TO", "RETURN", "IMBALANCE", "ERRORCODE", "ALL", "AGGREGATE", - "ERRORLEVEL", "ORDER", "BY", "RANK", "ASC", "DESC", "MIN", - "MAX", "FIRST", "LAST", "INDEXOF", "ABS", "KEY", "LN", - "LOG", "TRUNC", "ROUND", "POWER", "MOD", "LEN", "CONCAT", - "TRIM", "UCASE", "LCASE", "SUBSTR", "SUM", "AVG", "MEDIAN", - "COUNT", "DIMENSION", "MEASURE", "ATTRIBUTE", "FILTER", - "MERGE", "EXP", "ROLE", "VIRAL", "CHARSET_MATCH", "TYPE", - "NVL", "HIERARCHY", "OPTIONAL", "INVALID", "VALUE_DOMAIN", - "VARIABLE", "DATA", "STRUCTURE", "DATASET", "OPERATOR", - "DEFINE", "PUT_SYMBOL", "DATAPOINT", "HIERARCHICAL", "RULESET", - "RULE", "END", "ALTER_DATASET", "LTRIM", "RTRIM", "INSTR", - "REPLACE", "CEIL", "FLOOR", "SQRT", "ANY", "SETDIFF", - "STDDEV_POP", "STDDEV_SAMP", "VAR_POP", "VAR_SAMP", "GROUP", - "EXCEPT", "HAVING", "FIRST_VALUE", "LAST_VALUE", "LAG", - "LEAD", "RATIO_TO_REPORT", "OVER", "PRECEDING", "FOLLOWING", - "UNBOUNDED", "PARTITION", "ROWS", "RANGE", "CURRENT", - "VALID", "FILL_TIME_SERIES", "FLOW_TO_STOCK", "STOCK_TO_FLOW", - "TIMESHIFT", "MEASURES", "NO_MEASURES", "CONDITION", "BOOLEAN", - "DATE", "TIME_PERIOD", "NUMBER", "STRING", "TIME", "INTEGER", - "FLOAT", "LIST", "RECORD", "RESTRICT", "YYYY", "MM", "DD", - "MAX_LENGTH", "REGEXP", "IS", "WHEN", "FROM", "AGGREGATES", - "POINTS", "POINT", "TOTAL", "PARTIAL", "ALWAYS", "INNER_JOIN", - "LEFT_JOIN", "CROSS_JOIN", "FULL_JOIN", "MAPS_FROM", "MAPS_TO", - "MAP_TO", "MAP_FROM", "RETURNS", "PIVOT", "CUSTOMPIVOT", - "UNPIVOT", "SUBSPACE", "APPLY", "CONDITIONED", "PERIOD_INDICATOR", - "SINGLE", "DURATION", "TIME_AGG", "UNIT", "VALUE", "VALUEDOMAINS", - "VARIABLES", "INPUT", "OUTPUT", "CAST", "RULE_PRIORITY", - "DATASET_PRIORITY", "DEFAULT", "CHECK_DATAPOINT", "CHECK_HIERARCHY", - "COMPUTED", "NON_NULL", "NON_ZERO", "PARTIAL_NULL", "PARTIAL_ZERO", - "ALWAYS_NULL", "ALWAYS_ZERO", "COMPONENTS", "ALL_MEASURES", - "SCALAR", "COMPONENT", "DATAPOINT_ON_VD", "DATAPOINT_ON_VAR", - "HIERARCHICAL_ON_VD", "HIERARCHICAL_ON_VAR", "SET", "LANGUAGE", - "LETTER", "DIGITS0_9", "INTEGER_CONSTANT", "NUMBER_CONSTANT", - "BOOLEAN_CONSTANT", "STRING_CONSTANT", "IDENTIFIER", "WS", - "EOL", "ML_COMMENT", "SL_COMMENT" ] + ruleNames = [ + "LPAREN", + "RPAREN", + "QLPAREN", + "QRPAREN", + "GLPAREN", + "GRPAREN", + "EQ", + "LT", + "MT", + "ME", + "NEQ", + "LE", + "PLUS", + "MINUS", + "MUL", + "DIV", + "COMMA", + "POINTER", + "COLON", + "ASSIGN", + "MEMBERSHIP", + "EVAL", + "IF", + "CASE", + "THEN", + "ELSE", + "USING", + "WITH", + "CURRENT_DATE", + "DATEDIFF", + "DATEADD", + "YEAR_OP", + "MONTH_OP", + "DAYOFMONTH", + "DAYOFYEAR", + "DAYTOYEAR", + "DAYTOMONTH", + "YEARTODAY", + "MONTHTODAY", + "ON", + "DROP", + "KEEP", + "CALC", + "ATTRCALC", + "RENAME", + "AS", + "AND", + "OR", + "XOR", + "NOT", + "BETWEEN", + "IN", + "NOT_IN", + "NULL_CONSTANT", + "ISNULL", + "EX", + "UNION", + "DIFF", + "SYMDIFF", + "INTERSECT", + "RANDOM", + "KEYS", + "INTYEAR", + "INTMONTH", + "INTDAY", + "CHECK", + "EXISTS_IN", + "TO", + "RETURN", + "IMBALANCE", + "ERRORCODE", + "ALL", + "AGGREGATE", + "ERRORLEVEL", + "ORDER", + "BY", + "RANK", + "ASC", + "DESC", + "MIN", + "MAX", + "FIRST", + "LAST", + "INDEXOF", + "ABS", + "KEY", + "LN", + "LOG", + "TRUNC", + "ROUND", + "POWER", + "MOD", + "LEN", + "CONCAT", + "TRIM", + "UCASE", + "LCASE", + "SUBSTR", + "SUM", + "AVG", + "MEDIAN", + "COUNT", + "DIMENSION", + "MEASURE", + "ATTRIBUTE", + "FILTER", + "MERGE", + "EXP", + "ROLE", + "VIRAL", + "CHARSET_MATCH", + "TYPE", + "NVL", + "HIERARCHY", + "OPTIONAL", + "INVALID", + "VALUE_DOMAIN", + "VARIABLE", + "DATA", + "STRUCTURE", + "DATASET", + "OPERATOR", + "DEFINE", + "PUT_SYMBOL", + "DATAPOINT", + "HIERARCHICAL", + "RULESET", + "RULE", + "END", + "ALTER_DATASET", + "LTRIM", + "RTRIM", + "INSTR", + "REPLACE", + "CEIL", + "FLOOR", + "SQRT", + "ANY", + "SETDIFF", + "STDDEV_POP", + "STDDEV_SAMP", + "VAR_POP", + "VAR_SAMP", + "GROUP", + "EXCEPT", + "HAVING", + "FIRST_VALUE", + "LAST_VALUE", + "LAG", + "LEAD", + "RATIO_TO_REPORT", + "OVER", + "PRECEDING", + "FOLLOWING", + "UNBOUNDED", + "PARTITION", + "ROWS", + "RANGE", + "CURRENT", + "VALID", + "FILL_TIME_SERIES", + "FLOW_TO_STOCK", + "STOCK_TO_FLOW", + "TIMESHIFT", + "MEASURES", + "NO_MEASURES", + "CONDITION", + "BOOLEAN", + "DATE", + "TIME_PERIOD", + "NUMBER", + "STRING", + "TIME", + "INTEGER", + "FLOAT", + "LIST", + "RECORD", + "RESTRICT", + "YYYY", + "MM", + "DD", + "MAX_LENGTH", + "REGEXP", + "IS", + "WHEN", + "FROM", + "AGGREGATES", + "POINTS", + "POINT", + "TOTAL", + "PARTIAL", + "ALWAYS", + "INNER_JOIN", + "LEFT_JOIN", + "CROSS_JOIN", + "FULL_JOIN", + "MAPS_FROM", + "MAPS_TO", + "MAP_TO", + "MAP_FROM", + "RETURNS", + "PIVOT", + "CUSTOMPIVOT", + "UNPIVOT", + "SUBSPACE", + "APPLY", + "CONDITIONED", + "PERIOD_INDICATOR", + "SINGLE", + "DURATION", + "TIME_AGG", + "UNIT", + "VALUE", + "VALUEDOMAINS", + "VARIABLES", + "INPUT", + "OUTPUT", + "CAST", + "RULE_PRIORITY", + "DATASET_PRIORITY", + "DEFAULT", + "CHECK_DATAPOINT", + "CHECK_HIERARCHY", + "COMPUTED", + "NON_NULL", + "NON_ZERO", + "PARTIAL_NULL", + "PARTIAL_ZERO", + "ALWAYS_NULL", + "ALWAYS_ZERO", + "COMPONENTS", + "ALL_MEASURES", + "SCALAR", + "COMPONENT", + "DATAPOINT_ON_VD", + "DATAPOINT_ON_VAR", + "HIERARCHICAL_ON_VD", + "HIERARCHICAL_ON_VAR", + "SET", + "LANGUAGE", + "LETTER", + "DIGITS0_9", + "INTEGER_CONSTANT", + "NUMBER_CONSTANT", + "BOOLEAN_CONSTANT", + "STRING_CONSTANT", + "IDENTIFIER", + "WS", + "EOL", + "ML_COMMENT", + "SL_COMMENT", + ] grammarFileName = "Vtl.g4" - def __init__(self, input=None, output:TextIO = sys.stdout): + def __init__(self, input=None, output: TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.9.3") - self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._interp = LexerATNSimulator( + self, self.atn, self.decisionsToDFA, PredictionContextCache() + ) self._actions = None self._predicates = None - - diff --git a/src/vtlengine/AST/Grammar/parser.py b/src/vtlengine/AST/Grammar/parser.py index b6225f7d6..3509a55c8 100644 --- a/src/vtlengine/AST/Grammar/parser.py +++ b/src/vtlengine/AST/Grammar/parser.py @@ -4,10 +4,11 @@ from antlr4 import Parser as ANTLRParser from io import StringIO import sys + if sys.version_info[1] > 5: - from typing import TextIO + from typing import TextIO else: - from typing.io import TextIO + from typing.io import TextIO def serializedATN(): @@ -18,8 +19,8 @@ def serializedATN(): buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23") buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31") buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36") - buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t") - buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4") + buf.write('\4\37\t\37\4 \t \4!\t!\4"\t"\4#\t#\4$\t$\4%\t%\4&\t') + buf.write("&\4'\t'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4") buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64") buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t") buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t") @@ -123,18 +124,18 @@ def serializedATN(): buf.write("\3!\3!\3!\3!\3!\3!\5!\u0480\n!\3!\3!\5!\u0484\n!\3!\5") buf.write("!\u0487\n!\3!\5!\u048a\n!\3!\5!\u048d\n!\3!\3!\3!\3!\3") buf.write("!\3!\5!\u0495\n!\3!\5!\u0498\n!\3!\5!\u049b\n!\3!\5!\u049e") - buf.write("\n!\3!\3!\5!\u04a2\n!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3") + buf.write('\n!\3!\3!\5!\u04a2\n!\3"\3"\3"\3"\3"\3"\3"\3#\3') buf.write("#\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3$\5$\u04ba\n$\3") buf.write("%\3%\3%\3%\3%\5%\u04c1\n%\5%\u04c3\n%\3%\3%\3&\3&\3&\3") buf.write("&\3&\3&\5&\u04cd\n&\3&\5&\u04d0\n&\3&\5&\u04d3\n&\3&\3") buf.write("&\3&\3&\3&\3&\3&\3&\3&\3&\5&\u04df\n&\5&\u04e1\n&\3&\3") buf.write("&\3&\5&\u04e6\n&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3") - buf.write("&\3&\5&\u04f6\n&\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u04fe\n\'") - buf.write("\3\'\5\'\u0501\n\'\3\'\5\'\u0504\n\'\3\'\3\'\3\'\3\'\3") - buf.write("\'\3\'\3\'\3\'\3\'\5\'\u050f\n\'\5\'\u0511\n\'\3\'\3\'") - buf.write("\3\'\5\'\u0516\n\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'") - buf.write("\3\'\5\'\u0522\n\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'") - buf.write("\3\'\3\'\3\'\3\'\3\'\5\'\u0532\n\'\3(\3(\3(\3(\3)\3)\3") + buf.write("&\3&\5&\u04f6\n&\3'\3'\3'\3'\3'\3'\5'\u04fe\n'") + buf.write("\3'\5'\u0501\n'\3'\5'\u0504\n'\3'\3'\3'\3'\3") + buf.write("'\3'\3'\3'\3'\5'\u050f\n'\5'\u0511\n'\3'\3'") + buf.write("\3'\5'\u0516\n'\3'\3'\3'\3'\3'\3'\3'\3'\3'") + buf.write("\3'\5'\u0522\n'\3'\3'\3'\3'\3'\3'\3'\3'\3'") + buf.write("\3'\3'\3'\3'\3'\5'\u0532\n'\3(\3(\3(\3(\3)\3)\3") buf.write(")\7)\u053b\n)\f)\16)\u053e\13)\3*\5*\u0541\n*\3*\3*\3") buf.write("*\3*\3+\5+\u0548\n+\3+\3+\3+\3+\3,\3,\3,\3,\5,\u0552\n") buf.write(",\3-\3-\3-\3-\3-\3-\3-\3-\5-\u055c\n-\3-\3-\3-\3-\3-\3") @@ -178,13 +179,13 @@ def serializedATN(): buf.write("\13b\3b\3b\3c\3c\3c\3d\3d\3d\3e\3e\3f\3f\5f\u072d\nf\3") buf.write("g\3g\5g\u0731\ng\3h\3h\3h\3h\3h\5h\u0738\nh\3i\3i\3i\3") buf.write("j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3o\3o\3o\2\4\6\bp\2\4\6\b") - buf.write("\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668") + buf.write('\n\f\16\20\22\24\26\30\32\34\36 "$&(*,.\60\62\64\668') buf.write(":<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084") buf.write("\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096") buf.write("\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8") buf.write("\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba") buf.write("\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc") - buf.write("\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\2\'\4") + buf.write("\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\2'\4") buf.write("\2\17\20\64\64\3\2\21\22\4\2\17\20``\3\2\62\63\3\2\66") buf.write("\67\3\2+,\4\2\u00cc\u00cc\u00ce\u00ce\3\2\u00c3\u00c4") buf.write("\3\2\u00c5\u00c6\5\2__ac\u0085\u0086\6\2WWYYnn\u0089\u008b") @@ -201,7 +202,7 @@ def serializedATN(): buf.write("\u0190\3\2\2\2\20\u0192\3\2\2\2\22\u019b\3\2\2\2\24\u01a3") buf.write("\3\2\2\2\26\u01a6\3\2\2\2\30\u01af\3\2\2\2\32\u01b8\3") buf.write("\2\2\2\34\u01bd\3\2\2\2\36\u01ca\3\2\2\2 \u01df\3\2\2") - buf.write("\2\"\u0213\3\2\2\2$\u024e\3\2\2\2&\u0289\3\2\2\2(\u028d") + buf.write('\2"\u0213\3\2\2\2$\u024e\3\2\2\2&\u0289\3\2\2\2(\u028d') buf.write("\3\2\2\2*\u0291\3\2\2\2,\u02c3\3\2\2\2.\u02f5\3\2\2\2") buf.write("\60\u030c\3\2\2\2\62\u0323\3\2\2\2\64\u0345\3\2\2\2\66") buf.write("\u035c\3\2\2\28\u03c4\3\2\2\2:\u042c\3\2\2\2<\u044b\3") @@ -238,7 +239,7 @@ def serializedATN(): buf.write("\3\2\2\2\u00e8\u00e9\5\u00bc_\2\u00e9\u00ea\7\26\2\2\u00ea") buf.write("\u00eb\5\6\4\2\u00eb\u00f2\3\2\2\2\u00ec\u00ed\5\u00bc") buf.write("_\2\u00ed\u00ee\7~\2\2\u00ee\u00ef\5\6\4\2\u00ef\u00f2") - buf.write("\3\2\2\2\u00f0\u00f2\5\"\22\2\u00f1\u00e8\3\2\2\2\u00f1") + buf.write('\3\2\2\2\u00f0\u00f2\5"\22\2\u00f1\u00e8\3\2\2\2\u00f1') buf.write("\u00ec\3\2\2\2\u00f1\u00f0\3\2\2\2\u00f2\5\3\2\2\2\u00f3") buf.write("\u00f4\b\4\1\2\u00f4\u00f5\7\3\2\2\u00f5\u00f6\5\6\4\2") buf.write("\u00f6\u00f7\7\4\2\2\u00f7\u0112\3\2\2\2\u00f8\u0112\5") @@ -300,14 +301,14 @@ def serializedATN(): buf.write("\u016f\3\2\2\2\u016f\t\3\2\2\2\u0170\u016e\3\2\2\2\u0171") buf.write("\u017a\5&\24\2\u0172\u017a\5.\30\2\u0173\u017a\5\62\32") buf.write("\2\u0174\u017a\5\66\34\2\u0175\u017a\5:\36\2\u0176\u017a") - buf.write("\5D#\2\u0177\u017a\5F$\2\u0178\u017a\5L\'\2\u0179\u0171") + buf.write("\5D#\2\u0177\u017a\5F$\2\u0178\u017a\5L'\2\u0179\u0171") buf.write("\3\2\2\2\u0179\u0172\3\2\2\2\u0179\u0173\3\2\2\2\u0179") buf.write("\u0174\3\2\2\2\u0179\u0175\3\2\2\2\u0179\u0176\3\2\2\2") buf.write("\u0179\u0177\3\2\2\2\u0179\u0178\3\2\2\2\u017a\13\3\2") buf.write("\2\2\u017b\u0188\5 \21\2\u017c\u0188\5$\23\2\u017d\u0188") buf.write("\5,\27\2\u017e\u0188\5\60\31\2\u017f\u0188\5\64\33\2\u0180") buf.write("\u0188\58\35\2\u0181\u0188\5<\37\2\u0182\u0188\5> \2\u0183") - buf.write("\u0188\5@!\2\u0184\u0188\5B\"\2\u0185\u0188\5H%\2\u0186") + buf.write('\u0188\5@!\2\u0184\u0188\5B"\2\u0185\u0188\5H%\2\u0186') buf.write("\u0188\5J&\2\u0187\u017b\3\2\2\2\u0187\u017c\3\2\2\2\u0187") buf.write("\u017d\3\2\2\2\u0187\u017e\3\2\2\2\u0187\u017f\3\2\2\2") buf.write("\u0187\u0180\3\2\2\2\u0187\u0181\3\2\2\2\u0187\u0182\3") @@ -424,7 +425,7 @@ def serializedATN(): buf.write("\7\u00cb\2\2\u0284\u0286\5x=\2\u0285\u0283\3\2\2\2\u0285") buf.write("\u0286\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0288\7\4\2\2") buf.write("\u0288\u028a\3\2\2\2\u0289\u0250\3\2\2\2\u0289\u025e\3") - buf.write("\2\2\2\u0289\u026c\3\2\2\2\u028a\'\3\2\2\2\u028b\u028e") + buf.write("\2\2\2\u0289\u026c\3\2\2\2\u028a'\3\2\2\2\u028b\u028e") buf.write("\5\b\5\2\u028c\u028e\7u\2\2\u028d\u028b\3\2\2\2\u028d") buf.write("\u028c\3\2\2\2\u028e)\3\2\2\2\u028f\u0292\5\6\4\2\u0290") buf.write("\u0292\7u\2\2\u0291\u028f\3\2\2\2\u0291\u0290\3\2\2\2") @@ -539,7 +540,7 @@ def serializedATN(): buf.write("\u0393\u0394\7!\2\2\u0394\u0395\7\3\2\2\u0395\u0396\5") buf.write("\6\4\2\u0396\u0397\7\23\2\2\u0397\u0398\5\6\4\2\u0398") buf.write("\u0399\7\23\2\2\u0399\u039a\5\6\4\2\u039a\u039b\7\4\2") - buf.write("\2\u039b\u03c5\3\2\2\2\u039c\u039d\7\"\2\2\u039d\u039e") + buf.write('\2\u039b\u03c5\3\2\2\2\u039c\u039d\7"\2\2\u039d\u039e') buf.write("\7\3\2\2\u039e\u039f\5\6\4\2\u039f\u03a0\7\4\2\2\u03a0") buf.write("\u03c5\3\2\2\2\u03a1\u03a2\7#\2\2\u03a2\u03a3\7\3\2\2") buf.write("\u03a3\u03a4\5\6\4\2\u03a4\u03a5\7\4\2\2\u03a5\u03c5\3") @@ -548,7 +549,7 @@ def serializedATN(): buf.write("\u03ac\7%\2\2\u03ac\u03ad\7\3\2\2\u03ad\u03ae\5\6\4\2") buf.write("\u03ae\u03af\7\4\2\2\u03af\u03c5\3\2\2\2\u03b0\u03b1\7") buf.write("&\2\2\u03b1\u03b2\7\3\2\2\u03b2\u03b3\5\6\4\2\u03b3\u03b4") - buf.write("\7\4\2\2\u03b4\u03c5\3\2\2\2\u03b5\u03b6\7\'\2\2\u03b6") + buf.write("\7\4\2\2\u03b4\u03c5\3\2\2\2\u03b5\u03b6\7'\2\2\u03b6") buf.write("\u03b7\7\3\2\2\u03b7\u03b8\5\6\4\2\u03b8\u03b9\7\4\2\2") buf.write("\u03b9\u03c5\3\2\2\2\u03ba\u03bb\7(\2\2\u03bb\u03bc\7") buf.write("\3\2\2\u03bc\u03bd\5\6\4\2\u03bd\u03be\7\4\2\2\u03be\u03c5") @@ -585,7 +586,7 @@ def serializedATN(): buf.write("\u03fb\u03fc\7!\2\2\u03fc\u03fd\7\3\2\2\u03fd\u03fe\5") buf.write("\b\5\2\u03fe\u03ff\7\23\2\2\u03ff\u0400\5\b\5\2\u0400") buf.write("\u0401\7\23\2\2\u0401\u0402\5\b\5\2\u0402\u0403\7\4\2") - buf.write("\2\u0403\u042d\3\2\2\2\u0404\u0405\7\"\2\2\u0405\u0406") + buf.write('\2\u0403\u042d\3\2\2\2\u0404\u0405\7"\2\2\u0405\u0406') buf.write("\7\3\2\2\u0406\u0407\5\b\5\2\u0407\u0408\7\4\2\2\u0408") buf.write("\u042d\3\2\2\2\u0409\u040a\7#\2\2\u040a\u040b\7\3\2\2") buf.write("\u040b\u040c\5\b\5\2\u040c\u040d\7\4\2\2\u040d\u042d\3") @@ -594,7 +595,7 @@ def serializedATN(): buf.write("\u0414\7%\2\2\u0414\u0415\7\3\2\2\u0415\u0416\5\b\5\2") buf.write("\u0416\u0417\7\4\2\2\u0417\u042d\3\2\2\2\u0418\u0419\7") buf.write("&\2\2\u0419\u041a\7\3\2\2\u041a\u041b\5\b\5\2\u041b\u041c") - buf.write("\7\4\2\2\u041c\u042d\3\2\2\2\u041d\u041e\7\'\2\2\u041e") + buf.write("\7\4\2\2\u041c\u042d\3\2\2\2\u041d\u041e\7'\2\2\u041e") buf.write("\u041f\7\3\2\2\u041f\u0420\5\b\5\2\u0420\u0421\7\4\2\2") buf.write("\u0421\u042d\3\2\2\2\u0422\u0423\7(\2\2\u0423\u0424\7") buf.write("\3\2\2\u0424\u0425\5\b\5\2\u0425\u0426\7\4\2\2\u0426\u042d") @@ -927,7 +928,7 @@ def serializedATN(): buf.write("\u0701\3\2\2\2\u0701\u00b1\3\2\2\2\u0702\u0700\3\2\2\2") buf.write("\u0703\u0704\t \2\2\u0704\u00b3\3\2\2\2\u0705\u0706\7") buf.write("H\2\2\u0706\u0707\5\6\4\2\u0707\u00b5\3\2\2\2\u0708\u0709") - buf.write("\t!\2\2\u0709\u00b7\3\2\2\2\u070a\u070b\t\"\2\2\u070b") + buf.write('\t!\2\2\u0709\u00b7\3\2\2\2\u070a\u070b\t"\2\2\u070b') buf.write("\u00b9\3\2\2\2\u070c\u070d\7\u00f7\2\2\u070d\u00bb\3\2") buf.write("\2\2\u070e\u070f\7\u00f7\2\2\u070f\u00bd\3\2\2\2\u0710") buf.write("\u0711\7\u00f7\2\2\u0711\u00bf\3\2\2\2\u0712\u0715\7\u00f7") @@ -980,119 +981,517 @@ def serializedATN(): class Parser(ANTLRParser): - grammarFileName = "Vtl.g4" atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] sharedContextCache = PredictionContextCache() - literalNames = [ "", "'('", "')'", "'['", "']'", "'{'", "'}'", - "'='", "'<'", "'>'", "'>='", "'<>'", "'<='", "'+'", - "'-'", "'*'", "'/'", "','", "'->'", "':'", "':='", - "'#'", "'eval'", "'if'", "'case'", "'then'", "'else'", - "'using'", "'with'", "'current_date'", "'datediff'", - "'dateadd'", "'year'", "'month'", "'dayofmonth'", "'dayofyear'", - "'daytoyear'", "'daytomonth'", "'yeartoday'", "'monthtoday'", - "'on'", "'drop'", "'keep'", "'calc'", "'attrcalc'", - "'rename'", "'as'", "'and'", "'or'", "'xor'", "'not'", - "'between'", "'in'", "'not_in'", "'null'", "'isnull'", - "'ex'", "'union'", "'diff'", "'symdiff'", "'intersect'", - "'random'", "'keys'", "'intyear'", "'intmonth'", "'intday'", - "'check'", "'exists_in'", "'to'", "'return'", "'imbalance'", - "'errorcode'", "'all'", "'aggr'", "'errorlevel'", "'order'", - "'by'", "'rank'", "'asc'", "'desc'", "'min'", "'max'", - "'first'", "'last'", "'indexof'", "'abs'", "'key'", - "'ln'", "'log'", "'trunc'", "'round'", "'power'", "'mod'", - "'length'", "'||'", "'trim'", "'upper'", "'lower'", - "'substr'", "'sum'", "'avg'", "'median'", "'count'", - "'identifier'", "'measure'", "'attribute'", "'filter'", - "'merge'", "'exp'", "'componentRole'", "'viral'", "'match_characters'", - "'type'", "'nvl'", "'hierarchy'", "'_'", "'invalid'", - "'valuedomain'", "'variable'", "'data'", "'structure'", - "'dataset'", "'operator'", "'define'", "'<-'", "'datapoint'", - "'hierarchical'", "'ruleset'", "'rule'", "'end'", "'alterDataset'", - "'ltrim'", "'rtrim'", "'instr'", "'replace'", "'ceil'", - "'floor'", "'sqrt'", "'any'", "'setdiff'", "'stddev_pop'", - "'stddev_samp'", "'var_pop'", "'var_samp'", "'group'", - "'except'", "'having'", "'first_value'", "'last_value'", - "'lag'", "'lead'", "'ratio_to_report'", "'over'", "'preceding'", - "'following'", "'unbounded'", "'partition'", "'rows'", - "'range'", "'current'", "'valid'", "'fill_time_series'", - "'flow_to_stock'", "'stock_to_flow'", "'timeshift'", - "'measures'", "'no_measures'", "'condition'", "'boolean'", - "'date'", "'time_period'", "'number'", "'string'", - "'time'", "'integer'", "'float'", "'list'", "'record'", - "'restrict'", "'yyyy'", "'mm'", "'dd'", "'maxLength'", - "'regexp'", "'is'", "'when'", "'from'", "'aggregates'", - "'points'", "'point'", "'total'", "'partial'", "'always'", - "'inner_join'", "'left_join'", "'cross_join'", "'full_join'", - "'maps_from'", "'maps_to'", "'map_to'", "'map_from'", - "'returns'", "'pivot'", "'customPivot'", "'unpivot'", - "'sub'", "'apply'", "'conditioned'", "'period_indicator'", - "'single'", "'duration'", "'time_agg'", "'unit'", "'Value'", - "'valuedomains'", "'variables'", "'input'", "'output'", - "'cast'", "'rule_priority'", "'dataset_priority'", - "'default'", "'check_datapoint'", "'check_hierarchy'", - "'computed'", "'non_null'", "'non_zero'", "'partial_null'", - "'partial_zero'", "'always_null'", "'always_zero'", - "'components'", "'all_measures'", "'scalar'", "'component'", - "'datapoint_on_valuedomains'", "'datapoint_on_variables'", - "'hierarchical_on_valuedomains'", "'hierarchical_on_variables'", - "'set'", "'language'", "", "", "", - "", "", "", "';'" ] - - symbolicNames = [ "", "LPAREN", "RPAREN", "QLPAREN", "QRPAREN", - "GLPAREN", "GRPAREN", "EQ", "LT", "MT", "ME", "NEQ", - "LE", "PLUS", "MINUS", "MUL", "DIV", "COMMA", "POINTER", - "COLON", "ASSIGN", "MEMBERSHIP", "EVAL", "IF", "CASE", - "THEN", "ELSE", "USING", "WITH", "CURRENT_DATE", "DATEDIFF", - "DATEADD", "YEAR_OP", "MONTH_OP", "DAYOFMONTH", "DAYOFYEAR", - "DAYTOYEAR", "DAYTOMONTH", "YEARTODAY", "MONTHTODAY", - "ON", "DROP", "KEEP", "CALC", "ATTRCALC", "RENAME", - "AS", "AND", "OR", "XOR", "NOT", "BETWEEN", "IN", - "NOT_IN", "NULL_CONSTANT", "ISNULL", "EX", "UNION", - "DIFF", "SYMDIFF", "INTERSECT", "RANDOM", "KEYS", - "INTYEAR", "INTMONTH", "INTDAY", "CHECK", "EXISTS_IN", - "TO", "RETURN", "IMBALANCE", "ERRORCODE", "ALL", "AGGREGATE", - "ERRORLEVEL", "ORDER", "BY", "RANK", "ASC", "DESC", - "MIN", "MAX", "FIRST", "LAST", "INDEXOF", "ABS", "KEY", - "LN", "LOG", "TRUNC", "ROUND", "POWER", "MOD", "LEN", - "CONCAT", "TRIM", "UCASE", "LCASE", "SUBSTR", "SUM", - "AVG", "MEDIAN", "COUNT", "DIMENSION", "MEASURE", - "ATTRIBUTE", "FILTER", "MERGE", "EXP", "ROLE", "VIRAL", - "CHARSET_MATCH", "TYPE", "NVL", "HIERARCHY", "OPTIONAL", - "INVALID", "VALUE_DOMAIN", "VARIABLE", "DATA", "STRUCTURE", - "DATASET", "OPERATOR", "DEFINE", "PUT_SYMBOL", "DATAPOINT", - "HIERARCHICAL", "RULESET", "RULE", "END", "ALTER_DATASET", - "LTRIM", "RTRIM", "INSTR", "REPLACE", "CEIL", "FLOOR", - "SQRT", "ANY", "SETDIFF", "STDDEV_POP", "STDDEV_SAMP", - "VAR_POP", "VAR_SAMP", "GROUP", "EXCEPT", "HAVING", - "FIRST_VALUE", "LAST_VALUE", "LAG", "LEAD", "RATIO_TO_REPORT", - "OVER", "PRECEDING", "FOLLOWING", "UNBOUNDED", "PARTITION", - "ROWS", "RANGE", "CURRENT", "VALID", "FILL_TIME_SERIES", - "FLOW_TO_STOCK", "STOCK_TO_FLOW", "TIMESHIFT", "MEASURES", - "NO_MEASURES", "CONDITION", "BOOLEAN", "DATE", "TIME_PERIOD", - "NUMBER", "STRING", "TIME", "INTEGER", "FLOAT", "LIST", - "RECORD", "RESTRICT", "YYYY", "MM", "DD", "MAX_LENGTH", - "REGEXP", "IS", "WHEN", "FROM", "AGGREGATES", "POINTS", - "POINT", "TOTAL", "PARTIAL", "ALWAYS", "INNER_JOIN", - "LEFT_JOIN", "CROSS_JOIN", "FULL_JOIN", "MAPS_FROM", - "MAPS_TO", "MAP_TO", "MAP_FROM", "RETURNS", "PIVOT", - "CUSTOMPIVOT", "UNPIVOT", "SUBSPACE", "APPLY", "CONDITIONED", - "PERIOD_INDICATOR", "SINGLE", "DURATION", "TIME_AGG", - "UNIT", "VALUE", "VALUEDOMAINS", "VARIABLES", "INPUT", - "OUTPUT", "CAST", "RULE_PRIORITY", "DATASET_PRIORITY", - "DEFAULT", "CHECK_DATAPOINT", "CHECK_HIERARCHY", "COMPUTED", - "NON_NULL", "NON_ZERO", "PARTIAL_NULL", "PARTIAL_ZERO", - "ALWAYS_NULL", "ALWAYS_ZERO", "COMPONENTS", "ALL_MEASURES", - "SCALAR", "COMPONENT", "DATAPOINT_ON_VD", "DATAPOINT_ON_VAR", - "HIERARCHICAL_ON_VD", "HIERARCHICAL_ON_VAR", "SET", - "LANGUAGE", "INTEGER_CONSTANT", "NUMBER_CONSTANT", - "BOOLEAN_CONSTANT", "STRING_CONSTANT", "IDENTIFIER", - "WS", "EOL", "ML_COMMENT", "SL_COMMENT" ] + literalNames = [ + "", + "'('", + "')'", + "'['", + "']'", + "'{'", + "'}'", + "'='", + "'<'", + "'>'", + "'>='", + "'<>'", + "'<='", + "'+'", + "'-'", + "'*'", + "'/'", + "','", + "'->'", + "':'", + "':='", + "'#'", + "'eval'", + "'if'", + "'case'", + "'then'", + "'else'", + "'using'", + "'with'", + "'current_date'", + "'datediff'", + "'dateadd'", + "'year'", + "'month'", + "'dayofmonth'", + "'dayofyear'", + "'daytoyear'", + "'daytomonth'", + "'yeartoday'", + "'monthtoday'", + "'on'", + "'drop'", + "'keep'", + "'calc'", + "'attrcalc'", + "'rename'", + "'as'", + "'and'", + "'or'", + "'xor'", + "'not'", + "'between'", + "'in'", + "'not_in'", + "'null'", + "'isnull'", + "'ex'", + "'union'", + "'diff'", + "'symdiff'", + "'intersect'", + "'random'", + "'keys'", + "'intyear'", + "'intmonth'", + "'intday'", + "'check'", + "'exists_in'", + "'to'", + "'return'", + "'imbalance'", + "'errorcode'", + "'all'", + "'aggr'", + "'errorlevel'", + "'order'", + "'by'", + "'rank'", + "'asc'", + "'desc'", + "'min'", + "'max'", + "'first'", + "'last'", + "'indexof'", + "'abs'", + "'key'", + "'ln'", + "'log'", + "'trunc'", + "'round'", + "'power'", + "'mod'", + "'length'", + "'||'", + "'trim'", + "'upper'", + "'lower'", + "'substr'", + "'sum'", + "'avg'", + "'median'", + "'count'", + "'identifier'", + "'measure'", + "'attribute'", + "'filter'", + "'merge'", + "'exp'", + "'componentRole'", + "'viral'", + "'match_characters'", + "'type'", + "'nvl'", + "'hierarchy'", + "'_'", + "'invalid'", + "'valuedomain'", + "'variable'", + "'data'", + "'structure'", + "'dataset'", + "'operator'", + "'define'", + "'<-'", + "'datapoint'", + "'hierarchical'", + "'ruleset'", + "'rule'", + "'end'", + "'alterDataset'", + "'ltrim'", + "'rtrim'", + "'instr'", + "'replace'", + "'ceil'", + "'floor'", + "'sqrt'", + "'any'", + "'setdiff'", + "'stddev_pop'", + "'stddev_samp'", + "'var_pop'", + "'var_samp'", + "'group'", + "'except'", + "'having'", + "'first_value'", + "'last_value'", + "'lag'", + "'lead'", + "'ratio_to_report'", + "'over'", + "'preceding'", + "'following'", + "'unbounded'", + "'partition'", + "'rows'", + "'range'", + "'current'", + "'valid'", + "'fill_time_series'", + "'flow_to_stock'", + "'stock_to_flow'", + "'timeshift'", + "'measures'", + "'no_measures'", + "'condition'", + "'boolean'", + "'date'", + "'time_period'", + "'number'", + "'string'", + "'time'", + "'integer'", + "'float'", + "'list'", + "'record'", + "'restrict'", + "'yyyy'", + "'mm'", + "'dd'", + "'maxLength'", + "'regexp'", + "'is'", + "'when'", + "'from'", + "'aggregates'", + "'points'", + "'point'", + "'total'", + "'partial'", + "'always'", + "'inner_join'", + "'left_join'", + "'cross_join'", + "'full_join'", + "'maps_from'", + "'maps_to'", + "'map_to'", + "'map_from'", + "'returns'", + "'pivot'", + "'customPivot'", + "'unpivot'", + "'sub'", + "'apply'", + "'conditioned'", + "'period_indicator'", + "'single'", + "'duration'", + "'time_agg'", + "'unit'", + "'Value'", + "'valuedomains'", + "'variables'", + "'input'", + "'output'", + "'cast'", + "'rule_priority'", + "'dataset_priority'", + "'default'", + "'check_datapoint'", + "'check_hierarchy'", + "'computed'", + "'non_null'", + "'non_zero'", + "'partial_null'", + "'partial_zero'", + "'always_null'", + "'always_zero'", + "'components'", + "'all_measures'", + "'scalar'", + "'component'", + "'datapoint_on_valuedomains'", + "'datapoint_on_variables'", + "'hierarchical_on_valuedomains'", + "'hierarchical_on_variables'", + "'set'", + "'language'", + "", + "", + "", + "", + "", + "", + "';'", + ] + + symbolicNames = [ + "", + "LPAREN", + "RPAREN", + "QLPAREN", + "QRPAREN", + "GLPAREN", + "GRPAREN", + "EQ", + "LT", + "MT", + "ME", + "NEQ", + "LE", + "PLUS", + "MINUS", + "MUL", + "DIV", + "COMMA", + "POINTER", + "COLON", + "ASSIGN", + "MEMBERSHIP", + "EVAL", + "IF", + "CASE", + "THEN", + "ELSE", + "USING", + "WITH", + "CURRENT_DATE", + "DATEDIFF", + "DATEADD", + "YEAR_OP", + "MONTH_OP", + "DAYOFMONTH", + "DAYOFYEAR", + "DAYTOYEAR", + "DAYTOMONTH", + "YEARTODAY", + "MONTHTODAY", + "ON", + "DROP", + "KEEP", + "CALC", + "ATTRCALC", + "RENAME", + "AS", + "AND", + "OR", + "XOR", + "NOT", + "BETWEEN", + "IN", + "NOT_IN", + "NULL_CONSTANT", + "ISNULL", + "EX", + "UNION", + "DIFF", + "SYMDIFF", + "INTERSECT", + "RANDOM", + "KEYS", + "INTYEAR", + "INTMONTH", + "INTDAY", + "CHECK", + "EXISTS_IN", + "TO", + "RETURN", + "IMBALANCE", + "ERRORCODE", + "ALL", + "AGGREGATE", + "ERRORLEVEL", + "ORDER", + "BY", + "RANK", + "ASC", + "DESC", + "MIN", + "MAX", + "FIRST", + "LAST", + "INDEXOF", + "ABS", + "KEY", + "LN", + "LOG", + "TRUNC", + "ROUND", + "POWER", + "MOD", + "LEN", + "CONCAT", + "TRIM", + "UCASE", + "LCASE", + "SUBSTR", + "SUM", + "AVG", + "MEDIAN", + "COUNT", + "DIMENSION", + "MEASURE", + "ATTRIBUTE", + "FILTER", + "MERGE", + "EXP", + "ROLE", + "VIRAL", + "CHARSET_MATCH", + "TYPE", + "NVL", + "HIERARCHY", + "OPTIONAL", + "INVALID", + "VALUE_DOMAIN", + "VARIABLE", + "DATA", + "STRUCTURE", + "DATASET", + "OPERATOR", + "DEFINE", + "PUT_SYMBOL", + "DATAPOINT", + "HIERARCHICAL", + "RULESET", + "RULE", + "END", + "ALTER_DATASET", + "LTRIM", + "RTRIM", + "INSTR", + "REPLACE", + "CEIL", + "FLOOR", + "SQRT", + "ANY", + "SETDIFF", + "STDDEV_POP", + "STDDEV_SAMP", + "VAR_POP", + "VAR_SAMP", + "GROUP", + "EXCEPT", + "HAVING", + "FIRST_VALUE", + "LAST_VALUE", + "LAG", + "LEAD", + "RATIO_TO_REPORT", + "OVER", + "PRECEDING", + "FOLLOWING", + "UNBOUNDED", + "PARTITION", + "ROWS", + "RANGE", + "CURRENT", + "VALID", + "FILL_TIME_SERIES", + "FLOW_TO_STOCK", + "STOCK_TO_FLOW", + "TIMESHIFT", + "MEASURES", + "NO_MEASURES", + "CONDITION", + "BOOLEAN", + "DATE", + "TIME_PERIOD", + "NUMBER", + "STRING", + "TIME", + "INTEGER", + "FLOAT", + "LIST", + "RECORD", + "RESTRICT", + "YYYY", + "MM", + "DD", + "MAX_LENGTH", + "REGEXP", + "IS", + "WHEN", + "FROM", + "AGGREGATES", + "POINTS", + "POINT", + "TOTAL", + "PARTIAL", + "ALWAYS", + "INNER_JOIN", + "LEFT_JOIN", + "CROSS_JOIN", + "FULL_JOIN", + "MAPS_FROM", + "MAPS_TO", + "MAP_TO", + "MAP_FROM", + "RETURNS", + "PIVOT", + "CUSTOMPIVOT", + "UNPIVOT", + "SUBSPACE", + "APPLY", + "CONDITIONED", + "PERIOD_INDICATOR", + "SINGLE", + "DURATION", + "TIME_AGG", + "UNIT", + "VALUE", + "VALUEDOMAINS", + "VARIABLES", + "INPUT", + "OUTPUT", + "CAST", + "RULE_PRIORITY", + "DATASET_PRIORITY", + "DEFAULT", + "CHECK_DATAPOINT", + "CHECK_HIERARCHY", + "COMPUTED", + "NON_NULL", + "NON_ZERO", + "PARTIAL_NULL", + "PARTIAL_ZERO", + "ALWAYS_NULL", + "ALWAYS_ZERO", + "COMPONENTS", + "ALL_MEASURES", + "SCALAR", + "COMPONENT", + "DATAPOINT_ON_VD", + "DATAPOINT_ON_VAR", + "HIERARCHICAL_ON_VD", + "HIERARCHICAL_ON_VAR", + "SET", + "LANGUAGE", + "INTEGER_CONSTANT", + "NUMBER_CONSTANT", + "BOOLEAN_CONSTANT", + "STRING_CONSTANT", + "IDENTIFIER", + "WS", + "EOL", + "ML_COMMENT", + "SL_COMMENT", + ] RULE_start = 0 RULE_statement = 1 @@ -1205,318 +1604,395 @@ class Parser(ANTLRParser): RULE_basicScalarType = 108 RULE_retainType = 109 - ruleNames = [ "start", "statement", "expr", "exprComponent", "functionsComponents", - "functions", "datasetClause", "renameClause", "aggrClause", - "filterClause", "calcClause", "keepOrDropClause", "pivotOrUnpivotClause", - "customPivotClause", "subspaceClause", "joinOperators", - "defOperators", "genericOperators", "genericOperatorsComponent", - "parameterComponent", "parameter", "stringOperators", - "stringOperatorsComponent", "numericOperators", "numericOperatorsComponent", - "comparisonOperators", "comparisonOperatorsComponent", - "timeOperators", "timeOperatorsComponent", "setOperators", - "hierarchyOperators", "validationOperators", "conditionalOperators", - "conditionalOperatorsComponent", "aggrOperators", "aggrOperatorsGrouping", - "anFunction", "anFunctionComponent", "renameClauseItem", - "aggregateClause", "aggrFunctionClause", "calcClauseItem", - "subspaceClauseItem", "scalarItem", "joinClauseWithoutUsing", - "joinClause", "joinClauseItem", "joinBody", "joinApplyClause", - "partitionByClause", "orderByClause", "orderByItem", - "windowingClause", "signedInteger", "limitClauseItem", - "groupingClause", "havingClause", "parameterItem", "outputParameterType", - "outputParameterTypeComponent", "inputParameterType", - "rulesetType", "scalarType", "componentType", "datasetType", - "evalDatasetType", "scalarSetType", "dpRuleset", "hrRuleset", - "valueDomainName", "rulesetID", "rulesetSignature", "signature", - "ruleClauseDatapoint", "ruleItemDatapoint", "ruleClauseHierarchical", - "ruleItemHierarchical", "hierRuleSignature", "valueDomainSignature", - "codeItemRelation", "codeItemRelationClause", "valueDomainValue", - "scalarTypeConstraint", "compConstraint", "multModifier", - "validationOutput", "validationMode", "conditionClause", - "inputMode", "imbalanceExpr", "inputModeHierarchy", "outputModeHierarchy", - "alias", "varID", "simpleComponentId", "componentID", - "lists", "erCode", "erLevel", "comparisonOperand", "optionalExpr", - "optionalExprComponent", "componentRole", "viralAttribute", - "valueDomainID", "operatorID", "routineName", "constant", - "basicScalarType", "retainType" ] + ruleNames = [ + "start", + "statement", + "expr", + "exprComponent", + "functionsComponents", + "functions", + "datasetClause", + "renameClause", + "aggrClause", + "filterClause", + "calcClause", + "keepOrDropClause", + "pivotOrUnpivotClause", + "customPivotClause", + "subspaceClause", + "joinOperators", + "defOperators", + "genericOperators", + "genericOperatorsComponent", + "parameterComponent", + "parameter", + "stringOperators", + "stringOperatorsComponent", + "numericOperators", + "numericOperatorsComponent", + "comparisonOperators", + "comparisonOperatorsComponent", + "timeOperators", + "timeOperatorsComponent", + "setOperators", + "hierarchyOperators", + "validationOperators", + "conditionalOperators", + "conditionalOperatorsComponent", + "aggrOperators", + "aggrOperatorsGrouping", + "anFunction", + "anFunctionComponent", + "renameClauseItem", + "aggregateClause", + "aggrFunctionClause", + "calcClauseItem", + "subspaceClauseItem", + "scalarItem", + "joinClauseWithoutUsing", + "joinClause", + "joinClauseItem", + "joinBody", + "joinApplyClause", + "partitionByClause", + "orderByClause", + "orderByItem", + "windowingClause", + "signedInteger", + "limitClauseItem", + "groupingClause", + "havingClause", + "parameterItem", + "outputParameterType", + "outputParameterTypeComponent", + "inputParameterType", + "rulesetType", + "scalarType", + "componentType", + "datasetType", + "evalDatasetType", + "scalarSetType", + "dpRuleset", + "hrRuleset", + "valueDomainName", + "rulesetID", + "rulesetSignature", + "signature", + "ruleClauseDatapoint", + "ruleItemDatapoint", + "ruleClauseHierarchical", + "ruleItemHierarchical", + "hierRuleSignature", + "valueDomainSignature", + "codeItemRelation", + "codeItemRelationClause", + "valueDomainValue", + "scalarTypeConstraint", + "compConstraint", + "multModifier", + "validationOutput", + "validationMode", + "conditionClause", + "inputMode", + "imbalanceExpr", + "inputModeHierarchy", + "outputModeHierarchy", + "alias", + "varID", + "simpleComponentId", + "componentID", + "lists", + "erCode", + "erLevel", + "comparisonOperand", + "optionalExpr", + "optionalExprComponent", + "componentRole", + "viralAttribute", + "valueDomainID", + "operatorID", + "routineName", + "constant", + "basicScalarType", + "retainType", + ] EOF = Token.EOF - LPAREN=1 - RPAREN=2 - QLPAREN=3 - QRPAREN=4 - GLPAREN=5 - GRPAREN=6 - EQ=7 - LT=8 - MT=9 - ME=10 - NEQ=11 - LE=12 - PLUS=13 - MINUS=14 - MUL=15 - DIV=16 - COMMA=17 - POINTER=18 - COLON=19 - ASSIGN=20 - MEMBERSHIP=21 - EVAL=22 - IF=23 - CASE=24 - THEN=25 - ELSE=26 - USING=27 - WITH=28 - CURRENT_DATE=29 - DATEDIFF=30 - DATEADD=31 - YEAR_OP=32 - MONTH_OP=33 - DAYOFMONTH=34 - DAYOFYEAR=35 - DAYTOYEAR=36 - DAYTOMONTH=37 - YEARTODAY=38 - MONTHTODAY=39 - ON=40 - DROP=41 - KEEP=42 - CALC=43 - ATTRCALC=44 - RENAME=45 - AS=46 - AND=47 - OR=48 - XOR=49 - NOT=50 - BETWEEN=51 - IN=52 - NOT_IN=53 - NULL_CONSTANT=54 - ISNULL=55 - EX=56 - UNION=57 - DIFF=58 - SYMDIFF=59 - INTERSECT=60 - RANDOM=61 - KEYS=62 - INTYEAR=63 - INTMONTH=64 - INTDAY=65 - CHECK=66 - EXISTS_IN=67 - TO=68 - RETURN=69 - IMBALANCE=70 - ERRORCODE=71 - ALL=72 - AGGREGATE=73 - ERRORLEVEL=74 - ORDER=75 - BY=76 - RANK=77 - ASC=78 - DESC=79 - MIN=80 - MAX=81 - FIRST=82 - LAST=83 - INDEXOF=84 - ABS=85 - KEY=86 - LN=87 - LOG=88 - TRUNC=89 - ROUND=90 - POWER=91 - MOD=92 - LEN=93 - CONCAT=94 - TRIM=95 - UCASE=96 - LCASE=97 - SUBSTR=98 - SUM=99 - AVG=100 - MEDIAN=101 - COUNT=102 - DIMENSION=103 - MEASURE=104 - ATTRIBUTE=105 - FILTER=106 - MERGE=107 - EXP=108 - ROLE=109 - VIRAL=110 - CHARSET_MATCH=111 - TYPE=112 - NVL=113 - HIERARCHY=114 - OPTIONAL=115 - INVALID=116 - VALUE_DOMAIN=117 - VARIABLE=118 - DATA=119 - STRUCTURE=120 - DATASET=121 - OPERATOR=122 - DEFINE=123 - PUT_SYMBOL=124 - DATAPOINT=125 - HIERARCHICAL=126 - RULESET=127 - RULE=128 - END=129 - ALTER_DATASET=130 - LTRIM=131 - RTRIM=132 - INSTR=133 - REPLACE=134 - CEIL=135 - FLOOR=136 - SQRT=137 - ANY=138 - SETDIFF=139 - STDDEV_POP=140 - STDDEV_SAMP=141 - VAR_POP=142 - VAR_SAMP=143 - GROUP=144 - EXCEPT=145 - HAVING=146 - FIRST_VALUE=147 - LAST_VALUE=148 - LAG=149 - LEAD=150 - RATIO_TO_REPORT=151 - OVER=152 - PRECEDING=153 - FOLLOWING=154 - UNBOUNDED=155 - PARTITION=156 - ROWS=157 - RANGE=158 - CURRENT=159 - VALID=160 - FILL_TIME_SERIES=161 - FLOW_TO_STOCK=162 - STOCK_TO_FLOW=163 - TIMESHIFT=164 - MEASURES=165 - NO_MEASURES=166 - CONDITION=167 - BOOLEAN=168 - DATE=169 - TIME_PERIOD=170 - NUMBER=171 - STRING=172 - TIME=173 - INTEGER=174 - FLOAT=175 - LIST=176 - RECORD=177 - RESTRICT=178 - YYYY=179 - MM=180 - DD=181 - MAX_LENGTH=182 - REGEXP=183 - IS=184 - WHEN=185 - FROM=186 - AGGREGATES=187 - POINTS=188 - POINT=189 - TOTAL=190 - PARTIAL=191 - ALWAYS=192 - INNER_JOIN=193 - LEFT_JOIN=194 - CROSS_JOIN=195 - FULL_JOIN=196 - MAPS_FROM=197 - MAPS_TO=198 - MAP_TO=199 - MAP_FROM=200 - RETURNS=201 - PIVOT=202 - CUSTOMPIVOT=203 - UNPIVOT=204 - SUBSPACE=205 - APPLY=206 - CONDITIONED=207 - PERIOD_INDICATOR=208 - SINGLE=209 - DURATION=210 - TIME_AGG=211 - UNIT=212 - VALUE=213 - VALUEDOMAINS=214 - VARIABLES=215 - INPUT=216 - OUTPUT=217 - CAST=218 - RULE_PRIORITY=219 - DATASET_PRIORITY=220 - DEFAULT=221 - CHECK_DATAPOINT=222 - CHECK_HIERARCHY=223 - COMPUTED=224 - NON_NULL=225 - NON_ZERO=226 - PARTIAL_NULL=227 - PARTIAL_ZERO=228 - ALWAYS_NULL=229 - ALWAYS_ZERO=230 - COMPONENTS=231 - ALL_MEASURES=232 - SCALAR=233 - COMPONENT=234 - DATAPOINT_ON_VD=235 - DATAPOINT_ON_VAR=236 - HIERARCHICAL_ON_VD=237 - HIERARCHICAL_ON_VAR=238 - SET=239 - LANGUAGE=240 - INTEGER_CONSTANT=241 - NUMBER_CONSTANT=242 - BOOLEAN_CONSTANT=243 - STRING_CONSTANT=244 - IDENTIFIER=245 - WS=246 - EOL=247 - ML_COMMENT=248 - SL_COMMENT=249 - - def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + LPAREN = 1 + RPAREN = 2 + QLPAREN = 3 + QRPAREN = 4 + GLPAREN = 5 + GRPAREN = 6 + EQ = 7 + LT = 8 + MT = 9 + ME = 10 + NEQ = 11 + LE = 12 + PLUS = 13 + MINUS = 14 + MUL = 15 + DIV = 16 + COMMA = 17 + POINTER = 18 + COLON = 19 + ASSIGN = 20 + MEMBERSHIP = 21 + EVAL = 22 + IF = 23 + CASE = 24 + THEN = 25 + ELSE = 26 + USING = 27 + WITH = 28 + CURRENT_DATE = 29 + DATEDIFF = 30 + DATEADD = 31 + YEAR_OP = 32 + MONTH_OP = 33 + DAYOFMONTH = 34 + DAYOFYEAR = 35 + DAYTOYEAR = 36 + DAYTOMONTH = 37 + YEARTODAY = 38 + MONTHTODAY = 39 + ON = 40 + DROP = 41 + KEEP = 42 + CALC = 43 + ATTRCALC = 44 + RENAME = 45 + AS = 46 + AND = 47 + OR = 48 + XOR = 49 + NOT = 50 + BETWEEN = 51 + IN = 52 + NOT_IN = 53 + NULL_CONSTANT = 54 + ISNULL = 55 + EX = 56 + UNION = 57 + DIFF = 58 + SYMDIFF = 59 + INTERSECT = 60 + RANDOM = 61 + KEYS = 62 + INTYEAR = 63 + INTMONTH = 64 + INTDAY = 65 + CHECK = 66 + EXISTS_IN = 67 + TO = 68 + RETURN = 69 + IMBALANCE = 70 + ERRORCODE = 71 + ALL = 72 + AGGREGATE = 73 + ERRORLEVEL = 74 + ORDER = 75 + BY = 76 + RANK = 77 + ASC = 78 + DESC = 79 + MIN = 80 + MAX = 81 + FIRST = 82 + LAST = 83 + INDEXOF = 84 + ABS = 85 + KEY = 86 + LN = 87 + LOG = 88 + TRUNC = 89 + ROUND = 90 + POWER = 91 + MOD = 92 + LEN = 93 + CONCAT = 94 + TRIM = 95 + UCASE = 96 + LCASE = 97 + SUBSTR = 98 + SUM = 99 + AVG = 100 + MEDIAN = 101 + COUNT = 102 + DIMENSION = 103 + MEASURE = 104 + ATTRIBUTE = 105 + FILTER = 106 + MERGE = 107 + EXP = 108 + ROLE = 109 + VIRAL = 110 + CHARSET_MATCH = 111 + TYPE = 112 + NVL = 113 + HIERARCHY = 114 + OPTIONAL = 115 + INVALID = 116 + VALUE_DOMAIN = 117 + VARIABLE = 118 + DATA = 119 + STRUCTURE = 120 + DATASET = 121 + OPERATOR = 122 + DEFINE = 123 + PUT_SYMBOL = 124 + DATAPOINT = 125 + HIERARCHICAL = 126 + RULESET = 127 + RULE = 128 + END = 129 + ALTER_DATASET = 130 + LTRIM = 131 + RTRIM = 132 + INSTR = 133 + REPLACE = 134 + CEIL = 135 + FLOOR = 136 + SQRT = 137 + ANY = 138 + SETDIFF = 139 + STDDEV_POP = 140 + STDDEV_SAMP = 141 + VAR_POP = 142 + VAR_SAMP = 143 + GROUP = 144 + EXCEPT = 145 + HAVING = 146 + FIRST_VALUE = 147 + LAST_VALUE = 148 + LAG = 149 + LEAD = 150 + RATIO_TO_REPORT = 151 + OVER = 152 + PRECEDING = 153 + FOLLOWING = 154 + UNBOUNDED = 155 + PARTITION = 156 + ROWS = 157 + RANGE = 158 + CURRENT = 159 + VALID = 160 + FILL_TIME_SERIES = 161 + FLOW_TO_STOCK = 162 + STOCK_TO_FLOW = 163 + TIMESHIFT = 164 + MEASURES = 165 + NO_MEASURES = 166 + CONDITION = 167 + BOOLEAN = 168 + DATE = 169 + TIME_PERIOD = 170 + NUMBER = 171 + STRING = 172 + TIME = 173 + INTEGER = 174 + FLOAT = 175 + LIST = 176 + RECORD = 177 + RESTRICT = 178 + YYYY = 179 + MM = 180 + DD = 181 + MAX_LENGTH = 182 + REGEXP = 183 + IS = 184 + WHEN = 185 + FROM = 186 + AGGREGATES = 187 + POINTS = 188 + POINT = 189 + TOTAL = 190 + PARTIAL = 191 + ALWAYS = 192 + INNER_JOIN = 193 + LEFT_JOIN = 194 + CROSS_JOIN = 195 + FULL_JOIN = 196 + MAPS_FROM = 197 + MAPS_TO = 198 + MAP_TO = 199 + MAP_FROM = 200 + RETURNS = 201 + PIVOT = 202 + CUSTOMPIVOT = 203 + UNPIVOT = 204 + SUBSPACE = 205 + APPLY = 206 + CONDITIONED = 207 + PERIOD_INDICATOR = 208 + SINGLE = 209 + DURATION = 210 + TIME_AGG = 211 + UNIT = 212 + VALUE = 213 + VALUEDOMAINS = 214 + VARIABLES = 215 + INPUT = 216 + OUTPUT = 217 + CAST = 218 + RULE_PRIORITY = 219 + DATASET_PRIORITY = 220 + DEFAULT = 221 + CHECK_DATAPOINT = 222 + CHECK_HIERARCHY = 223 + COMPUTED = 224 + NON_NULL = 225 + NON_ZERO = 226 + PARTIAL_NULL = 227 + PARTIAL_ZERO = 228 + ALWAYS_NULL = 229 + ALWAYS_ZERO = 230 + COMPONENTS = 231 + ALL_MEASURES = 232 + SCALAR = 233 + COMPONENT = 234 + DATAPOINT_ON_VD = 235 + DATAPOINT_ON_VAR = 236 + HIERARCHICAL_ON_VD = 237 + HIERARCHICAL_ON_VAR = 238 + SET = 239 + LANGUAGE = 240 + INTEGER_CONSTANT = 241 + NUMBER_CONSTANT = 242 + BOOLEAN_CONSTANT = 243 + STRING_CONSTANT = 244 + IDENTIFIER = 245 + WS = 246 + EOL = 247 + ML_COMMENT = 248 + SL_COMMENT = 249 + + def __init__(self, input: TokenStream, output: TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.9.3") - self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._interp = ParserATNSimulator( + self, self.atn, self.decisionsToDFA, self.sharedContextCache + ) self._predicates = None - - - class StartContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def EOF(self): return self.getToken(Parser.EOF, 0) - def statement(self, i:int=None): + def statement(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.StatementContext) else: - return self.getTypedRuleContext(Parser.StatementContext,i) - + return self.getTypedRuleContext(Parser.StatementContext, i) - def EOL(self, i:int=None): + def EOL(self, i: int = None): if i is None: return self.getTokens(Parser.EOL) else: @@ -1525,34 +2001,31 @@ def EOL(self, i:int=None): def getRuleIndex(self): return Parser.RULE_start - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterStart" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStart"): listener.enterStart(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitStart" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStart"): listener.exitStart(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitStart" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStart"): return visitor.visitStart(self) else: return visitor.visitChildren(self) - - - def start(self): localctx = Parser.StartContext(self, self._ctx, self.state) self.enterRule(localctx, 0, self.RULE_start) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 225 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.DEFINE or _la==Parser.IDENTIFIER: + while _la == Parser.DEFINE or _la == Parser.IDENTIFIER: self.state = 220 self.statement() self.state = 221 @@ -1571,110 +2044,103 @@ def start(self): self.exitRule() return localctx - class StatementContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_statement - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class DefineExpressionContext(StatementContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StatementContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.StatementContext super().__init__(ANTLRParser) self.copyFrom(ctx) def defOperators(self): - return self.getTypedRuleContext(Parser.DefOperatorsContext,0) + return self.getTypedRuleContext(Parser.DefOperatorsContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDefineExpression" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDefineExpression"): listener.enterDefineExpression(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDefineExpression" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDefineExpression"): listener.exitDefineExpression(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDefineExpression" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDefineExpression"): return visitor.visitDefineExpression(self) else: return visitor.visitChildren(self) - class TemporaryAssignmentContext(StatementContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StatementContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.StatementContext super().__init__(ANTLRParser) self.copyFrom(ctx) def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext,0) + return self.getTypedRuleContext(Parser.VarIDContext, 0) def ASSIGN(self): return self.getToken(Parser.ASSIGN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + def expr(self): + return self.getTypedRuleContext(Parser.ExprContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTemporaryAssignment" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTemporaryAssignment"): listener.enterTemporaryAssignment(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTemporaryAssignment" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTemporaryAssignment"): listener.exitTemporaryAssignment(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTemporaryAssignment" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTemporaryAssignment"): return visitor.visitTemporaryAssignment(self) else: return visitor.visitChildren(self) - class PersistAssignmentContext(StatementContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StatementContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.StatementContext super().__init__(ANTLRParser) self.copyFrom(ctx) def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext,0) + return self.getTypedRuleContext(Parser.VarIDContext, 0) def PUT_SYMBOL(self): return self.getToken(Parser.PUT_SYMBOL, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + def expr(self): + return self.getTypedRuleContext(Parser.ExprContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPersistAssignment" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPersistAssignment"): listener.enterPersistAssignment(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPersistAssignment" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPersistAssignment"): listener.exitPersistAssignment(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPersistAssignment" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPersistAssignment"): return visitor.visitPersistAssignment(self) else: return visitor.visitChildren(self) - - def statement(self): localctx = Parser.StatementContext(self, self._ctx, self.state) @@ -1682,7 +2148,7 @@ def statement(self): try: self.state = 239 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,1,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 1, self._ctx) if la_ == 1: localctx = Parser.TemporaryAssignmentContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -1712,7 +2178,6 @@ def statement(self): self.defOperators() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -1721,497 +2186,475 @@ def statement(self): self.exitRule() return localctx - class ExprContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_expr - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - class VarIdExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext,0) + return self.getTypedRuleContext(Parser.VarIDContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVarIdExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVarIdExpr"): listener.enterVarIdExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVarIdExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVarIdExpr"): listener.exitVarIdExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVarIdExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitVarIdExpr"): return visitor.visitVarIdExpr(self) else: return visitor.visitChildren(self) - class MembershipExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def MEMBERSHIP(self): return self.getToken(Parser.MEMBERSHIP, 0) - def simpleComponentId(self): - return self.getTypedRuleContext(Parser.SimpleComponentIdContext,0) + def simpleComponentId(self): + return self.getTypedRuleContext(Parser.SimpleComponentIdContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterMembershipExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMembershipExpr"): listener.enterMembershipExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitMembershipExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMembershipExpr"): listener.exitMembershipExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitMembershipExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMembershipExpr"): return visitor.visitMembershipExpr(self) else: return visitor.visitChildren(self) - class InNotInExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.op = None # Token + self.left = None # ExprContext + self.op = None # Token self.copyFrom(ctx) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def IN(self): return self.getToken(Parser.IN, 0) + def NOT_IN(self): return self.getToken(Parser.NOT_IN, 0) + def lists(self): - return self.getTypedRuleContext(Parser.ListsContext,0) + return self.getTypedRuleContext(Parser.ListsContext, 0) def valueDomainID(self): - return self.getTypedRuleContext(Parser.ValueDomainIDContext,0) - + return self.getTypedRuleContext(Parser.ValueDomainIDContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInNotInExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInNotInExpr"): listener.enterInNotInExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInNotInExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInNotInExpr"): listener.exitInNotInExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInNotInExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInNotInExpr"): return visitor.visitInNotInExpr(self) else: return visitor.visitChildren(self) - class BooleanExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.op = None # Token - self.right = None # ExprContext + self.left = None # ExprContext + self.op = None # Token + self.right = None # ExprContext self.copyFrom(ctx) - def expr(self, i:int=None): + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) def AND(self): return self.getToken(Parser.AND, 0) + def OR(self): return self.getToken(Parser.OR, 0) + def XOR(self): return self.getToken(Parser.XOR, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBooleanExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBooleanExpr"): listener.enterBooleanExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBooleanExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBooleanExpr"): listener.exitBooleanExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBooleanExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBooleanExpr"): return visitor.visitBooleanExpr(self) else: return visitor.visitChildren(self) - class ComparisonExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.op = None # ComparisonOperandContext - self.right = None # ExprContext + self.left = None # ExprContext + self.op = None # ComparisonOperandContext + self.right = None # ExprContext self.copyFrom(ctx) - def expr(self, i:int=None): + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) def comparisonOperand(self): - return self.getTypedRuleContext(Parser.ComparisonOperandContext,0) + return self.getTypedRuleContext(Parser.ComparisonOperandContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterComparisonExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterComparisonExpr"): listener.enterComparisonExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitComparisonExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitComparisonExpr"): listener.exitComparisonExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitComparisonExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComparisonExpr"): return visitor.visitComparisonExpr(self) else: return visitor.visitChildren(self) - class UnaryExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.op = None # Token - self.right = None # ExprContext + self.op = None # Token + self.right = None # ExprContext self.copyFrom(ctx) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def PLUS(self): return self.getToken(Parser.PLUS, 0) + def MINUS(self): return self.getToken(Parser.MINUS, 0) + def NOT(self): return self.getToken(Parser.NOT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUnaryExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUnaryExpr"): listener.enterUnaryExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUnaryExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUnaryExpr"): listener.exitUnaryExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUnaryExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryExpr"): return visitor.visitUnaryExpr(self) else: return visitor.visitChildren(self) - class FunctionsExpressionContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def functions(self): - return self.getTypedRuleContext(Parser.FunctionsContext,0) - + return self.getTypedRuleContext(Parser.FunctionsContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunctionsExpression" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunctionsExpression"): listener.enterFunctionsExpression(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunctionsExpression" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunctionsExpression"): listener.exitFunctionsExpression(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunctionsExpression" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFunctionsExpression"): return visitor.visitFunctionsExpression(self) else: return visitor.visitChildren(self) - class IfExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.conditionalExpr = None # ExprContext - self.thenExpr = None # ExprContext - self.elseExpr = None # ExprContext + self.conditionalExpr = None # ExprContext + self.thenExpr = None # ExprContext + self.elseExpr = None # ExprContext self.copyFrom(ctx) def IF(self): return self.getToken(Parser.IF, 0) + def THEN(self): return self.getToken(Parser.THEN, 0) + def ELSE(self): return self.getToken(Parser.ELSE, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) - + return self.getTypedRuleContext(Parser.ExprContext, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIfExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIfExpr"): listener.enterIfExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIfExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIfExpr"): listener.exitIfExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIfExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIfExpr"): return visitor.visitIfExpr(self) else: return visitor.visitChildren(self) - class ClauseExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.dataset = None # ExprContext - self.clause = None # DatasetClauseContext + self.dataset = None # ExprContext + self.clause = None # DatasetClauseContext self.copyFrom(ctx) def QLPAREN(self): return self.getToken(Parser.QLPAREN, 0) + def QRPAREN(self): return self.getToken(Parser.QRPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def datasetClause(self): - return self.getTypedRuleContext(Parser.DatasetClauseContext,0) + return self.getTypedRuleContext(Parser.DatasetClauseContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterClauseExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterClauseExpr"): listener.enterClauseExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitClauseExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitClauseExpr"): listener.exitClauseExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitClauseExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitClauseExpr"): return visitor.visitClauseExpr(self) else: return visitor.visitChildren(self) - class CaseExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CASE(self): return self.getToken(Parser.CASE, 0) + def ELSE(self): return self.getToken(Parser.ELSE, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) - def WHEN(self, i:int=None): + def WHEN(self, i: int = None): if i is None: return self.getTokens(Parser.WHEN) else: return self.getToken(Parser.WHEN, i) - def THEN(self, i:int=None): + + def THEN(self, i: int = None): if i is None: return self.getTokens(Parser.THEN) else: return self.getToken(Parser.THEN, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCaseExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCaseExpr"): listener.enterCaseExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCaseExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCaseExpr"): listener.exitCaseExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCaseExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCaseExpr"): return visitor.visitCaseExpr(self) else: return visitor.visitChildren(self) - class ArithmeticExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.op = None # Token - self.right = None # ExprContext + self.left = None # ExprContext + self.op = None # Token + self.right = None # ExprContext self.copyFrom(ctx) - def expr(self, i:int=None): + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) def MUL(self): return self.getToken(Parser.MUL, 0) + def DIV(self): return self.getToken(Parser.DIV, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterArithmeticExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterArithmeticExpr"): listener.enterArithmeticExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitArithmeticExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitArithmeticExpr"): listener.exitArithmeticExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitArithmeticExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArithmeticExpr"): return visitor.visitArithmeticExpr(self) else: return visitor.visitChildren(self) - class ParenthesisExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterParenthesisExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterParenthesisExpr"): listener.enterParenthesisExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitParenthesisExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitParenthesisExpr"): listener.exitParenthesisExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitParenthesisExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParenthesisExpr"): return visitor.visitParenthesisExpr(self) else: return visitor.visitChildren(self) - class ConstantExprContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) self.copyFrom(ctx) def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext,0) + return self.getTypedRuleContext(Parser.ConstantContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterConstantExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConstantExpr"): listener.enterConstantExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitConstantExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConstantExpr"): listener.exitConstantExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitConstantExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConstantExpr"): return visitor.visitConstantExpr(self) else: return visitor.visitChildren(self) - class ArithmeticExprOrConcatContext(ExprContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprContext + def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.op = None # Token - self.right = None # ExprContext + self.left = None # ExprContext + self.op = None # Token + self.right = None # ExprContext self.copyFrom(ctx) - def expr(self, i:int=None): + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) def PLUS(self): return self.getToken(Parser.PLUS, 0) + def MINUS(self): return self.getToken(Parser.MINUS, 0) + def CONCAT(self): return self.getToken(Parser.CONCAT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterArithmeticExprOrConcat" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterArithmeticExprOrConcat"): listener.enterArithmeticExprOrConcat(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitArithmeticExprOrConcat" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitArithmeticExprOrConcat"): listener.exitArithmeticExprOrConcat(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitArithmeticExprOrConcat" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArithmeticExprOrConcat"): return visitor.visitArithmeticExprOrConcat(self) else: return visitor.visitChildren(self) - - - def expr(self, _p:int=0): + def expr(self, _p: int = 0): _parentctx = self._ctx _parentState = self.state localctx = Parser.ExprContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 4 self.enterRecursionRule(localctx, 4, self.RULE_expr, _p) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 271 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,3,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 3, self._ctx) if la_ == 1: localctx = Parser.ParenthesisExprContext(self, localctx) self._ctx = localctx @@ -2240,7 +2683,13 @@ def expr(self, _p:int=0): self.state = 247 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT))) != 0)): + if not ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) & ((1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT)) + ) + != 0 + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2273,7 +2722,7 @@ def expr(self, _p:int=0): _prevctx = localctx self.state = 256 self.match(Parser.CASE) - self.state = 262 + self.state = 262 self._errHandler.sync(self) _la = self._input.LA(1) while True: @@ -2285,10 +2734,10 @@ def expr(self, _p:int=0): self.match(Parser.THEN) self.state = 260 self.expr(0) - self.state = 264 + self.state = 264 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la==Parser.WHEN): + if not (_la == Parser.WHEN): break self.state = 266 @@ -2313,31 +2762,33 @@ def expr(self, _p:int=0): self.varID() pass - self._ctx.stop = self._input.LT(-1) self.state = 305 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,6,self._ctx) - while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: - if _alt==1: + _alt = self._interp.adaptivePredict(self._input, 6, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx self.state = 303 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,5,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 5, self._ctx) if la_ == 1: - localctx = Parser.ArithmeticExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) + localctx = Parser.ArithmeticExprContext( + self, Parser.ExprContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 273 if not self.precpred(self._ctx, 10): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 10)") self.state = 274 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.MUL or _la==Parser.DIV): + if not (_la == Parser.MUL or _la == Parser.DIV): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2347,17 +2798,20 @@ def expr(self, _p:int=0): pass elif la_ == 2: - localctx = Parser.ArithmeticExprOrConcatContext(self, Parser.ExprContext(self, _parentctx, _parentState)) + localctx = Parser.ArithmeticExprOrConcatContext( + self, Parser.ExprContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 276 if not self.precpred(self._ctx, 9): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 9)") self.state = 277 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.PLUS or _la==Parser.MINUS or _la==Parser.CONCAT): + if not (_la == Parser.PLUS or _la == Parser.MINUS or _la == Parser.CONCAT): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2367,12 +2821,15 @@ def expr(self, _p:int=0): pass elif la_ == 3: - localctx = Parser.ComparisonExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) + localctx = Parser.ComparisonExprContext( + self, Parser.ExprContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 279 if not self.precpred(self._ctx, 8): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 8)") self.state = 280 localctx.op = self.comparisonOperand() @@ -2381,12 +2838,15 @@ def expr(self, _p:int=0): pass elif la_ == 4: - localctx = Parser.BooleanExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) + localctx = Parser.BooleanExprContext( + self, Parser.ExprContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 283 if not self.precpred(self._ctx, 6): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") self.state = 284 localctx.op = self.match(Parser.AND) @@ -2395,17 +2855,20 @@ def expr(self, _p:int=0): pass elif la_ == 5: - localctx = Parser.BooleanExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) + localctx = Parser.BooleanExprContext( + self, Parser.ExprContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 286 if not self.precpred(self._ctx, 5): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") self.state = 287 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.OR or _la==Parser.XOR): + if not (_la == Parser.OR or _la == Parser.XOR): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2415,12 +2878,15 @@ def expr(self, _p:int=0): pass elif la_ == 6: - localctx = Parser.ClauseExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) + localctx = Parser.ClauseExprContext( + self, Parser.ExprContext(self, _parentctx, _parentState) + ) localctx.dataset = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 289 if not self.precpred(self._ctx, 13): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 13)") self.state = 290 self.match(Parser.QLPAREN) @@ -2431,11 +2897,14 @@ def expr(self, _p:int=0): pass elif la_ == 7: - localctx = Parser.MembershipExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) + localctx = Parser.MembershipExprContext( + self, Parser.ExprContext(self, _parentctx, _parentState) + ) self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 294 if not self.precpred(self._ctx, 12): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 12)") self.state = 295 self.match(Parser.MEMBERSHIP) @@ -2444,17 +2913,20 @@ def expr(self, _p:int=0): pass elif la_ == 8: - localctx = Parser.InNotInExprContext(self, Parser.ExprContext(self, _parentctx, _parentState)) + localctx = Parser.InNotInExprContext( + self, Parser.ExprContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) self.state = 297 if not self.precpred(self._ctx, 7): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 7)") self.state = 298 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.IN or _la==Parser.NOT_IN): + if not (_la == Parser.IN or _la == Parser.NOT_IN): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2475,10 +2947,9 @@ def expr(self, _p:int=0): pass - self.state = 307 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,6,self._ctx) + _alt = self._interp.adaptivePredict(self._input, 6, self._ctx) except RecognitionException as re: localctx.exception = re @@ -2488,432 +2959,437 @@ def expr(self, _p:int=0): self.unrollRecursionContexts(_parentctx) return localctx - class ExprComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_exprComponent - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - class ArithmeticExprCompContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.op = None # Token - self.right = None # ExprComponentContext + self.left = None # ExprComponentContext + self.op = None # Token + self.right = None # ExprComponentContext self.copyFrom(ctx) - def exprComponent(self, i:int=None): + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) + return self.getTypedRuleContext(Parser.ExprComponentContext, i) def MUL(self): return self.getToken(Parser.MUL, 0) + def DIV(self): return self.getToken(Parser.DIV, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterArithmeticExprComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterArithmeticExprComp"): listener.enterArithmeticExprComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitArithmeticExprComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitArithmeticExprComp"): listener.exitArithmeticExprComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitArithmeticExprComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArithmeticExprComp"): return visitor.visitArithmeticExprComp(self) else: return visitor.visitChildren(self) - class IfExprCompContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.conditionalExpr = None # ExprComponentContext - self.thenExpr = None # ExprComponentContext - self.elseExpr = None # ExprComponentContext + self.conditionalExpr = None # ExprComponentContext + self.thenExpr = None # ExprComponentContext + self.elseExpr = None # ExprComponentContext self.copyFrom(ctx) def IF(self): return self.getToken(Parser.IF, 0) + def THEN(self): return self.getToken(Parser.THEN, 0) + def ELSE(self): return self.getToken(Parser.ELSE, 0) - def exprComponent(self, i:int=None): + + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) + return self.getTypedRuleContext(Parser.ExprComponentContext, i) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIfExprComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIfExprComp"): listener.enterIfExprComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIfExprComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIfExprComp"): listener.exitIfExprComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIfExprComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIfExprComp"): return visitor.visitIfExprComp(self) else: return visitor.visitChildren(self) - class ComparisonExprCompContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.right = None # ExprComponentContext + self.left = None # ExprComponentContext + self.right = None # ExprComponentContext self.copyFrom(ctx) def comparisonOperand(self): - return self.getTypedRuleContext(Parser.ComparisonOperandContext,0) + return self.getTypedRuleContext(Parser.ComparisonOperandContext, 0) - def exprComponent(self, i:int=None): + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) - + return self.getTypedRuleContext(Parser.ExprComponentContext, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterComparisonExprComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterComparisonExprComp"): listener.enterComparisonExprComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitComparisonExprComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitComparisonExprComp"): listener.exitComparisonExprComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitComparisonExprComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComparisonExprComp"): return visitor.visitComparisonExprComp(self) else: return visitor.visitChildren(self) - class FunctionsExpressionCompContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def functionsComponents(self): - return self.getTypedRuleContext(Parser.FunctionsComponentsContext,0) + return self.getTypedRuleContext(Parser.FunctionsComponentsContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunctionsExpressionComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunctionsExpressionComp"): listener.enterFunctionsExpressionComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunctionsExpressionComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunctionsExpressionComp"): listener.exitFunctionsExpressionComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunctionsExpressionComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFunctionsExpressionComp"): return visitor.visitFunctionsExpressionComp(self) else: return visitor.visitChildren(self) - class CompIdContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext,0) - + return self.getTypedRuleContext(Parser.ComponentIDContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCompId" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCompId"): listener.enterCompId(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCompId" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCompId"): listener.exitCompId(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCompId" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCompId"): return visitor.visitCompId(self) else: return visitor.visitChildren(self) - class ConstantExprCompContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext,0) + return self.getTypedRuleContext(Parser.ConstantContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterConstantExprComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConstantExprComp"): listener.enterConstantExprComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitConstantExprComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConstantExprComp"): listener.exitConstantExprComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitConstantExprComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConstantExprComp"): return visitor.visitConstantExprComp(self) else: return visitor.visitChildren(self) - class ArithmeticExprOrConcatCompContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.op = None # Token - self.right = None # ExprComponentContext + self.left = None # ExprComponentContext + self.op = None # Token + self.right = None # ExprComponentContext self.copyFrom(ctx) - def exprComponent(self, i:int=None): + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) + return self.getTypedRuleContext(Parser.ExprComponentContext, i) def PLUS(self): return self.getToken(Parser.PLUS, 0) + def MINUS(self): return self.getToken(Parser.MINUS, 0) + def CONCAT(self): return self.getToken(Parser.CONCAT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterArithmeticExprOrConcatComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterArithmeticExprOrConcatComp"): listener.enterArithmeticExprOrConcatComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitArithmeticExprOrConcatComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitArithmeticExprOrConcatComp"): listener.exitArithmeticExprOrConcatComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitArithmeticExprOrConcatComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArithmeticExprOrConcatComp"): return visitor.visitArithmeticExprOrConcatComp(self) else: return visitor.visitChildren(self) - class ParenthesisExprCompContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterParenthesisExprComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterParenthesisExprComp"): listener.enterParenthesisExprComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitParenthesisExprComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitParenthesisExprComp"): listener.exitParenthesisExprComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitParenthesisExprComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParenthesisExprComp"): return visitor.visitParenthesisExprComp(self) else: return visitor.visitChildren(self) - class InNotInExprCompContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.op = None # Token + self.left = None # ExprComponentContext + self.op = None # Token self.copyFrom(ctx) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def IN(self): return self.getToken(Parser.IN, 0) + def NOT_IN(self): return self.getToken(Parser.NOT_IN, 0) + def lists(self): - return self.getTypedRuleContext(Parser.ListsContext,0) + return self.getTypedRuleContext(Parser.ListsContext, 0) def valueDomainID(self): - return self.getTypedRuleContext(Parser.ValueDomainIDContext,0) + return self.getTypedRuleContext(Parser.ValueDomainIDContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInNotInExprComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInNotInExprComp"): listener.enterInNotInExprComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInNotInExprComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInNotInExprComp"): listener.exitInNotInExprComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInNotInExprComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInNotInExprComp"): return visitor.visitInNotInExprComp(self) else: return visitor.visitChildren(self) - class UnaryExprCompContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.right = None # ExprComponentContext + self.op = None # Token + self.right = None # ExprComponentContext self.copyFrom(ctx) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def PLUS(self): return self.getToken(Parser.PLUS, 0) + def MINUS(self): return self.getToken(Parser.MINUS, 0) + def NOT(self): return self.getToken(Parser.NOT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUnaryExprComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUnaryExprComp"): listener.enterUnaryExprComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUnaryExprComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUnaryExprComp"): listener.exitUnaryExprComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUnaryExprComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryExprComp"): return visitor.visitUnaryExprComp(self) else: return visitor.visitChildren(self) - class CaseExprCompContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CASE(self): return self.getToken(Parser.CASE, 0) + def ELSE(self): return self.getToken(Parser.ELSE, 0) - def exprComponent(self, i:int=None): + + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) + return self.getTypedRuleContext(Parser.ExprComponentContext, i) - def WHEN(self, i:int=None): + def WHEN(self, i: int = None): if i is None: return self.getTokens(Parser.WHEN) else: return self.getToken(Parser.WHEN, i) - def THEN(self, i:int=None): + + def THEN(self, i: int = None): if i is None: return self.getTokens(Parser.THEN) else: return self.getToken(Parser.THEN, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCaseExprComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCaseExprComp"): listener.enterCaseExprComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCaseExprComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCaseExprComp"): listener.exitCaseExprComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCaseExprComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCaseExprComp"): return visitor.visitCaseExprComp(self) else: return visitor.visitChildren(self) - class BooleanExprCompContext(ExprComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ExprComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ExprComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.op = None # Token - self.right = None # ExprComponentContext + self.left = None # ExprComponentContext + self.op = None # Token + self.right = None # ExprComponentContext self.copyFrom(ctx) - def exprComponent(self, i:int=None): + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) + return self.getTypedRuleContext(Parser.ExprComponentContext, i) def AND(self): return self.getToken(Parser.AND, 0) + def OR(self): return self.getToken(Parser.OR, 0) + def XOR(self): return self.getToken(Parser.XOR, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBooleanExprComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBooleanExprComp"): listener.enterBooleanExprComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBooleanExprComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBooleanExprComp"): listener.exitBooleanExprComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBooleanExprComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBooleanExprComp"): return visitor.visitBooleanExprComp(self) else: return visitor.visitChildren(self) - - - def exprComponent(self, _p:int=0): + def exprComponent(self, _p: int = 0): _parentctx = self._ctx _parentState = self.state localctx = Parser.ExprComponentContext(self, self._ctx, _parentState) _prevctx = localctx _startState = 6 self.enterRecursionRule(localctx, 6, self.RULE_exprComponent, _p) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 338 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,8,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 8, self._ctx) if la_ == 1: localctx = Parser.ParenthesisExprCompContext(self, localctx) self._ctx = localctx @@ -2942,7 +3418,13 @@ def exprComponent(self, _p:int=0): self.state = 314 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT))) != 0)): + if not ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) & ((1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT)) + ) + != 0 + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -2975,7 +3457,7 @@ def exprComponent(self, _p:int=0): _prevctx = localctx self.state = 323 self.match(Parser.CASE) - self.state = 329 + self.state = 329 self._errHandler.sync(self) _la = self._input.LA(1) while True: @@ -2987,10 +3469,10 @@ def exprComponent(self, _p:int=0): self.match(Parser.THEN) self.state = 327 self.exprComponent(0) - self.state = 331 + self.state = 331 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la==Parser.WHEN): + if not (_la == Parser.WHEN): break self.state = 333 @@ -3015,31 +3497,33 @@ def exprComponent(self, _p:int=0): self.componentID() pass - self._ctx.stop = self._input.LT(-1) self.state = 364 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,11,self._ctx) - while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: - if _alt==1: + _alt = self._interp.adaptivePredict(self._input, 11, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: if self._parseListeners is not None: self.triggerExitRuleEvent() _prevctx = localctx self.state = 362 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,10,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 10, self._ctx) if la_ == 1: - localctx = Parser.ArithmeticExprCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) + localctx = Parser.ArithmeticExprCompContext( + self, Parser.ExprComponentContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 340 if not self.precpred(self._ctx, 10): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 10)") self.state = 341 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.MUL or _la==Parser.DIV): + if not (_la == Parser.MUL or _la == Parser.DIV): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3049,17 +3533,20 @@ def exprComponent(self, _p:int=0): pass elif la_ == 2: - localctx = Parser.ArithmeticExprOrConcatCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) + localctx = Parser.ArithmeticExprOrConcatCompContext( + self, Parser.ExprComponentContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 343 if not self.precpred(self._ctx, 9): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 9)") self.state = 344 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.PLUS or _la==Parser.MINUS or _la==Parser.CONCAT): + if not (_la == Parser.PLUS or _la == Parser.MINUS or _la == Parser.CONCAT): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3069,12 +3556,15 @@ def exprComponent(self, _p:int=0): pass elif la_ == 3: - localctx = Parser.ComparisonExprCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) + localctx = Parser.ComparisonExprCompContext( + self, Parser.ExprComponentContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 346 if not self.precpred(self._ctx, 8): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 8)") self.state = 347 self.comparisonOperand() @@ -3083,12 +3573,15 @@ def exprComponent(self, _p:int=0): pass elif la_ == 4: - localctx = Parser.BooleanExprCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) + localctx = Parser.BooleanExprCompContext( + self, Parser.ExprComponentContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 350 if not self.precpred(self._ctx, 6): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") self.state = 351 localctx.op = self.match(Parser.AND) @@ -3097,17 +3590,20 @@ def exprComponent(self, _p:int=0): pass elif la_ == 5: - localctx = Parser.BooleanExprCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) + localctx = Parser.BooleanExprCompContext( + self, Parser.ExprComponentContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 353 if not self.precpred(self._ctx, 5): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") self.state = 354 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.OR or _la==Parser.XOR): + if not (_la == Parser.OR or _la == Parser.XOR): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3117,17 +3613,20 @@ def exprComponent(self, _p:int=0): pass elif la_ == 6: - localctx = Parser.InNotInExprCompContext(self, Parser.ExprComponentContext(self, _parentctx, _parentState)) + localctx = Parser.InNotInExprCompContext( + self, Parser.ExprComponentContext(self, _parentctx, _parentState) + ) localctx.left = _prevctx self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent) self.state = 356 if not self.precpred(self._ctx, 7): from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 7)") self.state = 357 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.IN or _la==Parser.NOT_IN): + if not (_la == Parser.IN or _la == Parser.NOT_IN): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3148,10 +3647,9 @@ def exprComponent(self, _p:int=0): pass - self.state = 366 self._errHandler.sync(self) - _alt = self._interp.adaptivePredict(self._input,11,self._ctx) + _alt = self._interp.adaptivePredict(self._input, 11, self._ctx) except RecognitionException as re: localctx.exception = re @@ -3161,225 +3659,211 @@ def exprComponent(self, _p:int=0): self.unrollRecursionContexts(_parentctx) return localctx - class FunctionsComponentsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_functionsComponents - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class NumericFunctionsComponentsContext(FunctionsComponentsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def numericOperatorsComponent(self): - return self.getTypedRuleContext(Parser.NumericOperatorsComponentContext,0) + return self.getTypedRuleContext(Parser.NumericOperatorsComponentContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNumericFunctionsComponents" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNumericFunctionsComponents"): listener.enterNumericFunctionsComponents(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNumericFunctionsComponents" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNumericFunctionsComponents"): listener.exitNumericFunctionsComponents(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitNumericFunctionsComponents" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNumericFunctionsComponents"): return visitor.visitNumericFunctionsComponents(self) else: return visitor.visitChildren(self) - class StringFunctionsComponentsContext(FunctionsComponentsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def stringOperatorsComponent(self): - return self.getTypedRuleContext(Parser.StringOperatorsComponentContext,0) - + return self.getTypedRuleContext(Parser.StringOperatorsComponentContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterStringFunctionsComponents" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStringFunctionsComponents"): listener.enterStringFunctionsComponents(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitStringFunctionsComponents" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStringFunctionsComponents"): listener.exitStringFunctionsComponents(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitStringFunctionsComponents" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringFunctionsComponents"): return visitor.visitStringFunctionsComponents(self) else: return visitor.visitChildren(self) - class ComparisonFunctionsComponentsContext(FunctionsComponentsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def comparisonOperatorsComponent(self): - return self.getTypedRuleContext(Parser.ComparisonOperatorsComponentContext,0) + return self.getTypedRuleContext(Parser.ComparisonOperatorsComponentContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterComparisonFunctionsComponents" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterComparisonFunctionsComponents"): listener.enterComparisonFunctionsComponents(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitComparisonFunctionsComponents" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitComparisonFunctionsComponents"): listener.exitComparisonFunctionsComponents(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitComparisonFunctionsComponents" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComparisonFunctionsComponents"): return visitor.visitComparisonFunctionsComponents(self) else: return visitor.visitChildren(self) - class TimeFunctionsComponentsContext(FunctionsComponentsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def timeOperatorsComponent(self): - return self.getTypedRuleContext(Parser.TimeOperatorsComponentContext,0) - + return self.getTypedRuleContext(Parser.TimeOperatorsComponentContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimeFunctionsComponents" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimeFunctionsComponents"): listener.enterTimeFunctionsComponents(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimeFunctionsComponents" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimeFunctionsComponents"): listener.exitTimeFunctionsComponents(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimeFunctionsComponents" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeFunctionsComponents"): return visitor.visitTimeFunctionsComponents(self) else: return visitor.visitChildren(self) - class GenericFunctionsComponentsContext(FunctionsComponentsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def genericOperatorsComponent(self): - return self.getTypedRuleContext(Parser.GenericOperatorsComponentContext,0) + return self.getTypedRuleContext(Parser.GenericOperatorsComponentContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterGenericFunctionsComponents" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericFunctionsComponents"): listener.enterGenericFunctionsComponents(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitGenericFunctionsComponents" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericFunctionsComponents"): listener.exitGenericFunctionsComponents(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitGenericFunctionsComponents" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericFunctionsComponents"): return visitor.visitGenericFunctionsComponents(self) else: return visitor.visitChildren(self) - class AnalyticFunctionsComponentsContext(FunctionsComponentsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def anFunctionComponent(self): - return self.getTypedRuleContext(Parser.AnFunctionComponentContext,0) - + return self.getTypedRuleContext(Parser.AnFunctionComponentContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAnalyticFunctionsComponents" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAnalyticFunctionsComponents"): listener.enterAnalyticFunctionsComponents(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAnalyticFunctionsComponents" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAnalyticFunctionsComponents"): listener.exitAnalyticFunctionsComponents(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAnalyticFunctionsComponents" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAnalyticFunctionsComponents"): return visitor.visitAnalyticFunctionsComponents(self) else: return visitor.visitChildren(self) - class ConditionalFunctionsComponentsContext(FunctionsComponentsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def conditionalOperatorsComponent(self): - return self.getTypedRuleContext(Parser.ConditionalOperatorsComponentContext,0) + return self.getTypedRuleContext(Parser.ConditionalOperatorsComponentContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterConditionalFunctionsComponents" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConditionalFunctionsComponents"): listener.enterConditionalFunctionsComponents(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitConditionalFunctionsComponents" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConditionalFunctionsComponents"): listener.exitConditionalFunctionsComponents(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitConditionalFunctionsComponents" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConditionalFunctionsComponents"): return visitor.visitConditionalFunctionsComponents(self) else: return visitor.visitChildren(self) - class AggregateFunctionsComponentsContext(FunctionsComponentsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsComponentsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsComponentsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def aggrOperators(self): - return self.getTypedRuleContext(Parser.AggrOperatorsContext,0) - + return self.getTypedRuleContext(Parser.AggrOperatorsContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAggregateFunctionsComponents" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAggregateFunctionsComponents"): listener.enterAggregateFunctionsComponents(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAggregateFunctionsComponents" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAggregateFunctionsComponents"): listener.exitAggregateFunctionsComponents(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAggregateFunctionsComponents" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggregateFunctionsComponents"): return visitor.visitAggregateFunctionsComponents(self) else: return visitor.visitChildren(self) - - def functionsComponents(self): localctx = Parser.FunctionsComponentsContext(self, self._ctx, self.state) @@ -3387,7 +3871,7 @@ def functionsComponents(self): try: self.state = 375 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,12,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 12, self._ctx) if la_ == 1: localctx = Parser.GenericFunctionsComponentsContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3444,7 +3928,6 @@ def functionsComponents(self): self.anFunctionComponent() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -3453,325 +3936,307 @@ def functionsComponents(self): self.exitRule() return localctx - class FunctionsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_functions - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class HierarchyFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def hierarchyOperators(self): - return self.getTypedRuleContext(Parser.HierarchyOperatorsContext,0) + return self.getTypedRuleContext(Parser.HierarchyOperatorsContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterHierarchyFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterHierarchyFunctions"): listener.enterHierarchyFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitHierarchyFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitHierarchyFunctions"): listener.exitHierarchyFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitHierarchyFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHierarchyFunctions"): return visitor.visitHierarchyFunctions(self) else: return visitor.visitChildren(self) - class StringFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def stringOperators(self): - return self.getTypedRuleContext(Parser.StringOperatorsContext,0) - + return self.getTypedRuleContext(Parser.StringOperatorsContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterStringFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStringFunctions"): listener.enterStringFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitStringFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStringFunctions"): listener.exitStringFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitStringFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringFunctions"): return visitor.visitStringFunctions(self) else: return visitor.visitChildren(self) - class ValidationFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def validationOperators(self): - return self.getTypedRuleContext(Parser.ValidationOperatorsContext,0) + return self.getTypedRuleContext(Parser.ValidationOperatorsContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterValidationFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterValidationFunctions"): listener.enterValidationFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitValidationFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitValidationFunctions"): listener.exitValidationFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitValidationFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidationFunctions"): return visitor.visitValidationFunctions(self) else: return visitor.visitChildren(self) - class GenericFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def genericOperators(self): - return self.getTypedRuleContext(Parser.GenericOperatorsContext,0) - + return self.getTypedRuleContext(Parser.GenericOperatorsContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterGenericFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericFunctions"): listener.enterGenericFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitGenericFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericFunctions"): listener.exitGenericFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitGenericFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericFunctions"): return visitor.visitGenericFunctions(self) else: return visitor.visitChildren(self) - class ConditionalFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def conditionalOperators(self): - return self.getTypedRuleContext(Parser.ConditionalOperatorsContext,0) + return self.getTypedRuleContext(Parser.ConditionalOperatorsContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterConditionalFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConditionalFunctions"): listener.enterConditionalFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitConditionalFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConditionalFunctions"): listener.exitConditionalFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitConditionalFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConditionalFunctions"): return visitor.visitConditionalFunctions(self) else: return visitor.visitChildren(self) - class AggregateFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def aggrOperatorsGrouping(self): - return self.getTypedRuleContext(Parser.AggrOperatorsGroupingContext,0) - + return self.getTypedRuleContext(Parser.AggrOperatorsGroupingContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAggregateFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAggregateFunctions"): listener.enterAggregateFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAggregateFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAggregateFunctions"): listener.exitAggregateFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAggregateFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggregateFunctions"): return visitor.visitAggregateFunctions(self) else: return visitor.visitChildren(self) - class JoinFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def joinOperators(self): - return self.getTypedRuleContext(Parser.JoinOperatorsContext,0) + return self.getTypedRuleContext(Parser.JoinOperatorsContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterJoinFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterJoinFunctions"): listener.enterJoinFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitJoinFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitJoinFunctions"): listener.exitJoinFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitJoinFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinFunctions"): return visitor.visitJoinFunctions(self) else: return visitor.visitChildren(self) - class ComparisonFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def comparisonOperators(self): - return self.getTypedRuleContext(Parser.ComparisonOperatorsContext,0) - + return self.getTypedRuleContext(Parser.ComparisonOperatorsContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterComparisonFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterComparisonFunctions"): listener.enterComparisonFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitComparisonFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitComparisonFunctions"): listener.exitComparisonFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitComparisonFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComparisonFunctions"): return visitor.visitComparisonFunctions(self) else: return visitor.visitChildren(self) - class NumericFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def numericOperators(self): - return self.getTypedRuleContext(Parser.NumericOperatorsContext,0) + return self.getTypedRuleContext(Parser.NumericOperatorsContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNumericFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNumericFunctions"): listener.enterNumericFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNumericFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNumericFunctions"): listener.exitNumericFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitNumericFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNumericFunctions"): return visitor.visitNumericFunctions(self) else: return visitor.visitChildren(self) - class TimeFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def timeOperators(self): - return self.getTypedRuleContext(Parser.TimeOperatorsContext,0) - + return self.getTypedRuleContext(Parser.TimeOperatorsContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimeFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimeFunctions"): listener.enterTimeFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimeFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimeFunctions"): listener.exitTimeFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimeFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeFunctions"): return visitor.visitTimeFunctions(self) else: return visitor.visitChildren(self) - class SetFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def setOperators(self): - return self.getTypedRuleContext(Parser.SetOperatorsContext,0) + return self.getTypedRuleContext(Parser.SetOperatorsContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSetFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSetFunctions"): listener.enterSetFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSetFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSetFunctions"): listener.exitSetFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSetFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSetFunctions"): return visitor.visitSetFunctions(self) else: return visitor.visitChildren(self) - class AnalyticFunctionsContext(FunctionsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.FunctionsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.FunctionsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def anFunction(self): - return self.getTypedRuleContext(Parser.AnFunctionContext,0) - + return self.getTypedRuleContext(Parser.AnFunctionContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAnalyticFunctions" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAnalyticFunctions"): listener.enterAnalyticFunctions(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAnalyticFunctions" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAnalyticFunctions"): listener.exitAnalyticFunctions(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAnalyticFunctions" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAnalyticFunctions"): return visitor.visitAnalyticFunctions(self) else: return visitor.visitChildren(self) - - def functions(self): localctx = Parser.FunctionsContext(self, self._ctx, self.state) @@ -3779,7 +4244,7 @@ def functions(self): try: self.state = 389 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,13,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 13, self._ctx) if la_ == 1: localctx = Parser.JoinFunctionsContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3864,7 +4329,6 @@ def functions(self): self.anFunction() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -3873,62 +4337,51 @@ def functions(self): self.exitRule() return localctx - class DatasetClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def renameClause(self): - return self.getTypedRuleContext(Parser.RenameClauseContext,0) - + return self.getTypedRuleContext(Parser.RenameClauseContext, 0) def aggrClause(self): - return self.getTypedRuleContext(Parser.AggrClauseContext,0) - + return self.getTypedRuleContext(Parser.AggrClauseContext, 0) def filterClause(self): - return self.getTypedRuleContext(Parser.FilterClauseContext,0) - + return self.getTypedRuleContext(Parser.FilterClauseContext, 0) def calcClause(self): - return self.getTypedRuleContext(Parser.CalcClauseContext,0) - + return self.getTypedRuleContext(Parser.CalcClauseContext, 0) def keepOrDropClause(self): - return self.getTypedRuleContext(Parser.KeepOrDropClauseContext,0) - + return self.getTypedRuleContext(Parser.KeepOrDropClauseContext, 0) def pivotOrUnpivotClause(self): - return self.getTypedRuleContext(Parser.PivotOrUnpivotClauseContext,0) - + return self.getTypedRuleContext(Parser.PivotOrUnpivotClauseContext, 0) def subspaceClause(self): - return self.getTypedRuleContext(Parser.SubspaceClauseContext,0) - + return self.getTypedRuleContext(Parser.SubspaceClauseContext, 0) def getRuleIndex(self): return Parser.RULE_datasetClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDatasetClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDatasetClause"): listener.enterDatasetClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDatasetClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDatasetClause"): listener.exitDatasetClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDatasetClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDatasetClause"): return visitor.visitDatasetClause(self) else: return visitor.visitChildren(self) - - - def datasetClause(self): localctx = Parser.DatasetClauseContext(self, self._ctx, self.state) @@ -3983,25 +4436,23 @@ def datasetClause(self): self.exitRule() return localctx - class RenameClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def RENAME(self): return self.getToken(Parser.RENAME, 0) - def renameClauseItem(self, i:int=None): + def renameClauseItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.RenameClauseItemContext) else: - return self.getTypedRuleContext(Parser.RenameClauseItemContext,i) - + return self.getTypedRuleContext(Parser.RenameClauseItemContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -4010,28 +4461,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_renameClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRenameClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRenameClause"): listener.enterRenameClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRenameClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRenameClause"): listener.exitRenameClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRenameClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRenameClause"): return visitor.visitRenameClause(self) else: return visitor.visitChildren(self) - - - def renameClause(self): localctx = Parser.RenameClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 14, self.RULE_renameClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 400 @@ -4041,7 +4489,7 @@ def renameClause(self): self.state = 406 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 402 self.match(Parser.COMMA) self.state = 403 @@ -4058,11 +4506,10 @@ def renameClause(self): self.exitRule() return localctx - class AggrClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -4070,42 +4517,36 @@ def AGGREGATE(self): return self.getToken(Parser.AGGREGATE, 0) def aggregateClause(self): - return self.getTypedRuleContext(Parser.AggregateClauseContext,0) - + return self.getTypedRuleContext(Parser.AggregateClauseContext, 0) def groupingClause(self): - return self.getTypedRuleContext(Parser.GroupingClauseContext,0) - + return self.getTypedRuleContext(Parser.GroupingClauseContext, 0) def havingClause(self): - return self.getTypedRuleContext(Parser.HavingClauseContext,0) - + return self.getTypedRuleContext(Parser.HavingClauseContext, 0) def getRuleIndex(self): return Parser.RULE_aggrClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAggrClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAggrClause"): listener.enterAggrClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAggrClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAggrClause"): listener.exitAggrClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAggrClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggrClause"): return visitor.visitAggrClause(self) else: return visitor.visitChildren(self) - - - def aggrClause(self): localctx = Parser.AggrClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 16, self.RULE_aggrClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 409 @@ -4115,19 +4556,16 @@ def aggrClause(self): self.state = 415 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.GROUP: + if _la == Parser.GROUP: self.state = 411 self.groupingClause() self.state = 413 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.HAVING: + if _la == Parser.HAVING: self.state = 412 self.havingClause() - - - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -4136,11 +4574,10 @@ def aggrClause(self): self.exitRule() return localctx - class FilterClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -4148,29 +4585,25 @@ def FILTER(self): return self.getToken(Parser.FILTER, 0) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) - + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def getRuleIndex(self): return Parser.RULE_filterClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFilterClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFilterClause"): listener.enterFilterClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFilterClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFilterClause"): listener.exitFilterClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFilterClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFilterClause"): return visitor.visitFilterClause(self) else: return visitor.visitChildren(self) - - - def filterClause(self): localctx = Parser.FilterClauseContext(self, self._ctx, self.state) @@ -4189,25 +4622,23 @@ def filterClause(self): self.exitRule() return localctx - class CalcClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def CALC(self): return self.getToken(Parser.CALC, 0) - def calcClauseItem(self, i:int=None): + def calcClauseItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.CalcClauseItemContext) else: - return self.getTypedRuleContext(Parser.CalcClauseItemContext,i) - + return self.getTypedRuleContext(Parser.CalcClauseItemContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -4216,28 +4647,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_calcClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCalcClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCalcClause"): listener.enterCalcClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCalcClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCalcClause"): listener.exitCalcClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCalcClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCalcClause"): return visitor.visitCalcClause(self) else: return visitor.visitChildren(self) - - - def calcClause(self): localctx = Parser.CalcClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 20, self.RULE_calcClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 420 @@ -4247,7 +4675,7 @@ def calcClause(self): self.state = 426 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 422 self.match(Parser.COMMA) self.state = 423 @@ -4264,21 +4692,19 @@ def calcClause(self): self.exitRule() return localctx - class KeepOrDropClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.op = None # Token + self.op = None # Token - def componentID(self, i:int=None): + def componentID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext,i) - + return self.getTypedRuleContext(Parser.ComponentIDContext, i) def KEEP(self): return self.getToken(Parser.KEEP, 0) @@ -4286,7 +4712,7 @@ def KEEP(self): def DROP(self): return self.getToken(Parser.DROP, 0) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -4295,34 +4721,31 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_keepOrDropClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterKeepOrDropClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterKeepOrDropClause"): listener.enterKeepOrDropClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitKeepOrDropClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitKeepOrDropClause"): listener.exitKeepOrDropClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitKeepOrDropClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitKeepOrDropClause"): return visitor.visitKeepOrDropClause(self) else: return visitor.visitChildren(self) - - - def keepOrDropClause(self): localctx = Parser.KeepOrDropClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 22, self.RULE_keepOrDropClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 429 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.DROP or _la==Parser.KEEP): + if not (_la == Parser.DROP or _la == Parser.KEEP): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4332,7 +4755,7 @@ def keepOrDropClause(self): self.state = 435 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 431 self.match(Parser.COMMA) self.state = 432 @@ -4349,26 +4772,24 @@ def keepOrDropClause(self): self.exitRule() return localctx - class PivotOrUnpivotClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.op = None # Token - self.id_ = None # ComponentIDContext - self.mea = None # ComponentIDContext + self.op = None # Token + self.id_ = None # ComponentIDContext + self.mea = None # ComponentIDContext def COMMA(self): return self.getToken(Parser.COMMA, 0) - def componentID(self, i:int=None): + def componentID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext,i) - + return self.getTypedRuleContext(Parser.ComponentIDContext, i) def PIVOT(self): return self.getToken(Parser.PIVOT, 0) @@ -4379,34 +4800,31 @@ def UNPIVOT(self): def getRuleIndex(self): return Parser.RULE_pivotOrUnpivotClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPivotOrUnpivotClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPivotOrUnpivotClause"): listener.enterPivotOrUnpivotClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPivotOrUnpivotClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPivotOrUnpivotClause"): listener.exitPivotOrUnpivotClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPivotOrUnpivotClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPivotOrUnpivotClause"): return visitor.visitPivotOrUnpivotClause(self) else: return visitor.visitChildren(self) - - - def pivotOrUnpivotClause(self): localctx = Parser.PivotOrUnpivotClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 24, self.RULE_pivotOrUnpivotClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 438 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.PIVOT or _la==Parser.UNPIVOT): + if not (_la == Parser.PIVOT or _la == Parser.UNPIVOT): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4425,20 +4843,19 @@ def pivotOrUnpivotClause(self): self.exitRule() return localctx - class CustomPivotClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.id_ = None # ComponentIDContext - self.mea = None # ComponentIDContext + self.id_ = None # ComponentIDContext + self.mea = None # ComponentIDContext def CUSTOMPIVOT(self): return self.getToken(Parser.CUSTOMPIVOT, 0) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -4447,45 +4864,40 @@ def COMMA(self, i:int=None): def IN(self): return self.getToken(Parser.IN, 0) - def constant(self, i:int=None): + def constant(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ConstantContext) else: - return self.getTypedRuleContext(Parser.ConstantContext,i) + return self.getTypedRuleContext(Parser.ConstantContext, i) - - def componentID(self, i:int=None): + def componentID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext,i) - + return self.getTypedRuleContext(Parser.ComponentIDContext, i) def getRuleIndex(self): return Parser.RULE_customPivotClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCustomPivotClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCustomPivotClause"): listener.enterCustomPivotClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCustomPivotClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCustomPivotClause"): listener.exitCustomPivotClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCustomPivotClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCustomPivotClause"): return visitor.visitCustomPivotClause(self) else: return visitor.visitChildren(self) - - - def customPivotClause(self): localctx = Parser.CustomPivotClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 26, self.RULE_customPivotClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 443 @@ -4503,7 +4915,7 @@ def customPivotClause(self): self.state = 453 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 449 self.match(Parser.COMMA) self.state = 450 @@ -4520,25 +4932,23 @@ def customPivotClause(self): self.exitRule() return localctx - class SubspaceClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def SUBSPACE(self): return self.getToken(Parser.SUBSPACE, 0) - def subspaceClauseItem(self, i:int=None): + def subspaceClauseItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.SubspaceClauseItemContext) else: - return self.getTypedRuleContext(Parser.SubspaceClauseItemContext,i) + return self.getTypedRuleContext(Parser.SubspaceClauseItemContext, i) - - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -4547,28 +4957,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_subspaceClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSubspaceClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSubspaceClause"): listener.enterSubspaceClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSubspaceClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSubspaceClause"): listener.exitSubspaceClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSubspaceClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSubspaceClause"): return visitor.visitSubspaceClause(self) else: return visitor.visitChildren(self) - - - def subspaceClause(self): localctx = Parser.SubspaceClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 28, self.RULE_subspaceClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 456 @@ -4578,7 +4985,7 @@ def subspaceClause(self): self.state = 462 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 458 self.match(Parser.COMMA) self.state = 459 @@ -4595,74 +5002,73 @@ def subspaceClause(self): self.exitRule() return localctx - class JoinOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_joinOperators - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class JoinExprContext(JoinOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.JoinOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.JoinOperatorsContext super().__init__(ANTLRParser) - self.joinKeyword = None # Token + self.joinKeyword = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def joinClause(self): - return self.getTypedRuleContext(Parser.JoinClauseContext,0) + return self.getTypedRuleContext(Parser.JoinClauseContext, 0) def joinBody(self): - return self.getTypedRuleContext(Parser.JoinBodyContext,0) + return self.getTypedRuleContext(Parser.JoinBodyContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def INNER_JOIN(self): return self.getToken(Parser.INNER_JOIN, 0) + def LEFT_JOIN(self): return self.getToken(Parser.LEFT_JOIN, 0) + def joinClauseWithoutUsing(self): - return self.getTypedRuleContext(Parser.JoinClauseWithoutUsingContext,0) + return self.getTypedRuleContext(Parser.JoinClauseWithoutUsingContext, 0) def FULL_JOIN(self): return self.getToken(Parser.FULL_JOIN, 0) + def CROSS_JOIN(self): return self.getToken(Parser.CROSS_JOIN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterJoinExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterJoinExpr"): listener.enterJoinExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitJoinExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitJoinExpr"): listener.exitJoinExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitJoinExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinExpr"): return visitor.visitJoinExpr(self) else: return visitor.visitChildren(self) - - def joinOperators(self): localctx = Parser.JoinOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 30, self.RULE_joinOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 477 self._errHandler.sync(self) @@ -4673,7 +5079,7 @@ def joinOperators(self): self.state = 465 localctx.joinKeyword = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.INNER_JOIN or _la==Parser.LEFT_JOIN): + if not (_la == Parser.INNER_JOIN or _la == Parser.LEFT_JOIN): localctx.joinKeyword = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4693,7 +5099,7 @@ def joinOperators(self): self.state = 471 localctx.joinKeyword = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.CROSS_JOIN or _la==Parser.FULL_JOIN): + if not (_la == Parser.CROSS_JOIN or _la == Parser.FULL_JOIN): localctx.joinKeyword = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4718,195 +5124,208 @@ def joinOperators(self): self.exitRule() return localctx - class DefOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_defOperators - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class DefOperatorContext(DefOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DefOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.DefOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DEFINE(self): return self.getToken(Parser.DEFINE, 0) - def OPERATOR(self, i:int=None): + + def OPERATOR(self, i: int = None): if i is None: return self.getTokens(Parser.OPERATOR) else: return self.getToken(Parser.OPERATOR, i) + def operatorID(self): - return self.getTypedRuleContext(Parser.OperatorIDContext,0) + return self.getTypedRuleContext(Parser.OperatorIDContext, 0) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def IS(self): return self.getToken(Parser.IS, 0) + def END(self): return self.getToken(Parser.END, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) - def parameterItem(self, i:int=None): + def parameterItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ParameterItemContext) else: - return self.getTypedRuleContext(Parser.ParameterItemContext,i) + return self.getTypedRuleContext(Parser.ParameterItemContext, i) def RETURNS(self): return self.getToken(Parser.RETURNS, 0) + def outputParameterType(self): - return self.getTypedRuleContext(Parser.OutputParameterTypeContext,0) + return self.getTypedRuleContext(Parser.OutputParameterTypeContext, 0) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDefOperator" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDefOperator"): listener.enterDefOperator(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDefOperator" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDefOperator"): listener.exitDefOperator(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDefOperator" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDefOperator"): return visitor.visitDefOperator(self) else: return visitor.visitChildren(self) - class DefHierarchicalContext(DefOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DefOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.DefOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DEFINE(self): return self.getToken(Parser.DEFINE, 0) - def HIERARCHICAL(self, i:int=None): + + def HIERARCHICAL(self, i: int = None): if i is None: return self.getTokens(Parser.HIERARCHICAL) else: return self.getToken(Parser.HIERARCHICAL, i) - def RULESET(self, i:int=None): + + def RULESET(self, i: int = None): if i is None: return self.getTokens(Parser.RULESET) else: return self.getToken(Parser.RULESET, i) + def rulesetID(self): - return self.getTypedRuleContext(Parser.RulesetIDContext,0) + return self.getTypedRuleContext(Parser.RulesetIDContext, 0) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def hierRuleSignature(self): - return self.getTypedRuleContext(Parser.HierRuleSignatureContext,0) + return self.getTypedRuleContext(Parser.HierRuleSignatureContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def IS(self): return self.getToken(Parser.IS, 0) + def ruleClauseHierarchical(self): - return self.getTypedRuleContext(Parser.RuleClauseHierarchicalContext,0) + return self.getTypedRuleContext(Parser.RuleClauseHierarchicalContext, 0) def END(self): return self.getToken(Parser.END, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDefHierarchical" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDefHierarchical"): listener.enterDefHierarchical(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDefHierarchical" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDefHierarchical"): listener.exitDefHierarchical(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDefHierarchical" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDefHierarchical"): return visitor.visitDefHierarchical(self) else: return visitor.visitChildren(self) - class DefDatapointRulesetContext(DefOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DefOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.DefOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DEFINE(self): return self.getToken(Parser.DEFINE, 0) - def DATAPOINT(self, i:int=None): + + def DATAPOINT(self, i: int = None): if i is None: return self.getTokens(Parser.DATAPOINT) else: return self.getToken(Parser.DATAPOINT, i) - def RULESET(self, i:int=None): + + def RULESET(self, i: int = None): if i is None: return self.getTokens(Parser.RULESET) else: return self.getToken(Parser.RULESET, i) + def rulesetID(self): - return self.getTypedRuleContext(Parser.RulesetIDContext,0) + return self.getTypedRuleContext(Parser.RulesetIDContext, 0) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def rulesetSignature(self): - return self.getTypedRuleContext(Parser.RulesetSignatureContext,0) + return self.getTypedRuleContext(Parser.RulesetSignatureContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def IS(self): return self.getToken(Parser.IS, 0) + def ruleClauseDatapoint(self): - return self.getTypedRuleContext(Parser.RuleClauseDatapointContext,0) + return self.getTypedRuleContext(Parser.RuleClauseDatapointContext, 0) def END(self): return self.getToken(Parser.END, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDefDatapointRuleset" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDefDatapointRuleset"): listener.enterDefDatapointRuleset(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDefDatapointRuleset" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDefDatapointRuleset"): listener.exitDefDatapointRuleset(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDefDatapointRuleset" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDefDatapointRuleset"): return visitor.visitDefDatapointRuleset(self) else: return visitor.visitChildren(self) - - def defOperators(self): localctx = Parser.DefOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 32, self.RULE_defOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 529 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,26,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 26, self._ctx) if la_ == 1: localctx = Parser.DefOperatorContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -4921,13 +5340,13 @@ def defOperators(self): self.state = 491 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.IDENTIFIER: + if _la == Parser.IDENTIFIER: self.state = 483 self.parameterItem() self.state = 488 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 484 self.match(Parser.COMMA) self.state = 485 @@ -4936,20 +5355,17 @@ def defOperators(self): self._errHandler.sync(self) _la = self._input.LA(1) - - self.state = 493 self.match(Parser.RPAREN) self.state = 496 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.RETURNS: + if _la == Parser.RETURNS: self.state = 494 self.match(Parser.RETURNS) self.state = 495 self.outputParameterType() - self.state = 498 self.match(Parser.IS) @@ -5019,7 +5435,6 @@ def defOperators(self): self.match(Parser.RULESET) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -5028,177 +5443,183 @@ def defOperators(self): self.exitRule() return localctx - class GenericOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_genericOperators - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class EvalAtomContext(GenericOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.GenericOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def EVAL(self): return self.getToken(Parser.EVAL, 0) - def LPAREN(self, i:int=None): + + def LPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) + def routineName(self): - return self.getTypedRuleContext(Parser.RoutineNameContext,0) + return self.getTypedRuleContext(Parser.RoutineNameContext, 0) - def RPAREN(self, i:int=None): + def RPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) - def varID(self, i:int=None): + + def varID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.VarIDContext) else: - return self.getTypedRuleContext(Parser.VarIDContext,i) + return self.getTypedRuleContext(Parser.VarIDContext, i) - def scalarItem(self, i:int=None): + def scalarItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ScalarItemContext) else: - return self.getTypedRuleContext(Parser.ScalarItemContext,i) + return self.getTypedRuleContext(Parser.ScalarItemContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def LANGUAGE(self): return self.getToken(Parser.LANGUAGE, 0) + def STRING_CONSTANT(self): return self.getToken(Parser.STRING_CONSTANT, 0) + def RETURNS(self): return self.getToken(Parser.RETURNS, 0) - def evalDatasetType(self): - return self.getTypedRuleContext(Parser.EvalDatasetTypeContext,0) + def evalDatasetType(self): + return self.getTypedRuleContext(Parser.EvalDatasetTypeContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterEvalAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterEvalAtom"): listener.enterEvalAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitEvalAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitEvalAtom"): listener.exitEvalAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitEvalAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitEvalAtom"): return visitor.visitEvalAtom(self) else: return visitor.visitChildren(self) - class CastExprDatasetContext(GenericOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.GenericOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CAST(self): return self.getToken(Parser.CAST, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def basicScalarType(self): - return self.getTypedRuleContext(Parser.BasicScalarTypeContext,0) + return self.getTypedRuleContext(Parser.BasicScalarTypeContext, 0) def valueDomainName(self): - return self.getTypedRuleContext(Parser.ValueDomainNameContext,0) + return self.getTypedRuleContext(Parser.ValueDomainNameContext, 0) def STRING_CONSTANT(self): return self.getToken(Parser.STRING_CONSTANT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCastExprDataset" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCastExprDataset"): listener.enterCastExprDataset(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCastExprDataset" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCastExprDataset"): listener.exitCastExprDataset(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCastExprDataset" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCastExprDataset"): return visitor.visitCastExprDataset(self) else: return visitor.visitChildren(self) - class CallDatasetContext(GenericOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.GenericOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def operatorID(self): - return self.getTypedRuleContext(Parser.OperatorIDContext,0) + return self.getTypedRuleContext(Parser.OperatorIDContext, 0) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def parameter(self, i:int=None): + + def parameter(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ParameterContext) else: - return self.getTypedRuleContext(Parser.ParameterContext,i) + return self.getTypedRuleContext(Parser.ParameterContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCallDataset" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCallDataset"): listener.enterCallDataset(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCallDataset" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCallDataset"): listener.exitCallDataset(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCallDataset" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCallDataset"): return visitor.visitCallDataset(self) else: return visitor.visitChildren(self) - - def genericOperators(self): localctx = Parser.GenericOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 34, self.RULE_genericOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 588 self._errHandler.sync(self) @@ -5213,13 +5634,135 @@ def genericOperators(self): self.state = 541 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CASE) | (1 << Parser.CURRENT_DATE) | (1 << Parser.DATEDIFF) | (1 << Parser.DATEADD) | (1 << Parser.YEAR_OP) | (1 << Parser.MONTH_OP) | (1 << Parser.DAYOFMONTH) | (1 << Parser.DAYOFYEAR) | (1 << Parser.DAYTOYEAR) | (1 << Parser.DAYTOMONTH) | (1 << Parser.YEARTODAY) | (1 << Parser.MONTHTODAY) | (1 << Parser.NOT) | (1 << Parser.BETWEEN) | (1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL) | (1 << Parser.UNION) | (1 << Parser.SYMDIFF) | (1 << Parser.INTERSECT) | (1 << Parser.RANDOM))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Parser.CHECK - 66)) | (1 << (Parser.EXISTS_IN - 66)) | (1 << (Parser.MIN - 66)) | (1 << (Parser.MAX - 66)) | (1 << (Parser.ABS - 66)) | (1 << (Parser.LN - 66)) | (1 << (Parser.LOG - 66)) | (1 << (Parser.TRUNC - 66)) | (1 << (Parser.ROUND - 66)) | (1 << (Parser.POWER - 66)) | (1 << (Parser.MOD - 66)) | (1 << (Parser.LEN - 66)) | (1 << (Parser.TRIM - 66)) | (1 << (Parser.UCASE - 66)) | (1 << (Parser.LCASE - 66)) | (1 << (Parser.SUBSTR - 66)) | (1 << (Parser.SUM - 66)) | (1 << (Parser.AVG - 66)) | (1 << (Parser.MEDIAN - 66)) | (1 << (Parser.COUNT - 66)) | (1 << (Parser.EXP - 66)) | (1 << (Parser.CHARSET_MATCH - 66)) | (1 << (Parser.NVL - 66)) | (1 << (Parser.HIERARCHY - 66)) | (1 << (Parser.OPTIONAL - 66)))) != 0) or ((((_la - 131)) & ~0x3f) == 0 and ((1 << (_la - 131)) & ((1 << (Parser.LTRIM - 131)) | (1 << (Parser.RTRIM - 131)) | (1 << (Parser.INSTR - 131)) | (1 << (Parser.REPLACE - 131)) | (1 << (Parser.CEIL - 131)) | (1 << (Parser.FLOOR - 131)) | (1 << (Parser.SQRT - 131)) | (1 << (Parser.SETDIFF - 131)) | (1 << (Parser.STDDEV_POP - 131)) | (1 << (Parser.STDDEV_SAMP - 131)) | (1 << (Parser.VAR_POP - 131)) | (1 << (Parser.VAR_SAMP - 131)) | (1 << (Parser.FIRST_VALUE - 131)) | (1 << (Parser.LAST_VALUE - 131)) | (1 << (Parser.LAG - 131)) | (1 << (Parser.LEAD - 131)) | (1 << (Parser.RATIO_TO_REPORT - 131)) | (1 << (Parser.FILL_TIME_SERIES - 131)) | (1 << (Parser.FLOW_TO_STOCK - 131)) | (1 << (Parser.STOCK_TO_FLOW - 131)) | (1 << (Parser.TIMESHIFT - 131)) | (1 << (Parser.INNER_JOIN - 131)) | (1 << (Parser.LEFT_JOIN - 131)))) != 0) or ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & ((1 << (Parser.CROSS_JOIN - 195)) | (1 << (Parser.FULL_JOIN - 195)) | (1 << (Parser.PERIOD_INDICATOR - 195)) | (1 << (Parser.TIME_AGG - 195)) | (1 << (Parser.CAST - 195)) | (1 << (Parser.CHECK_DATAPOINT - 195)) | (1 << (Parser.CHECK_HIERARCHY - 195)) | (1 << (Parser.INTEGER_CONSTANT - 195)) | (1 << (Parser.NUMBER_CONSTANT - 195)) | (1 << (Parser.BOOLEAN_CONSTANT - 195)) | (1 << (Parser.STRING_CONSTANT - 195)) | (1 << (Parser.IDENTIFIER - 195)))) != 0): + if ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << Parser.LPAREN) + | (1 << Parser.PLUS) + | (1 << Parser.MINUS) + | (1 << Parser.EVAL) + | (1 << Parser.IF) + | (1 << Parser.CASE) + | (1 << Parser.CURRENT_DATE) + | (1 << Parser.DATEDIFF) + | (1 << Parser.DATEADD) + | (1 << Parser.YEAR_OP) + | (1 << Parser.MONTH_OP) + | (1 << Parser.DAYOFMONTH) + | (1 << Parser.DAYOFYEAR) + | (1 << Parser.DAYTOYEAR) + | (1 << Parser.DAYTOMONTH) + | (1 << Parser.YEARTODAY) + | (1 << Parser.MONTHTODAY) + | (1 << Parser.NOT) + | (1 << Parser.BETWEEN) + | (1 << Parser.NULL_CONSTANT) + | (1 << Parser.ISNULL) + | (1 << Parser.UNION) + | (1 << Parser.SYMDIFF) + | (1 << Parser.INTERSECT) + | (1 << Parser.RANDOM) + ) + ) + != 0 + ) + or ( + ((_la - 66) & ~0x3F) == 0 + and ( + (1 << (_la - 66)) + & ( + (1 << (Parser.CHECK - 66)) + | (1 << (Parser.EXISTS_IN - 66)) + | (1 << (Parser.MIN - 66)) + | (1 << (Parser.MAX - 66)) + | (1 << (Parser.ABS - 66)) + | (1 << (Parser.LN - 66)) + | (1 << (Parser.LOG - 66)) + | (1 << (Parser.TRUNC - 66)) + | (1 << (Parser.ROUND - 66)) + | (1 << (Parser.POWER - 66)) + | (1 << (Parser.MOD - 66)) + | (1 << (Parser.LEN - 66)) + | (1 << (Parser.TRIM - 66)) + | (1 << (Parser.UCASE - 66)) + | (1 << (Parser.LCASE - 66)) + | (1 << (Parser.SUBSTR - 66)) + | (1 << (Parser.SUM - 66)) + | (1 << (Parser.AVG - 66)) + | (1 << (Parser.MEDIAN - 66)) + | (1 << (Parser.COUNT - 66)) + | (1 << (Parser.EXP - 66)) + | (1 << (Parser.CHARSET_MATCH - 66)) + | (1 << (Parser.NVL - 66)) + | (1 << (Parser.HIERARCHY - 66)) + | (1 << (Parser.OPTIONAL - 66)) + ) + ) + != 0 + ) + or ( + ((_la - 131) & ~0x3F) == 0 + and ( + (1 << (_la - 131)) + & ( + (1 << (Parser.LTRIM - 131)) + | (1 << (Parser.RTRIM - 131)) + | (1 << (Parser.INSTR - 131)) + | (1 << (Parser.REPLACE - 131)) + | (1 << (Parser.CEIL - 131)) + | (1 << (Parser.FLOOR - 131)) + | (1 << (Parser.SQRT - 131)) + | (1 << (Parser.SETDIFF - 131)) + | (1 << (Parser.STDDEV_POP - 131)) + | (1 << (Parser.STDDEV_SAMP - 131)) + | (1 << (Parser.VAR_POP - 131)) + | (1 << (Parser.VAR_SAMP - 131)) + | (1 << (Parser.FIRST_VALUE - 131)) + | (1 << (Parser.LAST_VALUE - 131)) + | (1 << (Parser.LAG - 131)) + | (1 << (Parser.LEAD - 131)) + | (1 << (Parser.RATIO_TO_REPORT - 131)) + | (1 << (Parser.FILL_TIME_SERIES - 131)) + | (1 << (Parser.FLOW_TO_STOCK - 131)) + | (1 << (Parser.STOCK_TO_FLOW - 131)) + | (1 << (Parser.TIMESHIFT - 131)) + | (1 << (Parser.INNER_JOIN - 131)) + | (1 << (Parser.LEFT_JOIN - 131)) + ) + ) + != 0 + ) + or ( + ((_la - 195) & ~0x3F) == 0 + and ( + (1 << (_la - 195)) + & ( + (1 << (Parser.CROSS_JOIN - 195)) + | (1 << (Parser.FULL_JOIN - 195)) + | (1 << (Parser.PERIOD_INDICATOR - 195)) + | (1 << (Parser.TIME_AGG - 195)) + | (1 << (Parser.CAST - 195)) + | (1 << (Parser.CHECK_DATAPOINT - 195)) + | (1 << (Parser.CHECK_HIERARCHY - 195)) + | (1 << (Parser.INTEGER_CONSTANT - 195)) + | (1 << (Parser.NUMBER_CONSTANT - 195)) + | (1 << (Parser.BOOLEAN_CONSTANT - 195)) + | (1 << (Parser.STRING_CONSTANT - 195)) + | (1 << (Parser.IDENTIFIER - 195)) + ) + ) + != 0 + ) + ): self.state = 533 self.parameter() self.state = 538 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 534 self.match(Parser.COMMA) self.state = 535 @@ -5228,8 +5771,6 @@ def genericOperators(self): self._errHandler.sync(self) _la = self._input.LA(1) - - self.state = 543 self.match(Parser.RPAREN) pass @@ -5251,7 +5792,14 @@ def genericOperators(self): self.state = 549 self.varID() pass - elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT]: + elif token in [ + Parser.NULL_CONSTANT, + Parser.CAST, + Parser.INTEGER_CONSTANT, + Parser.NUMBER_CONSTANT, + Parser.BOOLEAN_CONSTANT, + Parser.STRING_CONSTANT, + ]: self.state = 550 self.scalarItem() pass @@ -5262,7 +5810,7 @@ def genericOperators(self): self.state = 560 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 553 self.match(Parser.COMMA) self.state = 556 @@ -5272,7 +5820,14 @@ def genericOperators(self): self.state = 554 self.varID() pass - elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT]: + elif token in [ + Parser.NULL_CONSTANT, + Parser.CAST, + Parser.INTEGER_CONSTANT, + Parser.NUMBER_CONSTANT, + Parser.BOOLEAN_CONSTANT, + Parser.STRING_CONSTANT, + ]: self.state = 555 self.scalarItem() pass @@ -5288,23 +5843,21 @@ def genericOperators(self): self.state = 566 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.LANGUAGE: + if _la == Parser.LANGUAGE: self.state = 564 self.match(Parser.LANGUAGE) self.state = 565 self.match(Parser.STRING_CONSTANT) - self.state = 570 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.RETURNS: + if _la == Parser.RETURNS: self.state = 568 self.match(Parser.RETURNS) self.state = 569 self.evalDatasetType() - self.state = 572 self.match(Parser.RPAREN) pass @@ -5322,7 +5875,17 @@ def genericOperators(self): self.state = 580 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR]: + if token in [ + Parser.BOOLEAN, + Parser.DATE, + Parser.TIME_PERIOD, + Parser.NUMBER, + Parser.STRING, + Parser.TIME, + Parser.INTEGER, + Parser.DURATION, + Parser.SCALAR, + ]: self.state = 578 self.basicScalarType() pass @@ -5336,13 +5899,12 @@ def genericOperators(self): self.state = 584 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 582 self.match(Parser.COMMA) self.state = 583 self.match(Parser.STRING_CONSTANT) - self.state = 586 self.match(Parser.RPAREN) pass @@ -5357,177 +5919,183 @@ def genericOperators(self): self.exitRule() return localctx - class GenericOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_genericOperatorsComponent - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class EvalAtomComponentContext(GenericOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.GenericOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def EVAL(self): return self.getToken(Parser.EVAL, 0) - def LPAREN(self, i:int=None): + + def LPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) + def routineName(self): - return self.getTypedRuleContext(Parser.RoutineNameContext,0) + return self.getTypedRuleContext(Parser.RoutineNameContext, 0) - def RPAREN(self, i:int=None): + def RPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) - def componentID(self, i:int=None): + + def componentID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext,i) + return self.getTypedRuleContext(Parser.ComponentIDContext, i) - def scalarItem(self, i:int=None): + def scalarItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ScalarItemContext) else: - return self.getTypedRuleContext(Parser.ScalarItemContext,i) + return self.getTypedRuleContext(Parser.ScalarItemContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def LANGUAGE(self): return self.getToken(Parser.LANGUAGE, 0) + def STRING_CONSTANT(self): return self.getToken(Parser.STRING_CONSTANT, 0) + def RETURNS(self): return self.getToken(Parser.RETURNS, 0) - def outputParameterTypeComponent(self): - return self.getTypedRuleContext(Parser.OutputParameterTypeComponentContext,0) + def outputParameterTypeComponent(self): + return self.getTypedRuleContext(Parser.OutputParameterTypeComponentContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterEvalAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterEvalAtomComponent"): listener.enterEvalAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitEvalAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitEvalAtomComponent"): listener.exitEvalAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitEvalAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitEvalAtomComponent"): return visitor.visitEvalAtomComponent(self) else: return visitor.visitChildren(self) - class CastExprComponentContext(GenericOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.GenericOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CAST(self): return self.getToken(Parser.CAST, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def basicScalarType(self): - return self.getTypedRuleContext(Parser.BasicScalarTypeContext,0) + return self.getTypedRuleContext(Parser.BasicScalarTypeContext, 0) def valueDomainName(self): - return self.getTypedRuleContext(Parser.ValueDomainNameContext,0) + return self.getTypedRuleContext(Parser.ValueDomainNameContext, 0) def STRING_CONSTANT(self): return self.getToken(Parser.STRING_CONSTANT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCastExprComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCastExprComponent"): listener.enterCastExprComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCastExprComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCastExprComponent"): listener.exitCastExprComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCastExprComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCastExprComponent"): return visitor.visitCastExprComponent(self) else: return visitor.visitChildren(self) - class CallComponentContext(GenericOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GenericOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.GenericOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def operatorID(self): - return self.getTypedRuleContext(Parser.OperatorIDContext,0) + return self.getTypedRuleContext(Parser.OperatorIDContext, 0) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def parameterComponent(self, i:int=None): + + def parameterComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ParameterComponentContext) else: - return self.getTypedRuleContext(Parser.ParameterComponentContext,i) + return self.getTypedRuleContext(Parser.ParameterComponentContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCallComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCallComponent"): listener.enterCallComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCallComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCallComponent"): listener.exitCallComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCallComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCallComponent"): return visitor.visitCallComponent(self) else: return visitor.visitChildren(self) - - def genericOperatorsComponent(self): localctx = Parser.GenericOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 36, self.RULE_genericOperatorsComponent) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 647 self._errHandler.sync(self) @@ -5542,13 +6110,123 @@ def genericOperatorsComponent(self): self.state = 600 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CASE) | (1 << Parser.CURRENT_DATE) | (1 << Parser.DATEDIFF) | (1 << Parser.DATEADD) | (1 << Parser.YEAR_OP) | (1 << Parser.MONTH_OP) | (1 << Parser.DAYOFMONTH) | (1 << Parser.DAYOFYEAR) | (1 << Parser.DAYTOYEAR) | (1 << Parser.DAYTOMONTH) | (1 << Parser.YEARTODAY) | (1 << Parser.MONTHTODAY) | (1 << Parser.NOT) | (1 << Parser.BETWEEN) | (1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL) | (1 << Parser.RANDOM))) != 0) or ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & ((1 << (Parser.RANK - 77)) | (1 << (Parser.MIN - 77)) | (1 << (Parser.MAX - 77)) | (1 << (Parser.ABS - 77)) | (1 << (Parser.LN - 77)) | (1 << (Parser.LOG - 77)) | (1 << (Parser.TRUNC - 77)) | (1 << (Parser.ROUND - 77)) | (1 << (Parser.POWER - 77)) | (1 << (Parser.MOD - 77)) | (1 << (Parser.LEN - 77)) | (1 << (Parser.TRIM - 77)) | (1 << (Parser.UCASE - 77)) | (1 << (Parser.LCASE - 77)) | (1 << (Parser.SUBSTR - 77)) | (1 << (Parser.SUM - 77)) | (1 << (Parser.AVG - 77)) | (1 << (Parser.MEDIAN - 77)) | (1 << (Parser.COUNT - 77)) | (1 << (Parser.EXP - 77)) | (1 << (Parser.CHARSET_MATCH - 77)) | (1 << (Parser.NVL - 77)) | (1 << (Parser.OPTIONAL - 77)) | (1 << (Parser.LTRIM - 77)) | (1 << (Parser.RTRIM - 77)) | (1 << (Parser.INSTR - 77)) | (1 << (Parser.REPLACE - 77)) | (1 << (Parser.CEIL - 77)) | (1 << (Parser.FLOOR - 77)) | (1 << (Parser.SQRT - 77)) | (1 << (Parser.STDDEV_POP - 77)))) != 0) or ((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & ((1 << (Parser.STDDEV_SAMP - 141)) | (1 << (Parser.VAR_POP - 141)) | (1 << (Parser.VAR_SAMP - 141)) | (1 << (Parser.FIRST_VALUE - 141)) | (1 << (Parser.LAST_VALUE - 141)) | (1 << (Parser.LAG - 141)) | (1 << (Parser.LEAD - 141)) | (1 << (Parser.RATIO_TO_REPORT - 141)) | (1 << (Parser.FILL_TIME_SERIES - 141)) | (1 << (Parser.FLOW_TO_STOCK - 141)) | (1 << (Parser.STOCK_TO_FLOW - 141)) | (1 << (Parser.TIMESHIFT - 141)))) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & ((1 << (Parser.PERIOD_INDICATOR - 208)) | (1 << (Parser.TIME_AGG - 208)) | (1 << (Parser.CAST - 208)) | (1 << (Parser.INTEGER_CONSTANT - 208)) | (1 << (Parser.NUMBER_CONSTANT - 208)) | (1 << (Parser.BOOLEAN_CONSTANT - 208)) | (1 << (Parser.STRING_CONSTANT - 208)) | (1 << (Parser.IDENTIFIER - 208)))) != 0): + if ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << Parser.LPAREN) + | (1 << Parser.PLUS) + | (1 << Parser.MINUS) + | (1 << Parser.EVAL) + | (1 << Parser.IF) + | (1 << Parser.CASE) + | (1 << Parser.CURRENT_DATE) + | (1 << Parser.DATEDIFF) + | (1 << Parser.DATEADD) + | (1 << Parser.YEAR_OP) + | (1 << Parser.MONTH_OP) + | (1 << Parser.DAYOFMONTH) + | (1 << Parser.DAYOFYEAR) + | (1 << Parser.DAYTOYEAR) + | (1 << Parser.DAYTOMONTH) + | (1 << Parser.YEARTODAY) + | (1 << Parser.MONTHTODAY) + | (1 << Parser.NOT) + | (1 << Parser.BETWEEN) + | (1 << Parser.NULL_CONSTANT) + | (1 << Parser.ISNULL) + | (1 << Parser.RANDOM) + ) + ) + != 0 + ) + or ( + ((_la - 77) & ~0x3F) == 0 + and ( + (1 << (_la - 77)) + & ( + (1 << (Parser.RANK - 77)) + | (1 << (Parser.MIN - 77)) + | (1 << (Parser.MAX - 77)) + | (1 << (Parser.ABS - 77)) + | (1 << (Parser.LN - 77)) + | (1 << (Parser.LOG - 77)) + | (1 << (Parser.TRUNC - 77)) + | (1 << (Parser.ROUND - 77)) + | (1 << (Parser.POWER - 77)) + | (1 << (Parser.MOD - 77)) + | (1 << (Parser.LEN - 77)) + | (1 << (Parser.TRIM - 77)) + | (1 << (Parser.UCASE - 77)) + | (1 << (Parser.LCASE - 77)) + | (1 << (Parser.SUBSTR - 77)) + | (1 << (Parser.SUM - 77)) + | (1 << (Parser.AVG - 77)) + | (1 << (Parser.MEDIAN - 77)) + | (1 << (Parser.COUNT - 77)) + | (1 << (Parser.EXP - 77)) + | (1 << (Parser.CHARSET_MATCH - 77)) + | (1 << (Parser.NVL - 77)) + | (1 << (Parser.OPTIONAL - 77)) + | (1 << (Parser.LTRIM - 77)) + | (1 << (Parser.RTRIM - 77)) + | (1 << (Parser.INSTR - 77)) + | (1 << (Parser.REPLACE - 77)) + | (1 << (Parser.CEIL - 77)) + | (1 << (Parser.FLOOR - 77)) + | (1 << (Parser.SQRT - 77)) + | (1 << (Parser.STDDEV_POP - 77)) + ) + ) + != 0 + ) + or ( + ((_la - 141) & ~0x3F) == 0 + and ( + (1 << (_la - 141)) + & ( + (1 << (Parser.STDDEV_SAMP - 141)) + | (1 << (Parser.VAR_POP - 141)) + | (1 << (Parser.VAR_SAMP - 141)) + | (1 << (Parser.FIRST_VALUE - 141)) + | (1 << (Parser.LAST_VALUE - 141)) + | (1 << (Parser.LAG - 141)) + | (1 << (Parser.LEAD - 141)) + | (1 << (Parser.RATIO_TO_REPORT - 141)) + | (1 << (Parser.FILL_TIME_SERIES - 141)) + | (1 << (Parser.FLOW_TO_STOCK - 141)) + | (1 << (Parser.STOCK_TO_FLOW - 141)) + | (1 << (Parser.TIMESHIFT - 141)) + ) + ) + != 0 + ) + or ( + ((_la - 208) & ~0x3F) == 0 + and ( + (1 << (_la - 208)) + & ( + (1 << (Parser.PERIOD_INDICATOR - 208)) + | (1 << (Parser.TIME_AGG - 208)) + | (1 << (Parser.CAST - 208)) + | (1 << (Parser.INTEGER_CONSTANT - 208)) + | (1 << (Parser.NUMBER_CONSTANT - 208)) + | (1 << (Parser.BOOLEAN_CONSTANT - 208)) + | (1 << (Parser.STRING_CONSTANT - 208)) + | (1 << (Parser.IDENTIFIER - 208)) + ) + ) + != 0 + ) + ): self.state = 592 self.parameterComponent() self.state = 597 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 593 self.match(Parser.COMMA) self.state = 594 @@ -5557,8 +6235,6 @@ def genericOperatorsComponent(self): self._errHandler.sync(self) _la = self._input.LA(1) - - self.state = 602 self.match(Parser.RPAREN) pass @@ -5576,7 +6252,17 @@ def genericOperatorsComponent(self): self.state = 610 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR]: + if token in [ + Parser.BOOLEAN, + Parser.DATE, + Parser.TIME_PERIOD, + Parser.NUMBER, + Parser.STRING, + Parser.TIME, + Parser.INTEGER, + Parser.DURATION, + Parser.SCALAR, + ]: self.state = 608 self.basicScalarType() pass @@ -5590,13 +6276,12 @@ def genericOperatorsComponent(self): self.state = 614 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 612 self.match(Parser.COMMA) self.state = 613 self.match(Parser.STRING_CONSTANT) - self.state = 616 self.match(Parser.RPAREN) pass @@ -5618,7 +6303,14 @@ def genericOperatorsComponent(self): self.state = 622 self.componentID() pass - elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT]: + elif token in [ + Parser.NULL_CONSTANT, + Parser.CAST, + Parser.INTEGER_CONSTANT, + Parser.NUMBER_CONSTANT, + Parser.BOOLEAN_CONSTANT, + Parser.STRING_CONSTANT, + ]: self.state = 623 self.scalarItem() pass @@ -5629,7 +6321,7 @@ def genericOperatorsComponent(self): self.state = 633 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 626 self.match(Parser.COMMA) self.state = 629 @@ -5639,7 +6331,14 @@ def genericOperatorsComponent(self): self.state = 627 self.componentID() pass - elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT]: + elif token in [ + Parser.NULL_CONSTANT, + Parser.CAST, + Parser.INTEGER_CONSTANT, + Parser.NUMBER_CONSTANT, + Parser.BOOLEAN_CONSTANT, + Parser.STRING_CONSTANT, + ]: self.state = 628 self.scalarItem() pass @@ -5655,23 +6354,21 @@ def genericOperatorsComponent(self): self.state = 639 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.LANGUAGE: + if _la == Parser.LANGUAGE: self.state = 637 self.match(Parser.LANGUAGE) self.state = 638 self.match(Parser.STRING_CONSTANT) - self.state = 643 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.RETURNS: + if _la == Parser.RETURNS: self.state = 641 self.match(Parser.RETURNS) self.state = 642 self.outputParameterTypeComponent() - self.state = 645 self.match(Parser.RPAREN) pass @@ -5686,17 +6383,15 @@ def genericOperatorsComponent(self): self.exitRule() return localctx - class ParameterComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) - + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) @@ -5704,23 +6399,20 @@ def OPTIONAL(self): def getRuleIndex(self): return Parser.RULE_parameterComponent - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterParameterComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterParameterComponent"): listener.enterParameterComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitParameterComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitParameterComponent"): listener.exitParameterComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitParameterComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParameterComponent"): return visitor.visitParameterComponent(self) else: return visitor.visitChildren(self) - - - def parameterComponent(self): localctx = Parser.ParameterComponentContext(self, self._ctx, self.state) @@ -5729,7 +6421,80 @@ def parameterComponent(self): self.state = 651 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF, Parser.CASE, Parser.CURRENT_DATE, Parser.DATEDIFF, Parser.DATEADD, Parser.YEAR_OP, Parser.MONTH_OP, Parser.DAYOFMONTH, Parser.DAYOFYEAR, Parser.DAYTOYEAR, Parser.DAYTOMONTH, Parser.YEARTODAY, Parser.MONTHTODAY, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT, Parser.ISNULL, Parser.RANDOM, Parser.RANK, Parser.MIN, Parser.MAX, Parser.ABS, Parser.LN, Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER, Parser.MOD, Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.SUBSTR, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.EXP, Parser.CHARSET_MATCH, Parser.NVL, Parser.LTRIM, Parser.RTRIM, Parser.INSTR, Parser.REPLACE, Parser.CEIL, Parser.FLOOR, Parser.SQRT, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT, Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW, Parser.TIMESHIFT, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT, Parser.IDENTIFIER]: + if token in [ + Parser.LPAREN, + Parser.PLUS, + Parser.MINUS, + Parser.EVAL, + Parser.IF, + Parser.CASE, + Parser.CURRENT_DATE, + Parser.DATEDIFF, + Parser.DATEADD, + Parser.YEAR_OP, + Parser.MONTH_OP, + Parser.DAYOFMONTH, + Parser.DAYOFYEAR, + Parser.DAYTOYEAR, + Parser.DAYTOMONTH, + Parser.YEARTODAY, + Parser.MONTHTODAY, + Parser.NOT, + Parser.BETWEEN, + Parser.NULL_CONSTANT, + Parser.ISNULL, + Parser.RANDOM, + Parser.RANK, + Parser.MIN, + Parser.MAX, + Parser.ABS, + Parser.LN, + Parser.LOG, + Parser.TRUNC, + Parser.ROUND, + Parser.POWER, + Parser.MOD, + Parser.LEN, + Parser.TRIM, + Parser.UCASE, + Parser.LCASE, + Parser.SUBSTR, + Parser.SUM, + Parser.AVG, + Parser.MEDIAN, + Parser.COUNT, + Parser.EXP, + Parser.CHARSET_MATCH, + Parser.NVL, + Parser.LTRIM, + Parser.RTRIM, + Parser.INSTR, + Parser.REPLACE, + Parser.CEIL, + Parser.FLOOR, + Parser.SQRT, + Parser.STDDEV_POP, + Parser.STDDEV_SAMP, + Parser.VAR_POP, + Parser.VAR_SAMP, + Parser.FIRST_VALUE, + Parser.LAST_VALUE, + Parser.LAG, + Parser.LEAD, + Parser.RATIO_TO_REPORT, + Parser.FILL_TIME_SERIES, + Parser.FLOW_TO_STOCK, + Parser.STOCK_TO_FLOW, + Parser.TIMESHIFT, + Parser.PERIOD_INDICATOR, + Parser.TIME_AGG, + Parser.CAST, + Parser.INTEGER_CONSTANT, + Parser.NUMBER_CONSTANT, + Parser.BOOLEAN_CONSTANT, + Parser.STRING_CONSTANT, + Parser.IDENTIFIER, + ]: self.enterOuterAlt(localctx, 1) self.state = 649 self.exprComponent(0) @@ -5750,17 +6515,15 @@ def parameterComponent(self): self.exitRule() return localctx - class ParameterContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) - + return self.getTypedRuleContext(Parser.ExprContext, 0) def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) @@ -5768,23 +6531,20 @@ def OPTIONAL(self): def getRuleIndex(self): return Parser.RULE_parameter - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterParameter" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterParameter"): listener.enterParameter(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitParameter" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitParameter"): listener.exitParameter(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitParameter" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParameter"): return visitor.visitParameter(self) else: return visitor.visitChildren(self) - - - def parameter(self): localctx = Parser.ParameterContext(self, self._ctx, self.state) @@ -5793,7 +6553,92 @@ def parameter(self): self.state = 655 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF, Parser.CASE, Parser.CURRENT_DATE, Parser.DATEDIFF, Parser.DATEADD, Parser.YEAR_OP, Parser.MONTH_OP, Parser.DAYOFMONTH, Parser.DAYOFYEAR, Parser.DAYTOYEAR, Parser.DAYTOMONTH, Parser.YEARTODAY, Parser.MONTHTODAY, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT, Parser.ISNULL, Parser.UNION, Parser.SYMDIFF, Parser.INTERSECT, Parser.RANDOM, Parser.CHECK, Parser.EXISTS_IN, Parser.MIN, Parser.MAX, Parser.ABS, Parser.LN, Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER, Parser.MOD, Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.SUBSTR, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.EXP, Parser.CHARSET_MATCH, Parser.NVL, Parser.HIERARCHY, Parser.LTRIM, Parser.RTRIM, Parser.INSTR, Parser.REPLACE, Parser.CEIL, Parser.FLOOR, Parser.SQRT, Parser.SETDIFF, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT, Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW, Parser.TIMESHIFT, Parser.INNER_JOIN, Parser.LEFT_JOIN, Parser.CROSS_JOIN, Parser.FULL_JOIN, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST, Parser.CHECK_DATAPOINT, Parser.CHECK_HIERARCHY, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT, Parser.IDENTIFIER]: + if token in [ + Parser.LPAREN, + Parser.PLUS, + Parser.MINUS, + Parser.EVAL, + Parser.IF, + Parser.CASE, + Parser.CURRENT_DATE, + Parser.DATEDIFF, + Parser.DATEADD, + Parser.YEAR_OP, + Parser.MONTH_OP, + Parser.DAYOFMONTH, + Parser.DAYOFYEAR, + Parser.DAYTOYEAR, + Parser.DAYTOMONTH, + Parser.YEARTODAY, + Parser.MONTHTODAY, + Parser.NOT, + Parser.BETWEEN, + Parser.NULL_CONSTANT, + Parser.ISNULL, + Parser.UNION, + Parser.SYMDIFF, + Parser.INTERSECT, + Parser.RANDOM, + Parser.CHECK, + Parser.EXISTS_IN, + Parser.MIN, + Parser.MAX, + Parser.ABS, + Parser.LN, + Parser.LOG, + Parser.TRUNC, + Parser.ROUND, + Parser.POWER, + Parser.MOD, + Parser.LEN, + Parser.TRIM, + Parser.UCASE, + Parser.LCASE, + Parser.SUBSTR, + Parser.SUM, + Parser.AVG, + Parser.MEDIAN, + Parser.COUNT, + Parser.EXP, + Parser.CHARSET_MATCH, + Parser.NVL, + Parser.HIERARCHY, + Parser.LTRIM, + Parser.RTRIM, + Parser.INSTR, + Parser.REPLACE, + Parser.CEIL, + Parser.FLOOR, + Parser.SQRT, + Parser.SETDIFF, + Parser.STDDEV_POP, + Parser.STDDEV_SAMP, + Parser.VAR_POP, + Parser.VAR_SAMP, + Parser.FIRST_VALUE, + Parser.LAST_VALUE, + Parser.LAG, + Parser.LEAD, + Parser.RATIO_TO_REPORT, + Parser.FILL_TIME_SERIES, + Parser.FLOW_TO_STOCK, + Parser.STOCK_TO_FLOW, + Parser.TIMESHIFT, + Parser.INNER_JOIN, + Parser.LEFT_JOIN, + Parser.CROSS_JOIN, + Parser.FULL_JOIN, + Parser.PERIOD_INDICATOR, + Parser.TIME_AGG, + Parser.CAST, + Parser.CHECK_DATAPOINT, + Parser.CHECK_HIERARCHY, + Parser.INTEGER_CONSTANT, + Parser.NUMBER_CONSTANT, + Parser.BOOLEAN_CONSTANT, + Parser.STRING_CONSTANT, + Parser.IDENTIFIER, + ]: self.enterOuterAlt(localctx, 1) self.state = 653 self.expr(0) @@ -5814,218 +6659,249 @@ def parameter(self): self.exitRule() return localctx - class StringOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_stringOperators - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class InstrAtomContext(StringOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.StringOperatorsContext super().__init__(ANTLRParser) - self.pattern = None # ExprContext - self.startParameter = None # OptionalExprContext - self.occurrenceParameter = None # OptionalExprContext + self.pattern = None # ExprContext + self.startParameter = None # OptionalExprContext + self.occurrenceParameter = None # OptionalExprContext self.copyFrom(ctx) def INSTR(self): return self.getToken(Parser.INSTR, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def optionalExpr(self, i:int=None): + + def optionalExpr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.OptionalExprContext) else: - return self.getTypedRuleContext(Parser.OptionalExprContext,i) - + return self.getTypedRuleContext(Parser.OptionalExprContext, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInstrAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInstrAtom"): listener.enterInstrAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInstrAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInstrAtom"): listener.exitInstrAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInstrAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInstrAtom"): return visitor.visitInstrAtom(self) else: return visitor.visitChildren(self) - class UnaryStringFunctionContext(StringOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.StringOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def TRIM(self): return self.getToken(Parser.TRIM, 0) + def LTRIM(self): return self.getToken(Parser.LTRIM, 0) + def RTRIM(self): return self.getToken(Parser.RTRIM, 0) + def UCASE(self): return self.getToken(Parser.UCASE, 0) + def LCASE(self): return self.getToken(Parser.LCASE, 0) + def LEN(self): return self.getToken(Parser.LEN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUnaryStringFunction" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUnaryStringFunction"): listener.enterUnaryStringFunction(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUnaryStringFunction" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUnaryStringFunction"): listener.exitUnaryStringFunction(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUnaryStringFunction" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryStringFunction"): return visitor.visitUnaryStringFunction(self) else: return visitor.visitChildren(self) - class SubstrAtomContext(StringOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.StringOperatorsContext super().__init__(ANTLRParser) - self.startParameter = None # OptionalExprContext - self.endParameter = None # OptionalExprContext + self.startParameter = None # OptionalExprContext + self.endParameter = None # OptionalExprContext self.copyFrom(ctx) def SUBSTR(self): return self.getToken(Parser.SUBSTR, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def optionalExpr(self, i:int=None): + + def optionalExpr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.OptionalExprContext) else: - return self.getTypedRuleContext(Parser.OptionalExprContext,i) - + return self.getTypedRuleContext(Parser.OptionalExprContext, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSubstrAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSubstrAtom"): listener.enterSubstrAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSubstrAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSubstrAtom"): listener.exitSubstrAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSubstrAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSubstrAtom"): return visitor.visitSubstrAtom(self) else: return visitor.visitChildren(self) - class ReplaceAtomContext(StringOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.StringOperatorsContext super().__init__(ANTLRParser) - self.param = None # ExprContext + self.param = None # ExprContext self.copyFrom(ctx) def REPLACE(self): return self.getToken(Parser.REPLACE, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def optionalExpr(self): - return self.getTypedRuleContext(Parser.OptionalExprContext,0) + def optionalExpr(self): + return self.getTypedRuleContext(Parser.OptionalExprContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterReplaceAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterReplaceAtom"): listener.enterReplaceAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitReplaceAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitReplaceAtom"): listener.exitReplaceAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitReplaceAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitReplaceAtom"): return visitor.visitReplaceAtom(self) else: return visitor.visitChildren(self) - - def stringOperators(self): localctx = Parser.StringOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 42, self.RULE_stringOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 705 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.LTRIM, Parser.RTRIM]: + if token in [ + Parser.LEN, + Parser.TRIM, + Parser.UCASE, + Parser.LCASE, + Parser.LTRIM, + Parser.RTRIM, + ]: localctx = Parser.UnaryStringFunctionContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 657 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(((((_la - 93)) & ~0x3f) == 0 and ((1 << (_la - 93)) & ((1 << (Parser.LEN - 93)) | (1 << (Parser.TRIM - 93)) | (1 << (Parser.UCASE - 93)) | (1 << (Parser.LCASE - 93)) | (1 << (Parser.LTRIM - 93)) | (1 << (Parser.RTRIM - 93)))) != 0)): + if not ( + ((_la - 93) & ~0x3F) == 0 + and ( + (1 << (_la - 93)) + & ( + (1 << (Parser.LEN - 93)) + | (1 << (Parser.TRIM - 93)) + | (1 << (Parser.UCASE - 93)) + | (1 << (Parser.LCASE - 93)) + | (1 << (Parser.LTRIM - 93)) + | (1 << (Parser.RTRIM - 93)) + ) + ) + != 0 + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6048,12 +6924,12 @@ def stringOperators(self): self.expr(0) self.state = 675 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,50,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 50, self._ctx) if la_ == 1: self.state = 671 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 665 self.match(Parser.COMMA) self.state = 666 @@ -6064,7 +6940,6 @@ def stringOperators(self): self.state = 669 localctx.endParameter = self.optionalExpr() - pass elif la_ == 2: @@ -6074,7 +6949,6 @@ def stringOperators(self): localctx.startParameter = self.optionalExpr() pass - self.state = 677 self.match(Parser.RPAREN) pass @@ -6094,13 +6968,12 @@ def stringOperators(self): self.state = 686 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 684 self.match(Parser.COMMA) self.state = 685 self.optionalExpr() - self.state = 688 self.match(Parser.RPAREN) pass @@ -6119,24 +6992,22 @@ def stringOperators(self): localctx.pattern = self.expr(0) self.state = 697 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,52,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 52, self._ctx) if la_ == 1: self.state = 695 self.match(Parser.COMMA) self.state = 696 localctx.startParameter = self.optionalExpr() - self.state = 701 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 699 self.match(Parser.COMMA) self.state = 700 localctx.occurrenceParameter = self.optionalExpr() - self.state = 703 self.match(Parser.RPAREN) pass @@ -6151,218 +7022,249 @@ def stringOperators(self): self.exitRule() return localctx - class StringOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_stringOperatorsComponent - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class ReplaceAtomComponentContext(StringOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.StringOperatorsComponentContext super().__init__(ANTLRParser) - self.param = None # ExprComponentContext + self.param = None # ExprComponentContext self.copyFrom(ctx) def REPLACE(self): return self.getToken(Parser.REPLACE, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self, i:int=None): + + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) + return self.getTypedRuleContext(Parser.ExprComponentContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def optionalExprComponent(self): - return self.getTypedRuleContext(Parser.OptionalExprComponentContext,0) + def optionalExprComponent(self): + return self.getTypedRuleContext(Parser.OptionalExprComponentContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterReplaceAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterReplaceAtomComponent"): listener.enterReplaceAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitReplaceAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitReplaceAtomComponent"): listener.exitReplaceAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitReplaceAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitReplaceAtomComponent"): return visitor.visitReplaceAtomComponent(self) else: return visitor.visitChildren(self) - class UnaryStringFunctionComponentContext(StringOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.StringOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def TRIM(self): return self.getToken(Parser.TRIM, 0) + def LTRIM(self): return self.getToken(Parser.LTRIM, 0) + def RTRIM(self): return self.getToken(Parser.RTRIM, 0) + def UCASE(self): return self.getToken(Parser.UCASE, 0) + def LCASE(self): return self.getToken(Parser.LCASE, 0) + def LEN(self): return self.getToken(Parser.LEN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUnaryStringFunctionComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUnaryStringFunctionComponent"): listener.enterUnaryStringFunctionComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUnaryStringFunctionComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUnaryStringFunctionComponent"): listener.exitUnaryStringFunctionComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUnaryStringFunctionComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryStringFunctionComponent"): return visitor.visitUnaryStringFunctionComponent(self) else: return visitor.visitChildren(self) - class SubstrAtomComponentContext(StringOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.StringOperatorsComponentContext super().__init__(ANTLRParser) - self.startParameter = None # OptionalExprComponentContext - self.endParameter = None # OptionalExprComponentContext + self.startParameter = None # OptionalExprComponentContext + self.endParameter = None # OptionalExprComponentContext self.copyFrom(ctx) def SUBSTR(self): return self.getToken(Parser.SUBSTR, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def optionalExprComponent(self, i:int=None): + + def optionalExprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.OptionalExprComponentContext) else: - return self.getTypedRuleContext(Parser.OptionalExprComponentContext,i) - + return self.getTypedRuleContext(Parser.OptionalExprComponentContext, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSubstrAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSubstrAtomComponent"): listener.enterSubstrAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSubstrAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSubstrAtomComponent"): listener.exitSubstrAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSubstrAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSubstrAtomComponent"): return visitor.visitSubstrAtomComponent(self) else: return visitor.visitChildren(self) - class InstrAtomComponentContext(StringOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.StringOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.StringOperatorsComponentContext super().__init__(ANTLRParser) - self.pattern = None # ExprComponentContext - self.startParameter = None # OptionalExprComponentContext - self.occurrenceParameter = None # OptionalExprComponentContext + self.pattern = None # ExprComponentContext + self.startParameter = None # OptionalExprComponentContext + self.occurrenceParameter = None # OptionalExprComponentContext self.copyFrom(ctx) def INSTR(self): return self.getToken(Parser.INSTR, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def exprComponent(self, i:int=None): + + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) + return self.getTypedRuleContext(Parser.ExprComponentContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def optionalExprComponent(self, i:int=None): + + def optionalExprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.OptionalExprComponentContext) else: - return self.getTypedRuleContext(Parser.OptionalExprComponentContext,i) + return self.getTypedRuleContext(Parser.OptionalExprComponentContext, i) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInstrAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInstrAtomComponent"): listener.enterInstrAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInstrAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInstrAtomComponent"): listener.exitInstrAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInstrAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInstrAtomComponent"): return visitor.visitInstrAtomComponent(self) else: return visitor.visitChildren(self) - - def stringOperatorsComponent(self): localctx = Parser.StringOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 44, self.RULE_stringOperatorsComponent) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 755 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.LTRIM, Parser.RTRIM]: + if token in [ + Parser.LEN, + Parser.TRIM, + Parser.UCASE, + Parser.LCASE, + Parser.LTRIM, + Parser.RTRIM, + ]: localctx = Parser.UnaryStringFunctionComponentContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 707 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(((((_la - 93)) & ~0x3f) == 0 and ((1 << (_la - 93)) & ((1 << (Parser.LEN - 93)) | (1 << (Parser.TRIM - 93)) | (1 << (Parser.UCASE - 93)) | (1 << (Parser.LCASE - 93)) | (1 << (Parser.LTRIM - 93)) | (1 << (Parser.RTRIM - 93)))) != 0)): + if not ( + ((_la - 93) & ~0x3F) == 0 + and ( + (1 << (_la - 93)) + & ( + (1 << (Parser.LEN - 93)) + | (1 << (Parser.TRIM - 93)) + | (1 << (Parser.UCASE - 93)) + | (1 << (Parser.LCASE - 93)) + | (1 << (Parser.LTRIM - 93)) + | (1 << (Parser.RTRIM - 93)) + ) + ) + != 0 + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6385,12 +7287,12 @@ def stringOperatorsComponent(self): self.exprComponent(0) self.state = 725 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,56,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 56, self._ctx) if la_ == 1: self.state = 721 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 715 self.match(Parser.COMMA) self.state = 716 @@ -6401,7 +7303,6 @@ def stringOperatorsComponent(self): self.state = 719 localctx.endParameter = self.optionalExprComponent() - pass elif la_ == 2: @@ -6411,7 +7312,6 @@ def stringOperatorsComponent(self): localctx.startParameter = self.optionalExprComponent() pass - self.state = 727 self.match(Parser.RPAREN) pass @@ -6431,13 +7331,12 @@ def stringOperatorsComponent(self): self.state = 736 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 734 self.match(Parser.COMMA) self.state = 735 self.optionalExprComponent() - self.state = 738 self.match(Parser.RPAREN) pass @@ -6456,24 +7355,22 @@ def stringOperatorsComponent(self): localctx.pattern = self.exprComponent(0) self.state = 747 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,58,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 58, self._ctx) if la_ == 1: self.state = 745 self.match(Parser.COMMA) self.state = 746 localctx.startParameter = self.optionalExprComponent() - self.state = 751 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 749 self.match(Parser.COMMA) self.state = 750 localctx.occurrenceParameter = self.optionalExprComponent() - self.state = 753 self.match(Parser.RPAREN) pass @@ -6488,156 +7385,167 @@ def stringOperatorsComponent(self): self.exitRule() return localctx - class NumericOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_numericOperators - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class UnaryNumericContext(NumericOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.NumericOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def CEIL(self): return self.getToken(Parser.CEIL, 0) + def FLOOR(self): return self.getToken(Parser.FLOOR, 0) + def ABS(self): return self.getToken(Parser.ABS, 0) + def EXP(self): return self.getToken(Parser.EXP, 0) + def LN(self): return self.getToken(Parser.LN, 0) + def SQRT(self): return self.getToken(Parser.SQRT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUnaryNumeric" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUnaryNumeric"): listener.enterUnaryNumeric(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUnaryNumeric" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUnaryNumeric"): listener.exitUnaryNumeric(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUnaryNumeric" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryNumeric"): return visitor.visitUnaryNumeric(self) else: return visitor.visitChildren(self) - class UnaryWithOptionalNumericContext(NumericOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.NumericOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def ROUND(self): return self.getToken(Parser.ROUND, 0) + def TRUNC(self): return self.getToken(Parser.TRUNC, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) - def optionalExpr(self): - return self.getTypedRuleContext(Parser.OptionalExprContext,0) + def optionalExpr(self): + return self.getTypedRuleContext(Parser.OptionalExprContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUnaryWithOptionalNumeric" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUnaryWithOptionalNumeric"): listener.enterUnaryWithOptionalNumeric(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUnaryWithOptionalNumeric" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUnaryWithOptionalNumeric"): listener.exitUnaryWithOptionalNumeric(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUnaryWithOptionalNumeric" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryWithOptionalNumeric"): return visitor.visitUnaryWithOptionalNumeric(self) else: return visitor.visitChildren(self) - class BinaryNumericContext(NumericOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.NumericOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token - self.left = None # ExprContext - self.right = None # ExprContext + self.op = None # Token + self.left = None # ExprContext + self.right = None # ExprContext self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) def MOD(self): return self.getToken(Parser.MOD, 0) + def POWER(self): return self.getToken(Parser.POWER, 0) + def LOG(self): return self.getToken(Parser.LOG, 0) + def RANDOM(self): return self.getToken(Parser.RANDOM, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBinaryNumeric" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBinaryNumeric"): listener.enterBinaryNumeric(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBinaryNumeric" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBinaryNumeric"): listener.exitBinaryNumeric(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBinaryNumeric" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBinaryNumeric"): return visitor.visitBinaryNumeric(self) else: return visitor.visitChildren(self) - - def numericOperators(self): localctx = Parser.NumericOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 46, self.RULE_numericOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 778 self._errHandler.sync(self) @@ -6648,7 +7556,21 @@ def numericOperators(self): self.state = 757 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & ((1 << (Parser.ABS - 85)) | (1 << (Parser.LN - 85)) | (1 << (Parser.EXP - 85)) | (1 << (Parser.CEIL - 85)) | (1 << (Parser.FLOOR - 85)) | (1 << (Parser.SQRT - 85)))) != 0)): + if not ( + ((_la - 85) & ~0x3F) == 0 + and ( + (1 << (_la - 85)) + & ( + (1 << (Parser.ABS - 85)) + | (1 << (Parser.LN - 85)) + | (1 << (Parser.EXP - 85)) + | (1 << (Parser.CEIL - 85)) + | (1 << (Parser.FLOOR - 85)) + | (1 << (Parser.SQRT - 85)) + ) + ) + != 0 + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6666,7 +7588,7 @@ def numericOperators(self): self.state = 762 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.TRUNC or _la==Parser.ROUND): + if not (_la == Parser.TRUNC or _la == Parser.ROUND): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6678,13 +7600,12 @@ def numericOperators(self): self.state = 767 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 765 self.match(Parser.COMMA) self.state = 766 self.optionalExpr() - self.state = 769 self.match(Parser.RPAREN) pass @@ -6694,7 +7615,19 @@ def numericOperators(self): self.state = 771 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(((((_la - 61)) & ~0x3f) == 0 and ((1 << (_la - 61)) & ((1 << (Parser.RANDOM - 61)) | (1 << (Parser.LOG - 61)) | (1 << (Parser.POWER - 61)) | (1 << (Parser.MOD - 61)))) != 0)): + if not ( + ((_la - 61) & ~0x3F) == 0 + and ( + (1 << (_la - 61)) + & ( + (1 << (Parser.RANDOM - 61)) + | (1 << (Parser.LOG - 61)) + | (1 << (Parser.POWER - 61)) + | (1 << (Parser.MOD - 61)) + ) + ) + != 0 + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6721,156 +7654,167 @@ def numericOperators(self): self.exitRule() return localctx - class NumericOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_numericOperatorsComponent - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class UnaryNumericComponentContext(NumericOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.NumericOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def CEIL(self): return self.getToken(Parser.CEIL, 0) + def FLOOR(self): return self.getToken(Parser.FLOOR, 0) + def ABS(self): return self.getToken(Parser.ABS, 0) + def EXP(self): return self.getToken(Parser.EXP, 0) + def LN(self): return self.getToken(Parser.LN, 0) + def SQRT(self): return self.getToken(Parser.SQRT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUnaryNumericComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUnaryNumericComponent"): listener.enterUnaryNumericComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUnaryNumericComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUnaryNumericComponent"): listener.exitUnaryNumericComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUnaryNumericComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryNumericComponent"): return visitor.visitUnaryNumericComponent(self) else: return visitor.visitChildren(self) - class BinaryNumericComponentContext(NumericOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.NumericOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.left = None # ExprComponentContext - self.right = None # ExprComponentContext + self.op = None # Token + self.left = None # ExprComponentContext + self.right = None # ExprComponentContext self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def exprComponent(self, i:int=None): + + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) + return self.getTypedRuleContext(Parser.ExprComponentContext, i) def MOD(self): return self.getToken(Parser.MOD, 0) + def POWER(self): return self.getToken(Parser.POWER, 0) + def LOG(self): return self.getToken(Parser.LOG, 0) + def RANDOM(self): return self.getToken(Parser.RANDOM, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBinaryNumericComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBinaryNumericComponent"): listener.enterBinaryNumericComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBinaryNumericComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBinaryNumericComponent"): listener.exitBinaryNumericComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBinaryNumericComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBinaryNumericComponent"): return visitor.visitBinaryNumericComponent(self) else: return visitor.visitChildren(self) - class UnaryWithOptionalNumericComponentContext(NumericOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.NumericOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.NumericOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def ROUND(self): return self.getToken(Parser.ROUND, 0) + def TRUNC(self): return self.getToken(Parser.TRUNC, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) - def optionalExprComponent(self): - return self.getTypedRuleContext(Parser.OptionalExprComponentContext,0) + def optionalExprComponent(self): + return self.getTypedRuleContext(Parser.OptionalExprComponentContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUnaryWithOptionalNumericComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUnaryWithOptionalNumericComponent"): listener.enterUnaryWithOptionalNumericComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUnaryWithOptionalNumericComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUnaryWithOptionalNumericComponent"): listener.exitUnaryWithOptionalNumericComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUnaryWithOptionalNumericComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryWithOptionalNumericComponent"): return visitor.visitUnaryWithOptionalNumericComponent(self) else: return visitor.visitChildren(self) - - def numericOperatorsComponent(self): localctx = Parser.NumericOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 48, self.RULE_numericOperatorsComponent) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 801 self._errHandler.sync(self) @@ -6881,7 +7825,21 @@ def numericOperatorsComponent(self): self.state = 780 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & ((1 << (Parser.ABS - 85)) | (1 << (Parser.LN - 85)) | (1 << (Parser.EXP - 85)) | (1 << (Parser.CEIL - 85)) | (1 << (Parser.FLOOR - 85)) | (1 << (Parser.SQRT - 85)))) != 0)): + if not ( + ((_la - 85) & ~0x3F) == 0 + and ( + (1 << (_la - 85)) + & ( + (1 << (Parser.ABS - 85)) + | (1 << (Parser.LN - 85)) + | (1 << (Parser.EXP - 85)) + | (1 << (Parser.CEIL - 85)) + | (1 << (Parser.FLOOR - 85)) + | (1 << (Parser.SQRT - 85)) + ) + ) + != 0 + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6899,7 +7857,7 @@ def numericOperatorsComponent(self): self.state = 785 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.TRUNC or _la==Parser.ROUND): + if not (_la == Parser.TRUNC or _la == Parser.ROUND): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6911,13 +7869,12 @@ def numericOperatorsComponent(self): self.state = 790 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 788 self.match(Parser.COMMA) self.state = 789 self.optionalExprComponent() - self.state = 792 self.match(Parser.RPAREN) pass @@ -6927,7 +7884,19 @@ def numericOperatorsComponent(self): self.state = 794 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(((((_la - 61)) & ~0x3f) == 0 and ((1 << (_la - 61)) & ((1 << (Parser.RANDOM - 61)) | (1 << (Parser.LOG - 61)) | (1 << (Parser.POWER - 61)) | (1 << (Parser.MOD - 61)))) != 0)): + if not ( + ((_la - 61) & ~0x3F) == 0 + and ( + (1 << (_la - 61)) + & ( + (1 << (Parser.RANDOM - 61)) + | (1 << (Parser.LOG - 61)) + | (1 << (Parser.POWER - 61)) + | (1 << (Parser.MOD - 61)) + ) + ) + != 0 + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -6954,185 +7923,190 @@ def numericOperatorsComponent(self): self.exitRule() return localctx - class ComparisonOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_comparisonOperators - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class BetweenAtomContext(ComparisonOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ComparisonOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.from_ = None # ExprContext - self.to_ = None # ExprContext + self.op = None # ExprContext + self.from_ = None # ExprContext + self.to_ = None # ExprContext self.copyFrom(ctx) def BETWEEN(self): return self.getToken(Parser.BETWEEN, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBetweenAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBetweenAtom"): listener.enterBetweenAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBetweenAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBetweenAtom"): listener.exitBetweenAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBetweenAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBetweenAtom"): return visitor.visitBetweenAtom(self) else: return visitor.visitChildren(self) - class CharsetMatchAtomContext(ComparisonOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ComparisonOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.pattern = None # ExprContext + self.op = None # ExprContext + self.pattern = None # ExprContext self.copyFrom(ctx) def CHARSET_MATCH(self): return self.getToken(Parser.CHARSET_MATCH, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) - + return self.getTypedRuleContext(Parser.ExprContext, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCharsetMatchAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCharsetMatchAtom"): listener.enterCharsetMatchAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCharsetMatchAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCharsetMatchAtom"): listener.exitCharsetMatchAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCharsetMatchAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCharsetMatchAtom"): return visitor.visitCharsetMatchAtom(self) else: return visitor.visitChildren(self) - class IsNullAtomContext(ComparisonOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ComparisonOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def ISNULL(self): return self.getToken(Parser.ISNULL, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIsNullAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIsNullAtom"): listener.enterIsNullAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIsNullAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIsNullAtom"): listener.exitIsNullAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIsNullAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIsNullAtom"): return visitor.visitIsNullAtom(self) else: return visitor.visitChildren(self) - class ExistInAtomContext(ComparisonOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ComparisonOperatorsContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.right = None # ExprContext + self.left = None # ExprContext + self.right = None # ExprContext self.copyFrom(ctx) def EXISTS_IN(self): return self.getToken(Parser.EXISTS_IN, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) def retainType(self): - return self.getTypedRuleContext(Parser.RetainTypeContext,0) - + return self.getTypedRuleContext(Parser.RetainTypeContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterExistInAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterExistInAtom"): listener.enterExistInAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitExistInAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitExistInAtom"): listener.exitExistInAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitExistInAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitExistInAtom"): return visitor.visitExistInAtom(self) else: return visitor.visitChildren(self) - - def comparisonOperators(self): localctx = Parser.ComparisonOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 50, self.RULE_comparisonOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 835 self._errHandler.sync(self) @@ -7201,13 +8175,12 @@ def comparisonOperators(self): self.state = 831 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 829 self.match(Parser.COMMA) self.state = 830 self.retainType() - self.state = 833 self.match(Parser.RPAREN) pass @@ -7222,136 +8195,138 @@ def comparisonOperators(self): self.exitRule() return localctx - class ComparisonOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_comparisonOperatorsComponent - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class IsNullAtomComponentContext(ComparisonOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ComparisonOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def ISNULL(self): return self.getToken(Parser.ISNULL, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIsNullAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIsNullAtomComponent"): listener.enterIsNullAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIsNullAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIsNullAtomComponent"): listener.exitIsNullAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIsNullAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIsNullAtomComponent"): return visitor.visitIsNullAtomComponent(self) else: return visitor.visitChildren(self) - class CharsetMatchAtomComponentContext(ComparisonOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ComparisonOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # ExprComponentContext - self.pattern = None # ExprComponentContext + self.op = None # ExprComponentContext + self.pattern = None # ExprComponentContext self.copyFrom(ctx) def CHARSET_MATCH(self): return self.getToken(Parser.CHARSET_MATCH, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def exprComponent(self, i:int=None): + + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) - + return self.getTypedRuleContext(Parser.ExprComponentContext, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCharsetMatchAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCharsetMatchAtomComponent"): listener.enterCharsetMatchAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCharsetMatchAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCharsetMatchAtomComponent"): listener.exitCharsetMatchAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCharsetMatchAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCharsetMatchAtomComponent"): return visitor.visitCharsetMatchAtomComponent(self) else: return visitor.visitChildren(self) - class BetweenAtomComponentContext(ComparisonOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ComparisonOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ComparisonOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # ExprComponentContext - self.from_ = None # ExprComponentContext - self.to_ = None # ExprComponentContext + self.op = None # ExprComponentContext + self.from_ = None # ExprComponentContext + self.to_ = None # ExprComponentContext self.copyFrom(ctx) def BETWEEN(self): return self.getToken(Parser.BETWEEN, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def exprComponent(self, i:int=None): + + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) - + return self.getTypedRuleContext(Parser.ExprComponentContext, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBetweenAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBetweenAtomComponent"): listener.enterBetweenAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBetweenAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBetweenAtomComponent"): listener.exitBetweenAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBetweenAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBetweenAtomComponent"): return visitor.visitBetweenAtomComponent(self) else: return visitor.visitChildren(self) - - def comparisonOperatorsComponent(self): localctx = Parser.ComparisonOperatorsComponentContext(self, self._ctx, self.state) @@ -7419,574 +8394,612 @@ def comparisonOperatorsComponent(self): self.exitRule() return localctx - class TimeOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_timeOperators - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class DayToYearAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYTOYEAR(self): return self.getToken(Parser.DAYTOYEAR, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDayToYearAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDayToYearAtom"): listener.enterDayToYearAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDayToYearAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDayToYearAtom"): listener.exitDayToYearAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDayToYearAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayToYearAtom"): return visitor.visitDayToYearAtom(self) else: return visitor.visitChildren(self) - class YearAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def YEAR_OP(self): return self.getToken(Parser.YEAR_OP, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterYearAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterYearAtom"): listener.enterYearAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitYearAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitYearAtom"): listener.exitYearAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitYearAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitYearAtom"): return visitor.visitYearAtom(self) else: return visitor.visitChildren(self) - class MonthToDayAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def MONTHTODAY(self): return self.getToken(Parser.MONTHTODAY, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterMonthToDayAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMonthToDayAtom"): listener.enterMonthToDayAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitMonthToDayAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMonthToDayAtom"): listener.exitMonthToDayAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitMonthToDayAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMonthToDayAtom"): return visitor.visitMonthToDayAtom(self) else: return visitor.visitChildren(self) - class DayToMonthAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYTOMONTH(self): return self.getToken(Parser.DAYTOMONTH, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDayToMonthAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDayToMonthAtom"): listener.enterDayToMonthAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDayToMonthAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDayToMonthAtom"): listener.exitDayToMonthAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDayToMonthAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayToMonthAtom"): return visitor.visitDayToMonthAtom(self) else: return visitor.visitChildren(self) - class PeriodAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def PERIOD_INDICATOR(self): return self.getToken(Parser.PERIOD_INDICATOR, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + def expr(self): + return self.getTypedRuleContext(Parser.ExprContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPeriodAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPeriodAtom"): listener.enterPeriodAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPeriodAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPeriodAtom"): listener.exitPeriodAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPeriodAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPeriodAtom"): return visitor.visitPeriodAtom(self) else: return visitor.visitChildren(self) - class FillTimeAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def FILL_TIME_SERIES(self): return self.getToken(Parser.FILL_TIME_SERIES, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def SINGLE(self): return self.getToken(Parser.SINGLE, 0) + def ALL(self): return self.getToken(Parser.ALL, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFillTimeAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFillTimeAtom"): listener.enterFillTimeAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFillTimeAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFillTimeAtom"): listener.exitFillTimeAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFillTimeAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFillTimeAtom"): return visitor.visitFillTimeAtom(self) else: return visitor.visitChildren(self) - class MonthAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def MONTH_OP(self): return self.getToken(Parser.MONTH_OP, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterMonthAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMonthAtom"): listener.enterMonthAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitMonthAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMonthAtom"): listener.exitMonthAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitMonthAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMonthAtom"): return visitor.visitMonthAtom(self) else: return visitor.visitChildren(self) - class DayOfYearAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYOFYEAR(self): return self.getToken(Parser.DAYOFYEAR, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDayOfYearAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDayOfYearAtom"): listener.enterDayOfYearAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDayOfYearAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDayOfYearAtom"): listener.exitDayOfYearAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDayOfYearAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayOfYearAtom"): return visitor.visitDayOfYearAtom(self) else: return visitor.visitChildren(self) - class FlowAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def FLOW_TO_STOCK(self): return self.getToken(Parser.FLOW_TO_STOCK, 0) + def STOCK_TO_FLOW(self): return self.getToken(Parser.STOCK_TO_FLOW, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFlowAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFlowAtom"): listener.enterFlowAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFlowAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFlowAtom"): listener.exitFlowAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFlowAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFlowAtom"): return visitor.visitFlowAtom(self) else: return visitor.visitChildren(self) - class TimeShiftAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def TIMESHIFT(self): return self.getToken(Parser.TIMESHIFT, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def COMMA(self): return self.getToken(Parser.COMMA, 0) + def signedInteger(self): - return self.getTypedRuleContext(Parser.SignedIntegerContext,0) + return self.getTypedRuleContext(Parser.SignedIntegerContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimeShiftAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimeShiftAtom"): listener.enterTimeShiftAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimeShiftAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimeShiftAtom"): listener.exitTimeShiftAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimeShiftAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeShiftAtom"): return visitor.visitTimeShiftAtom(self) else: return visitor.visitChildren(self) - class TimeAggAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) - self.periodIndTo = None # Token - self.periodIndFrom = None # Token - self.op = None # OptionalExprContext + self.periodIndTo = None # Token + self.periodIndFrom = None # Token + self.op = None # OptionalExprContext self.copyFrom(ctx) def TIME_AGG(self): return self.getToken(Parser.TIME_AGG, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def STRING_CONSTANT(self, i:int=None): + + def STRING_CONSTANT(self, i: int = None): if i is None: return self.getTokens(Parser.STRING_CONSTANT) else: return self.getToken(Parser.STRING_CONSTANT, i) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def optionalExpr(self): - return self.getTypedRuleContext(Parser.OptionalExprContext,0) + return self.getTypedRuleContext(Parser.OptionalExprContext, 0) def FIRST(self): return self.getToken(Parser.FIRST, 0) + def LAST(self): return self.getToken(Parser.LAST, 0) + def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimeAggAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimeAggAtom"): listener.enterTimeAggAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimeAggAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimeAggAtom"): listener.exitTimeAggAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimeAggAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeAggAtom"): return visitor.visitTimeAggAtom(self) else: return visitor.visitChildren(self) - class DateDiffAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) - self.dateFrom = None # ExprContext - self.dateTo = None # ExprContext + self.dateFrom = None # ExprContext + self.dateTo = None # ExprContext self.copyFrom(ctx) def DATEDIFF(self): return self.getToken(Parser.DATEDIFF, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDateDiffAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDateDiffAtom"): listener.enterDateDiffAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDateDiffAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDateDiffAtom"): listener.exitDateDiffAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDateDiffAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateDiffAtom"): return visitor.visitDateDiffAtom(self) else: return visitor.visitChildren(self) - class DateAddAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.shiftNumber = None # ExprContext - self.periodInd = None # ExprContext + self.op = None # ExprContext + self.shiftNumber = None # ExprContext + self.periodInd = None # ExprContext self.copyFrom(ctx) def DATEADD(self): return self.getToken(Parser.DATEADD, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDateAddAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDateAddAtom"): listener.enterDateAddAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDateAddAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDateAddAtom"): listener.exitDateAddAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDateAddAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateAddAtom"): return visitor.visitDateAddAtom(self) else: return visitor.visitChildren(self) - class YearToDayAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def YEARTODAY(self): return self.getToken(Parser.YEARTODAY, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterYearToDayAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterYearToDayAtom"): listener.enterYearToDayAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitYearToDayAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitYearToDayAtom"): listener.exitYearToDayAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitYearToDayAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitYearToDayAtom"): return visitor.visitYearToDayAtom(self) else: return visitor.visitChildren(self) - class DayOfMonthAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYOFMONTH(self): return self.getToken(Parser.DAYOFMONTH, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDayOfMonthAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDayOfMonthAtom"): listener.enterDayOfMonthAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDayOfMonthAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDayOfMonthAtom"): listener.exitDayOfMonthAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDayOfMonthAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayOfMonthAtom"): return visitor.visitDayOfMonthAtom(self) else: return visitor.visitChildren(self) - class CurrentDateAtomContext(TimeOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CURRENT_DATE(self): return self.getToken(Parser.CURRENT_DATE, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCurrentDateAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCurrentDateAtom"): listener.enterCurrentDateAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCurrentDateAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCurrentDateAtom"): listener.exitCurrentDateAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCurrentDateAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCurrentDateAtom"): return visitor.visitCurrentDateAtom(self) else: return visitor.visitChildren(self) - - def timeOperators(self): localctx = Parser.TimeOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 54, self.RULE_timeOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 962 self._errHandler.sync(self) @@ -8001,11 +9014,131 @@ def timeOperators(self): self.state = 863 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CASE) | (1 << Parser.CURRENT_DATE) | (1 << Parser.DATEDIFF) | (1 << Parser.DATEADD) | (1 << Parser.YEAR_OP) | (1 << Parser.MONTH_OP) | (1 << Parser.DAYOFMONTH) | (1 << Parser.DAYOFYEAR) | (1 << Parser.DAYTOYEAR) | (1 << Parser.DAYTOMONTH) | (1 << Parser.YEARTODAY) | (1 << Parser.MONTHTODAY) | (1 << Parser.NOT) | (1 << Parser.BETWEEN) | (1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL) | (1 << Parser.UNION) | (1 << Parser.SYMDIFF) | (1 << Parser.INTERSECT) | (1 << Parser.RANDOM))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Parser.CHECK - 66)) | (1 << (Parser.EXISTS_IN - 66)) | (1 << (Parser.MIN - 66)) | (1 << (Parser.MAX - 66)) | (1 << (Parser.ABS - 66)) | (1 << (Parser.LN - 66)) | (1 << (Parser.LOG - 66)) | (1 << (Parser.TRUNC - 66)) | (1 << (Parser.ROUND - 66)) | (1 << (Parser.POWER - 66)) | (1 << (Parser.MOD - 66)) | (1 << (Parser.LEN - 66)) | (1 << (Parser.TRIM - 66)) | (1 << (Parser.UCASE - 66)) | (1 << (Parser.LCASE - 66)) | (1 << (Parser.SUBSTR - 66)) | (1 << (Parser.SUM - 66)) | (1 << (Parser.AVG - 66)) | (1 << (Parser.MEDIAN - 66)) | (1 << (Parser.COUNT - 66)) | (1 << (Parser.EXP - 66)) | (1 << (Parser.CHARSET_MATCH - 66)) | (1 << (Parser.NVL - 66)) | (1 << (Parser.HIERARCHY - 66)))) != 0) or ((((_la - 131)) & ~0x3f) == 0 and ((1 << (_la - 131)) & ((1 << (Parser.LTRIM - 131)) | (1 << (Parser.RTRIM - 131)) | (1 << (Parser.INSTR - 131)) | (1 << (Parser.REPLACE - 131)) | (1 << (Parser.CEIL - 131)) | (1 << (Parser.FLOOR - 131)) | (1 << (Parser.SQRT - 131)) | (1 << (Parser.SETDIFF - 131)) | (1 << (Parser.STDDEV_POP - 131)) | (1 << (Parser.STDDEV_SAMP - 131)) | (1 << (Parser.VAR_POP - 131)) | (1 << (Parser.VAR_SAMP - 131)) | (1 << (Parser.FIRST_VALUE - 131)) | (1 << (Parser.LAST_VALUE - 131)) | (1 << (Parser.LAG - 131)) | (1 << (Parser.LEAD - 131)) | (1 << (Parser.RATIO_TO_REPORT - 131)) | (1 << (Parser.FILL_TIME_SERIES - 131)) | (1 << (Parser.FLOW_TO_STOCK - 131)) | (1 << (Parser.STOCK_TO_FLOW - 131)) | (1 << (Parser.TIMESHIFT - 131)) | (1 << (Parser.INNER_JOIN - 131)) | (1 << (Parser.LEFT_JOIN - 131)))) != 0) or ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & ((1 << (Parser.CROSS_JOIN - 195)) | (1 << (Parser.FULL_JOIN - 195)) | (1 << (Parser.PERIOD_INDICATOR - 195)) | (1 << (Parser.TIME_AGG - 195)) | (1 << (Parser.CAST - 195)) | (1 << (Parser.CHECK_DATAPOINT - 195)) | (1 << (Parser.CHECK_HIERARCHY - 195)) | (1 << (Parser.INTEGER_CONSTANT - 195)) | (1 << (Parser.NUMBER_CONSTANT - 195)) | (1 << (Parser.BOOLEAN_CONSTANT - 195)) | (1 << (Parser.STRING_CONSTANT - 195)) | (1 << (Parser.IDENTIFIER - 195)))) != 0): + if ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << Parser.LPAREN) + | (1 << Parser.PLUS) + | (1 << Parser.MINUS) + | (1 << Parser.EVAL) + | (1 << Parser.IF) + | (1 << Parser.CASE) + | (1 << Parser.CURRENT_DATE) + | (1 << Parser.DATEDIFF) + | (1 << Parser.DATEADD) + | (1 << Parser.YEAR_OP) + | (1 << Parser.MONTH_OP) + | (1 << Parser.DAYOFMONTH) + | (1 << Parser.DAYOFYEAR) + | (1 << Parser.DAYTOYEAR) + | (1 << Parser.DAYTOMONTH) + | (1 << Parser.YEARTODAY) + | (1 << Parser.MONTHTODAY) + | (1 << Parser.NOT) + | (1 << Parser.BETWEEN) + | (1 << Parser.NULL_CONSTANT) + | (1 << Parser.ISNULL) + | (1 << Parser.UNION) + | (1 << Parser.SYMDIFF) + | (1 << Parser.INTERSECT) + | (1 << Parser.RANDOM) + ) + ) + != 0 + ) + or ( + ((_la - 66) & ~0x3F) == 0 + and ( + (1 << (_la - 66)) + & ( + (1 << (Parser.CHECK - 66)) + | (1 << (Parser.EXISTS_IN - 66)) + | (1 << (Parser.MIN - 66)) + | (1 << (Parser.MAX - 66)) + | (1 << (Parser.ABS - 66)) + | (1 << (Parser.LN - 66)) + | (1 << (Parser.LOG - 66)) + | (1 << (Parser.TRUNC - 66)) + | (1 << (Parser.ROUND - 66)) + | (1 << (Parser.POWER - 66)) + | (1 << (Parser.MOD - 66)) + | (1 << (Parser.LEN - 66)) + | (1 << (Parser.TRIM - 66)) + | (1 << (Parser.UCASE - 66)) + | (1 << (Parser.LCASE - 66)) + | (1 << (Parser.SUBSTR - 66)) + | (1 << (Parser.SUM - 66)) + | (1 << (Parser.AVG - 66)) + | (1 << (Parser.MEDIAN - 66)) + | (1 << (Parser.COUNT - 66)) + | (1 << (Parser.EXP - 66)) + | (1 << (Parser.CHARSET_MATCH - 66)) + | (1 << (Parser.NVL - 66)) + | (1 << (Parser.HIERARCHY - 66)) + ) + ) + != 0 + ) + or ( + ((_la - 131) & ~0x3F) == 0 + and ( + (1 << (_la - 131)) + & ( + (1 << (Parser.LTRIM - 131)) + | (1 << (Parser.RTRIM - 131)) + | (1 << (Parser.INSTR - 131)) + | (1 << (Parser.REPLACE - 131)) + | (1 << (Parser.CEIL - 131)) + | (1 << (Parser.FLOOR - 131)) + | (1 << (Parser.SQRT - 131)) + | (1 << (Parser.SETDIFF - 131)) + | (1 << (Parser.STDDEV_POP - 131)) + | (1 << (Parser.STDDEV_SAMP - 131)) + | (1 << (Parser.VAR_POP - 131)) + | (1 << (Parser.VAR_SAMP - 131)) + | (1 << (Parser.FIRST_VALUE - 131)) + | (1 << (Parser.LAST_VALUE - 131)) + | (1 << (Parser.LAG - 131)) + | (1 << (Parser.LEAD - 131)) + | (1 << (Parser.RATIO_TO_REPORT - 131)) + | (1 << (Parser.FILL_TIME_SERIES - 131)) + | (1 << (Parser.FLOW_TO_STOCK - 131)) + | (1 << (Parser.STOCK_TO_FLOW - 131)) + | (1 << (Parser.TIMESHIFT - 131)) + | (1 << (Parser.INNER_JOIN - 131)) + | (1 << (Parser.LEFT_JOIN - 131)) + ) + ) + != 0 + ) + or ( + ((_la - 195) & ~0x3F) == 0 + and ( + (1 << (_la - 195)) + & ( + (1 << (Parser.CROSS_JOIN - 195)) + | (1 << (Parser.FULL_JOIN - 195)) + | (1 << (Parser.PERIOD_INDICATOR - 195)) + | (1 << (Parser.TIME_AGG - 195)) + | (1 << (Parser.CAST - 195)) + | (1 << (Parser.CHECK_DATAPOINT - 195)) + | (1 << (Parser.CHECK_HIERARCHY - 195)) + | (1 << (Parser.INTEGER_CONSTANT - 195)) + | (1 << (Parser.NUMBER_CONSTANT - 195)) + | (1 << (Parser.BOOLEAN_CONSTANT - 195)) + | (1 << (Parser.STRING_CONSTANT - 195)) + | (1 << (Parser.IDENTIFIER - 195)) + ) + ) + != 0 + ) + ): self.state = 862 self.expr(0) - self.state = 865 self.match(Parser.RPAREN) pass @@ -8021,18 +9154,17 @@ def timeOperators(self): self.state = 871 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 869 self.match(Parser.COMMA) self.state = 870 _la = self._input.LA(1) - if not(_la==Parser.ALL or _la==Parser.SINGLE): + if not (_la == Parser.ALL or _la == Parser.SINGLE): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 873 self.match(Parser.RPAREN) pass @@ -8042,7 +9174,7 @@ def timeOperators(self): self.state = 875 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.FLOW_TO_STOCK or _la==Parser.STOCK_TO_FLOW): + if not (_la == Parser.FLOW_TO_STOCK or _la == Parser.STOCK_TO_FLOW): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -8081,45 +9213,42 @@ def timeOperators(self): localctx.periodIndTo = self.match(Parser.STRING_CONSTANT) self.state = 892 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,70,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 70, self._ctx) if la_ == 1: self.state = 890 self.match(Parser.COMMA) self.state = 891 localctx.periodIndFrom = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.OPTIONAL or _la==Parser.STRING_CONSTANT): + if not (_la == Parser.OPTIONAL or _la == Parser.STRING_CONSTANT): localctx.periodIndFrom = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 896 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,71,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 71, self._ctx) if la_ == 1: self.state = 894 self.match(Parser.COMMA) self.state = 895 localctx.op = self.optionalExpr() - self.state = 900 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 898 self.match(Parser.COMMA) self.state = 899 _la = self._input.LA(1) - if not(_la==Parser.FIRST or _la==Parser.LAST): + if not (_la == Parser.FIRST or _la == Parser.LAST): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 902 self.match(Parser.RPAREN) pass @@ -8276,574 +9405,612 @@ def timeOperators(self): self.exitRule() return localctx - class TimeOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_timeOperatorsComponent - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class PeriodAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def PERIOD_INDICATOR(self): return self.getToken(Parser.PERIOD_INDICATOR, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + def exprComponent(self): + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPeriodAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPeriodAtomComponent"): listener.enterPeriodAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPeriodAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPeriodAtomComponent"): listener.exitPeriodAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPeriodAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPeriodAtomComponent"): return visitor.visitPeriodAtomComponent(self) else: return visitor.visitChildren(self) - class TimeShiftAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def TIMESHIFT(self): return self.getToken(Parser.TIMESHIFT, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def COMMA(self): return self.getToken(Parser.COMMA, 0) + def signedInteger(self): - return self.getTypedRuleContext(Parser.SignedIntegerContext,0) + return self.getTypedRuleContext(Parser.SignedIntegerContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimeShiftAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimeShiftAtomComponent"): listener.enterTimeShiftAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimeShiftAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimeShiftAtomComponent"): listener.exitTimeShiftAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimeShiftAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeShiftAtomComponent"): return visitor.visitTimeShiftAtomComponent(self) else: return visitor.visitChildren(self) - class TimeAggAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) - self.periodIndTo = None # Token - self.periodIndFrom = None # Token - self.op = None # OptionalExprComponentContext + self.periodIndTo = None # Token + self.periodIndFrom = None # Token + self.op = None # OptionalExprComponentContext self.copyFrom(ctx) def TIME_AGG(self): return self.getToken(Parser.TIME_AGG, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def STRING_CONSTANT(self, i:int=None): + + def STRING_CONSTANT(self, i: int = None): if i is None: return self.getTokens(Parser.STRING_CONSTANT) else: return self.getToken(Parser.STRING_CONSTANT, i) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def optionalExprComponent(self): - return self.getTypedRuleContext(Parser.OptionalExprComponentContext,0) + return self.getTypedRuleContext(Parser.OptionalExprComponentContext, 0) def FIRST(self): return self.getToken(Parser.FIRST, 0) + def LAST(self): return self.getToken(Parser.LAST, 0) + def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimeAggAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimeAggAtomComponent"): listener.enterTimeAggAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimeAggAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimeAggAtomComponent"): listener.exitTimeAggAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimeAggAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeAggAtomComponent"): return visitor.visitTimeAggAtomComponent(self) else: return visitor.visitChildren(self) - class DayToMonthAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYTOMONTH(self): return self.getToken(Parser.DAYTOMONTH, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDayToMonthAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDayToMonthAtomComponent"): listener.enterDayToMonthAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDayToMonthAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDayToMonthAtomComponent"): listener.exitDayToMonthAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDayToMonthAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayToMonthAtomComponent"): return visitor.visitDayToMonthAtomComponent(self) else: return visitor.visitChildren(self) - class DateAddAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # ExprComponentContext - self.shiftNumber = None # ExprComponentContext - self.periodInd = None # ExprComponentContext + self.op = None # ExprComponentContext + self.shiftNumber = None # ExprComponentContext + self.periodInd = None # ExprComponentContext self.copyFrom(ctx) def DATEADD(self): return self.getToken(Parser.DATEADD, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def exprComponent(self, i:int=None): + + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) + return self.getTypedRuleContext(Parser.ExprComponentContext, i) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDateAddAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDateAddAtomComponent"): listener.enterDateAddAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDateAddAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDateAddAtomComponent"): listener.exitDateAddAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDateAddAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateAddAtomComponent"): return visitor.visitDateAddAtomComponent(self) else: return visitor.visitChildren(self) - class MonthToDayAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def MONTHTODAY(self): return self.getToken(Parser.MONTHTODAY, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterMonthToDayAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMonthToDayAtomComponent"): listener.enterMonthToDayAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitMonthToDayAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMonthToDayAtomComponent"): listener.exitMonthToDayAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitMonthToDayAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMonthToDayAtomComponent"): return visitor.visitMonthToDayAtomComponent(self) else: return visitor.visitChildren(self) - class DayOfMonthAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYOFMONTH(self): return self.getToken(Parser.DAYOFMONTH, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDayOfMonthAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDayOfMonthAtomComponent"): listener.enterDayOfMonthAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDayOfMonthAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDayOfMonthAtomComponent"): listener.exitDayOfMonthAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDayOfMonthAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayOfMonthAtomComponent"): return visitor.visitDayOfMonthAtomComponent(self) else: return visitor.visitChildren(self) - class DayOfYearAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYOFYEAR(self): return self.getToken(Parser.DAYOFYEAR, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDayOfYearAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDayOfYearAtomComponent"): listener.enterDayOfYearAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDayOfYearAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDayOfYearAtomComponent"): listener.exitDayOfYearAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDayOfYearAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayOfYearAtomComponent"): return visitor.visitDayOfYearAtomComponent(self) else: return visitor.visitChildren(self) - class MonthAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def MONTH_OP(self): return self.getToken(Parser.MONTH_OP, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterMonthAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMonthAtomComponent"): listener.enterMonthAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitMonthAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMonthAtomComponent"): listener.exitMonthAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitMonthAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMonthAtomComponent"): return visitor.visitMonthAtomComponent(self) else: return visitor.visitChildren(self) - class YearToDayAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def YEARTODAY(self): return self.getToken(Parser.YEARTODAY, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterYearToDayAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterYearToDayAtomComponent"): listener.enterYearToDayAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitYearToDayAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitYearToDayAtomComponent"): listener.exitYearToDayAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitYearToDayAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitYearToDayAtomComponent"): return visitor.visitYearToDayAtomComponent(self) else: return visitor.visitChildren(self) - class FillTimeAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def FILL_TIME_SERIES(self): return self.getToken(Parser.FILL_TIME_SERIES, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def SINGLE(self): return self.getToken(Parser.SINGLE, 0) + def ALL(self): return self.getToken(Parser.ALL, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFillTimeAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFillTimeAtomComponent"): listener.enterFillTimeAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFillTimeAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFillTimeAtomComponent"): listener.exitFillTimeAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFillTimeAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFillTimeAtomComponent"): return visitor.visitFillTimeAtomComponent(self) else: return visitor.visitChildren(self) - class DayToYearAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DAYTOYEAR(self): return self.getToken(Parser.DAYTOYEAR, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDayToYearAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDayToYearAtomComponent"): listener.enterDayToYearAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDayToYearAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDayToYearAtomComponent"): listener.exitDayToYearAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDayToYearAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayToYearAtomComponent"): return visitor.visitDayToYearAtomComponent(self) else: return visitor.visitChildren(self) - class CurrentDateAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CURRENT_DATE(self): return self.getToken(Parser.CURRENT_DATE, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCurrentDateAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCurrentDateAtomComponent"): listener.enterCurrentDateAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCurrentDateAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCurrentDateAtomComponent"): listener.exitCurrentDateAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCurrentDateAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCurrentDateAtomComponent"): return visitor.visitCurrentDateAtomComponent(self) else: return visitor.visitChildren(self) - class FlowAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def FLOW_TO_STOCK(self): return self.getToken(Parser.FLOW_TO_STOCK, 0) + def STOCK_TO_FLOW(self): return self.getToken(Parser.STOCK_TO_FLOW, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFlowAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFlowAtomComponent"): listener.enterFlowAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFlowAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFlowAtomComponent"): listener.exitFlowAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFlowAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFlowAtomComponent"): return visitor.visitFlowAtomComponent(self) else: return visitor.visitChildren(self) - class DateDiffAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) - self.dateFrom = None # ExprComponentContext - self.dateTo = None # ExprComponentContext + self.dateFrom = None # ExprComponentContext + self.dateTo = None # ExprComponentContext self.copyFrom(ctx) def DATEDIFF(self): return self.getToken(Parser.DATEDIFF, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def exprComponent(self, i:int=None): + + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) + return self.getTypedRuleContext(Parser.ExprComponentContext, i) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDateDiffAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDateDiffAtomComponent"): listener.enterDateDiffAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDateDiffAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDateDiffAtomComponent"): listener.exitDateDiffAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDateDiffAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateDiffAtomComponent"): return visitor.visitDateDiffAtomComponent(self) else: return visitor.visitChildren(self) - class YearAtomComponentContext(TimeOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.TimeOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.TimeOperatorsComponentContext super().__init__(ANTLRParser) self.copyFrom(ctx) def YEAR_OP(self): return self.getToken(Parser.YEAR_OP, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterYearAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterYearAtomComponent"): listener.enterYearAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitYearAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitYearAtomComponent"): listener.exitYearAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitYearAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitYearAtomComponent"): return visitor.visitYearAtomComponent(self) else: return visitor.visitChildren(self) - - def timeOperatorsComponent(self): localctx = Parser.TimeOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 56, self.RULE_timeOperatorsComponent) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1066 self._errHandler.sync(self) @@ -8858,11 +10025,119 @@ def timeOperatorsComponent(self): self.state = 967 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CASE) | (1 << Parser.CURRENT_DATE) | (1 << Parser.DATEDIFF) | (1 << Parser.DATEADD) | (1 << Parser.YEAR_OP) | (1 << Parser.MONTH_OP) | (1 << Parser.DAYOFMONTH) | (1 << Parser.DAYOFYEAR) | (1 << Parser.DAYTOYEAR) | (1 << Parser.DAYTOMONTH) | (1 << Parser.YEARTODAY) | (1 << Parser.MONTHTODAY) | (1 << Parser.NOT) | (1 << Parser.BETWEEN) | (1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL) | (1 << Parser.RANDOM))) != 0) or ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & ((1 << (Parser.RANK - 77)) | (1 << (Parser.MIN - 77)) | (1 << (Parser.MAX - 77)) | (1 << (Parser.ABS - 77)) | (1 << (Parser.LN - 77)) | (1 << (Parser.LOG - 77)) | (1 << (Parser.TRUNC - 77)) | (1 << (Parser.ROUND - 77)) | (1 << (Parser.POWER - 77)) | (1 << (Parser.MOD - 77)) | (1 << (Parser.LEN - 77)) | (1 << (Parser.TRIM - 77)) | (1 << (Parser.UCASE - 77)) | (1 << (Parser.LCASE - 77)) | (1 << (Parser.SUBSTR - 77)) | (1 << (Parser.SUM - 77)) | (1 << (Parser.AVG - 77)) | (1 << (Parser.MEDIAN - 77)) | (1 << (Parser.COUNT - 77)) | (1 << (Parser.EXP - 77)) | (1 << (Parser.CHARSET_MATCH - 77)) | (1 << (Parser.NVL - 77)) | (1 << (Parser.LTRIM - 77)) | (1 << (Parser.RTRIM - 77)) | (1 << (Parser.INSTR - 77)) | (1 << (Parser.REPLACE - 77)) | (1 << (Parser.CEIL - 77)) | (1 << (Parser.FLOOR - 77)) | (1 << (Parser.SQRT - 77)) | (1 << (Parser.STDDEV_POP - 77)))) != 0) or ((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & ((1 << (Parser.STDDEV_SAMP - 141)) | (1 << (Parser.VAR_POP - 141)) | (1 << (Parser.VAR_SAMP - 141)) | (1 << (Parser.FIRST_VALUE - 141)) | (1 << (Parser.LAST_VALUE - 141)) | (1 << (Parser.LAG - 141)) | (1 << (Parser.LEAD - 141)) | (1 << (Parser.RATIO_TO_REPORT - 141)) | (1 << (Parser.FILL_TIME_SERIES - 141)) | (1 << (Parser.FLOW_TO_STOCK - 141)) | (1 << (Parser.STOCK_TO_FLOW - 141)) | (1 << (Parser.TIMESHIFT - 141)))) != 0) or ((((_la - 208)) & ~0x3f) == 0 and ((1 << (_la - 208)) & ((1 << (Parser.PERIOD_INDICATOR - 208)) | (1 << (Parser.TIME_AGG - 208)) | (1 << (Parser.CAST - 208)) | (1 << (Parser.INTEGER_CONSTANT - 208)) | (1 << (Parser.NUMBER_CONSTANT - 208)) | (1 << (Parser.BOOLEAN_CONSTANT - 208)) | (1 << (Parser.STRING_CONSTANT - 208)) | (1 << (Parser.IDENTIFIER - 208)))) != 0): + if ( + ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << Parser.LPAREN) + | (1 << Parser.PLUS) + | (1 << Parser.MINUS) + | (1 << Parser.EVAL) + | (1 << Parser.IF) + | (1 << Parser.CASE) + | (1 << Parser.CURRENT_DATE) + | (1 << Parser.DATEDIFF) + | (1 << Parser.DATEADD) + | (1 << Parser.YEAR_OP) + | (1 << Parser.MONTH_OP) + | (1 << Parser.DAYOFMONTH) + | (1 << Parser.DAYOFYEAR) + | (1 << Parser.DAYTOYEAR) + | (1 << Parser.DAYTOMONTH) + | (1 << Parser.YEARTODAY) + | (1 << Parser.MONTHTODAY) + | (1 << Parser.NOT) + | (1 << Parser.BETWEEN) + | (1 << Parser.NULL_CONSTANT) + | (1 << Parser.ISNULL) + | (1 << Parser.RANDOM) + ) + ) + != 0 + ) + or ( + ((_la - 77) & ~0x3F) == 0 + and ( + (1 << (_la - 77)) + & ( + (1 << (Parser.RANK - 77)) + | (1 << (Parser.MIN - 77)) + | (1 << (Parser.MAX - 77)) + | (1 << (Parser.ABS - 77)) + | (1 << (Parser.LN - 77)) + | (1 << (Parser.LOG - 77)) + | (1 << (Parser.TRUNC - 77)) + | (1 << (Parser.ROUND - 77)) + | (1 << (Parser.POWER - 77)) + | (1 << (Parser.MOD - 77)) + | (1 << (Parser.LEN - 77)) + | (1 << (Parser.TRIM - 77)) + | (1 << (Parser.UCASE - 77)) + | (1 << (Parser.LCASE - 77)) + | (1 << (Parser.SUBSTR - 77)) + | (1 << (Parser.SUM - 77)) + | (1 << (Parser.AVG - 77)) + | (1 << (Parser.MEDIAN - 77)) + | (1 << (Parser.COUNT - 77)) + | (1 << (Parser.EXP - 77)) + | (1 << (Parser.CHARSET_MATCH - 77)) + | (1 << (Parser.NVL - 77)) + | (1 << (Parser.LTRIM - 77)) + | (1 << (Parser.RTRIM - 77)) + | (1 << (Parser.INSTR - 77)) + | (1 << (Parser.REPLACE - 77)) + | (1 << (Parser.CEIL - 77)) + | (1 << (Parser.FLOOR - 77)) + | (1 << (Parser.SQRT - 77)) + | (1 << (Parser.STDDEV_POP - 77)) + ) + ) + != 0 + ) + or ( + ((_la - 141) & ~0x3F) == 0 + and ( + (1 << (_la - 141)) + & ( + (1 << (Parser.STDDEV_SAMP - 141)) + | (1 << (Parser.VAR_POP - 141)) + | (1 << (Parser.VAR_SAMP - 141)) + | (1 << (Parser.FIRST_VALUE - 141)) + | (1 << (Parser.LAST_VALUE - 141)) + | (1 << (Parser.LAG - 141)) + | (1 << (Parser.LEAD - 141)) + | (1 << (Parser.RATIO_TO_REPORT - 141)) + | (1 << (Parser.FILL_TIME_SERIES - 141)) + | (1 << (Parser.FLOW_TO_STOCK - 141)) + | (1 << (Parser.STOCK_TO_FLOW - 141)) + | (1 << (Parser.TIMESHIFT - 141)) + ) + ) + != 0 + ) + or ( + ((_la - 208) & ~0x3F) == 0 + and ( + (1 << (_la - 208)) + & ( + (1 << (Parser.PERIOD_INDICATOR - 208)) + | (1 << (Parser.TIME_AGG - 208)) + | (1 << (Parser.CAST - 208)) + | (1 << (Parser.INTEGER_CONSTANT - 208)) + | (1 << (Parser.NUMBER_CONSTANT - 208)) + | (1 << (Parser.BOOLEAN_CONSTANT - 208)) + | (1 << (Parser.STRING_CONSTANT - 208)) + | (1 << (Parser.IDENTIFIER - 208)) + ) + ) + != 0 + ) + ): self.state = 966 self.exprComponent(0) - self.state = 969 self.match(Parser.RPAREN) pass @@ -8878,18 +10153,17 @@ def timeOperatorsComponent(self): self.state = 975 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 973 self.match(Parser.COMMA) self.state = 974 _la = self._input.LA(1) - if not(_la==Parser.ALL or _la==Parser.SINGLE): + if not (_la == Parser.ALL or _la == Parser.SINGLE): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 977 self.match(Parser.RPAREN) pass @@ -8899,7 +10173,7 @@ def timeOperatorsComponent(self): self.state = 979 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.FLOW_TO_STOCK or _la==Parser.STOCK_TO_FLOW): + if not (_la == Parser.FLOW_TO_STOCK or _la == Parser.STOCK_TO_FLOW): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -8938,45 +10212,42 @@ def timeOperatorsComponent(self): localctx.periodIndTo = self.match(Parser.STRING_CONSTANT) self.state = 996 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,76,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 76, self._ctx) if la_ == 1: self.state = 994 self.match(Parser.COMMA) self.state = 995 localctx.periodIndFrom = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.OPTIONAL or _la==Parser.STRING_CONSTANT): + if not (_la == Parser.OPTIONAL or _la == Parser.STRING_CONSTANT): localctx.periodIndFrom = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 1000 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,77,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 77, self._ctx) if la_ == 1: self.state = 998 self.match(Parser.COMMA) self.state = 999 localctx.op = self.optionalExprComponent() - self.state = 1004 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 1002 self.match(Parser.COMMA) self.state = 1003 _la = self._input.LA(1) - if not(_la==Parser.FIRST or _la==Parser.LAST): + if not (_la == Parser.FIRST or _la == Parser.LAST): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 1006 self.match(Parser.RPAREN) pass @@ -9133,151 +10404,155 @@ def timeOperatorsComponent(self): self.exitRule() return localctx - class SetOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_setOperators - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class SetOrSYmDiffAtomContext(SetOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.SetOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.SetOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token - self.left = None # ExprContext - self.right = None # ExprContext + self.op = None # Token + self.left = None # ExprContext + self.right = None # ExprContext self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) def SETDIFF(self): return self.getToken(Parser.SETDIFF, 0) + def SYMDIFF(self): return self.getToken(Parser.SYMDIFF, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSetOrSYmDiffAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSetOrSYmDiffAtom"): listener.enterSetOrSYmDiffAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSetOrSYmDiffAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSetOrSYmDiffAtom"): listener.exitSetOrSYmDiffAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSetOrSYmDiffAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSetOrSYmDiffAtom"): return visitor.visitSetOrSYmDiffAtom(self) else: return visitor.visitChildren(self) - class IntersectAtomContext(SetOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.SetOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.SetOperatorsContext super().__init__(ANTLRParser) - self.left = None # ExprContext + self.left = None # ExprContext self.copyFrom(ctx) def INTERSECT(self): return self.getToken(Parser.INTERSECT, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntersectAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntersectAtom"): listener.enterIntersectAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntersectAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntersectAtom"): listener.exitIntersectAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntersectAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntersectAtom"): return visitor.visitIntersectAtom(self) else: return visitor.visitChildren(self) - class UnionAtomContext(SetOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.SetOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.SetOperatorsContext super().__init__(ANTLRParser) - self.left = None # ExprContext + self.left = None # ExprContext self.copyFrom(ctx) def UNION(self): return self.getToken(Parser.UNION, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUnionAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUnionAtom"): listener.enterUnionAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUnionAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUnionAtom"): listener.exitUnionAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUnionAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnionAtom"): return visitor.visitUnionAtom(self) else: return visitor.visitChildren(self) - - def setOperators(self): localctx = Parser.SetOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 58, self.RULE_setOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1097 self._errHandler.sync(self) @@ -9291,7 +10566,7 @@ def setOperators(self): self.match(Parser.LPAREN) self.state = 1070 localctx.left = self.expr(0) - self.state = 1073 + self.state = 1073 self._errHandler.sync(self) _la = self._input.LA(1) while True: @@ -9299,10 +10574,10 @@ def setOperators(self): self.match(Parser.COMMA) self.state = 1072 self.expr(0) - self.state = 1075 + self.state = 1075 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la==Parser.COMMA): + if not (_la == Parser.COMMA): break self.state = 1077 @@ -9317,7 +10592,7 @@ def setOperators(self): self.match(Parser.LPAREN) self.state = 1081 localctx.left = self.expr(0) - self.state = 1084 + self.state = 1084 self._errHandler.sync(self) _la = self._input.LA(1) while True: @@ -9325,10 +10600,10 @@ def setOperators(self): self.match(Parser.COMMA) self.state = 1083 self.expr(0) - self.state = 1086 + self.state = 1086 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la==Parser.COMMA): + if not (_la == Parser.COMMA): break self.state = 1088 @@ -9340,7 +10615,7 @@ def setOperators(self): self.state = 1090 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.SYMDIFF or _la==Parser.SETDIFF): + if not (_la == Parser.SYMDIFF or _la == Parser.SETDIFF): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -9367,16 +10642,15 @@ def setOperators(self): self.exitRule() return localctx - class HierarchyOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.op = None # ExprContext - self.hrName = None # Token - self.ruleComponent = None # ComponentIDContext + self.op = None # ExprContext + self.hrName = None # Token + self.ruleComponent = None # ComponentIDContext def HIERARCHY(self): return self.getToken(Parser.HIERARCHY, 0) @@ -9391,60 +10665,51 @@ def RPAREN(self): return self.getToken(Parser.RPAREN, 0) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) - + return self.getTypedRuleContext(Parser.ExprContext, 0) def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) def conditionClause(self): - return self.getTypedRuleContext(Parser.ConditionClauseContext,0) - + return self.getTypedRuleContext(Parser.ConditionClauseContext, 0) def RULE(self): return self.getToken(Parser.RULE, 0) def validationMode(self): - return self.getTypedRuleContext(Parser.ValidationModeContext,0) - + return self.getTypedRuleContext(Parser.ValidationModeContext, 0) def inputModeHierarchy(self): - return self.getTypedRuleContext(Parser.InputModeHierarchyContext,0) - + return self.getTypedRuleContext(Parser.InputModeHierarchyContext, 0) def outputModeHierarchy(self): - return self.getTypedRuleContext(Parser.OutputModeHierarchyContext,0) - + return self.getTypedRuleContext(Parser.OutputModeHierarchyContext, 0) def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext,0) - + return self.getTypedRuleContext(Parser.ComponentIDContext, 0) def getRuleIndex(self): return Parser.RULE_hierarchyOperators - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterHierarchyOperators" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterHierarchyOperators"): listener.enterHierarchyOperators(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitHierarchyOperators" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitHierarchyOperators"): listener.exitHierarchyOperators(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitHierarchyOperators" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHierarchyOperators"): return visitor.visitHierarchyOperators(self) else: return visitor.visitChildren(self) - - - def hierarchyOperators(self): localctx = Parser.HierarchyOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 60, self.RULE_hierarchyOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1099 @@ -9460,45 +10725,50 @@ def hierarchyOperators(self): self.state = 1105 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.CONDITION: + if _la == Parser.CONDITION: self.state = 1104 self.conditionClause() - self.state = 1109 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,84,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 84, self._ctx) if la_ == 1: self.state = 1107 self.match(Parser.RULE) self.state = 1108 localctx.ruleComponent = self.componentID() - self.state = 1112 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 225)) & ~0x3f) == 0 and ((1 << (_la - 225)) & ((1 << (Parser.NON_NULL - 225)) | (1 << (Parser.NON_ZERO - 225)) | (1 << (Parser.PARTIAL_NULL - 225)) | (1 << (Parser.PARTIAL_ZERO - 225)) | (1 << (Parser.ALWAYS_NULL - 225)) | (1 << (Parser.ALWAYS_ZERO - 225)))) != 0): + if ((_la - 225) & ~0x3F) == 0 and ( + (1 << (_la - 225)) + & ( + (1 << (Parser.NON_NULL - 225)) + | (1 << (Parser.NON_ZERO - 225)) + | (1 << (Parser.PARTIAL_NULL - 225)) + | (1 << (Parser.PARTIAL_ZERO - 225)) + | (1 << (Parser.ALWAYS_NULL - 225)) + | (1 << (Parser.ALWAYS_ZERO - 225)) + ) + ) != 0: self.state = 1111 self.validationMode() - self.state = 1115 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.DATASET or _la==Parser.RULE or _la==Parser.RULE_PRIORITY: + if _la == Parser.DATASET or _la == Parser.RULE or _la == Parser.RULE_PRIORITY: self.state = 1114 self.inputModeHierarchy() - self.state = 1118 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ALL or _la==Parser.COMPUTED: + if _la == Parser.ALL or _la == Parser.COMPUTED: self.state = 1117 self.outputModeHierarchy() - self.state = 1120 self.match(Parser.RPAREN) except RecognitionException as re: @@ -9509,183 +10779,191 @@ def hierarchyOperators(self): self.exitRule() return localctx - class ValidationOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_validationOperators - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class ValidateHRrulesetContext(ValidationOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ValidationOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ValidationOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.hrName = None # Token + self.op = None # ExprContext + self.hrName = None # Token self.copyFrom(ctx) def CHECK_HIERARCHY(self): return self.getToken(Parser.CHECK_HIERARCHY, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) + def conditionClause(self): - return self.getTypedRuleContext(Parser.ConditionClauseContext,0) + return self.getTypedRuleContext(Parser.ConditionClauseContext, 0) def RULE(self): return self.getToken(Parser.RULE, 0) + def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext,0) + return self.getTypedRuleContext(Parser.ComponentIDContext, 0) def validationMode(self): - return self.getTypedRuleContext(Parser.ValidationModeContext,0) + return self.getTypedRuleContext(Parser.ValidationModeContext, 0) def inputMode(self): - return self.getTypedRuleContext(Parser.InputModeContext,0) + return self.getTypedRuleContext(Parser.InputModeContext, 0) def validationOutput(self): - return self.getTypedRuleContext(Parser.ValidationOutputContext,0) + return self.getTypedRuleContext(Parser.ValidationOutputContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterValidateHRruleset" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterValidateHRruleset"): listener.enterValidateHRruleset(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitValidateHRruleset" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitValidateHRruleset"): listener.exitValidateHRruleset(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitValidateHRruleset" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidateHRruleset"): return visitor.visitValidateHRruleset(self) else: return visitor.visitChildren(self) - class ValidateDPrulesetContext(ValidationOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ValidationOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ValidationOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.dpName = None # Token + self.op = None # ExprContext + self.dpName = None # Token self.copyFrom(ctx) def CHECK_DATAPOINT(self): return self.getToken(Parser.CHECK_DATAPOINT, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) + def COMPONENTS(self): return self.getToken(Parser.COMPONENTS, 0) - def componentID(self, i:int=None): + + def componentID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext,i) + return self.getTypedRuleContext(Parser.ComponentIDContext, i) def validationOutput(self): - return self.getTypedRuleContext(Parser.ValidationOutputContext,0) + return self.getTypedRuleContext(Parser.ValidationOutputContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterValidateDPruleset" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterValidateDPruleset"): listener.enterValidateDPruleset(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitValidateDPruleset" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitValidateDPruleset"): listener.exitValidateDPruleset(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitValidateDPruleset" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidateDPruleset"): return visitor.visitValidateDPruleset(self) else: return visitor.visitChildren(self) - class ValidationSimpleContext(ValidationOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ValidationOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ValidationOperatorsContext super().__init__(ANTLRParser) - self.op = None # ExprContext - self.codeErr = None # ErCodeContext - self.levelCode = None # ErLevelContext - self.output = None # Token + self.op = None # ExprContext + self.codeErr = None # ErCodeContext + self.levelCode = None # ErLevelContext + self.output = None # Token self.copyFrom(ctx) def CHECK(self): return self.getToken(Parser.CHECK, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def imbalanceExpr(self): - return self.getTypedRuleContext(Parser.ImbalanceExprContext,0) + return self.getTypedRuleContext(Parser.ImbalanceExprContext, 0) def erCode(self): - return self.getTypedRuleContext(Parser.ErCodeContext,0) + return self.getTypedRuleContext(Parser.ErCodeContext, 0) def erLevel(self): - return self.getTypedRuleContext(Parser.ErLevelContext,0) + return self.getTypedRuleContext(Parser.ErLevelContext, 0) def INVALID(self): return self.getToken(Parser.INVALID, 0) + def ALL(self): return self.getToken(Parser.ALL, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterValidationSimple" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterValidationSimple"): listener.enterValidationSimple(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitValidationSimple" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitValidationSimple"): listener.exitValidationSimple(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitValidationSimple" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidationSimple"): return visitor.visitValidationSimple(self) else: return visitor.visitChildren(self) - - def validationOperators(self): localctx = Parser.ValidationOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 62, self.RULE_validationOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1183 self._errHandler.sync(self) @@ -9706,7 +10984,7 @@ def validationOperators(self): self.state = 1136 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMPONENTS: + if _la == Parser.COMPONENTS: self.state = 1127 self.match(Parser.COMPONENTS) self.state = 1128 @@ -9714,7 +10992,7 @@ def validationOperators(self): self.state = 1133 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1129 self.match(Parser.COMMA) self.state = 1130 @@ -9723,16 +11001,13 @@ def validationOperators(self): self._errHandler.sync(self) _la = self._input.LA(1) - - self.state = 1139 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ALL or _la==Parser.INVALID or _la==Parser.ALL_MEASURES: + if _la == Parser.ALL or _la == Parser.INVALID or _la == Parser.ALL_MEASURES: self.state = 1138 self.validationOutput() - self.state = 1141 self.match(Parser.RPAREN) pass @@ -9752,45 +11027,50 @@ def validationOperators(self): self.state = 1149 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.CONDITION: + if _la == Parser.CONDITION: self.state = 1148 self.conditionClause() - self.state = 1153 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.RULE: + if _la == Parser.RULE: self.state = 1151 self.match(Parser.RULE) self.state = 1152 self.componentID() - self.state = 1156 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 225)) & ~0x3f) == 0 and ((1 << (_la - 225)) & ((1 << (Parser.NON_NULL - 225)) | (1 << (Parser.NON_ZERO - 225)) | (1 << (Parser.PARTIAL_NULL - 225)) | (1 << (Parser.PARTIAL_ZERO - 225)) | (1 << (Parser.ALWAYS_NULL - 225)) | (1 << (Parser.ALWAYS_ZERO - 225)))) != 0): + if ((_la - 225) & ~0x3F) == 0 and ( + (1 << (_la - 225)) + & ( + (1 << (Parser.NON_NULL - 225)) + | (1 << (Parser.NON_ZERO - 225)) + | (1 << (Parser.PARTIAL_NULL - 225)) + | (1 << (Parser.PARTIAL_ZERO - 225)) + | (1 << (Parser.ALWAYS_NULL - 225)) + | (1 << (Parser.ALWAYS_ZERO - 225)) + ) + ) != 0: self.state = 1155 self.validationMode() - self.state = 1159 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.DATASET or _la==Parser.DATASET_PRIORITY: + if _la == Parser.DATASET or _la == Parser.DATASET_PRIORITY: self.state = 1158 self.inputMode() - self.state = 1162 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ALL or _la==Parser.INVALID or _la==Parser.ALL_MEASURES: + if _la == Parser.ALL or _la == Parser.INVALID or _la == Parser.ALL_MEASURES: self.state = 1161 self.validationOutput() - self.state = 1164 self.match(Parser.RPAREN) pass @@ -9806,41 +11086,37 @@ def validationOperators(self): self.state = 1170 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ERRORCODE: + if _la == Parser.ERRORCODE: self.state = 1169 localctx.codeErr = self.erCode() - self.state = 1173 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ERRORLEVEL: + if _la == Parser.ERRORLEVEL: self.state = 1172 localctx.levelCode = self.erLevel() - self.state = 1176 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.IMBALANCE: + if _la == Parser.IMBALANCE: self.state = 1175 self.imbalanceExpr() - self.state = 1179 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ALL or _la==Parser.INVALID: + if _la == Parser.ALL or _la == Parser.INVALID: self.state = 1178 localctx.output = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.ALL or _la==Parser.INVALID): + if not (_la == Parser.ALL or _la == Parser.INVALID): localctx.output = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 1181 self.match(Parser.RPAREN) pass @@ -9855,63 +11131,60 @@ def validationOperators(self): self.exitRule() return localctx - class ConditionalOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_conditionalOperators - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class NvlAtomContext(ConditionalOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ConditionalOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ConditionalOperatorsContext super().__init__(ANTLRParser) - self.left = None # ExprContext - self.right = None # ExprContext + self.left = None # ExprContext + self.right = None # ExprContext self.copyFrom(ctx) def NVL(self): return self.getToken(Parser.NVL, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def expr(self, i:int=None): + + def expr(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprContext) else: - return self.getTypedRuleContext(Parser.ExprContext,i) + return self.getTypedRuleContext(Parser.ExprContext, i) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNvlAtom" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNvlAtom"): listener.enterNvlAtom(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNvlAtom" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNvlAtom"): listener.exitNvlAtom(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitNvlAtom" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNvlAtom"): return visitor.visitNvlAtom(self) else: return visitor.visitChildren(self) - - def conditionalOperators(self): localctx = Parser.ConditionalOperatorsContext(self, self._ctx, self.state) @@ -9939,63 +11212,60 @@ def conditionalOperators(self): self.exitRule() return localctx - class ConditionalOperatorsComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_conditionalOperatorsComponent - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class NvlAtomComponentContext(ConditionalOperatorsComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ConditionalOperatorsComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ConditionalOperatorsComponentContext super().__init__(ANTLRParser) - self.left = None # ExprComponentContext - self.right = None # ExprComponentContext + self.left = None # ExprComponentContext + self.right = None # ExprComponentContext self.copyFrom(ctx) def NVL(self): return self.getToken(Parser.NVL, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def exprComponent(self, i:int=None): + + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) - + return self.getTypedRuleContext(Parser.ExprComponentContext, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNvlAtomComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNvlAtomComponent"): listener.enterNvlAtomComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNvlAtomComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNvlAtomComponent"): listener.exitNvlAtomComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitNvlAtomComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNvlAtomComponent"): return visitor.visitNvlAtomComponent(self) else: return visitor.visitChildren(self) - - def conditionalOperatorsComponent(self): localctx = Parser.ConditionalOperatorsComponentContext(self, self._ctx, self.state) @@ -10023,119 +11293,144 @@ def conditionalOperatorsComponent(self): self.exitRule() return localctx - class AggrOperatorsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_aggrOperators - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class AggrCompContext(AggrOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AggrOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.AggrOperatorsContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def SUM(self): return self.getToken(Parser.SUM, 0) + def AVG(self): return self.getToken(Parser.AVG, 0) + def COUNT(self): return self.getToken(Parser.COUNT, 0) + def MEDIAN(self): return self.getToken(Parser.MEDIAN, 0) + def MIN(self): return self.getToken(Parser.MIN, 0) + def MAX(self): return self.getToken(Parser.MAX, 0) + def STDDEV_POP(self): return self.getToken(Parser.STDDEV_POP, 0) + def STDDEV_SAMP(self): return self.getToken(Parser.STDDEV_SAMP, 0) + def VAR_POP(self): return self.getToken(Parser.VAR_POP, 0) + def VAR_SAMP(self): return self.getToken(Parser.VAR_SAMP, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAggrComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAggrComp"): listener.enterAggrComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAggrComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAggrComp"): listener.exitAggrComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAggrComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggrComp"): return visitor.visitAggrComp(self) else: return visitor.visitChildren(self) - class CountAggrCompContext(AggrOperatorsContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AggrOperatorsContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.AggrOperatorsContext super().__init__(ANTLRParser) self.copyFrom(ctx) def COUNT(self): return self.getToken(Parser.COUNT, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCountAggrComp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCountAggrComp"): listener.enterCountAggrComp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCountAggrComp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCountAggrComp"): listener.exitCountAggrComp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCountAggrComp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCountAggrComp"): return visitor.visitCountAggrComp(self) else: return visitor.visitChildren(self) - - def aggrOperators(self): localctx = Parser.AggrOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 68, self.RULE_aggrOperators) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1207 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,101,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 101, self._ctx) if la_ == 1: localctx = Parser.AggrCompContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 1199 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (Parser.MIN - 80)) | (1 << (Parser.MAX - 80)) | (1 << (Parser.SUM - 80)) | (1 << (Parser.AVG - 80)) | (1 << (Parser.MEDIAN - 80)) | (1 << (Parser.COUNT - 80)) | (1 << (Parser.STDDEV_POP - 80)) | (1 << (Parser.STDDEV_SAMP - 80)) | (1 << (Parser.VAR_POP - 80)) | (1 << (Parser.VAR_SAMP - 80)))) != 0)): + if not ( + ((_la - 80) & ~0x3F) == 0 + and ( + (1 << (_la - 80)) + & ( + (1 << (Parser.MIN - 80)) + | (1 << (Parser.MAX - 80)) + | (1 << (Parser.SUM - 80)) + | (1 << (Parser.AVG - 80)) + | (1 << (Parser.MEDIAN - 80)) + | (1 << (Parser.COUNT - 80)) + | (1 << (Parser.STDDEV_POP - 80)) + | (1 << (Parser.STDDEV_SAMP - 80)) + | (1 << (Parser.VAR_POP - 80)) + | (1 << (Parser.VAR_SAMP - 80)) + ) + ) + != 0 + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -10159,7 +11454,6 @@ def aggrOperators(self): self.match(Parser.RPAREN) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -10168,93 +11462,116 @@ def aggrOperators(self): self.exitRule() return localctx - class AggrOperatorsGroupingContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_aggrOperatorsGrouping - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class AggrDatasetContext(AggrOperatorsGroupingContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AggrOperatorsGroupingContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.AggrOperatorsGroupingContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def SUM(self): return self.getToken(Parser.SUM, 0) + def AVG(self): return self.getToken(Parser.AVG, 0) + def COUNT(self): return self.getToken(Parser.COUNT, 0) + def MEDIAN(self): return self.getToken(Parser.MEDIAN, 0) + def MIN(self): return self.getToken(Parser.MIN, 0) + def MAX(self): return self.getToken(Parser.MAX, 0) + def STDDEV_POP(self): return self.getToken(Parser.STDDEV_POP, 0) + def STDDEV_SAMP(self): return self.getToken(Parser.STDDEV_SAMP, 0) + def VAR_POP(self): return self.getToken(Parser.VAR_POP, 0) + def VAR_SAMP(self): return self.getToken(Parser.VAR_SAMP, 0) + def groupingClause(self): - return self.getTypedRuleContext(Parser.GroupingClauseContext,0) + return self.getTypedRuleContext(Parser.GroupingClauseContext, 0) def havingClause(self): - return self.getTypedRuleContext(Parser.HavingClauseContext,0) + return self.getTypedRuleContext(Parser.HavingClauseContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAggrDataset" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAggrDataset"): listener.enterAggrDataset(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAggrDataset" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAggrDataset"): listener.exitAggrDataset(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAggrDataset" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggrDataset"): return visitor.visitAggrDataset(self) else: return visitor.visitChildren(self) - - def aggrOperatorsGrouping(self): localctx = Parser.AggrOperatorsGroupingContext(self, self._ctx, self.state) self.enterRule(localctx, 70, self.RULE_aggrOperatorsGrouping) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = Parser.AggrDatasetContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 1209 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (Parser.MIN - 80)) | (1 << (Parser.MAX - 80)) | (1 << (Parser.SUM - 80)) | (1 << (Parser.AVG - 80)) | (1 << (Parser.MEDIAN - 80)) | (1 << (Parser.COUNT - 80)) | (1 << (Parser.STDDEV_POP - 80)) | (1 << (Parser.STDDEV_SAMP - 80)) | (1 << (Parser.VAR_POP - 80)) | (1 << (Parser.VAR_SAMP - 80)))) != 0)): + if not ( + ((_la - 80) & ~0x3F) == 0 + and ( + (1 << (_la - 80)) + & ( + (1 << (Parser.MIN - 80)) + | (1 << (Parser.MAX - 80)) + | (1 << (Parser.SUM - 80)) + | (1 << (Parser.AVG - 80)) + | (1 << (Parser.MEDIAN - 80)) + | (1 << (Parser.COUNT - 80)) + | (1 << (Parser.STDDEV_POP - 80)) + | (1 << (Parser.STDDEV_SAMP - 80)) + | (1 << (Parser.VAR_POP - 80)) + | (1 << (Parser.VAR_SAMP - 80)) + ) + ) + != 0 + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -10266,19 +11583,16 @@ def aggrOperatorsGrouping(self): self.state = 1216 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.GROUP: + if _la == Parser.GROUP: self.state = 1212 self.groupingClause() self.state = 1214 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.HAVING: + if _la == Parser.HAVING: self.state = 1213 self.havingClause() - - - self.state = 1218 self.match(Parser.RPAREN) except RecognitionException as re: @@ -10289,222 +11603,273 @@ def aggrOperatorsGrouping(self): self.exitRule() return localctx - class AnFunctionContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_anFunction - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class LagOrLeadAnContext(AnFunctionContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.AnFunctionContext super().__init__(ANTLRParser) - self.op = None # Token - self.offset = None # SignedIntegerContext - self.defaultValue = None # ScalarItemContext - self.partition = None # PartitionByClauseContext - self.orderBy = None # OrderByClauseContext + self.op = None # Token + self.offset = None # SignedIntegerContext + self.defaultValue = None # ScalarItemContext + self.partition = None # PartitionByClauseContext + self.orderBy = None # OrderByClauseContext self.copyFrom(ctx) - def LPAREN(self, i:int=None): + def LPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def OVER(self): return self.getToken(Parser.OVER, 0) - def RPAREN(self, i:int=None): + + def RPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) + def LAG(self): return self.getToken(Parser.LAG, 0) + def LEAD(self): return self.getToken(Parser.LEAD, 0) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def orderByClause(self): - return self.getTypedRuleContext(Parser.OrderByClauseContext,0) + return self.getTypedRuleContext(Parser.OrderByClauseContext, 0) def signedInteger(self): - return self.getTypedRuleContext(Parser.SignedIntegerContext,0) + return self.getTypedRuleContext(Parser.SignedIntegerContext, 0) def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) def scalarItem(self): - return self.getTypedRuleContext(Parser.ScalarItemContext,0) - + return self.getTypedRuleContext(Parser.ScalarItemContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterLagOrLeadAn" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterLagOrLeadAn"): listener.enterLagOrLeadAn(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitLagOrLeadAn" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitLagOrLeadAn"): listener.exitLagOrLeadAn(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitLagOrLeadAn" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitLagOrLeadAn"): return visitor.visitLagOrLeadAn(self) else: return visitor.visitChildren(self) - class RatioToReportAnContext(AnFunctionContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.AnFunctionContext super().__init__(ANTLRParser) - self.op = None # Token - self.partition = None # PartitionByClauseContext + self.op = None # Token + self.partition = None # PartitionByClauseContext self.copyFrom(ctx) - def LPAREN(self, i:int=None): + def LPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def OVER(self): return self.getToken(Parser.OVER, 0) - def RPAREN(self, i:int=None): + + def RPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) + def RATIO_TO_REPORT(self): return self.getToken(Parser.RATIO_TO_REPORT, 0) - def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) + def partitionByClause(self): + return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRatioToReportAn" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRatioToReportAn"): listener.enterRatioToReportAn(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRatioToReportAn" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRatioToReportAn"): listener.exitRatioToReportAn(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRatioToReportAn" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRatioToReportAn"): return visitor.visitRatioToReportAn(self) else: return visitor.visitChildren(self) - class AnSimpleFunctionContext(AnFunctionContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.AnFunctionContext super().__init__(ANTLRParser) - self.op = None # Token - self.partition = None # PartitionByClauseContext - self.orderBy = None # OrderByClauseContext - self.windowing = None # WindowingClauseContext + self.op = None # Token + self.partition = None # PartitionByClauseContext + self.orderBy = None # OrderByClauseContext + self.windowing = None # WindowingClauseContext self.copyFrom(ctx) - def LPAREN(self, i:int=None): + def LPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) + def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) + return self.getTypedRuleContext(Parser.ExprContext, 0) def OVER(self): return self.getToken(Parser.OVER, 0) - def RPAREN(self, i:int=None): + + def RPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) + def SUM(self): return self.getToken(Parser.SUM, 0) + def AVG(self): return self.getToken(Parser.AVG, 0) + def COUNT(self): return self.getToken(Parser.COUNT, 0) + def MEDIAN(self): return self.getToken(Parser.MEDIAN, 0) + def MIN(self): return self.getToken(Parser.MIN, 0) + def MAX(self): return self.getToken(Parser.MAX, 0) + def STDDEV_POP(self): return self.getToken(Parser.STDDEV_POP, 0) + def STDDEV_SAMP(self): return self.getToken(Parser.STDDEV_SAMP, 0) + def VAR_POP(self): return self.getToken(Parser.VAR_POP, 0) + def VAR_SAMP(self): return self.getToken(Parser.VAR_SAMP, 0) + def FIRST_VALUE(self): return self.getToken(Parser.FIRST_VALUE, 0) + def LAST_VALUE(self): return self.getToken(Parser.LAST_VALUE, 0) + def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) def orderByClause(self): - return self.getTypedRuleContext(Parser.OrderByClauseContext,0) + return self.getTypedRuleContext(Parser.OrderByClauseContext, 0) def windowingClause(self): - return self.getTypedRuleContext(Parser.WindowingClauseContext,0) - + return self.getTypedRuleContext(Parser.WindowingClauseContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAnSimpleFunction" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAnSimpleFunction"): listener.enterAnSimpleFunction(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAnSimpleFunction" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAnSimpleFunction"): listener.exitAnSimpleFunction(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAnSimpleFunction" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAnSimpleFunction"): return visitor.visitAnSimpleFunction(self) else: return visitor.visitChildren(self) - - def anFunction(self): localctx = Parser.AnFunctionContext(self, self._ctx, self.state) self.enterRule(localctx, 72, self.RULE_anFunction) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1267 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.MIN, Parser.MAX, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE]: + if token in [ + Parser.MIN, + Parser.MAX, + Parser.SUM, + Parser.AVG, + Parser.MEDIAN, + Parser.COUNT, + Parser.STDDEV_POP, + Parser.STDDEV_SAMP, + Parser.VAR_POP, + Parser.VAR_SAMP, + Parser.FIRST_VALUE, + Parser.LAST_VALUE, + ]: localctx = Parser.AnSimpleFunctionContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 1220 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (Parser.MIN - 80)) | (1 << (Parser.MAX - 80)) | (1 << (Parser.SUM - 80)) | (1 << (Parser.AVG - 80)) | (1 << (Parser.MEDIAN - 80)) | (1 << (Parser.COUNT - 80)) | (1 << (Parser.STDDEV_POP - 80)) | (1 << (Parser.STDDEV_SAMP - 80)) | (1 << (Parser.VAR_POP - 80)) | (1 << (Parser.VAR_SAMP - 80)))) != 0) or _la==Parser.FIRST_VALUE or _la==Parser.LAST_VALUE): + if not ( + ( + ((_la - 80) & ~0x3F) == 0 + and ( + (1 << (_la - 80)) + & ( + (1 << (Parser.MIN - 80)) + | (1 << (Parser.MAX - 80)) + | (1 << (Parser.SUM - 80)) + | (1 << (Parser.AVG - 80)) + | (1 << (Parser.MEDIAN - 80)) + | (1 << (Parser.COUNT - 80)) + | (1 << (Parser.STDDEV_POP - 80)) + | (1 << (Parser.STDDEV_SAMP - 80)) + | (1 << (Parser.VAR_POP - 80)) + | (1 << (Parser.VAR_SAMP - 80)) + ) + ) + != 0 + ) + or _la == Parser.FIRST_VALUE + or _la == Parser.LAST_VALUE + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -10521,27 +11886,24 @@ def anFunction(self): self.state = 1226 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.PARTITION: + if _la == Parser.PARTITION: self.state = 1225 localctx.partition = self.partitionByClause() - self.state = 1229 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ORDER: + if _la == Parser.ORDER: self.state = 1228 localctx.orderBy = self.orderByClause() - self.state = 1232 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.DATA or _la==Parser.RANGE: + if _la == Parser.DATA or _la == Parser.RANGE: self.state = 1231 localctx.windowing = self.windowingClause() - self.state = 1234 self.match(Parser.RPAREN) self.state = 1235 @@ -10553,7 +11915,7 @@ def anFunction(self): self.state = 1237 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.LAG or _la==Parser.LEAD): + if not (_la == Parser.LAG or _la == Parser.LEAD): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -10565,7 +11927,7 @@ def anFunction(self): self.state = 1246 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 1240 self.match(Parser.COMMA) self.state = 1241 @@ -10573,15 +11935,12 @@ def anFunction(self): self.state = 1244 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 1242 self.match(Parser.COMMA) self.state = 1243 localctx.defaultValue = self.scalarItem() - - - self.state = 1248 self.match(Parser.OVER) self.state = 1249 @@ -10590,11 +11949,10 @@ def anFunction(self): self.state = 1251 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.PARTITION: + if _la == Parser.PARTITION: self.state = 1250 localctx.partition = self.partitionByClause() - self.state = 1253 localctx.orderBy = self.orderByClause() self.state = 1255 @@ -10634,264 +11992,318 @@ def anFunction(self): self.exitRule() return localctx - class AnFunctionComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_anFunctionComponent - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class AnSimpleFunctionComponentContext(AnFunctionComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.AnFunctionComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.partition = None # PartitionByClauseContext - self.orderBy = None # OrderByClauseContext - self.windowing = None # WindowingClauseContext + self.op = None # Token + self.partition = None # PartitionByClauseContext + self.orderBy = None # OrderByClauseContext + self.windowing = None # WindowingClauseContext self.copyFrom(ctx) - def LPAREN(self, i:int=None): + def LPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def OVER(self): return self.getToken(Parser.OVER, 0) - def RPAREN(self, i:int=None): + + def RPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) + def SUM(self): return self.getToken(Parser.SUM, 0) + def AVG(self): return self.getToken(Parser.AVG, 0) + def COUNT(self): return self.getToken(Parser.COUNT, 0) + def MEDIAN(self): return self.getToken(Parser.MEDIAN, 0) + def MIN(self): return self.getToken(Parser.MIN, 0) + def MAX(self): return self.getToken(Parser.MAX, 0) + def STDDEV_POP(self): return self.getToken(Parser.STDDEV_POP, 0) + def STDDEV_SAMP(self): return self.getToken(Parser.STDDEV_SAMP, 0) + def VAR_POP(self): return self.getToken(Parser.VAR_POP, 0) + def VAR_SAMP(self): return self.getToken(Parser.VAR_SAMP, 0) + def FIRST_VALUE(self): return self.getToken(Parser.FIRST_VALUE, 0) + def LAST_VALUE(self): return self.getToken(Parser.LAST_VALUE, 0) + def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) def orderByClause(self): - return self.getTypedRuleContext(Parser.OrderByClauseContext,0) + return self.getTypedRuleContext(Parser.OrderByClauseContext, 0) def windowingClause(self): - return self.getTypedRuleContext(Parser.WindowingClauseContext,0) - + return self.getTypedRuleContext(Parser.WindowingClauseContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAnSimpleFunctionComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAnSimpleFunctionComponent"): listener.enterAnSimpleFunctionComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAnSimpleFunctionComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAnSimpleFunctionComponent"): listener.exitAnSimpleFunctionComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAnSimpleFunctionComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAnSimpleFunctionComponent"): return visitor.visitAnSimpleFunctionComponent(self) else: return visitor.visitChildren(self) - class LagOrLeadAnComponentContext(AnFunctionComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.AnFunctionComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.offet = None # SignedIntegerContext - self.defaultValue = None # ScalarItemContext - self.partition = None # PartitionByClauseContext - self.orderBy = None # OrderByClauseContext + self.op = None # Token + self.offet = None # SignedIntegerContext + self.defaultValue = None # ScalarItemContext + self.partition = None # PartitionByClauseContext + self.orderBy = None # OrderByClauseContext self.copyFrom(ctx) - def LPAREN(self, i:int=None): + def LPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def OVER(self): return self.getToken(Parser.OVER, 0) - def RPAREN(self, i:int=None): + + def RPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) + def LAG(self): return self.getToken(Parser.LAG, 0) + def LEAD(self): return self.getToken(Parser.LEAD, 0) + def COMMA(self): return self.getToken(Parser.COMMA, 0) + def orderByClause(self): - return self.getTypedRuleContext(Parser.OrderByClauseContext,0) + return self.getTypedRuleContext(Parser.OrderByClauseContext, 0) def signedInteger(self): - return self.getTypedRuleContext(Parser.SignedIntegerContext,0) + return self.getTypedRuleContext(Parser.SignedIntegerContext, 0) def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) def scalarItem(self): - return self.getTypedRuleContext(Parser.ScalarItemContext,0) - + return self.getTypedRuleContext(Parser.ScalarItemContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterLagOrLeadAnComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterLagOrLeadAnComponent"): listener.enterLagOrLeadAnComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitLagOrLeadAnComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitLagOrLeadAnComponent"): listener.exitLagOrLeadAnComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitLagOrLeadAnComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitLagOrLeadAnComponent"): return visitor.visitLagOrLeadAnComponent(self) else: return visitor.visitChildren(self) - class RankAnComponentContext(AnFunctionComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.AnFunctionComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.partition = None # PartitionByClauseContext - self.orderBy = None # OrderByClauseContext + self.op = None # Token + self.partition = None # PartitionByClauseContext + self.orderBy = None # OrderByClauseContext self.copyFrom(ctx) - def LPAREN(self, i:int=None): + def LPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) + def OVER(self): return self.getToken(Parser.OVER, 0) - def RPAREN(self, i:int=None): + + def RPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) + def RANK(self): return self.getToken(Parser.RANK, 0) + def orderByClause(self): - return self.getTypedRuleContext(Parser.OrderByClauseContext,0) + return self.getTypedRuleContext(Parser.OrderByClauseContext, 0) def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) + return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRankAnComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRankAnComponent"): listener.enterRankAnComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRankAnComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRankAnComponent"): listener.exitRankAnComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRankAnComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRankAnComponent"): return visitor.visitRankAnComponent(self) else: return visitor.visitChildren(self) - class RatioToReportAnComponentContext(AnFunctionComponentContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.AnFunctionComponentContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.AnFunctionComponentContext super().__init__(ANTLRParser) - self.op = None # Token - self.partition = None # PartitionByClauseContext + self.op = None # Token + self.partition = None # PartitionByClauseContext self.copyFrom(ctx) - def LPAREN(self, i:int=None): + def LPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.LPAREN) else: return self.getToken(Parser.LPAREN, i) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def OVER(self): return self.getToken(Parser.OVER, 0) - def RPAREN(self, i:int=None): + + def RPAREN(self, i: int = None): if i is None: return self.getTokens(Parser.RPAREN) else: return self.getToken(Parser.RPAREN, i) + def RATIO_TO_REPORT(self): return self.getToken(Parser.RATIO_TO_REPORT, 0) - def partitionByClause(self): - return self.getTypedRuleContext(Parser.PartitionByClauseContext,0) + def partitionByClause(self): + return self.getTypedRuleContext(Parser.PartitionByClauseContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRatioToReportAnComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRatioToReportAnComponent"): listener.enterRatioToReportAnComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRatioToReportAnComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRatioToReportAnComponent"): listener.exitRatioToReportAnComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRatioToReportAnComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRatioToReportAnComponent"): return visitor.visitRatioToReportAnComponent(self) else: return visitor.visitChildren(self) - - def anFunctionComponent(self): localctx = Parser.AnFunctionComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 74, self.RULE_anFunctionComponent) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1327 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.MIN, Parser.MAX, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE]: + if token in [ + Parser.MIN, + Parser.MAX, + Parser.SUM, + Parser.AVG, + Parser.MEDIAN, + Parser.COUNT, + Parser.STDDEV_POP, + Parser.STDDEV_SAMP, + Parser.VAR_POP, + Parser.VAR_SAMP, + Parser.FIRST_VALUE, + Parser.LAST_VALUE, + ]: localctx = Parser.AnSimpleFunctionComponentContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 1269 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (Parser.MIN - 80)) | (1 << (Parser.MAX - 80)) | (1 << (Parser.SUM - 80)) | (1 << (Parser.AVG - 80)) | (1 << (Parser.MEDIAN - 80)) | (1 << (Parser.COUNT - 80)) | (1 << (Parser.STDDEV_POP - 80)) | (1 << (Parser.STDDEV_SAMP - 80)) | (1 << (Parser.VAR_POP - 80)) | (1 << (Parser.VAR_SAMP - 80)))) != 0) or _la==Parser.FIRST_VALUE or _la==Parser.LAST_VALUE): + if not ( + ( + ((_la - 80) & ~0x3F) == 0 + and ( + (1 << (_la - 80)) + & ( + (1 << (Parser.MIN - 80)) + | (1 << (Parser.MAX - 80)) + | (1 << (Parser.SUM - 80)) + | (1 << (Parser.AVG - 80)) + | (1 << (Parser.MEDIAN - 80)) + | (1 << (Parser.COUNT - 80)) + | (1 << (Parser.STDDEV_POP - 80)) + | (1 << (Parser.STDDEV_SAMP - 80)) + | (1 << (Parser.VAR_POP - 80)) + | (1 << (Parser.VAR_SAMP - 80)) + ) + ) + != 0 + ) + or _la == Parser.FIRST_VALUE + or _la == Parser.LAST_VALUE + ): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -10908,27 +12320,24 @@ def anFunctionComponent(self): self.state = 1275 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.PARTITION: + if _la == Parser.PARTITION: self.state = 1274 localctx.partition = self.partitionByClause() - self.state = 1278 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ORDER: + if _la == Parser.ORDER: self.state = 1277 localctx.orderBy = self.orderByClause() - self.state = 1281 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.DATA or _la==Parser.RANGE: + if _la == Parser.DATA or _la == Parser.RANGE: self.state = 1280 localctx.windowing = self.windowingClause() - self.state = 1283 self.match(Parser.RPAREN) self.state = 1284 @@ -10940,7 +12349,7 @@ def anFunctionComponent(self): self.state = 1286 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.LAG or _la==Parser.LEAD): + if not (_la == Parser.LAG or _la == Parser.LEAD): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -10952,7 +12361,7 @@ def anFunctionComponent(self): self.state = 1294 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 1289 self.match(Parser.COMMA) self.state = 1290 @@ -10960,13 +12369,23 @@ def anFunctionComponent(self): self.state = 1292 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.NULL_CONSTANT or ((((_la - 218)) & ~0x3f) == 0 and ((1 << (_la - 218)) & ((1 << (Parser.CAST - 218)) | (1 << (Parser.INTEGER_CONSTANT - 218)) | (1 << (Parser.NUMBER_CONSTANT - 218)) | (1 << (Parser.BOOLEAN_CONSTANT - 218)) | (1 << (Parser.STRING_CONSTANT - 218)))) != 0): + if _la == Parser.NULL_CONSTANT or ( + ((_la - 218) & ~0x3F) == 0 + and ( + (1 << (_la - 218)) + & ( + (1 << (Parser.CAST - 218)) + | (1 << (Parser.INTEGER_CONSTANT - 218)) + | (1 << (Parser.NUMBER_CONSTANT - 218)) + | (1 << (Parser.BOOLEAN_CONSTANT - 218)) + | (1 << (Parser.STRING_CONSTANT - 218)) + ) + ) + != 0 + ): self.state = 1291 localctx.defaultValue = self.scalarItem() - - - self.state = 1296 self.match(Parser.OVER) self.state = 1297 @@ -10975,11 +12394,10 @@ def anFunctionComponent(self): self.state = 1299 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.PARTITION: + if _la == Parser.PARTITION: self.state = 1298 localctx.partition = self.partitionByClause() - self.state = 1301 localctx.orderBy = self.orderByClause() self.state = 1303 @@ -11002,11 +12420,10 @@ def anFunctionComponent(self): self.state = 1311 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.PARTITION: + if _la == Parser.PARTITION: self.state = 1310 localctx.partition = self.partitionByClause() - self.state = 1313 localctx.orderBy = self.orderByClause() self.state = 1315 @@ -11046,46 +12463,41 @@ def anFunctionComponent(self): self.exitRule() return localctx - class RenameClauseItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.fromName = None # ComponentIDContext - self.toName = None # ComponentIDContext + self.fromName = None # ComponentIDContext + self.toName = None # ComponentIDContext def TO(self): return self.getToken(Parser.TO, 0) - def componentID(self, i:int=None): + def componentID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext,i) - + return self.getTypedRuleContext(Parser.ComponentIDContext, i) def getRuleIndex(self): return Parser.RULE_renameClauseItem - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRenameClauseItem" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRenameClauseItem"): listener.enterRenameClauseItem(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRenameClauseItem" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRenameClauseItem"): listener.exitRenameClauseItem(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRenameClauseItem" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRenameClauseItem"): return visitor.visitRenameClauseItem(self) else: return visitor.visitChildren(self) - - - def renameClauseItem(self): localctx = Parser.RenameClauseItemContext(self, self._ctx, self.state) @@ -11106,22 +12518,20 @@ def renameClauseItem(self): self.exitRule() return localctx - class AggregateClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def aggrFunctionClause(self, i:int=None): + def aggrFunctionClause(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.AggrFunctionClauseContext) else: - return self.getTypedRuleContext(Parser.AggrFunctionClauseContext,i) + return self.getTypedRuleContext(Parser.AggrFunctionClauseContext, i) - - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -11130,28 +12540,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_aggregateClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAggregateClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAggregateClause"): listener.enterAggregateClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAggregateClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAggregateClause"): listener.exitAggregateClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAggregateClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggregateClause"): return visitor.visitAggregateClause(self) else: return visitor.visitChildren(self) - - - def aggregateClause(self): localctx = Parser.AggregateClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 78, self.RULE_aggregateClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1333 @@ -11159,7 +12566,7 @@ def aggregateClause(self): self.state = 1338 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1334 self.match(Parser.COMMA) self.state = 1335 @@ -11176,64 +12583,68 @@ def aggregateClause(self): self.exitRule() return localctx - class AggrFunctionClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext,0) - + return self.getTypedRuleContext(Parser.ComponentIDContext, 0) def ASSIGN(self): return self.getToken(Parser.ASSIGN, 0) def aggrOperators(self): - return self.getTypedRuleContext(Parser.AggrOperatorsContext,0) - + return self.getTypedRuleContext(Parser.AggrOperatorsContext, 0) def componentRole(self): - return self.getTypedRuleContext(Parser.ComponentRoleContext,0) - + return self.getTypedRuleContext(Parser.ComponentRoleContext, 0) def getRuleIndex(self): return Parser.RULE_aggrFunctionClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAggrFunctionClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAggrFunctionClause"): listener.enterAggrFunctionClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAggrFunctionClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAggrFunctionClause"): listener.exitAggrFunctionClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAggrFunctionClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggrFunctionClause"): return visitor.visitAggrFunctionClause(self) else: return visitor.visitChildren(self) - - - def aggrFunctionClause(self): localctx = Parser.AggrFunctionClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 80, self.RULE_aggrFunctionClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1342 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 103)) & ~0x3f) == 0 and ((1 << (_la - 103)) & ((1 << (Parser.DIMENSION - 103)) | (1 << (Parser.MEASURE - 103)) | (1 << (Parser.ATTRIBUTE - 103)) | (1 << (Parser.VIRAL - 103)))) != 0) or _la==Parser.COMPONENT: + if ( + ((_la - 103) & ~0x3F) == 0 + and ( + (1 << (_la - 103)) + & ( + (1 << (Parser.DIMENSION - 103)) + | (1 << (Parser.MEASURE - 103)) + | (1 << (Parser.ATTRIBUTE - 103)) + | (1 << (Parser.VIRAL - 103)) + ) + ) + != 0 + ) or _la == Parser.COMPONENT: self.state = 1341 self.componentRole() - self.state = 1344 self.componentID() self.state = 1345 @@ -11248,64 +12659,68 @@ def aggrFunctionClause(self): self.exitRule() return localctx - class CalcClauseItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext,0) - + return self.getTypedRuleContext(Parser.ComponentIDContext, 0) def ASSIGN(self): return self.getToken(Parser.ASSIGN, 0) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) - + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def componentRole(self): - return self.getTypedRuleContext(Parser.ComponentRoleContext,0) - + return self.getTypedRuleContext(Parser.ComponentRoleContext, 0) def getRuleIndex(self): return Parser.RULE_calcClauseItem - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCalcClauseItem" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCalcClauseItem"): listener.enterCalcClauseItem(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCalcClauseItem" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCalcClauseItem"): listener.exitCalcClauseItem(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCalcClauseItem" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCalcClauseItem"): return visitor.visitCalcClauseItem(self) else: return visitor.visitChildren(self) - - - def calcClauseItem(self): localctx = Parser.CalcClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 82, self.RULE_calcClauseItem) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1349 self._errHandler.sync(self) _la = self._input.LA(1) - if ((((_la - 103)) & ~0x3f) == 0 and ((1 << (_la - 103)) & ((1 << (Parser.DIMENSION - 103)) | (1 << (Parser.MEASURE - 103)) | (1 << (Parser.ATTRIBUTE - 103)) | (1 << (Parser.VIRAL - 103)))) != 0) or _la==Parser.COMPONENT: + if ( + ((_la - 103) & ~0x3F) == 0 + and ( + (1 << (_la - 103)) + & ( + (1 << (Parser.DIMENSION - 103)) + | (1 << (Parser.MEASURE - 103)) + | (1 << (Parser.ATTRIBUTE - 103)) + | (1 << (Parser.VIRAL - 103)) + ) + ) + != 0 + ) or _la == Parser.COMPONENT: self.state = 1348 self.componentRole() - self.state = 1351 self.componentID() self.state = 1352 @@ -11320,49 +12735,42 @@ def calcClauseItem(self): self.exitRule() return localctx - class SubspaceClauseItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext,0) - + return self.getTypedRuleContext(Parser.ComponentIDContext, 0) def EQ(self): return self.getToken(Parser.EQ, 0) def scalarItem(self): - return self.getTypedRuleContext(Parser.ScalarItemContext,0) - + return self.getTypedRuleContext(Parser.ScalarItemContext, 0) def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext,0) - + return self.getTypedRuleContext(Parser.VarIDContext, 0) def getRuleIndex(self): return Parser.RULE_subspaceClauseItem - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSubspaceClauseItem" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSubspaceClauseItem"): listener.enterSubspaceClauseItem(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSubspaceClauseItem" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSubspaceClauseItem"): listener.exitSubspaceClauseItem(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSubspaceClauseItem" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSubspaceClauseItem"): return visitor.visitSubspaceClauseItem(self) else: return visitor.visitChildren(self) - - - def subspaceClauseItem(self): localctx = Parser.SubspaceClauseItemContext(self, self._ctx, self.state) @@ -11376,7 +12784,14 @@ def subspaceClauseItem(self): self.state = 1359 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT]: + if token in [ + Parser.NULL_CONSTANT, + Parser.CAST, + Parser.INTEGER_CONSTANT, + Parser.NUMBER_CONSTANT, + Parser.BOOLEAN_CONSTANT, + Parser.STRING_CONSTANT, + ]: self.state = 1357 self.scalarItem() pass @@ -11395,141 +12810,142 @@ def subspaceClauseItem(self): self.exitRule() return localctx - class ScalarItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_scalarItem - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class ScalarWithCastContext(ScalarItemContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ScalarItemContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ScalarItemContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CAST(self): return self.getToken(Parser.CAST, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext,0) + return self.getTypedRuleContext(Parser.ConstantContext, 0) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def basicScalarType(self): - return self.getTypedRuleContext(Parser.BasicScalarTypeContext,0) + return self.getTypedRuleContext(Parser.BasicScalarTypeContext, 0) def STRING_CONSTANT(self): return self.getToken(Parser.STRING_CONSTANT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterScalarWithCast" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterScalarWithCast"): listener.enterScalarWithCast(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitScalarWithCast" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitScalarWithCast"): listener.exitScalarWithCast(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitScalarWithCast" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitScalarWithCast"): return visitor.visitScalarWithCast(self) else: return visitor.visitChildren(self) - class SimpleScalarContext(ScalarItemContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ScalarItemContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ScalarItemContext super().__init__(ANTLRParser) self.copyFrom(ctx) def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext,0) + return self.getTypedRuleContext(Parser.ConstantContext, 0) - - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSimpleScalar" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSimpleScalar"): listener.enterSimpleScalar(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSimpleScalar" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSimpleScalar"): listener.exitSimpleScalar(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSimpleScalar" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSimpleScalar"): return visitor.visitSimpleScalar(self) else: return visitor.visitChildren(self) - class ScalarVarWithCastContext(ScalarItemContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ScalarItemContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ScalarItemContext super().__init__(ANTLRParser) self.copyFrom(ctx) def CAST(self): return self.getToken(Parser.CAST, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext,0) + return self.getTypedRuleContext(Parser.VarIDContext, 0) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) + def basicScalarType(self): - return self.getTypedRuleContext(Parser.BasicScalarTypeContext,0) + return self.getTypedRuleContext(Parser.BasicScalarTypeContext, 0) def STRING_CONSTANT(self): return self.getToken(Parser.STRING_CONSTANT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterScalarVarWithCast" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterScalarVarWithCast"): listener.enterScalarVarWithCast(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitScalarVarWithCast" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitScalarVarWithCast"): listener.exitScalarVarWithCast(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitScalarVarWithCast" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitScalarVarWithCast"): return visitor.visitScalarVarWithCast(self) else: return visitor.visitChildren(self) - - def scalarItem(self): localctx = Parser.ScalarItemContext(self, self._ctx, self.state) self.enterRule(localctx, 86, self.RULE_scalarItem) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1384 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,125,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 125, self._ctx) if la_ == 1: localctx = Parser.SimpleScalarContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -11554,13 +12970,12 @@ def scalarItem(self): self.state = 1369 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 1367 self.match(Parser.COMMA) self.state = 1368 self.match(Parser.STRING_CONSTANT) - self.state = 1371 self.match(Parser.RPAREN) pass @@ -11582,18 +12997,16 @@ def scalarItem(self): self.state = 1380 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.COMMA: + if _la == Parser.COMMA: self.state = 1378 self.match(Parser.COMMA) self.state = 1379 self.match(Parser.STRING_CONSTANT) - self.state = 1382 self.match(Parser.RPAREN) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -11602,22 +13015,20 @@ def scalarItem(self): self.exitRule() return localctx - class JoinClauseWithoutUsingContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def joinClauseItem(self, i:int=None): + def joinClauseItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.JoinClauseItemContext) else: - return self.getTypedRuleContext(Parser.JoinClauseItemContext,i) - + return self.getTypedRuleContext(Parser.JoinClauseItemContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -11626,28 +13037,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_joinClauseWithoutUsing - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterJoinClauseWithoutUsing" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterJoinClauseWithoutUsing"): listener.enterJoinClauseWithoutUsing(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitJoinClauseWithoutUsing" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitJoinClauseWithoutUsing"): listener.exitJoinClauseWithoutUsing(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitJoinClauseWithoutUsing" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinClauseWithoutUsing"): return visitor.visitJoinClauseWithoutUsing(self) else: return visitor.visitChildren(self) - - - def joinClauseWithoutUsing(self): localctx = Parser.JoinClauseWithoutUsingContext(self, self._ctx, self.state) self.enterRule(localctx, 88, self.RULE_joinClauseWithoutUsing) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1386 @@ -11655,7 +13063,7 @@ def joinClauseWithoutUsing(self): self.state = 1391 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1387 self.match(Parser.COMMA) self.state = 1388 @@ -11672,22 +13080,20 @@ def joinClauseWithoutUsing(self): self.exitRule() return localctx - class JoinClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def joinClauseItem(self, i:int=None): + def joinClauseItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.JoinClauseItemContext) else: - return self.getTypedRuleContext(Parser.JoinClauseItemContext,i) + return self.getTypedRuleContext(Parser.JoinClauseItemContext, i) - - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -11696,38 +13102,34 @@ def COMMA(self, i:int=None): def USING(self): return self.getToken(Parser.USING, 0) - def componentID(self, i:int=None): + def componentID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext,i) - + return self.getTypedRuleContext(Parser.ComponentIDContext, i) def getRuleIndex(self): return Parser.RULE_joinClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterJoinClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterJoinClause"): listener.enterJoinClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitJoinClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitJoinClause"): listener.exitJoinClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitJoinClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinClause"): return visitor.visitJoinClause(self) else: return visitor.visitChildren(self) - - - def joinClause(self): localctx = Parser.JoinClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 90, self.RULE_joinClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1394 @@ -11735,7 +13137,7 @@ def joinClause(self): self.state = 1399 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1395 self.match(Parser.COMMA) self.state = 1396 @@ -11747,7 +13149,7 @@ def joinClause(self): self.state = 1411 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.USING: + if _la == Parser.USING: self.state = 1402 self.match(Parser.USING) self.state = 1403 @@ -11755,7 +13157,7 @@ def joinClause(self): self.state = 1408 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1404 self.match(Parser.COMMA) self.state = 1405 @@ -11764,8 +13166,6 @@ def joinClause(self): self._errHandler.sync(self) _la = self._input.LA(1) - - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -11774,50 +13174,44 @@ def joinClause(self): self.exitRule() return localctx - class JoinClauseItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) - + return self.getTypedRuleContext(Parser.ExprContext, 0) def AS(self): return self.getToken(Parser.AS, 0) def alias(self): - return self.getTypedRuleContext(Parser.AliasContext,0) - + return self.getTypedRuleContext(Parser.AliasContext, 0) def getRuleIndex(self): return Parser.RULE_joinClauseItem - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterJoinClauseItem" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterJoinClauseItem"): listener.enterJoinClauseItem(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitJoinClauseItem" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitJoinClauseItem"): listener.exitJoinClauseItem(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitJoinClauseItem" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinClauseItem"): return visitor.visitJoinClauseItem(self) else: return visitor.visitChildren(self) - - - def joinClauseItem(self): localctx = Parser.JoinClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 92, self.RULE_joinClauseItem) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1413 @@ -11825,13 +13219,12 @@ def joinClauseItem(self): self.state = 1416 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.AS: + if _la == Parser.AS: self.state = 1414 self.match(Parser.AS) self.state = 1415 self.alias() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -11840,73 +13233,62 @@ def joinClauseItem(self): self.exitRule() return localctx - class JoinBodyContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def filterClause(self): - return self.getTypedRuleContext(Parser.FilterClauseContext,0) - + return self.getTypedRuleContext(Parser.FilterClauseContext, 0) def calcClause(self): - return self.getTypedRuleContext(Parser.CalcClauseContext,0) - + return self.getTypedRuleContext(Parser.CalcClauseContext, 0) def joinApplyClause(self): - return self.getTypedRuleContext(Parser.JoinApplyClauseContext,0) - + return self.getTypedRuleContext(Parser.JoinApplyClauseContext, 0) def aggrClause(self): - return self.getTypedRuleContext(Parser.AggrClauseContext,0) - + return self.getTypedRuleContext(Parser.AggrClauseContext, 0) def keepOrDropClause(self): - return self.getTypedRuleContext(Parser.KeepOrDropClauseContext,0) - + return self.getTypedRuleContext(Parser.KeepOrDropClauseContext, 0) def renameClause(self): - return self.getTypedRuleContext(Parser.RenameClauseContext,0) - + return self.getTypedRuleContext(Parser.RenameClauseContext, 0) def getRuleIndex(self): return Parser.RULE_joinBody - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterJoinBody" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterJoinBody"): listener.enterJoinBody(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitJoinBody" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitJoinBody"): listener.exitJoinBody(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitJoinBody" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinBody"): return visitor.visitJoinBody(self) else: return visitor.visitChildren(self) - - - def joinBody(self): localctx = Parser.JoinBodyContext(self, self._ctx, self.state) self.enterRule(localctx, 94, self.RULE_joinBody) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1419 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.FILTER: + if _la == Parser.FILTER: self.state = 1418 self.filterClause() - self.state = 1424 self._errHandler.sync(self) token = self._input.LA(1) @@ -11929,19 +13311,17 @@ def joinBody(self): self.state = 1427 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.DROP or _la==Parser.KEEP: + if _la == Parser.DROP or _la == Parser.KEEP: self.state = 1426 self.keepOrDropClause() - self.state = 1430 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.RENAME: + if _la == Parser.RENAME: self.state = 1429 self.renameClause() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -11950,11 +13330,10 @@ def joinBody(self): self.exitRule() return localctx - class JoinApplyClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -11962,29 +13341,25 @@ def APPLY(self): return self.getToken(Parser.APPLY, 0) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) - + return self.getTypedRuleContext(Parser.ExprContext, 0) def getRuleIndex(self): return Parser.RULE_joinApplyClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterJoinApplyClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterJoinApplyClause"): listener.enterJoinApplyClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitJoinApplyClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitJoinApplyClause"): listener.exitJoinApplyClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitJoinApplyClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinApplyClause"): return visitor.visitJoinApplyClause(self) else: return visitor.visitChildren(self) - - - def joinApplyClause(self): localctx = Parser.JoinApplyClauseContext(self, self._ctx, self.state) @@ -12003,11 +13378,10 @@ def joinApplyClause(self): self.exitRule() return localctx - class PartitionByClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12017,14 +13391,13 @@ def PARTITION(self): def BY(self): return self.getToken(Parser.BY, 0) - def componentID(self, i:int=None): + def componentID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext,i) - + return self.getTypedRuleContext(Parser.ComponentIDContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -12033,28 +13406,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_partitionByClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPartitionByClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPartitionByClause"): listener.enterPartitionByClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPartitionByClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPartitionByClause"): listener.exitPartitionByClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPartitionByClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPartitionByClause"): return visitor.visitPartitionByClause(self) else: return visitor.visitChildren(self) - - - def partitionByClause(self): localctx = Parser.PartitionByClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 98, self.RULE_partitionByClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1435 @@ -12066,7 +13436,7 @@ def partitionByClause(self): self.state = 1442 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1438 self.match(Parser.COMMA) self.state = 1439 @@ -12083,11 +13453,10 @@ def partitionByClause(self): self.exitRule() return localctx - class OrderByClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12097,14 +13466,13 @@ def ORDER(self): def BY(self): return self.getToken(Parser.BY, 0) - def orderByItem(self, i:int=None): + def orderByItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.OrderByItemContext) else: - return self.getTypedRuleContext(Parser.OrderByItemContext,i) + return self.getTypedRuleContext(Parser.OrderByItemContext, i) - - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -12113,28 +13481,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_orderByClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOrderByClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOrderByClause"): listener.enterOrderByClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOrderByClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOrderByClause"): listener.exitOrderByClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOrderByClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOrderByClause"): return visitor.visitOrderByClause(self) else: return visitor.visitChildren(self) - - - def orderByClause(self): localctx = Parser.OrderByClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 100, self.RULE_orderByClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1445 @@ -12146,7 +13511,7 @@ def orderByClause(self): self.state = 1452 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1448 self.match(Parser.COMMA) self.state = 1449 @@ -12163,17 +13528,15 @@ def orderByClause(self): self.exitRule() return localctx - class OrderByItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext,0) - + return self.getTypedRuleContext(Parser.ComponentIDContext, 0) def ASC(self): return self.getToken(Parser.ASC, 0) @@ -12184,28 +13547,25 @@ def DESC(self): def getRuleIndex(self): return Parser.RULE_orderByItem - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOrderByItem" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOrderByItem"): listener.enterOrderByItem(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOrderByItem" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOrderByItem"): listener.exitOrderByItem(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOrderByItem" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOrderByItem"): return visitor.visitOrderByItem(self) else: return visitor.visitChildren(self) - - - def orderByItem(self): localctx = Parser.OrderByItemContext(self, self._ctx, self.state) self.enterRule(localctx, 102, self.RULE_orderByItem) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1455 @@ -12213,16 +13573,15 @@ def orderByItem(self): self.state = 1457 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ASC or _la==Parser.DESC: + if _la == Parser.ASC or _la == Parser.DESC: self.state = 1456 _la = self._input.LA(1) - if not(_la==Parser.ASC or _la==Parser.DESC): + if not (_la == Parser.ASC or _la == Parser.DESC): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -12231,15 +13590,14 @@ def orderByItem(self): self.exitRule() return localctx - class WindowingClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.from_ = None # LimitClauseItemContext - self.to_ = None # LimitClauseItemContext + self.from_ = None # LimitClauseItemContext + self.to_ = None # LimitClauseItemContext def BETWEEN(self): return self.getToken(Parser.BETWEEN, 0) @@ -12247,12 +13605,11 @@ def BETWEEN(self): def AND(self): return self.getToken(Parser.AND, 0) - def limitClauseItem(self, i:int=None): + def limitClauseItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.LimitClauseItemContext) else: - return self.getTypedRuleContext(Parser.LimitClauseItemContext,i) - + return self.getTypedRuleContext(Parser.LimitClauseItemContext, i) def RANGE(self): return self.getToken(Parser.RANGE, 0) @@ -12266,23 +13623,20 @@ def POINTS(self): def getRuleIndex(self): return Parser.RULE_windowingClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterWindowingClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWindowingClause"): listener.enterWindowingClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitWindowingClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWindowingClause"): listener.exitWindowingClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitWindowingClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWindowingClause"): return visitor.visitWindowingClause(self) else: return visitor.visitChildren(self) - - - def windowingClause(self): localctx = Parser.WindowingClauseContext(self, self._ctx, self.state) @@ -12321,11 +13675,10 @@ def windowingClause(self): self.exitRule() return localctx - class SignedIntegerContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12335,23 +13688,20 @@ def INTEGER_CONSTANT(self): def getRuleIndex(self): return Parser.RULE_signedInteger - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSignedInteger" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSignedInteger"): listener.enterSignedInteger(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSignedInteger" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSignedInteger"): listener.exitSignedInteger(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSignedInteger" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSignedInteger"): return visitor.visitSignedInteger(self) else: return visitor.visitChildren(self) - - - def signedInteger(self): localctx = Parser.SignedIntegerContext(self, self._ctx, self.state) @@ -12368,11 +13718,10 @@ def signedInteger(self): self.exitRule() return localctx - class LimitClauseItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12400,23 +13749,20 @@ def UNBOUNDED(self): def getRuleIndex(self): return Parser.RULE_limitClauseItem - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterLimitClauseItem" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterLimitClauseItem"): listener.enterLimitClauseItem(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitLimitClauseItem" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitLimitClauseItem"): listener.exitLimitClauseItem(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitLimitClauseItem" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitLimitClauseItem"): return visitor.visitLimitClauseItem(self) else: return visitor.visitChildren(self) - - - def limitClauseItem(self): localctx = Parser.LimitClauseItemContext(self, self._ctx, self.state) @@ -12424,7 +13770,7 @@ def limitClauseItem(self): try: self.state = 1482 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,139,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 139, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 1471 @@ -12467,7 +13813,6 @@ def limitClauseItem(self): self.match(Parser.FOLLOWING) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -12476,103 +13821,101 @@ def limitClauseItem(self): self.exitRule() return localctx - class GroupingClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_groupingClause - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class GroupAllContext(GroupingClauseContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GroupingClauseContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.GroupingClauseContext super().__init__(ANTLRParser) self.copyFrom(ctx) def GROUP(self): return self.getToken(Parser.GROUP, 0) + def ALL(self): return self.getToken(Parser.ALL, 0) - def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + def exprComponent(self): + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterGroupAll" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGroupAll"): listener.enterGroupAll(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitGroupAll" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGroupAll"): listener.exitGroupAll(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitGroupAll" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGroupAll"): return visitor.visitGroupAll(self) else: return visitor.visitChildren(self) - class GroupByOrExceptContext(GroupingClauseContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.GroupingClauseContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.GroupingClauseContext super().__init__(ANTLRParser) - self.op = None # Token + self.op = None # Token self.copyFrom(ctx) def GROUP(self): return self.getToken(Parser.GROUP, 0) - def componentID(self, i:int=None): + + def componentID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext,i) + return self.getTypedRuleContext(Parser.ComponentIDContext, i) def BY(self): return self.getToken(Parser.BY, 0) + def EXCEPT(self): return self.getToken(Parser.EXCEPT, 0) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterGroupByOrExcept" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGroupByOrExcept"): listener.enterGroupByOrExcept(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitGroupByOrExcept" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGroupByOrExcept"): listener.exitGroupByOrExcept(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitGroupByOrExcept" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGroupByOrExcept"): return visitor.visitGroupByOrExcept(self) else: return visitor.visitChildren(self) - - def groupingClause(self): localctx = Parser.GroupingClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 110, self.RULE_groupingClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1497 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,141,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 141, self._ctx) if la_ == 1: localctx = Parser.GroupByOrExceptContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -12581,7 +13924,7 @@ def groupingClause(self): self.state = 1485 localctx.op = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.BY or _la==Parser.EXCEPT): + if not (_la == Parser.BY or _la == Parser.EXCEPT): localctx.op = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -12591,7 +13934,7 @@ def groupingClause(self): self.state = 1491 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1487 self.match(Parser.COMMA) self.state = 1488 @@ -12613,7 +13956,6 @@ def groupingClause(self): self.exprComponent(0) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -12622,11 +13964,10 @@ def groupingClause(self): self.exitRule() return localctx - class HavingClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12634,29 +13975,25 @@ def HAVING(self): return self.getToken(Parser.HAVING, 0) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) - + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def getRuleIndex(self): return Parser.RULE_havingClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterHavingClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterHavingClause"): listener.enterHavingClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitHavingClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitHavingClause"): listener.exitHavingClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitHavingClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHavingClause"): return visitor.visitHavingClause(self) else: return visitor.visitChildren(self) - - - def havingClause(self): localctx = Parser.HavingClauseContext(self, self._ctx, self.state) @@ -12675,54 +14012,47 @@ def havingClause(self): self.exitRule() return localctx - class ParameterItemContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext,0) - + return self.getTypedRuleContext(Parser.VarIDContext, 0) def inputParameterType(self): - return self.getTypedRuleContext(Parser.InputParameterTypeContext,0) - + return self.getTypedRuleContext(Parser.InputParameterTypeContext, 0) def DEFAULT(self): return self.getToken(Parser.DEFAULT, 0) def scalarItem(self): - return self.getTypedRuleContext(Parser.ScalarItemContext,0) - + return self.getTypedRuleContext(Parser.ScalarItemContext, 0) def getRuleIndex(self): return Parser.RULE_parameterItem - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterParameterItem" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterParameterItem"): listener.enterParameterItem(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitParameterItem" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitParameterItem"): listener.exitParameterItem(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitParameterItem" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParameterItem"): return visitor.visitParameterItem(self) else: return visitor.visitChildren(self) - - - def parameterItem(self): localctx = Parser.ParameterItemContext(self, self._ctx, self.state) self.enterRule(localctx, 114, self.RULE_parameterItem) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1502 @@ -12732,13 +14062,12 @@ def parameterItem(self): self.state = 1506 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.DEFAULT: + if _la == Parser.DEFAULT: self.state = 1504 self.match(Parser.DEFAULT) self.state = 1505 self.scalarItem() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -12747,46 +14076,39 @@ def parameterItem(self): self.exitRule() return localctx - class OutputParameterTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext,0) - + return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) def datasetType(self): - return self.getTypedRuleContext(Parser.DatasetTypeContext,0) - + return self.getTypedRuleContext(Parser.DatasetTypeContext, 0) def componentType(self): - return self.getTypedRuleContext(Parser.ComponentTypeContext,0) - + return self.getTypedRuleContext(Parser.ComponentTypeContext, 0) def getRuleIndex(self): return Parser.RULE_outputParameterType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOutputParameterType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOutputParameterType"): listener.enterOutputParameterType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOutputParameterType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOutputParameterType"): listener.exitOutputParameterType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOutputParameterType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOutputParameterType"): return visitor.visitOutputParameterType(self) else: return visitor.visitChildren(self) - - - def outputParameterType(self): localctx = Parser.OutputParameterTypeContext(self, self._ctx, self.state) @@ -12795,7 +14117,18 @@ def outputParameterType(self): self.state = 1511 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR, Parser.IDENTIFIER]: + if token in [ + Parser.BOOLEAN, + Parser.DATE, + Parser.TIME_PERIOD, + Parser.NUMBER, + Parser.STRING, + Parser.TIME, + Parser.INTEGER, + Parser.DURATION, + Parser.SCALAR, + Parser.IDENTIFIER, + ]: self.enterOuterAlt(localctx, 1) self.state = 1508 self.scalarType() @@ -12805,7 +14138,13 @@ def outputParameterType(self): self.state = 1509 self.datasetType() pass - elif token in [Parser.DIMENSION, Parser.MEASURE, Parser.ATTRIBUTE, Parser.VIRAL, Parser.COMPONENT]: + elif token in [ + Parser.DIMENSION, + Parser.MEASURE, + Parser.ATTRIBUTE, + Parser.VIRAL, + Parser.COMPONENT, + ]: self.enterOuterAlt(localctx, 3) self.state = 1510 self.componentType() @@ -12821,42 +14160,36 @@ def outputParameterType(self): self.exitRule() return localctx - class OutputParameterTypeComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentType(self): - return self.getTypedRuleContext(Parser.ComponentTypeContext,0) - + return self.getTypedRuleContext(Parser.ComponentTypeContext, 0) def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext,0) - + return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) def getRuleIndex(self): return Parser.RULE_outputParameterTypeComponent - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOutputParameterTypeComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOutputParameterTypeComponent"): listener.enterOutputParameterTypeComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOutputParameterTypeComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOutputParameterTypeComponent"): listener.exitOutputParameterTypeComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOutputParameterTypeComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOutputParameterTypeComponent"): return visitor.visitOutputParameterTypeComponent(self) else: return visitor.visitChildren(self) - - - def outputParameterTypeComponent(self): localctx = Parser.OutputParameterTypeComponentContext(self, self._ctx, self.state) @@ -12865,12 +14198,29 @@ def outputParameterTypeComponent(self): self.state = 1515 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.DIMENSION, Parser.MEASURE, Parser.ATTRIBUTE, Parser.VIRAL, Parser.COMPONENT]: + if token in [ + Parser.DIMENSION, + Parser.MEASURE, + Parser.ATTRIBUTE, + Parser.VIRAL, + Parser.COMPONENT, + ]: self.enterOuterAlt(localctx, 1) self.state = 1513 self.componentType() pass - elif token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR, Parser.IDENTIFIER]: + elif token in [ + Parser.BOOLEAN, + Parser.DATE, + Parser.TIME_PERIOD, + Parser.NUMBER, + Parser.STRING, + Parser.TIME, + Parser.INTEGER, + Parser.DURATION, + Parser.SCALAR, + Parser.IDENTIFIER, + ]: self.enterOuterAlt(localctx, 2) self.state = 1514 self.scalarType() @@ -12886,54 +14236,45 @@ def outputParameterTypeComponent(self): self.exitRule() return localctx - class InputParameterTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext,0) - + return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) def datasetType(self): - return self.getTypedRuleContext(Parser.DatasetTypeContext,0) - + return self.getTypedRuleContext(Parser.DatasetTypeContext, 0) def scalarSetType(self): - return self.getTypedRuleContext(Parser.ScalarSetTypeContext,0) - + return self.getTypedRuleContext(Parser.ScalarSetTypeContext, 0) def rulesetType(self): - return self.getTypedRuleContext(Parser.RulesetTypeContext,0) - + return self.getTypedRuleContext(Parser.RulesetTypeContext, 0) def componentType(self): - return self.getTypedRuleContext(Parser.ComponentTypeContext,0) - + return self.getTypedRuleContext(Parser.ComponentTypeContext, 0) def getRuleIndex(self): return Parser.RULE_inputParameterType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInputParameterType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInputParameterType"): listener.enterInputParameterType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInputParameterType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInputParameterType"): listener.exitInputParameterType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInputParameterType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInputParameterType"): return visitor.visitInputParameterType(self) else: return visitor.visitChildren(self) - - - def inputParameterType(self): localctx = Parser.InputParameterTypeContext(self, self._ctx, self.state) @@ -12942,7 +14283,18 @@ def inputParameterType(self): self.state = 1522 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR, Parser.IDENTIFIER]: + if token in [ + Parser.BOOLEAN, + Parser.DATE, + Parser.TIME_PERIOD, + Parser.NUMBER, + Parser.STRING, + Parser.TIME, + Parser.INTEGER, + Parser.DURATION, + Parser.SCALAR, + Parser.IDENTIFIER, + ]: self.enterOuterAlt(localctx, 1) self.state = 1517 self.scalarType() @@ -12957,12 +14309,26 @@ def inputParameterType(self): self.state = 1519 self.scalarSetType() pass - elif token in [Parser.DATAPOINT, Parser.HIERARCHICAL, Parser.RULESET, Parser.DATAPOINT_ON_VD, Parser.DATAPOINT_ON_VAR, Parser.HIERARCHICAL_ON_VD, Parser.HIERARCHICAL_ON_VAR]: + elif token in [ + Parser.DATAPOINT, + Parser.HIERARCHICAL, + Parser.RULESET, + Parser.DATAPOINT_ON_VD, + Parser.DATAPOINT_ON_VAR, + Parser.HIERARCHICAL_ON_VD, + Parser.HIERARCHICAL_ON_VAR, + ]: self.enterOuterAlt(localctx, 4) self.state = 1520 self.rulesetType() pass - elif token in [Parser.DIMENSION, Parser.MEASURE, Parser.ATTRIBUTE, Parser.VIRAL, Parser.COMPONENT]: + elif token in [ + Parser.DIMENSION, + Parser.MEASURE, + Parser.ATTRIBUTE, + Parser.VIRAL, + Parser.COMPONENT, + ]: self.enterOuterAlt(localctx, 5) self.state = 1521 self.componentType() @@ -12978,11 +14344,10 @@ def inputParameterType(self): self.exitRule() return localctx - class RulesetTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -12990,33 +14355,28 @@ def RULESET(self): return self.getToken(Parser.RULESET, 0) def dpRuleset(self): - return self.getTypedRuleContext(Parser.DpRulesetContext,0) - + return self.getTypedRuleContext(Parser.DpRulesetContext, 0) def hrRuleset(self): - return self.getTypedRuleContext(Parser.HrRulesetContext,0) - + return self.getTypedRuleContext(Parser.HrRulesetContext, 0) def getRuleIndex(self): return Parser.RULE_rulesetType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRulesetType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRulesetType"): listener.enterRulesetType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRulesetType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRulesetType"): listener.exitRulesetType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRulesetType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRulesetType"): return visitor.visitRulesetType(self) else: return visitor.visitChildren(self) - - - def rulesetType(self): localctx = Parser.RulesetTypeContext(self, self._ctx, self.state) @@ -13035,7 +14395,11 @@ def rulesetType(self): self.state = 1525 self.dpRuleset() pass - elif token in [Parser.HIERARCHICAL, Parser.HIERARCHICAL_ON_VD, Parser.HIERARCHICAL_ON_VAR]: + elif token in [ + Parser.HIERARCHICAL, + Parser.HIERARCHICAL_ON_VD, + Parser.HIERARCHICAL_ON_VAR, + ]: self.enterOuterAlt(localctx, 3) self.state = 1526 self.hrRuleset() @@ -13051,25 +14415,21 @@ def rulesetType(self): self.exitRule() return localctx - class ScalarTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def basicScalarType(self): - return self.getTypedRuleContext(Parser.BasicScalarTypeContext,0) - + return self.getTypedRuleContext(Parser.BasicScalarTypeContext, 0) def valueDomainName(self): - return self.getTypedRuleContext(Parser.ValueDomainNameContext,0) - + return self.getTypedRuleContext(Parser.ValueDomainNameContext, 0) def scalarTypeConstraint(self): - return self.getTypedRuleContext(Parser.ScalarTypeConstraintContext,0) - + return self.getTypedRuleContext(Parser.ScalarTypeConstraintContext, 0) def NULL_CONSTANT(self): return self.getToken(Parser.NULL_CONSTANT, 0) @@ -13080,34 +14440,41 @@ def NOT(self): def getRuleIndex(self): return Parser.RULE_scalarType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterScalarType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterScalarType"): listener.enterScalarType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitScalarType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitScalarType"): listener.exitScalarType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitScalarType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitScalarType"): return visitor.visitScalarType(self) else: return visitor.visitChildren(self) - - - def scalarType(self): localctx = Parser.ScalarTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 124, self.RULE_scalarType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1531 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR]: + if token in [ + Parser.BOOLEAN, + Parser.DATE, + Parser.TIME_PERIOD, + Parser.NUMBER, + Parser.STRING, + Parser.TIME, + Parser.INTEGER, + Parser.DURATION, + Parser.SCALAR, + ]: self.state = 1529 self.basicScalarType() pass @@ -13121,27 +14488,24 @@ def scalarType(self): self.state = 1534 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.QLPAREN or _la==Parser.GLPAREN: + if _la == Parser.QLPAREN or _la == Parser.GLPAREN: self.state = 1533 self.scalarTypeConstraint() - self.state = 1540 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.NOT or _la==Parser.NULL_CONSTANT: + if _la == Parser.NOT or _la == Parser.NULL_CONSTANT: self.state = 1537 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.NOT: + if _la == Parser.NOT: self.state = 1536 self.match(Parser.NOT) - self.state = 1539 self.match(Parser.NULL_CONSTANT) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -13150,24 +14514,21 @@ def scalarType(self): self.exitRule() return localctx - class ComponentTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentRole(self): - return self.getTypedRuleContext(Parser.ComponentRoleContext,0) - + return self.getTypedRuleContext(Parser.ComponentRoleContext, 0) def LT(self): return self.getToken(Parser.LT, 0) def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext,0) - + return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) def MT(self): return self.getToken(Parser.MT, 0) @@ -13175,28 +14536,25 @@ def MT(self): def getRuleIndex(self): return Parser.RULE_componentType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterComponentType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterComponentType"): listener.enterComponentType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitComponentType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitComponentType"): listener.exitComponentType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitComponentType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComponentType"): return visitor.visitComponentType(self) else: return visitor.visitChildren(self) - - - def componentType(self): localctx = Parser.ComponentTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 126, self.RULE_componentType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1542 @@ -13204,7 +14562,7 @@ def componentType(self): self.state = 1547 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.LT: + if _la == Parser.LT: self.state = 1543 self.match(Parser.LT) self.state = 1544 @@ -13212,7 +14570,6 @@ def componentType(self): self.state = 1545 self.match(Parser.MT) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -13221,11 +14578,10 @@ def componentType(self): self.exitRule() return localctx - class DatasetTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -13235,17 +14591,16 @@ def DATASET(self): def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - def compConstraint(self, i:int=None): + def compConstraint(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.CompConstraintContext) else: - return self.getTypedRuleContext(Parser.CompConstraintContext,i) - + return self.getTypedRuleContext(Parser.CompConstraintContext, i) def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -13254,28 +14609,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_datasetType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDatasetType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDatasetType"): listener.enterDatasetType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDatasetType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDatasetType"): listener.exitDatasetType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDatasetType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDatasetType"): return visitor.visitDatasetType(self) else: return visitor.visitChildren(self) - - - def datasetType(self): localctx = Parser.DatasetTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 128, self.RULE_datasetType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1549 @@ -13283,7 +14635,7 @@ def datasetType(self): self.state = 1561 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.GLPAREN: + if _la == Parser.GLPAREN: self.state = 1550 self.match(Parser.GLPAREN) self.state = 1551 @@ -13291,7 +14643,7 @@ def datasetType(self): self.state = 1556 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1552 self.match(Parser.COMMA) self.state = 1553 @@ -13303,7 +14655,6 @@ def datasetType(self): self.state = 1559 self.match(Parser.GRPAREN) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -13312,42 +14663,36 @@ def datasetType(self): self.exitRule() return localctx - class EvalDatasetTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def datasetType(self): - return self.getTypedRuleContext(Parser.DatasetTypeContext,0) - + return self.getTypedRuleContext(Parser.DatasetTypeContext, 0) def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext,0) - + return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) def getRuleIndex(self): return Parser.RULE_evalDatasetType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterEvalDatasetType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterEvalDatasetType"): listener.enterEvalDatasetType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitEvalDatasetType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitEvalDatasetType"): listener.exitEvalDatasetType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitEvalDatasetType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitEvalDatasetType"): return visitor.visitEvalDatasetType(self) else: return visitor.visitChildren(self) - - - def evalDatasetType(self): localctx = Parser.EvalDatasetTypeContext(self, self._ctx, self.state) @@ -13361,7 +14706,18 @@ def evalDatasetType(self): self.state = 1563 self.datasetType() pass - elif token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER, Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR, Parser.IDENTIFIER]: + elif token in [ + Parser.BOOLEAN, + Parser.DATE, + Parser.TIME_PERIOD, + Parser.NUMBER, + Parser.STRING, + Parser.TIME, + Parser.INTEGER, + Parser.DURATION, + Parser.SCALAR, + Parser.IDENTIFIER, + ]: self.enterOuterAlt(localctx, 2) self.state = 1564 self.scalarType() @@ -13377,11 +14733,10 @@ def evalDatasetType(self): self.exitRule() return localctx - class ScalarSetTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -13392,8 +14747,7 @@ def LT(self): return self.getToken(Parser.LT, 0) def scalarType(self): - return self.getTypedRuleContext(Parser.ScalarTypeContext,0) - + return self.getTypedRuleContext(Parser.ScalarTypeContext, 0) def MT(self): return self.getToken(Parser.MT, 0) @@ -13401,28 +14755,25 @@ def MT(self): def getRuleIndex(self): return Parser.RULE_scalarSetType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterScalarSetType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterScalarSetType"): listener.enterScalarSetType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitScalarSetType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitScalarSetType"): listener.exitScalarSetType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitScalarSetType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitScalarSetType"): return visitor.visitScalarSetType(self) else: return visitor.visitChildren(self) - - - def scalarSetType(self): localctx = Parser.ScalarSetTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 132, self.RULE_scalarSetType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1567 @@ -13430,7 +14781,7 @@ def scalarSetType(self): self.state = 1572 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.LT: + if _la == Parser.LT: self.state = 1568 self.match(Parser.LT) self.state = 1569 @@ -13438,7 +14789,6 @@ def scalarSetType(self): self.state = 1570 self.match(Parser.MT) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -13447,132 +14797,132 @@ def scalarSetType(self): self.exitRule() return localctx - class DpRulesetContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_dpRuleset - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class DataPointVdContext(DpRulesetContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DpRulesetContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.DpRulesetContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DATAPOINT_ON_VD(self): return self.getToken(Parser.DATAPOINT_ON_VD, 0) + def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - def valueDomainName(self, i:int=None): + + def valueDomainName(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ValueDomainNameContext) else: - return self.getTypedRuleContext(Parser.ValueDomainNameContext,i) + return self.getTypedRuleContext(Parser.ValueDomainNameContext, i) def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - def MUL(self, i:int=None): + + def MUL(self, i: int = None): if i is None: return self.getTokens(Parser.MUL) else: return self.getToken(Parser.MUL, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDataPointVd" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDataPointVd"): listener.enterDataPointVd(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDataPointVd" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDataPointVd"): listener.exitDataPointVd(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDataPointVd" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDataPointVd"): return visitor.visitDataPointVd(self) else: return visitor.visitChildren(self) - class DataPointVarContext(DpRulesetContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DpRulesetContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.DpRulesetContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DATAPOINT_ON_VAR(self): return self.getToken(Parser.DATAPOINT_ON_VAR, 0) + def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - def varID(self, i:int=None): + + def varID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.VarIDContext) else: - return self.getTypedRuleContext(Parser.VarIDContext,i) + return self.getTypedRuleContext(Parser.VarIDContext, i) def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - def MUL(self, i:int=None): + + def MUL(self, i: int = None): if i is None: return self.getTokens(Parser.MUL) else: return self.getToken(Parser.MUL, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDataPointVar" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDataPointVar"): listener.enterDataPointVar(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDataPointVar" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDataPointVar"): listener.exitDataPointVar(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDataPointVar" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDataPointVar"): return visitor.visitDataPointVar(self) else: return visitor.visitChildren(self) - class DataPointContext(DpRulesetContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.DpRulesetContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.DpRulesetContext super().__init__(ANTLRParser) self.copyFrom(ctx) def DATAPOINT(self): return self.getToken(Parser.DATAPOINT, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDataPoint" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDataPoint"): listener.enterDataPoint(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDataPoint" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDataPoint"): listener.exitDataPoint(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDataPoint" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDataPoint"): return visitor.visitDataPoint(self) else: return visitor.visitChildren(self) - - def dpRuleset(self): localctx = Parser.DpRulesetContext(self, self._ctx, self.state) self.enterRule(localctx, 134, self.RULE_dpRuleset) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1603 self._errHandler.sync(self) @@ -13591,7 +14941,7 @@ def dpRuleset(self): self.state = 1587 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.GLPAREN: + if _la == Parser.GLPAREN: self.state = 1576 self.match(Parser.GLPAREN) self.state = 1577 @@ -13599,7 +14949,7 @@ def dpRuleset(self): self.state = 1582 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.MUL: + while _la == Parser.MUL: self.state = 1578 self.match(Parser.MUL) self.state = 1579 @@ -13611,7 +14961,6 @@ def dpRuleset(self): self.state = 1585 self.match(Parser.GRPAREN) - pass elif token in [Parser.DATAPOINT_ON_VAR]: localctx = Parser.DataPointVarContext(self, localctx) @@ -13621,7 +14970,7 @@ def dpRuleset(self): self.state = 1601 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.GLPAREN: + if _la == Parser.GLPAREN: self.state = 1590 self.match(Parser.GLPAREN) self.state = 1591 @@ -13629,7 +14978,7 @@ def dpRuleset(self): self.state = 1596 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.MUL: + while _la == Parser.MUL: self.state = 1592 self.match(Parser.MUL) self.state = 1593 @@ -13641,7 +14990,6 @@ def dpRuleset(self): self.state = 1599 self.match(Parser.GRPAREN) - pass else: raise NoViableAltException(self) @@ -13654,144 +15002,149 @@ def dpRuleset(self): self.exitRule() return localctx - class HrRulesetContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_hrRuleset - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class HrRulesetVdTypeContext(HrRulesetContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.HrRulesetContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.HrRulesetContext super().__init__(ANTLRParser) - self.vdName = None # Token + self.vdName = None # Token self.copyFrom(ctx) def HIERARCHICAL_ON_VD(self): return self.getToken(Parser.HIERARCHICAL_ON_VD, 0) + def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) + def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) + def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) + def LPAREN(self): return self.getToken(Parser.LPAREN, 0) - def valueDomainName(self, i:int=None): + + def valueDomainName(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ValueDomainNameContext) else: - return self.getTypedRuleContext(Parser.ValueDomainNameContext,i) + return self.getTypedRuleContext(Parser.ValueDomainNameContext, i) def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def MUL(self, i:int=None): + + def MUL(self, i: int = None): if i is None: return self.getTokens(Parser.MUL) else: return self.getToken(Parser.MUL, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterHrRulesetVdType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterHrRulesetVdType"): listener.enterHrRulesetVdType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitHrRulesetVdType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitHrRulesetVdType"): listener.exitHrRulesetVdType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitHrRulesetVdType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHrRulesetVdType"): return visitor.visitHrRulesetVdType(self) else: return visitor.visitChildren(self) - class HrRulesetVarTypeContext(HrRulesetContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.HrRulesetContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.HrRulesetContext super().__init__(ANTLRParser) - self.varName = None # VarIDContext + self.varName = None # VarIDContext self.copyFrom(ctx) def HIERARCHICAL_ON_VAR(self): return self.getToken(Parser.HIERARCHICAL_ON_VAR, 0) + def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) + def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - def varID(self, i:int=None): + + def varID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.VarIDContext) else: - return self.getTypedRuleContext(Parser.VarIDContext,i) + return self.getTypedRuleContext(Parser.VarIDContext, i) def LPAREN(self): return self.getToken(Parser.LPAREN, 0) + def RPAREN(self): return self.getToken(Parser.RPAREN, 0) - def MUL(self, i:int=None): + + def MUL(self, i: int = None): if i is None: return self.getTokens(Parser.MUL) else: return self.getToken(Parser.MUL, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterHrRulesetVarType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterHrRulesetVarType"): listener.enterHrRulesetVarType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitHrRulesetVarType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitHrRulesetVarType"): listener.exitHrRulesetVarType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitHrRulesetVarType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHrRulesetVarType"): return visitor.visitHrRulesetVarType(self) else: return visitor.visitChildren(self) - class HrRulesetTypeContext(HrRulesetContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.HrRulesetContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.HrRulesetContext super().__init__(ANTLRParser) self.copyFrom(ctx) def HIERARCHICAL(self): return self.getToken(Parser.HIERARCHICAL, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterHrRulesetType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterHrRulesetType"): listener.enterHrRulesetType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitHrRulesetType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitHrRulesetType"): listener.exitHrRulesetType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitHrRulesetType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHrRulesetType"): return visitor.visitHrRulesetType(self) else: return visitor.visitChildren(self) - - def hrRuleset(self): localctx = Parser.HrRulesetContext(self, self._ctx, self.state) self.enterRule(localctx, 136, self.RULE_hrRuleset) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1645 self._errHandler.sync(self) @@ -13810,7 +15163,7 @@ def hrRuleset(self): self.state = 1623 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.GLPAREN: + if _la == Parser.GLPAREN: self.state = 1607 self.match(Parser.GLPAREN) self.state = 1608 @@ -13818,7 +15171,7 @@ def hrRuleset(self): self.state = 1620 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.LPAREN: + if _la == Parser.LPAREN: self.state = 1609 self.match(Parser.LPAREN) self.state = 1610 @@ -13826,7 +15179,7 @@ def hrRuleset(self): self.state = 1615 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.MUL: + while _la == Parser.MUL: self.state = 1611 self.match(Parser.MUL) self.state = 1612 @@ -13838,11 +15191,9 @@ def hrRuleset(self): self.state = 1618 self.match(Parser.RPAREN) - self.state = 1622 self.match(Parser.GRPAREN) - pass elif token in [Parser.HIERARCHICAL_ON_VAR]: localctx = Parser.HrRulesetVarTypeContext(self, localctx) @@ -13852,7 +15203,7 @@ def hrRuleset(self): self.state = 1643 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.GLPAREN: + if _la == Parser.GLPAREN: self.state = 1626 self.match(Parser.GLPAREN) self.state = 1627 @@ -13860,7 +15211,7 @@ def hrRuleset(self): self.state = 1639 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.LPAREN: + if _la == Parser.LPAREN: self.state = 1628 self.match(Parser.LPAREN) self.state = 1629 @@ -13868,7 +15219,7 @@ def hrRuleset(self): self.state = 1634 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.MUL: + while _la == Parser.MUL: self.state = 1630 self.match(Parser.MUL) self.state = 1631 @@ -13880,11 +15231,9 @@ def hrRuleset(self): self.state = 1637 self.match(Parser.RPAREN) - self.state = 1641 self.match(Parser.GRPAREN) - pass else: raise NoViableAltException(self) @@ -13897,11 +15246,10 @@ def hrRuleset(self): self.exitRule() return localctx - class ValueDomainNameContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -13911,23 +15259,20 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_valueDomainName - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterValueDomainName" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterValueDomainName"): listener.enterValueDomainName(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitValueDomainName" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitValueDomainName"): listener.exitValueDomainName(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitValueDomainName" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValueDomainName"): return visitor.visitValueDomainName(self) else: return visitor.visitChildren(self) - - - def valueDomainName(self): localctx = Parser.ValueDomainNameContext(self, self._ctx, self.state) @@ -13944,11 +15289,10 @@ def valueDomainName(self): self.exitRule() return localctx - class RulesetIDContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -13958,23 +15302,20 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_rulesetID - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRulesetID" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRulesetID"): listener.enterRulesetID(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRulesetID" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRulesetID"): listener.exitRulesetID(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRulesetID" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRulesetID"): return visitor.visitRulesetID(self) else: return visitor.visitChildren(self) - - - def rulesetID(self): localctx = Parser.RulesetIDContext(self, self._ctx, self.state) @@ -13991,20 +15332,18 @@ def rulesetID(self): self.exitRule() return localctx - class RulesetSignatureContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def signature(self, i:int=None): + def signature(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.SignatureContext) else: - return self.getTypedRuleContext(Parser.SignatureContext,i) - + return self.getTypedRuleContext(Parser.SignatureContext, i) def VALUE_DOMAIN(self): return self.getToken(Parser.VALUE_DOMAIN, 0) @@ -14012,7 +15351,7 @@ def VALUE_DOMAIN(self): def VARIABLE(self): return self.getToken(Parser.VARIABLE, 0) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -14021,33 +15360,30 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_rulesetSignature - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRulesetSignature" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRulesetSignature"): listener.enterRulesetSignature(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRulesetSignature" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRulesetSignature"): listener.exitRulesetSignature(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRulesetSignature" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRulesetSignature"): return visitor.visitRulesetSignature(self) else: return visitor.visitChildren(self) - - - def rulesetSignature(self): localctx = Parser.RulesetSignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 142, self.RULE_rulesetSignature) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1651 _la = self._input.LA(1) - if not(_la==Parser.VALUE_DOMAIN or _la==Parser.VARIABLE): + if not (_la == Parser.VALUE_DOMAIN or _la == Parser.VARIABLE): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -14057,7 +15393,7 @@ def rulesetSignature(self): self.state = 1657 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1653 self.match(Parser.COMMA) self.state = 1654 @@ -14074,50 +15410,44 @@ def rulesetSignature(self): self.exitRule() return localctx - class SignatureContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def varID(self): - return self.getTypedRuleContext(Parser.VarIDContext,0) - + return self.getTypedRuleContext(Parser.VarIDContext, 0) def AS(self): return self.getToken(Parser.AS, 0) def alias(self): - return self.getTypedRuleContext(Parser.AliasContext,0) - + return self.getTypedRuleContext(Parser.AliasContext, 0) def getRuleIndex(self): return Parser.RULE_signature - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSignature" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSignature"): listener.enterSignature(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSignature" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSignature"): listener.exitSignature(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSignature" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSignature"): return visitor.visitSignature(self) else: return visitor.visitChildren(self) - - - def signature(self): localctx = Parser.SignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 144, self.RULE_signature) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1660 @@ -14125,13 +15455,12 @@ def signature(self): self.state = 1663 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.AS: + if _la == Parser.AS: self.state = 1661 self.match(Parser.AS) self.state = 1662 self.alias() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -14140,22 +15469,20 @@ def signature(self): self.exitRule() return localctx - class RuleClauseDatapointContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def ruleItemDatapoint(self, i:int=None): + def ruleItemDatapoint(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.RuleItemDatapointContext) else: - return self.getTypedRuleContext(Parser.RuleItemDatapointContext,i) + return self.getTypedRuleContext(Parser.RuleItemDatapointContext, i) - - def EOL(self, i:int=None): + def EOL(self, i: int = None): if i is None: return self.getTokens(Parser.EOL) else: @@ -14164,28 +15491,25 @@ def EOL(self, i:int=None): def getRuleIndex(self): return Parser.RULE_ruleClauseDatapoint - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRuleClauseDatapoint" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRuleClauseDatapoint"): listener.enterRuleClauseDatapoint(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRuleClauseDatapoint" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRuleClauseDatapoint"): listener.exitRuleClauseDatapoint(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRuleClauseDatapoint" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRuleClauseDatapoint"): return visitor.visitRuleClauseDatapoint(self) else: return visitor.visitChildren(self) - - - def ruleClauseDatapoint(self): localctx = Parser.RuleClauseDatapointContext(self, self._ctx, self.state) self.enterRule(localctx, 146, self.RULE_ruleClauseDatapoint) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1665 @@ -14193,7 +15517,7 @@ def ruleClauseDatapoint(self): self.state = 1670 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.EOL: + while _la == Parser.EOL: self.state = 1666 self.match(Parser.EOL) self.state = 1667 @@ -14210,23 +15534,21 @@ def ruleClauseDatapoint(self): self.exitRule() return localctx - class RuleItemDatapointContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.ruleName = None # Token - self.antecedentContiditon = None # ExprComponentContext - self.consequentCondition = None # ExprComponentContext + self.ruleName = None # Token + self.antecedentContiditon = None # ExprComponentContext + self.consequentCondition = None # ExprComponentContext - def exprComponent(self, i:int=None): + def exprComponent(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ExprComponentContext) else: - return self.getTypedRuleContext(Parser.ExprComponentContext,i) - + return self.getTypedRuleContext(Parser.ExprComponentContext, i) def COLON(self): return self.getToken(Parser.COLON, 0) @@ -14238,12 +15560,10 @@ def THEN(self): return self.getToken(Parser.THEN, 0) def erCode(self): - return self.getTypedRuleContext(Parser.ErCodeContext,0) - + return self.getTypedRuleContext(Parser.ErCodeContext, 0) def erLevel(self): - return self.getTypedRuleContext(Parser.ErLevelContext,0) - + return self.getTypedRuleContext(Parser.ErLevelContext, 0) def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) @@ -14251,44 +15571,40 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_ruleItemDatapoint - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRuleItemDatapoint" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRuleItemDatapoint"): listener.enterRuleItemDatapoint(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRuleItemDatapoint" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRuleItemDatapoint"): listener.exitRuleItemDatapoint(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRuleItemDatapoint" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRuleItemDatapoint"): return visitor.visitRuleItemDatapoint(self) else: return visitor.visitChildren(self) - - - def ruleItemDatapoint(self): localctx = Parser.RuleItemDatapointContext(self, self._ctx, self.state) self.enterRule(localctx, 148, self.RULE_ruleItemDatapoint) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1675 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,171,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 171, self._ctx) if la_ == 1: self.state = 1673 localctx.ruleName = self.match(Parser.IDENTIFIER) self.state = 1674 self.match(Parser.COLON) - self.state = 1681 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.WHEN: + if _la == Parser.WHEN: self.state = 1677 self.match(Parser.WHEN) self.state = 1678 @@ -14296,25 +15612,22 @@ def ruleItemDatapoint(self): self.state = 1679 self.match(Parser.THEN) - self.state = 1683 localctx.consequentCondition = self.exprComponent(0) self.state = 1685 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ERRORCODE: + if _la == Parser.ERRORCODE: self.state = 1684 self.erCode() - self.state = 1688 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ERRORLEVEL: + if _la == Parser.ERRORLEVEL: self.state = 1687 self.erLevel() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -14323,22 +15636,20 @@ def ruleItemDatapoint(self): self.exitRule() return localctx - class RuleClauseHierarchicalContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def ruleItemHierarchical(self, i:int=None): + def ruleItemHierarchical(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.RuleItemHierarchicalContext) else: - return self.getTypedRuleContext(Parser.RuleItemHierarchicalContext,i) + return self.getTypedRuleContext(Parser.RuleItemHierarchicalContext, i) - - def EOL(self, i:int=None): + def EOL(self, i: int = None): if i is None: return self.getTokens(Parser.EOL) else: @@ -14347,28 +15658,25 @@ def EOL(self, i:int=None): def getRuleIndex(self): return Parser.RULE_ruleClauseHierarchical - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRuleClauseHierarchical" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRuleClauseHierarchical"): listener.enterRuleClauseHierarchical(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRuleClauseHierarchical" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRuleClauseHierarchical"): listener.exitRuleClauseHierarchical(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRuleClauseHierarchical" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRuleClauseHierarchical"): return visitor.visitRuleClauseHierarchical(self) else: return visitor.visitChildren(self) - - - def ruleClauseHierarchical(self): localctx = Parser.RuleClauseHierarchicalContext(self, self._ctx, self.state) self.enterRule(localctx, 150, self.RULE_ruleClauseHierarchical) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1690 @@ -14376,7 +15684,7 @@ def ruleClauseHierarchical(self): self.state = 1695 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.EOL: + while _la == Parser.EOL: self.state = 1691 self.match(Parser.EOL) self.state = 1692 @@ -14393,29 +15701,25 @@ def ruleClauseHierarchical(self): self.exitRule() return localctx - class RuleItemHierarchicalContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.ruleName = None # Token + self.ruleName = None # Token def codeItemRelation(self): - return self.getTypedRuleContext(Parser.CodeItemRelationContext,0) - + return self.getTypedRuleContext(Parser.CodeItemRelationContext, 0) def COLON(self): return self.getToken(Parser.COLON, 0) def erCode(self): - return self.getTypedRuleContext(Parser.ErCodeContext,0) - + return self.getTypedRuleContext(Parser.ErCodeContext, 0) def erLevel(self): - return self.getTypedRuleContext(Parser.ErLevelContext,0) - + return self.getTypedRuleContext(Parser.ErLevelContext, 0) def IDENTIFIER(self): return self.getToken(Parser.IDENTIFIER, 0) @@ -14423,58 +15727,52 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_ruleItemHierarchical - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRuleItemHierarchical" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRuleItemHierarchical"): listener.enterRuleItemHierarchical(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRuleItemHierarchical" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRuleItemHierarchical"): listener.exitRuleItemHierarchical(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRuleItemHierarchical" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRuleItemHierarchical"): return visitor.visitRuleItemHierarchical(self) else: return visitor.visitChildren(self) - - - def ruleItemHierarchical(self): localctx = Parser.RuleItemHierarchicalContext(self, self._ctx, self.state) self.enterRule(localctx, 152, self.RULE_ruleItemHierarchical) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1700 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,176,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 176, self._ctx) if la_ == 1: self.state = 1698 localctx.ruleName = self.match(Parser.IDENTIFIER) self.state = 1699 self.match(Parser.COLON) - self.state = 1702 self.codeItemRelation() self.state = 1704 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ERRORCODE: + if _la == Parser.ERRORCODE: self.state = 1703 self.erCode() - self.state = 1707 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.ERRORLEVEL: + if _la == Parser.ERRORLEVEL: self.state = 1706 self.erLevel() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -14483,11 +15781,10 @@ def ruleItemHierarchical(self): self.exitRule() return localctx - class HierRuleSignatureContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -14507,39 +15804,35 @@ def CONDITION(self): return self.getToken(Parser.CONDITION, 0) def valueDomainSignature(self): - return self.getTypedRuleContext(Parser.ValueDomainSignatureContext,0) - + return self.getTypedRuleContext(Parser.ValueDomainSignatureContext, 0) def getRuleIndex(self): return Parser.RULE_hierRuleSignature - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterHierRuleSignature" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterHierRuleSignature"): listener.enterHierRuleSignature(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitHierRuleSignature" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitHierRuleSignature"): listener.exitHierRuleSignature(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitHierRuleSignature" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHierRuleSignature"): return visitor.visitHierRuleSignature(self) else: return visitor.visitChildren(self) - - - def hierRuleSignature(self): localctx = Parser.HierRuleSignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 154, self.RULE_hierRuleSignature) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1709 _la = self._input.LA(1) - if not(_la==Parser.VALUE_DOMAIN or _la==Parser.VARIABLE): + if not (_la == Parser.VALUE_DOMAIN or _la == Parser.VARIABLE): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -14547,13 +15840,12 @@ def hierRuleSignature(self): self.state = 1712 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.CONDITION: + if _la == Parser.CONDITION: self.state = 1710 self.match(Parser.CONDITION) self.state = 1711 self.valueDomainSignature() - self.state = 1714 self.match(Parser.RULE) self.state = 1715 @@ -14566,22 +15858,20 @@ def hierRuleSignature(self): self.exitRule() return localctx - class ValueDomainSignatureContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def signature(self, i:int=None): + def signature(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.SignatureContext) else: - return self.getTypedRuleContext(Parser.SignatureContext,i) - + return self.getTypedRuleContext(Parser.SignatureContext, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -14590,28 +15880,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_valueDomainSignature - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterValueDomainSignature" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterValueDomainSignature"): listener.enterValueDomainSignature(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitValueDomainSignature" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitValueDomainSignature"): listener.exitValueDomainSignature(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitValueDomainSignature" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValueDomainSignature"): return visitor.visitValueDomainSignature(self) else: return visitor.visitChildren(self) - - - def valueDomainSignature(self): localctx = Parser.ValueDomainSignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 156, self.RULE_valueDomainSignature) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1717 @@ -14619,7 +15906,7 @@ def valueDomainSignature(self): self.state = 1722 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1718 self.match(Parser.COMMA) self.state = 1719 @@ -14636,71 +15923,63 @@ def valueDomainSignature(self): self.exitRule() return localctx - class CodeItemRelationContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.codetemRef = None # ValueDomainValueContext + self.codetemRef = None # ValueDomainValueContext - def codeItemRelationClause(self, i:int=None): + def codeItemRelationClause(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.CodeItemRelationClauseContext) else: - return self.getTypedRuleContext(Parser.CodeItemRelationClauseContext,i) - + return self.getTypedRuleContext(Parser.CodeItemRelationClauseContext, i) def valueDomainValue(self): - return self.getTypedRuleContext(Parser.ValueDomainValueContext,0) - + return self.getTypedRuleContext(Parser.ValueDomainValueContext, 0) def WHEN(self): return self.getToken(Parser.WHEN, 0) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) - + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def THEN(self): return self.getToken(Parser.THEN, 0) def comparisonOperand(self): - return self.getTypedRuleContext(Parser.ComparisonOperandContext,0) - + return self.getTypedRuleContext(Parser.ComparisonOperandContext, 0) def getRuleIndex(self): return Parser.RULE_codeItemRelation - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCodeItemRelation" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCodeItemRelation"): listener.enterCodeItemRelation(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCodeItemRelation" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCodeItemRelation"): listener.exitCodeItemRelation(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCodeItemRelation" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCodeItemRelation"): return visitor.visitCodeItemRelation(self) else: return visitor.visitChildren(self) - - - def codeItemRelation(self): localctx = Parser.CodeItemRelationContext(self, self._ctx, self.state) self.enterRule(localctx, 158, self.RULE_codeItemRelation) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1729 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.WHEN: + if _la == Parser.WHEN: self.state = 1725 self.match(Parser.WHEN) self.state = 1726 @@ -14708,23 +15987,46 @@ def codeItemRelation(self): self.state = 1727 self.match(Parser.THEN) - self.state = 1731 localctx.codetemRef = self.valueDomainValue() self.state = 1733 self._errHandler.sync(self) _la = self._input.LA(1) - if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.EQ) | (1 << Parser.LT) | (1 << Parser.MT) | (1 << Parser.ME) | (1 << Parser.NEQ) | (1 << Parser.LE))) != 0): + if ((_la) & ~0x3F) == 0 and ( + (1 << _la) + & ( + (1 << Parser.EQ) + | (1 << Parser.LT) + | (1 << Parser.MT) + | (1 << Parser.ME) + | (1 << Parser.NEQ) + | (1 << Parser.LE) + ) + ) != 0: self.state = 1732 self.comparisonOperand() - self.state = 1735 self.codeItemRelationClause() self.state = 1739 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.PLUS or _la==Parser.MINUS or ((((_la - 241)) & ~0x3f) == 0 and ((1 << (_la - 241)) & ((1 << (Parser.INTEGER_CONSTANT - 241)) | (1 << (Parser.NUMBER_CONSTANT - 241)) | (1 << (Parser.IDENTIFIER - 241)))) != 0): + while ( + _la == Parser.PLUS + or _la == Parser.MINUS + or ( + ((_la - 241) & ~0x3F) == 0 + and ( + (1 << (_la - 241)) + & ( + (1 << (Parser.INTEGER_CONSTANT - 241)) + | (1 << (Parser.NUMBER_CONSTANT - 241)) + | (1 << (Parser.IDENTIFIER - 241)) + ) + ) + != 0 + ) + ): self.state = 1736 self.codeItemRelationClause() self.state = 1741 @@ -14739,20 +16041,18 @@ def codeItemRelation(self): self.exitRule() return localctx - class CodeItemRelationClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - self.opAdd = None # Token - self.rightCodeItem = None # ValueDomainValueContext - self.rightCondition = None # ExprComponentContext + self.opAdd = None # Token + self.rightCodeItem = None # ValueDomainValueContext + self.rightCondition = None # ExprComponentContext def valueDomainValue(self): - return self.getTypedRuleContext(Parser.ValueDomainValueContext,0) - + return self.getTypedRuleContext(Parser.ValueDomainValueContext, 0) def QLPAREN(self): return self.getToken(Parser.QLPAREN, 0) @@ -14761,8 +16061,7 @@ def QRPAREN(self): return self.getToken(Parser.QRPAREN, 0) def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) - + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def PLUS(self): return self.getToken(Parser.PLUS, 0) @@ -14773,50 +16072,46 @@ def MINUS(self): def getRuleIndex(self): return Parser.RULE_codeItemRelationClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCodeItemRelationClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCodeItemRelationClause"): listener.enterCodeItemRelationClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCodeItemRelationClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCodeItemRelationClause"): listener.exitCodeItemRelationClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCodeItemRelationClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCodeItemRelationClause"): return visitor.visitCodeItemRelationClause(self) else: return visitor.visitChildren(self) - - - def codeItemRelationClause(self): localctx = Parser.CodeItemRelationClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 160, self.RULE_codeItemRelationClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1743 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.PLUS or _la==Parser.MINUS: + if _la == Parser.PLUS or _la == Parser.MINUS: self.state = 1742 localctx.opAdd = self._input.LT(1) _la = self._input.LA(1) - if not(_la==Parser.PLUS or _la==Parser.MINUS): + if not (_la == Parser.PLUS or _la == Parser.MINUS): localctx.opAdd = self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 1745 localctx.rightCodeItem = self.valueDomainValue() self.state = 1750 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.QLPAREN: + if _la == Parser.QLPAREN: self.state = 1746 self.match(Parser.QLPAREN) self.state = 1747 @@ -14824,7 +16119,6 @@ def codeItemRelationClause(self): self.state = 1748 self.match(Parser.QRPAREN) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -14833,11 +16127,10 @@ def codeItemRelationClause(self): self.exitRule() return localctx - class ValueDomainValueContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -14853,33 +16146,41 @@ def NUMBER_CONSTANT(self): def getRuleIndex(self): return Parser.RULE_valueDomainValue - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterValueDomainValue" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterValueDomainValue"): listener.enterValueDomainValue(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitValueDomainValue" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitValueDomainValue"): listener.exitValueDomainValue(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitValueDomainValue" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValueDomainValue"): return visitor.visitValueDomainValue(self) else: return visitor.visitChildren(self) - - - def valueDomainValue(self): localctx = Parser.ValueDomainValueContext(self, self._ctx, self.state) self.enterRule(localctx, 162, self.RULE_valueDomainValue) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1752 _la = self._input.LA(1) - if not(((((_la - 241)) & ~0x3f) == 0 and ((1 << (_la - 241)) & ((1 << (Parser.INTEGER_CONSTANT - 241)) | (1 << (Parser.NUMBER_CONSTANT - 241)) | (1 << (Parser.IDENTIFIER - 241)))) != 0)): + if not ( + ((_la - 241) & ~0x3F) == 0 + and ( + (1 << (_la - 241)) + & ( + (1 << (Parser.INTEGER_CONSTANT - 241)) + | (1 << (Parser.NUMBER_CONSTANT - 241)) + | (1 << (Parser.IDENTIFIER - 241)) + ) + ) + != 0 + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -14892,96 +16193,93 @@ def valueDomainValue(self): self.exitRule() return localctx - class ScalarTypeConstraintContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def getRuleIndex(self): return Parser.RULE_scalarTypeConstraint - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class RangeConstraintContext(ScalarTypeConstraintContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ScalarTypeConstraintContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ScalarTypeConstraintContext super().__init__(ANTLRParser) self.copyFrom(ctx) def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - def scalarItem(self, i:int=None): + + def scalarItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ScalarItemContext) else: - return self.getTypedRuleContext(Parser.ScalarItemContext,i) + return self.getTypedRuleContext(Parser.ScalarItemContext, i) def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - def COMMA(self, i:int=None): + + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: return self.getToken(Parser.COMMA, i) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRangeConstraint" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRangeConstraint"): listener.enterRangeConstraint(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRangeConstraint" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRangeConstraint"): listener.exitRangeConstraint(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRangeConstraint" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRangeConstraint"): return visitor.visitRangeConstraint(self) else: return visitor.visitChildren(self) - class ConditionConstraintContext(ScalarTypeConstraintContext): - - def __init__(self, ANTLRParser, ctx:ParserRuleContext): # actually a Parser.ScalarTypeConstraintContext + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ScalarTypeConstraintContext super().__init__(ANTLRParser) self.copyFrom(ctx) def QLPAREN(self): return self.getToken(Parser.QLPAREN, 0) + def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def QRPAREN(self): return self.getToken(Parser.QRPAREN, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterConditionConstraint" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConditionConstraint"): listener.enterConditionConstraint(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitConditionConstraint" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConditionConstraint"): listener.exitConditionConstraint(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitConditionConstraint" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConditionConstraint"): return visitor.visitConditionConstraint(self) else: return visitor.visitChildren(self) - - def scalarTypeConstraint(self): localctx = Parser.ScalarTypeConstraintContext(self, self._ctx, self.state) self.enterRule(localctx, 164, self.RULE_scalarTypeConstraint) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 1769 self._errHandler.sync(self) @@ -15006,7 +16304,7 @@ def scalarTypeConstraint(self): self.state = 1764 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1760 self.match(Parser.COMMA) self.state = 1761 @@ -15029,46 +16327,39 @@ def scalarTypeConstraint(self): self.exitRule() return localctx - class CompConstraintContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def componentType(self): - return self.getTypedRuleContext(Parser.ComponentTypeContext,0) - + return self.getTypedRuleContext(Parser.ComponentTypeContext, 0) def componentID(self): - return self.getTypedRuleContext(Parser.ComponentIDContext,0) - + return self.getTypedRuleContext(Parser.ComponentIDContext, 0) def multModifier(self): - return self.getTypedRuleContext(Parser.MultModifierContext,0) - + return self.getTypedRuleContext(Parser.MultModifierContext, 0) def getRuleIndex(self): return Parser.RULE_compConstraint - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterCompConstraint" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCompConstraint"): listener.enterCompConstraint(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitCompConstraint" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCompConstraint"): listener.exitCompConstraint(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitCompConstraint" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCompConstraint"): return visitor.visitCompConstraint(self) else: return visitor.visitChildren(self) - - - def compConstraint(self): localctx = Parser.CompConstraintContext(self, self._ctx, self.state) @@ -15099,11 +16390,10 @@ def compConstraint(self): self.exitRule() return localctx - class MultModifierContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15119,28 +16409,25 @@ def MUL(self): def getRuleIndex(self): return Parser.RULE_multModifier - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterMultModifier" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMultModifier"): listener.enterMultModifier(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitMultModifier" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMultModifier"): listener.exitMultModifier(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitMultModifier" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMultModifier"): return visitor.visitMultModifier(self) else: return visitor.visitChildren(self) - - - def multModifier(self): localctx = Parser.MultModifierContext(self, self._ctx, self.state) self.enterRule(localctx, 168, self.RULE_multModifier) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1776 @@ -15148,16 +16435,15 @@ def multModifier(self): self.state = 1778 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==Parser.PLUS or _la==Parser.MUL: + if _la == Parser.PLUS or _la == Parser.MUL: self.state = 1777 _la = self._input.LA(1) - if not(_la==Parser.PLUS or _la==Parser.MUL): + if not (_la == Parser.PLUS or _la == Parser.MUL): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -15166,11 +16452,10 @@ def multModifier(self): self.exitRule() return localctx - class ValidationOutputContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15186,33 +16471,30 @@ def ALL(self): def getRuleIndex(self): return Parser.RULE_validationOutput - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterValidationOutput" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterValidationOutput"): listener.enterValidationOutput(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitValidationOutput" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitValidationOutput"): listener.exitValidationOutput(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitValidationOutput" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidationOutput"): return visitor.visitValidationOutput(self) else: return visitor.visitChildren(self) - - - def validationOutput(self): localctx = Parser.ValidationOutputContext(self, self._ctx, self.state) self.enterRule(localctx, 170, self.RULE_validationOutput) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1780 _la = self._input.LA(1) - if not(_la==Parser.ALL or _la==Parser.INVALID or _la==Parser.ALL_MEASURES): + if not (_la == Parser.ALL or _la == Parser.INVALID or _la == Parser.ALL_MEASURES): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -15225,11 +16507,10 @@ def validationOutput(self): self.exitRule() return localctx - class ValidationModeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15254,33 +16535,44 @@ def ALWAYS_ZERO(self): def getRuleIndex(self): return Parser.RULE_validationMode - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterValidationMode" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterValidationMode"): listener.enterValidationMode(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitValidationMode" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitValidationMode"): listener.exitValidationMode(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitValidationMode" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidationMode"): return visitor.visitValidationMode(self) else: return visitor.visitChildren(self) - - - def validationMode(self): localctx = Parser.ValidationModeContext(self, self._ctx, self.state) self.enterRule(localctx, 172, self.RULE_validationMode) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1782 _la = self._input.LA(1) - if not(((((_la - 225)) & ~0x3f) == 0 and ((1 << (_la - 225)) & ((1 << (Parser.NON_NULL - 225)) | (1 << (Parser.NON_ZERO - 225)) | (1 << (Parser.PARTIAL_NULL - 225)) | (1 << (Parser.PARTIAL_ZERO - 225)) | (1 << (Parser.ALWAYS_NULL - 225)) | (1 << (Parser.ALWAYS_ZERO - 225)))) != 0)): + if not ( + ((_la - 225) & ~0x3F) == 0 + and ( + (1 << (_la - 225)) + & ( + (1 << (Parser.NON_NULL - 225)) + | (1 << (Parser.NON_ZERO - 225)) + | (1 << (Parser.PARTIAL_NULL - 225)) + | (1 << (Parser.PARTIAL_ZERO - 225)) + | (1 << (Parser.ALWAYS_NULL - 225)) + | (1 << (Parser.ALWAYS_ZERO - 225)) + ) + ) + != 0 + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -15293,25 +16585,23 @@ def validationMode(self): self.exitRule() return localctx - class ConditionClauseContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def CONDITION(self): return self.getToken(Parser.CONDITION, 0) - def componentID(self, i:int=None): + def componentID(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ComponentIDContext) else: - return self.getTypedRuleContext(Parser.ComponentIDContext,i) + return self.getTypedRuleContext(Parser.ComponentIDContext, i) - - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -15320,28 +16610,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_conditionClause - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterConditionClause" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConditionClause"): listener.enterConditionClause(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitConditionClause" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConditionClause"): listener.exitConditionClause(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitConditionClause" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConditionClause"): return visitor.visitConditionClause(self) else: return visitor.visitChildren(self) - - - def conditionClause(self): localctx = Parser.ConditionClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 174, self.RULE_conditionClause) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1784 @@ -15351,7 +16638,7 @@ def conditionClause(self): self.state = 1790 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1786 self.match(Parser.COMMA) self.state = 1787 @@ -15368,11 +16655,10 @@ def conditionClause(self): self.exitRule() return localctx - class InputModeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15385,33 +16671,30 @@ def DATASET_PRIORITY(self): def getRuleIndex(self): return Parser.RULE_inputMode - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInputMode" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInputMode"): listener.enterInputMode(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInputMode" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInputMode"): listener.exitInputMode(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInputMode" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInputMode"): return visitor.visitInputMode(self) else: return visitor.visitChildren(self) - - - def inputMode(self): localctx = Parser.InputModeContext(self, self._ctx, self.state) self.enterRule(localctx, 176, self.RULE_inputMode) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1793 _la = self._input.LA(1) - if not(_la==Parser.DATASET or _la==Parser.DATASET_PRIORITY): + if not (_la == Parser.DATASET or _la == Parser.DATASET_PRIORITY): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -15424,11 +16707,10 @@ def inputMode(self): self.exitRule() return localctx - class ImbalanceExprContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15436,29 +16718,25 @@ def IMBALANCE(self): return self.getToken(Parser.IMBALANCE, 0) def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) - + return self.getTypedRuleContext(Parser.ExprContext, 0) def getRuleIndex(self): return Parser.RULE_imbalanceExpr - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterImbalanceExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterImbalanceExpr"): listener.enterImbalanceExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitImbalanceExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitImbalanceExpr"): listener.exitImbalanceExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitImbalanceExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitImbalanceExpr"): return visitor.visitImbalanceExpr(self) else: return visitor.visitChildren(self) - - - def imbalanceExpr(self): localctx = Parser.ImbalanceExprContext(self, self._ctx, self.state) @@ -15477,11 +16755,10 @@ def imbalanceExpr(self): self.exitRule() return localctx - class InputModeHierarchyContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15497,33 +16774,30 @@ def RULE_PRIORITY(self): def getRuleIndex(self): return Parser.RULE_inputModeHierarchy - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInputModeHierarchy" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInputModeHierarchy"): listener.enterInputModeHierarchy(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInputModeHierarchy" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInputModeHierarchy"): listener.exitInputModeHierarchy(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInputModeHierarchy" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInputModeHierarchy"): return visitor.visitInputModeHierarchy(self) else: return visitor.visitChildren(self) - - - def inputModeHierarchy(self): localctx = Parser.InputModeHierarchyContext(self, self._ctx, self.state) self.enterRule(localctx, 180, self.RULE_inputModeHierarchy) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1798 _la = self._input.LA(1) - if not(_la==Parser.DATASET or _la==Parser.RULE or _la==Parser.RULE_PRIORITY): + if not (_la == Parser.DATASET or _la == Parser.RULE or _la == Parser.RULE_PRIORITY): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -15536,11 +16810,10 @@ def inputModeHierarchy(self): self.exitRule() return localctx - class OutputModeHierarchyContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15553,33 +16826,30 @@ def ALL(self): def getRuleIndex(self): return Parser.RULE_outputModeHierarchy - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOutputModeHierarchy" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOutputModeHierarchy"): listener.enterOutputModeHierarchy(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOutputModeHierarchy" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOutputModeHierarchy"): listener.exitOutputModeHierarchy(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOutputModeHierarchy" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOutputModeHierarchy"): return visitor.visitOutputModeHierarchy(self) else: return visitor.visitChildren(self) - - - def outputModeHierarchy(self): localctx = Parser.OutputModeHierarchyContext(self, self._ctx, self.state) self.enterRule(localctx, 182, self.RULE_outputModeHierarchy) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1800 _la = self._input.LA(1) - if not(_la==Parser.ALL or _la==Parser.COMPUTED): + if not (_la == Parser.ALL or _la == Parser.COMPUTED): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -15592,11 +16862,10 @@ def outputModeHierarchy(self): self.exitRule() return localctx - class AliasContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15606,23 +16875,20 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_alias - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterAlias" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAlias"): listener.enterAlias(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitAlias" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAlias"): listener.exitAlias(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitAlias" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAlias"): return visitor.visitAlias(self) else: return visitor.visitChildren(self) - - - def alias(self): localctx = Parser.AliasContext(self, self._ctx, self.state) @@ -15639,11 +16905,10 @@ def alias(self): self.exitRule() return localctx - class VarIDContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15653,23 +16918,20 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_varID - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVarID" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVarID"): listener.enterVarID(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVarID" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVarID"): listener.exitVarID(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVarID" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitVarID"): return visitor.visitVarID(self) else: return visitor.visitChildren(self) - - - def varID(self): localctx = Parser.VarIDContext(self, self._ctx, self.state) @@ -15686,11 +16948,10 @@ def varID(self): self.exitRule() return localctx - class SimpleComponentIdContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15700,23 +16961,20 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_simpleComponentId - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSimpleComponentId" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSimpleComponentId"): listener.enterSimpleComponentId(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSimpleComponentId" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSimpleComponentId"): listener.exitSimpleComponentId(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSimpleComponentId" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSimpleComponentId"): return visitor.visitSimpleComponentId(self) else: return visitor.visitChildren(self) - - - def simpleComponentId(self): localctx = Parser.SimpleComponentIdContext(self, self._ctx, self.state) @@ -15733,15 +16991,14 @@ def simpleComponentId(self): self.exitRule() return localctx - class ComponentIDContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser - def IDENTIFIER(self, i:int=None): + def IDENTIFIER(self, i: int = None): if i is None: return self.getTokens(Parser.IDENTIFIER) else: @@ -15753,23 +17010,20 @@ def MEMBERSHIP(self): def getRuleIndex(self): return Parser.RULE_componentID - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterComponentID" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterComponentID"): listener.enterComponentID(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitComponentID" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitComponentID"): listener.exitComponentID(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitComponentID" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComponentID"): return visitor.visitComponentID(self) else: return visitor.visitChildren(self) - - - def componentID(self): localctx = Parser.ComponentIDContext(self, self._ctx, self.state) @@ -15780,14 +17034,13 @@ def componentID(self): self.match(Parser.IDENTIFIER) self.state = 1811 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,191,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 191, self._ctx) if la_ == 1: self.state = 1809 self.match(Parser.MEMBERSHIP) self.state = 1810 self.match(Parser.IDENTIFIER) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -15796,28 +17049,26 @@ def componentID(self): self.exitRule() return localctx - class ListsContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def GLPAREN(self): return self.getToken(Parser.GLPAREN, 0) - def scalarItem(self, i:int=None): + def scalarItem(self, i: int = None): if i is None: return self.getTypedRuleContexts(Parser.ScalarItemContext) else: - return self.getTypedRuleContext(Parser.ScalarItemContext,i) - + return self.getTypedRuleContext(Parser.ScalarItemContext, i) def GRPAREN(self): return self.getToken(Parser.GRPAREN, 0) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(Parser.COMMA) else: @@ -15826,28 +17077,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return Parser.RULE_lists - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterLists" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterLists"): listener.enterLists(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitLists" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitLists"): listener.exitLists(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitLists" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitLists"): return visitor.visitLists(self) else: return visitor.visitChildren(self) - - - def lists(self): localctx = Parser.ListsContext(self, self._ctx, self.state) self.enterRule(localctx, 192, self.RULE_lists) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1813 @@ -15857,7 +17105,7 @@ def lists(self): self.state = 1819 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==Parser.COMMA: + while _la == Parser.COMMA: self.state = 1815 self.match(Parser.COMMA) self.state = 1816 @@ -15876,11 +17124,10 @@ def lists(self): self.exitRule() return localctx - class ErCodeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15888,29 +17135,25 @@ def ERRORCODE(self): return self.getToken(Parser.ERRORCODE, 0) def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext,0) - + return self.getTypedRuleContext(Parser.ConstantContext, 0) def getRuleIndex(self): return Parser.RULE_erCode - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterErCode" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterErCode"): listener.enterErCode(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitErCode" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitErCode"): listener.exitErCode(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitErCode" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitErCode"): return visitor.visitErCode(self) else: return visitor.visitChildren(self) - - - def erCode(self): localctx = Parser.ErCodeContext(self, self._ctx, self.state) @@ -15929,11 +17172,10 @@ def erCode(self): self.exitRule() return localctx - class ErLevelContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -15941,29 +17183,25 @@ def ERRORLEVEL(self): return self.getToken(Parser.ERRORLEVEL, 0) def constant(self): - return self.getTypedRuleContext(Parser.ConstantContext,0) - + return self.getTypedRuleContext(Parser.ConstantContext, 0) def getRuleIndex(self): return Parser.RULE_erLevel - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterErLevel" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterErLevel"): listener.enterErLevel(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitErLevel" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitErLevel"): listener.exitErLevel(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitErLevel" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitErLevel"): return visitor.visitErLevel(self) else: return visitor.visitChildren(self) - - - def erLevel(self): localctx = Parser.ErLevelContext(self, self._ctx, self.state) @@ -15982,11 +17220,10 @@ def erLevel(self): self.exitRule() return localctx - class ComparisonOperandContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16011,33 +17248,44 @@ def NEQ(self): def getRuleIndex(self): return Parser.RULE_comparisonOperand - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterComparisonOperand" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterComparisonOperand"): listener.enterComparisonOperand(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitComparisonOperand" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitComparisonOperand"): listener.exitComparisonOperand(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitComparisonOperand" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComparisonOperand"): return visitor.visitComparisonOperand(self) else: return visitor.visitChildren(self) - - - def comparisonOperand(self): localctx = Parser.ComparisonOperandContext(self, self._ctx, self.state) self.enterRule(localctx, 198, self.RULE_comparisonOperand) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1830 _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Parser.EQ) | (1 << Parser.LT) | (1 << Parser.MT) | (1 << Parser.ME) | (1 << Parser.NEQ) | (1 << Parser.LE))) != 0)): + if not ( + ((_la) & ~0x3F) == 0 + and ( + (1 << _la) + & ( + (1 << Parser.EQ) + | (1 << Parser.LT) + | (1 << Parser.MT) + | (1 << Parser.ME) + | (1 << Parser.NEQ) + | (1 << Parser.LE) + ) + ) + != 0 + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -16050,17 +17298,15 @@ def comparisonOperand(self): self.exitRule() return localctx - class OptionalExprContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def expr(self): - return self.getTypedRuleContext(Parser.ExprContext,0) - + return self.getTypedRuleContext(Parser.ExprContext, 0) def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) @@ -16068,23 +17314,20 @@ def OPTIONAL(self): def getRuleIndex(self): return Parser.RULE_optionalExpr - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOptionalExpr" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOptionalExpr"): listener.enterOptionalExpr(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOptionalExpr" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOptionalExpr"): listener.exitOptionalExpr(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOptionalExpr" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOptionalExpr"): return visitor.visitOptionalExpr(self) else: return visitor.visitChildren(self) - - - def optionalExpr(self): localctx = Parser.OptionalExprContext(self, self._ctx, self.state) @@ -16093,7 +17336,92 @@ def optionalExpr(self): self.state = 1834 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF, Parser.CASE, Parser.CURRENT_DATE, Parser.DATEDIFF, Parser.DATEADD, Parser.YEAR_OP, Parser.MONTH_OP, Parser.DAYOFMONTH, Parser.DAYOFYEAR, Parser.DAYTOYEAR, Parser.DAYTOMONTH, Parser.YEARTODAY, Parser.MONTHTODAY, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT, Parser.ISNULL, Parser.UNION, Parser.SYMDIFF, Parser.INTERSECT, Parser.RANDOM, Parser.CHECK, Parser.EXISTS_IN, Parser.MIN, Parser.MAX, Parser.ABS, Parser.LN, Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER, Parser.MOD, Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.SUBSTR, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.EXP, Parser.CHARSET_MATCH, Parser.NVL, Parser.HIERARCHY, Parser.LTRIM, Parser.RTRIM, Parser.INSTR, Parser.REPLACE, Parser.CEIL, Parser.FLOOR, Parser.SQRT, Parser.SETDIFF, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT, Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW, Parser.TIMESHIFT, Parser.INNER_JOIN, Parser.LEFT_JOIN, Parser.CROSS_JOIN, Parser.FULL_JOIN, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST, Parser.CHECK_DATAPOINT, Parser.CHECK_HIERARCHY, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT, Parser.IDENTIFIER]: + if token in [ + Parser.LPAREN, + Parser.PLUS, + Parser.MINUS, + Parser.EVAL, + Parser.IF, + Parser.CASE, + Parser.CURRENT_DATE, + Parser.DATEDIFF, + Parser.DATEADD, + Parser.YEAR_OP, + Parser.MONTH_OP, + Parser.DAYOFMONTH, + Parser.DAYOFYEAR, + Parser.DAYTOYEAR, + Parser.DAYTOMONTH, + Parser.YEARTODAY, + Parser.MONTHTODAY, + Parser.NOT, + Parser.BETWEEN, + Parser.NULL_CONSTANT, + Parser.ISNULL, + Parser.UNION, + Parser.SYMDIFF, + Parser.INTERSECT, + Parser.RANDOM, + Parser.CHECK, + Parser.EXISTS_IN, + Parser.MIN, + Parser.MAX, + Parser.ABS, + Parser.LN, + Parser.LOG, + Parser.TRUNC, + Parser.ROUND, + Parser.POWER, + Parser.MOD, + Parser.LEN, + Parser.TRIM, + Parser.UCASE, + Parser.LCASE, + Parser.SUBSTR, + Parser.SUM, + Parser.AVG, + Parser.MEDIAN, + Parser.COUNT, + Parser.EXP, + Parser.CHARSET_MATCH, + Parser.NVL, + Parser.HIERARCHY, + Parser.LTRIM, + Parser.RTRIM, + Parser.INSTR, + Parser.REPLACE, + Parser.CEIL, + Parser.FLOOR, + Parser.SQRT, + Parser.SETDIFF, + Parser.STDDEV_POP, + Parser.STDDEV_SAMP, + Parser.VAR_POP, + Parser.VAR_SAMP, + Parser.FIRST_VALUE, + Parser.LAST_VALUE, + Parser.LAG, + Parser.LEAD, + Parser.RATIO_TO_REPORT, + Parser.FILL_TIME_SERIES, + Parser.FLOW_TO_STOCK, + Parser.STOCK_TO_FLOW, + Parser.TIMESHIFT, + Parser.INNER_JOIN, + Parser.LEFT_JOIN, + Parser.CROSS_JOIN, + Parser.FULL_JOIN, + Parser.PERIOD_INDICATOR, + Parser.TIME_AGG, + Parser.CAST, + Parser.CHECK_DATAPOINT, + Parser.CHECK_HIERARCHY, + Parser.INTEGER_CONSTANT, + Parser.NUMBER_CONSTANT, + Parser.BOOLEAN_CONSTANT, + Parser.STRING_CONSTANT, + Parser.IDENTIFIER, + ]: self.enterOuterAlt(localctx, 1) self.state = 1832 self.expr(0) @@ -16114,17 +17442,15 @@ def optionalExpr(self): self.exitRule() return localctx - class OptionalExprComponentContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser def exprComponent(self): - return self.getTypedRuleContext(Parser.ExprComponentContext,0) - + return self.getTypedRuleContext(Parser.ExprComponentContext, 0) def OPTIONAL(self): return self.getToken(Parser.OPTIONAL, 0) @@ -16132,23 +17458,20 @@ def OPTIONAL(self): def getRuleIndex(self): return Parser.RULE_optionalExprComponent - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOptionalExprComponent" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOptionalExprComponent"): listener.enterOptionalExprComponent(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOptionalExprComponent" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOptionalExprComponent"): listener.exitOptionalExprComponent(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOptionalExprComponent" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOptionalExprComponent"): return visitor.visitOptionalExprComponent(self) else: return visitor.visitChildren(self) - - - def optionalExprComponent(self): localctx = Parser.OptionalExprComponentContext(self, self._ctx, self.state) @@ -16157,7 +17480,80 @@ def optionalExprComponent(self): self.state = 1838 self._errHandler.sync(self) token = self._input.LA(1) - if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF, Parser.CASE, Parser.CURRENT_DATE, Parser.DATEDIFF, Parser.DATEADD, Parser.YEAR_OP, Parser.MONTH_OP, Parser.DAYOFMONTH, Parser.DAYOFYEAR, Parser.DAYTOYEAR, Parser.DAYTOMONTH, Parser.YEARTODAY, Parser.MONTHTODAY, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT, Parser.ISNULL, Parser.RANDOM, Parser.RANK, Parser.MIN, Parser.MAX, Parser.ABS, Parser.LN, Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER, Parser.MOD, Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.SUBSTR, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.EXP, Parser.CHARSET_MATCH, Parser.NVL, Parser.LTRIM, Parser.RTRIM, Parser.INSTR, Parser.REPLACE, Parser.CEIL, Parser.FLOOR, Parser.SQRT, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT, Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW, Parser.TIMESHIFT, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT, Parser.IDENTIFIER]: + if token in [ + Parser.LPAREN, + Parser.PLUS, + Parser.MINUS, + Parser.EVAL, + Parser.IF, + Parser.CASE, + Parser.CURRENT_DATE, + Parser.DATEDIFF, + Parser.DATEADD, + Parser.YEAR_OP, + Parser.MONTH_OP, + Parser.DAYOFMONTH, + Parser.DAYOFYEAR, + Parser.DAYTOYEAR, + Parser.DAYTOMONTH, + Parser.YEARTODAY, + Parser.MONTHTODAY, + Parser.NOT, + Parser.BETWEEN, + Parser.NULL_CONSTANT, + Parser.ISNULL, + Parser.RANDOM, + Parser.RANK, + Parser.MIN, + Parser.MAX, + Parser.ABS, + Parser.LN, + Parser.LOG, + Parser.TRUNC, + Parser.ROUND, + Parser.POWER, + Parser.MOD, + Parser.LEN, + Parser.TRIM, + Parser.UCASE, + Parser.LCASE, + Parser.SUBSTR, + Parser.SUM, + Parser.AVG, + Parser.MEDIAN, + Parser.COUNT, + Parser.EXP, + Parser.CHARSET_MATCH, + Parser.NVL, + Parser.LTRIM, + Parser.RTRIM, + Parser.INSTR, + Parser.REPLACE, + Parser.CEIL, + Parser.FLOOR, + Parser.SQRT, + Parser.STDDEV_POP, + Parser.STDDEV_SAMP, + Parser.VAR_POP, + Parser.VAR_SAMP, + Parser.FIRST_VALUE, + Parser.LAST_VALUE, + Parser.LAG, + Parser.LEAD, + Parser.RATIO_TO_REPORT, + Parser.FILL_TIME_SERIES, + Parser.FLOW_TO_STOCK, + Parser.STOCK_TO_FLOW, + Parser.TIMESHIFT, + Parser.PERIOD_INDICATOR, + Parser.TIME_AGG, + Parser.CAST, + Parser.INTEGER_CONSTANT, + Parser.NUMBER_CONSTANT, + Parser.BOOLEAN_CONSTANT, + Parser.STRING_CONSTANT, + Parser.IDENTIFIER, + ]: self.enterOuterAlt(localctx, 1) self.state = 1836 self.exprComponent(0) @@ -16178,11 +17574,10 @@ def optionalExprComponent(self): self.exitRule() return localctx - class ComponentRoleContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16199,29 +17594,25 @@ def ATTRIBUTE(self): return self.getToken(Parser.ATTRIBUTE, 0) def viralAttribute(self): - return self.getTypedRuleContext(Parser.ViralAttributeContext,0) - + return self.getTypedRuleContext(Parser.ViralAttributeContext, 0) def getRuleIndex(self): return Parser.RULE_componentRole - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterComponentRole" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterComponentRole"): listener.enterComponentRole(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitComponentRole" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitComponentRole"): listener.exitComponentRole(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitComponentRole" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComponentRole"): return visitor.visitComponentRole(self) else: return visitor.visitChildren(self) - - - def componentRole(self): localctx = Parser.ComponentRoleContext(self, self._ctx, self.state) @@ -16266,11 +17657,10 @@ def componentRole(self): self.exitRule() return localctx - class ViralAttributeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16283,23 +17673,20 @@ def ATTRIBUTE(self): def getRuleIndex(self): return Parser.RULE_viralAttribute - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterViralAttribute" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterViralAttribute"): listener.enterViralAttribute(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitViralAttribute" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitViralAttribute"): listener.exitViralAttribute(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitViralAttribute" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitViralAttribute"): return visitor.visitViralAttribute(self) else: return visitor.visitChildren(self) - - - def viralAttribute(self): localctx = Parser.ViralAttributeContext(self, self._ctx, self.state) @@ -16318,11 +17705,10 @@ def viralAttribute(self): self.exitRule() return localctx - class ValueDomainIDContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16332,23 +17718,20 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_valueDomainID - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterValueDomainID" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterValueDomainID"): listener.enterValueDomainID(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitValueDomainID" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitValueDomainID"): listener.exitValueDomainID(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitValueDomainID" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValueDomainID"): return visitor.visitValueDomainID(self) else: return visitor.visitChildren(self) - - - def valueDomainID(self): localctx = Parser.ValueDomainIDContext(self, self._ctx, self.state) @@ -16365,11 +17748,10 @@ def valueDomainID(self): self.exitRule() return localctx - class OperatorIDContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16379,23 +17761,20 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_operatorID - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOperatorID" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOperatorID"): listener.enterOperatorID(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOperatorID" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOperatorID"): listener.exitOperatorID(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOperatorID" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOperatorID"): return visitor.visitOperatorID(self) else: return visitor.visitChildren(self) - - - def operatorID(self): localctx = Parser.OperatorIDContext(self, self._ctx, self.state) @@ -16412,11 +17791,10 @@ def operatorID(self): self.exitRule() return localctx - class RoutineNameContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16426,23 +17804,20 @@ def IDENTIFIER(self): def getRuleIndex(self): return Parser.RULE_routineName - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRoutineName" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRoutineName"): listener.enterRoutineName(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRoutineName" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRoutineName"): listener.exitRoutineName(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRoutineName" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRoutineName"): return visitor.visitRoutineName(self) else: return visitor.visitChildren(self) - - - def routineName(self): localctx = Parser.RoutineNameContext(self, self._ctx, self.state) @@ -16459,11 +17834,10 @@ def routineName(self): self.exitRule() return localctx - class ConstantContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16485,33 +17859,45 @@ def NULL_CONSTANT(self): def getRuleIndex(self): return Parser.RULE_constant - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterConstant" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConstant"): listener.enterConstant(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitConstant" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConstant"): listener.exitConstant(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitConstant" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConstant"): return visitor.visitConstant(self) else: return visitor.visitChildren(self) - - - def constant(self): localctx = Parser.ConstantContext(self, self._ctx, self.state) self.enterRule(localctx, 214, self.RULE_constant) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1856 _la = self._input.LA(1) - if not(_la==Parser.NULL_CONSTANT or ((((_la - 241)) & ~0x3f) == 0 and ((1 << (_la - 241)) & ((1 << (Parser.INTEGER_CONSTANT - 241)) | (1 << (Parser.NUMBER_CONSTANT - 241)) | (1 << (Parser.BOOLEAN_CONSTANT - 241)) | (1 << (Parser.STRING_CONSTANT - 241)))) != 0)): + if not ( + _la == Parser.NULL_CONSTANT + or ( + ((_la - 241) & ~0x3F) == 0 + and ( + (1 << (_la - 241)) + & ( + (1 << (Parser.INTEGER_CONSTANT - 241)) + | (1 << (Parser.NUMBER_CONSTANT - 241)) + | (1 << (Parser.BOOLEAN_CONSTANT - 241)) + | (1 << (Parser.STRING_CONSTANT - 241)) + ) + ) + != 0 + ) + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -16524,11 +17910,10 @@ def constant(self): self.exitRule() return localctx - class BasicScalarTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16562,33 +17947,49 @@ def SCALAR(self): def getRuleIndex(self): return Parser.RULE_basicScalarType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBasicScalarType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBasicScalarType"): listener.enterBasicScalarType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBasicScalarType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBasicScalarType"): listener.exitBasicScalarType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBasicScalarType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBasicScalarType"): return visitor.visitBasicScalarType(self) else: return visitor.visitChildren(self) - - - def basicScalarType(self): localctx = Parser.BasicScalarTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 216, self.RULE_basicScalarType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1858 _la = self._input.LA(1) - if not(((((_la - 168)) & ~0x3f) == 0 and ((1 << (_la - 168)) & ((1 << (Parser.BOOLEAN - 168)) | (1 << (Parser.DATE - 168)) | (1 << (Parser.TIME_PERIOD - 168)) | (1 << (Parser.NUMBER - 168)) | (1 << (Parser.STRING - 168)) | (1 << (Parser.TIME - 168)) | (1 << (Parser.INTEGER - 168)) | (1 << (Parser.DURATION - 168)))) != 0) or _la==Parser.SCALAR): + if not ( + ( + ((_la - 168) & ~0x3F) == 0 + and ( + (1 << (_la - 168)) + & ( + (1 << (Parser.BOOLEAN - 168)) + | (1 << (Parser.DATE - 168)) + | (1 << (Parser.TIME_PERIOD - 168)) + | (1 << (Parser.NUMBER - 168)) + | (1 << (Parser.STRING - 168)) + | (1 << (Parser.TIME - 168)) + | (1 << (Parser.INTEGER - 168)) + | (1 << (Parser.DURATION - 168)) + ) + ) + != 0 + ) + or _la == Parser.SCALAR + ): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -16601,11 +18002,10 @@ def basicScalarType(self): self.exitRule() return localctx - class RetainTypeContext(ParserRuleContext): __slots__ = "ANTLRParser" - def __init__(self, ANTLRParser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__(self, ANTLRParser, parent: ParserRuleContext = None, invokingState: int = -1): super().__init__(parent, invokingState) self.ANTLRParser = ANTLRParser @@ -16618,33 +18018,30 @@ def ALL(self): def getRuleIndex(self): return Parser.RULE_retainType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterRetainType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRetainType"): listener.enterRetainType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitRetainType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRetainType"): listener.exitRetainType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitRetainType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRetainType"): return visitor.visitRetainType(self) else: return visitor.visitChildren(self) - - - def retainType(self): localctx = Parser.RetainTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 218, self.RULE_retainType) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 1860 _la = self._input.LA(1) - if not(_la==Parser.ALL or _la==Parser.BOOLEAN_CONSTANT): + if not (_la == Parser.ALL or _la == Parser.BOOLEAN_CONSTANT): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -16657,9 +18054,7 @@ def retainType(self): self.exitRule() return localctx - - - def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): + def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int): if self._predicates == None: self._predicates = dict() self._predicates[2] = self.expr_sempred @@ -16670,64 +18065,46 @@ def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): else: return pred(localctx, predIndex) - def expr_sempred(self, localctx:ExprContext, predIndex:int): - if predIndex == 0: - return self.precpred(self._ctx, 10) - - - if predIndex == 1: - return self.precpred(self._ctx, 9) - - - if predIndex == 2: - return self.precpred(self._ctx, 8) - - - if predIndex == 3: - return self.precpred(self._ctx, 6) - - - if predIndex == 4: - return self.precpred(self._ctx, 5) - + def expr_sempred(self, localctx: ExprContext, predIndex: int): + if predIndex == 0: + return self.precpred(self._ctx, 10) - if predIndex == 5: - return self.precpred(self._ctx, 13) - + if predIndex == 1: + return self.precpred(self._ctx, 9) - if predIndex == 6: - return self.precpred(self._ctx, 12) - + if predIndex == 2: + return self.precpred(self._ctx, 8) - if predIndex == 7: - return self.precpred(self._ctx, 7) - + if predIndex == 3: + return self.precpred(self._ctx, 6) - def exprComponent_sempred(self, localctx:ExprComponentContext, predIndex:int): - if predIndex == 8: - return self.precpred(self._ctx, 10) - + if predIndex == 4: + return self.precpred(self._ctx, 5) - if predIndex == 9: - return self.precpred(self._ctx, 9) - + if predIndex == 5: + return self.precpred(self._ctx, 13) - if predIndex == 10: - return self.precpred(self._ctx, 8) - + if predIndex == 6: + return self.precpred(self._ctx, 12) - if predIndex == 11: - return self.precpred(self._ctx, 6) - + if predIndex == 7: + return self.precpred(self._ctx, 7) - if predIndex == 12: - return self.precpred(self._ctx, 5) - + def exprComponent_sempred(self, localctx: ExprComponentContext, predIndex: int): + if predIndex == 8: + return self.precpred(self._ctx, 10) - if predIndex == 13: - return self.precpred(self._ctx, 7) - + if predIndex == 9: + return self.precpred(self._ctx, 9) + if predIndex == 10: + return self.precpred(self._ctx, 8) + if predIndex == 11: + return self.precpred(self._ctx, 6) + if predIndex == 12: + return self.precpred(self._ctx, 5) + if predIndex == 13: + return self.precpred(self._ctx, 7) diff --git a/tests/Cast/test_cast.py b/tests/Cast/test_cast.py index 52f30d86d..0c15e57fd 100644 --- a/tests/Cast/test_cast.py +++ b/tests/Cast/test_cast.py @@ -65,7 +65,7 @@ def test_GH_537_1(self): """ code = "GH_537_1" number_inputs = 1 - reference_names = ["1", "2"] + reference_names = ["1"] self.BaseTest(code, number_inputs, references_names=reference_names) From 9a778654877b06be06137dac135509fe0ab073e4 Mon Sep 17 00:00:00 2001 From: Mateo Date: Thu, 26 Feb 2026 13:27:40 +0100 Subject: [PATCH 09/10] Fixed mypy errors --- src/vtlengine/AST/Grammar/parser.py | 6 ++++-- src/vtlengine/Operators/Numeric.py | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/vtlengine/AST/Grammar/parser.py b/src/vtlengine/AST/Grammar/parser.py index 3509a55c8..d1b074ba6 100644 --- a/src/vtlengine/AST/Grammar/parser.py +++ b/src/vtlengine/AST/Grammar/parser.py @@ -1,5 +1,7 @@ # Generated from Vtl.g4 by ANTLR 4.9.3 # encoding: utf-8 +from typing import Any + from antlr4 import * from antlr4 import Parser as ANTLRParser from io import StringIO @@ -8,7 +10,7 @@ if sys.version_info[1] > 5: from typing import TextIO else: - from typing.io import TextIO + from typing.io import TextIO # type: ignore def serializedATN(): @@ -2015,7 +2017,7 @@ def accept(self, visitor: ParseTreeVisitor): else: return visitor.visitChildren(self) - def start(self): + def start(self) -> Any: localctx = Parser.StartContext(self, self._ctx, self.state) self.enterRule(localctx, 0, self.RULE_start) diff --git a/src/vtlengine/Operators/Numeric.py b/src/vtlengine/Operators/Numeric.py index a8c1f6847..5e9b4eb2a 100644 --- a/src/vtlengine/Operators/Numeric.py +++ b/src/vtlengine/Operators/Numeric.py @@ -47,7 +47,7 @@ def apply_operation_component(cls, series: Any) -> Any: if cls.pc_func is not None: arr = series.values._pa_array return pd.Series( - pd.arrays.ArrowExtensionArray(cls.pc_func(arr)), # type: ignore[attr-defined] + pd.arrays.ArrowExtensionArray(cls.pc_func(arr)), index=series.index, ) return super().apply_operation_component(series) From d47255a12a041d7f687c2090d668af233d66cc58 Mon Sep 17 00:00:00 2001 From: Mateo Date: Thu, 26 Feb 2026 13:33:57 +0100 Subject: [PATCH 10/10] Minor fix --- src/vtlengine/Operators/Numeric.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/vtlengine/Operators/Numeric.py b/src/vtlengine/Operators/Numeric.py index 5e9b4eb2a..e748ef969 100644 --- a/src/vtlengine/Operators/Numeric.py +++ b/src/vtlengine/Operators/Numeric.py @@ -47,7 +47,7 @@ def apply_operation_component(cls, series: Any) -> Any: if cls.pc_func is not None: arr = series.values._pa_array return pd.Series( - pd.arrays.ArrowExtensionArray(cls.pc_func(arr)), + pd.arrays.ArrowExtensionArray(cls.pc_func(arr)), # type: ignore[attr-defined,unused-ignore] index=series.index, ) return super().apply_operation_component(series)