diff --git a/extensions/unsigned_integers.yaml b/extensions/unsigned_integers.yaml new file mode 100644 index 000000000..a183a8103 --- /dev/null +++ b/extensions/unsigned_integers.yaml @@ -0,0 +1,309 @@ +%YAML 1.2 +--- +urn: "extension:io.substrait:unsigned_integers" + +types: + - name: u8 + description: > + Unsigned 8-bit integer (0 to 255). + Values are encoded as decimal strings in the structure representation. + structure: + value: str + - name: u16 + description: > + Unsigned 16-bit integer (0 to 65535). + Values are encoded as decimal strings in the structure representation. + structure: + value: str + - name: u32 + description: > + Unsigned 32-bit integer (0 to 4294967295). + Values are encoded as decimal strings in the structure representation. + structure: + value: str + - name: u64 + description: > + Unsigned 64-bit integer (0 to 18446744073709551615). + Values are encoded as decimal strings in the structure representation. + structure: + value: str + +scalar_functions: + - + name: "add" + description: "Add two unsigned integer values." + impls: + - args: + - name: x + value: u!u8 + - name: y + value: u!u8 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u8 + - args: + - name: x + value: u!u16 + - name: y + value: u!u16 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u16 + - args: + - name: x + value: u!u32 + - name: y + value: u!u32 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u32 + - args: + - name: x + value: u!u64 + - name: y + value: u!u64 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u64 + - + name: "subtract" + description: "Subtract one unsigned integer value from another." + impls: + - args: + - name: x + value: u!u8 + - name: y + value: u!u8 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u8 + - args: + - name: x + value: u!u16 + - name: y + value: u!u16 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u16 + - args: + - name: x + value: u!u32 + - name: y + value: u!u32 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u32 + - args: + - name: x + value: u!u64 + - name: y + value: u!u64 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u64 + - + name: "multiply" + description: "Multiply two unsigned integer values." + impls: + - args: + - name: x + value: u!u8 + - name: y + value: u!u8 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u8 + - args: + - name: x + value: u!u16 + - name: y + value: u!u16 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u16 + - args: + - name: x + value: u!u32 + - name: y + value: u!u32 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u32 + - args: + - name: x + value: u!u64 + - name: y + value: u!u64 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u64 + - + name: "divide" + description: > + Divide x by y. Partial values are truncated (i.e. rounded towards 0). + The `on_division_by_zero` option governs behavior in cases where y is 0. + If either x or y are out of range, behavior will be governed by `on_domain_error`. + impls: + - args: + - name: x + value: u!u8 + - name: y + value: u!u8 + options: + on_domain_error: + values: [ "NULL", ERROR ] + on_division_by_zero: + values: [ "NULL", ERROR ] + return: u!u8 + - args: + - name: x + value: u!u16 + - name: y + value: u!u16 + options: + on_domain_error: + values: [ "NULL", ERROR ] + on_division_by_zero: + values: [ "NULL", ERROR ] + return: u!u16 + - args: + - name: x + value: u!u32 + - name: y + value: u!u32 + options: + on_domain_error: + values: [ "NULL", ERROR ] + on_division_by_zero: + values: [ "NULL", ERROR ] + return: u!u32 + - args: + - name: x + value: u!u64 + - name: y + value: u!u64 + options: + on_domain_error: + values: [ "NULL", ERROR ] + on_division_by_zero: + values: [ "NULL", ERROR ] + return: u!u64 + +aggregate_functions: + - name: "sum" + description: Sum a set of unsigned integer values. The sum of zero elements yields null. + impls: + - args: + - name: x + value: u!u8 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? + - args: + - name: x + value: u!u16 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? + - args: + - name: x + value: u!u32 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? + - args: + - name: x + value: u!u64 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? + - name: "min" + description: Min of a set of unsigned integer values. + impls: + - args: + - name: x + value: u!u8 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u8? + return: u!u8? + - args: + - name: x + value: u!u16 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u16? + return: u!u16? + - args: + - name: x + value: u!u32 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u32? + return: u!u32? + - args: + - name: x + value: u!u64 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? + - name: "max" + description: Max of a set of unsigned integer values. + impls: + - args: + - name: x + value: u!u8 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u8? + return: u!u8? + - args: + - name: x + value: u!u16 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u16? + return: u!u16? + - args: + - name: x + value: u!u32 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u32? + return: u!u32? + - args: + - name: x + value: u!u64 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? diff --git a/grammar/FuncTestCaseParser.g4 b/grammar/FuncTestCaseParser.g4 index 1139d4166..bc41dcfc3 100644 --- a/grammar/FuncTestCaseParser.g4 +++ b/grammar/FuncTestCaseParser.g4 @@ -48,7 +48,8 @@ result ; argument - : nullArg + : udtArg + | nullArg | enumArg | intArg | floatArg @@ -217,6 +218,10 @@ lambdaArg : literalLambda DoubleColon funcType ; +udtArg + : literal DoubleColon UserDefined Identifier isnull=QMark? + ; + enumArg : Identifier DoubleColon EnumType ; diff --git a/site/docs/extensions/generate_function_docs.py b/site/docs/extensions/generate_function_docs.py index c92b4096b..5ef5070ad 100644 --- a/site/docs/extensions/generate_function_docs.py +++ b/site/docs/extensions/generate_function_docs.py @@ -21,7 +21,7 @@ def write_markdown(file_obj: dict, file_name: str) -> None: mdFile.new_line(f"{key}: {value}") for function_classification, value in file_obj.items(): - if function_classification == "urn": + if function_classification in ("urn", "dependencies"): continue function_classification_str = function_classification.replace("_", " ").title() mdFile.new_header(level=2, title=f"{function_classification_str}") diff --git a/tests/baseline.json b/tests/baseline.json index 3d5441246..41e73bb25 100644 --- a/tests/baseline.json +++ b/tests/baseline.json @@ -1,16 +1,16 @@ { "registry": { - "extension_count": 15, - "dependency_count": 15, - "function_count": 173, - "num_aggregate_functions": 28, - "num_scalar_functions": 170, + "extension_count": 16, + "dependency_count": 18, + "function_count": 174, + "num_aggregate_functions": 31, + "num_scalar_functions": 174, "num_window_functions": 11, - "num_function_overloads": 533 + "num_function_overloads": 565 }, "coverage": { - "total_test_count": 1168, - "num_function_variants": 533, - "num_covered_function_variants": 245 + "total_test_count": 1297, + "num_function_variants": 565, + "num_covered_function_variants": 277 } } diff --git a/tests/cases/arithmetic_unsigned/add.test b/tests/cases/arithmetic_unsigned/add.test new file mode 100644 index 000000000..eabd2268d --- /dev/null +++ b/tests/cases/arithmetic_unsigned/add.test @@ -0,0 +1,16 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +add('200'::u!u8, '50'::u!u8) = '250'::u!u8 +add('50000'::u!u16, '10000'::u!u16) = '60000'::u!u16 +add('3000000000'::u!u32, '1000000000'::u!u32) = '4000000000'::u!u32 +add('10000000000000000000'::u!u64, '1000000000000000000'::u!u64) = '11000000000000000000'::u!u64 + +# overflow: Examples demonstrating overflow behavior +add('200'::u!u8, '100'::u!u8) [overflow:ERROR] = +add('60000'::u!u16, '10000'::u!u16) [overflow:ERROR] = +add('4000000000'::u!u32, '1000000000'::u!u32) [overflow:ERROR] = +add('18446744073709551615'::u!u64, '1'::u!u64) [overflow:ERROR] = +add('200'::u!u8, '100'::u!u8) [overflow:SATURATE] = '255'::u!u8 +add('200'::u!u8, '100'::u!u8) [overflow:SILENT] = diff --git a/tests/cases/arithmetic_unsigned/divide.test b/tests/cases/arithmetic_unsigned/divide.test new file mode 100644 index 000000000..22be0983a --- /dev/null +++ b/tests/cases/arithmetic_unsigned/divide.test @@ -0,0 +1,12 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +divide('250'::u!u8, '5'::u!u8) = '50'::u!u8 +divide('60000'::u!u16, '100'::u!u16) = '600'::u!u16 +divide('4000000000'::u!u32, '200'::u!u32) = '20000000'::u!u32 +divide('10000000000000000000'::u!u64, '5000'::u!u64) = '2000000000000000'::u!u64 + +# division_by_zero: Examples demonstrating division by zero +divide('5'::u!u8, '0'::u!u8) [on_division_by_zero:NULL] = null::u!u8 +divide('5'::u!u8, '0'::u!u8) [on_division_by_zero:ERROR] = diff --git a/tests/cases/arithmetic_unsigned/max.test b/tests/cases/arithmetic_unsigned/max.test new file mode 100644 index 000000000..5419890e3 --- /dev/null +++ b/tests/cases/arithmetic_unsigned/max.test @@ -0,0 +1,13 @@ +### SUBSTRAIT_AGGREGATE_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +max(('20', '3', '1', '10', '0', '5')::u!u8) = '20'::u!u8? +max(('32768', '32767', '20000', '30000')::u!u16) = '32768'::u!u16? +max(('214748648', '214748647', '21470048', '4000000')::u!u32) = '214748648'::u!u32? +max(('2000000000', '3217908979', '629000000', '100000000', '0', '987654321')::u!u64) = '3217908979'::u!u64? + +# null_handling: Examples with null as input or output +max((Null, Null, Null)::u!u16) = Null::u!u16? +max(()::u!u16) = Null::u!u16? +max(('200', Null, '50', '100', Null, '5')::u!u64) = '200'::u!u64? diff --git a/tests/cases/arithmetic_unsigned/min.test b/tests/cases/arithmetic_unsigned/min.test new file mode 100644 index 000000000..e572a367d --- /dev/null +++ b/tests/cases/arithmetic_unsigned/min.test @@ -0,0 +1,13 @@ +### SUBSTRAIT_AGGREGATE_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +min(('20', '3', '1', '10', '0', '5')::u!u8) = '0'::u!u8? +min(('32768', '32767', '20000', '30000')::u!u16) = '20000'::u!u16? +min(('214748648', '214748647', '21470048', '4000000')::u!u32) = '4000000'::u!u32? +min(('2000000000', '3217908979', '629000000', '100000000', '0', '987654321')::u!u64) = '0'::u!u64? + +# null_handling: Examples with null as input or output +min((Null, Null, Null)::u!u16) = Null::u!u16? +min(()::u!u16) = Null::u!u16? +min(('200', Null, '50', '100', Null, '5')::u!u64) = '5'::u!u64? diff --git a/tests/cases/arithmetic_unsigned/multiply.test b/tests/cases/arithmetic_unsigned/multiply.test new file mode 100644 index 000000000..f442be8eb --- /dev/null +++ b/tests/cases/arithmetic_unsigned/multiply.test @@ -0,0 +1,16 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +multiply('25'::u!u8, '5'::u!u8) = '125'::u!u8 +multiply('200'::u!u16, '100'::u!u16) = '20000'::u!u16 +multiply('300'::u!u32, '200'::u!u32) = '60000'::u!u32 +multiply('80000'::u!u64, '5000'::u!u64) = '400000000'::u!u64 + +# overflow: Examples demonstrating overflow behavior +multiply('200'::u!u8, '2'::u!u8) [overflow:ERROR] = +multiply('40000'::u!u16, '2'::u!u16) [overflow:ERROR] = +multiply('3000000000'::u!u32, '2'::u!u32) [overflow:ERROR] = +multiply('10000000000000000000'::u!u64, '2'::u!u64) [overflow:ERROR] = +multiply('200'::u!u8, '2'::u!u8) [overflow:SATURATE] = '255'::u!u8 +multiply('200'::u!u8, '2'::u!u8) [overflow:SILENT] = diff --git a/tests/cases/arithmetic_unsigned/subtract.test b/tests/cases/arithmetic_unsigned/subtract.test new file mode 100644 index 000000000..a8aceb968 --- /dev/null +++ b/tests/cases/arithmetic_unsigned/subtract.test @@ -0,0 +1,16 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +subtract('250'::u!u8, '50'::u!u8) = '200'::u!u8 +subtract('60000'::u!u16, '10000'::u!u16) = '50000'::u!u16 +subtract('4000000000'::u!u32, '1000000000'::u!u32) = '3000000000'::u!u32 +subtract('11000000000000000000'::u!u64, '1000000000000000000'::u!u64) = '10000000000000000000'::u!u64 + +# overflow: Examples demonstrating overflow behavior +subtract('0'::u!u8, '1'::u!u8) [overflow:ERROR] = +subtract('0'::u!u16, '1'::u!u16) [overflow:ERROR] = +subtract('0'::u!u32, '1'::u!u32) [overflow:ERROR] = +subtract('0'::u!u64, '1'::u!u64) [overflow:ERROR] = +subtract('0'::u!u8, '1'::u!u8) [overflow:SATURATE] = '0'::u!u8 +subtract('0'::u!u8, '1'::u!u8) [overflow:SILENT] = diff --git a/tests/cases/arithmetic_unsigned/sum.test b/tests/cases/arithmetic_unsigned/sum.test new file mode 100644 index 000000000..0536c979d --- /dev/null +++ b/tests/cases/arithmetic_unsigned/sum.test @@ -0,0 +1,16 @@ +### SUBSTRAIT_AGGREGATE_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +sum(('0', '1', '2', '20')::u!u8) = '23'::u!u64? +sum(('100', '200', '50')::u!u16) = '350'::u!u64? +sum(('2000000', '3217908', '629000', '100000', '0', '987654')::u!u32) = '6934562'::u!u64? +sum(('1000000000000', '2000000000000', '3000000000000')::u!u64) = '6000000000000'::u!u64? + +# overflow: Examples demonstrating overflow behavior +sum(('18446744073709551614', '1', '1', '1', '1', '10000000000')::u!u64) [overflow:ERROR] = + +# null_handling: Examples with null as input or output +sum((Null, Null, Null)::u!u16) = Null::u!u64? +sum(()::u!u16) = Null::u!u64? +sum(('200', Null, '50', '0', Null, '100')::u!u32) = '350'::u!u64? diff --git a/tests/coverage/antlr_parser/FuncTestCaseParser.py b/tests/coverage/antlr_parser/FuncTestCaseParser.py index fdc96e159..dcb49b436 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParser.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParser.py @@ -11,7 +11,7 @@ def serializedATN(): return [ - 4,1,129,746,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6, + 4,1,129,756,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6, 7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7, 13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2, 20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7, @@ -23,270 +23,274 @@ def serializedATN(): 59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7, 65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2, 72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7, - 78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,1,0,1,0,4,0, - 171,8,0,11,0,12,0,172,1,0,1,0,1,1,1,1,1,1,5,1,180,8,1,10,1,12,1, - 183,9,1,1,2,1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,1,3,1,3,5,3,196,8,3, - 10,3,12,3,199,9,3,1,4,1,4,1,4,1,4,1,4,1,5,1,5,1,6,1,6,1,6,1,6,1, - 6,1,6,1,6,1,6,3,6,216,8,6,1,6,1,6,1,6,1,7,3,7,222,8,7,1,7,4,7,225, - 8,7,11,7,12,7,226,1,7,3,7,230,8,7,1,7,4,7,233,8,7,11,7,12,7,234, - 3,7,237,8,7,1,8,1,8,1,8,5,8,242,8,8,10,8,12,8,245,9,8,1,9,1,9,3, - 9,249,8,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10, - 1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,3,10, - 274,8,10,1,11,1,11,1,11,1,11,1,11,3,11,281,8,11,1,11,1,11,1,11,1, - 12,1,12,1,12,1,12,3,12,290,8,12,1,12,1,12,1,12,1,12,1,12,1,12,3, - 12,298,8,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,3,12,307,8,12,1,13, - 1,13,1,13,1,13,1,13,1,13,5,13,315,8,13,10,13,12,13,318,9,13,1,13, - 1,13,1,13,1,13,1,14,1,14,1,14,1,14,5,14,328,8,14,10,14,12,14,331, - 9,14,3,14,333,8,14,1,14,1,14,1,15,1,15,1,15,1,15,1,16,1,16,1,16, - 1,16,5,16,345,8,16,10,16,12,16,348,9,16,3,16,350,8,16,1,16,1,16, - 1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,3,17,365, - 8,17,1,18,1,18,1,18,5,18,370,8,18,10,18,12,18,373,9,18,1,19,1,19, - 1,19,5,19,378,8,19,10,19,12,19,381,9,19,1,20,1,20,1,20,1,20,3,20, - 387,8,20,1,21,1,21,1,21,1,21,3,21,393,8,21,1,22,1,22,1,22,3,22,398, - 8,22,1,23,1,23,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,26,1,26, - 1,26,1,26,1,27,1,27,1,27,1,27,1,28,1,28,1,28,1,28,1,29,1,29,1,29, - 1,29,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1,32,1,32,1,32,1,32, - 1,33,1,33,1,33,1,33,1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,35,1,36, - 1,36,1,36,1,36,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1,38,1,39,1,39, - 1,39,1,39,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,42,1,42,1,42, - 1,42,1,43,1,43,1,43,1,43,1,44,1,44,1,44,1,44,1,45,1,45,1,45,1,45, - 1,46,1,46,1,46,1,46,5,46,494,8,46,10,46,12,46,497,9,46,3,46,499, - 8,46,1,46,1,46,1,47,1,47,3,47,505,8,47,1,48,1,48,1,48,1,48,1,48, - 1,48,1,49,1,49,1,49,1,49,1,49,4,49,518,8,49,11,49,12,49,519,1,49, - 3,49,523,8,49,1,50,1,50,1,50,1,50,1,50,1,51,1,51,3,51,532,8,51,1, - 52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,546, - 8,52,1,52,1,52,1,52,3,52,551,8,52,3,52,553,8,52,1,53,1,53,3,53,557, - 8,53,1,54,1,54,3,54,561,8,54,1,55,1,55,3,55,565,8,55,1,56,1,56,3, - 56,569,8,56,1,57,1,57,3,57,573,8,57,1,58,1,58,3,58,577,8,58,1,59, - 1,59,3,59,581,8,59,1,60,1,60,3,60,585,8,60,1,61,1,61,3,61,589,8, - 61,1,62,1,62,3,62,593,8,62,1,63,1,63,3,63,597,8,63,1,63,1,63,1,63, - 1,63,3,63,603,8,63,1,64,1,64,3,64,607,8,64,1,64,1,64,1,64,1,64,3, - 64,613,8,64,1,65,1,65,3,65,617,8,65,1,65,1,65,1,65,1,65,1,66,1,66, - 3,66,625,8,66,1,66,1,66,1,66,1,66,1,67,1,67,3,67,633,8,67,1,67,1, - 67,1,67,1,67,1,68,1,68,3,68,641,8,68,1,68,1,68,1,68,1,68,1,68,1, - 68,3,68,649,8,68,1,69,1,69,3,69,653,8,69,1,69,1,69,1,69,1,69,1,70, - 1,70,3,70,661,8,70,1,70,1,70,1,70,1,70,1,71,1,71,3,71,669,8,71,1, - 71,1,71,1,71,1,71,1,72,1,72,3,72,677,8,72,1,72,1,72,1,72,1,72,1, - 73,1,73,3,73,685,8,73,1,73,1,73,1,73,1,73,1,73,1,73,1,74,1,74,1, - 74,1,74,1,74,5,74,698,8,74,10,74,12,74,701,9,74,1,74,1,74,3,74,705, - 8,74,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,3,75, - 718,8,75,1,76,1,76,1,77,1,77,1,78,1,78,1,78,1,78,1,79,1,79,1,80, - 1,80,1,81,1,81,1,81,5,81,735,8,81,10,81,12,81,738,9,81,1,82,1,82, - 1,83,1,83,3,83,744,8,83,1,83,0,0,84,0,2,4,6,8,10,12,14,16,18,20, + 78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,1, + 0,1,0,4,0,173,8,0,11,0,12,0,174,1,0,1,0,1,1,1,1,1,1,5,1,182,8,1, + 10,1,12,1,185,9,1,1,2,1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,1,3,1,3,5, + 3,198,8,3,10,3,12,3,201,9,3,1,4,1,4,1,4,1,4,1,4,1,5,1,5,1,6,1,6, + 1,6,1,6,1,6,1,6,1,6,1,6,3,6,218,8,6,1,6,1,6,1,6,1,7,3,7,224,8,7, + 1,7,4,7,227,8,7,11,7,12,7,228,1,7,3,7,232,8,7,1,7,4,7,235,8,7,11, + 7,12,7,236,3,7,239,8,7,1,8,1,8,1,8,5,8,244,8,8,10,8,12,8,247,9,8, + 1,9,1,9,3,9,251,8,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10, + 1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10, + 1,10,1,10,3,10,277,8,10,1,11,1,11,1,11,1,11,1,11,3,11,284,8,11,1, + 11,1,11,1,11,1,12,1,12,1,12,1,12,3,12,293,8,12,1,12,1,12,1,12,1, + 12,1,12,1,12,3,12,301,8,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,3, + 12,310,8,12,1,13,1,13,1,13,1,13,1,13,1,13,5,13,318,8,13,10,13,12, + 13,321,9,13,1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14,5,14,331,8,14, + 10,14,12,14,334,9,14,3,14,336,8,14,1,14,1,14,1,15,1,15,1,15,1,15, + 1,16,1,16,1,16,1,16,5,16,348,8,16,10,16,12,16,351,9,16,3,16,353, + 8,16,1,16,1,16,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17, + 1,17,3,17,368,8,17,1,18,1,18,1,18,5,18,373,8,18,10,18,12,18,376, + 9,18,1,19,1,19,1,19,5,19,381,8,19,10,19,12,19,384,9,19,1,20,1,20, + 1,20,1,20,3,20,390,8,20,1,21,1,21,1,21,1,21,3,21,396,8,21,1,22,1, + 22,1,22,3,22,401,8,22,1,23,1,23,1,24,1,24,1,24,1,24,1,25,1,25,1, + 25,1,25,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,28,1,28,1,28,1, + 28,1,29,1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1, + 32,1,32,1,32,1,32,1,33,1,33,1,33,1,33,1,34,1,34,1,34,1,34,1,35,1, + 35,1,35,1,35,1,36,1,36,1,36,1,36,1,37,1,37,1,37,1,37,1,38,1,38,1, + 38,1,38,1,39,1,39,1,39,1,39,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1, + 41,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,44,1,44,1,44,1,44,1, + 45,1,45,1,45,1,45,1,45,3,45,494,8,45,1,46,1,46,1,46,1,46,1,47,1, + 47,1,47,1,47,5,47,504,8,47,10,47,12,47,507,9,47,3,47,509,8,47,1, + 47,1,47,1,48,1,48,3,48,515,8,48,1,49,1,49,1,49,1,49,1,49,1,49,1, + 50,1,50,1,50,1,50,1,50,4,50,528,8,50,11,50,12,50,529,1,50,3,50,533, + 8,50,1,51,1,51,1,51,1,51,1,51,1,52,1,52,3,52,542,8,52,1,53,1,53, + 1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,556,8,53, + 1,53,1,53,1,53,3,53,561,8,53,3,53,563,8,53,1,54,1,54,3,54,567,8, + 54,1,55,1,55,3,55,571,8,55,1,56,1,56,3,56,575,8,56,1,57,1,57,3,57, + 579,8,57,1,58,1,58,3,58,583,8,58,1,59,1,59,3,59,587,8,59,1,60,1, + 60,3,60,591,8,60,1,61,1,61,3,61,595,8,61,1,62,1,62,3,62,599,8,62, + 1,63,1,63,3,63,603,8,63,1,64,1,64,3,64,607,8,64,1,64,1,64,1,64,1, + 64,3,64,613,8,64,1,65,1,65,3,65,617,8,65,1,65,1,65,1,65,1,65,3,65, + 623,8,65,1,66,1,66,3,66,627,8,66,1,66,1,66,1,66,1,66,1,67,1,67,3, + 67,635,8,67,1,67,1,67,1,67,1,67,1,68,1,68,3,68,643,8,68,1,68,1,68, + 1,68,1,68,1,69,1,69,3,69,651,8,69,1,69,1,69,1,69,1,69,1,69,1,69, + 3,69,659,8,69,1,70,1,70,3,70,663,8,70,1,70,1,70,1,70,1,70,1,71,1, + 71,3,71,671,8,71,1,71,1,71,1,71,1,71,1,72,1,72,3,72,679,8,72,1,72, + 1,72,1,72,1,72,1,73,1,73,3,73,687,8,73,1,73,1,73,1,73,1,73,1,74, + 1,74,3,74,695,8,74,1,74,1,74,1,74,1,74,1,74,1,74,1,75,1,75,1,75, + 1,75,1,75,5,75,708,8,75,10,75,12,75,711,9,75,1,75,1,75,3,75,715, + 8,75,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,3,76, + 728,8,76,1,77,1,77,1,78,1,78,1,79,1,79,1,79,1,79,1,80,1,80,1,81, + 1,81,1,82,1,82,1,82,5,82,745,8,82,10,82,12,82,748,9,82,1,83,1,83, + 1,84,1,84,3,84,754,8,84,1,84,0,0,85,0,2,4,6,8,10,12,14,16,18,20, 22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64, 66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106, 108,110,112,114,116,118,120,122,124,126,128,130,132,134,136,138, - 140,142,144,146,148,150,152,154,156,158,160,162,164,166,0,23,1,0, - 3,4,2,0,18,18,26,26,2,0,55,55,84,84,2,0,62,62,85,85,2,0,63,63,86, - 86,1,0,56,59,1,0,60,61,2,0,64,64,87,87,2,0,65,65,88,88,2,0,68,68, - 89,89,2,0,69,69,90,90,2,0,70,70,91,91,2,0,76,76,96,96,2,0,77,77, - 97,97,2,0,78,78,98,98,2,0,72,72,92,92,2,0,73,73,93,93,2,0,74,74, - 94,94,2,0,75,75,95,95,1,0,10,11,3,0,12,13,21,22,128,128,5,0,14,20, - 23,23,27,27,45,45,128,128,2,0,23,23,123,124,777,0,168,1,0,0,0,2, - 176,1,0,0,0,4,184,1,0,0,0,6,189,1,0,0,0,8,200,1,0,0,0,10,205,1,0, - 0,0,12,207,1,0,0,0,14,236,1,0,0,0,16,238,1,0,0,0,18,248,1,0,0,0, - 20,273,1,0,0,0,22,275,1,0,0,0,24,306,1,0,0,0,26,308,1,0,0,0,28,323, - 1,0,0,0,30,336,1,0,0,0,32,340,1,0,0,0,34,364,1,0,0,0,36,366,1,0, - 0,0,38,374,1,0,0,0,40,386,1,0,0,0,42,392,1,0,0,0,44,397,1,0,0,0, - 46,399,1,0,0,0,48,401,1,0,0,0,50,405,1,0,0,0,52,409,1,0,0,0,54,413, - 1,0,0,0,56,417,1,0,0,0,58,421,1,0,0,0,60,425,1,0,0,0,62,429,1,0, - 0,0,64,433,1,0,0,0,66,437,1,0,0,0,68,441,1,0,0,0,70,445,1,0,0,0, - 72,449,1,0,0,0,74,453,1,0,0,0,76,457,1,0,0,0,78,461,1,0,0,0,80,465, - 1,0,0,0,82,469,1,0,0,0,84,473,1,0,0,0,86,477,1,0,0,0,88,481,1,0, - 0,0,90,485,1,0,0,0,92,489,1,0,0,0,94,504,1,0,0,0,96,506,1,0,0,0, - 98,522,1,0,0,0,100,524,1,0,0,0,102,531,1,0,0,0,104,552,1,0,0,0,106, - 554,1,0,0,0,108,558,1,0,0,0,110,562,1,0,0,0,112,566,1,0,0,0,114, - 570,1,0,0,0,116,574,1,0,0,0,118,578,1,0,0,0,120,582,1,0,0,0,122, - 586,1,0,0,0,124,590,1,0,0,0,126,594,1,0,0,0,128,604,1,0,0,0,130, - 614,1,0,0,0,132,622,1,0,0,0,134,630,1,0,0,0,136,638,1,0,0,0,138, - 650,1,0,0,0,140,658,1,0,0,0,142,666,1,0,0,0,144,674,1,0,0,0,146, - 682,1,0,0,0,148,704,1,0,0,0,150,717,1,0,0,0,152,719,1,0,0,0,154, - 721,1,0,0,0,156,723,1,0,0,0,158,727,1,0,0,0,160,729,1,0,0,0,162, - 731,1,0,0,0,164,739,1,0,0,0,166,743,1,0,0,0,168,170,3,2,1,0,169, - 171,3,14,7,0,170,169,1,0,0,0,171,172,1,0,0,0,172,170,1,0,0,0,172, - 173,1,0,0,0,173,174,1,0,0,0,174,175,5,0,0,1,175,1,1,0,0,0,176,177, - 3,4,2,0,177,181,3,6,3,0,178,180,3,8,4,0,179,178,1,0,0,0,180,183, - 1,0,0,0,181,179,1,0,0,0,181,182,1,0,0,0,182,3,1,0,0,0,183,181,1, - 0,0,0,184,185,5,2,0,0,185,186,7,0,0,0,186,187,5,119,0,0,187,188, - 5,7,0,0,188,5,1,0,0,0,189,190,5,2,0,0,190,191,5,5,0,0,191,192,5, - 119,0,0,192,197,5,46,0,0,193,194,5,118,0,0,194,196,5,46,0,0,195, - 193,1,0,0,0,196,199,1,0,0,0,197,195,1,0,0,0,197,198,1,0,0,0,198, - 7,1,0,0,0,199,197,1,0,0,0,200,201,5,2,0,0,201,202,5,6,0,0,202,203, - 5,119,0,0,203,204,5,46,0,0,204,9,1,0,0,0,205,206,5,8,0,0,206,11, - 1,0,0,0,207,208,3,166,83,0,208,209,5,114,0,0,209,210,3,16,8,0,210, - 215,5,115,0,0,211,212,5,116,0,0,212,213,3,162,81,0,213,214,5,117, - 0,0,214,216,1,0,0,0,215,211,1,0,0,0,215,216,1,0,0,0,216,217,1,0, - 0,0,217,218,5,107,0,0,218,219,3,18,9,0,219,13,1,0,0,0,220,222,3, - 10,5,0,221,220,1,0,0,0,221,222,1,0,0,0,222,224,1,0,0,0,223,225,3, - 12,6,0,224,223,1,0,0,0,225,226,1,0,0,0,226,224,1,0,0,0,226,227,1, - 0,0,0,227,237,1,0,0,0,228,230,3,10,5,0,229,228,1,0,0,0,229,230,1, - 0,0,0,230,232,1,0,0,0,231,233,3,22,11,0,232,231,1,0,0,0,233,234, - 1,0,0,0,234,232,1,0,0,0,234,235,1,0,0,0,235,237,1,0,0,0,236,221, - 1,0,0,0,236,229,1,0,0,0,237,15,1,0,0,0,238,243,3,20,10,0,239,240, - 5,118,0,0,240,242,3,20,10,0,241,239,1,0,0,0,242,245,1,0,0,0,243, - 241,1,0,0,0,243,244,1,0,0,0,244,17,1,0,0,0,245,243,1,0,0,0,246,249, - 3,20,10,0,247,249,3,154,77,0,248,246,1,0,0,0,248,247,1,0,0,0,249, - 19,1,0,0,0,250,274,3,48,24,0,251,274,3,90,45,0,252,274,3,50,25,0, - 253,274,3,52,26,0,254,274,3,56,28,0,255,274,3,58,29,0,256,274,3, - 54,27,0,257,274,3,60,30,0,258,274,3,62,31,0,259,274,3,64,32,0,260, - 274,3,66,33,0,261,274,3,68,34,0,262,274,3,70,35,0,263,274,3,72,36, - 0,264,274,3,74,37,0,265,274,3,76,38,0,266,274,3,78,39,0,267,274, - 3,80,40,0,268,274,3,82,41,0,269,274,3,84,42,0,270,274,3,86,43,0, - 271,274,3,88,44,0,272,274,5,128,0,0,273,250,1,0,0,0,273,251,1,0, - 0,0,273,252,1,0,0,0,273,253,1,0,0,0,273,254,1,0,0,0,273,255,1,0, - 0,0,273,256,1,0,0,0,273,257,1,0,0,0,273,258,1,0,0,0,273,259,1,0, - 0,0,273,260,1,0,0,0,273,261,1,0,0,0,273,262,1,0,0,0,273,263,1,0, - 0,0,273,264,1,0,0,0,273,265,1,0,0,0,273,266,1,0,0,0,273,267,1,0, - 0,0,273,268,1,0,0,0,273,269,1,0,0,0,273,270,1,0,0,0,273,271,1,0, - 0,0,273,272,1,0,0,0,274,21,1,0,0,0,275,280,3,24,12,0,276,277,5,116, - 0,0,277,278,3,162,81,0,278,279,5,117,0,0,279,281,1,0,0,0,280,276, - 1,0,0,0,280,281,1,0,0,0,281,282,1,0,0,0,282,283,5,107,0,0,283,284, - 3,18,9,0,284,23,1,0,0,0,285,286,3,26,13,0,286,287,3,166,83,0,287, - 289,5,114,0,0,288,290,3,36,18,0,289,288,1,0,0,0,289,290,1,0,0,0, - 290,291,1,0,0,0,291,292,5,115,0,0,292,307,1,0,0,0,293,294,3,28,14, - 0,294,295,3,166,83,0,295,297,5,114,0,0,296,298,3,38,19,0,297,296, - 1,0,0,0,297,298,1,0,0,0,298,299,1,0,0,0,299,300,5,115,0,0,300,307, - 1,0,0,0,301,302,3,166,83,0,302,303,5,114,0,0,303,304,3,30,15,0,304, - 305,5,115,0,0,305,307,1,0,0,0,306,285,1,0,0,0,306,293,1,0,0,0,306, - 301,1,0,0,0,307,25,1,0,0,0,308,309,5,9,0,0,309,310,5,128,0,0,310, - 311,5,114,0,0,311,316,3,102,51,0,312,313,5,118,0,0,313,315,3,102, - 51,0,314,312,1,0,0,0,315,318,1,0,0,0,316,314,1,0,0,0,316,317,1,0, - 0,0,317,319,1,0,0,0,318,316,1,0,0,0,319,320,5,115,0,0,320,321,5, - 107,0,0,321,322,3,28,14,0,322,27,1,0,0,0,323,332,5,114,0,0,324,329, - 3,32,16,0,325,326,5,118,0,0,326,328,3,32,16,0,327,325,1,0,0,0,328, - 331,1,0,0,0,329,327,1,0,0,0,329,330,1,0,0,0,330,333,1,0,0,0,331, - 329,1,0,0,0,332,324,1,0,0,0,332,333,1,0,0,0,333,334,1,0,0,0,334, - 335,5,115,0,0,335,29,1,0,0,0,336,337,3,32,16,0,337,338,5,101,0,0, - 338,339,3,102,51,0,339,31,1,0,0,0,340,349,5,114,0,0,341,346,3,34, - 17,0,342,343,5,118,0,0,343,345,3,34,17,0,344,342,1,0,0,0,345,348, - 1,0,0,0,346,344,1,0,0,0,346,347,1,0,0,0,347,350,1,0,0,0,348,346, - 1,0,0,0,349,341,1,0,0,0,349,350,1,0,0,0,350,351,1,0,0,0,351,352, - 5,115,0,0,352,33,1,0,0,0,353,365,5,45,0,0,354,365,3,44,22,0,355, - 365,5,27,0,0,356,365,5,46,0,0,357,365,5,31,0,0,358,365,5,30,0,0, - 359,365,5,29,0,0,360,365,5,28,0,0,361,365,5,42,0,0,362,365,5,43, - 0,0,363,365,5,44,0,0,364,353,1,0,0,0,364,354,1,0,0,0,364,355,1,0, - 0,0,364,356,1,0,0,0,364,357,1,0,0,0,364,358,1,0,0,0,364,359,1,0, - 0,0,364,360,1,0,0,0,364,361,1,0,0,0,364,362,1,0,0,0,364,363,1,0, - 0,0,365,35,1,0,0,0,366,371,3,40,20,0,367,368,5,118,0,0,368,370,3, - 40,20,0,369,367,1,0,0,0,370,373,1,0,0,0,371,369,1,0,0,0,371,372, - 1,0,0,0,372,37,1,0,0,0,373,371,1,0,0,0,374,379,3,42,21,0,375,376, - 5,118,0,0,376,378,3,42,21,0,377,375,1,0,0,0,378,381,1,0,0,0,379, - 377,1,0,0,0,379,380,1,0,0,0,380,39,1,0,0,0,381,379,1,0,0,0,382,383, - 5,128,0,0,383,384,5,122,0,0,384,387,5,48,0,0,385,387,3,20,10,0,386, - 382,1,0,0,0,386,385,1,0,0,0,387,41,1,0,0,0,388,389,5,48,0,0,389, - 390,5,101,0,0,390,393,3,102,51,0,391,393,3,20,10,0,392,388,1,0,0, - 0,392,391,1,0,0,0,393,43,1,0,0,0,394,398,5,25,0,0,395,398,5,24,0, - 0,396,398,3,46,23,0,397,394,1,0,0,0,397,395,1,0,0,0,397,396,1,0, - 0,0,398,45,1,0,0,0,399,400,7,1,0,0,400,47,1,0,0,0,401,402,5,45,0, - 0,402,403,5,101,0,0,403,404,3,102,51,0,404,49,1,0,0,0,405,406,5, - 24,0,0,406,407,5,101,0,0,407,408,3,112,56,0,408,51,1,0,0,0,409,410, - 3,44,22,0,410,411,5,101,0,0,411,412,3,114,57,0,412,53,1,0,0,0,413, - 414,3,44,22,0,414,415,5,101,0,0,415,416,3,136,68,0,416,55,1,0,0, - 0,417,418,5,27,0,0,418,419,5,101,0,0,419,420,3,106,53,0,420,57,1, - 0,0,0,421,422,5,46,0,0,422,423,5,101,0,0,423,424,3,108,54,0,424, - 59,1,0,0,0,425,426,5,31,0,0,426,427,5,101,0,0,427,428,3,116,58,0, - 428,61,1,0,0,0,429,430,5,30,0,0,430,431,5,101,0,0,431,432,3,118, - 59,0,432,63,1,0,0,0,433,434,5,29,0,0,434,435,5,101,0,0,435,436,3, - 120,60,0,436,65,1,0,0,0,437,438,5,28,0,0,438,439,5,101,0,0,439,440, - 3,122,61,0,440,67,1,0,0,0,441,442,5,42,0,0,442,443,5,101,0,0,443, - 444,3,124,62,0,444,69,1,0,0,0,445,446,5,43,0,0,446,447,5,101,0,0, - 447,448,3,126,63,0,448,71,1,0,0,0,449,450,5,44,0,0,450,451,5,101, - 0,0,451,452,3,128,64,0,452,73,1,0,0,0,453,454,5,46,0,0,454,455,5, - 101,0,0,455,456,3,130,65,0,456,75,1,0,0,0,457,458,5,46,0,0,458,459, - 5,101,0,0,459,460,3,132,66,0,460,77,1,0,0,0,461,462,5,46,0,0,462, - 463,5,101,0,0,463,464,3,134,67,0,464,79,1,0,0,0,465,466,5,30,0,0, - 466,467,5,101,0,0,467,468,3,138,69,0,468,81,1,0,0,0,469,470,5,29, - 0,0,470,471,5,101,0,0,471,472,3,140,70,0,472,83,1,0,0,0,473,474, - 5,28,0,0,474,475,5,101,0,0,475,476,3,142,71,0,476,85,1,0,0,0,477, - 478,3,92,46,0,478,479,5,101,0,0,479,480,3,144,72,0,480,87,1,0,0, - 0,481,482,3,96,48,0,482,483,5,101,0,0,483,484,3,146,73,0,484,89, - 1,0,0,0,485,486,5,128,0,0,486,487,5,101,0,0,487,488,5,47,0,0,488, - 91,1,0,0,0,489,498,5,116,0,0,490,495,3,94,47,0,491,492,5,118,0,0, - 492,494,3,94,47,0,493,491,1,0,0,0,494,497,1,0,0,0,495,493,1,0,0, - 0,495,496,1,0,0,0,496,499,1,0,0,0,497,495,1,0,0,0,498,490,1,0,0, - 0,498,499,1,0,0,0,499,500,1,0,0,0,500,501,5,117,0,0,501,93,1,0,0, - 0,502,505,3,34,17,0,503,505,3,92,46,0,504,502,1,0,0,0,504,503,1, - 0,0,0,505,95,1,0,0,0,506,507,5,114,0,0,507,508,3,98,49,0,508,509, - 5,126,0,0,509,510,3,100,50,0,510,511,5,115,0,0,511,97,1,0,0,0,512, - 523,5,128,0,0,513,514,5,114,0,0,514,517,5,128,0,0,515,516,5,118, - 0,0,516,518,5,128,0,0,517,515,1,0,0,0,518,519,1,0,0,0,519,517,1, - 0,0,0,519,520,1,0,0,0,520,521,1,0,0,0,521,523,5,115,0,0,522,512, - 1,0,0,0,522,513,1,0,0,0,523,99,1,0,0,0,524,525,3,166,83,0,525,526, - 5,114,0,0,526,527,3,16,8,0,527,528,5,115,0,0,528,101,1,0,0,0,529, - 532,3,104,52,0,530,532,3,150,75,0,531,529,1,0,0,0,531,530,1,0,0, - 0,532,103,1,0,0,0,533,553,3,106,53,0,534,553,3,112,56,0,535,553, - 3,114,57,0,536,553,3,108,54,0,537,553,3,110,55,0,538,553,3,120,60, - 0,539,553,3,122,61,0,540,553,3,116,58,0,541,553,3,118,59,0,542,553, - 3,124,62,0,543,545,5,71,0,0,544,546,5,120,0,0,545,544,1,0,0,0,545, - 546,1,0,0,0,546,553,1,0,0,0,547,548,5,83,0,0,548,550,5,128,0,0,549, - 551,5,120,0,0,550,549,1,0,0,0,550,551,1,0,0,0,551,553,1,0,0,0,552, - 533,1,0,0,0,552,534,1,0,0,0,552,535,1,0,0,0,552,536,1,0,0,0,552, - 537,1,0,0,0,552,538,1,0,0,0,552,539,1,0,0,0,552,540,1,0,0,0,552, - 541,1,0,0,0,552,542,1,0,0,0,552,543,1,0,0,0,552,547,1,0,0,0,553, - 105,1,0,0,0,554,556,7,2,0,0,555,557,5,120,0,0,556,555,1,0,0,0,556, - 557,1,0,0,0,557,107,1,0,0,0,558,560,7,3,0,0,559,561,5,120,0,0,560, - 559,1,0,0,0,560,561,1,0,0,0,561,109,1,0,0,0,562,564,7,4,0,0,563, - 565,5,120,0,0,564,563,1,0,0,0,564,565,1,0,0,0,565,111,1,0,0,0,566, - 568,7,5,0,0,567,569,5,120,0,0,568,567,1,0,0,0,568,569,1,0,0,0,569, - 113,1,0,0,0,570,572,7,6,0,0,571,573,5,120,0,0,572,571,1,0,0,0,572, - 573,1,0,0,0,573,115,1,0,0,0,574,576,5,66,0,0,575,577,5,120,0,0,576, - 575,1,0,0,0,576,577,1,0,0,0,577,117,1,0,0,0,578,580,5,67,0,0,579, - 581,5,120,0,0,580,579,1,0,0,0,580,581,1,0,0,0,581,119,1,0,0,0,582, - 584,7,7,0,0,583,585,5,120,0,0,584,583,1,0,0,0,584,585,1,0,0,0,585, - 121,1,0,0,0,586,588,7,8,0,0,587,589,5,120,0,0,588,587,1,0,0,0,588, - 589,1,0,0,0,589,123,1,0,0,0,590,592,7,9,0,0,591,593,5,120,0,0,592, - 591,1,0,0,0,592,593,1,0,0,0,593,125,1,0,0,0,594,596,7,10,0,0,595, - 597,5,120,0,0,596,595,1,0,0,0,596,597,1,0,0,0,597,602,1,0,0,0,598, - 599,5,40,0,0,599,600,3,152,76,0,600,601,5,41,0,0,601,603,1,0,0,0, - 602,598,1,0,0,0,602,603,1,0,0,0,603,127,1,0,0,0,604,606,7,11,0,0, - 605,607,5,120,0,0,606,605,1,0,0,0,606,607,1,0,0,0,607,612,1,0,0, - 0,608,609,5,40,0,0,609,610,3,152,76,0,610,611,5,41,0,0,611,613,1, - 0,0,0,612,608,1,0,0,0,612,613,1,0,0,0,613,129,1,0,0,0,614,616,7, - 12,0,0,615,617,5,120,0,0,616,615,1,0,0,0,616,617,1,0,0,0,617,618, - 1,0,0,0,618,619,5,40,0,0,619,620,3,152,76,0,620,621,5,41,0,0,621, - 131,1,0,0,0,622,624,7,13,0,0,623,625,5,120,0,0,624,623,1,0,0,0,624, - 625,1,0,0,0,625,626,1,0,0,0,626,627,5,40,0,0,627,628,3,152,76,0, - 628,629,5,41,0,0,629,133,1,0,0,0,630,632,7,14,0,0,631,633,5,120, - 0,0,632,631,1,0,0,0,632,633,1,0,0,0,633,634,1,0,0,0,634,635,5,40, - 0,0,635,636,3,152,76,0,636,637,5,41,0,0,637,135,1,0,0,0,638,640, - 7,15,0,0,639,641,5,120,0,0,640,639,1,0,0,0,640,641,1,0,0,0,641,648, - 1,0,0,0,642,643,5,40,0,0,643,644,3,152,76,0,644,645,5,118,0,0,645, - 646,3,152,76,0,646,647,5,41,0,0,647,649,1,0,0,0,648,642,1,0,0,0, - 648,649,1,0,0,0,649,137,1,0,0,0,650,652,7,16,0,0,651,653,5,120,0, - 0,652,651,1,0,0,0,652,653,1,0,0,0,653,654,1,0,0,0,654,655,5,40,0, - 0,655,656,3,152,76,0,656,657,5,41,0,0,657,139,1,0,0,0,658,660,7, - 17,0,0,659,661,5,120,0,0,660,659,1,0,0,0,660,661,1,0,0,0,661,662, - 1,0,0,0,662,663,5,40,0,0,663,664,3,152,76,0,664,665,5,41,0,0,665, - 141,1,0,0,0,666,668,7,18,0,0,667,669,5,120,0,0,668,667,1,0,0,0,668, - 669,1,0,0,0,669,670,1,0,0,0,670,671,5,40,0,0,671,672,3,152,76,0, - 672,673,5,41,0,0,673,143,1,0,0,0,674,676,5,81,0,0,675,677,5,120, - 0,0,676,675,1,0,0,0,676,677,1,0,0,0,677,678,1,0,0,0,678,679,5,40, - 0,0,679,680,3,102,51,0,680,681,5,41,0,0,681,145,1,0,0,0,682,684, - 5,54,0,0,683,685,5,120,0,0,684,683,1,0,0,0,684,685,1,0,0,0,685,686, - 1,0,0,0,686,687,5,40,0,0,687,688,3,148,74,0,688,689,5,126,0,0,689, - 690,3,102,51,0,690,691,5,41,0,0,691,147,1,0,0,0,692,705,3,102,51, - 0,693,694,5,114,0,0,694,699,3,102,51,0,695,696,5,118,0,0,696,698, - 3,102,51,0,697,695,1,0,0,0,698,701,1,0,0,0,699,697,1,0,0,0,699,700, - 1,0,0,0,700,702,1,0,0,0,701,699,1,0,0,0,702,703,5,115,0,0,703,705, - 1,0,0,0,704,692,1,0,0,0,704,693,1,0,0,0,705,149,1,0,0,0,706,718, - 3,130,65,0,707,718,3,132,66,0,708,718,3,134,67,0,709,718,3,136,68, - 0,710,718,3,126,63,0,711,718,3,128,64,0,712,718,3,138,69,0,713,718, - 3,140,70,0,714,718,3,142,71,0,715,718,3,144,72,0,716,718,3,146,73, - 0,717,706,1,0,0,0,717,707,1,0,0,0,717,708,1,0,0,0,717,709,1,0,0, - 0,717,710,1,0,0,0,717,711,1,0,0,0,717,712,1,0,0,0,717,713,1,0,0, - 0,717,714,1,0,0,0,717,715,1,0,0,0,717,716,1,0,0,0,718,151,1,0,0, - 0,719,720,5,24,0,0,720,153,1,0,0,0,721,722,7,19,0,0,722,155,1,0, - 0,0,723,724,3,158,79,0,724,725,5,119,0,0,725,726,3,160,80,0,726, - 157,1,0,0,0,727,728,7,20,0,0,728,159,1,0,0,0,729,730,7,21,0,0,730, - 161,1,0,0,0,731,736,3,156,78,0,732,733,5,118,0,0,733,735,3,156,78, - 0,734,732,1,0,0,0,735,738,1,0,0,0,736,734,1,0,0,0,736,737,1,0,0, - 0,737,163,1,0,0,0,738,736,1,0,0,0,739,740,7,22,0,0,740,165,1,0,0, - 0,741,744,3,164,82,0,742,744,5,128,0,0,743,741,1,0,0,0,743,742,1, - 0,0,0,744,167,1,0,0,0,65,172,181,197,215,221,226,229,234,236,243, - 248,273,280,289,297,306,316,329,332,346,349,364,371,379,386,392, - 397,495,498,504,519,522,531,545,550,552,556,560,564,568,572,576, - 580,584,588,592,596,602,606,612,616,624,632,640,648,652,660,668, - 676,684,699,704,717,736,743 + 140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,0,23, + 1,0,3,4,2,0,18,18,26,26,2,0,55,55,84,84,2,0,62,62,85,85,2,0,63,63, + 86,86,1,0,56,59,1,0,60,61,2,0,64,64,87,87,2,0,65,65,88,88,2,0,68, + 68,89,89,2,0,69,69,90,90,2,0,70,70,91,91,2,0,76,76,96,96,2,0,77, + 77,97,97,2,0,78,78,98,98,2,0,72,72,92,92,2,0,73,73,93,93,2,0,74, + 74,94,94,2,0,75,75,95,95,1,0,10,11,3,0,12,13,21,22,128,128,5,0,14, + 20,23,23,27,27,45,45,128,128,2,0,23,23,123,124,788,0,170,1,0,0,0, + 2,178,1,0,0,0,4,186,1,0,0,0,6,191,1,0,0,0,8,202,1,0,0,0,10,207,1, + 0,0,0,12,209,1,0,0,0,14,238,1,0,0,0,16,240,1,0,0,0,18,250,1,0,0, + 0,20,276,1,0,0,0,22,278,1,0,0,0,24,309,1,0,0,0,26,311,1,0,0,0,28, + 326,1,0,0,0,30,339,1,0,0,0,32,343,1,0,0,0,34,367,1,0,0,0,36,369, + 1,0,0,0,38,377,1,0,0,0,40,389,1,0,0,0,42,395,1,0,0,0,44,400,1,0, + 0,0,46,402,1,0,0,0,48,404,1,0,0,0,50,408,1,0,0,0,52,412,1,0,0,0, + 54,416,1,0,0,0,56,420,1,0,0,0,58,424,1,0,0,0,60,428,1,0,0,0,62,432, + 1,0,0,0,64,436,1,0,0,0,66,440,1,0,0,0,68,444,1,0,0,0,70,448,1,0, + 0,0,72,452,1,0,0,0,74,456,1,0,0,0,76,460,1,0,0,0,78,464,1,0,0,0, + 80,468,1,0,0,0,82,472,1,0,0,0,84,476,1,0,0,0,86,480,1,0,0,0,88,484, + 1,0,0,0,90,488,1,0,0,0,92,495,1,0,0,0,94,499,1,0,0,0,96,514,1,0, + 0,0,98,516,1,0,0,0,100,532,1,0,0,0,102,534,1,0,0,0,104,541,1,0,0, + 0,106,562,1,0,0,0,108,564,1,0,0,0,110,568,1,0,0,0,112,572,1,0,0, + 0,114,576,1,0,0,0,116,580,1,0,0,0,118,584,1,0,0,0,120,588,1,0,0, + 0,122,592,1,0,0,0,124,596,1,0,0,0,126,600,1,0,0,0,128,604,1,0,0, + 0,130,614,1,0,0,0,132,624,1,0,0,0,134,632,1,0,0,0,136,640,1,0,0, + 0,138,648,1,0,0,0,140,660,1,0,0,0,142,668,1,0,0,0,144,676,1,0,0, + 0,146,684,1,0,0,0,148,692,1,0,0,0,150,714,1,0,0,0,152,727,1,0,0, + 0,154,729,1,0,0,0,156,731,1,0,0,0,158,733,1,0,0,0,160,737,1,0,0, + 0,162,739,1,0,0,0,164,741,1,0,0,0,166,749,1,0,0,0,168,753,1,0,0, + 0,170,172,3,2,1,0,171,173,3,14,7,0,172,171,1,0,0,0,173,174,1,0,0, + 0,174,172,1,0,0,0,174,175,1,0,0,0,175,176,1,0,0,0,176,177,5,0,0, + 1,177,1,1,0,0,0,178,179,3,4,2,0,179,183,3,6,3,0,180,182,3,8,4,0, + 181,180,1,0,0,0,182,185,1,0,0,0,183,181,1,0,0,0,183,184,1,0,0,0, + 184,3,1,0,0,0,185,183,1,0,0,0,186,187,5,2,0,0,187,188,7,0,0,0,188, + 189,5,119,0,0,189,190,5,7,0,0,190,5,1,0,0,0,191,192,5,2,0,0,192, + 193,5,5,0,0,193,194,5,119,0,0,194,199,5,46,0,0,195,196,5,118,0,0, + 196,198,5,46,0,0,197,195,1,0,0,0,198,201,1,0,0,0,199,197,1,0,0,0, + 199,200,1,0,0,0,200,7,1,0,0,0,201,199,1,0,0,0,202,203,5,2,0,0,203, + 204,5,6,0,0,204,205,5,119,0,0,205,206,5,46,0,0,206,9,1,0,0,0,207, + 208,5,8,0,0,208,11,1,0,0,0,209,210,3,168,84,0,210,211,5,114,0,0, + 211,212,3,16,8,0,212,217,5,115,0,0,213,214,5,116,0,0,214,215,3,164, + 82,0,215,216,5,117,0,0,216,218,1,0,0,0,217,213,1,0,0,0,217,218,1, + 0,0,0,218,219,1,0,0,0,219,220,5,107,0,0,220,221,3,18,9,0,221,13, + 1,0,0,0,222,224,3,10,5,0,223,222,1,0,0,0,223,224,1,0,0,0,224,226, + 1,0,0,0,225,227,3,12,6,0,226,225,1,0,0,0,227,228,1,0,0,0,228,226, + 1,0,0,0,228,229,1,0,0,0,229,239,1,0,0,0,230,232,3,10,5,0,231,230, + 1,0,0,0,231,232,1,0,0,0,232,234,1,0,0,0,233,235,3,22,11,0,234,233, + 1,0,0,0,235,236,1,0,0,0,236,234,1,0,0,0,236,237,1,0,0,0,237,239, + 1,0,0,0,238,223,1,0,0,0,238,231,1,0,0,0,239,15,1,0,0,0,240,245,3, + 20,10,0,241,242,5,118,0,0,242,244,3,20,10,0,243,241,1,0,0,0,244, + 247,1,0,0,0,245,243,1,0,0,0,245,246,1,0,0,0,246,17,1,0,0,0,247,245, + 1,0,0,0,248,251,3,20,10,0,249,251,3,156,78,0,250,248,1,0,0,0,250, + 249,1,0,0,0,251,19,1,0,0,0,252,277,3,90,45,0,253,277,3,48,24,0,254, + 277,3,92,46,0,255,277,3,50,25,0,256,277,3,52,26,0,257,277,3,56,28, + 0,258,277,3,58,29,0,259,277,3,54,27,0,260,277,3,60,30,0,261,277, + 3,62,31,0,262,277,3,64,32,0,263,277,3,66,33,0,264,277,3,68,34,0, + 265,277,3,70,35,0,266,277,3,72,36,0,267,277,3,74,37,0,268,277,3, + 76,38,0,269,277,3,78,39,0,270,277,3,80,40,0,271,277,3,82,41,0,272, + 277,3,84,42,0,273,277,3,86,43,0,274,277,3,88,44,0,275,277,5,128, + 0,0,276,252,1,0,0,0,276,253,1,0,0,0,276,254,1,0,0,0,276,255,1,0, + 0,0,276,256,1,0,0,0,276,257,1,0,0,0,276,258,1,0,0,0,276,259,1,0, + 0,0,276,260,1,0,0,0,276,261,1,0,0,0,276,262,1,0,0,0,276,263,1,0, + 0,0,276,264,1,0,0,0,276,265,1,0,0,0,276,266,1,0,0,0,276,267,1,0, + 0,0,276,268,1,0,0,0,276,269,1,0,0,0,276,270,1,0,0,0,276,271,1,0, + 0,0,276,272,1,0,0,0,276,273,1,0,0,0,276,274,1,0,0,0,276,275,1,0, + 0,0,277,21,1,0,0,0,278,283,3,24,12,0,279,280,5,116,0,0,280,281,3, + 164,82,0,281,282,5,117,0,0,282,284,1,0,0,0,283,279,1,0,0,0,283,284, + 1,0,0,0,284,285,1,0,0,0,285,286,5,107,0,0,286,287,3,18,9,0,287,23, + 1,0,0,0,288,289,3,26,13,0,289,290,3,168,84,0,290,292,5,114,0,0,291, + 293,3,36,18,0,292,291,1,0,0,0,292,293,1,0,0,0,293,294,1,0,0,0,294, + 295,5,115,0,0,295,310,1,0,0,0,296,297,3,28,14,0,297,298,3,168,84, + 0,298,300,5,114,0,0,299,301,3,38,19,0,300,299,1,0,0,0,300,301,1, + 0,0,0,301,302,1,0,0,0,302,303,5,115,0,0,303,310,1,0,0,0,304,305, + 3,168,84,0,305,306,5,114,0,0,306,307,3,30,15,0,307,308,5,115,0,0, + 308,310,1,0,0,0,309,288,1,0,0,0,309,296,1,0,0,0,309,304,1,0,0,0, + 310,25,1,0,0,0,311,312,5,9,0,0,312,313,5,128,0,0,313,314,5,114,0, + 0,314,319,3,104,52,0,315,316,5,118,0,0,316,318,3,104,52,0,317,315, + 1,0,0,0,318,321,1,0,0,0,319,317,1,0,0,0,319,320,1,0,0,0,320,322, + 1,0,0,0,321,319,1,0,0,0,322,323,5,115,0,0,323,324,5,107,0,0,324, + 325,3,28,14,0,325,27,1,0,0,0,326,335,5,114,0,0,327,332,3,32,16,0, + 328,329,5,118,0,0,329,331,3,32,16,0,330,328,1,0,0,0,331,334,1,0, + 0,0,332,330,1,0,0,0,332,333,1,0,0,0,333,336,1,0,0,0,334,332,1,0, + 0,0,335,327,1,0,0,0,335,336,1,0,0,0,336,337,1,0,0,0,337,338,5,115, + 0,0,338,29,1,0,0,0,339,340,3,32,16,0,340,341,5,101,0,0,341,342,3, + 104,52,0,342,31,1,0,0,0,343,352,5,114,0,0,344,349,3,34,17,0,345, + 346,5,118,0,0,346,348,3,34,17,0,347,345,1,0,0,0,348,351,1,0,0,0, + 349,347,1,0,0,0,349,350,1,0,0,0,350,353,1,0,0,0,351,349,1,0,0,0, + 352,344,1,0,0,0,352,353,1,0,0,0,353,354,1,0,0,0,354,355,5,115,0, + 0,355,33,1,0,0,0,356,368,5,45,0,0,357,368,3,44,22,0,358,368,5,27, + 0,0,359,368,5,46,0,0,360,368,5,31,0,0,361,368,5,30,0,0,362,368,5, + 29,0,0,363,368,5,28,0,0,364,368,5,42,0,0,365,368,5,43,0,0,366,368, + 5,44,0,0,367,356,1,0,0,0,367,357,1,0,0,0,367,358,1,0,0,0,367,359, + 1,0,0,0,367,360,1,0,0,0,367,361,1,0,0,0,367,362,1,0,0,0,367,363, + 1,0,0,0,367,364,1,0,0,0,367,365,1,0,0,0,367,366,1,0,0,0,368,35,1, + 0,0,0,369,374,3,40,20,0,370,371,5,118,0,0,371,373,3,40,20,0,372, + 370,1,0,0,0,373,376,1,0,0,0,374,372,1,0,0,0,374,375,1,0,0,0,375, + 37,1,0,0,0,376,374,1,0,0,0,377,382,3,42,21,0,378,379,5,118,0,0,379, + 381,3,42,21,0,380,378,1,0,0,0,381,384,1,0,0,0,382,380,1,0,0,0,382, + 383,1,0,0,0,383,39,1,0,0,0,384,382,1,0,0,0,385,386,5,128,0,0,386, + 387,5,122,0,0,387,390,5,48,0,0,388,390,3,20,10,0,389,385,1,0,0,0, + 389,388,1,0,0,0,390,41,1,0,0,0,391,392,5,48,0,0,392,393,5,101,0, + 0,393,396,3,104,52,0,394,396,3,20,10,0,395,391,1,0,0,0,395,394,1, + 0,0,0,396,43,1,0,0,0,397,401,5,25,0,0,398,401,5,24,0,0,399,401,3, + 46,23,0,400,397,1,0,0,0,400,398,1,0,0,0,400,399,1,0,0,0,401,45,1, + 0,0,0,402,403,7,1,0,0,403,47,1,0,0,0,404,405,5,45,0,0,405,406,5, + 101,0,0,406,407,3,104,52,0,407,49,1,0,0,0,408,409,5,24,0,0,409,410, + 5,101,0,0,410,411,3,114,57,0,411,51,1,0,0,0,412,413,3,44,22,0,413, + 414,5,101,0,0,414,415,3,116,58,0,415,53,1,0,0,0,416,417,3,44,22, + 0,417,418,5,101,0,0,418,419,3,138,69,0,419,55,1,0,0,0,420,421,5, + 27,0,0,421,422,5,101,0,0,422,423,3,108,54,0,423,57,1,0,0,0,424,425, + 5,46,0,0,425,426,5,101,0,0,426,427,3,110,55,0,427,59,1,0,0,0,428, + 429,5,31,0,0,429,430,5,101,0,0,430,431,3,118,59,0,431,61,1,0,0,0, + 432,433,5,30,0,0,433,434,5,101,0,0,434,435,3,120,60,0,435,63,1,0, + 0,0,436,437,5,29,0,0,437,438,5,101,0,0,438,439,3,122,61,0,439,65, + 1,0,0,0,440,441,5,28,0,0,441,442,5,101,0,0,442,443,3,124,62,0,443, + 67,1,0,0,0,444,445,5,42,0,0,445,446,5,101,0,0,446,447,3,126,63,0, + 447,69,1,0,0,0,448,449,5,43,0,0,449,450,5,101,0,0,450,451,3,128, + 64,0,451,71,1,0,0,0,452,453,5,44,0,0,453,454,5,101,0,0,454,455,3, + 130,65,0,455,73,1,0,0,0,456,457,5,46,0,0,457,458,5,101,0,0,458,459, + 3,132,66,0,459,75,1,0,0,0,460,461,5,46,0,0,461,462,5,101,0,0,462, + 463,3,134,67,0,463,77,1,0,0,0,464,465,5,46,0,0,465,466,5,101,0,0, + 466,467,3,136,68,0,467,79,1,0,0,0,468,469,5,30,0,0,469,470,5,101, + 0,0,470,471,3,140,70,0,471,81,1,0,0,0,472,473,5,29,0,0,473,474,5, + 101,0,0,474,475,3,142,71,0,475,83,1,0,0,0,476,477,5,28,0,0,477,478, + 5,101,0,0,478,479,3,144,72,0,479,85,1,0,0,0,480,481,3,94,47,0,481, + 482,5,101,0,0,482,483,3,146,73,0,483,87,1,0,0,0,484,485,3,98,49, + 0,485,486,5,101,0,0,486,487,3,148,74,0,487,89,1,0,0,0,488,489,3, + 34,17,0,489,490,5,101,0,0,490,491,5,83,0,0,491,493,5,128,0,0,492, + 494,5,120,0,0,493,492,1,0,0,0,493,494,1,0,0,0,494,91,1,0,0,0,495, + 496,5,128,0,0,496,497,5,101,0,0,497,498,5,47,0,0,498,93,1,0,0,0, + 499,508,5,116,0,0,500,505,3,96,48,0,501,502,5,118,0,0,502,504,3, + 96,48,0,503,501,1,0,0,0,504,507,1,0,0,0,505,503,1,0,0,0,505,506, + 1,0,0,0,506,509,1,0,0,0,507,505,1,0,0,0,508,500,1,0,0,0,508,509, + 1,0,0,0,509,510,1,0,0,0,510,511,5,117,0,0,511,95,1,0,0,0,512,515, + 3,34,17,0,513,515,3,94,47,0,514,512,1,0,0,0,514,513,1,0,0,0,515, + 97,1,0,0,0,516,517,5,114,0,0,517,518,3,100,50,0,518,519,5,126,0, + 0,519,520,3,102,51,0,520,521,5,115,0,0,521,99,1,0,0,0,522,533,5, + 128,0,0,523,524,5,114,0,0,524,527,5,128,0,0,525,526,5,118,0,0,526, + 528,5,128,0,0,527,525,1,0,0,0,528,529,1,0,0,0,529,527,1,0,0,0,529, + 530,1,0,0,0,530,531,1,0,0,0,531,533,5,115,0,0,532,522,1,0,0,0,532, + 523,1,0,0,0,533,101,1,0,0,0,534,535,3,168,84,0,535,536,5,114,0,0, + 536,537,3,16,8,0,537,538,5,115,0,0,538,103,1,0,0,0,539,542,3,106, + 53,0,540,542,3,152,76,0,541,539,1,0,0,0,541,540,1,0,0,0,542,105, + 1,0,0,0,543,563,3,108,54,0,544,563,3,114,57,0,545,563,3,116,58,0, + 546,563,3,110,55,0,547,563,3,112,56,0,548,563,3,122,61,0,549,563, + 3,124,62,0,550,563,3,118,59,0,551,563,3,120,60,0,552,563,3,126,63, + 0,553,555,5,71,0,0,554,556,5,120,0,0,555,554,1,0,0,0,555,556,1,0, + 0,0,556,563,1,0,0,0,557,558,5,83,0,0,558,560,5,128,0,0,559,561,5, + 120,0,0,560,559,1,0,0,0,560,561,1,0,0,0,561,563,1,0,0,0,562,543, + 1,0,0,0,562,544,1,0,0,0,562,545,1,0,0,0,562,546,1,0,0,0,562,547, + 1,0,0,0,562,548,1,0,0,0,562,549,1,0,0,0,562,550,1,0,0,0,562,551, + 1,0,0,0,562,552,1,0,0,0,562,553,1,0,0,0,562,557,1,0,0,0,563,107, + 1,0,0,0,564,566,7,2,0,0,565,567,5,120,0,0,566,565,1,0,0,0,566,567, + 1,0,0,0,567,109,1,0,0,0,568,570,7,3,0,0,569,571,5,120,0,0,570,569, + 1,0,0,0,570,571,1,0,0,0,571,111,1,0,0,0,572,574,7,4,0,0,573,575, + 5,120,0,0,574,573,1,0,0,0,574,575,1,0,0,0,575,113,1,0,0,0,576,578, + 7,5,0,0,577,579,5,120,0,0,578,577,1,0,0,0,578,579,1,0,0,0,579,115, + 1,0,0,0,580,582,7,6,0,0,581,583,5,120,0,0,582,581,1,0,0,0,582,583, + 1,0,0,0,583,117,1,0,0,0,584,586,5,66,0,0,585,587,5,120,0,0,586,585, + 1,0,0,0,586,587,1,0,0,0,587,119,1,0,0,0,588,590,5,67,0,0,589,591, + 5,120,0,0,590,589,1,0,0,0,590,591,1,0,0,0,591,121,1,0,0,0,592,594, + 7,7,0,0,593,595,5,120,0,0,594,593,1,0,0,0,594,595,1,0,0,0,595,123, + 1,0,0,0,596,598,7,8,0,0,597,599,5,120,0,0,598,597,1,0,0,0,598,599, + 1,0,0,0,599,125,1,0,0,0,600,602,7,9,0,0,601,603,5,120,0,0,602,601, + 1,0,0,0,602,603,1,0,0,0,603,127,1,0,0,0,604,606,7,10,0,0,605,607, + 5,120,0,0,606,605,1,0,0,0,606,607,1,0,0,0,607,612,1,0,0,0,608,609, + 5,40,0,0,609,610,3,154,77,0,610,611,5,41,0,0,611,613,1,0,0,0,612, + 608,1,0,0,0,612,613,1,0,0,0,613,129,1,0,0,0,614,616,7,11,0,0,615, + 617,5,120,0,0,616,615,1,0,0,0,616,617,1,0,0,0,617,622,1,0,0,0,618, + 619,5,40,0,0,619,620,3,154,77,0,620,621,5,41,0,0,621,623,1,0,0,0, + 622,618,1,0,0,0,622,623,1,0,0,0,623,131,1,0,0,0,624,626,7,12,0,0, + 625,627,5,120,0,0,626,625,1,0,0,0,626,627,1,0,0,0,627,628,1,0,0, + 0,628,629,5,40,0,0,629,630,3,154,77,0,630,631,5,41,0,0,631,133,1, + 0,0,0,632,634,7,13,0,0,633,635,5,120,0,0,634,633,1,0,0,0,634,635, + 1,0,0,0,635,636,1,0,0,0,636,637,5,40,0,0,637,638,3,154,77,0,638, + 639,5,41,0,0,639,135,1,0,0,0,640,642,7,14,0,0,641,643,5,120,0,0, + 642,641,1,0,0,0,642,643,1,0,0,0,643,644,1,0,0,0,644,645,5,40,0,0, + 645,646,3,154,77,0,646,647,5,41,0,0,647,137,1,0,0,0,648,650,7,15, + 0,0,649,651,5,120,0,0,650,649,1,0,0,0,650,651,1,0,0,0,651,658,1, + 0,0,0,652,653,5,40,0,0,653,654,3,154,77,0,654,655,5,118,0,0,655, + 656,3,154,77,0,656,657,5,41,0,0,657,659,1,0,0,0,658,652,1,0,0,0, + 658,659,1,0,0,0,659,139,1,0,0,0,660,662,7,16,0,0,661,663,5,120,0, + 0,662,661,1,0,0,0,662,663,1,0,0,0,663,664,1,0,0,0,664,665,5,40,0, + 0,665,666,3,154,77,0,666,667,5,41,0,0,667,141,1,0,0,0,668,670,7, + 17,0,0,669,671,5,120,0,0,670,669,1,0,0,0,670,671,1,0,0,0,671,672, + 1,0,0,0,672,673,5,40,0,0,673,674,3,154,77,0,674,675,5,41,0,0,675, + 143,1,0,0,0,676,678,7,18,0,0,677,679,5,120,0,0,678,677,1,0,0,0,678, + 679,1,0,0,0,679,680,1,0,0,0,680,681,5,40,0,0,681,682,3,154,77,0, + 682,683,5,41,0,0,683,145,1,0,0,0,684,686,5,81,0,0,685,687,5,120, + 0,0,686,685,1,0,0,0,686,687,1,0,0,0,687,688,1,0,0,0,688,689,5,40, + 0,0,689,690,3,104,52,0,690,691,5,41,0,0,691,147,1,0,0,0,692,694, + 5,54,0,0,693,695,5,120,0,0,694,693,1,0,0,0,694,695,1,0,0,0,695,696, + 1,0,0,0,696,697,5,40,0,0,697,698,3,150,75,0,698,699,5,126,0,0,699, + 700,3,104,52,0,700,701,5,41,0,0,701,149,1,0,0,0,702,715,3,104,52, + 0,703,704,5,114,0,0,704,709,3,104,52,0,705,706,5,118,0,0,706,708, + 3,104,52,0,707,705,1,0,0,0,708,711,1,0,0,0,709,707,1,0,0,0,709,710, + 1,0,0,0,710,712,1,0,0,0,711,709,1,0,0,0,712,713,5,115,0,0,713,715, + 1,0,0,0,714,702,1,0,0,0,714,703,1,0,0,0,715,151,1,0,0,0,716,728, + 3,132,66,0,717,728,3,134,67,0,718,728,3,136,68,0,719,728,3,138,69, + 0,720,728,3,128,64,0,721,728,3,130,65,0,722,728,3,140,70,0,723,728, + 3,142,71,0,724,728,3,144,72,0,725,728,3,146,73,0,726,728,3,148,74, + 0,727,716,1,0,0,0,727,717,1,0,0,0,727,718,1,0,0,0,727,719,1,0,0, + 0,727,720,1,0,0,0,727,721,1,0,0,0,727,722,1,0,0,0,727,723,1,0,0, + 0,727,724,1,0,0,0,727,725,1,0,0,0,727,726,1,0,0,0,728,153,1,0,0, + 0,729,730,5,24,0,0,730,155,1,0,0,0,731,732,7,19,0,0,732,157,1,0, + 0,0,733,734,3,160,80,0,734,735,5,119,0,0,735,736,3,162,81,0,736, + 159,1,0,0,0,737,738,7,20,0,0,738,161,1,0,0,0,739,740,7,21,0,0,740, + 163,1,0,0,0,741,746,3,158,79,0,742,743,5,118,0,0,743,745,3,158,79, + 0,744,742,1,0,0,0,745,748,1,0,0,0,746,744,1,0,0,0,746,747,1,0,0, + 0,747,165,1,0,0,0,748,746,1,0,0,0,749,750,7,22,0,0,750,167,1,0,0, + 0,751,754,3,166,83,0,752,754,5,128,0,0,753,751,1,0,0,0,753,752,1, + 0,0,0,754,169,1,0,0,0,66,174,183,199,217,223,228,231,236,238,245, + 250,276,283,292,300,309,319,332,335,349,352,367,374,382,389,395, + 400,493,505,508,514,529,532,541,555,560,562,566,570,574,578,582, + 586,590,594,598,602,606,612,616,622,626,634,642,650,658,662,670, + 678,686,694,709,714,727,746,753 ] class FuncTestCaseParser ( Parser ): @@ -402,45 +406,46 @@ class FuncTestCaseParser ( Parser ): RULE_precisionTimestampTZArg = 42 RULE_listArg = 43 RULE_lambdaArg = 44 - RULE_enumArg = 45 - RULE_literalList = 46 - RULE_listElement = 47 - RULE_literalLambda = 48 - RULE_lambdaParameters = 49 - RULE_lambdaBody = 50 - RULE_dataType = 51 - RULE_scalarType = 52 - RULE_booleanType = 53 - RULE_stringType = 54 - RULE_binaryType = 55 - RULE_intType = 56 - RULE_floatType = 57 - RULE_dateType = 58 - RULE_timeType = 59 - RULE_timestampType = 60 - RULE_timestampTZType = 61 - RULE_intervalYearType = 62 - RULE_intervalDayType = 63 - RULE_intervalCompoundType = 64 - RULE_fixedCharType = 65 - RULE_varCharType = 66 - RULE_fixedBinaryType = 67 - RULE_decimalType = 68 - RULE_precisionTimeType = 69 - RULE_precisionTimestampType = 70 - RULE_precisionTimestampTZType = 71 - RULE_listType = 72 - RULE_funcType = 73 - RULE_funcParameters = 74 - RULE_parameterizedType = 75 - RULE_numericParameter = 76 - RULE_substraitError = 77 - RULE_funcOption = 78 - RULE_optionName = 79 - RULE_optionValue = 80 - RULE_funcOptions = 81 - RULE_nonReserved = 82 - RULE_identifier = 83 + RULE_udtArg = 45 + RULE_enumArg = 46 + RULE_literalList = 47 + RULE_listElement = 48 + RULE_literalLambda = 49 + RULE_lambdaParameters = 50 + RULE_lambdaBody = 51 + RULE_dataType = 52 + RULE_scalarType = 53 + RULE_booleanType = 54 + RULE_stringType = 55 + RULE_binaryType = 56 + RULE_intType = 57 + RULE_floatType = 58 + RULE_dateType = 59 + RULE_timeType = 60 + RULE_timestampType = 61 + RULE_timestampTZType = 62 + RULE_intervalYearType = 63 + RULE_intervalDayType = 64 + RULE_intervalCompoundType = 65 + RULE_fixedCharType = 66 + RULE_varCharType = 67 + RULE_fixedBinaryType = 68 + RULE_decimalType = 69 + RULE_precisionTimeType = 70 + RULE_precisionTimestampType = 71 + RULE_precisionTimestampTZType = 72 + RULE_listType = 73 + RULE_funcType = 74 + RULE_funcParameters = 75 + RULE_parameterizedType = 76 + RULE_numericParameter = 77 + RULE_substraitError = 78 + RULE_funcOption = 79 + RULE_optionName = 80 + RULE_optionValue = 81 + RULE_funcOptions = 82 + RULE_nonReserved = 83 + RULE_identifier = 84 ruleNames = [ "doc", "header", "version", "include", "dependency", "testGroupDescription", "testCase", "testGroup", "arguments", @@ -453,13 +458,14 @@ class FuncTestCaseParser ( Parser ): "timestampTzArg", "intervalYearArg", "intervalDayArg", "intervalCompoundArg", "fixedCharArg", "varCharArg", "fixedBinaryArg", "precisionTimeArg", "precisionTimestampArg", - "precisionTimestampTZArg", "listArg", "lambdaArg", "enumArg", - "literalList", "listElement", "literalLambda", "lambdaParameters", - "lambdaBody", "dataType", "scalarType", "booleanType", - "stringType", "binaryType", "intType", "floatType", "dateType", - "timeType", "timestampType", "timestampTZType", "intervalYearType", - "intervalDayType", "intervalCompoundType", "fixedCharType", - "varCharType", "fixedBinaryType", "decimalType", "precisionTimeType", + "precisionTimestampTZArg", "listArg", "lambdaArg", "udtArg", + "enumArg", "literalList", "listElement", "literalLambda", + "lambdaParameters", "lambdaBody", "dataType", "scalarType", + "booleanType", "stringType", "binaryType", "intType", + "floatType", "dateType", "timeType", "timestampType", + "timestampTZType", "intervalYearType", "intervalDayType", + "intervalCompoundType", "fixedCharType", "varCharType", + "fixedBinaryType", "decimalType", "precisionTimeType", "precisionTimestampType", "precisionTimestampTZType", "listType", "funcType", "funcParameters", "parameterizedType", "numericParameter", "substraitError", "funcOption", "optionName", @@ -653,21 +659,21 @@ def doc(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 168 + self.state = 170 self.header() - self.state = 170 + self.state = 172 self._errHandler.sync(self) _la = self._input.LA(1) while True: - self.state = 169 + self.state = 171 self.testGroup() - self.state = 172 + self.state = 174 self._errHandler.sync(self) _la = self._input.LA(1) if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 8389376) != 0) or ((((_la - 114)) & ~0x3f) == 0 and ((1 << (_la - 114)) & 17921) != 0)): break - self.state = 174 + self.state = 176 self.match(FuncTestCaseParser.EOF) except RecognitionException as re: localctx.exception = re @@ -727,17 +733,17 @@ def header(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 176 + self.state = 178 self.version() - self.state = 177 + self.state = 179 self.include() - self.state = 181 + self.state = 183 self._errHandler.sync(self) _la = self._input.LA(1) while _la==2: - self.state = 178 + self.state = 180 self.dependency() - self.state = 183 + self.state = 185 self._errHandler.sync(self) _la = self._input.LA(1) @@ -799,18 +805,18 @@ def version(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 184 + self.state = 186 self.match(FuncTestCaseParser.TripleHash) - self.state = 185 + self.state = 187 _la = self._input.LA(1) if not(_la==3 or _la==4): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 186 + self.state = 188 self.match(FuncTestCaseParser.Colon) - self.state = 187 + self.state = 189 self.match(FuncTestCaseParser.FormatVersion) except RecognitionException as re: localctx.exception = re @@ -876,23 +882,23 @@ def include(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 189 + self.state = 191 self.match(FuncTestCaseParser.TripleHash) - self.state = 190 + self.state = 192 self.match(FuncTestCaseParser.SubstraitInclude) - self.state = 191 + self.state = 193 self.match(FuncTestCaseParser.Colon) - self.state = 192 + self.state = 194 self.match(FuncTestCaseParser.StringLiteral) - self.state = 197 + self.state = 199 self._errHandler.sync(self) _la = self._input.LA(1) while _la==118: - self.state = 193 + self.state = 195 self.match(FuncTestCaseParser.Comma) - self.state = 194 + self.state = 196 self.match(FuncTestCaseParser.StringLiteral) - self.state = 199 + self.state = 201 self._errHandler.sync(self) _la = self._input.LA(1) @@ -950,13 +956,13 @@ def dependency(self): self.enterRule(localctx, 8, self.RULE_dependency) try: self.enterOuterAlt(localctx, 1) - self.state = 200 + self.state = 202 self.match(FuncTestCaseParser.TripleHash) - self.state = 201 + self.state = 203 self.match(FuncTestCaseParser.SubstraitDependency) - self.state = 202 + self.state = 204 self.match(FuncTestCaseParser.Colon) - self.state = 203 + self.state = 205 self.match(FuncTestCaseParser.StringLiteral) except RecognitionException as re: localctx.exception = re @@ -1003,7 +1009,7 @@ def testGroupDescription(self): self.enterRule(localctx, 10, self.RULE_testGroupDescription) try: self.enterOuterAlt(localctx, 1) - self.state = 205 + self.state = 207 self.match(FuncTestCaseParser.DescriptionLine) except RecognitionException as re: localctx.exception = re @@ -1080,29 +1086,29 @@ def testCase(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 207 + self.state = 209 localctx.functionName = self.identifier() - self.state = 208 + self.state = 210 self.match(FuncTestCaseParser.OParen) - self.state = 209 + self.state = 211 self.arguments() - self.state = 210 + self.state = 212 self.match(FuncTestCaseParser.CParen) - self.state = 215 + self.state = 217 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 211 + self.state = 213 self.match(FuncTestCaseParser.OBracket) - self.state = 212 + self.state = 214 self.funcOptions() - self.state = 213 + self.state = 215 self.match(FuncTestCaseParser.CBracket) - self.state = 217 + self.state = 219 self.match(FuncTestCaseParser.Eq) - self.state = 218 + self.state = 220 self.result() except RecognitionException as re: localctx.exception = re @@ -1199,31 +1205,31 @@ def testGroup(self): self.enterRule(localctx, 14, self.RULE_testGroup) self._la = 0 # Token type try: - self.state = 236 + self.state = 238 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,8,self._ctx) if la_ == 1: localctx = FuncTestCaseParser.ScalarFuncTestGroupContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 221 + self.state = 223 self._errHandler.sync(self) _la = self._input.LA(1) if _la==8: - self.state = 220 + self.state = 222 self.testGroupDescription() - self.state = 224 + self.state = 226 self._errHandler.sync(self) _alt = 1 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt == 1: - self.state = 223 + self.state = 225 self.testCase() else: raise NoViableAltException(self) - self.state = 226 + self.state = 228 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,5,self._ctx) @@ -1232,25 +1238,25 @@ def testGroup(self): elif la_ == 2: localctx = FuncTestCaseParser.AggregateFuncTestGroupContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 229 + self.state = 231 self._errHandler.sync(self) _la = self._input.LA(1) if _la==8: - self.state = 228 + self.state = 230 self.testGroupDescription() - self.state = 232 + self.state = 234 self._errHandler.sync(self) _alt = 1 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt == 1: - self.state = 231 + self.state = 233 self.aggFuncTestCase() else: raise NoViableAltException(self) - self.state = 234 + self.state = 236 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,7,self._ctx) @@ -1313,17 +1319,17 @@ def arguments(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 238 + self.state = 240 self.argument() - self.state = 243 + self.state = 245 self._errHandler.sync(self) _la = self._input.LA(1) while _la==118: - self.state = 239 + self.state = 241 self.match(FuncTestCaseParser.Comma) - self.state = 240 + self.state = 242 self.argument() - self.state = 245 + self.state = 247 self._errHandler.sync(self) _la = self._input.LA(1) @@ -1376,17 +1382,17 @@ def result(self): localctx = FuncTestCaseParser.ResultContext(self, self._ctx, self.state) self.enterRule(localctx, 18, self.RULE_result) try: - self.state = 248 + self.state = 250 self._errHandler.sync(self) token = self._input.LA(1) if token in [18, 24, 25, 26, 27, 28, 29, 30, 31, 42, 43, 44, 45, 46, 114, 116, 128]: self.enterOuterAlt(localctx, 1) - self.state = 246 + self.state = 248 self.argument() pass elif token in [10, 11]: self.enterOuterAlt(localctx, 2) - self.state = 247 + self.state = 249 self.substraitError() pass else: @@ -1408,6 +1414,10 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): super().__init__(parent, invokingState) self.parser = parser + def udtArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.UdtArgContext,0) + + def nullArg(self): return self.getTypedRuleContext(FuncTestCaseParser.NullArgContext,0) @@ -1524,144 +1534,150 @@ def argument(self): localctx = FuncTestCaseParser.ArgumentContext(self, self._ctx, self.state) self.enterRule(localctx, 20, self.RULE_argument) try: - self.state = 273 + self.state = 276 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,11,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) - self.state = 250 - self.nullArg() + self.state = 252 + self.udtArg() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) - self.state = 251 - self.enumArg() + self.state = 253 + self.nullArg() pass elif la_ == 3: self.enterOuterAlt(localctx, 3) - self.state = 252 - self.intArg() + self.state = 254 + self.enumArg() pass elif la_ == 4: self.enterOuterAlt(localctx, 4) - self.state = 253 - self.floatArg() + self.state = 255 + self.intArg() pass elif la_ == 5: self.enterOuterAlt(localctx, 5) - self.state = 254 - self.booleanArg() + self.state = 256 + self.floatArg() pass elif la_ == 6: self.enterOuterAlt(localctx, 6) - self.state = 255 - self.stringArg() + self.state = 257 + self.booleanArg() pass elif la_ == 7: self.enterOuterAlt(localctx, 7) - self.state = 256 - self.decimalArg() + self.state = 258 + self.stringArg() pass elif la_ == 8: self.enterOuterAlt(localctx, 8) - self.state = 257 - self.dateArg() + self.state = 259 + self.decimalArg() pass elif la_ == 9: self.enterOuterAlt(localctx, 9) - self.state = 258 - self.timeArg() + self.state = 260 + self.dateArg() pass elif la_ == 10: self.enterOuterAlt(localctx, 10) - self.state = 259 - self.timestampArg() + self.state = 261 + self.timeArg() pass elif la_ == 11: self.enterOuterAlt(localctx, 11) - self.state = 260 - self.timestampTzArg() + self.state = 262 + self.timestampArg() pass elif la_ == 12: self.enterOuterAlt(localctx, 12) - self.state = 261 - self.intervalYearArg() + self.state = 263 + self.timestampTzArg() pass elif la_ == 13: self.enterOuterAlt(localctx, 13) - self.state = 262 - self.intervalDayArg() + self.state = 264 + self.intervalYearArg() pass elif la_ == 14: self.enterOuterAlt(localctx, 14) - self.state = 263 - self.intervalCompoundArg() + self.state = 265 + self.intervalDayArg() pass elif la_ == 15: self.enterOuterAlt(localctx, 15) - self.state = 264 - self.fixedCharArg() + self.state = 266 + self.intervalCompoundArg() pass elif la_ == 16: self.enterOuterAlt(localctx, 16) - self.state = 265 - self.varCharArg() + self.state = 267 + self.fixedCharArg() pass elif la_ == 17: self.enterOuterAlt(localctx, 17) - self.state = 266 - self.fixedBinaryArg() + self.state = 268 + self.varCharArg() pass elif la_ == 18: self.enterOuterAlt(localctx, 18) - self.state = 267 - self.precisionTimeArg() + self.state = 269 + self.fixedBinaryArg() pass elif la_ == 19: self.enterOuterAlt(localctx, 19) - self.state = 268 - self.precisionTimestampArg() + self.state = 270 + self.precisionTimeArg() pass elif la_ == 20: self.enterOuterAlt(localctx, 20) - self.state = 269 - self.precisionTimestampTZArg() + self.state = 271 + self.precisionTimestampArg() pass elif la_ == 21: self.enterOuterAlt(localctx, 21) - self.state = 270 - self.listArg() + self.state = 272 + self.precisionTimestampTZArg() pass elif la_ == 22: self.enterOuterAlt(localctx, 22) - self.state = 271 - self.lambdaArg() + self.state = 273 + self.listArg() pass elif la_ == 23: self.enterOuterAlt(localctx, 23) - self.state = 272 + self.state = 274 + self.lambdaArg() + pass + + elif la_ == 24: + self.enterOuterAlt(localctx, 24) + self.state = 275 self.match(FuncTestCaseParser.Identifier) pass @@ -1730,23 +1746,23 @@ def aggFuncTestCase(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 275 + self.state = 278 self.aggFuncCall() - self.state = 280 + self.state = 283 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 276 + self.state = 279 self.match(FuncTestCaseParser.OBracket) - self.state = 277 + self.state = 280 self.funcOptions() - self.state = 278 + self.state = 281 self.match(FuncTestCaseParser.CBracket) - self.state = 282 + self.state = 285 self.match(FuncTestCaseParser.Eq) - self.state = 283 + self.state = 286 self.result() except RecognitionException as re: localctx.exception = re @@ -1886,59 +1902,59 @@ def aggFuncCall(self): self.enterRule(localctx, 24, self.RULE_aggFuncCall) self._la = 0 # Token type try: - self.state = 306 + self.state = 309 self._errHandler.sync(self) token = self._input.LA(1) if token in [9]: localctx = FuncTestCaseParser.MultiArgAggregateFuncCallContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 285 + self.state = 288 self.tableData() - self.state = 286 + self.state = 289 localctx.funcName = self.identifier() - self.state = 287 + self.state = 290 self.match(FuncTestCaseParser.OParen) - self.state = 289 + self.state = 292 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 136343720296448) != 0) or ((((_la - 114)) & ~0x3f) == 0 and ((1 << (_la - 114)) & 16389) != 0): - self.state = 288 + self.state = 291 self.qualifiedAggregateFuncArgs() - self.state = 291 + self.state = 294 self.match(FuncTestCaseParser.CParen) pass elif token in [114]: localctx = FuncTestCaseParser.CompactAggregateFuncCallContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 293 + self.state = 296 self.tableRows() - self.state = 294 + self.state = 297 localctx.functName = self.identifier() - self.state = 295 + self.state = 298 self.match(FuncTestCaseParser.OParen) - self.state = 297 + self.state = 300 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 417818697007104) != 0) or ((((_la - 114)) & ~0x3f) == 0 and ((1 << (_la - 114)) & 16389) != 0): - self.state = 296 + self.state = 299 self.aggregateFuncArgs() - self.state = 299 + self.state = 302 self.match(FuncTestCaseParser.CParen) pass elif token in [23, 123, 124, 128]: localctx = FuncTestCaseParser.SingleArgAggregateFuncCallContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 301 + self.state = 304 localctx.functName = self.identifier() - self.state = 302 + self.state = 305 self.match(FuncTestCaseParser.OParen) - self.state = 303 + self.state = 306 self.dataColumn() - self.state = 304 + self.state = 307 self.match(FuncTestCaseParser.CParen) pass else: @@ -2020,31 +2036,31 @@ def tableData(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 308 + self.state = 311 self.match(FuncTestCaseParser.Define) - self.state = 309 + self.state = 312 localctx.tableName = self.match(FuncTestCaseParser.Identifier) - self.state = 310 + self.state = 313 self.match(FuncTestCaseParser.OParen) - self.state = 311 + self.state = 314 self.dataType() - self.state = 316 + self.state = 319 self._errHandler.sync(self) _la = self._input.LA(1) while _la==118: - self.state = 312 + self.state = 315 self.match(FuncTestCaseParser.Comma) - self.state = 313 + self.state = 316 self.dataType() - self.state = 318 + self.state = 321 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 319 + self.state = 322 self.match(FuncTestCaseParser.CParen) - self.state = 320 + self.state = 323 self.match(FuncTestCaseParser.Eq) - self.state = 321 + self.state = 324 self.tableRows() except RecognitionException as re: localctx.exception = re @@ -2108,29 +2124,29 @@ def tableRows(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 323 + self.state = 326 self.match(FuncTestCaseParser.OParen) - self.state = 332 + self.state = 335 self._errHandler.sync(self) _la = self._input.LA(1) if _la==114: - self.state = 324 + self.state = 327 self.columnValues() - self.state = 329 + self.state = 332 self._errHandler.sync(self) _la = self._input.LA(1) while _la==118: - self.state = 325 + self.state = 328 self.match(FuncTestCaseParser.Comma) - self.state = 326 + self.state = 329 self.columnValues() - self.state = 331 + self.state = 334 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 334 + self.state = 337 self.match(FuncTestCaseParser.CParen) except RecognitionException as re: localctx.exception = re @@ -2185,11 +2201,11 @@ def dataColumn(self): self.enterRule(localctx, 30, self.RULE_dataColumn) try: self.enterOuterAlt(localctx, 1) - self.state = 336 + self.state = 339 self.columnValues() - self.state = 337 + self.state = 340 self.match(FuncTestCaseParser.DoubleColon) - self.state = 338 + self.state = 341 self.dataType() except RecognitionException as re: localctx.exception = re @@ -2253,29 +2269,29 @@ def columnValues(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 340 + self.state = 343 self.match(FuncTestCaseParser.OParen) - self.state = 349 + self.state = 352 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 136343720296448) != 0): - self.state = 341 + self.state = 344 self.literal() - self.state = 346 + self.state = 349 self._errHandler.sync(self) _la = self._input.LA(1) while _la==118: - self.state = 342 + self.state = 345 self.match(FuncTestCaseParser.Comma) - self.state = 343 + self.state = 346 self.literal() - self.state = 348 + self.state = 351 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 351 + self.state = 354 self.match(FuncTestCaseParser.CParen) except RecognitionException as re: localctx.exception = re @@ -2352,62 +2368,62 @@ def literal(self): localctx = FuncTestCaseParser.LiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 34, self.RULE_literal) try: - self.state = 364 + self.state = 367 self._errHandler.sync(self) token = self._input.LA(1) if token in [45]: self.enterOuterAlt(localctx, 1) - self.state = 353 + self.state = 356 self.match(FuncTestCaseParser.NullLiteral) pass elif token in [18, 24, 25, 26]: self.enterOuterAlt(localctx, 2) - self.state = 354 + self.state = 357 self.numericLiteral() pass elif token in [27]: self.enterOuterAlt(localctx, 3) - self.state = 355 + self.state = 358 self.match(FuncTestCaseParser.BooleanLiteral) pass elif token in [46]: self.enterOuterAlt(localctx, 4) - self.state = 356 + self.state = 359 self.match(FuncTestCaseParser.StringLiteral) pass elif token in [31]: self.enterOuterAlt(localctx, 5) - self.state = 357 + self.state = 360 self.match(FuncTestCaseParser.DateLiteral) pass elif token in [30]: self.enterOuterAlt(localctx, 6) - self.state = 358 + self.state = 361 self.match(FuncTestCaseParser.TimeLiteral) pass elif token in [29]: self.enterOuterAlt(localctx, 7) - self.state = 359 + self.state = 362 self.match(FuncTestCaseParser.TimestampLiteral) pass elif token in [28]: self.enterOuterAlt(localctx, 8) - self.state = 360 + self.state = 363 self.match(FuncTestCaseParser.TimestampTzLiteral) pass elif token in [42]: self.enterOuterAlt(localctx, 9) - self.state = 361 + self.state = 364 self.match(FuncTestCaseParser.IntervalYearLiteral) pass elif token in [43]: self.enterOuterAlt(localctx, 10) - self.state = 362 + self.state = 365 self.match(FuncTestCaseParser.IntervalDayLiteral) pass elif token in [44]: self.enterOuterAlt(localctx, 11) - self.state = 363 + self.state = 366 self.match(FuncTestCaseParser.IntervalCompoundLiteral) pass else: @@ -2469,17 +2485,17 @@ def qualifiedAggregateFuncArgs(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 366 + self.state = 369 self.qualifiedAggregateFuncArg() - self.state = 371 + self.state = 374 self._errHandler.sync(self) _la = self._input.LA(1) while _la==118: - self.state = 367 + self.state = 370 self.match(FuncTestCaseParser.Comma) - self.state = 368 + self.state = 371 self.qualifiedAggregateFuncArg() - self.state = 373 + self.state = 376 self._errHandler.sync(self) _la = self._input.LA(1) @@ -2539,17 +2555,17 @@ def aggregateFuncArgs(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 374 + self.state = 377 self.aggregateFuncArg() - self.state = 379 + self.state = 382 self._errHandler.sync(self) _la = self._input.LA(1) while _la==118: - self.state = 375 + self.state = 378 self.match(FuncTestCaseParser.Comma) - self.state = 376 + self.state = 379 self.aggregateFuncArg() - self.state = 381 + self.state = 384 self._errHandler.sync(self) _la = self._input.LA(1) @@ -2608,22 +2624,22 @@ def qualifiedAggregateFuncArg(self): localctx = FuncTestCaseParser.QualifiedAggregateFuncArgContext(self, self._ctx, self.state) self.enterRule(localctx, 40, self.RULE_qualifiedAggregateFuncArg) try: - self.state = 386 + self.state = 389 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,24,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) - self.state = 382 + self.state = 385 localctx.tableName = self.match(FuncTestCaseParser.Identifier) - self.state = 383 + self.state = 386 self.match(FuncTestCaseParser.Dot) - self.state = 384 + self.state = 387 self.match(FuncTestCaseParser.ColumnName) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) - self.state = 385 + self.state = 388 self.argument() pass @@ -2683,21 +2699,21 @@ def aggregateFuncArg(self): localctx = FuncTestCaseParser.AggregateFuncArgContext(self, self._ctx, self.state) self.enterRule(localctx, 42, self.RULE_aggregateFuncArg) try: - self.state = 392 + self.state = 395 self._errHandler.sync(self) token = self._input.LA(1) if token in [48]: self.enterOuterAlt(localctx, 1) - self.state = 388 + self.state = 391 self.match(FuncTestCaseParser.ColumnName) - self.state = 389 + self.state = 392 self.match(FuncTestCaseParser.DoubleColon) - self.state = 390 + self.state = 393 self.dataType() pass elif token in [18, 24, 25, 26, 27, 28, 29, 30, 31, 42, 43, 44, 45, 46, 114, 116, 128]: self.enterOuterAlt(localctx, 2) - self.state = 391 + self.state = 394 self.argument() pass else: @@ -2754,22 +2770,22 @@ def numericLiteral(self): localctx = FuncTestCaseParser.NumericLiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 44, self.RULE_numericLiteral) try: - self.state = 397 + self.state = 400 self._errHandler.sync(self) token = self._input.LA(1) if token in [25]: self.enterOuterAlt(localctx, 1) - self.state = 394 + self.state = 397 self.match(FuncTestCaseParser.DecimalLiteral) pass elif token in [24]: self.enterOuterAlt(localctx, 2) - self.state = 395 + self.state = 398 self.match(FuncTestCaseParser.IntegerLiteral) pass elif token in [18, 26]: self.enterOuterAlt(localctx, 3) - self.state = 396 + self.state = 399 self.floatLiteral() pass else: @@ -2824,7 +2840,7 @@ def floatLiteral(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 399 + self.state = 402 _la = self._input.LA(1) if not(_la==18 or _la==26): self._errHandler.recoverInline(self) @@ -2883,11 +2899,11 @@ def nullArg(self): self.enterRule(localctx, 48, self.RULE_nullArg) try: self.enterOuterAlt(localctx, 1) - self.state = 401 + self.state = 404 self.match(FuncTestCaseParser.NullLiteral) - self.state = 402 + self.state = 405 self.match(FuncTestCaseParser.DoubleColon) - self.state = 403 + self.state = 406 self.dataType() except RecognitionException as re: localctx.exception = re @@ -2941,11 +2957,11 @@ def intArg(self): self.enterRule(localctx, 50, self.RULE_intArg) try: self.enterOuterAlt(localctx, 1) - self.state = 405 + self.state = 408 self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 406 + self.state = 409 self.match(FuncTestCaseParser.DoubleColon) - self.state = 407 + self.state = 410 self.intType() except RecognitionException as re: localctx.exception = re @@ -3000,11 +3016,11 @@ def floatArg(self): self.enterRule(localctx, 52, self.RULE_floatArg) try: self.enterOuterAlt(localctx, 1) - self.state = 409 + self.state = 412 self.numericLiteral() - self.state = 410 + self.state = 413 self.match(FuncTestCaseParser.DoubleColon) - self.state = 411 + self.state = 414 self.floatType() except RecognitionException as re: localctx.exception = re @@ -3059,11 +3075,11 @@ def decimalArg(self): self.enterRule(localctx, 54, self.RULE_decimalArg) try: self.enterOuterAlt(localctx, 1) - self.state = 413 + self.state = 416 self.numericLiteral() - self.state = 414 + self.state = 417 self.match(FuncTestCaseParser.DoubleColon) - self.state = 415 + self.state = 418 self.decimalType() except RecognitionException as re: localctx.exception = re @@ -3117,11 +3133,11 @@ def booleanArg(self): self.enterRule(localctx, 56, self.RULE_booleanArg) try: self.enterOuterAlt(localctx, 1) - self.state = 417 + self.state = 420 self.match(FuncTestCaseParser.BooleanLiteral) - self.state = 418 + self.state = 421 self.match(FuncTestCaseParser.DoubleColon) - self.state = 419 + self.state = 422 self.booleanType() except RecognitionException as re: localctx.exception = re @@ -3175,11 +3191,11 @@ def stringArg(self): self.enterRule(localctx, 58, self.RULE_stringArg) try: self.enterOuterAlt(localctx, 1) - self.state = 421 + self.state = 424 self.match(FuncTestCaseParser.StringLiteral) - self.state = 422 + self.state = 425 self.match(FuncTestCaseParser.DoubleColon) - self.state = 423 + self.state = 426 self.stringType() except RecognitionException as re: localctx.exception = re @@ -3233,11 +3249,11 @@ def dateArg(self): self.enterRule(localctx, 60, self.RULE_dateArg) try: self.enterOuterAlt(localctx, 1) - self.state = 425 + self.state = 428 self.match(FuncTestCaseParser.DateLiteral) - self.state = 426 + self.state = 429 self.match(FuncTestCaseParser.DoubleColon) - self.state = 427 + self.state = 430 self.dateType() except RecognitionException as re: localctx.exception = re @@ -3291,11 +3307,11 @@ def timeArg(self): self.enterRule(localctx, 62, self.RULE_timeArg) try: self.enterOuterAlt(localctx, 1) - self.state = 429 + self.state = 432 self.match(FuncTestCaseParser.TimeLiteral) - self.state = 430 + self.state = 433 self.match(FuncTestCaseParser.DoubleColon) - self.state = 431 + self.state = 434 self.timeType() except RecognitionException as re: localctx.exception = re @@ -3349,11 +3365,11 @@ def timestampArg(self): self.enterRule(localctx, 64, self.RULE_timestampArg) try: self.enterOuterAlt(localctx, 1) - self.state = 433 + self.state = 436 self.match(FuncTestCaseParser.TimestampLiteral) - self.state = 434 + self.state = 437 self.match(FuncTestCaseParser.DoubleColon) - self.state = 435 + self.state = 438 self.timestampType() except RecognitionException as re: localctx.exception = re @@ -3407,11 +3423,11 @@ def timestampTzArg(self): self.enterRule(localctx, 66, self.RULE_timestampTzArg) try: self.enterOuterAlt(localctx, 1) - self.state = 437 + self.state = 440 self.match(FuncTestCaseParser.TimestampTzLiteral) - self.state = 438 + self.state = 441 self.match(FuncTestCaseParser.DoubleColon) - self.state = 439 + self.state = 442 self.timestampTZType() except RecognitionException as re: localctx.exception = re @@ -3465,11 +3481,11 @@ def intervalYearArg(self): self.enterRule(localctx, 68, self.RULE_intervalYearArg) try: self.enterOuterAlt(localctx, 1) - self.state = 441 + self.state = 444 self.match(FuncTestCaseParser.IntervalYearLiteral) - self.state = 442 + self.state = 445 self.match(FuncTestCaseParser.DoubleColon) - self.state = 443 + self.state = 446 self.intervalYearType() except RecognitionException as re: localctx.exception = re @@ -3523,11 +3539,11 @@ def intervalDayArg(self): self.enterRule(localctx, 70, self.RULE_intervalDayArg) try: self.enterOuterAlt(localctx, 1) - self.state = 445 + self.state = 448 self.match(FuncTestCaseParser.IntervalDayLiteral) - self.state = 446 + self.state = 449 self.match(FuncTestCaseParser.DoubleColon) - self.state = 447 + self.state = 450 self.intervalDayType() except RecognitionException as re: localctx.exception = re @@ -3581,11 +3597,11 @@ def intervalCompoundArg(self): self.enterRule(localctx, 72, self.RULE_intervalCompoundArg) try: self.enterOuterAlt(localctx, 1) - self.state = 449 + self.state = 452 self.match(FuncTestCaseParser.IntervalCompoundLiteral) - self.state = 450 + self.state = 453 self.match(FuncTestCaseParser.DoubleColon) - self.state = 451 + self.state = 454 self.intervalCompoundType() except RecognitionException as re: localctx.exception = re @@ -3639,11 +3655,11 @@ def fixedCharArg(self): self.enterRule(localctx, 74, self.RULE_fixedCharArg) try: self.enterOuterAlt(localctx, 1) - self.state = 453 + self.state = 456 self.match(FuncTestCaseParser.StringLiteral) - self.state = 454 + self.state = 457 self.match(FuncTestCaseParser.DoubleColon) - self.state = 455 + self.state = 458 self.fixedCharType() except RecognitionException as re: localctx.exception = re @@ -3697,11 +3713,11 @@ def varCharArg(self): self.enterRule(localctx, 76, self.RULE_varCharArg) try: self.enterOuterAlt(localctx, 1) - self.state = 457 + self.state = 460 self.match(FuncTestCaseParser.StringLiteral) - self.state = 458 + self.state = 461 self.match(FuncTestCaseParser.DoubleColon) - self.state = 459 + self.state = 462 self.varCharType() except RecognitionException as re: localctx.exception = re @@ -3755,11 +3771,11 @@ def fixedBinaryArg(self): self.enterRule(localctx, 78, self.RULE_fixedBinaryArg) try: self.enterOuterAlt(localctx, 1) - self.state = 461 + self.state = 464 self.match(FuncTestCaseParser.StringLiteral) - self.state = 462 + self.state = 465 self.match(FuncTestCaseParser.DoubleColon) - self.state = 463 + self.state = 466 self.fixedBinaryType() except RecognitionException as re: localctx.exception = re @@ -3813,11 +3829,11 @@ def precisionTimeArg(self): self.enterRule(localctx, 80, self.RULE_precisionTimeArg) try: self.enterOuterAlt(localctx, 1) - self.state = 465 + self.state = 468 self.match(FuncTestCaseParser.TimeLiteral) - self.state = 466 + self.state = 469 self.match(FuncTestCaseParser.DoubleColon) - self.state = 467 + self.state = 470 self.precisionTimeType() except RecognitionException as re: localctx.exception = re @@ -3871,11 +3887,11 @@ def precisionTimestampArg(self): self.enterRule(localctx, 82, self.RULE_precisionTimestampArg) try: self.enterOuterAlt(localctx, 1) - self.state = 469 + self.state = 472 self.match(FuncTestCaseParser.TimestampLiteral) - self.state = 470 + self.state = 473 self.match(FuncTestCaseParser.DoubleColon) - self.state = 471 + self.state = 474 self.precisionTimestampType() except RecognitionException as re: localctx.exception = re @@ -3929,11 +3945,11 @@ def precisionTimestampTZArg(self): self.enterRule(localctx, 84, self.RULE_precisionTimestampTZArg) try: self.enterOuterAlt(localctx, 1) - self.state = 473 + self.state = 476 self.match(FuncTestCaseParser.TimestampTzLiteral) - self.state = 474 + self.state = 477 self.match(FuncTestCaseParser.DoubleColon) - self.state = 475 + self.state = 478 self.precisionTimestampTZType() except RecognitionException as re: localctx.exception = re @@ -3988,11 +4004,11 @@ def listArg(self): self.enterRule(localctx, 86, self.RULE_listArg) try: self.enterOuterAlt(localctx, 1) - self.state = 477 + self.state = 480 self.literalList() - self.state = 478 + self.state = 481 self.match(FuncTestCaseParser.DoubleColon) - self.state = 479 + self.state = 482 self.listType() except RecognitionException as re: localctx.exception = re @@ -4047,11 +4063,11 @@ def lambdaArg(self): self.enterRule(localctx, 88, self.RULE_lambdaArg) try: self.enterOuterAlt(localctx, 1) - self.state = 481 + self.state = 484 self.literalLambda() - self.state = 482 + self.state = 485 self.match(FuncTestCaseParser.DoubleColon) - self.state = 483 + self.state = 486 self.funcType() except RecognitionException as re: localctx.exception = re @@ -4062,6 +4078,82 @@ def lambdaArg(self): return localctx + class UdtArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.isnull = None # Token + + def literal(self): + return self.getTypedRuleContext(FuncTestCaseParser.LiteralContext,0) + + + def DoubleColon(self): + return self.getToken(FuncTestCaseParser.DoubleColon, 0) + + def UserDefined(self): + return self.getToken(FuncTestCaseParser.UserDefined, 0) + + def Identifier(self): + return self.getToken(FuncTestCaseParser.Identifier, 0) + + def QMark(self): + return self.getToken(FuncTestCaseParser.QMark, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_udtArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUdtArg" ): + listener.enterUdtArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUdtArg" ): + listener.exitUdtArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUdtArg" ): + return visitor.visitUdtArg(self) + else: + return visitor.visitChildren(self) + + + + + def udtArg(self): + + localctx = FuncTestCaseParser.UdtArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 90, self.RULE_udtArg) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 488 + self.literal() + self.state = 489 + self.match(FuncTestCaseParser.DoubleColon) + self.state = 490 + self.match(FuncTestCaseParser.UserDefined) + self.state = 491 + self.match(FuncTestCaseParser.Identifier) + self.state = 493 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==120: + self.state = 492 + localctx.isnull = self.match(FuncTestCaseParser.QMark) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class EnumArgContext(ParserRuleContext): __slots__ = 'parser' @@ -4101,14 +4193,14 @@ def accept(self, visitor:ParseTreeVisitor): def enumArg(self): localctx = FuncTestCaseParser.EnumArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 90, self.RULE_enumArg) + self.enterRule(localctx, 92, self.RULE_enumArg) try: self.enterOuterAlt(localctx, 1) - self.state = 485 + self.state = 495 self.match(FuncTestCaseParser.Identifier) - self.state = 486 + self.state = 496 self.match(FuncTestCaseParser.DoubleColon) - self.state = 487 + self.state = 497 self.match(FuncTestCaseParser.EnumType) except RecognitionException as re: localctx.exception = re @@ -4168,33 +4260,33 @@ def accept(self, visitor:ParseTreeVisitor): def literalList(self): localctx = FuncTestCaseParser.LiteralListContext(self, self._ctx, self.state) - self.enterRule(localctx, 92, self.RULE_literalList) + self.enterRule(localctx, 94, self.RULE_literalList) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 489 + self.state = 499 self.match(FuncTestCaseParser.OBracket) - self.state = 498 + self.state = 508 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 136343720296448) != 0) or _la==116: - self.state = 490 + self.state = 500 self.listElement() - self.state = 495 + self.state = 505 self._errHandler.sync(self) _la = self._input.LA(1) while _la==118: - self.state = 491 + self.state = 501 self.match(FuncTestCaseParser.Comma) - self.state = 492 + self.state = 502 self.listElement() - self.state = 497 + self.state = 507 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 500 + self.state = 510 self.match(FuncTestCaseParser.CBracket) except RecognitionException as re: localctx.exception = re @@ -4243,19 +4335,19 @@ def accept(self, visitor:ParseTreeVisitor): def listElement(self): localctx = FuncTestCaseParser.ListElementContext(self, self._ctx, self.state) - self.enterRule(localctx, 94, self.RULE_listElement) + self.enterRule(localctx, 96, self.RULE_listElement) try: - self.state = 504 + self.state = 514 self._errHandler.sync(self) token = self._input.LA(1) if token in [18, 24, 25, 26, 27, 28, 29, 30, 31, 42, 43, 44, 45, 46]: self.enterOuterAlt(localctx, 1) - self.state = 502 + self.state = 512 self.literal() pass elif token in [116]: self.enterOuterAlt(localctx, 2) - self.state = 503 + self.state = 513 self.literalList() pass else: @@ -4317,18 +4409,18 @@ def accept(self, visitor:ParseTreeVisitor): def literalLambda(self): localctx = FuncTestCaseParser.LiteralLambdaContext(self, self._ctx, self.state) - self.enterRule(localctx, 96, self.RULE_literalLambda) + self.enterRule(localctx, 98, self.RULE_literalLambda) try: self.enterOuterAlt(localctx, 1) - self.state = 506 + self.state = 516 self.match(FuncTestCaseParser.OParen) - self.state = 507 + self.state = 517 self.lambdaParameters() - self.state = 508 + self.state = 518 self.match(FuncTestCaseParser.Arrow) - self.state = 509 + self.state = 519 self.lambdaBody() - self.state = 510 + self.state = 520 self.match(FuncTestCaseParser.CParen) except RecognitionException as re: localctx.exception = re @@ -4420,40 +4512,40 @@ def accept(self, visitor:ParseTreeVisitor): def lambdaParameters(self): localctx = FuncTestCaseParser.LambdaParametersContext(self, self._ctx, self.state) - self.enterRule(localctx, 98, self.RULE_lambdaParameters) + self.enterRule(localctx, 100, self.RULE_lambdaParameters) self._la = 0 # Token type try: - self.state = 522 + self.state = 532 self._errHandler.sync(self) token = self._input.LA(1) if token in [128]: localctx = FuncTestCaseParser.SingleParamContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 512 + self.state = 522 self.match(FuncTestCaseParser.Identifier) pass elif token in [114]: localctx = FuncTestCaseParser.TupleParamsContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 513 + self.state = 523 self.match(FuncTestCaseParser.OParen) - self.state = 514 + self.state = 524 self.match(FuncTestCaseParser.Identifier) - self.state = 517 + self.state = 527 self._errHandler.sync(self) _la = self._input.LA(1) while True: - self.state = 515 + self.state = 525 self.match(FuncTestCaseParser.Comma) - self.state = 516 + self.state = 526 self.match(FuncTestCaseParser.Identifier) - self.state = 519 + self.state = 529 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==118): break - self.state = 521 + self.state = 531 self.match(FuncTestCaseParser.CParen) pass else: @@ -4512,16 +4604,16 @@ def accept(self, visitor:ParseTreeVisitor): def lambdaBody(self): localctx = FuncTestCaseParser.LambdaBodyContext(self, self._ctx, self.state) - self.enterRule(localctx, 100, self.RULE_lambdaBody) + self.enterRule(localctx, 102, self.RULE_lambdaBody) try: self.enterOuterAlt(localctx, 1) - self.state = 524 + self.state = 534 self.identifier() - self.state = 525 + self.state = 535 self.match(FuncTestCaseParser.OParen) - self.state = 526 + self.state = 536 self.arguments() - self.state = 527 + self.state = 537 self.match(FuncTestCaseParser.CParen) except RecognitionException as re: localctx.exception = re @@ -4570,19 +4662,19 @@ def accept(self, visitor:ParseTreeVisitor): def dataType(self): localctx = FuncTestCaseParser.DataTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 102, self.RULE_dataType) + self.enterRule(localctx, 104, self.RULE_dataType) try: - self.state = 531 + self.state = 541 self._errHandler.sync(self) token = self._input.LA(1) if token in [55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 71, 83, 84, 85, 86, 87, 88, 89]: self.enterOuterAlt(localctx, 1) - self.state = 529 + self.state = 539 self.scalarType() pass elif token in [54, 69, 70, 72, 73, 74, 75, 76, 77, 78, 81, 90, 91, 92, 93, 94, 95, 96, 97, 98]: self.enterOuterAlt(localctx, 2) - self.state = 530 + self.state = 540 self.parameterizedType() pass else: @@ -4924,82 +5016,82 @@ def accept(self, visitor:ParseTreeVisitor): def scalarType(self): localctx = FuncTestCaseParser.ScalarTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 104, self.RULE_scalarType) + self.enterRule(localctx, 106, self.RULE_scalarType) self._la = 0 # Token type try: - self.state = 552 + self.state = 562 self._errHandler.sync(self) token = self._input.LA(1) if token in [55, 84]: localctx = FuncTestCaseParser.BooleanContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 533 + self.state = 543 self.booleanType() pass elif token in [56, 57, 58, 59]: localctx = FuncTestCaseParser.IntContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 534 + self.state = 544 self.intType() pass elif token in [60, 61]: localctx = FuncTestCaseParser.FloatContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 535 + self.state = 545 self.floatType() pass elif token in [62, 85]: localctx = FuncTestCaseParser.StringContext(self, localctx) self.enterOuterAlt(localctx, 4) - self.state = 536 + self.state = 546 self.stringType() pass elif token in [63, 86]: localctx = FuncTestCaseParser.BinaryContext(self, localctx) self.enterOuterAlt(localctx, 5) - self.state = 537 + self.state = 547 self.binaryType() pass elif token in [64, 87]: localctx = FuncTestCaseParser.TimestampContext(self, localctx) self.enterOuterAlt(localctx, 6) - self.state = 538 + self.state = 548 self.timestampType() pass elif token in [65, 88]: localctx = FuncTestCaseParser.TimestampTzContext(self, localctx) self.enterOuterAlt(localctx, 7) - self.state = 539 + self.state = 549 self.timestampTZType() pass elif token in [66]: localctx = FuncTestCaseParser.DateContext(self, localctx) self.enterOuterAlt(localctx, 8) - self.state = 540 + self.state = 550 self.dateType() pass elif token in [67]: localctx = FuncTestCaseParser.TimeContext(self, localctx) self.enterOuterAlt(localctx, 9) - self.state = 541 + self.state = 551 self.timeType() pass elif token in [68, 89]: localctx = FuncTestCaseParser.IntervalYearContext(self, localctx) self.enterOuterAlt(localctx, 10) - self.state = 542 + self.state = 552 self.intervalYearType() pass elif token in [71]: localctx = FuncTestCaseParser.UuidContext(self, localctx) self.enterOuterAlt(localctx, 11) - self.state = 543 + self.state = 553 self.match(FuncTestCaseParser.UUID) - self.state = 545 + self.state = 555 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 544 + self.state = 554 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5007,15 +5099,15 @@ def scalarType(self): elif token in [83]: localctx = FuncTestCaseParser.UserDefinedContext(self, localctx) self.enterOuterAlt(localctx, 12) - self.state = 547 + self.state = 557 self.match(FuncTestCaseParser.UserDefined) - self.state = 548 + self.state = 558 self.match(FuncTestCaseParser.Identifier) - self.state = 550 + self.state = 560 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 549 + self.state = 559 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5072,22 +5164,22 @@ def accept(self, visitor:ParseTreeVisitor): def booleanType(self): localctx = FuncTestCaseParser.BooleanTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 106, self.RULE_booleanType) + self.enterRule(localctx, 108, self.RULE_booleanType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 554 + self.state = 564 _la = self._input.LA(1) if not(_la==55 or _la==84): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 556 + self.state = 566 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 555 + self.state = 565 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5140,22 +5232,22 @@ def accept(self, visitor:ParseTreeVisitor): def stringType(self): localctx = FuncTestCaseParser.StringTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 108, self.RULE_stringType) + self.enterRule(localctx, 110, self.RULE_stringType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 558 + self.state = 568 _la = self._input.LA(1) if not(_la==62 or _la==85): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 560 + self.state = 570 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 559 + self.state = 569 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5208,22 +5300,22 @@ def accept(self, visitor:ParseTreeVisitor): def binaryType(self): localctx = FuncTestCaseParser.BinaryTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 110, self.RULE_binaryType) + self.enterRule(localctx, 112, self.RULE_binaryType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 562 + self.state = 572 _la = self._input.LA(1) if not(_la==63 or _la==86): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 564 + self.state = 574 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 563 + self.state = 573 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5282,22 +5374,22 @@ def accept(self, visitor:ParseTreeVisitor): def intType(self): localctx = FuncTestCaseParser.IntTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 112, self.RULE_intType) + self.enterRule(localctx, 114, self.RULE_intType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 566 + self.state = 576 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 1080863910568919040) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 568 + self.state = 578 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 567 + self.state = 577 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5350,22 +5442,22 @@ def accept(self, visitor:ParseTreeVisitor): def floatType(self): localctx = FuncTestCaseParser.FloatTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 114, self.RULE_floatType) + self.enterRule(localctx, 116, self.RULE_floatType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 570 + self.state = 580 _la = self._input.LA(1) if not(_la==60 or _la==61): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 572 + self.state = 582 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 571 + self.state = 581 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5415,17 +5507,17 @@ def accept(self, visitor:ParseTreeVisitor): def dateType(self): localctx = FuncTestCaseParser.DateTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 116, self.RULE_dateType) + self.enterRule(localctx, 118, self.RULE_dateType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 574 + self.state = 584 self.match(FuncTestCaseParser.Date) - self.state = 576 + self.state = 586 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 575 + self.state = 585 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5475,17 +5567,17 @@ def accept(self, visitor:ParseTreeVisitor): def timeType(self): localctx = FuncTestCaseParser.TimeTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 118, self.RULE_timeType) + self.enterRule(localctx, 120, self.RULE_timeType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 578 + self.state = 588 self.match(FuncTestCaseParser.Time) - self.state = 580 + self.state = 590 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 579 + self.state = 589 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5538,22 +5630,22 @@ def accept(self, visitor:ParseTreeVisitor): def timestampType(self): localctx = FuncTestCaseParser.TimestampTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 120, self.RULE_timestampType) + self.enterRule(localctx, 122, self.RULE_timestampType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 582 + self.state = 592 _la = self._input.LA(1) if not(_la==64 or _la==87): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 584 + self.state = 594 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 583 + self.state = 593 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5606,22 +5698,22 @@ def accept(self, visitor:ParseTreeVisitor): def timestampTZType(self): localctx = FuncTestCaseParser.TimestampTZTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 122, self.RULE_timestampTZType) + self.enterRule(localctx, 124, self.RULE_timestampTZType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 586 + self.state = 596 _la = self._input.LA(1) if not(_la==65 or _la==88): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 588 + self.state = 598 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 587 + self.state = 597 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5674,22 +5766,22 @@ def accept(self, visitor:ParseTreeVisitor): def intervalYearType(self): localctx = FuncTestCaseParser.IntervalYearTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 124, self.RULE_intervalYearType) + self.enterRule(localctx, 126, self.RULE_intervalYearType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 590 + self.state = 600 _la = self._input.LA(1) if not(_la==68 or _la==89): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 592 + self.state = 602 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 591 + self.state = 601 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5753,34 +5845,34 @@ def accept(self, visitor:ParseTreeVisitor): def intervalDayType(self): localctx = FuncTestCaseParser.IntervalDayTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 126, self.RULE_intervalDayType) + self.enterRule(localctx, 128, self.RULE_intervalDayType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 594 + self.state = 604 _la = self._input.LA(1) if not(_la==69 or _la==90): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 596 + self.state = 606 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 595 + self.state = 605 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 602 + self.state = 612 self._errHandler.sync(self) _la = self._input.LA(1) if _la==40: - self.state = 598 + self.state = 608 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 599 + self.state = 609 localctx.len_ = self.numericParameter() - self.state = 600 + self.state = 610 self.match(FuncTestCaseParser.CAngleBracket) @@ -5844,34 +5936,34 @@ def accept(self, visitor:ParseTreeVisitor): def intervalCompoundType(self): localctx = FuncTestCaseParser.IntervalCompoundTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 128, self.RULE_intervalCompoundType) + self.enterRule(localctx, 130, self.RULE_intervalCompoundType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 604 + self.state = 614 _la = self._input.LA(1) if not(_la==70 or _la==91): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 606 + self.state = 616 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 605 + self.state = 615 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 612 + self.state = 622 self._errHandler.sync(self) _la = self._input.LA(1) if _la==40: - self.state = 608 + self.state = 618 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 609 + self.state = 619 localctx.len_ = self.numericParameter() - self.state = 610 + self.state = 620 self.match(FuncTestCaseParser.CAngleBracket) @@ -5935,30 +6027,30 @@ def accept(self, visitor:ParseTreeVisitor): def fixedCharType(self): localctx = FuncTestCaseParser.FixedCharTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 130, self.RULE_fixedCharType) + self.enterRule(localctx, 132, self.RULE_fixedCharType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 614 + self.state = 624 _la = self._input.LA(1) if not(_la==76 or _la==96): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 616 + self.state = 626 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 615 + self.state = 625 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 618 + self.state = 628 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 619 + self.state = 629 localctx.len_ = self.numericParameter() - self.state = 620 + self.state = 630 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6020,30 +6112,30 @@ def accept(self, visitor:ParseTreeVisitor): def varCharType(self): localctx = FuncTestCaseParser.VarCharTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 132, self.RULE_varCharType) + self.enterRule(localctx, 134, self.RULE_varCharType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 622 + self.state = 632 _la = self._input.LA(1) if not(_la==77 or _la==97): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 624 + self.state = 634 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 623 + self.state = 633 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 626 + self.state = 636 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 627 + self.state = 637 localctx.len_ = self.numericParameter() - self.state = 628 + self.state = 638 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6105,30 +6197,30 @@ def accept(self, visitor:ParseTreeVisitor): def fixedBinaryType(self): localctx = FuncTestCaseParser.FixedBinaryTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 134, self.RULE_fixedBinaryType) + self.enterRule(localctx, 136, self.RULE_fixedBinaryType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 630 + self.state = 640 _la = self._input.LA(1) if not(_la==78 or _la==98): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 632 + self.state = 642 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 631 + self.state = 641 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 634 + self.state = 644 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 635 + self.state = 645 localctx.len_ = self.numericParameter() - self.state = 636 + self.state = 646 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6197,38 +6289,38 @@ def accept(self, visitor:ParseTreeVisitor): def decimalType(self): localctx = FuncTestCaseParser.DecimalTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 136, self.RULE_decimalType) + self.enterRule(localctx, 138, self.RULE_decimalType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 638 + self.state = 648 _la = self._input.LA(1) if not(_la==72 or _la==92): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 640 + self.state = 650 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 639 + self.state = 649 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 648 + self.state = 658 self._errHandler.sync(self) _la = self._input.LA(1) if _la==40: - self.state = 642 + self.state = 652 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 643 + self.state = 653 localctx.precision = self.numericParameter() - self.state = 644 + self.state = 654 self.match(FuncTestCaseParser.Comma) - self.state = 645 + self.state = 655 localctx.scale = self.numericParameter() - self.state = 646 + self.state = 656 self.match(FuncTestCaseParser.CAngleBracket) @@ -6292,30 +6384,30 @@ def accept(self, visitor:ParseTreeVisitor): def precisionTimeType(self): localctx = FuncTestCaseParser.PrecisionTimeTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 138, self.RULE_precisionTimeType) + self.enterRule(localctx, 140, self.RULE_precisionTimeType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 650 + self.state = 660 _la = self._input.LA(1) if not(_la==73 or _la==93): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 652 + self.state = 662 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 651 + self.state = 661 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 654 + self.state = 664 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 655 + self.state = 665 localctx.precision = self.numericParameter() - self.state = 656 + self.state = 666 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6377,30 +6469,30 @@ def accept(self, visitor:ParseTreeVisitor): def precisionTimestampType(self): localctx = FuncTestCaseParser.PrecisionTimestampTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 140, self.RULE_precisionTimestampType) + self.enterRule(localctx, 142, self.RULE_precisionTimestampType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 658 + self.state = 668 _la = self._input.LA(1) if not(_la==74 or _la==94): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 660 + self.state = 670 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 659 + self.state = 669 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 662 + self.state = 672 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 663 + self.state = 673 localctx.precision = self.numericParameter() - self.state = 664 + self.state = 674 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6462,30 +6554,30 @@ def accept(self, visitor:ParseTreeVisitor): def precisionTimestampTZType(self): localctx = FuncTestCaseParser.PrecisionTimestampTZTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 142, self.RULE_precisionTimestampTZType) + self.enterRule(localctx, 144, self.RULE_precisionTimestampTZType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 666 + self.state = 676 _la = self._input.LA(1) if not(_la==75 or _la==95): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 668 + self.state = 678 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 667 + self.state = 677 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 670 + self.state = 680 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 671 + self.state = 681 localctx.precision = self.numericParameter() - self.state = 672 + self.state = 682 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6552,26 +6644,26 @@ def accept(self, visitor:ParseTreeVisitor): def listType(self): localctx = FuncTestCaseParser.ListTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 144, self.RULE_listType) + self.enterRule(localctx, 146, self.RULE_listType) self._la = 0 # Token type try: localctx = FuncTestCaseParser.ListContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 674 + self.state = 684 self.match(FuncTestCaseParser.List) - self.state = 676 + self.state = 686 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 675 + self.state = 685 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 678 + self.state = 688 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 679 + self.state = 689 localctx.elemType = self.dataType() - self.state = 680 + self.state = 690 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6638,29 +6730,29 @@ def accept(self, visitor:ParseTreeVisitor): def funcType(self): localctx = FuncTestCaseParser.FuncTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 146, self.RULE_funcType) + self.enterRule(localctx, 148, self.RULE_funcType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 682 + self.state = 692 self.match(FuncTestCaseParser.Func) - self.state = 684 + self.state = 694 self._errHandler.sync(self) _la = self._input.LA(1) if _la==120: - self.state = 683 + self.state = 693 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 686 + self.state = 696 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 687 + self.state = 697 localctx.params = self.funcParameters() - self.state = 688 + self.state = 698 self.match(FuncTestCaseParser.Arrow) - self.state = 689 + self.state = 699 localctx.returnType = self.dataType() - self.state = 690 + self.state = 700 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6754,38 +6846,38 @@ def accept(self, visitor:ParseTreeVisitor): def funcParameters(self): localctx = FuncTestCaseParser.FuncParametersContext(self, self._ctx, self.state) - self.enterRule(localctx, 148, self.RULE_funcParameters) + self.enterRule(localctx, 150, self.RULE_funcParameters) self._la = 0 # Token type try: - self.state = 704 + self.state = 714 self._errHandler.sync(self) token = self._input.LA(1) if token in [54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 81, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98]: localctx = FuncTestCaseParser.SingleFuncParamContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 692 + self.state = 702 self.dataType() pass elif token in [114]: localctx = FuncTestCaseParser.FuncParamsWithParensContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 693 + self.state = 703 self.match(FuncTestCaseParser.OParen) - self.state = 694 + self.state = 704 self.dataType() - self.state = 699 + self.state = 709 self._errHandler.sync(self) _la = self._input.LA(1) while _la==118: - self.state = 695 + self.state = 705 self.match(FuncTestCaseParser.Comma) - self.state = 696 + self.state = 706 self.dataType() - self.state = 701 + self.state = 711 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 702 + self.state = 712 self.match(FuncTestCaseParser.CParen) pass else: @@ -6874,64 +6966,64 @@ def accept(self, visitor:ParseTreeVisitor): def parameterizedType(self): localctx = FuncTestCaseParser.ParameterizedTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 150, self.RULE_parameterizedType) + self.enterRule(localctx, 152, self.RULE_parameterizedType) try: - self.state = 717 + self.state = 727 self._errHandler.sync(self) token = self._input.LA(1) if token in [76, 96]: self.enterOuterAlt(localctx, 1) - self.state = 706 + self.state = 716 self.fixedCharType() pass elif token in [77, 97]: self.enterOuterAlt(localctx, 2) - self.state = 707 + self.state = 717 self.varCharType() pass elif token in [78, 98]: self.enterOuterAlt(localctx, 3) - self.state = 708 + self.state = 718 self.fixedBinaryType() pass elif token in [72, 92]: self.enterOuterAlt(localctx, 4) - self.state = 709 + self.state = 719 self.decimalType() pass elif token in [69, 90]: self.enterOuterAlt(localctx, 5) - self.state = 710 + self.state = 720 self.intervalDayType() pass elif token in [70, 91]: self.enterOuterAlt(localctx, 6) - self.state = 711 + self.state = 721 self.intervalCompoundType() pass elif token in [73, 93]: self.enterOuterAlt(localctx, 7) - self.state = 712 + self.state = 722 self.precisionTimeType() pass elif token in [74, 94]: self.enterOuterAlt(localctx, 8) - self.state = 713 + self.state = 723 self.precisionTimestampType() pass elif token in [75, 95]: self.enterOuterAlt(localctx, 9) - self.state = 714 + self.state = 724 self.precisionTimestampTZType() pass elif token in [81]: self.enterOuterAlt(localctx, 10) - self.state = 715 + self.state = 725 self.listType() pass elif token in [54]: self.enterOuterAlt(localctx, 11) - self.state = 716 + self.state = 726 self.funcType() pass else: @@ -6991,11 +7083,11 @@ def accept(self, visitor:ParseTreeVisitor): def numericParameter(self): localctx = FuncTestCaseParser.NumericParameterContext(self, self._ctx, self.state) - self.enterRule(localctx, 152, self.RULE_numericParameter) + self.enterRule(localctx, 154, self.RULE_numericParameter) try: localctx = FuncTestCaseParser.IntegerLiteralContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 719 + self.state = 729 self.match(FuncTestCaseParser.IntegerLiteral) except RecognitionException as re: localctx.exception = re @@ -7042,11 +7134,11 @@ def accept(self, visitor:ParseTreeVisitor): def substraitError(self): localctx = FuncTestCaseParser.SubstraitErrorContext(self, self._ctx, self.state) - self.enterRule(localctx, 154, self.RULE_substraitError) + self.enterRule(localctx, 156, self.RULE_substraitError) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 721 + self.state = 731 _la = self._input.LA(1) if not(_la==10 or _la==11): self._errHandler.recoverInline(self) @@ -7103,14 +7195,14 @@ def accept(self, visitor:ParseTreeVisitor): def funcOption(self): localctx = FuncTestCaseParser.FuncOptionContext(self, self._ctx, self.state) - self.enterRule(localctx, 156, self.RULE_funcOption) + self.enterRule(localctx, 158, self.RULE_funcOption) try: self.enterOuterAlt(localctx, 1) - self.state = 723 + self.state = 733 self.optionName() - self.state = 724 + self.state = 734 self.match(FuncTestCaseParser.Colon) - self.state = 725 + self.state = 735 self.optionValue() except RecognitionException as re: localctx.exception = re @@ -7166,11 +7258,11 @@ def accept(self, visitor:ParseTreeVisitor): def optionName(self): localctx = FuncTestCaseParser.OptionNameContext(self, self._ctx, self.state) - self.enterRule(localctx, 158, self.RULE_optionName) + self.enterRule(localctx, 160, self.RULE_optionName) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 727 + self.state = 737 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 6303744) != 0) or _la==128): self._errHandler.recoverInline(self) @@ -7249,11 +7341,11 @@ def accept(self, visitor:ParseTreeVisitor): def optionValue(self): localctx = FuncTestCaseParser.OptionValueContext(self, self._ctx, self.state) - self.enterRule(localctx, 160, self.RULE_optionValue) + self.enterRule(localctx, 162, self.RULE_optionValue) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 729 + self.state = 739 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 35184516775936) != 0) or _la==128): self._errHandler.recoverInline(self) @@ -7312,21 +7404,21 @@ def accept(self, visitor:ParseTreeVisitor): def funcOptions(self): localctx = FuncTestCaseParser.FuncOptionsContext(self, self._ctx, self.state) - self.enterRule(localctx, 162, self.RULE_funcOptions) + self.enterRule(localctx, 164, self.RULE_funcOptions) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 731 + self.state = 741 self.funcOption() - self.state = 736 + self.state = 746 self._errHandler.sync(self) _la = self._input.LA(1) while _la==118: - self.state = 732 + self.state = 742 self.match(FuncTestCaseParser.Comma) - self.state = 733 + self.state = 743 self.funcOption() - self.state = 738 + self.state = 748 self._errHandler.sync(self) _la = self._input.LA(1) @@ -7378,11 +7470,11 @@ def accept(self, visitor:ParseTreeVisitor): def nonReserved(self): localctx = FuncTestCaseParser.NonReservedContext(self, self._ctx, self.state) - self.enterRule(localctx, 164, self.RULE_nonReserved) + self.enterRule(localctx, 166, self.RULE_nonReserved) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 739 + self.state = 749 _la = self._input.LA(1) if not(_la==23 or _la==123 or _la==124): self._errHandler.recoverInline(self) @@ -7435,19 +7527,19 @@ def accept(self, visitor:ParseTreeVisitor): def identifier(self): localctx = FuncTestCaseParser.IdentifierContext(self, self._ctx, self.state) - self.enterRule(localctx, 166, self.RULE_identifier) + self.enterRule(localctx, 168, self.RULE_identifier) try: - self.state = 743 + self.state = 753 self._errHandler.sync(self) token = self._input.LA(1) if token in [23, 123, 124]: self.enterOuterAlt(localctx, 1) - self.state = 741 + self.state = 751 self.nonReserved() pass elif token in [128]: self.enterOuterAlt(localctx, 2) - self.state = 742 + self.state = 752 self.match(FuncTestCaseParser.Identifier) pass else: diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py index 68d8d9354..e44496abc 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py @@ -441,6 +441,15 @@ def exitLambdaArg(self, ctx:FuncTestCaseParser.LambdaArgContext): pass + # Enter a parse tree produced by FuncTestCaseParser#udtArg. + def enterUdtArg(self, ctx:FuncTestCaseParser.UdtArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#udtArg. + def exitUdtArg(self, ctx:FuncTestCaseParser.UdtArgContext): + pass + + # Enter a parse tree produced by FuncTestCaseParser#enumArg. def enterEnumArg(self, ctx:FuncTestCaseParser.EnumArgContext): pass diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py index 2888a99e5..a456d8778 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py @@ -250,6 +250,11 @@ def visitLambdaArg(self, ctx:FuncTestCaseParser.LambdaArgContext): return self.visitChildren(ctx) + # Visit a parse tree produced by FuncTestCaseParser#udtArg. + def visitUdtArg(self, ctx:FuncTestCaseParser.UdtArgContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#enumArg. def visitEnumArg(self, ctx:FuncTestCaseParser.EnumArgContext): return self.visitChildren(ctx) diff --git a/tests/coverage/extensions.py b/tests/coverage/extensions.py index 4f9ae1d3c..e21c62e60 100644 --- a/tests/coverage/extensions.py +++ b/tests/coverage/extensions.py @@ -163,10 +163,16 @@ def add_functions_to_map(func_list, function_map, suffix, extension, uri): @staticmethod def read_substrait_extensions(dir_path: str): # read files from extensions directory + # Scan all YAML files, not just functions_* prefixed ones, so that + # self-contained extension type files (e.g. unsigned_integers.yaml) + # with function definitions are also discovered. Files without + # scalar_functions/aggregate_functions/window_functions sections are + # safely skipped by the guards below. unknown.yaml is excluded + # because it defines an "unknown" type not in the type mapping. extensions = [] for root, dirs, files in os.walk(dir_path): for file in files: - if file.endswith(".yaml") and file.startswith("functions_"): + if file.endswith(".yaml") and file != "unknown.yaml": extensions.append(os.path.join(root, file)) extensions.sort() diff --git a/tests/coverage/visitor.py b/tests/coverage/visitor.py index 820eb6583..ab3255568 100644 --- a/tests/coverage/visitor.py +++ b/tests/coverage/visitor.py @@ -274,6 +274,8 @@ def visitArguments(self, ctx: FuncTestCaseParser.ArgumentsContext): return arguments def visitArgument(self, ctx: FuncTestCaseParser.ArgumentContext): + if ctx.udtArg() is not None: + return self.visitUdtArg(ctx.udtArg()) if ctx.intArg() is not None: return self.visitIntArg(ctx.intArg()) if ctx.floatArg() is not None: @@ -511,6 +513,15 @@ def visitEnumArg(self, ctx: FuncTestCaseParser.EnumArgContext): def visitDataType(self, ctx: FuncTestCaseParser.DataTypeContext): return ctx.getText() + def visitUdtArg(self, ctx: FuncTestCaseParser.UdtArgContext): + value, _ = self.visitLiteral(ctx.literal()) + # Type is "u!" + identifier, e.g., "u!u8" + type_str = "u!" + ctx.Identifier().getText().lower() + is_nullable = ctx.isnull is not None + if is_nullable: + type_str += "?" + return CaseLiteral(value=value, type=type_str, nullable=is_nullable) + def visitResult(self, ctx: FuncTestCaseParser.ResultContext): if ctx.argument() is not None: return self.visitArgument(ctx.argument())