diff --git a/README.md b/README.md index 2607c0eb..f838987c 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ publications can be found. Building SuperC requires `bison` and `sat4j`. For debian and ubuntu run - apt-get install bison libz3-java sat4j + apt-get install bison libz3-java sat4j graphviz The following environment variables are expected by SuperC/xtc. diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_action.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_action.p4 new file mode 100644 index 00000000..903167d4 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_action.p4 @@ -0,0 +1,9 @@ +action Forward_a(out bit<9> outputPort, bit<9> port) { + outputPort = port; +} + +control ActionInvoker() { + apply { + Forward_a(5, 10); + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_action_nested.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_action_nested.p4 new file mode 100644 index 00000000..a39378c4 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_action_nested.p4 @@ -0,0 +1,12 @@ +action Forward_a(out bit<9> outputPort, bit<9> port) { + outputPort = port; +} + +control ActionInvoker() { + action Forward_a(bit<9> port) { + port = 1; + } + apply { + Forward_a(5); + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_control.ast b/fonda/p4_testsuite/callGraphTestCases/CGTest_control.ast new file mode 100644 index 00000000..1df71772 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_control.ast @@ -0,0 +1,511 @@ +SuperP4, v. 2.4.0, (C) 2009-2012 New York University +Portions Copyright (c) 1989, 1990 James A. Roskind +Processing CGTest_control.p4 ... +TranslationUnit( + start( + program( + input( + Conditional( + , + declaration( + typeDeclaration( + derivedTypeDeclaration( + headerTypeDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "header" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "vlan_tag_t" + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "{" + ), + structFieldList( + Conditional( + , + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "eth_type" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ), + Conditional( + , + declaration( + typeDeclaration( + derivedTypeDeclaration( + structTypeDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "struct" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "parsed_headers_t" + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "{" + ), + structFieldList( + Conditional( + (declare-fun |(defined WITH_DOUBLE_VLAN_TERMINATION)| () Bool)(declare-fun |(defined WITH_BNG)| () Bool)(declare-fun |(defined WITH_XCONNECT)| () Bool)(assert (or |(defined WITH_XCONNECT)| |(defined WITH_BNG)| |(defined WITH_DOUBLE_VLAN_TERMINATION)|)), + structField( + optAnnotations(), + typeRef( + typeName( + prefixedType( + superc.core.Syntax$Text( + "vlan_tag_t" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "inner_vlan_tag" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ), + Conditional( + , + declaration( + controlDeclaration( + controlTypeDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "control" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "process_int_main" + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "(" + ), + parameterList( + Conditional( + , + nonEmptyParameterList( + Conditional( + , + parameter( + optAnnotations(), + direction( + superc.core.Syntax$Language( + "inout" + ) + ), + typeRef( + typeName( + prefixedType( + superc.core.Syntax$Text( + "parsed_headers_t" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "hdr" + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ")" + ) + ), + optConstructorParameters(), + superc.core.Syntax$Language( + "{" + ), + controlLocalDeclarations(), + superc.core.Syntax$Language( + "apply" + ), + controlBody( + blockStatement( + optAnnotations(), + superc.core.Syntax$Language( + "{" + ), + statOrDeclList( + Conditional( + , + statementOrDeclaration( + statement( + conditionalStatement( + superc.core.Syntax$Language( + "if" + ), + superc.core.Syntax$Language( + "(" + ), + expression( + Conditional( + , + nonTypeName( + superc.core.Syntax$Text( + "hdr" + ) + ) + ), + Conditional( + , + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "int_header" + ) + ) + ) + ) + ), + Conditional( + , + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "isValid" + ) + ) + ) + ) + ), + Conditional( + , + superc.core.Syntax$Language( + "(" + ) + ), + Conditional( + , + argumentList() + ), + Conditional( + , + superc.core.Syntax$Language( + ")" + ) + ) + ), + superc.core.Syntax$Language( + ")" + ), + statement( + blockStatement( + optAnnotations(), + superc.core.Syntax$Language( + "{" + ), + statOrDeclList( + Conditional( + (declare-fun |(defined WITH_INT_TRANSIT)| () Bool)(assert |(defined WITH_INT_TRANSIT)|), + statementOrDeclaration( + statement( + assignmentOrMethodCallStatement( + lvalue( + lvalue( + prefixedNonTypeName( + nonTypeName( + superc.core.Syntax$Text( + "hdr" + ) + ) + ) + ), + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "eth_type" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "=" + ), + expression( + Conditional( + (declare-fun |(defined WITH_INT_TRANSIT)| () Bool)(assert |(defined WITH_INT_TRANSIT)|), + nonTypeName( + superc.core.Syntax$Text( + "hdr" + ) + ) + ), + Conditional( + (declare-fun |(defined WITH_INT_TRANSIT)| () Bool)(assert |(defined WITH_INT_TRANSIT)|), + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "eth_type" + ) + ) + ) + ) + ), + Conditional( + (declare-fun |(defined WITH_INT_TRANSIT)| () Bool)(assert |(defined WITH_INT_TRANSIT)|), + superc.core.Syntax$Language( + "-" + ) + ), + Conditional( + (declare-fun |(defined WITH_INT_TRANSIT)| () Bool)(assert |(defined WITH_INT_TRANSIT)|), + expression( + Conditional( + (declare-fun |(defined WITH_INT_TRANSIT)| () Bool)(assert |(defined WITH_INT_TRANSIT)|), + superc.core.Syntax$Text( + "1" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ), + Conditional( + , + declaration( + controlDeclaration( + controlTypeDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "control" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "FabricEgress" + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "(" + ), + parameterList( + Conditional( + , + nonEmptyParameterList( + Conditional( + , + parameter( + optAnnotations(), + direction( + superc.core.Syntax$Language( + "inout" + ) + ), + typeRef( + typeName( + prefixedType( + superc.core.Syntax$Text( + "parsed_headers_t" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "hdr" + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ")" + ) + ), + optConstructorParameters(), + superc.core.Syntax$Language( + "{" + ), + controlLocalDeclarations(), + superc.core.Syntax$Language( + "apply" + ), + controlBody( + blockStatement( + optAnnotations(), + superc.core.Syntax$Language( + "{" + ), + statOrDeclList( + Conditional( + (declare-fun |(defined WITH_INT)| () Bool)(assert |(defined WITH_INT)|), + statementOrDeclaration( + statement( + directApplication( + typeName( + prefixedType( + superc.core.Syntax$Text( + "process_int_main" + ) + ) + ), + superc.core.Syntax$Language( + "." + ), + superc.core.Syntax$Language( + "apply" + ), + superc.core.Syntax$Language( + "(" + ), + argumentList( + Conditional( + (declare-fun |(defined WITH_INT)| () Bool)(assert |(defined WITH_INT)|), + nonEmptyArgList( + Conditional( + (declare-fun |(defined WITH_INT)| () Bool)(assert |(defined WITH_INT)|), + argument( + expression( + Conditional( + (declare-fun |(defined WITH_INT)| () Bool)(assert |(defined WITH_INT)|), + nonTypeName( + superc.core.Syntax$Text( + "hdr" + ) + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ")" + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_control.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_control.p4 new file mode 100644 index 00000000..f5f06b5b --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_control.p4 @@ -0,0 +1,14 @@ +control process_int_main () { + apply { + // if(hdr.int_header == 1) { + // hdr = hdr - 1; + // } + } +} +// control, apply - use APPLY as namespace of fegress, directapplication +// future - use PC scope +control FabricEgress () { + apply { + process_int_main.apply(); + } +} diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_control_duplicate_blocks.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_control_duplicate_blocks.p4 new file mode 100644 index 00000000..52709a13 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_control_duplicate_blocks.p4 @@ -0,0 +1,26 @@ +control process_int_main () { + apply { + } +} +control process_int_main () { + apply { + } +} +control process_int_main2 () { + apply { + } +} +// control, apply - use APPLY as namespace of fegress, directapplication +// future - use PC scope +control FabricEgress () { + apply { + process_int_main.apply(); + } +} + +control FabricEgress () { + apply { + process_int_main.apply(); + process_int_main2.apply(); + } +} diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_extern.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_extern.p4 new file mode 100644 index 00000000..f59dcc29 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_extern.p4 @@ -0,0 +1,7 @@ +extern packet_in { + void extract(out int headerLvalue); + T lookahead(); + bit<32> length(); // This method may be unavailable in some architectures + void advance(bit<32> bits); + packet_in(int a); // constructor +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_extern_overloading.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_extern_overloading.p4 new file mode 100644 index 00000000..0b6b1edb --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_extern_overloading.p4 @@ -0,0 +1,7 @@ +extern packet_in { + void extract(out T headerLvalue); + void extract(out T variableSizeHeader, in bit<32> varFieldSizeBits); + T lookahead(); + bit<32> length(); // This method may be unavailable in some architectures + void advance(bit<32> bits); +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_extern_specializedType.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_extern_specializedType.p4 new file mode 100644 index 00000000..46b1fa7f --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_extern_specializedType.p4 @@ -0,0 +1,7 @@ +extern packet_in { + void extract(out T headerLvalue); + T lookahead(); + bit<32> length(); // This method may be unavailable in some architectures + void advance(bit<32> bits); + packet_in(int a); // constructor +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_function.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_function.p4 new file mode 100644 index 00000000..44442054 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_function.p4 @@ -0,0 +1,13 @@ +bit<16> max(in bit<16> left, in bit<16> right) { + if (left > right) + left = right; + return right; +} + +control c(out bit<16> b) { + apply { + max(10, 12); + } +} + +// change functionProtype usage to make name as identifier for extern and functiondeclaration diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_functionDecl.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_functionDecl.p4 new file mode 100644 index 00000000..49ecad1d --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_functionDecl.p4 @@ -0,0 +1,13 @@ +bool isGreaterThan(bit<16> a, bit<16> b) { + if(a < b) { + return false; + } + + return true; +} + +control test_control(bit<16> a) { + bool c = isGreaterThan(a, 5); + + apply {} +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_functionOverload.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_functionOverload.p4 new file mode 100644 index 00000000..e577d19e --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_functionOverload.p4 @@ -0,0 +1,21 @@ +bool isGreaterThan(bit<16> a, bit<16> b) { + if(a < b) { + return false; + } + + return true; +} + +bool isGreaterThan(bit<16> c, bit<16> d, bit<16> e) { + if(c < d && d > e) { + return false; + } + return true; +} + +control test_control(bit<16> a) { + bool c = isGreaterThan(a, 5); + bool d = isGreaterThan(a, 5, 6); + + apply {} +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_const.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_const.p4 new file mode 100644 index 00000000..ecef0592 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_const.p4 @@ -0,0 +1,6 @@ +struct childStruct { + T varIt; + S a; +} + +const childStruct, bool> a = { varIt = 5, a = false }; \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_controlTypeDecl.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_controlTypeDecl.p4 new file mode 100644 index 00000000..ecc5a0fc --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_controlTypeDecl.p4 @@ -0,0 +1,12 @@ +control type_decl(out T b); + +control dummy(out bit<16> b) { + bit<16> a; + apply { + a = b; + } +} + +package final_package(type_decl> input_obj); + +final_package(dummy()) test; \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_default_parameter.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_default_parameter.p4 new file mode 100644 index 00000000..00f52c82 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_default_parameter.p4 @@ -0,0 +1,10 @@ +// Need to check how this works as new instance of generic_value is still of type T +// rather than bit<16> from dummy +control dummy(out bit<16> b) { + apply { + } +} + +control generic_value(out T b); + +package default_value(generic_value control_as_param = dummy()); \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_diffTypeParamNames.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_diffTypeParamNames.p4 new file mode 100644 index 00000000..87a5ae27 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_diffTypeParamNames.p4 @@ -0,0 +1,14 @@ +struct Child { + G data; +} + +struct Parent { + Child g; +} + +control c() { + apply { + Parent> n; + bit<16> x = n.g.data; + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_externFunction.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_externFunction.p4 new file mode 100644 index 00000000..1f816180 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_externFunction.p4 @@ -0,0 +1,8 @@ +extern T test_function(inout T z); + +control dummy(out bit<16> b) { + bit<16> a = test_function>(b); + apply { + a = b; + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_functionDecl.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_functionDecl.p4 new file mode 100644 index 00000000..3e441cff --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_functionDecl.p4 @@ -0,0 +1,13 @@ +bool isEqual(S a, S b) { + if(a == b) { + return false; + } + + return true; +} + +control test_control(bit<16> a) { + bool c = isEqual>(a, 5); + + apply {} +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_header.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_header.p4 new file mode 100644 index 00000000..13b58a22 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_header.p4 @@ -0,0 +1,9 @@ +header header1_test { + T a; + bit<48> test; +} + +control test() { + header1_test hdr_var; + apply { } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_headerUnion.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_headerUnion.p4 new file mode 100644 index 00000000..238ef5fa --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_headerUnion.p4 @@ -0,0 +1,11 @@ +// Generic header union +header_union HU { + bit<16> regular; + T generic; +} + +control test() { + HU> test; + apply { + } +} diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_header_nested.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_header_nested.p4 new file mode 100644 index 00000000..47a7cb94 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_header_nested.p4 @@ -0,0 +1,27 @@ +// Note: not compiling in p4c if struct if defined before +// (CGTest_generic_header.p4 compiles), need to check why +header parentHdr { + T t; +} + +struct childStruct { + bit<16> varIt; + parentHdr> t; +} + +header header1_test { + T a; + bit<48> test; + childStruct structTest; +} + +const bit<16> a = 2 * 5; + +control test() { + header1_test> hdr_var; + bit<16> value; + apply { + hdr_var.isValid(); + value = hdr_var.structTest.t.setValid(); + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_invokingExpression.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_invokingExpression.p4 new file mode 100644 index 00000000..966be769 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_invokingExpression.p4 @@ -0,0 +1,12 @@ +extern test { + test(); + T getTheDifference(in T a, bit<16> b); +} + +parser name(bit<16> a) { + test() e; + + state State { + bit<16> c = e.getTheDifference(a, 5); + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_invokingExpression_methodCallstatement.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_invokingExpression_methodCallstatement.p4 new file mode 100644 index 00000000..53938286 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_invokingExpression_methodCallstatement.p4 @@ -0,0 +1,32 @@ +extern test { + test(); + // getTheDifference is a generator function even when + // extern is resolved with generic (because of H) + T getTheDifference(in H a, bit<16> b); + + // getTheSum wouldn't be an instance when extern + // resolved - so wouldn't be generated again + T getTheSum(in T a, bit<16> b); + + // no generic return type + bool isEqual(in bit<16> a, T b); +} + +// doesn't have global type parameter (extern declaration parent of method prototype) +extern parentNotGeneric { + parentNotGeneric(); + bool isEqual2(in bit<16> a, T b); +} + +parser name(bit<16> a) { + test>() e; + parentNotGeneric() f; + + bool isEqual = e.isEqual(5, 6); + bool isEqual2 = f.isEqual2(5, 10w6); + + state State { + e.getTheDifference(a, 5); + bit<16> c = e.getTheSum(a, 5); + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_methodcallstatements.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_methodcallstatements.p4 new file mode 100644 index 00000000..71cab650 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_methodcallstatements.p4 @@ -0,0 +1,16 @@ +extern test { + test(); + T getTheDifference(in H a, bit<16> b); +} +parser name(bit<16> a) { + test>() e; + + state State { + e.getTheDifference(a, 5); + } +} +// Note: output is: +// getTheDifference: a(PARAMETER, BASETYPE), b(PARAMETER, BASETYPE) +// getTheDifference: H(TYPEPARAMETER), a(PARAMETERGENERATOR, TYPEPARAMETER), b(PARAMETER, BASETYPE) +// getTheDifference: H(TYPEPARAMETER), a(PARAMETERGENERATOR, TYPEPARAMETER), b(PARAMETER, BASETYPE) +// Need to differentiate the first two diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_packageTypeDecl.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_packageTypeDecl.p4 new file mode 100644 index 00000000..fc972b45 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_packageTypeDecl.p4 @@ -0,0 +1,3 @@ +package simple_switch(T should_be_int); + +simple_switch>(2w0) test; \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_package_parser.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_package_parser.p4 new file mode 100644 index 00000000..05c0cd0c --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_package_parser.p4 @@ -0,0 +1,12 @@ +parser parser_decl(out bit<16> b) { + bit<16> a = 1; + state start { + b = a + b; + transition accept; + } +} + +parser parser_type_decl(out T b); +package only_package(T _p); + +only_package>>(parser_decl()) test; \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_parserTypeDecl.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_parserTypeDecl.p4 new file mode 100644 index 00000000..7072aee1 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_parserTypeDecl.p4 @@ -0,0 +1,15 @@ +extern test { + test(); + void extract(); +} + +// parserTypeDeclaration can be generic +// but not parserDeclaration +parser with_generics(in T a, U externObj); + +control top()(with_generics, test> hello) { + test() e; + apply { + e.extract(); + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_struct.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_struct.p4 new file mode 100644 index 00000000..63cf7d00 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_struct.p4 @@ -0,0 +1,12 @@ +// Breaks generateInstance function +struct childStruct { + T varIt; + S a; +} + +control test() { + childStruct, bool> struct_var; + bit<16> value; + apply { + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_struct_nested_inside_header.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_struct_nested_inside_header.p4 new file mode 100644 index 00000000..d406118f --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_struct_nested_inside_header.p4 @@ -0,0 +1,23 @@ +// Breaks generateInstance function +// 1. When childStruct t; is added as a structField, the type is stillchildStruct since not all the generic values are defined (T) +// 2. When parentHdr is instantiated as a type for variable hdr_var, it passed in value for T +// 2a. So ideally childStruct shouldn't have a problem being created as a regular object as all values are defined +// But breaks in current implementation as the value of c cannot be referred when generating instance of childStruct +// as c is in the AST and cannot be retrieved in the P4LanguageObject generateInstance function +struct childStruct { + T varIt; + S a; +} + +header parentHdr { + bool c; + childStruct t; + T a; +} + +control test() { + parentHdr> hdr_var; + bit<16> value; + apply { + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_variable.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_variable.p4 new file mode 100644 index 00000000..da9644fc --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_generic_variable.p4 @@ -0,0 +1,18 @@ +X getSum(X a) { + X b; + + return b; +} + +bool isEqual(T a, bit<16> u) { + bit<16> c = getSum(u); + // bit<16> c = getSum(a); // this does not compile + return false; +} + +control test_control(bit<16> a) { + + bool isEqualAnswer = isEqual>(16w1, 16w12); + + apply {} +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_header.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_header.p4 new file mode 100644 index 00000000..f3b152f2 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_header.p4 @@ -0,0 +1,9 @@ +header header1_test { + bit<16> a; + bit<48> test; +} + +control test() { + header1_test hdr_var; + apply { } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_instantiation_initializer.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_instantiation_initializer.p4 new file mode 100644 index 00000000..fd558158 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_instantiation_initializer.p4 @@ -0,0 +1,20 @@ +extern Balancer { + Balancer(); + // get the number of active flows + bit<32> getFlowCount(); + // return port index used for load-balancing + // @param address: IPv4 source address of flow + abstract bit<4> on_new_flow(in bit<32> address); +} + +control test() { + // Instantiate a balancer + Balancer() b = { // provide an implementation for the abstract methods + bit<4> on_new_flow(in bit<32> address) { + // uses the address and the number of flows to load balance + bit<32> count = this.getFlowCount(); // call method of the same instance + return (address + count)[3:0]; + } + }; + apply {} +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_package_parser.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_package_parser.p4 new file mode 100644 index 00000000..b7ca414a --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_package_parser.p4 @@ -0,0 +1,12 @@ +parser parser_decl(bit<16> b) { + bit<16> a = 1; + state start { + a = a + b; + transition accept; + } +} + +parser parser_type_decl(bit<16> b); +package only_package(parser_type_decl _p); + +only_package(parser_decl()) test; \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_parser.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser.p4 new file mode 100644 index 00000000..a6a9ba92 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser.p4 @@ -0,0 +1,22 @@ +parser P(inout int data) { + state start { + int b; + transition select(b) { + 0: parse_tcp_option_ss; + 1: parse_tcp_option_s; + 2: parse_tcp_option_sack; + } + } + + state parse_tcp_option_s { + transition start; + } + + state parse_tcp_option_ss { + transition start; + } + + state parse_tcp_option_sack { + transition start; + } +} diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_parserTypeDecl.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_parserTypeDecl.p4 new file mode 100644 index 00000000..f5952909 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_parserTypeDecl.p4 @@ -0,0 +1,14 @@ +extern test { + test(); + void extract(); +} + +// parserTypeDeclaration can be generic +// but not parserDeclaration +parser normal_parser(in bit<16> a, test externObj); + +control top()(normal_parser hello) { + test() e; + apply { + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_control.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_control.p4 new file mode 100644 index 00000000..52938989 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_control.p4 @@ -0,0 +1,28 @@ +control process_int_main () { + apply { + if(1 == 1) { + int i = 1; + } + } +} + +control FabricEgress () { + apply { + process_int_main.apply(); + } +} + +parser P(inout H data) { + state start { + transition select() { + 5: parse_tcp_option_sack; + } + } + +// Some states omitted + + state parse_tcp_option_sack { + FabricEgress.apply(); + transition start; + } +} diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_empty.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_empty.p4 new file mode 100644 index 00000000..4e281bd0 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_empty.p4 @@ -0,0 +1,3 @@ +parser P(inout int data) { + state check {} +} diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_expressions.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_expressions.p4 new file mode 100644 index 00000000..86787812 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_expressions.p4 @@ -0,0 +1,55 @@ +extern packet_in { + void extract(out T headerLvalue); + T fillin(int number); +} + +extern packet_out_fake { + void compile(out O hello, in T hi); + int fake2(); +} + +header ipv6_t { + bit<4> next_hdr; + packet_out_fake packet_out_test; +} + +struct parsed_headers_t { + int ethernet; + ipv6_t ipv6; +} + +struct fabric_metadata_t { + bit<8> ip_proto; +} + +parser FabricParser (packet_in packet, + out parsed_headers_t hdr, + inout fabric_metadata_t fabric_metadata) { + + bit<6> last_ipv4_dscp = 0; + + state start { + transition select(hdr.ethernet) { + 8w6: empty; + } + } + + state empty { + + } + + state parse_packet_out { + // call made to packet (packet_in type) + // lvalue construct based namespacing for packet.extract() + packet.extract(hdr.ethernet); + // type checking next_dr under ipv6 scope under the hdr scope + fabric_metadata.ip_proto = hdr.ipv6.next_hdr; + // call made to packet_out_fake construct + // namespacing parsed_headers_t -> ipv6_t -> packet_out_fake -> compile + // (expression construct for hdr.ipv6.packet_out_test.compile()) + packet.extract(hdr.ipv6.packet_out_test.compile()); + transition select(packet.fillin(2).fake2()) { + default : start; + } + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_extensive.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_extensive.p4 new file mode 100644 index 00000000..94af9e2e --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_extensive.p4 @@ -0,0 +1,253 @@ +extern packet_in { + void extract(out T headerLvalue); + void extract(out T variableSizeHeader, in bit<32> varFieldSizeBits); + T lookahead(); + bit<32> length(); // This method may be unavailable in some architectures + void advance(bit<32> bits); +} + +typedef bit<9> PortId_t; + +struct standard_metadata_t { + PortId_t ingress_port; + PortId_t egress_spec; + PortId_t egress_port; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<6> dscp; + bit<2> ecn; + bit<16> total_len; + bit<16> identification; + bit<3> flags; + bit<13> frag_offset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdr_checksum; + bit<32> src_addr; + bit<32> dst_addr; +} + +header ipv6_t { + bit<4> next_hdr; +} + +header eth_type_t { + bit<16> value; +} + +header ethernet_t { + eth_type_t eth_type; +} + +struct parsed_headers_t { + ethernet_t ethernet; + int packet_out; + ipv4_t ipv4; + ipv6_t ipv6; +} + +struct fabric_metadata_t { + bit<16> ip_eth_type; + int vlan_id; + bit<3> vlan_pri; + bit<1> vlan_cfi; + bit<8> mpls_ttl; + bool skip_forwarding; + bool is_ipv4; + bool is_ipv6; + int fwd_type; + int next_id; + bool is_multicast; + bool is_controller_packet_out; + bit<8> ip_proto; + bit<16> l4_sport; + bit<16> l4_dport; + bit<32> ipv4_src_addr; + bit<32> ipv4_dst_addr; + int slice_id; + bit<2> packet_color; + bit<6> dscp; +} + +parser FabricParser (packet_in packet, + out parsed_headers_t hdr, + inout fabric_metadata_t fabric_metadata, + inout standard_metadata_t standard_metadata) { + + bit<6> last_ipv4_dscp = 0; + + state start { + transition select(standard_metadata.ingress_port) { + 1: parse_packet_out; + default: parse_ethernet; + } + } + + state parse_packet_out { + packet.extract(hdr.packet_out); + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + // fabric_metadata.last_eth_type = hdr.ethernet.eth_type; + fabric_metadata.vlan_id = DEFAULT_VLAN_ID; + transition select(hdr.ethernet.eth_type){ + // // ETHERTYPE_QINQ: parse_vlan_tag; + // ETHERTYPE_QINQ_NON_STD: parse_vlan_tag; + // ETHERTYPE_VLAN: parse_vlan_tag; + // ETHERTYPE_MPLS: parse_mpls; + // ETHERTYPE_IPV4: pre_parse_ipv4; + // ETHERTYPE_IPV6: pre_parse_ipv6; + default: accept; + } + } + + + state parse_mpls { + // packet.extract(hdr.mpls); + // fabric_metadata.is_mpls = _TRUE; + // fabric_metadata.mpls_label = hdr.mpls.label; + fabric_metadata.mpls_ttl = 5; + // There is only one MPLS label for this fabric. + // Assume header after MPLS header is IPv4/IPv6 + // Lookup first 4 bits for version + transition select(packet.lookahead>()) { + // The packet should be either IPv4 or IPv6. + // If we have MPLS, go directly to parsing state without + // moving to pre_ states, the packet is considered MPLS + IP_VERSION_4: parse_ipv4; + IP_VERSION_6: parse_ipv6; + default: parse_ethernet; + } + } + + // Intermediate state to set is_ipv4 + state pre_parse_ipv4 { + fabric_metadata.is_ipv4 = true; + transition parse_ipv4; + } + state parse_ipv4 { + packet.extract(hdr.ipv4); + fabric_metadata.ip_proto = hdr.ipv4.protocol; + fabric_metadata.ip_eth_type = ETHERTYPE_IPV4; + last_ipv4_dscp = hdr.ipv4.dscp; + //Need header verification? + transition select(hdr.ipv4.protocol) { + PROTO_TCP: parse_tcp; + // PROTO_UDP: parse_udp; + // PROTO_ICMP: parse_icmp; + default: accept; + } + } + + // // Intermediate state to set is_ipv6 + // state pre_parse_ipv6 { + // fabric_metadata.is_ipv6 = true; + // transition parse_ipv6; + // } + state parse_ipv6 { + packet.extract(hdr.ipv6); + fabric_metadata.ip_proto = hdr.ipv6.next_hdr; + fabric_metadata.ip_eth_type = ETHERTYPE_IPV6; + transition select(hdr.ipv6.next_hdr) { + // PROTO_TCP: parse_tcp; + // PROTO_UDP: parse_udp; + // PROTO_ICMPV6: parse_icmp; + default: accept; + } + } + + state parse_tcp { + // packet.extract(hdr.tcp); + // fabric_metadata.l4_sport = hdr.tcp.sport; + // fabric_metadata.l4_dport = hdr.tcp.dport; + transition parse_int; + } + + // state parse_udp { + // packet.extract(hdr.udp); + // fabric_metadata.l4_sport = hdr.udp.sport; + // fabric_metadata.l4_dport = hdr.udp.dport; + // transition select(hdr.udp.dport) { + // UDP_PORT_GTPU: parse_gtpu; + // default: parse_int; + // } + // } + + // state parse_icmp { + // packet.extract(hdr.icmp); + // transition accept; + // } + + // state parse_gtpu { + // transition select(hdr.ipv4.dst_addr[31:32-S1U_SGW_PREFIX_LEN]) { + // // Avoid parsing GTP and inner headers if we know this GTP packet + // // is not to be processed by this switch. + // // FIXME: use parser value sets when support is ready in ONOS. + // // To set the S1U_SGW_PREFIX value at runtime. + // S1U_SGW_PREFIX[31:32-S1U_SGW_PREFIX_LEN]: do_parse_gtpu; + // default: accept; + // } + // } + + // state do_parse_gtpu { + // packet.extract(hdr.gtpu); + // transition parse_inner_ipv4; + // } + + // state parse_inner_ipv4 { + // packet.extract(hdr.inner_ipv4); + // last_ipv4_dscp = hdr.inner_ipv4.dscp; + // transition select(hdr.inner_ipv4.protocol) { + // PROTO_TCP: parse_tcp; + // PROTO_UDP: parse_inner_udp; + // PROTO_ICMP: parse_icmp; + // default: accept; + // } + // } + + // state parse_inner_udp { + // packet.extract(hdr.inner_udp); + // fabric_metadata.l4_sport = hdr.inner_udp.sport; + // fabric_metadata.l4_dport = hdr.inner_udp.dport; + // transition parse_int; + // } + + state parse_int { + transition select(last_ipv4_dscp) { + // INT_DSCP &&& INT_DSCP: parse_intl4_shim; + default: accept; + } + } + + // state parse_intl4_shim { + // packet.extract(hdr.intl4_shim); + // transition parse_int_header; + // } + + // state parse_int_header { + // packet.extract(hdr.int_header); + // // If there is no INT metadata but the INT header (plus shim and tail) + // // exists, default value of length field in shim header should be + // // INT_HEADER_LEN_WORDS. + // transition select (hdr.intl4_shim.len_words) { + // INT_HEADER_LEN_WORDS: parse_intl4_tail; + // default: parse_int_data; + // } + // } + + // state parse_int_data { + // // Parse INT metadata stack, but not tail + // packet.extract(hdr.int_data, (bit<32>) (hdr.intl4_shim.len_words - INT_HEADER_LEN_WORDS) << 5); + // transition parse_intl4_tail; + // } + + // state parse_intl4_tail { + // packet.extract(hdr.intl4_tail); + // transition accept; + // } +} diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_undefined.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_undefined.p4 new file mode 100644 index 00000000..06dc306d --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_parser_undefined.p4 @@ -0,0 +1,17 @@ +parser P(inout H data) { + state start { + transition select(b) { + 5: parse_tcp_option_sack; + 0: parse_tcp_option_end; + 1: parse_tcp_option_nop; + 2: parse_tcp_option_ss; + 3: parse_tcp_option_s; + } + } + +// Some states omitted + + state parse_tcp_option_sack { + transition start; + } +} diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_table.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_table.p4 new file mode 100644 index 00000000..e8b892d9 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_table.p4 @@ -0,0 +1,27 @@ +control pipe(out bool pass) { + action Reject(bit<8> rej, bit<8> bar) { + if (rej == 0) { + pass = true; + } else { + pass = false; + } + } + action NotAccpet(bit<8> rej, bit<8> bar) { + if (rej == 0) { + pass = false; + } else { + pass = true; + } + } + table t { + actions = { + Reject(); + NotAccpet(); + } + default_action = Reject(1, 0); + } + apply { + bool x = true; + t.apply(); + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_table_with_lvalue_apply.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_table_with_lvalue_apply.p4 new file mode 100644 index 00000000..2f8835e5 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_table_with_lvalue_apply.p4 @@ -0,0 +1,20 @@ +control pipe() { + action Reject(bit<8> rej, bit<8> bar, bool pass) { + if (rej == 0) { + pass = true; + } else { + pass = false; + } + if (bar == 0) { + pass = false; + } + } + table t { + actions = { Reject(); Reject(); } + default_action = Reject(1, 0); + } + apply { + bool x = true; + t.apply(); + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/CGTest_typedef_header.p4 b/fonda/p4_testsuite/callGraphTestCases/CGTest_typedef_header.p4 new file mode 100644 index 00000000..ec1af64a --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/CGTest_typedef_header.p4 @@ -0,0 +1,14 @@ +header GH { + T data; +} + +typedef GH>[3] Stack; + +control c(out bit x) { + GH g; + apply { + Stack s; + bool b = s[0].isValid(); + b = g.isValid(); + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_function.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_function.out new file mode 100644 index 00000000..bffad6fa --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_function.out @@ -0,0 +1,2 @@ +GLOBAL: increment_0(FUNCTIONDECLARATION, BASETYPE) +increment_0: validity(VARIABLE, BASETYPE) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_functionDecl.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_functionDecl.out new file mode 100644 index 00000000..15cd1bb9 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_functionDecl.out @@ -0,0 +1,3 @@ +GLOBAL: isGreaterThan_2(FUNCTIONDECLARATION, BASETYPE), test_control(CONTROLDECLARATION) +isGreaterThan_2: a(PARAMETER, BASETYPE), b(PARAMETER, BASETYPE) +test_control: isGreaterThan_2(FUNCTIONDECLARATION, BASETYPE)(GLOBAL(CONSTANTVALUE)), a(PARAMETER, BASETYPE), apply(DEFAULT), c(VARIABLE, BASETYPE) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_functionOverload.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_functionOverload.out new file mode 100644 index 00000000..36d90c16 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_functionOverload.out @@ -0,0 +1,4 @@ +GLOBAL: isGreaterThan_2(FUNCTIONDECLARATION, BASETYPE), isGreaterThan_3(FUNCTIONDECLARATION, BASETYPE), test_control(CONTROLDECLARATION) +isGreaterThan_2: a(PARAMETER, BASETYPE), b(PARAMETER, BASETYPE) +isGreaterThan_3: c(PARAMETER, BASETYPE), d(PARAMETER, BASETYPE), e(PARAMETER, BASETYPE) +test_control: isGreaterThan_2(FUNCTIONDECLARATION, BASETYPE)(GLOBAL(CONSTANTVALUE)), isGreaterThan_3(FUNCTIONDECLARATION, BASETYPE)(GLOBAL(CONSTANTVALUE)), a(PARAMETER, BASETYPE), apply(DEFAULT), c(VARIABLE, BASETYPE), d(VARIABLE, BASETYPE) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_const.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_const.out new file mode 100644 index 00000000..f3292871 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_const.out @@ -0,0 +1,3 @@ +GLOBAL: a(VARIABLE, STRUCTTYPEDECLARATION), childStruct(STRUCTTYPEDECLARATIONGENERATOR) +childStruct: a(VARIABLE, BASETYPE), varIt(VARIABLE, BASETYPE) +childStruct: S(TYPEPARAMETER), T(TYPEPARAMETER), a(VARIABLEGENERATOR, TYPEPARAMETER), varIt(VARIABLEGENERATOR, TYPEPARAMETER) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_controlTypeDecl.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_controlTypeDecl.out new file mode 100644 index 00000000..1db0ef05 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_controlTypeDecl.out @@ -0,0 +1,5 @@ +GLOBAL: dummy(CONTROLDECLARATION)(GLOBAL(CONSTANTVALUE)), final_package(PACKAGETYPEDECLARATION)(GLOBAL(CONSTANTVALUE)), dummy(CONTROLDECLARATION), final_package(PACKAGETYPEDECLARATION), test(SUBCLASS, PACKAGETYPEDECLARATION), type_decl(CONTROLTYPEDECLARATIONGENERATOR) +dummy: a(VARIABLE, BASETYPE), apply(DEFAULT), b(PARAMETER, BASETYPE) +final_package: input_obj(PARAMETER, CONTROLTYPEDECLARATION) +type_decl: apply(DEFAULT), b(PARAMETER, BASETYPE) +type_decl: T(TYPEPARAMETER), apply(DEFAULT), b(PARAMETERGENERATOR, TYPEPARAMETER) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_diffTypeParamNames.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_diffTypeParamNames.out new file mode 100644 index 00000000..c56631c3 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_diffTypeParamNames.out @@ -0,0 +1,7 @@ +Child: data(VARIABLE, BASETYPE) +Child: G(TYPEPARAMETER), data(VARIABLEGENERATOR, TYPEPARAMETER) +GLOBAL: Child(STRUCTTYPEDECLARATIONGENERATOR), Parent(STRUCTTYPEDECLARATIONGENERATOR), c(CONTROLDECLARATION) +Parent: g(VARIABLE, STRUCTTYPEDECLARATION) +Parent: T(TYPEPARAMETER), g(VARIABLEGENERATOR, STRUCTTYPEDECLARATIONGENERATOR) +apply: n(VARIABLE, STRUCTTYPEDECLARATION), x(VARIABLE, BASETYPE) +c: apply(DEFAULT) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_externFunction.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_externFunction.out new file mode 100644 index 00000000..90f6f9e8 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_externFunction.out @@ -0,0 +1,4 @@ +GLOBAL: dummy(CONTROLDECLARATION), test_function_1(EXTERNFUNCTIONDECLARATIONGENERATOR, TYPEPARAMETER) +dummy: test_function_1(EXTERNFUNCTIONDECLARATION, BASETYPE)(GLOBAL(CONSTANTVALUE)), a(VARIABLE, BASETYPE), apply(DEFAULT), b(PARAMETER, BASETYPE) +test_function_1: z(PARAMETER, BASETYPE) +test_function_1: T(TYPEPARAMETER), z(PARAMETERGENERATOR, TYPEPARAMETER) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_functionDecl.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_functionDecl.out new file mode 100644 index 00000000..c8c8b7c3 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_functionDecl.out @@ -0,0 +1,4 @@ +GLOBAL: isEqual_2(FUNCTIONDECLARATIONGENERATOR, BASETYPE), test_control(CONTROLDECLARATION) +isEqual_2: a(PARAMETER, BASETYPE), b(PARAMETER, BASETYPE) +isEqual_2: S(TYPEPARAMETER), a(PARAMETERGENERATOR, TYPEPARAMETER), b(PARAMETERGENERATOR, TYPEPARAMETER) +test_control: isEqual_2(FUNCTIONDECLARATION, BASETYPE)(GLOBAL(CONSTANTVALUE)), a(PARAMETER, BASETYPE), apply(DEFAULT), c(VARIABLE, BASETYPE) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_header.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_header.out new file mode 100644 index 00000000..70df0921 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_header.out @@ -0,0 +1,4 @@ +GLOBAL: header1_test(HEADERTYPEDECLARATIONGENERATOR), test(CONTROLDECLARATION) +header1_test: a(VARIABLE, BASETYPE), isValid(FUNCTIONPROTOTYPE, BASETYPE), setInvalid(FUNCTIONPROTOTYPE, BASETYPE), setValid(FUNCTIONPROTOTYPE, BASETYPE), test(VARIABLE, BASETYPE) +header1_test: T(TYPEPARAMETER), a(VARIABLEGENERATOR, TYPEPARAMETER), isValid(FUNCTIONPROTOTYPE, BASETYPE), minSizeInBits(FUNCTIONPROTOTYPE, BASETYPE), minSizeInBytes(FUNCTIONPROTOTYPE, BASETYPE), setInvalid(FUNCTIONPROTOTYPE, BASETYPE), setValid(FUNCTIONPROTOTYPE, BASETYPE), test(VARIABLE, BASETYPE) +test: apply(DEFAULT), hdr_var(VARIABLE, HEADERTYPEDECLARATION) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_headerUnion.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_headerUnion.out new file mode 100644 index 00000000..0f1d4cae --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_headerUnion.out @@ -0,0 +1,4 @@ +GLOBAL: HU(HEADERUNIONDECLARATIONGENERATOR), test(CONTROLDECLARATION) +HU: generic(VARIABLE, BASETYPE), regular(VARIABLE, BASETYPE) +HU: T(TYPEPARAMETER), generic(VARIABLEGENERATOR, TYPEPARAMETER), regular(VARIABLE, BASETYPE) +test: apply(DEFAULT), test(VARIABLE, HEADERUNIONDECLARATION) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_header_nested.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_header_nested.out new file mode 100644 index 00000000..9d6f0460 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_header_nested.out @@ -0,0 +1,7 @@ +GLOBAL: a(VARIABLE, BASETYPE), childStruct(STRUCTTYPEDECLARATION), header1_test(HEADERTYPEDECLARATIONGENERATOR), parentHdr(HEADERTYPEDECLARATIONGENERATOR), test(CONTROLDECLARATION) +childStruct: t(VARIABLE, HEADERTYPEDECLARATION), varIt(VARIABLE, BASETYPE) +header1_test: a(VARIABLE, BASETYPE), isValid(FUNCTIONPROTOTYPE, BASETYPE), setInvalid(FUNCTIONPROTOTYPE, BASETYPE), setValid(FUNCTIONPROTOTYPE, BASETYPE), structTest(VARIABLE, STRUCTTYPEDECLARATION), test(VARIABLE, BASETYPE) +header1_test: T(TYPEPARAMETER), a(VARIABLEGENERATOR, TYPEPARAMETER), isValid(FUNCTIONPROTOTYPE, BASETYPE), minSizeInBits(FUNCTIONPROTOTYPE, BASETYPE), minSizeInBytes(FUNCTIONPROTOTYPE, BASETYPE), setInvalid(FUNCTIONPROTOTYPE, BASETYPE), setValid(FUNCTIONPROTOTYPE, BASETYPE), structTest(VARIABLE, STRUCTTYPEDECLARATION), test(VARIABLE, BASETYPE) +parentHdr: isValid(FUNCTIONPROTOTYPE, BASETYPE), setInvalid(FUNCTIONPROTOTYPE, BASETYPE), setValid(FUNCTIONPROTOTYPE, BASETYPE), t(VARIABLE, BASETYPE) +parentHdr: T(TYPEPARAMETER), isValid(FUNCTIONPROTOTYPE, BASETYPE), minSizeInBits(FUNCTIONPROTOTYPE, BASETYPE), minSizeInBytes(FUNCTIONPROTOTYPE, BASETYPE), setInvalid(FUNCTIONPROTOTYPE, BASETYPE), setValid(FUNCTIONPROTOTYPE, BASETYPE), t(VARIABLEGENERATOR, TYPEPARAMETER) +test: apply(DEFAULT): [isValid(FUNCTIONPROTOTYPE, BASETYPE), setValid(FUNCTIONPROTOTYPE, BASETYPE)], hdr_var(VARIABLE, HEADERTYPEDECLARATION), value(VARIABLE, BASETYPE) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_invokingExpression.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_invokingExpression.out new file mode 100644 index 00000000..d1ca6f99 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_invokingExpression.out @@ -0,0 +1,6 @@ +GLOBAL: name(PARSERDECLARATION), test(EXTERNDECLARATION) +State: getTheDifference_2(FUNCTIONPROTOTYPE, BASETYPE)(test(EXTERNDECLARATION)), c(VARIABLE, BASETYPE) +getTheDifference_2: a(PARAMETER, BASETYPE), b(PARAMETER, BASETYPE) +getTheDifference_2: T(TYPEPARAMETER), a(PARAMETERGENERATOR, TYPEPARAMETER), b(PARAMETER, BASETYPE) +name: test(EXTERNDECLARATION)(GLOBAL(CONSTANTVALUE)), State(DEFAULT), a(PARAMETER, BASETYPE), accept(DEFAULT), apply(INVOKABLEKEYWORD), e(SUBCLASS, EXTERNDECLARATION), reject(DEFAULT) +test: getTheDifference_2(FUNCTIONPROTOTYPEGENERATOR, TYPEPARAMETER), test(DEFAULT) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_invokingExpression_methodCallstatement.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_invokingExpression_methodCallstatement.out new file mode 100644 index 00000000..8e2022e8 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_invokingExpression_methodCallstatement.out @@ -0,0 +1,15 @@ +GLOBAL: name(PARSERDECLARATION), parentNotGeneric(EXTERNDECLARATION), test(EXTERNDECLARATIONGENERATOR) +State: getTheDifference_2(FUNCTIONPROTOTYPE, BASETYPE)(test(EXTERNDECLARATIONGENERATOR)), getTheSum_2(FUNCTIONPROTOTYPE, BASETYPE)(test(EXTERNDECLARATIONGENERATOR)), c(VARIABLE, BASETYPE) +getTheDifference_2: a(PARAMETER, BASETYPE), b(PARAMETER, BASETYPE) +getTheDifference_2: H(TYPEPARAMETER), a(PARAMETERGENERATOR, TYPEPARAMETER), b(PARAMETER, BASETYPE) +getTheDifference_2: H(TYPEPARAMETER), a(PARAMETERGENERATOR, TYPEPARAMETER), b(PARAMETER, BASETYPE) +getTheSum_2: a(PARAMETER, BASETYPE), b(PARAMETER, BASETYPE) +getTheSum_2: a(PARAMETERGENERATOR, TYPEPARAMETER), b(PARAMETER, BASETYPE) +isEqual2_2: a(PARAMETER, BASETYPE), b(PARAMETER, STRING) +isEqual2_2: T(TYPEPARAMETER), a(PARAMETER, BASETYPE), b(PARAMETERGENERATOR, TYPEPARAMETER) +isEqual_2: a(PARAMETER, BASETYPE), b(PARAMETER, BASETYPE) +isEqual_2: a(PARAMETER, BASETYPE), b(PARAMETERGENERATOR, TYPEPARAMETER) +name: isEqual2_2(FUNCTIONPROTOTYPE, BASETYPE)(parentNotGeneric(EXTERNDECLARATION)), isEqual_2(FUNCTIONPROTOTYPE, BASETYPE)(test(EXTERNDECLARATIONGENERATOR)), parentNotGeneric(EXTERNDECLARATION)(GLOBAL(CONSTANTVALUE)), test(EXTERNDECLARATION)(GLOBAL(CONSTANTVALUE)), State(DEFAULT), a(PARAMETER, BASETYPE), accept(DEFAULT), apply(INVOKABLEKEYWORD), e(SUBCLASS, EXTERNDECLARATION), f(SUBCLASS, EXTERNDECLARATION), isEqual(VARIABLE, BASETYPE), isEqual2(VARIABLE, BASETYPE), reject(DEFAULT) +parentNotGeneric: isEqual2_2(FUNCTIONPROTOTYPEGENERATOR, BASETYPE), parentNotGeneric(DEFAULT) +test: getTheDifference_2(FUNCTIONPROTOTYPEGENERATOR, BASETYPE), getTheSum_2(FUNCTIONPROTOTYPE, BASETYPE), isEqual_2(FUNCTIONPROTOTYPE, BASETYPE), test(DEFAULT) +test: T(TYPEPARAMETER), getTheDifference_2(FUNCTIONPROTOTYPEGENERATOR, TYPEPARAMETER), getTheSum_2(FUNCTIONPROTOTYPEGENERATOR, TYPEPARAMETER), isEqual_2(FUNCTIONPROTOTYPEGENERATOR, BASETYPE), test(DEFAULT) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_methodcallstatements.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_methodcallstatements.out new file mode 100644 index 00000000..ec42c1fb --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_methodcallstatements.out @@ -0,0 +1,7 @@ +GLOBAL: name(PARSERDECLARATION), test(EXTERNDECLARATIONGENERATOR) +getTheDifference_2: a(PARAMETER, BASETYPE), b(PARAMETER, BASETYPE) +getTheDifference_2: H(TYPEPARAMETER), a(PARAMETERGENERATOR, TYPEPARAMETER), b(PARAMETER, BASETYPE) +getTheDifference_2: H(TYPEPARAMETER), a(PARAMETERGENERATOR, TYPEPARAMETER), b(PARAMETER, BASETYPE) +name: test(EXTERNDECLARATION)(GLOBAL(CONSTANTVALUE)), State(DEFAULT): [getTheDifference_2(FUNCTIONPROTOTYPE, BASETYPE)], a(PARAMETER, BASETYPE), accept(DEFAULT), apply(INVOKABLEKEYWORD), e(SUBCLASS, EXTERNDECLARATION), reject(DEFAULT) +test: getTheDifference_2(FUNCTIONPROTOTYPEGENERATOR, BASETYPE), test(DEFAULT) +test: T(TYPEPARAMETER), getTheDifference_2(FUNCTIONPROTOTYPEGENERATOR, TYPEPARAMETER), test(DEFAULT) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_packageTypeDecl.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_packageTypeDecl.out new file mode 100644 index 00000000..cd4491bd --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_packageTypeDecl.out @@ -0,0 +1,3 @@ +GLOBAL: simple_switch(PACKAGETYPEDECLARATION)(GLOBAL(CONSTANTVALUE)), simple_switch(PACKAGETYPEDECLARATIONGENERATOR), test(SUBCLASS, PACKAGETYPEDECLARATION) +simple_switch: should_be_int(PARAMETER, BASETYPE) +simple_switch: T(TYPEPARAMETER), should_be_int(PARAMETERGENERATOR, TYPEPARAMETER) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_package_parser.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_package_parser.out new file mode 100644 index 00000000..5a9520d2 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_package_parser.out @@ -0,0 +1,6 @@ +GLOBAL: only_package(PACKAGETYPEDECLARATION)(GLOBAL(CONSTANTVALUE)), parser_decl(PARSERDECLARATION)(GLOBAL(CONSTANTVALUE)), only_package(PACKAGETYPEDECLARATIONGENERATOR), parser_decl(PARSERDECLARATION), parser_type_decl(PARSERTYPEDECLARATIONGENERATOR), test(SUBCLASS, PACKAGETYPEDECLARATION) +only_package: _p(PARAMETER, PARSERTYPEDECLARATION) +only_package: T(TYPEPARAMETER), _p(PARAMETERGENERATOR, TYPEPARAMETER) +parser_decl: a(VARIABLE, BASETYPE), accept(DEFAULT), apply(INVOKABLEKEYWORD), b(PARAMETER, BASETYPE), reject(DEFAULT), start(DEFAULT): [accept(DEFAULT)] +parser_type_decl: apply(DEFAULT), b(PARAMETER, BASETYPE) +parser_type_decl: T(TYPEPARAMETER), apply(DEFAULT), b(PARAMETERGENERATOR, TYPEPARAMETER) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_parserTypeDecl.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_parserTypeDecl.out new file mode 100644 index 00000000..889b6f67 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_parserTypeDecl.out @@ -0,0 +1,5 @@ +GLOBAL: test(EXTERNDECLARATION), top(CONTROLDECLARATION), with_generics(PARSERTYPEDECLARATIONGENERATOR) +test: extract_0(FUNCTIONPROTOTYPE, BASETYPE), test(DEFAULT) +top: test(EXTERNDECLARATION)(GLOBAL(CONSTANTVALUE)), apply(DEFAULT): [extract_0(FUNCTIONPROTOTYPE, BASETYPE)], e(SUBCLASS, EXTERNDECLARATION), hello(PARAMETER, PARSERTYPEDECLARATION) +with_generics: a(PARAMETER, BASETYPE), apply(DEFAULT): [extract_0(FUNCTIONPROTOTYPE, BASETYPE)], externObj(PARAMETER, EXTERNDECLARATION) +with_generics: T(TYPEPARAMETER), U(TYPEPARAMETER), a(PARAMETERGENERATOR, TYPEPARAMETER), apply(DEFAULT): [extract_0(FUNCTIONPROTOTYPE, BASETYPE)], externObj(PARAMETERGENERATOR, TYPEPARAMETER) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_struct.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_struct.out new file mode 100644 index 00000000..9090a134 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_struct.out @@ -0,0 +1,4 @@ +GLOBAL: childStruct(STRUCTTYPEDECLARATIONGENERATOR), test(CONTROLDECLARATION) +childStruct: a(VARIABLE, BASETYPE), varIt(VARIABLE, BASETYPE) +childStruct: S(TYPEPARAMETER), T(TYPEPARAMETER), a(VARIABLEGENERATOR, TYPEPARAMETER), varIt(VARIABLEGENERATOR, TYPEPARAMETER) +test: apply(DEFAULT), struct_var(VARIABLE, STRUCTTYPEDECLARATION), value(VARIABLE, BASETYPE) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_variable.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_variable.out new file mode 100644 index 00000000..0f33c822 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_generic_variable.out @@ -0,0 +1,7 @@ +GLOBAL: getSum_1(FUNCTIONDECLARATIONGENERATOR, TYPEPARAMETER), isEqual_2(FUNCTIONDECLARATIONGENERATOR, BASETYPE), test_control(CONTROLDECLARATION) +getSum_1: a(PARAMETER, BASETYPE), b(VARIABLE, BASETYPE) +getSum_1: a(PARAMETER, BASETYPE), b(VARIABLE, BASETYPE) +getSum_1: X(TYPEPARAMETER), a(PARAMETERGENERATOR, TYPEPARAMETER), b(VARIABLEGENERATOR, TYPEPARAMETER) +isEqual_2: a(PARAMETER, BASETYPE), c(VARIABLE, BASETYPE), u(PARAMETER, BASETYPE) +isEqual_2: getSum_1(FUNCTIONDECLARATION, BASETYPE)(GLOBAL(CONSTANTVALUE)), T(TYPEPARAMETER), a(PARAMETERGENERATOR, TYPEPARAMETER), c(VARIABLE, BASETYPE), u(PARAMETER, BASETYPE) +test_control: isEqual_2(FUNCTIONDECLARATION, BASETYPE)(GLOBAL(CONSTANTVALUE)), a(PARAMETER, BASETYPE), apply(DEFAULT), isEqualAnswer(VARIABLE, BASETYPE) diff --git a/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_typedef_header.out b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_typedef_header.out new file mode 100644 index 00000000..cbc5a093 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/output_files/CGTest_typedef_header.out @@ -0,0 +1,6 @@ +GH: data(VARIABLE, BASETYPE), isValid(FUNCTIONPROTOTYPE, BASETYPE), setInvalid(FUNCTIONPROTOTYPE, BASETYPE), setValid(FUNCTIONPROTOTYPE, BASETYPE) +GH: data(VARIABLE, BASETYPE), isValid(FUNCTIONPROTOTYPE, BASETYPE), setInvalid(FUNCTIONPROTOTYPE, BASETYPE), setValid(FUNCTIONPROTOTYPE, BASETYPE) +GH: T(TYPEPARAMETER), data(VARIABLEGENERATOR, TYPEPARAMETER), isValid(FUNCTIONPROTOTYPE, BASETYPE), minSizeInBits(FUNCTIONPROTOTYPE, BASETYPE), minSizeInBytes(FUNCTIONPROTOTYPE, BASETYPE), setInvalid(FUNCTIONPROTOTYPE, BASETYPE), setValid(FUNCTIONPROTOTYPE, BASETYPE) +GLOBAL: GH(HEADERTYPEDECLARATIONGENERATOR), Stack(TYPEDEFDECLARATION, HEADERTYPEDECLARATION), c(CONTROLDECLARATION) +apply: isValid(FUNCTIONPROTOTYPE, BASETYPE)(GH(HEADERTYPEDECLARATION)), b(VARIABLE, BASETYPE), s(VARIABLE, HEADERTYPEDECLARATION) +c: apply(DEFAULT), g(VARIABLE, HEADERTYPEDECLARATION), x(PARAMETER, BASETYPE) diff --git a/fonda/p4_testsuite/callGraphTestCases/test_script.py b/fonda/p4_testsuite/callGraphTestCases/test_script.py new file mode 100644 index 00000000..b37d4300 --- /dev/null +++ b/fonda/p4_testsuite/callGraphTestCases/test_script.py @@ -0,0 +1,20 @@ +import filecmp +import os + +files = [] +tmp_output_file_name = "tmp.out" +for file in os.listdir('output_files/'): + # print(file) + if(file[-3:] == "out"): + # print(file) + files.append(file[:-4]) + +print(files) + +for file in files: + os.system("java superc.SuperP4 -silent -printCallGraph " + file + ".p4 > " + tmp_output_file_name) + result = filecmp.cmp('output_files/' + file + ".out", tmp_output_file_name) + if result != True: + print("FAILED: " + file + " output differs") + else: + print("Passed: " + file) \ No newline at end of file diff --git a/fonda/p4_testsuite/grammar/multiline_define.p4 b/fonda/p4_testsuite/grammar/multiline_define.p4 new file mode 100644 index 00000000..3f6f346c --- /dev/null +++ b/fonda/p4_testsuite/grammar/multiline_define.p4 @@ -0,0 +1,4 @@ +#define CUR_VERSION \ + 1 + +const int a = CUR_VERSION; \ No newline at end of file diff --git a/fonda/p4_testsuite/grammar/multiline_ifdef.p4 b/fonda/p4_testsuite/grammar/multiline_ifdef.p4 new file mode 100644 index 00000000..5ddedd8a --- /dev/null +++ b/fonda/p4_testsuite/grammar/multiline_ifdef.p4 @@ -0,0 +1,6 @@ +#ifdef TEST_VAR || \ + DEBUG +#define CUR_VERSION 1 +#endif + +const int a = CUR_VERSION; \ No newline at end of file diff --git a/fonda/p4_testsuite/grammar/multiline_preprocessor.p4 b/fonda/p4_testsuite/grammar/multiline_preprocessor.p4 new file mode 100644 index 00000000..e6a6945d --- /dev/null +++ b/fonda/p4_testsuite/grammar/multiline_preprocessor.p4 @@ -0,0 +1,19 @@ +#define INGRESS_MAC_ACL_KEY \ + bit<34> bit1; \ + bool h1; + +#if defined(EGRESS_IP_ACL_ENABLE) || defined(EGRESS_MIRROR_ACL_ENABLE) \ + || defined(DTEL_FLOW_REPORT_ENABLE) + const int a = 1; +#endif + +#define H int a; + +#ifdef HELLO +struct P { + INGRESS_MAC_ACL_KEY + H + bit<32> f1; \ + bit<32> f2; +} +#endif diff --git a/fonda/p4_testsuite/grammar/multiline_statement.p4 b/fonda/p4_testsuite/grammar/multiline_statement.p4 new file mode 100644 index 00000000..544a4866 --- /dev/null +++ b/fonda/p4_testsuite/grammar/multiline_statement.p4 @@ -0,0 +1,4 @@ +header P { + bit<16> \ + a; +} \ No newline at end of file diff --git a/fonda/p4_testsuite/grammar/multiline_struct_preprocessor_define.p4 b/fonda/p4_testsuite/grammar/multiline_struct_preprocessor_define.p4 new file mode 100644 index 00000000..d313c90d --- /dev/null +++ b/fonda/p4_testsuite/grammar/multiline_struct_preprocessor_define.p4 @@ -0,0 +1,7 @@ +#define INGRESS_MAC_ACL_KEY \ + bit<16> bit1; \ + bool h1; + +struct P { + INGRESS_MAC_ACL_KEY +} \ No newline at end of file diff --git a/fonda/p4_testsuite/grammar/output/multiline_define.ast b/fonda/p4_testsuite/grammar/output/multiline_define.ast new file mode 100644 index 00000000..cb713b4a --- /dev/null +++ b/fonda/p4_testsuite/grammar/output/multiline_define.ast @@ -0,0 +1,52 @@ +SuperP4, v. 2.4.0, (C) 2009-2012 New York University +Portions Copyright (c) 1989, 1990 James A. Roskind +Processing /mnt/fonda/p4_testsuite/grammar/multiline_define.p4 ... +TranslationUnit( + start( + program( + input( + Conditional( + , + declaration( + constantDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "const" + ), + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "a" + ) + ) + ), + superc.core.Syntax$Language( + "=" + ), + initializer( + expression( + Conditional( + , + superc.core.Syntax$Text( + "1" + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/grammar/output/multiline_ifdef.ast b/fonda/p4_testsuite/grammar/output/multiline_ifdef.ast new file mode 100644 index 00000000..e864fce8 --- /dev/null +++ b/fonda/p4_testsuite/grammar/output/multiline_ifdef.ast @@ -0,0 +1,68 @@ +SuperP4, v. 2.4.0, (C) 2009-2012 New York University +Portions Copyright (c) 1989, 1990 James A. Roskind +Processing /mnt/fonda/p4_testsuite/grammar/multiline_ifdef.p4 ... +TranslationUnit( + start( + program( + input( + Conditional( + , + declaration( + constantDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "const" + ), + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "a" + ) + ) + ), + superc.core.Syntax$Language( + "=" + ), + Conditional( + (declare-fun |(defined TEST_VAR)| () Bool)(assert |(defined TEST_VAR)|), + initializer( + expression( + Conditional( + (declare-fun |(defined TEST_VAR)| () Bool)(assert |(defined TEST_VAR)|), + superc.core.Syntax$Text( + "1" + ) + ) + ) + ), + (declare-fun |(defined TEST_VAR)| () Bool)(assert (not |(defined TEST_VAR)|)), + initializer( + expression( + Conditional( + (declare-fun |(defined TEST_VAR)| () Bool)(assert (not |(defined TEST_VAR)|)), + nonTypeName( + superc.core.Syntax$Text( + "CUR_VERSION" + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/grammar/output/multiline_preprocessor.ast b/fonda/p4_testsuite/grammar/output/multiline_preprocessor.ast new file mode 100644 index 00000000..b245fec0 --- /dev/null +++ b/fonda/p4_testsuite/grammar/output/multiline_preprocessor.ast @@ -0,0 +1,237 @@ +SuperP4, v. 2.4.0, (C) 2009-2012 New York University +Portions Copyright (c) 1989, 1990 James A. Roskind +Processing /mnt/fonda/p4_testsuite/grammar/multiline_preprocessor.p4 ... +TranslationUnit( + start( + program( + input( + Conditional( + (declare-fun |(defined DTEL_FLOW_REPORT_ENABLE)| () Bool)(declare-fun |(defined EGRESS_MIRROR_ACL_ENABLE)| () Bool)(declare-fun |(defined EGRESS_IP_ACL_ENABLE)| () Bool)(assert (or |(defined EGRESS_IP_ACL_ENABLE)| |(defined EGRESS_MIRROR_ACL_ENABLE)| |(defined DTEL_FLOW_REPORT_ENABLE)|)), + declaration( + constantDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "const" + ), + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "a" + ) + ) + ), + superc.core.Syntax$Language( + "=" + ), + initializer( + expression( + Conditional( + (declare-fun |(defined DTEL_FLOW_REPORT_ENABLE)| () Bool)(declare-fun |(defined EGRESS_MIRROR_ACL_ENABLE)| () Bool)(declare-fun |(defined EGRESS_IP_ACL_ENABLE)| () Bool)(assert (or |(defined EGRESS_IP_ACL_ENABLE)| |(defined EGRESS_MIRROR_ACL_ENABLE)| |(defined DTEL_FLOW_REPORT_ENABLE)|)), + superc.core.Syntax$Text( + "1" + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + Conditional( + (declare-fun |(defined HELLO)| () Bool)(assert |(defined HELLO)|), + declaration( + typeDeclaration( + derivedTypeDeclaration( + structTypeDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "struct" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "P" + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "{" + ), + structFieldList( + Conditional( + (declare-fun |(defined HELLO)| () Bool)(assert |(defined HELLO)|), + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "34" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "bit1" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ), + Conditional( + (declare-fun |(defined HELLO)| () Bool)(assert |(defined HELLO)|), + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "bool" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "h1" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ), + Conditional( + (declare-fun |(defined HELLO)| () Bool)(assert |(defined HELLO)|), + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "a" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ), + Conditional( + (declare-fun |(defined HELLO)| () Bool)(assert |(defined HELLO)|), + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "32" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "f1" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ), + Conditional( + (declare-fun |(defined HELLO)| () Bool)(assert |(defined HELLO)|), + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "32" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "f2" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/grammar/output/multiline_statement.ast b/fonda/p4_testsuite/grammar/output/multiline_statement.ast new file mode 100644 index 00000000..38f4684c --- /dev/null +++ b/fonda/p4_testsuite/grammar/output/multiline_statement.ast @@ -0,0 +1,78 @@ +SuperP4, v. 2.4.0, (C) 2009-2012 New York University +Portions Copyright (c) 1989, 1990 James A. Roskind +Processing /mnt/fonda/p4_testsuite/grammar/multiline_statement.p4 ... +TranslationUnit( + start( + program( + input( + Conditional( + , + declaration( + typeDeclaration( + derivedTypeDeclaration( + headerTypeDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "header" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "P" + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "{" + ), + structFieldList( + Conditional( + , + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "16" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "a" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/grammar/output/multiline_struct_preprocessor_define.ast b/fonda/p4_testsuite/grammar/output/multiline_struct_preprocessor_define.ast new file mode 100644 index 00000000..2c26d83e --- /dev/null +++ b/fonda/p4_testsuite/grammar/output/multiline_struct_preprocessor_define.ast @@ -0,0 +1,101 @@ +SuperP4, v. 2.4.0, (C) 2009-2012 New York University +Portions Copyright (c) 1989, 1990 James A. Roskind +Processing /mnt/fonda/p4_testsuite/grammar/multiline_struct_preprocessor_define.p4 ... +TranslationUnit( + start( + program( + input( + Conditional( + , + declaration( + typeDeclaration( + derivedTypeDeclaration( + structTypeDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "struct" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "P" + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "{" + ), + structFieldList( + Conditional( + , + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "16" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "bit1" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ), + Conditional( + , + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "bool" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "h1" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-00.ast b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-00.ast new file mode 100644 index 00000000..a6372990 --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-00.ast @@ -0,0 +1,311 @@ +Processing Exp-Header-Action.p4 ... +TranslationUnit( + start( + program( + input( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(declare-fun |(defined CONFIG_A)| () Bool)(assert (or (and |(defined CONFIG_A)| |(defined CONFIG_B)|) (and |(defined CONFIG_A)| (not |(defined CONFIG_B)|)))), + declaration( + typeDeclaration( + derivedTypeDeclaration( + headerTypeDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "header" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "int_data_t" + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "{" + ), + structFieldList( + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "varbit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "8032" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "data" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ), + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + declaration( + actionDeclaration( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(declare-fun |(defined CONFIG_A)| () Bool)(assert (let ((a!1 (or (and (not |(defined CONFIG_A)|) |(defined CONFIG_B)|) (and (not |(defined CONFIG_A)|) (not |(defined CONFIG_B)|))))) (or (and a!1 |(defined CONFIG_B)|) (and a!1 (not |(defined CONFIG_B)|))))), + optAnnotations(), + (declare-fun |(defined CONFIG_B)| () Bool)(declare-fun |(defined CONFIG_A)| () Bool)(assert (or (and |(defined CONFIG_A)| |(defined CONFIG_B)|) (and |(defined CONFIG_A)| (not |(defined CONFIG_B)|)))), + optAnnotations() + ), + superc.core.Syntax$Language( + "action" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "ac1" + ) + ) + ), + superc.core.Syntax$Language( + "(" + ), + parameterList( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + nonEmptyParameterList( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + parameter( + optAnnotations(), + direction(), + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "j" + ) + ) + ) + ) + ), + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + superc.core.Syntax$Language( + "," + ) + ), + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + parameter( + optAnnotations(), + direction(), + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "i" + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ")" + ), + blockStatement( + optAnnotations(), + superc.core.Syntax$Language( + "{" + ), + statOrDeclList( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + statementOrDeclaration( + variableDeclaration( + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "j" + ) + ) + ), + optInitializer( + superc.core.Syntax$Language( + "=" + ), + initializer( + expression( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + superc.core.Syntax$Text( + "5" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ), + Conditional( + , + declaration( + actionDeclaration( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert (not |(defined CONFIG_B)|)), + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(declare-fun |(defined CONFIG_A)| () Bool)(assert (let ((a!1 (or (and (not |(defined CONFIG_A)|) |(defined CONFIG_B)|) (and (not |(defined CONFIG_A)|) (not |(defined CONFIG_B)|))))) (or (and a!1 |(defined CONFIG_B)|) (and a!1 (not |(defined CONFIG_B)|))))), + optAnnotations(), + (declare-fun |(defined CONFIG_B)| () Bool)(declare-fun |(defined CONFIG_A)| () Bool)(assert (or (and |(defined CONFIG_A)| |(defined CONFIG_B)|) (and |(defined CONFIG_A)| (not |(defined CONFIG_B)|)))), + optAnnotations() + ), + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + optAnnotations() + ), + superc.core.Syntax$Language( + "action" + ), + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert (not |(defined CONFIG_B)|)), + name( + nonTypeName( + superc.core.Syntax$Text( + "ac2" + ) + ) + ), + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + name( + nonTypeName( + superc.core.Syntax$Text( + "ac2" + ) + ) + ) + ), + superc.core.Syntax$Language( + "(" + ), + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert (not |(defined CONFIG_B)|)), + parameterList(), + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + parameterList() + ), + superc.core.Syntax$Language( + ")" + ), + blockStatement( + optAnnotations(), + superc.core.Syntax$Language( + "{" + ), + statOrDeclList( + Conditional( + , + statementOrDeclaration( + variableDeclaration( + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "j" + ) + ) + ), + optInitializer( + superc.core.Syntax$Language( + "=" + ), + initializer( + expression( + Conditional( + , + superc.core.Syntax$Text( + "5" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-00.ast.expected b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-00.ast.expected new file mode 100644 index 00000000..7c431d4b --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-00.ast.expected @@ -0,0 +1,297 @@ +Processing Exp-Header-Action.p4 ... +TranslationUnit( + start( + program( + input( + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + declaration( + typeDeclaration( + derivedTypeDeclaration( + headerTypeDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "header" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "int_data_t" + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "{" + ), + structFieldList( + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "varbit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "8032" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "data" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ), + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + declaration( + actionDeclaration( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + optAnnotations(), + ), + superc.core.Syntax$Language( + "action" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "ac1" + ) + ) + ), + superc.core.Syntax$Language( + "(" + ), + parameterList( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + nonEmptyParameterList( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + parameter( + optAnnotations(), + direction(), + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "j" + ) + ) + ) + ) + ), + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + superc.core.Syntax$Language( + "," + ) + ), + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + parameter( + optAnnotations(), + direction(), + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "i" + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ")" + ), + blockStatement( + optAnnotations(), + superc.core.Syntax$Language( + "{" + ), + statOrDeclList( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + statementOrDeclaration( + variableDeclaration( + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "j" + ) + ) + ), + optInitializer( + superc.core.Syntax$Language( + "=" + ), + initializer( + expression( + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + superc.core.Syntax$Text( + "5" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ), + Conditional( + , + declaration( + actionDeclaration( + Conditional( + , + ), + superc.core.Syntax$Language( + "action" + ), + Conditional( + , + name( + nonTypeName( + superc.core.Syntax$Text( + "ac2" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "ac2" + ) + ) + ) + ), + superc.core.Syntax$Language( + "(" + ), + Conditional( + parameterList() + ), + superc.core.Syntax$Language( + ")" + ), + blockStatement( + optAnnotations(), + superc.core.Syntax$Language( + "{" + ), + statOrDeclList( + Conditional( + , + statementOrDeclaration( + variableDeclaration( + typeRef( + baseType( + superc.core.Syntax$Language( + "int" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "j" + ) + ) + ), + optInitializer( + superc.core.Syntax$Language( + "=" + ), + initializer( + expression( + Conditional( + , + superc.core.Syntax$Text( + "5" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-00.p4 b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-00.p4 new file mode 100644 index 00000000..fc3b5d6c --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-00.p4 @@ -0,0 +1,16 @@ +#ifdef CONFIG_A +header int_data_t { + varbit<8032> data; +} +#endif + +#ifdef CONFIG_B +action ac1 (int j, int i) { + int j = 5; +} +#endif + + +action ac2 () { + int j = 5; +} \ No newline at end of file diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-01.ast b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-01.ast new file mode 100644 index 00000000..557ea0ce --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-01.ast @@ -0,0 +1,115 @@ +SuperP4, v. 2.4.0, (C) 2009-2012 New York University +Portions Copyright (c) 1989, 1990 James A. Roskind +Processing exmp-01.p4 ... +TranslationUnit( + start( + program( + input( + Conditional( + , + declaration( + typeDeclaration( + derivedTypeDeclaration( + headerTypeDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "header" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "int_data_t" + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "{" + ), + structFieldList( + Conditional( + , + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "4" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "flag" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ), + (declare-fun |(defined CONFIG_A)| () Bool)(assert (not |(defined CONFIG_A)|)), + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "4" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "flag" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-01.ast.expected b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-01.ast.expected new file mode 100644 index 00000000..564bdf28 --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-01.ast.expected @@ -0,0 +1,112 @@ +TranslationUnit( + start( + program( + input( + Conditional( + , + declaration( + typeDeclaration( + derivedTypeDeclaration( + headerTypeDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "header" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "int_data_t" + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "{" + ), + structFieldList( + Conditional( + , + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "4" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "flag" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ), + (declare-fun |(defined CONFIG_A)| () Bool)(assert (not |(defined CONFIG_A)|)), + structField( + optAnnotations(), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "4" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "flag" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-01.p4 b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-01.p4 new file mode 100644 index 00000000..af149b70 --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-01.p4 @@ -0,0 +1,7 @@ +header int_data_t { + #ifdef CONFIG_A + bit<4> flag; + #else + bit<4> flag; + #endif +} diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-02.ast b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-02.ast new file mode 100644 index 00000000..401ff84f --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-02.ast @@ -0,0 +1,510 @@ +TranslationUnit( + start( + program( + input( + Conditional( + , + declaration( + constantDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "const" + ), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "16" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "TYPE_IPV4" + ) + ) + ), + superc.core.Syntax$Language( + "=" + ), + initializer( + expression( + Conditional( + , + superc.core.Syntax$Text( + "0x800" + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + declaration( + constantDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "const" + ), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "16" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "TYPE_IPV6" + ) + ) + ), + superc.core.Syntax$Language( + "=" + ), + initializer( + expression( + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + superc.core.Syntax$Text( + "0x900" + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + Conditional( + , + declaration( + parserDeclaration( + parserTypeDeclaration( + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert (not |(defined CONFIG_A)|)), + optAnnotations(), + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + optAnnotations() + ), + superc.core.Syntax$Language( + "parser" + ), + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert (not |(defined CONFIG_A)|)), + name( + nonTypeName( + superc.core.Syntax$Text( + "MyParser" + ) + ) + ), + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + name( + nonTypeName( + superc.core.Syntax$Text( + "MyParser" + ) + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "(" + ), + parameterList( + Conditional( + , + nonEmptyParameterList( + Conditional( + , + parameter( + optAnnotations(), + direction( + superc.core.Syntax$Language( + "in" + ) + ), + typeRef( + baseType( + superc.core.Syntax$Language( + "bool" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "k" + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ")" + ) + ), + optConstructorParameters(), + superc.core.Syntax$Language( + "{" + ), + parserLocalElements(), + parserStates( + Conditional( + , + parserState( + optAnnotations(), + superc.core.Syntax$Language( + "state" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "start" + ) + ) + ), + superc.core.Syntax$Language( + "{" + ), + parserStatements(), + transitionStatement( + superc.core.Syntax$Language( + "transition" + ), + stateExpression( + name( + nonTypeName( + superc.core.Syntax$Text( + "parse_ethernet" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ), + Conditional( + , + parserState( + optAnnotations(), + superc.core.Syntax$Language( + "state" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "parse_ethernet" + ) + ) + ), + superc.core.Syntax$Language( + "{" + ), + parserStatements( + Conditional( + , + parserStatement( + assignmentOrMethodCallStatement( + lvalue( + lvalue( + prefixedNonTypeName( + nonTypeName( + superc.core.Syntax$Text( + "packet" + ) + ) + ) + ), + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "extract" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "(" + ), + argumentList( + Conditional( + , + nonEmptyArgList( + Conditional( + , + argument( + expression( + Conditional( + , + nonTypeName( + superc.core.Syntax$Text( + "hdr" + ) + ) + ), + Conditional( + , + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "ethernet" + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ")" + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ), + transitionStatement( + superc.core.Syntax$Language( + "transition" + ), + stateExpression( + selectExpression( + superc.core.Syntax$Language( + "select" + ), + superc.core.Syntax$Language( + "(" + ), + expressionList( + Conditional( + , + expression( + Conditional( + , + nonTypeName( + superc.core.Syntax$Text( + "hdr" + ) + ) + ), + Conditional( + , + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "ethernet" + ) + ) + ) + ) + ), + Conditional( + , + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "etherType" + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ")" + ), + superc.core.Syntax$Language( + "{" + ), + selectCaseList( + Conditional( + , + selectCase( + keysetExpression( + simpleKeysetExpression( + expression( + Conditional( + , + nonTypeName( + superc.core.Syntax$Text( + "TYPE_IPV4" + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ":" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "parse_ipv4" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ), + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + selectCase( + keysetExpression( + simpleKeysetExpression( + expression( + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + nonTypeName( + superc.core.Syntax$Text( + "TYPE_IPV6" + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ":" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "parse_ipv6" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ), + Conditional( + , + selectCase( + keysetExpression( + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert (not |(defined CONFIG_A)|)), + simpleKeysetExpression( + superc.core.Syntax$Language( + "default" + ) + ), + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + simpleKeysetExpression( + superc.core.Syntax$Language( + "default" + ) + ) + ) + ), + superc.core.Syntax$Language( + ":" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "accept" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-02.ast.expected b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-02.ast.expected new file mode 100644 index 00000000..1d298916 --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-02.ast.expected @@ -0,0 +1,498 @@ +TranslationUnit( + start( + program( + input( + Conditional( + , + declaration( + constantDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "const" + ), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "16" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "TYPE_IPV4" + ) + ) + ), + superc.core.Syntax$Language( + "=" + ), + initializer( + expression( + Conditional( + , + superc.core.Syntax$Text( + "0x800" + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + declaration( + constantDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "const" + ), + typeRef( + baseType( + superc.core.Syntax$Language( + "bit" + ), + l_angle( + superc.core.Syntax$Language( + "<" + ) + ), + superc.core.Syntax$Text( + "16" + ), + r_angle( + superc.core.Syntax$Language( + ">" + ) + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "TYPE_IPV6" + ) + ) + ), + superc.core.Syntax$Language( + "=" + ), + initializer( + expression( + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + superc.core.Syntax$Text( + "0x900" + ) + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + Conditional( + , + declaration( + parserDeclaration( + parserTypeDeclaration( + Conditional( + , + optAnnotations() + ), + superc.core.Syntax$Language( + "parser" + ), + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert (not |(defined CONFIG_A)|)), + name( + nonTypeName( + superc.core.Syntax$Text( + "MyParser" + ) + ) + ), + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + name( + nonTypeName( + superc.core.Syntax$Text( + "MyParser" + ) + ) + ) + ), + optTypeParameters(), + superc.core.Syntax$Language( + "(" + ), + parameterList( + Conditional( + , + nonEmptyParameterList( + Conditional( + , + parameter( + optAnnotations(), + direction(), + typeRef( + baseType( + superc.core.Syntax$Language( + "packet_in" + ) + ) + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "packet" + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ")" + ) + ), + optConstructorParameters(), + superc.core.Syntax$Language( + "{" + ), + parserLocalElements(), + parserStates( + Conditional( + , + parserState( + optAnnotations(), + superc.core.Syntax$Language( + "state" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "start" + ) + ) + ), + superc.core.Syntax$Language( + "{" + ), + parserStatements(), + transitionStatement( + superc.core.Syntax$Language( + "transition" + ), + stateExpression( + name( + nonTypeName( + superc.core.Syntax$Text( + "parse_ethernet" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ), + Conditional( + , + parserState( + optAnnotations(), + superc.core.Syntax$Language( + "state" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "parse_ethernet" + ) + ) + ), + superc.core.Syntax$Language( + "{" + ), + parserStatements( + Conditional( + , + parserStatement( + assignmentOrMethodCallStatement( + lvalue( + lvalue( + prefixedNonTypeName( + nonTypeName( + superc.core.Syntax$Text( + "packet" + ) + ) + ) + ), + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "extract" + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + "(" + ), + argumentList( + Conditional( + , + nonEmptyArgList( + Conditional( + , + argument( + expression( + Conditional( + , + nonTypeName( + superc.core.Syntax$Text( + "hdr" + ) + ) + ), + Conditional( + , + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "ethernet" + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ")" + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ), + transitionStatement( + superc.core.Syntax$Language( + "transition" + ), + stateExpression( + selectExpression( + superc.core.Syntax$Language( + "select" + ), + superc.core.Syntax$Language( + "(" + ), + expressionList( + Conditional( + , + expression( + Conditional( + , + nonTypeName( + superc.core.Syntax$Text( + "hdr" + ) + ) + ), + Conditional( + , + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "ethernet" + ) + ) + ) + ) + ), + Conditional( + , + dot_name( + superc.core.Syntax$Language( + "." + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "etherType" + ) + ) + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ")" + ), + superc.core.Syntax$Language( + "{" + ), + selectCaseList( + Conditional( + , + selectCase( + keysetExpression( + simpleKeysetExpression( + expression( + Conditional( + , + nonTypeName( + superc.core.Syntax$Text( + "TYPE_IPV4" + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ":" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "parse_ipv4" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ), + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + selectCase( + keysetExpression( + simpleKeysetExpression( + expression( + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + nonTypeName( + superc.core.Syntax$Text( + "TYPE_IPV6" + ) + ) + ) + ) + ) + ), + superc.core.Syntax$Language( + ":" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "parse_ipv6" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ), + Conditional( + , + selectCase( + keysetExpression( + Conditional( + , + simpleKeysetExpression( + superc.core.Syntax$Language( + "default" + ) + ), + ) + ), + superc.core.Syntax$Language( + ":" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "accept" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ), + superc.core.Syntax$Language( + "}" + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-02.p4 b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-02.p4 new file mode 100644 index 00000000..74b4ff01 --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp-02.p4 @@ -0,0 +1,21 @@ +const bit<16> TYPE_IPV4 = 0x800; +#ifdef CONFIG_A + const bit<16> TYPE_IPV6 = 0x900; +#endif + +parser MyParser (in bool k) { + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + TYPE_IPV4: parse_ipv4; + #ifdef CONFIG_A + TYPE_IPV6: parse_ipv6; + #endif + default: accept; + } + } +} \ No newline at end of file diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_back-to-back_conditionals.p4 b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_back-to-back_conditionals.p4 new file mode 100644 index 00000000..c4ca6e08 --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_back-to-back_conditionals.p4 @@ -0,0 +1,7 @@ +#ifdef CONFIG_A +; +#endif + +#ifdef CONFIG_B +extern hello; +#endif diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_single_condition.p4 b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_single_condition.p4 new file mode 100644 index 00000000..1b15c2ff --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_single_condition.p4 @@ -0,0 +1,3 @@ +#ifdef CONFIG_A +; +#endif diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_snippet.DeepDupCheck.ast b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_snippet.DeepDupCheck.ast new file mode 100644 index 00000000..8f06603c --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_snippet.DeepDupCheck.ast @@ -0,0 +1,56 @@ +TranslationUnit( + start( + program( + input( + Conditional( + (declare-fun |(defined CONFIG_A)| () Bool)(assert |(defined CONFIG_A)|), + superc.core.Syntax$Language( + ";" + ) + ), + Conditional( + , + declaration( + externDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "extern" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "not_a_list" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ), + Conditional( + (declare-fun |(defined CONFIG_B)| () Bool)(assert |(defined CONFIG_B)|), + declaration( + externDeclaration( + optAnnotations(), + superc.core.Syntax$Language( + "extern" + ), + name( + nonTypeName( + superc.core.Syntax$Text( + "hello" + ) + ) + ), + superc.core.Syntax$Language( + ";" + ) + ) + ) + ) + ) + ) + ) +) diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_snippet.p4 b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_snippet.p4 new file mode 100644 index 00000000..f4302d9a --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_snippet.p4 @@ -0,0 +1,9 @@ +#ifdef CONFIG_A +; +#endif + +extern list_testing; + +#ifdef CONFIG_B +extern hello; +#endif diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_withoutLists.p4 b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_withoutLists.p4 new file mode 100644 index 00000000..72531b1e --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/exmp_withoutLists.p4 @@ -0,0 +1,15 @@ +#ifdef CONFIG_A +; +#endif + +extern not_a_list; + +#ifdef CONFIG_B +extern hello; +#endif + +extern not_a_list_2; + +#ifdef CONFIG_C +extern config_c_hello; +#endif diff --git a/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/global_condition.p4 b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/global_condition.p4 new file mode 100644 index 00000000..f7db6ace --- /dev/null +++ b/fonda/p4_testsuite/productionInsideConditionalTestCases/ast-examples/global_condition.p4 @@ -0,0 +1,8 @@ +#ifndef CONFIG_A +#define CONFIG_A + +extern hello; + +typedef bit<3> fwd_type_t; + +#endif diff --git a/src/superc/SuperP4.java b/src/superc/SuperP4.java index 9082ca97..bee3ac09 100644 --- a/src/superc/SuperP4.java +++ b/src/superc/SuperP4.java @@ -17,9 +17,10 @@ * USA. */ package superc; +import java.lang.reflect.*; import java.lang.StringBuilder; - +import java.nio.Buffer; import java.io.File; import java.io.Reader; import java.io.BufferedReader; @@ -31,6 +32,7 @@ import java.util.ArrayList; import java.util.List; import java.util.Arrays; +import java.util.Collections; import java.util.LinkedList; import java.util.Queue; import java.util.Map; @@ -39,6 +41,7 @@ import java.util.HashMap; import java.util.Iterator; import java.util.Set; +import java.util.Stack; import superc.core.Lexer; import superc.core.LexerCreator; @@ -82,6 +85,10 @@ import superc.p4parser.P4LexerCreator; import superc.p4parser.P4TokenCreator; +import superc.p4parser.GraphViz; +// import static guru.nidi.graphviz.model.Factory.*; +import superc.p4parser.CallGraphGenerator; + import superc.p4parser.P4Context.SymbolTable.STField; import xtc.tree.Node; @@ -136,6 +143,14 @@ public class SuperP4 extends Tool { /** Simplify nested conditionals in preprocessor output. */ private final static boolean SIMPLIFY_NESTED_CONDITIONALS = true; + HashSet set = new HashSet<>(); + // ArrayList blockValues = new ArrayList(); + ArrayList> blockValues = new ArrayList<>(); + // HashMap template_block_map = new HashMap<>(); + ArrayList> template_block_map = new ArrayList<>(); + HashMap> conditionalsInsideSpecificBlosk; + HashMap> conditionalsInsideEverything = new HashMap<>(); + int counter = 0; /** Create a new tool. */ public SuperP4() { /* Nothing to do. */ } @@ -326,6 +341,14 @@ public void init() { // Output and debugging bool("printAST", "printAST", false, "Print the parsed AST."). + bool("preprocessorUsageMatrix", "preprocessorUsageMatrix", false, + "Print intersection matrix of grammar constructs and preprocessor present inside each construct."). + word("templateFileForMatrix", "templateFileForMatrix", true, + "Path to text file containing the blocks names in the main package instantiation.."). + bool("callGraph", "callGraph", false, + "Create a call graph plot (will be saved as a PDF with same name)"). + bool("printCallGraph", "printCallGraph", false, + "Print the calculated call graph"). bool("printSource", "printSource", false, "Print the parsed AST in C source form."). bool("suppressConditions", "suppressConditions", false, @@ -356,7 +379,9 @@ public void init() { "Show lookaheads on each parse loop (warning: very voluminous " + "output!)"). bool("macroTable", "macroTable", false, - "Show the macro symbol table.") + "Show the macro symbol table."). + bool("macroDependencies", "macroDependencies", false, + "Show which macros depend on free macros") ; } @@ -606,7 +631,8 @@ public void remove() { // macros and includes. macroTable = new MacroTable(tokenCreator); macroTable - .getConfigurationVariables(runtime.test("configurationVariables")); + .getConfigurationVariables(runtime.test("configurationVariables") || + runtime.test("macroDependencies")); macroTable.getHeaderGuards(runtime.test("headerGuards")); presenceConditionManager = new PresenceConditionManager(); if (runtime.test("suppressConditions")) { @@ -1196,289 +1222,383 @@ public Object getValue(int id, String name, Pair values) { runtime.console().format((Node) translationUnit).pln().flush(); } - if (runtime.test("printSource")) { - OutputStreamWriter writer = new OutputStreamWriter(System.out); - - System.err.println("Print Source"); - - LinkedList parents - = new LinkedList(); - parents.push(presenceConditionManager.newTrue()); - - printSource((Node) translationUnit, - presenceConditionManager.newTrue(), - parents, writer); - - parents.pop(); - assert(parents.size() == 0); - - writer.flush(); + if(runtime.test("callGraph") || runtime.test("printCallGraph")) { + CallGraphGenerator graph = new CallGraphGenerator(); + graph.buildSymbolTable((Node) translationUnit); + graph.buildCallGraph((Node) translationUnit); + if(runtime.test("printCallGraph")) { + graph.printCallGraph(); + } + graph.createCallGraphVisual(file.getName() + ".callGraph"); } + if(runtime.test("preprocessorUsageMatrix")) { + String templateFilePath = null; + for (Object o : runtime.getList("templateFileForMatrix")) { + if (o instanceof String) { + String s; + + if(templateFilePath != null) { + System.err.println("Passed in two paths for template file. Expecting only one of syntax \"-templateFileForMatrix \"PATH_TO_TEMPLATE_FILE.txt\"\""); + } + + s = (String) o; + templateFilePath = s; + } + } - // if (runtime.test("configureAllYes") || runtime.test("configureAllNo")) { - // OutputStreamWriter writer = new OutputStreamWriter(System.out); - // boolean defaultSetting = runtime.test("configureAllYes") ? true : false; - // List clExceptions = null != runtime.getString("configureExceptions") ? - // Arrays.asList(runtime.getString("configureExceptions").split(",")) : - // null; - - // List exceptions = new LinkedList(); - // Map nonbooleans = new HashMap(); - // ConditionEvaluator evaluator = null; - // BDD configuration; - - // if (null != clExceptions) { - // exceptions.addAll(clExceptions); - // } - - // if (null != runtime.getString("configFile")) { - // BufferedReader configFile = - // new BufferedReader(new FileReader(runtime.getString("configFile"))); - // String line; - - // // Turn on the configuration variables from a linux .config - // // file - // while (null != (line = configFile.readLine())) { - // if (line.length() == 0) continue; - // if (line.startsWith("#")) continue; - // if (line.endsWith("=y")) { // boolean and tristate - // String exception = - // "(defined " + line.substring(0,line.length() - 2) + ")"; - // exceptions.add(exception); - // } else { // non-boolean - // String[] def = line.split("="); - // String exception = "(defined " + def[0] + ")"; - // exceptions.add(exception); - // nonbooleans.put(def[0], def[1]); - // } - // } - // } + if(templateFilePath != null) { + blockValues.add(new ArrayList()); + template_block_map.add(new HashMap()); - // // PresenceCondition t = presenceConditionManager.newTrue(); - // // macroTable._define("CONFIG_64BIT", new MacroTable.Macro.Object(null), t); + ArrayList template = readTemplate(templateFilePath); + collectBlockNames((Node) translationUnit, template); + // System.err.println("Final count: " + template_block_map.size() + "\nblock size: " + blockValues.size()); + for(int i = 0; i < template_block_map.size(); i++) { + template_block_map.set(i, (HashMap) stripParenthesis(template_block_map.get(i))); + } + // template_block_map = (HashMap) stripParenthesis(template_block_map); + System.out.println("Passed in block names and actual mapped function values:" + template_block_map); + for(int i = 0; i < blockValues.size(); i++) { + blockValues.set(i, (ArrayList) stripParenthesis(blockValues.get(i))); + } - // // StringBuilder sb; - // // String name = "BITS_PER_LONG"; - // // // String name = "CONFIG_64BIT"; - - // // sb = new StringBuilder(); - - // // sb.append(name); - // // sb.append("\n"); - // // sb.append("-------------------------------------------"); - // // sb.append("\n"); - // // for (MacroTable.Entry e : macroTable.table.get(name)) { - // // sb.append(e); - // // sb.append("\n"); - // // } - // // sb.append("\n"); + // blockValues = (ArrayList) stripParenthesis(blockValues); + for(ArrayList blockValue : blockValues) { + if(blockValue.isEmpty()) { + continue; + } - // // System.err.println(sb.toString()); + initializeConditionalsInside(blockValue); + // System.out.println(blockValue); + + // collect macros for specific block names collected based on user input + walkAST((Node) translationUnit, "", false, blockValue); + + convertNotConditionalsAndRemoveDefinedWordForStatPurposes(conditionalsInsideSpecificBlosk); + System.out.println("--------Printing out macros present DIRECTLY under the specific construct blocks--------\n"); + printMatrix(conditionalsInsideSpecificBlosk); + System.out.println("\n--------Done printing macros present DIRECTLY under the specific construct blocks--------\n\n"); + + collectASTData((Node) translationUnit); + convertNotConditionalsAndRemoveDefinedWordForStatPurposes(presenceCondMap); + + for(String e: presenceCondMap.keySet()) { + if(conditionalsInsideSpecificBlosk.containsKey(e)) { + if(! conditionalsInsideSpecificBlosk.get(e).equals(presenceCondMap.get(e))) { + System.err.println("Something not right: " + e); + System.exit(1); + } + } + } - // if (null != nonbooleans) { - // evaluator = new ConditionEvaluator(ExpressionParser.fromRats(), - // presenceConditionManager, - // macroTable); - // } + expandCPP(); + removeEmpty(presenceCondMap); - // configuration = presenceConditionManager. - // createConfiguration(defaultSetting, exceptions); - // System.err.println("Configure AST"); - - // configureAST((Node) translationUnit, configuration, nonbooleans, writer); - // configuration.free(); - - // writer.flush(); - // } else if (null != runtime.getString("configFile")) { - // OutputStreamWriter writer = new OutputStreamWriter(System.out); - // Map nonbooleans = new HashMap(); - // BufferedReader configFile = - // new BufferedReader(new FileReader(runtime.getString("configFile"))); - // List clExceptions = null != runtime.getString("configureExceptions") ? - // Arrays.asList(runtime.getString("configureExceptions").split(",")) : - // null; - // PresenceCondition t = - // presenceConditionManager.newTrue(); - // Iterator clIterator = null != clExceptions ? clExceptions.iterator() - // : null; - // String line; - // HashSet configuredVars = new HashSet(); - - // // Put the config file definitions into the macro symbol table - // while (null != (line = configFile.readLine()) || - // clIterator != null && - // clIterator.hasNext() && - // null != (line = clIterator.next())) { - // if (line.length() == 0) { - // continue; - // } else if (line.startsWith("# ") && line.endsWith(" is not set")) { - // String var_name = line.substring(2,line.length() - " is not set".length()); - // macroTable._define(var_name, - // MacroTable.Macro.undefined, - // t); - // configuredVars.add(var_name); - // } else if (line.startsWith("#")) { // ignore comments other than undefined config vars - // continue; - // } else if (line.endsWith("=y")) { // store boolean and tristate config vars - // String var_name = line.substring(0,line.length() - 2); - // // if (var_name.equals("__KERNEL__")) System.err.println("before define " + macroTable.contains("__KERNEL__")); - // macroTable._define(var_name, - // new MacroTable.Macro.Object(null), - // t); - // configuredVars.add(var_name); - // // if (var_name.equals("__KERNEL__")) System.err.println("after define " + macroTable.contains("__KERNEL__")); - // } else { // store non-boolean config var defs - // String[] def = line.split("="); - // List def_list = new LinkedList(); - // final CLexer clexer; - // Syntax syntax = null; - - // if (def.length > 1) { - // clexer = new CLexer(new StringReader(def[1])); - // clexer.setFileName("config file"); - - // while (true) { - // try { - // syntax = clexer.yylex(); - // } catch (IOException e) { - // e.printStackTrace(); - // throw new RuntimeException(); - // } - // if (syntax.kind() == Kind.EOF) break; - // def_list.add(syntax); - // } - // macroTable._define(def[0], - // new MacroTable.Macro.Object(def_list), - // t); - // nonbooleans.put(def[0], def[1]); - // configuredVars.add(def[0]); - // } else { - // // System.err.println("wrong " + line); - // } - // } - // } + presenceCondMap = keepOnlySpecifics(blockValue, presenceCondMap); + System.out.println("---!!---Printing out macros present ANYWHERE under the specific construct blocks---!!---\n"); + printMatrix(presenceCondMap); + System.out.println("\n---!!---Done printing macros present ANYWHERE under the specific construct blocks---!!---\n"); + presenceCondMap.clear(); + } + } - // // Pull any other macros not defined in the config file to false - // for (String var_name : macroTable.table.keySet()) { - // if (! configuredVars.contains(var_name)) { - // macroTable._define(var_name, - // MacroTable.Macro.undefined, - // t); - // } - // } + //collect macros for all blocks + walkASTForAllConstructs((Node) translationUnit, null); - // // StringBuilder sb; - // // // String name = "__KERNEL__"; - // // // String name = "BITS_PER_LONG"; - // // // String name = "CONFIG_64BIT"; - // // // String name = "__CHECKER__"; - // // String name = "__section"; - - // // sb = new StringBuilder(); + convertNotConditionalsAndRemoveDefinedWordForStatPurposes(conditionalsInsideEverything); + System.out.println("--------Printing out macro mappings for all constructs--------\n"); + printMatrix(conditionalsInsideEverything); + System.out.println("\n--------Done printing mappings for all constructs--------\n"); - // // sb.append(name); - // // sb.append("\n"); - // // sb.append("-------------------------------------------"); - // // sb.append("\n"); - // // for (MacroTable.Entry e : macroTable.table.get(name)) { - // // sb.append(e); - // // sb.append("\n"); - // // } - // // sb.append("\n"); - - // // System.err.println(sb.toString()); - - // // Evaluate each BDD variable according to the Linux .config - // // file settings. - // BDD configuration = presenceConditionManager.newTrue().getBDD(); - // int var_idx = 0; - // String var_name = null; - - // // conditionEvaluator.setPullUndefinedFalse(true); - // while (null != (var_name = presenceConditionManager.getVariableManager().getName(var_idx++))) { - // String var_cond = "#if " + var_name + "\n#else\n#endif\n"; - // // System.err.println(var_cond); - // HeaderFileManager var_filemanager = - // new HeaderFileManager(new StringReader(var_cond), - // new File(var_name), - // null, null, null, null, null); - // // System.err.println("current: " + presenceConditionManager.reference().isTrue()) - // ; - // Preprocessor var_evaluator = - // new Preprocessor(var_filemanager, - // macroTable, - // presenceConditionManager, - // conditionEvaluator, - // tokenCreator); - - // Syntax syntax = var_evaluator.next(); - - // if (syntax.kind() == Kind.CONDITIONAL) { - // PresenceCondition presult = ((Conditional) syntax).presenceCondition(); - // // if (var_name.equals("(defined __KERNEL__)")) { - // // System.err.println("after configure " + var_name); - // // System.err.println("after configure " + var_cond); - // // System.err.println("after configure " + presult.toString()); - // // } - // if (presult.isTrue()) { - // configuration.andWith(presenceConditionManager.getVariableManager().getVariable(var_name)); - // // System.err.println("FJDSKL"); - // } else // if (presult.isFalse()) - // { - // BDD ith = presenceConditionManager.getVariableManager().getVariable(var_name); - // BDD not = ith.not(); - // ith.free(); - // configuration.andWith(not); - // // System.err.println("noonononon"); - // } // else { - // // System.err.println("unresolved expression"); - // // System.err.println(var_name + " " + presult.toString()); - // // System.exit(1); - // // } - // } else { - // System.err.println("handle incorrect evaluation"); - // System.exit(1); - // } + // System.out.println(presenceCondMap); - // while (syntax.kind() != Kind.EOF) syntax = var_evaluator.next(); - // } + // String dot_string = toDot(callGraph, "callGraph"); + // System.out.println("digraph{" + dot_string + "}"); - // // Evaluate each macro in the macro table until each is - // // unconditionally defined. + if (runtime.test("printSource")) { + OutputStreamWriter writer = new OutputStreamWriter(System.out); - // // After parsing, replace identifiers, recursively evaluate if - // // necessary + System.err.println("Print Source"); - // // // Evaluate each BDD it using the above evaluator - // // BDD configuration = presenceConditionManager.evaluateBDDs(visitor); + LinkedList parents + = new LinkedList(); - // System.err.println("Configure AST"); - // configureAST((Node) translationUnit, configuration, nonbooleans, writer); - // configuration.free(); + parents.push(presenceConditionManager.newTrue()); - // writer.flush(); - // } + printSource((Node) translationUnit, + presenceConditionManager.newTrue(), + parents, writer); - if (runtime.test("statisticsParser")) { - IdentityHashMap seen - = new IdentityHashMap(); - int count = dagNodeCount((Node) translationUnit, seen); - runtime.errConsole().pln(String.format("dag_nodes %d", count)); + parents.pop(); + assert(parents.size() == 0); + + writer.flush(); + } - int shared = 0; - for (Integer i : seen.values()) { - if (i > 1) { - shared++; + // if (runtime.test("configureAllYes") || runtime.test("configureAllNo")) { + // OutputStreamWriter writer = new OutputStreamWriter(System.out); + // boolean defaultSetting = runtime.test("configureAllYes") ? true : false; + // List clExceptions = null != runtime.getString("configureExceptions") ? + // Arrays.asList(runtime.getString("configureExceptions").split(",")) : + // null; + + // List exceptions = new LinkedList(); + // Map nonbooleans = new HashMap(); + // ConditionEvaluator evaluator = null; + // BDD configuration; + + // if (null != clExceptions) { + // exceptions.addAll(clExceptions); + // } + + // if (null != runtime.getString("configFile")) { + // BufferedReader configFile = + // new BufferedReader(new FileReader(runtime.getString("configFile"))); + // String line; + + // // Turn on the configuration variables from a linux .config + // // file + // while (null != (line = configFile.readLine())) { + // if (line.length() == 0) continue; + // if (line.startsWith("#")) continue; + // if (line.endsWith("=y")) { // boolean and tristate + // String exception = + // "(defined " + line.substring(0,line.length() - 2) + ")"; + // exceptions.add(exception); + // } else { // non-boolean + // String[] def = line.split("="); + // String exception = "(defined " + def[0] + ")"; + // exceptions.add(exception); + // nonbooleans.put(def[0], def[1]); + // } + // } + // } + + // // PresenceCondition t = presenceConditionManager.newTrue(); + // // macroTable._define("CONFIG_64BIT", new MacroTable.Macro.Object(null), t); + + // // StringBuilder sb; + // // String name = "BITS_PER_LONG"; + // // // String name = "CONFIG_64BIT"; + + // // sb = new StringBuilder(); + + // // sb.append(name); + // // sb.append("\n"); + // // sb.append("-------------------------------------------"); + // // sb.append("\n"); + // // for (MacroTable.Entry e : macroTable.table.get(name)) { + // // sb.append(e); + // // sb.append("\n"); + // // } + // // sb.append("\n"); + + // // System.err.println(sb.toString()); + + // if (null != nonbooleans) { + // evaluator = new ConditionEvaluator(ExpressionParser.fromRats(), + // presenceConditionManager, + // macroTable); + // } + + // configuration = presenceConditionManager. + // createConfiguration(defaultSetting, exceptions); + // System.err.println("Configure AST"); + + // configureAST((Node) translationUnit, configuration, nonbooleans, writer); + // configuration.free(); + + // writer.flush(); + // } else if (null != runtime.getString("configFile")) { + // OutputStreamWriter writer = new OutputStreamWriter(System.out); + // Map nonbooleans = new HashMap(); + // BufferedReader configFile = + // new BufferedReader(new FileReader(runtime.getString("configFile"))); + // List clExceptions = null != runtime.getString("configureExceptions") ? + // Arrays.asList(runtime.getString("configureExceptions").split(",")) : + // null; + // PresenceCondition t = + // presenceConditionManager.newTrue(); + // Iterator clIterator = null != clExceptions ? clExceptions.iterator() + // : null; + // String line; + // HashSet configuredVars = new HashSet(); + + // // Put the config file definitions into the macro symbol table + // while (null != (line = configFile.readLine()) || + // clIterator != null && + // clIterator.hasNext() && + // null != (line = clIterator.next())) { + // if (line.length() == 0) { + // continue; + // } else if (line.startsWith("# ") && line.endsWith(" is not set")) { + // String var_name = line.substring(2,line.length() - " is not set".length()); + // macroTable._define(var_name, + // MacroTable.Macro.undefined, + // t); + // configuredVars.add(var_name); + // } else if (line.startsWith("#")) { // ignore comments other than undefined config vars + // continue; + // } else if (line.endsWith("=y")) { // store boolean and tristate config vars + // String var_name = line.substring(0,line.length() - 2); + // // if (var_name.equals("__KERNEL__")) System.err.println("before define " + macroTable.contains("__KERNEL__")); + // macroTable._define(var_name, + // new MacroTable.Macro.Object(null), + // t); + // configuredVars.add(var_name); + // // if (var_name.equals("__KERNEL__")) System.err.println("after define " + macroTable.contains("__KERNEL__")); + // } else { // store non-boolean config var defs + // String[] def = line.split("="); + // List def_list = new LinkedList(); + // final CLexer clexer; + // Syntax syntax = null; + + // if (def.length > 1) { + // clexer = new CLexer(new StringReader(def[1])); + // clexer.setFileName("config file"); + + // while (true) { + // try { + // syntax = clexer.yylex(); + // } catch (IOException e) { + // e.printStackTrace(); + // throw new RuntimeException(); + // } + // if (syntax.kind() == Kind.EOF) break; + // def_list.add(syntax); + // } + // macroTable._define(def[0], + // new MacroTable.Macro.Object(def_list), + // t); + // nonbooleans.put(def[0], def[1]); + // configuredVars.add(def[0]); + // } else { + // // System.err.println("wrong " + line); + // } + // } + // } + + // // Pull any other macros not defined in the config file to false + // for (String var_name : macroTable.table.keySet()) { + // if (! configuredVars.contains(var_name)) { + // macroTable._define(var_name, + // MacroTable.Macro.undefined, + // t); + // } + // } + + // // StringBuilder sb; + // // // String name = "__KERNEL__"; + // // // String name = "BITS_PER_LONG"; + // // // String name = "CONFIG_64BIT"; + // // // String name = "__CHECKER__"; + // // String name = "__section"; + + // // sb = new StringBuilder(); + + // // sb.append(name); + // // sb.append("\n"); + // // sb.append("-------------------------------------------"); + // // sb.append("\n"); + // // for (MacroTable.Entry e : macroTable.table.get(name)) { + // // sb.append(e); + // // sb.append("\n"); + // // } + // // sb.append("\n"); + + // // System.err.println(sb.toString()); + + // // Evaluate each BDD variable according to the Linux .config + // // file settings. + // BDD configuration = presenceConditionManager.newTrue().getBDD(); + // int var_idx = 0; + // String var_name = null; + + // // conditionEvaluator.setPullUndefinedFalse(true); + // while (null != (var_name = presenceConditionManager.getVariableManager().getName(var_idx++))) { + // String var_cond = "#if " + var_name + "\n#else\n#endif\n"; + // // System.err.println(var_cond); + // HeaderFileManager var_filemanager = + // new HeaderFileManager(new StringReader(var_cond), + // new File(var_name), + // null, null, null, null, null); + // // System.err.println("current: " + presenceConditionManager.reference().isTrue()) + // ; + // Preprocessor var_evaluator = + // new Preprocessor(var_filemanager, + // macroTable, + // presenceConditionManager, + // conditionEvaluator, + // tokenCreator); + + // Syntax syntax = var_evaluator.next(); + + // if (syntax.kind() == Kind.CONDITIONAL) { + // PresenceCondition presult = ((Conditional) syntax).presenceCondition(); + // // if (var_name.equals("(defined __KERNEL__)")) { + // // System.err.println("after configure " + var_name); + // // System.err.println("after configure " + var_cond); + // // System.err.println("after configure " + presult.toString()); + // // } + // if (presult.isTrue()) { + // configuration.andWith(presenceConditionManager.getVariableManager().getVariable(var_name)); + // // System.err.println("FJDSKL"); + // } else // if (presult.isFalse()) + // { + // BDD ith = presenceConditionManager.getVariableManager().getVariable(var_name); + // BDD not = ith.not(); + // ith.free(); + // configuration.andWith(not); + // // System.err.println("noonononon"); + // } // else { + // // System.err.println("unresolved expression"); + // // System.err.println(var_name + " " + presult.toString()); + // // System.exit(1); + // // } + // } else { + // System.err.println("handle incorrect evaluation"); + // System.exit(1); + // } + + // while (syntax.kind() != Kind.EOF) syntax = var_evaluator.next(); + // } + + // // Evaluate each macro in the macro table until each is + // // unconditionally defined. + + // // After parsing, replace identifiers, recursively evaluate if + // // necessary + + // // // Evaluate each BDD it using the above evaluator + // // BDD configuration = presenceConditionManager.evaluateBDDs(visitor); + + // System.err.println("Configure AST"); + // configureAST((Node) translationUnit, configuration, nonbooleans, writer); + // configuration.free(); + + // writer.flush(); + // } + + if (runtime.test("statisticsParser")) { + IdentityHashMap seen + = new IdentityHashMap(); + int count = dagNodeCount((Node) translationUnit, seen); + runtime.errConsole().pln(String.format("dag_nodes %d", count)); + + int shared = 0; + for (Integer i : seen.values()) { + if (i > 1) { + shared++; + } } + runtime.errConsole().pln(String.format("dag_nodes_shared %d", shared)); + runtime.errConsole().flush(); } - runtime.errConsole().pln(String.format("dag_nodes_shared %d", shared)); - runtime.errConsole().flush(); - } - result = (Node) translationUnit; + result = (Node) translationUnit; + } } - // Print optional statistics and debugging information. if (runtime.test("macroTable")) { System.err.println("Macro Table"); @@ -1493,6 +1613,23 @@ public Object getValue(int id, String name, Pair values) { } } + if (runtime.test("macroDependencies")) { + Set configVariables = new HashSet<>(); + + for (String name : macroTable.configurationVariables) { + if (! macroTable.headerGuards.contains(name)) { + configVariables.add(name); + } + } + + // System.out.println("Configuration (free) variables: " + configVariables); + HashMap> dependentStrings = macroTable.getDependentMacros(configVariables); + // System.out.println(dependentStrings); + System.out.println("--------Printing maco dependencies--------\n"); + printMatrix(dependentStrings); + System.out.println("\n--------Done printing macro dependencies--------\n"); + } + if (runtime.test("headerGuards")) { for (String name : macroTable.headerGuards) { System.err.println("header_guard " + name); @@ -1740,4 +1877,560 @@ public Node preprocess(Node node) { public static void main(String[] args) { new SuperP4().run(args); } + + /** + * Takes in the filepath containing the template of the P4 model + * and returns a list of the template in order + * + * Assumption: First value in template is model name and last value is the word "name" to indicate end of instantiation + * + * @param filepath The path to where the template file is located + * @return An arraylist containing the order of network model + * @throws IOException + */ + public ArrayList readTemplate(String filepath) throws IOException{ + File file = new File(filepath); + ArrayList template = new ArrayList<>(); + BufferedReader reader = new BufferedReader(new FileReader(file)); + + String line; + boolean seenName = false; + while((line = reader.readLine()) != null) { + if(line.toLowerCase().equals("name")) { + seenName = true; + } + template.add(line); + } + + System.out.println(template); + + if(! seenName) { + System.out.println("'name' word not found in the template to indicate end of parameters"); + System.exit(1); + } + + return template; + } + + /** + * Walks the AST tree to obtain the specific block names from switch instantiation + * + * @param node The obj structure containing the final AST of the program + * @param template An ArrayList structure containing the order of network model parameters + */ + public String collectBlockNames(Object obj, ArrayList template) { + // System.out.println(obj.getClass()); + if(obj instanceof Node) { + Node node = (Node) obj; + // System.out.println("name is: " + node.getName() + " of class " + node.getClass()); + // if(node.getName().equals("nonTypeName")) { + // System.out.println("next is: " + (node.get(0) instanceof Syntax ? node.get(0) : node.getGeneric(0))); + // } + // if(node.isToken()) { + // System.out.println("Token texT:" + node.getTokenText()); + // } + Iterator its = node.iterator(); + // System.out.println(noded.getName()); + String lastValue = ""; + while(its.hasNext()) { + Object cur = its.next(); + + String rValue = collectBlockNames(cur, template); + // System.out.println("rvalue is: " + rValue); + + if(blockValues.get(blockValues.size() - 1).size() == 0) { + if(node.getName() == "instantiation" && + rValue.toLowerCase().equals(template.get(0).toLowerCase())) { + template_block_map.get(template_block_map.size() - 1).put(template.get(blockValues.get(blockValues.size() - 1).size()), rValue); + blockValues.get(blockValues.size() - 1).add(rValue); + } + lastValue = rValue; + } + else { + lastValue = lastValue.concat(rValue); + if (node.getName() == "argument") { + assert blockValues.get(blockValues.size() - 1).size() < (template.size()-1) : "number of values in blockValues should be less than number of provided argument, but current it is: " + blockValues.get(blockValues.size() - 1).size() + " with the value:" + blockValues.get(blockValues.size() - 1); + + template_block_map.get(template_block_map.size() - 1).put(template.get(blockValues.get(blockValues.size() - 1).size()), lastValue); + blockValues.get(blockValues.size() - 1).add(lastValue); + lastValue = ""; + } + if(node.getName() == "name") { + // assert blockValues.get(blockValues.size() - 1).size() == (template.size()-1) : "At the name construct, meaning we should have reached end of instantiation block but not all values obtained. Current values: " + blockValues.get(blockValues.size() - 1); + if(blockValues.get(blockValues.size() - 1).size() != (template.size()-1)) { + blockValues.get(blockValues.size() - 1).clear(); + template_block_map.get(template_block_map.size() - 1).clear(); + } else { + template_block_map.get(template_block_map.size() - 1).put(template.get(blockValues.get(blockValues.size() - 1).size()), lastValue); + blockValues.get(blockValues.size() - 1).add(lastValue); + lastValue = ""; + // System.err.println("Encountered name value, adding new block value"); + blockValues.add(new ArrayList()); + template_block_map.add(new HashMap()); + } + } + } + } + return lastValue; + } + else { + // System.out.println(obj.toString()); + // set.add(obj.getClass()); + // System.out.println("NOT A NODE\n"); + if(obj instanceof PresenceCondition) { + PresenceCondition pc = (PresenceCondition) obj; + // System.out.println(pc); + } + if(obj instanceof String) { + return obj.toString(); + } + else { + return ""; + } + } + // System.out.println(set); + } + + public Object stripParenthesis(Object collection) { + if(collection instanceof ArrayList) { + ArrayList blockValues = (ArrayList) collection; + + for(int i = 0; i < blockValues.size(); i++) { + blockValues.set(i, blockValues.get(i).replace("()", "")); + } + + return blockValues; + } + else if(collection instanceof HashMap) { + HashMap map = (HashMap) collection; + for(String key : map.keySet()) { + map.put(key, (map.get(key).replace("()", ""))); + } + + return map; + } + + else { + System.err.println("ERROR, unsupported type given"); + return collection; + } + } + + public void initializeConditionalsInside(ArrayList blockValues) { + conditionalsInsideSpecificBlosk = new HashMap<>(); + if(! blockValues.isEmpty()) { + // removing package name and the variable name as it is not blocks we are interested in + blockValues.remove(0); + blockValues.remove(blockValues.size()-1); + + for(int i = 0; i < blockValues.size(); i++) { + conditionalsInsideSpecificBlosk.put(blockValues.get(i), new HashSet<>()); + } + } + } + + public String walkAST(Object obj, String currentBlock, boolean isDeclaration, ArrayList blockValues) { + // System.out.println(obj.getClass()); + if(obj instanceof Node) { + Node node = (Node) obj; + Iterator its = node.iterator(); + while(its.hasNext()) { + Object cur = its.next(); + String rValue; + + if(cur instanceof Node && ((Node) cur).getName().equals("declaration")) { + // since the "modules" when instantiating the package are declaration based constructs + rValue = walkAST(cur, currentBlock, true, blockValues); + } else { + if(cur instanceof Node && ((Node) cur).getName().equals("nonTypeName")) { + Set methods = ((Node) cur).properties(); + for (Object method : methods) { + System.out.printf("method: %s", method.toString()); + System.out.println(); + } + } + rValue = walkAST(cur, currentBlock, isDeclaration, blockValues); + } + + if(cur instanceof Node && ((Node) cur).getName().equals("declaration")){ + // System.out.println("sending back " + currentBlock); + currentBlock = ""; + } + else { + currentBlock = rValue == "" ? currentBlock : rValue; + } + } + return currentBlock; + } + else { + if(obj instanceof PresenceCondition) { + PresenceCondition pc = (PresenceCondition) obj; + if(isDeclaration && (! currentBlock.isEmpty())) { + // System.out.println("curBlock: " + currentBlock); + // System.out.println(conditionalsInsideSpecificBlosk.get(currentBlock)); + // System.out.println("adding value in block: " + currentBlock + " at loc: " + obj + " " + pc.getAllConfigs().toString()); + // System.out.println(currentBlock); + conditionalsInsideSpecificBlosk.get(currentBlock).addAll(pc.getAllConfigs()); + } + // System.out.println(pc); + } + if(obj instanceof String) { + if(blockValues.contains(obj.toString())) { + return obj.toString(); + } + return ""; + } + else { + return ""; + } + } + } + + public void walkASTForAllConstructs(Object obj, ArrayList listOfNestedBlocks) { + // System.out.println(obj.getClass()); + if(listOfNestedBlocks == null) { + listOfNestedBlocks = new ArrayList(); + } + + if(obj instanceof Node) { + Node node = (Node) obj; + Iterator its = node.iterator(); + + while(its.hasNext()) { + Object cur = its.next(); + if(cur instanceof Node) { + Node curNode = (Node) cur; + listOfNestedBlocks.add(curNode.getName()); + walkASTForAllConstructs(cur, listOfNestedBlocks); + listOfNestedBlocks.remove(listOfNestedBlocks.size()-1); + } else { + walkASTForAllConstructs(cur, listOfNestedBlocks); + } + } + return; + } + else { + if(obj instanceof PresenceCondition) { + PresenceCondition pc = (PresenceCondition) obj; + for(String blockName: listOfNestedBlocks) { + if(conditionalsInsideEverything.containsKey(blockName)) { + conditionalsInsideEverything.get(blockName).addAll(pc.getAllConfigs()); + } + else { + conditionalsInsideEverything.put(blockName, new HashSet<>()); + conditionalsInsideEverything.get(blockName).addAll(pc.getAllConfigs()); + } + } + } + return; + } + } + + + boolean printUnit = false; + public void convertNotConditionalsAndRemoveDefinedWordForStatPurposes(HashMap> workingSet) { + for(String key : workingSet.keySet()) { + // System.out.println("OG size for " + key + " is " + workingSet.get(key).size()); + Iterator itr = workingSet.get(key).iterator(); + HashSet temp = new HashSet<>(); + while(itr.hasNext()) { + String str = itr.next(); + str = str.replace("(defined", ""); + str = str.replace(")", ""); + if(str.startsWith("!")) { + str = str.substring(1); + } + str = str.stripLeading(); + temp.add(str); + itr.remove(); + } + + workingSet.get(key).addAll(temp); + } + } + + public void printMatrix(HashMap> workingSet) { + // System.out.println("\nPRINTING MATRIX"); + // System.out.println(workingSet); + HashSet allValuesTogether = new HashSet<>(); + + for(String key : workingSet.keySet()) { + allValuesTogether.addAll(workingSet.get(key)); + } + + ArrayList sortedConditionalValues = new ArrayList<>(allValuesTogether); + Collections.sort(sortedConditionalValues); + + ArrayList constructNames = new ArrayList<>(workingSet.keySet()); + // Collections.sort(constructNames); + + int [][] matrix = new int[sortedConditionalValues.size()][constructNames.size()]; + + + for(int i = 0; i < sortedConditionalValues.size(); i++) { + for(int j = 0; j < constructNames.size(); j++) { + matrix[i][j] = workingSet.get(constructNames.get(j)).contains(sortedConditionalValues.get(i)) ? 1 : 0; + } + } + + // Loop through all elements of current row + for (int j = 0; j < matrix[0].length; j++) { + System.out.print(constructNames.get(j)+ " "); + } + System.out.println(); + + for (int i = 0; i < matrix.length; i++) { + System.out.print(sortedConditionalValues.get(i) + " "); + // Loop through all elements of current row + for (int j = 0; j < matrix[i].length; j++) { + System.out.print(matrix[i][j] + " "); + } + System.out.println(); + } + } + + public class declarationClass { + String declarationsString; + boolean hasName; + + declarationClass(String name, boolean hasName) { + this.declarationsString = name; + this.hasName = hasName; + } + + declarationClass(String name) { + this.declarationsString = name; + this.hasName = false; + } + } + + HashMap> presenceCondMap = new HashMap<>(); + HashMap> callGraph = new HashMap<>(); + Stack blockNames = new Stack<>(); + HashSet declarationsOptions = new HashSet<>(Arrays.asList("constantDeclaration", + "externDeclaration", + "actionDeclaration", + "parserDeclaration", + "typeDeclaration", + "controlDeclaration", + "instantiation", + "errorDeclaration", + "matchKindDeclaration", + "functionDeclaration")); + int nestedDepth = 0; + // boolean findingDeclName = false; + int findingDeclName = 0; + int findingTypeRefName = 0; + Stack declarationsStack = new Stack<>(); + + public void collectASTData(Object unit) { + if(printUnit) + System.out.println("CURRENT UNIT: " + unit + " of type: " + unit.getClass()); + if(unit instanceof Node){ + visit((Node) unit); + // collectASTData((Node) unit); + } + else if(unit instanceof PresenceCondition) { + visit((PresenceCondition) unit); + } + else if(unit instanceof String) { + visit((String) unit); + } + else { + System.err.println("interesting error"); + System.exit(1); + } + // visit(unit); + } + + public Object visit(Node node) { + // System.out.println("name: " + node.getName()); + Iterator itr = node.iterator(); + + // declarationoptions - contains only list of blocks names we want to track + // we check if current node is something we want to track + if(declarationsOptions.contains(node.getName())) { + // push on top of scope stack + declarationsStack.push(new declarationClass(node.getName(), false)); + + // if we are entering a new declaration stack, we ideally want to find its name + // set flag to 1 to indicate we want to find name + if(findingDeclName == 0) { + findingDeclName = 1; + } + } + if(findingDeclName == 1 && node.getName().equals("nonTypeName")) { + // nonTypeName is the construct that is used to name a declaration + // so if we are entering the nonTypeName after entering a declaration block, + // the string under nonTypeName will be the name of the current declaration block + // set flag to 2 to indicate the next string value will be name of current declaration + findingDeclName = 2; + } + + if(findingTypeRefName == 0 && node.getName().equals("typeName")) { + // findingTypeRefName is the flag that will be used to indicate whether + // we are entering a block that might contains a typeref (declared type_identifier) + findingTypeRefName = 1; + } + + while(itr.hasNext()) { + // Go through child nodes + Object cur = itr.next(); + collectASTData(cur); + } + + if(declarationsOptions.contains(node.getName())) { + assert declarationsStack.peek().declarationsString.equals(node.getName()) : "top of stack not same as outcoming order"; + // Exiting declaration block + declarationClass popped = declarationsStack.pop(); + + if(popped.hasName && findingDeclName == 3) { + // since we are exiting declaration block, reset global flag and block name + + // System.out.println("Exiting block: " + blockNames.pop() + " for type: " + node.getName()); + findingDeclName = 0; + printUnit = false; + blockNames.pop(); + } + } + + return node; + } + + public Object visit(PresenceCondition node) { + if(blockNames.isEmpty()) { + return node; + } + + // System.out.println("adding to block: " + blockNames.peek() + " value: " + node.getAllConfigs()); + + if(presenceCondMap.containsKey(blockNames.peek())) { + presenceCondMap.get(blockNames.peek()).addAll(node.getAllConfigs()); + } else { + presenceCondMap.put(blockNames.peek(), new HashSet<>(node.getAllConfigs())); + } + + return node; + } + + public String visit(String node) { + if(findingDeclName == 2) { + blockNames.push(node); + callGraph.put(node, new HashSet<>()); + findingDeclName = 3; + + declarationsStack.peek().hasName = true; + + // System.out.println("new blockname: " + node); + // if(node.equals("FabricEgress")) + // printUnit = true; + } + + if(findingTypeRefName == 1) { + if(blockNames.isEmpty()) { + if(! callGraph.containsKey("Global")) { + callGraph.put("Global", new HashSet<>()); + } + callGraph.get("Global").add(node); + } else { + assert callGraph.containsKey(blockNames.peek()) : "found a typeref but current blockname is not in callgraph: " + blockNames.peek(); + + // Adding the current typeref name (the block that is being called) as a connecting edge to current block + callGraph.get(blockNames.peek()).add(node); + } + + findingTypeRefName = 0; + } + return node; + } + + public void expandCPP() { + int magnitude = magnitude(presenceCondMap); + int newMagnitude = magnitude; + do { + magnitude = newMagnitude; + + for(String key : callGraph.keySet()) { + if(! presenceCondMap.containsKey(key)) { + continue; + } + + Set calleSet = new HashSet<>(); + + for(String calleBlock : callGraph.get(key)) { + if(! presenceCondMap.containsKey(calleBlock)) + continue; + + calleSet.addAll(presenceCondMap.get(calleBlock)); + } + // TODO: use addAll's return value to check if it changes the value + presenceCondMap.get(key).addAll(calleSet); + } + + newMagnitude = magnitude(presenceCondMap); + + } while(magnitude != newMagnitude); + } + + public int magnitude(HashMap> presenceCondMap) { + int counter = 0; + + for(String key: presenceCondMap.keySet()) { + counter += presenceCondMap.get(key).size(); + } + + return counter; + } + + public HashMap> removeEmpty(HashMap> presenceMap) { + Iterator itr = presenceMap.entrySet().iterator(); + + presenceMap.values().removeIf(Set::isEmpty); + + return presenceMap; + } + + public HashMap> keepOnlySpecifics(ArrayList blockValues, HashMap> maps) { + HashMap> filtered = new HashMap<>(); + + for(String key : maps.keySet()) { + if(blockValues.contains(key)) { + filtered.put(key, maps.get(key)); + } + } + + return filtered; + } + + public String toDot(HashMap> callGraph, String filename) { + String dot_string = ""; + + for(String key: callGraph.keySet()) { + dot_string += key; + for(String value: callGraph.get(key)) { + dot_string += "->" + value; + } + dot_string += ";"; + } + System.out.println(dot_string); + createDotGraph(dot_string, filename); + return dot_string; + } + + public static void createDotGraph(String dotFormat,String fileName) +{ + GraphViz gv=new GraphViz(); + gv.addln(gv.start_graph()); + gv.add(dotFormat); + gv.addln(gv.end_graph()); + // String type = "gif"; + String type = "pdf"; + // gv.increaseDpi(); + gv.decreaseDpi(); + gv.decreaseDpi(); + System.out.println(gv.toString()); + File out = new File(fileName+"."+ type); + gv.writeGraphToFile( gv.getGraph( gv.getDotSource(), type ), out ); +} + } diff --git a/src/superc/core/ForkMergeParser.java b/src/superc/core/ForkMergeParser.java index 31bfbeea..827666ae 100644 --- a/src/superc/core/ForkMergeParser.java +++ b/src/superc/core/ForkMergeParser.java @@ -1,5 +1,5 @@ -/* - * xtc - The eXTensible Compiler +/* +* xtc - The eXTensible Compiler * Copyright (C) 2009-2012 New York University * * This program is free software; you can redistribute it and/or @@ -103,7 +103,7 @@ private static enum ParsingAction { * state with an Syntax.Error object. The subparser will be merged * instead of thrown away. */ - final private static boolean NEW_ERROR_HANDLING = false; + final private static boolean NEW_ERROR_HANDLING = true; /** Save the disjunction of invalid configurations. */ final private static boolean SAVE_ERROR_COND = false; @@ -780,8 +780,8 @@ public Object parse() { } } else { // No follow-set caching. - followSet = follow(subparser.lookahead.token, - subparser.presenceCondition).values(); + followSet = new LinkedList(follow(subparser.lookahead.token, + subparser.presenceCondition).values()); } break; @@ -886,7 +886,6 @@ public Object parse() { assert subparser.lookahead.token.syntax.kind() == Kind.LANGUAGE || subparser.lookahead.token.syntax.toConditional().tag() == ConditionalTag.START; - Collection tokenSet = partition(followSet, subparser); processedParsers.addAll(fork(subparser, tokenSet)); @@ -909,9 +908,23 @@ public Object parse() { } processedParsers.clear(); + // Check termination conditions for the parser. if (subparsers.size() == 0) { - // Done. + // Done, because all subparsers have reached the ACCEPT state break; + } else { + int numErrorParsers = 0; + for (Subparser subparser : subparsers) { + switch (subparser.lookahead.getAction()) { + case ERROR: + numErrorParsers++; + break; + } + } + if (subparsers.size() == numErrorParsers) { + // Done, because all subparsers are in the error state + break; + } } // Merge subparsers. @@ -1562,7 +1575,6 @@ public Map follow(OrderedSyntax a, case CONDITIONAL: Conditional conditional = a.syntax.toConditional(); - switch (conditional.tag()) { case START: a = skipConditional(a); @@ -1621,6 +1633,7 @@ private PresenceCondition first(Map result, if (! result.containsKey(a.getSequenceNumber())) { result.put(a.getSequenceNumber(), new Lookahead(a, presenceCondition.addRef())); + presenceCondition.simplify(); } else { Lookahead n = result.get(a.getSequenceNumber()); PresenceCondition union = n.presenceCondition.or(presenceCondition); @@ -1654,6 +1667,7 @@ private PresenceCondition first(Map result, == ConditionalTag.END)) { PresenceCondition nestedPresenceCondition = presenceCondition .and(a.syntax.toConditional().presenceCondition); + nestedPresenceCondition.simplify(); // Move into the branch. a = a.getNext(); @@ -1992,6 +2006,7 @@ private List merge(List subset) { // scopes, can be merged, e.g., same nesting level, (7) the // grammar node is considered complete, i.e., non-complete // nodes shouldn't be children of conditional nodes + // (8) errors should not be merged here. boolean sameTokenType = (subparser.lookahead.token.syntax.kind() == Kind.LANGUAGE && subparser.lookahead.token.syntax.toLanguage().tag() @@ -2003,7 +2018,8 @@ private List merge(List subset) { && (! hasParsingContext || subparser.scope.mayMerge(compareParser.scope)) // (6) && subparser.stack.isMergeable(compareParser.stack) // (3,4) - && subparser.stack != compareParser.stack) { // (5) + && subparser.stack != compareParser.stack // (5) + && ParsingAction.ERROR != subparser.lookahead.action ) { // (8) // Move subparser to merge list. mergedParsers.addLast(compareParser); subset.remove(inner); @@ -2023,6 +2039,7 @@ private List merge(List subset) { StackFrame s = subparser.stack; for (Subparser mergedParser : mergedParsers) { + // TODO Try to move 2068 to here (reset s) int dist = 0; StackFrame t = mergedParser.stack; @@ -2051,11 +2068,16 @@ private List merge(List subset) { // Combine each stack frame's semantic values, updating the // presence condition along the way. + + //Merging the stack frame at the common ancestor point + + // stack frame merge constructs the merged one stack frame - where the static conditional is inserted for (Subparser mergedParser : mergedParsers) { subparser.stack.merge(subparser.presenceCondition, mergedParser.stack, mergedParser.presenceCondition, - maxDist); + maxDist, + semanticValues); PresenceCondition or = subparser.presenceCondition.or(mergedParser.presenceCondition); @@ -2182,6 +2204,7 @@ private Collection partition(Collection tokenSet, = set.presenceCondition.or(n.presenceCondition); set.presenceCondition.delRef(); set.presenceCondition = union; + union.simplify(); } else { sharedReductions.put(n.getActionData(), n); } @@ -3081,12 +3104,20 @@ private int checkHeight() { * other state stack's semantic value. * @param dist The distance down the stack to merge. */ + + // TODO: pass in the semanticvalue to the merge function and remove localSemanticValue var public void merge(PresenceCondition thisPresenceCondition, StackFrame other, PresenceCondition otherPresenceCondition, - int dist) { + int dist, + SemanticValues semanticValues) { if (dist == 0) return; + SemanticValues.ValueType valueType = semanticValues.getValueType(this.symbol); + + // empty = null when nothing is present, but input() is not null + Boolean areSameStackFrames = equals(this, other); + int flags = (null != this.value ? 1 : 0) | (null != other.value ? 2 : 0); @@ -3121,6 +3152,8 @@ public void merge(PresenceCondition thisPresenceCondition, if (this.value == other.value) { // Both are already pointing to the same list node. Don't // create a conditional. + } else if(areSameStackFrames) { + // Both are the exact same stackframes/trees. Don't do anything. } else if (FLATTEN_MERGED_CHOICE_NODES) { // Flatten both values into a single conditional. GNode cnode = GNode.create(CHOICE_NODE_NAME); @@ -3172,6 +3205,15 @@ public void merge(PresenceCondition thisPresenceCondition, this.value = cnode; // } else if (! ((Node) this.value).getName().equals(CHOICE_NODE_NAME)) { + } + else if (valueType == SemanticValues.ValueType.LIST) { + // System.err.println("Merging as a list"); + assert(other.value instanceof GNode); + assert(this.value instanceof GNode); + Iterator otherIterator = ((GNode) other.value).iterator(); + while(otherIterator.hasNext()) { + ((GNode) this.value).add(otherIterator.next()); + } } else { // Combine the two value, this and other, into a choice // node. @@ -3195,10 +3237,109 @@ public void merge(PresenceCondition thisPresenceCondition, // System.err.println(this.value); if (this.next != null) { - this.next.merge(thisPresenceCondition, other.next,otherPresenceCondition, dist - 1); + this.next.merge(thisPresenceCondition, other.next,otherPresenceCondition, dist - 1, semanticValues); } } + /** + * Deep-checks if two stack frames are the same + * + * @param current The current parsing state. + * @param other The other parsing state to be compared with. + * @return true if both the stack frames are the same. + */ + public Boolean equals(StackFrame current, StackFrame other) { + // Loop until the current and other values are both null + while(current != null || other != null) { + + // If inside the loop, at least one of them (current or other) + // is not null. So if another value is null, then current != null + if(current == null || other == null) { + return false; + } + + if(current.height != other.height || + current.state != other.state || + current.symbol != other.symbol) { + return false; + } + + if(! areSameSemanticValues(current.value, other.value)) { + return false; + } + // if(current.value != null) { + // System.err.println("Value class is: " + current.value.getClass() + " with value: " + current.value); + // if(current.value instanceof GNode) { + // assert(current.value instanceof GNode); + + // // TODO: Remove this unnecessary assert + // if(other.value == null) { + // System.err.println("Testing whether null other results in false"); + // assert(((GNode) current.value).equals(other.value) == false); + // } + + // if(! ((GNode) current.value).equals(other.value)) { + // return false; + // } + // } else { + // System.err.println("Not a GNode. Value class is: " + current.value.getClass() + " with value: " + current.value); + // assert(current.value instanceof Syntax); + // if(((Syntax) current.value).getTokenText.equals(other.value) { + // System.err.println("current.value " + current.value + " != other.value " + other.value); + // return false; + // } + // } + // } else if(current.value != other.value) { + // // current.value is null, if other.value is not null return false + // return false; + // } + + current = current.next; + other = other.next; + }; + + return true; + + } + + /** + * Checks if the semantic values are the same. + * + * Modularized since semantic value object can be of different classes. + * + * @param current The current parsing state's value. + * @param other The other parsing state's value to be compared with. + * @return Returns true if they are the same. + */ + public Boolean areSameSemanticValues(Object current, Object other) { + if(current == null && other == null) { + return true; + } + + if(current == null || other == null) { + return false; + } + + assert(current instanceof GNode || current instanceof Syntax); + assert(other instanceof GNode || other instanceof Syntax); + + if (current instanceof GNode) { + return ((GNode) current).equals(other); + } else if (current instanceof Syntax) { + if(current.getClass() != other.getClass()) { + return false; + } + if(! ((Syntax) current).getTokenText().equals(((Syntax) other).getTokenText())) { + return false; + } + } else { + // In case assert is disabled + return false; + } + + return true; + } + /** * Get the string representation. * diff --git a/src/superc/core/MacroTable.java b/src/superc/core/MacroTable.java index b5c68c4c..ccb2e724 100644 --- a/src/superc/core/MacroTable.java +++ b/src/superc/core/MacroTable.java @@ -108,6 +108,29 @@ public boolean getHeaderGuards() { return getHeaderGuards; } + public HashMap> getDependentMacros(Set freeMacros) { + HashMap> finalStrings = new HashMap<>(); + for(String name : table.keySet()) { + for(Entry pcs : table.get(name)) { + for(String free_macro : freeMacros) { + String formattedDefinedMacro = "(defined " + free_macro + ")"; + String formattedNotDefinedMacro = "!(defined " + free_macro + ")"; + // System.out.println("pcs: " + pcs.presenceCondition); + // System.out.println("pcs: " + pcs.presenceCondition.getAllConfigs()); + if((pcs.presenceCondition.getAllConfigs().contains(formattedDefinedMacro) || + pcs.presenceCondition.getAllConfigs().contains(formattedNotDefinedMacro)) && + ! free_macro.equals(name)) { + if( !finalStrings.containsKey(free_macro)) { + finalStrings.put(free_macro, new HashSet<>()); + } + finalStrings.get(free_macro).add(name); + } + } + } + } + return finalStrings; + } + /** * Only allow macros with a given prefix to be free macros. Pass * null to turn this feature off. It is off by default. diff --git a/src/superc/core/PresenceConditionManager.java b/src/superc/core/PresenceConditionManager.java index 118eccef..e5b66f1d 100644 --- a/src/superc/core/PresenceConditionManager.java +++ b/src/superc/core/PresenceConditionManager.java @@ -734,7 +734,7 @@ private PresenceCondition(BDD bdd, Node tree, BoolExpr expr) { this.refs = 1; this.tree = tree; this.expr = expr; - // this.simplify(); + this.simplify(); } private PresenceCondition(boolean value) { @@ -907,8 +907,8 @@ public void delRef() { } public boolean useContextSimplify = true; - public String nameContextSimplify = "ctx-simplify"; // better than "simplify" alone - // public String nameContextSimplify = "ctx-solver-simplify"; // best simplification, but very slow due to calls to solver + // public String nameContextSimplify = "ctx-simplify"; // better than "simplify" alone + public String nameContextSimplify = "ctx-solver-simplify"; // best simplification, but very slow due to calls to solver protected void simplify() { if (! isSimplified) { diff --git a/src/superc/p4parser/CallGraphGenerator.java b/src/superc/p4parser/CallGraphGenerator.java new file mode 100644 index 00000000..66d24d94 --- /dev/null +++ b/src/superc/p4parser/CallGraphGenerator.java @@ -0,0 +1,2799 @@ +package superc.p4parser; +import java.io.File; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Map; +import java.util.Stack; + +import superc.core.PresenceConditionManager.PresenceCondition; +import superc.core.Syntax; +import superc.p4parser.P4LanguageObject.AbstractObjectOfLanguage; +import superc.p4parser.P4LanguageObject.BaseTypesCollection; +import superc.p4parser.P4LanguageObject.ConstantTreeGlobalObjects; +import superc.p4parser.P4LanguageObject.ControlDeclaration; +import superc.p4parser.P4LanguageObject.ControlTypeDeclaration; +import superc.p4parser.P4LanguageObject.Direction; +import superc.p4parser.P4LanguageObject.EnumDeclaration; +import superc.p4parser.P4LanguageObject.ExternDeclaration; +import superc.p4parser.P4LanguageObject.FunctionDeclaration; +import superc.p4parser.P4LanguageObject.FunctionDeclarationGenerator; +import superc.p4parser.P4LanguageObject.FunctionPrototype; +import superc.p4parser.P4LanguageObject.FunctionPrototypeGenerator; +import superc.p4parser.P4LanguageObject.FunctionPrototypePlaceHolder; +import superc.p4parser.P4LanguageObject.Generator; +import superc.p4parser.P4LanguageObject.HeaderStackType; +import superc.p4parser.P4LanguageObject.HeaderTypeDeclaration; +import superc.p4parser.P4LanguageObject.HeaderUnionDeclaration; +import superc.p4parser.P4LanguageObject.InvokableLanguageKeyword; +import superc.p4parser.P4LanguageObject.LObjectKind; +import superc.p4parser.P4LanguageObject.LanguageObject; +import superc.p4parser.P4LanguageObject.PackageTypeDeclaration; +import superc.p4parser.P4LanguageObject.Parameter; +import superc.p4parser.P4LanguageObject.ParserDeclaration; +import superc.p4parser.P4LanguageObject.ParserTypeDeclaration; +import superc.p4parser.P4LanguageObject.StructTypeDeclaration; +import superc.p4parser.P4LanguageObject.SubClass; +import superc.p4parser.P4LanguageObject.TupleType; +import superc.p4parser.P4LanguageObject.TypeDefDeclaration; +import superc.p4parser.P4LanguageObject.TypeParameter; +import superc.p4parser.P4LanguageObject.Variable; +import superc.p4parser.P4LanguageObject.VariableGenerator; +import superc.p4parser.P4LanguageObject.AbstractObjectOfLanguage; +import superc.p4parser.TemporaryParameterValues; +import xtc.tree.GNode; +import xtc.tree.Node; +import xtc.tree.Visitor; + +public class CallGraphGenerator { + + private static final P4LanguageObject p4LanguageObject = new P4LanguageObject(); + private static final BaseTypesCollection baseTypesCollection = p4LanguageObject.new BaseTypesCollection(); + private static final Direction directionClass = p4LanguageObject.new Direction(); + SymbolTable symtab; + Stack scope; + private final String nodeLanguageObjectPropertyString = "languageObject"; + // A list of grammar constructs that are not yet supported in visitor methods and might contain invocation + HashSet notExplicitlySupported = new HashSet<>(Arrays.asList()); + HashMap> callGraphObject; + + // Stack of "temporary" values like parameters and generic values for a specific function. + // As function calls are parsed, the parameters and type generics are stored here in a stack + // and used when generating an instance and/or for name mangling + Stack temporaryValues; + + public CallGraphGenerator() { + this.symtab = new SymbolTable(); + this.scope = new Stack<>(); + this.callGraphObject = new HashMap<>(); + this.temporaryValues = new Stack<>(); + + scope.add(Symbols.getGlobalScope()); + } + + /** + * Looks up the given name in the symbol table and adds it as a callee to the current scope. + * @param name The name of the symbol to look up + */ + public void lookupInSymTabAndAddAsCallee(String name) { + + // looks up in the symbol table under the current scope + // if not in current scope, checks under parent scopes. + AbstractObjectOfLanguage callee = symtab.symtabLookup(scope.peek(), name, temporaryValues, definitionsVisitor, scope); + + customAssert(callee != null, "UNCAUGHT Calling to an undefined symbol when expecting it to be defined beforehand (" + name + ")"); + addAsCallee(callee); + } + + /** + * Adds the passed in language object as a callee to the current scope. + * @param callee The object that should be added as a callee + */ + public void addAsCallee(AbstractObjectOfLanguage callee) { + if( !callGraphObject.containsKey(scope.peek())) { + callGraphObject.put(scope.peek(), new HashSet<>()); + } + callGraphObject.get(scope.peek()).add(callee); + } + + public void buildSymbolTable(Node translationUnit) { + definitionsVisitor.dispatch(translationUnit.getGeneric(0)); + } + + public void buildCallGraph(Node translationUnit) { + callGraphVisitor.dispatch(translationUnit.getGeneric(0)); + } + + public void createCallGraphVisual(String fileName) { + String dotFormat = toDot(); + createDotGraph(dotFormat, fileName); + } + + private Visitor definitionsVisitor = new Visitor() { + // default visitor + public AbstractObjectOfLanguage visit(GNode n) { + // filtering out block that aren't supported yet and can cause silent failures + customAssert(! notExplicitlySupported.contains(n.getName()), n.getName() + " is not supported at the moment"); + + // just visiting the child nodes since no specific dispatch is available for current node + AbstractObjectOfLanguage valueToReturn = Symbols.getDefaultLanguageObject(); + Iterator itr = n.iterator(); + while(itr.hasNext()) { + Object nextObj = itr.next(); + // customAssert((!nextObj.getClass().equals(PresenceCondition.class)) : "PresenceCondition nodes not supported at the moment. Under node: " + nextObj; + if(nextObj instanceof Syntax) { + // Since Syntax objects are not nodes + // System.out.println("It's a syntax obj: " + nextObj.toString()); + // System.out.println("tag: " + ((Language) nextObj).tag()); + continue; + } else if(nextObj instanceof PresenceCondition) { + // TODO handle PC scenarios under conditional nodes + + continue; + } + valueToReturn = (AbstractObjectOfLanguage) dispatch((Node) nextObj); + } + return valueToReturn; + } + + public AbstractObjectOfLanguage visitcontrolDeclaration(GNode n) { + // If need to parse parameters, visit the controltypedeclaration instead of static function to get name + String controlBlockName = getNameOfControlBlock(getGNodeUnderConditional(n.getGeneric(0))); + + ControlDeclaration controlObj = p4LanguageObject.new ControlDeclaration(controlBlockName, scope.peek()); + symtab.addToSymtab(scope.peek(), controlBlockName, controlObj); + scope.add(controlObj); + + AbstractObjectOfLanguage controlTypeDecl = visitcontrolTypeDeclaration(getGNodeUnderConditional(n.getGeneric(0)), false); + + if(controlTypeDecl.isGeneratorClass()) { + System.err.println("Control declaration (" + controlBlockName + ") cannot have generics."); + System.exit(1); + } + + dispatch(getGNodeUnderConditional(n.getGeneric(1))); // optConstructorParameters + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // controlLocalDeclarations + String applyBlockName = n.get(4).toString(); + + // start parse controlBody + GNode oldN = n; + n = getGNodeUnderConditional(n.getGeneric(5)); // controlBody + AbstractObjectOfLanguage apply = symtab.addToSymtab(scope.peek(), applyBlockName); + scope.add(apply); + + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // controlBody can have only one child + + scope.pop(); + n = oldN; + //end parse controlBody + + scope.pop(); + controlObj.setNode(n); + return controlObj; + } + + public AbstractObjectOfLanguage visitheaderTypeDeclaration(GNode n) { + String headerTypeName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + AbstractObjectOfLanguage headerTypeDeclarationObject = p4LanguageObject.new HeaderTypeDeclaration(headerTypeName, scope.peek()); + + if(getGNodeUnderConditional(n.getGeneric(3)).size() > 0) { + headerTypeDeclarationObject.setNode(n); + headerTypeDeclarationObject = p4LanguageObject.new HeaderTypeDeclarationGenerator((HeaderTypeDeclaration) headerTypeDeclarationObject); + } + + symtab.addToSymtab(scope.peek(), headerTypeName, headerTypeDeclarationObject); + scope.add(headerTypeDeclarationObject); + + // default functions associated with headers + FunctionPrototype isValid = p4LanguageObject.new FunctionPrototype("isValid", scope.peek(), baseTypesCollection.getLanguageObjectOfBaseType("bool")); + FunctionPrototype setValid = p4LanguageObject.new FunctionPrototype("setValid", scope.peek(), baseTypesCollection.getVoidLanguageObject()); + FunctionPrototype setInvalid = p4LanguageObject.new FunctionPrototype("setInvalid", scope.peek(), baseTypesCollection.getVoidLanguageObject()); + FunctionPrototype minSizeInBits = p4LanguageObject.new FunctionPrototype("minSizeInBits", scope.peek(), baseTypesCollection.getLanguageObjectOfBaseType("int")); + FunctionPrototype minSizeInBytes = p4LanguageObject.new FunctionPrototype("minSizeInBytes", scope.peek(), baseTypesCollection.getLanguageObjectOfBaseType("int")); + symtab.addToSymtab(scope.peek(), "isValid", isValid); + symtab.addToSymtab(scope.peek(), "setValid", setValid); + symtab.addToSymtab(scope.peek(), "setInvalid", setInvalid); + symtab.addToSymtab(scope.peek(), "minSizeInBits", minSizeInBits); + symtab.addToSymtab(scope.peek(), "minSizeInBytes", minSizeInBytes); + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // optTypeParameters + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // structFieldList + + scope.pop(); + + headerTypeDeclarationObject.setNode(n); + return headerTypeDeclarationObject; + } + + public AbstractObjectOfLanguage visitheaderUnionDeclaration(GNode n) { + String headerUnionName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + AbstractObjectOfLanguage headerUnionDeclarationObject = p4LanguageObject.new HeaderUnionDeclaration(headerUnionName, scope.peek()); + + if(getGNodeUnderConditional(n.getGeneric(3)).size() > 0) { + headerUnionDeclarationObject.setNode(n); + headerUnionDeclarationObject = p4LanguageObject.new HeaderUnionDeclarationGenerator((HeaderUnionDeclaration) headerUnionDeclarationObject); + } + + symtab.addToSymtab(scope.peek(), headerUnionName, headerUnionDeclarationObject); + scope.add(headerUnionDeclarationObject); + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // optTypeParameters + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // structFieldList + + // Header union has access to all members inside it, so adding those member under this scope as well + Map valuesUnderOriginal = symtab.getSymTab().get(headerUnionDeclarationObject); + Map valuesUnder = new HashMap<>(); + for(String key : valuesUnderOriginal.keySet()) { + if(valuesUnderOriginal.get(key).hasAssociatedType()) { + valuesUnder.put(key, valuesUnderOriginal.get(key)); + } + } + + for(String key : valuesUnder.keySet()) { + Map childValues = symtab.getSymTab().get(valuesUnder.get(key).getType()); + if(childValues != null) { + for(String childKey : childValues.keySet()) { + if(symtab.doesSymbolExist(scope.peek(), childKey)) { + continue; + } + symtab.addToSymtab(scope.peek(), childKey, childValues.get(childKey)); + } + } + } + + scope.pop(); + headerUnionDeclarationObject.setNode(n); + return headerUnionDeclarationObject; + } + + public AbstractObjectOfLanguage visittypeRef(GNode n) { + /* + Parses the constructs and returns the type + For typeName, it looks up in the symbol table and returns it + For baseType, respective basetype language object is retrieved from the BaseTypes class + For specializedType and headerStackType the inner constructs are parsed and the value associated with that typeName is returned + For tupletype, a new "tuple" symbol is added to the symtab and that is returned + */ + GNode innerNode = getGNodeUnderConditional(n.getGeneric(0)); + String typeName; + AbstractObjectOfLanguage typeObject; + + switch(innerNode.getName()) { + case "typeName": + typeName = getNameFromTypeName(innerNode); + typeObject = symtab.symtabLookup(scope.peek(), typeName, temporaryValues, definitionsVisitor, scope); + // Since type names point directly to the type and not a instance of that type - + // Update: generic-struct.p4i - the type can be a typedef + // customAssert(!typeObject.hasAssociatedType() : typeObject.getName() + "of constructor: " + typeObject.getConstructType() + " with type: " + typeObject.getType().getName() + " of constructor: " + typeObject.getType().getConstructType(); + return typeObject; + case "baseType": + String baseTypeString = getBaseTypeAsString(innerNode); + if(innerNode.size() > 3) { + // if size of baseType is greater than 3 then it is a production with expression inside it + dispatch(innerNode.getGeneric(3)); + } + return baseTypesCollection.getLanguageObjectOfBaseType(baseTypeString); + case "specializedType": + return (AbstractObjectOfLanguage) dispatch(innerNode); + case "headerStackType": + return (AbstractObjectOfLanguage) dispatch(innerNode); + case "tupleType": + return (AbstractObjectOfLanguage) dispatch(innerNode); + default: + System.err.println("Unhandled new case for typeRef"); + System.exit(1); + return p4LanguageObject.new ConstantTreeGlobalObjects("ERROR"); + } + } + + public AbstractObjectOfLanguage visitstructTypeDeclaration(GNode n) { + String structName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + AbstractObjectOfLanguage structTypeObj = p4LanguageObject.new StructTypeDeclaration(structName, scope.peek()); + + if(getGNodeUnderConditional(n.getGeneric(3)).size() > 0) { + structTypeObj.setNode(n); + structTypeObj = p4LanguageObject.new StructTypeDeclarationGenerator((StructTypeDeclaration) structTypeObj); + } + + symtab.addToSymtab(scope.peek(), structName, structTypeObj); + scope.add(structTypeObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // optTypeParameters + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // structFieldList + + scope.pop(); + structTypeObj.setNode(n); + return structTypeObj; + } + + public AbstractObjectOfLanguage visitstructField(GNode n) { + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // optAnnotations + AbstractObjectOfLanguage typeRefObj = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(1))); + typeRefObj = (typeRefObj.hasAssociatedType() ? typeRefObj.getType() : typeRefObj); + String fieldName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + // System.out.println("visiting struct field: " + fieldName + " with type: " + typeRefObj.getConstructType() ); + AbstractObjectOfLanguage newStructFieldObj = p4LanguageObject.new Variable(fieldName, scope.peek(), typeRefObj); + if(typeRefObj.getConstructType() == LObjectKind.TYPEPARAMETER || typeRefObj.isGeneratorClass()) { + newStructFieldObj.setNode(n); + newStructFieldObj = p4LanguageObject.new VariableGenerator((Variable) newStructFieldObj); + } + symtab.addToSymtab(scope.peek(), fieldName, newStructFieldObj); + newStructFieldObj.setNode(n); + + return newStructFieldObj; + } + + public AbstractObjectOfLanguage visitvariableDeclaration(GNode n) { + // Two productions - one that annotations in the beginning and one does not + int typeRefIndex = 0; + if(n.size() == 5) { // with the annotations + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // annotations + typeRefIndex = 1; + } + + AbstractObjectOfLanguage typeRefObj = (AbstractObjectOfLanguage) dispatch(n.getGeneric(typeRefIndex)); + typeRefObj = (typeRefObj.hasAssociatedType() ? typeRefObj.getType() : typeRefObj); + String variableName = getStringUnderName(n.getGeneric(typeRefIndex+1)); + AbstractObjectOfLanguage variableObj = p4LanguageObject.new Variable(variableName, scope.peek(), typeRefObj); + if(typeRefObj.getConstructType() == LObjectKind.TYPEPARAMETER) { + variableObj.setNode(n); + variableObj = p4LanguageObject.new VariableGenerator((Variable) variableObj); + } + // System.out.println("adding variable named: " + variableName + " under scope: " + scope.peek().getName() + " with type: " + typeRefObj.getName() + " of type: " + typeRefObj.getConstructType()); + symtab.addToSymtab(scope.peek(), variableName, variableObj); + scope.add(variableObj); + + if(getGNodeUnderConditional(n.getGeneric(typeRefIndex + 2)).size() > 0) { + customAssert(!variableObj.isGeneratorClass(), "Assuming that variable assignment is just default value that has no associated type"); + if(variableObj.isGeneratorClass()) { + System.err.println("Assuming that variable assignment is just default value that has no associated type"); + System.exit(1); + } + AbstractObjectOfLanguage optionalInitializer = (AbstractObjectOfLanguage) dispatch(n.getGeneric(typeRefIndex+2)); + ((Variable) variableObj).setAssignedExpression(optionalInitializer); + } + + scope.pop(); + variableObj.setNode(n); + return variableObj; + } + + public AbstractObjectOfLanguage visitenumDeclaration(GNode n) { + /* + Two possible productions: one is normal enums and one is serializable enums, the latter has a type + First one has 6 values and other has 7 values, the latter cause of added type + */ + if(n.size() == 6) { + String enumName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + EnumDeclaration enumObj = p4LanguageObject.new EnumDeclaration(enumName, scope.peek()); + symtab.addToSymtab(scope.peek(), enumName, enumObj); + scope.add(enumObj); + + // Adding enum identifiers + GNode identifiersList = getGNodeUnderConditional(n.getGeneric(4)); + Iterator itr = identifiersList.iterator(); + + while(itr.hasNext()) { + Object next = itr.next(); + if(next instanceof Syntax) { + // COMMA + continue; + } + Object underConditional = getValueUnderConditional((GNode) next); + if(underConditional instanceof Syntax) { + // also COMMA (but surrounded by conditional) + continue; + } + + GNode nextGNode = (GNode) underConditional; + customAssert(nextGNode.getName() == "name"); + String identifierString = getStringUnderName(nextGNode); + + LanguageObject newIdentifier = p4LanguageObject.new LanguageObject(identifierString, scope.peek()); + symtab.addToSymtab(scope.peek(), identifierString, newIdentifier); + } + + scope.pop(); + enumObj.setNode(n); + return enumObj; + } else { + String enumName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(3))); + AbstractObjectOfLanguage type = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(2))); + + customAssert(!type.isGeneratorClass(), "Haven't explored a case where an enum can be declared of generic type."); + + EnumDeclaration enumObj = p4LanguageObject.new EnumDeclaration(enumName, scope.peek(), type); + symtab.addToSymtab(scope.peek(), enumName, enumObj); + scope.add(enumObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // specifiedIdentifierList + + scope.pop(); + enumObj.setNode(n); + return enumObj; + } + } + + public AbstractObjectOfLanguage visitspecifiedIdentifier(GNode n) { + String identifierName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(0))); + + // TODO: for stricter type checking, ensure that the the initializer values are tracked + // (see grammar) and that they are of the declared enum type + LanguageObject newIdentifier = p4LanguageObject.new LanguageObject(identifierName, scope.peek()); + symtab.addToSymtab(scope.peek(), identifierName, newIdentifier); + + newIdentifier.setNode(n); + return newIdentifier; + } + + public AbstractObjectOfLanguage visittypedefDeclaration(GNode n) { + // Two types of typeDefs: TYPEDEF and TYPE () + // Two types of associated type values: typeRef and derivedTypeDeclaration + // derivedTypeDeclaration declares a new type and uses that type, so need to parse that first + + String typeName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(3))); + + if(getGNodeUnderConditional(n.getGeneric(2)).getName() == "typeRef") { + AbstractObjectOfLanguage typeRefObj = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(2))); + + customAssert(typeRefObj != Symbols.getDefaultLanguageObject()); + customAssert(!typeRefObj.isGeneratorClass()); + + String typeDefName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(3))); + TypeDefDeclaration typeDefObj; + if(n.get(1).toString() == "typedef") { + typeDefObj = p4LanguageObject.new TypeDefDeclaration(typeDefName, scope.peek(), typeRefObj, true); + } else { + typeDefObj = p4LanguageObject.new TypeDefDeclaration(typeDefName, scope.peek(), typeRefObj, false); + } + + symtab.addToSymtab(scope.peek(), typeDefName, typeDefObj); + typeDefObj.setNode(n); + + return typeDefObj; + } else { + AbstractObjectOfLanguage derivedTypeDeclarationObj = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(2))); + customAssert(derivedTypeDeclarationObj != Symbols.getDefaultLanguageObject(), derivedTypeDeclarationObj.getConstructType().toString()); + customAssert(!derivedTypeDeclarationObj.isGeneratorClass()); + + String typeDefName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(3))); + TypeDefDeclaration typeDefObj; + if(n.get(1).toString() == "typedef") { + typeDefObj = p4LanguageObject.new TypeDefDeclaration(typeDefName, scope.peek(), derivedTypeDeclarationObj, true); + } else { + typeDefObj = p4LanguageObject.new TypeDefDeclaration(typeDefName, scope.peek(), derivedTypeDeclarationObj, false); + } + + symtab.addToSymtab(scope.peek(), typeDefName, typeDefObj); + typeDefObj.setNode(n); + + return typeDefObj; + } + } + + public AbstractObjectOfLanguage visitparserTypeDeclaration(GNode n) { + return visitparserTypeDeclaration(n, true); + } + + /** + * Pass addToSymtab as false when we consider the type declaration to be part of parser declaration + * Set it to true if parser type declaration is independent of parser declaration + * @param n + * @param addToSymtab + * @return + */ + public AbstractObjectOfLanguage visitparserTypeDeclaration(GNode n, boolean addToSymtab) { + String parserTypeName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + AbstractObjectOfLanguage parserTypeObj = p4LanguageObject.new ParserTypeDeclaration(parserTypeName, scope.peek()); + + if(getGNodeUnderConditional(n.getGeneric(3)).size() > 0) { // has type parameters, so generator + parserTypeObj.setNode(n); + parserTypeObj = p4LanguageObject.new ParserTypeDeclarationGenerator((ParserTypeDeclaration) parserTypeObj); + } + + if(addToSymtab) { + symtab.addToSymtab(scope.peek(), parserTypeName, parserTypeObj); + scope.add(parserTypeObj); + } + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // optTypeParameters + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // parameterList + + if(addToSymtab) { + symtab.addToSymtab(scope.peek(), "apply"); + scope.pop(); + } + + parserTypeObj.setNode(n); + + return parserTypeObj; + } + + public AbstractObjectOfLanguage visitcontrolTypeDeclaration(GNode n) { + return visitcontrolTypeDeclaration(n, true); + } + /** + * Pass addToSymtab as false when we consider the type declaration to be part of the control declaration + * Set it to true if control type declaration is independent of control declaration + * @param n + * @param addToSymtab + * @return + */ + public AbstractObjectOfLanguage visitcontrolTypeDeclaration(GNode n, Boolean addToSymtab) { + String controlTypeName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + AbstractObjectOfLanguage controlTypeObj = p4LanguageObject.new ControlTypeDeclaration(controlTypeName, scope.peek()); + + if(getGNodeUnderConditional(n.getGeneric(3)).size() > 0) { // has type parameters, so generator + controlTypeObj.setNode(n); + controlTypeObj = p4LanguageObject.new ControlTypeDeclarationGenerator((ControlTypeDeclaration) controlTypeObj); + } + + if(addToSymtab) { + symtab.addToSymtab(scope.peek(), controlTypeName, controlTypeObj); + scope.add(controlTypeObj); + } + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // optTypeParameters + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // parameterList + + if(addToSymtab) { + symtab.addToSymtab(scope.peek(), "apply"); + scope.pop(); + } + + controlTypeObj.setNode(n); + + return controlTypeObj; + } + + public AbstractObjectOfLanguage visitpackageTypeDeclaration(GNode n) { + String packageTypeName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + AbstractObjectOfLanguage packageTypeObj = p4LanguageObject.new PackageTypeDeclaration(packageTypeName, scope.peek()); + + // check if it has generic parameters, if so make it generator class + if(getGNodeUnderConditional(n.getGeneric(3)).size() > 0) { + packageTypeObj.setNode(n); + packageTypeObj = p4LanguageObject.new PackageTypeDeclarationGenerator((PackageTypeDeclaration) packageTypeObj); + } + + symtab.addToSymtab(scope.peek(), packageTypeName, packageTypeObj); + scope.add(packageTypeObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // optTypeParameters + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // parameterList + + scope.pop(); + + packageTypeObj.setNode(n); + + return packageTypeObj; + } + + public AbstractObjectOfLanguage visittypeOrVoid(GNode n) { + if(n.get(0).toString() == "void") { + return baseTypesCollection.getVoidLanguageObject(); + } else if(n.get(0) instanceof GNode) { + customAssert(getGNodeUnderConditional(n.getGeneric(0)).getName() == "typeRef"); + return (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(0))); + } else { // IDENTIFIER - may be type variable + String identifier = n.get(0).toString(); + return symtab.retrieveSymbolOrTypeVariable(scope, scope.peek(), identifier, temporaryValues, definitionsVisitor); + } + } + + public AbstractObjectOfLanguage visitfunctionPrototype(GNode n) { + return visitfunctionPrototype(n, LObjectKind.FUNCTIONPROTOTYPE); + } + + public AbstractObjectOfLanguage visitfunctionPrototype(GNode n, LObjectKind classType) { + AbstractObjectOfLanguage typeOrVoid; + GNode typeOrVoidNode = getGNodeUnderConditional(n.getGeneric(0)); + String identifier = null; + // visittypeOrVoid + if(typeOrVoidNode.get(0).toString() == "void") { + typeOrVoid = baseTypesCollection.getVoidLanguageObject(); + } else if(typeOrVoidNode.get(0) instanceof GNode) { + customAssert(getGNodeUnderConditional(typeOrVoidNode.getGeneric(0)).getName() == "typeRef"); + typeOrVoid = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(typeOrVoidNode.getGeneric(0))); + } else { // IDENTIFIER - may be type variable + identifier = typeOrVoidNode.get(0).toString(); + typeOrVoid = symtab.symtabLookupIfExists(scope.peek(), identifier, true, true, temporaryValues, definitionsVisitor, scope); + // System.out.println("looking up result of " + identifier + ": " + typeOrVoid.getName()); + } + + String functionPrototypeNameOriginal= getStringUnderName(getGNodeUnderConditional(n.getGeneric(1))); + FunctionPrototypePlaceHolder placeHolder = p4LanguageObject.new FunctionPrototypePlaceHolder(functionPrototypeNameOriginal, scope.peek()); + symtab.addToSymtab(scope.peek(), functionPrototypeNameOriginal, placeHolder); + // Key to differentiating function and method overloading (name mangling) + // NOTE! P4 allows function overloading of same parameter sizes but only when the parameter names are different - NOT SUPPORTED YET + String functionPrototypeName = functionPrototypeNameOriginal + "_" + getParameterSize(getGNodeUnderConditional(n.getGeneric(4)), false); // adding parameter size to the name + String functionPrototypeNameWithoutDefaultVals = functionPrototypeNameOriginal + "_" + getParameterSizeWithoutDefaultValues(getGNodeUnderConditional(n.getGeneric(4))); // adding parameter size to the name but excluding default values count + // System.out.println("Type value is: " + (typeOrVoid.getName()) + " with identifier: " + identifier + " for func prototype: " + functionPrototypeName + " add to symtab value: " + addToSymtab); + AbstractObjectOfLanguage functionPrototypeObj = p4LanguageObject.getRespectiveFunctionPrototypeClass(functionPrototypeName, scope.peek(), typeOrVoid, classType); + + // can optimize this + boolean areParametersGeneric = isAnyParameterGeneric(getGNodeUnderConditional(n.getGeneric(4)), getGNodeUnderConditional(n.getGeneric(2))); + + if(typeOrVoid.getConstructType() == LObjectKind.TYPEPARAMETER || + getGNodeUnderConditional(n.getGeneric(2)).size() > 0 || + areParametersGeneric) { + functionPrototypeObj.setNode(n); + functionPrototypeObj = p4LanguageObject.getRespectiveFunctionPrototypeGeneratorClass((FunctionPrototype) functionPrototypeObj); + } + + symtab.addToSymtab(scope.peek(), functionPrototypeName, functionPrototypeObj); + if(! functionPrototypeName.equals(functionPrototypeNameWithoutDefaultVals)) { + System.err.println("re-adding function name: " + functionPrototypeNameOriginal + " but mangled with parameter size excluding default values."); + symtab.addToSymtab(scope.peek(), functionPrototypeNameWithoutDefaultVals, functionPrototypeObj); + } + scope.add(functionPrototypeObj); + if(typeOrVoid == Symbols.getDefaultLanguageObject() || typeOrVoid == Symbols.getUndeclaredObject()) { + // System.err.println("adding type parameter to symbol table"); + customAssert(identifier != null); + typeOrVoid = symtab.retrieveSymbolOrTypeVariable(scope, scope.peek(), identifier, temporaryValues, definitionsVisitor); + if(functionPrototypeObj.isGeneratorClass()) { + ((FunctionPrototypeGenerator) functionPrototypeObj).setType(typeOrVoid); + } else { + ((FunctionPrototype) functionPrototypeObj).setType(typeOrVoid); + } + } + + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // optTypeParameters + dispatch(getGNodeUnderConditional(n.getGeneric(4))); // parameterList + + scope.pop(); + + // System.out.println("Created function prototype: " + functionPrototypeName + " with parameters: " + + // functionPrototypeObj.getParameterList() + " and return type: " + functionPrototypeObj.getType() + + // " along with type parameters: " + functionPrototypeObj.getOptTypeParameters()); + functionPrototypeObj.setNode(n); + customAssert(!n.hasProperty(nodeLanguageObjectPropertyString)); + n.setProperty(nodeLanguageObjectPropertyString, functionPrototypeObj); + + return functionPrototypeObj; + } + + public AbstractObjectOfLanguage visitactionDeclaration(GNode n) { + // Each action in the list of actions for a table must have a distinct name + String actionBlockName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + AbstractObjectOfLanguage actionObj = symtab.addToSymtab(scope.peek(), actionBlockName); + scope.add(actionObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(4))); // parameterList + dispatch(getGNodeUnderConditional(n.getGeneric(6))); // blockStatement + + scope.pop(); + + actionObj.setNode(n); + + return actionObj; + } + + // follow similar as last time (break into three different grammar constructs) + // . member values has structfield list inside it, so no function calls inside it - but matters for data flow + // header functions - push_front + public AbstractObjectOfLanguage visitassignmentOrMethodCallStatement(GNode n) { + if(getGNodeUnderConditional(n.getGeneric(0)).getName() == "methodCallStatements") { + // method call statements + return (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(0))); + } else { + // assignment statement + AbstractObjectOfLanguage lvalue = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(0))); // lvalue + // Asserting that this lvalue call does not invoke functions + customAssert(lvalue.getConstructType() != LObjectKind.EXTERNDECLARATION || + lvalue.getConstructType() != LObjectKind.EXTERNFUNCTIONDECLARATION || + lvalue.getConstructType() != LObjectKind.FUNCTION || + lvalue.getConstructType() != LObjectKind.FUNCTIONPROTOTYPE || + lvalue.getConstructType() != LObjectKind.PARSERDECLARATION || + lvalue.getConstructType() != LObjectKind.PARSERTYPEDECLARATION || + lvalue.getConstructType() != LObjectKind.CONTROLDECLARATION || + lvalue.getConstructType() != LObjectKind.CONTROLTYPEDECLARATION || + lvalue.getConstructType() != LObjectKind.PACKAGETYPEDECLARATION); + + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // expression + return Symbols.getDefaultLanguageObject(); + } + } + + public AbstractObjectOfLanguage visitmethodCallStatements(GNode n) { + temporaryValues.add(new TemporaryParameterValues()); + + // There are two possible set of sub productions, both which have argument list under it + // but one has typeArgumentList before argument list, so argumentList is not at the same place + // hence check the size to see which production we are currently under and dispatching + // the visitor at the respective argumentList position + if(n.size() == 5) { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // argumentlist + } else { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // typeArgumentList + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // argumentList + } + + + AbstractObjectOfLanguage method = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(0))); // lvalue + + customAssert(!method.isGeneratorClass(), method.getName() + " is called but is still tagged as generator"); + n.setProperty("callee", method); + + temporaryValues.pop(); + + return Symbols.getDefaultLanguageObject(); + } + + // does parsing and type checking + public AbstractObjectOfLanguage visitlvalue(GNode n) { + AbstractObjectOfLanguage lvalue = parseLValue(scope.peek(), n, this); + lvalue.setNode(n); + return lvalue; + } + + public AbstractObjectOfLanguage visitlvalueExpression(GNode n) { + // Two possible productions: + // L_BRACKET expression R_BRACKET - size 3 + // L_BRACKET expression COLON expression R_BRACKET - size 5 + + dispatch(getGNodeUnderConditional(n.getGeneric(1))); // always expression + + if(n.size() == 5) { // L_BRACKET expression COLON expression R_BRACKET + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // expression + } + + return Symbols.getDefaultLanguageObject(); + } + + public AbstractObjectOfLanguage visitargument(GNode n) { + customAssert(!temporaryValues.empty()); + if(n.get(0) instanceof Syntax || + getValueUnderConditional(n.getGeneric(0)) instanceof Syntax) { + temporaryValues.peek().addToParameters(baseTypesCollection.getDontCareLanguageObject()); + return baseTypesCollection.getDontCareLanguageObject(); + } + + AbstractObjectOfLanguage value; + if(getGNodeUnderConditional(n.getGeneric(0)).getName() == "expression") { + // System.out.println("visiting argument expression with name: " + getGNodeUnderConditional(n.getGeneric(0)).getName()); + value = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(0))); + } else { + // System.out.println("visting names argument expression with name: " + getGNodeUnderConditional(n.getGeneric(0)).toString()); + value = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(2))); + } + temporaryValues.peek().addToParameters(value); + return value; + } + + public AbstractObjectOfLanguage visitexpression(GNode n) { + // System.out.println("entering expression: " + n); + if(n.get(0) instanceof Syntax && n.size() == 1) { + // TODO: handle booleans separately and "this" word + return p4LanguageObject.new OLangString(n.get(0).toString(), scope.peek()); + } + + Iterator itr = n.iterator(); + AbstractObjectOfLanguage finalValue = null; + AbstractObjectOfLanguage localScope = scope.peek(); + while(itr.hasNext()) { + // System.out.println("new final value: " + localScope + " with name: " + localScope.getName()); + Node next = (Node) itr.next(); + if(next instanceof Syntax) { + if(next.toString() == "[") { + // System.err.println("encountered ["); + AbstractObjectOfLanguage number = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional((GNode) itr.next())); + Object nextVal = getValueUnderConditional((GNode) itr.next()); + if(nextVal.toString() == ":") { + AbstractObjectOfLanguage secondNumber = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional((GNode) itr.next())); + nextVal = getValueUnderConditional((GNode) itr.next()); + } + customAssert(nextVal.toString() == "]"); + } + // eg: NOT expression (skips over NOT and goes to expression) + finalValue = p4LanguageObject.new OLangString(next.toString(), scope.peek()); + continue; + } + Object underConditional = getValueUnderConditional((GNode) next); + + if(underConditional instanceof Syntax) { + if(underConditional.toString() == "[") { + // System.err.println("encountered ["); + AbstractObjectOfLanguage number = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional((GNode) itr.next())); + Object nextVal = getValueUnderConditional((GNode) itr.next()); + if(nextVal.toString() == ":") { + AbstractObjectOfLanguage secondNumber = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional((GNode) itr.next())); + nextVal = getValueUnderConditional((GNode) itr.next()); + } + customAssert(nextVal.toString() == "]"); + } + finalValue = p4LanguageObject.new OLangString(underConditional.toString(), scope.peek()); + continue; + } + + GNode childNode = (GNode) underConditional; + // System.out.println("traversing: " + childNode.getName() + " " + childNode.toString()); + switch(childNode.getName()) { + // we tell symtab look up to not generate an instance if the look up value is of generator class + // since expression parsing for invoking expression is different and that's where we have to generate instances + // Here we are just look up values to type check + case "expression": + finalValue = (AbstractObjectOfLanguage) dispatch(childNode); + localScope = finalValue; + // System.out.println("expression: " + finalValue.getName()); + break; + case "nonTypeName": + // nonTypeName + AbstractObjectOfLanguage lookup = symtab.nonTypeNameSymtabLookUp(localScope, getStringUnderNonTypeName(getGNodeUnderConditional(childNode)), false, true, false, temporaryValues, definitionsVisitor, scope); + customAssert(!lookup.isGeneratorClass()); + // System.out.println("found nonTypeName: " + lookup.getName()); + finalValue = lookup; + localScope = lookup; + break; + case "dotPrefix": + // dotPrefix nonTypeName + // continuing because the while loop will reach nonTypeName + customAssert(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(1))).getName() == "nonTypeName"); + childNode = getGNodeUnderConditional((GNode) itr.next()); + customAssert(childNode.getName() == "nonTypeName"); + AbstractObjectOfLanguage lookupNonTypeName = symtab.nonTypeNameSymtabLookUp(localScope, getStringUnderNonTypeName(getGNodeUnderConditional(childNode)), false, true, false, temporaryValues, definitionsVisitor, scope); + customAssert(!lookupNonTypeName.isGeneratorClass()); + + return lookupNonTypeName; + case "typeName": + // typeName dot_name + // doing namespacing + AbstractObjectOfLanguage typeNameLO = symtab.symtabLookup(localScope, getNameFromTypeName(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0)))), true, false, temporaryValues, definitionsVisitor, scope); + customAssert(!typeNameLO.isGeneratorClass()); + localScope = typeNameLO; + finalValue = typeNameLO; + // System.out.println("typeName: " + finalValue.getName()); + break; + case "dot_name": + String dotNameString = getStringUnderDotName(childNode); + // System.out.println("localscope: " + localScope.getName()); + AbstractObjectOfLanguage symtabLookUpValue = symtab.symtabLookup(localScope, dotNameString, true, false, temporaryValues, definitionsVisitor, scope); + customAssert(!symtabLookUpValue.isGeneratorClass()); + // System.out.println("look up result: " + symtabLookUpValue.getName() + " under node: " + childNode); + finalValue = symtabLookUpValue; + localScope = finalValue; + // System.out.println("new value under dot name: " + dotNameString); + break; + default: + finalValue = (AbstractObjectOfLanguage) dispatch(childNode); + localScope = finalValue; + // System.out.println("default: " + finalValue.getName()); + } + } + customAssert(finalValue != null); + return finalValue; + } + + public AbstractObjectOfLanguage visitnonBraceExpression(GNode n) { + // System.out.println("entering expression: " + n); + if(n.get(0) instanceof Syntax && n.size() == 1) { + // TODO: handle booleans separately and "this" word + return p4LanguageObject.new OLangString(n.get(0).toString(), scope.peek()); + } + + Iterator itr = n.iterator(); + AbstractObjectOfLanguage finalValue = null; + AbstractObjectOfLanguage localScope = scope.peek(); + while(itr.hasNext()) { + // System.out.println("new final value: " + localScope + " with name: " + localScope.getName()); + Node next = (Node) itr.next(); + if(next instanceof Syntax) { + if(next.toString() == "[") { + // System.err.println("encountered ["); + AbstractObjectOfLanguage number = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional((GNode) itr.next())); + Object nextVal = getValueUnderConditional((GNode) itr.next()); + if(nextVal.toString() == ":") { + AbstractObjectOfLanguage secondNumber = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional((GNode) itr.next())); + nextVal = getValueUnderConditional((GNode) itr.next()); + } + customAssert(nextVal.toString() == "]"); + } + // eg: NOT expression (skips over NOT and goes to expression) + finalValue = p4LanguageObject.new OLangString(next.toString(), scope.peek()); + continue; + } + Object underConditional = getValueUnderConditional((GNode) next); + + if(underConditional instanceof Syntax) { + if(underConditional.toString() == "[") { + // System.err.println("encountered ["); + AbstractObjectOfLanguage number = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional((GNode) itr.next())); + Object nextVal = getValueUnderConditional((GNode) itr.next()); + if(nextVal.toString() == ":") { + AbstractObjectOfLanguage secondNumber = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional((GNode) itr.next())); + nextVal = getValueUnderConditional((GNode) itr.next()); + } + customAssert(nextVal.toString() == "]"); + } + finalValue = p4LanguageObject.new OLangString(underConditional.toString(), scope.peek()); + continue; + } + + GNode childNode = (GNode) underConditional; + // System.out.println("traversing: " + childNode.getName() + " " + childNode.toString()); + switch(childNode.getName()) { + // we tell symtab look up to not generate an instance if the look up value is of generator class + // since expression parsing for invoking expression is different and that's where we have to generate instances + // Here we are just look up values to type check + case "expression": + finalValue = (AbstractObjectOfLanguage) dispatch(childNode); + localScope = finalValue; + // System.out.println("expression: " + finalValue.getName()); + break; + case "nonBraceExpression": + finalValue = (AbstractObjectOfLanguage) dispatch(childNode); + localScope = finalValue; + // System.out.println("expression: " + finalValue.getName()); + break; + case "nonTypeName": + // nonTypeName + AbstractObjectOfLanguage lookup = symtab.nonTypeNameSymtabLookUp(localScope, getStringUnderNonTypeName(getGNodeUnderConditional(childNode)), false, true, false, temporaryValues, definitionsVisitor, scope); + customAssert(!lookup.isGeneratorClass()); + // System.out.println("found nonTypeName: " + lookup.getName()); + finalValue = lookup; + localScope = lookup; + break; + case "dotPrefix": + // dotPrefix nonTypeName + // continuing because the while loop will reach nonTypeName + customAssert(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(1))).getName() == "nonTypeName"); + childNode = getGNodeUnderConditional((GNode) itr.next()); + customAssert(childNode.getName() == "nonTypeName"); + AbstractObjectOfLanguage lookupNonTypeName = symtab.nonTypeNameSymtabLookUp(localScope, getStringUnderNonTypeName(getGNodeUnderConditional(childNode)), false, true, false, temporaryValues, definitionsVisitor, scope); + customAssert(!lookupNonTypeName.isGeneratorClass()); + + return lookupNonTypeName; + case "typeName": + // typeName dot_name + // doing namespacing + AbstractObjectOfLanguage typeNameLO = symtab.symtabLookup(localScope, getNameFromTypeName(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0)))), true, false, temporaryValues, definitionsVisitor, scope); + customAssert(!typeNameLO.isGeneratorClass()); + localScope = typeNameLO; + finalValue = typeNameLO; + // System.out.println("typeName: " + finalValue.getName()); + break; + case "dot_name": + String dotNameString = getStringUnderDotName(childNode); + // System.out.println("localscope: " + localScope.getName()); + AbstractObjectOfLanguage symtabLookUpValue = symtab.symtabLookup(localScope, dotNameString, true, false, temporaryValues, definitionsVisitor, scope); + customAssert(!symtabLookUpValue.isGeneratorClass()); + // System.out.println("look up result: " + symtabLookUpValue.getName() + " under node: " + childNode); + finalValue = symtabLookUpValue; + localScope = finalValue; + // System.out.println("new value under dot name: " + dotNameString); + break; + default: + finalValue = (AbstractObjectOfLanguage) dispatch(childNode); + localScope = finalValue; + // System.out.println("default: " + finalValue.getName()); + } + } + customAssert(finalValue != null); + return finalValue; + } + + public AbstractObjectOfLanguage visitinvokingExpression(GNode n) { + AbstractObjectOfLanguage returnValue; + + temporaryValues.add(new TemporaryParameterValues()); + + GNode nGetGeneric0 = getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0))); + if(nGetGeneric0.getName() == "namedType") { + // one of three possible productions, starts with namedType + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // argumentList + + if(getGNodeUnderConditional(nGetGeneric0.getGeneric(0)).getName() == "typeName") { + String namedType = getStringUnderNamedType(nGetGeneric0); + AbstractObjectOfLanguage namedTypeObj = symtab.symtabLookup(scope.peek(), namedType, temporaryValues, definitionsVisitor, scope); + + returnValue = namedTypeObj; + } else { // specializedType + AbstractObjectOfLanguage specialiazedType = visitspecializedType(getGNodeUnderConditional(nGetGeneric0.getGeneric(0)), true); + returnValue = specialiazedType; + } + } else { + // two possible productions, one contains extra set of type arguments + // inside angle brackets (of size 4 & 7) + + if(n.size() == 4) { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // argumentList + } else { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // realTypeArgumentList + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // argumentList + } + + // first element pointing to name is an expression, extract from that + AbstractObjectOfLanguage expressionCallee = getCalleeFromExpression(nGetGeneric0, this); + + returnValue = expressionCallee; + } + + customAssert(!returnValue.isGeneratorClass(), returnValue.getName() + " is called but is still tagged as generator"); + + n.setProperty("callee", returnValue); + + temporaryValues.pop(); + return returnValue; + } + + public AbstractObjectOfLanguage visitinvokingNonBraceExpression(GNode n) { + AbstractObjectOfLanguage returnValue; + + temporaryValues.add(new TemporaryParameterValues()); + + GNode nGetGeneric0 = getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0))); + if(nGetGeneric0.getName() == "namedType") { + // one of three possible productions, starts with namedType + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // argumentList + + if(getGNodeUnderConditional(nGetGeneric0.getGeneric(0)).getName() == "typeName") { + String namedType = getStringUnderNamedType(nGetGeneric0); + AbstractObjectOfLanguage namedTypeObj = symtab.symtabLookup(scope.peek(), namedType, temporaryValues, definitionsVisitor, scope); + + returnValue = namedTypeObj; + } else { // specializedType + AbstractObjectOfLanguage specialiazedType = visitspecializedType(getGNodeUnderConditional(nGetGeneric0.getGeneric(0)), true); + returnValue = specialiazedType; + } + } else { + // two possible productions, one contains extra set of type arguments + // inside angle brackets (of size 4 & 7) + + if(n.size() == 4) { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // argumentList + } else { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // realTypeArgumentList + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // argumentList + } + + // first element pointing to name is an expression, extract from that + AbstractObjectOfLanguage expressionCallee = getCalleeFromNonBraceExpression(nGetGeneric0, this); + + returnValue = expressionCallee; + } + + customAssert(!returnValue.isGeneratorClass(), returnValue.getName() + " is called but is still tagged as generator"); + + n.setProperty("callee", returnValue); + + temporaryValues.pop(); + return returnValue; + } + + public AbstractObjectOfLanguage visitrealTypeArgumentList(GNode n) { + // temporaryValues.getTypeParameters().clear(); + + Iterator itr = n.iterator(); + while(itr.hasNext()) { + Object nextVal = getValueUnderConditional(itr.next()); + if(nextVal instanceof Syntax) { + // COMMA + continue; + } + + GNode nextChild = (GNode) nextVal; + dispatch(nextChild); + } + + return Symbols.getDefaultLanguageObject(); + } + + public AbstractObjectOfLanguage visitrealTypeArg(GNode n) { + AbstractObjectOfLanguage returnValue; + if(getValueUnderConditional(n.get(0)) instanceof Syntax) { + // void or dontcare (_) + if(getValueUnderConditional(n.get(0)).toString() == "_") { + returnValue = baseTypesCollection.getDontCareLanguageObject(); + } else { + returnValue = baseTypesCollection.getVoidLanguageObject(); + } + } else { + returnValue = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(0))); + } + + customAssert(!temporaryValues.empty()); + temporaryValues.peek().addToTypeParameters(returnValue); + return returnValue; + } + + public AbstractObjectOfLanguage visitexternDeclaration(GNode n) { + if(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0))).getName() == "externFunctionDeclaration") { // separate dispatch available for this + return (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0)))); + } else { + if(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(2))).getName() == "nonTypeName") { + String externName = getStringUnderNonTypeName(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(2)))); + AbstractObjectOfLanguage externObj = p4LanguageObject.new ExternDeclaration(externName, scope.peek());; + if(getGNodeUnderConditional(n.getGeneric(3)).size() > 0) { + externObj.setNode(n); + // has type parameters, so generator + externObj = p4LanguageObject.new ExternDeclarationGenerator((ExternDeclaration) externObj); + } + + symtab.addToSymtab(scope.peek(), externName, externObj); + // symtab.print(); + scope.add(externObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // optTypeParameters + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // methodPrototypes + + scope.pop(); + externObj.setNode(n); + return externObj; + } else { // only option left is "optAnnotations EXTERN name SEMICOLON" production but that is not valid anymore + System.err.println("externDeclaration with the grammar: \"optAnnotations EXTERN name SEMICOLON\" is deprecated"); + System.exit(1); + return Symbols.getDefaultLanguageObject(); + } + } + } + + // extern function declarations are invokable constructs as per the language specs + // so keeping track of that in the symbol table for future invocations + public AbstractObjectOfLanguage visitexternFunctionDeclaration(GNode n) { + AbstractObjectOfLanguage functionPrototype = (AbstractObjectOfLanguage) visitfunctionPrototype(getGNodeUnderConditional(n.getGeneric(2)), LObjectKind.EXTERNFUNCTIONDECLARATION); + functionPrototype.setNode(n); + return functionPrototype; + } + + // Interesting: functionDeclaration not part of P416? not in online language specification -- experimental + // + public AbstractObjectOfLanguage visitfunctionDeclaration(GNode n) { + // as per language specification, functionPrototype will describe the name and type signature of the function + + AbstractObjectOfLanguage functionPrototype = visitfunctionPrototype(getGNodeUnderConditional(n.getGeneric(0)), LObjectKind.FUNCTIONDECLARATION); // functionPrototype (for parameters) + scope.add(functionPrototype); + AbstractObjectOfLanguage blockStatement = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(1))); // blockstatement + + if(functionPrototype.isGeneratorClass()) { + customAssert(functionPrototype.isGeneratorClass()); + ((FunctionDeclarationGenerator) functionPrototype).setBlockStatement(blockStatement); + } else { + ((FunctionDeclaration) functionPrototype).setBlockStatement(blockStatement); + } + + scope.pop(); + functionPrototype.setNode(n); + return functionPrototype; + } + + public AbstractObjectOfLanguage visitmethodPrototype(GNode n) { + /* methodPrototype + optAnnotations functionPrototype SEMICOLON + optAnnotations ABSTRACT functionPrototype SEMICOLON + constructorMethodPrototype + + constructorMethodPrototype: + optAnnotations TYPE_IDENTIFIER L_PAREN parameterList R_PAREN SEMICOLON + + Where last one is a constructor + */ + + if(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0))).getName() == "constructorMethodPrototype") { + return (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0)))); + } else if(n.get(1) instanceof Syntax) { // keyword ABSTRACT + // TODO: need to handle abstract methods + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // optAnnotations + + AbstractObjectOfLanguage functionObj = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(2)))); + + return functionObj; + } else { + customAssert(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(1))).getName() == "functionPrototype", "unhandled case in method prototype"); + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // optAnnotations + + AbstractObjectOfLanguage functionObj = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(1)))); + + return functionObj; + } + } + + // TODO: will be coherent to handle this as a function + // Atm it treats it as a keyword and instead makes the parent scope (the extern block of the same name) into a + // pseudo function with parameters. There can be multiple constructor methods, so need to change this to act like a function prototype + // Doing so we also need to handle constructor scope. Looking up constructor method in the symboltable now just looks + // at the extern block, not the constructor method present inside it - this has to change if we switch to function prototype-like + public AbstractObjectOfLanguage visitconstructorMethodPrototype(GNode n) { + String type_identifier = n.get(1).toString(); + // System.out.println("constructor inside: " + type_identifier); + + customAssert(type_identifier.equals(scope.peek().getName()), "Extern constructor not of the same name as extern block. Potential constructor name: " + type_identifier + ", extern name: " + scope.peek().getName()); + AbstractObjectOfLanguage constructor = symtab.addToSymtab(scope.peek(), type_identifier); + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // parameterList + + return constructor; + } + + public AbstractObjectOfLanguage visitparameter(GNode n) { + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // optAnnotations + GNode typeRefNode = getGNodeUnderConditional(n.getGeneric(2)); + // String type_ref_string = getTypeStringUnderTypeRef(typeRefNode); + String name = getStringUnderName(getGNodeUnderConditional(n.getGeneric(3))); + String directionString; + if(getGNodeUnderConditional(n.getGeneric(1)).size() > 0) { + directionString = getGNodeUnderConditional(n.getGeneric(1)).get(0).toString(); + } else { + directionString = ""; + } + + ConstantTreeGlobalObjects direction; + + if(!directionString.isEmpty()) { + direction = (ConstantTreeGlobalObjects) directionClass.getLanguageObjectOfDirection(directionString); + } else { + direction = null; + } + + AbstractObjectOfLanguage parameterType; + + parameterType = (AbstractObjectOfLanguage) dispatch(typeRefNode); + + AbstractObjectOfLanguage newParameterObj; + AbstractObjectOfLanguage expression = null; + + if(n.size() == 6) { + customAssert(direction == null || direction == directionClass.getLanguageObjectOfDirection("in")); + // "optAnnotations direction typeRef name ASSIGN expression {}" productiom + // so need to take care of expression + // The other production is just "optAnnotations direction typeRef name" + expression = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(5))); + + customAssert(!expression.isGeneratorClass()); + if(expression.hasAssociatedType()) { + customAssert(!expression.getType().isGeneratorClass()); + } + + } + + newParameterObj = p4LanguageObject.new Parameter(name, scope.peek(), parameterType, direction, expression); + + if(parameterType.getConstructType() == LObjectKind.TYPEPARAMETER) { + newParameterObj.setNode(n); + newParameterObj = p4LanguageObject.new ParameterGenerator((Parameter) newParameterObj); + // customAssert(scope.peek().isGeneratorClass() : "Trying to add generic parameter: " + newParameterObj.getName() + " but parent is set to be generator class. Parent: " + scope.peek().getName() + "(" + scope.peek().getConstructType() + ")"; + } + // System.out.println("adding new parameter: '" + name + "' to scope: " + scope.peek().getName() + " " + scope.peek()); + symtab.addToSymtab(scope.peek(), name, newParameterObj); + scope.peek().addParameter(newParameterObj); + + if(n.size() == 6) { + newParameterObj.increaseDefaultParameterCount(); + } + + newParameterObj.setNode(n); + return newParameterObj; + } + + public AbstractObjectOfLanguage visittypeParameterList(GNode n) { + /* + Two possible productions: + name + typeParameterList COMMA name ----- list + */ + TypeParameter typeParameterObj = null; + // typeParameterList is tagged as list, so instead of being recursive it will have a list + // of type parameters. So iterating over them + Iterator itr = n.iterator(); + Node next; + while(itr.hasNext()) { + next = (Node) itr.next(); + customAssert(next instanceof GNode == true); + GNode childNode = (GNode) next; + Object valueUnderConditional = getValueUnderConditional(childNode); + if (valueUnderConditional instanceof Syntax) continue; // "," + childNode = (GNode) valueUnderConditional; + customAssert(childNode.getName() == "name"); + String name = getStringUnderName(childNode); + // System.out.println("adding type parameter: " + name + " to scope: " + scope.peek().getName()); + AbstractObjectOfLanguage retrievedValue = symtab.retrieveSymbolOrTypeVariable(scope, scope.peek(), name, true, temporaryValues, definitionsVisitor); + customAssert(retrievedValue.getConstructType() == LObjectKind.TYPEPARAMETER, "assertion failed. Expected typeparmeter construct type but got: " + retrievedValue.getConstructType()); + typeParameterObj = (TypeParameter) retrievedValue; + // since type parameters only occur inside optTypeParameters + customAssert(scope.peek().isGeneratorClass(), "Scope is under: " + scope.peek().getName() + " that is not a generator class. Of construct type: " + scope.peek().getConstructType()); + ((Generator) scope.peek()).addOptTypeParameters(typeParameterObj); + // symtab.addToSymtab(scope.peek(), name, typeParameterObj); + } + customAssert(typeParameterObj != null); + + return typeParameterObj; + } + + public AbstractObjectOfLanguage visitparserDeclaration(GNode n) { + String parserName = getStringUnderParserTypeDeclaration(getGNodeUnderConditional(n.getGeneric(0))); + + ParserDeclaration parserObj = p4LanguageObject.new ParserDeclaration(parserName, scope.peek()); + // if it has type parameters under parserTypeDeclaration, cannot happen as per language specifications + // (https://p4.org/p4-spec/docs/P4-16-working-spec.html#sec-parser-decl) + if(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0))).getGeneric(3).size() > 0) { + System.err.println("Parser declaration (" + parserName + ") cannot have generics."); + System.exit(1); + } + + symtab.addToSymtab(scope.peek(), parserName, parserObj); + scope.add(parserObj); + + AbstractObjectOfLanguage parserTypeDeclaration = visitparserTypeDeclaration(getGNodeUnderConditional(n.getGeneric(0)), false); + customAssert(!parserTypeDeclaration.isGeneratorClass()); + parserObj.setParserTypeDeclaration((ParserTypeDeclaration) parserTypeDeclaration); + + dispatch(getGNodeUnderConditional(n.getGeneric(1))); // optConstructorParameters + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // parserLocalElements TODO: valueSetDeclaration needs to be traced for data flow + dispatch(getGNodeUnderConditional(n.getGeneric(4))); // parserStates + + // built in parser states + symtab.addToSymtab(scope.peek(), "accept"); + symtab.addToSymtab(scope.peek(), "reject"); + + // built in functions + symtab.addToSymtab(scope.peek(), "apply", p4LanguageObject.new InvokableLanguageKeyword("apply", scope.peek())); + + scope.pop(); + + parserObj.setNode(n); + + return parserObj; + } + + public AbstractObjectOfLanguage visittypeArg(GNode n) { + AbstractObjectOfLanguage returnValue; + if(getValueUnderConditional(n.get(0)) instanceof Syntax) { + // void or dontcare (_) + if(getValueUnderConditional(n.get(0)).toString() == "_") { + returnValue = baseTypesCollection.getDontCareLanguageObject(); + } else { + returnValue = baseTypesCollection.getVoidLanguageObject(); + } + } else { + if(getGNodeUnderConditional(n.getGeneric(0)).getName() == "nonTypeName") { + String name = getStringUnderNonTypeName(getGNodeUnderConditional(n.getGeneric(0))); + returnValue = symtab.nonTypeNameSymtabLookUp(scope.peek(), name, true, temporaryValues, definitionsVisitor, scope); + } else { + returnValue = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(0))); + } + } + + customAssert(!temporaryValues.empty()); + temporaryValues.peek().addToTypeParameters(returnValue); + return returnValue; + } + + public AbstractObjectOfLanguage visittupleType(GNode n) { + temporaryValues.add(new TemporaryParameterValues()); + TupleType newTuple = p4LanguageObject.new TupleType(scope.peek()); + + dispatch(getGNodeUnderConditional(n.getGeneric(2))); + + temporaryValues.pop(); + + newTuple.setNode(n); + + return newTuple; + } + + public AbstractObjectOfLanguage visitspecializedType(GNode n) { + return visitspecializedType(n, false); + } + + // has special variable for fromInstantiation since instantiation construct + // can provide its own parameter arguments that can be used to look up symtab constructs + // with generic + public AbstractObjectOfLanguage visitspecializedType(GNode n, boolean fromInstantiation) { + String name = getNameFromTypeName(getGNodeUnderConditional(n.getGeneric(0))); + + if(! fromInstantiation) { + temporaryValues.add(new TemporaryParameterValues()); + } + + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // typeArgumentList + + AbstractObjectOfLanguage typeObj = symtab.symtabLookup(scope.peek(), name, temporaryValues, definitionsVisitor, scope); + + if(! fromInstantiation) { + temporaryValues.pop(); + } + + return typeObj; + } + + public AbstractObjectOfLanguage visitheaderStackType(GNode n) { + return visitheaderStackType(n, false); + } + + public AbstractObjectOfLanguage visitheaderStackType(GNode n, boolean fromInstantiation) { + // since header stack type is just a regular header or specialized type with multiple + // instances (an array of headers) - https://p4.org/p4-spec/docs/P4-16-working-spec.html#sec-header-stacks + // TODO: we do not keep track of number of elements in the array + GNode firstChild = getGNodeUnderConditional(n.getGeneric(0)); + if(firstChild.getName() == "typeName") { + // TODO: right now the new header name is set to the same of the type itself and is placed under the original value scope + // ex: complex2.p4 + String name = getNameFromTypeName(firstChild); + AbstractObjectOfLanguage headerValue = symtab.symtabLookup(scope.peek(), name, temporaryValues, definitionsVisitor, scope); + customAssert(headerValue.getConstructType() == LObjectKind.HEADERTYPEDECLARATION || headerValue.getConstructType() == LObjectKind.HEADERUNIONDECLARATION); + // System.out.println("new header stack type: " + name + " creating under scope: " + headerValue.getName()); + HeaderStackType newHdrStack = p4LanguageObject.new HeaderStackType(name, headerValue, headerValue); + // symtab.addToSymtab(headerValue, name, newHdrStack); // will be re-adding the type that will cause an error + + InvokableLanguageKeyword next = p4LanguageObject.new InvokableLanguageKeyword("next", newHdrStack); + InvokableLanguageKeyword last = p4LanguageObject.new InvokableLanguageKeyword("last", newHdrStack); + InvokableLanguageKeyword lastIndex = p4LanguageObject.new InvokableLanguageKeyword("lastIndex", newHdrStack); + InvokableLanguageKeyword size = p4LanguageObject.new InvokableLanguageKeyword("size", newHdrStack); + FunctionPrototype pushFront = p4LanguageObject.new FunctionPrototype("push_front", newHdrStack, baseTypesCollection.getVoidLanguageObject()); + FunctionPrototype popFront = p4LanguageObject.new FunctionPrototype("pop_front", newHdrStack, baseTypesCollection.getVoidLanguageObject()); + symtab.addToSymtab(newHdrStack, "next", next); + symtab.addToSymtab(newHdrStack, "last", last); + symtab.addToSymtab(newHdrStack, "lastIndex", lastIndex); + symtab.addToSymtab(newHdrStack, "size", size); + symtab.addToSymtab(newHdrStack, "push_front", pushFront); + symtab.addToSymtab(newHdrStack, "pop_front", popFront); + + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // expression + + newHdrStack.setNode(n); + + return newHdrStack; + } else { + // specializedType + customAssert(firstChild.getName() == "specializedType"); + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // expression + AbstractObjectOfLanguage specializedType = (AbstractObjectOfLanguage) visitspecializedType(firstChild, fromInstantiation); + specializedType.setNode(n); + + return specializedType; + } + } + + public AbstractObjectOfLanguage visitvalueSetDeclaration(GNode n) { + AbstractObjectOfLanguage type; + String name = getStringUnderName(getGNodeUnderConditional(n.getGeneric(8))); + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // optAnnotations + AbstractObjectOfLanguage newobj = symtab.addToSymtab(scope.peek(), name); + scope.add(newobj); + + switch(getGNodeUnderConditional(n.getGeneric(3)).getName()) { + case "typeName": + String typeName = getNameFromTypeName(getGNodeUnderConditional(n.getGeneric(3))); + type = symtab.symtabLookup(scope.peek(), typeName, temporaryValues, definitionsVisitor, scope); + break; + case "baseType": + String baseTypeString = getBaseTypeAsString(getGNodeUnderConditional(n.getGeneric(3))); + type = baseTypesCollection.getLanguageObjectOfBaseType(baseTypeString); + break; + case "tupleType": + type = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(3))); + break; + } + dispatch(getGNodeUnderConditional(n.getGeneric(6))); // expression + + scope.pop(); + + newobj.setNode(n); + + return newobj; + } + + public AbstractObjectOfLanguage visitparserState(GNode n) { + String stateName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + customAssert(stateName != "accept" && stateName != "reject"); + AbstractObjectOfLanguage stateObj = symtab.addToSymtab(scope.peek(), stateName); + scope.add(stateObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(4))); // parserStatements + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // transitionStatement + + scope.pop(); + + stateObj.setNode(n); + + return stateObj; + + } + + public AbstractObjectOfLanguage visitstateExpression(GNode n) { + if(n.size() == 1) { // selectExpression; (name SEMICOLON is handled in callGraphVisitor) + return (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(0))); + } + return Symbols.getDefaultLanguageObject(); + } + + // TODO: check if we need to list table scope (if not, remove from callGraphGenerator as well) + // TODO: take care of MATCH_KIND and KEY ASSIGN production of tablepropertylist + public AbstractObjectOfLanguage visittableDeclaration(GNode n) { + String tableName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + AbstractObjectOfLanguage tableObj = symtab.addToSymtab(scope.peek(), tableName); + scope.add(tableObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(4))); // tablePropertyList + + // built in functions + EnumDeclaration actionList = p4LanguageObject.new EnumDeclaration("action_list", scope.peek()); + symtab.addToSymtab(scope.peek(), "action_list", actionList); + + InvokableLanguageKeyword applyKeyword = p4LanguageObject.new InvokableLanguageKeyword("apply", scope.peek()); + symtab.addToSymtab(scope.peek(), "apply", applyKeyword); + scope.add(applyKeyword); + + Variable hit = p4LanguageObject.new Variable("hit", scope.peek(), baseTypesCollection.getLanguageObjectOfBaseType("bool")); + Variable miss = p4LanguageObject.new Variable("miss", scope.peek(), baseTypesCollection.getLanguageObjectOfBaseType("bool")); + Variable actionRun = p4LanguageObject.new Variable("action_run", scope.peek(), actionList); + symtab.addToSymtab(scope.peek(), "hit", hit); + symtab.addToSymtab(scope.peek(), "miss", miss); + symtab.addToSymtab(scope.peek(), "action_run", actionRun); + + scope.pop(); + + scope.pop(); + + tableObj.setNode(n); + + return tableObj; + } + + public AbstractObjectOfLanguage visitconstantDeclaration(GNode n) { + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // optAnnotations + String name = getStringUnderName(getGNodeUnderConditional(n.getGeneric(3))); + AbstractObjectOfLanguage typeRefObj = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(2))); + typeRefObj = (typeRefObj.hasAssociatedType() ? typeRefObj.getType() : typeRefObj); + AbstractObjectOfLanguage constVariable = p4LanguageObject.new Variable(name, scope.peek(), typeRefObj); + if(typeRefObj.getConstructType() == LObjectKind.TYPEPARAMETER || typeRefObj.isGeneratorClass()) { + constVariable.setNode(n); + constVariable = p4LanguageObject.new VariableGenerator((Variable) constVariable); + } + symtab.addToSymtab(scope.peek(), name, constVariable); + scope.add(constVariable); + + AbstractObjectOfLanguage initializer = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(5))); + customAssert(!initializer.isGeneratorClass()); + if(constVariable.isGeneratorClass()) { + ((VariableGenerator) constVariable).setAssignedExpression(initializer); + } else { + ((Variable) constVariable).setAssignedExpression(initializer); + } + + scope.pop(); + + constVariable.setNode(n); + + return constVariable; + } + + public AbstractObjectOfLanguage visitaction(GNode n) { + dispatch(n.getGeneric(0)); // optAnnotations + + return (AbstractObjectOfLanguage) dispatch(n.getGeneric(1)); // return result of visitactionRef + } + + public AbstractObjectOfLanguage visitactionRef(GNode n) { + temporaryValues.add(new TemporaryParameterValues()); + String actionRefName = getStringUnderPrefixedNonTypeName(getGNodeUnderConditional(n.getGeneric(0))); + if(n.size() > 1) { + // actionRef production contains argumentlist + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // argumentList + } + + AbstractObjectOfLanguage callee = symtab.symtabLookup(scope.peek(), actionRefName, temporaryValues, definitionsVisitor, scope); + n.setProperty("callee", callee); + + temporaryValues.pop(); + + return callee; + } + + public AbstractObjectOfLanguage visitentry(GNode n) { + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // keysetExpression + + AbstractObjectOfLanguage actionRefObj = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(2))); + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // optAnnotations + + return actionRefObj; + } + + public AbstractObjectOfLanguage visitinstantiation(GNode n) { + int typeRefIndx = 0; + + if(n.getGeneric(0).getName() == "annotations") { + typeRefIndx = 1; + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // annotations + } + + temporaryValues.add(new TemporaryParameterValues()); + AbstractObjectOfLanguage typeRefObj; + dispatch(n.getGeneric(typeRefIndx + 2)); // argumentList + if(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(typeRefIndx)).getGeneric(0)).getName() == "specializedType") { + typeRefObj = visitspecializedType(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(typeRefIndx)).getGeneric(0)), true); + } else if (getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(typeRefIndx)).getGeneric(0)).getName() == "headerStackType") { + typeRefObj = visitheaderStackType(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(typeRefIndx)).getGeneric(0)), true); + } else { + typeRefObj = (AbstractObjectOfLanguage) dispatch(getGNodeUnderConditional(n.getGeneric(typeRefIndx))); + } + + String name = getStringUnderName(getGNodeUnderConditional(n.getGeneric(typeRefIndx+4))); + SubClass instantiationVar = p4LanguageObject.new SubClass(name, scope.peek(), typeRefObj); + symtab.addToSymtab(scope.peek(), name, instantiationVar); + + scope.add(instantiationVar); + + if(n.size() > typeRefIndx + 6) { + dispatch(getGNodeUnderConditional(n.getGeneric(typeRefIndx + 6))); // objInitializer + } + + scope.pop(); + + temporaryValues.pop(); + instantiationVar.setNode(n); + + return instantiationVar; + } + + public AbstractObjectOfLanguage visitdirectApplication(GNode n) { + // As per the grammar we can have only one typename before the `.apply`, so nesting can't happen + temporaryValues.add(new TemporaryParameterValues()); + + dispatch(getGNodeUnderConditional(n.getGeneric(4))); // argumentList + + String calleeName = getNameFromTypeName(getGNodeUnderConditional(n.getGeneric(0))); + + AbstractObjectOfLanguage callee = symtab.symtabLookup(scope.peek(), calleeName, temporaryValues, definitionsVisitor, scope); + + temporaryValues.pop(); + n.setProperty("callee", callee); + + return callee; + } + }; + + private Visitor callGraphVisitor = new Visitor() { + // default visitor + // For function calls, the values should be stored inside the called with the property name "callee" as it is already + // calculated during the type checking phase. + public Node visit(GNode n) { + // filtering out block that aren't supported yet and can cause silent failures + customAssert(! notExplicitlySupported.contains(n.getName()), n.getName() + " is not supported at the moment"); + + // just visiting the child nodes since no specific dispatch is available for current node + Iterator itr = n.iterator(); + while(itr.hasNext()) { + Object nextObj = itr.next(); + // customAssert((!nextObj.getClass().equals(PresenceCondition.class)) : "PresenceCondition nodes not supported at the moment. Under node: " + nextObj; + if(nextObj instanceof Syntax) { + // Since Syntax objects are not nodes + // System.out.println("It's a syntax obj: " + nextObj.toString()); + // System.out.println("tag: " + ((Language) nextObj).tag()); + continue; + } else if(nextObj instanceof PresenceCondition) { + // TODO handle PC scenarios under conditional nodes + + // customAssert(((PresenceCondition) nextObj).getAllConfigs().size() == 0 : "non-empty PresenceCondition nodes not supported at the moment"; + continue; + } + dispatch((Node) nextObj); + } + return n; + } + + public Node visitcontrolDeclaration(GNode n) { + // If need to parse parameters, visit the controltypedeclaration instead of static function to get name + String controlBlockName = getNameOfControlBlock(getGNodeUnderConditional(n.getGeneric(0))); + + AbstractObjectOfLanguage controlObj = symtab.symtabLookup(scope.peek(), controlBlockName, true, false, temporaryValues, definitionsVisitor, scope); + scope.add(controlObj); + + // skipping visiting controlTypeDeclaration + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // controlLocalDeclarations + String applyBlockName = n.get(4).toString(); + + // start parse controlBody + GNode oldN = n; + n = getGNodeUnderConditional(n.getGeneric(5)); // controlBody + AbstractObjectOfLanguage apply = symtab.symtabLookup(scope.peek(), applyBlockName, true, false, temporaryValues, definitionsVisitor, scope); + // lookupInSymTabAndAddAsCallee(applyBlockName); // TODO: ask if need to insert this as a callee? + scope.add(apply); + + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // controlBody can have only one child + + scope.pop(); + n = oldN; + //end parse controlBody + + scope.pop(); + return n; + } + + public Node visitactionDeclaration(GNode n) { + // Each action in the list of actions for a table must have a distinct name + String actionBlockName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + AbstractObjectOfLanguage actionObj = symtab.symtabLookup(scope.peek(), actionBlockName, true, false, temporaryValues, definitionsVisitor, scope); + scope.add(actionObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(4))); // parameterList + dispatch(getGNodeUnderConditional(n.getGeneric(6))); // blockStatement + + scope.pop(); + + return n; + } + + // Interesting: functionDeclaration not part of P416? not in online language specification -- experimental + // + public Node visitfunctionDeclaration(GNode n) { + Node functionPrototype = getGNodeUnderConditional(n.getGeneric(0)); + + dispatch(functionPrototype); + + customAssert(functionPrototype.hasProperty(nodeLanguageObjectPropertyString)); + AbstractObjectOfLanguage functionObj = (AbstractObjectOfLanguage) functionPrototype.getProperty(nodeLanguageObjectPropertyString); + scope.add(functionObj); + + // dispatch(getGNodeUnderConditional(n.getGeneric(0))); // functionPrototype (for parameters) + dispatch(getGNodeUnderConditional(n.getGeneric(1))); // blockstatement + + scope.pop(); + return n; + } + + public Node visitparserDeclaration(GNode n) { + String parserName = getStringUnderParserTypeDeclaration(getGNodeUnderConditional(n.getGeneric(0))); // TODO: take of parameter list here if needed to + AbstractObjectOfLanguage parserObj = symtab.symtabLookup(scope.peek(), parserName, true, false, temporaryValues, definitionsVisitor, scope); + scope.add(parserObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // parserLocalElements TODO: valueSetDeclaration needs to be traced for data flow + dispatch(getGNodeUnderConditional(n.getGeneric(4))); // parserStates + + scope.pop(); + + return n; + } + + public Node visitparserState(GNode n) { + String stateName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + + AbstractObjectOfLanguage stateObj = symtab.symtabLookup(scope.peek(), stateName, true, false, temporaryValues, definitionsVisitor, scope); + scope.add(stateObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(4))); // parserStatements + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // transitionStatement + + scope.pop(); + + return n; + + } + + public Node visitexternDeclaration(GNode n) { + if(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0))).getName() == "externFunctionDeclaration") { // generic dispatch + dispatch(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0)))); + return n; + } else { + if(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(2))).getName() == "nonTypeName") { + String externName = getStringUnderNonTypeName(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(2)))); + AbstractObjectOfLanguage externObj = symtab.symtabLookup(scope.peek(), externName, true, false, temporaryValues, definitionsVisitor, scope); + scope.add(externObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // optTypeParameters + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // methodPrototypes + + scope.pop(); + } else { + System.err.println("externDeclaration with the grammar: \"optAnnotations EXTERN name SEMICOLON\" is deprecated"); + System.exit(1); + } + + return n; + } + } + + public Node visitmethodPrototype(GNode n) { + /* methodPrototype + optAnnotations functionPrototype SEMICOLON + optAnnotations ABSTRACT functionPrototype SEMICOLON + constructorMethodPrototype + + constructorMethodPrototype: + optAnnotations TYPE_IDENTIFIER L_PAREN parameterList R_PAREN SEMICOLON + + Where last one is a constructor + */ + + if(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0))).getName() == "constructorMethodPrototype") { + dispatch(getGNodeUnderConditional(n.getGeneric(0))); + } else if(n.get(1) instanceof Syntax) { // keyword ABSTRACT + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // optAnnotations + GNode functionPrototypeNode = getGNodeUnderConditional(n.getGeneric(2)); + customAssert(functionPrototypeNode.hasProperty(nodeLanguageObjectPropertyString)); + + AbstractObjectOfLanguage functionObj = (AbstractObjectOfLanguage) functionPrototypeNode.getProperty(nodeLanguageObjectPropertyString); + scope.add(functionObj); + + dispatch(functionPrototypeNode); + + scope.pop(); + } else { + customAssert(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(1))).getName() == "functionPrototype", "unhandled case in method prototype"); + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // optAnnotations + GNode functionPrototypeNode = getGNodeUnderConditional(n.getGeneric(1)); + customAssert(functionPrototypeNode.hasProperty(nodeLanguageObjectPropertyString)); + AbstractObjectOfLanguage functionObj = (AbstractObjectOfLanguage) functionPrototypeNode.getProperty(nodeLanguageObjectPropertyString); + scope.add(functionObj); + + dispatch(functionPrototypeNode); + + scope.pop(); + } + + return n; + } + + public Node visitconstructorMethodPrototype(GNode n) { + String type_identifier = n.get(1).toString(); + + // methodPrototype -> constructorMethodPrototype is directly under parent extern scope + // so can retrieve the extern block's name from the scope + // TODO: check if there is a better way + + customAssert(type_identifier.equals(scope.peek().getName()), "Extern constructor not of the same name as extern block"); + AbstractObjectOfLanguage constructor = symtab.symtabLookup(scope.peek(), type_identifier, true, false, temporaryValues, definitionsVisitor, scope); + scope.add(constructor); + + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // parameterList + + scope.pop(); + + return n; + } + + public Node visitdirectApplication(GNode n) { + // As per the grammar we can have only one typename before the `.apply`, so nesting can't happen + customAssert(n.hasProperty("callee")); + addAsCallee((AbstractObjectOfLanguage) n.getProperty("callee")); + + temporaryValues.add(new TemporaryParameterValues()); + + dispatch(getGNodeUnderConditional(n.getGeneric(4))); // argumentList + + // String calleeName = getNameFromTypeName(getGNodeUnderConditional(n.getGeneric(0))); + + // lookupInSymTabAndAddAsCallee(calleeName); + + temporaryValues.pop(); + return n; + } + + public Node visitassignmentOrMethodCallStatement(GNode n) { + if(getGNodeUnderConditional(n.getGeneric(0)).getName() == "methodCallStatements") { + // method call statements + dispatch(getGNodeUnderConditional(n.getGeneric(0))); + } else { // TODO: make clear which production + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // lvalue + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // expression + } + + return n; + } + + public Node visitmethodCallStatements(GNode n) { + customAssert(n.hasProperty("callee")); + addAsCallee((AbstractObjectOfLanguage) n.getProperty("callee")); + + temporaryValues.add(new TemporaryParameterValues()); + + // There are two possible set of sub productions, both which have argument list under it + // but one has typeArgumentList before argument list, so argumentList is not at the same place + // hence check the size to see which production we are currently under and dispatching + // the visitor at the respective argumentList position + if(n.size() == 5) { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); //argumentlist + } else { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // typeArgumentList + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // argumentList + } + + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // lvalue + + // only legal value of lvalue for method call statements is prefixedNonTypeName + // with dot_name as lvalueExpressions cannot be used for method call statements + // AbstractObjectOfLanguage lvalueFinal = parseLValue(scope.peek(), getGNodeUnderConditional(n.getGeneric(0)), this); + // if(calleeMethodName == "this") { + // addAsCallee(getParentInstance(scope.peek())); + // } else { + // // lookupInSymTabAndAddAsCallee(calleeMethodName); + // addAsCallee(lvalueFinal); + // } + + + temporaryValues.pop(); + return n; + } + + // TODO: check if we need to list table scope (if not, remove from definitions dispatcher as well) + public Node visittableDeclaration(GNode n) { + String tableName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + AbstractObjectOfLanguage tableObj = symtab.symtabLookup(scope.peek(), tableName, true, false, temporaryValues, definitionsVisitor, scope); + scope.add(tableObj); + + dispatch(getGNodeUnderConditional(n.getGeneric(4))); // tablePropertyList + + scope.pop(); + + return n; + } + + public Node visitstateExpression(GNode n) { + if(n.size() == 2) { // name SEMICOLON + // TODO: need to handle keywords like accept or reject + String stateName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(0))); + lookupInSymTabAndAddAsCallee(stateName); + } else { // selectExpression; + dispatch(getGNodeUnderConditional(n.getGeneric(0))); + } + return n; + } + + public Node visitselectCase(GNode n) { + // TODO trace keysetExpression for data + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // keysetExpression + + String selectName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + lookupInSymTabAndAddAsCallee(selectName); + + return n; + } + + public Node visitaction(GNode n) { + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // optAnnotations + + dispatch(getGNodeUnderConditional(n.getGeneric(1))); // actionRef + + return n; + } + + public Node visitactionRef(GNode n) { + customAssert(n.hasProperty("callee")); + addAsCallee((AbstractObjectOfLanguage) n.getProperty("callee")); + + temporaryValues.add(new TemporaryParameterValues()); + String actionRefName = getStringUnderPrefixedNonTypeName(getGNodeUnderConditional(n.getGeneric(0))); + if(n.size() > 1) { + // actionRef production contains argumentlist + dispatch(getGNodeUnderConditional(n.getGeneric(2))); + } + + temporaryValues.pop(); + return n; + } + + public Node visitentry(GNode n) { + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // keysetExpression + + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // actionRef + dispatch(getGNodeUnderConditional(n.getGeneric(3))); // optAnnotations + + return n; + } + + public Node visitinvokingExpression(GNode n) { + customAssert(n.hasProperty("callee")); + addAsCallee((AbstractObjectOfLanguage) n.getProperty("callee")); + + temporaryValues.add(new TemporaryParameterValues()); + + GNode nGetGeneric0 = getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0))); + if(nGetGeneric0.getName() == "namedType") { + // one of three possible productions, starts with namedType + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // argumentList + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // namedType + } else { // first element pointing to name is an expression + if(n.size() == 4) { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // argumentList + } else { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // realTypeArgumentList + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // argumentList + } + + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // expression + } + + temporaryValues.pop(); + + return n; + } + + public Node visitinvokingNonBraceExpression(GNode n) { + customAssert(n.hasProperty("callee")); + addAsCallee((AbstractObjectOfLanguage) n.getProperty("callee")); + + temporaryValues.add(new TemporaryParameterValues()); + + GNode nGetGeneric0 = getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(0))); + if(nGetGeneric0.getName() == "namedType") { + // one of three possible productions, starts with namedType + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // argumentList + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // namedType + } else { // first element pointing to name is an expression + if(n.size() == 4) { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // argumentList + } else { + dispatch(getGNodeUnderConditional(n.getGeneric(2))); // realTypeArgumentList + dispatch(getGNodeUnderConditional(n.getGeneric(5))); // argumentList + } + + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // expression + } + + temporaryValues.pop(); + + return n; + } + + public Node visitinstantiation(GNode n) { + temporaryValues.add(new TemporaryParameterValues()); + int typeRefIndx = 0; + + if(n.getGeneric(0).getName() == "annotations") { + typeRefIndx = 1; + dispatch(getGNodeUnderConditional(n.getGeneric(0))); // annotations + } + + String instanceName = getStringUnderName(getGNodeUnderConditional(n.getGeneric(typeRefIndx + 4))); + + dispatch(getGNodeUnderConditional(n.getGeneric(typeRefIndx + 2))); // argumentList + AbstractObjectOfLanguage instanceType = symtab.symtabLookup(scope.peek(), instanceName, false, true, temporaryValues, definitionsVisitor, scope); + // AbstractObjectOfLanguage instanceType = symtab.symtabLookup(scope.peek(), instanceName); + + // customAssert(instanceType.getConstructType() == LObjectKind.SUBCLASS : instanceType.getName() + " has constructor: " + instanceType.getConstructType() + " instead of "; + + addAsCallee(symtab.getParameterTypeIfPresent(instanceType)); + + scope.add(instanceType); + if(n.size() > typeRefIndx + 6) { + dispatch(getGNodeUnderConditional(n.getGeneric(typeRefIndx + 6))); // optInitializer + } + scope.pop(); + temporaryValues.pop(); + + return n; + } + }; + + /** + * Given an actionRef node, gets the name of the mentioned action and returns that + * @param n actionRef node + * @return Returns the String present under the actionRef + */ + public String getNameUnderActionRef(GNode n) { + customAssert(n.getName() == "actionRef"); + + String actionRefName = getStringUnderPrefixedNonTypeName(getGNodeUnderConditional(n.getGeneric(0))); + + return actionRefName; + } + + /** + * Handles possible expressions that can be used to invoke an entity. + * + * Specifically invoked when the expression is inside an invoking expression + * and is invoking a previously declared entity (callee). + * Handles those possible expressions, including namespacing if present, and adds + * the invoked entity as a call to the current scope object. + * + * nonTypeName, dotPrefix nonTypeName, typeName dot_name, expression dot_name + * Note: `NOT expression` will be taken care of by recursion + * @param n + * @return + */ + public AbstractObjectOfLanguage getCalleeFromExpression(GNode n, Visitor visitor) { + Iterator itr = n.iterator(); + AbstractObjectOfLanguage finalValue = null; + AbstractObjectOfLanguage localScope = scope.peek(); + while(itr.hasNext()) { + Node next = (Node) itr.next(); + if(next instanceof Syntax) { + if(next.toString() == "!") { + continue; + } else if(next.toString() == "this") { + finalValue = getParentInstance(localScope); + localScope = finalValue; + } else if(next.toString() == "[") { + // System.err.println("encountered ["); + visitor.dispatch(getGNodeUnderConditional((GNode) itr.next())); + Object nextVal = getValueUnderConditional((GNode) itr.next()); + if(nextVal.toString() == ":") { + visitor.dispatch(getGNodeUnderConditional((GNode) itr.next())); + nextVal = getValueUnderConditional((GNode) itr.next()); + } + customAssert(nextVal.toString() == "]"); + } else if(next.toString() == "(") { + // casting -> production: L_PAREN typeRef R_PAREN expression %prec PREFIX + // return the value under the last expression value + return getCalleeFromExpression(getGNodeUnderConditional(n.getGeneric(3)), visitor); + } else { + customAssert(false, "Encountered an invalid expression when expecting something to be invoked (" + next.toString() + ")"); + } + continue; + } + + Object underConditional = getValueUnderConditional((GNode) next); + if(underConditional instanceof Syntax) { + if(underConditional.toString() == "!") { + continue; + } else if(underConditional.toString() == "this") { + finalValue = getParentInstance(localScope); + localScope = finalValue; + } else if(underConditional.toString() == "[") { + // System.err.println("encountered ["); + visitor.dispatch(getGNodeUnderConditional((GNode) itr.next())); + Object nextVal = getValueUnderConditional((GNode) itr.next()); + if(nextVal.toString() == ":") { + visitor.dispatch(getGNodeUnderConditional((GNode) itr.next())); + nextVal = getValueUnderConditional((GNode) itr.next()); + } + customAssert(nextVal.toString() == "]"); + } else if(underConditional.toString() == "(") { + // casting -> production: L_PAREN typeRef R_PAREN expression %prec PREFIX + // return the value under the last expression value + return getCalleeFromExpression(getGNodeUnderConditional(n.getGeneric(3)), visitor); + } else { + customAssert(false, "Encountered an invalid expression when expecting something to be invoked (" + underConditional.toString() + ")"); + } + continue; + } + + GNode childNode = (GNode) underConditional; + switch(childNode.getName()) { + case "expression": + finalValue = getCalleeFromExpression(childNode, visitor); + localScope = finalValue; + customAssert(getGNodeUnderConditional(n.getGeneric(1)).getName() == "dot_name", "Not an invoking expression"); + break; + case "nonTypeName": + // nonTypeName + AbstractObjectOfLanguage lookup = symtab.nonTypeNameSymtabLookUp(localScope, getStringUnderNonTypeName(getGNodeUnderConditional(childNode)), false, temporaryValues, definitionsVisitor, scope); + + finalValue = lookup; + localScope = lookup; + break; + case "dotPrefix": + // dotPrefix nonTypeName + // continuing because the while loop will reach nonTypeName + customAssert(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(1))).getName() == "nonTypeName"); + // System.out.println("dot prefix"); + childNode = getGNodeUnderConditional((GNode) itr.next()); + customAssert(childNode.getName() == "nonTypeName"); + AbstractObjectOfLanguage lookupNonTypeName = symtab.nonTypeNameSymtabLookUp(localScope, getStringUnderNonTypeName(getGNodeUnderConditional(childNode)), false, temporaryValues, definitionsVisitor, scope); + + return lookupNonTypeName; + case "typeName": + // typeName dot_name + // doing namespacing + AbstractObjectOfLanguage typeNameLO = symtab.symtabLookup(localScope, getNameFromTypeName(getGNodeUnderConditional(n.getGeneric(0))), temporaryValues, definitionsVisitor, scope); + customAssert(typeNameLO.getConstructType() != LObjectKind.TYPEPARAMETER); + + localScope = typeNameLO; + finalValue = typeNameLO; + break; + case "dot_name": + String dotNameString = getStringUnderDotName(childNode); + AbstractObjectOfLanguage nameObj = symtab.symtabLookup(localScope, dotNameString, temporaryValues, definitionsVisitor, scope); + + finalValue = nameObj; + localScope = finalValue; + break; + case "invokingExpression": + Object invokingExpressionResult = visitor.dispatch(childNode); + if(invokingExpressionResult instanceof AbstractObjectOfLanguage) { + finalValue = localScope = (AbstractObjectOfLanguage) invokingExpressionResult; + } + break; + default: + customAssert(false, childNode.getName() + "::Encountered a situation where expression inside invoking expression was not of expected value"); + } + } + customAssert(finalValue != null); + customAssert(finalValue.getConstructType() != LObjectKind.TYPEPARAMETER); + return finalValue; + } + + /** + * Handles possible expressions that can be used to invoke an entity. + * Similar to getCalleeFromExpression + * + * Specifically invoked when the expression is inside an invoking expression + * and is invoking a previously declared entity (callee). + * Handles those possible expressions, including namespacing if present, and adds + * the invoked entity as a call to the current scope object. + * @param n + * @return + */ + // TODO: update to be similar as expression + public AbstractObjectOfLanguage getCalleeFromNonBraceExpression(GNode n, Visitor visitor) { + Iterator itr = n.iterator(); + AbstractObjectOfLanguage finalValue = null; + AbstractObjectOfLanguage localScope = scope.peek(); + while(itr.hasNext()) { + Node next = (Node) itr.next(); + if(next instanceof Syntax) { + if(next.toString() == "!") { + continue; + } else if(next.toString() == "this") { + finalValue = getParentInstance(localScope); + localScope = finalValue; + } else if(next.toString() == "[") { + // System.err.println("encountered ["); + visitor.dispatch(getGNodeUnderConditional((GNode) itr.next())); + Object nextVal = getValueUnderConditional((GNode) itr.next()); + if(nextVal.toString() == ":") { + visitor.dispatch(getGNodeUnderConditional((GNode) itr.next())); + nextVal = getValueUnderConditional((GNode) itr.next()); + } + customAssert(nextVal.toString() == "]"); + } else if(next.toString() == "(") { + // casting -> production: L_PAREN typeRef R_PAREN expression %prec PREFIX + // return the value under the last expression value + return getCalleeFromExpression(getGNodeUnderConditional(n.getGeneric(3)), visitor); + } else { + customAssert(false, "Encountered an invalid expression when expecting something to be invoked (" + next.toString() + ")"); + } + continue; + } + + Object underConditional = getValueUnderConditional((GNode) next); + if(underConditional instanceof Syntax) { + if(underConditional.toString() == "!") { + continue; + } else if(underConditional.toString() == "this") { + finalValue = getParentInstance(localScope); + localScope = finalValue; + } else if(underConditional.toString() == "[") { + // System.err.println("encountered ["); + visitor.dispatch(getGNodeUnderConditional((GNode) itr.next())); + Object nextVal = getValueUnderConditional((GNode) itr.next()); + if(nextVal.toString() == ":") { + visitor.dispatch(getGNodeUnderConditional((GNode) itr.next())); + nextVal = getValueUnderConditional((GNode) itr.next()); + } + customAssert(nextVal.toString() == "]"); + } else if(underConditional.toString() == "(") { + // casting -> production: L_PAREN typeRef R_PAREN expression %prec PREFIX + // return the value under the last expression value + return getCalleeFromExpression(getGNodeUnderConditional(n.getGeneric(3)), visitor); + } else { + customAssert(false, "Encountered an invalid expression when expecting something to be invoked (" + underConditional.toString() + ")"); + } + continue; + } + + GNode childNode = (GNode) underConditional; + switch(childNode.getName()) { + case "nonBraceExpression": + finalValue = getCalleeFromNonBraceExpression(childNode, visitor); + localScope = finalValue; + customAssert(getGNodeUnderConditional(n.getGeneric(1)).getName() == "dot_name", "Not an invoking expression"); + break; + case "nonTypeName": + // nonTypeName + AbstractObjectOfLanguage lookup = symtab.nonTypeNameSymtabLookUp(localScope, getStringUnderNonTypeName(getGNodeUnderConditional(childNode)), false, temporaryValues, definitionsVisitor, scope); + + finalValue = lookup; + localScope = lookup; + break; + case "dotPrefix": + // dotPrefix nonTypeName + // continuing because the while loop will reach nonTypeName + customAssert(getGNodeUnderConditional(getGNodeUnderConditional(n.getGeneric(1))).getName() == "nonTypeName"); + // System.out.println("dot prefix"); + childNode = getGNodeUnderConditional((GNode) itr.next()); + customAssert(childNode.getName() == "nonTypeName"); + AbstractObjectOfLanguage lookupNonTypeName = symtab.nonTypeNameSymtabLookUp(localScope, getStringUnderNonTypeName(getGNodeUnderConditional(childNode)), false, temporaryValues, definitionsVisitor, scope); + + return lookupNonTypeName; + case "typeName": + // typeName dot_name + // doing namespacing + AbstractObjectOfLanguage typeNameLO = symtab.symtabLookup(localScope, getNameFromTypeName(getGNodeUnderConditional(n.getGeneric(0))), temporaryValues, definitionsVisitor, scope); + customAssert(typeNameLO.getConstructType() != LObjectKind.TYPEPARAMETER); + + localScope = typeNameLO; + finalValue = typeNameLO; + break; + case "dot_name": + String dotNameString = getStringUnderDotName(childNode); + AbstractObjectOfLanguage nameObj = symtab.symtabLookup(localScope, dotNameString, temporaryValues, definitionsVisitor, scope); + + finalValue = nameObj; + localScope = finalValue; + break; + case "invokingExpression": + Object invokingExpressionResult = visitor.dispatch(childNode); + if(invokingExpressionResult instanceof AbstractObjectOfLanguage) { + finalValue = localScope = (AbstractObjectOfLanguage) invokingExpressionResult; + } + break; + default: + customAssert(false, childNode.getName() + "::Encountered a situation where expression inside invoking expression was not of expected value"); + } + } + customAssert(finalValue != null); + customAssert(finalValue.getConstructType() != LObjectKind.TYPEPARAMETER); + return finalValue; + } + + // This is currently used because certain nodes will be wrapped under an empty conditional + // Modify this to track with conditional branch information + public GNode getGNodeUnderConditional(GNode n) { + Object receivedValue = getValueUnderConditional(n); + customAssert(receivedValue instanceof GNode, "Got " + receivedValue.toString()); + + return (GNode) receivedValue; + } + + public Object getValueUnderConditional(Object givenNode) { + if(givenNode instanceof Syntax) { + return givenNode; + } + + GNode n = (GNode) givenNode; + + if(n.getName() == "Conditional") { + // since first child is the presence condition + return n.get(1); + } else { + return n; + } + } + + public String getStringUnderNamedType(GNode n) { + customAssert(n.getName() == "namedType"); + + if(getGNodeUnderConditional(n.getGeneric(0)).getName() == "typeName") { // typeName + return getNameFromTypeName(getGNodeUnderConditional(n.getGeneric(0))); + } else { //specializedType + return getStringUnderSpecializedTypeName(getGNodeUnderConditional(n.getGeneric(0))); + } + } + + public String getStringUnderSpecializedTypeName(GNode n) { + customAssert(n.getName() == "specializedType"); + + // TODO: take care of typeArgumentList + + return getNameFromTypeName(getGNodeUnderConditional(n.getGeneric(0))); + } + + public String getNameFromTypeName(GNode n) { + customAssert(n.getName() == "typeName"); + + // only child is prefixedType and that is used only under typeName + n = getGNodeUnderConditional(n.getGeneric(0)); + + // prefixedType can have just TYPE_IDENTIFIER or can be prefixed with a dot + if(n.size() > 1) { + // prefixed with a dot + // TODO: handle cases where .TYPE_IDENTIFIER means something under scope + return n.get(1).toString(); + } else { + return n.get(0).toString(); + } + } + + public String getNameOfControlBlock(GNode n) { + customAssert(n.getName() == "controlTypeDeclaration"); + + // Third child node is the `name` construct + return getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + } + + // TODO: !! (need to change AbstractObjectOfLanguage to include which construct each symbol is from) + public void ensureDotValueIsOnlySpecificConstructs(GNode n) { + customAssert(true); + } + + public String getStringUnderName(GNode n) { + customAssert(n.getName() == "name"); + + // child is either nonTypeName or TYPE_IDENTIFIER + if(n.get(0) instanceof Syntax) { + // TYPE_IDENTIFIER + return n.get(0).toString(); + } else { + // nonTypeName + return getStringUnderNonTypeName(getGNodeUnderConditional(n.getGeneric(0))); + } + } + + public String getStringUnderNonTypeName(GNode n) { + customAssert(n.getName() == "nonTypeName"); + // System.out.println(n.toString()); + // System.out.println(n.get(0)); + // System.out.println(((Language) n.get(0)).tag()); + // only terminals under nonTypeName, but right now only handling IDENTIFIER tokens, not reserved keywords + // customAssert((P4Tag.IDENTIFIER == ((Language) n.get(0)).tag() || n.get(0).toString() == "apply") : "non-IDENTIFIER terminals not supported under nonTypeName atm"; + return n.get(0).toString(); + } + + public String getStringUnderPrefixedNonTypeName(GNode n) { + customAssert(n.getName() == "prefixedNonTypeName"); + customAssert(! ((GNode) getGNodeUnderConditional(n.getGeneric(0))).getName().equals("dotPrefix"), "Retrieving nontypenames with a dot as a prefix not supported yet"); + + return getStringUnderNonTypeName(getGNodeUnderConditional(n.getGeneric(0))); + } + + public AbstractObjectOfLanguage getParentInstance(AbstractObjectOfLanguage localScope) { + // System.out.println("Trying to find parent of: " + localScope.getName() + " with now constructor as: " + localScope.getConstructType()); + if(localScope.getConstructType() == LObjectKind.SUBCLASS) { + customAssert(((SubClass) localScope).getOriginalClass().getConstructType() == LObjectKind.EXTERNDECLARATION); + return ((SubClass) localScope).getOriginalClass(); + } else { + customAssert(localScope.getConstructType() != LObjectKind.BASETYPE && + localScope.getConstructType() != LObjectKind.ANONYMOUS && + localScope.getConstructType() != LObjectKind.CONSTANTVALUE); + if(localScope.getConstructType() == LObjectKind.EXTERNDECLARATION) { + return localScope; + } + return getParentInstance(localScope.getNameSpace()); + } + } + + public ArrayList parseparsedOptTypeParameters(GNode n, Visitor visitor) { + ArrayList parsedOptTypeParameters = new ArrayList<>(); + customAssert(n.getName() == "realTypeArgumentList"); + + Iterator itr = n.iterator(); + while(itr.hasNext()) { + Object nextVal = getValueUnderConditional(itr.next()); + if(nextVal instanceof Syntax) { + // COMMA + continue; + } + + GNode nextChild = (GNode) nextVal; + parsedOptTypeParameters.add((AbstractObjectOfLanguage) visitor.dispatch(nextChild)); + } + + return parsedOptTypeParameters; + } + + /** + * Parses and type checks the values present inside lvalue constructs (goes through nested namespace) + * @param localScope + * @param n + * @param visitor + * @return null if it is a lvalueExpression + * TODO: need to handle cases like .apply() + */ + public AbstractObjectOfLanguage parseLValue(AbstractObjectOfLanguage localScope, GNode n, Visitor visitor) { + if(n.get(0) instanceof Syntax) { // keyword "THIS" + customAssert(n.get(0).toString() == "this"); + return getParentInstance(localScope); + } + + Iterator nit = n.iterator(); + AbstractObjectOfLanguage finalValue = null; + GNode childNode = getGNodeUnderConditional(n.getGeneric(0)); + + for(int i = 1; i < n.size() + 1; i++) { + // System.out.println("child name: " + childNode.getName()); + switch(childNode.getName()) { + case "prefixedNonTypeName": + // has to be "Identifiers of a base or derived type." (https://p4.org/p4-spec/docs/P4-16-working-spec.html#sec-lvalues) + String name = getStringUnderPrefixedNonTypeName(childNode); + return symtab.symtabLookup(localScope, name, temporaryValues, definitionsVisitor, scope); + case "lvalue": + AbstractObjectOfLanguage leftSideValue = parseLValue(localScope, childNode, visitor); // has to devolve into prefixedNonTypeName + customAssert(leftSideValue != null, "Undefined value used"); + localScope = leftSideValue; + finalValue = leftSideValue; + break; + case "dot_name": + String dotValueObjName = getStringUnderName(childNode.getGeneric(1)); + // System.out.println("dot value looking up name: " + dotValueObjName + " under scope: " + localScope.getName()); + AbstractObjectOfLanguage dotValueObject = symtab.symtabLookup(localScope, dotValueObjName, temporaryValues, definitionsVisitor, scope); + finalValue = dotValueObject; + localScope = dotValueObject; + // System.out.println("new dot name scope: " + dotValueObject.getName()); + // switch(localScope.getConstructType()) { + // case STRUCTTYPEDECLARATION: + // case HEADERTYPEDECLARATION: + // case HEADERUNIONDECLARATION: + // break; + // default: + // // System.err.println("Type error, referring to undefined value: " + childNode.getName()); + // customAssert(false : "Type error for dot values, referring to construct: " + scope.peek().getConstructType(); + // System.exit(1); + // } + break; + case "lvalueExpression": + // scope.add(localScope); + visitor.dispatch(childNode.getGeneric(1)); + if(childNode.size() > 3) { + visitor.dispatch(childNode.getGeneric(3)); + } + // scope.pop(); + break; + default: + // System.err.println("Unexpected case when parsing l-value. Value: " + childNode.getName()); + customAssert(false, "Unexpected case when parsing l-value. Value: " + childNode.getName()); + System.exit(1); + } + + if(i < n.size()) + childNode = (GNode) n.get(i); + } + + if(finalValue == null) { + customAssert(false, "Undefined value accessed : " + n.getName()); + } + return finalValue; + } + + /** + * Takes in parameterList node and return true if any of them have a generic type + * @param n + * @return + */ + public boolean isAnyParameterGeneric(GNode n, GNode optTypeParameters) { + customAssert(n.getName() == "parameterList"); + customAssert(optTypeParameters.getName() == "optTypeParameters"); + + if(n.size() == 0) { + return false; + } + + Iterator itr; + + ArrayList typeParams = new ArrayList<>(); + if(optTypeParameters.size() != 0) { + // typeParameterList iterator + itr = getGNodeUnderConditional(getGNodeUnderConditional(optTypeParameters.getGeneric(0)).getGeneric(1)).iterator(); + while(itr.hasNext()) { + Object next = itr.next(); + if(next instanceof Syntax || getValueUnderConditional(next) instanceof Syntax) { + // COMMA + continue; + } + GNode name = getGNodeUnderConditional((GNode) next); + customAssert(name.getName() == "name"); + typeParams.add(getStringUnderName(name)); + } + } + + + GNode nonEmptyParameterList = getGNodeUnderConditional(n.getGeneric(0)); + itr = nonEmptyParameterList.iterator(); + while(itr.hasNext()) { + Object next = itr.next(); + if(next instanceof Syntax || getValueUnderConditional(next) instanceof Syntax) { + // COMMA + continue; + } + GNode parameter = getGNodeUnderConditional((GNode) next); + GNode typeRef = getGNodeUnderConditional(getGNodeUnderConditional(parameter.getGeneric(2)).getGeneric(0)); + AbstractObjectOfLanguage typeObj; + String typeName; + switch(typeRef.getName()) { + case "typeName": + typeName = getNameFromTypeName(typeRef); + typeObj = symtab.symtabLookupIfExists(scope.peek(), typeName, true, true, temporaryValues, definitionsVisitor, scope); + // Since type names point directly to the type and not a instance of that type - + // Update: generic-struct.p4i - the type can be a typedef + // customAssert(!typeObject.hasAssociatedType() : typeObject.getName() + "of constructor: " + typeObject.getConstructType() + " with type: " + typeObject.getType().getName() + " of constructor: " + typeObject.getType().getConstructType(); + break; + case "baseType": + typeName = getBaseTypeAsString(typeRef); + typeObj = baseTypesCollection.getLanguageObjectOfBaseType(typeName); + break; + case "specializedType": + typeName = getStringUnderSpecializedTypeName(typeRef); + typeObj = symtab.symtabLookupIfExists(scope.peek(), typeName, true, true, temporaryValues, definitionsVisitor, scope); + break; + case "headerStackType": + typeName = getStringUnderHeaderStackType(typeRef); + typeObj = symtab.symtabLookupIfExists(scope.peek(), typeName, true, true, temporaryValues, definitionsVisitor, scope); + break; + case "tupleType": + typeObj = Symbols.getDefaultLanguageObject(); + typeName = ""; + break; + default: + System.err.println("Unhandled new case for typeRef: " + typeRef.getName()); + System.exit(1); + typeObj = Symbols.getDefaultLanguageObject(); + typeName = ""; + } + + if(typeObj.isGeneratorClass() || typeObj.getConstructType() == LObjectKind.TYPEPARAMETER || + (typeObj.hasAssociatedType() && typeObj.getType().isGeneratorClass())) { + return true; + } else if(typeObj == Symbols.getDefaultLanguageObject() && typeParams.contains(typeName)) { + return true; + } + + } + + return false; + } + + public String getTypeStringUnderTypeRef(GNode n) { + customAssert(n.getName() == "typeRef"); + + switch(getGNodeUnderConditional(n.getGeneric(0)).getName()) { + case "typeName": + return getNameFromTypeName(getGNodeUnderConditional(n.getGeneric(0))); + case "baseType": + return getBaseTypeAsString(getGNodeUnderConditional(n.getGeneric(0))); + case "specializedType": + return LObjectKind.SPECIALIZEDTYPE.toString(); + case "headerStackType": + return LObjectKind.HEADERSTACKTYPE.toString(); + case "tupleType": + return LObjectKind.TUPLETYPE.toString(); + default: + System.err.println("Unhandled new case for typeRef"); + System.exit(1); + } + + return "Unhandled case under type ref"; + } + + public String getBaseTypeAsString(GNode n) { + customAssert(n.getName() == "baseType"); + + // handle expressions within basetype + return n.get(0).toString(); + } + + public String getStringUnderHeaderStackType(GNode n) { + customAssert(n.getName() == "headerStackType"); + + // TODO: handle expression inside + if(getGNodeUnderConditional(n.getGeneric(0)).getName() == "typeName") { + return getNameFromTypeName(getGNodeUnderConditional(n.getGeneric(0))); + } else if(getGNodeUnderConditional(n.getGeneric(0)).getName() == "specializedType") { + return getStringUnderSpecializedTypeName(getGNodeUnderConditional(n.getGeneric(0))); + } else { + System.err.println("Unhandled header stack type case"); + System.exit(1); + } + + return "Unhandled case under header stack type"; + } + + public String getStringUnderDotName(GNode n) { + return getStringUnderName(getGNodeUnderConditional(n.getGeneric(1))); + } + + public String getStringUnderFunctionPrototype(GNode n) { + customAssert(n.getName() == "functionPrototype"); + + return getStringUnderName(getGNodeUnderConditional(n.getGeneric(1))); + } + + public String getStringUnderParserTypeDeclaration(GNode n) { + customAssert(n.getName() == "parserTypeDeclaration"); + + return getStringUnderName(getGNodeUnderConditional(n.getGeneric(2))); + } + + public String getStringUnderActionRef(GNode n) { + customAssert(n.getName() == "actionRef"); + + String prefixedNonTypeName = getStringUnderPrefixedNonTypeName(getGNodeUnderConditional(n.getGeneric(0))); + + // TODO: parse argumentList? + + return prefixedNonTypeName; + } + + public int getParameterSize(GNode n, boolean subtractDefaultValues) { + customAssert(n.getName() == "parameterList"); + + if(n.size() == 0) { + return 0; + } + + GNode nonEmptyParameterList = getGNodeUnderConditional(n.getGeneric(0)); + int counter = 0; + int defaultValues = 0; + + Iterator itr = nonEmptyParameterList.iterator(); + while(itr.hasNext()) { + Object next = itr.next(); + + if(next instanceof Syntax || getValueUnderConditional(next) instanceof Syntax) { + // Comma + continue; + } + + customAssert(next instanceof GNode); + customAssert(getGNodeUnderConditional((GNode) next).getName() == "parameter", getGNodeUnderConditional((GNode) next).getName()); + counter += 1; + if(getGNodeUnderConditional((GNode) next).size() == 6) { + defaultValues += 1; + } + } + + return subtractDefaultValues ? (counter - defaultValues) : counter; + } + + public int getParameterSizeWithoutDefaultValues(GNode n) { + return getParameterSize(n, true); + } + + public void printCallGraph() { + ArrayList sortedSymtabKeys = new ArrayList<>(symtab.getSymTab().keySet()); + Collections.sort(sortedSymtabKeys); + for(AbstractObjectOfLanguage key : sortedSymtabKeys) { + // FunctionPrototypePlaceholder is just a value to mask function name mangling + if(key.getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + continue; + } + System.out.println(key.toStringExtensive(symtab.getSymTab(), callGraphObject, Symbols.getGlobalScope())); + } + // System.out.println(callGraphObject); + } + + public String toDot() { + String dotFormat = ""; + for(AbstractObjectOfLanguage key : symtab.getSymTab().keySet()) { + if(key.getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + // FunctionPrototypePlaceholder is just a value to mask function name mangling + continue; + } + dotFormat += key.toDotString(symtab.getSymTab(), callGraphObject, Symbols.getGlobalScope()); + } + + // System.out.println(dotFormat); + return dotFormat; + } + + public static void createDotGraph(String dotFormat,String fileName) { + String check = "{rank=same; a1, b1 } {rank=same; a2, b2 } a1 [label=\"This calls\"] a2 [label=\"This defines\"] b1 [label=\"this\"] b2 [label=\"this\"] a1 -> b1 [ minlen=4 ] a2 -> b2 [ style=dashed, color=blue, minlen=4 ]"; + dotFormat += check; + GraphViz gv=new GraphViz(); + gv.addln(gv.start_graph()); + gv.add(dotFormat); + gv.addln(gv.end_graph()); + // String type = "gif"; + String type = "pdf"; + // gv.increaseDpi(); + gv.decreaseDpi(); + gv.decreaseDpi(); + // System.out.println(gv.toString()); + File out = new File(fileName+"."+ type); + gv.writeGraphToFile( gv.getGraph( gv.getDotSource(), type ), out ); + } + + public void customAssert(boolean condition) { + customAssert(condition, "Assertion Error."); + } + + public void customAssert(boolean condition, String errorMessage) { + assert condition : errorMessage; + if(! condition) { + System.err.println(errorMessage); + System.exit(1); + } + } + +} + +// Notes: +/* +L-value (lvalue) has a production that uses namespace to retrieve certain values (using the dot notation). +According to the language specification (section 6.6), only structure, header, and header union field member access operations +can happen using the dot notation. And none of productions can contain any type of function declaration and nothing inside those +productions can be invoked. +Hence it isn't necessary to traverse lvalue for call graphs, but is necessary for data flow analysis. + + +None of the grammar constructs (control, action, function, and parser) that define invokable blocks allow for nested declarations of the same type inside themselves. + +Expressions. +Possible expressions that can be present in an invocation (invokingExpression). +nonTypeName, dotPrefix nonTypeName, typeName dot_name, expression dot_name +Note: `NOT expression` will be taken care of by recursion +Note: Multiple declarations of same name: cannot occur. +Note: Overloading is possible for functions and method (language specification, 7.2.9.2) +*/ \ No newline at end of file diff --git a/src/superc/p4parser/GraphViz.java b/src/superc/p4parser/GraphViz.java new file mode 100644 index 00000000..46298881 --- /dev/null +++ b/src/superc/p4parser/GraphViz.java @@ -0,0 +1,369 @@ +// GraphViz.java - a simple API to call dot from Java programs +// from: https://stackoverflow.com/questions/26481910/how-to-call-graphviz-from-java/26497613 +/*$Id$*/ +/* + ****************************************************************************** + * * + * (c) Copyright Laszlo Szathmary * + * * + * This program is free software; you can redistribute it and/or modify it * + * under the terms of the GNU Lesser General Public License as published by * + * the Free Software Foundation; either version 2.1 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, but * + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public * + * License for more details. * + * * + * You should have received a copy of the GNU Lesser General Public License * + * along with this program; if not, write to the Free Software Foundation, * + * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * + * * + ****************************************************************************** + */ +package superc.p4parser; +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.DataInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.FileWriter; +import java.io.InputStreamReader; +import java.util.Properties; +import java.io.FileNotFoundException; + + +/** + *
+ *
Purpose: GraphViz Java API + *
+ * + *
Description: + *
With this Java class you can simply call dot + * from your Java programs. + *
Example usage: + *
+ * 
+ *    GraphViz gv = new GraphViz();
+ *    gv.addln(gv.start_graph());
+ *    gv.addln("A -> B;");
+ *    gv.addln("A -> C;");
+ *    gv.addln(gv.end_graph());
+ *    System.out.println(gv.getDotSource());
+ *
+ *    String type = "gif";
+ *    File out = new File("out." + type);   // out.gif in this example
+ *    gv.writeGraphToFile( gv.getGraph( gv.getDotSource(), type ), out );
+ *
+ *
+ * + *
+ * + * @version v0.5.1, 2013/03/18 (March) -- Patch of Juan Hoyos (Mac support) + * @version v0.5, 2012/04/24 (April) -- Patch of Abdur Rahman (OS detection + start subgraph + + * read config file) + * @version v0.4, 2011/02/05 (February) -- Patch of Keheliya Gallaba is added. Now you + * can specify the type of the output file: gif, dot, fig, pdf, ps, svg, png, etc. + * @version v0.3, 2010/11/29 (November) -- Windows support + ability to read the graph from a text file + * @version v0.2, 2010/07/22 (July) -- bug fix + * @version v0.1, 2003/12/04 (December) -- first release + * @author Laszlo Szathmary (jabba.laci@gmail.com) + */ +public class GraphViz +{ + /** + * Detects the client's operating system. + */ + private final static String osName = System.getProperty("os.name").replaceAll("\\s",""); + + /** + * Load the config.properties file. + */ + private final static String cfgProp = System.getenv("JAVA_DEV_ROOT") + "/src/superc/p4parser/config.properties"; + private final static Properties configFile = new Properties() { + private final static long serialVersionUID = 1L; { + try { + load(new FileInputStream(cfgProp)); + } catch (Exception e) {} + } + }; + + /** + * The dir. where temporary files will be created. + */ + private static String TEMP_DIR = System.getenv("JAVA_DEV_ROOT") + "/src/superc/p4parser/tmp/"; + + /** + * Where is your dot program located? It will be called externally. + */ + private static String DOT = configFile.getProperty("dotFor" + osName); + + /** + * The image size in dpi. 96 dpi is normal size. Higher values are 10% higher each. + * Lower values 10% lower each. + * + * dpi patch by Peter Mueller + */ + private int[] dpiSizes = {46, 51, 57, 63, 70, 78, 86, 96, 106, 116, 128, 141, 155, 170, 187, 206, 226, 249}; + + /** + * Define the index in the image size array. + */ + private int currentDpiPos = 7; + + /** + * Increase the image size (dpi). + */ + public void increaseDpi() { + if ( this.currentDpiPos < (this.dpiSizes.length - 1) ) { + ++this.currentDpiPos; + } + } + + /** + * Decrease the image size (dpi). + */ + public void decreaseDpi() { + if (this.currentDpiPos > 0) { + --this.currentDpiPos; + } + } + + public int getImageDpi() { + return this.dpiSizes[this.currentDpiPos]; + } + + /** + * The source of the graph written in dot language. + */ + private StringBuilder graph = new StringBuilder(); + + /** + * Constructor: creates a new GraphViz object that will contain + * a graph. + */ + public GraphViz() { + } + + /** + * Returns the graph's source description in dot language. + * @return Source of the graph in dot language. + */ + public String getDotSource() { + return this.graph.toString(); + } + + /** + * Adds a string to the graph's source (without newline). + */ + public void add(String line) { + this.graph.append(line); + } + + /** + * Adds a string to the graph's source (with newline). + */ + public void addln(String line) { + this.graph.append(line + "\n"); + } + + /** + * Adds a newline to the graph's source. + */ + public void addln() { + this.graph.append('\n'); + } + + public void clearGraph(){ + this.graph = new StringBuilder(); + } + + /** + * Returns the graph as an image in binary format. + * @param dot_source Source of the graph to be drawn. + * @param type Type of the output image to be produced, e.g.: gif, dot, fig, pdf, ps, svg, png. + * @return A byte array containing the image of the graph. + */ + public byte[] getGraph(String dot_source, String type) + { + File dot; + byte[] img_stream = null; + + try { + dot = writeDotSourceToFile(dot_source); + if (dot != null) + { + img_stream = get_img_stream(dot, type); + if (dot.delete() == false) + System.err.println("Warning: " + dot.getAbsolutePath() + " could not be deleted!"); + return img_stream; + } + return null; + } catch (java.io.IOException ioe) { return null; } + } + + /** + * Writes the graph's image in a file. + * @param img A byte array containing the image of the graph. + * @param file Name of the file to where we want to write. + * @return Success: 1, Failure: -1 + */ + public int writeGraphToFile(byte[] img, String file) + { + File to = new File(file); + return writeGraphToFile(img, to); + } + + /** + * Writes the graph's image in a file. + * @param img A byte array containing the image of the graph. + * @param to A File object to where we want to write. + * @return Success: 1, Failure: -1 + */ + public int writeGraphToFile(byte[] img, File to) + { + try { + FileOutputStream fos = new FileOutputStream(to); + fos.write(img); + fos.close(); + } catch (FileNotFoundException e) { + e.printStackTrace(); + }catch (java.io.IOException ioe) { System.out.println(ioe); return -1; } + return 1; + } + + /** + * It will call the external dot program, and return the image in + * binary format. + * @param dot Source of the graph (in dot language). + * @param type Type of the output image to be produced, e.g.: gif, dot, fig, pdf, ps, svg, png. + * @return The image of the graph in .gif format. + */ + private byte[] get_img_stream(File dot, String type) + { + File img; + byte[] img_stream = null; + + try { + img = File.createTempFile("graph_", "."+type, new File(GraphViz.TEMP_DIR)); + Runtime rt = Runtime.getRuntime(); + + // patch by Mike Chenault + String[] args = {DOT, "-T"+type, "-Gdpi="+dpiSizes[this.currentDpiPos], dot.getAbsolutePath(), "-o", img.getAbsolutePath()}; + + Process p = rt.exec(args); + + p.waitFor(); + + FileInputStream in = new FileInputStream(img.getAbsolutePath()); + img_stream = new byte[in.available()]; + in.read(img_stream); + // Close it if we need to + if( in != null ) in.close(); + + if (img.delete() == false) + System.err.println("Warning: " + img.getAbsolutePath() + " could not be deleted!"); + } + catch (java.io.IOException ioe) { + System.err.println("Error: in I/O processing of tempfile in dir " + GraphViz.TEMP_DIR+"\n"); + System.err.println(" or in calling external command"); + ioe.printStackTrace(); + } + catch (java.lang.InterruptedException ie) { + System.err.println("Error: the execution of the external program was interrupted"); + ie.printStackTrace(); + } + + return img_stream; + } + + /** + * Writes the source of the graph in a file, and returns the written file + * as a File object. + * @param str Source of the graph (in dot language). + * @return The file (as a File object) that contains the source of the graph. + */ + private File writeDotSourceToFile(String str) throws java.io.IOException + { + File temp; + try { + temp = File.createTempFile("dorrr",".dot", new File(GraphViz.TEMP_DIR)); + FileWriter fout = new FileWriter(temp); + fout.write(str); + BufferedWriter br=new BufferedWriter(new FileWriter("dotsource.dot")); + br.write(str); + br.flush(); + br.close(); + fout.close(); + } + catch (Exception e) { + System.err.println("Error: I/O error while writing the dot source to temp file!"); + return null; + } + return temp; + } + + /** + * Returns a string that is used to start a graph. + * @return A string to open a graph. + */ + public String start_graph() { + return "digraph G {"; + } + + /** + * Returns a string that is used to end a graph. + * @return A string to close a graph. + */ + public String end_graph() { + return "}"; + } + + /** + * Takes the cluster or subgraph id as input parameter and returns a string + * that is used to start a subgraph. + * @return A string to open a subgraph. + */ + public String start_subgraph(int clusterid) { + return "subgraph cluster_" + clusterid + " {"; + } + + /** + * Returns a string that is used to end a graph. + * @return A string to close a graph. + */ + public String end_subgraph() { + return "}"; + } + + /** + * Read a DOT graph from a text file. + * + * @param input Input text file containing the DOT graph + * source. + */ + public void readSource(String input) + { + StringBuilder sb = new StringBuilder(); + + try + { + FileInputStream fis = new FileInputStream(input); + DataInputStream dis = new DataInputStream(fis); + BufferedReader br = new BufferedReader(new InputStreamReader(dis)); + String line; + while ((line = br.readLine()) != null) { + sb.append(line); + } + dis.close(); + } + catch (Exception e) { + System.err.println("Error: " + e.getMessage()); + } + + this.graph = sb; + } + +} // end of class GraphViz \ No newline at end of file diff --git a/src/superc/p4parser/Makefile b/src/superc/p4parser/Makefile index 768fa0d6..c698065f 100644 --- a/src/superc/p4parser/Makefile +++ b/src/superc/p4parser/Makefile @@ -55,7 +55,13 @@ SOURCE = \ P4TokenCreator.java \ P4Values.java \ P4Actions.java \ - P4Context.java + P4Context.java \ + GraphViz.java \ + CallGraphGenerator.java \ + P4LanguageObject.java \ + Symbols.java \ + SymbolTable.java \ + TemporaryParameterValues.java JNI_SOURCE = diff --git a/src/superc/p4parser/P4Actions.java b/src/superc/p4parser/P4Actions.java index 5eea7472..0ac58034 100644 --- a/src/superc/p4parser/P4Actions.java +++ b/src/superc/p4parser/P4Actions.java @@ -268,20 +268,8 @@ public Object action(int production, Subparser subparser, Object value) { {} break; - case 40: - {} - break; - - case 41: - {} - break; - - case 42: - {} - break; - case 43: - {} + {} break; case 44: @@ -289,7 +277,7 @@ public Object action(int production, Subparser subparser, Object value) { break; case 45: - {} + {} break; case 46: @@ -469,11 +457,11 @@ public Object action(int production, Subparser subparser, Object value) { break; case 90: - {} + {} break; case 91: - {} + {} break; case 92: @@ -536,7 +524,7 @@ public Object action(int production, Subparser subparser, Object value) { {} break; - case 108: + case 107: {} break; @@ -629,19 +617,19 @@ public Object action(int production, Subparser subparser, Object value) { break; case 131: - {} + {} break; case 132: - {} + {} break; case 133: - {} + {} break; case 134: - {} + {} break; case 135: @@ -649,31 +637,31 @@ public Object action(int production, Subparser subparser, Object value) { break; case 136: - {} + { ReenterScope(subparser); } break; case 137: - {} + { ExitReentrantScope(subparser); } break; case 138: - {} + {} break; case 139: - {} + {} break; case 140: - {} + {} break; case 141: - {} + {} break; case 142: - {} + {} break; case 143: @@ -681,26 +669,26 @@ public Object action(int production, Subparser subparser, Object value) { break; case 144: - {} + {} break; case 145: - {} + {} break; case 146: - { - saveBaseType(subparser, getNodeAt(subparser, 8)); - bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); - } + {} break; case 147: - {} + {} break; case 148: - {} + { + saveBaseType(subparser, getNodeAt(subparser, 8)); + bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); + } break; case 149: @@ -711,68 +699,60 @@ public Object action(int production, Subparser subparser, Object value) { {} break; - case 151: - {} - break; - - case 152: - {} - break; - case 153: - {} + {} break; case 154: - {} + {} break; case 155: - {} + {} break; case 156: - {} + {} break; case 157: - {} + {} break; case 158: - {} + {} break; case 159: - { EnterScope(subparser); } + {} break; case 160: - { ExitScope(subparser); } + {} break; case 161: - {} + { ReenterScope(subparser); } break; case 162: - {} + { ExitScope(subparser); } break; case 163: - {} + {} break; case 164: - {} + {} break; case 165: - {} + {} break; case 166: - {} + {} break; case 167: @@ -780,30 +760,30 @@ public Object action(int production, Subparser subparser, Object value) { break; case 168: - {} + {} break; case 169: - {} + {} break; case 170: - { - saveBaseType(subparser, getNodeAt(subparser, 8)); - bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); - } + {} break; case 171: - {} + {} break; case 172: - {} + { + saveBaseType(subparser, getNodeAt(subparser, 8)); + bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); + } break; case 173: - {} + {} break; case 174: @@ -811,23 +791,23 @@ public Object action(int production, Subparser subparser, Object value) { break; case 175: - {} + {} break; case 176: - {} + {} break; case 177: - {} + {} break; case 178: - {} + {} break; case 179: - {} + {} break; case 180: @@ -847,111 +827,111 @@ public Object action(int production, Subparser subparser, Object value) { break; case 184: - {} + {} break; case 185: - {} + {} break; case 186: - {} + {} break; case 187: - {} + {} break; case 188: - {} + {} break; case 189: - {} + {} break; case 190: - {} + {} break; case 191: - {} + {} break; case 192: - {} + {} break; case 193: - {} + {} break; case 194: - {} + {} break; case 195: - {} + {} break; case 196: - {} + {} break; case 197: - {} + {} break; case 198: - {} + {} break; case 199: - {} + {} break; case 200: - {} + {} break; case 201: - {} + {} break; case 202: - {} + {} break; case 203: - {} + {} break; case 204: - {} + {} break; case 205: - {} + {} break; case 206: - {} + {} break; case 207: - {} + {} break; case 208: - {} + {} break; case 209: - {} + {} break; case 210: - {} + {} break; case 211: @@ -963,216 +943,252 @@ public Object action(int production, Subparser subparser, Object value) { break; case 213: - {} + {} break; case 214: - {} + { ReenterScope(subparser); } break; case 215: + { ExitScope(subparser); } + break; + + case 216: + {} + break; + + case 217: + {} + break; + + case 218: + {} + break; + + case 219: { saveBaseType(subparser, getNodeAt(subparser, 8)); bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } break; - case 216: + case 220: {} break; - case 217: + case 221: {} break; - case 218: + case 222: {} break; - case 219: + case 223: {} break; - case 220: + case 224: {} break; - case 221: + case 225: {} break; - case 222: + case 226: {} break; - case 223: + case 227: {} break; - case 224: + case 228: { saveBaseType(subparser, getNodeAt(subparser, 2)); bindIdent(subparser, getNodeAt(subparser, 2), getNodeAt(subparser, 1)); } break; - case 225: + case 229: {} break; - case 229: + case 230: + { ReenterScope(subparser); } + break; + + case 231: + { ExitScope(subparser); } + break; + + case 236: {} break; - case 230: + case 237: {} break; - case 231: + case 238: {} break; - case 232: + case 239: {} break; - case 233: + case 240: {} break; - case 234: + case 241: {} break; - case 235: + case 242: + {} + break; + + case 243: {} break; - case 236: + case 245: {} break; - case 237: + case 246: {} break; - case 238: + case 247: {} break; - case 239: + case 248: {} break; - case 240: + case 249: {} break; - case 241: + case 250: {} break; - case 242: + case 251: {} break; - case 243: + case 252: {} break; - case 244: + case 253: {} break; - case 245: + case 254: {} break; - case 246: + case 255: {} break; - case 247: + case 256: {} break; - case 248: + case 257: {} break; - case 249: + case 258: {} break; - case 250: + case 259: {} break; - case 251: + case 260: {} break; - case 252: + case 261: {} break; - case 253: + case 262: {} break; - case 254: + case 263: {} break; - case 255: + case 264: {} break; - case 256: + case 265: {} break; - case 257: + case 266: {} break; - case 258: + case 267: {} break; - case 259: + case 268: {} break; - case 260: + case 269: {} break; - case 261: + case 270: {} break; - case 262: + case 271: {} break; - case 263: + case 272: {} break; - case 264: + case 273: {} break; - case 265: + case 274: {} break; - case 266: - {} + case 275: + { EnterScope(subparser); } break; - case 267: + case 276: + { ExitReentrantScope(subparser); } + break; + + case 277: + {} + break; + + case 278: { // ASK possible to get the production name? (typeParameterList) // // saveBaseType(subparser, getNodeAt(subparser, 12)); @@ -1182,890 +1198,931 @@ public Object action(int production, Subparser subparser, Object value) { } break; - case 268: + case 279: { bindIdent(subparser, null, getNodeAt(subparser, 1), true); } break; - case 269: + case 280: {} break; - case 270: + case 281: {} break; - case 271: + case 282: {} break; - case 272: + case 283: {} break; - case 273: + case 284: {} break; - case 274: + case 285: {} break; - case 275: + case 286: {} break; - case 276: + case 287: {} break; - case 277: + case 288: {} break; - case 278: + case 289: {} break; - case 279: + case 290: {} break; - case 280: + case 291: {} break; - case 281: + case 292: {} break; - case 282: + case 293: {} break; - case 283: + case 294: {} break; - case 284: + case 295: {} break; - case 285: + case 296: {} break; - case 286: + case 297: {} break; - case 287: + case 298: {} break; - case 288: + case 299: {} break; - case 289: + case 300: {} break; - case 290: - {} + case 301: + { ReenterScope(subparser); } break; - case 291: - {} + case 302: + { ExitScope(subparser); } break; - case 292: + case 303: { saveBaseType(subparser, getNodeAt(subparser, 8)); bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } break; - case 293: + case 304: + { ReenterScope(subparser); } + break; + + case 305: + { ExitScope(subparser); } + break; + + case 306: { - saveBaseType(subparser, getNodeAt(subparser, 6)); - bindIdent(subparser, getNodeAt(subparser, 6), getNodeAt(subparser, 5)); + saveBaseType(subparser, getNodeAt(subparser, 8)); + bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } break; - case 294: - {} + case 307: + { ReenterScope(subparser); } break; - case 295: - {} + case 308: + { ExitScope(subparser); } break; - case 296: - { + case 309: + { saveBaseType(subparser, getNodeAt(subparser, 8)); bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } break; - case 297: + case 310: {} break; - case 298: + case 311: {} break; - case 299: + case 312: {} break; - case 300: + case 313: {} break; - case 301: + case 314: { saveBaseType(subparser, getNodeAt(subparser, 6)); bindIdent(subparser, getNodeAt(subparser, 6), getNodeAt(subparser, 5)); } break; - case 302: + case 315: {} break; - case 303: + case 316: { saveBaseType(subparser, getNodeAt(subparser, 7)); bindIdent(subparser, getNodeAt(subparser, 7), getNodeAt(subparser, 5)); } break; - case 304: + case 317: {} break; - case 305: + case 318: {} break; - case 306: + case 319: {} break; - case 307: + case 320: {} break; - case 308: + case 321: {} break; - case 309: + case 322: {} break; - case 310: + case 323: {} break; - case 311: + case 324: { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } break; - case 312: + case 325: { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } break; - case 313: + case 326: { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } break; - case 314: + case 327: { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } break; - case 315: + case 328: {} break; - case 316: + case 329: {} break; - case 317: + case 330: {} break; - case 318: + case 331: + {} + break; + + case 332: {} break; - case 319: + case 333: {} break; - case 320: + case 334: {} break; - case 321: + case 335: {} break; - case 322: + case 336: {} break; - case 323: + case 337: {} break; - case 324: + case 338: {} break; - case 325: + case 339: {} break; - case 326: + case 340: {} break; - case 327: + case 341: {} break; - case 328: + case 342: {} break; - case 329: + case 343: {} break; - case 330: + case 344: {} break; - case 331: + case 345: {} break; - case 332: + case 346: {} break; - case 333: + case 347: {} break; - case 334: + case 348: {} break; - case 335: + case 349: {} break; - case 336: + case 350: {} break; - case 337: + case 351: {} break; - case 338: + case 352: {} break; - case 339: + case 353: {} break; - case 340: + case 354: {} break; - case 341: + case 355: {} break; - case 342: + case 356: {} break; - case 343: + case 357: {} break; - case 344: + case 358: {} break; - case 345: + case 359: {} break; - case 346: + case 360: {} break; - case 347: + case 361: {} break; - case 348: + case 362: + { EnterScope(subparser); } + break; + + case 363: + { ExitScope(subparser); } + break; + + case 364: {} break; - case 349: + case 365: {} break; - case 350: + case 366: {} break; - case 351: + case 367: {} break; - case 352: + case 368: {} break; - case 353: + case 369: {} break; - case 354: + case 370: {} break; - case 355: + case 371: {} break; - case 356: + case 372: {} break; - case 357: + case 373: {} break; - case 358: + case 374: {} break; - case 359: + case 375: {} break; - case 360: + case 377: {} break; - case 361: + case 378: {} break; - case 362: + case 379: {} break; - case 363: + case 380: {} break; - case 364: + case 381: {} break; - case 365: - { - saveBaseType(subparser, getNodeAt(subparser, 6)); - bindIdent(subparser, getNodeAt(subparser, 6), getNodeAt(subparser, 5)); + case 382: + { EnterScope(subparser); } + break; + + case 383: + { + saveBaseType(subparser, getNodeAt(subparser, 7)); + bindIdent(subparser, getNodeAt(subparser, 7), getNodeAt(subparser, 6)); + ExitScope(subparser); } break; - case 366: + case 384: { saveBaseType(subparser, getNodeAt(subparser, 4)); bindIdent(subparser, getNodeAt(subparser, 4), getNodeAt(subparser, 3)); } break; - case 367: + case 385: { saveBaseType(subparser, getNodeAt(subparser, 4)); bindIdent(subparser, getNodeAt(subparser, 4), getNodeAt(subparser, 3)); } break; - case 368: + case 386: {} break; - case 369: + case 387: {} break; - case 370: + case 388: {} break; - case 371: + case 389: {} break; - case 372: - {} + case 390: + { ReenterScope(subparser); } break; - case 373: + case 391: + { ExitScope(subparser); } + break; + + case 392: {} break; - case 374: + case 393: {} break; - case 375: + case 394: {} break; - case 376: + case 395: {} break; - case 377: + case 396: {} break; - case 378: + case 397: {} break; - case 379: + case 398: {} break; - case 380: + case 399: {} break; - case 381: + case 400: {} break; - case 382: + case 401: {} break; - case 383: + case 402: {} break; - case 384: + case 403: {} break; - case 385: + case 404: {} break; - case 386: + case 405: {} break; - case 387: + case 406: {} break; - case 388: + case 407: {} break; - case 389: + case 408: {} break; - case 390: - {} + case 409: + {} break; - case 391: - {} + case 410: + {} break; - case 392: + case 411: + {} + break; + + case 412: {} break; - case 393: + case 413: {} break; - case 394: + case 414: {} break; - case 395: + case 415: {} break; - case 396: + case 416: {} break; - case 397: + case 417: {} break; - case 398: + case 418: {} break; - case 399: + case 419: {} break; - case 400: + case 420: {} break; - case 401: + case 421: {} break; - case 402: + case 422: {} break; - case 403: + case 423: {} break; - case 404: + case 424: {} break; - case 405: + case 425: {} break; - case 406: + case 426: {} break; - case 407: + case 427: {} break; - case 408: + case 428: {} break; - case 409: + case 429: {} break; - case 410: + case 430: {} break; - case 411: + case 431: {} break; - case 412: + case 432: {} break; - case 413: + case 433: {} break; - case 414: + case 434: {} break; - case 415: + case 435: {} break; - case 416: + case 436: {} break; - case 417: + case 437: {} break; - case 418: + case 438: {} break; - case 419: + case 439: {} break; - case 420: + case 440: {} break; - case 421: + case 441: {} break; - case 422: + case 442: {} break; - case 423: + case 443: {} break; - case 424: + case 444: {} break; - case 425: + case 445: {} break; - case 426: + case 446: {} break; - case 427: + case 447: {} break; - case 428: + case 448: {} break; - case 429: + case 449: {} break; - case 430: + case 450: {} break; - case 431: + case 451: {} break; - case 432: + case 452: {} break; - case 433: - {} + case 453: + {} break; - case 434: + case 454: + {} + break; + + case 456: {} break; - case 435: + case 457: {} break; - case 436: - {} + case 458: + {} break; - case 437: + case 459: {} break; - case 438: + case 460: {} break; - case 439: + case 461: {} break; - case 440: + case 462: {} break; - case 441: + case 463: {} break; - case 442: + case 464: {} break; - case 443: + case 465: {} break; - case 444: + case 466: {} break; - case 445: + case 467: {} break; - case 446: + case 468: {} break; - case 447: + case 469: {} break; - case 448: + case 470: {} break; - case 449: + case 471: {} break; - case 450: + case 472: {} break; - case 451: + case 473: {} break; - case 452: + case 474: {} break; - case 453: + case 475: {} break; - case 454: + case 476: {} break; - case 455: + case 477: {} break; - case 456: + case 478: {} break; - case 457: + case 479: {} break; - case 458: + case 480: {} break; - case 459: + case 481: {} break; - case 460: + case 482: {} break; - case 461: + case 483: {} break; - case 462: + case 484: {} break; - case 463: + case 485: {} break; - case 464: + case 486: {} break; - case 465: + case 487: {} break; - case 466: + case 488: {} break; - case 467: + case 489: {} break; - case 468: + case 490: {} break; - case 469: + case 491: {} break; - case 470: + case 492: {} break; - case 471: + case 493: {} break; - case 472: + case 494: {} break; - case 473: + case 495: {} break; - case 474: + case 496: {} break; - case 475: + case 497: {} break; - case 476: - {} + case 498: + {} break; - case 477: + case 499: + {} + break; + + case 501: {} break; - case 478: + case 502: {} break; - case 479: - {} + case 503: + {} break; diff --git a/src/superc/p4parser/P4LanguageObject.java b/src/superc/p4parser/P4LanguageObject.java new file mode 100644 index 00000000..41cf470d --- /dev/null +++ b/src/superc/p4parser/P4LanguageObject.java @@ -0,0 +1,2649 @@ +package superc.p4parser; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Map; +import java.util.Stack; +import java.util.TreeMap; +import java.util.TreeSet; + +import xtc.tree.GNode; +import xtc.tree.Visitor; + +// For symbols +class P4LanguageObject { + // Boolean flags to turn on and off features + boolean OUTPUT_TYPES = true; + + // conditioned callees + enum LObjectKind { + CONSTANTVALUE, + HEADERTYPEDECLARATION, + HEADERTYPEDECLARATIONGENERATOR, + HEADERUNIONDECLARATION, + HEADERUNIONDECLARATIONGENERATOR, + STRUCTTYPEDECLARATION, + STRUCTTYPEDECLARATIONGENERATOR, + ENUMDECLARATION, + TYPEDEFDECLARATION, + PARSERTYPEDECLARATION, + PARSERTYPEDECLARATIONGENERATOR, + PACKAGETYPEDECLARATION, + PACKAGETYPEDECLARATIONGENERATOR, + EXTERNDECLARATION, + EXTERNDECLARATIONGENERATOR, + EXTERNFUNCTIONDECLARATION, + EXTERNFUNCTIONDECLARATIONGENERATOR, + PARAMETER, + PARAMETERGENERATOR, + CONTROLTYPEDECLARATION, + CONTROLTYPEDECLARATIONGENERATOR, + TYPEORVOID, + TYPEPARAMETER, + STRUCTFIELD, + STRING, + DEFAULT, + FUNCTIONPROTOTYPE, + FUNCTIONPROTOTYPEGENERATOR, + CONTROLDECLARATION, + PARSERDECLARATION, + PARSERDECLARATIONGENERATOR, + TABLEDECLARATION, + INVOKABLEKEYWORD, + BUILTINFUNCTION, + VARIABLE, + VARIABLEGENERATOR, + BASETYPE, + FUNCTION, + METHOD, + TUPLETYPE, + SPECIALIZEDTYPE, + HEADERSTACKTYPE, + ANONYMOUS, + SUBCLASS, + FUNCTIONDECLARATION, + FUNCTIONDECLARATIONGENERATOR, + FUNCTIONPROTOTYPEPLACEHOLDER + } + + // TODO handle constructor method prototype parameters & action declarations + + abstract class AbstractObjectOfLanguage implements Comparable{ + private final String name; + private final AbstractObjectOfLanguage nameSpace; + abstract boolean isScoped(); + // not making this private to avoid allocating memory since it is not present most times + private ArrayList optConstructorParameters = null; + // private ArrayList optAnnotations = null; + private ArrayList parameters; + + private int defaultParameterCount; + + // abstract method to return respective enum + abstract LObjectKind getConstructType(); + + abstract boolean isGeneratorClass(); + + GNode associatedNode; + + public void setNode(GNode n) { + assert n != null; + this.associatedNode = n; + } + + public GNode getNode() { + assert this.hasNode(); + return this.associatedNode; + } + + public boolean hasNode() { + return !(this.associatedNode == null); + } + + boolean hasAssociatedType() { + return false; + } + + public boolean hasParameters() { + return ! this.parameters.isEmpty(); + } + + public void addParameter(AbstractObjectOfLanguage parameter) { + assert parameter.getConstructType() == LObjectKind.PARAMETER || parameter.getConstructType() == LObjectKind.PARAMETERGENERATOR; + this.parameters.add(parameter); + } + + public ArrayList getParameters() { + return this.parameters; + } + + AbstractObjectOfLanguage getType() { + // System.err.println("No associated type found for: \"" + name + "\""); + // System.exit(1); + assert false : "No associated type found for: \"" + name + "\""; + return null; + } + + public String getName() { + return this.getName(false); + } + + public String getName(boolean output_types) { + if(this.name == null) { + System.err.println(this.getConstructType().toString() + " construct does not have a name associated with it."); + } + + if(output_types) { + if(this.hasAssociatedType()) { + // Switching this to include regular construct type as well to differentiate + // cases where a generator construct has an already defined type value that doesn't change + // after generating new instance (CGTest_generic_variable.p4 test case) + return this.name + "(" + this.getConstructType() + ", " + this.getType().getConstructType() + ")"; + } else { + return this.name + "(" + this.getConstructType() + ")"; + } + } else { + return this.name; + } + } + + public boolean hasName() { + return this.name != null; + } + + public boolean hasOptConstructorParameters() { + return (optConstructorParameters != null); + } + + // public boolean hasOptAnnotations() { + // return optAnnotations != null; + // } + + void addParsedOptTypeParameters(AbstractObjectOfLanguage typeParameter) { + System.err.println("This object does not passed in values for generic parameters."); + System.exit(1); + } + + boolean hasParsedOptTypeParameters() { + return false; + } + + ArrayList getParsedOptTypeParameters() { + System.err.println("Cannot obtain parsed type parameters for this object (" + this.name + ")"); + System.exit(1); + return null; + } + + public AbstractObjectOfLanguage getNameSpace() { + return this.nameSpace; + } + + public String getNameSpaceString(AbstractObjectOfLanguage global_scope) { + if(this == global_scope) { + return name; + } + + return this.nameSpace.name; + } + + public ArrayList getOptConstructorParameters() { + return this.optConstructorParameters; + } + + public void addToOptConstructorParametersList(Parameter parameter) { + if(optConstructorParameters == null) { + this.optConstructorParameters = new ArrayList<>(); + } + + this.optConstructorParameters.add(parameter); + } + + // public void addToOptAnnotations(Annotation annotation) { + // if (optAnnotations == null) { + // this.optAnnotations = new ArrayList<>(); + // } + + // this.optAnnotations.add(annotation); + // } + + public void increaseDefaultParameterCount() { + defaultParameterCount += 1; + } + + public int getDefaultParameterCount() { + return this.defaultParameterCount; + } + + public AbstractObjectOfLanguage(String name, AbstractObjectOfLanguage nameSpace) { + this.name = name; + this.nameSpace = nameSpace; + this.parameters = new ArrayList<>(); + this.associatedNode = null; + this.defaultParameterCount = 0; + } + + public AbstractObjectOfLanguage(AbstractObjectOfLanguage nameSpace) { + this(null, nameSpace); + } + + public String toString(AbstractObjectOfLanguage global_scope) { + // For simple toString calls where the current value is not present under the symbol table + if(this == global_scope) { + return name; + } + + return name + "(" + this.getNameSpaceString(global_scope) + ")"; + } + + @Override + public int compareTo(AbstractObjectOfLanguage e) { + return this.getName(true).compareTo(e.getName(true)); + } + + /** + * A toString function to use when in-depth detail about current object is needed. + * Outputs the callees present under the current object if it is not present under the global scope. + * @return + */ + public String toStringExtensive(Map> symtabGiven, HashMap> callGraphObjectGiven, AbstractObjectOfLanguage global_scope) { + String finalString = name + ": "; + + TreeMap> symtab = new TreeMap<>(); + + for(AbstractObjectOfLanguage mainKey : symtabGiven.keySet()) { + if(mainKey.getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + continue; + } + symtab.put(mainKey, new TreeMap()); + for(String childKey : symtabGiven.get(mainKey).keySet()) { + if(symtabGiven.get(mainKey).get(childKey).getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + continue; + } + symtab.get(mainKey).put(childKey, symtabGiven.get(mainKey).get(childKey)); + } + } + + TreeMap> callGraphObject = new TreeMap<>(); + // HashMap> + for(AbstractObjectOfLanguage mainKey : callGraphObjectGiven.keySet()) { + if(mainKey.getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + continue; + } + callGraphObject.put(mainKey, new TreeSet<>()); + for(AbstractObjectOfLanguage childKey : callGraphObjectGiven.get(mainKey)) { + if(childKey.getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + continue; + } + callGraphObject.get(mainKey).add(childKey); + } + } + + Iterator itr = symtab.get(this).keySet().iterator(); + + ArrayList parentCalleeNames = new ArrayList<>(); + if(callGraphObject.containsKey(this)) { + for(AbstractObjectOfLanguage callee : callGraphObject.get(this)) { + if(callee.getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + continue; + } + parentCalleeNames.add(callee.getName(OUTPUT_TYPES) + "(" + callee.getNameSpace().getName(OUTPUT_TYPES) + ")"); + } + } + + if(! parentCalleeNames.isEmpty()) { + for(int i = 0; i < parentCalleeNames.size(); i++) { + finalString += parentCalleeNames.get(i) + (i == parentCalleeNames.size() - 1 ? "" : ", "); + } + } + + finalString += (itr.hasNext() && !parentCalleeNames.isEmpty() ? ", " : ""); + + while(itr.hasNext()) { + String childKey = (String) itr.next(); + AbstractObjectOfLanguage childLangObj = symtab.get(this).get(childKey); + if(childLangObj.getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + continue; + } + finalString += childLangObj.getName(OUTPUT_TYPES); + if(symtab.containsKey(childLangObj)) { + finalString += itr.hasNext() ? ", " : ""; + continue; + } + // System.out.println("debug: " + childLangObj.getName() + " with parent: " + childLangObj.getParentNameSpaces(global_scope)); + + ArrayList calleeNames = new ArrayList<>(); + if(callGraphObject.containsKey(childLangObj)) { + for(AbstractObjectOfLanguage callee : callGraphObject.get(childLangObj)) { + calleeNames.add(callee.getName(OUTPUT_TYPES)); + } + } + + if(! calleeNames.isEmpty()) { + Collections.sort(calleeNames); + finalString += ": " + calleeNames.toString(); + } + finalString += (itr.hasNext() ? ", " : ""); + } + + return finalString; + } + + public String toDotString(Map> symtab, HashMap> callGraphObject, AbstractObjectOfLanguage global_scope) { + boolean showVariables = true; + boolean showCallGraph = true; + String finalString = ""; + String initialString = ""; + + Iterator itr = symtab.get(this).keySet().iterator(); + finalString += this.hashCode(global_scope) + ";"; + finalString += this.hashCode(global_scope) + " [label=\"" + this.getName(OUTPUT_TYPES) + "\"];"; + initialString = finalString; + + if(showCallGraph) { + ArrayList parentCalleeNames = new ArrayList<>(); + if(callGraphObject.containsKey(this)) { + for(AbstractObjectOfLanguage callee : callGraphObject.get(this)) { + parentCalleeNames.add(callee); + } + } + + if(! parentCalleeNames.isEmpty()) { + for(AbstractObjectOfLanguage localCallee : parentCalleeNames) { + finalString += this.hashCode(global_scope) + "->" + localCallee.hashCode(global_scope) + ";"; + finalString += localCallee.hashCode(global_scope) + " [label=\"" + localCallee.getName(OUTPUT_TYPES) + "\"];"; + } + } + } + + if(showVariables) { + while(itr.hasNext()) { + String childKey = (String) itr.next(); + AbstractObjectOfLanguage childLangObj = symtab.get(this).get(childKey); + if(childLangObj.getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + continue; + } + finalString += this.hashCode(global_scope) + " -> " + childLangObj.hashCode(global_scope) + " [style=dashed, color=blue];"; + finalString += childLangObj.hashCode(global_scope) + " [label=\"" + childLangObj.getName(OUTPUT_TYPES) + "\"];"; + + // If it is a subclass, put it under the parent class in graph + if(childLangObj.getConstructType() == LObjectKind.SUBCLASS) { + finalString += ((SubClass) childLangObj).getOriginalClass().hashCode(global_scope) + "->" + childLangObj.hashCode(global_scope) + "[color=red]"; + finalString += childLangObj.hashCode(global_scope) + " [style=filled, fillcolor=bisque];"; + } + + if(symtab.containsKey(childLangObj)) { + continue; + } + + if(showCallGraph) { + ArrayList calleeNames = new ArrayList<>(); + if(callGraphObject.containsKey(childLangObj)) { + for(AbstractObjectOfLanguage callee : callGraphObject.get(childLangObj)) { + calleeNames.add(callee); + } + } + + if(! calleeNames.isEmpty()) { + for(AbstractObjectOfLanguage localCallee : calleeNames) { + finalString += childLangObj.hashCode(global_scope) + "->" + localCallee.hashCode(global_scope) + ";"; + finalString += localCallee.hashCode(global_scope) + " [label=\"" + localCallee.name + "\"];"; + } + } + } + + } + } + + // finalString += this.hashCode() + " [label=\"" + this.name + "\"]"; + // System.out.println(finalString); + return (initialString.equals(finalString) ? "" : finalString); + } + + /** + * Having same name under the same scope means they are "equal" for our usage and have same hash value + */ + public boolean equals(Object object, AbstractObjectOfLanguage global_scope) { + if(this == object) { + return true; + } + if(object == null) { + return false; + } + if (object instanceof AbstractObjectOfLanguage == false) { + return false; + } + + AbstractObjectOfLanguage compObject = (AbstractObjectOfLanguage) object; + + if(compObject == global_scope || this == global_scope) { + // if both are global_scope, then it should have returned true at the beginning + return false; + } + + if(compObject.name.equals(this.name) + && compObject.nameSpace.equals(this.nameSpace)) { + return true; + } + + return false; + } + + /** + * Generates a unique hash code based on the scoping ancestry + * (If two blocks are under the same scope then they are the same piece of code) + * @param global_scope + * @return + */ + public int hashCode(AbstractObjectOfLanguage global_scope) { + String hashString = ""; + if(this.nameSpace != null) { + // not the GLOBAL AbstractObjectOfLanguage + hashString += this.getParentNameSpaces(global_scope) + "/"; + } + hashString += this.name; + + return hashString.hashCode(); + } + + /** + * Returns a string with current scope name and the ancestry scope name. + * @param global_scope + * @return + */ + public String getParentNameSpaces(AbstractObjectOfLanguage global_scope) { + String ancestorNameSpace = ""; + AbstractObjectOfLanguage currentNameSpace = this.nameSpace; + if(this == global_scope || currentNameSpace == global_scope) { + return "GLOBAL"; + } + + while(currentNameSpace != global_scope) { + ancestorNameSpace += (ancestorNameSpace.isBlank() ? "" : "/"); + ancestorNameSpace += currentNameSpace.name; + currentNameSpace = currentNameSpace.nameSpace; + } + + return ancestorNameSpace; + } + + // END generic functions + + } + + abstract class Generator extends AbstractObjectOfLanguage { + private RegularLanguageObject originalRegularObject; + private ArrayList optTypeParameters; + + void addOptTypeParameters(TypeParameter typeParameter) { + this.optTypeParameters.add(typeParameter); + } + + boolean hasOptTypeParameters() { + return !this.optTypeParameters.isEmpty(); + } + + ArrayList getOptTypeParameters() { + return this.optTypeParameters; + } + + @Override + public boolean isGeneratorClass() { + return true; + } + + @Override + public boolean isScoped() { + return originalRegularObject.isScoped(); + } + + public RegularLanguageObject getRegularLanguageObject() { + return this.originalRegularObject; + } + + @Override + public boolean hasAssociatedType() { + return this.getRegularLanguageObject().hasAssociatedType(); + } + + @Override + AbstractObjectOfLanguage getType() { + return this.getRegularLanguageObject().getType(); + } + + @Override + public void increaseDefaultParameterCount() { + this.getRegularLanguageObject().increaseDefaultParameterCount(); + } + + @Override + public int getDefaultParameterCount() { + return this.getRegularLanguageObject().getDefaultParameterCount(); + } + + public AbstractObjectOfLanguage generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope + ) { + ArrayList typeMappings; + ArrayList parameterMappings; + // For cases when types are not passed in and parameters are empty + if(parsedTypeParameters.isEmpty() && parsedParameters.size() != this.getParameters().size()) { + typeMappings = new ArrayList<>(); + } else { + if(parsedTypeParameters.isEmpty()) { + assert parsedParameters.size() == this.getParameters().size(); + } + typeMappings = this.getOptTypeParameters(); + } + + parameterMappings = this.getParameters(); + return this.generateInstance(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, valuesUnderScope, symtab, visitor, scope); + } + + // type mappings are introduced for cases one generator function calls a child generator construct's generateInstance function and passes in + // in its own (parent) parsedTypeParameters and parsedParameters to the child generator construct. So in those cases those values + // are passed to the parent's generic types and not the child's. Hence to differentiate it we pass in typeMappings (e.x. CGTest_generic_invokingExpression_methodCallstatement) + // example is ExternDeclarationGenerator potentially calling a child functionPrototype's generator function + // Similar case for parameter mappings (e.g. nested function prototypes) + + abstract public AbstractObjectOfLanguage generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope); + public void handleGenericsUnderScope(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map> symtab, + Visitor visitor, + Stack scope, + AbstractObjectOfLanguage newInstance) { + Map valuesUnderScope = symtab.get(this); + // System.out.println("same?: " + (check == valuesUnderScope)); + for(String names : valuesUnderScope.keySet()) { + AbstractObjectOfLanguage childUnderScope = valuesUnderScope.get(names); + AbstractObjectOfLanguage newChildToAdd; + if(childUnderScope.getConstructType() == LObjectKind.PARAMETER || childUnderScope.getConstructType() == LObjectKind.PARAMETERGENERATOR) { + // assuming that parameters will be handled separately + continue; + } + if(childUnderScope.isGeneratorClass()) { + // System.out.println("going to generate instance of: " + childUnderScope.getName() + " of construct: " + childUnderScope.getConstructType()); + newChildToAdd = ((Generator) childUnderScope).generateInstance(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, valuesUnderScope, symtab, visitor, scope); + // System.out.println("generated instance of: " + childUnderScope.getName() + " of newtype: " + newChildToAdd.getConstructType() + " " + (newChildToAdd.hasAssociatedType() ? newChildToAdd.getType().getConstructType() : "")); + } else if(childUnderScope.getConstructType() == LObjectKind.TYPEPARAMETER) { + // Type parameters are a child of functions since they are looked up in symtab when setting types of variables + // so just ignore this + if(typeMappings.contains(childUnderScope)) { + // we do not add it back since the type parameter is defined in this invocation + // and will no longer be generic + // System.out.println("skipping: " + childUnderScope.getName()); + continue; + } + // System.out.println("adding type: " + childUnderScope.getName()); + newChildToAdd = childUnderScope; + } else if (childUnderScope.hasAssociatedType() && childUnderScope.getType().getConstructType() == LObjectKind.TYPEPARAMETER) { + assert false : "NEED TO HANDLE THIS! " + childUnderScope.getName() + " has generic type: " + childUnderScope.getType().getName() + " of construct: " + childUnderScope.getConstructType(); + newChildToAdd = childUnderScope; + } else { + newChildToAdd = childUnderScope; + } + + if(newChildToAdd.isGeneratorClass()) { + assert newInstance.isGeneratorClass(); + // System.out.println("Error: new child (" + newChildToAdd.getName() + ")still remains of type generic."); + // System.exit(1); + } + + addToSymtab(newInstance, newChildToAdd.getName(), newChildToAdd, symtab); + } + } + + public Generator(RegularLanguageObject regularLanguageObject) { + super(regularLanguageObject.getName(), regularLanguageObject.getNameSpace()); + assert regularLanguageObject.hasName() : "Anonymous class types not allowed for generators"; + + this.originalRegularObject = regularLanguageObject; + this.optTypeParameters = new ArrayList<>(); + } + } + + abstract class RegularLanguageObject extends AbstractObjectOfLanguage { + @Override + public boolean isGeneratorClass() { + return false; + } + + public RegularLanguageObject(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + } + + public RegularLanguageObject(AbstractObjectOfLanguage nameSpace) { + super(nameSpace); + } + } + + // Generator classes + + class PackageTypeDeclarationGenerator extends Generator { + @Override + public LObjectKind getConstructType() { + return LObjectKind.PACKAGETYPEDECLARATIONGENERATOR; + } + + public PackageTypeDeclarationGenerator(PackageTypeDeclaration packageTypeDeclaration) { + super(packageTypeDeclaration); + } + + @Override + public PackageTypeDeclaration generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + PackageTypeDeclaration newInstance = new PackageTypeDeclaration(this.getName(), this.getNameSpace()); + if(! parsedTypeParameters.isEmpty()) { + assert this.hasParameters() : "Assuming that if package type declaration has type parameters, then there are regular parameters passed in with generic types"; + // assert ! parsedParameters.isEmpty(); // doesn't necessarily need to have parameters passed (arch1.p4 example) + } + + // assert parameterMappings.size() == parsedParameters.size() : "parametermapping size: " + parameterMappings.size() + " but parsedParameter size: " + parsedParameters.size(); + + ArrayList originalParameters = parameterMappings; + for(int i = 0; i < parameterMappings.size(); i++) { + AbstractObjectOfLanguage currentParam = originalParameters.get(i); + AbstractObjectOfLanguage newParam = currentParam; + + if(currentParam.isGeneratorClass()) { + assert typeMappings.contains(currentParam.getType()); + newParam = ((ParameterGenerator) currentParam).generateInstance(parsedTypeParameters, parsedParameters, typeMappings, originalParameters, symtab.get(valuesUnderScope.get(currentParam.getName())), symtab, visitor, scope); + } + + newInstance.addParameter(newParam); + addToSymtab(newInstance, newParam.getName(), newParam, symtab); + } + + // this.handleGenericsUnderScope(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, symtab, visitor, scope, newInstance); + + return newInstance; + } + } + + class ParserTypeDeclarationGenerator extends Generator { + @Override + public LObjectKind getConstructType() { + return LObjectKind.PARSERTYPEDECLARATIONGENERATOR; + } + + public ParserTypeDeclarationGenerator(ParserTypeDeclaration parserTypeDeclaration) { + super(parserTypeDeclaration); + } + + public ParserTypeDeclaration generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + ParserTypeDeclaration newInstance = new ParserTypeDeclaration(this.getName(), this.getNameSpace()); + // if(! parsedParameters.isEmpty()) { + // assert parameterMappings.size() == parsedParameters.size(); + // } + + ArrayList originalParameters = parameterMappings; + for(int i = 0; i < originalParameters.size(); i++) { + AbstractObjectOfLanguage currentParam = originalParameters.get(i); + AbstractObjectOfLanguage newParam = currentParam; + + if(currentParam.isGeneratorClass()) { + assert typeMappings.contains(currentParam.getType()); + newParam = ((ParameterGenerator) currentParam).generateInstance(parsedTypeParameters, parsedParameters, typeMappings, originalParameters, symtab.get(valuesUnderScope.get(currentParam.getName())), symtab, visitor, scope); + } + + newInstance.addParameter(newParam); + addToSymtab(newInstance, newParam.getName(), newParam, symtab); + } + + addToSymtab(newInstance, "apply", symtab); + + // this.handleGenericsUnderScope(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, symtab, visitor, scope, newInstance); + + return newInstance; + } + } + + class ControlTypeDeclarationGenerator extends Generator { + @Override + public LObjectKind getConstructType() { + return LObjectKind.CONTROLTYPEDECLARATIONGENERATOR; + } + + public ControlTypeDeclarationGenerator(ControlTypeDeclaration controlTypeDeclaration) { + super(controlTypeDeclaration); + } + + public ControlTypeDeclaration generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + ControlTypeDeclaration newInstance = new ControlTypeDeclaration(this.getName(), this.getNameSpace()); + + // if(! parsedParameters.isEmpty()) { + // assert parameterMappings.size() == parsedParameters.size(); + // } + + ArrayList originalParameters = parameterMappings; + for(int i = 0; i < originalParameters.size(); i++) { + AbstractObjectOfLanguage currentParam = originalParameters.get(i); + AbstractObjectOfLanguage newParam = currentParam; + + if(currentParam.isGeneratorClass()) { + assert typeMappings.contains(currentParam.getType()); + newParam = ((ParameterGenerator) currentParam).generateInstance(parsedTypeParameters, parsedParameters, typeMappings, originalParameters, symtab.get(valuesUnderScope.get(currentParam.getName())), symtab, visitor, scope); + } + + newInstance.addParameter(newParam); + addToSymtab(newInstance, newParam.getName(), newParam, symtab); + } + + addToSymtab(newInstance, "apply", symtab); + + // this.handleGenericsUnderScope(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, symtab, visitor, scope, newInstance); + + return newInstance; + } + } + + class ExternDeclarationGenerator extends Generator { + @Override + public LObjectKind getConstructType() { + return LObjectKind.EXTERNDECLARATIONGENERATOR; + } + + public ExternDeclarationGenerator(ExternDeclaration externDeclaration) { + super(externDeclaration); + } + + public ExternDeclaration generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + // System.out.println("generating for: " + this.getName()); + // assert this.getOptTypeParameters().size() == parsedTypeParameters.size() : "optypeparam size: " + this.getOptTypeParameters().size() + " parsedtype: " + parsedTypeParameters.size(); // proven unnecessary with issue2480.p4 + // assert parameterMappings.size() == parsedParameters.size() : this.getName() + " parmetermapping size: " + parameterMappings.size() + " parsedparameters: " + parsedParameters.size(); // issue2273 - since constructors make the extern declaration itself a function + ExternDeclaration newInstance = new ExternDeclaration(this.getName(), this.getNameSpace()); + + for(String names : valuesUnderScope.keySet()) { + AbstractObjectOfLanguage childUnderScope = valuesUnderScope.get(names); + AbstractObjectOfLanguage newChildToAdd; + if(childUnderScope.getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + newChildToAdd = childUnderScope; + } + else if(childUnderScope.isGeneratorClass()) { + newChildToAdd = ((Generator) childUnderScope).generateInstance(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, valuesUnderScope, symtab, visitor, scope); + } else if(childUnderScope.getConstructType() == LObjectKind.TYPEPARAMETER) { + // Type parameters are a child of functions since they are looked up in symtab when setting types of variables + // so just ignore this + if(typeMappings.contains(childUnderScope)) { + // we do not add it back since the type parameter is defined in this invocation + // and will no longer be generic + continue; + } + newChildToAdd = childUnderScope; + } else if(childUnderScope.getName().equals(this.getName())) { + // constructor + newChildToAdd = addToSymtab(newInstance, childUnderScope.getName(), symtab); + + ArrayList originalParameters = parameterMappings; + for(int i = 0; i < originalParameters.size(); i++) { + AbstractObjectOfLanguage currentParam = originalParameters.get(i); + AbstractObjectOfLanguage newParam = currentParam; + + if(currentParam.isGeneratorClass()) { + assert typeMappings.contains(currentParam.getType()); + newParam = ((ParameterGenerator) currentParam).generateInstance(parsedTypeParameters, parsedParameters, typeMappings, originalParameters, symtab.get(valuesUnderScope.get(currentParam.getName())), symtab, visitor, scope); + } + + newInstance.addParameter(newParam); + newChildToAdd = newParam; + // addToSymtab(newInstance, newParam.getName(), newParam, symtab); + } + } else if(childUnderScope.hasAssociatedType() && childUnderScope.getType().getConstructType() == LObjectKind.TYPEPARAMETER) { + assert false : "NEED TO HANDLE THIS! " + childUnderScope.getName() + " has generic type: " + childUnderScope.getType().getName() + " of construct: " + childUnderScope.getConstructType(); + newChildToAdd = childUnderScope; + } else { + newChildToAdd = childUnderScope; + } + + addToSymtab(newInstance, newChildToAdd.getName(), newChildToAdd, symtab); + } + + return newInstance; + } + } + + class FunctionPrototypeGenerator extends Generator { + // not final for generic return types that have to be of this name space, so they will be added later when this + // object is created and used as that generic type's scope. + @Override + public LObjectKind getConstructType() { + return LObjectKind.FUNCTIONPROTOTYPEGENERATOR; + } + + public void setType(AbstractObjectOfLanguage typeOrVoid) { + ((FunctionPrototype) this.getRegularLanguageObject()).setType(typeOrVoid); + } + + public FunctionPrototypeGenerator(FunctionPrototype functionPrototype){ + super(functionPrototype); + } + + public AbstractObjectOfLanguage generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + return this.generateInstance(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, valuesUnderScope, symtab, visitor, scope, LObjectKind.FUNCTIONPROTOTYPE); + } + public AbstractObjectOfLanguage generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope, + LObjectKind classType) { + AbstractObjectOfLanguage newType; + AbstractObjectOfLanguage typeOrVoid = super.getRegularLanguageObject().getType(); + boolean doesHaveTypeParameters = false; + if(typeOrVoid.getConstructType() == LObjectKind.TYPEPARAMETER) { + // can pull this out to be a new helper function + if(! typeMappings.contains(typeOrVoid)) { + doesHaveTypeParameters = true; + newType = typeOrVoid; + } else { + assert typeMappings.contains(typeOrVoid) : this.getName() + " is supposed to contain the generic: " + typeOrVoid.getName(); + + if(parsedTypeParameters.isEmpty()) { + assert doesParameterListContainThisGeneric(parameterMappings, typeOrVoid); + int indexOfGeneric = getIndexOfParameterWithTheGeneric(parameterMappings, typeOrVoid); + // assert indexOfGeneric >= 0 : "Generic: " + typeOrVoid.getName() + " not present inside generator class"; + newType = parsedParameters.get(indexOfGeneric); + if(newType.hasAssociatedType()) { + newType = newType.getType(); + } + } else { + int indexOfGeneric = typeMappings.indexOf(typeOrVoid); + newType = parsedTypeParameters.get(indexOfGeneric); + } + } + } else { + newType = typeOrVoid; + } + + // assert parameterMappings.size() == parsedParameters.size(); + FunctionPrototype newInstance = getRespectiveFunctionPrototypeClass(this.getName(), this.getNameSpace(), newType, classType); + // FunctionPrototype newInstance = new FunctionPrototype(this.getName(), this.getNameSpace(), newType); + FunctionPrototypeGenerator newPrototypeInstance = null; + + // ArrayList parameterMappings = parameterMappings; + if(! doesHaveTypeParameters) { + for(int i = 0; i < this.getParameters().size(); i++) { + AbstractObjectOfLanguage currentParam = this.getParameters().get(i); + if(currentParam.getType().getConstructType() == LObjectKind.TYPEPARAMETER) { + // System.out.println(this.getName() + " has: " + this.getParameters().size() + " and given: " + parsedParameters.size()); + if(! typeMappings.contains(currentParam.getType())) { + if(parsedParameters.isEmpty() || + parsedParameters.size() != this.getParameters().size() || // when a child is called from parent + parsedParameters.get(i).isGeneratorClass() || + parsedParameters.get(i).getConstructType() == LObjectKind.TYPEPARAMETER || + (parsedParameters.get(i).hasAssociatedType() && parsedParameters.get(i).getType().getConstructType() == LObjectKind.TYPEPARAMETER)) { + // System.out.println("marked as generator becaues of: " + currentParam.getName()); + doesHaveTypeParameters = true; + break; + } + } + } + } + } + + if(doesHaveTypeParameters){ + // newPrototypeInstance = new FunctionPrototypeGenerator(newInstance); + newPrototypeInstance = getRespectiveFunctionPrototypeGeneratorClass(newInstance); + for(TypeParameter e : this.getOptTypeParameters()) { + newPrototypeInstance.addOptTypeParameters(e); + } + } + + // We pass in parent scope for cases when functionPrototype is part of a parent construct (functionDeclaration & externFunctionDeclaration) + // where the parameters are added to the parent scope and not the functionPrototype scope + AbstractObjectOfLanguage parentScope; + if(doesHaveTypeParameters) { + parentScope = newPrototypeInstance; + } else { + parentScope = newInstance; + } + // TODO: this.getParameters vs parameterMappings + for(int i = 0; i < this.getParameters().size(); i++) { + AbstractObjectOfLanguage newParam; + AbstractObjectOfLanguage currentParam = this.getParameters().get(i); + + if(currentParam.isGeneratorClass()) { + newParam = ((ParameterGenerator) currentParam).generateInstance(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, symtab.get(valuesUnderScope.get(currentParam.getName())), symtab, visitor, scope); + } else { + newParam = currentParam; + } + + if(doesHaveTypeParameters) { + assert newPrototypeInstance != null; + newPrototypeInstance.addParameter(newParam); + } else { + newInstance.addParameter(newParam); + } + + if(newParam.getType().getConstructType() == LObjectKind.TYPEPARAMETER) { + assert newParam.isGeneratorClass() : newParam.getName() + " is expected to be a generator class"; + addToSymtab(parentScope, newParam.getType().getName(), newParam.getType(), symtab); + } + + addToSymtab(parentScope, newParam.getName(), newParam, symtab); + } + + return (doesHaveTypeParameters ? newPrototypeInstance : newInstance); + } + } + + class ExternFunctionDeclarationGenerator extends FunctionPrototypeGenerator { + @Override + public LObjectKind getConstructType() { + return LObjectKind.EXTERNFUNCTIONDECLARATIONGENERATOR; + } + + public ExternFunctionDeclarationGenerator(ExternFunctionDeclaration externDeclaration){ + super(externDeclaration); + } + + public AbstractObjectOfLanguage generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + + // AbstractObjectOfLanguage externObj = new ExternFunctionDeclaration(this.getName(), this.getNameSpace()); + // AbstractObjectOfLanguage functionPrototype = this.getFunctionPrototype().generateInstance(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, valuesUnderScope, symtab, externObj); + AbstractObjectOfLanguage functionPrototype = super.generateInstance(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, valuesUnderScope, symtab, visitor, scope, LObjectKind.EXTERNFUNCTIONDECLARATION); + + // if(functionPrototype.isGeneratorClass()) { + // externObj = new ExternFunctionDeclarationGenerator((ExternFunctionDeclaration) externObj); + // // ((ExternFunctionDeclarationGenerator) externObj).setFunctionPrototype((FunctionPrototypeGenerator) functionPrototype); + // } else { + // // ((ExternFunctionDeclaration) externObj).setFunctionPrototype((FunctionPrototype) functionPrototype); + // } + + // this.handleGenericsUnderScope(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, symtab, visitor, scope, functionPrototype); + + return functionPrototype; + } + } + + class VariableGenerator extends Generator { + @Override + public LObjectKind getConstructType() { + return LObjectKind.VARIABLEGENERATOR; + } + + boolean hasAssignedExpression() { + return (((Variable) this.getRegularLanguageObject()).getAssignedExpression() != null); + } + + public AbstractObjectOfLanguage getAssignedExpression() { + return (((Variable) this.getRegularLanguageObject()).getAssignedExpression()); + } + + public void setAssignedExpression(AbstractObjectOfLanguage expression) { + ((Variable) this.getRegularLanguageObject()).assignedExpression = expression; + } + + public VariableGenerator(Variable variable) { + super(variable); + } + + public AbstractObjectOfLanguage generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + AbstractObjectOfLanguage newVarType; + if(this.getType().isGeneratorClass()) { + // System.out.println("Type of variable is of generator class. Generating it. Type: " + this.getType().getName() + " of construct: " + this.getType().getConstructType()); + newVarType = ((Generator) this.getType()).generateInstance(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, valuesUnderScope, symtab, visitor, scope); + // System.out.println("generated type of variable: " + newVarType.getConstructType()); + } else { + if(! typeMappings.contains(this.getType())) { + // the generic type of this variable is not yet defined, + // so still generic thus still generator type + return this; + } + + if(parsedTypeParameters.isEmpty()) { + // if(parameterMappings == null) { + // System.err.println("Cannot be null when no type parameters are passed!"); + // System.exit(1); + // } + assert parameterMappings != null; + assert doesParameterListContainThisGeneric(parameterMappings, this.getType()) : this.getName(); + int indexOfGeneric = getIndexOfParameterWithTheGeneric(parameterMappings, this.getType()); + // assert indexOfGeneric >= 0 : "Generic: " + this.getType().getName() + " not present inside generator class"; + newVarType = parsedParameters.get(indexOfGeneric); + } else { + int indexOfGeneric = typeMappings.indexOf(this.getType()); + newVarType = parsedTypeParameters.get(indexOfGeneric); + } + } + + if(newVarType.hasAssociatedType()) { + assert newVarType.getType().getConstructType() != LObjectKind.TYPEPARAMETER && !newVarType.getType().isGeneratorClass(); + newVarType = newVarType.getType(); + } + AbstractObjectOfLanguage newVar = new Variable(this.getName(), this.getNameSpace(), newVarType, this.getAssignedExpression()); + + // if(newVarType.getConstructType() == LObjectKind.TYPEPARAMETER) { + // newVar = new VariableGenerator((Variable) newVar); + // } + + return newVar; + } + } + + class FunctionDeclarationGenerator extends FunctionPrototypeGenerator { + @Override + public LObjectKind getConstructType() { + return LObjectKind.FUNCTIONDECLARATIONGENERATOR; + } + + @Override + public boolean isScoped() { + return true; + } + + public void setBlockStatement(AbstractObjectOfLanguage blockStatement) { + assert ((FunctionDeclaration) this.getRegularLanguageObject()).getBlockStatement() == null; + + ((FunctionDeclaration) this.getRegularLanguageObject()).setBlockStatement(blockStatement); + } + + public AbstractObjectOfLanguage getBlockStatement() { + return ((FunctionDeclaration) this.getRegularLanguageObject()).getBlockStatement(); + } + + public FunctionDeclarationGenerator(FunctionDeclaration functionDeclaration){ + super(functionDeclaration); + } + + public AbstractObjectOfLanguage generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + + // AbstractObjectOfLanguage functionObj = new FunctionDeclaration(this.getName(), this.getNameSpace()); + AbstractObjectOfLanguage functionPrototype = super.generateInstance(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, valuesUnderScope, symtab, visitor, scope, LObjectKind.FUNCTIONDECLARATION); + if(functionPrototype.isGeneratorClass()) { + // functionObj = new FunctionDeclarationGenerator((FunctionDeclaration) functionObj); + // ((FunctionDeclarationGenerator) functionObj).setFunctionPrototype((FunctionPrototypeGenerator) functionPrototype); + ((FunctionDeclarationGenerator) functionPrototype).setBlockStatement(((FunctionDeclaration) this.getRegularLanguageObject()).getBlockStatement()); + } else { + // ((FunctionDeclaration) functionObj).setFunctionPrototype((FunctionPrototype) functionPrototype); + ((FunctionDeclaration) functionPrototype).setBlockStatement(((FunctionDeclaration) this.getRegularLanguageObject()).getBlockStatement()); + } + + + // Taking care of values under the scope + addGenericsInSymtab(parsedTypeParameters, typeMappings, parameterMappings, parsedParameters, functionPrototype, symtab); + + Iterator itr = this.getNode().iterator(); + scope.add(functionPrototype); + Object nextobj = this.getNode().get(1); + + if(((GNode) nextobj).getName() == "Conditional") { + // since first child is the presence condition + nextobj = ((GNode) nextobj).get(1); + } + + assert nextobj instanceof GNode; + visitor.dispatch((GNode) nextobj); + scope.pop(); + + removeFromSymtab(functionPrototype, typeMappings, symtab); + + // this.handleGenericsUnderScope(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, symtab, visitor, scope, functionPrototype); + + return functionPrototype; + } + } + + class ParameterGenerator extends VariableGenerator { + @Override + public LObjectKind getConstructType() { + return LObjectKind.PARAMETERGENERATOR; + } + + public ParameterGenerator(Parameter parameter) { + super(parameter); + } + + public ConstantTreeGlobalObjects getDirection() { + return ((Parameter) this.getRegularLanguageObject()).getDirection(); + } + + // public AbstractObjectOfLanguage generateInstance(ArrayList parsedTypeParameters, + // ArrayList parsedParameters, + // ArrayList typeMappings, + // Map valuesUnderScope, + // Map> symtab) { + // return this.generateInstance(parsedTypeParameters, parsedParameters, typeMappings, null, valuesUnderScope, symtab); + // } + + public AbstractObjectOfLanguage generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + AbstractObjectOfLanguage newParamType; + if(! typeMappings.contains(this.getType())) { + // the generic type of this variable is not yet defined, + // so still generic thus still generator type + return this; + } + + assert typeMappings.contains(this.getType()); + + if(parsedTypeParameters.isEmpty()) { + // if(parameterMappings == null) { + // System.err.println("Cannot be null when no type parameters are passed!"); + // System.exit(1); + // } + assert parameterMappings != null; + assert doesParameterListContainThisGeneric(parameterMappings, this.getType()) : this.getName(); + int indexOfGeneric = getIndexOfParameterWithTheGeneric(parameterMappings, this.getType()); + // assert indexOfGeneric >= 0 : "Generic: " + this.getType().getName() + " not present inside generator class"; + newParamType = parsedParameters.get(indexOfGeneric); + } else { + int indexOfGeneric = typeMappings.indexOf(this.getType()); + newParamType = parsedTypeParameters.get(indexOfGeneric); + } + + if(newParamType.hasAssociatedType()) { + assert newParamType.getType().getConstructType() != LObjectKind.TYPEPARAMETER && !newParamType.getType().isGeneratorClass(); + newParamType = newParamType.getType(); + } + + // System.out.println("replacing parameter with type of: " + this.getName() + " with new type: " + newParamType.getName() + " (old type: " + this.getType().getName() + ")"); + + Parameter newParam = new Parameter(this.getName(), this.getNameSpace(), newParamType, this.getDirection(), this.getAssignedExpression()); + + return newParam; + } + } + + class HeaderTypeDeclarationGenerator extends Generator { + @Override + public LObjectKind getConstructType() { + return LObjectKind.HEADERTYPEDECLARATIONGENERATOR; + } + + @Override + public boolean isScoped() { + return true; + } + + ArrayList getStructFieldList() { + return ((HeaderTypeDeclaration) this.getRegularLanguageObject()).getStructFieldList(); + } + + public boolean hasStructFieldList() { + return ((HeaderTypeDeclaration) this.getRegularLanguageObject()).hasStructFieldList(); + } + + public void addToStructFieldList(StructField structField) { + ((HeaderTypeDeclaration) this.getRegularLanguageObject()).addToStructFieldList(structField); + } + + HeaderTypeDeclarationGenerator(HeaderTypeDeclaration headerTypeDeclaration) { + super(headerTypeDeclaration); + } + + public HeaderTypeDeclaration generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + HeaderTypeDeclaration headerTypeDecl = new HeaderTypeDeclaration(this.getName(), this.getNameSpace()); + // System.out.println("Generating instance of header: " + this.getName()); + assert parsedParameters.isEmpty() && parameterMappings.isEmpty() : "Haven't explored cases where header is invoked in a nested block where the parent block has parameters passed in (headers do not have passed in parameters, just generic types)."; + assert typeMappings.size() == this.getOptTypeParameters().size(); + + // Taking care of values under the scope + addGenericsInSymtab(parsedTypeParameters, typeMappings, parameterMappings, parsedParameters, headerTypeDecl, symtab); + + Iterator itr = this.getNode().iterator(); + scope.add(headerTypeDecl); + Object nextobj = this.getNode().get(5); + + if(((GNode) nextobj).getName() == "Conditional") { + // since first child is the presence condition + nextobj = ((GNode) nextobj).get(1); + } + + assert nextobj instanceof GNode; + visitor.dispatch((GNode) nextobj); + scope.pop(); + + removeFromSymtab(headerTypeDecl, typeMappings, symtab); + + /// default functions associated with headers + FunctionPrototype isValid = new FunctionPrototype("isValid", headerTypeDecl, ((AbstractObjectOfLanguage) valuesUnderScope.get("isValid")).getType()); + FunctionPrototype setValid = new FunctionPrototype("setValid", headerTypeDecl, ((AbstractObjectOfLanguage) valuesUnderScope.get("setValid")).getType()); + FunctionPrototype setInvalid = new FunctionPrototype("setInvalid", headerTypeDecl, ((AbstractObjectOfLanguage) valuesUnderScope.get("setInvalid")).getType()); + addToSymtab(headerTypeDecl, "isValid", isValid, symtab); + addToSymtab(headerTypeDecl, "setValid", setValid, symtab); + addToSymtab(headerTypeDecl, "setInvalid", setInvalid, symtab); + + + // this.handleGenericsUnderScope(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, symtab, visitor, scope, headerTypeDecl); + + return headerTypeDecl; + + } + } + + class StructTypeDeclarationGenerator extends Generator { + @Override + public LObjectKind getConstructType() { + return LObjectKind.STRUCTTYPEDECLARATIONGENERATOR; + } + + @Override + public boolean isScoped() { + return true; + } + + ArrayList getStructFieldList() { + return ((StructTypeDeclaration) this.getRegularLanguageObject()).getStructFieldList(); + } + + public boolean hasStructFieldList() { + return ((StructTypeDeclaration) this.getRegularLanguageObject()).hasStructFieldList(); + } + + public void addToStructFieldList(StructField structField) { + ((StructTypeDeclaration) this.getRegularLanguageObject()).addToStructFieldList(structField); + } + + StructTypeDeclarationGenerator(StructTypeDeclaration structTypeDeclaration) { + super(structTypeDeclaration); + } + + public AbstractObjectOfLanguage generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + AbstractObjectOfLanguage newInstance = new StructTypeDeclaration(this.getName(), this.getNameSpace()); + + + assert parsedParameters.isEmpty() && parameterMappings.isEmpty() : "Haven't explored cases where struct type is invoked in a nested block where the parent block has parameters passed in (struct types do not have passed in parameters, just generic types)."; + assert typeMappings.size() == this.getOptTypeParameters().size(); + + // TODO: CGTest_generic_struct.p4 case + for(int i = 0; i < parsedTypeParameters.size(); i++) { + AbstractObjectOfLanguage passedInType = parsedTypeParameters.get(i); + if(passedInType.getConstructType() == LObjectKind.TYPEPARAMETER || + passedInType.isGeneratorClass() || + passedInType.hasAssociatedType() && (passedInType.getType().isGeneratorClass() || passedInType.getType().getConstructType() == LObjectKind.TYPEPARAMETER)) { + return this; + } + } + + addGenericsInSymtab(parsedTypeParameters, typeMappings, parameterMappings, parsedParameters, newInstance, symtab); + + Iterator itr = this.getNode().iterator(); + scope.add(newInstance); + Object nextobj = this.getNode().get(5); + + if(((GNode) nextobj).getName() == "Conditional") { + // since first child is the presence condition + nextobj = ((GNode) nextobj).get(1); + } + + assert nextobj instanceof GNode; + visitor.dispatch((GNode) nextobj); + scope.pop(); + + removeFromSymtab(newInstance, typeMappings, symtab); + // this.handleGenericsUnderScope(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, symtab, visitor, scope, newInstance); + return newInstance; + + } + } + + class HeaderUnionDeclarationGenerator extends Generator { + @Override + public LObjectKind getConstructType() { + return LObjectKind.HEADERUNIONDECLARATIONGENERATOR; + } + + ArrayList getStructFieldList() { + return ((HeaderUnionDeclaration) this.getRegularLanguageObject()).getStructFieldList(); + } + + public boolean hasStructFieldList() { + return ((HeaderUnionDeclaration) this.getRegularLanguageObject()).hasStructFieldList(); + } + + public void addToStructFieldList(StructField structField) { + ((HeaderUnionDeclaration) this.getRegularLanguageObject()).addToStructFieldList(structField); + } + + HeaderUnionDeclarationGenerator(HeaderUnionDeclaration headerUnionDeclaration) { + super(headerUnionDeclaration); + } + + public AbstractObjectOfLanguage generateInstance(ArrayList parsedTypeParameters, + ArrayList parsedParameters, + ArrayList typeMappings, + ArrayList parameterMappings, + Map valuesUnderScope, + Map> symtab, + Visitor visitor, + Stack scope) { + AbstractObjectOfLanguage newInstance = new HeaderUnionDeclaration(this.getName(), this.getNameSpace()); + + assert parsedParameters.isEmpty() && parameterMappings.isEmpty() : "Haven't explored cases where struct type is invoked in a nested block where the parent block has parameters passed in (struct types do not have passed in parameters, just generic types)."; + assert typeMappings.size() == this.getOptTypeParameters().size(); + + + // Taking care of values under the scope + addGenericsInSymtab(parsedTypeParameters, typeMappings, parameterMappings, parsedParameters, newInstance, symtab); + + Iterator itr = this.getNode().iterator(); + scope.add(newInstance); + Object nextobj = this.getNode().get(5); + + if(((GNode) nextobj).getName() == "Conditional") { + // since first child is the presence condition + nextobj = ((GNode) nextobj).get(1); + } + + assert nextobj instanceof GNode; + visitor.dispatch((GNode) nextobj); + scope.pop(); + + removeFromSymtab(newInstance, typeMappings, symtab); + + // this.handleGenericsUnderScope(parsedTypeParameters, parsedParameters, typeMappings, parameterMappings, symtab, visitor, scope, newInstance); + + return newInstance; + + } + } + + // End of generator class + + // Regular classes + + class LanguageObject extends RegularLanguageObject { + private final boolean isScoped; + @Override + public LObjectKind getConstructType() { + return LObjectKind.DEFAULT; + } + + @Override + public boolean isScoped() { + return isScoped; + } + + public LanguageObject(String name, AbstractObjectOfLanguage nameSpace, boolean isScoped) { + super(name, nameSpace); + this.isScoped = isScoped; + } + + public LanguageObject(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + this.isScoped = false; + } + } + + /** + * Class used to declare global constant language objects like global scope. + */ + class ConstantTreeGlobalObjects extends RegularLanguageObject { + private final boolean isScoped; + @Override + public LObjectKind getConstructType() { + return LObjectKind.CONSTANTVALUE; + } + + @Override + public boolean isScoped() { + return isScoped; + } + + @Override + public AbstractObjectOfLanguage getNameSpace() { + // System.err.println("ConstantTreeGlobalObjects do not have a namespace since they are global level"); + // System.exit(1); + assert false : "ConstantTreeGlobalObjects do not have a namespace since they are global level"; + + return null; + } + + public ConstantTreeGlobalObjects(String name, boolean isScoped) { + super(name, null); + this.isScoped = isScoped; + } + + public ConstantTreeGlobalObjects(String name) { + super(name, null); + this.isScoped = true; + } + } + + class HeaderTypeDeclaration extends RegularLanguageObject { + private final ArrayList structFieldList; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.HEADERTYPEDECLARATION; + } + + @Override + public boolean isScoped() { + return true; + } + + ArrayList getStructFieldList() { + return this.structFieldList; + } + + public boolean hasStructFieldList() { + return !this.structFieldList.isEmpty(); + } + + public void addToStructFieldList(StructField structField) { + this.structFieldList.add(structField); + } + + HeaderTypeDeclaration(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + this.structFieldList = new ArrayList<>(); + } + } + + class HeaderUnionDeclaration extends RegularLanguageObject { + private final ArrayList structFieldList; + @Override + public LObjectKind getConstructType() { + return LObjectKind.HEADERUNIONDECLARATION; + } + + @Override + public boolean isScoped() { + return true; + } + + ArrayList getStructFieldList() { + return this.structFieldList; + } + + public boolean hasStructFieldList() { + return !this.structFieldList.isEmpty(); + } + + public void addToStructFieldList(StructField structField) { + this.structFieldList.add(structField); + } + + HeaderUnionDeclaration(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + this.structFieldList = new ArrayList<>(); + } + } + + class HeaderStackType extends RegularLanguageObject { + AbstractObjectOfLanguage parentScope; + @Override + public LObjectKind getConstructType() { + return LObjectKind.HEADERSTACKTYPE; + } + + @Override + public boolean isScoped() { + return true; + } + + @Override + public AbstractObjectOfLanguage getNameSpace() { + return this.parentScope; + } + + public HeaderStackType(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage parentScope) { + super(name, nameSpace); + this.parentScope = parentScope; + } + } + + class StructTypeDeclaration extends RegularLanguageObject { + private final ArrayList structFieldList; + @Override + public LObjectKind getConstructType() { + return LObjectKind.STRUCTTYPEDECLARATION; + } + + @Override + public boolean isScoped() { + return true; + } + + ArrayList getStructFieldList() { + return this.structFieldList; + } + + public boolean hasStructFieldList() { + return !this.structFieldList.isEmpty(); + } + + public void addToStructFieldList(StructField structField) { + this.structFieldList.add(structField); + } + + StructTypeDeclaration(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + this.structFieldList = new ArrayList<>(); + } + } + + class EnumDeclaration extends RegularLanguageObject { + // normal enums and serializable enums that have an associated type + private final AbstractObjectOfLanguage type; + private final ArrayList identifierList; + // private final ArrayList specifiedIdentifierList; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.ENUMDECLARATION; + } + + @Override + public boolean isScoped() { + return true; + } + + boolean doesEnumHaveType() { + return this.type != null; + } + + public AbstractObjectOfLanguage getEnumType() { + return this.type; + } + + public boolean hasIdentifiersList() { + return (this.identifierList != null && + !this.identifierList.isEmpty()); + } + + // public boolean hasSpecifiedIdentifiersList() { + // return (this.specifiedIdentifierList != null + // && !this.specifiedIdentifierList.isEmpty()); + // } + + public void addToIdentifierList(AbstractObjectOfLanguage identifier) { + this.identifierList.add(identifier); + } + + // public void addToSpecifiedIdentifierList(SpecifiedIdentifier identifier) { + // this.specifiedIdentifierList.add(identifier); + // } + + public ArrayList getIdentifierList() { + return this.identifierList; + } + + // public ArrayList getSpecifiedIdentifierList() { + // return this.specifiedIdentifierList; + // } + + public EnumDeclaration(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + this.type = null; + this.identifierList = new ArrayList<>(); + // this.specifiedIdentifierList = null; + } + + public EnumDeclaration(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage type) { + super(name, nameSpace); + this.type = type; + // this.specifiedIdentifierList = new ArrayList<>(); + this.identifierList = new ArrayList<>(); + } + } + + class TypeDefDeclaration extends RegularLanguageObject { + // typdef vs type -> difference is made in parsing context where both values + // are stored in symtab for TYPEDEF while only newly declared variable name is stored + // in symtab for TYPE + private final AbstractObjectOfLanguage type; + private final boolean isTypeDef; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.TYPEDEFDECLARATION; + } + + /* Since type can either be of TypeRef or derivedTypeDeclaration + where derivedTypeDeclaration can be headerTypeDeclaration, headerUnionDeclaration + structTypeDeclaration, or enumDeclaration, and they can be scoped. + */ + @Override + public boolean isScoped() { + return type.isScoped(); + } + + @Override + boolean hasAssociatedType() { + return true; + } + + @Override + public AbstractObjectOfLanguage getType() { + return this.type; + } + + public boolean isTypeDef() { + return this.isTypeDef; + } + + public TypeDefDeclaration(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage type, Boolean typeDef) { + super(name, nameSpace); + this.type = type; + this.isTypeDef = typeDef; + } + } + + class ParserTypeDeclaration extends RegularLanguageObject { + @Override + public LObjectKind getConstructType() { + return LObjectKind.PARSERTYPEDECLARATION; + } + + @Override + public boolean isScoped() { + return false; + } + + public ParserTypeDeclaration(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + } + } + + class PackageTypeDeclaration extends RegularLanguageObject { + @Override + public LObjectKind getConstructType() { + return LObjectKind.PACKAGETYPEDECLARATION; + } + + @Override + public boolean isScoped() { + return false; + } + + public PackageTypeDeclaration(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + } + } + + /** + * This class is specifically for the production: + * optAnnotations EXTERN nonTypeName optTypeParameters L_BRACE methodPrototypes R_BRACE + * + * Note: + * optAnnotations EXTERN name SEMICOLON -- not valid anymore in new language spec + * + * externFunctionDeclaration is under another class + */ + class ExternDeclaration extends RegularLanguageObject { + // method prototypes can occur only inside the first production of extern declaration + // private final ArrayList methodPrototypes; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.EXTERNDECLARATION; + } + + // technically scoped for "optAnnotations EXTERN name SEMICOLON" production as well + @Override + public boolean isScoped() { + return true; + } + + public ExternDeclaration(String name, AbstractObjectOfLanguage scope) { + super(name, scope); + // methodPrototypes = new ArrayList<>(); + } + + // public ArrayList getMethodPrototypes() { + // return this.methodPrototypes; + // } + + // public void addMethodPrototype(MethodPrototype newMethodPrototype) { + // this.methodPrototypes.add(newMethodPrototype); + // } + + // public boolean hasMethodPrototypes() { + // return !this.methodPrototypes.isEmpty(); + // } + } + + class ExternFunctionDeclaration extends FunctionPrototype { + @Override + public LObjectKind getConstructType() { + return LObjectKind.EXTERNFUNCTIONDECLARATION; + } + + public ExternFunctionDeclaration(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage typeOrVoid){ + super(name, nameSpace, typeOrVoid); + } + } + + class FunctionDeclaration extends FunctionPrototype { + private AbstractObjectOfLanguage blockStatement; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.FUNCTIONDECLARATION; + } + + public void setBlockStatement(AbstractObjectOfLanguage blockStatement) { + assert this.blockStatement == null; + + this.blockStatement = blockStatement; + } + + public AbstractObjectOfLanguage getBlockStatement() { + return this.blockStatement; + } + + public FunctionDeclaration(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage typeOrVoid){ + super(name, nameSpace, typeOrVoid); + this.blockStatement = null; + } + } + + class FunctionPrototype extends RegularLanguageObject { + // not final for generic return types that have to be of this name space, so they will be added later when this + // object is created and used as that generic type's scope. + private AbstractObjectOfLanguage typeOrVoid; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.FUNCTIONPROTOTYPE; + } + + @Override + public boolean isScoped() { + return true; + } + + @Override + public boolean hasAssociatedType() { + return true; + } + + @Override + AbstractObjectOfLanguage getType() { + return this.typeOrVoid; + } + + public void setType(AbstractObjectOfLanguage typeOrVoid) { + // assert this.typeOrVoid == null; + if(this.typeOrVoid != null) { + if(this.typeOrVoid.getName() != "UNDECLARED OBJECT") { + System.err.println("Old type being replaced for: " + this.getName() + ". Old type: " + this.typeOrVoid.getName() + ", new type being set: " + typeOrVoid.getName()); + } + } + + this.typeOrVoid = typeOrVoid; + } + + public FunctionPrototype(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage typeOrVoid){ + super(name, nameSpace); + this.typeOrVoid = typeOrVoid; + } + } + + + class FunctionPrototypePlaceHolder extends RegularLanguageObject { + // Class that is stored in symbol table to indicate that there is at least one function that + // exists under the scope with this name but need the number of parameters to get the exact functions + @Override + public LObjectKind getConstructType() { + return LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER; + } + + @Override + public boolean isScoped() { + assert false : "Cannot get scope of placeholder object"; + System.err.println("Cannot get scope of placeholder object"); + System.exit(1); + return false; + } + + @Override + public boolean hasAssociatedType() { + assert false : "Cannot check for types of placeholder object"; + System.err.println("Cannot check for types of placeholder object"); + System.exit(1); + return false; + } + + @Override + AbstractObjectOfLanguage getType() { + assert false : "Cannot get type of placeholder object"; + System.err.println("Cannot get type of placeholder object"); + System.exit(1); + return null; + } + + public FunctionPrototypePlaceHolder(String name, AbstractObjectOfLanguage nameSpace){ + super(name, nameSpace); + } + } + + // combines control type declaration + class ControlTypeDeclaration extends RegularLanguageObject { + @Override + public LObjectKind getConstructType() { + return LObjectKind.CONTROLTYPEDECLARATION; + } + + @Override + public boolean isScoped() { + return true; + } + + public ControlTypeDeclaration(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + } + } + + // Basic AST node classes. Making them new language object to support compiler built in functions + class ControlDeclaration extends RegularLanguageObject { + @Override + public LObjectKind getConstructType() { + return LObjectKind.CONTROLDECLARATION; + } + + @Override + public boolean isScoped() { + return true; + } + + public ControlDeclaration(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + } + } + + class ParserDeclaration extends RegularLanguageObject { + private ParserTypeDeclaration parserTypeDeclaration; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.PARSERDECLARATION; + } + + @Override + public boolean isScoped() { + return true; + } + + public void setParserTypeDeclaration(ParserTypeDeclaration parserTypeDeclaration) { + assert this.parserTypeDeclaration == null; + + this.parserTypeDeclaration = parserTypeDeclaration; + } + + public ParserTypeDeclaration getParserTypeDeclaration() { + return this.parserTypeDeclaration; + } + + public ParserDeclaration(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + } + } + + class TableDeclaration extends RegularLanguageObject { + @Override + public LObjectKind getConstructType() { + return LObjectKind.TABLEDECLARATION; + } + + @Override + public boolean isScoped() { + return true; + } + + public TableDeclaration(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + } + } + + // Support Classes + + class TypeOrVoid extends RegularLanguageObject { + private AbstractObjectOfLanguage typeRef; + private ConstantTreeGlobalObjects voidVar; + private AbstractObjectOfLanguage identifier; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.TYPEORVOID; + } + + @Override + public boolean isScoped() { + return false; + } + + // void and dontcare are still types + @Override + boolean hasAssociatedType() { + return true; + } + + @Override + AbstractObjectOfLanguage getType() { + if(this.typeRef != null) { + return this.typeRef; + } else if(this.identifier != null) { + return this.identifier; + } else { + assert this.voidVar != null; + return this.voidVar; + } + } + + boolean isConstantTreeGlobalObjects() { + return voidVar != null; + } + + boolean isTypeRef() { + return typeRef != null; + } + + boolean isIdentifier() { + return identifier != null; + } + + TypeOrVoid(AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage typeRef, boolean isTypeRef) { + super(typeRef.getName(), nameSpace); + if(isTypeRef) { + this.typeRef = typeRef; + this.identifier = null; + } else { + this.identifier = typeRef; + this.typeRef = null; + } + this.identifier = null; + this.voidVar = null; + } + + TypeOrVoid(AbstractObjectOfLanguage nameSpace, ConstantTreeGlobalObjects voidVar) { + super(voidVar.getName(), nameSpace); + this.identifier = null; + this.typeRef = null; + this.voidVar = voidVar; + } + } + + class Variable extends RegularLanguageObject { + private final AbstractObjectOfLanguage type; + private AbstractObjectOfLanguage assignedExpression; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.VARIABLE; + } + + @Override + public boolean isScoped() { + return false; + } + + @Override + boolean hasAssociatedType() { + return true; + } + + @Override + public AbstractObjectOfLanguage getType() { + return this.type; + } + + boolean hasAssignedExpression() { + return (assignedExpression != null); + } + + public AbstractObjectOfLanguage getAssignedExpression() { + return this.assignedExpression; + } + + public void setAssignedExpression(AbstractObjectOfLanguage expression) { + this.assignedExpression = expression; + } + + public Variable(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage type) { + super(name, nameSpace); + this.type = type; + this.assignedExpression = null; + } + + public Variable(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage type, AbstractObjectOfLanguage assignedExpression) { + super(name, nameSpace); + this.type = type; + this.assignedExpression = assignedExpression; + } + } + + class Parameter extends Variable { + private final ConstantTreeGlobalObjects direction; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.PARAMETER; + } + + @Override + public boolean isScoped() { + return false; + } + + public ConstantTreeGlobalObjects getDirection() { + return this.direction; + } + + // Right now we are assuming that the invoker has already created or retrieved the type and direction object + // and will pass it to us + public Parameter(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage type, ConstantTreeGlobalObjects direction) { + super(name, nameSpace, type); + this.direction = direction; + } + + public Parameter(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage type, ConstantTreeGlobalObjects direction, AbstractObjectOfLanguage assignedExpression) { + super(name, nameSpace, type, assignedExpression); + this.direction = direction; + } + } + + class TypeParameter extends RegularLanguageObject { + @Override + public LObjectKind getConstructType() { + return LObjectKind.TYPEPARAMETER; + } + + @Override + public boolean isScoped() { + return false; + } + + TypeParameter(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + } + } + + class StructField extends RegularLanguageObject { + private final AbstractObjectOfLanguage type; + @Override + public LObjectKind getConstructType() { + return LObjectKind.STRUCTFIELD; + } + + @Override + public boolean isScoped() { + return false; + } + + @Override + boolean hasAssociatedType() { + return true; + } + + @Override + public AbstractObjectOfLanguage getType() { + return this.type; + } + + public StructField(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage typeRef) { + super(name, nameSpace); + this.type = typeRef; + } + } + + class OLangString extends RegularLanguageObject { + @Override + public boolean isScoped() { + return false; + } + + @Override + public LObjectKind getConstructType() { + return LObjectKind.STRING; + } + + public OLangString(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + } + } + + class InvokableLanguageKeyword extends RegularLanguageObject { + @Override + public boolean isScoped() { + return false; + } + + @Override + public LObjectKind getConstructType() { + return LObjectKind.INVOKABLEKEYWORD; + } + + public InvokableLanguageKeyword(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + } + } + + class BuiltinFunction extends RegularLanguageObject { + @Override + public boolean isScoped() { + return false; + } + + @Override + public LObjectKind getConstructType() { + return LObjectKind.BUILTINFUNCTION; + } + + public BuiltinFunction(String name, AbstractObjectOfLanguage nameSpace) { + super(name, nameSpace); + } + } + + class BaseTypes extends RegularLanguageObject { + @Override + public LObjectKind getConstructType() { + return LObjectKind.BASETYPE; + } + + @Override + public boolean isScoped() { + return false; + } + + @Override + public AbstractObjectOfLanguage getNameSpace() { + // System.err.println("ConstantTreeGlobalObjects do not have a namespace since they are global level"); + // System.exit(1); + assert false : "Error: Base types cannot be used as namespaces. Referring to (" + this.getName() + ") base type."; + + return null; + } + + public BaseTypes(String name) { + super(name, null); + } + } + + class AnonymousType extends RegularLanguageObject { + @Override + public LObjectKind getConstructType() { + return LObjectKind.ANONYMOUS; + } + + @Override + public boolean isScoped() { + return false; + } + + @Override + public String getName() { + System.err.println("Error: cannot get name for anonymous types."); + System.exit(1); + return ""; + } + + public AnonymousType(AbstractObjectOfLanguage nameSpace) { + super("", nameSpace); + } + } + + class TupleType extends AnonymousType { + private final ArrayList typeArgumentsList; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.TUPLETYPE; + } + + public void addToTypeArgumentList(AbstractObjectOfLanguage typeArg) { + typeArgumentsList.add(typeArg); + } + + public ArrayList getTypeArgumentList() { + return typeArgumentsList; + } + + public boolean hasTypeArguments() { + return ! typeArgumentsList.isEmpty(); + } + + public TupleType(AbstractObjectOfLanguage nameSpace) { + super(nameSpace); + typeArgumentsList = new ArrayList<>(); + } + } + + class SpecializedType extends RegularLanguageObject { + private final ArrayList typeArgumentsList; + + private final AbstractObjectOfLanguage type; + @Override + public LObjectKind getConstructType() { + return LObjectKind.SPECIALIZEDTYPE; + } + + @Override + public boolean isScoped() { + return false; + } + + @Override + public boolean hasAssociatedType() { + return true; + } + + @Override + public AbstractObjectOfLanguage getType() { + return this.type; + } + + @Override + public AbstractObjectOfLanguage getNameSpace() { + return this.type; + } + + @Override + void addParsedOptTypeParameters(AbstractObjectOfLanguage typeParameter) { + this.type.addParsedOptTypeParameters(typeParameter); + } + + @Override + boolean hasParsedOptTypeParameters() { + return this.type.hasParsedOptTypeParameters(); + } + + @Override + ArrayList getParsedOptTypeParameters() { + return this.type.getParsedOptTypeParameters(); + } + + public void addToTypeArgumentList(AbstractObjectOfLanguage typeArg) { + typeArgumentsList.add(typeArg); + } + + public ArrayList getTypeArgumentList() { + return typeArgumentsList; + } + + public boolean hasTypeArguments() { + return ! typeArgumentsList.isEmpty(); + } + + public SpecializedType(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage type) { + super(name, nameSpace); + this.type = type; + typeArgumentsList = new ArrayList<>(); + } + } + + public class SubClass extends RegularLanguageObject { + AbstractObjectOfLanguage originalClass; + + @Override + public LObjectKind getConstructType() { + return LObjectKind.SUBCLASS; + } + + @Override + public boolean isScoped() { + return true; + } + + @Override + public boolean hasAssociatedType() { + return true; + } + + @Override + public AbstractObjectOfLanguage getType() { + return this.originalClass; + } + + // @Override + // public String getName() { + // return "(" + this.originalClass.getName() + ") " + super.getName(); + // } + + public AbstractObjectOfLanguage getOriginalClass() { + return this.originalClass; + } + + public SubClass(String name, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage originalClass) { + super(name, nameSpace); + this.originalClass = originalClass; + } + } + + // End of regular classes + + public class BaseTypesCollection { + private ArrayList baseTypes; + private Map baseTypeObjects; + private BaseTypes voidObject; + private BaseTypes dontCareObject; + private String voidString = "void"; + private String dontCare = "_"; + + { + baseTypes = new ArrayList<>(); + baseTypes.add("bool"); + baseTypes.add("error"); + baseTypes.add("bit"); + baseTypes.add("string"); + baseTypes.add("int"); + baseTypes.add("varbit"); + + baseTypeObjects = new HashMap<>(); + + for(String type : baseTypes) { + baseTypeObjects.put(type, new BaseTypes(type)); + } + + voidObject = new BaseTypes(voidString); + dontCareObject = new BaseTypes(dontCare); + } + + public boolean isBaseType(String type) { + return baseTypes.contains(type); + } + + public AbstractObjectOfLanguage getLanguageObjectOfBaseType(String type) { + assert baseTypes.contains(type); + + return baseTypeObjects.get(type); + } + + public BaseTypes getVoidLanguageObject() { + return this.voidObject; + } + + public BaseTypes getDontCareLanguageObject() { + return this.dontCareObject; + } + + public boolean isVoid(String type) { + return type == voidString; + } + + public boolean isDontCare(String type) { + return type == dontCare; + } + } + + public class Direction { + private ArrayList directions; + private Map directionTypeObjects; + + { + directions = new ArrayList<>(); + directions.add("in"); + directions.add("out"); + directions.add("inout"); + + directionTypeObjects = new HashMap<>(); + + for(String type : directions) { + directionTypeObjects.put(type, new ConstantTreeGlobalObjects(type)); + } + } + + public ConstantTreeGlobalObjects getLanguageObjectOfDirection(String type) { + assert directions.contains(type); + + return directionTypeObjects.get(type); + } + } + + static class ReservedKeywords { + public static HashSet nonTypeNameKeywords = new HashSet<>(); + public static HashSet nonTableKwNameKeywords = new HashSet<>(); + static { + nonTypeNameKeywords.add("key"); + nonTypeNameKeywords.add("actions"); + nonTypeNameKeywords.add("state"); + nonTypeNameKeywords.add("entries"); + nonTypeNameKeywords.add("type"); + nonTypeNameKeywords.add("apply"); + + nonTableKwNameKeywords.add("state"); + nonTableKwNameKeywords.add("type"); + nonTableKwNameKeywords.add("apply"); + } + + public static boolean isNonTypeNameKeyword(String name) { + return nonTypeNameKeywords.contains(name); + } + + public static boolean isNonTableKwNameKeywords(String name) { + return nonTableKwNameKeywords.contains(name); + } + } + + public AbstractObjectOfLanguage addToSymtab(AbstractObjectOfLanguage scope, String name, Map> symtab) { + LanguageObject newLangObj = new LanguageObject(name, scope); + return addToSymtab(scope, name, newLangObj, symtab); + } + + public AbstractObjectOfLanguage addToSymtab(AbstractObjectOfLanguage scope, String name, AbstractObjectOfLanguage newLangObj, Map> symtab) { + // System.out.println("adding: " + name + " under scope: " + scope.getName() + scope.getConstructType() + " with current construct type: " + newLangObj.getConstructType()); + if( !symtab.containsKey(scope)) { + // System.out.println("new symtab: " + scope.getName() + " of construct: " + scope.getConstructType()); + symtab.put(scope, new HashMap<>()); + } + + if(symtab.get(scope).containsKey(name)) { + boolean isDuplicateFunctionOrMethod = true; + if(newLangObj.getConstructType() == LObjectKind.FUNCTION || + newLangObj.getConstructType() == LObjectKind.METHOD) { + // isDuplicateFunctionOrMethod = isFunctionAndMethodDuplicate(newLangObj, symtab.get(scope).get(name)); + isDuplicateFunctionOrMethod = true; + } + // TODO: Tuples are exceptions + if(isDuplicateFunctionOrMethod) { + System.err.println("Multiple declaration warning (FIX): another entity with the same name (" + + name + + ") already exists"); + } + // System.exit(1); + } else { + // nodeObj = p4LanguageObject.new LanguageObject(name, scope); + symtab.get(scope).put(name, newLangObj); + } + + return newLangObj; + } + + public void addGenericsInSymtab(ArrayList parsedTypeParameters, ArrayList typeMappings, ArrayList parameterMappings, ArrayList parsedParameters, AbstractObjectOfLanguage newInstance, Map> symtab) { + // assert parsedTypeParameters.size() == typeMappings.size() : parsedTypeParameters.size() + " " + typeMappings.size(); + for(int i = 0; i < typeMappings.size(); i++) { + AbstractObjectOfLanguage currentType = typeMappings.get(i), newType; + assert typeMappings.contains(currentType) : "Supposed to contain the generic: " + currentType.getName(); + + if(parsedTypeParameters.isEmpty()) { + assert doesParameterListContainThisGeneric(parameterMappings, currentType); + int indexOfGeneric = getIndexOfParameterWithTheGeneric(parameterMappings, currentType); + // assert indexOfGeneric >= 0 : "Generic: " + currentType.getName() + " not present inside generator class"; + newType = parsedParameters.get(indexOfGeneric); + if(newType.hasAssociatedType()) { + newType = newType.getType(); + } + } else { + int indexOfGeneric = typeMappings.indexOf(currentType); + newType = parsedTypeParameters.get(indexOfGeneric); + } + + Variable newConvertedVar = new Variable(currentType.getName(), newInstance, newType); + addToSymtab(newInstance, newConvertedVar.getName(), newConvertedVar, symtab); + } + } + + public void removeFromSymtab(AbstractObjectOfLanguage scope, ArrayList typeMappings, Map> symtab) { + // System.out.println("adding: " + name + " under scope: " + scope.getName() + scope.getConstructType() + " with current construct type: " + newLangObj.getConstructType()); + if( !symtab.containsKey(scope)) { + System.err.println("Scope: " + scope.getName() + " not found."); + System.exit(1); + } + + for(TypeParameter obj : typeMappings) { + if(symtab.get(scope).containsKey(obj.getName())) { + symtab.get(scope).remove(obj.getName()); + } + } + } + + public int getIndexOfParameterWithTheGeneric(ArrayList parameters, AbstractObjectOfLanguage typeParameter) { + int index = -1; + for(int i = 0; i < parameters.size(); i++) { + assert parameters.get(i).getConstructType() == LObjectKind.PARAMETER || parameters.get(i).getConstructType() == LObjectKind.PARAMETERGENERATOR; + AbstractObjectOfLanguage p = parameters.get(i); + if(p.getType().getConstructType() == LObjectKind.TYPEPARAMETER && + p.getType() == typeParameter) { + index = i; + } + } + + return index; + } + + public boolean doesParameterListContainThisGeneric(ArrayList parameters, AbstractObjectOfLanguage type) { + int indexOfIt = getIndexOfParameterWithTheGeneric(parameters, type); + + if(indexOfIt < 0) { + return false; + } else { + return true; + } + } + + public FunctionPrototype getRespectiveFunctionPrototypeClass(String functionPrototypeName, AbstractObjectOfLanguage nameSpace, AbstractObjectOfLanguage typeOrVoid, LObjectKind classType) { + FunctionPrototype functionPrototypeObj; + switch(classType) { + case FUNCTIONPROTOTYPE: + functionPrototypeObj = new FunctionPrototype(functionPrototypeName, nameSpace, typeOrVoid); + break; + case EXTERNFUNCTIONDECLARATION: + functionPrototypeObj = new ExternFunctionDeclaration(functionPrototypeName, nameSpace, typeOrVoid); + break; + case FUNCTIONDECLARATION: + functionPrototypeObj = new FunctionDeclaration(functionPrototypeName, nameSpace, typeOrVoid); + break; + default: + assert false : "Unhandled class: " + classType.toString(); + functionPrototypeObj = null; + } + + return functionPrototypeObj; + } + + public FunctionPrototypeGenerator getRespectiveFunctionPrototypeGeneratorClass(FunctionPrototype functionPrototypeObj) { + FunctionPrototypeGenerator newInstance; + switch(functionPrototypeObj.getConstructType()) { + case FUNCTIONPROTOTYPE: + newInstance = new FunctionPrototypeGenerator((FunctionPrototype) functionPrototypeObj); + break; + case EXTERNFUNCTIONDECLARATION: + newInstance = new ExternFunctionDeclarationGenerator((ExternFunctionDeclaration) functionPrototypeObj); + break; + case FUNCTIONDECLARATION: + newInstance = new FunctionDeclarationGenerator((FunctionDeclaration) functionPrototypeObj); + break; + default: + assert false : "Unhandled class: " + functionPrototypeObj.getConstructType().toString(); + newInstance = null; + } + + return newInstance; + } +} + +/* +Note: opt type parameters are not allowed inside controlTypeDeclaration if it is used inside control declaration +same with parsers + +When the object is declared -> if it has type parameters in it (whether as type) or as a parameter, mark it as generator +Note: if a type variable is created for that specific object, assert that it is present inside optTypeParameter +7.2.10 -> if it is present in the parent object, need not to be present inside the optTypeParameter + + */ \ No newline at end of file diff --git a/src/superc/p4parser/P4Lexer.java b/src/superc/p4parser/P4Lexer.java index 78ce14b5..346ddc97 100644 --- a/src/superc/p4parser/P4Lexer.java +++ b/src/superc/p4parser/P4Lexer.java @@ -1,4 +1,4 @@ -/* The following code was generated by JFlex 1.4.3 on 5/8/21, 12:10 AM */ +/* The following code was generated by JFlex 1.4.3 on 4/9/22, 2:07 PM */ package superc.p4parser; @@ -15,7 +15,7 @@ /** * This class is a scanner generated by * JFlex 1.4.3 - * on 5/8/21, 12:10 AM from the specification file + * on 4/9/22, 2:07 PM from the specification file * p4lexer.l.i */ class P4Lexer implements superc.core.Lexer { @@ -29,11 +29,12 @@ class P4Lexer implements superc.core.Lexer { /** lexical states */ public static final int PRAGMA_LINE = 4; public static final int YYINITIAL = 0; + public static final int PREPROC = 6; public static final int COMMENT = 2; - public static final int PP_FRACTION_NON_EMPTY = 6; - public static final int RANGE_DOTS = 10; - public static final int PP_FRACTION_CAN_BE_EMPTY = 8; - public static final int RANGE_END = 12; + public static final int PP_FRACTION_NON_EMPTY = 8; + public static final int RANGE_DOTS = 12; + public static final int PP_FRACTION_CAN_BE_EMPTY = 10; + public static final int RANGE_END = 14; /** * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l @@ -42,22 +43,22 @@ class P4Lexer implements superc.core.Lexer { * l is of the form l = 2*k, k a non negative integer */ private static final int ZZ_LEXSTATE[] = { - 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6 + 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6 }; /** * Translates characters to character classes */ private static final String ZZ_CMAP_PACKED = - "\11\0\1\26\1\7\2\0\1\30\22\0\1\105\1\66\1\6\1\61"+ - "\1\0\1\72\1\62\1\3\1\56\1\57\1\71\1\70\1\60\1\24"+ - "\1\25\1\27\1\10\1\20\6\16\2\2\1\101\1\103\1\63\1\65"+ - "\1\67\1\102\1\104\1\12\1\17\1\12\1\13\1\22\1\107\5\1"+ - "\1\106\2\1\1\15\1\23\7\1\1\11\2\1\1\75\1\5\1\76"+ - "\1\73\1\14\1\0\1\31\1\32\1\36\1\44\1\45\1\46\1\54"+ - "\1\52\1\37\1\1\1\53\1\42\1\50\1\4\1\40\1\41\1\1"+ - "\1\35\1\33\1\34\1\47\1\55\1\21\1\51\1\43\1\1\1\77"+ - "\1\64\1\100\1\74\uff81\0"; + "\11\0\1\26\1\7\1\27\1\0\1\30\22\0\1\31\1\70\1\6"+ + "\1\63\1\0\1\74\1\64\1\3\1\60\1\61\1\73\1\72\1\62"+ + "\1\24\1\25\1\32\1\10\1\20\6\16\2\2\1\103\1\105\1\65"+ + "\1\67\1\71\1\104\1\106\1\12\1\17\1\12\1\13\1\22\1\110"+ + "\5\1\1\107\2\1\1\15\1\23\7\1\1\11\2\1\1\77\1\5"+ + "\1\100\1\75\1\14\1\0\1\33\1\34\1\40\1\46\1\47\1\50"+ + "\1\56\1\54\1\41\1\1\1\55\1\44\1\52\1\4\1\42\1\43"+ + "\1\1\1\37\1\35\1\36\1\51\1\57\1\21\1\53\1\45\1\1"+ + "\1\101\1\66\1\102\1\76\uff81\0"; /** * Translates characters to character classes @@ -70,32 +71,32 @@ class P4Lexer implements superc.core.Lexer { private static final int [] ZZ_ACTION = zzUnpackAction(); private static final String ZZ_ACTION_PACKED_0 = - "\4\0\1\1\10\0\1\2\1\3\1\0\1\4\1\3"+ + "\4\0\1\1\10\0\1\2\1\3\2\0\1\4\1\3"+ "\1\5\1\6\1\7\1\10\1\11\20\2\1\12\1\13"+ "\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23"+ "\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33"+ "\1\34\1\35\1\36\1\37\1\40\1\41\1\42\1\41"+ "\1\43\1\0\1\1\2\44\1\1\1\45\10\0\1\43"+ - "\1\3\2\43\1\46\1\0\1\47\1\4\1\0\4\43"+ - "\1\50\1\51\1\0\1\52\17\2\1\53\1\54\15\2"+ - "\1\55\1\0\1\56\1\57\1\60\1\0\1\61\1\0"+ - "\1\62\1\63\1\64\1\65\1\66\1\0\1\67\1\0"+ - "\1\1\1\0\1\70\5\0\1\43\1\3\1\71\1\0"+ - "\2\43\1\46\4\3\1\43\1\50\3\2\1\72\15\2"+ - "\1\73\1\2\1\74\14\2\1\75\3\2\1\0\1\76"+ - "\1\77\1\100\3\0\1\71\1\46\1\0\1\101\1\50"+ - "\1\0\3\2\1\102\7\2\1\103\1\104\1\2\1\105"+ - "\10\2\1\106\1\2\1\107\1\2\1\110\5\2\1\111"+ - "\3\0\2\2\1\112\1\2\1\113\3\2\1\114\2\2"+ - "\1\115\1\2\1\116\1\2\1\117\4\2\1\120\1\2"+ - "\1\121\4\2\1\122\1\0\1\2\1\123\1\124\1\125"+ - "\1\126\1\127\2\2\1\130\1\2\1\131\3\2\1\132"+ - "\1\2\1\133\1\134\1\2\1\122\1\0\1\2\1\135"+ - "\1\2\1\136\1\137\1\140\1\141\1\142\3\2\1\143"+ - "\1\144\7\2\1\145\1\146\1\147\2\2\1\150"; + "\1\3\2\43\1\46\1\0\1\47\1\0\1\4\1\0"+ + "\4\43\1\50\1\51\1\0\1\52\17\2\1\53\1\54"+ + "\15\2\1\0\1\55\1\56\1\57\1\60\1\0\1\61"+ + "\1\0\1\62\1\63\1\64\1\65\1\66\1\0\1\67"+ + "\1\0\1\1\1\0\1\70\5\0\1\43\1\3\1\71"+ + "\1\0\2\43\1\46\4\3\1\43\1\50\3\2\1\72"+ + "\15\2\1\73\1\2\1\74\14\2\1\75\3\2\1\0"+ + "\1\76\1\77\1\100\3\0\1\71\1\46\1\0\1\101"+ + "\1\50\1\0\3\2\1\102\7\2\1\103\1\104\1\2"+ + "\1\105\10\2\1\106\1\2\1\107\1\2\1\110\5\2"+ + "\1\111\3\0\2\2\1\112\1\2\1\113\3\2\1\114"+ + "\2\2\1\115\1\2\1\116\1\2\1\117\4\2\1\120"+ + "\1\2\1\121\4\2\1\122\1\0\1\2\1\123\1\124"+ + "\1\125\1\126\1\127\2\2\1\130\1\2\1\131\3\2"+ + "\1\132\1\2\1\133\1\134\1\2\1\122\1\0\1\2"+ + "\1\135\1\2\1\136\1\137\1\140\1\141\1\142\3\2"+ + "\1\143\1\144\7\2\1\145\1\146\1\147\2\2\1\150"; private static int [] zzUnpackAction() { - int [] result = new int[326]; + int [] result = new int[328]; int offset = 0; offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result); return result; @@ -120,50 +121,50 @@ private static int zzUnpackAction(String packed, int offset, int [] result) { private static final int [] ZZ_ROWMAP = zzUnpackRowMap(); private static final String ZZ_ROWMAP_PACKED_0 = - "\0\0\0\110\0\220\0\330\0\u0120\0\u0168\0\u01b0\0\u01f8"+ - "\0\u0240\0\u0288\0\u02d0\0\u0318\0\u0360\0\u03a8\0\u03f0\0\u0438"+ - "\0\u0480\0\u04c8\0\u03a8\0\u0510\0\u0558\0\u05a0\0\u05e8\0\u0630"+ - "\0\u0678\0\u06c0\0\u0708\0\u0750\0\u0798\0\u07e0\0\u0828\0\u0870"+ - "\0\u08b8\0\u0900\0\u0948\0\u0990\0\u09d8\0\u0a20\0\u0a68\0\u0510"+ - "\0\u0510\0\u0510\0\u0ab0\0\u0af8\0\u0b40\0\u0b88\0\u0bd0\0\u0c18"+ - "\0\u0c60\0\u0ca8\0\u0510\0\u0510\0\u0510\0\u0510\0\u0510\0\u0510"+ - "\0\u0510\0\u0510\0\u0510\0\u0510\0\u0510\0\u0cf0\0\u0d38\0\u0510"+ - "\0\u0d80\0\u0dc8\0\u0e10\0\u0e58\0\u0510\0\u0ea0\0\u0510\0\u01b0"+ - "\0\u0ee8\0\u0510\0\u0f30\0\u0f78\0\u0fc0\0\u1008\0\u0318\0\u1050"+ - "\0\u1098\0\u10e0\0\u1128\0\u1170\0\u11b8\0\u1200\0\u0510\0\u1248"+ - "\0\u1290\0\u12d8\0\u10e0\0\u1320\0\u1368\0\u13b0\0\u0510\0\u13f8"+ - "\0\u0510\0\u1440\0\u1488\0\u14d0\0\u1518\0\u1560\0\u15a8\0\u15f0"+ - "\0\u1638\0\u1680\0\u16c8\0\u1710\0\u1758\0\u17a0\0\u17e8\0\u1830"+ - "\0\u1878\0\u03a8\0\u18c0\0\u1908\0\u1950\0\u1998\0\u19e0\0\u1a28"+ - "\0\u1a70\0\u1ab8\0\u1b00\0\u1b48\0\u1b90\0\u1bd8\0\u1c20\0\u0510"+ - "\0\u1c68\0\u1cb0\0\u0510\0\u0510\0\u1cf8\0\u0510\0\u1d40\0\u0510"+ - "\0\u0510\0\u0510\0\u0510\0\u0510\0\u1d88\0\u0510\0\u0ea0\0\u1dd0"+ - "\0\u1e18\0\u0510\0\u1e60\0\u1ea8\0\u0510\0\u1ef0\0\u1f38\0\u1f80"+ - "\0\u1fc8\0\u2010\0\u2058\0\u20a0\0\u20e8\0\u1098\0\u12d8\0\u2130"+ - "\0\u1320\0\u1368\0\u2178\0\u1098\0\u21c0\0\u2208\0\u2250\0\u03a8"+ - "\0\u2298\0\u22e0\0\u2328\0\u2370\0\u23b8\0\u2400\0\u2448\0\u2490"+ - "\0\u24d8\0\u2520\0\u2568\0\u25b0\0\u25f8\0\u03a8\0\u2640\0\u03a8"+ - "\0\u2688\0\u26d0\0\u2718\0\u2760\0\u27a8\0\u27f0\0\u2838\0\u2880"+ - "\0\u28c8\0\u2910\0\u2958\0\u29a0\0\u03a8\0\u29e8\0\u2a30\0\u2a78"+ - "\0\u2ac0\0\u0510\0\u0510\0\u0510\0\u2b08\0\u1e60\0\u2b50\0\u1098"+ - "\0\u2b98\0\u2be0\0\u20e8\0\u2c28\0\u2c70\0\u2cb8\0\u2d00\0\u2d48"+ - "\0\u03a8\0\u2d90\0\u2dd8\0\u2e20\0\u2e68\0\u2eb0\0\u2ef8\0\u2f40"+ - "\0\u03a8\0\u2f88\0\u2fd0\0\u03a8\0\u3018\0\u3060\0\u30a8\0\u30f0"+ - "\0\u3138\0\u3180\0\u31c8\0\u3210\0\u03a8\0\u3258\0\u03a8\0\u32a0"+ - "\0\u03a8\0\u32e8\0\u3330\0\u3378\0\u33c0\0\u3408\0\u03a8\0\u3450"+ - "\0\u3498\0\u34e0\0\u3528\0\u3570\0\u03a8\0\u35b8\0\u03a8\0\u3600"+ - "\0\u3648\0\u3690\0\u03a8\0\u36d8\0\u3720\0\u03a8\0\u3768\0\u03a8"+ - "\0\u37b0\0\u03a8\0\u37f8\0\u3840\0\u3888\0\u38d0\0\u03a8\0\u3918"+ - "\0\u03a8\0\u3960\0\u39a8\0\u39f0\0\u3a38\0\u3a80\0\u3ac8\0\u3b10"+ - "\0\u3b58\0\u03a8\0\u03a8\0\u03a8\0\u03a8\0\u3ba0\0\u3be8\0\u03a8"+ - "\0\u3c30\0\u03a8\0\u3c78\0\u3cc0\0\u3d08\0\u03a8\0\u3d50\0\u3d98"+ - "\0\u03a8\0\u3de0\0\u3e28\0\u3e70\0\u3eb8\0\u03a8\0\u3f00\0\u03a8"+ - "\0\u03a8\0\u03a8\0\u03a8\0\u03a8\0\u3f48\0\u3f90\0\u3fd8\0\u0510"+ - "\0\u03a8\0\u4020\0\u4068\0\u40b0\0\u40f8\0\u4140\0\u4188\0\u41d0"+ - "\0\u03a8\0\u03a8\0\u03a8\0\u4218\0\u4260\0\u03a8"; + "\0\0\0\111\0\222\0\333\0\u0124\0\u016d\0\u01b6\0\u01ff"+ + "\0\u0248\0\u0291\0\u02da\0\u0323\0\u036c\0\u03b5\0\u03fe\0\u0447"+ + "\0\u0490\0\u04d9\0\u0522\0\u03b5\0\u056b\0\u05b4\0\u05fd\0\u0646"+ + "\0\u068f\0\u06d8\0\u0721\0\u076a\0\u07b3\0\u07fc\0\u0845\0\u088e"+ + "\0\u08d7\0\u0920\0\u0969\0\u09b2\0\u09fb\0\u0a44\0\u0a8d\0\u0ad6"+ + "\0\u056b\0\u056b\0\u056b\0\u0b1f\0\u0b68\0\u0bb1\0\u0bfa\0\u0c43"+ + "\0\u0c8c\0\u0cd5\0\u0d1e\0\u056b\0\u056b\0\u056b\0\u056b\0\u056b"+ + "\0\u056b\0\u056b\0\u056b\0\u056b\0\u056b\0\u056b\0\u0d67\0\u0db0"+ + "\0\u056b\0\u0df9\0\u0e42\0\u0e8b\0\u0ed4\0\u056b\0\u0f1d\0\u056b"+ + "\0\u01b6\0\u0f66\0\u056b\0\u0faf\0\u0ff8\0\u1041\0\u108a\0\u0323"+ + "\0\u10d3\0\u111c\0\u1165\0\u11ae\0\u11f7\0\u1240\0\u1289\0\u056b"+ + "\0\u12d2\0\u131b\0\u1364\0\u13ad\0\u1165\0\u13f6\0\u143f\0\u1488"+ + "\0\u056b\0\u14d1\0\u056b\0\u151a\0\u1563\0\u15ac\0\u15f5\0\u163e"+ + "\0\u1687\0\u16d0\0\u1719\0\u1762\0\u17ab\0\u17f4\0\u183d\0\u1886"+ + "\0\u18cf\0\u1918\0\u1961\0\u03b5\0\u19aa\0\u19f3\0\u1a3c\0\u1a85"+ + "\0\u1ace\0\u1b17\0\u1b60\0\u1ba9\0\u1bf2\0\u1c3b\0\u1c84\0\u1ccd"+ + "\0\u1d16\0\u1d5f\0\u056b\0\u1da8\0\u056b\0\u056b\0\u1df1\0\u056b"+ + "\0\u1e3a\0\u056b\0\u056b\0\u056b\0\u056b\0\u056b\0\u1e83\0\u056b"+ + "\0\u0f1d\0\u1ecc\0\u1f15\0\u056b\0\u1f5e\0\u1fa7\0\u056b\0\u1ff0"+ + "\0\u2039\0\u2082\0\u20cb\0\u2114\0\u215d\0\u21a6\0\u21ef\0\u111c"+ + "\0\u13ad\0\u2238\0\u13f6\0\u143f\0\u2281\0\u111c\0\u22ca\0\u2313"+ + "\0\u235c\0\u03b5\0\u23a5\0\u23ee\0\u2437\0\u2480\0\u24c9\0\u2512"+ + "\0\u255b\0\u25a4\0\u25ed\0\u2636\0\u267f\0\u26c8\0\u2711\0\u03b5"+ + "\0\u275a\0\u03b5\0\u27a3\0\u27ec\0\u2835\0\u287e\0\u28c7\0\u2910"+ + "\0\u2959\0\u29a2\0\u29eb\0\u2a34\0\u2a7d\0\u2ac6\0\u03b5\0\u2b0f"+ + "\0\u2b58\0\u2ba1\0\u2bea\0\u056b\0\u056b\0\u056b\0\u2c33\0\u1f5e"+ + "\0\u2c7c\0\u111c\0\u2cc5\0\u2d0e\0\u21ef\0\u2d57\0\u2da0\0\u2de9"+ + "\0\u2e32\0\u2e7b\0\u03b5\0\u2ec4\0\u2f0d\0\u2f56\0\u2f9f\0\u2fe8"+ + "\0\u3031\0\u307a\0\u03b5\0\u30c3\0\u310c\0\u03b5\0\u3155\0\u319e"+ + "\0\u31e7\0\u3230\0\u3279\0\u32c2\0\u330b\0\u3354\0\u03b5\0\u339d"+ + "\0\u03b5\0\u33e6\0\u03b5\0\u342f\0\u3478\0\u34c1\0\u350a\0\u3553"+ + "\0\u03b5\0\u359c\0\u35e5\0\u362e\0\u3677\0\u36c0\0\u03b5\0\u3709"+ + "\0\u03b5\0\u3752\0\u379b\0\u37e4\0\u03b5\0\u382d\0\u3876\0\u03b5"+ + "\0\u38bf\0\u03b5\0\u3908\0\u03b5\0\u3951\0\u399a\0\u39e3\0\u3a2c"+ + "\0\u03b5\0\u3a75\0\u03b5\0\u3abe\0\u3b07\0\u3b50\0\u3b99\0\u3be2"+ + "\0\u3c2b\0\u3c74\0\u3cbd\0\u03b5\0\u03b5\0\u03b5\0\u03b5\0\u3d06"+ + "\0\u3d4f\0\u03b5\0\u3d98\0\u03b5\0\u3de1\0\u3e2a\0\u3e73\0\u03b5"+ + "\0\u3ebc\0\u3f05\0\u03b5\0\u3f4e\0\u3f97\0\u3fe0\0\u4029\0\u03b5"+ + "\0\u4072\0\u03b5\0\u03b5\0\u03b5\0\u03b5\0\u03b5\0\u40bb\0\u4104"+ + "\0\u414d\0\u056b\0\u03b5\0\u4196\0\u41df\0\u4228\0\u4271\0\u42ba"+ + "\0\u4303\0\u434c\0\u03b5\0\u03b5\0\u03b5\0\u4395\0\u43de\0\u03b5"; private static int [] zzUnpackRowMap() { - int [] result = new int[326]; + int [] result = new int[328]; int offset = 0; offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result); return result; @@ -186,364 +187,365 @@ private static int zzUnpackRowMap(String packed, int offset, int [] result) { private static final int [] ZZ_TRANS = zzUnpackTrans(); private static final String ZZ_TRANS_PACKED_0 = - "\1\0\1\16\1\17\1\0\1\16\1\0\1\20\1\21"+ - "\1\22\3\16\1\23\1\16\1\17\1\16\1\17\3\16"+ - "\1\24\1\25\1\26\1\27\1\26\1\30\1\31\1\32"+ - "\1\33\1\34\1\35\1\36\1\37\1\40\2\16\1\41"+ - "\1\42\1\43\1\16\1\44\1\16\1\45\1\46\1\16"+ - "\1\47\1\50\1\51\1\52\1\53\1\54\1\55\1\56"+ - "\1\57\1\60\1\61\1\62\1\63\1\64\1\65\1\66"+ - "\1\67\1\70\1\71\1\72\1\73\1\74\1\75\1\76"+ - "\1\26\2\16\7\77\1\100\61\77\1\101\16\77\2\0"+ - "\1\102\5\0\1\102\5\0\1\102\1\0\1\102\4\0"+ - "\1\103\64\0\1\104\5\0\1\104\5\0\1\104\1\0"+ - "\1\104\67\0\7\105\1\0\12\105\2\106\15\105\1\106"+ - "\1\107\2\105\1\106\1\107\37\105\2\107\2\0\1\110"+ - "\5\0\1\110\5\0\1\110\1\0\1\110\4\0\1\111"+ - "\64\0\1\110\5\0\1\110\5\0\1\110\1\0\1\110"+ - "\71\0\1\10\5\0\1\10\5\0\1\10\1\0\1\10"+ - "\4\0\1\112\64\0\1\113\5\0\1\113\5\0\1\113"+ - "\1\0\1\113\21\0\1\114\3\0\1\114\37\0\2\114"+ - "\2\0\1\10\5\0\1\10\5\0\1\10\1\0\1\10"+ - "\71\0\1\115\5\0\1\115\5\0\1\115\1\0\1\115"+ - "\21\0\1\116\3\0\1\116\37\0\2\116\2\0\1\117"+ - "\5\0\1\117\5\0\1\117\1\0\1\117\71\0\1\120"+ - "\5\0\1\120\5\0\1\120\1\0\1\120\70\0\2\16"+ - "\1\0\1\16\3\0\14\16\5\0\25\16\30\0\2\16"+ - "\1\0\1\121\1\17\1\0\1\121\3\0\1\17\3\121"+ - "\1\122\1\121\1\17\1\121\1\17\1\123\2\124\1\0"+ - "\1\125\3\0\2\121\1\123\5\121\1\124\3\121\1\124"+ - "\10\121\30\0\2\121\5\20\1\126\1\127\101\20\7\0"+ - "\1\21\16\0\1\130\1\131\1\130\54\0\1\130\3\0"+ - "\1\121\1\17\1\0\1\121\3\0\1\17\1\132\1\121"+ - "\1\133\1\122\1\134\1\17\1\135\1\17\1\123\2\124"+ - "\1\0\1\125\3\0\1\121\1\135\1\123\4\121\1\134"+ - "\1\124\2\121\1\133\1\124\3\121\1\132\4\121\30\0"+ - "\2\121\112\0\1\136\5\0\1\136\5\0\1\136\1\0"+ - "\1\136\4\0\1\137\71\0\1\21\16\0\1\26\1\131"+ - "\1\26\54\0\1\26\31\0\1\140\41\0\1\141\17\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\1\16\1\142"+ - "\3\16\1\143\2\16\1\144\14\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\6\16\1\145"+ - "\1\146\15\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\11\16\1\147\2\16\5\0\3\16\1\150\10\16"+ - "\1\151\10\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\1\152\3\16\1\153\5\16\1\154"+ - "\3\16\1\155\2\16\1\156\3\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\14\16\1\157"+ - "\10\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\7\16\1\160\15\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\161\3\0\14\16\5\0\15\16\1\162"+ - "\7\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\16\16\1\163\6\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\1\164\24\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ - "\5\0\14\16\1\165\10\16\30\0\2\16\1\0\2\16"+ - "\1\0\1\166\3\0\14\16\5\0\4\16\1\167\4\16"+ - "\1\170\6\16\1\171\4\16\30\0\2\16\1\0\2\16"+ - "\1\0\1\16\3\0\14\16\5\0\1\172\24\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\1\173\24\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\14\16\1\174\10\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\14\16"+ - "\1\175\10\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\1\176\6\16\1\177\15\16\30\0"+ - "\2\16\61\0\1\200\23\0\1\201\64\0\1\202\110\0"+ - "\1\203\1\0\1\204\46\0\1\205\37\0\1\206\3\0"+ - "\1\207\104\0\1\210\107\0\1\211\107\0\1\212\1\0"+ - "\1\213\110\0\1\214\60\0\1\215\46\0\7\77\1\0"+ - "\61\77\1\0\16\77\27\0\1\216\61\0\1\121\1\102"+ - "\1\0\1\121\3\0\1\102\5\121\1\102\1\121\1\102"+ - "\1\121\2\124\1\0\1\125\3\0\10\121\1\124\3\121"+ - "\1\124\10\121\30\0\2\121\2\0\1\136\5\0\1\136"+ - "\5\0\1\136\1\0\1\136\71\0\1\104\5\0\1\104"+ - "\5\0\1\104\1\0\1\104\1\0\2\217\15\0\1\217"+ - "\1\107\2\0\1\217\1\107\37\0\2\107\2\0\1\220"+ - "\5\0\1\220\5\0\1\220\1\0\1\220\3\0\1\221"+ - "\43\0\1\221\44\0\1\222\64\0\1\113\5\0\1\113"+ - "\5\0\1\113\1\0\1\113\1\0\2\223\1\224\14\0"+ - "\1\223\3\0\1\223\22\0\1\224\21\0\1\113\5\0"+ - "\1\113\5\0\1\113\1\0\1\113\71\0\1\115\5\0"+ - "\1\115\5\0\1\115\1\0\1\115\1\0\2\225\1\226"+ - "\14\0\1\225\3\0\1\225\22\0\1\226\21\0\1\115"+ - "\5\0\1\115\5\0\1\115\1\0\1\115\71\0\1\120"+ - "\5\0\1\120\5\0\1\120\1\0\1\120\4\0\1\227"+ - "\63\0\2\121\1\0\1\121\3\0\12\121\2\230\1\0"+ - "\1\121\3\0\10\121\1\230\3\121\1\230\10\121\30\0"+ - "\2\121\1\0\1\121\1\122\1\0\1\121\3\0\1\122"+ - "\3\121\1\122\1\121\1\122\1\121\1\122\1\121\2\230"+ - "\1\0\1\121\3\0\10\121\1\230\3\121\1\230\10\121"+ - "\30\0\2\121\1\0\1\121\1\122\1\0\1\121\3\0"+ - "\1\231\3\121\1\122\1\121\1\122\1\121\1\122\1\121"+ - "\2\230\1\0\1\121\3\0\10\121\1\230\3\121\1\230"+ - "\10\121\30\0\2\121\1\0\1\121\1\232\1\0\1\121"+ - "\3\0\1\232\5\121\1\232\1\121\1\232\1\121\2\230"+ - "\1\233\1\121\3\0\10\121\1\230\3\121\1\230\10\121"+ - "\12\0\1\233\15\0\2\121\1\0\1\121\1\136\1\0"+ - "\1\121\3\0\1\136\5\121\1\136\1\121\1\136\1\121"+ - "\2\234\1\0\1\235\3\0\10\121\1\234\1\236\2\121"+ - "\1\234\1\236\7\121\30\0\2\236\3\0\5\20\24\0"+ - "\2\20\44\0\1\20\33\0\1\130\1\0\1\130\54\0"+ - "\1\130\31\0\1\140\61\0\1\121\1\237\1\0\1\121"+ - "\3\0\1\237\1\121\3\237\1\121\3\237\1\121\1\240"+ - "\1\230\1\0\1\121\3\0\2\237\3\121\1\237\2\121"+ - "\1\230\2\121\1\237\1\240\1\237\7\121\30\0\1\121"+ - "\1\237\1\0\2\121\1\0\1\121\3\0\1\241\3\121"+ - "\1\241\1\121\1\241\1\121\1\241\1\121\2\230\1\0"+ - "\1\121\3\0\10\121\1\230\3\121\1\230\10\121\30\0"+ - "\2\121\1\0\2\121\1\0\1\121\3\0\1\242\3\121"+ - "\1\242\3\121\1\242\1\121\2\230\1\0\1\121\3\0"+ - "\10\121\1\230\3\121\1\230\10\121\30\0\2\121\1\0"+ - "\1\121\1\136\1\0\1\121\3\0\1\136\5\121\1\136"+ - "\1\121\1\136\1\121\2\243\1\0\1\121\3\0\10\121"+ - "\1\243\1\244\2\121\1\243\1\244\7\121\30\0\2\244"+ - "\7\140\1\21\20\140\1\0\57\140\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\2\16\1\245\22\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\3\16\1\246\21\16\30\0\2\16\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\10\16\1\247\14\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\3\16\1\250\21\16\30\0\2\16\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\7\16\1\251\15\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\6\16\1\252\16\16\30\0\2\16\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\1\253\3\16\1\254\20\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ - "\5\0\11\16\1\255\13\16\30\0\2\16\1\0\2\16"+ - "\1\0\1\16\3\0\14\16\5\0\1\16\1\256\23\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ - "\5\0\1\257\15\16\1\260\6\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\10\16\1\261"+ - "\14\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\10\16\1\262\14\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\6\16\1\263"+ - "\16\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\3\16\1\264\21\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\265\3\0\14\16\5\0\25\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\3\16\1\266\3\16\1\267\15\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\3\16\1\270"+ - "\21\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\4\16\1\271\1\272\17\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\15\16"+ - "\1\273\7\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\3\16\1\274\12\16\1\275\6\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ - "\5\0\4\16\1\276\20\16\30\0\2\16\1\0\2\16"+ - "\1\0\1\16\3\0\14\16\5\0\2\16\1\277\22\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ - "\5\0\3\16\1\300\2\16\1\301\16\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\11\16"+ - "\1\302\13\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\3\16\1\303\21\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\1\304"+ - "\24\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\12\16\1\305\12\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\4\16\1\306"+ - "\4\16\1\307\13\16\30\0\2\16\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\6\16\1\310\16\16\30\0"+ - "\2\16\2\0\1\311\5\0\1\311\5\0\1\311\1\0"+ - "\1\311\151\0\1\312\111\0\1\313\107\0\1\314\60\0"+ - "\1\315\54\0\1\220\5\0\1\220\5\0\1\220\1\0"+ - "\1\220\21\0\1\107\3\0\1\107\37\0\2\107\2\0"+ - "\1\220\5\0\1\220\5\0\1\220\1\0\1\220\71\0"+ - "\1\316\5\0\1\316\5\0\1\316\1\0\1\316\111\0"+ - "\2\223\15\0\1\223\3\0\1\223\64\0\2\225\15\0"+ - "\1\225\3\0\1\225\67\0\1\225\63\0\2\121\1\0"+ - "\1\121\3\0\12\121\2\230\1\317\1\121\3\0\10\121"+ - "\1\230\3\121\1\230\10\121\12\0\1\317\15\0\2\121"+ - "\1\0\1\121\1\122\1\0\1\121\3\0\1\122\1\132"+ - "\1\121\1\133\1\122\1\134\1\122\1\135\1\122\1\121"+ - "\2\230\1\0\1\121\3\0\1\121\1\135\5\121\1\134"+ - "\1\230\2\121\1\133\1\230\3\121\1\132\4\121\30\0"+ - "\2\121\1\0\1\121\1\232\1\0\1\121\3\0\1\232"+ - "\5\121\1\232\1\121\1\232\1\121\2\230\1\0\1\121"+ - "\3\0\10\121\1\230\1\320\2\121\1\230\1\320\7\121"+ - "\30\0\2\320\2\0\1\232\5\0\1\232\5\0\1\232"+ - "\1\0\1\232\70\0\1\121\1\321\1\0\1\121\3\0"+ - "\1\321\5\121\1\321\1\121\1\321\1\121\2\230\1\322"+ - "\1\121\3\0\10\121\1\230\3\121\1\230\10\121\12\0"+ - "\1\322\15\0\2\121\1\0\1\121\1\323\1\0\1\121"+ - "\3\0\1\323\5\121\1\323\1\121\1\323\1\121\2\230"+ - "\1\0\1\121\3\0\10\121\1\230\3\121\1\230\10\121"+ - "\30\0\2\121\1\0\1\121\1\237\1\0\1\121\3\0"+ - "\1\237\1\121\3\237\1\121\3\237\1\121\1\240\1\230"+ - "\1\317\1\121\3\0\2\237\3\121\1\237\2\121\1\230"+ - "\2\121\1\237\1\240\1\237\7\121\12\0\1\317\15\0"+ - "\1\121\1\237\1\0\1\121\1\324\1\0\1\121\3\0"+ - "\1\324\5\121\1\324\1\121\1\324\1\121\2\230\1\325"+ - "\1\121\3\0\10\121\1\230\3\121\1\230\10\121\12\0"+ - "\1\325\15\0\2\121\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\3\16\1\326\21\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\6\16\1\327"+ - "\16\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\11\16\1\330\13\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\11\16\1\331"+ - "\13\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\3\16\1\332\21\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\3\16\1\333"+ - "\21\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\6\16\1\334\7\16\1\335\6\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\14\16\1\336\10\16\30\0\2\16\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\11\16\1\337\13\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\340\3\0\14\16\5\0"+ - "\25\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\14\16\1\341\10\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\14\16\1\342"+ - "\10\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\11\16\1\343\13\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\2\16\1\344"+ - "\22\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\16\16\1\345\6\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\2\16\1\346"+ - "\1\347\21\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\16\16\1\350\6\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\2\16"+ - "\1\351\22\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\22\16\1\352\2\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\1\353"+ - "\24\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\4\16\1\354\20\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\17\16\1\355"+ - "\5\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\7\16\1\356\15\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\14\16\1\357"+ - "\10\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\14\16\1\360\10\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\3\16\1\361"+ - "\21\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\2\16\1\362\22\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\5\16\1\363"+ - "\17\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\13\16\1\364\11\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\1\16\1\365"+ - "\23\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\16\16\1\366\6\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\13\16\1\367"+ - "\11\16\30\0\2\16\2\0\1\311\3\0\1\370\1\0"+ - "\1\311\5\0\1\311\1\0\1\311\64\0\1\371\33\0"+ - "\1\372\60\0\1\121\5\0\1\121\5\0\1\121\1\0"+ - "\1\121\70\0\1\121\1\321\1\0\1\121\3\0\1\321"+ - "\5\121\1\321\1\121\1\321\1\121\2\230\1\0\1\121"+ - "\3\0\10\121\1\230\1\236\2\121\1\230\1\236\7\121"+ - "\30\0\2\236\2\0\1\321\5\0\1\321\5\0\1\321"+ - "\1\0\1\321\70\0\1\121\1\324\1\0\1\121\3\0"+ - "\1\324\5\121\1\324\1\121\1\324\1\121\2\230\1\0"+ - "\1\121\3\0\10\121\1\230\1\244\2\121\1\230\1\244"+ - "\7\121\30\0\2\244\2\0\1\324\5\0\1\324\5\0"+ - "\1\324\1\0\1\324\70\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\4\16\1\373\20\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\7\16\1\374"+ - "\15\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\12\16\1\375\12\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\16\3\0\14\16\5\0\5\16\1\376"+ - "\17\16\30\0\2\16\1\0\2\16\1\0\1\16\3\0"+ - "\14\16\5\0\14\16\1\377\10\16\30\0\2\16\1\0"+ - "\2\16\1\0\1\u0100\3\0\14\16\5\0\25\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\5\16\1\u0101\17\16\30\0\2\16\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\5\16\1\u0102\17\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\14\16\1\u0103\10\16\30\0\2\16\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\2\16\1\u0104\22\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\13\16\1\u0105\11\16\30\0\2\16\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\14\16\1\u0106\10\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\4\16\1\u0107\20\16\30\0\2\16\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\3\16\1\u0108\21\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\4\16\1\u0109\20\16\30\0\2\16\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\3\16\1\u010a\21\16\30\0"+ - "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\5\0"+ - "\14\16\1\u010b\10\16\30\0\2\16\1\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\1\u010c\24\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\16\16"+ - "\1\u010d\6\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\6\16\1\u010e\16\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\4\16"+ - "\1\u010f\20\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\4\16\1\u0110\20\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\14\16"+ - "\1\u0111\10\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\21\16\1\u0112\3\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\14\16"+ - "\1\u0113\10\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\6\16\1\u0114\16\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\14\16"+ - "\1\u0115\10\16\30\0\2\16\6\370\1\u0116\101\370\6\0"+ - "\1\370\76\0\1\371\56\0\1\u0117\34\0\2\16\1\0"+ - "\1\16\3\0\14\16\5\0\1\u0118\24\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\u0119\3\0\14\16\5\0\25\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ - "\5\0\21\16\1\u011a\3\16\30\0\2\16\1\0\2\16"+ - "\1\0\1\16\3\0\14\16\5\0\23\16\1\u011b\1\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ - "\5\0\3\16\1\u011c\21\16\30\0\2\16\1\0\2\16"+ - "\1\0\1\16\3\0\14\16\5\0\3\16\1\u011d\21\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ - "\5\0\6\16\1\u011e\16\16\30\0\2\16\1\0\2\16"+ - "\1\0\1\16\3\0\14\16\5\0\14\16\1\u011f\10\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\u0120\3\0\14\16"+ - "\5\0\25\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\7\16\1\u0121\15\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\4\16"+ - "\1\u0122\20\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\23\16\1\u0123\1\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\11\16"+ - "\1\u0124\13\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\14\16\1\u0125\10\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\u0126\3\0\14\16\5\0\25\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\4\16"+ - "\1\u0127\7\16\5\0\25\16\30\0\2\16\1\0\2\16"+ - "\1\0\1\16\3\0\14\16\5\0\4\16\1\u0128\20\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ - "\5\0\3\16\1\u0129\21\16\30\0\2\16\1\0\2\16"+ - "\1\0\1\16\3\0\4\16\1\u012a\7\16\5\0\25\16"+ - "\30\0\2\16\2\0\1\u012b\5\0\1\u012b\5\0\1\u012b"+ - "\1\0\1\u012b\5\0\1\u0116\56\0\1\u0116\52\0\1\u012c"+ - "\40\0\2\16\1\0\1\16\3\0\14\16\5\0\5\16"+ - "\1\u012d\17\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\2\16\1\u012e\22\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\3\16"+ - "\1\u012f\21\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\15\16\1\u0130\7\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\11\16"+ - "\1\u0131\13\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\14\16\1\u0132\10\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\3\16"+ - "\1\u0133\21\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\2\16\1\u0134\22\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\22\16"+ - "\1\u0135\2\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\4\16\1\u0136\7\16\5\0\25\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\2\16"+ - "\1\u0137\22\16\30\0\2\16\2\0\1\u012b\5\0\1\u012b"+ - "\5\0\1\u012b\1\0\1\u012b\64\0\1\u012b\33\0\1\u0138"+ - "\57\0\2\16\1\0\1\16\3\0\14\16\5\0\3\16"+ - "\1\u0139\21\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\6\16\1\u013a\16\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\6\16"+ - "\1\u013b\16\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\16\16\1\u013c\6\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\16\3\0\14\16\5\0\14\16"+ - "\1\u013d\10\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\7\16\1\u013e\15\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\u013f\3\0\14\16\5\0\25\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\u0140\3\0\14\16"+ - "\5\0\25\16\30\0\2\16\1\0\2\16\1\0\1\16"+ - "\3\0\14\16\5\0\3\16\1\u0141\21\16\30\0\2\16"+ - "\1\0\2\16\1\0\1\u0142\3\0\14\16\5\0\25\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ - "\5\0\13\16\1\u0143\11\16\30\0\2\16\1\0\2\16"+ - "\1\0\1\16\3\0\14\16\5\0\6\16\1\u0144\16\16"+ - "\30\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ - "\5\0\7\16\1\u0145\15\16\30\0\2\16\1\0\2\16"+ - "\1\0\1\u0146\3\0\14\16\5\0\25\16\30\0\2\16"; + "\1\0\1\16\1\17\1\0\1\16\1\20\1\21\1\22"+ + "\1\23\3\16\1\24\1\16\1\17\1\16\1\17\3\16"+ + "\1\25\1\26\4\27\1\30\1\31\1\32\1\33\1\34"+ + "\1\35\1\36\1\37\1\40\1\41\2\16\1\42\1\43"+ + "\1\44\1\16\1\45\1\16\1\46\1\47\1\16\1\50"+ + "\1\51\1\52\1\53\1\54\1\55\1\56\1\57\1\60"+ + "\1\61\1\62\1\63\1\64\1\65\1\66\1\67\1\70"+ + "\1\71\1\72\1\73\1\74\1\75\1\76\1\77\2\16"+ + "\7\100\1\101\63\100\1\102\15\100\2\0\1\103\5\0"+ + "\1\103\5\0\1\103\1\0\1\103\4\0\1\104\65\0"+ + "\1\105\5\0\1\105\5\0\1\105\1\0\1\105\70\0"+ + "\7\106\1\0\12\106\2\107\17\106\1\107\1\110\2\106"+ + "\1\107\1\110\36\106\2\110\2\0\1\111\5\0\1\111"+ + "\5\0\1\111\1\0\1\111\4\0\1\112\65\0\1\111"+ + "\5\0\1\111\5\0\1\111\1\0\1\111\72\0\1\10"+ + "\5\0\1\10\5\0\1\10\1\0\1\10\4\0\1\113"+ + "\65\0\1\114\5\0\1\114\5\0\1\114\1\0\1\114"+ + "\23\0\1\115\3\0\1\115\36\0\2\115\2\0\1\10"+ + "\5\0\1\10\5\0\1\10\1\0\1\10\72\0\1\116"+ + "\5\0\1\116\5\0\1\116\1\0\1\116\23\0\1\117"+ + "\3\0\1\117\36\0\2\117\2\0\1\120\5\0\1\120"+ + "\5\0\1\120\1\0\1\120\72\0\1\121\5\0\1\121"+ + "\5\0\1\121\1\0\1\121\71\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\25\16\27\0\2\16\1\0\1\122"+ + "\1\17\1\0\1\122\3\0\1\17\3\122\1\123\1\122"+ + "\1\17\1\122\1\17\1\124\2\125\1\0\1\126\5\0"+ + "\2\122\1\124\5\122\1\125\3\122\1\125\10\122\27\0"+ + "\2\122\7\0\1\27\101\0\5\21\1\127\1\130\102\21"+ + "\5\0\1\131\1\0\1\22\16\0\2\132\1\22\1\132"+ + "\1\133\57\0\1\122\1\17\1\0\1\122\3\0\1\17"+ + "\1\134\1\122\1\135\1\123\1\136\1\17\1\137\1\17"+ + "\1\124\2\125\1\0\1\126\5\0\1\122\1\137\1\124"+ + "\4\122\1\136\1\125\2\122\1\135\1\125\3\122\1\134"+ + "\4\122\27\0\2\122\113\0\1\140\5\0\1\140\5\0"+ + "\1\140\1\0\1\140\4\0\1\141\70\0\1\20\1\0"+ + "\1\22\16\0\4\27\1\133\110\0\1\142\40\0\1\143"+ + "\16\0\2\16\1\0\1\16\3\0\14\16\7\0\1\16"+ + "\1\144\3\16\1\145\2\16\1\146\14\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\6\16"+ + "\1\147\1\150\15\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\11\16\1\151\2\16\7\0\3\16\1\152"+ + "\10\16\1\153\10\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\1\154\3\16\1\155\5\16"+ + "\1\156\3\16\1\157\2\16\1\160\3\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\14\16"+ + "\1\161\10\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\7\16\1\162\15\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\163\3\0\14\16\7\0\15\16"+ + "\1\164\7\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\16\16\1\165\6\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\1\166"+ + "\24\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\14\16\7\0\14\16\1\167\10\16\27\0\2\16\1\0"+ + "\2\16\1\0\1\170\3\0\14\16\7\0\4\16\1\171"+ + "\4\16\1\172\6\16\1\173\4\16\27\0\2\16\1\0"+ + "\2\16\1\0\1\16\3\0\14\16\7\0\1\174\24\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\1\175\24\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\14\16\1\176\10\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\14\16\1\177\10\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\1\200\6\16\1\201\15\16"+ + "\27\0\2\16\31\0\1\202\31\0\1\203\111\0\1\204"+ + "\111\0\1\205\1\0\1\206\45\0\1\207\41\0\1\210"+ + "\3\0\1\211\105\0\1\212\110\0\1\213\110\0\1\214"+ + "\1\0\1\215\111\0\1\216\61\0\1\217\45\0\7\100"+ + "\1\0\63\100\1\0\15\100\32\0\1\220\57\0\1\122"+ + "\1\103\1\0\1\122\3\0\1\103\5\122\1\103\1\122"+ + "\1\103\1\122\2\125\1\0\1\126\5\0\10\122\1\125"+ + "\3\122\1\125\10\122\27\0\2\122\2\0\1\140\5\0"+ + "\1\140\5\0\1\140\1\0\1\140\72\0\1\105\5\0"+ + "\1\105\5\0\1\105\1\0\1\105\1\0\2\221\17\0"+ + "\1\221\1\110\2\0\1\221\1\110\36\0\2\110\2\0"+ + "\1\222\5\0\1\222\5\0\1\222\1\0\1\222\3\0"+ + "\1\223\45\0\1\223\43\0\1\224\65\0\1\114\5\0"+ + "\1\114\5\0\1\114\1\0\1\114\1\0\2\225\1\226"+ + "\16\0\1\225\3\0\1\225\22\0\1\226\20\0\1\114"+ + "\5\0\1\114\5\0\1\114\1\0\1\114\72\0\1\116"+ + "\5\0\1\116\5\0\1\116\1\0\1\116\1\0\2\227"+ + "\1\230\16\0\1\227\3\0\1\227\22\0\1\230\20\0"+ + "\1\116\5\0\1\116\5\0\1\116\1\0\1\116\72\0"+ + "\1\121\5\0\1\121\5\0\1\121\1\0\1\121\4\0"+ + "\1\231\64\0\2\122\1\0\1\122\3\0\12\122\2\232"+ + "\1\0\1\122\5\0\10\122\1\232\3\122\1\232\10\122"+ + "\27\0\2\122\1\0\1\122\1\123\1\0\1\122\3\0"+ + "\1\123\3\122\1\123\1\122\1\123\1\122\1\123\1\122"+ + "\2\232\1\0\1\122\5\0\10\122\1\232\3\122\1\232"+ + "\10\122\27\0\2\122\1\0\1\122\1\123\1\0\1\122"+ + "\3\0\1\233\3\122\1\123\1\122\1\123\1\122\1\123"+ + "\1\122\2\232\1\0\1\122\5\0\10\122\1\232\3\122"+ + "\1\232\10\122\27\0\2\122\1\0\1\122\1\234\1\0"+ + "\1\122\3\0\1\234\5\122\1\234\1\122\1\234\1\122"+ + "\2\232\1\235\1\122\5\0\10\122\1\232\3\122\1\232"+ + "\10\122\12\0\1\235\14\0\2\122\1\0\1\122\1\140"+ + "\1\0\1\122\3\0\1\140\5\122\1\140\1\122\1\140"+ + "\1\122\2\236\1\0\1\237\5\0\10\122\1\236\1\240"+ + "\2\122\1\236\1\240\7\122\27\0\2\240\3\0\5\21"+ + "\26\0\2\21\44\0\1\21\13\0\1\132\106\0\1\131"+ + "\20\0\4\132\111\0\1\142\57\0\1\122\1\241\1\0"+ + "\1\122\3\0\1\241\1\122\3\241\1\122\3\241\1\122"+ + "\1\242\1\232\1\0\1\122\5\0\2\241\3\122\1\241"+ + "\2\122\1\232\2\122\1\241\1\242\1\241\7\122\27\0"+ + "\1\122\1\241\1\0\2\122\1\0\1\122\3\0\1\243"+ + "\3\122\1\243\1\122\1\243\1\122\1\243\1\122\2\232"+ + "\1\0\1\122\5\0\10\122\1\232\3\122\1\232\10\122"+ + "\27\0\2\122\1\0\2\122\1\0\1\122\3\0\1\244"+ + "\3\122\1\244\3\122\1\244\1\122\2\232\1\0\1\122"+ + "\5\0\10\122\1\232\3\122\1\232\10\122\27\0\2\122"+ + "\1\0\1\122\1\140\1\0\1\122\3\0\1\140\5\122"+ + "\1\140\1\122\1\140\1\122\2\245\1\0\1\122\5\0"+ + "\10\122\1\245\1\246\2\122\1\245\1\246\7\122\27\0"+ + "\2\246\7\142\1\22\20\142\1\22\60\142\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\2\16\1\247\22\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\3\16\1\250\21\16\27\0\2\16\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\10\16\1\251\14\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\3\16\1\252\21\16\27\0\2\16\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\7\16\1\253\15\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\6\16\1\254\16\16\27\0\2\16\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\1\255\3\16\1\256"+ + "\20\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\14\16\7\0\11\16\1\257\13\16\27\0\2\16\1\0"+ + "\2\16\1\0\1\16\3\0\14\16\7\0\1\16\1\260"+ + "\23\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\14\16\7\0\1\261\15\16\1\262\6\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\10\16"+ + "\1\263\14\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\10\16\1\264\14\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\6\16"+ + "\1\265\16\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\3\16\1\266\21\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\267\3\0\14\16\7\0\25\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\3\16\1\270\3\16\1\271\15\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\3\16"+ + "\1\272\21\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\4\16\1\273\1\274\17\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\15\16\1\275\7\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\3\16\1\276\12\16\1\277"+ + "\6\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\14\16\7\0\4\16\1\300\20\16\27\0\2\16\1\0"+ + "\2\16\1\0\1\16\3\0\14\16\7\0\2\16\1\301"+ + "\22\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\14\16\7\0\3\16\1\302\2\16\1\303\16\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\11\16\1\304\13\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\3\16\1\305\21\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\1\306\24\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\12\16\1\307\12\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\4\16"+ + "\1\310\4\16\1\311\13\16\27\0\2\16\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\6\16\1\312\16\16"+ + "\27\0\2\16\2\0\1\313\5\0\1\313\5\0\1\313"+ + "\1\0\1\313\154\0\1\314\112\0\1\315\110\0\1\316"+ + "\61\0\1\317\53\0\1\222\5\0\1\222\5\0\1\222"+ + "\1\0\1\222\23\0\1\110\3\0\1\110\36\0\2\110"+ + "\2\0\1\222\5\0\1\222\5\0\1\222\1\0\1\222"+ + "\72\0\1\320\5\0\1\320\5\0\1\320\1\0\1\320"+ + "\112\0\2\225\17\0\1\225\3\0\1\225\63\0\2\227"+ + "\17\0\1\227\3\0\1\227\66\0\1\227\64\0\2\122"+ + "\1\0\1\122\3\0\12\122\2\232\1\321\1\122\5\0"+ + "\10\122\1\232\3\122\1\232\10\122\12\0\1\321\14\0"+ + "\2\122\1\0\1\122\1\123\1\0\1\122\3\0\1\123"+ + "\1\134\1\122\1\135\1\123\1\136\1\123\1\137\1\123"+ + "\1\122\2\232\1\0\1\122\5\0\1\122\1\137\5\122"+ + "\1\136\1\232\2\122\1\135\1\232\3\122\1\134\4\122"+ + "\27\0\2\122\1\0\1\122\1\234\1\0\1\122\3\0"+ + "\1\234\5\122\1\234\1\122\1\234\1\122\2\232\1\0"+ + "\1\122\5\0\10\122\1\232\1\322\2\122\1\232\1\322"+ + "\7\122\27\0\2\322\2\0\1\234\5\0\1\234\5\0"+ + "\1\234\1\0\1\234\71\0\1\122\1\323\1\0\1\122"+ + "\3\0\1\323\5\122\1\323\1\122\1\323\1\122\2\232"+ + "\1\324\1\122\5\0\10\122\1\232\3\122\1\232\10\122"+ + "\12\0\1\324\14\0\2\122\1\0\1\122\1\325\1\0"+ + "\1\122\3\0\1\325\5\122\1\325\1\122\1\325\1\122"+ + "\2\232\1\0\1\122\5\0\10\122\1\232\3\122\1\232"+ + "\10\122\27\0\2\122\1\0\1\122\1\241\1\0\1\122"+ + "\3\0\1\241\1\122\3\241\1\122\3\241\1\122\1\242"+ + "\1\232\1\321\1\122\5\0\2\241\3\122\1\241\2\122"+ + "\1\232\2\122\1\241\1\242\1\241\7\122\12\0\1\321"+ + "\14\0\1\122\1\241\1\0\1\122\1\326\1\0\1\122"+ + "\3\0\1\326\5\122\1\326\1\122\1\326\1\122\2\232"+ + "\1\327\1\122\5\0\10\122\1\232\3\122\1\232\10\122"+ + "\12\0\1\327\14\0\2\122\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\3\16\1\330\21\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\6\16"+ + "\1\331\16\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\11\16\1\332\13\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\11\16"+ + "\1\333\13\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\3\16\1\334\21\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\3\16"+ + "\1\335\21\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\6\16\1\336\7\16\1\337\6\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\14\16\1\340\10\16\27\0\2\16\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\11\16\1\341\13\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\342\3\0\14\16"+ + "\7\0\25\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\14\16\1\343\10\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\14\16"+ + "\1\344\10\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\11\16\1\345\13\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\2\16"+ + "\1\346\22\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\16\16\1\347\6\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\2\16"+ + "\1\350\1\351\21\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\16\16\1\352\6\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\2\16\1\353\22\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\22\16\1\354\2\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\1\355\24\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\4\16\1\356\20\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\17\16"+ + "\1\357\5\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\7\16\1\360\15\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\14\16"+ + "\1\361\10\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\14\16\1\362\10\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\3\16"+ + "\1\363\21\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\2\16\1\364\22\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\5\16"+ + "\1\365\17\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\13\16\1\366\11\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\1\16"+ + "\1\367\23\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\16\16\1\370\6\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\13\16"+ + "\1\371\11\16\27\0\2\16\2\0\1\313\3\0\1\372"+ + "\1\0\1\313\5\0\1\313\1\0\1\313\10\0\1\373"+ + "\112\0\1\374\57\0\1\122\5\0\1\122\5\0\1\122"+ + "\1\0\1\122\71\0\1\122\1\323\1\0\1\122\3\0"+ + "\1\323\5\122\1\323\1\122\1\323\1\122\2\232\1\0"+ + "\1\122\5\0\10\122\1\232\1\240\2\122\1\232\1\240"+ + "\7\122\27\0\2\240\2\0\1\323\5\0\1\323\5\0"+ + "\1\323\1\0\1\323\71\0\1\122\1\326\1\0\1\122"+ + "\3\0\1\326\5\122\1\326\1\122\1\326\1\122\2\232"+ + "\1\0\1\122\5\0\10\122\1\232\1\246\2\122\1\232"+ + "\1\246\7\122\27\0\2\246\2\0\1\326\5\0\1\326"+ + "\5\0\1\326\1\0\1\326\71\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\4\16\1\375\20\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\7\16"+ + "\1\376\15\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\12\16\1\377\12\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\16\3\0\14\16\7\0\5\16"+ + "\1\u0100\17\16\27\0\2\16\1\0\2\16\1\0\1\16"+ + "\3\0\14\16\7\0\14\16\1\u0101\10\16\27\0\2\16"+ + "\1\0\2\16\1\0\1\u0102\3\0\14\16\7\0\25\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\5\16\1\u0103\17\16\27\0\2\16\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\5\16\1\u0104\17\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\14\16\1\u0105\10\16\27\0\2\16\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\2\16\1\u0106\22\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\13\16\1\u0107\11\16\27\0\2\16\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\14\16\1\u0108\10\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\4\16\1\u0109\20\16\27\0\2\16\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\3\16\1\u010a\21\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\4\16\1\u010b\20\16\27\0\2\16\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\3\16\1\u010c\21\16"+ + "\27\0\2\16\1\0\2\16\1\0\1\16\3\0\14\16"+ + "\7\0\14\16\1\u010d\10\16\27\0\2\16\1\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\1\u010e\24\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\16\16\1\u010f\6\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\6\16\1\u0110\16\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\4\16\1\u0111\20\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\4\16\1\u0112\20\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\14\16\1\u0113\10\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\21\16\1\u0114\3\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\14\16\1\u0115\10\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\6\16\1\u0116\16\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\14\16\1\u0117\10\16\27\0\2\16\6\372\1\u0118\102\372"+ + "\6\0\1\372\22\0\1\373\135\0\1\u0119\33\0\2\16"+ + "\1\0\1\16\3\0\14\16\7\0\1\u011a\24\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\u011b\3\0\14\16\7\0"+ + "\25\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\14\16\7\0\21\16\1\u011c\3\16\27\0\2\16\1\0"+ + "\2\16\1\0\1\16\3\0\14\16\7\0\23\16\1\u011d"+ + "\1\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\14\16\7\0\3\16\1\u011e\21\16\27\0\2\16\1\0"+ + "\2\16\1\0\1\16\3\0\14\16\7\0\3\16\1\u011f"+ + "\21\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\14\16\7\0\6\16\1\u0120\16\16\27\0\2\16\1\0"+ + "\2\16\1\0\1\16\3\0\14\16\7\0\14\16\1\u0121"+ + "\10\16\27\0\2\16\1\0\2\16\1\0\1\u0122\3\0"+ + "\14\16\7\0\25\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\7\16\1\u0123\15\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\4\16\1\u0124\20\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\23\16\1\u0125\1\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\11\16\1\u0126\13\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\14\16\1\u0127\10\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\u0128\3\0\14\16\7\0"+ + "\25\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\4\16\1\u0129\7\16\7\0\25\16\27\0\2\16\1\0"+ + "\2\16\1\0\1\16\3\0\14\16\7\0\4\16\1\u012a"+ + "\20\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\14\16\7\0\3\16\1\u012b\21\16\27\0\2\16\1\0"+ + "\2\16\1\0\1\16\3\0\4\16\1\u012c\7\16\7\0"+ + "\25\16\27\0\2\16\2\0\1\u012d\5\0\1\u012d\5\0"+ + "\1\u012d\1\0\1\u012d\5\0\1\u0118\2\0\1\u0118\131\0"+ + "\1\u012e\37\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\5\16\1\u012f\17\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\2\16\1\u0130\22\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\3\16\1\u0131\21\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\15\16\1\u0132\7\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\11\16\1\u0133\13\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\14\16\1\u0134\10\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\3\16\1\u0135\21\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\2\16\1\u0136\22\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\22\16\1\u0137\2\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\4\16\1\u0138\7\16\7\0\25\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\2\16\1\u0139\22\16\27\0\2\16\2\0\1\u012d\5\0"+ + "\1\u012d\5\0\1\u012d\1\0\1\u012d\10\0\1\u012d\112\0"+ + "\1\u013a\56\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\3\16\1\u013b\21\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\6\16\1\u013c\16\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\6\16\1\u013d\16\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\16\16\1\u013e\6\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\16\3\0\14\16\7\0"+ + "\14\16\1\u013f\10\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\7\16\1\u0140\15\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\u0141\3\0\14\16\7\0"+ + "\25\16\27\0\2\16\1\0\2\16\1\0\1\u0142\3\0"+ + "\14\16\7\0\25\16\27\0\2\16\1\0\2\16\1\0"+ + "\1\16\3\0\14\16\7\0\3\16\1\u0143\21\16\27\0"+ + "\2\16\1\0\2\16\1\0\1\u0144\3\0\14\16\7\0"+ + "\25\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\14\16\7\0\13\16\1\u0145\11\16\27\0\2\16\1\0"+ + "\2\16\1\0\1\16\3\0\14\16\7\0\6\16\1\u0146"+ + "\16\16\27\0\2\16\1\0\2\16\1\0\1\16\3\0"+ + "\14\16\7\0\7\16\1\u0147\15\16\27\0\2\16\1\0"+ + "\2\16\1\0\1\u0148\3\0\14\16\7\0\25\16\27\0"+ + "\2\16"; private static int [] zzUnpackTrans() { - int [] result = new int[17064]; + int [] result = new int[17447]; int offset = 0; offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result); return result; @@ -581,19 +583,19 @@ private static int zzUnpackTrans(String packed, int offset, int [] result) { private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute(); private static final String ZZ_ATTRIBUTE_PACKED_0 = - "\4\0\1\1\5\0\1\1\2\0\2\1\1\0\3\1"+ + "\4\0\1\1\5\0\1\1\2\0\2\1\2\0\3\1"+ "\1\11\23\1\3\11\10\1\13\11\2\1\1\11\2\1"+ "\1\0\1\1\1\11\1\1\1\11\1\1\1\0\1\11"+ - "\1\1\2\0\2\1\1\0\5\1\1\0\1\11\1\1"+ - "\1\0\5\1\1\11\1\0\1\11\36\1\1\11\1\0"+ - "\1\1\2\11\1\0\1\11\1\0\5\11\1\0\1\11"+ - "\1\0\1\1\1\0\1\11\2\0\1\11\2\0\3\1"+ - "\1\0\55\1\1\0\3\11\1\0\1\1\1\0\2\1"+ - "\1\0\2\1\1\0\42\1\3\0\34\1\1\0\24\1"+ - "\1\0\13\1\1\11\16\1"; + "\1\1\2\0\2\1\1\0\5\1\1\0\1\11\1\0"+ + "\1\1\1\0\5\1\1\11\1\0\1\11\36\1\1\0"+ + "\1\11\1\1\2\11\1\0\1\11\1\0\5\11\1\0"+ + "\1\11\1\0\1\1\1\0\1\11\2\0\1\11\2\0"+ + "\3\1\1\0\55\1\1\0\3\11\1\0\1\1\1\0"+ + "\2\1\1\0\2\1\1\0\42\1\3\0\34\1\1\0"+ + "\24\1\1\0\13\1\1\11\16\1"; private static int [] zzUnpackAttribute() { - int [] result = new int[326]; + int [] result = new int[328]; int offset = 0; offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result); return result; @@ -716,7 +718,7 @@ public void setFileName(String fileName) { char [] map = new char[0x10000]; int i = 0; /* index in packed string */ int j = 0; /* index in unpacked array */ - while (i < 168) { + while (i < 170) { int count = packed.charAt(i++); char value = packed.charAt(i++); do map[j++] = value; while (--count > 0); diff --git a/src/superc/p4parser/P4ParseTables.java b/src/superc/p4parser/P4ParseTables.java index b75c3ff7..0cc1dadb 100644 --- a/src/superc/p4parser/P4ParseTables.java +++ b/src/superc/p4parser/P4ParseTables.java @@ -24,16 +24,16 @@ public class P4ParseTables extends ParseTables { public P4ParseTables() { super( 4, // YYFINAL - 3954, // YYLAST + 4072, // YYLAST 118, // YYNTOKENS - 147, // YYNNTS - 483, // YYNRULES - 888, // YYNSTATES + 169, // YYNNTS + 507, // YYNRULES + 909, // YYNSTATES 2, // YYUNDEFTOK 372, // YYMAXUTOK 0, // YYEOF - -765, // YYPACT_NINF - -243, // YYTABLE_NINF + -806, // YYPACT_NINF + -400, // YYTABLE_NINF yytranslate_wrapper.yytranslate, yytname_wrapper.yytname, yytoknum_wrapper.yytoknum, @@ -235,17 +235,19 @@ public static class yytname_wrapper { "optAnnotations", "annotations", "annotation", + "structuredAnnotationBody", "annotationBody", "annotationToken", "kvList", "kvPair", "parameterList", + "$@1", "nonEmptyParameterList", "parameter", "direction", "packageTypeDeclaration", - "$@1", "$@2", + "$@3", "instantiation", "objInitializer", "objDeclarations", @@ -253,20 +255,20 @@ public static class yytname_wrapper { "optConstructorParameters", "dotPrefix", "parserDeclaration", - "$@3", "$@4", + "$@5", "parserLocalElements", "parserLocalElement", "parserTypeDeclaration", - "$@5", "$@6", + "$@7", "parserStates", "parserState", - "$@7", + "$@8", "parserStatements", "parserStatement", "parserBlockStatement", - "$@8", + "$@9", "transitionStatement", "stateExpression", "selectExpression", @@ -279,19 +281,26 @@ public static class yytname_wrapper { "simpleKeysetExpression", "valueSetDeclaration", "controlDeclaration", - "controlTypeDeclaration", - "$@9", "$@10", + "$@11", + "controlTypeDeclaration", + "$@12", + "$@13", "controlLocalDeclarations", "controlLocalDeclaration", "controlBody", "externDeclaration", - "$@11", - "$@12", + "$@14", + "$@15", + "$@16", + "$@17", + "externFunctionDeclaration", "methodPrototypes", "functionPrototype", - "$@13", + "$@18", "methodPrototype", + "$@19", + "constructorMethodPrototype", "typeRef", "namedType", "prefixedType", @@ -303,6 +312,8 @@ public static class yytname_wrapper { "typeOrVoid", "optTypeParameters", "typeParameters", + "$@20", + "$@21", "typeParameterList", "typeArg", "typeArgumentList", @@ -311,17 +322,19 @@ public static class yytname_wrapper { "typeDeclaration", "derivedTypeDeclaration", "headerTypeDeclaration", - "$@14", - "$@15", + "$@22", + "$@23", "structTypeDeclaration", + "$@24", + "$@25", "headerUnionDeclaration", - "$@16", - "$@17", + "$@26", + "$@27", "structFieldList", "structField", "enumDeclaration", - "$@18", - "$@19", + "$@28", + "$@29", "specifiedIdentifierList", "specifiedIdentifier", "errorDeclaration", @@ -329,6 +342,7 @@ public static class yytname_wrapper { "identifierList", "typedefDeclaration", "assignmentOrMethodCallStatement", + "methodCallStatements", "emptyStatement", "exitStatement", "returnStatement", @@ -336,7 +350,7 @@ public static class yytname_wrapper { "directApplication", "statement", "blockStatement", - "$@20", + "$@30", "statOrDeclList", "switchStatement", "switchCases", @@ -344,30 +358,38 @@ public static class yytname_wrapper { "switchLabel", "statementOrDeclaration", "tableDeclaration", + "$@31", + "$@32", "tablePropertyList", "tableProperty", "keyElementList", "keyElement", "actionList", + "action", "actionRef", "entry", "entriesList", "actionDeclaration", + "$@33", "variableDeclaration", "constantDeclaration", "optInitializer", "initializer", "functionDeclaration", + "$@34", "argumentList", "nonEmptyArgList", "argument", "expressionList", "prefixedNonTypeName", "dot_name", - "$@21", + "$@35", "lvalue", + "lvalueExpression", "expression", + "invokingExpression", "nonBraceExpression", + "invokingNonBraceExpression", "l_angle", "r_angle" }; @@ -396,51 +418,53 @@ public static class yyr1_wrapper { 122, 122, 122, 122, 122, 122, 122, 123, 123, 123, 123, 123, 123, 123, 124, 124, 125, 125, 125, 125, 125, 126, 126, 127, 127, 128, 128, 129, 129, 129, - 129, 129, 130, 130, 130, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 132, 132, 133, 134, 134, 135, 135, 136, 136, - 137, 137, 137, 137, 139, 140, 138, 141, 141, 141, - 141, 142, 143, 143, 144, 144, 145, 145, 146, 148, - 149, 147, 150, 150, 151, 151, 151, 151, 153, 154, - 152, 155, 155, 157, 156, 158, 158, 159, 159, 159, - 159, 159, 159, 159, 161, 160, 162, 162, 163, 163, - 164, 165, 165, 166, 167, 167, 168, 168, 169, 169, - 170, 170, 170, 170, 171, 171, 171, 171, 171, 172, - 172, 172, 173, 175, 176, 174, 177, 177, 178, 178, - 178, 178, 178, 179, 181, 182, 180, 180, 180, 183, - 183, 185, 184, 186, 186, 186, 187, 187, 187, 187, - 187, 188, 188, 189, 189, 190, 191, 192, 192, 193, - 194, 194, 194, 194, 194, 194, 194, 194, 194, 194, - 194, 195, 195, 195, 196, 196, 197, 198, 198, 199, - 199, 199, 199, 200, 200, 200, 201, 201, 201, 202, - 202, 203, 203, 203, 203, 203, 204, 204, 204, 204, - 206, 207, 205, 208, 210, 211, 209, 212, 212, 213, - 215, 214, 216, 214, 217, 217, 218, 219, 220, 221, - 221, 222, 222, 222, 222, 223, 223, 223, 224, 225, - 226, 226, 227, 227, 228, 229, 229, 229, 229, 229, - 229, 229, 229, 231, 230, 232, 232, 233, 234, 234, - 235, 235, 236, 236, 237, 237, 237, 237, 238, 239, - 239, 240, 240, 240, 240, 241, 241, 242, 243, 243, - 244, 244, 245, 246, 246, 247, 248, 248, 249, 250, - 250, 251, 252, 253, 253, 254, 254, 255, 255, 255, - 256, 256, 256, 257, 257, 259, 258, 260, 260, 260, - 260, 260, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 263, 263, 264, 264 + 129, 130, 130, 131, 131, 131, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 133, 133, 134, 135, 136, 135, 137, 137, + 138, 138, 139, 139, 139, 139, 141, 142, 140, 143, + 143, 143, 143, 144, 145, 145, 146, 146, 147, 147, + 148, 150, 151, 149, 152, 152, 153, 153, 153, 153, + 155, 156, 154, 157, 157, 159, 158, 160, 160, 161, + 161, 161, 161, 161, 161, 161, 163, 162, 164, 164, + 165, 165, 166, 167, 167, 168, 169, 169, 170, 170, + 171, 171, 172, 172, 172, 172, 173, 173, 173, 173, + 173, 174, 174, 174, 176, 177, 175, 179, 180, 178, + 181, 181, 182, 182, 182, 182, 182, 183, 185, 186, + 187, 188, 184, 184, 184, 189, 190, 190, 192, 191, + 193, 193, 194, 193, 195, 196, 196, 196, 196, 196, + 197, 197, 198, 198, 199, 200, 201, 201, 202, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 204, 204, 204, 205, 205, 207, 208, 206, 209, 209, + 210, 210, 210, 210, 211, 211, 211, 212, 212, 212, + 213, 213, 214, 214, 214, 214, 214, 215, 215, 215, + 215, 217, 218, 216, 220, 221, 219, 223, 224, 222, + 225, 225, 226, 228, 227, 229, 227, 230, 230, 231, + 232, 233, 234, 234, 235, 235, 235, 235, 236, 236, + 237, 237, 238, 239, 240, 240, 241, 241, 242, 243, + 243, 243, 243, 243, 243, 243, 243, 245, 244, 246, + 246, 247, 248, 248, 249, 249, 250, 250, 251, 251, + 251, 251, 253, 254, 252, 255, 255, 256, 256, 256, + 256, 257, 257, 258, 259, 259, 260, 261, 261, 262, + 263, 263, 265, 264, 266, 266, 267, 268, 268, 269, + 271, 270, 272, 272, 273, 273, 274, 274, 274, 275, + 275, 275, 276, 276, 278, 277, 279, 279, 279, 279, + 280, 280, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 282, 282, 282, 282, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 284, 284, 284, 284, 285, 285, 286, 286 }; } @@ -450,7 +474,7 @@ public static class yyr2_wrapper { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 2, 2, 5, 5, - 5, 4, 0, 4, 2, 1, 1, 1, 1, 1, + 4, 1, 1, 0, 4, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -459,956 +483,986 @@ public static class yyr2_wrapper { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 3, 3, 0, 1, 1, 3, 4, 6, - 1, 1, 1, 0, 0, 0, 9, 7, 6, 9, - 8, 3, 0, 2, 1, 1, 0, 3, 1, 0, - 0, 8, 0, 2, 1, 1, 1, 1, 0, 0, - 9, 1, 2, 0, 8, 0, 2, 1, 1, 1, - 1, 1, 1, 1, 0, 5, 0, 2, 2, 1, - 7, 0, 2, 4, 1, 1, 5, 3, 1, 3, - 3, 3, 1, 1, 1, 3, 3, 1, 1, 10, - 10, 10, 7, 0, 0, 9, 0, 2, 1, 1, - 1, 1, 1, 1, 0, 0, 9, 4, 4, 0, - 2, 0, 7, 3, 4, 6, 1, 1, 1, 1, - 1, 1, 1, 1, 2, 1, 4, 4, 4, 4, - 1, 1, 1, 1, 1, 4, 4, 4, 6, 6, - 6, 1, 1, 1, 0, 1, 3, 1, 3, 1, - 1, 1, 1, 0, 1, 3, 1, 1, 1, 1, - 3, 1, 2, 2, 2, 2, 1, 1, 1, 1, - 0, 0, 9, 7, 0, 0, 9, 0, 2, 4, - 0, 7, 0, 8, 1, 3, 3, 4, 4, 1, - 3, 4, 4, 4, 4, 5, 8, 4, 1, 2, - 2, 3, 5, 7, 7, 1, 1, 1, 1, 1, - 1, 1, 1, 0, 5, 0, 2, 7, 0, 2, - 3, 2, 1, 1, 1, 1, 1, 1, 6, 1, - 2, 5, 5, 7, 6, 0, 2, 5, 0, 4, - 1, 4, 5, 1, 2, 7, 5, 4, 7, 0, - 2, 1, 2, 0, 1, 1, 3, 1, 3, 1, - 0, 1, 3, 1, 2, 0, 3, 1, 1, 2, - 4, 6, 1, 1, 1, 1, 1, 1, 2, 4, + 1, 1, 1, 3, 3, 0, 0, 2, 1, 3, + 4, 6, 1, 1, 1, 0, 0, 0, 9, 7, + 6, 9, 8, 3, 0, 2, 1, 1, 0, 3, + 1, 0, 0, 8, 0, 2, 1, 1, 1, 1, + 0, 0, 9, 1, 2, 0, 8, 0, 2, 1, + 1, 1, 1, 1, 1, 1, 0, 5, 0, 2, + 2, 1, 7, 0, 2, 4, 1, 1, 5, 3, + 1, 3, 3, 3, 1, 1, 1, 3, 3, 1, + 1, 10, 10, 10, 0, 0, 9, 0, 0, 9, + 0, 2, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 11, 1, 4, 4, 0, 2, 0, 7, + 3, 4, 0, 2, 6, 1, 1, 1, 1, 1, + 1, 1, 1, 2, 1, 4, 4, 4, 4, 1, + 1, 1, 1, 1, 4, 4, 4, 6, 6, 6, + 1, 1, 1, 0, 1, 0, 0, 5, 1, 3, + 1, 1, 1, 1, 0, 1, 3, 1, 1, 1, + 1, 3, 1, 2, 2, 2, 2, 1, 1, 1, + 1, 0, 0, 9, 0, 0, 9, 0, 0, 9, + 0, 2, 4, 0, 7, 0, 8, 1, 3, 3, + 4, 4, 1, 3, 4, 4, 4, 4, 1, 4, + 5, 8, 1, 2, 2, 3, 5, 7, 7, 1, + 1, 1, 1, 1, 1, 1, 1, 0, 5, 0, + 2, 7, 0, 2, 3, 2, 1, 1, 1, 1, + 1, 1, 0, 0, 8, 1, 2, 5, 5, 7, + 6, 0, 2, 5, 0, 2, 3, 1, 4, 5, + 1, 2, 0, 8, 5, 4, 7, 0, 2, 1, + 0, 3, 0, 1, 1, 3, 1, 3, 1, 0, + 1, 3, 1, 2, 0, 3, 1, 1, 2, 2, + 3, 5, 1, 1, 1, 1, 1, 1, 2, 4, 6, 3, 3, 3, 2, 2, 2, 2, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 5, 7, 4, 4, 4, 1, 1, 1, - 1, 1, 1, 2, 4, 6, 3, 2, 2, 2, - 2, 2, 3, 2, 3, 3, 3, 3, 3, 3, - 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 5, 7, 4, 4, 4, - 1, 1, 1, 1 + 3, 3, 5, 4, 1, 0, 7, 4, 4, 1, + 1, 1, 1, 1, 1, 2, 4, 6, 3, 2, + 2, 2, 2, 2, 3, 2, 3, 3, 3, 3, + 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 5, 4, 1, + 0, 7, 4, 4, 1, 1, 1, 1 }; } public static class yydefact_wrapper { public static final int[] yydefact = { - 4, 0, 2, 33, 1, 158, 6, 0, 250, 252, - 251, 254, 0, 0, 253, 0, 0, 262, 263, 243, - 5, 0, 34, 35, 0, 13, 0, 10, 156, 12, - 156, 8, 33, 261, 245, 237, 240, 239, 238, 236, - 0, 11, 281, 286, 288, 287, 289, 14, 15, 0, - 9, 7, 16, 20, 18, 22, 19, 23, 21, 17, - 25, 24, 37, 480, 481, 0, 0, 0, 0, 42, - 273, 0, 0, 0, 0, 0, 0, 0, 0, 33, - 0, 0, 0, 33, 251, 36, 0, 285, 244, 33, - 283, 159, 284, 0, 0, 34, 372, 373, 0, 273, - 0, 264, 282, 380, 42, 0, 0, 309, 0, 0, - 0, 0, 0, 272, 271, 270, 269, 274, 0, 0, - 0, 0, 0, 213, 243, 300, 0, 263, 224, 0, - 0, 261, 290, 294, 0, 0, 0, 144, 168, 264, - 0, 0, 373, 143, 0, 135, 136, 0, 216, 333, - 0, 0, 0, 380, 0, 0, 379, 394, 395, 396, - 0, 393, 392, 397, 0, 0, 0, 241, 242, 0, - 374, 375, 377, 397, 0, 0, 0, 231, 265, 0, - 0, 0, 131, 0, 381, 0, 0, 482, 483, 255, - 307, 0, 0, 256, 308, 45, 41, 104, 103, 99, - 100, 102, 101, 106, 108, 107, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 95, - 122, 96, 42, 123, 124, 130, 125, 126, 127, 128, - 129, 105, 90, 98, 97, 84, 61, 82, 46, 47, + 4, 0, 2, 33, 1, 160, 6, 0, 259, 261, + 260, 263, 0, 0, 262, 0, 0, 271, 272, 252, + 5, 0, 34, 35, 0, 13, 0, 10, 158, 12, + 158, 8, 233, 390, 270, 254, 246, 249, 248, 247, + 245, 0, 11, 292, 297, 299, 298, 300, 14, 15, + 0, 9, 7, 16, 20, 18, 22, 19, 23, 21, + 17, 25, 24, 37, 504, 505, 0, 0, 0, 0, + 43, 284, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 33, 260, 36, 0, 296, 253, + 136, 294, 0, 295, 0, 33, 455, 455, 284, 455, + 273, 293, 455, 43, 455, 0, 322, 0, 455, 0, + 0, 0, 283, 282, 281, 280, 285, 0, 455, 0, + 0, 0, 217, 252, 313, 0, 272, 228, 0, 0, + 270, 273, 273, 0, 34, 0, 0, 146, 170, 273, + 0, 0, 455, 0, 33, 161, 214, 0, 391, 455, + 455, 455, 455, 455, 455, 398, 414, 415, 416, 0, + 413, 412, 417, 0, 0, 0, 250, 251, 0, 393, + 394, 396, 454, 417, 0, 0, 0, 238, 274, 275, + 0, 0, 42, 132, 41, 400, 0, 0, 506, 507, + 264, 320, 0, 0, 265, 321, 46, 40, 105, 104, + 100, 101, 103, 102, 107, 109, 108, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 96, 123, 97, 43, 124, 125, 131, 126, 127, 128, + 129, 130, 106, 91, 99, 98, 85, 62, 83, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 62, 63, 64, 65, 66, 67, 68, - 76, 69, 70, 71, 73, 72, 74, 75, 77, 78, - 79, 80, 81, 83, 85, 86, 87, 88, 89, 91, - 92, 93, 94, 44, 0, 246, 0, 257, 33, 0, - 264, 0, 302, 264, 228, 227, 264, 264, 313, 314, - 264, 264, 0, 311, 312, 0, 140, 142, 141, 0, - 157, 33, 162, 33, 335, 407, 406, 405, 0, 0, - 251, 0, 237, 238, 0, 404, 0, 0, 398, 373, - 385, 408, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 373, 0, 0, 410, 0, 247, - 249, 248, 0, 267, 0, 0, 40, 0, 39, 0, - 38, 0, 310, 0, 0, 275, 0, 0, 0, 214, - 0, 0, 225, 291, 295, 145, 169, 297, 0, 0, - 137, 33, 33, 0, 34, 221, 217, 0, 220, 219, - 222, 218, 33, 402, 401, 0, 403, 409, 378, 0, - 0, 0, 376, 420, 421, 418, 430, 431, 424, 425, - 414, 415, 416, 417, 411, 412, 413, 428, 426, 427, - 0, 423, 0, 0, 0, 429, 278, 277, 276, 279, - 0, 422, 33, 0, 266, 133, 132, 382, 258, 259, - 43, 260, 33, 0, 371, 0, 0, 0, 0, 0, - 0, 0, 0, 33, 0, 138, 0, 165, 163, 33, - 171, 167, 166, 164, 0, 223, 0, 0, 369, 334, - 318, 388, 0, 0, 0, 0, 383, 0, 347, 0, - 237, 325, 328, 331, 330, 327, 326, 346, 329, 332, - 336, 344, 345, 387, 0, 436, 435, 386, 0, 148, - 399, 0, 419, 434, 0, 0, 0, 0, 268, 365, - 368, 33, 301, 0, 0, 304, 229, 297, 297, 33, - 33, 293, 0, 298, 0, 147, 0, 0, 0, 0, - 0, 172, 212, 0, 369, 0, 0, 319, 0, 320, - 0, 0, 384, 0, 0, 373, 0, 389, 273, 152, - 0, 0, 432, 280, 373, 232, 0, 0, 303, 0, - 33, 33, 33, 0, 0, 0, 0, 139, 173, 0, - 161, 33, 0, 370, 367, 0, 321, 0, 0, 0, - 0, 0, 0, 0, 150, 400, 0, 215, 306, 305, - 226, 0, 230, 292, 296, 146, 170, 0, 149, 0, - 0, 0, 0, 0, 0, 31, 33, 349, 366, 33, - 0, 373, 390, 0, 0, 317, 0, 151, 0, 155, - 153, 154, 433, 0, 243, 0, 299, 175, 0, 0, - 0, 0, 0, 32, 0, 348, 350, 0, 322, 338, - 0, 0, 315, 373, 0, 33, 233, 33, 0, 0, - 0, 358, 355, 28, 0, 30, 29, 26, 27, 0, - 33, 0, 0, 391, 0, 234, 0, 0, 0, 34, - 176, 182, 0, 0, 177, 179, 183, 178, 180, 181, - 0, 0, 0, 33, 0, 0, 0, 323, 0, 0, - 0, 337, 0, 0, 439, 440, 441, 342, 0, 438, - 437, 442, 0, 0, 241, 339, 0, 343, 324, 0, - 0, 0, 0, 187, 189, 184, 0, 174, 0, 0, - 0, 352, 0, 351, 356, 0, 0, 0, 450, 449, - 448, 0, 0, 447, 0, 443, 373, 451, 341, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 373, - 0, 0, 453, 0, 316, 235, 380, 188, 175, 0, - 0, 0, 0, 0, 360, 0, 0, 208, 207, 0, - 194, 195, 363, 0, 204, 354, 0, 446, 452, 0, - 340, 463, 464, 461, 473, 474, 467, 468, 457, 458, - 459, 460, 454, 455, 456, 471, 469, 470, 0, 466, - 0, 0, 0, 472, 0, 465, 0, 33, 211, 210, - 209, 359, 373, 33, 203, 202, 0, 0, 204, 0, - 353, 364, 0, 0, 479, 478, 444, 0, 462, 477, - 0, 0, 0, 185, 0, 0, 197, 0, 0, 0, - 33, 205, 206, 0, 475, 373, 191, 361, 357, 0, - 198, 200, 201, 0, 445, 0, 0, 196, 0, 362, - 476, 190, 192, 0, 199, 0, 0, 193 + 58, 59, 60, 61, 63, 64, 65, 66, 67, 68, + 69, 77, 70, 71, 72, 74, 73, 75, 76, 78, + 79, 80, 81, 82, 84, 86, 87, 88, 89, 90, + 92, 93, 94, 95, 45, 0, 255, 0, 266, 136, + 0, 273, 0, 315, 273, 234, 235, 0, 0, 326, + 327, 273, 273, 0, 324, 325, 0, 159, 145, 137, + 138, 164, 220, 347, 427, 426, 425, 0, 0, 260, + 0, 246, 247, 0, 424, 0, 455, 418, 455, 404, + 428, 0, 455, 455, 455, 455, 455, 455, 455, 455, + 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, + 455, 455, 0, 455, 455, 455, 430, 455, 256, 258, + 257, 0, 0, 455, 39, 0, 455, 38, 0, 323, + 0, 0, 286, 0, 0, 455, 218, 0, 0, 229, + 301, 307, 147, 171, 304, 0, 142, 144, 143, 0, + 33, 33, 33, 349, 422, 421, 455, 423, 429, 397, + 0, 0, 0, 395, 440, 441, 438, 450, 451, 444, + 445, 434, 435, 436, 437, 431, 432, 433, 448, 446, + 447, 0, 443, 455, 0, 0, 449, 289, 288, 287, + 290, 0, 442, 136, 278, 276, 134, 133, 401, 267, + 268, 44, 269, 382, 0, 389, 0, 0, 0, 0, + 310, 310, 0, 0, 310, 0, 0, 139, 0, 34, + 167, 165, 33, 173, 169, 0, 168, 166, 33, 0, + 225, 221, 224, 223, 226, 222, 33, 453, 458, 405, + 0, 150, 419, 455, 439, 457, 455, 0, 0, 0, + 0, 0, 33, 386, 136, 314, 0, 0, 317, 230, + 33, 33, 136, 136, 33, 0, 149, 140, 0, 0, + 0, 0, 0, 174, 387, 215, 227, 0, 348, 332, + 407, 0, 0, 455, 0, 402, 0, 361, 0, 246, + 339, 328, 342, 345, 344, 341, 340, 360, 343, 346, + 350, 358, 359, 406, 0, 154, 0, 0, 452, 291, + 455, 239, 279, 277, 383, 0, 455, 316, 0, 236, + 0, 0, 311, 0, 0, 0, 0, 0, 455, 175, + 0, 387, 163, 455, 0, 0, 0, 333, 455, 334, + 0, 455, 403, 0, 455, 455, 455, 408, 409, 284, + 0, 152, 420, 0, 219, 319, 318, 33, 0, 303, + 309, 148, 172, 306, 151, 141, 0, 0, 0, 0, + 0, 388, 385, 216, 362, 0, 335, 0, 0, 0, + 0, 0, 0, 153, 0, 157, 155, 156, 456, 0, + 0, 237, 242, 0, 177, 0, 0, 0, 384, 33, + 33, 0, 455, 410, 455, 0, 329, 0, 0, 252, + 0, 232, 243, 312, 33, 455, 455, 455, 0, 0, + 31, 33, 365, 0, 336, 352, 0, 0, 330, 455, + 0, 136, 240, 0, 0, 34, 178, 184, 0, 0, + 179, 181, 185, 180, 182, 183, 0, 0, 0, 0, + 0, 32, 0, 0, 366, 33, 500, 0, 411, 0, + 241, 0, 0, 0, 189, 191, 186, 0, 176, 0, + 0, 0, 374, 371, 0, 28, 30, 29, 26, 27, + 0, 364, 337, 455, 455, 455, 351, 455, 455, 461, + 462, 463, 356, 0, 460, 459, 464, 0, 0, 250, + 353, 0, 357, 499, 338, 0, 0, 455, 190, 177, + 0, 0, 0, 33, 455, 0, 455, 472, 471, 470, + 0, 0, 469, 0, 465, 455, 473, 355, 455, 455, + 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, + 455, 455, 455, 455, 455, 455, 455, 0, 455, 455, + 455, 475, 455, 331, 244, 0, 33, 213, 212, 211, + 368, 0, 375, 367, 372, 0, 455, 0, 455, 468, + 474, 0, 354, 485, 486, 483, 495, 496, 489, 490, + 479, 480, 481, 482, 476, 477, 478, 493, 491, 492, + 0, 488, 455, 0, 0, 494, 0, 487, 0, 187, + 0, 0, 377, 0, 455, 210, 209, 0, 196, 197, + 380, 455, 206, 370, 498, 503, 466, 455, 484, 502, + 455, 0, 193, 376, 455, 33, 205, 204, 0, 0, + 206, 0, 369, 381, 455, 455, 0, 497, 455, 455, + 0, 0, 199, 455, 455, 455, 33, 207, 208, 467, + 0, 192, 194, 0, 378, 373, 0, 200, 202, 203, + 0, 501, 0, 198, 455, 379, 0, 201, 195 }; } public static class yydefgoto_wrapper { public static final int[] yydefgoto = { - -1, 1, 2, 3, 20, 173, 164, 669, 644, 143, - 95, 23, 112, 283, 181, 182, 144, 145, 146, 309, - 24, 300, 461, 25, 560, 593, 630, 91, 165, 27, - 147, 540, 391, 468, 28, 301, 462, 469, 470, 609, - 657, 680, 681, 778, 682, 723, 724, 876, 882, 789, - 790, 869, 836, 791, 471, 29, 30, 290, 455, 313, - 396, 474, 31, 293, 458, 570, 32, 362, 602, 116, - 166, 34, 167, 36, 37, 168, 39, 40, 177, 178, - 364, 117, 118, 439, 440, 41, 42, 43, 296, 459, - 44, 45, 297, 460, 463, 533, 46, 291, 381, 524, - 525, 47, 48, 108, 49, 491, 492, 493, 494, 495, - 496, 497, 498, 314, 402, 499, 671, 715, 716, 500, - 398, 616, 617, 694, 734, 693, 783, 792, 793, 50, - 688, 689, 546, 453, 52, 169, 170, 171, 183, 503, - 357, 410, 504, 172, 717, 358, 189 + -1, 1, 2, 3, 20, 173, 163, 720, 692, 147, + 134, 23, 181, 111, 284, 182, 183, 143, 144, 309, + 310, 389, 24, 301, 452, 25, 546, 590, 626, 92, + 164, 27, 311, 512, 391, 461, 28, 302, 453, 462, + 463, 606, 654, 676, 677, 749, 678, 704, 705, 879, + 892, 847, 848, 896, 868, 849, 464, 29, 312, 575, + 30, 291, 446, 392, 471, 515, 31, 294, 449, 559, + 630, 32, 597, 33, 361, 631, 652, 632, 115, 165, + 35, 166, 37, 38, 167, 40, 41, 177, 178, 362, + 491, 435, 116, 117, 430, 431, 42, 43, 44, 450, + 561, 45, 454, 566, 46, 451, 563, 500, 562, 47, + 292, 378, 497, 498, 48, 49, 107, 50, 530, 531, + 532, 533, 534, 535, 536, 537, 538, 393, 476, 539, + 696, 740, 741, 540, 472, 639, 693, 661, 662, 754, + 804, 753, 802, 841, 850, 851, 51, 492, 684, 685, + 574, 444, 53, 95, 168, 169, 170, 184, 543, 356, + 401, 544, 588, 171, 172, 742, 743, 357, 190 }; } public static class yypact_wrapper { public static final int[] yypact = { - -765, 30, -765, 511, -765, -765, -765, 423, -765, 125, - -14, 125, 14, 423, -765, 125, 125, -765, -765, -765, - -765, 797, 962, -765, -21, -765, -39, -765, 84, -765, - 136, -765, 43, 53, -765, 372, -765, -765, 72, -765, - 423, -765, -765, -765, -765, -765, -765, -765, -765, 50, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, 172, -765, -765, -27, 423, -18, 423, -765, - 2434, -16, 423, 374, 423, 2564, 2477, 423, 423, 962, - 423, 423, 423, 962, -765, -765, 71, -765, -765, 45, - -765, -765, -765, 86, 97, 43, -765, 2051, 2247, 2434, - 2247, 125, -765, 2296, -765, 2247, 196, -765, 61, 2247, - 196, 107, 1786, -765, -765, -765, -765, -765, 329, 2247, - 196, 126, 423, -765, 67, -765, 423, 227, 89, 100, - 149, -765, -765, -765, 133, 423, 423, -765, -765, 125, - 423, 423, 2051, 212, 173, 188, -765, 203, -765, -765, - 2247, 2247, 2247, 2296, 1348, 2247, -765, -765, -765, -765, - 193, -765, -765, 205, 229, 617, 243, -11, -765, 238, - 247, -765, 3655, -765, 2841, 329, 2878, -765, -765, 423, - 246, -3, -765, 0, 3655, 1878, 2915, -765, -765, -765, - -765, 423, 2952, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, 2434, -765, 2989, -765, 45, 252, - 125, 268, -765, 125, -765, -765, 125, 125, -765, -765, - 125, 125, 272, -765, -765, 276, -765, -765, -765, 374, - -765, 43, -765, 919, -765, 307, 307, 307, 159, 163, - 193, 279, 183, 241, 3026, 307, 423, 2247, -765, 2051, - -765, -765, 423, 2051, 2247, 2247, 2247, 2247, 2247, 2247, - 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, - 2247, 2247, 2247, 284, 2051, 2247, 2247, -765, 1074, -765, - -765, -765, 289, -765, 395, 2247, -765, 423, -765, 2247, - -765, 196, -765, 196, 1970, -765, 196, 290, 2247, -765, - 423, 309, -765, -765, -765, -765, -765, -765, 423, 423, - -765, 962, 43, -24, 962, -765, -765, 10, -765, -765, - -765, -765, 1141, -765, -765, 2247, -765, -765, 3655, 305, - 423, 294, -765, 3830, 3830, 1061, 3799, 3766, 1608, 1608, - 184, 184, 184, 184, 307, 307, 307, 3861, 1505, 3892, - 2730, 3830, 2247, 314, 3063, 184, -765, -765, -765, -765, - 402, 3830, 45, 423, -765, 3655, -765, 3655, -765, -765, - -765, -765, 43, 302, 3655, 318, 215, 423, 328, 330, - 338, 346, 349, -12, 327, 332, -44, -765, -765, 5, - -765, -765, -765, -765, 358, -765, 423, 66, 348, -765, - -765, -765, 357, 356, 2100, 367, -765, 32, -765, 617, - 234, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, 381, 307, -765, -765, 377, -765, - -765, 2247, 1061, -765, 2247, 2434, 375, 378, -765, -765, - -765, 45, -765, 369, 242, -765, -765, -765, -765, 45, - 45, -765, 374, -765, 377, -765, 2247, 423, 125, 335, - 390, -765, -765, 396, 348, 2247, 384, -765, 2247, -765, - 3100, 2247, -765, 382, 2247, 2051, 2247, -765, 2434, -765, - 397, 3137, 3729, -765, 2051, -765, 388, 2247, -765, 423, - 64, 105, 106, 403, 408, 423, 406, 3655, -765, 374, - -765, -13, 413, -765, -765, 3174, -765, 3211, 424, 2767, - 422, 3248, 329, 854, -765, -765, 425, -765, -765, -765, - -765, 228, -765, -765, -765, -765, -765, 420, -765, 437, - 196, 196, 196, 427, 428, 414, 233, -765, -765, 2531, - 444, 2051, -765, 2247, 431, -765, 446, -765, 962, -765, - -765, -765, -765, 156, 447, 436, -765, -765, 449, 451, - 452, 461, 463, -765, 69, -765, -765, 454, 432, -765, - 462, 3285, -765, 2051, 457, 45, -765, 2343, 2247, 2247, - 2247, -765, -765, -765, 464, -765, -765, -765, -765, 466, - 2531, 2149, 468, -765, 478, -765, 484, 278, 76, 962, - -765, -765, 491, 423, -765, -765, -765, -765, -765, -765, - 3322, 3359, 3396, 108, 2198, 495, 2247, -765, 2247, 2247, - 2247, -765, 1348, 2247, -765, -765, -765, -765, 486, -765, - -765, -765, 617, 490, -11, -765, 492, 3692, -765, 485, - 489, 500, 493, -765, -765, -765, 423, -765, 423, 423, - 423, -765, 273, -765, -765, 3433, 1527, 494, 307, 307, - 307, 502, 3470, 307, 423, -765, 2051, -765, -17, 2247, - 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, - 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 513, 2051, - 2247, 2247, -765, 1074, -765, -765, 2247, -765, -765, 504, - 505, 506, 689, 507, 518, 423, 1258, -765, -765, 520, - -765, -765, -765, 738, 2690, -765, 2247, -765, -765, 523, - -765, 3830, 3830, 1061, 3799, 3766, 1608, 1608, 184, 184, - 184, 184, 307, 307, 307, 3861, 1505, 3892, 2804, 3830, - 2247, 524, 3507, 184, 402, 3830, 1, 2391, -765, -765, - -765, -765, 2051, 43, 517, 525, 529, 527, 2650, 273, - -765, -765, 2247, 2247, 307, -765, -765, 2247, 1061, -765, - 2247, 534, 541, -765, 535, 530, -765, 1684, 2247, 2247, - 43, 3655, 3655, 3544, 3729, 2051, -765, -765, -765, 94, - -765, 3581, 3618, 531, -765, 543, 1435, -765, 1684, -765, - -765, -765, -765, 542, -765, 423, 538, -765 + -806, 31, -806, 198, -806, -806, -806, 546, -806, 10, + 61, 10, 75, 546, -806, 10, 10, -806, -806, -806, + -806, 901, 785, -806, 67, -806, 33, -806, 169, -806, + 194, -806, -806, -806, 113, -806, 253, -806, -806, 145, + -806, 546, -806, -806, -806, -806, -806, -806, -806, -806, + 146, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, 213, -806, -806, -28, 546, -27, 546, + -806, 2551, -25, 546, 483, 546, 2681, 2594, 546, 546, + 785, 546, 546, 546, 785, -806, -806, 168, -806, -806, + 182, -806, 218, -806, 227, -13, 1917, 2413, 2551, 2413, + 10, -806, 1966, -806, 2413, 190, -806, -6, 2413, 190, + 94, 1652, -806, -806, -806, -806, -806, 154, 2413, 190, + 215, 546, -806, 109, -806, 546, 214, 210, 217, 223, + -806, 10, 10, 143, -13, 546, 546, -806, -806, 10, + 546, 546, 1917, 238, -13, -806, -806, 247, -806, 2413, + 2413, 2413, 2015, 975, 2413, -806, -806, -806, -806, 242, + -806, -806, 245, 272, 639, 260, -12, -806, 290, 277, + -806, 3772, -806, -806, 2958, 154, 2995, -806, -806, -806, + 292, 307, 297, -806, 298, 3772, 1744, 3032, -806, -806, + -806, -806, 546, 3069, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, 2551, -806, 3106, -806, 182, + 300, 10, 316, -806, 10, -806, -806, 318, 319, -806, + -806, 10, 10, 325, -806, -806, 320, -806, 96, 321, + -806, -806, -806, -806, 262, 262, 262, 95, 130, 242, + 323, 3, 224, 3143, 262, 546, 2413, -806, 1917, -806, + -806, 546, 2217, 2413, 2413, 2413, 2413, 2413, 2413, 2413, + 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, + 2413, 2413, 339, 1917, 2413, 2413, -806, 1143, -806, -806, + -806, 338, 546, 2413, -806, 546, 2413, -806, 190, -806, + 190, 1836, -806, 190, 348, 2413, -806, 546, 345, -806, + -806, -806, -806, -806, -806, 546, -806, -806, -806, 483, + -13, 785, 314, -806, -806, -806, 2413, -806, -806, 3772, + 354, 546, 221, -806, 1129, 1129, 4010, 3916, 3883, 3949, + 3949, 187, 187, 187, 187, 262, 262, 262, 1477, 3980, + 1536, 2847, 1129, 2413, 355, 3180, 187, -806, -806, -806, + -806, 276, 1129, 182, -806, 353, 3772, -806, 3772, -806, + -806, -806, -806, -806, 350, 3772, 360, 140, 546, 367, + -806, -806, 364, 366, -806, 280, 546, -806, -18, 785, + -806, -806, -5, -806, -806, 270, -806, -806, -13, -21, + -806, -806, -806, -806, -806, -806, 1532, 262, -806, -806, + 369, -806, -806, 2413, 4010, -806, 2413, 2551, 371, 373, + 546, 190, -13, -806, 182, -806, 365, 161, -806, -806, + 6, 16, 182, 182, 18, 369, -806, 368, 546, 10, + 459, 330, 383, -806, 374, -806, -806, 546, -806, -806, + -806, 372, 384, 2266, 386, -806, 47, -806, 639, 335, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, 286, -806, 375, 3217, 3846, -806, + 1917, -806, -806, -806, -806, 389, 2413, -806, 546, -806, + 483, 398, -806, 399, 395, 397, 404, 392, 2413, -806, + 483, 374, -806, 2413, 393, 407, 409, -806, 2413, -806, + 3254, 2413, -806, 385, 2413, 1917, 2413, -806, -806, 2551, + 858, -806, -806, 403, -806, -806, -806, 65, 546, -806, + -806, -806, -806, -806, -806, 3772, 414, 190, 190, 190, + 405, -806, -806, -806, -806, 3291, -806, 3328, 411, 2884, + 415, 3365, 154, -806, 785, -806, -806, -806, -806, 612, + 417, -806, -806, 410, -806, 419, 420, 421, -806, 110, + 2648, 429, 1917, -806, 2413, 418, -806, 425, 714, 427, + 426, -806, -806, -806, 2460, 2413, 2413, 2413, 408, 428, + 413, 26, -806, 431, 416, -806, 432, 3402, -806, 1917, + 437, 182, -806, 257, 62, 785, -806, -806, 444, 546, + -806, -806, -806, -806, -806, -806, 3439, 3476, 3513, 446, + 456, 433, 37, 457, -806, 2648, 2315, 445, -806, 454, + -806, 460, 465, 462, -806, -806, -806, 546, -806, 546, + 546, 546, -806, -806, 466, -806, -806, -806, -806, -806, + 467, -806, -806, 2413, 2413, 2413, -806, 975, 2413, -806, + -806, -806, -806, 461, -806, -806, -806, 639, 475, -12, + -806, 473, 3809, -806, -806, 469, 472, 2064, -806, -806, + 476, 477, 479, 70, 2364, 494, 2413, 262, 262, 262, + 489, 3550, 262, 546, -806, 1917, -806, -17, 2413, 2413, + 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, + 2413, 2413, 2413, 2413, 2413, 2413, 2413, 496, 1917, 2413, + 2413, -806, 1143, -806, -806, 49, 2508, -806, -806, -806, + -806, 53, -806, -806, -806, 3587, 2115, 487, 2413, -806, + -806, 491, -806, 1129, 1129, 4010, 3916, 3883, 3949, 3949, + 187, 187, 187, 187, 262, 262, 262, 1477, 3980, 1536, + 2921, 1129, 2413, 502, 3624, 187, 276, 1129, 513, -806, + 176, 500, 509, 546, 1224, -806, -806, 508, -806, -806, + -806, 1312, 2807, -806, 262, -806, -806, 2413, 4010, -806, + 2413, 514, -806, -806, 1917, -13, 511, 512, 518, 519, + 2767, 53, -806, -806, 2413, 2413, 3661, 3846, 1917, 1383, + 521, 525, -806, 2166, 2413, 2413, -13, 3772, 3772, -806, + 526, -806, -806, 531, -806, -806, 163, -806, 3698, 3735, + 529, -806, 546, -806, 2166, -806, 532, -806, -806 }; } public static class yypgoto_wrapper { public static final int[] yypgoto = { - -765, -765, -765, -765, -765, -7, 117, -765, -765, 8, - 2, -19, -83, -765, 448, 232, -261, -765, 291, -765, - -765, -765, -765, -303, 70, -765, -765, 575, 237, -765, - -765, -765, -765, -765, -765, -765, -765, -765, 137, -765, - -168, -765, -765, -765, -765, -765, -765, -765, -765, -263, - -765, -765, -765, -764, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -75, -765, -765, 604, - -56, -765, 339, 40, -765, 389, 51, -765, -89, -765, - -765, -277, -91, -765, -144, -765, 92, -765, -765, -765, - -765, -765, -765, -765, -131, -765, -765, -765, -765, -765, - 63, -765, -765, -53, -765, -645, -641, -765, -765, -640, - -637, -576, -28, -765, -765, -765, -765, -765, -765, -765, - -765, -765, 17, -765, -765, -765, -205, -157, -765, 322, - -290, 11, 93, -526, 48, -129, -765, 310, -151, -708, - -158, -765, -765, 929, -765, 239, -92 + -806, -806, -806, -806, -806, -7, 97, -806, -806, 14, + 5, -15, -806, -83, -806, 449, 216, -251, -806, -806, + 212, -806, -806, -806, -806, -376, 98, -806, -806, 576, + 117, -806, -806, -806, -806, -806, -806, -806, -806, -806, + 148, -806, -141, -806, -806, -806, -806, -806, -806, -806, + -806, -267, -806, -806, -806, -805, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -75, -806, -806, -806, -806, 208, -77, + -806, 363, 43, -806, 239, 50, -806, -99, -806, -806, + -806, -806, -275, -93, -806, -171, -806, 69, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -201, -806, -806, + -806, -806, -806, 64, -806, -806, -60, -806, -642, -806, + -640, -806, -806, -636, -635, -612, -94, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -37, -806, + -806, -806, -806, -245, -224, -806, 237, -806, -370, 8, + 63, -543, 42, -806, -119, -806, 305, -149, -775, -162, + -806, -806, -806, 776, -806, -806, -806, 484, -74 }; } public static class yytable_wrapper { public static final int[] yytable = { - 61, 130, 319, 85, 96, 22, 61, 375, 175, 331, - 395, 21, 684, 305, 51, 111, 685, 686, 193, 583, - 687, 185, 837, 400, 784, 105, 285, 377, 287, -33, - 4, 73, 66, 61, 109, 531, 119, 63, 64, 87, - 94, 598, 366, 648, 7, 368, 72, 330, 7, 7, - 302, 73, -160, 367, 852, 537, 369, 369, 613, 61, - 68, 61, 97, 115, 538, 61, 7, 61, 61, 128, - 61, 61, 88, 61, 61, 61, 85, 614, 149, 476, - 13, 53, 54, 360, 13, 13, 106, 134, 467, 55, - 163, 134, 115, 870, 697, 110, 163, 120, -134, 488, - 56, 472, 13, 57, 7, 97, 7, 73, 190, 58, - 102, 600, 501, -25, 884, 61, 100, 191, 142, 61, - 59, 60, 725, 142, 62, 7, -25, -25, 61, 61, - 69, 784, 148, 61, 61, 163, 89, 53, 54, 374, - 13, 663, 13, 149, 90, 55, 163, 877, 664, -24, - 878, 73, 603, 604, 194, 731, 56, 101, 328, 57, - 294, 13, 665, 191, 331, 58, 7, 7, 666, 7, - 737, 136, 61, 63, 64, 141, 59, 60, 288, 667, - 668, 517, 684, 107, 61, 107, 685, 686, 89, 121, - 687, 123, 125, 129, 132, 133, 92, 137, 138, 139, - 409, 379, 13, 13, 382, 13, 403, 383, 384, 295, - 404, 385, 386, 75, 5, 367, 103, 77, 78, 369, - 180, 345, 346, 347, 104, 433, 310, 98, 351, 8, - 9, 63, 64, 64, 82, -241, 354, 84, 563, 289, - 26, 330, 330, 292, 311, 11, 187, 188, 65, 312, - 67, 326, 298, 299, 70, 71, 14, 303, 304, 26, - 566, 15, 522, 16, -24, 17, 18, 19, 573, 574, - 180, 191, 444, -17, 99, -17, -17, 115, 98, 448, - 645, 449, 63, 64, 451, 100, 5, -17, 327, 568, - 629, 332, 553, -242, 7, 329, 363, 633, 569, 306, - 307, 8, 9, 333, 613, 365, 308, 26, 372, 84, - 26, 378, 26, 26, 380, 394, 26, 11, 387, 61, - 26, 393, 163, 614, 401, 61, 163, 456, 14, 388, - 13, 5, 405, 15, 432, 16, 26, 17, 18, 634, - 179, 442, 35, 452, 53, 54, 557, 163, 516, 53, - 54, 351, 55, 508, 509, 457, 64, 55, 506, 354, - 61, 35, 520, 56, 475, 330, 57, 513, 56, 721, - 521, 57, 58, 61, 526, 85, 527, 58, 179, 187, - 188, 61, 61, 59, 528, 284, 534, 535, 59, 60, - 61, 536, 38, 394, 676, 486, 571, 572, 529, 466, - 94, 530, 473, 61, 394, 542, 99, 545, 548, 35, - 487, 38, 35, 502, 35, 35, 98, 547, 35, 551, - 63, 64, 35, 559, 519, 554, 590, 564, 567, 63, - 64, 565, 5, 555, 537, 596, 61, 580, 35, 330, - 556, 597, 581, 407, 584, 187, 188, 8, 9, 411, - 61, 443, 187, 188, 588, 84, 605, 594, 515, 38, - 94, 606, 38, 11, 38, 38, 608, 592, 38, 61, - 61, 532, 38, 618, 14, 624, 621, 539, 632, 15, - 636, 16, 552, 637, 180, 19, 641, 642, 38, 643, - 649, 652, 650, 322, 53, 54, 656, 107, 653, 655, - 626, 658, 55, 659, 660, 464, 465, 661, 115, 662, - 670, -3, 553, 56, 478, 672, 57, 675, 638, 639, - 640, 26, 58, 695, 674, 696, 635, 507, 718, 179, - 61, 719, 179, 59, 60, 179, 179, 720, 727, 179, - 179, 736, 746, 323, 744, 774, 26, 748, 163, 775, - 26, 115, 776, 777, 795, 796, 747, 163, 654, 772, - 518, 99, 61, 820, 828, 829, 830, 831, 61, 5, - 832, 6, 7, -208, 523, 839, 845, 849, 601, 532, - 532, -207, 856, 857, 8, 9, 865, 866, 867, 615, - 868, 879, 10, 543, 544, 628, 880, 885, 887, 446, - 11, 318, 390, 12, 576, 93, 541, 33, 13, 85, - 827, 14, 486, 883, 163, 713, 15, 799, 16, 611, - 17, 18, 19, 35, 615, 826, 86, 94, 26, 824, - 612, 26, 599, 646, 860, 399, 841, 582, 0, 489, - 821, 631, 0, 412, 0, 0, 163, 0, 35, 0, - 486, 0, 35, 0, 578, 0, 0, 0, 0, 679, - 85, 0, 0, 486, 711, 678, 0, 0, 0, 0, - 61, 0, 0, 38, 0, 0, 61, 122, 94, 126, - 131, 0, 0, 135, 0, 0, 523, 140, 53, 54, - 0, 0, 607, 0, 0, 0, 55, 322, 38, 0, - 0, 732, 38, 854, 0, 745, 0, 56, 0, 0, - 57, 0, 0, 0, 0, 0, 58, 0, 0, 61, - 800, 61, 61, 61, 0, 486, 0, 59, 88, 99, - 35, 0, 851, 35, 0, 0, 875, 61, 0, 163, - 0, 490, 0, 558, 0, 0, 0, 323, 0, 0, - 0, 0, 26, 0, 0, 0, 94, 0, 321, 0, - 53, 54, 163, 0, 0, 0, 0, 0, 55, 26, - 0, 150, 151, 0, 0, 552, 0, 579, 61, 56, - 38, 152, 57, 38, 153, 840, 0, 0, 58, 0, - 786, 38, 155, 0, 722, 26, 5, 0, 0, 59, - 478, 787, 0, 0, 157, 158, 159, 0, 0, 53, - 54, 0, 0, 0, 0, 788, 26, 55, 0, 160, - 486, 0, 0, 0, 0, 163, 0, 0, 56, 679, - 26, 57, 486, 0, 0, 678, 0, 58, 26, 0, - 0, 855, 0, 544, 0, 779, 780, 781, 59, 19, - 161, 162, 0, 0, 35, 0, 489, 0, 163, 0, - 0, 798, 0, 0, 0, 26, 0, 72, 873, 0, - 26, 35, 73, 74, 0, 0, 0, 75, 61, 0, - 76, 77, 78, 0, 0, 0, 0, 0, 0, 0, - 79, 0, 80, 81, 489, 0, 0, 35, 82, 0, - 0, 627, 833, 83, 38, 0, 0, 489, 712, 0, - 0, 0, 5, 389, 0, 7, 26, 397, 610, 0, - 0, 38, 0, 0, 0, 0, 0, 8, 9, 0, - 0, 0, 35, 0, 0, 84, 0, 0, 0, 0, - 35, 0, 0, 11, 0, 0, 0, 38, 0, 0, - 0, 13, 0, 99, 14, 0, 773, 0, 647, 15, - 0, 16, 438, 17, 18, 19, 0, 35, 0, 782, - 0, 0, 35, 0, 0, 0, 0, 5, 0, 0, - 7, 0, 38, 0, 0, 0, 0, 0, 0, 0, - 38, 392, 8, 9, 0, 397, 490, 0, 477, 0, - 84, 0, 886, 0, 0, 0, 397, 0, 11, 647, - 714, 0, 0, 0, 0, 0, 13, 38, 35, 14, - 5, 0, 38, 7, 15, 0, 16, 174, 0, 176, - 19, 0, 184, 0, 186, 8, 9, 0, 192, 0, - 0, 322, 0, 84, 0, 0, 38, 0, 286, 0, - 0, 11, 0, 0, 0, 0, 0, 0, 0, 13, - 0, 0, 14, 0, 489, 0, 0, 15, 38, 16, - 0, 0, 0, 19, 0, 0, 782, 0, 0, 315, - 316, 317, 184, 324, 325, 0, 0, 0, 0, 0, - 0, 323, 0, 0, 341, 342, 343, 344, 345, 346, - 347, 0, 0, 0, 0, 351, 0, 150, 151, 0, - 64, 0, 322, 354, 0, 0, 0, 152, 0, 330, - 153, 0, 0, 356, 0, 322, 154, 0, 155, 0, - 0, 0, 5, 0, 0, 0, 575, 436, 0, 0, - 157, 158, 159, 0, 0, 53, 54, 8, 9, 0, - 0, 0, 0, 55, 0, 320, 0, 0, 0, 0, - 0, 0, 323, 11, 56, 0, 490, 57, 0, 0, - 0, 0, 0, 58, 14, 323, 0, 0, 0, 15, - 0, 16, 0, 437, 59, 19, 161, 162, 479, 0, - 0, 0, 0, 0, 0, 0, 0, 33, 0, 5, - 0, 480, 7, 0, 0, 131, 0, 0, 0, 481, - 0, 0, 53, 54, 8, 9, 38, 0, 0, 0, - 55, 0, 84, 482, 0, 0, 0, 483, 0, 0, - 11, 56, 86, 0, 57, 0, 0, 131, 13, 484, - 58, 14, 0, 485, 0, 0, 15, 0, 16, 0, - 0, 59, 19, 0, 0, 0, 408, 0, 0, 0, - 0, 683, 0, 413, 414, 415, 416, 417, 418, 419, - 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 430, 431, 0, 726, 434, 435, 0, 441, 0, 0, - 0, 150, 151, 0, 445, 0, 0, 0, 447, 0, - 0, 152, 0, 0, 153, 0, 741, 454, 0, 0, - 154, 0, 155, 0, 0, 0, 5, 0, 0, 0, - 0, 834, 0, 0, 157, 158, 159, 0, 0, 53, - 54, 8, 9, 0, 505, 835, 0, 55, 0, 320, - 0, 0, 0, 0, 0, 0, 0, 11, 56, 0, - 0, 57, 0, 0, 0, 0, 0, 58, 14, 0, - 0, 512, 0, 15, 0, 16, 0, 0, 59, 19, - 161, 162, 0, 0, 0, 0, 0, 438, 0, 0, - 0, 150, 151, 0, 0, 0, 0, 0, 0, 0, - 321, 152, 0, 0, 153, 0, 0, 0, 0, 0, - 154, 0, 155, 0, 0, 0, 5, 0, 0, 0, - 0, 0, 0, 550, 157, 158, 159, 0, 0, 53, - 54, 8, 9, 0, 0, 0, 0, 55, 0, 320, - 0, 683, 0, 0, 0, 0, 0, 11, 56, 0, - 561, 57, 0, 562, 0, 0, 0, 58, 14, 0, - 0, 0, 0, 15, 0, 16, 0, 0, 59, 19, - 161, 162, 0, 0, 0, 577, 0, 0, 150, 151, - 0, 0, 0, 0, 454, 0, 0, 585, 152, 0, - 587, 153, 881, 589, 0, 591, 0, 786, 0, 155, - 0, 0, 0, 5, 0, 0, 454, 0, 787, 0, - 0, 157, 158, 159, 0, 0, 53, 54, 0, 0, - 0, 0, 788, 0, 55, 0, 160, 0, 0, 0, - 0, 0, 0, 0, 0, 56, 0, 0, 57, 0, - 0, 0, 0, 336, 58, 0, 0, 0, 341, 342, - 343, 344, 345, 346, 347, 59, 19, 161, 162, 351, - 0, 0, 651, 0, 64, 0, 353, 354, 0, 0, - 150, 151, 0, 330, 0, 0, 0, 356, 0, 0, - 152, 0, 0, 153, 0, 0, 0, 0, 0, 786, - 0, 155, 0, 0, 0, 5, 0, 690, 691, 692, - 787, 0, 0, 157, 158, 159, 0, 0, 53, 54, - 0, 0, 0, 0, 788, 0, 55, 0, 160, 0, - 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, - 57, 0, 0, 735, 0, 454, 58, 738, 739, 740, - 0, 742, 743, 0, 334, 335, 336, 59, 19, 161, - 162, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 0, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, 0, 794, 330, 0, 0, 0, - 356, 0, 0, 0, 0, 0, 0, 0, 801, 802, - 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, - 813, 814, 815, 816, 817, 818, 819, 0, 0, 822, - 823, 0, 825, 0, 0, 184, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 838, 0, 150, 151, 0, - 0, 0, 794, 0, 0, 844, 0, 152, 0, 0, - 153, 0, 0, 0, 0, 0, 154, 0, 155, 0, - 0, 0, 5, 0, 0, 0, 0, 787, 0, 848, - 157, 158, 159, 0, 0, 53, 54, 0, 0, 0, - 0, 788, 0, 55, 0, 160, 0, 0, 0, 0, - 0, 861, 862, 0, 56, 0, 863, 57, 0, 864, - 0, 0, 0, 58, 0, 0, 794, 871, 872, 0, - 0, 0, 0, 0, 59, 19, 161, 162, 0, 0, - 0, 0, 0, 0, 0, 794, 0, 794, 195, 196, - 0, 0, 197, 198, 0, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 0, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 195, 0, 0, 0, 197, 198, 0, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 370, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 195, 0, 0, 0, 197, 198, 0, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 450, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 150, 151, 0, 0, 0, 0, - 0, 0, 0, 0, 152, 0, 0, 153, 0, 0, - 0, 0, 0, 154, 0, 155, 0, 0, 0, 5, - 0, 0, 0, 0, 156, 0, 0, 157, 158, 159, - 0, 0, 53, 54, 0, 0, 0, 0, 0, 0, - 55, 0, 160, 150, 151, 0, 0, 0, 0, 0, - 0, 56, 0, 152, 57, 0, 153, 0, 0, 0, - 58, 0, 154, 0, 155, 0, 0, 0, 5, 0, - 549, 59, 124, 161, 162, 0, 157, 158, 159, 0, - 0, 53, 54, 0, 0, 0, 0, 0, 0, 55, - 0, 160, 698, 699, 0, 0, 0, 0, 0, 0, - 56, 0, 700, 57, 0, 0, 701, 0, 0, 58, - 0, 702, 0, 703, 0, 0, 0, 5, 0, 0, - 59, 19, 161, 162, 0, 704, 705, 706, 0, 0, - 53, 54, 0, 0, 0, 0, 707, 0, 55, 0, - 708, 150, 151, 0, 0, 0, 0, 0, 0, 56, - 0, 152, 57, 0, 153, 733, 0, 0, 58, 0, - 154, 0, 155, 0, 0, 0, 5, 0, 0, 59, - 19, 709, 710, 0, 157, 158, 159, 0, 0, 53, - 54, 0, 0, 0, 0, 0, 0, 55, 0, 160, - 150, 151, 0, 0, 0, 0, 0, 0, 56, 0, - 152, 57, 0, 153, 0, 0, 0, 58, 0, 154, - 0, 155, 0, 0, 0, 5, 0, 0, 59, 19, - 161, 162, 0, 157, 158, 159, 0, 0, 53, 54, - 0, 0, 0, 0, 0, 0, 55, 0, 160, 150, - 151, 0, 0, 0, 0, 0, 0, 56, 0, 152, - 57, 0, 153, 0, 0, 0, 58, 0, 154, 0, - 155, 0, 0, 0, 5, 0, 0, 59, 19, 161, - 162, 0, 157, 158, 159, 0, 0, 53, 54, 0, - 0, 0, 0, 0, 0, 55, 0, 160, 0, 0, - 0, 0, 0, 0, 0, 0, 56, 0, 0, 57, - -186, 0, 0, 0, 0, 58, 0, 0, 0, 0, - 0, 5, 0, 480, 7, 0, 59, 124, 161, 162, - 0, 481, 0, 0, 53, 54, 8, 9, 0, 0, - 0, 0, 55, 0, 84, 0, 0, 0, 0, 483, - 0, 0, 11, 56, 0, 0, 57, 0, 853, 0, - 13, 0, 58, 14, 0, 0, 0, 677, 15, 5, - 16, 480, 7, 59, 19, 0, 0, 0, 0, 481, - 0, 0, 53, 54, 8, 9, 0, 0, 0, 0, - 55, 0, 84, 0, 0, 0, 0, 483, 0, 0, - 11, 56, 0, 0, 57, 0, 0, 0, 13, 0, - 58, 14, 5, 0, 0, 0, 15, 113, 16, 0, - 0, 59, 19, 0, 0, 53, 54, 8, 9, 0, - 0, 0, 0, 55, 0, 84, 0, 0, 0, 0, - 0, 0, 0, 11, 56, 0, 0, 57, 0, 0, - 0, 0, 0, 58, 14, 5, 0, 0, 0, 15, - 0, 16, 0, 114, 59, 19, 0, 0, 53, 54, - 8, 9, 0, 0, 0, 0, 55, 0, 84, 0, - 0, 0, 0, 0, 0, 0, 11, 56, 0, 0, - 57, 0, 0, 0, 0, 0, 58, 14, 0, 0, - 0, 0, 15, 0, 16, 0, 17, 127, 124, 5, - 0, 480, 7, 0, 0, 0, 0, 0, 0, 481, - 0, 0, 53, 54, 0, 0, 0, 0, 0, 0, - 55, 0, 0, 482, 0, 0, 0, 483, 0, 0, - 0, 56, 5, 0, 57, 0, 0, 0, 13, 484, - 58, 0, 0, 485, 0, 53, 54, 8, 9, 0, - 0, 59, 19, 55, 0, 84, 0, 0, 0, 0, - 0, 0, 0, 11, 56, 0, 0, 57, 0, 0, - 0, 0, 0, 58, 14, 0, 0, 0, 0, 15, - 0, 16, 0, 0, 59, 124, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 406, 0, 0, 0, 355, 330, 0, - 0, 0, 356, 0, 858, 859, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 0, 0, 0, 0, 355, 330, 0, - 0, 0, 356, 0, 842, 843, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 510, 0, 0, 63, 64, - 352, 353, 354, 0, 0, 511, 0, 355, 330, 0, - 0, 0, 356, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 0, 351, 622, 0, 0, 63, 64, 352, 353, 354, - 0, 0, 623, 0, 355, 330, 0, 0, 0, 356, - 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 350, 0, 351, 846, - 0, 0, 63, 64, 352, 353, 354, 0, 0, 847, - 0, 355, 330, 0, 0, 0, 356, 334, 335, 336, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 0, 351, 359, 0, 0, 63, - 64, 352, 353, 354, 0, 0, 0, 0, 355, 330, - 0, 0, 0, 356, 334, 335, 336, 337, 338, 339, + 62, 148, 129, 318, 330, 175, 62, 86, 22, 110, + 372, 52, 680, 595, 681, 460, 470, 21, 682, 683, + 186, 466, 474, 306, 104, 108, 842, 118, 664, -33, + 611, 4, 297, 298, 62, 194, 64, 65, 374, 869, + 303, 191, -162, 286, 7, 288, 329, 97, 7, 73, + 192, 64, 65, -302, 74, -250, 7, 74, 64, 65, + 62, 329, 62, -308, 114, -305, 62, 7, 62, 62, + 127, 62, 62, -363, 62, 62, 62, 7, 897, 7, + 13, 508, 517, 722, 13, 105, 109, 7, 119, 162, + 509, 114, 13, 313, 133, 162, 842, 658, 133, 907, + 527, 359, 838, 13, 63, 366, 541, 67, 706, 715, + 70, 5, -231, 13, 62, 13, 659, 800, 62, 86, + 26, 69, 74, 13, 54, 55, 7, 88, 62, 62, + 716, 7, 56, 62, 62, 162, 717, 74, 100, 26, + 371, 195, 394, 57, 89, 162, 58, 718, 719, 136, + 192, 365, 59, 141, 680, -25, 681, 327, 308, 330, + 682, 683, 13, 60, 106, 96, 106, 13, -25, -25, + 120, 7, 122, 124, 128, 131, 132, 395, 137, 138, + 139, 658, 489, 386, 387, 62, 366, 495, 26, 99, + 388, 26, 376, 26, 26, 379, 192, 26, -3, 180, + 659, 26, 382, 383, 188, 189, 101, 13, 557, 400, + 285, 34, 549, 807, 625, 26, 903, 558, 290, 904, + 142, 90, 293, 76, 344, 345, 346, 78, 79, 91, + 87, 350, 299, 300, 424, -135, 65, 304, 305, 353, + 188, 189, 39, 555, 83, 329, 90, 54, 55, 180, + 501, 564, 565, 504, 93, 56, 5, 102, 6, 7, + -17, 39, -17, -17, 145, 103, 57, 289, 99, 58, + -24, 8, 9, 146, -17, 59, -251, 295, 114, 10, + 480, 481, 121, 296, 125, 130, 60, 11, 135, 369, + 12, 307, 140, 313, 439, 13, 440, 97, 14, 442, + 325, 64, 65, 15, -24, 16, 350, 17, 18, 19, + 39, 65, 328, 39, 353, 39, 39, 447, 62, 39, + 329, 162, 96, 39, 62, 162, 188, 189, 54, 55, + 584, 326, 487, 332, 64, 65, 56, 39, 585, 505, + 506, 54, 55, 331, 329, 586, 162, 57, 702, 56, + 58, 363, 364, 365, 366, 62, 59, 488, 62, 375, + 57, 320, 377, 58, 380, 381, 36, 60, 61, 59, + 62, 384, 5, 385, 516, 7, 396, 390, 62, 97, + 60, 61, 587, 64, 65, 36, 468, 8, 9, 423, + 433, 448, 322, 583, 62, 85, 459, 459, 554, 467, + 475, 443, 26, 11, 308, 458, 469, 478, 485, 490, + 493, 13, 494, 499, 14, 545, 502, 553, 503, 15, + 701, 16, 398, 550, 556, 19, 551, 568, 402, 508, + 572, 593, 577, 573, 36, 591, 578, 36, 581, 36, + 36, 62, 594, 36, 86, 599, 600, 36, 601, 62, + 602, 603, 604, 612, 613, 614, 628, 618, 62, 434, + 634, 36, 180, 642, 651, 638, 620, 689, 645, 525, + 653, 655, 656, 657, 106, 665, 511, 669, 668, 671, + 114, 459, 455, 62, 542, 697, 672, 690, 691, 583, + 526, 708, 712, 66, 695, 68, 622, 700, 479, 71, + 72, 62, 713, 62, 721, 744, 26, 745, 26, 26, + 62, 142, 714, 746, 560, 560, 321, 747, 560, 763, + 98, 582, 748, 666, 39, 755, 756, 765, 767, 793, + 54, 55, 794, 635, 636, 637, 797, 798, 56, 799, + 806, 5, 808, 162, 855, 496, 832, 853, 647, 57, + 699, 62, 58, 507, 650, 859, 8, 9, 59, 862, + 863, 864, 514, 871, 85, 429, 878, -210, -209, 60, + 61, 882, 11, 670, 894, 883, 26, 766, 162, 901, + 791, 437, 114, 14, 179, 895, 902, 552, 15, 905, + 16, 62, 908, 528, 19, 624, 322, 456, 795, 465, + 465, 317, 457, 567, 26, 569, 94, 571, 796, 86, + 513, 629, 893, 608, 576, 179, 179, 54, 55, 738, + 609, 836, 596, 179, 694, 56, 886, 873, 39, 473, + 39, 39, 627, 525, 610, 162, 57, 403, 0, 58, + 0, 0, 0, 0, 0, 59, 811, 525, 36, 0, + 98, 0, 0, 660, 0, 496, 60, 61, 0, 675, + 86, 0, 162, 0, 0, 0, 62, 510, 674, 833, + 5, 0, 62, 812, 0, 660, 0, 26, 0, 0, + 0, 648, 0, 0, 465, 8, 9, 26, 525, 736, + 0, 0, 0, 85, 0, 633, 0, 0, 39, 0, + 62, 11, 62, 62, 62, 0, 26, 26, 0, 0, + 54, 55, 14, 0, 0, 39, 0, 15, 56, 16, + 321, 17, 18, 649, 0, 0, 39, 0, 0, 57, + 764, 0, 58, 0, 0, 0, 0, 0, 59, 0, + 0, 26, 0, 0, 0, 880, 26, 0, 0, 60, + 89, 0, 36, 0, 36, 36, 62, 528, 162, 890, + 0, 0, 861, 0, 0, 26, 0, 801, 598, 0, + 703, 528, 5, 0, 0, 179, 514, 0, 179, 0, + 0, 162, 0, 0, 0, 179, 179, 8, 9, 525, + 0, 0, 26, 0, 525, 85, 0, 0, 34, 39, + 0, 675, 0, 11, 571, 98, 750, 751, 752, 0, + 674, 0, 528, 737, 14, 0, 0, 0, 0, 15, + 0, 16, 36, 17, 18, 19, 0, 0, 39, 39, + 0, 0, 87, 582, 0, 0, 62, 130, 0, 529, + 0, 0, 0, 5, 0, 0, 7, 0, 0, 0, + 36, 0, 0, 0, 0, 0, 130, 162, 8, 9, + 810, 0, 679, 39, 525, 0, 85, 0, 39, 0, + 0, 162, 0, 174, 11, 176, 0, 0, 185, 881, + 187, 0, 13, 707, 193, 14, 0, 39, 0, 0, + 15, 0, 16, 39, 287, 62, 19, 0, 0, 0, + 900, 0, 0, 0, 0, 623, 0, 0, 0, 0, + 0, 0, 0, 528, 39, 0, 5, 0, 840, 7, + 0, 0, 0, 36, 0, 314, 315, 316, 185, 323, + 324, 8, 9, 607, 0, 760, 0, 0, 0, 85, + 865, 0, 0, 0, 0, 0, 0, 11, 0, 0, + 0, 0, 36, 36, 0, 13, 0, 0, 14, 0, + 0, 0, 0, 15, 0, 16, 322, 17, 18, 19, + 0, 73, 0, 0, 0, 0, 74, 75, 0, 0, + 0, 76, 0, 0, 77, 78, 79, 36, 840, 0, + 0, 0, 36, 570, 80, 0, 81, 82, 0, 906, + 429, 0, 83, 663, 679, 0, 0, 84, 149, 150, + 0, 36, 0, 98, 0, 0, 0, 529, 151, 0, + 0, 152, 0, 0, 0, 0, 0, 153, 589, 154, + 0, 322, 0, 5, 0, 39, 0, 0, 36, 0, + 0, 156, 157, 158, 0, 0, 54, 55, 8, 9, + 0, 0, 320, 0, 56, 0, 319, 0, 663, 739, + 0, 0, 0, 0, 11, 57, 0, 0, 58, 0, + 0, 0, 0, 0, 59, 14, 0, 0, 0, 0, + 15, 0, 16, 322, 0, 60, 19, 160, 161, 0, + 321, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 399, 0, 0, 0, 0, 0, 0, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, 0, 0, + 425, 426, 0, 432, 0, 0, 0, 0, 0, 436, + 0, 0, 438, 0, 0, 0, 0, 0, 0, 0, + 0, 445, 0, 0, 0, 321, 0, 335, 0, 529, + 0, 0, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 477, 350, 0, 0, 149, 150, 65, 0, + 352, 353, 0, 0, 0, 0, 151, 329, 0, 152, + 0, 355, 0, 0, 0, 153, 0, 154, 0, 484, + 0, 5, 0, 0, 0, 0, 427, 321, 0, 156, + 157, 158, 0, 0, 54, 55, 8, 9, 0, 0, + 0, 0, 56, 98, 319, 0, 792, 0, 0, 0, + 0, 0, 11, 57, 0, 0, 58, 0, 0, 0, + 0, 0, 59, 14, 0, 0, 0, 0, 15, 0, + 16, 0, 428, 60, 19, 160, 161, 149, 150, 547, + 0, 0, 548, 0, 0, 0, 0, 151, 0, 0, + 152, 0, 0, 0, 0, 0, 153, 0, 154, 0, + 0, 0, 5, 0, 0, 0, 0, 866, 0, 0, + 156, 157, 158, 0, 0, 54, 55, 8, 9, 580, + 0, 867, 0, 56, 0, 319, 0, 0, 0, 0, + 0, 0, 0, 11, 57, 0, 0, 58, 0, 0, + 0, 0, 0, 59, 14, 0, 0, 0, 0, 15, + 0, 16, 445, 0, 60, 19, 160, 161, 0, 0, + 0, 0, 0, 0, 605, 149, 150, 0, 0, 445, + 0, 0, 0, 0, 615, 151, 0, 617, 152, 872, + 619, 0, 621, 0, 844, 0, 154, 0, 0, 0, + 5, 0, 0, 0, 0, 845, 0, 0, 156, 157, + 158, 0, 0, 54, 55, 0, 0, 0, 0, 846, + 0, 56, 0, 159, 0, 0, 0, 0, 0, 0, + 0, 0, 57, 0, 0, 58, 0, 0, 0, 0, + 0, 59, 0, 0, 0, 0, 149, 150, 0, 0, + 667, 0, 60, 19, 160, 161, 151, 0, 0, 152, + 891, 686, 687, 688, 0, 844, 0, 154, 0, 0, + 0, 5, 0, 0, 0, 0, 845, 0, 0, 156, + 157, 158, 0, 0, 54, 55, 0, 0, 0, 0, + 846, 0, 56, 0, 159, 0, 0, 0, 0, 0, + 0, 0, 0, 57, 0, 0, 58, 0, 0, 0, + 0, 0, 59, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 60, 19, 160, 161, 0, 0, 757, + 758, 759, 0, 761, 762, 335, 0, 0, 0, 0, + 340, 341, 342, 343, 344, 345, 346, 0, 348, 349, + 0, 350, 0, 185, 0, 0, 65, 0, 352, 353, + 805, 0, 445, 0, 0, 329, 0, 0, 0, 355, + 0, 0, 0, 0, 813, 814, 815, 816, 817, 818, + 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, + 829, 830, 831, 0, 335, 834, 835, 0, 837, 340, + 341, 342, 343, 344, 345, 346, 0, 348, 0, 518, + 350, 0, 852, 0, 854, 65, 0, 352, 353, 0, + 5, 0, 519, 7, 329, 0, 0, 0, 355, 0, + 520, 0, 0, 54, 55, 8, 9, 0, 858, 0, + 0, 56, 0, 85, 521, 0, 0, 0, 522, 0, + 870, 11, 57, 0, 0, 58, 0, 852, 0, 13, + 523, 59, 14, 876, 524, 0, 877, 15, 0, 16, + 0, 0, 60, 19, 0, 0, 0, 0, 0, 0, + 887, 888, 0, 0, 0, 852, 0, 0, 0, 852, + 898, 899, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 196, 197, 0, 0, 198, 199, + 852, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 0, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 196, 0, 0, 0, + 198, 199, 0, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 367, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 196, 0, + 0, 0, 198, 199, 0, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 441, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 149, 150, 0, 0, 0, 0, 0, 0, 0, 0, + 151, 0, 0, 152, 0, 0, 0, 0, 0, 153, + -392, 154, 0, 0, 0, 5, 0, 0, 0, 0, + 155, 0, 0, 156, 157, 158, 0, 0, 54, 55, + 0, 0, 0, 0, 0, 0, 56, 0, 159, 149, + 150, 0, 0, 0, 0, 0, 0, 57, 0, 151, + 58, -399, 152, 0, 0, 0, 59, 0, 153, 0, + 154, 0, -399, 0, 5, 0, 0, 60, 123, 160, + 161, 0, 156, 157, 158, 0, 0, 54, 55, 0, + 0, 0, 0, 0, 0, 56, 0, 159, 149, 150, + 0, 0, 0, 0, 0, 0, 57, 0, 151, 58, + 0, 152, -399, 0, 0, 59, 0, 153, 0, 154, + 0, -399, 0, 5, 0, 0, 60, 123, 160, 161, + 0, 156, 157, 158, 0, 0, 54, 55, 0, 0, + 0, 0, 0, 0, 56, 0, 159, 149, 150, 0, + 0, 0, 0, 0, 0, 57, 0, 151, 58, 0, + 152, 0, 0, 0, 59, 0, 153, -399, 154, 0, + -399, 0, 5, 0, 0, 60, 123, 160, 161, 0, + 156, 157, 158, 0, 0, 54, 55, 0, 0, 0, + 0, 0, 0, 56, 0, 159, 0, 0, 149, 150, + 0, 0, 0, 0, 57, 0, 0, 58, 151, 0, + 0, 152, 0, 59, 0, 0, 0, 844, 0, 154, + 0, 0, 0, 5, 60, 19, 160, 161, 845, 0, + 0, 156, 157, 158, 0, 0, 54, 55, 0, 0, + 0, 0, 846, 0, 56, 0, 159, 0, 0, 149, + 150, 0, 0, 0, 0, 57, 0, 0, 58, 151, + 0, 0, 152, 0, 59, 0, 0, 0, 153, 0, + 154, 0, 0, 0, 5, 60, 19, 160, 161, 845, + 0, 0, 156, 157, 158, 0, 0, 54, 55, 0, + 0, 0, 0, 846, 0, 56, 0, 159, 0, 0, + 149, 150, 0, 0, 0, 0, 57, 0, 0, 58, + 151, 0, 0, 152, 0, 59, 0, 0, 0, 153, + 0, 154, 0, 0, 0, 5, 60, 19, 160, 161, + 155, 0, 0, 156, 157, 158, 0, 0, 54, 55, + 0, 0, 0, 0, 0, 0, 56, 0, 159, 149, + 150, 0, 0, 0, 0, 0, 0, 57, 0, 151, + 58, 0, 152, 0, 0, 0, 59, 0, 153, 0, + 154, 0, 0, 0, 5, 0, 579, 60, 123, 160, + 161, 0, 156, 157, 158, 0, 0, 54, 55, 0, + 0, 0, 0, 0, 0, 56, 0, 159, 723, 724, + 0, 0, 0, 0, 0, 0, 57, 0, 725, 58, + 0, 0, 726, 0, 0, 59, 0, 727, 0, 728, + 0, 0, 0, 5, 0, 0, 60, 19, 160, 161, + 0, 729, 730, 731, 0, 0, 54, 55, 0, 0, + 0, 0, 732, 0, 56, 0, 733, 149, 150, 0, + 0, 0, 0, 0, 0, 57, 0, 151, 58, 0, + 152, 803, 0, 0, 59, 0, 153, 0, 154, 0, + 0, 0, 5, 0, 0, 60, 19, 734, 735, 0, + 156, 157, 158, 0, 0, 54, 55, 0, 0, 0, + 0, 0, 0, 56, 0, 159, 149, 150, 0, 0, + 0, 0, 0, 0, 57, 0, 151, 58, 0, 152, + 0, 0, 0, 59, 0, 153, 0, 154, 0, 0, + 0, 5, 0, 0, 60, 19, 160, 161, 0, 156, + 157, 158, 0, 0, 54, 55, 0, 0, 0, 0, + 0, 0, 56, 0, 159, 0, 0, 0, 0, 0, + 0, 0, 0, 57, 0, 0, 58, -188, 0, 0, + 0, 0, 59, 0, 0, 0, 0, 0, 5, 0, + 519, 7, 0, 60, 19, 160, 161, 0, 520, 0, + 0, 54, 55, 8, 9, 0, 0, 0, 0, 56, + 0, 85, 0, 0, 0, 0, 522, 0, 0, 11, + 57, 0, 0, 58, 0, 839, 0, 13, 0, 59, + 14, 0, 0, 0, 673, 15, 5, 16, 519, 7, + 60, 19, 0, 0, 0, 0, 520, 0, 0, 54, + 55, 8, 9, 0, 0, 0, 0, 56, 0, 85, + 0, 0, 0, 0, 522, 0, 0, 11, 57, 0, + 0, 58, 0, 0, 0, 13, 0, 59, 14, 5, + 0, 0, 0, 15, 112, 16, 0, 0, 60, 19, + 0, 0, 54, 55, 8, 9, 0, 0, 0, 0, + 56, 0, 85, 0, 0, 0, 0, 0, 0, 0, + 11, 57, 0, 0, 58, 0, 0, 0, 0, 0, + 59, 14, 5, 0, 0, 0, 15, 0, 16, 0, + 113, 60, 19, 0, 0, 54, 55, 8, 9, 0, + 0, 0, 0, 56, 0, 85, 0, 0, 0, 0, + 0, 0, 0, 11, 57, 0, 0, 58, 0, 0, + 0, 0, 0, 59, 14, 0, 0, 0, 0, 15, + 0, 16, 0, 17, 126, 123, 5, 0, 519, 7, + 0, 0, 0, 0, 0, 0, 520, 0, 0, 54, + 55, 0, 0, 0, 0, 0, 0, 56, 0, 0, + 521, 0, 0, 0, 522, 0, 0, 0, 57, 5, + 0, 58, 0, 0, 0, 13, 523, 59, 0, 0, + 524, 0, 54, 55, 8, 9, 0, 0, 60, 19, + 56, 0, 85, 0, 0, 0, 0, 0, 0, 0, + 11, 57, 0, 0, 58, 0, 0, 0, 0, 0, + 59, 14, 0, 0, 0, 0, 15, 0, 16, 0, + 0, 60, 123, 333, 334, 335, 336, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 0, 350, 0, 0, 0, 64, 65, 351, 352, 353, + 397, 0, 0, 0, 354, 329, 0, 0, 0, 355, + 0, 884, 885, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 361, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, 0, 355, 330, 0, 0, 0, - 356, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 0, 351, - 0, 0, 0, 63, 64, 352, 353, 354, 371, 0, - 0, 0, 355, 330, 0, 0, 0, 356, 334, 335, + 0, 350, 0, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 0, 0, 354, 329, 0, 0, 0, 355, + 0, 874, 875, 333, 334, 335, 336, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 0, 350, 482, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 483, 0, 354, 329, 0, 0, 0, 355, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 0, 350, 643, + 0, 0, 64, 65, 351, 352, 353, 0, 0, 644, + 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 0, 351, 0, 0, 0, - 63, 64, 352, 353, 354, 373, 0, 0, 0, 355, - 330, 0, 0, 0, 356, 334, 335, 336, 337, 338, + 346, 347, 348, 349, 0, 350, 856, 0, 0, 64, + 65, 351, 352, 353, 0, 0, 857, 0, 354, 329, + 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 376, 0, 0, 0, 355, 330, 0, 0, - 0, 356, 334, 335, 336, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, 347, 348, 349, 350, 0, - 351, 0, 0, 0, 63, 64, 352, 353, 354, 406, - 0, 0, 0, 355, 330, 0, 0, 0, 356, 334, + 349, 0, 350, 358, 0, 0, 64, 65, 351, 352, + 353, 0, 0, 0, 0, 354, 329, 0, 0, 0, + 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 0, 350, + 360, 0, 0, 64, 65, 351, 352, 353, 0, 0, + 0, 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, 347, 348, 349, 350, 0, 351, 0, 0, - 0, 63, 64, 352, 353, 354, 0, 0, 514, 0, - 355, 330, 0, 0, 0, 356, 334, 335, 336, 337, + 345, 346, 347, 348, 349, 0, 350, 0, 0, 0, + 64, 65, 351, 352, 353, 368, 0, 0, 0, 354, + 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 0, 0, 0, 0, 355, 330, 0, - 586, 0, 356, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 0, 351, 595, 0, 0, 63, 64, 352, 353, 354, - 0, 0, 0, 0, 355, 330, 0, 0, 0, 356, + 348, 349, 0, 350, 0, 0, 0, 64, 65, 351, + 352, 353, 370, 0, 0, 0, 354, 329, 0, 0, + 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 373, + 0, 0, 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 350, 0, 351, 0, - 0, 0, 63, 64, 352, 353, 354, 619, 0, 0, - 0, 355, 330, 0, 0, 0, 356, 334, 335, 336, + 344, 345, 346, 347, 348, 349, 0, 350, 0, 0, + 0, 64, 65, 351, 352, 353, 397, 0, 0, 0, + 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 0, 351, 0, 0, 0, 63, - 64, 352, 353, 354, 620, 0, 0, 0, 355, 330, - 0, 0, 0, 356, 334, 335, 336, 337, 338, 339, + 347, 348, 349, 0, 350, 0, 0, 0, 64, 65, + 351, 352, 353, 0, 0, 486, 0, 354, 329, 0, + 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 0, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, 0, 355, 330, 0, 625, 0, - 356, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 0, 351, - 673, 0, 0, 63, 64, 352, 353, 354, 0, 0, - 0, 0, 355, 330, 0, 0, 0, 356, 334, 335, + 0, 350, 592, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 0, 0, 354, 329, 0, 0, 0, 355, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 0, 350, 0, + 0, 0, 64, 65, 351, 352, 353, 0, 0, 0, + 0, 354, 329, 0, 616, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 0, 351, 0, 0, 0, - 63, 64, 352, 353, 354, 728, 0, 0, 0, 355, - 330, 0, 0, 0, 356, 334, 335, 336, 337, 338, + 346, 347, 348, 349, 0, 350, 0, 0, 0, 64, + 65, 351, 352, 353, 640, 0, 0, 0, 354, 329, + 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 729, 0, 0, 0, 355, 330, 0, 0, - 0, 356, 334, 335, 336, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, 347, 348, 349, 350, 0, - 351, 0, 0, 0, 63, 64, 352, 353, 354, 730, - 0, 0, 0, 355, 330, 0, 0, 0, 356, 334, + 349, 0, 350, 0, 0, 0, 64, 65, 351, 352, + 353, 641, 0, 0, 0, 354, 329, 0, 0, 0, + 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 0, 350, + 0, 0, 0, 64, 65, 351, 352, 353, 0, 0, + 0, 0, 354, 329, 0, 646, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, 347, 348, 349, 350, 0, 351, 0, 0, - 0, 63, 64, 352, 353, 354, 0, 0, 785, 0, - 355, 330, 0, 0, 0, 356, 334, 335, 336, 337, + 345, 346, 347, 348, 349, 0, 350, 698, 0, 0, + 64, 65, 351, 352, 353, 0, 0, 0, 0, 354, + 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 797, 0, 0, 0, 355, 330, 0, - 0, 0, 356, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 0, 351, 0, 0, 0, 63, 64, 352, 353, 354, - 0, 0, 850, 0, 355, 330, 0, 0, 0, 356, + 348, 349, 0, 350, 0, 0, 0, 64, 65, 351, + 352, 353, 709, 0, 0, 0, 354, 329, 0, 0, + 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 710, + 0, 0, 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 350, 0, 351, 874, - 0, 0, 63, 64, 352, 353, 354, 0, 0, 0, - 0, 355, 330, 0, 0, 0, 356, 334, 335, 336, + 344, 345, 346, 347, 348, 349, 0, 350, 0, 0, + 0, 64, 65, 351, 352, 353, 711, 0, 0, 0, + 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 0, 351, 0, 0, 0, 63, - 64, 352, 353, 354, 0, 0, 0, -205, 355, 330, - 0, 0, 0, 356, 334, 335, 336, 337, 338, 339, + 347, 348, 349, 0, 350, 0, 0, 0, 64, 65, + 351, 352, 353, 809, 0, 0, 0, 354, 329, 0, + 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 0, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, -206, 355, 330, 0, 0, 0, - 356, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 0, 351, - 0, 0, 0, 63, 64, 352, 353, 354, 0, 0, - 0, 0, 355, 330, 0, 0, 0, 356, 749, 750, - 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, - 761, 762, 763, 764, 765, 0, 766, 0, 0, 0, - 63, 64, 767, 768, 769, 0, 0, 0, 0, 770, - 330, 0, 0, 0, 771, 334, 335, 336, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 0, 0, 0, 0, 0, 330, 0, 0, - 0, 356, 334, 335, 336, 337, 0, 339, 340, 341, - 342, 343, 344, 345, 346, 347, 348, 349, 350, 0, - 351, 0, 0, 0, 63, 64, 352, 353, 354, 0, - 0, 0, 0, 0, 330, 334, 335, 336, 356, 0, + 0, 350, 0, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 843, 0, 354, 329, 0, 0, 0, 355, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 0, 350, 0, + 0, 0, 64, 65, 351, 352, 353, 0, 0, 860, + 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, + 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, 347, 348, 349, 0, 350, 889, 0, 0, 64, + 65, 351, 352, 353, 0, 0, 0, 0, 354, 329, + 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 0, 0, 0, 0, 0, 330, 336, 0, - 0, 356, 0, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 0, 64, - 0, 353, 354, 0, 0, 0, 0, 0, 330, 336, - 0, 0, 356, 0, 341, 342, 343, 344, 345, 346, - 347, 0, 349, 350, 0, 351, 0, 0, 0, 0, - 64, 0, 353, 354, 0, 0, 0, 0, 0, 330, - 336, 0, 0, 356, 0, 341, 342, 343, 344, 345, - 346, 347, 0, 349, 0, 0, 351, 0, 0, 0, - 0, 64, 0, 353, 354, 0, 0, 0, 0, 0, - 330, 0, 0, 0, 356 + 349, 0, 350, 0, 0, 0, 64, 65, 351, 352, + 353, 0, 0, 0, -207, 354, 329, 0, 0, 0, + 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 0, 350, + 0, 0, 0, 64, 65, 351, 352, 353, 0, 0, + 0, -208, 354, 329, 0, 0, 0, 355, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 0, 350, 0, 0, 0, + 64, 65, 351, 352, 353, 0, 0, 0, 0, 354, + 329, 0, 0, 0, 355, 768, 769, 770, 771, 772, + 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, + 783, 784, 0, 785, 0, 0, 0, 64, 65, 786, + 787, 788, 0, 0, 0, 0, 789, 329, 0, 0, + 0, 790, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 0, + 0, 0, 0, 0, 329, 0, 0, 0, 355, 333, + 334, 335, 336, 0, 338, 339, 340, 341, 342, 343, + 344, 345, 346, 347, 348, 349, 0, 350, 0, 0, + 0, 64, 65, 351, 352, 353, 0, 0, 0, 0, + 0, 329, 333, 334, 335, 355, 0, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 0, + 0, 0, 0, 0, 329, 333, 334, 335, 355, 0, + 0, 0, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 0, 350, 0, 0, 0, 64, 65, 351, + 352, 353, 0, 0, 0, 0, 0, 329, 335, 0, + 0, 355, 0, 340, 341, 342, 343, 344, 345, 346, + 0, 0, 0, 0, 350, 0, 0, 0, 0, 65, + 0, 352, 353, 0, 0, 0, 0, 0, 329, 0, + 0, 0, 355, 340, 341, 342, 343, 344, 345, 346, + 0, 0, 0, 0, 350, 0, 0, 0, 0, 65, + 0, 0, 353, 0, 0, 0, 0, 0, 329, 0, + 0, 0, 355 }; } public static class yycheck_wrapper { public static final int[] yycheck = { - 7, 76, 153, 22, 32, 3, 13, 284, 99, 167, - 313, 3, 657, 142, 3, 68, 657, 657, 110, 545, - 657, 104, 786, 313, 732, 52, 118, 288, 120, 46, - 0, 75, 46, 40, 52, 47, 52, 48, 49, 60, - 32, 567, 45, 619, 61, 45, 70, 58, 61, 61, - 139, 75, 47, 56, 53, 99, 56, 56, 71, 66, - 46, 68, 52, 70, 108, 72, 61, 74, 75, 76, - 77, 78, 111, 80, 81, 82, 95, 90, 46, 103, - 97, 71, 72, 175, 97, 97, 113, 79, 391, 79, - 97, 83, 99, 857, 670, 113, 103, 113, 53, 402, - 90, 391, 97, 93, 61, 52, 61, 75, 47, 99, - 60, 47, 402, 46, 878, 122, 44, 56, 52, 126, - 110, 111, 46, 52, 7, 61, 59, 60, 135, 136, - 13, 839, 46, 140, 141, 142, 52, 71, 72, 222, - 97, 72, 97, 46, 60, 79, 153, 53, 79, 60, - 56, 75, 47, 47, 47, 47, 90, 40, 165, 93, - 60, 97, 93, 56, 322, 99, 61, 61, 99, 61, - 696, 79, 179, 48, 49, 83, 110, 111, 52, 110, - 111, 442, 827, 66, 191, 68, 827, 827, 52, 72, - 827, 74, 75, 76, 77, 78, 60, 80, 81, 82, - 329, 290, 97, 97, 293, 97, 47, 296, 297, 60, - 47, 300, 301, 80, 58, 56, 44, 84, 85, 56, - 103, 37, 38, 39, 52, 354, 53, 44, 44, 73, - 74, 48, 49, 49, 101, 52, 52, 81, 515, 122, - 3, 58, 58, 126, 56, 89, 50, 51, 9, 46, - 11, 58, 135, 136, 15, 16, 100, 140, 141, 22, - 521, 105, 47, 107, 59, 109, 110, 111, 529, 530, - 153, 56, 364, 46, 35, 48, 49, 284, 44, 371, - 47, 373, 48, 49, 376, 44, 58, 60, 59, 47, - 593, 53, 58, 52, 61, 52, 179, 69, 56, 87, - 88, 73, 74, 56, 71, 59, 94, 70, 191, 81, - 73, 59, 75, 76, 46, 313, 79, 89, 46, 326, - 83, 313, 329, 90, 313, 332, 333, 380, 100, 53, - 97, 58, 53, 105, 50, 107, 99, 109, 110, 111, - 101, 52, 3, 53, 71, 72, 504, 354, 440, 71, - 72, 44, 79, 59, 60, 46, 49, 79, 53, 52, - 367, 22, 60, 90, 392, 58, 93, 53, 90, 91, - 52, 93, 99, 380, 46, 394, 46, 99, 139, 50, - 51, 388, 389, 110, 46, 56, 59, 60, 110, 111, - 397, 59, 3, 391, 655, 402, 527, 528, 52, 391, - 392, 52, 391, 410, 402, 47, 167, 59, 52, 70, - 402, 22, 73, 402, 75, 76, 44, 60, 79, 52, - 48, 49, 83, 46, 452, 44, 555, 52, 59, 48, - 49, 53, 58, 52, 99, 564, 443, 47, 99, 58, - 59, 53, 46, 326, 60, 50, 51, 73, 74, 332, - 457, 56, 50, 51, 72, 81, 53, 60, 56, 70, - 452, 53, 73, 89, 75, 76, 60, 558, 79, 476, - 477, 463, 83, 60, 100, 53, 52, 469, 53, 105, - 60, 107, 489, 46, 367, 111, 59, 59, 99, 75, - 46, 60, 621, 154, 71, 72, 60, 380, 52, 52, - 592, 52, 79, 52, 52, 388, 389, 46, 515, 46, - 78, 0, 58, 90, 397, 53, 93, 60, 610, 611, - 612, 284, 99, 59, 653, 59, 601, 410, 60, 290, - 537, 53, 293, 110, 111, 296, 297, 53, 47, 300, - 301, 46, 52, 154, 58, 60, 309, 55, 555, 60, - 313, 558, 52, 60, 60, 53, 714, 564, 633, 717, - 443, 322, 569, 50, 60, 60, 60, 60, 575, 58, - 52, 60, 61, 56, 457, 55, 53, 53, 570, 571, - 572, 56, 53, 56, 73, 74, 52, 46, 53, 581, - 60, 60, 81, 476, 477, 593, 53, 55, 60, 367, - 89, 153, 311, 92, 534, 30, 469, 3, 97, 628, - 778, 100, 619, 876, 621, 671, 105, 746, 107, 579, - 109, 110, 111, 284, 616, 776, 22, 619, 391, 773, - 579, 394, 569, 616, 839, 313, 793, 544, -1, 402, - 769, 593, -1, 333, -1, -1, 653, -1, 309, -1, - 657, -1, 313, -1, 537, -1, -1, -1, -1, 657, - 679, -1, -1, 670, 671, 657, -1, -1, -1, -1, - 677, -1, -1, 284, -1, -1, 683, 73, 670, 75, - 76, -1, -1, 79, -1, -1, 569, 83, 71, 72, - -1, -1, 575, -1, -1, -1, 79, 358, 309, -1, - -1, 693, 313, 832, -1, 712, -1, 90, -1, -1, - 93, -1, -1, -1, -1, -1, 99, -1, -1, 726, - 748, 728, 729, 730, -1, 732, -1, 110, 111, 490, - 391, -1, 824, 394, -1, -1, 865, 744, -1, 746, - -1, 402, -1, 504, -1, -1, -1, 358, -1, -1, - -1, -1, 515, -1, -1, -1, 748, -1, 154, -1, - 71, 72, 769, -1, -1, -1, -1, -1, 79, 532, - -1, 33, 34, -1, -1, 782, -1, 538, 785, 90, - 391, 43, 93, 394, 46, 47, -1, -1, 99, -1, - 52, 402, 54, -1, 677, 558, 58, -1, -1, 110, - 683, 63, -1, -1, 66, 67, 68, -1, -1, 71, - 72, -1, -1, -1, -1, 77, 579, 79, -1, 81, - 827, -1, -1, -1, -1, 832, -1, -1, 90, 827, - 593, 93, 839, -1, -1, 827, -1, 99, 601, -1, - -1, 833, -1, 726, -1, 728, 729, 730, 110, 111, - 112, 113, -1, -1, 515, -1, 619, -1, 865, -1, - -1, 744, -1, -1, -1, 628, -1, 70, 860, -1, - 633, 532, 75, 76, -1, -1, -1, 80, 885, -1, - 83, 84, 85, -1, -1, -1, -1, -1, -1, -1, - 93, -1, 95, 96, 657, -1, -1, 558, 101, -1, - -1, 47, 785, 106, 515, -1, -1, 670, 671, -1, - -1, -1, 58, 309, -1, 61, 679, 313, 579, -1, - -1, 532, -1, -1, -1, -1, -1, 73, 74, -1, - -1, -1, 593, -1, -1, 81, -1, -1, -1, -1, - 601, -1, -1, 89, -1, -1, -1, 558, -1, -1, - -1, 97, -1, 714, 100, -1, 717, -1, 619, 105, - -1, 107, 358, 109, 110, 111, -1, 628, -1, 732, - -1, -1, 633, -1, -1, -1, -1, 58, -1, -1, - 61, -1, 593, -1, -1, -1, -1, -1, -1, -1, - 601, 72, 73, 74, -1, 391, 657, -1, 394, -1, - 81, -1, 885, -1, -1, -1, 402, -1, 89, 670, - 671, -1, -1, -1, -1, -1, 97, 628, 679, 100, - 58, -1, 633, 61, 105, -1, 107, 98, -1, 100, - 111, -1, 103, -1, 105, 73, 74, -1, 109, -1, - -1, 702, -1, 81, -1, -1, 657, -1, 119, -1, - -1, 89, -1, -1, -1, -1, -1, -1, -1, 97, - -1, -1, 100, -1, 827, -1, -1, 105, 679, 107, - -1, -1, -1, 111, -1, -1, 839, -1, -1, 150, - 151, 152, 153, 154, 155, -1, -1, -1, -1, -1, - -1, 702, -1, -1, 33, 34, 35, 36, 37, 38, - 39, -1, -1, -1, -1, 44, -1, 33, 34, -1, - 49, -1, 773, 52, -1, -1, -1, 43, -1, 58, - 46, -1, -1, 62, -1, 786, 52, -1, 54, -1, - -1, -1, 58, -1, -1, -1, 532, 63, -1, -1, - 66, 67, 68, -1, -1, 71, 72, 73, 74, -1, - -1, -1, -1, 79, -1, 81, -1, -1, -1, -1, - -1, -1, 773, 89, 90, -1, 827, 93, -1, -1, - -1, -1, -1, 99, 100, 786, -1, -1, -1, 105, - -1, 107, -1, 109, 110, 111, 112, 113, 47, -1, - -1, -1, -1, -1, -1, -1, -1, 593, -1, 58, - -1, 60, 61, -1, -1, 601, -1, -1, -1, 68, - -1, -1, 71, 72, 73, 74, 827, -1, -1, -1, - 79, -1, 81, 82, -1, -1, -1, 86, -1, -1, - 89, 90, 628, -1, 93, -1, -1, 633, 97, 98, - 99, 100, -1, 102, -1, -1, 105, -1, 107, -1, - -1, 110, 111, -1, -1, -1, 327, -1, -1, -1, - -1, 657, -1, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, 352, -1, 679, 355, 356, -1, 358, -1, -1, - -1, 33, 34, -1, 365, -1, -1, -1, 369, -1, - -1, 43, -1, -1, 46, -1, 702, 378, -1, -1, - 52, -1, 54, -1, -1, -1, 58, -1, -1, -1, - -1, 63, -1, -1, 66, 67, 68, -1, -1, 71, - 72, 73, 74, -1, 405, 77, -1, 79, -1, 81, - -1, -1, -1, -1, -1, -1, -1, 89, 90, -1, - -1, 93, -1, -1, -1, -1, -1, 99, 100, -1, - -1, 432, -1, 105, -1, 107, -1, -1, 110, 111, - 112, 113, -1, -1, -1, -1, -1, 773, -1, -1, - -1, 33, 34, -1, -1, -1, -1, -1, -1, -1, - 786, 43, -1, -1, 46, -1, -1, -1, -1, -1, - 52, -1, 54, -1, -1, -1, 58, -1, -1, -1, - -1, -1, -1, 484, 66, 67, 68, -1, -1, 71, - 72, 73, 74, -1, -1, -1, -1, 79, -1, 81, - -1, 827, -1, -1, -1, -1, -1, 89, 90, -1, - 511, 93, -1, 514, -1, -1, -1, 99, 100, -1, - -1, -1, -1, 105, -1, 107, -1, -1, 110, 111, - 112, 113, -1, -1, -1, 536, -1, -1, 33, 34, - -1, -1, -1, -1, 545, -1, -1, 548, 43, -1, - 551, 46, 47, 554, -1, 556, -1, 52, -1, 54, - -1, -1, -1, 58, -1, -1, 567, -1, 63, -1, - -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, - -1, -1, 77, -1, 79, -1, 81, -1, -1, -1, - -1, -1, -1, -1, -1, 90, -1, -1, 93, -1, - -1, -1, -1, 28, 99, -1, -1, -1, 33, 34, - 35, 36, 37, 38, 39, 110, 111, 112, 113, 44, - -1, -1, 623, -1, 49, -1, 51, 52, -1, -1, - 33, 34, -1, 58, -1, -1, -1, 62, -1, -1, - 43, -1, -1, 46, -1, -1, -1, -1, -1, 52, - -1, 54, -1, -1, -1, 58, -1, 658, 659, 660, - 63, -1, -1, 66, 67, 68, -1, -1, 71, 72, - -1, -1, -1, -1, 77, -1, 79, -1, 81, -1, - -1, -1, -1, -1, -1, -1, -1, 90, -1, -1, - 93, -1, -1, 694, -1, 696, 99, 698, 699, 700, - -1, 702, 703, -1, 26, 27, 28, 110, 111, 112, - 113, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, - 52, -1, -1, -1, -1, 736, 58, -1, -1, -1, - 62, -1, -1, -1, -1, -1, -1, -1, 749, 750, - 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, - 761, 762, 763, 764, 765, 766, 767, -1, -1, 770, - 771, -1, 773, -1, -1, 776, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 786, -1, 33, 34, -1, - -1, -1, 793, -1, -1, 796, -1, 43, -1, -1, + 7, 95, 77, 152, 166, 98, 13, 22, 3, 69, + 285, 3, 654, 556, 654, 391, 392, 3, 654, 654, + 103, 391, 392, 142, 52, 52, 801, 52, 640, 46, + 573, 0, 131, 132, 41, 109, 48, 49, 289, 844, + 139, 47, 47, 117, 61, 119, 58, 44, 61, 70, + 56, 48, 49, 47, 75, 52, 61, 75, 48, 49, + 67, 58, 69, 47, 71, 47, 73, 61, 75, 76, + 77, 78, 79, 47, 81, 82, 83, 61, 883, 61, + 97, 99, 103, 695, 97, 113, 113, 61, 113, 96, + 108, 98, 97, 46, 80, 102, 871, 71, 84, 904, + 476, 175, 53, 97, 7, 56, 476, 46, 46, 72, + 13, 58, 47, 97, 121, 97, 90, 47, 125, 134, + 3, 46, 75, 97, 71, 72, 61, 60, 135, 136, + 93, 61, 79, 140, 141, 142, 99, 75, 41, 22, + 223, 47, 47, 90, 111, 152, 93, 110, 111, 80, + 56, 56, 99, 84, 796, 46, 796, 164, 144, 321, + 796, 796, 97, 110, 67, 52, 69, 97, 59, 60, + 73, 61, 75, 76, 77, 78, 79, 47, 81, 82, + 83, 71, 433, 87, 88, 192, 56, 47, 71, 44, + 94, 74, 291, 76, 77, 294, 56, 80, 0, 102, + 90, 84, 301, 302, 50, 51, 60, 97, 47, 328, + 56, 3, 487, 756, 590, 98, 53, 56, 121, 56, + 52, 52, 125, 80, 37, 38, 39, 84, 85, 60, + 22, 44, 135, 136, 353, 53, 49, 140, 141, 52, + 50, 51, 3, 494, 101, 58, 52, 71, 72, 152, + 451, 502, 503, 454, 60, 79, 58, 44, 60, 61, + 46, 22, 48, 49, 46, 52, 90, 52, 44, 93, + 60, 73, 74, 46, 60, 99, 52, 60, 285, 81, + 59, 60, 74, 60, 76, 77, 110, 89, 80, 192, + 92, 53, 84, 46, 368, 97, 370, 44, 100, 373, + 58, 48, 49, 105, 59, 107, 44, 109, 110, 111, + 71, 49, 52, 74, 52, 76, 77, 377, 325, 80, + 58, 328, 52, 84, 331, 332, 50, 51, 71, 72, + 44, 59, 56, 56, 48, 49, 79, 98, 52, 59, + 60, 71, 72, 53, 58, 59, 353, 90, 91, 79, + 93, 59, 45, 56, 56, 362, 99, 431, 365, 59, + 90, 153, 46, 93, 46, 46, 3, 110, 111, 99, + 377, 46, 58, 53, 468, 61, 53, 56, 385, 44, + 110, 111, 544, 48, 49, 22, 72, 73, 74, 50, + 52, 46, 153, 58, 401, 81, 391, 392, 492, 391, + 392, 53, 285, 89, 390, 391, 392, 53, 53, 56, + 60, 97, 52, 46, 100, 46, 52, 491, 52, 105, + 671, 107, 325, 52, 59, 111, 53, 59, 331, 99, + 47, 550, 60, 59, 71, 60, 52, 74, 52, 76, + 77, 448, 53, 80, 459, 47, 47, 84, 53, 456, + 53, 47, 60, 60, 47, 46, 53, 72, 465, 362, + 46, 98, 365, 52, 47, 60, 585, 59, 53, 476, + 60, 52, 52, 52, 377, 46, 462, 52, 60, 52, + 487, 476, 385, 490, 476, 53, 60, 59, 75, 58, + 476, 47, 46, 9, 78, 11, 589, 60, 401, 15, + 16, 508, 46, 510, 47, 60, 389, 53, 391, 392, + 517, 52, 79, 53, 500, 501, 153, 52, 504, 58, + 36, 528, 60, 642, 285, 59, 59, 52, 55, 60, + 71, 72, 60, 607, 608, 609, 60, 60, 79, 60, + 46, 58, 53, 550, 53, 448, 50, 60, 622, 90, + 669, 558, 93, 456, 629, 53, 73, 74, 99, 46, + 60, 52, 465, 55, 81, 357, 52, 56, 56, 110, + 111, 53, 89, 648, 53, 56, 459, 739, 585, 53, + 742, 365, 589, 100, 100, 60, 55, 490, 105, 60, + 107, 598, 60, 476, 111, 590, 357, 389, 747, 391, + 392, 152, 390, 505, 487, 508, 30, 510, 749, 624, + 462, 597, 879, 570, 517, 131, 132, 71, 72, 696, + 570, 792, 558, 139, 661, 79, 871, 851, 389, 392, + 391, 392, 590, 640, 571, 642, 90, 332, -1, 93, + -1, -1, -1, -1, -1, 99, 765, 654, 285, -1, + 166, -1, -1, 639, -1, 558, 110, 111, -1, 654, + 675, -1, 669, -1, -1, -1, 673, 459, 654, 788, + 58, -1, 679, 767, -1, 661, -1, 560, -1, -1, + -1, 69, -1, -1, 476, 73, 74, 570, 695, 696, + -1, -1, -1, 81, -1, 598, -1, -1, 459, -1, + 707, 89, 709, 710, 711, -1, 589, 590, -1, -1, + 71, 72, 100, -1, -1, 476, -1, 105, 79, 107, + 357, 109, 110, 111, -1, -1, 487, -1, -1, 90, + 737, -1, 93, -1, -1, -1, -1, -1, 99, -1, + -1, 624, -1, -1, -1, 864, 629, -1, -1, 110, + 111, -1, 389, -1, 391, 392, 763, 640, 765, 878, + -1, -1, 836, -1, -1, 648, -1, 753, 560, -1, + 673, 654, 58, -1, -1, 291, 679, -1, 294, -1, + -1, 788, -1, -1, -1, 301, 302, 73, 74, 796, + -1, -1, 675, -1, 801, 81, -1, -1, 590, 560, + -1, 796, -1, 89, 707, 321, 709, 710, 711, -1, + 796, -1, 695, 696, 100, -1, -1, -1, -1, 105, + -1, 107, 459, 109, 110, 111, -1, -1, 589, 590, + -1, -1, 624, 840, -1, -1, 843, 629, -1, 476, + -1, -1, -1, 58, -1, -1, 61, -1, -1, -1, + 487, -1, -1, -1, -1, -1, 648, 864, 73, 74, + 763, -1, 654, 624, 871, -1, 81, -1, 629, -1, + -1, 878, -1, 97, 89, 99, -1, -1, 102, 865, + 104, -1, 97, 675, 108, 100, -1, 648, -1, -1, + 105, -1, 107, 654, 118, 902, 111, -1, -1, -1, + 886, -1, -1, -1, -1, 47, -1, -1, -1, -1, + -1, -1, -1, 796, 675, -1, 58, -1, 801, 61, + -1, -1, -1, 560, -1, 149, 150, 151, 152, 153, + 154, 73, 74, 570, -1, 727, -1, -1, -1, 81, + 843, -1, -1, -1, -1, -1, -1, 89, -1, -1, + -1, -1, 589, 590, -1, 97, -1, -1, 100, -1, + -1, -1, -1, 105, -1, 107, 727, 109, 110, 111, + -1, 70, -1, -1, -1, -1, 75, 76, -1, -1, + -1, 80, -1, -1, 83, 84, 85, 624, 871, -1, + -1, -1, 629, 509, 93, -1, 95, 96, -1, 902, + 792, -1, 101, 640, 796, -1, -1, 106, 33, 34, + -1, 648, -1, 529, -1, -1, -1, 654, 43, -1, + -1, 46, -1, -1, -1, -1, -1, 52, 544, 54, + -1, 792, -1, 58, -1, 796, -1, -1, 675, -1, + -1, 66, 67, 68, -1, -1, 71, 72, 73, 74, + -1, -1, 844, -1, 79, -1, 81, -1, 695, 696, + -1, -1, -1, -1, 89, 90, -1, -1, 93, -1, + -1, -1, -1, -1, 99, 100, -1, -1, -1, -1, + 105, -1, 107, 844, -1, 110, 111, 112, 113, -1, + 727, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 326, -1, -1, -1, -1, -1, -1, 333, + 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, 347, 348, 349, 350, 351, -1, -1, + 354, 355, -1, 357, -1, -1, -1, -1, -1, 363, + -1, -1, 366, -1, -1, -1, -1, -1, -1, -1, + -1, 375, -1, -1, -1, 792, -1, 28, -1, 796, + -1, -1, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 396, 44, -1, -1, 33, 34, 49, -1, + 51, 52, -1, -1, -1, -1, 43, 58, -1, 46, + -1, 62, -1, -1, -1, 52, -1, 54, -1, 423, + -1, 58, -1, -1, -1, -1, 63, 844, -1, 66, + 67, 68, -1, -1, 71, 72, 73, 74, -1, -1, + -1, -1, 79, 739, 81, -1, 742, -1, -1, -1, + -1, -1, 89, 90, -1, -1, 93, -1, -1, -1, + -1, -1, 99, 100, -1, -1, -1, -1, 105, -1, + 107, -1, 109, 110, 111, 112, 113, 33, 34, 483, + -1, -1, 486, -1, -1, -1, -1, 43, -1, -1, 46, -1, -1, -1, -1, -1, 52, -1, 54, -1, - -1, -1, 58, -1, -1, -1, -1, 63, -1, 820, - 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, + -1, -1, 58, -1, -1, -1, -1, 63, -1, -1, + 66, 67, 68, -1, -1, 71, 72, 73, 74, 523, -1, 77, -1, 79, -1, 81, -1, -1, -1, -1, - -1, 842, 843, -1, 90, -1, 847, 93, -1, 850, - -1, -1, -1, 99, -1, -1, 857, 858, 859, -1, - -1, -1, -1, -1, 110, 111, 112, 113, -1, -1, - -1, -1, -1, -1, -1, 876, -1, 878, 22, 23, + -1, -1, -1, 89, 90, -1, -1, 93, -1, -1, + -1, -1, -1, 99, 100, -1, -1, -1, -1, 105, + -1, 107, 556, -1, 110, 111, 112, 113, -1, -1, + -1, -1, -1, -1, 568, 33, 34, -1, -1, 573, + -1, -1, -1, -1, 578, 43, -1, 581, 46, 47, + 584, -1, 586, -1, 52, -1, 54, -1, -1, -1, + 58, -1, -1, -1, -1, 63, -1, -1, 66, 67, + 68, -1, -1, 71, 72, -1, -1, -1, -1, 77, + -1, 79, -1, 81, -1, -1, -1, -1, -1, -1, + -1, -1, 90, -1, -1, 93, -1, -1, -1, -1, + -1, 99, -1, -1, -1, -1, 33, 34, -1, -1, + 644, -1, 110, 111, 112, 113, 43, -1, -1, 46, + 47, 655, 656, 657, -1, 52, -1, 54, -1, -1, + -1, 58, -1, -1, -1, -1, 63, -1, -1, 66, + 67, 68, -1, -1, 71, 72, -1, -1, -1, -1, + 77, -1, 79, -1, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 90, -1, -1, 93, -1, -1, -1, + -1, -1, 99, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 110, 111, 112, 113, -1, -1, 723, + 724, 725, -1, 727, 728, 28, -1, -1, -1, -1, + 33, 34, 35, 36, 37, 38, 39, -1, 41, 42, + -1, 44, -1, 747, -1, -1, 49, -1, 51, 52, + 754, -1, 756, -1, -1, 58, -1, -1, -1, 62, + -1, -1, -1, -1, 768, 769, 770, 771, 772, 773, + 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, + 784, 785, 786, -1, 28, 789, 790, -1, 792, 33, + 34, 35, 36, 37, 38, 39, -1, 41, -1, 47, + 44, -1, 806, -1, 808, 49, -1, 51, 52, -1, + 58, -1, 60, 61, 58, -1, -1, -1, 62, -1, + 68, -1, -1, 71, 72, 73, 74, -1, 832, -1, + -1, 79, -1, 81, 82, -1, -1, -1, 86, -1, + 844, 89, 90, -1, -1, 93, -1, 851, -1, 97, + 98, 99, 100, 857, 102, -1, 860, 105, -1, 107, + -1, -1, 110, 111, -1, -1, -1, -1, -1, -1, + 874, 875, -1, -1, -1, 879, -1, -1, -1, 883, + 884, 885, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, -1, -1, 26, 27, + 904, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, -1, 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, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 22, -1, -1, -1, + 26, 27, -1, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 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, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 22, -1, -1, -1, 26, 27, -1, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, -1, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 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, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 22, -1, -1, -1, 26, 27, -1, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 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, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 22, -1, -1, -1, 26, 27, -1, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 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, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 33, 34, -1, -1, -1, -1, - -1, -1, -1, -1, 43, -1, -1, 46, -1, -1, - -1, -1, -1, 52, -1, 54, -1, -1, -1, 58, - -1, -1, -1, -1, 63, -1, -1, 66, 67, 68, - -1, -1, 71, 72, -1, -1, -1, -1, -1, -1, - 79, -1, 81, 33, 34, -1, -1, -1, -1, -1, - -1, 90, -1, 43, 93, -1, 46, -1, -1, -1, - 99, -1, 52, -1, 54, -1, -1, -1, 58, -1, - 60, 110, 111, 112, 113, -1, 66, 67, 68, -1, - -1, 71, 72, -1, -1, -1, -1, -1, -1, 79, - -1, 81, 33, 34, -1, -1, -1, -1, -1, -1, - 90, -1, 43, 93, -1, -1, 47, -1, -1, 99, - -1, 52, -1, 54, -1, -1, -1, 58, -1, -1, - 110, 111, 112, 113, -1, 66, 67, 68, -1, -1, - 71, 72, -1, -1, -1, -1, 77, -1, 79, -1, - 81, 33, 34, -1, -1, -1, -1, -1, -1, 90, - -1, 43, 93, -1, 46, 47, -1, -1, 99, -1, - 52, -1, 54, -1, -1, -1, 58, -1, -1, 110, - 111, 112, 113, -1, 66, 67, 68, -1, -1, 71, - 72, -1, -1, -1, -1, -1, -1, 79, -1, 81, - 33, 34, -1, -1, -1, -1, -1, -1, 90, -1, - 43, 93, -1, 46, -1, -1, -1, 99, -1, 52, - -1, 54, -1, -1, -1, 58, -1, -1, 110, 111, - 112, 113, -1, 66, 67, 68, -1, -1, 71, 72, + 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, + 43, -1, -1, 46, -1, -1, -1, -1, -1, 52, + 53, 54, -1, -1, -1, 58, -1, -1, -1, -1, + 63, -1, -1, 66, 67, 68, -1, -1, 71, 72, + -1, -1, -1, -1, -1, -1, 79, -1, 81, 33, + 34, -1, -1, -1, -1, -1, -1, 90, -1, 43, + 93, 45, 46, -1, -1, -1, 99, -1, 52, -1, + 54, -1, 56, -1, 58, -1, -1, 110, 111, 112, + 113, -1, 66, 67, 68, -1, -1, 71, 72, -1, + -1, -1, -1, -1, -1, 79, -1, 81, 33, 34, + -1, -1, -1, -1, -1, -1, 90, -1, 43, 93, + -1, 46, 47, -1, -1, 99, -1, 52, -1, 54, + -1, 56, -1, 58, -1, -1, 110, 111, 112, 113, + -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, + -1, -1, -1, -1, 79, -1, 81, 33, 34, -1, + -1, -1, -1, -1, -1, 90, -1, 43, 93, -1, + 46, -1, -1, -1, 99, -1, 52, 53, 54, -1, + 56, -1, 58, -1, -1, 110, 111, 112, 113, -1, + 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, + -1, -1, -1, 79, -1, 81, -1, -1, 33, 34, + -1, -1, -1, -1, 90, -1, -1, 93, 43, -1, + -1, 46, -1, 99, -1, -1, -1, 52, -1, 54, + -1, -1, -1, 58, 110, 111, 112, 113, 63, -1, + -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, + -1, -1, 77, -1, 79, -1, 81, -1, -1, 33, + 34, -1, -1, -1, -1, 90, -1, -1, 93, 43, + -1, -1, 46, -1, 99, -1, -1, -1, 52, -1, + 54, -1, -1, -1, 58, 110, 111, 112, 113, 63, + -1, -1, 66, 67, 68, -1, -1, 71, 72, -1, + -1, -1, -1, 77, -1, 79, -1, 81, -1, -1, + 33, 34, -1, -1, -1, -1, 90, -1, -1, 93, + 43, -1, -1, 46, -1, 99, -1, -1, -1, 52, + -1, 54, -1, -1, -1, 58, 110, 111, 112, 113, + 63, -1, -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, -1, -1, -1, 79, -1, 81, 33, 34, -1, -1, -1, -1, -1, -1, 90, -1, 43, 93, -1, 46, -1, -1, -1, 99, -1, 52, -1, - 54, -1, -1, -1, 58, -1, -1, 110, 111, 112, + 54, -1, -1, -1, 58, -1, 60, 110, 111, 112, 113, -1, 66, 67, 68, -1, -1, 71, 72, -1, - -1, -1, -1, -1, -1, 79, -1, 81, -1, -1, - -1, -1, -1, -1, -1, -1, 90, -1, -1, 93, - 47, -1, -1, -1, -1, 99, -1, -1, -1, -1, - -1, 58, -1, 60, 61, -1, 110, 111, 112, 113, - -1, 68, -1, -1, 71, 72, 73, 74, -1, -1, - -1, -1, 79, -1, 81, -1, -1, -1, -1, 86, - -1, -1, 89, 90, -1, -1, 93, -1, 47, -1, - 97, -1, 99, 100, -1, -1, -1, 104, 105, 58, - 107, 60, 61, 110, 111, -1, -1, -1, -1, 68, + -1, -1, -1, -1, -1, 79, -1, 81, 33, 34, + -1, -1, -1, -1, -1, -1, 90, -1, 43, 93, + -1, -1, 47, -1, -1, 99, -1, 52, -1, 54, + -1, -1, -1, 58, -1, -1, 110, 111, 112, 113, + -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, + -1, -1, 77, -1, 79, -1, 81, 33, 34, -1, + -1, -1, -1, -1, -1, 90, -1, 43, 93, -1, + 46, 47, -1, -1, 99, -1, 52, -1, 54, -1, + -1, -1, 58, -1, -1, 110, 111, 112, 113, -1, + 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, + -1, -1, -1, 79, -1, 81, 33, 34, -1, -1, + -1, -1, -1, -1, 90, -1, 43, 93, -1, 46, + -1, -1, -1, 99, -1, 52, -1, 54, -1, -1, + -1, 58, -1, -1, 110, 111, 112, 113, -1, 66, + 67, 68, -1, -1, 71, 72, -1, -1, -1, -1, + -1, -1, 79, -1, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 90, -1, -1, 93, 47, -1, -1, + -1, -1, 99, -1, -1, -1, -1, -1, 58, -1, + 60, 61, -1, 110, 111, 112, 113, -1, 68, -1, + -1, 71, 72, 73, 74, -1, -1, -1, -1, 79, + -1, 81, -1, -1, -1, -1, 86, -1, -1, 89, + 90, -1, -1, 93, -1, 47, -1, 97, -1, 99, + 100, -1, -1, -1, 104, 105, 58, 107, 60, 61, + 110, 111, -1, -1, -1, -1, 68, -1, -1, 71, + 72, 73, 74, -1, -1, -1, -1, 79, -1, 81, + -1, -1, -1, -1, 86, -1, -1, 89, 90, -1, + -1, 93, -1, -1, -1, 97, -1, 99, 100, 58, + -1, -1, -1, 105, 63, 107, -1, -1, 110, 111, -1, -1, 71, 72, 73, 74, -1, -1, -1, -1, - 79, -1, 81, -1, -1, -1, -1, 86, -1, -1, - 89, 90, -1, -1, 93, -1, -1, -1, 97, -1, - 99, 100, 58, -1, -1, -1, 105, 63, 107, -1, - -1, 110, 111, -1, -1, 71, 72, 73, 74, -1, + 79, -1, 81, -1, -1, -1, -1, -1, -1, -1, + 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, + 99, 100, 58, -1, -1, -1, 105, -1, 107, -1, + 109, 110, 111, -1, -1, 71, 72, 73, 74, -1, -1, -1, -1, 79, -1, 81, -1, -1, -1, -1, -1, -1, -1, 89, 90, -1, -1, 93, -1, -1, - -1, -1, -1, 99, 100, 58, -1, -1, -1, 105, - -1, 107, -1, 109, 110, 111, -1, -1, 71, 72, - 73, 74, -1, -1, -1, -1, 79, -1, 81, -1, - -1, -1, -1, -1, -1, -1, 89, 90, -1, -1, - 93, -1, -1, -1, -1, -1, 99, 100, -1, -1, - -1, -1, 105, -1, 107, -1, 109, 110, 111, 58, - -1, 60, 61, -1, -1, -1, -1, -1, -1, 68, - -1, -1, 71, 72, -1, -1, -1, -1, -1, -1, - 79, -1, -1, 82, -1, -1, -1, 86, -1, -1, - -1, 90, 58, -1, 93, -1, -1, -1, 97, 98, - 99, -1, -1, 102, -1, 71, 72, 73, 74, -1, - -1, 110, 111, 79, -1, 81, -1, -1, -1, -1, - -1, -1, -1, 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, 99, 100, -1, -1, -1, -1, 105, - -1, 107, -1, -1, 110, 111, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, - 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, - -1, -1, 62, -1, 64, 65, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, - 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, - -1, -1, 62, -1, 64, 65, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, - 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, - -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, + -1, 107, -1, 109, 110, 111, 58, -1, 60, 61, + -1, -1, -1, -1, -1, -1, 68, -1, -1, 71, + 72, -1, -1, -1, -1, -1, -1, 79, -1, -1, + 82, -1, -1, -1, 86, -1, -1, -1, 90, 58, + -1, 93, -1, -1, -1, 97, 98, 99, -1, -1, + 102, -1, 71, 72, 73, 74, -1, -1, 110, 111, + 79, -1, 81, -1, -1, -1, -1, -1, -1, -1, + 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, + 99, 100, -1, -1, -1, -1, 105, -1, 107, -1, + -1, 110, 111, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, + 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, + -1, 64, 65, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, + -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, + -1, 64, 65, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, @@ -1418,14 +1472,14 @@ public static class yycheck_wrapper { -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, - 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, + 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, - -1, -1, -1, 48, 49, 50, 51, 52, 53, -1, + 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, @@ -1440,33 +1494,33 @@ public static class yycheck_wrapper { -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, - -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, + -1, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, - 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, - 60, -1, 62, 26, 27, 28, 29, 30, 31, 32, + 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, + -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, - -1, -1, 48, 49, 50, 51, 52, 53, -1, -1, - -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, + -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, + -1, 57, 58, -1, 60, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, - 52, -1, -1, -1, -1, 57, 58, -1, 60, -1, + 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, - 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, - -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, + -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, + -1, -1, 57, 58, -1, 60, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, - 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, + 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, + 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, @@ -1477,7 +1531,7 @@ public static class yycheck_wrapper { -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, - -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, + -1, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, @@ -1487,12 +1541,12 @@ public static class yycheck_wrapper { -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, - -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, + 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, + -1, -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, - 49, 50, 51, 52, -1, -1, -1, 56, 57, 58, + 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, + 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, @@ -1500,31 +1554,35 @@ public static class yycheck_wrapper { 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, - -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, + -1, 56, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, - 51, 52, -1, -1, -1, -1, -1, 58, -1, -1, - -1, 62, 26, 27, 28, 29, -1, 31, 32, 33, + 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, + -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, + 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, + -1, -1, -1, -1, 58, -1, -1, -1, 62, 26, + 27, 28, 29, -1, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, + -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, + -1, 58, 26, 27, 28, 62, -1, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, -1, 58, 26, 27, 28, 62, -1, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + -1, -1, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, -1, 58, 28, -1, -1, 62, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, -1, -1, -1, -1, 49, - -1, 51, 52, -1, -1, -1, -1, -1, 58, 28, - -1, -1, 62, -1, 33, 34, 35, 36, 37, 38, - 39, -1, 41, 42, -1, 44, -1, -1, -1, -1, - 49, -1, 51, 52, -1, -1, -1, -1, -1, 58, - 28, -1, -1, 62, -1, 33, 34, 35, 36, 37, - 38, 39, -1, 41, -1, -1, 44, -1, -1, -1, - -1, 49, -1, 51, 52, -1, -1, -1, -1, -1, - 58, -1, -1, -1, 62 + -1, -1, -1, -1, 44, -1, -1, -1, -1, 49, + -1, 51, 52, -1, -1, -1, -1, -1, 58, -1, + -1, -1, 62, 33, 34, 35, 36, 37, 38, 39, + -1, -1, -1, -1, 44, -1, -1, -1, -1, 49, + -1, -1, 52, -1, -1, -1, -1, -1, 58, -1, + -1, -1, 62 }; } @@ -1532,93 +1590,95 @@ public static class yystos_wrapper { public static final int[] yystos = { 0, 119, 120, 121, 0, 58, 60, 61, 73, 74, 81, 89, 92, 97, 100, 105, 107, 109, 110, 111, - 122, 127, 128, 129, 138, 141, 146, 147, 152, 173, - 174, 180, 184, 187, 189, 190, 191, 192, 193, 194, - 195, 203, 204, 205, 208, 209, 214, 219, 220, 222, - 247, 249, 252, 71, 72, 79, 90, 93, 99, 110, - 111, 123, 124, 48, 49, 263, 46, 263, 46, 124, - 263, 263, 70, 75, 76, 80, 83, 84, 85, 93, - 95, 96, 101, 106, 81, 129, 187, 60, 111, 52, - 60, 145, 60, 145, 127, 128, 230, 52, 44, 263, - 44, 124, 60, 44, 52, 52, 113, 124, 221, 52, - 113, 221, 130, 63, 109, 123, 187, 199, 200, 52, - 113, 124, 187, 124, 111, 124, 187, 110, 123, 124, - 184, 187, 124, 124, 127, 187, 204, 124, 124, 124, - 187, 204, 52, 127, 134, 135, 136, 148, 46, 46, - 33, 34, 43, 46, 52, 54, 63, 66, 67, 68, - 81, 112, 113, 123, 124, 146, 188, 190, 193, 253, - 254, 255, 261, 123, 261, 200, 261, 196, 197, 263, - 124, 132, 133, 256, 261, 130, 261, 50, 51, 264, - 47, 56, 261, 264, 47, 22, 23, 26, 27, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 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, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 131, 56, 264, 261, 264, 52, 124, - 175, 215, 124, 181, 60, 60, 206, 210, 124, 124, - 139, 153, 196, 124, 124, 253, 87, 88, 94, 137, - 53, 56, 46, 177, 231, 261, 261, 261, 132, 256, - 81, 187, 190, 193, 261, 261, 58, 59, 123, 52, - 58, 258, 53, 56, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 44, 50, 51, 52, 57, 62, 258, 263, 45, - 264, 45, 185, 124, 198, 59, 45, 56, 45, 56, - 53, 53, 124, 53, 130, 199, 53, 134, 59, 196, - 46, 216, 196, 196, 196, 196, 196, 46, 53, 187, - 136, 150, 72, 127, 128, 141, 178, 187, 238, 247, - 248, 249, 232, 47, 47, 53, 53, 124, 261, 253, - 259, 124, 255, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 50, 253, 261, 261, 63, 109, 187, 201, - 202, 261, 52, 56, 264, 261, 133, 261, 264, 264, - 53, 264, 53, 251, 261, 176, 221, 46, 182, 207, - 211, 140, 154, 212, 124, 124, 127, 141, 151, 155, - 156, 172, 248, 249, 179, 230, 103, 187, 124, 47, - 60, 68, 82, 86, 98, 102, 123, 127, 141, 146, - 190, 223, 224, 225, 226, 227, 228, 229, 230, 233, - 237, 248, 249, 257, 260, 261, 53, 124, 59, 60, - 45, 55, 261, 53, 55, 56, 264, 134, 124, 230, - 60, 52, 47, 124, 217, 218, 46, 46, 46, 52, - 52, 47, 127, 213, 59, 60, 59, 99, 108, 127, - 149, 156, 47, 124, 124, 59, 250, 60, 52, 60, - 261, 52, 123, 58, 44, 52, 59, 258, 263, 46, - 142, 261, 261, 199, 52, 53, 134, 59, 47, 56, - 183, 212, 212, 134, 134, 187, 142, 261, 124, 263, - 47, 46, 250, 251, 60, 261, 60, 261, 72, 261, - 253, 261, 200, 143, 60, 45, 253, 53, 251, 218, - 47, 127, 186, 47, 47, 53, 53, 124, 60, 157, - 190, 191, 194, 71, 90, 127, 239, 240, 60, 53, - 53, 52, 45, 55, 53, 60, 264, 47, 128, 141, - 144, 252, 53, 69, 111, 184, 60, 46, 264, 264, - 264, 59, 59, 75, 126, 47, 240, 190, 229, 46, - 253, 261, 60, 52, 184, 52, 60, 158, 52, 52, - 52, 46, 46, 72, 79, 93, 99, 110, 111, 125, - 78, 234, 53, 45, 253, 60, 134, 104, 127, 128, - 159, 160, 162, 187, 223, 224, 227, 228, 248, 249, - 261, 261, 261, 243, 241, 59, 59, 229, 33, 34, - 43, 47, 52, 54, 66, 67, 68, 77, 81, 112, - 113, 123, 146, 188, 190, 235, 236, 262, 60, 53, - 53, 91, 124, 163, 164, 46, 187, 47, 53, 53, - 53, 47, 127, 47, 242, 261, 46, 251, 261, 261, - 261, 187, 261, 261, 58, 123, 52, 258, 55, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 44, 50, 51, 52, - 57, 62, 258, 263, 60, 60, 52, 60, 161, 124, - 124, 124, 146, 244, 257, 55, 52, 63, 77, 167, - 168, 171, 245, 246, 261, 60, 53, 53, 124, 253, - 230, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 50, 253, 261, 261, 202, 261, 256, 158, 60, 60, - 60, 60, 52, 124, 63, 77, 170, 171, 261, 55, - 47, 245, 64, 65, 261, 53, 45, 55, 261, 53, - 55, 264, 53, 47, 253, 127, 53, 56, 64, 65, - 244, 261, 261, 261, 261, 52, 46, 53, 60, 169, - 171, 261, 261, 127, 45, 253, 165, 53, 56, 60, - 53, 47, 166, 167, 171, 55, 124, 60 + 122, 127, 128, 129, 140, 143, 148, 149, 154, 175, + 178, 184, 189, 191, 196, 198, 199, 200, 201, 202, + 203, 204, 214, 215, 216, 219, 222, 227, 232, 233, + 235, 264, 267, 270, 71, 72, 79, 90, 93, 99, + 110, 111, 123, 124, 48, 49, 285, 46, 285, 46, + 124, 285, 285, 70, 75, 76, 80, 83, 84, 85, + 93, 95, 96, 101, 106, 81, 129, 196, 60, 111, + 52, 60, 147, 60, 147, 271, 52, 44, 285, 44, + 124, 60, 44, 52, 52, 113, 124, 234, 52, 113, + 234, 131, 63, 109, 123, 196, 210, 211, 52, 113, + 124, 196, 124, 111, 124, 196, 110, 123, 124, 191, + 196, 124, 124, 127, 128, 196, 215, 124, 124, 124, + 196, 215, 52, 135, 136, 46, 46, 127, 244, 33, + 34, 43, 46, 52, 54, 63, 66, 67, 68, 81, + 112, 113, 123, 124, 148, 197, 199, 202, 272, 273, + 274, 281, 282, 123, 281, 211, 281, 205, 206, 285, + 124, 130, 133, 134, 275, 281, 131, 281, 50, 51, + 286, 47, 56, 281, 286, 47, 22, 23, 26, 27, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 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, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 132, 56, 286, 281, 286, 52, + 124, 179, 228, 124, 185, 60, 60, 205, 205, 124, + 124, 141, 155, 205, 124, 124, 272, 53, 127, 137, + 138, 150, 176, 46, 281, 281, 281, 133, 275, 81, + 196, 199, 202, 281, 281, 58, 59, 123, 52, 58, + 277, 53, 56, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 44, 50, 51, 52, 57, 62, 277, 285, 45, 286, + 45, 192, 207, 59, 45, 56, 56, 53, 53, 124, + 53, 131, 210, 53, 135, 59, 205, 46, 229, 205, + 46, 46, 205, 205, 46, 53, 87, 88, 94, 139, + 56, 152, 181, 245, 47, 47, 53, 53, 124, 281, + 272, 278, 124, 274, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 50, 272, 281, 281, 63, 109, 196, + 212, 213, 281, 52, 124, 209, 281, 134, 281, 286, + 286, 53, 286, 53, 269, 281, 180, 234, 46, 186, + 217, 223, 142, 156, 220, 124, 196, 138, 127, 128, + 143, 153, 157, 158, 174, 196, 266, 267, 72, 127, + 143, 182, 252, 264, 266, 267, 246, 281, 53, 124, + 59, 60, 45, 55, 281, 53, 55, 56, 286, 135, + 56, 208, 265, 60, 52, 47, 124, 230, 231, 46, + 225, 225, 52, 52, 225, 59, 60, 124, 99, 108, + 196, 127, 151, 158, 124, 183, 244, 103, 47, 60, + 68, 82, 86, 98, 102, 123, 127, 143, 148, 199, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 247, + 251, 266, 267, 276, 279, 46, 144, 281, 281, 210, + 52, 53, 124, 286, 244, 135, 59, 47, 56, 187, + 127, 218, 226, 224, 135, 135, 221, 144, 59, 124, + 285, 124, 47, 59, 268, 177, 124, 60, 52, 60, + 281, 52, 123, 58, 44, 52, 59, 277, 280, 285, + 145, 60, 45, 272, 53, 269, 231, 190, 196, 47, + 47, 53, 53, 47, 60, 281, 159, 199, 200, 203, + 268, 269, 60, 47, 46, 281, 60, 281, 72, 281, + 272, 281, 211, 47, 128, 143, 146, 270, 53, 127, + 188, 193, 195, 124, 46, 286, 286, 286, 60, 253, + 53, 53, 52, 45, 55, 53, 60, 286, 69, 111, + 191, 47, 194, 60, 160, 52, 52, 52, 71, 90, + 127, 255, 256, 199, 243, 46, 272, 281, 60, 52, + 191, 52, 60, 104, 127, 128, 161, 162, 164, 196, + 236, 238, 241, 242, 266, 267, 281, 281, 281, 59, + 59, 75, 126, 254, 256, 78, 248, 53, 45, 272, + 60, 135, 91, 124, 165, 166, 46, 196, 47, 53, + 53, 53, 46, 46, 79, 72, 93, 99, 110, 111, + 125, 47, 243, 33, 34, 43, 47, 52, 54, 66, + 67, 68, 77, 81, 112, 113, 123, 148, 197, 199, + 249, 250, 283, 284, 60, 53, 53, 52, 60, 163, + 124, 124, 124, 259, 257, 59, 59, 281, 281, 281, + 196, 281, 281, 58, 123, 52, 277, 55, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 44, 50, 51, 52, 57, + 62, 277, 285, 60, 60, 275, 160, 60, 60, 60, + 47, 127, 260, 47, 258, 281, 46, 269, 53, 53, + 124, 272, 244, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 50, 272, 281, 281, 213, 281, 53, 47, + 148, 261, 276, 55, 52, 63, 77, 169, 170, 173, + 262, 263, 281, 60, 281, 53, 45, 55, 281, 53, + 55, 286, 46, 60, 52, 124, 63, 77, 172, 173, + 281, 55, 47, 262, 64, 65, 281, 281, 52, 167, + 272, 127, 53, 56, 64, 65, 261, 281, 281, 45, + 272, 47, 168, 169, 53, 60, 171, 173, 281, 281, + 127, 53, 55, 53, 56, 60, 124, 173, 60 }; } diff --git a/src/superc/p4parser/P4Tag.java b/src/superc/p4parser/P4Tag.java index 1acdef28..f7648cce 100644 --- a/src/superc/p4parser/P4Tag.java +++ b/src/superc/p4parser/P4Tag.java @@ -109,7 +109,7 @@ public enum P4Tag implements superc.core.Syntax.LanguageTag { END_PRAGMA(getID("END_PRAGMA"), null), PRAGMA(getID("PRAGMA"), "@pragma"), FLOATING_CONSTANT(getID("FLOATING_CONSTANT"), null, false, PreprocessorTag.NUMBER), -PPNUM(getID("PPNUM"), null, false, PreprocessorTag.NUMBER) +PPNUM(getID("PPNUM"), null, false, PreprocessorTag.NUMBER), ; private final int id; diff --git a/src/superc/p4parser/P4Values.java b/src/superc/p4parser/P4Values.java index 38129218..792efb28 100644 --- a/src/superc/p4parser/P4Values.java +++ b/src/superc/p4parser/P4Values.java @@ -48,7 +48,7 @@ public Object getValue(int id, String name, Pair values) { return value; } public ValueType getValueType(int id) { - if (0 <= id && id < 121 || 262 < id) { + if (0 <= id && id < 121 || 284 < id) { return ValueType.NODE; } switch (id - 121) { @@ -56,104 +56,134 @@ public ValueType getValueType(int id) { // Fall through case 7: // annotations (128) // Fall through - case 9: // annotationBody (130) + case 10: // annotationBody (131) // Fall through - case 11: // kvList (132) + case 12: // kvList (133) // Fall through - case 13: // parameterList (134) + case 14: // parameterList (135) // Fall through - case 14: // nonEmptyParameterList (135) + case 16: // nonEmptyParameterList (137) // Fall through - case 29: // parserLocalElements (150) + case 31: // parserLocalElements (152) // Fall through - case 34: // parserStates (155) + case 36: // parserStates (157) // Fall through - case 37: // parserStatements (158) + case 39: // parserStatements (160) // Fall through - case 44: // selectCaseList (165) + case 46: // selectCaseList (167) // Fall through - case 48: // simpleExpressionList (169) + case 50: // simpleExpressionList (171) // Fall through - case 56: // controlLocalDeclarations (177) + case 60: // controlLocalDeclarations (181) // Fall through - case 62: // methodPrototypes (183) + case 69: // methodPrototypes (190) // Fall through - case 77: // typeParameterList (198) + case 88: // typeParameterList (209) // Fall through - case 79: // typeArgumentList (200) + case 90: // typeArgumentList (211) // Fall through - case 81: // realTypeArgumentList (202) + case 92: // realTypeArgumentList (213) // Fall through - case 91: // structFieldList (212) + case 104: // structFieldList (225) // Fall through - case 96: // specifiedIdentifierList (217) + case 109: // specifiedIdentifierList (230) // Fall through - case 100: // identifierList (221) + case 113: // identifierList (234) // Fall through - case 111: // statOrDeclList (232) + case 125: // statOrDeclList (246) // Fall through - case 113: // switchCases (234) + case 127: // switchCases (248) // Fall through - case 118: // tablePropertyList (239) + case 134: // tablePropertyList (255) // Fall through - case 120: // keyElementList (241) + case 136: // keyElementList (257) // Fall through - case 122: // actionList (243) + case 138: // actionList (259) // Fall through - case 125: // entriesList (246) + case 142: // entriesList (263) // Fall through - case 132: // argumentList (253) + case 152: // nonEmptyArgList (273) // Fall through - case 133: // nonEmptyArgList (254) + case 154: // expressionList (275) // Fall through - case 135: // expressionList (256) + case 160: // expression (281) // Fall through - case 140: // expression (261) + case 161: // invokingExpression (282) // Fall through - case 141: // nonBraceExpression (262) + case 162: // nonBraceExpression (283) + // Fall through + case 163: // invokingNonBraceExpression (284) return ValueType.LIST; - case 18: // $@1 (139) + case 15: // $@1 (136) // Fall through - case 19: // $@2 (140) + case 20: // $@2 (141) // Fall through - case 27: // $@3 (148) + case 21: // $@3 (142) // Fall through - case 28: // $@4 (149) + case 29: // $@4 (150) // Fall through - case 32: // $@5 (153) + case 30: // $@5 (151) // Fall through - case 33: // $@6 (154) + case 34: // $@6 (155) // Fall through - case 36: // $@7 (157) + case 35: // $@7 (156) // Fall through - case 40: // $@8 (161) + case 38: // $@8 (159) // Fall through - case 54: // $@9 (175) + case 42: // $@9 (163) // Fall through case 55: // $@10 (176) // Fall through - case 60: // $@11 (181) + case 56: // $@11 (177) + // Fall through + case 58: // $@12 (179) + // Fall through + case 59: // $@13 (180) + // Fall through + case 64: // $@14 (185) + // Fall through + case 65: // $@15 (186) + // Fall through + case 66: // $@16 (187) + // Fall through + case 67: // $@17 (188) + // Fall through + case 71: // $@18 (192) + // Fall through + case 73: // $@19 (194) + // Fall through + case 86: // $@20 (207) // Fall through - case 61: // $@12 (182) + case 87: // $@21 (208) // Fall through - case 64: // $@13 (185) + case 96: // $@22 (217) // Fall through - case 85: // $@14 (206) + case 97: // $@23 (218) // Fall through - case 86: // $@15 (207) + case 99: // $@24 (220) // Fall through - case 89: // $@16 (210) + case 100: // $@25 (221) // Fall through - case 90: // $@17 (211) + case 102: // $@26 (223) // Fall through - case 94: // $@18 (215) + case 103: // $@27 (224) // Fall through - case 95: // $@19 (216) + case 107: // $@28 (228) // Fall through - case 110: // $@20 (231) + case 108: // $@29 (229) // Fall through - case 138: // $@21 (259) + case 124: // $@30 (245) + // Fall through + case 132: // $@31 (253) + // Fall through + case 133: // $@32 (254) + // Fall through + case 144: // $@33 (265) + // Fall through + case 150: // $@34 (271) + // Fall through + case 157: // $@35 (278) return ValueType.ACTION; default: @@ -162,17 +192,63 @@ public ValueType getValueType(int id) { } public boolean isComplete(int id) { switch(id) { - case 256: // expressionList + case 256: // tableProperty + // Fall through + case 257: // keyElementList + // Fall through + case 258: // keyElement + // Fall through + case 259: // actionList + // Fall through + case 260: // action + // Fall through + case 261: // actionRef // Fall through - case 258: // dot_name + case 262: // entry // Fall through - case 259: // $@21 + case 263: // entriesList // Fall through - case 260: // lvalue + case 264: // actionDeclaration // Fall through - case 261: // expression + case 265: // $@33 // Fall through - case 262: // nonBraceExpression + case 266: // variableDeclaration + // Fall through + case 267: // constantDeclaration + // Fall through + case 268: // optInitializer + // Fall through + case 269: // initializer + // Fall through + case 270: // functionDeclaration + // Fall through + case 271: // $@34 + // Fall through + case 272: // argumentList + // Fall through + case 273: // nonEmptyArgList + // Fall through + case 274: // argument + // Fall through + case 275: // expressionList + // Fall through + case 277: // dot_name + // Fall through + case 278: // $@35 + // Fall through + case 279: // lvalue + // Fall through + case 280: // lvalueExpression + // Fall through + case 281: // expression + // Fall through + case 282: // invokingExpression + // Fall through + case 283: // nonBraceExpression + // Fall through + case 284: // invokingNonBraceExpression + // Fall through + case 119: // start // Fall through case 120: // program // Fall through @@ -186,231 +262,227 @@ public boolean isComplete(int id) { // Fall through case 129: // annotation // Fall through - case 130: // annotationBody + case 131: // annotationBody // Fall through - case 132: // kvList + case 133: // kvList // Fall through - case 133: // kvPair + case 134: // kvPair // Fall through - case 134: // parameterList + case 135: // parameterList // Fall through - case 135: // nonEmptyParameterList + case 136: // $@1 // Fall through - case 136: // parameter + case 137: // nonEmptyParameterList // Fall through - case 138: // packageTypeDeclaration + case 138: // parameter // Fall through - case 139: // $@1 + case 140: // packageTypeDeclaration // Fall through - case 140: // $@2 + case 141: // $@2 // Fall through - case 141: // instantiation + case 142: // $@3 // Fall through - case 145: // optConstructorParameters + case 143: // instantiation // Fall through - case 147: // parserDeclaration + case 147: // optConstructorParameters // Fall through - case 148: // $@3 + case 149: // parserDeclaration // Fall through - case 149: // $@4 + case 150: // $@4 // Fall through - case 150: // parserLocalElements + case 151: // $@5 // Fall through - case 151: // parserLocalElement + case 152: // parserLocalElements // Fall through - case 152: // parserTypeDeclaration + case 153: // parserLocalElement // Fall through - case 153: // $@5 + case 154: // parserTypeDeclaration // Fall through - case 154: // $@6 + case 155: // $@6 // Fall through - case 155: // parserStates + case 156: // $@7 // Fall through - case 156: // parserState + case 157: // parserStates // Fall through - case 157: // $@7 + case 158: // parserState // Fall through - case 158: // parserStatements + case 159: // $@8 // Fall through - case 159: // parserStatement + case 160: // parserStatements // Fall through - case 160: // parserBlockStatement + case 161: // parserStatement // Fall through - case 161: // $@8 + case 162: // parserBlockStatement // Fall through - case 162: // transitionStatement + case 163: // $@9 // Fall through - case 163: // stateExpression + case 164: // transitionStatement // Fall through - case 164: // selectExpression + case 165: // stateExpression // Fall through - case 165: // selectCaseList + case 166: // selectExpression // Fall through - case 167: // keysetExpression + case 167: // selectCaseList // Fall through - case 168: // tupleKeysetExpression + case 169: // keysetExpression // Fall through - case 169: // simpleExpressionList + case 170: // tupleKeysetExpression // Fall through - case 170: // reducedSimpleKeysetExpression + case 171: // simpleExpressionList // Fall through - case 171: // simpleKeysetExpression + case 172: // reducedSimpleKeysetExpression // Fall through - case 172: // valueSetDeclaration + case 173: // simpleKeysetExpression // Fall through - case 173: // controlDeclaration + case 174: // valueSetDeclaration // Fall through - case 174: // controlTypeDeclaration - // Fall through - case 175: // $@9 + case 175: // controlDeclaration // Fall through case 176: // $@10 // Fall through - case 177: // controlLocalDeclarations - // Fall through - case 178: // controlLocalDeclaration + case 177: // $@11 // Fall through - case 179: // controlBody + case 178: // controlTypeDeclaration // Fall through - case 180: // externDeclaration + case 179: // $@12 // Fall through - case 181: // $@11 + case 180: // $@13 // Fall through - case 182: // $@12 + case 181: // controlLocalDeclarations // Fall through - case 183: // methodPrototypes + case 182: // controlLocalDeclaration // Fall through - case 185: // $@13 + case 183: // controlBody // Fall through - case 186: // methodPrototype + case 184: // externDeclaration // Fall through - case 187: // typeRef + case 185: // $@14 // Fall through - case 188: // namedType + case 186: // $@15 // Fall through - case 189: // prefixedType + case 187: // $@16 // Fall through - case 190: // typeName + case 188: // $@17 // Fall through - case 191: // tupleType + case 189: // externFunctionDeclaration // Fall through - case 192: // headerStackType + case 190: // methodPrototypes // Fall through - case 193: // specializedType + case 192: // $@18 // Fall through - case 196: // optTypeParameters + case 193: // methodPrototype // Fall through - case 197: // typeParameters + case 194: // $@19 // Fall through - case 198: // typeParameterList + case 195: // constructorMethodPrototype // Fall through - case 200: // typeArgumentList + case 196: // typeRef // Fall through - case 202: // realTypeArgumentList + case 197: // namedType // Fall through - case 203: // typeDeclaration + case 198: // prefixedType // Fall through - case 204: // derivedTypeDeclaration + case 199: // typeName // Fall through - case 205: // headerTypeDeclaration + case 200: // tupleType // Fall through - case 206: // $@14 + case 201: // headerStackType // Fall through - case 207: // $@15 + case 202: // specializedType // Fall through - case 208: // structTypeDeclaration + case 205: // optTypeParameters // Fall through - case 209: // headerUnionDeclaration + case 206: // typeParameters // Fall through - case 210: // $@16 + case 207: // $@20 // Fall through - case 211: // $@17 + case 208: // $@21 // Fall through - case 212: // structFieldList + case 209: // typeParameterList // Fall through - case 213: // structField + case 211: // typeArgumentList // Fall through - case 214: // enumDeclaration + case 213: // realTypeArgumentList // Fall through - case 215: // $@18 + case 214: // typeDeclaration // Fall through - case 216: // $@19 + case 215: // derivedTypeDeclaration // Fall through - case 217: // specifiedIdentifierList + case 216: // headerTypeDeclaration // Fall through - case 218: // specifiedIdentifier + case 217: // $@22 // Fall through - case 219: // errorDeclaration + case 218: // $@23 // Fall through - case 220: // matchKindDeclaration + case 219: // structTypeDeclaration // Fall through - case 221: // identifierList + case 220: // $@24 // Fall through - case 222: // typedefDeclaration + case 221: // $@25 // Fall through - case 223: // assignmentOrMethodCallStatement + case 222: // headerUnionDeclaration // Fall through - case 224: // emptyStatement + case 223: // $@26 // Fall through - case 225: // exitStatement + case 224: // $@27 // Fall through - case 226: // returnStatement + case 225: // structFieldList // Fall through - case 227: // conditionalStatement + case 226: // structField // Fall through - case 228: // directApplication + case 227: // enumDeclaration // Fall through - case 229: // statement + case 228: // $@28 // Fall through - case 230: // blockStatement + case 229: // $@29 // Fall through - case 231: // $@20 + case 230: // specifiedIdentifierList // Fall through - case 232: // statOrDeclList + case 231: // specifiedIdentifier // Fall through - case 233: // switchStatement + case 232: // errorDeclaration // Fall through - case 234: // switchCases + case 233: // matchKindDeclaration // Fall through - case 235: // switchCase + case 234: // identifierList // Fall through - case 237: // statementOrDeclaration + case 235: // typedefDeclaration // Fall through - case 238: // tableDeclaration + case 236: // assignmentOrMethodCallStatement // Fall through - case 239: // tablePropertyList + case 238: // emptyStatement // Fall through - case 240: // tableProperty + case 239: // exitStatement // Fall through - case 241: // keyElementList + case 240: // returnStatement // Fall through - case 242: // keyElement + case 241: // conditionalStatement // Fall through - case 243: // actionList + case 242: // directApplication // Fall through - case 244: // actionRef + case 243: // statement // Fall through - case 245: // entry + case 244: // blockStatement // Fall through - case 246: // entriesList + case 245: // $@30 // Fall through - case 247: // actionDeclaration + case 246: // statOrDeclList // Fall through - case 248: // variableDeclaration + case 247: // switchStatement // Fall through - case 249: // constantDeclaration + case 248: // switchCases // Fall through - case 250: // optInitializer + case 249: // switchCase // Fall through - case 251: // initializer + case 251: // statementOrDeclaration // Fall through - case 252: // functionDeclaration + case 252: // tableDeclaration // Fall through - case 253: // argumentList + case 253: // $@31 // Fall through - case 254: // nonEmptyArgList + case 254: // $@32 // Fall through - case 255: // argument + case 255: // tablePropertyList return true; default: diff --git a/src/superc/p4parser/SymbolTable.java b/src/superc/p4parser/SymbolTable.java new file mode 100644 index 00000000..c2aae7e6 --- /dev/null +++ b/src/superc/p4parser/SymbolTable.java @@ -0,0 +1,286 @@ +package superc.p4parser; + +import java.util.HashMap; +import java.util.Map; +import java.util.Stack; + +import superc.p4parser.TemporaryParameterValues; +import superc.p4parser.P4LanguageObject.AbstractObjectOfLanguage; +import superc.p4parser.P4LanguageObject.Generator; +import superc.p4parser.P4LanguageObject.LObjectKind; +import superc.p4parser.P4LanguageObject.LanguageObject; +import superc.p4parser.P4LanguageObject.ReservedKeywords; +import superc.p4parser.P4LanguageObject.TypeParameter; +import xtc.tree.Visitor; + +public class SymbolTable { + Map> symtab; + private static final P4LanguageObject p4LanguageObject = new P4LanguageObject(); + + public SymbolTable() { + this.symtab = new HashMap<>(); + } + + public Map> getSymTab() { + return this.symtab; + } + + /** + * Creates the scope if not present, creates entity for name under scope if not present. + * Adds the entity to the given scope if it doesn't already exist. + * + * Returns the existing or newly created entity. + * @param scope + * @param name + * @return + */ + public AbstractObjectOfLanguage addToSymtab(AbstractObjectOfLanguage scope, String name) { + LanguageObject newLangObj = p4LanguageObject.new LanguageObject(name, scope); + return addToSymtab(scope, name, newLangObj); + } + + public AbstractObjectOfLanguage addToSymtab(AbstractObjectOfLanguage scope, String name, AbstractObjectOfLanguage newLangObj) { + if( !symtab.containsKey(scope)) { + symtab.put(scope, new HashMap<>()); + } + + if(symtab.get(scope).containsKey(name)) { + if(newLangObj.getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + assert symtab.get(scope).get(name).getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER; + } else if((scope.getConstructType() == LObjectKind.EXTERNDECLARATION || scope.getConstructType() == LObjectKind.EXTERNDECLARATIONGENERATOR)) { + // Since constructors are added like variables and not functions) + } else { + // TODO: Tuples are exceptions + if(!Symbols.getOverridableConstructs().contains(newLangObj.getConstructType())) { + // header default values exception + if(scope.getConstructType() == LObjectKind.HEADERSTACKTYPE || + scope.getConstructType() == LObjectKind.HEADERTYPEDECLARATION || + scope.getConstructType() == LObjectKind.HEADERTYPEDECLARATIONGENERATOR || + scope.getConstructType() == LObjectKind.HEADERUNIONDECLARATION || + scope.getConstructType() == LObjectKind.HEADERUNIONDECLARATIONGENERATOR) { + if(Symbols.getDefaultHeaderFunctions().contains(name)) { + System.err.println("Adding a variable of same name as a default header function, so not adding it and ignoring it: " + name); + } + } else if(newLangObj.getConstructType() == LObjectKind.VARIABLE) { + // assert symtab.get(scope).get(name).getConstructType() == LObjectKind.VARIABLE; + System.err.println("Adding a new variable (" + newLangObj.getName() + ") that will overshadow another value (" + symtab.get(scope).get(name).getConstructType() + ")."); // technically not adding it to the symtab, just ignoring it. TODO: check if need to create a new object for data tracing purposes + } else if(newLangObj.getConstructType() != symtab.get(scope).get(name).getConstructType()) { + System.err.println("Redefining a value named: " + name + ". The new value of construct: " + newLangObj.getConstructType() + " will overshadow old value of construct: " + symtab.get(scope).get(name).getConstructType()); + } + else { + assert false : "Error: " + name + " is already defined and of the same construct type " + newLangObj.getConstructType() + ". Redefining it."; + System.err.println("Error: " + name + " is already defined and of the same construct type " + newLangObj.getConstructType() + ". Redefining it."); + System.exit(1); + } + } else { + System.err.println("Unhandled case where two functions with the same number of parameters are defined. Still need to handle overloading methods when number of parameters are same but parameters names are different: " + name); + } + // System.exit(1); + } + } else { + // nodeObj = p4LanguageObject.new LanguageObject(name, scope); + symtab.get(scope).put(name, newLangObj); + } + + return newLangObj; + } + + /** + * Checks if scope exists in the symbol table. + * Returns true if it does, false otherwise. + * @param scope + * @return Boolean + */ + public boolean doesScopeExist(AbstractObjectOfLanguage scope) { + return symtab.containsKey(scope); + } + + /** + * Checks if the given name exists under the given scope. + * Returns true if it does, false otherwise. + * @param scope The scope to check under + * @param name The name to find under the scope + * @return Boolean + */ + public boolean doesSymbolExist(AbstractObjectOfLanguage scope, String name) { + if( !doesScopeExist(scope) || + !symtab.get(scope).containsKey(name)) { + return false; + } + + return true; + } + + /** + * Returns the type associated with a variable, if it has an associated type. + * Else returns the passed in variable itself. + * @param variable + * @return + */ + public AbstractObjectOfLanguage getParameterTypeIfPresent(AbstractObjectOfLanguage variable) { + // System.err.println("Getting parameter type of: " + variable.getName() + " of constructor: " + variable.getConstructType()); + // Note: checking for subclass for example bfd_offload + if(variable.hasAssociatedType()) { + if(variable.getType().getConstructType() == LObjectKind.BASETYPE) { + return variable; + } + return variable.getType(); + } else { + return variable; + } + } + + public AbstractObjectOfLanguage nonTypeNameSymtabLookUp(AbstractObjectOfLanguage localScope, String name, boolean canBeNewIdentifier, Stack temporaryValues, Visitor definitionsVisitor, Stack scope) { + return nonTypeNameSymtabLookUp(localScope, name, canBeNewIdentifier, true, true, temporaryValues, definitionsVisitor, scope); + } + + /** + * A symtab look up function specific for non type names since the referring string + * can either be an already defined value, a reserved keyword, or just a new value. + * Returns the language object if the value is already defined or if a reserved keyword, + * else creates a new string language object if it is a new identifier. + * @param localScope + * @param name + * @param canBeNewIdentifier If set to false, then the value must be in symbol table or a reserved keyword. + * @param getAssociatedType if set to true, will return the associated type of object, if it has + * @return + */ + // TODO: no longer need generateInstance parameter -> safely remove that + public AbstractObjectOfLanguage nonTypeNameSymtabLookUp(AbstractObjectOfLanguage localScope, String name, boolean canBeNewIdentifier, boolean getAssociatedType, boolean generateInstance, Stack temporaryValues, Visitor definitionsVisitor, Stack scope) { + AbstractObjectOfLanguage lookupValue = symtabLookupIfExists(localScope, name, getAssociatedType, generateInstance, temporaryValues, definitionsVisitor, scope); + if(lookupValue == Symbols.getUndeclaredObject()) { + if(canBeNewIdentifier || ReservedKeywords.isNonTypeNameKeyword(name)) { + // System.out.println("New nontypename identifier: " + name); + return p4LanguageObject.new OLangString(name, localScope); + } else { + // System.err.println("Calling to an undefined symbol \"" + typeName + "\"";); + // System.exit(1); + assert false : "Calling to an undefined symbol \"" + name + "\""; + } + } + // System.out.println("found an existing nontypename: " + name); + + return lookupValue; + } + + public AbstractObjectOfLanguage symtabLookup(AbstractObjectOfLanguage localScope, String typeName, Stack temporaryValues, Visitor definitionsVisitor, Stack scope) { + return symtabLookup(localScope, typeName, true, true, temporaryValues, definitionsVisitor, scope); + } + + /** + * Checks if the scope and symbol exists, returns the corresponding object from symtab if it does. + * Recursively goes through the parent scopes if not found under current scope. + * Error is thrown if it does not exist. + * @param localScope + * @param typeName + * @param getAssociatedType if set to true, will return the associated type of object, if it has + * @return + */ + public AbstractObjectOfLanguage symtabLookup(AbstractObjectOfLanguage localScope, String typeName, boolean getAssociatedType, boolean generateInstance, Stack temporaryValues, Visitor definitionsVisitor, Stack scope) { + // System.out.println("looking up: " + typeName + " under: " + localScope.getName() + " of type: " + localScope.getConstructType()); + // if(localScope.getConstructType() == LObjectKind.SPECIALIZEDTYPE) { + // System.out.println("specizlied type: " + localScope.getName() + " type arg list: " + ((SpecializedType)localScope).getTypeArgumentList()); + // } + AbstractObjectOfLanguage lookupValue = symtabLookupIfExists(localScope, typeName, getAssociatedType, generateInstance, temporaryValues, definitionsVisitor, scope); + if(lookupValue == Symbols.getUndeclaredObject()) { + // System.err.println("Calling to an undefined symbol \"" + typeName + "\"";); + // System.exit(1); + assert false : "Calling to an undefined symbol \"" + typeName + "\""; + } + + return lookupValue; + } + + public AbstractObjectOfLanguage retrieveSymbolOrTypeVariable(Stack scope, AbstractObjectOfLanguage localScope, String typeName, Stack temporaryValues, Visitor definitionsVisitor) { + return retrieveSymbolOrTypeVariable(scope, localScope, typeName, false, temporaryValues, definitionsVisitor); + } + + /** + * Similar to symtab lookup, but treats the value as a type variable + * if it is not found in the symbol table + * @param localScope + * @param typeName + * @param getAssociatedType if set to true, will return the associated type of object, if it has + * @return + */ + public AbstractObjectOfLanguage retrieveSymbolOrTypeVariable(Stack scope, AbstractObjectOfLanguage localScope, String typeName, boolean createTypeVar, Stack temporaryValues, Visitor definitionsVisitor) { + AbstractObjectOfLanguage lookupValue = symtabLookupIfExists(localScope, typeName, true, true, temporaryValues, definitionsVisitor, scope); + if (lookupValue == Symbols.getUndeclaredObject()) { + TypeParameter typeParameterObj = p4LanguageObject.new TypeParameter(typeName, localScope); + // System.out.println("Creating new type variable: " + typeParameterObj.getName()); + // NOTE: initially was not adding to symbol table + addToSymtab(scope.peek(), typeName, typeParameterObj); + return typeParameterObj; + } else { + if(createTypeVar && lookupValue.getConstructType() != LObjectKind.TYPEPARAMETER) { + System.err.println("Currently parsing type variable identifier " + typeName + " will be shadowing " + typeName + " of construct tye: " + lookupValue.getConstructType()); + + TypeParameter typeParameterObj = p4LanguageObject.new TypeParameter(typeName, localScope); + // System.out.println("Creating new type variable: " + typeParameterObj.getName()); + // NOTE: initially was not adding to symbol table + addToSymtab(scope.peek(), typeName, typeParameterObj); + return typeParameterObj; + } + return lookupValue; + } + } + + /** + * Checks if scope and symbol exists, returns the corresponding object from symtab if it does. + * Recursively goes through the parent scopes if not found under current scope. + * Treats value as a type variable if symbol is not found and canBeTypeVariable is set to true. + * If canBeTypeVariable is set to false and symbol is not found, an error is thrown. + * If the retrieved value is of generator class and the temporary variables are not empty, + * a new instance of that value will be generated + * @param localScope The scope to check under. Changes as we recursively go through scopes + * @param typeName + * @param primaryScope The initial scope that the symbol was supposed to be checked under. Keep track of initial one for type variable declarations. + * @param canBeTypeVariable A boolean variable indicating whether the symbol can possibly be a new type variable + * @return + */ + public AbstractObjectOfLanguage symtabLookupIfExists(AbstractObjectOfLanguage localScope, String typeName, boolean getAssociatedType, boolean generateInstance, Stack temporaryValues, Visitor definitionsVisitor, Stack scope) { + assert !typeName.isBlank() : "typeName is not supposed to be empty when looking it up on symbol table"; + + boolean doesExistInCurrentScope = doesSymbolExist(localScope, typeName); + + // if the symbol does not exist in the current scope, check under its parent scope + if( !doesExistInCurrentScope) { + if(localScope.equals(Symbols.getGlobalScope())) { + return Symbols.getUndeclaredObject(); + } + + return symtabLookupIfExists(localScope.getNameSpace(), typeName, getAssociatedType, generateInstance, temporaryValues, definitionsVisitor, scope); + } else { + AbstractObjectOfLanguage symtabValue = symtab.get(localScope).get(typeName); + if(symtabValue.getConstructType() == LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER) { + assert !temporaryValues.isEmpty() : temporaryValues.size(); + typeName += "_" + temporaryValues.peek().getParameters().size(); + assert doesSymbolExist(localScope, typeName) : typeName; + symtabValue = symtab.get(localScope).get(typeName); + assert symtabValue.getConstructType() != LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER; + } + // if(generateInstance && symtabValue.isGeneratorClass()) { + // Changed symtab lookup to invoke the generate instance function on a generated class + // if and only if either parameters or type parameters were parsed/read in. This makes it simpler to identify when a symtab look up is just to retrieve types + // (like in type checking stage where we get type of variable and that type is of generator class) vs. creating an instance of that generator class for calls. + if(symtabValue.isGeneratorClass() && !temporaryValues.isEmpty() && + (!temporaryValues.peek().getParameters().isEmpty() | !temporaryValues.peek().getTypeParameters().isEmpty())) { + // System.err.println("Generating instance of: " + symtabValue.getName() + "\n"); + // System.out.println("parameters size: " + temporaryValues.peek().getParameters().size() + "; type parameters size: " + temporaryValues.peek().getTypeParameters().size()); + assert (!temporaryValues.isEmpty()); + assert (!temporaryValues.peek().getParameters().isEmpty() | !temporaryValues.peek().getTypeParameters().isEmpty()); + symtabValue = ((Generator) symtabValue).generateInstance(temporaryValues.peek().getTypeParameters(), temporaryValues.peek().getParameters(), symtab.get(symtabValue), symtab, definitionsVisitor, scope); + } + if(getAssociatedType) { + AbstractObjectOfLanguage value = getParameterTypeIfPresent(symtabValue); + return value; + } else { + return symtabValue; + } + } + } + + public void print() { + System.out.println(symtab); + } +} diff --git a/src/superc/p4parser/Symbols.java b/src/superc/p4parser/Symbols.java new file mode 100644 index 00000000..652d9d42 --- /dev/null +++ b/src/superc/p4parser/Symbols.java @@ -0,0 +1,73 @@ +package superc.p4parser; + +import java.util.ArrayList; +import java.util.HashSet; + +import superc.p4parser.P4LanguageObject.AbstractObjectOfLanguage; +import superc.p4parser.P4LanguageObject.LObjectKind; + +public class Symbols { + // Constant values + public static P4LanguageObject p4LanguageObject = new P4LanguageObject(); + public static final AbstractObjectOfLanguage global_scope = p4LanguageObject.new ConstantTreeGlobalObjects("GLOBAL"); + public static final AbstractObjectOfLanguage undefined_scope = p4LanguageObject.new ConstantTreeGlobalObjects("UNDEFINED"); + public static final AbstractObjectOfLanguage undeclared_object = p4LanguageObject.new ConstantTreeGlobalObjects("UNDECLARED OBJECT"); + public static final AbstractObjectOfLanguage default_language_object = p4LanguageObject.new ConstantTreeGlobalObjects("DEFAULT"); + + public static HashSet overridableConstructs = new HashSet<>(); + public static ArrayList defaultHeaderFunction = new ArrayList<>(); + + static { + + overridableConstructs.add(LObjectKind.FUNCTION); + overridableConstructs.add(LObjectKind.FUNCTIONDECLARATION); + overridableConstructs.add(LObjectKind.FUNCTIONPROTOTYPE); + overridableConstructs.add(LObjectKind.FUNCTIONPROTOTYPEGENERATOR); + overridableConstructs.add(LObjectKind.METHOD); + overridableConstructs.add(LObjectKind.EXTERNFUNCTIONDECLARATION); + overridableConstructs.add(LObjectKind.EXTERNFUNCTIONDECLARATIONGENERATOR); + overridableConstructs.add(LObjectKind.FUNCTIONPROTOTYPEPLACEHOLDER); + + // issue1334.p4 in the p4c test suite -> turns out control and package blocks are also overridable + overridableConstructs.add(LObjectKind.CONTROLDECLARATION); + overridableConstructs.add(LObjectKind.CONTROLTYPEDECLARATION); + overridableConstructs.add(LObjectKind.CONTROLTYPEDECLARATIONGENERATOR); + overridableConstructs.add(LObjectKind.PACKAGETYPEDECLARATION); + overridableConstructs.add(LObjectKind.PACKAGETYPEDECLARATIONGENERATOR); + overridableConstructs.add(LObjectKind.PARSERDECLARATION); + overridableConstructs.add(LObjectKind.PARSERDECLARATIONGENERATOR); + overridableConstructs.add(LObjectKind.PARSERTYPEDECLARATION); + overridableConstructs.add(LObjectKind.PARSERTYPEDECLARATIONGENERATOR); + + // default functions associated with headers + defaultHeaderFunction.add("isValid"); + defaultHeaderFunction.add("setValid"); + defaultHeaderFunction.add("setInvalid"); + defaultHeaderFunction.add("minSizeInBits"); + defaultHeaderFunction.add("minSizeInBytes"); + } + + public static HashSet getOverridableConstructs() { + return overridableConstructs; + } + + public static ArrayList getDefaultHeaderFunctions() { + return defaultHeaderFunction; + } + + public static AbstractObjectOfLanguage getGlobalScope() { + return global_scope; + } + + public static AbstractObjectOfLanguage getUndefinedScope() { + return undefined_scope; + } + + public static AbstractObjectOfLanguage getUndeclaredObject() { + return undeclared_object; + } + + public static AbstractObjectOfLanguage getDefaultLanguageObject() { + return default_language_object; + } +} \ No newline at end of file diff --git a/src/superc/p4parser/TemporaryParameterValues.java b/src/superc/p4parser/TemporaryParameterValues.java new file mode 100644 index 00000000..56431c4c --- /dev/null +++ b/src/superc/p4parser/TemporaryParameterValues.java @@ -0,0 +1,30 @@ +package superc.p4parser; +import java.util.ArrayList; +import superc.p4parser.P4LanguageObject.AbstractObjectOfLanguage; + +// Temporary value classes +public class TemporaryParameterValues { + ArrayList parameters; + ArrayList typeParameters; + + public ArrayList getParameters() { + return this.parameters; + } + + public ArrayList getTypeParameters() { + return this.typeParameters; + } + + public void addToParameters(AbstractObjectOfLanguage parameter) { + this.parameters.add(parameter); + } + + public void addToTypeParameters(AbstractObjectOfLanguage parameter) { + this.typeParameters.add(parameter); + } + + public TemporaryParameterValues() { + this.parameters = new ArrayList<>(); + this.typeParameters = new ArrayList<>(); + } +} \ No newline at end of file diff --git a/src/superc/p4parser/config.properties b/src/superc/p4parser/config.properties new file mode 100644 index 00000000..ecca02d7 --- /dev/null +++ b/src/superc/p4parser/config.properties @@ -0,0 +1,23 @@ +############################################################## +# Linux Configurations # +############################################################## +# The dir. where temporary files will be created. +tempDirForLinux = /tmp +# Where is your dot program located? It will be called externally. +dotForLinux = /usr/bin/dot + +############################################################## +# Windows Configurations # +############################################################## +# The dir. where temporary files will be created. +tempDirForWindows = c:/temp +# Where is your dot program located? It will be called externally. +dotForWindows = "c:/Program Files (x86)/Graphviz 2.28/bin/dot.exe" + +############################################################## +# Mac Configurations # +############################################################## +# The dir. where temporary files will be created. +tempDirForMacOSX = /tmp +# Where is your dot program located? It will be called externally. +dotForMacOSX = /usr/local/bin/dot \ No newline at end of file diff --git a/src/superc/p4parser/p4lexer.l b/src/superc/p4parser/p4lexer.l index 6078ec24..2effbee8 100644 --- a/src/superc/p4parser/p4lexer.l +++ b/src/superc/p4parser/p4lexer.l @@ -59,7 +59,7 @@ */ # define LANGUAGE_FULL(token, jflex_text, tag_text) LANGUAGE(token, jflex_text) -#else +#else /* ifdef LANGUAGE_TAGS */ # define LANGUAGE(token, text) token(getID(#token), text), # define TEXT(token, regex, hasName) token(getID(#token), null, hasName), # define PREPROCESSOR(token, pptag, text) \ @@ -67,7 +67,7 @@ # define PREPROCESSOR_TEXT(token, pptag, regex, hasName) \ token(getID(#token), null, hasName, PreprocessorTag.pptag), # define LANGUAGE_FULL(token, jflex_text, tag_text) LANGUAGE(token, tag_text) -#endif +#endif /* end of ifndef LANGUAGE_TAGS */ #ifndef LANGUAGE_TAGS // Generate the lexer specification. @@ -122,8 +122,8 @@ import superc.core.Syntax.EOF; %line %column -%state COMMENT PRAGMA_LINE -%xstate PP_FRACTION_NON_EMPTY PP_FRACTION_CAN_BE_EMPTY RANGE_DOTS RANGE_END +%state COMMENT PRAGMA_LINE PREPROC +%xstate PP_FRACTION_NON_EMPTY PP_FRACTION_CAN_BE_EMPTY RANGE_DOTS RANGE_END /* Uncomment this for a lexer debugging. See the JFlex manual. */ // %debug @@ -146,10 +146,15 @@ preprocessor numbers. */ exponent_part=([eE]|[pP])[-+]?[0-9]+ preprocessing_number="."?[0-9]+([0-9a-zA-Z._]|{exponent_part})* -whitespace=[ \t\r]+ -newline=\n +h_tab=[\011] +v_tab=[\013] +c_return=[\015] +horizontal_white=[ ]|{h_tab} +newline=\r|\n|\r\n +// comment=[/][*]([^*/]|[^*][/]|[*][^/])*[*][/] linecomment="//"[^\r\n]*{newline} - +continuation="\\\n" +whitespace=({horizontal_white})+|({v_tab}|{c_return})+|{continuation} %% @@ -179,7 +184,7 @@ linecomment="//"[^\r\n]*{newline} return new Layout(yytext(), true); } -#else // Generate the P4Tag enumeration. +#else // Generate the P4Tag enumeration. ifdef LANGUAGE_TAGS package PACKAGE_NAME; import superc.core.Syntax.Layout; @@ -187,7 +192,7 @@ import superc.core.Syntax.PreprocessorTag; import superc.core.Syntax.Language; public enum P4Tag implements superc.core.Syntax.LanguageTag { -#endif +#endif // END of ifndef LANGUAGE_TAGS LANGUAGE(ABSTRACT,"abstract") LANGUAGE(ACTION,"action") @@ -409,12 +414,12 @@ return new Layout(comment.toString(), false); } -#else +#else /* ifdef LANGUAGE_TAGS */ TYPE_IDENTIFIER(getID("TYPE_IDENTIFIER"), null, true), END_PRAGMA(getID("END_PRAGMA"), null), PRAGMA(getID("PRAGMA"), "@pragma"), FLOATING_CONSTANT(getID("FLOATING_CONSTANT"), null, false, PreprocessorTag.NUMBER), -PPNUM(getID("PPNUM"), null, false, PreprocessorTag.NUMBER) +PPNUM(getID("PPNUM"), null, false, PreprocessorTag.NUMBER), ; private final int id; @@ -477,5 +482,5 @@ PPNUM(getID("PPNUM"), null, false, PreprocessorTag.NUMBER) } } -#endif +#endif /* end LANGUAGE_TAGS */ diff --git a/src/superc/p4parser/p4parser.action_switches b/src/superc/p4parser/p4parser.action_switches index 6e94b0ca..b9443f97 100644 --- a/src/superc/p4parser/p4parser.action_switches +++ b/src/superc/p4parser/p4parser.action_switches @@ -142,20 +142,8 @@ {} break; - case 40: - {} - break; - - case 41: - {} - break; - - case 42: - {} - break; - case 43: - {} + {} break; case 44: @@ -163,7 +151,7 @@ break; case 45: - {} + {} break; case 46: @@ -343,11 +331,11 @@ break; case 90: - {} + {} break; case 91: - {} + {} break; case 92: @@ -410,7 +398,7 @@ {} break; - case 108: + case 107: {} break; @@ -503,19 +491,19 @@ break; case 131: - {} + {} break; case 132: - {} + {} break; case 133: - {} + {} break; case 134: - {} + {} break; case 135: @@ -523,31 +511,31 @@ break; case 136: - {} + { ReenterScope(subparser); } break; case 137: - {} + { ExitReentrantScope(subparser); } break; case 138: - {} + {} break; case 139: - {} + {} break; case 140: - {} + {} break; case 141: - {} + {} break; case 142: - {} + {} break; case 143: @@ -555,26 +543,26 @@ break; case 144: - {} + {} break; case 145: - {} + {} break; case 146: - { - saveBaseType(subparser, getNodeAt(subparser, 8)); - bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); - } + {} break; case 147: - {} + {} break; case 148: - {} + { + saveBaseType(subparser, getNodeAt(subparser, 8)); + bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); + } break; case 149: @@ -585,68 +573,60 @@ {} break; - case 151: - {} - break; - - case 152: - {} - break; - case 153: - {} + {} break; case 154: - {} + {} break; case 155: - {} + {} break; case 156: - {} + {} break; case 157: - {} + {} break; case 158: - {} + {} break; case 159: - { EnterScope(subparser); } + {} break; case 160: - { ExitScope(subparser); } + {} break; case 161: - {} + { ReenterScope(subparser); } break; case 162: - {} + { ExitScope(subparser); } break; case 163: - {} + {} break; case 164: - {} + {} break; case 165: - {} + {} break; case 166: - {} + {} break; case 167: @@ -654,30 +634,30 @@ break; case 168: - {} + {} break; case 169: - {} + {} break; case 170: - { - saveBaseType(subparser, getNodeAt(subparser, 8)); - bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); - } + {} break; case 171: - {} + {} break; case 172: - {} + { + saveBaseType(subparser, getNodeAt(subparser, 8)); + bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); + } break; case 173: - {} + {} break; case 174: @@ -685,23 +665,23 @@ break; case 175: - {} + {} break; case 176: - {} + {} break; case 177: - {} + {} break; case 178: - {} + {} break; case 179: - {} + {} break; case 180: @@ -721,111 +701,111 @@ break; case 184: - {} + {} break; case 185: - {} + {} break; case 186: - {} + {} break; case 187: - {} + {} break; case 188: - {} + {} break; case 189: - {} + {} break; case 190: - {} + {} break; case 191: - {} + {} break; case 192: - {} + {} break; case 193: - {} + {} break; case 194: - {} + {} break; case 195: - {} + {} break; case 196: - {} + {} break; case 197: - {} + {} break; case 198: - {} + {} break; case 199: - {} + {} break; case 200: - {} + {} break; case 201: - {} + {} break; case 202: - {} + {} break; case 203: - {} + {} break; case 204: - {} + {} break; case 205: - {} + {} break; case 206: - {} + {} break; case 207: - {} + {} break; case 208: - {} + {} break; case 209: - {} + {} break; case 210: - {} + {} break; case 211: @@ -837,216 +817,252 @@ break; case 213: - {} + {} break; case 214: - {} + { ReenterScope(subparser); } break; case 215: + { ExitScope(subparser); } + break; + + case 216: + {} + break; + + case 217: + {} + break; + + case 218: + {} + break; + + case 219: { saveBaseType(subparser, getNodeAt(subparser, 8)); bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } break; - case 216: + case 220: {} break; - case 217: + case 221: {} break; - case 218: + case 222: {} break; - case 219: + case 223: {} break; - case 220: + case 224: {} break; - case 221: + case 225: {} break; - case 222: + case 226: {} break; - case 223: + case 227: {} break; - case 224: + case 228: { saveBaseType(subparser, getNodeAt(subparser, 2)); bindIdent(subparser, getNodeAt(subparser, 2), getNodeAt(subparser, 1)); } break; - case 225: + case 229: {} break; - case 229: + case 230: + { ReenterScope(subparser); } + break; + + case 231: + { ExitScope(subparser); } + break; + + case 236: {} break; - case 230: + case 237: {} break; - case 231: + case 238: {} break; - case 232: + case 239: {} break; - case 233: + case 240: {} break; - case 234: + case 241: {} break; - case 235: + case 242: + {} + break; + + case 243: {} break; - case 236: + case 245: {} break; - case 237: + case 246: {} break; - case 238: + case 247: {} break; - case 239: + case 248: {} break; - case 240: + case 249: {} break; - case 241: + case 250: {} break; - case 242: + case 251: {} break; - case 243: + case 252: {} break; - case 244: + case 253: {} break; - case 245: + case 254: {} break; - case 246: + case 255: {} break; - case 247: + case 256: {} break; - case 248: + case 257: {} break; - case 249: + case 258: {} break; - case 250: + case 259: {} break; - case 251: + case 260: {} break; - case 252: + case 261: {} break; - case 253: + case 262: {} break; - case 254: + case 263: {} break; - case 255: + case 264: {} break; - case 256: + case 265: {} break; - case 257: + case 266: {} break; - case 258: + case 267: {} break; - case 259: + case 268: {} break; - case 260: + case 269: {} break; - case 261: + case 270: {} break; - case 262: + case 271: {} break; - case 263: + case 272: {} break; - case 264: + case 273: {} break; - case 265: + case 274: {} break; - case 266: - {} + case 275: + { EnterScope(subparser); } break; - case 267: + case 276: + { ExitReentrantScope(subparser); } + break; + + case 277: + {} + break; + + case 278: { // ASK possible to get the production name? (typeParameterList) // // saveBaseType(subparser, getNodeAt(subparser, 12)); @@ -1056,890 +1072,931 @@ } break; - case 268: + case 279: { bindIdent(subparser, null, getNodeAt(subparser, 1), true); } break; - case 269: + case 280: {} break; - case 270: + case 281: {} break; - case 271: + case 282: {} break; - case 272: + case 283: {} break; - case 273: + case 284: {} break; - case 274: + case 285: {} break; - case 275: + case 286: {} break; - case 276: + case 287: {} break; - case 277: + case 288: {} break; - case 278: + case 289: {} break; - case 279: + case 290: {} break; - case 280: + case 291: {} break; - case 281: + case 292: {} break; - case 282: + case 293: {} break; - case 283: + case 294: {} break; - case 284: + case 295: {} break; - case 285: + case 296: {} break; - case 286: + case 297: {} break; - case 287: + case 298: {} break; - case 288: + case 299: {} break; - case 289: + case 300: {} break; - case 290: - {} + case 301: + { ReenterScope(subparser); } break; - case 291: - {} + case 302: + { ExitScope(subparser); } break; - case 292: + case 303: { saveBaseType(subparser, getNodeAt(subparser, 8)); bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } break; - case 293: + case 304: + { ReenterScope(subparser); } + break; + + case 305: + { ExitScope(subparser); } + break; + + case 306: { - saveBaseType(subparser, getNodeAt(subparser, 6)); - bindIdent(subparser, getNodeAt(subparser, 6), getNodeAt(subparser, 5)); + saveBaseType(subparser, getNodeAt(subparser, 8)); + bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } break; - case 294: - {} + case 307: + { ReenterScope(subparser); } break; - case 295: - {} + case 308: + { ExitScope(subparser); } break; - case 296: - { + case 309: + { saveBaseType(subparser, getNodeAt(subparser, 8)); bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } break; - case 297: + case 310: {} break; - case 298: + case 311: {} break; - case 299: + case 312: {} break; - case 300: + case 313: {} break; - case 301: + case 314: { saveBaseType(subparser, getNodeAt(subparser, 6)); bindIdent(subparser, getNodeAt(subparser, 6), getNodeAt(subparser, 5)); } break; - case 302: + case 315: {} break; - case 303: + case 316: { saveBaseType(subparser, getNodeAt(subparser, 7)); bindIdent(subparser, getNodeAt(subparser, 7), getNodeAt(subparser, 5)); } break; - case 304: + case 317: {} break; - case 305: + case 318: {} break; - case 306: + case 319: {} break; - case 307: + case 320: {} break; - case 308: + case 321: {} break; - case 309: + case 322: {} break; - case 310: + case 323: {} break; - case 311: + case 324: { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } break; - case 312: + case 325: { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } break; - case 313: + case 326: { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } break; - case 314: + case 327: { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } break; - case 315: + case 328: {} break; - case 316: + case 329: {} break; - case 317: + case 330: {} break; - case 318: + case 331: + {} + break; + + case 332: {} break; - case 319: + case 333: {} break; - case 320: + case 334: {} break; - case 321: + case 335: {} break; - case 322: + case 336: {} break; - case 323: + case 337: {} break; - case 324: + case 338: {} break; - case 325: + case 339: {} break; - case 326: + case 340: {} break; - case 327: + case 341: {} break; - case 328: + case 342: {} break; - case 329: + case 343: {} break; - case 330: + case 344: {} break; - case 331: + case 345: {} break; - case 332: + case 346: {} break; - case 333: + case 347: {} break; - case 334: + case 348: {} break; - case 335: + case 349: {} break; - case 336: + case 350: {} break; - case 337: + case 351: {} break; - case 338: + case 352: {} break; - case 339: + case 353: {} break; - case 340: + case 354: {} break; - case 341: + case 355: {} break; - case 342: + case 356: {} break; - case 343: + case 357: {} break; - case 344: + case 358: {} break; - case 345: + case 359: {} break; - case 346: + case 360: {} break; - case 347: + case 361: {} break; - case 348: + case 362: + { EnterScope(subparser); } + break; + + case 363: + { ExitScope(subparser); } + break; + + case 364: {} break; - case 349: + case 365: {} break; - case 350: + case 366: {} break; - case 351: + case 367: {} break; - case 352: + case 368: {} break; - case 353: + case 369: {} break; - case 354: + case 370: {} break; - case 355: + case 371: {} break; - case 356: + case 372: {} break; - case 357: + case 373: {} break; - case 358: + case 374: {} break; - case 359: + case 375: {} break; - case 360: + case 377: {} break; - case 361: + case 378: {} break; - case 362: + case 379: {} break; - case 363: + case 380: {} break; - case 364: + case 381: {} break; - case 365: - { - saveBaseType(subparser, getNodeAt(subparser, 6)); - bindIdent(subparser, getNodeAt(subparser, 6), getNodeAt(subparser, 5)); + case 382: + { EnterScope(subparser); } + break; + + case 383: + { + saveBaseType(subparser, getNodeAt(subparser, 7)); + bindIdent(subparser, getNodeAt(subparser, 7), getNodeAt(subparser, 6)); + ExitScope(subparser); } break; - case 366: + case 384: { saveBaseType(subparser, getNodeAt(subparser, 4)); bindIdent(subparser, getNodeAt(subparser, 4), getNodeAt(subparser, 3)); } break; - case 367: + case 385: { saveBaseType(subparser, getNodeAt(subparser, 4)); bindIdent(subparser, getNodeAt(subparser, 4), getNodeAt(subparser, 3)); } break; - case 368: + case 386: {} break; - case 369: + case 387: {} break; - case 370: + case 388: {} break; - case 371: + case 389: {} break; - case 372: - {} + case 390: + { ReenterScope(subparser); } break; - case 373: + case 391: + { ExitScope(subparser); } + break; + + case 392: {} break; - case 374: + case 393: {} break; - case 375: + case 394: {} break; - case 376: + case 395: {} break; - case 377: + case 396: {} break; - case 378: + case 397: {} break; - case 379: + case 398: {} break; - case 380: + case 399: {} break; - case 381: + case 400: {} break; - case 382: + case 401: {} break; - case 383: + case 402: {} break; - case 384: + case 403: {} break; - case 385: + case 404: {} break; - case 386: + case 405: {} break; - case 387: + case 406: {} break; - case 388: + case 407: {} break; - case 389: + case 408: {} break; - case 390: - {} + case 409: + {} break; - case 391: - {} + case 410: + {} break; - case 392: + case 411: + {} + break; + + case 412: {} break; - case 393: + case 413: {} break; - case 394: + case 414: {} break; - case 395: + case 415: {} break; - case 396: + case 416: {} break; - case 397: + case 417: {} break; - case 398: + case 418: {} break; - case 399: + case 419: {} break; - case 400: + case 420: {} break; - case 401: + case 421: {} break; - case 402: + case 422: {} break; - case 403: + case 423: {} break; - case 404: + case 424: {} break; - case 405: + case 425: {} break; - case 406: + case 426: {} break; - case 407: + case 427: {} break; - case 408: + case 428: {} break; - case 409: + case 429: {} break; - case 410: + case 430: {} break; - case 411: + case 431: {} break; - case 412: + case 432: {} break; - case 413: + case 433: {} break; - case 414: + case 434: {} break; - case 415: + case 435: {} break; - case 416: + case 436: {} break; - case 417: + case 437: {} break; - case 418: + case 438: {} break; - case 419: + case 439: {} break; - case 420: + case 440: {} break; - case 421: + case 441: {} break; - case 422: + case 442: {} break; - case 423: + case 443: {} break; - case 424: + case 444: {} break; - case 425: + case 445: {} break; - case 426: + case 446: {} break; - case 427: + case 447: {} break; - case 428: + case 448: {} break; - case 429: + case 449: {} break; - case 430: + case 450: {} break; - case 431: + case 451: {} break; - case 432: + case 452: {} break; - case 433: - {} + case 453: + {} break; - case 434: + case 454: + {} + break; + + case 456: {} break; - case 435: + case 457: {} break; - case 436: - {} + case 458: + {} break; - case 437: + case 459: {} break; - case 438: + case 460: {} break; - case 439: + case 461: {} break; - case 440: + case 462: {} break; - case 441: + case 463: {} break; - case 442: + case 464: {} break; - case 443: + case 465: {} break; - case 444: + case 466: {} break; - case 445: + case 467: {} break; - case 446: + case 468: {} break; - case 447: + case 469: {} break; - case 448: + case 470: {} break; - case 449: + case 471: {} break; - case 450: + case 472: {} break; - case 451: + case 473: {} break; - case 452: + case 474: {} break; - case 453: + case 475: {} break; - case 454: + case 476: {} break; - case 455: + case 477: {} break; - case 456: + case 478: {} break; - case 457: + case 479: {} break; - case 458: + case 480: {} break; - case 459: + case 481: {} break; - case 460: + case 482: {} break; - case 461: + case 483: {} break; - case 462: + case 484: {} break; - case 463: + case 485: {} break; - case 464: + case 486: {} break; - case 465: + case 487: {} break; - case 466: + case 488: {} break; - case 467: + case 489: {} break; - case 468: + case 490: {} break; - case 469: + case 491: {} break; - case 470: + case 492: {} break; - case 471: + case 493: {} break; - case 472: + case 494: {} break; - case 473: + case 495: {} break; - case 474: + case 496: {} break; - case 475: + case 497: {} break; - case 476: - {} + case 498: + {} break; - case 477: + case 499: + {} + break; + + case 501: {} break; - case 478: + case 502: {} break; - case 479: - {} + case 503: + {} break; diff --git a/src/superc/p4parser/p4parser.bison_content b/src/superc/p4parser/p4parser.bison_content index 6ff9e07c..957302cf 100644 --- a/src/superc/p4parser/p4parser.bison_content +++ b/src/superc/p4parser/p4parser.bison_content @@ -547,16 +547,16 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 4 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 3954 +#define YYLAST 4072 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 118 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 147 +#define YYNNTS 169 /* YYNRULES -- Number of rules. */ -#define YYNRULES 483 +#define YYNRULES 507 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 888 +#define YYNSTATES 909 #define YYUNDEFTOK 2 #define YYMAXUTOK 372 @@ -619,51 +619,53 @@ static const yytype_int16 yyrline[] = 257, 258, 259, 260, 261, 262, 263, 267, 268, 269, 270, 271, 272, 273, 277, 278, 282, 283, 284, 285, 286, 290, 291, 295, 296, 300, 301, 305, 307, 309, - 311, 315, 320, 321, 323, 328, 329, 330, 331, 332, - 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 375, 376, 377, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 418, 419, 423, 427, 428, 432, 433, 437, 438, - 442, 443, 444, 445, 449, 450, 449, 458, 460, 463, - 466, 472, 477, 478, 482, 483, 487, 488, 492, 498, - 499, 498, 505, 506, 510, 511, 512, 513, 518, 519, - 517, 527, 528, 532, 532, 538, 539, 543, 544, 545, - 546, 547, 548, 549, 553, 553, 558, 559, 563, 564, - 568, 573, 574, 578, 583, 584, 588, 590, 594, 595, - 600, 601, 602, 603, 607, 608, 609, 610, 611, 615, - 618, 621, 629, 636, 637, 635, 645, 646, 650, 651, - 652, 653, 654, 658, 665, 669, 664, 671, 672, 676, - 677, 682, 681, 687, 688, 689, 696, 697, 698, 699, - 700, 704, 705, 709, 710, 714, 718, 722, 723, 727, - 731, 732, 733, 734, 735, 736, 738, 740, 743, 745, - 747, 752, 753, 754, 759, 760, 764, 768, 775, 781, - 782, 784, 785, 789, 790, 791, 795, 796, 797, 803, - 804, 808, 809, 810, 811, 812, 816, 817, 818, 819, - 823, 823, 823, 832, 841, 841, 841, 849, 850, 854, - 859, 858, 864, 864, 872, 873, 877, 881, 886, 892, - 893, 897, 901, 905, 909, 919, 922, 925, 931, 935, - 939, 940, 944, 946, 952, 956, 957, 958, 959, 960, - 961, 962, 963, 967, 967, 972, 973, 977, 981, 982, - 986, 987, 991, 992, 996, 997, 998, 999, 1005, 1011, - 1012, 1016, 1018, 1020, 1022, 1027, 1028, 1032, 1037, 1038, - 1043, 1045, 1050, 1055, 1056, 1062, 1071, 1075, 1082, 1087, - 1088, 1092, 1098, 1102, 1103, 1107, 1108, 1112, 1113, 1114, - 1118, 1119, 1120, 1124, 1125, 1129, 1129, 1133, 1134, 1135, - 1136, 1137, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, - 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1159, - 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, - 1172, 1173, 1174, 1176, 1178, 1179, 1180, 1181, 1182, 1183, - 1184, 1185, 1186, 1187, 1189, 1191, 1193, 1197, 1198, 1199, - 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, - 1210, 1211, 1213, 1215, 1216, 1217, 1218, 1219, 1220, 1221, - 1222, 1223, 1224, 1226, 1227, 1228, 1230, 1231, 1232, 1233, - 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1242, 1244, 1246, - 1269, 1269, 1270, 1270 + 313, 317, 318, 322, 323, 325, 330, 331, 332, 333, + 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 420, 421, 425, 429, 430, 430, 434, 435, + 439, 440, 444, 445, 446, 447, 451, 452, 451, 460, + 462, 464, 466, 471, 476, 477, 481, 482, 486, 487, + 491, 498, 498, 497, 504, 505, 509, 510, 511, 512, + 517, 518, 516, 526, 527, 531, 531, 537, 538, 542, + 543, 544, 545, 546, 547, 548, 552, 552, 557, 558, + 562, 563, 567, 572, 573, 577, 582, 583, 587, 589, + 593, 594, 599, 600, 601, 602, 606, 607, 608, 609, + 610, 614, 617, 620, 629, 631, 628, 637, 638, 636, + 646, 647, 651, 652, 653, 654, 655, 659, 666, 670, + 671, 671, 665, 672, 673, 677, 681, 682, 687, 686, + 692, 693, 694, 694, 699, 705, 706, 707, 708, 709, + 713, 714, 718, 719, 723, 727, 731, 732, 736, 740, + 741, 742, 743, 744, 745, 747, 749, 752, 754, 756, + 761, 762, 763, 768, 769, 773, 773, 773, 777, 784, + 790, 791, 793, 794, 798, 799, 800, 804, 805, 806, + 812, 813, 817, 818, 819, 820, 821, 825, 826, 827, + 828, 833, 834, 832, 844, 846, 843, 855, 857, 854, + 864, 865, 869, 874, 873, 879, 879, 887, 888, 892, + 896, 901, 907, 908, 912, 916, 920, 924, 934, 936, + 941, 943, 948, 952, 956, 957, 961, 963, 969, 973, + 974, 975, 976, 977, 978, 979, 980, 984, 984, 989, + 990, 994, 998, 999, 1003, 1004, 1008, 1009, 1013, 1014, + 1015, 1016, 1023, 1023, 1022, 1028, 1029, 1033, 1035, 1037, + 1039, 1044, 1045, 1049, 1054, 1055, 1060, 1064, 1066, 1071, + 1076, 1077, 1083, 1083, 1093, 1097, 1104, 1109, 1110, 1114, + 1120, 1120, 1124, 1125, 1129, 1130, 1134, 1135, 1136, 1140, + 1141, 1142, 1146, 1147, 1151, 1151, 1155, 1156, 1157, 1158, + 1162, 1163, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, + 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1184, + 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, + 1197, 1198, 1199, 1201, 1203, 1204, 1205, 1206, 1207, 1208, + 1209, 1210, 1211, 1212, 1213, 1215, 1216, 1218, 1220, 1225, + 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, + 1236, 1237, 1238, 1239, 1241, 1243, 1244, 1245, 1246, 1247, + 1248, 1249, 1250, 1251, 1252, 1254, 1255, 1256, 1258, 1259, + 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, + 1271, 1272, 1274, 1276, 1300, 1300, 1301, 1301 }; #endif @@ -696,42 +698,48 @@ static const char *const yytname[] = "FLOATING_CONSTANT", "PPNUM", "PREFIX", "THEN", "$accept", "start", "program", "input", "declaration", "nonTypeName", "name", "nonTableKwName", "optCONST", "optAnnotations", "annotations", - "annotation", "annotationBody", "annotationToken", "kvList", "kvPair", - "parameterList", "nonEmptyParameterList", "parameter", "direction", - "packageTypeDeclaration", "$@1", "$@2", "instantiation", + "annotation", "structuredAnnotationBody", "annotationBody", + "annotationToken", "kvList", "kvPair", "parameterList", "$@1", + "nonEmptyParameterList", "parameter", "direction", + "packageTypeDeclaration", "$@2", "$@3", "instantiation", "objInitializer", "objDeclarations", "objDeclaration", - "optConstructorParameters", "dotPrefix", "parserDeclaration", "$@3", - "$@4", "parserLocalElements", "parserLocalElement", - "parserTypeDeclaration", "$@5", "$@6", "parserStates", "parserState", - "$@7", "parserStatements", "parserStatement", "parserBlockStatement", - "$@8", "transitionStatement", "stateExpression", "selectExpression", + "optConstructorParameters", "dotPrefix", "parserDeclaration", "$@4", + "$@5", "parserLocalElements", "parserLocalElement", + "parserTypeDeclaration", "$@6", "$@7", "parserStates", "parserState", + "$@8", "parserStatements", "parserStatement", "parserBlockStatement", + "$@9", "transitionStatement", "stateExpression", "selectExpression", "selectCaseList", "selectCase", "keysetExpression", "tupleKeysetExpression", "simpleExpressionList", "reducedSimpleKeysetExpression", "simpleKeysetExpression", - "valueSetDeclaration", "controlDeclaration", "controlTypeDeclaration", - "$@9", "$@10", "controlLocalDeclarations", "controlLocalDeclaration", - "controlBody", "externDeclaration", "$@11", "$@12", "methodPrototypes", - "functionPrototype", "$@13", "methodPrototype", "typeRef", "namedType", - "prefixedType", "typeName", "tupleType", "headerStackType", - "specializedType", "baseType", "typeOrVoid", "optTypeParameters", - "typeParameters", "typeParameterList", "typeArg", "typeArgumentList", + "valueSetDeclaration", "controlDeclaration", "$@10", "$@11", + "controlTypeDeclaration", "$@12", "$@13", "controlLocalDeclarations", + "controlLocalDeclaration", "controlBody", "externDeclaration", "$@14", + "$@15", "$@16", "$@17", "externFunctionDeclaration", "methodPrototypes", + "functionPrototype", "$@18", "methodPrototype", "$@19", + "constructorMethodPrototype", "typeRef", "namedType", "prefixedType", + "typeName", "tupleType", "headerStackType", "specializedType", + "baseType", "typeOrVoid", "optTypeParameters", "typeParameters", "$@20", + "$@21", "typeParameterList", "typeArg", "typeArgumentList", "realTypeArg", "realTypeArgumentList", "typeDeclaration", - "derivedTypeDeclaration", "headerTypeDeclaration", "$@14", "$@15", - "structTypeDeclaration", "headerUnionDeclaration", "$@16", "$@17", - "structFieldList", "structField", "enumDeclaration", "$@18", "$@19", - "specifiedIdentifierList", "specifiedIdentifier", "errorDeclaration", - "matchKindDeclaration", "identifierList", "typedefDeclaration", - "assignmentOrMethodCallStatement", "emptyStatement", "exitStatement", + "derivedTypeDeclaration", "headerTypeDeclaration", "$@22", "$@23", + "structTypeDeclaration", "$@24", "$@25", "headerUnionDeclaration", + "$@26", "$@27", "structFieldList", "structField", "enumDeclaration", + "$@28", "$@29", "specifiedIdentifierList", "specifiedIdentifier", + "errorDeclaration", "matchKindDeclaration", "identifierList", + "typedefDeclaration", "assignmentOrMethodCallStatement", + "methodCallStatements", "emptyStatement", "exitStatement", "returnStatement", "conditionalStatement", "directApplication", - "statement", "blockStatement", "$@20", "statOrDeclList", + "statement", "blockStatement", "$@30", "statOrDeclList", "switchStatement", "switchCases", "switchCase", "switchLabel", - "statementOrDeclaration", "tableDeclaration", "tablePropertyList", - "tableProperty", "keyElementList", "keyElement", "actionList", - "actionRef", "entry", "entriesList", "actionDeclaration", - "variableDeclaration", "constantDeclaration", "optInitializer", - "initializer", "functionDeclaration", "argumentList", "nonEmptyArgList", - "argument", "expressionList", "prefixedNonTypeName", "dot_name", "$@21", - "lvalue", "expression", "nonBraceExpression", "l_angle", "r_angle", YY_NULLPTR + "statementOrDeclaration", "tableDeclaration", "$@31", "$@32", + "tablePropertyList", "tableProperty", "keyElementList", "keyElement", + "actionList", "action", "actionRef", "entry", "entriesList", + "actionDeclaration", "$@33", "variableDeclaration", + "constantDeclaration", "optInitializer", "initializer", + "functionDeclaration", "$@34", "argumentList", "nonEmptyArgList", + "argument", "expressionList", "prefixedNonTypeName", "dot_name", "$@35", + "lvalue", "lvalueExpression", "expression", "invokingExpression", + "nonBraceExpression", "invokingNonBraceExpression", "l_angle", "r_angle", YY_NULLPTR }; #endif @@ -755,12 +763,12 @@ static const yytype_int16 yytoknum[] = }; # endif -#define YYPACT_NINF (-765) +#define YYPACT_NINF (-806) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-243) +#define YYTABLE_NINF (-400) #define yytable_value_is_error(Yyn) \ 0 @@ -769,95 +777,97 @@ static const yytype_int16 yytoknum[] = STATE-NUM. */ static const yytype_int16 yypact[] = { - -765, 30, -765, 511, -765, -765, -765, 423, -765, 125, - -14, 125, 14, 423, -765, 125, 125, -765, -765, -765, - -765, 797, 962, -765, -21, -765, -39, -765, 84, -765, - 136, -765, 43, 53, -765, 372, -765, -765, 72, -765, - 423, -765, -765, -765, -765, -765, -765, -765, -765, 50, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, 172, -765, -765, -27, 423, -18, 423, -765, - 2434, -16, 423, 374, 423, 2564, 2477, 423, 423, 962, - 423, 423, 423, 962, -765, -765, 71, -765, -765, 45, - -765, -765, -765, 86, 97, 43, -765, 2051, 2247, 2434, - 2247, 125, -765, 2296, -765, 2247, 196, -765, 61, 2247, - 196, 107, 1786, -765, -765, -765, -765, -765, 329, 2247, - 196, 126, 423, -765, 67, -765, 423, 227, 89, 100, - 149, -765, -765, -765, 133, 423, 423, -765, -765, 125, - 423, 423, 2051, 212, 173, 188, -765, 203, -765, -765, - 2247, 2247, 2247, 2296, 1348, 2247, -765, -765, -765, -765, - 193, -765, -765, 205, 229, 617, 243, -11, -765, 238, - 247, -765, 3655, -765, 2841, 329, 2878, -765, -765, 423, - 246, -3, -765, 0, 3655, 1878, 2915, -765, -765, -765, - -765, 423, 2952, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, 2434, -765, 2989, -765, 45, 252, - 125, 268, -765, 125, -765, -765, 125, 125, -765, -765, - 125, 125, 272, -765, -765, 276, -765, -765, -765, 374, - -765, 43, -765, 919, -765, 307, 307, 307, 159, 163, - 193, 279, 183, 241, 3026, 307, 423, 2247, -765, 2051, - -765, -765, 423, 2051, 2247, 2247, 2247, 2247, 2247, 2247, - 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, - 2247, 2247, 2247, 284, 2051, 2247, 2247, -765, 1074, -765, - -765, -765, 289, -765, 395, 2247, -765, 423, -765, 2247, - -765, 196, -765, 196, 1970, -765, 196, 290, 2247, -765, - 423, 309, -765, -765, -765, -765, -765, -765, 423, 423, - -765, 962, 43, -24, 962, -765, -765, 10, -765, -765, - -765, -765, 1141, -765, -765, 2247, -765, -765, 3655, 305, - 423, 294, -765, 3830, 3830, 1061, 3799, 3766, 1608, 1608, - 184, 184, 184, 184, 307, 307, 307, 3861, 1505, 3892, - 2730, 3830, 2247, 314, 3063, 184, -765, -765, -765, -765, - 402, 3830, 45, 423, -765, 3655, -765, 3655, -765, -765, - -765, -765, 43, 302, 3655, 318, 215, 423, 328, 330, - 338, 346, 349, -12, 327, 332, -44, -765, -765, 5, - -765, -765, -765, -765, 358, -765, 423, 66, 348, -765, - -765, -765, 357, 356, 2100, 367, -765, 32, -765, 617, - 234, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, 381, 307, -765, -765, 377, -765, - -765, 2247, 1061, -765, 2247, 2434, 375, 378, -765, -765, - -765, 45, -765, 369, 242, -765, -765, -765, -765, 45, - 45, -765, 374, -765, 377, -765, 2247, 423, 125, 335, - 390, -765, -765, 396, 348, 2247, 384, -765, 2247, -765, - 3100, 2247, -765, 382, 2247, 2051, 2247, -765, 2434, -765, - 397, 3137, 3729, -765, 2051, -765, 388, 2247, -765, 423, - 64, 105, 106, 403, 408, 423, 406, 3655, -765, 374, - -765, -13, 413, -765, -765, 3174, -765, 3211, 424, 2767, - 422, 3248, 329, 854, -765, -765, 425, -765, -765, -765, - -765, 228, -765, -765, -765, -765, -765, 420, -765, 437, - 196, 196, 196, 427, 428, 414, 233, -765, -765, 2531, - 444, 2051, -765, 2247, 431, -765, 446, -765, 962, -765, - -765, -765, -765, 156, 447, 436, -765, -765, 449, 451, - 452, 461, 463, -765, 69, -765, -765, 454, 432, -765, - 462, 3285, -765, 2051, 457, 45, -765, 2343, 2247, 2247, - 2247, -765, -765, -765, 464, -765, -765, -765, -765, 466, - 2531, 2149, 468, -765, 478, -765, 484, 278, 76, 962, - -765, -765, 491, 423, -765, -765, -765, -765, -765, -765, - 3322, 3359, 3396, 108, 2198, 495, 2247, -765, 2247, 2247, - 2247, -765, 1348, 2247, -765, -765, -765, -765, 486, -765, - -765, -765, 617, 490, -11, -765, 492, 3692, -765, 485, - 489, 500, 493, -765, -765, -765, 423, -765, 423, 423, - 423, -765, 273, -765, -765, 3433, 1527, 494, 307, 307, - 307, 502, 3470, 307, 423, -765, 2051, -765, -17, 2247, - 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, - 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 513, 2051, - 2247, 2247, -765, 1074, -765, -765, 2247, -765, -765, 504, - 505, 506, 689, 507, 518, 423, 1258, -765, -765, 520, - -765, -765, -765, 738, 2690, -765, 2247, -765, -765, 523, - -765, 3830, 3830, 1061, 3799, 3766, 1608, 1608, 184, 184, - 184, 184, 307, 307, 307, 3861, 1505, 3892, 2804, 3830, - 2247, 524, 3507, 184, 402, 3830, 1, 2391, -765, -765, - -765, -765, 2051, 43, 517, 525, 529, 527, 2650, 273, - -765, -765, 2247, 2247, 307, -765, -765, 2247, 1061, -765, - 2247, 534, 541, -765, 535, 530, -765, 1684, 2247, 2247, - 43, 3655, 3655, 3544, 3729, 2051, -765, -765, -765, 94, - -765, 3581, 3618, 531, -765, 543, 1435, -765, 1684, -765, - -765, -765, -765, 542, -765, 423, 538, -765 + -806, 31, -806, 198, -806, -806, -806, 546, -806, 10, + 61, 10, 75, 546, -806, 10, 10, -806, -806, -806, + -806, 901, 785, -806, 67, -806, 33, -806, 169, -806, + 194, -806, -806, -806, 113, -806, 253, -806, -806, 145, + -806, 546, -806, -806, -806, -806, -806, -806, -806, -806, + 146, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, 213, -806, -806, -28, 546, -27, 546, + -806, 2551, -25, 546, 483, 546, 2681, 2594, 546, 546, + 785, 546, 546, 546, 785, -806, -806, 168, -806, -806, + 182, -806, 218, -806, 227, -13, 1917, 2413, 2551, 2413, + 10, -806, 1966, -806, 2413, 190, -806, -6, 2413, 190, + 94, 1652, -806, -806, -806, -806, -806, 154, 2413, 190, + 215, 546, -806, 109, -806, 546, 214, 210, 217, 223, + -806, 10, 10, 143, -13, 546, 546, -806, -806, 10, + 546, 546, 1917, 238, -13, -806, -806, 247, -806, 2413, + 2413, 2413, 2015, 975, 2413, -806, -806, -806, -806, 242, + -806, -806, 245, 272, 639, 260, -12, -806, 290, 277, + -806, 3772, -806, -806, 2958, 154, 2995, -806, -806, -806, + 292, 307, 297, -806, 298, 3772, 1744, 3032, -806, -806, + -806, -806, 546, 3069, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, 2551, -806, 3106, -806, 182, + 300, 10, 316, -806, 10, -806, -806, 318, 319, -806, + -806, 10, 10, 325, -806, -806, 320, -806, 96, 321, + -806, -806, -806, -806, 262, 262, 262, 95, 130, 242, + 323, 3, 224, 3143, 262, 546, 2413, -806, 1917, -806, + -806, 546, 2217, 2413, 2413, 2413, 2413, 2413, 2413, 2413, + 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, + 2413, 2413, 339, 1917, 2413, 2413, -806, 1143, -806, -806, + -806, 338, 546, 2413, -806, 546, 2413, -806, 190, -806, + 190, 1836, -806, 190, 348, 2413, -806, 546, 345, -806, + -806, -806, -806, -806, -806, 546, -806, -806, -806, 483, + -13, 785, 314, -806, -806, -806, 2413, -806, -806, 3772, + 354, 546, 221, -806, 1129, 1129, 4010, 3916, 3883, 3949, + 3949, 187, 187, 187, 187, 262, 262, 262, 1477, 3980, + 1536, 2847, 1129, 2413, 355, 3180, 187, -806, -806, -806, + -806, 276, 1129, 182, -806, 353, 3772, -806, 3772, -806, + -806, -806, -806, -806, 350, 3772, 360, 140, 546, 367, + -806, -806, 364, 366, -806, 280, 546, -806, -18, 785, + -806, -806, -5, -806, -806, 270, -806, -806, -13, -21, + -806, -806, -806, -806, -806, -806, 1532, 262, -806, -806, + 369, -806, -806, 2413, 4010, -806, 2413, 2551, 371, 373, + 546, 190, -13, -806, 182, -806, 365, 161, -806, -806, + 6, 16, 182, 182, 18, 369, -806, 368, 546, 10, + 459, 330, 383, -806, 374, -806, -806, 546, -806, -806, + -806, 372, 384, 2266, 386, -806, 47, -806, 639, 335, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, 286, -806, 375, 3217, 3846, -806, + 1917, -806, -806, -806, -806, 389, 2413, -806, 546, -806, + 483, 398, -806, 399, 395, 397, 404, 392, 2413, -806, + 483, 374, -806, 2413, 393, 407, 409, -806, 2413, -806, + 3254, 2413, -806, 385, 2413, 1917, 2413, -806, -806, 2551, + 858, -806, -806, 403, -806, -806, -806, 65, 546, -806, + -806, -806, -806, -806, -806, 3772, 414, 190, 190, 190, + 405, -806, -806, -806, -806, 3291, -806, 3328, 411, 2884, + 415, 3365, 154, -806, 785, -806, -806, -806, -806, 612, + 417, -806, -806, 410, -806, 419, 420, 421, -806, 110, + 2648, 429, 1917, -806, 2413, 418, -806, 425, 714, 427, + 426, -806, -806, -806, 2460, 2413, 2413, 2413, 408, 428, + 413, 26, -806, 431, 416, -806, 432, 3402, -806, 1917, + 437, 182, -806, 257, 62, 785, -806, -806, 444, 546, + -806, -806, -806, -806, -806, -806, 3439, 3476, 3513, 446, + 456, 433, 37, 457, -806, 2648, 2315, 445, -806, 454, + -806, 460, 465, 462, -806, -806, -806, 546, -806, 546, + 546, 546, -806, -806, 466, -806, -806, -806, -806, -806, + 467, -806, -806, 2413, 2413, 2413, -806, 975, 2413, -806, + -806, -806, -806, 461, -806, -806, -806, 639, 475, -12, + -806, 473, 3809, -806, -806, 469, 472, 2064, -806, -806, + 476, 477, 479, 70, 2364, 494, 2413, 262, 262, 262, + 489, 3550, 262, 546, -806, 1917, -806, -17, 2413, 2413, + 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, + 2413, 2413, 2413, 2413, 2413, 2413, 2413, 496, 1917, 2413, + 2413, -806, 1143, -806, -806, 49, 2508, -806, -806, -806, + -806, 53, -806, -806, -806, 3587, 2115, 487, 2413, -806, + -806, 491, -806, 1129, 1129, 4010, 3916, 3883, 3949, 3949, + 187, 187, 187, 187, 262, 262, 262, 1477, 3980, 1536, + 2921, 1129, 2413, 502, 3624, 187, 276, 1129, 513, -806, + 176, 500, 509, 546, 1224, -806, -806, 508, -806, -806, + -806, 1312, 2807, -806, 262, -806, -806, 2413, 4010, -806, + 2413, 514, -806, -806, 1917, -13, 511, 512, 518, 519, + 2767, 53, -806, -806, 2413, 2413, 3661, 3846, 1917, 1383, + 521, 525, -806, 2166, 2413, 2413, -13, 3772, 3772, -806, + 526, -806, -806, 531, -806, -806, 163, -806, 3698, 3735, + 529, -806, 546, -806, 2166, -806, 532, -806, -806 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -865,135 +875,141 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_int16 yydefact[] = { - 4, 0, 2, 33, 1, 158, 6, 0, 250, 252, - 251, 254, 0, 0, 253, 0, 0, 262, 263, 243, - 5, 0, 34, 35, 0, 13, 0, 10, 156, 12, - 156, 8, 33, 261, 245, 237, 240, 239, 238, 236, - 0, 11, 281, 286, 288, 287, 289, 14, 15, 0, - 9, 7, 16, 20, 18, 22, 19, 23, 21, 17, - 25, 24, 37, 480, 481, 0, 0, 0, 0, 42, - 273, 0, 0, 0, 0, 0, 0, 0, 0, 33, - 0, 0, 0, 33, 251, 36, 0, 285, 244, 33, - 283, 159, 284, 0, 0, 34, 372, 373, 0, 273, - 0, 264, 282, 380, 42, 0, 0, 309, 0, 0, - 0, 0, 0, 272, 271, 270, 269, 274, 0, 0, - 0, 0, 0, 213, 243, 300, 0, 263, 224, 0, - 0, 261, 290, 294, 0, 0, 0, 144, 168, 264, - 0, 0, 373, 143, 0, 135, 136, 0, 216, 333, - 0, 0, 0, 380, 0, 0, 379, 394, 395, 396, - 0, 393, 392, 397, 0, 0, 0, 241, 242, 0, - 374, 375, 377, 397, 0, 0, 0, 231, 265, 0, - 0, 0, 131, 0, 381, 0, 0, 482, 483, 255, - 307, 0, 0, 256, 308, 45, 41, 104, 103, 99, - 100, 102, 101, 106, 108, 107, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 95, - 122, 96, 42, 123, 124, 130, 125, 126, 127, 128, - 129, 105, 90, 98, 97, 84, 61, 82, 46, 47, + 4, 0, 2, 33, 1, 160, 6, 0, 259, 261, + 260, 263, 0, 0, 262, 0, 0, 271, 272, 252, + 5, 0, 34, 35, 0, 13, 0, 10, 158, 12, + 158, 8, 233, 390, 270, 254, 246, 249, 248, 247, + 245, 0, 11, 292, 297, 299, 298, 300, 14, 15, + 0, 9, 7, 16, 20, 18, 22, 19, 23, 21, + 17, 25, 24, 37, 504, 505, 0, 0, 0, 0, + 43, 284, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 33, 260, 36, 0, 296, 253, + 136, 294, 0, 295, 0, 33, 455, 455, 284, 455, + 273, 293, 455, 43, 455, 0, 322, 0, 455, 0, + 0, 0, 283, 282, 281, 280, 285, 0, 455, 0, + 0, 0, 217, 252, 313, 0, 272, 228, 0, 0, + 270, 273, 273, 0, 34, 0, 0, 146, 170, 273, + 0, 0, 455, 0, 33, 161, 214, 0, 391, 455, + 455, 455, 455, 455, 455, 398, 414, 415, 416, 0, + 413, 412, 417, 0, 0, 0, 250, 251, 0, 393, + 394, 396, 454, 417, 0, 0, 0, 238, 274, 275, + 0, 0, 42, 132, 41, 400, 0, 0, 506, 507, + 264, 320, 0, 0, 265, 321, 46, 40, 105, 104, + 100, 101, 103, 102, 107, 109, 108, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 96, 123, 97, 43, 124, 125, 131, 126, 127, 128, + 129, 130, 106, 91, 99, 98, 85, 62, 83, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 62, 63, 64, 65, 66, 67, 68, - 76, 69, 70, 71, 73, 72, 74, 75, 77, 78, - 79, 80, 81, 83, 85, 86, 87, 88, 89, 91, - 92, 93, 94, 44, 0, 246, 0, 257, 33, 0, - 264, 0, 302, 264, 228, 227, 264, 264, 313, 314, - 264, 264, 0, 311, 312, 0, 140, 142, 141, 0, - 157, 33, 162, 33, 335, 407, 406, 405, 0, 0, - 251, 0, 237, 238, 0, 404, 0, 0, 398, 373, - 385, 408, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 373, 0, 0, 410, 0, 247, - 249, 248, 0, 267, 0, 0, 40, 0, 39, 0, - 38, 0, 310, 0, 0, 275, 0, 0, 0, 214, - 0, 0, 225, 291, 295, 145, 169, 297, 0, 0, - 137, 33, 33, 0, 34, 221, 217, 0, 220, 219, - 222, 218, 33, 402, 401, 0, 403, 409, 378, 0, - 0, 0, 376, 420, 421, 418, 430, 431, 424, 425, - 414, 415, 416, 417, 411, 412, 413, 428, 426, 427, - 0, 423, 0, 0, 0, 429, 278, 277, 276, 279, - 0, 422, 33, 0, 266, 133, 132, 382, 258, 259, - 43, 260, 33, 0, 371, 0, 0, 0, 0, 0, - 0, 0, 0, 33, 0, 138, 0, 165, 163, 33, - 171, 167, 166, 164, 0, 223, 0, 0, 369, 334, - 318, 388, 0, 0, 0, 0, 383, 0, 347, 0, - 237, 325, 328, 331, 330, 327, 326, 346, 329, 332, - 336, 344, 345, 387, 0, 436, 435, 386, 0, 148, - 399, 0, 419, 434, 0, 0, 0, 0, 268, 365, - 368, 33, 301, 0, 0, 304, 229, 297, 297, 33, - 33, 293, 0, 298, 0, 147, 0, 0, 0, 0, - 0, 172, 212, 0, 369, 0, 0, 319, 0, 320, - 0, 0, 384, 0, 0, 373, 0, 389, 273, 152, - 0, 0, 432, 280, 373, 232, 0, 0, 303, 0, - 33, 33, 33, 0, 0, 0, 0, 139, 173, 0, - 161, 33, 0, 370, 367, 0, 321, 0, 0, 0, - 0, 0, 0, 0, 150, 400, 0, 215, 306, 305, - 226, 0, 230, 292, 296, 146, 170, 0, 149, 0, - 0, 0, 0, 0, 0, 31, 33, 349, 366, 33, - 0, 373, 390, 0, 0, 317, 0, 151, 0, 155, - 153, 154, 433, 0, 243, 0, 299, 175, 0, 0, - 0, 0, 0, 32, 0, 348, 350, 0, 322, 338, - 0, 0, 315, 373, 0, 33, 233, 33, 0, 0, - 0, 358, 355, 28, 0, 30, 29, 26, 27, 0, - 33, 0, 0, 391, 0, 234, 0, 0, 0, 34, - 176, 182, 0, 0, 177, 179, 183, 178, 180, 181, - 0, 0, 0, 33, 0, 0, 0, 323, 0, 0, - 0, 337, 0, 0, 439, 440, 441, 342, 0, 438, - 437, 442, 0, 0, 241, 339, 0, 343, 324, 0, - 0, 0, 0, 187, 189, 184, 0, 174, 0, 0, - 0, 352, 0, 351, 356, 0, 0, 0, 450, 449, - 448, 0, 0, 447, 0, 443, 373, 451, 341, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 373, - 0, 0, 453, 0, 316, 235, 380, 188, 175, 0, - 0, 0, 0, 0, 360, 0, 0, 208, 207, 0, - 194, 195, 363, 0, 204, 354, 0, 446, 452, 0, - 340, 463, 464, 461, 473, 474, 467, 468, 457, 458, - 459, 460, 454, 455, 456, 471, 469, 470, 0, 466, - 0, 0, 0, 472, 0, 465, 0, 33, 211, 210, - 209, 359, 373, 33, 203, 202, 0, 0, 204, 0, - 353, 364, 0, 0, 479, 478, 444, 0, 462, 477, - 0, 0, 0, 185, 0, 0, 197, 0, 0, 0, - 33, 205, 206, 0, 475, 373, 191, 361, 357, 0, - 198, 200, 201, 0, 445, 0, 0, 196, 0, 362, - 476, 190, 192, 0, 199, 0, 0, 193 + 58, 59, 60, 61, 63, 64, 65, 66, 67, 68, + 69, 77, 70, 71, 72, 74, 73, 75, 76, 78, + 79, 80, 81, 82, 84, 86, 87, 88, 89, 90, + 92, 93, 94, 95, 45, 0, 255, 0, 266, 136, + 0, 273, 0, 315, 273, 234, 235, 0, 0, 326, + 327, 273, 273, 0, 324, 325, 0, 159, 145, 137, + 138, 164, 220, 347, 427, 426, 425, 0, 0, 260, + 0, 246, 247, 0, 424, 0, 455, 418, 455, 404, + 428, 0, 455, 455, 455, 455, 455, 455, 455, 455, + 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, + 455, 455, 0, 455, 455, 455, 430, 455, 256, 258, + 257, 0, 0, 455, 39, 0, 455, 38, 0, 323, + 0, 0, 286, 0, 0, 455, 218, 0, 0, 229, + 301, 307, 147, 171, 304, 0, 142, 144, 143, 0, + 33, 33, 33, 349, 422, 421, 455, 423, 429, 397, + 0, 0, 0, 395, 440, 441, 438, 450, 451, 444, + 445, 434, 435, 436, 437, 431, 432, 433, 448, 446, + 447, 0, 443, 455, 0, 0, 449, 289, 288, 287, + 290, 0, 442, 136, 278, 276, 134, 133, 401, 267, + 268, 44, 269, 382, 0, 389, 0, 0, 0, 0, + 310, 310, 0, 0, 310, 0, 0, 139, 0, 34, + 167, 165, 33, 173, 169, 0, 168, 166, 33, 0, + 225, 221, 224, 223, 226, 222, 33, 453, 458, 405, + 0, 150, 419, 455, 439, 457, 455, 0, 0, 0, + 0, 0, 33, 386, 136, 314, 0, 0, 317, 230, + 33, 33, 136, 136, 33, 0, 149, 140, 0, 0, + 0, 0, 0, 174, 387, 215, 227, 0, 348, 332, + 407, 0, 0, 455, 0, 402, 0, 361, 0, 246, + 339, 328, 342, 345, 344, 341, 340, 360, 343, 346, + 350, 358, 359, 406, 0, 154, 0, 0, 452, 291, + 455, 239, 279, 277, 383, 0, 455, 316, 0, 236, + 0, 0, 311, 0, 0, 0, 0, 0, 455, 175, + 0, 387, 163, 455, 0, 0, 0, 333, 455, 334, + 0, 455, 403, 0, 455, 455, 455, 408, 409, 284, + 0, 152, 420, 0, 219, 319, 318, 33, 0, 303, + 309, 148, 172, 306, 151, 141, 0, 0, 0, 0, + 0, 388, 385, 216, 362, 0, 335, 0, 0, 0, + 0, 0, 0, 153, 0, 157, 155, 156, 456, 0, + 0, 237, 242, 0, 177, 0, 0, 0, 384, 33, + 33, 0, 455, 410, 455, 0, 329, 0, 0, 252, + 0, 232, 243, 312, 33, 455, 455, 455, 0, 0, + 31, 33, 365, 0, 336, 352, 0, 0, 330, 455, + 0, 136, 240, 0, 0, 34, 178, 184, 0, 0, + 179, 181, 185, 180, 182, 183, 0, 0, 0, 0, + 0, 32, 0, 0, 366, 33, 500, 0, 411, 0, + 241, 0, 0, 0, 189, 191, 186, 0, 176, 0, + 0, 0, 374, 371, 0, 28, 30, 29, 26, 27, + 0, 364, 337, 455, 455, 455, 351, 455, 455, 461, + 462, 463, 356, 0, 460, 459, 464, 0, 0, 250, + 353, 0, 357, 499, 338, 0, 0, 455, 190, 177, + 0, 0, 0, 33, 455, 0, 455, 472, 471, 470, + 0, 0, 469, 0, 465, 455, 473, 355, 455, 455, + 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, + 455, 455, 455, 455, 455, 455, 455, 0, 455, 455, + 455, 475, 455, 331, 244, 0, 33, 213, 212, 211, + 368, 0, 375, 367, 372, 0, 455, 0, 455, 468, + 474, 0, 354, 485, 486, 483, 495, 496, 489, 490, + 479, 480, 481, 482, 476, 477, 478, 493, 491, 492, + 0, 488, 455, 0, 0, 494, 0, 487, 0, 187, + 0, 0, 377, 0, 455, 210, 209, 0, 196, 197, + 380, 455, 206, 370, 498, 503, 466, 455, 484, 502, + 455, 0, 193, 376, 455, 33, 205, 204, 0, 0, + 206, 0, 369, 381, 455, 455, 0, 497, 455, 455, + 0, 0, 199, 455, 455, 455, 33, 207, 208, 467, + 0, 192, 194, 0, 378, 373, 0, 200, 202, 203, + 0, 501, 0, 198, 455, 379, 0, 201, 195 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -765, -765, -765, -765, -765, -7, 117, -765, -765, 8, - 2, -19, -83, -765, 448, 232, -261, -765, 291, -765, - -765, -765, -765, -303, 70, -765, -765, 575, 237, -765, - -765, -765, -765, -765, -765, -765, -765, -765, 137, -765, - -168, -765, -765, -765, -765, -765, -765, -765, -765, -263, - -765, -765, -765, -764, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -75, -765, -765, 604, - -56, -765, 339, 40, -765, 389, 51, -765, -89, -765, - -765, -277, -91, -765, -144, -765, 92, -765, -765, -765, - -765, -765, -765, -765, -131, -765, -765, -765, -765, -765, - 63, -765, -765, -53, -765, -645, -641, -765, -765, -640, - -637, -576, -28, -765, -765, -765, -765, -765, -765, -765, - -765, -765, 17, -765, -765, -765, -205, -157, -765, 322, - -290, 11, 93, -526, 48, -129, -765, 310, -151, -708, - -158, -765, -765, 929, -765, 239, -92 + -806, -806, -806, -806, -806, -7, 97, -806, -806, 14, + 5, -15, -806, -83, -806, 449, 216, -251, -806, -806, + 212, -806, -806, -806, -806, -376, 98, -806, -806, 576, + 117, -806, -806, -806, -806, -806, -806, -806, -806, -806, + 148, -806, -141, -806, -806, -806, -806, -806, -806, -806, + -806, -267, -806, -806, -806, -805, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -75, -806, -806, -806, -806, 208, -77, + -806, 363, 43, -806, 239, 50, -806, -99, -806, -806, + -806, -806, -275, -93, -806, -171, -806, 69, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -201, -806, -806, + -806, -806, -806, 64, -806, -806, -60, -806, -642, -806, + -640, -806, -806, -636, -635, -612, -94, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -37, -806, + -806, -806, -806, -245, -224, -806, 237, -806, -370, 8, + 63, -543, 42, -806, -119, -806, 305, -149, -775, -162, + -806, -806, -806, 776, -806, -806, -806, 484, -74 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 1, 2, 3, 20, 173, 164, 669, 644, 143, - 95, 23, 112, 283, 181, 182, 144, 145, 146, 309, - 24, 300, 461, 25, 560, 593, 630, 91, 165, 27, - 147, 540, 391, 468, 28, 301, 462, 469, 470, 609, - 657, 680, 681, 778, 682, 723, 724, 876, 882, 789, - 790, 869, 836, 791, 471, 29, 30, 290, 455, 313, - 396, 474, 31, 293, 458, 570, 32, 362, 602, 116, - 166, 34, 167, 36, 37, 168, 39, 40, 177, 178, - 364, 117, 118, 439, 440, 41, 42, 43, 296, 459, - 44, 45, 297, 460, 463, 533, 46, 291, 381, 524, - 525, 47, 48, 108, 49, 491, 492, 493, 494, 495, - 496, 497, 498, 314, 402, 499, 671, 715, 716, 500, - 398, 616, 617, 694, 734, 693, 783, 792, 793, 50, - 688, 689, 546, 453, 52, 169, 170, 171, 183, 503, - 357, 410, 504, 172, 717, 358, 189 + -1, 1, 2, 3, 20, 173, 163, 720, 692, 147, + 134, 23, 181, 111, 284, 182, 183, 143, 144, 309, + 310, 389, 24, 301, 452, 25, 546, 590, 626, 92, + 164, 27, 311, 512, 391, 461, 28, 302, 453, 462, + 463, 606, 654, 676, 677, 749, 678, 704, 705, 879, + 892, 847, 848, 896, 868, 849, 464, 29, 312, 575, + 30, 291, 446, 392, 471, 515, 31, 294, 449, 559, + 630, 32, 597, 33, 361, 631, 652, 632, 115, 165, + 35, 166, 37, 38, 167, 40, 41, 177, 178, 362, + 491, 435, 116, 117, 430, 431, 42, 43, 44, 450, + 561, 45, 454, 566, 46, 451, 563, 500, 562, 47, + 292, 378, 497, 498, 48, 49, 107, 50, 530, 531, + 532, 533, 534, 535, 536, 537, 538, 393, 476, 539, + 696, 740, 741, 540, 472, 639, 693, 661, 662, 754, + 804, 753, 802, 841, 850, 851, 51, 492, 684, 685, + 574, 444, 53, 95, 168, 169, 170, 184, 543, 356, + 401, 544, 588, 171, 172, 742, 743, 357, 190 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -1001,686 +1017,706 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 61, 130, 319, 85, 96, 22, 61, 375, 175, 331, - 395, 21, 684, 305, 51, 111, 685, 686, 193, 583, - 687, 185, 837, 400, 784, 105, 285, 377, 287, -33, - 4, 73, 66, 61, 109, 531, 119, 63, 64, 87, - 94, 598, 366, 648, 7, 368, 72, 330, 7, 7, - 302, 73, -160, 367, 852, 537, 369, 369, 613, 61, - 68, 61, 97, 115, 538, 61, 7, 61, 61, 128, - 61, 61, 88, 61, 61, 61, 85, 614, 149, 476, - 13, 53, 54, 360, 13, 13, 106, 134, 467, 55, - 163, 134, 115, 870, 697, 110, 163, 120, -134, 488, - 56, 472, 13, 57, 7, 97, 7, 73, 190, 58, - 102, 600, 501, -25, 884, 61, 100, 191, 142, 61, - 59, 60, 725, 142, 62, 7, -25, -25, 61, 61, - 69, 784, 148, 61, 61, 163, 89, 53, 54, 374, - 13, 663, 13, 149, 90, 55, 163, 877, 664, -24, - 878, 73, 603, 604, 194, 731, 56, 101, 328, 57, - 294, 13, 665, 191, 331, 58, 7, 7, 666, 7, - 737, 136, 61, 63, 64, 141, 59, 60, 288, 667, - 668, 517, 684, 107, 61, 107, 685, 686, 89, 121, - 687, 123, 125, 129, 132, 133, 92, 137, 138, 139, - 409, 379, 13, 13, 382, 13, 403, 383, 384, 295, - 404, 385, 386, 75, 5, 367, 103, 77, 78, 369, - 180, 345, 346, 347, 104, 433, 310, 98, 351, 8, - 9, 63, 64, 64, 82, -241, 354, 84, 563, 289, - 26, 330, 330, 292, 311, 11, 187, 188, 65, 312, - 67, 326, 298, 299, 70, 71, 14, 303, 304, 26, - 566, 15, 522, 16, -24, 17, 18, 19, 573, 574, - 180, 191, 444, -17, 99, -17, -17, 115, 98, 448, - 645, 449, 63, 64, 451, 100, 5, -17, 327, 568, - 629, 332, 553, -242, 7, 329, 363, 633, 569, 306, - 307, 8, 9, 333, 613, 365, 308, 26, 372, 84, - 26, 378, 26, 26, 380, 394, 26, 11, 387, 61, - 26, 393, 163, 614, 401, 61, 163, 456, 14, 388, - 13, 5, 405, 15, 432, 16, 26, 17, 18, 634, - 179, 442, 35, 452, 53, 54, 557, 163, 516, 53, - 54, 351, 55, 508, 509, 457, 64, 55, 506, 354, - 61, 35, 520, 56, 475, 330, 57, 513, 56, 721, - 521, 57, 58, 61, 526, 85, 527, 58, 179, 187, - 188, 61, 61, 59, 528, 284, 534, 535, 59, 60, - 61, 536, 38, 394, 676, 486, 571, 572, 529, 466, - 94, 530, 473, 61, 394, 542, 99, 545, 548, 35, - 487, 38, 35, 502, 35, 35, 98, 547, 35, 551, - 63, 64, 35, 559, 519, 554, 590, 564, 567, 63, - 64, 565, 5, 555, 537, 596, 61, 580, 35, 330, - 556, 597, 581, 407, 584, 187, 188, 8, 9, 411, - 61, 443, 187, 188, 588, 84, 605, 594, 515, 38, - 94, 606, 38, 11, 38, 38, 608, 592, 38, 61, - 61, 532, 38, 618, 14, 624, 621, 539, 632, 15, - 636, 16, 552, 637, 180, 19, 641, 642, 38, 643, - 649, 652, 650, 322, 53, 54, 656, 107, 653, 655, - 626, 658, 55, 659, 660, 464, 465, 661, 115, 662, - 670, -3, 553, 56, 478, 672, 57, 675, 638, 639, - 640, 26, 58, 695, 674, 696, 635, 507, 718, 179, - 61, 719, 179, 59, 60, 179, 179, 720, 727, 179, - 179, 736, 746, 323, 744, 774, 26, 748, 163, 775, - 26, 115, 776, 777, 795, 796, 747, 163, 654, 772, - 518, 99, 61, 820, 828, 829, 830, 831, 61, 5, - 832, 6, 7, -208, 523, 839, 845, 849, 601, 532, - 532, -207, 856, 857, 8, 9, 865, 866, 867, 615, - 868, 879, 10, 543, 544, 628, 880, 885, 887, 446, - 11, 318, 390, 12, 576, 93, 541, 33, 13, 85, - 827, 14, 486, 883, 163, 713, 15, 799, 16, 611, - 17, 18, 19, 35, 615, 826, 86, 94, 26, 824, - 612, 26, 599, 646, 860, 399, 841, 582, 0, 489, - 821, 631, 0, 412, 0, 0, 163, 0, 35, 0, - 486, 0, 35, 0, 578, 0, 0, 0, 0, 679, - 85, 0, 0, 486, 711, 678, 0, 0, 0, 0, - 61, 0, 0, 38, 0, 0, 61, 122, 94, 126, - 131, 0, 0, 135, 0, 0, 523, 140, 53, 54, - 0, 0, 607, 0, 0, 0, 55, 322, 38, 0, - 0, 732, 38, 854, 0, 745, 0, 56, 0, 0, - 57, 0, 0, 0, 0, 0, 58, 0, 0, 61, - 800, 61, 61, 61, 0, 486, 0, 59, 88, 99, - 35, 0, 851, 35, 0, 0, 875, 61, 0, 163, - 0, 490, 0, 558, 0, 0, 0, 323, 0, 0, - 0, 0, 26, 0, 0, 0, 94, 0, 321, 0, - 53, 54, 163, 0, 0, 0, 0, 0, 55, 26, - 0, 150, 151, 0, 0, 552, 0, 579, 61, 56, - 38, 152, 57, 38, 153, 840, 0, 0, 58, 0, - 786, 38, 155, 0, 722, 26, 5, 0, 0, 59, - 478, 787, 0, 0, 157, 158, 159, 0, 0, 53, - 54, 0, 0, 0, 0, 788, 26, 55, 0, 160, - 486, 0, 0, 0, 0, 163, 0, 0, 56, 679, - 26, 57, 486, 0, 0, 678, 0, 58, 26, 0, - 0, 855, 0, 544, 0, 779, 780, 781, 59, 19, - 161, 162, 0, 0, 35, 0, 489, 0, 163, 0, - 0, 798, 0, 0, 0, 26, 0, 72, 873, 0, - 26, 35, 73, 74, 0, 0, 0, 75, 61, 0, - 76, 77, 78, 0, 0, 0, 0, 0, 0, 0, - 79, 0, 80, 81, 489, 0, 0, 35, 82, 0, - 0, 627, 833, 83, 38, 0, 0, 489, 712, 0, - 0, 0, 5, 389, 0, 7, 26, 397, 610, 0, - 0, 38, 0, 0, 0, 0, 0, 8, 9, 0, - 0, 0, 35, 0, 0, 84, 0, 0, 0, 0, - 35, 0, 0, 11, 0, 0, 0, 38, 0, 0, - 0, 13, 0, 99, 14, 0, 773, 0, 647, 15, - 0, 16, 438, 17, 18, 19, 0, 35, 0, 782, - 0, 0, 35, 0, 0, 0, 0, 5, 0, 0, - 7, 0, 38, 0, 0, 0, 0, 0, 0, 0, - 38, 392, 8, 9, 0, 397, 490, 0, 477, 0, - 84, 0, 886, 0, 0, 0, 397, 0, 11, 647, - 714, 0, 0, 0, 0, 0, 13, 38, 35, 14, - 5, 0, 38, 7, 15, 0, 16, 174, 0, 176, - 19, 0, 184, 0, 186, 8, 9, 0, 192, 0, - 0, 322, 0, 84, 0, 0, 38, 0, 286, 0, - 0, 11, 0, 0, 0, 0, 0, 0, 0, 13, - 0, 0, 14, 0, 489, 0, 0, 15, 38, 16, - 0, 0, 0, 19, 0, 0, 782, 0, 0, 315, - 316, 317, 184, 324, 325, 0, 0, 0, 0, 0, - 0, 323, 0, 0, 341, 342, 343, 344, 345, 346, - 347, 0, 0, 0, 0, 351, 0, 150, 151, 0, - 64, 0, 322, 354, 0, 0, 0, 152, 0, 330, - 153, 0, 0, 356, 0, 322, 154, 0, 155, 0, - 0, 0, 5, 0, 0, 0, 575, 436, 0, 0, - 157, 158, 159, 0, 0, 53, 54, 8, 9, 0, - 0, 0, 0, 55, 0, 320, 0, 0, 0, 0, - 0, 0, 323, 11, 56, 0, 490, 57, 0, 0, - 0, 0, 0, 58, 14, 323, 0, 0, 0, 15, - 0, 16, 0, 437, 59, 19, 161, 162, 479, 0, - 0, 0, 0, 0, 0, 0, 0, 33, 0, 5, - 0, 480, 7, 0, 0, 131, 0, 0, 0, 481, - 0, 0, 53, 54, 8, 9, 38, 0, 0, 0, - 55, 0, 84, 482, 0, 0, 0, 483, 0, 0, - 11, 56, 86, 0, 57, 0, 0, 131, 13, 484, - 58, 14, 0, 485, 0, 0, 15, 0, 16, 0, - 0, 59, 19, 0, 0, 0, 408, 0, 0, 0, - 0, 683, 0, 413, 414, 415, 416, 417, 418, 419, - 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 430, 431, 0, 726, 434, 435, 0, 441, 0, 0, - 0, 150, 151, 0, 445, 0, 0, 0, 447, 0, - 0, 152, 0, 0, 153, 0, 741, 454, 0, 0, - 154, 0, 155, 0, 0, 0, 5, 0, 0, 0, - 0, 834, 0, 0, 157, 158, 159, 0, 0, 53, - 54, 8, 9, 0, 505, 835, 0, 55, 0, 320, - 0, 0, 0, 0, 0, 0, 0, 11, 56, 0, - 0, 57, 0, 0, 0, 0, 0, 58, 14, 0, - 0, 512, 0, 15, 0, 16, 0, 0, 59, 19, - 161, 162, 0, 0, 0, 0, 0, 438, 0, 0, - 0, 150, 151, 0, 0, 0, 0, 0, 0, 0, - 321, 152, 0, 0, 153, 0, 0, 0, 0, 0, - 154, 0, 155, 0, 0, 0, 5, 0, 0, 0, - 0, 0, 0, 550, 157, 158, 159, 0, 0, 53, - 54, 8, 9, 0, 0, 0, 0, 55, 0, 320, - 0, 683, 0, 0, 0, 0, 0, 11, 56, 0, - 561, 57, 0, 562, 0, 0, 0, 58, 14, 0, - 0, 0, 0, 15, 0, 16, 0, 0, 59, 19, - 161, 162, 0, 0, 0, 577, 0, 0, 150, 151, - 0, 0, 0, 0, 454, 0, 0, 585, 152, 0, - 587, 153, 881, 589, 0, 591, 0, 786, 0, 155, - 0, 0, 0, 5, 0, 0, 454, 0, 787, 0, - 0, 157, 158, 159, 0, 0, 53, 54, 0, 0, - 0, 0, 788, 0, 55, 0, 160, 0, 0, 0, - 0, 0, 0, 0, 0, 56, 0, 0, 57, 0, - 0, 0, 0, 336, 58, 0, 0, 0, 341, 342, - 343, 344, 345, 346, 347, 59, 19, 161, 162, 351, - 0, 0, 651, 0, 64, 0, 353, 354, 0, 0, - 150, 151, 0, 330, 0, 0, 0, 356, 0, 0, - 152, 0, 0, 153, 0, 0, 0, 0, 0, 786, - 0, 155, 0, 0, 0, 5, 0, 690, 691, 692, - 787, 0, 0, 157, 158, 159, 0, 0, 53, 54, - 0, 0, 0, 0, 788, 0, 55, 0, 160, 0, - 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, - 57, 0, 0, 735, 0, 454, 58, 738, 739, 740, - 0, 742, 743, 0, 334, 335, 336, 59, 19, 161, - 162, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 0, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, 0, 794, 330, 0, 0, 0, - 356, 0, 0, 0, 0, 0, 0, 0, 801, 802, - 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, - 813, 814, 815, 816, 817, 818, 819, 0, 0, 822, - 823, 0, 825, 0, 0, 184, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 838, 0, 150, 151, 0, - 0, 0, 794, 0, 0, 844, 0, 152, 0, 0, - 153, 0, 0, 0, 0, 0, 154, 0, 155, 0, - 0, 0, 5, 0, 0, 0, 0, 787, 0, 848, - 157, 158, 159, 0, 0, 53, 54, 0, 0, 0, - 0, 788, 0, 55, 0, 160, 0, 0, 0, 0, - 0, 861, 862, 0, 56, 0, 863, 57, 0, 864, - 0, 0, 0, 58, 0, 0, 794, 871, 872, 0, - 0, 0, 0, 0, 59, 19, 161, 162, 0, 0, - 0, 0, 0, 0, 0, 794, 0, 794, 195, 196, - 0, 0, 197, 198, 0, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 0, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 195, 0, 0, 0, 197, 198, 0, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 370, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 195, 0, 0, 0, 197, 198, 0, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 450, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 150, 151, 0, 0, 0, 0, - 0, 0, 0, 0, 152, 0, 0, 153, 0, 0, - 0, 0, 0, 154, 0, 155, 0, 0, 0, 5, - 0, 0, 0, 0, 156, 0, 0, 157, 158, 159, - 0, 0, 53, 54, 0, 0, 0, 0, 0, 0, - 55, 0, 160, 150, 151, 0, 0, 0, 0, 0, - 0, 56, 0, 152, 57, 0, 153, 0, 0, 0, - 58, 0, 154, 0, 155, 0, 0, 0, 5, 0, - 549, 59, 124, 161, 162, 0, 157, 158, 159, 0, - 0, 53, 54, 0, 0, 0, 0, 0, 0, 55, - 0, 160, 698, 699, 0, 0, 0, 0, 0, 0, - 56, 0, 700, 57, 0, 0, 701, 0, 0, 58, - 0, 702, 0, 703, 0, 0, 0, 5, 0, 0, - 59, 19, 161, 162, 0, 704, 705, 706, 0, 0, - 53, 54, 0, 0, 0, 0, 707, 0, 55, 0, - 708, 150, 151, 0, 0, 0, 0, 0, 0, 56, - 0, 152, 57, 0, 153, 733, 0, 0, 58, 0, - 154, 0, 155, 0, 0, 0, 5, 0, 0, 59, - 19, 709, 710, 0, 157, 158, 159, 0, 0, 53, - 54, 0, 0, 0, 0, 0, 0, 55, 0, 160, - 150, 151, 0, 0, 0, 0, 0, 0, 56, 0, - 152, 57, 0, 153, 0, 0, 0, 58, 0, 154, - 0, 155, 0, 0, 0, 5, 0, 0, 59, 19, - 161, 162, 0, 157, 158, 159, 0, 0, 53, 54, - 0, 0, 0, 0, 0, 0, 55, 0, 160, 150, - 151, 0, 0, 0, 0, 0, 0, 56, 0, 152, - 57, 0, 153, 0, 0, 0, 58, 0, 154, 0, - 155, 0, 0, 0, 5, 0, 0, 59, 19, 161, - 162, 0, 157, 158, 159, 0, 0, 53, 54, 0, - 0, 0, 0, 0, 0, 55, 0, 160, 0, 0, - 0, 0, 0, 0, 0, 0, 56, 0, 0, 57, - -186, 0, 0, 0, 0, 58, 0, 0, 0, 0, - 0, 5, 0, 480, 7, 0, 59, 124, 161, 162, - 0, 481, 0, 0, 53, 54, 8, 9, 0, 0, - 0, 0, 55, 0, 84, 0, 0, 0, 0, 483, - 0, 0, 11, 56, 0, 0, 57, 0, 853, 0, - 13, 0, 58, 14, 0, 0, 0, 677, 15, 5, - 16, 480, 7, 59, 19, 0, 0, 0, 0, 481, - 0, 0, 53, 54, 8, 9, 0, 0, 0, 0, - 55, 0, 84, 0, 0, 0, 0, 483, 0, 0, - 11, 56, 0, 0, 57, 0, 0, 0, 13, 0, - 58, 14, 5, 0, 0, 0, 15, 113, 16, 0, - 0, 59, 19, 0, 0, 53, 54, 8, 9, 0, - 0, 0, 0, 55, 0, 84, 0, 0, 0, 0, - 0, 0, 0, 11, 56, 0, 0, 57, 0, 0, - 0, 0, 0, 58, 14, 5, 0, 0, 0, 15, - 0, 16, 0, 114, 59, 19, 0, 0, 53, 54, - 8, 9, 0, 0, 0, 0, 55, 0, 84, 0, - 0, 0, 0, 0, 0, 0, 11, 56, 0, 0, - 57, 0, 0, 0, 0, 0, 58, 14, 0, 0, - 0, 0, 15, 0, 16, 0, 17, 127, 124, 5, - 0, 480, 7, 0, 0, 0, 0, 0, 0, 481, - 0, 0, 53, 54, 0, 0, 0, 0, 0, 0, - 55, 0, 0, 482, 0, 0, 0, 483, 0, 0, - 0, 56, 5, 0, 57, 0, 0, 0, 13, 484, - 58, 0, 0, 485, 0, 53, 54, 8, 9, 0, - 0, 59, 19, 55, 0, 84, 0, 0, 0, 0, - 0, 0, 0, 11, 56, 0, 0, 57, 0, 0, - 0, 0, 0, 58, 14, 0, 0, 0, 0, 15, - 0, 16, 0, 0, 59, 124, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 406, 0, 0, 0, 355, 330, 0, - 0, 0, 356, 0, 858, 859, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 0, 0, 0, 0, 355, 330, 0, - 0, 0, 356, 0, 842, 843, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 510, 0, 0, 63, 64, - 352, 353, 354, 0, 0, 511, 0, 355, 330, 0, - 0, 0, 356, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 0, 351, 622, 0, 0, 63, 64, 352, 353, 354, - 0, 0, 623, 0, 355, 330, 0, 0, 0, 356, - 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 350, 0, 351, 846, - 0, 0, 63, 64, 352, 353, 354, 0, 0, 847, - 0, 355, 330, 0, 0, 0, 356, 334, 335, 336, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 0, 351, 359, 0, 0, 63, - 64, 352, 353, 354, 0, 0, 0, 0, 355, 330, - 0, 0, 0, 356, 334, 335, 336, 337, 338, 339, + 62, 148, 129, 318, 330, 175, 62, 86, 22, 110, + 372, 52, 680, 595, 681, 460, 470, 21, 682, 683, + 186, 466, 474, 306, 104, 108, 842, 118, 664, -33, + 611, 4, 297, 298, 62, 194, 64, 65, 374, 869, + 303, 191, -162, 286, 7, 288, 329, 97, 7, 73, + 192, 64, 65, -302, 74, -250, 7, 74, 64, 65, + 62, 329, 62, -308, 114, -305, 62, 7, 62, 62, + 127, 62, 62, -363, 62, 62, 62, 7, 897, 7, + 13, 508, 517, 722, 13, 105, 109, 7, 119, 162, + 509, 114, 13, 313, 133, 162, 842, 658, 133, 907, + 527, 359, 838, 13, 63, 366, 541, 67, 706, 715, + 70, 5, -231, 13, 62, 13, 659, 800, 62, 86, + 26, 69, 74, 13, 54, 55, 7, 88, 62, 62, + 716, 7, 56, 62, 62, 162, 717, 74, 100, 26, + 371, 195, 394, 57, 89, 162, 58, 718, 719, 136, + 192, 365, 59, 141, 680, -25, 681, 327, 308, 330, + 682, 683, 13, 60, 106, 96, 106, 13, -25, -25, + 120, 7, 122, 124, 128, 131, 132, 395, 137, 138, + 139, 658, 489, 386, 387, 62, 366, 495, 26, 99, + 388, 26, 376, 26, 26, 379, 192, 26, -3, 180, + 659, 26, 382, 383, 188, 189, 101, 13, 557, 400, + 285, 34, 549, 807, 625, 26, 903, 558, 290, 904, + 142, 90, 293, 76, 344, 345, 346, 78, 79, 91, + 87, 350, 299, 300, 424, -135, 65, 304, 305, 353, + 188, 189, 39, 555, 83, 329, 90, 54, 55, 180, + 501, 564, 565, 504, 93, 56, 5, 102, 6, 7, + -17, 39, -17, -17, 145, 103, 57, 289, 99, 58, + -24, 8, 9, 146, -17, 59, -251, 295, 114, 10, + 480, 481, 121, 296, 125, 130, 60, 11, 135, 369, + 12, 307, 140, 313, 439, 13, 440, 97, 14, 442, + 325, 64, 65, 15, -24, 16, 350, 17, 18, 19, + 39, 65, 328, 39, 353, 39, 39, 447, 62, 39, + 329, 162, 96, 39, 62, 162, 188, 189, 54, 55, + 584, 326, 487, 332, 64, 65, 56, 39, 585, 505, + 506, 54, 55, 331, 329, 586, 162, 57, 702, 56, + 58, 363, 364, 365, 366, 62, 59, 488, 62, 375, + 57, 320, 377, 58, 380, 381, 36, 60, 61, 59, + 62, 384, 5, 385, 516, 7, 396, 390, 62, 97, + 60, 61, 587, 64, 65, 36, 468, 8, 9, 423, + 433, 448, 322, 583, 62, 85, 459, 459, 554, 467, + 475, 443, 26, 11, 308, 458, 469, 478, 485, 490, + 493, 13, 494, 499, 14, 545, 502, 553, 503, 15, + 701, 16, 398, 550, 556, 19, 551, 568, 402, 508, + 572, 593, 577, 573, 36, 591, 578, 36, 581, 36, + 36, 62, 594, 36, 86, 599, 600, 36, 601, 62, + 602, 603, 604, 612, 613, 614, 628, 618, 62, 434, + 634, 36, 180, 642, 651, 638, 620, 689, 645, 525, + 653, 655, 656, 657, 106, 665, 511, 669, 668, 671, + 114, 459, 455, 62, 542, 697, 672, 690, 691, 583, + 526, 708, 712, 66, 695, 68, 622, 700, 479, 71, + 72, 62, 713, 62, 721, 744, 26, 745, 26, 26, + 62, 142, 714, 746, 560, 560, 321, 747, 560, 763, + 98, 582, 748, 666, 39, 755, 756, 765, 767, 793, + 54, 55, 794, 635, 636, 637, 797, 798, 56, 799, + 806, 5, 808, 162, 855, 496, 832, 853, 647, 57, + 699, 62, 58, 507, 650, 859, 8, 9, 59, 862, + 863, 864, 514, 871, 85, 429, 878, -210, -209, 60, + 61, 882, 11, 670, 894, 883, 26, 766, 162, 901, + 791, 437, 114, 14, 179, 895, 902, 552, 15, 905, + 16, 62, 908, 528, 19, 624, 322, 456, 795, 465, + 465, 317, 457, 567, 26, 569, 94, 571, 796, 86, + 513, 629, 893, 608, 576, 179, 179, 54, 55, 738, + 609, 836, 596, 179, 694, 56, 886, 873, 39, 473, + 39, 39, 627, 525, 610, 162, 57, 403, 0, 58, + 0, 0, 0, 0, 0, 59, 811, 525, 36, 0, + 98, 0, 0, 660, 0, 496, 60, 61, 0, 675, + 86, 0, 162, 0, 0, 0, 62, 510, 674, 833, + 5, 0, 62, 812, 0, 660, 0, 26, 0, 0, + 0, 648, 0, 0, 465, 8, 9, 26, 525, 736, + 0, 0, 0, 85, 0, 633, 0, 0, 39, 0, + 62, 11, 62, 62, 62, 0, 26, 26, 0, 0, + 54, 55, 14, 0, 0, 39, 0, 15, 56, 16, + 321, 17, 18, 649, 0, 0, 39, 0, 0, 57, + 764, 0, 58, 0, 0, 0, 0, 0, 59, 0, + 0, 26, 0, 0, 0, 880, 26, 0, 0, 60, + 89, 0, 36, 0, 36, 36, 62, 528, 162, 890, + 0, 0, 861, 0, 0, 26, 0, 801, 598, 0, + 703, 528, 5, 0, 0, 179, 514, 0, 179, 0, + 0, 162, 0, 0, 0, 179, 179, 8, 9, 525, + 0, 0, 26, 0, 525, 85, 0, 0, 34, 39, + 0, 675, 0, 11, 571, 98, 750, 751, 752, 0, + 674, 0, 528, 737, 14, 0, 0, 0, 0, 15, + 0, 16, 36, 17, 18, 19, 0, 0, 39, 39, + 0, 0, 87, 582, 0, 0, 62, 130, 0, 529, + 0, 0, 0, 5, 0, 0, 7, 0, 0, 0, + 36, 0, 0, 0, 0, 0, 130, 162, 8, 9, + 810, 0, 679, 39, 525, 0, 85, 0, 39, 0, + 0, 162, 0, 174, 11, 176, 0, 0, 185, 881, + 187, 0, 13, 707, 193, 14, 0, 39, 0, 0, + 15, 0, 16, 39, 287, 62, 19, 0, 0, 0, + 900, 0, 0, 0, 0, 623, 0, 0, 0, 0, + 0, 0, 0, 528, 39, 0, 5, 0, 840, 7, + 0, 0, 0, 36, 0, 314, 315, 316, 185, 323, + 324, 8, 9, 607, 0, 760, 0, 0, 0, 85, + 865, 0, 0, 0, 0, 0, 0, 11, 0, 0, + 0, 0, 36, 36, 0, 13, 0, 0, 14, 0, + 0, 0, 0, 15, 0, 16, 322, 17, 18, 19, + 0, 73, 0, 0, 0, 0, 74, 75, 0, 0, + 0, 76, 0, 0, 77, 78, 79, 36, 840, 0, + 0, 0, 36, 570, 80, 0, 81, 82, 0, 906, + 429, 0, 83, 663, 679, 0, 0, 84, 149, 150, + 0, 36, 0, 98, 0, 0, 0, 529, 151, 0, + 0, 152, 0, 0, 0, 0, 0, 153, 589, 154, + 0, 322, 0, 5, 0, 39, 0, 0, 36, 0, + 0, 156, 157, 158, 0, 0, 54, 55, 8, 9, + 0, 0, 320, 0, 56, 0, 319, 0, 663, 739, + 0, 0, 0, 0, 11, 57, 0, 0, 58, 0, + 0, 0, 0, 0, 59, 14, 0, 0, 0, 0, + 15, 0, 16, 322, 0, 60, 19, 160, 161, 0, + 321, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 399, 0, 0, 0, 0, 0, 0, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, 0, 0, + 425, 426, 0, 432, 0, 0, 0, 0, 0, 436, + 0, 0, 438, 0, 0, 0, 0, 0, 0, 0, + 0, 445, 0, 0, 0, 321, 0, 335, 0, 529, + 0, 0, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 477, 350, 0, 0, 149, 150, 65, 0, + 352, 353, 0, 0, 0, 0, 151, 329, 0, 152, + 0, 355, 0, 0, 0, 153, 0, 154, 0, 484, + 0, 5, 0, 0, 0, 0, 427, 321, 0, 156, + 157, 158, 0, 0, 54, 55, 8, 9, 0, 0, + 0, 0, 56, 98, 319, 0, 792, 0, 0, 0, + 0, 0, 11, 57, 0, 0, 58, 0, 0, 0, + 0, 0, 59, 14, 0, 0, 0, 0, 15, 0, + 16, 0, 428, 60, 19, 160, 161, 149, 150, 547, + 0, 0, 548, 0, 0, 0, 0, 151, 0, 0, + 152, 0, 0, 0, 0, 0, 153, 0, 154, 0, + 0, 0, 5, 0, 0, 0, 0, 866, 0, 0, + 156, 157, 158, 0, 0, 54, 55, 8, 9, 580, + 0, 867, 0, 56, 0, 319, 0, 0, 0, 0, + 0, 0, 0, 11, 57, 0, 0, 58, 0, 0, + 0, 0, 0, 59, 14, 0, 0, 0, 0, 15, + 0, 16, 445, 0, 60, 19, 160, 161, 0, 0, + 0, 0, 0, 0, 605, 149, 150, 0, 0, 445, + 0, 0, 0, 0, 615, 151, 0, 617, 152, 872, + 619, 0, 621, 0, 844, 0, 154, 0, 0, 0, + 5, 0, 0, 0, 0, 845, 0, 0, 156, 157, + 158, 0, 0, 54, 55, 0, 0, 0, 0, 846, + 0, 56, 0, 159, 0, 0, 0, 0, 0, 0, + 0, 0, 57, 0, 0, 58, 0, 0, 0, 0, + 0, 59, 0, 0, 0, 0, 149, 150, 0, 0, + 667, 0, 60, 19, 160, 161, 151, 0, 0, 152, + 891, 686, 687, 688, 0, 844, 0, 154, 0, 0, + 0, 5, 0, 0, 0, 0, 845, 0, 0, 156, + 157, 158, 0, 0, 54, 55, 0, 0, 0, 0, + 846, 0, 56, 0, 159, 0, 0, 0, 0, 0, + 0, 0, 0, 57, 0, 0, 58, 0, 0, 0, + 0, 0, 59, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 60, 19, 160, 161, 0, 0, 757, + 758, 759, 0, 761, 762, 335, 0, 0, 0, 0, + 340, 341, 342, 343, 344, 345, 346, 0, 348, 349, + 0, 350, 0, 185, 0, 0, 65, 0, 352, 353, + 805, 0, 445, 0, 0, 329, 0, 0, 0, 355, + 0, 0, 0, 0, 813, 814, 815, 816, 817, 818, + 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, + 829, 830, 831, 0, 335, 834, 835, 0, 837, 340, + 341, 342, 343, 344, 345, 346, 0, 348, 0, 518, + 350, 0, 852, 0, 854, 65, 0, 352, 353, 0, + 5, 0, 519, 7, 329, 0, 0, 0, 355, 0, + 520, 0, 0, 54, 55, 8, 9, 0, 858, 0, + 0, 56, 0, 85, 521, 0, 0, 0, 522, 0, + 870, 11, 57, 0, 0, 58, 0, 852, 0, 13, + 523, 59, 14, 876, 524, 0, 877, 15, 0, 16, + 0, 0, 60, 19, 0, 0, 0, 0, 0, 0, + 887, 888, 0, 0, 0, 852, 0, 0, 0, 852, + 898, 899, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 196, 197, 0, 0, 198, 199, + 852, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 0, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 196, 0, 0, 0, + 198, 199, 0, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 367, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 196, 0, + 0, 0, 198, 199, 0, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 441, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 149, 150, 0, 0, 0, 0, 0, 0, 0, 0, + 151, 0, 0, 152, 0, 0, 0, 0, 0, 153, + -392, 154, 0, 0, 0, 5, 0, 0, 0, 0, + 155, 0, 0, 156, 157, 158, 0, 0, 54, 55, + 0, 0, 0, 0, 0, 0, 56, 0, 159, 149, + 150, 0, 0, 0, 0, 0, 0, 57, 0, 151, + 58, -399, 152, 0, 0, 0, 59, 0, 153, 0, + 154, 0, -399, 0, 5, 0, 0, 60, 123, 160, + 161, 0, 156, 157, 158, 0, 0, 54, 55, 0, + 0, 0, 0, 0, 0, 56, 0, 159, 149, 150, + 0, 0, 0, 0, 0, 0, 57, 0, 151, 58, + 0, 152, -399, 0, 0, 59, 0, 153, 0, 154, + 0, -399, 0, 5, 0, 0, 60, 123, 160, 161, + 0, 156, 157, 158, 0, 0, 54, 55, 0, 0, + 0, 0, 0, 0, 56, 0, 159, 149, 150, 0, + 0, 0, 0, 0, 0, 57, 0, 151, 58, 0, + 152, 0, 0, 0, 59, 0, 153, -399, 154, 0, + -399, 0, 5, 0, 0, 60, 123, 160, 161, 0, + 156, 157, 158, 0, 0, 54, 55, 0, 0, 0, + 0, 0, 0, 56, 0, 159, 0, 0, 149, 150, + 0, 0, 0, 0, 57, 0, 0, 58, 151, 0, + 0, 152, 0, 59, 0, 0, 0, 844, 0, 154, + 0, 0, 0, 5, 60, 19, 160, 161, 845, 0, + 0, 156, 157, 158, 0, 0, 54, 55, 0, 0, + 0, 0, 846, 0, 56, 0, 159, 0, 0, 149, + 150, 0, 0, 0, 0, 57, 0, 0, 58, 151, + 0, 0, 152, 0, 59, 0, 0, 0, 153, 0, + 154, 0, 0, 0, 5, 60, 19, 160, 161, 845, + 0, 0, 156, 157, 158, 0, 0, 54, 55, 0, + 0, 0, 0, 846, 0, 56, 0, 159, 0, 0, + 149, 150, 0, 0, 0, 0, 57, 0, 0, 58, + 151, 0, 0, 152, 0, 59, 0, 0, 0, 153, + 0, 154, 0, 0, 0, 5, 60, 19, 160, 161, + 155, 0, 0, 156, 157, 158, 0, 0, 54, 55, + 0, 0, 0, 0, 0, 0, 56, 0, 159, 149, + 150, 0, 0, 0, 0, 0, 0, 57, 0, 151, + 58, 0, 152, 0, 0, 0, 59, 0, 153, 0, + 154, 0, 0, 0, 5, 0, 579, 60, 123, 160, + 161, 0, 156, 157, 158, 0, 0, 54, 55, 0, + 0, 0, 0, 0, 0, 56, 0, 159, 723, 724, + 0, 0, 0, 0, 0, 0, 57, 0, 725, 58, + 0, 0, 726, 0, 0, 59, 0, 727, 0, 728, + 0, 0, 0, 5, 0, 0, 60, 19, 160, 161, + 0, 729, 730, 731, 0, 0, 54, 55, 0, 0, + 0, 0, 732, 0, 56, 0, 733, 149, 150, 0, + 0, 0, 0, 0, 0, 57, 0, 151, 58, 0, + 152, 803, 0, 0, 59, 0, 153, 0, 154, 0, + 0, 0, 5, 0, 0, 60, 19, 734, 735, 0, + 156, 157, 158, 0, 0, 54, 55, 0, 0, 0, + 0, 0, 0, 56, 0, 159, 149, 150, 0, 0, + 0, 0, 0, 0, 57, 0, 151, 58, 0, 152, + 0, 0, 0, 59, 0, 153, 0, 154, 0, 0, + 0, 5, 0, 0, 60, 19, 160, 161, 0, 156, + 157, 158, 0, 0, 54, 55, 0, 0, 0, 0, + 0, 0, 56, 0, 159, 0, 0, 0, 0, 0, + 0, 0, 0, 57, 0, 0, 58, -188, 0, 0, + 0, 0, 59, 0, 0, 0, 0, 0, 5, 0, + 519, 7, 0, 60, 19, 160, 161, 0, 520, 0, + 0, 54, 55, 8, 9, 0, 0, 0, 0, 56, + 0, 85, 0, 0, 0, 0, 522, 0, 0, 11, + 57, 0, 0, 58, 0, 839, 0, 13, 0, 59, + 14, 0, 0, 0, 673, 15, 5, 16, 519, 7, + 60, 19, 0, 0, 0, 0, 520, 0, 0, 54, + 55, 8, 9, 0, 0, 0, 0, 56, 0, 85, + 0, 0, 0, 0, 522, 0, 0, 11, 57, 0, + 0, 58, 0, 0, 0, 13, 0, 59, 14, 5, + 0, 0, 0, 15, 112, 16, 0, 0, 60, 19, + 0, 0, 54, 55, 8, 9, 0, 0, 0, 0, + 56, 0, 85, 0, 0, 0, 0, 0, 0, 0, + 11, 57, 0, 0, 58, 0, 0, 0, 0, 0, + 59, 14, 5, 0, 0, 0, 15, 0, 16, 0, + 113, 60, 19, 0, 0, 54, 55, 8, 9, 0, + 0, 0, 0, 56, 0, 85, 0, 0, 0, 0, + 0, 0, 0, 11, 57, 0, 0, 58, 0, 0, + 0, 0, 0, 59, 14, 0, 0, 0, 0, 15, + 0, 16, 0, 17, 126, 123, 5, 0, 519, 7, + 0, 0, 0, 0, 0, 0, 520, 0, 0, 54, + 55, 0, 0, 0, 0, 0, 0, 56, 0, 0, + 521, 0, 0, 0, 522, 0, 0, 0, 57, 5, + 0, 58, 0, 0, 0, 13, 523, 59, 0, 0, + 524, 0, 54, 55, 8, 9, 0, 0, 60, 19, + 56, 0, 85, 0, 0, 0, 0, 0, 0, 0, + 11, 57, 0, 0, 58, 0, 0, 0, 0, 0, + 59, 14, 0, 0, 0, 0, 15, 0, 16, 0, + 0, 60, 123, 333, 334, 335, 336, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 0, 350, 0, 0, 0, 64, 65, 351, 352, 353, + 397, 0, 0, 0, 354, 329, 0, 0, 0, 355, + 0, 884, 885, 333, 334, 335, 336, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 0, 350, 0, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 0, 0, 354, 329, 0, 0, 0, 355, + 0, 874, 875, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 361, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, 0, 355, 330, 0, 0, 0, - 356, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 0, 351, - 0, 0, 0, 63, 64, 352, 353, 354, 371, 0, - 0, 0, 355, 330, 0, 0, 0, 356, 334, 335, + 0, 350, 482, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 483, 0, 354, 329, 0, 0, 0, 355, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 0, 350, 643, + 0, 0, 64, 65, 351, 352, 353, 0, 0, 644, + 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 0, 351, 0, 0, 0, - 63, 64, 352, 353, 354, 373, 0, 0, 0, 355, - 330, 0, 0, 0, 356, 334, 335, 336, 337, 338, + 346, 347, 348, 349, 0, 350, 856, 0, 0, 64, + 65, 351, 352, 353, 0, 0, 857, 0, 354, 329, + 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 376, 0, 0, 0, 355, 330, 0, 0, - 0, 356, 334, 335, 336, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, 347, 348, 349, 350, 0, - 351, 0, 0, 0, 63, 64, 352, 353, 354, 406, - 0, 0, 0, 355, 330, 0, 0, 0, 356, 334, + 349, 0, 350, 358, 0, 0, 64, 65, 351, 352, + 353, 0, 0, 0, 0, 354, 329, 0, 0, 0, + 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 0, 350, + 360, 0, 0, 64, 65, 351, 352, 353, 0, 0, + 0, 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, 347, 348, 349, 350, 0, 351, 0, 0, - 0, 63, 64, 352, 353, 354, 0, 0, 514, 0, - 355, 330, 0, 0, 0, 356, 334, 335, 336, 337, + 345, 346, 347, 348, 349, 0, 350, 0, 0, 0, + 64, 65, 351, 352, 353, 368, 0, 0, 0, 354, + 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 0, 0, 0, 0, 355, 330, 0, - 586, 0, 356, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 0, 351, 595, 0, 0, 63, 64, 352, 353, 354, - 0, 0, 0, 0, 355, 330, 0, 0, 0, 356, + 348, 349, 0, 350, 0, 0, 0, 64, 65, 351, + 352, 353, 370, 0, 0, 0, 354, 329, 0, 0, + 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 373, + 0, 0, 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 350, 0, 351, 0, - 0, 0, 63, 64, 352, 353, 354, 619, 0, 0, - 0, 355, 330, 0, 0, 0, 356, 334, 335, 336, + 344, 345, 346, 347, 348, 349, 0, 350, 0, 0, + 0, 64, 65, 351, 352, 353, 397, 0, 0, 0, + 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 0, 351, 0, 0, 0, 63, - 64, 352, 353, 354, 620, 0, 0, 0, 355, 330, - 0, 0, 0, 356, 334, 335, 336, 337, 338, 339, + 347, 348, 349, 0, 350, 0, 0, 0, 64, 65, + 351, 352, 353, 0, 0, 486, 0, 354, 329, 0, + 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 0, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, 0, 355, 330, 0, 625, 0, - 356, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 0, 351, - 673, 0, 0, 63, 64, 352, 353, 354, 0, 0, - 0, 0, 355, 330, 0, 0, 0, 356, 334, 335, + 0, 350, 592, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 0, 0, 354, 329, 0, 0, 0, 355, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 0, 350, 0, + 0, 0, 64, 65, 351, 352, 353, 0, 0, 0, + 0, 354, 329, 0, 616, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 0, 351, 0, 0, 0, - 63, 64, 352, 353, 354, 728, 0, 0, 0, 355, - 330, 0, 0, 0, 356, 334, 335, 336, 337, 338, + 346, 347, 348, 349, 0, 350, 0, 0, 0, 64, + 65, 351, 352, 353, 640, 0, 0, 0, 354, 329, + 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 729, 0, 0, 0, 355, 330, 0, 0, - 0, 356, 334, 335, 336, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, 347, 348, 349, 350, 0, - 351, 0, 0, 0, 63, 64, 352, 353, 354, 730, - 0, 0, 0, 355, 330, 0, 0, 0, 356, 334, + 349, 0, 350, 0, 0, 0, 64, 65, 351, 352, + 353, 641, 0, 0, 0, 354, 329, 0, 0, 0, + 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 0, 350, + 0, 0, 0, 64, 65, 351, 352, 353, 0, 0, + 0, 0, 354, 329, 0, 646, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, 347, 348, 349, 350, 0, 351, 0, 0, - 0, 63, 64, 352, 353, 354, 0, 0, 785, 0, - 355, 330, 0, 0, 0, 356, 334, 335, 336, 337, + 345, 346, 347, 348, 349, 0, 350, 698, 0, 0, + 64, 65, 351, 352, 353, 0, 0, 0, 0, 354, + 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 797, 0, 0, 0, 355, 330, 0, - 0, 0, 356, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 0, 351, 0, 0, 0, 63, 64, 352, 353, 354, - 0, 0, 850, 0, 355, 330, 0, 0, 0, 356, + 348, 349, 0, 350, 0, 0, 0, 64, 65, 351, + 352, 353, 709, 0, 0, 0, 354, 329, 0, 0, + 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 710, + 0, 0, 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 350, 0, 351, 874, - 0, 0, 63, 64, 352, 353, 354, 0, 0, 0, - 0, 355, 330, 0, 0, 0, 356, 334, 335, 336, + 344, 345, 346, 347, 348, 349, 0, 350, 0, 0, + 0, 64, 65, 351, 352, 353, 711, 0, 0, 0, + 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 0, 351, 0, 0, 0, 63, - 64, 352, 353, 354, 0, 0, 0, -205, 355, 330, - 0, 0, 0, 356, 334, 335, 336, 337, 338, 339, + 347, 348, 349, 0, 350, 0, 0, 0, 64, 65, + 351, 352, 353, 809, 0, 0, 0, 354, 329, 0, + 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 0, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, -206, 355, 330, 0, 0, 0, - 356, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 0, 351, - 0, 0, 0, 63, 64, 352, 353, 354, 0, 0, - 0, 0, 355, 330, 0, 0, 0, 356, 749, 750, - 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, - 761, 762, 763, 764, 765, 0, 766, 0, 0, 0, - 63, 64, 767, 768, 769, 0, 0, 0, 0, 770, - 330, 0, 0, 0, 771, 334, 335, 336, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 0, 0, 0, 0, 0, 330, 0, 0, - 0, 356, 334, 335, 336, 337, 0, 339, 340, 341, - 342, 343, 344, 345, 346, 347, 348, 349, 350, 0, - 351, 0, 0, 0, 63, 64, 352, 353, 354, 0, - 0, 0, 0, 0, 330, 334, 335, 336, 356, 0, + 0, 350, 0, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 843, 0, 354, 329, 0, 0, 0, 355, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 0, 350, 0, + 0, 0, 64, 65, 351, 352, 353, 0, 0, 860, + 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, + 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, 347, 348, 349, 0, 350, 889, 0, 0, 64, + 65, 351, 352, 353, 0, 0, 0, 0, 354, 329, + 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 0, 0, 0, 0, 0, 330, 336, 0, - 0, 356, 0, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 0, 64, - 0, 353, 354, 0, 0, 0, 0, 0, 330, 336, - 0, 0, 356, 0, 341, 342, 343, 344, 345, 346, - 347, 0, 349, 350, 0, 351, 0, 0, 0, 0, - 64, 0, 353, 354, 0, 0, 0, 0, 0, 330, - 336, 0, 0, 356, 0, 341, 342, 343, 344, 345, - 346, 347, 0, 349, 0, 0, 351, 0, 0, 0, - 0, 64, 0, 353, 354, 0, 0, 0, 0, 0, - 330, 0, 0, 0, 356 + 349, 0, 350, 0, 0, 0, 64, 65, 351, 352, + 353, 0, 0, 0, -207, 354, 329, 0, 0, 0, + 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 0, 350, + 0, 0, 0, 64, 65, 351, 352, 353, 0, 0, + 0, -208, 354, 329, 0, 0, 0, 355, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 0, 350, 0, 0, 0, + 64, 65, 351, 352, 353, 0, 0, 0, 0, 354, + 329, 0, 0, 0, 355, 768, 769, 770, 771, 772, + 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, + 783, 784, 0, 785, 0, 0, 0, 64, 65, 786, + 787, 788, 0, 0, 0, 0, 789, 329, 0, 0, + 0, 790, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 0, + 0, 0, 0, 0, 329, 0, 0, 0, 355, 333, + 334, 335, 336, 0, 338, 339, 340, 341, 342, 343, + 344, 345, 346, 347, 348, 349, 0, 350, 0, 0, + 0, 64, 65, 351, 352, 353, 0, 0, 0, 0, + 0, 329, 333, 334, 335, 355, 0, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 0, + 0, 0, 0, 0, 329, 333, 334, 335, 355, 0, + 0, 0, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 0, 350, 0, 0, 0, 64, 65, 351, + 352, 353, 0, 0, 0, 0, 0, 329, 335, 0, + 0, 355, 0, 340, 341, 342, 343, 344, 345, 346, + 0, 0, 0, 0, 350, 0, 0, 0, 0, 65, + 0, 352, 353, 0, 0, 0, 0, 0, 329, 0, + 0, 0, 355, 340, 341, 342, 343, 344, 345, 346, + 0, 0, 0, 0, 350, 0, 0, 0, 0, 65, + 0, 0, 353, 0, 0, 0, 0, 0, 329, 0, + 0, 0, 355 }; static const yytype_int16 yycheck[] = { - 7, 76, 153, 22, 32, 3, 13, 284, 99, 167, - 313, 3, 657, 142, 3, 68, 657, 657, 110, 545, - 657, 104, 786, 313, 732, 52, 118, 288, 120, 46, - 0, 75, 46, 40, 52, 47, 52, 48, 49, 60, - 32, 567, 45, 619, 61, 45, 70, 58, 61, 61, - 139, 75, 47, 56, 53, 99, 56, 56, 71, 66, - 46, 68, 52, 70, 108, 72, 61, 74, 75, 76, - 77, 78, 111, 80, 81, 82, 95, 90, 46, 103, - 97, 71, 72, 175, 97, 97, 113, 79, 391, 79, - 97, 83, 99, 857, 670, 113, 103, 113, 53, 402, - 90, 391, 97, 93, 61, 52, 61, 75, 47, 99, - 60, 47, 402, 46, 878, 122, 44, 56, 52, 126, - 110, 111, 46, 52, 7, 61, 59, 60, 135, 136, - 13, 839, 46, 140, 141, 142, 52, 71, 72, 222, - 97, 72, 97, 46, 60, 79, 153, 53, 79, 60, - 56, 75, 47, 47, 47, 47, 90, 40, 165, 93, - 60, 97, 93, 56, 322, 99, 61, 61, 99, 61, - 696, 79, 179, 48, 49, 83, 110, 111, 52, 110, - 111, 442, 827, 66, 191, 68, 827, 827, 52, 72, - 827, 74, 75, 76, 77, 78, 60, 80, 81, 82, - 329, 290, 97, 97, 293, 97, 47, 296, 297, 60, - 47, 300, 301, 80, 58, 56, 44, 84, 85, 56, - 103, 37, 38, 39, 52, 354, 53, 44, 44, 73, - 74, 48, 49, 49, 101, 52, 52, 81, 515, 122, - 3, 58, 58, 126, 56, 89, 50, 51, 9, 46, - 11, 58, 135, 136, 15, 16, 100, 140, 141, 22, - 521, 105, 47, 107, 59, 109, 110, 111, 529, 530, - 153, 56, 364, 46, 35, 48, 49, 284, 44, 371, - 47, 373, 48, 49, 376, 44, 58, 60, 59, 47, - 593, 53, 58, 52, 61, 52, 179, 69, 56, 87, - 88, 73, 74, 56, 71, 59, 94, 70, 191, 81, - 73, 59, 75, 76, 46, 313, 79, 89, 46, 326, - 83, 313, 329, 90, 313, 332, 333, 380, 100, 53, - 97, 58, 53, 105, 50, 107, 99, 109, 110, 111, - 101, 52, 3, 53, 71, 72, 504, 354, 440, 71, - 72, 44, 79, 59, 60, 46, 49, 79, 53, 52, - 367, 22, 60, 90, 392, 58, 93, 53, 90, 91, - 52, 93, 99, 380, 46, 394, 46, 99, 139, 50, - 51, 388, 389, 110, 46, 56, 59, 60, 110, 111, - 397, 59, 3, 391, 655, 402, 527, 528, 52, 391, - 392, 52, 391, 410, 402, 47, 167, 59, 52, 70, - 402, 22, 73, 402, 75, 76, 44, 60, 79, 52, - 48, 49, 83, 46, 452, 44, 555, 52, 59, 48, - 49, 53, 58, 52, 99, 564, 443, 47, 99, 58, - 59, 53, 46, 326, 60, 50, 51, 73, 74, 332, - 457, 56, 50, 51, 72, 81, 53, 60, 56, 70, - 452, 53, 73, 89, 75, 76, 60, 558, 79, 476, - 477, 463, 83, 60, 100, 53, 52, 469, 53, 105, - 60, 107, 489, 46, 367, 111, 59, 59, 99, 75, - 46, 60, 621, 154, 71, 72, 60, 380, 52, 52, - 592, 52, 79, 52, 52, 388, 389, 46, 515, 46, - 78, 0, 58, 90, 397, 53, 93, 60, 610, 611, - 612, 284, 99, 59, 653, 59, 601, 410, 60, 290, - 537, 53, 293, 110, 111, 296, 297, 53, 47, 300, - 301, 46, 52, 154, 58, 60, 309, 55, 555, 60, - 313, 558, 52, 60, 60, 53, 714, 564, 633, 717, - 443, 322, 569, 50, 60, 60, 60, 60, 575, 58, - 52, 60, 61, 56, 457, 55, 53, 53, 570, 571, - 572, 56, 53, 56, 73, 74, 52, 46, 53, 581, - 60, 60, 81, 476, 477, 593, 53, 55, 60, 367, - 89, 153, 311, 92, 534, 30, 469, 3, 97, 628, - 778, 100, 619, 876, 621, 671, 105, 746, 107, 579, - 109, 110, 111, 284, 616, 776, 22, 619, 391, 773, - 579, 394, 569, 616, 839, 313, 793, 544, -1, 402, - 769, 593, -1, 333, -1, -1, 653, -1, 309, -1, - 657, -1, 313, -1, 537, -1, -1, -1, -1, 657, - 679, -1, -1, 670, 671, 657, -1, -1, -1, -1, - 677, -1, -1, 284, -1, -1, 683, 73, 670, 75, - 76, -1, -1, 79, -1, -1, 569, 83, 71, 72, - -1, -1, 575, -1, -1, -1, 79, 358, 309, -1, - -1, 693, 313, 832, -1, 712, -1, 90, -1, -1, - 93, -1, -1, -1, -1, -1, 99, -1, -1, 726, - 748, 728, 729, 730, -1, 732, -1, 110, 111, 490, - 391, -1, 824, 394, -1, -1, 865, 744, -1, 746, - -1, 402, -1, 504, -1, -1, -1, 358, -1, -1, - -1, -1, 515, -1, -1, -1, 748, -1, 154, -1, - 71, 72, 769, -1, -1, -1, -1, -1, 79, 532, - -1, 33, 34, -1, -1, 782, -1, 538, 785, 90, - 391, 43, 93, 394, 46, 47, -1, -1, 99, -1, - 52, 402, 54, -1, 677, 558, 58, -1, -1, 110, - 683, 63, -1, -1, 66, 67, 68, -1, -1, 71, - 72, -1, -1, -1, -1, 77, 579, 79, -1, 81, - 827, -1, -1, -1, -1, 832, -1, -1, 90, 827, - 593, 93, 839, -1, -1, 827, -1, 99, 601, -1, - -1, 833, -1, 726, -1, 728, 729, 730, 110, 111, - 112, 113, -1, -1, 515, -1, 619, -1, 865, -1, - -1, 744, -1, -1, -1, 628, -1, 70, 860, -1, - 633, 532, 75, 76, -1, -1, -1, 80, 885, -1, - 83, 84, 85, -1, -1, -1, -1, -1, -1, -1, - 93, -1, 95, 96, 657, -1, -1, 558, 101, -1, - -1, 47, 785, 106, 515, -1, -1, 670, 671, -1, - -1, -1, 58, 309, -1, 61, 679, 313, 579, -1, - -1, 532, -1, -1, -1, -1, -1, 73, 74, -1, - -1, -1, 593, -1, -1, 81, -1, -1, -1, -1, - 601, -1, -1, 89, -1, -1, -1, 558, -1, -1, - -1, 97, -1, 714, 100, -1, 717, -1, 619, 105, - -1, 107, 358, 109, 110, 111, -1, 628, -1, 732, - -1, -1, 633, -1, -1, -1, -1, 58, -1, -1, - 61, -1, 593, -1, -1, -1, -1, -1, -1, -1, - 601, 72, 73, 74, -1, 391, 657, -1, 394, -1, - 81, -1, 885, -1, -1, -1, 402, -1, 89, 670, - 671, -1, -1, -1, -1, -1, 97, 628, 679, 100, - 58, -1, 633, 61, 105, -1, 107, 98, -1, 100, - 111, -1, 103, -1, 105, 73, 74, -1, 109, -1, - -1, 702, -1, 81, -1, -1, 657, -1, 119, -1, - -1, 89, -1, -1, -1, -1, -1, -1, -1, 97, - -1, -1, 100, -1, 827, -1, -1, 105, 679, 107, - -1, -1, -1, 111, -1, -1, 839, -1, -1, 150, - 151, 152, 153, 154, 155, -1, -1, -1, -1, -1, - -1, 702, -1, -1, 33, 34, 35, 36, 37, 38, - 39, -1, -1, -1, -1, 44, -1, 33, 34, -1, - 49, -1, 773, 52, -1, -1, -1, 43, -1, 58, - 46, -1, -1, 62, -1, 786, 52, -1, 54, -1, - -1, -1, 58, -1, -1, -1, 532, 63, -1, -1, - 66, 67, 68, -1, -1, 71, 72, 73, 74, -1, - -1, -1, -1, 79, -1, 81, -1, -1, -1, -1, - -1, -1, 773, 89, 90, -1, 827, 93, -1, -1, - -1, -1, -1, 99, 100, 786, -1, -1, -1, 105, - -1, 107, -1, 109, 110, 111, 112, 113, 47, -1, - -1, -1, -1, -1, -1, -1, -1, 593, -1, 58, - -1, 60, 61, -1, -1, 601, -1, -1, -1, 68, - -1, -1, 71, 72, 73, 74, 827, -1, -1, -1, - 79, -1, 81, 82, -1, -1, -1, 86, -1, -1, - 89, 90, 628, -1, 93, -1, -1, 633, 97, 98, - 99, 100, -1, 102, -1, -1, 105, -1, 107, -1, - -1, 110, 111, -1, -1, -1, 327, -1, -1, -1, - -1, 657, -1, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, 352, -1, 679, 355, 356, -1, 358, -1, -1, - -1, 33, 34, -1, 365, -1, -1, -1, 369, -1, - -1, 43, -1, -1, 46, -1, 702, 378, -1, -1, - 52, -1, 54, -1, -1, -1, 58, -1, -1, -1, - -1, 63, -1, -1, 66, 67, 68, -1, -1, 71, - 72, 73, 74, -1, 405, 77, -1, 79, -1, 81, - -1, -1, -1, -1, -1, -1, -1, 89, 90, -1, - -1, 93, -1, -1, -1, -1, -1, 99, 100, -1, - -1, 432, -1, 105, -1, 107, -1, -1, 110, 111, - 112, 113, -1, -1, -1, -1, -1, 773, -1, -1, - -1, 33, 34, -1, -1, -1, -1, -1, -1, -1, - 786, 43, -1, -1, 46, -1, -1, -1, -1, -1, - 52, -1, 54, -1, -1, -1, 58, -1, -1, -1, - -1, -1, -1, 484, 66, 67, 68, -1, -1, 71, - 72, 73, 74, -1, -1, -1, -1, 79, -1, 81, - -1, 827, -1, -1, -1, -1, -1, 89, 90, -1, - 511, 93, -1, 514, -1, -1, -1, 99, 100, -1, - -1, -1, -1, 105, -1, 107, -1, -1, 110, 111, - 112, 113, -1, -1, -1, 536, -1, -1, 33, 34, - -1, -1, -1, -1, 545, -1, -1, 548, 43, -1, - 551, 46, 47, 554, -1, 556, -1, 52, -1, 54, - -1, -1, -1, 58, -1, -1, 567, -1, 63, -1, - -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, - -1, -1, 77, -1, 79, -1, 81, -1, -1, -1, - -1, -1, -1, -1, -1, 90, -1, -1, 93, -1, - -1, -1, -1, 28, 99, -1, -1, -1, 33, 34, - 35, 36, 37, 38, 39, 110, 111, 112, 113, 44, - -1, -1, 623, -1, 49, -1, 51, 52, -1, -1, - 33, 34, -1, 58, -1, -1, -1, 62, -1, -1, - 43, -1, -1, 46, -1, -1, -1, -1, -1, 52, - -1, 54, -1, -1, -1, 58, -1, 658, 659, 660, - 63, -1, -1, 66, 67, 68, -1, -1, 71, 72, - -1, -1, -1, -1, 77, -1, 79, -1, 81, -1, - -1, -1, -1, -1, -1, -1, -1, 90, -1, -1, - 93, -1, -1, 694, -1, 696, 99, 698, 699, 700, - -1, 702, 703, -1, 26, 27, 28, 110, 111, 112, - 113, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, - 52, -1, -1, -1, -1, 736, 58, -1, -1, -1, - 62, -1, -1, -1, -1, -1, -1, -1, 749, 750, - 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, - 761, 762, 763, 764, 765, 766, 767, -1, -1, 770, - 771, -1, 773, -1, -1, 776, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 786, -1, 33, 34, -1, - -1, -1, 793, -1, -1, 796, -1, 43, -1, -1, + 7, 95, 77, 152, 166, 98, 13, 22, 3, 69, + 285, 3, 654, 556, 654, 391, 392, 3, 654, 654, + 103, 391, 392, 142, 52, 52, 801, 52, 640, 46, + 573, 0, 131, 132, 41, 109, 48, 49, 289, 844, + 139, 47, 47, 117, 61, 119, 58, 44, 61, 70, + 56, 48, 49, 47, 75, 52, 61, 75, 48, 49, + 67, 58, 69, 47, 71, 47, 73, 61, 75, 76, + 77, 78, 79, 47, 81, 82, 83, 61, 883, 61, + 97, 99, 103, 695, 97, 113, 113, 61, 113, 96, + 108, 98, 97, 46, 80, 102, 871, 71, 84, 904, + 476, 175, 53, 97, 7, 56, 476, 46, 46, 72, + 13, 58, 47, 97, 121, 97, 90, 47, 125, 134, + 3, 46, 75, 97, 71, 72, 61, 60, 135, 136, + 93, 61, 79, 140, 141, 142, 99, 75, 41, 22, + 223, 47, 47, 90, 111, 152, 93, 110, 111, 80, + 56, 56, 99, 84, 796, 46, 796, 164, 144, 321, + 796, 796, 97, 110, 67, 52, 69, 97, 59, 60, + 73, 61, 75, 76, 77, 78, 79, 47, 81, 82, + 83, 71, 433, 87, 88, 192, 56, 47, 71, 44, + 94, 74, 291, 76, 77, 294, 56, 80, 0, 102, + 90, 84, 301, 302, 50, 51, 60, 97, 47, 328, + 56, 3, 487, 756, 590, 98, 53, 56, 121, 56, + 52, 52, 125, 80, 37, 38, 39, 84, 85, 60, + 22, 44, 135, 136, 353, 53, 49, 140, 141, 52, + 50, 51, 3, 494, 101, 58, 52, 71, 72, 152, + 451, 502, 503, 454, 60, 79, 58, 44, 60, 61, + 46, 22, 48, 49, 46, 52, 90, 52, 44, 93, + 60, 73, 74, 46, 60, 99, 52, 60, 285, 81, + 59, 60, 74, 60, 76, 77, 110, 89, 80, 192, + 92, 53, 84, 46, 368, 97, 370, 44, 100, 373, + 58, 48, 49, 105, 59, 107, 44, 109, 110, 111, + 71, 49, 52, 74, 52, 76, 77, 377, 325, 80, + 58, 328, 52, 84, 331, 332, 50, 51, 71, 72, + 44, 59, 56, 56, 48, 49, 79, 98, 52, 59, + 60, 71, 72, 53, 58, 59, 353, 90, 91, 79, + 93, 59, 45, 56, 56, 362, 99, 431, 365, 59, + 90, 153, 46, 93, 46, 46, 3, 110, 111, 99, + 377, 46, 58, 53, 468, 61, 53, 56, 385, 44, + 110, 111, 544, 48, 49, 22, 72, 73, 74, 50, + 52, 46, 153, 58, 401, 81, 391, 392, 492, 391, + 392, 53, 285, 89, 390, 391, 392, 53, 53, 56, + 60, 97, 52, 46, 100, 46, 52, 491, 52, 105, + 671, 107, 325, 52, 59, 111, 53, 59, 331, 99, + 47, 550, 60, 59, 71, 60, 52, 74, 52, 76, + 77, 448, 53, 80, 459, 47, 47, 84, 53, 456, + 53, 47, 60, 60, 47, 46, 53, 72, 465, 362, + 46, 98, 365, 52, 47, 60, 585, 59, 53, 476, + 60, 52, 52, 52, 377, 46, 462, 52, 60, 52, + 487, 476, 385, 490, 476, 53, 60, 59, 75, 58, + 476, 47, 46, 9, 78, 11, 589, 60, 401, 15, + 16, 508, 46, 510, 47, 60, 389, 53, 391, 392, + 517, 52, 79, 53, 500, 501, 153, 52, 504, 58, + 36, 528, 60, 642, 285, 59, 59, 52, 55, 60, + 71, 72, 60, 607, 608, 609, 60, 60, 79, 60, + 46, 58, 53, 550, 53, 448, 50, 60, 622, 90, + 669, 558, 93, 456, 629, 53, 73, 74, 99, 46, + 60, 52, 465, 55, 81, 357, 52, 56, 56, 110, + 111, 53, 89, 648, 53, 56, 459, 739, 585, 53, + 742, 365, 589, 100, 100, 60, 55, 490, 105, 60, + 107, 598, 60, 476, 111, 590, 357, 389, 747, 391, + 392, 152, 390, 505, 487, 508, 30, 510, 749, 624, + 462, 597, 879, 570, 517, 131, 132, 71, 72, 696, + 570, 792, 558, 139, 661, 79, 871, 851, 389, 392, + 391, 392, 590, 640, 571, 642, 90, 332, -1, 93, + -1, -1, -1, -1, -1, 99, 765, 654, 285, -1, + 166, -1, -1, 639, -1, 558, 110, 111, -1, 654, + 675, -1, 669, -1, -1, -1, 673, 459, 654, 788, + 58, -1, 679, 767, -1, 661, -1, 560, -1, -1, + -1, 69, -1, -1, 476, 73, 74, 570, 695, 696, + -1, -1, -1, 81, -1, 598, -1, -1, 459, -1, + 707, 89, 709, 710, 711, -1, 589, 590, -1, -1, + 71, 72, 100, -1, -1, 476, -1, 105, 79, 107, + 357, 109, 110, 111, -1, -1, 487, -1, -1, 90, + 737, -1, 93, -1, -1, -1, -1, -1, 99, -1, + -1, 624, -1, -1, -1, 864, 629, -1, -1, 110, + 111, -1, 389, -1, 391, 392, 763, 640, 765, 878, + -1, -1, 836, -1, -1, 648, -1, 753, 560, -1, + 673, 654, 58, -1, -1, 291, 679, -1, 294, -1, + -1, 788, -1, -1, -1, 301, 302, 73, 74, 796, + -1, -1, 675, -1, 801, 81, -1, -1, 590, 560, + -1, 796, -1, 89, 707, 321, 709, 710, 711, -1, + 796, -1, 695, 696, 100, -1, -1, -1, -1, 105, + -1, 107, 459, 109, 110, 111, -1, -1, 589, 590, + -1, -1, 624, 840, -1, -1, 843, 629, -1, 476, + -1, -1, -1, 58, -1, -1, 61, -1, -1, -1, + 487, -1, -1, -1, -1, -1, 648, 864, 73, 74, + 763, -1, 654, 624, 871, -1, 81, -1, 629, -1, + -1, 878, -1, 97, 89, 99, -1, -1, 102, 865, + 104, -1, 97, 675, 108, 100, -1, 648, -1, -1, + 105, -1, 107, 654, 118, 902, 111, -1, -1, -1, + 886, -1, -1, -1, -1, 47, -1, -1, -1, -1, + -1, -1, -1, 796, 675, -1, 58, -1, 801, 61, + -1, -1, -1, 560, -1, 149, 150, 151, 152, 153, + 154, 73, 74, 570, -1, 727, -1, -1, -1, 81, + 843, -1, -1, -1, -1, -1, -1, 89, -1, -1, + -1, -1, 589, 590, -1, 97, -1, -1, 100, -1, + -1, -1, -1, 105, -1, 107, 727, 109, 110, 111, + -1, 70, -1, -1, -1, -1, 75, 76, -1, -1, + -1, 80, -1, -1, 83, 84, 85, 624, 871, -1, + -1, -1, 629, 509, 93, -1, 95, 96, -1, 902, + 792, -1, 101, 640, 796, -1, -1, 106, 33, 34, + -1, 648, -1, 529, -1, -1, -1, 654, 43, -1, + -1, 46, -1, -1, -1, -1, -1, 52, 544, 54, + -1, 792, -1, 58, -1, 796, -1, -1, 675, -1, + -1, 66, 67, 68, -1, -1, 71, 72, 73, 74, + -1, -1, 844, -1, 79, -1, 81, -1, 695, 696, + -1, -1, -1, -1, 89, 90, -1, -1, 93, -1, + -1, -1, -1, -1, 99, 100, -1, -1, -1, -1, + 105, -1, 107, 844, -1, 110, 111, 112, 113, -1, + 727, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 326, -1, -1, -1, -1, -1, -1, 333, + 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, 347, 348, 349, 350, 351, -1, -1, + 354, 355, -1, 357, -1, -1, -1, -1, -1, 363, + -1, -1, 366, -1, -1, -1, -1, -1, -1, -1, + -1, 375, -1, -1, -1, 792, -1, 28, -1, 796, + -1, -1, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 396, 44, -1, -1, 33, 34, 49, -1, + 51, 52, -1, -1, -1, -1, 43, 58, -1, 46, + -1, 62, -1, -1, -1, 52, -1, 54, -1, 423, + -1, 58, -1, -1, -1, -1, 63, 844, -1, 66, + 67, 68, -1, -1, 71, 72, 73, 74, -1, -1, + -1, -1, 79, 739, 81, -1, 742, -1, -1, -1, + -1, -1, 89, 90, -1, -1, 93, -1, -1, -1, + -1, -1, 99, 100, -1, -1, -1, -1, 105, -1, + 107, -1, 109, 110, 111, 112, 113, 33, 34, 483, + -1, -1, 486, -1, -1, -1, -1, 43, -1, -1, 46, -1, -1, -1, -1, -1, 52, -1, 54, -1, - -1, -1, 58, -1, -1, -1, -1, 63, -1, 820, - 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, + -1, -1, 58, -1, -1, -1, -1, 63, -1, -1, + 66, 67, 68, -1, -1, 71, 72, 73, 74, 523, -1, 77, -1, 79, -1, 81, -1, -1, -1, -1, - -1, 842, 843, -1, 90, -1, 847, 93, -1, 850, - -1, -1, -1, 99, -1, -1, 857, 858, 859, -1, - -1, -1, -1, -1, 110, 111, 112, 113, -1, -1, - -1, -1, -1, -1, -1, 876, -1, 878, 22, 23, + -1, -1, -1, 89, 90, -1, -1, 93, -1, -1, + -1, -1, -1, 99, 100, -1, -1, -1, -1, 105, + -1, 107, 556, -1, 110, 111, 112, 113, -1, -1, + -1, -1, -1, -1, 568, 33, 34, -1, -1, 573, + -1, -1, -1, -1, 578, 43, -1, 581, 46, 47, + 584, -1, 586, -1, 52, -1, 54, -1, -1, -1, + 58, -1, -1, -1, -1, 63, -1, -1, 66, 67, + 68, -1, -1, 71, 72, -1, -1, -1, -1, 77, + -1, 79, -1, 81, -1, -1, -1, -1, -1, -1, + -1, -1, 90, -1, -1, 93, -1, -1, -1, -1, + -1, 99, -1, -1, -1, -1, 33, 34, -1, -1, + 644, -1, 110, 111, 112, 113, 43, -1, -1, 46, + 47, 655, 656, 657, -1, 52, -1, 54, -1, -1, + -1, 58, -1, -1, -1, -1, 63, -1, -1, 66, + 67, 68, -1, -1, 71, 72, -1, -1, -1, -1, + 77, -1, 79, -1, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 90, -1, -1, 93, -1, -1, -1, + -1, -1, 99, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 110, 111, 112, 113, -1, -1, 723, + 724, 725, -1, 727, 728, 28, -1, -1, -1, -1, + 33, 34, 35, 36, 37, 38, 39, -1, 41, 42, + -1, 44, -1, 747, -1, -1, 49, -1, 51, 52, + 754, -1, 756, -1, -1, 58, -1, -1, -1, 62, + -1, -1, -1, -1, 768, 769, 770, 771, 772, 773, + 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, + 784, 785, 786, -1, 28, 789, 790, -1, 792, 33, + 34, 35, 36, 37, 38, 39, -1, 41, -1, 47, + 44, -1, 806, -1, 808, 49, -1, 51, 52, -1, + 58, -1, 60, 61, 58, -1, -1, -1, 62, -1, + 68, -1, -1, 71, 72, 73, 74, -1, 832, -1, + -1, 79, -1, 81, 82, -1, -1, -1, 86, -1, + 844, 89, 90, -1, -1, 93, -1, 851, -1, 97, + 98, 99, 100, 857, 102, -1, 860, 105, -1, 107, + -1, -1, 110, 111, -1, -1, -1, -1, -1, -1, + 874, 875, -1, -1, -1, 879, -1, -1, -1, 883, + 884, 885, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, -1, -1, 26, 27, + 904, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, -1, 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, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 22, -1, -1, -1, + 26, 27, -1, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 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, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 22, -1, -1, -1, 26, 27, -1, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, -1, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 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, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 22, -1, -1, -1, 26, 27, -1, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 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, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 22, -1, -1, -1, 26, 27, -1, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 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, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 33, 34, -1, -1, -1, -1, - -1, -1, -1, -1, 43, -1, -1, 46, -1, -1, - -1, -1, -1, 52, -1, 54, -1, -1, -1, 58, - -1, -1, -1, -1, 63, -1, -1, 66, 67, 68, - -1, -1, 71, 72, -1, -1, -1, -1, -1, -1, - 79, -1, 81, 33, 34, -1, -1, -1, -1, -1, - -1, 90, -1, 43, 93, -1, 46, -1, -1, -1, - 99, -1, 52, -1, 54, -1, -1, -1, 58, -1, - 60, 110, 111, 112, 113, -1, 66, 67, 68, -1, - -1, 71, 72, -1, -1, -1, -1, -1, -1, 79, - -1, 81, 33, 34, -1, -1, -1, -1, -1, -1, - 90, -1, 43, 93, -1, -1, 47, -1, -1, 99, - -1, 52, -1, 54, -1, -1, -1, 58, -1, -1, - 110, 111, 112, 113, -1, 66, 67, 68, -1, -1, - 71, 72, -1, -1, -1, -1, 77, -1, 79, -1, - 81, 33, 34, -1, -1, -1, -1, -1, -1, 90, - -1, 43, 93, -1, 46, 47, -1, -1, 99, -1, - 52, -1, 54, -1, -1, -1, 58, -1, -1, 110, - 111, 112, 113, -1, 66, 67, 68, -1, -1, 71, - 72, -1, -1, -1, -1, -1, -1, 79, -1, 81, - 33, 34, -1, -1, -1, -1, -1, -1, 90, -1, - 43, 93, -1, 46, -1, -1, -1, 99, -1, 52, - -1, 54, -1, -1, -1, 58, -1, -1, 110, 111, - 112, 113, -1, 66, 67, 68, -1, -1, 71, 72, + 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, + 43, -1, -1, 46, -1, -1, -1, -1, -1, 52, + 53, 54, -1, -1, -1, 58, -1, -1, -1, -1, + 63, -1, -1, 66, 67, 68, -1, -1, 71, 72, + -1, -1, -1, -1, -1, -1, 79, -1, 81, 33, + 34, -1, -1, -1, -1, -1, -1, 90, -1, 43, + 93, 45, 46, -1, -1, -1, 99, -1, 52, -1, + 54, -1, 56, -1, 58, -1, -1, 110, 111, 112, + 113, -1, 66, 67, 68, -1, -1, 71, 72, -1, + -1, -1, -1, -1, -1, 79, -1, 81, 33, 34, + -1, -1, -1, -1, -1, -1, 90, -1, 43, 93, + -1, 46, 47, -1, -1, 99, -1, 52, -1, 54, + -1, 56, -1, 58, -1, -1, 110, 111, 112, 113, + -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, + -1, -1, -1, -1, 79, -1, 81, 33, 34, -1, + -1, -1, -1, -1, -1, 90, -1, 43, 93, -1, + 46, -1, -1, -1, 99, -1, 52, 53, 54, -1, + 56, -1, 58, -1, -1, 110, 111, 112, 113, -1, + 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, + -1, -1, -1, 79, -1, 81, -1, -1, 33, 34, + -1, -1, -1, -1, 90, -1, -1, 93, 43, -1, + -1, 46, -1, 99, -1, -1, -1, 52, -1, 54, + -1, -1, -1, 58, 110, 111, 112, 113, 63, -1, + -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, + -1, -1, 77, -1, 79, -1, 81, -1, -1, 33, + 34, -1, -1, -1, -1, 90, -1, -1, 93, 43, + -1, -1, 46, -1, 99, -1, -1, -1, 52, -1, + 54, -1, -1, -1, 58, 110, 111, 112, 113, 63, + -1, -1, 66, 67, 68, -1, -1, 71, 72, -1, + -1, -1, -1, 77, -1, 79, -1, 81, -1, -1, + 33, 34, -1, -1, -1, -1, 90, -1, -1, 93, + 43, -1, -1, 46, -1, 99, -1, -1, -1, 52, + -1, 54, -1, -1, -1, 58, 110, 111, 112, 113, + 63, -1, -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, -1, -1, -1, 79, -1, 81, 33, 34, -1, -1, -1, -1, -1, -1, 90, -1, 43, 93, -1, 46, -1, -1, -1, 99, -1, 52, -1, - 54, -1, -1, -1, 58, -1, -1, 110, 111, 112, + 54, -1, -1, -1, 58, -1, 60, 110, 111, 112, 113, -1, 66, 67, 68, -1, -1, 71, 72, -1, - -1, -1, -1, -1, -1, 79, -1, 81, -1, -1, - -1, -1, -1, -1, -1, -1, 90, -1, -1, 93, - 47, -1, -1, -1, -1, 99, -1, -1, -1, -1, - -1, 58, -1, 60, 61, -1, 110, 111, 112, 113, - -1, 68, -1, -1, 71, 72, 73, 74, -1, -1, - -1, -1, 79, -1, 81, -1, -1, -1, -1, 86, - -1, -1, 89, 90, -1, -1, 93, -1, 47, -1, - 97, -1, 99, 100, -1, -1, -1, 104, 105, 58, - 107, 60, 61, 110, 111, -1, -1, -1, -1, 68, + -1, -1, -1, -1, -1, 79, -1, 81, 33, 34, + -1, -1, -1, -1, -1, -1, 90, -1, 43, 93, + -1, -1, 47, -1, -1, 99, -1, 52, -1, 54, + -1, -1, -1, 58, -1, -1, 110, 111, 112, 113, + -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, + -1, -1, 77, -1, 79, -1, 81, 33, 34, -1, + -1, -1, -1, -1, -1, 90, -1, 43, 93, -1, + 46, 47, -1, -1, 99, -1, 52, -1, 54, -1, + -1, -1, 58, -1, -1, 110, 111, 112, 113, -1, + 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, + -1, -1, -1, 79, -1, 81, 33, 34, -1, -1, + -1, -1, -1, -1, 90, -1, 43, 93, -1, 46, + -1, -1, -1, 99, -1, 52, -1, 54, -1, -1, + -1, 58, -1, -1, 110, 111, 112, 113, -1, 66, + 67, 68, -1, -1, 71, 72, -1, -1, -1, -1, + -1, -1, 79, -1, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 90, -1, -1, 93, 47, -1, -1, + -1, -1, 99, -1, -1, -1, -1, -1, 58, -1, + 60, 61, -1, 110, 111, 112, 113, -1, 68, -1, + -1, 71, 72, 73, 74, -1, -1, -1, -1, 79, + -1, 81, -1, -1, -1, -1, 86, -1, -1, 89, + 90, -1, -1, 93, -1, 47, -1, 97, -1, 99, + 100, -1, -1, -1, 104, 105, 58, 107, 60, 61, + 110, 111, -1, -1, -1, -1, 68, -1, -1, 71, + 72, 73, 74, -1, -1, -1, -1, 79, -1, 81, + -1, -1, -1, -1, 86, -1, -1, 89, 90, -1, + -1, 93, -1, -1, -1, 97, -1, 99, 100, 58, + -1, -1, -1, 105, 63, 107, -1, -1, 110, 111, -1, -1, 71, 72, 73, 74, -1, -1, -1, -1, - 79, -1, 81, -1, -1, -1, -1, 86, -1, -1, - 89, 90, -1, -1, 93, -1, -1, -1, 97, -1, - 99, 100, 58, -1, -1, -1, 105, 63, 107, -1, - -1, 110, 111, -1, -1, 71, 72, 73, 74, -1, + 79, -1, 81, -1, -1, -1, -1, -1, -1, -1, + 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, + 99, 100, 58, -1, -1, -1, 105, -1, 107, -1, + 109, 110, 111, -1, -1, 71, 72, 73, 74, -1, -1, -1, -1, 79, -1, 81, -1, -1, -1, -1, -1, -1, -1, 89, 90, -1, -1, 93, -1, -1, - -1, -1, -1, 99, 100, 58, -1, -1, -1, 105, - -1, 107, -1, 109, 110, 111, -1, -1, 71, 72, - 73, 74, -1, -1, -1, -1, 79, -1, 81, -1, - -1, -1, -1, -1, -1, -1, 89, 90, -1, -1, - 93, -1, -1, -1, -1, -1, 99, 100, -1, -1, - -1, -1, 105, -1, 107, -1, 109, 110, 111, 58, - -1, 60, 61, -1, -1, -1, -1, -1, -1, 68, - -1, -1, 71, 72, -1, -1, -1, -1, -1, -1, - 79, -1, -1, 82, -1, -1, -1, 86, -1, -1, - -1, 90, 58, -1, 93, -1, -1, -1, 97, 98, - 99, -1, -1, 102, -1, 71, 72, 73, 74, -1, - -1, 110, 111, 79, -1, 81, -1, -1, -1, -1, - -1, -1, -1, 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, 99, 100, -1, -1, -1, -1, 105, - -1, 107, -1, -1, 110, 111, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, - 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, - -1, -1, 62, -1, 64, 65, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, - 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, - -1, -1, 62, -1, 64, 65, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, - 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, - -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, + -1, 107, -1, 109, 110, 111, 58, -1, 60, 61, + -1, -1, -1, -1, -1, -1, 68, -1, -1, 71, + 72, -1, -1, -1, -1, -1, -1, 79, -1, -1, + 82, -1, -1, -1, 86, -1, -1, -1, 90, 58, + -1, 93, -1, -1, -1, 97, 98, 99, -1, -1, + 102, -1, 71, 72, 73, 74, -1, -1, 110, 111, + 79, -1, 81, -1, -1, -1, -1, -1, -1, -1, + 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, + 99, 100, -1, -1, -1, -1, 105, -1, 107, -1, + -1, 110, 111, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, + 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, + -1, 64, 65, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, + -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, + -1, 64, 65, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, @@ -1690,14 +1726,14 @@ static const yytype_int16 yycheck[] = -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, - 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, + 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, - -1, -1, -1, 48, 49, 50, 51, 52, 53, -1, + 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, @@ -1712,33 +1748,33 @@ static const yytype_int16 yycheck[] = -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, - -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, + -1, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, - 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, - 60, -1, 62, 26, 27, 28, 29, 30, 31, 32, + 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, + -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, - -1, -1, 48, 49, 50, 51, 52, 53, -1, -1, - -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, + -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, + -1, 57, 58, -1, 60, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, - 52, -1, -1, -1, -1, 57, 58, -1, 60, -1, + 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, - 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, - -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, + -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, + -1, -1, 57, 58, -1, 60, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, - 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, + 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, + 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, @@ -1749,7 +1785,7 @@ static const yytype_int16 yycheck[] = -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, - -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, + -1, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, @@ -1759,12 +1795,12 @@ static const yytype_int16 yycheck[] = -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, - -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, + 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, + -1, -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, - 49, 50, 51, 52, -1, -1, -1, 56, 57, 58, + 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, + 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, @@ -1772,31 +1808,35 @@ static const yytype_int16 yycheck[] = 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, - -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, + -1, 56, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, - 51, 52, -1, -1, -1, -1, -1, 58, -1, -1, - -1, 62, 26, 27, 28, 29, -1, 31, 32, 33, + 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, + -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, + 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, + -1, -1, -1, -1, 58, -1, -1, -1, 62, 26, + 27, 28, 29, -1, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, + -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, + -1, 58, 26, 27, 28, 62, -1, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, -1, 58, 26, 27, 28, 62, -1, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + -1, -1, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, -1, 58, 28, -1, -1, 62, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, -1, -1, -1, -1, 49, - -1, 51, 52, -1, -1, -1, -1, -1, 58, 28, - -1, -1, 62, -1, 33, 34, 35, 36, 37, 38, - 39, -1, 41, 42, -1, 44, -1, -1, -1, -1, - 49, -1, 51, 52, -1, -1, -1, -1, -1, 58, - 28, -1, -1, 62, -1, 33, 34, 35, 36, 37, - 38, 39, -1, 41, -1, -1, 44, -1, -1, -1, - -1, 49, -1, 51, 52, -1, -1, -1, -1, -1, - 58, -1, -1, -1, 62 + -1, -1, -1, -1, 44, -1, -1, -1, -1, 49, + -1, 51, 52, -1, -1, -1, -1, -1, 58, -1, + -1, -1, 62, 33, 34, 35, 36, 37, 38, 39, + -1, -1, -1, -1, 44, -1, -1, -1, -1, 49, + -1, -1, 52, -1, -1, -1, -1, -1, 58, -1, + -1, -1, 62 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing @@ -1805,93 +1845,95 @@ static const yytype_int16 yystos[] = { 0, 119, 120, 121, 0, 58, 60, 61, 73, 74, 81, 89, 92, 97, 100, 105, 107, 109, 110, 111, - 122, 127, 128, 129, 138, 141, 146, 147, 152, 173, - 174, 180, 184, 187, 189, 190, 191, 192, 193, 194, - 195, 203, 204, 205, 208, 209, 214, 219, 220, 222, - 247, 249, 252, 71, 72, 79, 90, 93, 99, 110, - 111, 123, 124, 48, 49, 263, 46, 263, 46, 124, - 263, 263, 70, 75, 76, 80, 83, 84, 85, 93, - 95, 96, 101, 106, 81, 129, 187, 60, 111, 52, - 60, 145, 60, 145, 127, 128, 230, 52, 44, 263, - 44, 124, 60, 44, 52, 52, 113, 124, 221, 52, - 113, 221, 130, 63, 109, 123, 187, 199, 200, 52, - 113, 124, 187, 124, 111, 124, 187, 110, 123, 124, - 184, 187, 124, 124, 127, 187, 204, 124, 124, 124, - 187, 204, 52, 127, 134, 135, 136, 148, 46, 46, - 33, 34, 43, 46, 52, 54, 63, 66, 67, 68, - 81, 112, 113, 123, 124, 146, 188, 190, 193, 253, - 254, 255, 261, 123, 261, 200, 261, 196, 197, 263, - 124, 132, 133, 256, 261, 130, 261, 50, 51, 264, - 47, 56, 261, 264, 47, 22, 23, 26, 27, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 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, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 131, 56, 264, 261, 264, 52, 124, - 175, 215, 124, 181, 60, 60, 206, 210, 124, 124, - 139, 153, 196, 124, 124, 253, 87, 88, 94, 137, - 53, 56, 46, 177, 231, 261, 261, 261, 132, 256, - 81, 187, 190, 193, 261, 261, 58, 59, 123, 52, - 58, 258, 53, 56, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 44, 50, 51, 52, 57, 62, 258, 263, 45, - 264, 45, 185, 124, 198, 59, 45, 56, 45, 56, - 53, 53, 124, 53, 130, 199, 53, 134, 59, 196, - 46, 216, 196, 196, 196, 196, 196, 46, 53, 187, - 136, 150, 72, 127, 128, 141, 178, 187, 238, 247, - 248, 249, 232, 47, 47, 53, 53, 124, 261, 253, - 259, 124, 255, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 50, 253, 261, 261, 63, 109, 187, 201, - 202, 261, 52, 56, 264, 261, 133, 261, 264, 264, - 53, 264, 53, 251, 261, 176, 221, 46, 182, 207, - 211, 140, 154, 212, 124, 124, 127, 141, 151, 155, - 156, 172, 248, 249, 179, 230, 103, 187, 124, 47, - 60, 68, 82, 86, 98, 102, 123, 127, 141, 146, - 190, 223, 224, 225, 226, 227, 228, 229, 230, 233, - 237, 248, 249, 257, 260, 261, 53, 124, 59, 60, - 45, 55, 261, 53, 55, 56, 264, 134, 124, 230, - 60, 52, 47, 124, 217, 218, 46, 46, 46, 52, - 52, 47, 127, 213, 59, 60, 59, 99, 108, 127, - 149, 156, 47, 124, 124, 59, 250, 60, 52, 60, - 261, 52, 123, 58, 44, 52, 59, 258, 263, 46, - 142, 261, 261, 199, 52, 53, 134, 59, 47, 56, - 183, 212, 212, 134, 134, 187, 142, 261, 124, 263, - 47, 46, 250, 251, 60, 261, 60, 261, 72, 261, - 253, 261, 200, 143, 60, 45, 253, 53, 251, 218, - 47, 127, 186, 47, 47, 53, 53, 124, 60, 157, - 190, 191, 194, 71, 90, 127, 239, 240, 60, 53, - 53, 52, 45, 55, 53, 60, 264, 47, 128, 141, - 144, 252, 53, 69, 111, 184, 60, 46, 264, 264, - 264, 59, 59, 75, 126, 47, 240, 190, 229, 46, - 253, 261, 60, 52, 184, 52, 60, 158, 52, 52, - 52, 46, 46, 72, 79, 93, 99, 110, 111, 125, - 78, 234, 53, 45, 253, 60, 134, 104, 127, 128, - 159, 160, 162, 187, 223, 224, 227, 228, 248, 249, - 261, 261, 261, 243, 241, 59, 59, 229, 33, 34, - 43, 47, 52, 54, 66, 67, 68, 77, 81, 112, - 113, 123, 146, 188, 190, 235, 236, 262, 60, 53, - 53, 91, 124, 163, 164, 46, 187, 47, 53, 53, - 53, 47, 127, 47, 242, 261, 46, 251, 261, 261, - 261, 187, 261, 261, 58, 123, 52, 258, 55, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 44, 50, 51, 52, - 57, 62, 258, 263, 60, 60, 52, 60, 161, 124, - 124, 124, 146, 244, 257, 55, 52, 63, 77, 167, - 168, 171, 245, 246, 261, 60, 53, 53, 124, 253, - 230, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 50, 253, 261, 261, 202, 261, 256, 158, 60, 60, - 60, 60, 52, 124, 63, 77, 170, 171, 261, 55, - 47, 245, 64, 65, 261, 53, 45, 55, 261, 53, - 55, 264, 53, 47, 253, 127, 53, 56, 64, 65, - 244, 261, 261, 261, 261, 52, 46, 53, 60, 169, - 171, 261, 261, 127, 45, 253, 165, 53, 56, 60, - 53, 47, 166, 167, 171, 55, 124, 60 + 122, 127, 128, 129, 140, 143, 148, 149, 154, 175, + 178, 184, 189, 191, 196, 198, 199, 200, 201, 202, + 203, 204, 214, 215, 216, 219, 222, 227, 232, 233, + 235, 264, 267, 270, 71, 72, 79, 90, 93, 99, + 110, 111, 123, 124, 48, 49, 285, 46, 285, 46, + 124, 285, 285, 70, 75, 76, 80, 83, 84, 85, + 93, 95, 96, 101, 106, 81, 129, 196, 60, 111, + 52, 60, 147, 60, 147, 271, 52, 44, 285, 44, + 124, 60, 44, 52, 52, 113, 124, 234, 52, 113, + 234, 131, 63, 109, 123, 196, 210, 211, 52, 113, + 124, 196, 124, 111, 124, 196, 110, 123, 124, 191, + 196, 124, 124, 127, 128, 196, 215, 124, 124, 124, + 196, 215, 52, 135, 136, 46, 46, 127, 244, 33, + 34, 43, 46, 52, 54, 63, 66, 67, 68, 81, + 112, 113, 123, 124, 148, 197, 199, 202, 272, 273, + 274, 281, 282, 123, 281, 211, 281, 205, 206, 285, + 124, 130, 133, 134, 275, 281, 131, 281, 50, 51, + 286, 47, 56, 281, 286, 47, 22, 23, 26, 27, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 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, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 132, 56, 286, 281, 286, 52, + 124, 179, 228, 124, 185, 60, 60, 205, 205, 124, + 124, 141, 155, 205, 124, 124, 272, 53, 127, 137, + 138, 150, 176, 46, 281, 281, 281, 133, 275, 81, + 196, 199, 202, 281, 281, 58, 59, 123, 52, 58, + 277, 53, 56, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 44, 50, 51, 52, 57, 62, 277, 285, 45, 286, + 45, 192, 207, 59, 45, 56, 56, 53, 53, 124, + 53, 131, 210, 53, 135, 59, 205, 46, 229, 205, + 46, 46, 205, 205, 46, 53, 87, 88, 94, 139, + 56, 152, 181, 245, 47, 47, 53, 53, 124, 281, + 272, 278, 124, 274, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 50, 272, 281, 281, 63, 109, 196, + 212, 213, 281, 52, 124, 209, 281, 134, 281, 286, + 286, 53, 286, 53, 269, 281, 180, 234, 46, 186, + 217, 223, 142, 156, 220, 124, 196, 138, 127, 128, + 143, 153, 157, 158, 174, 196, 266, 267, 72, 127, + 143, 182, 252, 264, 266, 267, 246, 281, 53, 124, + 59, 60, 45, 55, 281, 53, 55, 56, 286, 135, + 56, 208, 265, 60, 52, 47, 124, 230, 231, 46, + 225, 225, 52, 52, 225, 59, 60, 124, 99, 108, + 196, 127, 151, 158, 124, 183, 244, 103, 47, 60, + 68, 82, 86, 98, 102, 123, 127, 143, 148, 199, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 247, + 251, 266, 267, 276, 279, 46, 144, 281, 281, 210, + 52, 53, 124, 286, 244, 135, 59, 47, 56, 187, + 127, 218, 226, 224, 135, 135, 221, 144, 59, 124, + 285, 124, 47, 59, 268, 177, 124, 60, 52, 60, + 281, 52, 123, 58, 44, 52, 59, 277, 280, 285, + 145, 60, 45, 272, 53, 269, 231, 190, 196, 47, + 47, 53, 53, 47, 60, 281, 159, 199, 200, 203, + 268, 269, 60, 47, 46, 281, 60, 281, 72, 281, + 272, 281, 211, 47, 128, 143, 146, 270, 53, 127, + 188, 193, 195, 124, 46, 286, 286, 286, 60, 253, + 53, 53, 52, 45, 55, 53, 60, 286, 69, 111, + 191, 47, 194, 60, 160, 52, 52, 52, 71, 90, + 127, 255, 256, 199, 243, 46, 272, 281, 60, 52, + 191, 52, 60, 104, 127, 128, 161, 162, 164, 196, + 236, 238, 241, 242, 266, 267, 281, 281, 281, 59, + 59, 75, 126, 254, 256, 78, 248, 53, 45, 272, + 60, 135, 91, 124, 165, 166, 46, 196, 47, 53, + 53, 53, 46, 46, 79, 72, 93, 99, 110, 111, + 125, 47, 243, 33, 34, 43, 47, 52, 54, 66, + 67, 68, 77, 81, 112, 113, 123, 148, 197, 199, + 249, 250, 283, 284, 60, 53, 53, 52, 60, 163, + 124, 124, 124, 259, 257, 59, 59, 281, 281, 281, + 196, 281, 281, 58, 123, 52, 277, 55, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 44, 50, 51, 52, 57, + 62, 277, 285, 60, 60, 275, 160, 60, 60, 60, + 47, 127, 260, 47, 258, 281, 46, 269, 53, 53, + 124, 272, 244, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 50, 272, 281, 281, 213, 281, 53, 47, + 148, 261, 276, 55, 52, 63, 77, 169, 170, 173, + 262, 263, 281, 60, 281, 53, 45, 55, 281, 53, + 55, 286, 46, 60, 52, 124, 63, 77, 172, 173, + 281, 55, 47, 262, 64, 65, 281, 281, 52, 167, + 272, 127, 53, 56, 64, 65, 261, 281, 281, 45, + 272, 47, 168, 169, 53, 60, 171, 173, 281, 281, + 127, 53, 55, 53, 56, 60, 124, 173, 60 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ @@ -1901,51 +1943,53 @@ static const yytype_int16 yyr1[] = 122, 122, 122, 122, 122, 122, 122, 123, 123, 123, 123, 123, 123, 123, 124, 124, 125, 125, 125, 125, 125, 126, 126, 127, 127, 128, 128, 129, 129, 129, - 129, 129, 130, 130, 130, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 132, 132, 133, 134, 134, 135, 135, 136, 136, - 137, 137, 137, 137, 139, 140, 138, 141, 141, 141, - 141, 142, 143, 143, 144, 144, 145, 145, 146, 148, - 149, 147, 150, 150, 151, 151, 151, 151, 153, 154, - 152, 155, 155, 157, 156, 158, 158, 159, 159, 159, - 159, 159, 159, 159, 161, 160, 162, 162, 163, 163, - 164, 165, 165, 166, 167, 167, 168, 168, 169, 169, - 170, 170, 170, 170, 171, 171, 171, 171, 171, 172, - 172, 172, 173, 175, 176, 174, 177, 177, 178, 178, - 178, 178, 178, 179, 181, 182, 180, 180, 180, 183, - 183, 185, 184, 186, 186, 186, 187, 187, 187, 187, - 187, 188, 188, 189, 189, 190, 191, 192, 192, 193, - 194, 194, 194, 194, 194, 194, 194, 194, 194, 194, - 194, 195, 195, 195, 196, 196, 197, 198, 198, 199, - 199, 199, 199, 200, 200, 200, 201, 201, 201, 202, - 202, 203, 203, 203, 203, 203, 204, 204, 204, 204, - 206, 207, 205, 208, 210, 211, 209, 212, 212, 213, - 215, 214, 216, 214, 217, 217, 218, 219, 220, 221, - 221, 222, 222, 222, 222, 223, 223, 223, 224, 225, - 226, 226, 227, 227, 228, 229, 229, 229, 229, 229, - 229, 229, 229, 231, 230, 232, 232, 233, 234, 234, - 235, 235, 236, 236, 237, 237, 237, 237, 238, 239, - 239, 240, 240, 240, 240, 241, 241, 242, 243, 243, - 244, 244, 245, 246, 246, 247, 248, 248, 249, 250, - 250, 251, 252, 253, 253, 254, 254, 255, 255, 255, - 256, 256, 256, 257, 257, 259, 258, 260, 260, 260, - 260, 260, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 263, 263, 264, 264 + 129, 130, 130, 131, 131, 131, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 133, 133, 134, 135, 136, 135, 137, 137, + 138, 138, 139, 139, 139, 139, 141, 142, 140, 143, + 143, 143, 143, 144, 145, 145, 146, 146, 147, 147, + 148, 150, 151, 149, 152, 152, 153, 153, 153, 153, + 155, 156, 154, 157, 157, 159, 158, 160, 160, 161, + 161, 161, 161, 161, 161, 161, 163, 162, 164, 164, + 165, 165, 166, 167, 167, 168, 169, 169, 170, 170, + 171, 171, 172, 172, 172, 172, 173, 173, 173, 173, + 173, 174, 174, 174, 176, 177, 175, 179, 180, 178, + 181, 181, 182, 182, 182, 182, 182, 183, 185, 186, + 187, 188, 184, 184, 184, 189, 190, 190, 192, 191, + 193, 193, 194, 193, 195, 196, 196, 196, 196, 196, + 197, 197, 198, 198, 199, 200, 201, 201, 202, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 204, 204, 204, 205, 205, 207, 208, 206, 209, 209, + 210, 210, 210, 210, 211, 211, 211, 212, 212, 212, + 213, 213, 214, 214, 214, 214, 214, 215, 215, 215, + 215, 217, 218, 216, 220, 221, 219, 223, 224, 222, + 225, 225, 226, 228, 227, 229, 227, 230, 230, 231, + 232, 233, 234, 234, 235, 235, 235, 235, 236, 236, + 237, 237, 238, 239, 240, 240, 241, 241, 242, 243, + 243, 243, 243, 243, 243, 243, 243, 245, 244, 246, + 246, 247, 248, 248, 249, 249, 250, 250, 251, 251, + 251, 251, 253, 254, 252, 255, 255, 256, 256, 256, + 256, 257, 257, 258, 259, 259, 260, 261, 261, 262, + 263, 263, 265, 264, 266, 266, 267, 268, 268, 269, + 271, 270, 272, 272, 273, 273, 274, 274, 274, 275, + 275, 275, 276, 276, 278, 277, 279, 279, 279, 279, + 280, 280, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 282, 282, 282, 282, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 284, 284, 284, 284, 285, 285, 286, 286 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ @@ -1955,7 +1999,7 @@ static const yytype_int8 yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 2, 2, 5, 5, - 5, 4, 0, 4, 2, 1, 1, 1, 1, 1, + 4, 1, 1, 0, 4, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -1964,42 +2008,44 @@ static const yytype_int8 yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 3, 3, 0, 1, 1, 3, 4, 6, - 1, 1, 1, 0, 0, 0, 9, 7, 6, 9, - 8, 3, 0, 2, 1, 1, 0, 3, 1, 0, - 0, 8, 0, 2, 1, 1, 1, 1, 0, 0, - 9, 1, 2, 0, 8, 0, 2, 1, 1, 1, - 1, 1, 1, 1, 0, 5, 0, 2, 2, 1, - 7, 0, 2, 4, 1, 1, 5, 3, 1, 3, - 3, 3, 1, 1, 1, 3, 3, 1, 1, 10, - 10, 10, 7, 0, 0, 9, 0, 2, 1, 1, - 1, 1, 1, 1, 0, 0, 9, 4, 4, 0, - 2, 0, 7, 3, 4, 6, 1, 1, 1, 1, - 1, 1, 1, 1, 2, 1, 4, 4, 4, 4, - 1, 1, 1, 1, 1, 4, 4, 4, 6, 6, - 6, 1, 1, 1, 0, 1, 3, 1, 3, 1, - 1, 1, 1, 0, 1, 3, 1, 1, 1, 1, - 3, 1, 2, 2, 2, 2, 1, 1, 1, 1, - 0, 0, 9, 7, 0, 0, 9, 0, 2, 4, - 0, 7, 0, 8, 1, 3, 3, 4, 4, 1, - 3, 4, 4, 4, 4, 5, 8, 4, 1, 2, - 2, 3, 5, 7, 7, 1, 1, 1, 1, 1, - 1, 1, 1, 0, 5, 0, 2, 7, 0, 2, - 3, 2, 1, 1, 1, 1, 1, 1, 6, 1, - 2, 5, 5, 7, 6, 0, 2, 5, 0, 4, - 1, 4, 5, 1, 2, 7, 5, 4, 7, 0, - 2, 1, 2, 0, 1, 1, 3, 1, 3, 1, - 0, 1, 3, 1, 2, 0, 3, 1, 1, 2, - 4, 6, 1, 1, 1, 1, 1, 1, 2, 4, + 1, 1, 1, 3, 3, 0, 0, 2, 1, 3, + 4, 6, 1, 1, 1, 0, 0, 0, 9, 7, + 6, 9, 8, 3, 0, 2, 1, 1, 0, 3, + 1, 0, 0, 8, 0, 2, 1, 1, 1, 1, + 0, 0, 9, 1, 2, 0, 8, 0, 2, 1, + 1, 1, 1, 1, 1, 1, 0, 5, 0, 2, + 2, 1, 7, 0, 2, 4, 1, 1, 5, 3, + 1, 3, 3, 3, 1, 1, 1, 3, 3, 1, + 1, 10, 10, 10, 0, 0, 9, 0, 0, 9, + 0, 2, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 11, 1, 4, 4, 0, 2, 0, 7, + 3, 4, 0, 2, 6, 1, 1, 1, 1, 1, + 1, 1, 1, 2, 1, 4, 4, 4, 4, 1, + 1, 1, 1, 1, 4, 4, 4, 6, 6, 6, + 1, 1, 1, 0, 1, 0, 0, 5, 1, 3, + 1, 1, 1, 1, 0, 1, 3, 1, 1, 1, + 1, 3, 1, 2, 2, 2, 2, 1, 1, 1, + 1, 0, 0, 9, 0, 0, 9, 0, 0, 9, + 0, 2, 4, 0, 7, 0, 8, 1, 3, 3, + 4, 4, 1, 3, 4, 4, 4, 4, 1, 4, + 5, 8, 1, 2, 2, 3, 5, 7, 7, 1, + 1, 1, 1, 1, 1, 1, 1, 0, 5, 0, + 2, 7, 0, 2, 3, 2, 1, 1, 1, 1, + 1, 1, 0, 0, 8, 1, 2, 5, 5, 7, + 6, 0, 2, 5, 0, 2, 3, 1, 4, 5, + 1, 2, 0, 8, 5, 4, 7, 0, 2, 1, + 0, 3, 0, 1, 1, 3, 1, 3, 1, 0, + 1, 3, 1, 2, 0, 3, 1, 1, 2, 2, + 3, 5, 1, 1, 1, 1, 1, 1, 2, 4, 6, 3, 3, 3, 2, 2, 2, 2, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 5, 7, 4, 4, 4, 1, 1, 1, - 1, 1, 1, 2, 4, 6, 3, 2, 2, 2, - 2, 2, 3, 2, 3, 3, 3, 3, 3, 3, - 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 5, 7, 4, 4, 4, - 1, 1, 1, 1 + 3, 3, 5, 4, 1, 0, 7, 4, 4, 1, + 1, 1, 1, 1, 1, 2, 4, 6, 3, 2, + 2, 2, 2, 2, 3, 2, 3, 3, 3, 3, + 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 5, 4, 1, + 0, 7, 4, 4, 1, 1, 1, 1 }; @@ -2694,7 +2740,7 @@ yyreduce: YY_REDUCE_PRINT (yyn); switch (yyn) { -#line 5670 "p4parser.tab.c" +#line 5801 "p4parser.tab.c" default: break; } @@ -2926,4 +2972,4 @@ yyreturn: #endif return yyresult; } -#line 1274 "p4parser.y" +#line 1305 "p4parser.y" diff --git a/src/superc/p4parser/p4parser.tab.c b/src/superc/p4parser/p4parser.tab.c index f6efa8f6..55e174eb 100644 --- a/src/superc/p4parser/p4parser.tab.c +++ b/src/superc/p4parser/p4parser.tab.c @@ -630,16 +630,16 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 4 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 3954 +#define YYLAST 4072 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 118 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 147 +#define YYNNTS 169 /* YYNRULES -- Number of rules. */ -#define YYNRULES 483 +#define YYNRULES 507 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 888 +#define YYNSTATES 909 #define YYUNDEFTOK 2 #define YYMAXUTOK 372 @@ -702,51 +702,53 @@ static const yytype_int16 yyrline[] = 257, 258, 259, 260, 261, 262, 263, 267, 268, 269, 270, 271, 272, 273, 277, 278, 282, 283, 284, 285, 286, 290, 291, 295, 296, 300, 301, 305, 307, 309, - 311, 315, 320, 321, 323, 328, 329, 330, 331, 332, - 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 375, 376, 377, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 418, 419, 423, 427, 428, 432, 433, 437, 438, - 442, 443, 444, 445, 449, 450, 449, 458, 460, 463, - 466, 472, 477, 478, 482, 483, 487, 488, 492, 498, - 499, 498, 505, 506, 510, 511, 512, 513, 518, 519, - 517, 527, 528, 532, 532, 538, 539, 543, 544, 545, - 546, 547, 548, 549, 553, 553, 558, 559, 563, 564, - 568, 573, 574, 578, 583, 584, 588, 590, 594, 595, - 600, 601, 602, 603, 607, 608, 609, 610, 611, 615, - 618, 621, 629, 636, 637, 635, 645, 646, 650, 651, - 652, 653, 654, 658, 665, 669, 664, 671, 672, 676, - 677, 682, 681, 687, 688, 689, 696, 697, 698, 699, - 700, 704, 705, 709, 710, 714, 718, 722, 723, 727, - 731, 732, 733, 734, 735, 736, 738, 740, 743, 745, - 747, 752, 753, 754, 759, 760, 764, 768, 775, 781, - 782, 784, 785, 789, 790, 791, 795, 796, 797, 803, - 804, 808, 809, 810, 811, 812, 816, 817, 818, 819, - 823, 823, 823, 832, 841, 841, 841, 849, 850, 854, - 859, 858, 864, 864, 872, 873, 877, 881, 886, 892, - 893, 897, 901, 905, 909, 919, 922, 925, 931, 935, - 939, 940, 944, 946, 952, 956, 957, 958, 959, 960, - 961, 962, 963, 967, 967, 972, 973, 977, 981, 982, - 986, 987, 991, 992, 996, 997, 998, 999, 1005, 1011, - 1012, 1016, 1018, 1020, 1022, 1027, 1028, 1032, 1037, 1038, - 1043, 1045, 1050, 1055, 1056, 1062, 1071, 1075, 1082, 1087, - 1088, 1092, 1098, 1102, 1103, 1107, 1108, 1112, 1113, 1114, - 1118, 1119, 1120, 1124, 1125, 1129, 1129, 1133, 1134, 1135, - 1136, 1137, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, - 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1159, - 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, - 1172, 1173, 1174, 1176, 1178, 1179, 1180, 1181, 1182, 1183, - 1184, 1185, 1186, 1187, 1189, 1191, 1193, 1197, 1198, 1199, - 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, - 1210, 1211, 1213, 1215, 1216, 1217, 1218, 1219, 1220, 1221, - 1222, 1223, 1224, 1226, 1227, 1228, 1230, 1231, 1232, 1233, - 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1242, 1244, 1246, - 1269, 1269, 1270, 1270 + 313, 317, 318, 322, 323, 325, 330, 331, 332, 333, + 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 420, 421, 425, 429, 430, 430, 434, 435, + 439, 440, 444, 445, 446, 447, 451, 452, 451, 460, + 462, 464, 466, 471, 476, 477, 481, 482, 486, 487, + 491, 498, 498, 497, 504, 505, 509, 510, 511, 512, + 517, 518, 516, 526, 527, 531, 531, 537, 538, 542, + 543, 544, 545, 546, 547, 548, 552, 552, 557, 558, + 562, 563, 567, 572, 573, 577, 582, 583, 587, 589, + 593, 594, 599, 600, 601, 602, 606, 607, 608, 609, + 610, 614, 617, 620, 629, 631, 628, 637, 638, 636, + 646, 647, 651, 652, 653, 654, 655, 659, 666, 670, + 671, 671, 665, 672, 673, 677, 681, 682, 687, 686, + 692, 693, 694, 694, 699, 705, 706, 707, 708, 709, + 713, 714, 718, 719, 723, 727, 731, 732, 736, 740, + 741, 742, 743, 744, 745, 747, 749, 752, 754, 756, + 761, 762, 763, 768, 769, 773, 773, 773, 777, 784, + 790, 791, 793, 794, 798, 799, 800, 804, 805, 806, + 812, 813, 817, 818, 819, 820, 821, 825, 826, 827, + 828, 833, 834, 832, 844, 846, 843, 855, 857, 854, + 864, 865, 869, 874, 873, 879, 879, 887, 888, 892, + 896, 901, 907, 908, 912, 916, 920, 924, 934, 936, + 941, 943, 948, 952, 956, 957, 961, 963, 969, 973, + 974, 975, 976, 977, 978, 979, 980, 984, 984, 989, + 990, 994, 998, 999, 1003, 1004, 1008, 1009, 1013, 1014, + 1015, 1016, 1023, 1023, 1022, 1028, 1029, 1033, 1035, 1037, + 1039, 1044, 1045, 1049, 1054, 1055, 1060, 1064, 1066, 1071, + 1076, 1077, 1083, 1083, 1093, 1097, 1104, 1109, 1110, 1114, + 1120, 1120, 1124, 1125, 1129, 1130, 1134, 1135, 1136, 1140, + 1141, 1142, 1146, 1147, 1151, 1151, 1155, 1156, 1157, 1158, + 1162, 1163, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, + 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1184, + 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, + 1197, 1198, 1199, 1201, 1203, 1204, 1205, 1206, 1207, 1208, + 1209, 1210, 1211, 1212, 1213, 1215, 1216, 1218, 1220, 1225, + 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, + 1236, 1237, 1238, 1239, 1241, 1243, 1244, 1245, 1246, 1247, + 1248, 1249, 1250, 1251, 1252, 1254, 1255, 1256, 1258, 1259, + 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, + 1271, 1272, 1274, 1276, 1300, 1300, 1301, 1301 }; #endif @@ -779,42 +781,48 @@ static const char *const yytname[] = "FLOATING_CONSTANT", "PPNUM", "PREFIX", "THEN", "$accept", "start", "program", "input", "declaration", "nonTypeName", "name", "nonTableKwName", "optCONST", "optAnnotations", "annotations", - "annotation", "annotationBody", "annotationToken", "kvList", "kvPair", - "parameterList", "nonEmptyParameterList", "parameter", "direction", - "packageTypeDeclaration", "$@1", "$@2", "instantiation", + "annotation", "structuredAnnotationBody", "annotationBody", + "annotationToken", "kvList", "kvPair", "parameterList", "$@1", + "nonEmptyParameterList", "parameter", "direction", + "packageTypeDeclaration", "$@2", "$@3", "instantiation", "objInitializer", "objDeclarations", "objDeclaration", - "optConstructorParameters", "dotPrefix", "parserDeclaration", "$@3", - "$@4", "parserLocalElements", "parserLocalElement", - "parserTypeDeclaration", "$@5", "$@6", "parserStates", "parserState", - "$@7", "parserStatements", "parserStatement", "parserBlockStatement", - "$@8", "transitionStatement", "stateExpression", "selectExpression", + "optConstructorParameters", "dotPrefix", "parserDeclaration", "$@4", + "$@5", "parserLocalElements", "parserLocalElement", + "parserTypeDeclaration", "$@6", "$@7", "parserStates", "parserState", + "$@8", "parserStatements", "parserStatement", "parserBlockStatement", + "$@9", "transitionStatement", "stateExpression", "selectExpression", "selectCaseList", "selectCase", "keysetExpression", "tupleKeysetExpression", "simpleExpressionList", "reducedSimpleKeysetExpression", "simpleKeysetExpression", - "valueSetDeclaration", "controlDeclaration", "controlTypeDeclaration", - "$@9", "$@10", "controlLocalDeclarations", "controlLocalDeclaration", - "controlBody", "externDeclaration", "$@11", "$@12", "methodPrototypes", - "functionPrototype", "$@13", "methodPrototype", "typeRef", "namedType", - "prefixedType", "typeName", "tupleType", "headerStackType", - "specializedType", "baseType", "typeOrVoid", "optTypeParameters", - "typeParameters", "typeParameterList", "typeArg", "typeArgumentList", + "valueSetDeclaration", "controlDeclaration", "$@10", "$@11", + "controlTypeDeclaration", "$@12", "$@13", "controlLocalDeclarations", + "controlLocalDeclaration", "controlBody", "externDeclaration", "$@14", + "$@15", "$@16", "$@17", "externFunctionDeclaration", "methodPrototypes", + "functionPrototype", "$@18", "methodPrototype", "$@19", + "constructorMethodPrototype", "typeRef", "namedType", "prefixedType", + "typeName", "tupleType", "headerStackType", "specializedType", + "baseType", "typeOrVoid", "optTypeParameters", "typeParameters", "$@20", + "$@21", "typeParameterList", "typeArg", "typeArgumentList", "realTypeArg", "realTypeArgumentList", "typeDeclaration", - "derivedTypeDeclaration", "headerTypeDeclaration", "$@14", "$@15", - "structTypeDeclaration", "headerUnionDeclaration", "$@16", "$@17", - "structFieldList", "structField", "enumDeclaration", "$@18", "$@19", - "specifiedIdentifierList", "specifiedIdentifier", "errorDeclaration", - "matchKindDeclaration", "identifierList", "typedefDeclaration", - "assignmentOrMethodCallStatement", "emptyStatement", "exitStatement", + "derivedTypeDeclaration", "headerTypeDeclaration", "$@22", "$@23", + "structTypeDeclaration", "$@24", "$@25", "headerUnionDeclaration", + "$@26", "$@27", "structFieldList", "structField", "enumDeclaration", + "$@28", "$@29", "specifiedIdentifierList", "specifiedIdentifier", + "errorDeclaration", "matchKindDeclaration", "identifierList", + "typedefDeclaration", "assignmentOrMethodCallStatement", + "methodCallStatements", "emptyStatement", "exitStatement", "returnStatement", "conditionalStatement", "directApplication", - "statement", "blockStatement", "$@20", "statOrDeclList", + "statement", "blockStatement", "$@30", "statOrDeclList", "switchStatement", "switchCases", "switchCase", "switchLabel", - "statementOrDeclaration", "tableDeclaration", "tablePropertyList", - "tableProperty", "keyElementList", "keyElement", "actionList", - "actionRef", "entry", "entriesList", "actionDeclaration", - "variableDeclaration", "constantDeclaration", "optInitializer", - "initializer", "functionDeclaration", "argumentList", "nonEmptyArgList", - "argument", "expressionList", "prefixedNonTypeName", "dot_name", "$@21", - "lvalue", "expression", "nonBraceExpression", "l_angle", "r_angle", YY_NULLPTR + "statementOrDeclaration", "tableDeclaration", "$@31", "$@32", + "tablePropertyList", "tableProperty", "keyElementList", "keyElement", + "actionList", "action", "actionRef", "entry", "entriesList", + "actionDeclaration", "$@33", "variableDeclaration", + "constantDeclaration", "optInitializer", "initializer", + "functionDeclaration", "$@34", "argumentList", "nonEmptyArgList", + "argument", "expressionList", "prefixedNonTypeName", "dot_name", "$@35", + "lvalue", "lvalueExpression", "expression", "invokingExpression", + "nonBraceExpression", "invokingNonBraceExpression", "l_angle", "r_angle", YY_NULLPTR }; #endif @@ -838,12 +846,12 @@ static const yytype_int16 yytoknum[] = }; # endif -#define YYPACT_NINF (-765) +#define YYPACT_NINF (-806) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-243) +#define YYTABLE_NINF (-400) #define yytable_value_is_error(Yyn) \ 0 @@ -852,95 +860,97 @@ static const yytype_int16 yytoknum[] = STATE-NUM. */ static const yytype_int16 yypact[] = { - -765, 30, -765, 511, -765, -765, -765, 423, -765, 125, - -14, 125, 14, 423, -765, 125, 125, -765, -765, -765, - -765, 797, 962, -765, -21, -765, -39, -765, 84, -765, - 136, -765, 43, 53, -765, 372, -765, -765, 72, -765, - 423, -765, -765, -765, -765, -765, -765, -765, -765, 50, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, 172, -765, -765, -27, 423, -18, 423, -765, - 2434, -16, 423, 374, 423, 2564, 2477, 423, 423, 962, - 423, 423, 423, 962, -765, -765, 71, -765, -765, 45, - -765, -765, -765, 86, 97, 43, -765, 2051, 2247, 2434, - 2247, 125, -765, 2296, -765, 2247, 196, -765, 61, 2247, - 196, 107, 1786, -765, -765, -765, -765, -765, 329, 2247, - 196, 126, 423, -765, 67, -765, 423, 227, 89, 100, - 149, -765, -765, -765, 133, 423, 423, -765, -765, 125, - 423, 423, 2051, 212, 173, 188, -765, 203, -765, -765, - 2247, 2247, 2247, 2296, 1348, 2247, -765, -765, -765, -765, - 193, -765, -765, 205, 229, 617, 243, -11, -765, 238, - 247, -765, 3655, -765, 2841, 329, 2878, -765, -765, 423, - 246, -3, -765, 0, 3655, 1878, 2915, -765, -765, -765, - -765, 423, 2952, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, 2434, -765, 2989, -765, 45, 252, - 125, 268, -765, 125, -765, -765, 125, 125, -765, -765, - 125, 125, 272, -765, -765, 276, -765, -765, -765, 374, - -765, 43, -765, 919, -765, 307, 307, 307, 159, 163, - 193, 279, 183, 241, 3026, 307, 423, 2247, -765, 2051, - -765, -765, 423, 2051, 2247, 2247, 2247, 2247, 2247, 2247, - 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, - 2247, 2247, 2247, 284, 2051, 2247, 2247, -765, 1074, -765, - -765, -765, 289, -765, 395, 2247, -765, 423, -765, 2247, - -765, 196, -765, 196, 1970, -765, 196, 290, 2247, -765, - 423, 309, -765, -765, -765, -765, -765, -765, 423, 423, - -765, 962, 43, -24, 962, -765, -765, 10, -765, -765, - -765, -765, 1141, -765, -765, 2247, -765, -765, 3655, 305, - 423, 294, -765, 3830, 3830, 1061, 3799, 3766, 1608, 1608, - 184, 184, 184, 184, 307, 307, 307, 3861, 1505, 3892, - 2730, 3830, 2247, 314, 3063, 184, -765, -765, -765, -765, - 402, 3830, 45, 423, -765, 3655, -765, 3655, -765, -765, - -765, -765, 43, 302, 3655, 318, 215, 423, 328, 330, - 338, 346, 349, -12, 327, 332, -44, -765, -765, 5, - -765, -765, -765, -765, 358, -765, 423, 66, 348, -765, - -765, -765, 357, 356, 2100, 367, -765, 32, -765, 617, - 234, -765, -765, -765, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, 381, 307, -765, -765, 377, -765, - -765, 2247, 1061, -765, 2247, 2434, 375, 378, -765, -765, - -765, 45, -765, 369, 242, -765, -765, -765, -765, 45, - 45, -765, 374, -765, 377, -765, 2247, 423, 125, 335, - 390, -765, -765, 396, 348, 2247, 384, -765, 2247, -765, - 3100, 2247, -765, 382, 2247, 2051, 2247, -765, 2434, -765, - 397, 3137, 3729, -765, 2051, -765, 388, 2247, -765, 423, - 64, 105, 106, 403, 408, 423, 406, 3655, -765, 374, - -765, -13, 413, -765, -765, 3174, -765, 3211, 424, 2767, - 422, 3248, 329, 854, -765, -765, 425, -765, -765, -765, - -765, 228, -765, -765, -765, -765, -765, 420, -765, 437, - 196, 196, 196, 427, 428, 414, 233, -765, -765, 2531, - 444, 2051, -765, 2247, 431, -765, 446, -765, 962, -765, - -765, -765, -765, 156, 447, 436, -765, -765, 449, 451, - 452, 461, 463, -765, 69, -765, -765, 454, 432, -765, - 462, 3285, -765, 2051, 457, 45, -765, 2343, 2247, 2247, - 2247, -765, -765, -765, 464, -765, -765, -765, -765, 466, - 2531, 2149, 468, -765, 478, -765, 484, 278, 76, 962, - -765, -765, 491, 423, -765, -765, -765, -765, -765, -765, - 3322, 3359, 3396, 108, 2198, 495, 2247, -765, 2247, 2247, - 2247, -765, 1348, 2247, -765, -765, -765, -765, 486, -765, - -765, -765, 617, 490, -11, -765, 492, 3692, -765, 485, - 489, 500, 493, -765, -765, -765, 423, -765, 423, 423, - 423, -765, 273, -765, -765, 3433, 1527, 494, 307, 307, - 307, 502, 3470, 307, 423, -765, 2051, -765, -17, 2247, - 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, - 2247, 2247, 2247, 2247, 2247, 2247, 2247, 2247, 513, 2051, - 2247, 2247, -765, 1074, -765, -765, 2247, -765, -765, 504, - 505, 506, 689, 507, 518, 423, 1258, -765, -765, 520, - -765, -765, -765, 738, 2690, -765, 2247, -765, -765, 523, - -765, 3830, 3830, 1061, 3799, 3766, 1608, 1608, 184, 184, - 184, 184, 307, 307, 307, 3861, 1505, 3892, 2804, 3830, - 2247, 524, 3507, 184, 402, 3830, 1, 2391, -765, -765, - -765, -765, 2051, 43, 517, 525, 529, 527, 2650, 273, - -765, -765, 2247, 2247, 307, -765, -765, 2247, 1061, -765, - 2247, 534, 541, -765, 535, 530, -765, 1684, 2247, 2247, - 43, 3655, 3655, 3544, 3729, 2051, -765, -765, -765, 94, - -765, 3581, 3618, 531, -765, 543, 1435, -765, 1684, -765, - -765, -765, -765, 542, -765, 423, 538, -765 + -806, 31, -806, 198, -806, -806, -806, 546, -806, 10, + 61, 10, 75, 546, -806, 10, 10, -806, -806, -806, + -806, 901, 785, -806, 67, -806, 33, -806, 169, -806, + 194, -806, -806, -806, 113, -806, 253, -806, -806, 145, + -806, 546, -806, -806, -806, -806, -806, -806, -806, -806, + 146, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, 213, -806, -806, -28, 546, -27, 546, + -806, 2551, -25, 546, 483, 546, 2681, 2594, 546, 546, + 785, 546, 546, 546, 785, -806, -806, 168, -806, -806, + 182, -806, 218, -806, 227, -13, 1917, 2413, 2551, 2413, + 10, -806, 1966, -806, 2413, 190, -806, -6, 2413, 190, + 94, 1652, -806, -806, -806, -806, -806, 154, 2413, 190, + 215, 546, -806, 109, -806, 546, 214, 210, 217, 223, + -806, 10, 10, 143, -13, 546, 546, -806, -806, 10, + 546, 546, 1917, 238, -13, -806, -806, 247, -806, 2413, + 2413, 2413, 2015, 975, 2413, -806, -806, -806, -806, 242, + -806, -806, 245, 272, 639, 260, -12, -806, 290, 277, + -806, 3772, -806, -806, 2958, 154, 2995, -806, -806, -806, + 292, 307, 297, -806, 298, 3772, 1744, 3032, -806, -806, + -806, -806, 546, 3069, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, -806, 2551, -806, 3106, -806, 182, + 300, 10, 316, -806, 10, -806, -806, 318, 319, -806, + -806, 10, 10, 325, -806, -806, 320, -806, 96, 321, + -806, -806, -806, -806, 262, 262, 262, 95, 130, 242, + 323, 3, 224, 3143, 262, 546, 2413, -806, 1917, -806, + -806, 546, 2217, 2413, 2413, 2413, 2413, 2413, 2413, 2413, + 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, + 2413, 2413, 339, 1917, 2413, 2413, -806, 1143, -806, -806, + -806, 338, 546, 2413, -806, 546, 2413, -806, 190, -806, + 190, 1836, -806, 190, 348, 2413, -806, 546, 345, -806, + -806, -806, -806, -806, -806, 546, -806, -806, -806, 483, + -13, 785, 314, -806, -806, -806, 2413, -806, -806, 3772, + 354, 546, 221, -806, 1129, 1129, 4010, 3916, 3883, 3949, + 3949, 187, 187, 187, 187, 262, 262, 262, 1477, 3980, + 1536, 2847, 1129, 2413, 355, 3180, 187, -806, -806, -806, + -806, 276, 1129, 182, -806, 353, 3772, -806, 3772, -806, + -806, -806, -806, -806, 350, 3772, 360, 140, 546, 367, + -806, -806, 364, 366, -806, 280, 546, -806, -18, 785, + -806, -806, -5, -806, -806, 270, -806, -806, -13, -21, + -806, -806, -806, -806, -806, -806, 1532, 262, -806, -806, + 369, -806, -806, 2413, 4010, -806, 2413, 2551, 371, 373, + 546, 190, -13, -806, 182, -806, 365, 161, -806, -806, + 6, 16, 182, 182, 18, 369, -806, 368, 546, 10, + 459, 330, 383, -806, 374, -806, -806, 546, -806, -806, + -806, 372, 384, 2266, 386, -806, 47, -806, 639, 335, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -806, 286, -806, 375, 3217, 3846, -806, + 1917, -806, -806, -806, -806, 389, 2413, -806, 546, -806, + 483, 398, -806, 399, 395, 397, 404, 392, 2413, -806, + 483, 374, -806, 2413, 393, 407, 409, -806, 2413, -806, + 3254, 2413, -806, 385, 2413, 1917, 2413, -806, -806, 2551, + 858, -806, -806, 403, -806, -806, -806, 65, 546, -806, + -806, -806, -806, -806, -806, 3772, 414, 190, 190, 190, + 405, -806, -806, -806, -806, 3291, -806, 3328, 411, 2884, + 415, 3365, 154, -806, 785, -806, -806, -806, -806, 612, + 417, -806, -806, 410, -806, 419, 420, 421, -806, 110, + 2648, 429, 1917, -806, 2413, 418, -806, 425, 714, 427, + 426, -806, -806, -806, 2460, 2413, 2413, 2413, 408, 428, + 413, 26, -806, 431, 416, -806, 432, 3402, -806, 1917, + 437, 182, -806, 257, 62, 785, -806, -806, 444, 546, + -806, -806, -806, -806, -806, -806, 3439, 3476, 3513, 446, + 456, 433, 37, 457, -806, 2648, 2315, 445, -806, 454, + -806, 460, 465, 462, -806, -806, -806, 546, -806, 546, + 546, 546, -806, -806, 466, -806, -806, -806, -806, -806, + 467, -806, -806, 2413, 2413, 2413, -806, 975, 2413, -806, + -806, -806, -806, 461, -806, -806, -806, 639, 475, -12, + -806, 473, 3809, -806, -806, 469, 472, 2064, -806, -806, + 476, 477, 479, 70, 2364, 494, 2413, 262, 262, 262, + 489, 3550, 262, 546, -806, 1917, -806, -17, 2413, 2413, + 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, 2413, + 2413, 2413, 2413, 2413, 2413, 2413, 2413, 496, 1917, 2413, + 2413, -806, 1143, -806, -806, 49, 2508, -806, -806, -806, + -806, 53, -806, -806, -806, 3587, 2115, 487, 2413, -806, + -806, 491, -806, 1129, 1129, 4010, 3916, 3883, 3949, 3949, + 187, 187, 187, 187, 262, 262, 262, 1477, 3980, 1536, + 2921, 1129, 2413, 502, 3624, 187, 276, 1129, 513, -806, + 176, 500, 509, 546, 1224, -806, -806, 508, -806, -806, + -806, 1312, 2807, -806, 262, -806, -806, 2413, 4010, -806, + 2413, 514, -806, -806, 1917, -13, 511, 512, 518, 519, + 2767, 53, -806, -806, 2413, 2413, 3661, 3846, 1917, 1383, + 521, 525, -806, 2166, 2413, 2413, -13, 3772, 3772, -806, + 526, -806, -806, 531, -806, -806, 163, -806, 3698, 3735, + 529, -806, 546, -806, 2166, -806, 532, -806, -806 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -948,135 +958,141 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_int16 yydefact[] = { - 4, 0, 2, 33, 1, 158, 6, 0, 250, 252, - 251, 254, 0, 0, 253, 0, 0, 262, 263, 243, - 5, 0, 34, 35, 0, 13, 0, 10, 156, 12, - 156, 8, 33, 261, 245, 237, 240, 239, 238, 236, - 0, 11, 281, 286, 288, 287, 289, 14, 15, 0, - 9, 7, 16, 20, 18, 22, 19, 23, 21, 17, - 25, 24, 37, 480, 481, 0, 0, 0, 0, 42, - 273, 0, 0, 0, 0, 0, 0, 0, 0, 33, - 0, 0, 0, 33, 251, 36, 0, 285, 244, 33, - 283, 159, 284, 0, 0, 34, 372, 373, 0, 273, - 0, 264, 282, 380, 42, 0, 0, 309, 0, 0, - 0, 0, 0, 272, 271, 270, 269, 274, 0, 0, - 0, 0, 0, 213, 243, 300, 0, 263, 224, 0, - 0, 261, 290, 294, 0, 0, 0, 144, 168, 264, - 0, 0, 373, 143, 0, 135, 136, 0, 216, 333, - 0, 0, 0, 380, 0, 0, 379, 394, 395, 396, - 0, 393, 392, 397, 0, 0, 0, 241, 242, 0, - 374, 375, 377, 397, 0, 0, 0, 231, 265, 0, - 0, 0, 131, 0, 381, 0, 0, 482, 483, 255, - 307, 0, 0, 256, 308, 45, 41, 104, 103, 99, - 100, 102, 101, 106, 108, 107, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 95, - 122, 96, 42, 123, 124, 130, 125, 126, 127, 128, - 129, 105, 90, 98, 97, 84, 61, 82, 46, 47, + 4, 0, 2, 33, 1, 160, 6, 0, 259, 261, + 260, 263, 0, 0, 262, 0, 0, 271, 272, 252, + 5, 0, 34, 35, 0, 13, 0, 10, 158, 12, + 158, 8, 233, 390, 270, 254, 246, 249, 248, 247, + 245, 0, 11, 292, 297, 299, 298, 300, 14, 15, + 0, 9, 7, 16, 20, 18, 22, 19, 23, 21, + 17, 25, 24, 37, 504, 505, 0, 0, 0, 0, + 43, 284, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 33, 260, 36, 0, 296, 253, + 136, 294, 0, 295, 0, 33, 455, 455, 284, 455, + 273, 293, 455, 43, 455, 0, 322, 0, 455, 0, + 0, 0, 283, 282, 281, 280, 285, 0, 455, 0, + 0, 0, 217, 252, 313, 0, 272, 228, 0, 0, + 270, 273, 273, 0, 34, 0, 0, 146, 170, 273, + 0, 0, 455, 0, 33, 161, 214, 0, 391, 455, + 455, 455, 455, 455, 455, 398, 414, 415, 416, 0, + 413, 412, 417, 0, 0, 0, 250, 251, 0, 393, + 394, 396, 454, 417, 0, 0, 0, 238, 274, 275, + 0, 0, 42, 132, 41, 400, 0, 0, 506, 507, + 264, 320, 0, 0, 265, 321, 46, 40, 105, 104, + 100, 101, 103, 102, 107, 109, 108, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 96, 123, 97, 43, 124, 125, 131, 126, 127, 128, + 129, 130, 106, 91, 99, 98, 85, 62, 83, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 62, 63, 64, 65, 66, 67, 68, - 76, 69, 70, 71, 73, 72, 74, 75, 77, 78, - 79, 80, 81, 83, 85, 86, 87, 88, 89, 91, - 92, 93, 94, 44, 0, 246, 0, 257, 33, 0, - 264, 0, 302, 264, 228, 227, 264, 264, 313, 314, - 264, 264, 0, 311, 312, 0, 140, 142, 141, 0, - 157, 33, 162, 33, 335, 407, 406, 405, 0, 0, - 251, 0, 237, 238, 0, 404, 0, 0, 398, 373, - 385, 408, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 373, 0, 0, 410, 0, 247, - 249, 248, 0, 267, 0, 0, 40, 0, 39, 0, - 38, 0, 310, 0, 0, 275, 0, 0, 0, 214, - 0, 0, 225, 291, 295, 145, 169, 297, 0, 0, - 137, 33, 33, 0, 34, 221, 217, 0, 220, 219, - 222, 218, 33, 402, 401, 0, 403, 409, 378, 0, - 0, 0, 376, 420, 421, 418, 430, 431, 424, 425, - 414, 415, 416, 417, 411, 412, 413, 428, 426, 427, - 0, 423, 0, 0, 0, 429, 278, 277, 276, 279, - 0, 422, 33, 0, 266, 133, 132, 382, 258, 259, - 43, 260, 33, 0, 371, 0, 0, 0, 0, 0, - 0, 0, 0, 33, 0, 138, 0, 165, 163, 33, - 171, 167, 166, 164, 0, 223, 0, 0, 369, 334, - 318, 388, 0, 0, 0, 0, 383, 0, 347, 0, - 237, 325, 328, 331, 330, 327, 326, 346, 329, 332, - 336, 344, 345, 387, 0, 436, 435, 386, 0, 148, - 399, 0, 419, 434, 0, 0, 0, 0, 268, 365, - 368, 33, 301, 0, 0, 304, 229, 297, 297, 33, - 33, 293, 0, 298, 0, 147, 0, 0, 0, 0, - 0, 172, 212, 0, 369, 0, 0, 319, 0, 320, - 0, 0, 384, 0, 0, 373, 0, 389, 273, 152, - 0, 0, 432, 280, 373, 232, 0, 0, 303, 0, - 33, 33, 33, 0, 0, 0, 0, 139, 173, 0, - 161, 33, 0, 370, 367, 0, 321, 0, 0, 0, - 0, 0, 0, 0, 150, 400, 0, 215, 306, 305, - 226, 0, 230, 292, 296, 146, 170, 0, 149, 0, - 0, 0, 0, 0, 0, 31, 33, 349, 366, 33, - 0, 373, 390, 0, 0, 317, 0, 151, 0, 155, - 153, 154, 433, 0, 243, 0, 299, 175, 0, 0, - 0, 0, 0, 32, 0, 348, 350, 0, 322, 338, - 0, 0, 315, 373, 0, 33, 233, 33, 0, 0, - 0, 358, 355, 28, 0, 30, 29, 26, 27, 0, - 33, 0, 0, 391, 0, 234, 0, 0, 0, 34, - 176, 182, 0, 0, 177, 179, 183, 178, 180, 181, - 0, 0, 0, 33, 0, 0, 0, 323, 0, 0, - 0, 337, 0, 0, 439, 440, 441, 342, 0, 438, - 437, 442, 0, 0, 241, 339, 0, 343, 324, 0, - 0, 0, 0, 187, 189, 184, 0, 174, 0, 0, - 0, 352, 0, 351, 356, 0, 0, 0, 450, 449, - 448, 0, 0, 447, 0, 443, 373, 451, 341, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 373, - 0, 0, 453, 0, 316, 235, 380, 188, 175, 0, - 0, 0, 0, 0, 360, 0, 0, 208, 207, 0, - 194, 195, 363, 0, 204, 354, 0, 446, 452, 0, - 340, 463, 464, 461, 473, 474, 467, 468, 457, 458, - 459, 460, 454, 455, 456, 471, 469, 470, 0, 466, - 0, 0, 0, 472, 0, 465, 0, 33, 211, 210, - 209, 359, 373, 33, 203, 202, 0, 0, 204, 0, - 353, 364, 0, 0, 479, 478, 444, 0, 462, 477, - 0, 0, 0, 185, 0, 0, 197, 0, 0, 0, - 33, 205, 206, 0, 475, 373, 191, 361, 357, 0, - 198, 200, 201, 0, 445, 0, 0, 196, 0, 362, - 476, 190, 192, 0, 199, 0, 0, 193 + 58, 59, 60, 61, 63, 64, 65, 66, 67, 68, + 69, 77, 70, 71, 72, 74, 73, 75, 76, 78, + 79, 80, 81, 82, 84, 86, 87, 88, 89, 90, + 92, 93, 94, 95, 45, 0, 255, 0, 266, 136, + 0, 273, 0, 315, 273, 234, 235, 0, 0, 326, + 327, 273, 273, 0, 324, 325, 0, 159, 145, 137, + 138, 164, 220, 347, 427, 426, 425, 0, 0, 260, + 0, 246, 247, 0, 424, 0, 455, 418, 455, 404, + 428, 0, 455, 455, 455, 455, 455, 455, 455, 455, + 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, + 455, 455, 0, 455, 455, 455, 430, 455, 256, 258, + 257, 0, 0, 455, 39, 0, 455, 38, 0, 323, + 0, 0, 286, 0, 0, 455, 218, 0, 0, 229, + 301, 307, 147, 171, 304, 0, 142, 144, 143, 0, + 33, 33, 33, 349, 422, 421, 455, 423, 429, 397, + 0, 0, 0, 395, 440, 441, 438, 450, 451, 444, + 445, 434, 435, 436, 437, 431, 432, 433, 448, 446, + 447, 0, 443, 455, 0, 0, 449, 289, 288, 287, + 290, 0, 442, 136, 278, 276, 134, 133, 401, 267, + 268, 44, 269, 382, 0, 389, 0, 0, 0, 0, + 310, 310, 0, 0, 310, 0, 0, 139, 0, 34, + 167, 165, 33, 173, 169, 0, 168, 166, 33, 0, + 225, 221, 224, 223, 226, 222, 33, 453, 458, 405, + 0, 150, 419, 455, 439, 457, 455, 0, 0, 0, + 0, 0, 33, 386, 136, 314, 0, 0, 317, 230, + 33, 33, 136, 136, 33, 0, 149, 140, 0, 0, + 0, 0, 0, 174, 387, 215, 227, 0, 348, 332, + 407, 0, 0, 455, 0, 402, 0, 361, 0, 246, + 339, 328, 342, 345, 344, 341, 340, 360, 343, 346, + 350, 358, 359, 406, 0, 154, 0, 0, 452, 291, + 455, 239, 279, 277, 383, 0, 455, 316, 0, 236, + 0, 0, 311, 0, 0, 0, 0, 0, 455, 175, + 0, 387, 163, 455, 0, 0, 0, 333, 455, 334, + 0, 455, 403, 0, 455, 455, 455, 408, 409, 284, + 0, 152, 420, 0, 219, 319, 318, 33, 0, 303, + 309, 148, 172, 306, 151, 141, 0, 0, 0, 0, + 0, 388, 385, 216, 362, 0, 335, 0, 0, 0, + 0, 0, 0, 153, 0, 157, 155, 156, 456, 0, + 0, 237, 242, 0, 177, 0, 0, 0, 384, 33, + 33, 0, 455, 410, 455, 0, 329, 0, 0, 252, + 0, 232, 243, 312, 33, 455, 455, 455, 0, 0, + 31, 33, 365, 0, 336, 352, 0, 0, 330, 455, + 0, 136, 240, 0, 0, 34, 178, 184, 0, 0, + 179, 181, 185, 180, 182, 183, 0, 0, 0, 0, + 0, 32, 0, 0, 366, 33, 500, 0, 411, 0, + 241, 0, 0, 0, 189, 191, 186, 0, 176, 0, + 0, 0, 374, 371, 0, 28, 30, 29, 26, 27, + 0, 364, 337, 455, 455, 455, 351, 455, 455, 461, + 462, 463, 356, 0, 460, 459, 464, 0, 0, 250, + 353, 0, 357, 499, 338, 0, 0, 455, 190, 177, + 0, 0, 0, 33, 455, 0, 455, 472, 471, 470, + 0, 0, 469, 0, 465, 455, 473, 355, 455, 455, + 455, 455, 455, 455, 455, 455, 455, 455, 455, 455, + 455, 455, 455, 455, 455, 455, 455, 0, 455, 455, + 455, 475, 455, 331, 244, 0, 33, 213, 212, 211, + 368, 0, 375, 367, 372, 0, 455, 0, 455, 468, + 474, 0, 354, 485, 486, 483, 495, 496, 489, 490, + 479, 480, 481, 482, 476, 477, 478, 493, 491, 492, + 0, 488, 455, 0, 0, 494, 0, 487, 0, 187, + 0, 0, 377, 0, 455, 210, 209, 0, 196, 197, + 380, 455, 206, 370, 498, 503, 466, 455, 484, 502, + 455, 0, 193, 376, 455, 33, 205, 204, 0, 0, + 206, 0, 369, 381, 455, 455, 0, 497, 455, 455, + 0, 0, 199, 455, 455, 455, 33, 207, 208, 467, + 0, 192, 194, 0, 378, 373, 0, 200, 202, 203, + 0, 501, 0, 198, 455, 379, 0, 201, 195 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -765, -765, -765, -765, -765, -7, 117, -765, -765, 8, - 2, -19, -83, -765, 448, 232, -261, -765, 291, -765, - -765, -765, -765, -303, 70, -765, -765, 575, 237, -765, - -765, -765, -765, -765, -765, -765, -765, -765, 137, -765, - -168, -765, -765, -765, -765, -765, -765, -765, -765, -263, - -765, -765, -765, -764, -765, -765, -765, -765, -765, -765, - -765, -765, -765, -765, -765, -765, -75, -765, -765, 604, - -56, -765, 339, 40, -765, 389, 51, -765, -89, -765, - -765, -277, -91, -765, -144, -765, 92, -765, -765, -765, - -765, -765, -765, -765, -131, -765, -765, -765, -765, -765, - 63, -765, -765, -53, -765, -645, -641, -765, -765, -640, - -637, -576, -28, -765, -765, -765, -765, -765, -765, -765, - -765, -765, 17, -765, -765, -765, -205, -157, -765, 322, - -290, 11, 93, -526, 48, -129, -765, 310, -151, -708, - -158, -765, -765, 929, -765, 239, -92 + -806, -806, -806, -806, -806, -7, 97, -806, -806, 14, + 5, -15, -806, -83, -806, 449, 216, -251, -806, -806, + 212, -806, -806, -806, -806, -376, 98, -806, -806, 576, + 117, -806, -806, -806, -806, -806, -806, -806, -806, -806, + 148, -806, -141, -806, -806, -806, -806, -806, -806, -806, + -806, -267, -806, -806, -806, -805, -806, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -806, -806, + -806, -806, -806, -75, -806, -806, -806, -806, 208, -77, + -806, 363, 43, -806, 239, 50, -806, -99, -806, -806, + -806, -806, -275, -93, -806, -171, -806, 69, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -201, -806, -806, + -806, -806, -806, 64, -806, -806, -60, -806, -642, -806, + -640, -806, -806, -636, -635, -612, -94, -806, -806, -806, + -806, -806, -806, -806, -806, -806, -806, -806, -37, -806, + -806, -806, -806, -245, -224, -806, 237, -806, -370, 8, + 63, -543, 42, -806, -119, -806, 305, -149, -775, -162, + -806, -806, -806, 776, -806, -806, -806, 484, -74 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 1, 2, 3, 20, 173, 164, 669, 644, 143, - 95, 23, 112, 283, 181, 182, 144, 145, 146, 309, - 24, 300, 461, 25, 560, 593, 630, 91, 165, 27, - 147, 540, 391, 468, 28, 301, 462, 469, 470, 609, - 657, 680, 681, 778, 682, 723, 724, 876, 882, 789, - 790, 869, 836, 791, 471, 29, 30, 290, 455, 313, - 396, 474, 31, 293, 458, 570, 32, 362, 602, 116, - 166, 34, 167, 36, 37, 168, 39, 40, 177, 178, - 364, 117, 118, 439, 440, 41, 42, 43, 296, 459, - 44, 45, 297, 460, 463, 533, 46, 291, 381, 524, - 525, 47, 48, 108, 49, 491, 492, 493, 494, 495, - 496, 497, 498, 314, 402, 499, 671, 715, 716, 500, - 398, 616, 617, 694, 734, 693, 783, 792, 793, 50, - 688, 689, 546, 453, 52, 169, 170, 171, 183, 503, - 357, 410, 504, 172, 717, 358, 189 + -1, 1, 2, 3, 20, 173, 163, 720, 692, 147, + 134, 23, 181, 111, 284, 182, 183, 143, 144, 309, + 310, 389, 24, 301, 452, 25, 546, 590, 626, 92, + 164, 27, 311, 512, 391, 461, 28, 302, 453, 462, + 463, 606, 654, 676, 677, 749, 678, 704, 705, 879, + 892, 847, 848, 896, 868, 849, 464, 29, 312, 575, + 30, 291, 446, 392, 471, 515, 31, 294, 449, 559, + 630, 32, 597, 33, 361, 631, 652, 632, 115, 165, + 35, 166, 37, 38, 167, 40, 41, 177, 178, 362, + 491, 435, 116, 117, 430, 431, 42, 43, 44, 450, + 561, 45, 454, 566, 46, 451, 563, 500, 562, 47, + 292, 378, 497, 498, 48, 49, 107, 50, 530, 531, + 532, 533, 534, 535, 536, 537, 538, 393, 476, 539, + 696, 740, 741, 540, 472, 639, 693, 661, 662, 754, + 804, 753, 802, 841, 850, 851, 51, 492, 684, 685, + 574, 444, 53, 95, 168, 169, 170, 184, 543, 356, + 401, 544, 588, 171, 172, 742, 743, 357, 190 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -1084,686 +1100,706 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 61, 130, 319, 85, 96, 22, 61, 375, 175, 331, - 395, 21, 684, 305, 51, 111, 685, 686, 193, 583, - 687, 185, 837, 400, 784, 105, 285, 377, 287, -33, - 4, 73, 66, 61, 109, 531, 119, 63, 64, 87, - 94, 598, 366, 648, 7, 368, 72, 330, 7, 7, - 302, 73, -160, 367, 852, 537, 369, 369, 613, 61, - 68, 61, 97, 115, 538, 61, 7, 61, 61, 128, - 61, 61, 88, 61, 61, 61, 85, 614, 149, 476, - 13, 53, 54, 360, 13, 13, 106, 134, 467, 55, - 163, 134, 115, 870, 697, 110, 163, 120, -134, 488, - 56, 472, 13, 57, 7, 97, 7, 73, 190, 58, - 102, 600, 501, -25, 884, 61, 100, 191, 142, 61, - 59, 60, 725, 142, 62, 7, -25, -25, 61, 61, - 69, 784, 148, 61, 61, 163, 89, 53, 54, 374, - 13, 663, 13, 149, 90, 55, 163, 877, 664, -24, - 878, 73, 603, 604, 194, 731, 56, 101, 328, 57, - 294, 13, 665, 191, 331, 58, 7, 7, 666, 7, - 737, 136, 61, 63, 64, 141, 59, 60, 288, 667, - 668, 517, 684, 107, 61, 107, 685, 686, 89, 121, - 687, 123, 125, 129, 132, 133, 92, 137, 138, 139, - 409, 379, 13, 13, 382, 13, 403, 383, 384, 295, - 404, 385, 386, 75, 5, 367, 103, 77, 78, 369, - 180, 345, 346, 347, 104, 433, 310, 98, 351, 8, - 9, 63, 64, 64, 82, -241, 354, 84, 563, 289, - 26, 330, 330, 292, 311, 11, 187, 188, 65, 312, - 67, 326, 298, 299, 70, 71, 14, 303, 304, 26, - 566, 15, 522, 16, -24, 17, 18, 19, 573, 574, - 180, 191, 444, -17, 99, -17, -17, 115, 98, 448, - 645, 449, 63, 64, 451, 100, 5, -17, 327, 568, - 629, 332, 553, -242, 7, 329, 363, 633, 569, 306, - 307, 8, 9, 333, 613, 365, 308, 26, 372, 84, - 26, 378, 26, 26, 380, 394, 26, 11, 387, 61, - 26, 393, 163, 614, 401, 61, 163, 456, 14, 388, - 13, 5, 405, 15, 432, 16, 26, 17, 18, 634, - 179, 442, 35, 452, 53, 54, 557, 163, 516, 53, - 54, 351, 55, 508, 509, 457, 64, 55, 506, 354, - 61, 35, 520, 56, 475, 330, 57, 513, 56, 721, - 521, 57, 58, 61, 526, 85, 527, 58, 179, 187, - 188, 61, 61, 59, 528, 284, 534, 535, 59, 60, - 61, 536, 38, 394, 676, 486, 571, 572, 529, 466, - 94, 530, 473, 61, 394, 542, 99, 545, 548, 35, - 487, 38, 35, 502, 35, 35, 98, 547, 35, 551, - 63, 64, 35, 559, 519, 554, 590, 564, 567, 63, - 64, 565, 5, 555, 537, 596, 61, 580, 35, 330, - 556, 597, 581, 407, 584, 187, 188, 8, 9, 411, - 61, 443, 187, 188, 588, 84, 605, 594, 515, 38, - 94, 606, 38, 11, 38, 38, 608, 592, 38, 61, - 61, 532, 38, 618, 14, 624, 621, 539, 632, 15, - 636, 16, 552, 637, 180, 19, 641, 642, 38, 643, - 649, 652, 650, 322, 53, 54, 656, 107, 653, 655, - 626, 658, 55, 659, 660, 464, 465, 661, 115, 662, - 670, -3, 553, 56, 478, 672, 57, 675, 638, 639, - 640, 26, 58, 695, 674, 696, 635, 507, 718, 179, - 61, 719, 179, 59, 60, 179, 179, 720, 727, 179, - 179, 736, 746, 323, 744, 774, 26, 748, 163, 775, - 26, 115, 776, 777, 795, 796, 747, 163, 654, 772, - 518, 99, 61, 820, 828, 829, 830, 831, 61, 5, - 832, 6, 7, -208, 523, 839, 845, 849, 601, 532, - 532, -207, 856, 857, 8, 9, 865, 866, 867, 615, - 868, 879, 10, 543, 544, 628, 880, 885, 887, 446, - 11, 318, 390, 12, 576, 93, 541, 33, 13, 85, - 827, 14, 486, 883, 163, 713, 15, 799, 16, 611, - 17, 18, 19, 35, 615, 826, 86, 94, 26, 824, - 612, 26, 599, 646, 860, 399, 841, 582, 0, 489, - 821, 631, 0, 412, 0, 0, 163, 0, 35, 0, - 486, 0, 35, 0, 578, 0, 0, 0, 0, 679, - 85, 0, 0, 486, 711, 678, 0, 0, 0, 0, - 61, 0, 0, 38, 0, 0, 61, 122, 94, 126, - 131, 0, 0, 135, 0, 0, 523, 140, 53, 54, - 0, 0, 607, 0, 0, 0, 55, 322, 38, 0, - 0, 732, 38, 854, 0, 745, 0, 56, 0, 0, - 57, 0, 0, 0, 0, 0, 58, 0, 0, 61, - 800, 61, 61, 61, 0, 486, 0, 59, 88, 99, - 35, 0, 851, 35, 0, 0, 875, 61, 0, 163, - 0, 490, 0, 558, 0, 0, 0, 323, 0, 0, - 0, 0, 26, 0, 0, 0, 94, 0, 321, 0, - 53, 54, 163, 0, 0, 0, 0, 0, 55, 26, - 0, 150, 151, 0, 0, 552, 0, 579, 61, 56, - 38, 152, 57, 38, 153, 840, 0, 0, 58, 0, - 786, 38, 155, 0, 722, 26, 5, 0, 0, 59, - 478, 787, 0, 0, 157, 158, 159, 0, 0, 53, - 54, 0, 0, 0, 0, 788, 26, 55, 0, 160, - 486, 0, 0, 0, 0, 163, 0, 0, 56, 679, - 26, 57, 486, 0, 0, 678, 0, 58, 26, 0, - 0, 855, 0, 544, 0, 779, 780, 781, 59, 19, - 161, 162, 0, 0, 35, 0, 489, 0, 163, 0, - 0, 798, 0, 0, 0, 26, 0, 72, 873, 0, - 26, 35, 73, 74, 0, 0, 0, 75, 61, 0, - 76, 77, 78, 0, 0, 0, 0, 0, 0, 0, - 79, 0, 80, 81, 489, 0, 0, 35, 82, 0, - 0, 627, 833, 83, 38, 0, 0, 489, 712, 0, - 0, 0, 5, 389, 0, 7, 26, 397, 610, 0, - 0, 38, 0, 0, 0, 0, 0, 8, 9, 0, - 0, 0, 35, 0, 0, 84, 0, 0, 0, 0, - 35, 0, 0, 11, 0, 0, 0, 38, 0, 0, - 0, 13, 0, 99, 14, 0, 773, 0, 647, 15, - 0, 16, 438, 17, 18, 19, 0, 35, 0, 782, - 0, 0, 35, 0, 0, 0, 0, 5, 0, 0, - 7, 0, 38, 0, 0, 0, 0, 0, 0, 0, - 38, 392, 8, 9, 0, 397, 490, 0, 477, 0, - 84, 0, 886, 0, 0, 0, 397, 0, 11, 647, - 714, 0, 0, 0, 0, 0, 13, 38, 35, 14, - 5, 0, 38, 7, 15, 0, 16, 174, 0, 176, - 19, 0, 184, 0, 186, 8, 9, 0, 192, 0, - 0, 322, 0, 84, 0, 0, 38, 0, 286, 0, - 0, 11, 0, 0, 0, 0, 0, 0, 0, 13, - 0, 0, 14, 0, 489, 0, 0, 15, 38, 16, - 0, 0, 0, 19, 0, 0, 782, 0, 0, 315, - 316, 317, 184, 324, 325, 0, 0, 0, 0, 0, - 0, 323, 0, 0, 341, 342, 343, 344, 345, 346, - 347, 0, 0, 0, 0, 351, 0, 150, 151, 0, - 64, 0, 322, 354, 0, 0, 0, 152, 0, 330, - 153, 0, 0, 356, 0, 322, 154, 0, 155, 0, - 0, 0, 5, 0, 0, 0, 575, 436, 0, 0, - 157, 158, 159, 0, 0, 53, 54, 8, 9, 0, - 0, 0, 0, 55, 0, 320, 0, 0, 0, 0, - 0, 0, 323, 11, 56, 0, 490, 57, 0, 0, - 0, 0, 0, 58, 14, 323, 0, 0, 0, 15, - 0, 16, 0, 437, 59, 19, 161, 162, 479, 0, - 0, 0, 0, 0, 0, 0, 0, 33, 0, 5, - 0, 480, 7, 0, 0, 131, 0, 0, 0, 481, - 0, 0, 53, 54, 8, 9, 38, 0, 0, 0, - 55, 0, 84, 482, 0, 0, 0, 483, 0, 0, - 11, 56, 86, 0, 57, 0, 0, 131, 13, 484, - 58, 14, 0, 485, 0, 0, 15, 0, 16, 0, - 0, 59, 19, 0, 0, 0, 408, 0, 0, 0, - 0, 683, 0, 413, 414, 415, 416, 417, 418, 419, - 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 430, 431, 0, 726, 434, 435, 0, 441, 0, 0, - 0, 150, 151, 0, 445, 0, 0, 0, 447, 0, - 0, 152, 0, 0, 153, 0, 741, 454, 0, 0, - 154, 0, 155, 0, 0, 0, 5, 0, 0, 0, - 0, 834, 0, 0, 157, 158, 159, 0, 0, 53, - 54, 8, 9, 0, 505, 835, 0, 55, 0, 320, - 0, 0, 0, 0, 0, 0, 0, 11, 56, 0, - 0, 57, 0, 0, 0, 0, 0, 58, 14, 0, - 0, 512, 0, 15, 0, 16, 0, 0, 59, 19, - 161, 162, 0, 0, 0, 0, 0, 438, 0, 0, - 0, 150, 151, 0, 0, 0, 0, 0, 0, 0, - 321, 152, 0, 0, 153, 0, 0, 0, 0, 0, - 154, 0, 155, 0, 0, 0, 5, 0, 0, 0, - 0, 0, 0, 550, 157, 158, 159, 0, 0, 53, - 54, 8, 9, 0, 0, 0, 0, 55, 0, 320, - 0, 683, 0, 0, 0, 0, 0, 11, 56, 0, - 561, 57, 0, 562, 0, 0, 0, 58, 14, 0, - 0, 0, 0, 15, 0, 16, 0, 0, 59, 19, - 161, 162, 0, 0, 0, 577, 0, 0, 150, 151, - 0, 0, 0, 0, 454, 0, 0, 585, 152, 0, - 587, 153, 881, 589, 0, 591, 0, 786, 0, 155, - 0, 0, 0, 5, 0, 0, 454, 0, 787, 0, - 0, 157, 158, 159, 0, 0, 53, 54, 0, 0, - 0, 0, 788, 0, 55, 0, 160, 0, 0, 0, - 0, 0, 0, 0, 0, 56, 0, 0, 57, 0, - 0, 0, 0, 336, 58, 0, 0, 0, 341, 342, - 343, 344, 345, 346, 347, 59, 19, 161, 162, 351, - 0, 0, 651, 0, 64, 0, 353, 354, 0, 0, - 150, 151, 0, 330, 0, 0, 0, 356, 0, 0, - 152, 0, 0, 153, 0, 0, 0, 0, 0, 786, - 0, 155, 0, 0, 0, 5, 0, 690, 691, 692, - 787, 0, 0, 157, 158, 159, 0, 0, 53, 54, - 0, 0, 0, 0, 788, 0, 55, 0, 160, 0, - 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, - 57, 0, 0, 735, 0, 454, 58, 738, 739, 740, - 0, 742, 743, 0, 334, 335, 336, 59, 19, 161, - 162, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 0, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, 0, 794, 330, 0, 0, 0, - 356, 0, 0, 0, 0, 0, 0, 0, 801, 802, - 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, - 813, 814, 815, 816, 817, 818, 819, 0, 0, 822, - 823, 0, 825, 0, 0, 184, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 838, 0, 150, 151, 0, - 0, 0, 794, 0, 0, 844, 0, 152, 0, 0, - 153, 0, 0, 0, 0, 0, 154, 0, 155, 0, - 0, 0, 5, 0, 0, 0, 0, 787, 0, 848, - 157, 158, 159, 0, 0, 53, 54, 0, 0, 0, - 0, 788, 0, 55, 0, 160, 0, 0, 0, 0, - 0, 861, 862, 0, 56, 0, 863, 57, 0, 864, - 0, 0, 0, 58, 0, 0, 794, 871, 872, 0, - 0, 0, 0, 0, 59, 19, 161, 162, 0, 0, - 0, 0, 0, 0, 0, 794, 0, 794, 195, 196, - 0, 0, 197, 198, 0, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 0, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 195, 0, 0, 0, 197, 198, 0, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 370, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 195, 0, 0, 0, 197, 198, 0, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 450, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 150, 151, 0, 0, 0, 0, - 0, 0, 0, 0, 152, 0, 0, 153, 0, 0, - 0, 0, 0, 154, 0, 155, 0, 0, 0, 5, - 0, 0, 0, 0, 156, 0, 0, 157, 158, 159, - 0, 0, 53, 54, 0, 0, 0, 0, 0, 0, - 55, 0, 160, 150, 151, 0, 0, 0, 0, 0, - 0, 56, 0, 152, 57, 0, 153, 0, 0, 0, - 58, 0, 154, 0, 155, 0, 0, 0, 5, 0, - 549, 59, 124, 161, 162, 0, 157, 158, 159, 0, - 0, 53, 54, 0, 0, 0, 0, 0, 0, 55, - 0, 160, 698, 699, 0, 0, 0, 0, 0, 0, - 56, 0, 700, 57, 0, 0, 701, 0, 0, 58, - 0, 702, 0, 703, 0, 0, 0, 5, 0, 0, - 59, 19, 161, 162, 0, 704, 705, 706, 0, 0, - 53, 54, 0, 0, 0, 0, 707, 0, 55, 0, - 708, 150, 151, 0, 0, 0, 0, 0, 0, 56, - 0, 152, 57, 0, 153, 733, 0, 0, 58, 0, - 154, 0, 155, 0, 0, 0, 5, 0, 0, 59, - 19, 709, 710, 0, 157, 158, 159, 0, 0, 53, - 54, 0, 0, 0, 0, 0, 0, 55, 0, 160, - 150, 151, 0, 0, 0, 0, 0, 0, 56, 0, - 152, 57, 0, 153, 0, 0, 0, 58, 0, 154, - 0, 155, 0, 0, 0, 5, 0, 0, 59, 19, - 161, 162, 0, 157, 158, 159, 0, 0, 53, 54, - 0, 0, 0, 0, 0, 0, 55, 0, 160, 150, - 151, 0, 0, 0, 0, 0, 0, 56, 0, 152, - 57, 0, 153, 0, 0, 0, 58, 0, 154, 0, - 155, 0, 0, 0, 5, 0, 0, 59, 19, 161, - 162, 0, 157, 158, 159, 0, 0, 53, 54, 0, - 0, 0, 0, 0, 0, 55, 0, 160, 0, 0, - 0, 0, 0, 0, 0, 0, 56, 0, 0, 57, - -186, 0, 0, 0, 0, 58, 0, 0, 0, 0, - 0, 5, 0, 480, 7, 0, 59, 124, 161, 162, - 0, 481, 0, 0, 53, 54, 8, 9, 0, 0, - 0, 0, 55, 0, 84, 0, 0, 0, 0, 483, - 0, 0, 11, 56, 0, 0, 57, 0, 853, 0, - 13, 0, 58, 14, 0, 0, 0, 677, 15, 5, - 16, 480, 7, 59, 19, 0, 0, 0, 0, 481, - 0, 0, 53, 54, 8, 9, 0, 0, 0, 0, - 55, 0, 84, 0, 0, 0, 0, 483, 0, 0, - 11, 56, 0, 0, 57, 0, 0, 0, 13, 0, - 58, 14, 5, 0, 0, 0, 15, 113, 16, 0, - 0, 59, 19, 0, 0, 53, 54, 8, 9, 0, - 0, 0, 0, 55, 0, 84, 0, 0, 0, 0, - 0, 0, 0, 11, 56, 0, 0, 57, 0, 0, - 0, 0, 0, 58, 14, 5, 0, 0, 0, 15, - 0, 16, 0, 114, 59, 19, 0, 0, 53, 54, - 8, 9, 0, 0, 0, 0, 55, 0, 84, 0, - 0, 0, 0, 0, 0, 0, 11, 56, 0, 0, - 57, 0, 0, 0, 0, 0, 58, 14, 0, 0, - 0, 0, 15, 0, 16, 0, 17, 127, 124, 5, - 0, 480, 7, 0, 0, 0, 0, 0, 0, 481, - 0, 0, 53, 54, 0, 0, 0, 0, 0, 0, - 55, 0, 0, 482, 0, 0, 0, 483, 0, 0, - 0, 56, 5, 0, 57, 0, 0, 0, 13, 484, - 58, 0, 0, 485, 0, 53, 54, 8, 9, 0, - 0, 59, 19, 55, 0, 84, 0, 0, 0, 0, - 0, 0, 0, 11, 56, 0, 0, 57, 0, 0, - 0, 0, 0, 58, 14, 0, 0, 0, 0, 15, - 0, 16, 0, 0, 59, 124, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 406, 0, 0, 0, 355, 330, 0, - 0, 0, 356, 0, 858, 859, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 0, 0, 0, 0, 355, 330, 0, - 0, 0, 356, 0, 842, 843, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 510, 0, 0, 63, 64, - 352, 353, 354, 0, 0, 511, 0, 355, 330, 0, - 0, 0, 356, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 0, 351, 622, 0, 0, 63, 64, 352, 353, 354, - 0, 0, 623, 0, 355, 330, 0, 0, 0, 356, - 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 350, 0, 351, 846, - 0, 0, 63, 64, 352, 353, 354, 0, 0, 847, - 0, 355, 330, 0, 0, 0, 356, 334, 335, 336, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 0, 351, 359, 0, 0, 63, - 64, 352, 353, 354, 0, 0, 0, 0, 355, 330, - 0, 0, 0, 356, 334, 335, 336, 337, 338, 339, + 62, 148, 129, 318, 330, 175, 62, 86, 22, 110, + 372, 52, 680, 595, 681, 460, 470, 21, 682, 683, + 186, 466, 474, 306, 104, 108, 842, 118, 664, -33, + 611, 4, 297, 298, 62, 194, 64, 65, 374, 869, + 303, 191, -162, 286, 7, 288, 329, 97, 7, 73, + 192, 64, 65, -302, 74, -250, 7, 74, 64, 65, + 62, 329, 62, -308, 114, -305, 62, 7, 62, 62, + 127, 62, 62, -363, 62, 62, 62, 7, 897, 7, + 13, 508, 517, 722, 13, 105, 109, 7, 119, 162, + 509, 114, 13, 313, 133, 162, 842, 658, 133, 907, + 527, 359, 838, 13, 63, 366, 541, 67, 706, 715, + 70, 5, -231, 13, 62, 13, 659, 800, 62, 86, + 26, 69, 74, 13, 54, 55, 7, 88, 62, 62, + 716, 7, 56, 62, 62, 162, 717, 74, 100, 26, + 371, 195, 394, 57, 89, 162, 58, 718, 719, 136, + 192, 365, 59, 141, 680, -25, 681, 327, 308, 330, + 682, 683, 13, 60, 106, 96, 106, 13, -25, -25, + 120, 7, 122, 124, 128, 131, 132, 395, 137, 138, + 139, 658, 489, 386, 387, 62, 366, 495, 26, 99, + 388, 26, 376, 26, 26, 379, 192, 26, -3, 180, + 659, 26, 382, 383, 188, 189, 101, 13, 557, 400, + 285, 34, 549, 807, 625, 26, 903, 558, 290, 904, + 142, 90, 293, 76, 344, 345, 346, 78, 79, 91, + 87, 350, 299, 300, 424, -135, 65, 304, 305, 353, + 188, 189, 39, 555, 83, 329, 90, 54, 55, 180, + 501, 564, 565, 504, 93, 56, 5, 102, 6, 7, + -17, 39, -17, -17, 145, 103, 57, 289, 99, 58, + -24, 8, 9, 146, -17, 59, -251, 295, 114, 10, + 480, 481, 121, 296, 125, 130, 60, 11, 135, 369, + 12, 307, 140, 313, 439, 13, 440, 97, 14, 442, + 325, 64, 65, 15, -24, 16, 350, 17, 18, 19, + 39, 65, 328, 39, 353, 39, 39, 447, 62, 39, + 329, 162, 96, 39, 62, 162, 188, 189, 54, 55, + 584, 326, 487, 332, 64, 65, 56, 39, 585, 505, + 506, 54, 55, 331, 329, 586, 162, 57, 702, 56, + 58, 363, 364, 365, 366, 62, 59, 488, 62, 375, + 57, 320, 377, 58, 380, 381, 36, 60, 61, 59, + 62, 384, 5, 385, 516, 7, 396, 390, 62, 97, + 60, 61, 587, 64, 65, 36, 468, 8, 9, 423, + 433, 448, 322, 583, 62, 85, 459, 459, 554, 467, + 475, 443, 26, 11, 308, 458, 469, 478, 485, 490, + 493, 13, 494, 499, 14, 545, 502, 553, 503, 15, + 701, 16, 398, 550, 556, 19, 551, 568, 402, 508, + 572, 593, 577, 573, 36, 591, 578, 36, 581, 36, + 36, 62, 594, 36, 86, 599, 600, 36, 601, 62, + 602, 603, 604, 612, 613, 614, 628, 618, 62, 434, + 634, 36, 180, 642, 651, 638, 620, 689, 645, 525, + 653, 655, 656, 657, 106, 665, 511, 669, 668, 671, + 114, 459, 455, 62, 542, 697, 672, 690, 691, 583, + 526, 708, 712, 66, 695, 68, 622, 700, 479, 71, + 72, 62, 713, 62, 721, 744, 26, 745, 26, 26, + 62, 142, 714, 746, 560, 560, 321, 747, 560, 763, + 98, 582, 748, 666, 39, 755, 756, 765, 767, 793, + 54, 55, 794, 635, 636, 637, 797, 798, 56, 799, + 806, 5, 808, 162, 855, 496, 832, 853, 647, 57, + 699, 62, 58, 507, 650, 859, 8, 9, 59, 862, + 863, 864, 514, 871, 85, 429, 878, -210, -209, 60, + 61, 882, 11, 670, 894, 883, 26, 766, 162, 901, + 791, 437, 114, 14, 179, 895, 902, 552, 15, 905, + 16, 62, 908, 528, 19, 624, 322, 456, 795, 465, + 465, 317, 457, 567, 26, 569, 94, 571, 796, 86, + 513, 629, 893, 608, 576, 179, 179, 54, 55, 738, + 609, 836, 596, 179, 694, 56, 886, 873, 39, 473, + 39, 39, 627, 525, 610, 162, 57, 403, 0, 58, + 0, 0, 0, 0, 0, 59, 811, 525, 36, 0, + 98, 0, 0, 660, 0, 496, 60, 61, 0, 675, + 86, 0, 162, 0, 0, 0, 62, 510, 674, 833, + 5, 0, 62, 812, 0, 660, 0, 26, 0, 0, + 0, 648, 0, 0, 465, 8, 9, 26, 525, 736, + 0, 0, 0, 85, 0, 633, 0, 0, 39, 0, + 62, 11, 62, 62, 62, 0, 26, 26, 0, 0, + 54, 55, 14, 0, 0, 39, 0, 15, 56, 16, + 321, 17, 18, 649, 0, 0, 39, 0, 0, 57, + 764, 0, 58, 0, 0, 0, 0, 0, 59, 0, + 0, 26, 0, 0, 0, 880, 26, 0, 0, 60, + 89, 0, 36, 0, 36, 36, 62, 528, 162, 890, + 0, 0, 861, 0, 0, 26, 0, 801, 598, 0, + 703, 528, 5, 0, 0, 179, 514, 0, 179, 0, + 0, 162, 0, 0, 0, 179, 179, 8, 9, 525, + 0, 0, 26, 0, 525, 85, 0, 0, 34, 39, + 0, 675, 0, 11, 571, 98, 750, 751, 752, 0, + 674, 0, 528, 737, 14, 0, 0, 0, 0, 15, + 0, 16, 36, 17, 18, 19, 0, 0, 39, 39, + 0, 0, 87, 582, 0, 0, 62, 130, 0, 529, + 0, 0, 0, 5, 0, 0, 7, 0, 0, 0, + 36, 0, 0, 0, 0, 0, 130, 162, 8, 9, + 810, 0, 679, 39, 525, 0, 85, 0, 39, 0, + 0, 162, 0, 174, 11, 176, 0, 0, 185, 881, + 187, 0, 13, 707, 193, 14, 0, 39, 0, 0, + 15, 0, 16, 39, 287, 62, 19, 0, 0, 0, + 900, 0, 0, 0, 0, 623, 0, 0, 0, 0, + 0, 0, 0, 528, 39, 0, 5, 0, 840, 7, + 0, 0, 0, 36, 0, 314, 315, 316, 185, 323, + 324, 8, 9, 607, 0, 760, 0, 0, 0, 85, + 865, 0, 0, 0, 0, 0, 0, 11, 0, 0, + 0, 0, 36, 36, 0, 13, 0, 0, 14, 0, + 0, 0, 0, 15, 0, 16, 322, 17, 18, 19, + 0, 73, 0, 0, 0, 0, 74, 75, 0, 0, + 0, 76, 0, 0, 77, 78, 79, 36, 840, 0, + 0, 0, 36, 570, 80, 0, 81, 82, 0, 906, + 429, 0, 83, 663, 679, 0, 0, 84, 149, 150, + 0, 36, 0, 98, 0, 0, 0, 529, 151, 0, + 0, 152, 0, 0, 0, 0, 0, 153, 589, 154, + 0, 322, 0, 5, 0, 39, 0, 0, 36, 0, + 0, 156, 157, 158, 0, 0, 54, 55, 8, 9, + 0, 0, 320, 0, 56, 0, 319, 0, 663, 739, + 0, 0, 0, 0, 11, 57, 0, 0, 58, 0, + 0, 0, 0, 0, 59, 14, 0, 0, 0, 0, + 15, 0, 16, 322, 0, 60, 19, 160, 161, 0, + 321, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 399, 0, 0, 0, 0, 0, 0, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, 0, 0, + 425, 426, 0, 432, 0, 0, 0, 0, 0, 436, + 0, 0, 438, 0, 0, 0, 0, 0, 0, 0, + 0, 445, 0, 0, 0, 321, 0, 335, 0, 529, + 0, 0, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 477, 350, 0, 0, 149, 150, 65, 0, + 352, 353, 0, 0, 0, 0, 151, 329, 0, 152, + 0, 355, 0, 0, 0, 153, 0, 154, 0, 484, + 0, 5, 0, 0, 0, 0, 427, 321, 0, 156, + 157, 158, 0, 0, 54, 55, 8, 9, 0, 0, + 0, 0, 56, 98, 319, 0, 792, 0, 0, 0, + 0, 0, 11, 57, 0, 0, 58, 0, 0, 0, + 0, 0, 59, 14, 0, 0, 0, 0, 15, 0, + 16, 0, 428, 60, 19, 160, 161, 149, 150, 547, + 0, 0, 548, 0, 0, 0, 0, 151, 0, 0, + 152, 0, 0, 0, 0, 0, 153, 0, 154, 0, + 0, 0, 5, 0, 0, 0, 0, 866, 0, 0, + 156, 157, 158, 0, 0, 54, 55, 8, 9, 580, + 0, 867, 0, 56, 0, 319, 0, 0, 0, 0, + 0, 0, 0, 11, 57, 0, 0, 58, 0, 0, + 0, 0, 0, 59, 14, 0, 0, 0, 0, 15, + 0, 16, 445, 0, 60, 19, 160, 161, 0, 0, + 0, 0, 0, 0, 605, 149, 150, 0, 0, 445, + 0, 0, 0, 0, 615, 151, 0, 617, 152, 872, + 619, 0, 621, 0, 844, 0, 154, 0, 0, 0, + 5, 0, 0, 0, 0, 845, 0, 0, 156, 157, + 158, 0, 0, 54, 55, 0, 0, 0, 0, 846, + 0, 56, 0, 159, 0, 0, 0, 0, 0, 0, + 0, 0, 57, 0, 0, 58, 0, 0, 0, 0, + 0, 59, 0, 0, 0, 0, 149, 150, 0, 0, + 667, 0, 60, 19, 160, 161, 151, 0, 0, 152, + 891, 686, 687, 688, 0, 844, 0, 154, 0, 0, + 0, 5, 0, 0, 0, 0, 845, 0, 0, 156, + 157, 158, 0, 0, 54, 55, 0, 0, 0, 0, + 846, 0, 56, 0, 159, 0, 0, 0, 0, 0, + 0, 0, 0, 57, 0, 0, 58, 0, 0, 0, + 0, 0, 59, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 60, 19, 160, 161, 0, 0, 757, + 758, 759, 0, 761, 762, 335, 0, 0, 0, 0, + 340, 341, 342, 343, 344, 345, 346, 0, 348, 349, + 0, 350, 0, 185, 0, 0, 65, 0, 352, 353, + 805, 0, 445, 0, 0, 329, 0, 0, 0, 355, + 0, 0, 0, 0, 813, 814, 815, 816, 817, 818, + 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, + 829, 830, 831, 0, 335, 834, 835, 0, 837, 340, + 341, 342, 343, 344, 345, 346, 0, 348, 0, 518, + 350, 0, 852, 0, 854, 65, 0, 352, 353, 0, + 5, 0, 519, 7, 329, 0, 0, 0, 355, 0, + 520, 0, 0, 54, 55, 8, 9, 0, 858, 0, + 0, 56, 0, 85, 521, 0, 0, 0, 522, 0, + 870, 11, 57, 0, 0, 58, 0, 852, 0, 13, + 523, 59, 14, 876, 524, 0, 877, 15, 0, 16, + 0, 0, 60, 19, 0, 0, 0, 0, 0, 0, + 887, 888, 0, 0, 0, 852, 0, 0, 0, 852, + 898, 899, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 196, 197, 0, 0, 198, 199, + 852, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 0, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 196, 0, 0, 0, + 198, 199, 0, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 367, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 196, 0, + 0, 0, 198, 199, 0, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 441, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 149, 150, 0, 0, 0, 0, 0, 0, 0, 0, + 151, 0, 0, 152, 0, 0, 0, 0, 0, 153, + -392, 154, 0, 0, 0, 5, 0, 0, 0, 0, + 155, 0, 0, 156, 157, 158, 0, 0, 54, 55, + 0, 0, 0, 0, 0, 0, 56, 0, 159, 149, + 150, 0, 0, 0, 0, 0, 0, 57, 0, 151, + 58, -399, 152, 0, 0, 0, 59, 0, 153, 0, + 154, 0, -399, 0, 5, 0, 0, 60, 123, 160, + 161, 0, 156, 157, 158, 0, 0, 54, 55, 0, + 0, 0, 0, 0, 0, 56, 0, 159, 149, 150, + 0, 0, 0, 0, 0, 0, 57, 0, 151, 58, + 0, 152, -399, 0, 0, 59, 0, 153, 0, 154, + 0, -399, 0, 5, 0, 0, 60, 123, 160, 161, + 0, 156, 157, 158, 0, 0, 54, 55, 0, 0, + 0, 0, 0, 0, 56, 0, 159, 149, 150, 0, + 0, 0, 0, 0, 0, 57, 0, 151, 58, 0, + 152, 0, 0, 0, 59, 0, 153, -399, 154, 0, + -399, 0, 5, 0, 0, 60, 123, 160, 161, 0, + 156, 157, 158, 0, 0, 54, 55, 0, 0, 0, + 0, 0, 0, 56, 0, 159, 0, 0, 149, 150, + 0, 0, 0, 0, 57, 0, 0, 58, 151, 0, + 0, 152, 0, 59, 0, 0, 0, 844, 0, 154, + 0, 0, 0, 5, 60, 19, 160, 161, 845, 0, + 0, 156, 157, 158, 0, 0, 54, 55, 0, 0, + 0, 0, 846, 0, 56, 0, 159, 0, 0, 149, + 150, 0, 0, 0, 0, 57, 0, 0, 58, 151, + 0, 0, 152, 0, 59, 0, 0, 0, 153, 0, + 154, 0, 0, 0, 5, 60, 19, 160, 161, 845, + 0, 0, 156, 157, 158, 0, 0, 54, 55, 0, + 0, 0, 0, 846, 0, 56, 0, 159, 0, 0, + 149, 150, 0, 0, 0, 0, 57, 0, 0, 58, + 151, 0, 0, 152, 0, 59, 0, 0, 0, 153, + 0, 154, 0, 0, 0, 5, 60, 19, 160, 161, + 155, 0, 0, 156, 157, 158, 0, 0, 54, 55, + 0, 0, 0, 0, 0, 0, 56, 0, 159, 149, + 150, 0, 0, 0, 0, 0, 0, 57, 0, 151, + 58, 0, 152, 0, 0, 0, 59, 0, 153, 0, + 154, 0, 0, 0, 5, 0, 579, 60, 123, 160, + 161, 0, 156, 157, 158, 0, 0, 54, 55, 0, + 0, 0, 0, 0, 0, 56, 0, 159, 723, 724, + 0, 0, 0, 0, 0, 0, 57, 0, 725, 58, + 0, 0, 726, 0, 0, 59, 0, 727, 0, 728, + 0, 0, 0, 5, 0, 0, 60, 19, 160, 161, + 0, 729, 730, 731, 0, 0, 54, 55, 0, 0, + 0, 0, 732, 0, 56, 0, 733, 149, 150, 0, + 0, 0, 0, 0, 0, 57, 0, 151, 58, 0, + 152, 803, 0, 0, 59, 0, 153, 0, 154, 0, + 0, 0, 5, 0, 0, 60, 19, 734, 735, 0, + 156, 157, 158, 0, 0, 54, 55, 0, 0, 0, + 0, 0, 0, 56, 0, 159, 149, 150, 0, 0, + 0, 0, 0, 0, 57, 0, 151, 58, 0, 152, + 0, 0, 0, 59, 0, 153, 0, 154, 0, 0, + 0, 5, 0, 0, 60, 19, 160, 161, 0, 156, + 157, 158, 0, 0, 54, 55, 0, 0, 0, 0, + 0, 0, 56, 0, 159, 0, 0, 0, 0, 0, + 0, 0, 0, 57, 0, 0, 58, -188, 0, 0, + 0, 0, 59, 0, 0, 0, 0, 0, 5, 0, + 519, 7, 0, 60, 19, 160, 161, 0, 520, 0, + 0, 54, 55, 8, 9, 0, 0, 0, 0, 56, + 0, 85, 0, 0, 0, 0, 522, 0, 0, 11, + 57, 0, 0, 58, 0, 839, 0, 13, 0, 59, + 14, 0, 0, 0, 673, 15, 5, 16, 519, 7, + 60, 19, 0, 0, 0, 0, 520, 0, 0, 54, + 55, 8, 9, 0, 0, 0, 0, 56, 0, 85, + 0, 0, 0, 0, 522, 0, 0, 11, 57, 0, + 0, 58, 0, 0, 0, 13, 0, 59, 14, 5, + 0, 0, 0, 15, 112, 16, 0, 0, 60, 19, + 0, 0, 54, 55, 8, 9, 0, 0, 0, 0, + 56, 0, 85, 0, 0, 0, 0, 0, 0, 0, + 11, 57, 0, 0, 58, 0, 0, 0, 0, 0, + 59, 14, 5, 0, 0, 0, 15, 0, 16, 0, + 113, 60, 19, 0, 0, 54, 55, 8, 9, 0, + 0, 0, 0, 56, 0, 85, 0, 0, 0, 0, + 0, 0, 0, 11, 57, 0, 0, 58, 0, 0, + 0, 0, 0, 59, 14, 0, 0, 0, 0, 15, + 0, 16, 0, 17, 126, 123, 5, 0, 519, 7, + 0, 0, 0, 0, 0, 0, 520, 0, 0, 54, + 55, 0, 0, 0, 0, 0, 0, 56, 0, 0, + 521, 0, 0, 0, 522, 0, 0, 0, 57, 5, + 0, 58, 0, 0, 0, 13, 523, 59, 0, 0, + 524, 0, 54, 55, 8, 9, 0, 0, 60, 19, + 56, 0, 85, 0, 0, 0, 0, 0, 0, 0, + 11, 57, 0, 0, 58, 0, 0, 0, 0, 0, + 59, 14, 0, 0, 0, 0, 15, 0, 16, 0, + 0, 60, 123, 333, 334, 335, 336, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 0, 350, 0, 0, 0, 64, 65, 351, 352, 353, + 397, 0, 0, 0, 354, 329, 0, 0, 0, 355, + 0, 884, 885, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 361, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, 0, 355, 330, 0, 0, 0, - 356, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 0, 351, - 0, 0, 0, 63, 64, 352, 353, 354, 371, 0, - 0, 0, 355, 330, 0, 0, 0, 356, 334, 335, + 0, 350, 0, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 0, 0, 354, 329, 0, 0, 0, 355, + 0, 874, 875, 333, 334, 335, 336, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 0, 350, 482, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 483, 0, 354, 329, 0, 0, 0, 355, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 0, 350, 643, + 0, 0, 64, 65, 351, 352, 353, 0, 0, 644, + 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 0, 351, 0, 0, 0, - 63, 64, 352, 353, 354, 373, 0, 0, 0, 355, - 330, 0, 0, 0, 356, 334, 335, 336, 337, 338, + 346, 347, 348, 349, 0, 350, 856, 0, 0, 64, + 65, 351, 352, 353, 0, 0, 857, 0, 354, 329, + 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 376, 0, 0, 0, 355, 330, 0, 0, - 0, 356, 334, 335, 336, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, 347, 348, 349, 350, 0, - 351, 0, 0, 0, 63, 64, 352, 353, 354, 406, - 0, 0, 0, 355, 330, 0, 0, 0, 356, 334, + 349, 0, 350, 358, 0, 0, 64, 65, 351, 352, + 353, 0, 0, 0, 0, 354, 329, 0, 0, 0, + 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 0, 350, + 360, 0, 0, 64, 65, 351, 352, 353, 0, 0, + 0, 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, 347, 348, 349, 350, 0, 351, 0, 0, - 0, 63, 64, 352, 353, 354, 0, 0, 514, 0, - 355, 330, 0, 0, 0, 356, 334, 335, 336, 337, + 345, 346, 347, 348, 349, 0, 350, 0, 0, 0, + 64, 65, 351, 352, 353, 368, 0, 0, 0, 354, + 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 0, 0, 0, 0, 355, 330, 0, - 586, 0, 356, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 0, 351, 595, 0, 0, 63, 64, 352, 353, 354, - 0, 0, 0, 0, 355, 330, 0, 0, 0, 356, + 348, 349, 0, 350, 0, 0, 0, 64, 65, 351, + 352, 353, 370, 0, 0, 0, 354, 329, 0, 0, + 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 373, + 0, 0, 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 350, 0, 351, 0, - 0, 0, 63, 64, 352, 353, 354, 619, 0, 0, - 0, 355, 330, 0, 0, 0, 356, 334, 335, 336, + 344, 345, 346, 347, 348, 349, 0, 350, 0, 0, + 0, 64, 65, 351, 352, 353, 397, 0, 0, 0, + 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 0, 351, 0, 0, 0, 63, - 64, 352, 353, 354, 620, 0, 0, 0, 355, 330, - 0, 0, 0, 356, 334, 335, 336, 337, 338, 339, + 347, 348, 349, 0, 350, 0, 0, 0, 64, 65, + 351, 352, 353, 0, 0, 486, 0, 354, 329, 0, + 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 0, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, 0, 355, 330, 0, 625, 0, - 356, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 0, 351, - 673, 0, 0, 63, 64, 352, 353, 354, 0, 0, - 0, 0, 355, 330, 0, 0, 0, 356, 334, 335, + 0, 350, 592, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 0, 0, 354, 329, 0, 0, 0, 355, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 0, 350, 0, + 0, 0, 64, 65, 351, 352, 353, 0, 0, 0, + 0, 354, 329, 0, 616, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, 347, 348, 349, 350, 0, 351, 0, 0, 0, - 63, 64, 352, 353, 354, 728, 0, 0, 0, 355, - 330, 0, 0, 0, 356, 334, 335, 336, 337, 338, + 346, 347, 348, 349, 0, 350, 0, 0, 0, 64, + 65, 351, 352, 353, 640, 0, 0, 0, 354, 329, + 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 729, 0, 0, 0, 355, 330, 0, 0, - 0, 356, 334, 335, 336, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, 347, 348, 349, 350, 0, - 351, 0, 0, 0, 63, 64, 352, 353, 354, 730, - 0, 0, 0, 355, 330, 0, 0, 0, 356, 334, + 349, 0, 350, 0, 0, 0, 64, 65, 351, 352, + 353, 641, 0, 0, 0, 354, 329, 0, 0, 0, + 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 0, 350, + 0, 0, 0, 64, 65, 351, 352, 353, 0, 0, + 0, 0, 354, 329, 0, 646, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, 347, 348, 349, 350, 0, 351, 0, 0, - 0, 63, 64, 352, 353, 354, 0, 0, 785, 0, - 355, 330, 0, 0, 0, 356, 334, 335, 336, 337, + 345, 346, 347, 348, 349, 0, 350, 698, 0, 0, + 64, 65, 351, 352, 353, 0, 0, 0, 0, 354, + 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 63, 64, - 352, 353, 354, 797, 0, 0, 0, 355, 330, 0, - 0, 0, 356, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 0, 351, 0, 0, 0, 63, 64, 352, 353, 354, - 0, 0, 850, 0, 355, 330, 0, 0, 0, 356, + 348, 349, 0, 350, 0, 0, 0, 64, 65, 351, + 352, 353, 709, 0, 0, 0, 354, 329, 0, 0, + 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 710, + 0, 0, 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, 347, 348, 349, 350, 0, 351, 874, - 0, 0, 63, 64, 352, 353, 354, 0, 0, 0, - 0, 355, 330, 0, 0, 0, 356, 334, 335, 336, + 344, 345, 346, 347, 348, 349, 0, 350, 0, 0, + 0, 64, 65, 351, 352, 353, 711, 0, 0, 0, + 354, 329, 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 0, 351, 0, 0, 0, 63, - 64, 352, 353, 354, 0, 0, 0, -205, 355, 330, - 0, 0, 0, 356, 334, 335, 336, 337, 338, 339, + 347, 348, 349, 0, 350, 0, 0, 0, 64, 65, + 351, 352, 353, 809, 0, 0, 0, 354, 329, 0, + 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 0, 351, 0, 0, 0, 63, 64, 352, 353, - 354, 0, 0, 0, -206, 355, 330, 0, 0, 0, - 356, 334, 335, 336, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 0, 351, - 0, 0, 0, 63, 64, 352, 353, 354, 0, 0, - 0, 0, 355, 330, 0, 0, 0, 356, 749, 750, - 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, - 761, 762, 763, 764, 765, 0, 766, 0, 0, 0, - 63, 64, 767, 768, 769, 0, 0, 0, 0, 770, - 330, 0, 0, 0, 771, 334, 335, 336, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 0, 0, 0, 0, 0, 330, 0, 0, - 0, 356, 334, 335, 336, 337, 0, 339, 340, 341, - 342, 343, 344, 345, 346, 347, 348, 349, 350, 0, - 351, 0, 0, 0, 63, 64, 352, 353, 354, 0, - 0, 0, 0, 0, 330, 334, 335, 336, 356, 0, + 0, 350, 0, 0, 0, 64, 65, 351, 352, 353, + 0, 0, 843, 0, 354, 329, 0, 0, 0, 355, + 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, 347, 348, 349, 0, 350, 0, + 0, 0, 64, 65, 351, 352, 353, 0, 0, 860, + 0, 354, 329, 0, 0, 0, 355, 333, 334, 335, + 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, 347, 348, 349, 0, 350, 889, 0, 0, 64, + 65, 351, 352, 353, 0, 0, 0, 0, 354, 329, + 0, 0, 0, 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 0, 351, 0, 0, 0, 63, 64, 352, - 353, 354, 0, 0, 0, 0, 0, 330, 336, 0, - 0, 356, 0, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 0, 351, 0, 0, 0, 0, 64, - 0, 353, 354, 0, 0, 0, 0, 0, 330, 336, - 0, 0, 356, 0, 341, 342, 343, 344, 345, 346, - 347, 0, 349, 350, 0, 351, 0, 0, 0, 0, - 64, 0, 353, 354, 0, 0, 0, 0, 0, 330, - 336, 0, 0, 356, 0, 341, 342, 343, 344, 345, - 346, 347, 0, 349, 0, 0, 351, 0, 0, 0, - 0, 64, 0, 353, 354, 0, 0, 0, 0, 0, - 330, 0, 0, 0, 356 + 349, 0, 350, 0, 0, 0, 64, 65, 351, 352, + 353, 0, 0, 0, -207, 354, 329, 0, 0, 0, + 355, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 0, 350, + 0, 0, 0, 64, 65, 351, 352, 353, 0, 0, + 0, -208, 354, 329, 0, 0, 0, 355, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 0, 350, 0, 0, 0, + 64, 65, 351, 352, 353, 0, 0, 0, 0, 354, + 329, 0, 0, 0, 355, 768, 769, 770, 771, 772, + 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, + 783, 784, 0, 785, 0, 0, 0, 64, 65, 786, + 787, 788, 0, 0, 0, 0, 789, 329, 0, 0, + 0, 790, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 0, + 0, 0, 0, 0, 329, 0, 0, 0, 355, 333, + 334, 335, 336, 0, 338, 339, 340, 341, 342, 343, + 344, 345, 346, 347, 348, 349, 0, 350, 0, 0, + 0, 64, 65, 351, 352, 353, 0, 0, 0, 0, + 0, 329, 333, 334, 335, 355, 0, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 0, + 350, 0, 0, 0, 64, 65, 351, 352, 353, 0, + 0, 0, 0, 0, 329, 333, 334, 335, 355, 0, + 0, 0, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 0, 350, 0, 0, 0, 64, 65, 351, + 352, 353, 0, 0, 0, 0, 0, 329, 335, 0, + 0, 355, 0, 340, 341, 342, 343, 344, 345, 346, + 0, 0, 0, 0, 350, 0, 0, 0, 0, 65, + 0, 352, 353, 0, 0, 0, 0, 0, 329, 0, + 0, 0, 355, 340, 341, 342, 343, 344, 345, 346, + 0, 0, 0, 0, 350, 0, 0, 0, 0, 65, + 0, 0, 353, 0, 0, 0, 0, 0, 329, 0, + 0, 0, 355 }; static const yytype_int16 yycheck[] = { - 7, 76, 153, 22, 32, 3, 13, 284, 99, 167, - 313, 3, 657, 142, 3, 68, 657, 657, 110, 545, - 657, 104, 786, 313, 732, 52, 118, 288, 120, 46, - 0, 75, 46, 40, 52, 47, 52, 48, 49, 60, - 32, 567, 45, 619, 61, 45, 70, 58, 61, 61, - 139, 75, 47, 56, 53, 99, 56, 56, 71, 66, - 46, 68, 52, 70, 108, 72, 61, 74, 75, 76, - 77, 78, 111, 80, 81, 82, 95, 90, 46, 103, - 97, 71, 72, 175, 97, 97, 113, 79, 391, 79, - 97, 83, 99, 857, 670, 113, 103, 113, 53, 402, - 90, 391, 97, 93, 61, 52, 61, 75, 47, 99, - 60, 47, 402, 46, 878, 122, 44, 56, 52, 126, - 110, 111, 46, 52, 7, 61, 59, 60, 135, 136, - 13, 839, 46, 140, 141, 142, 52, 71, 72, 222, - 97, 72, 97, 46, 60, 79, 153, 53, 79, 60, - 56, 75, 47, 47, 47, 47, 90, 40, 165, 93, - 60, 97, 93, 56, 322, 99, 61, 61, 99, 61, - 696, 79, 179, 48, 49, 83, 110, 111, 52, 110, - 111, 442, 827, 66, 191, 68, 827, 827, 52, 72, - 827, 74, 75, 76, 77, 78, 60, 80, 81, 82, - 329, 290, 97, 97, 293, 97, 47, 296, 297, 60, - 47, 300, 301, 80, 58, 56, 44, 84, 85, 56, - 103, 37, 38, 39, 52, 354, 53, 44, 44, 73, - 74, 48, 49, 49, 101, 52, 52, 81, 515, 122, - 3, 58, 58, 126, 56, 89, 50, 51, 9, 46, - 11, 58, 135, 136, 15, 16, 100, 140, 141, 22, - 521, 105, 47, 107, 59, 109, 110, 111, 529, 530, - 153, 56, 364, 46, 35, 48, 49, 284, 44, 371, - 47, 373, 48, 49, 376, 44, 58, 60, 59, 47, - 593, 53, 58, 52, 61, 52, 179, 69, 56, 87, - 88, 73, 74, 56, 71, 59, 94, 70, 191, 81, - 73, 59, 75, 76, 46, 313, 79, 89, 46, 326, - 83, 313, 329, 90, 313, 332, 333, 380, 100, 53, - 97, 58, 53, 105, 50, 107, 99, 109, 110, 111, - 101, 52, 3, 53, 71, 72, 504, 354, 440, 71, - 72, 44, 79, 59, 60, 46, 49, 79, 53, 52, - 367, 22, 60, 90, 392, 58, 93, 53, 90, 91, - 52, 93, 99, 380, 46, 394, 46, 99, 139, 50, - 51, 388, 389, 110, 46, 56, 59, 60, 110, 111, - 397, 59, 3, 391, 655, 402, 527, 528, 52, 391, - 392, 52, 391, 410, 402, 47, 167, 59, 52, 70, - 402, 22, 73, 402, 75, 76, 44, 60, 79, 52, - 48, 49, 83, 46, 452, 44, 555, 52, 59, 48, - 49, 53, 58, 52, 99, 564, 443, 47, 99, 58, - 59, 53, 46, 326, 60, 50, 51, 73, 74, 332, - 457, 56, 50, 51, 72, 81, 53, 60, 56, 70, - 452, 53, 73, 89, 75, 76, 60, 558, 79, 476, - 477, 463, 83, 60, 100, 53, 52, 469, 53, 105, - 60, 107, 489, 46, 367, 111, 59, 59, 99, 75, - 46, 60, 621, 154, 71, 72, 60, 380, 52, 52, - 592, 52, 79, 52, 52, 388, 389, 46, 515, 46, - 78, 0, 58, 90, 397, 53, 93, 60, 610, 611, - 612, 284, 99, 59, 653, 59, 601, 410, 60, 290, - 537, 53, 293, 110, 111, 296, 297, 53, 47, 300, - 301, 46, 52, 154, 58, 60, 309, 55, 555, 60, - 313, 558, 52, 60, 60, 53, 714, 564, 633, 717, - 443, 322, 569, 50, 60, 60, 60, 60, 575, 58, - 52, 60, 61, 56, 457, 55, 53, 53, 570, 571, - 572, 56, 53, 56, 73, 74, 52, 46, 53, 581, - 60, 60, 81, 476, 477, 593, 53, 55, 60, 367, - 89, 153, 311, 92, 534, 30, 469, 3, 97, 628, - 778, 100, 619, 876, 621, 671, 105, 746, 107, 579, - 109, 110, 111, 284, 616, 776, 22, 619, 391, 773, - 579, 394, 569, 616, 839, 313, 793, 544, -1, 402, - 769, 593, -1, 333, -1, -1, 653, -1, 309, -1, - 657, -1, 313, -1, 537, -1, -1, -1, -1, 657, - 679, -1, -1, 670, 671, 657, -1, -1, -1, -1, - 677, -1, -1, 284, -1, -1, 683, 73, 670, 75, - 76, -1, -1, 79, -1, -1, 569, 83, 71, 72, - -1, -1, 575, -1, -1, -1, 79, 358, 309, -1, - -1, 693, 313, 832, -1, 712, -1, 90, -1, -1, - 93, -1, -1, -1, -1, -1, 99, -1, -1, 726, - 748, 728, 729, 730, -1, 732, -1, 110, 111, 490, - 391, -1, 824, 394, -1, -1, 865, 744, -1, 746, - -1, 402, -1, 504, -1, -1, -1, 358, -1, -1, - -1, -1, 515, -1, -1, -1, 748, -1, 154, -1, - 71, 72, 769, -1, -1, -1, -1, -1, 79, 532, - -1, 33, 34, -1, -1, 782, -1, 538, 785, 90, - 391, 43, 93, 394, 46, 47, -1, -1, 99, -1, - 52, 402, 54, -1, 677, 558, 58, -1, -1, 110, - 683, 63, -1, -1, 66, 67, 68, -1, -1, 71, - 72, -1, -1, -1, -1, 77, 579, 79, -1, 81, - 827, -1, -1, -1, -1, 832, -1, -1, 90, 827, - 593, 93, 839, -1, -1, 827, -1, 99, 601, -1, - -1, 833, -1, 726, -1, 728, 729, 730, 110, 111, - 112, 113, -1, -1, 515, -1, 619, -1, 865, -1, - -1, 744, -1, -1, -1, 628, -1, 70, 860, -1, - 633, 532, 75, 76, -1, -1, -1, 80, 885, -1, - 83, 84, 85, -1, -1, -1, -1, -1, -1, -1, - 93, -1, 95, 96, 657, -1, -1, 558, 101, -1, - -1, 47, 785, 106, 515, -1, -1, 670, 671, -1, - -1, -1, 58, 309, -1, 61, 679, 313, 579, -1, - -1, 532, -1, -1, -1, -1, -1, 73, 74, -1, - -1, -1, 593, -1, -1, 81, -1, -1, -1, -1, - 601, -1, -1, 89, -1, -1, -1, 558, -1, -1, - -1, 97, -1, 714, 100, -1, 717, -1, 619, 105, - -1, 107, 358, 109, 110, 111, -1, 628, -1, 732, - -1, -1, 633, -1, -1, -1, -1, 58, -1, -1, - 61, -1, 593, -1, -1, -1, -1, -1, -1, -1, - 601, 72, 73, 74, -1, 391, 657, -1, 394, -1, - 81, -1, 885, -1, -1, -1, 402, -1, 89, 670, - 671, -1, -1, -1, -1, -1, 97, 628, 679, 100, - 58, -1, 633, 61, 105, -1, 107, 98, -1, 100, - 111, -1, 103, -1, 105, 73, 74, -1, 109, -1, - -1, 702, -1, 81, -1, -1, 657, -1, 119, -1, - -1, 89, -1, -1, -1, -1, -1, -1, -1, 97, - -1, -1, 100, -1, 827, -1, -1, 105, 679, 107, - -1, -1, -1, 111, -1, -1, 839, -1, -1, 150, - 151, 152, 153, 154, 155, -1, -1, -1, -1, -1, - -1, 702, -1, -1, 33, 34, 35, 36, 37, 38, - 39, -1, -1, -1, -1, 44, -1, 33, 34, -1, - 49, -1, 773, 52, -1, -1, -1, 43, -1, 58, - 46, -1, -1, 62, -1, 786, 52, -1, 54, -1, - -1, -1, 58, -1, -1, -1, 532, 63, -1, -1, - 66, 67, 68, -1, -1, 71, 72, 73, 74, -1, - -1, -1, -1, 79, -1, 81, -1, -1, -1, -1, - -1, -1, 773, 89, 90, -1, 827, 93, -1, -1, - -1, -1, -1, 99, 100, 786, -1, -1, -1, 105, - -1, 107, -1, 109, 110, 111, 112, 113, 47, -1, - -1, -1, -1, -1, -1, -1, -1, 593, -1, 58, - -1, 60, 61, -1, -1, 601, -1, -1, -1, 68, - -1, -1, 71, 72, 73, 74, 827, -1, -1, -1, - 79, -1, 81, 82, -1, -1, -1, 86, -1, -1, - 89, 90, 628, -1, 93, -1, -1, 633, 97, 98, - 99, 100, -1, 102, -1, -1, 105, -1, 107, -1, - -1, 110, 111, -1, -1, -1, 327, -1, -1, -1, - -1, 657, -1, 334, 335, 336, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, 352, -1, 679, 355, 356, -1, 358, -1, -1, - -1, 33, 34, -1, 365, -1, -1, -1, 369, -1, - -1, 43, -1, -1, 46, -1, 702, 378, -1, -1, - 52, -1, 54, -1, -1, -1, 58, -1, -1, -1, - -1, 63, -1, -1, 66, 67, 68, -1, -1, 71, - 72, 73, 74, -1, 405, 77, -1, 79, -1, 81, - -1, -1, -1, -1, -1, -1, -1, 89, 90, -1, - -1, 93, -1, -1, -1, -1, -1, 99, 100, -1, - -1, 432, -1, 105, -1, 107, -1, -1, 110, 111, - 112, 113, -1, -1, -1, -1, -1, 773, -1, -1, - -1, 33, 34, -1, -1, -1, -1, -1, -1, -1, - 786, 43, -1, -1, 46, -1, -1, -1, -1, -1, - 52, -1, 54, -1, -1, -1, 58, -1, -1, -1, - -1, -1, -1, 484, 66, 67, 68, -1, -1, 71, - 72, 73, 74, -1, -1, -1, -1, 79, -1, 81, - -1, 827, -1, -1, -1, -1, -1, 89, 90, -1, - 511, 93, -1, 514, -1, -1, -1, 99, 100, -1, - -1, -1, -1, 105, -1, 107, -1, -1, 110, 111, - 112, 113, -1, -1, -1, 536, -1, -1, 33, 34, - -1, -1, -1, -1, 545, -1, -1, 548, 43, -1, - 551, 46, 47, 554, -1, 556, -1, 52, -1, 54, - -1, -1, -1, 58, -1, -1, 567, -1, 63, -1, - -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, - -1, -1, 77, -1, 79, -1, 81, -1, -1, -1, - -1, -1, -1, -1, -1, 90, -1, -1, 93, -1, - -1, -1, -1, 28, 99, -1, -1, -1, 33, 34, - 35, 36, 37, 38, 39, 110, 111, 112, 113, 44, - -1, -1, 623, -1, 49, -1, 51, 52, -1, -1, - 33, 34, -1, 58, -1, -1, -1, 62, -1, -1, - 43, -1, -1, 46, -1, -1, -1, -1, -1, 52, - -1, 54, -1, -1, -1, 58, -1, 658, 659, 660, - 63, -1, -1, 66, 67, 68, -1, -1, 71, 72, - -1, -1, -1, -1, 77, -1, 79, -1, 81, -1, - -1, -1, -1, -1, -1, -1, -1, 90, -1, -1, - 93, -1, -1, 694, -1, 696, 99, 698, 699, 700, - -1, 702, 703, -1, 26, 27, 28, 110, 111, 112, - 113, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, - 52, -1, -1, -1, -1, 736, 58, -1, -1, -1, - 62, -1, -1, -1, -1, -1, -1, -1, 749, 750, - 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, - 761, 762, 763, 764, 765, 766, 767, -1, -1, 770, - 771, -1, 773, -1, -1, 776, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 786, -1, 33, 34, -1, - -1, -1, 793, -1, -1, 796, -1, 43, -1, -1, + 7, 95, 77, 152, 166, 98, 13, 22, 3, 69, + 285, 3, 654, 556, 654, 391, 392, 3, 654, 654, + 103, 391, 392, 142, 52, 52, 801, 52, 640, 46, + 573, 0, 131, 132, 41, 109, 48, 49, 289, 844, + 139, 47, 47, 117, 61, 119, 58, 44, 61, 70, + 56, 48, 49, 47, 75, 52, 61, 75, 48, 49, + 67, 58, 69, 47, 71, 47, 73, 61, 75, 76, + 77, 78, 79, 47, 81, 82, 83, 61, 883, 61, + 97, 99, 103, 695, 97, 113, 113, 61, 113, 96, + 108, 98, 97, 46, 80, 102, 871, 71, 84, 904, + 476, 175, 53, 97, 7, 56, 476, 46, 46, 72, + 13, 58, 47, 97, 121, 97, 90, 47, 125, 134, + 3, 46, 75, 97, 71, 72, 61, 60, 135, 136, + 93, 61, 79, 140, 141, 142, 99, 75, 41, 22, + 223, 47, 47, 90, 111, 152, 93, 110, 111, 80, + 56, 56, 99, 84, 796, 46, 796, 164, 144, 321, + 796, 796, 97, 110, 67, 52, 69, 97, 59, 60, + 73, 61, 75, 76, 77, 78, 79, 47, 81, 82, + 83, 71, 433, 87, 88, 192, 56, 47, 71, 44, + 94, 74, 291, 76, 77, 294, 56, 80, 0, 102, + 90, 84, 301, 302, 50, 51, 60, 97, 47, 328, + 56, 3, 487, 756, 590, 98, 53, 56, 121, 56, + 52, 52, 125, 80, 37, 38, 39, 84, 85, 60, + 22, 44, 135, 136, 353, 53, 49, 140, 141, 52, + 50, 51, 3, 494, 101, 58, 52, 71, 72, 152, + 451, 502, 503, 454, 60, 79, 58, 44, 60, 61, + 46, 22, 48, 49, 46, 52, 90, 52, 44, 93, + 60, 73, 74, 46, 60, 99, 52, 60, 285, 81, + 59, 60, 74, 60, 76, 77, 110, 89, 80, 192, + 92, 53, 84, 46, 368, 97, 370, 44, 100, 373, + 58, 48, 49, 105, 59, 107, 44, 109, 110, 111, + 71, 49, 52, 74, 52, 76, 77, 377, 325, 80, + 58, 328, 52, 84, 331, 332, 50, 51, 71, 72, + 44, 59, 56, 56, 48, 49, 79, 98, 52, 59, + 60, 71, 72, 53, 58, 59, 353, 90, 91, 79, + 93, 59, 45, 56, 56, 362, 99, 431, 365, 59, + 90, 153, 46, 93, 46, 46, 3, 110, 111, 99, + 377, 46, 58, 53, 468, 61, 53, 56, 385, 44, + 110, 111, 544, 48, 49, 22, 72, 73, 74, 50, + 52, 46, 153, 58, 401, 81, 391, 392, 492, 391, + 392, 53, 285, 89, 390, 391, 392, 53, 53, 56, + 60, 97, 52, 46, 100, 46, 52, 491, 52, 105, + 671, 107, 325, 52, 59, 111, 53, 59, 331, 99, + 47, 550, 60, 59, 71, 60, 52, 74, 52, 76, + 77, 448, 53, 80, 459, 47, 47, 84, 53, 456, + 53, 47, 60, 60, 47, 46, 53, 72, 465, 362, + 46, 98, 365, 52, 47, 60, 585, 59, 53, 476, + 60, 52, 52, 52, 377, 46, 462, 52, 60, 52, + 487, 476, 385, 490, 476, 53, 60, 59, 75, 58, + 476, 47, 46, 9, 78, 11, 589, 60, 401, 15, + 16, 508, 46, 510, 47, 60, 389, 53, 391, 392, + 517, 52, 79, 53, 500, 501, 153, 52, 504, 58, + 36, 528, 60, 642, 285, 59, 59, 52, 55, 60, + 71, 72, 60, 607, 608, 609, 60, 60, 79, 60, + 46, 58, 53, 550, 53, 448, 50, 60, 622, 90, + 669, 558, 93, 456, 629, 53, 73, 74, 99, 46, + 60, 52, 465, 55, 81, 357, 52, 56, 56, 110, + 111, 53, 89, 648, 53, 56, 459, 739, 585, 53, + 742, 365, 589, 100, 100, 60, 55, 490, 105, 60, + 107, 598, 60, 476, 111, 590, 357, 389, 747, 391, + 392, 152, 390, 505, 487, 508, 30, 510, 749, 624, + 462, 597, 879, 570, 517, 131, 132, 71, 72, 696, + 570, 792, 558, 139, 661, 79, 871, 851, 389, 392, + 391, 392, 590, 640, 571, 642, 90, 332, -1, 93, + -1, -1, -1, -1, -1, 99, 765, 654, 285, -1, + 166, -1, -1, 639, -1, 558, 110, 111, -1, 654, + 675, -1, 669, -1, -1, -1, 673, 459, 654, 788, + 58, -1, 679, 767, -1, 661, -1, 560, -1, -1, + -1, 69, -1, -1, 476, 73, 74, 570, 695, 696, + -1, -1, -1, 81, -1, 598, -1, -1, 459, -1, + 707, 89, 709, 710, 711, -1, 589, 590, -1, -1, + 71, 72, 100, -1, -1, 476, -1, 105, 79, 107, + 357, 109, 110, 111, -1, -1, 487, -1, -1, 90, + 737, -1, 93, -1, -1, -1, -1, -1, 99, -1, + -1, 624, -1, -1, -1, 864, 629, -1, -1, 110, + 111, -1, 389, -1, 391, 392, 763, 640, 765, 878, + -1, -1, 836, -1, -1, 648, -1, 753, 560, -1, + 673, 654, 58, -1, -1, 291, 679, -1, 294, -1, + -1, 788, -1, -1, -1, 301, 302, 73, 74, 796, + -1, -1, 675, -1, 801, 81, -1, -1, 590, 560, + -1, 796, -1, 89, 707, 321, 709, 710, 711, -1, + 796, -1, 695, 696, 100, -1, -1, -1, -1, 105, + -1, 107, 459, 109, 110, 111, -1, -1, 589, 590, + -1, -1, 624, 840, -1, -1, 843, 629, -1, 476, + -1, -1, -1, 58, -1, -1, 61, -1, -1, -1, + 487, -1, -1, -1, -1, -1, 648, 864, 73, 74, + 763, -1, 654, 624, 871, -1, 81, -1, 629, -1, + -1, 878, -1, 97, 89, 99, -1, -1, 102, 865, + 104, -1, 97, 675, 108, 100, -1, 648, -1, -1, + 105, -1, 107, 654, 118, 902, 111, -1, -1, -1, + 886, -1, -1, -1, -1, 47, -1, -1, -1, -1, + -1, -1, -1, 796, 675, -1, 58, -1, 801, 61, + -1, -1, -1, 560, -1, 149, 150, 151, 152, 153, + 154, 73, 74, 570, -1, 727, -1, -1, -1, 81, + 843, -1, -1, -1, -1, -1, -1, 89, -1, -1, + -1, -1, 589, 590, -1, 97, -1, -1, 100, -1, + -1, -1, -1, 105, -1, 107, 727, 109, 110, 111, + -1, 70, -1, -1, -1, -1, 75, 76, -1, -1, + -1, 80, -1, -1, 83, 84, 85, 624, 871, -1, + -1, -1, 629, 509, 93, -1, 95, 96, -1, 902, + 792, -1, 101, 640, 796, -1, -1, 106, 33, 34, + -1, 648, -1, 529, -1, -1, -1, 654, 43, -1, + -1, 46, -1, -1, -1, -1, -1, 52, 544, 54, + -1, 792, -1, 58, -1, 796, -1, -1, 675, -1, + -1, 66, 67, 68, -1, -1, 71, 72, 73, 74, + -1, -1, 844, -1, 79, -1, 81, -1, 695, 696, + -1, -1, -1, -1, 89, 90, -1, -1, 93, -1, + -1, -1, -1, -1, 99, 100, -1, -1, -1, -1, + 105, -1, 107, 844, -1, 110, 111, 112, 113, -1, + 727, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 326, -1, -1, -1, -1, -1, -1, 333, + 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, 347, 348, 349, 350, 351, -1, -1, + 354, 355, -1, 357, -1, -1, -1, -1, -1, 363, + -1, -1, 366, -1, -1, -1, -1, -1, -1, -1, + -1, 375, -1, -1, -1, 792, -1, 28, -1, 796, + -1, -1, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 396, 44, -1, -1, 33, 34, 49, -1, + 51, 52, -1, -1, -1, -1, 43, 58, -1, 46, + -1, 62, -1, -1, -1, 52, -1, 54, -1, 423, + -1, 58, -1, -1, -1, -1, 63, 844, -1, 66, + 67, 68, -1, -1, 71, 72, 73, 74, -1, -1, + -1, -1, 79, 739, 81, -1, 742, -1, -1, -1, + -1, -1, 89, 90, -1, -1, 93, -1, -1, -1, + -1, -1, 99, 100, -1, -1, -1, -1, 105, -1, + 107, -1, 109, 110, 111, 112, 113, 33, 34, 483, + -1, -1, 486, -1, -1, -1, -1, 43, -1, -1, 46, -1, -1, -1, -1, -1, 52, -1, 54, -1, - -1, -1, 58, -1, -1, -1, -1, 63, -1, 820, - 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, + -1, -1, 58, -1, -1, -1, -1, 63, -1, -1, + 66, 67, 68, -1, -1, 71, 72, 73, 74, 523, -1, 77, -1, 79, -1, 81, -1, -1, -1, -1, - -1, 842, 843, -1, 90, -1, 847, 93, -1, 850, - -1, -1, -1, 99, -1, -1, 857, 858, 859, -1, - -1, -1, -1, -1, 110, 111, 112, 113, -1, -1, - -1, -1, -1, -1, -1, 876, -1, 878, 22, 23, + -1, -1, -1, 89, 90, -1, -1, 93, -1, -1, + -1, -1, -1, 99, 100, -1, -1, -1, -1, 105, + -1, 107, 556, -1, 110, 111, 112, 113, -1, -1, + -1, -1, -1, -1, 568, 33, 34, -1, -1, 573, + -1, -1, -1, -1, 578, 43, -1, 581, 46, 47, + 584, -1, 586, -1, 52, -1, 54, -1, -1, -1, + 58, -1, -1, -1, -1, 63, -1, -1, 66, 67, + 68, -1, -1, 71, 72, -1, -1, -1, -1, 77, + -1, 79, -1, 81, -1, -1, -1, -1, -1, -1, + -1, -1, 90, -1, -1, 93, -1, -1, -1, -1, + -1, 99, -1, -1, -1, -1, 33, 34, -1, -1, + 644, -1, 110, 111, 112, 113, 43, -1, -1, 46, + 47, 655, 656, 657, -1, 52, -1, 54, -1, -1, + -1, 58, -1, -1, -1, -1, 63, -1, -1, 66, + 67, 68, -1, -1, 71, 72, -1, -1, -1, -1, + 77, -1, 79, -1, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 90, -1, -1, 93, -1, -1, -1, + -1, -1, 99, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 110, 111, 112, 113, -1, -1, 723, + 724, 725, -1, 727, 728, 28, -1, -1, -1, -1, + 33, 34, 35, 36, 37, 38, 39, -1, 41, 42, + -1, 44, -1, 747, -1, -1, 49, -1, 51, 52, + 754, -1, 756, -1, -1, 58, -1, -1, -1, 62, + -1, -1, -1, -1, 768, 769, 770, 771, 772, 773, + 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, + 784, 785, 786, -1, 28, 789, 790, -1, 792, 33, + 34, 35, 36, 37, 38, 39, -1, 41, -1, 47, + 44, -1, 806, -1, 808, 49, -1, 51, 52, -1, + 58, -1, 60, 61, 58, -1, -1, -1, 62, -1, + 68, -1, -1, 71, 72, 73, 74, -1, 832, -1, + -1, 79, -1, 81, 82, -1, -1, -1, 86, -1, + 844, 89, 90, -1, -1, 93, -1, 851, -1, 97, + 98, 99, 100, 857, 102, -1, 860, 105, -1, 107, + -1, -1, 110, 111, -1, -1, -1, -1, -1, -1, + 874, 875, -1, -1, -1, 879, -1, -1, -1, 883, + 884, 885, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, -1, -1, 26, 27, + 904, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, -1, 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, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 22, -1, -1, -1, + 26, 27, -1, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 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, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 22, -1, -1, -1, 26, 27, -1, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, -1, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 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, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 22, -1, -1, -1, 26, 27, -1, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 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, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 22, -1, -1, -1, 26, 27, -1, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 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, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 33, 34, -1, -1, -1, -1, - -1, -1, -1, -1, 43, -1, -1, 46, -1, -1, - -1, -1, -1, 52, -1, 54, -1, -1, -1, 58, - -1, -1, -1, -1, 63, -1, -1, 66, 67, 68, - -1, -1, 71, 72, -1, -1, -1, -1, -1, -1, - 79, -1, 81, 33, 34, -1, -1, -1, -1, -1, - -1, 90, -1, 43, 93, -1, 46, -1, -1, -1, - 99, -1, 52, -1, 54, -1, -1, -1, 58, -1, - 60, 110, 111, 112, 113, -1, 66, 67, 68, -1, - -1, 71, 72, -1, -1, -1, -1, -1, -1, 79, - -1, 81, 33, 34, -1, -1, -1, -1, -1, -1, - 90, -1, 43, 93, -1, -1, 47, -1, -1, 99, - -1, 52, -1, 54, -1, -1, -1, 58, -1, -1, - 110, 111, 112, 113, -1, 66, 67, 68, -1, -1, - 71, 72, -1, -1, -1, -1, 77, -1, 79, -1, - 81, 33, 34, -1, -1, -1, -1, -1, -1, 90, - -1, 43, 93, -1, 46, 47, -1, -1, 99, -1, - 52, -1, 54, -1, -1, -1, 58, -1, -1, 110, - 111, 112, 113, -1, 66, 67, 68, -1, -1, 71, - 72, -1, -1, -1, -1, -1, -1, 79, -1, 81, - 33, 34, -1, -1, -1, -1, -1, -1, 90, -1, - 43, 93, -1, 46, -1, -1, -1, 99, -1, 52, - -1, 54, -1, -1, -1, 58, -1, -1, 110, 111, - 112, 113, -1, 66, 67, 68, -1, -1, 71, 72, + 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, + 43, -1, -1, 46, -1, -1, -1, -1, -1, 52, + 53, 54, -1, -1, -1, 58, -1, -1, -1, -1, + 63, -1, -1, 66, 67, 68, -1, -1, 71, 72, + -1, -1, -1, -1, -1, -1, 79, -1, 81, 33, + 34, -1, -1, -1, -1, -1, -1, 90, -1, 43, + 93, 45, 46, -1, -1, -1, 99, -1, 52, -1, + 54, -1, 56, -1, 58, -1, -1, 110, 111, 112, + 113, -1, 66, 67, 68, -1, -1, 71, 72, -1, + -1, -1, -1, -1, -1, 79, -1, 81, 33, 34, + -1, -1, -1, -1, -1, -1, 90, -1, 43, 93, + -1, 46, 47, -1, -1, 99, -1, 52, -1, 54, + -1, 56, -1, 58, -1, -1, 110, 111, 112, 113, + -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, + -1, -1, -1, -1, 79, -1, 81, 33, 34, -1, + -1, -1, -1, -1, -1, 90, -1, 43, 93, -1, + 46, -1, -1, -1, 99, -1, 52, 53, 54, -1, + 56, -1, 58, -1, -1, 110, 111, 112, 113, -1, + 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, + -1, -1, -1, 79, -1, 81, -1, -1, 33, 34, + -1, -1, -1, -1, 90, -1, -1, 93, 43, -1, + -1, 46, -1, 99, -1, -1, -1, 52, -1, 54, + -1, -1, -1, 58, 110, 111, 112, 113, 63, -1, + -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, + -1, -1, 77, -1, 79, -1, 81, -1, -1, 33, + 34, -1, -1, -1, -1, 90, -1, -1, 93, 43, + -1, -1, 46, -1, 99, -1, -1, -1, 52, -1, + 54, -1, -1, -1, 58, 110, 111, 112, 113, 63, + -1, -1, 66, 67, 68, -1, -1, 71, 72, -1, + -1, -1, -1, 77, -1, 79, -1, 81, -1, -1, + 33, 34, -1, -1, -1, -1, 90, -1, -1, 93, + 43, -1, -1, 46, -1, 99, -1, -1, -1, 52, + -1, 54, -1, -1, -1, 58, 110, 111, 112, 113, + 63, -1, -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, -1, -1, -1, 79, -1, 81, 33, 34, -1, -1, -1, -1, -1, -1, 90, -1, 43, 93, -1, 46, -1, -1, -1, 99, -1, 52, -1, - 54, -1, -1, -1, 58, -1, -1, 110, 111, 112, + 54, -1, -1, -1, 58, -1, 60, 110, 111, 112, 113, -1, 66, 67, 68, -1, -1, 71, 72, -1, - -1, -1, -1, -1, -1, 79, -1, 81, -1, -1, - -1, -1, -1, -1, -1, -1, 90, -1, -1, 93, - 47, -1, -1, -1, -1, 99, -1, -1, -1, -1, - -1, 58, -1, 60, 61, -1, 110, 111, 112, 113, - -1, 68, -1, -1, 71, 72, 73, 74, -1, -1, - -1, -1, 79, -1, 81, -1, -1, -1, -1, 86, - -1, -1, 89, 90, -1, -1, 93, -1, 47, -1, - 97, -1, 99, 100, -1, -1, -1, 104, 105, 58, - 107, 60, 61, 110, 111, -1, -1, -1, -1, 68, + -1, -1, -1, -1, -1, 79, -1, 81, 33, 34, + -1, -1, -1, -1, -1, -1, 90, -1, 43, 93, + -1, -1, 47, -1, -1, 99, -1, 52, -1, 54, + -1, -1, -1, 58, -1, -1, 110, 111, 112, 113, + -1, 66, 67, 68, -1, -1, 71, 72, -1, -1, + -1, -1, 77, -1, 79, -1, 81, 33, 34, -1, + -1, -1, -1, -1, -1, 90, -1, 43, 93, -1, + 46, 47, -1, -1, 99, -1, 52, -1, 54, -1, + -1, -1, 58, -1, -1, 110, 111, 112, 113, -1, + 66, 67, 68, -1, -1, 71, 72, -1, -1, -1, + -1, -1, -1, 79, -1, 81, 33, 34, -1, -1, + -1, -1, -1, -1, 90, -1, 43, 93, -1, 46, + -1, -1, -1, 99, -1, 52, -1, 54, -1, -1, + -1, 58, -1, -1, 110, 111, 112, 113, -1, 66, + 67, 68, -1, -1, 71, 72, -1, -1, -1, -1, + -1, -1, 79, -1, 81, -1, -1, -1, -1, -1, + -1, -1, -1, 90, -1, -1, 93, 47, -1, -1, + -1, -1, 99, -1, -1, -1, -1, -1, 58, -1, + 60, 61, -1, 110, 111, 112, 113, -1, 68, -1, + -1, 71, 72, 73, 74, -1, -1, -1, -1, 79, + -1, 81, -1, -1, -1, -1, 86, -1, -1, 89, + 90, -1, -1, 93, -1, 47, -1, 97, -1, 99, + 100, -1, -1, -1, 104, 105, 58, 107, 60, 61, + 110, 111, -1, -1, -1, -1, 68, -1, -1, 71, + 72, 73, 74, -1, -1, -1, -1, 79, -1, 81, + -1, -1, -1, -1, 86, -1, -1, 89, 90, -1, + -1, 93, -1, -1, -1, 97, -1, 99, 100, 58, + -1, -1, -1, 105, 63, 107, -1, -1, 110, 111, -1, -1, 71, 72, 73, 74, -1, -1, -1, -1, - 79, -1, 81, -1, -1, -1, -1, 86, -1, -1, - 89, 90, -1, -1, 93, -1, -1, -1, 97, -1, - 99, 100, 58, -1, -1, -1, 105, 63, 107, -1, - -1, 110, 111, -1, -1, 71, 72, 73, 74, -1, + 79, -1, 81, -1, -1, -1, -1, -1, -1, -1, + 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, + 99, 100, 58, -1, -1, -1, 105, -1, 107, -1, + 109, 110, 111, -1, -1, 71, 72, 73, 74, -1, -1, -1, -1, 79, -1, 81, -1, -1, -1, -1, -1, -1, -1, 89, 90, -1, -1, 93, -1, -1, - -1, -1, -1, 99, 100, 58, -1, -1, -1, 105, - -1, 107, -1, 109, 110, 111, -1, -1, 71, 72, - 73, 74, -1, -1, -1, -1, 79, -1, 81, -1, - -1, -1, -1, -1, -1, -1, 89, 90, -1, -1, - 93, -1, -1, -1, -1, -1, 99, 100, -1, -1, - -1, -1, 105, -1, 107, -1, 109, 110, 111, 58, - -1, 60, 61, -1, -1, -1, -1, -1, -1, 68, - -1, -1, 71, 72, -1, -1, -1, -1, -1, -1, - 79, -1, -1, 82, -1, -1, -1, 86, -1, -1, - -1, 90, 58, -1, 93, -1, -1, -1, 97, 98, - 99, -1, -1, 102, -1, 71, 72, 73, 74, -1, - -1, 110, 111, 79, -1, 81, -1, -1, -1, -1, - -1, -1, -1, 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, 99, 100, -1, -1, -1, -1, 105, - -1, 107, -1, -1, 110, 111, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, - 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, - -1, -1, 62, -1, 64, 65, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, - 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, - -1, -1, 62, -1, 64, 65, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, - 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, - -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, + -1, 107, -1, 109, 110, 111, 58, -1, 60, 61, + -1, -1, -1, -1, -1, -1, 68, -1, -1, 71, + 72, -1, -1, -1, -1, -1, -1, 79, -1, -1, + 82, -1, -1, -1, 86, -1, -1, -1, 90, 58, + -1, 93, -1, -1, -1, 97, 98, 99, -1, -1, + 102, -1, 71, 72, 73, 74, -1, -1, 110, 111, + 79, -1, 81, -1, -1, -1, -1, -1, -1, -1, + 89, 90, -1, -1, 93, -1, -1, -1, -1, -1, + 99, 100, -1, -1, -1, -1, 105, -1, 107, -1, + -1, 110, 111, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, + 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, + -1, 64, 65, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, + -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, + -1, 64, 65, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, @@ -1773,14 +1809,14 @@ static const yytype_int16 yycheck[] = -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, - 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, + 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, - -1, -1, -1, 48, 49, 50, 51, 52, 53, -1, + 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, @@ -1795,33 +1831,33 @@ static const yytype_int16 yycheck[] = -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, - -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, + -1, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, - 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, - 60, -1, 62, 26, 27, 28, 29, 30, 31, 32, + 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, + -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, - -1, -1, 48, 49, 50, 51, 52, 53, -1, -1, - -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, + -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, + -1, 57, 58, -1, 60, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, - 52, -1, -1, -1, -1, 57, 58, -1, 60, -1, + 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, - 45, -1, -1, 48, 49, 50, 51, 52, -1, -1, - -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, + -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, + -1, -1, 57, 58, -1, 60, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, - 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, + 38, 39, 40, 41, 42, -1, 44, 45, -1, -1, + 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, @@ -1832,7 +1868,7 @@ static const yytype_int16 yycheck[] = -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, - -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, + -1, 48, 49, 50, 51, 52, 53, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, @@ -1842,12 +1878,12 @@ static const yytype_int16 yycheck[] = -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, - -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, + 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, + -1, -1, 48, 49, 50, 51, 52, -1, -1, 55, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, - 49, 50, 51, 52, -1, -1, -1, 56, 57, 58, + 39, 40, 41, 42, -1, 44, 45, -1, -1, 48, + 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, @@ -1855,31 +1891,35 @@ static const yytype_int16 yycheck[] = 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, - -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, + -1, 56, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, - 51, 52, -1, -1, -1, -1, -1, 58, -1, -1, - -1, 62, 26, 27, 28, 29, -1, 31, 32, 33, + 51, 52, -1, -1, -1, -1, 57, 58, -1, -1, + -1, 62, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, + 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, + -1, -1, -1, -1, 58, -1, -1, -1, 62, 26, + 27, 28, 29, -1, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, + -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, + -1, 58, 26, 27, 28, 62, -1, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, -1, 58, 26, 27, 28, 62, -1, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + -1, -1, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, 44, -1, -1, -1, 48, 49, 50, 51, 52, -1, -1, -1, -1, -1, 58, 28, -1, -1, 62, -1, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, -1, -1, -1, -1, 49, - -1, 51, 52, -1, -1, -1, -1, -1, 58, 28, - -1, -1, 62, -1, 33, 34, 35, 36, 37, 38, - 39, -1, 41, 42, -1, 44, -1, -1, -1, -1, - 49, -1, 51, 52, -1, -1, -1, -1, -1, 58, - 28, -1, -1, 62, -1, 33, 34, 35, 36, 37, - 38, 39, -1, 41, -1, -1, 44, -1, -1, -1, - -1, 49, -1, 51, 52, -1, -1, -1, -1, -1, - 58, -1, -1, -1, 62 + -1, -1, -1, -1, 44, -1, -1, -1, -1, 49, + -1, 51, 52, -1, -1, -1, -1, -1, 58, -1, + -1, -1, 62, 33, 34, 35, 36, 37, 38, 39, + -1, -1, -1, -1, 44, -1, -1, -1, -1, 49, + -1, -1, 52, -1, -1, -1, -1, -1, 58, -1, + -1, -1, 62 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing @@ -1888,93 +1928,95 @@ static const yytype_int16 yystos[] = { 0, 119, 120, 121, 0, 58, 60, 61, 73, 74, 81, 89, 92, 97, 100, 105, 107, 109, 110, 111, - 122, 127, 128, 129, 138, 141, 146, 147, 152, 173, - 174, 180, 184, 187, 189, 190, 191, 192, 193, 194, - 195, 203, 204, 205, 208, 209, 214, 219, 220, 222, - 247, 249, 252, 71, 72, 79, 90, 93, 99, 110, - 111, 123, 124, 48, 49, 263, 46, 263, 46, 124, - 263, 263, 70, 75, 76, 80, 83, 84, 85, 93, - 95, 96, 101, 106, 81, 129, 187, 60, 111, 52, - 60, 145, 60, 145, 127, 128, 230, 52, 44, 263, - 44, 124, 60, 44, 52, 52, 113, 124, 221, 52, - 113, 221, 130, 63, 109, 123, 187, 199, 200, 52, - 113, 124, 187, 124, 111, 124, 187, 110, 123, 124, - 184, 187, 124, 124, 127, 187, 204, 124, 124, 124, - 187, 204, 52, 127, 134, 135, 136, 148, 46, 46, - 33, 34, 43, 46, 52, 54, 63, 66, 67, 68, - 81, 112, 113, 123, 124, 146, 188, 190, 193, 253, - 254, 255, 261, 123, 261, 200, 261, 196, 197, 263, - 124, 132, 133, 256, 261, 130, 261, 50, 51, 264, - 47, 56, 261, 264, 47, 22, 23, 26, 27, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 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, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 131, 56, 264, 261, 264, 52, 124, - 175, 215, 124, 181, 60, 60, 206, 210, 124, 124, - 139, 153, 196, 124, 124, 253, 87, 88, 94, 137, - 53, 56, 46, 177, 231, 261, 261, 261, 132, 256, - 81, 187, 190, 193, 261, 261, 58, 59, 123, 52, - 58, 258, 53, 56, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 44, 50, 51, 52, 57, 62, 258, 263, 45, - 264, 45, 185, 124, 198, 59, 45, 56, 45, 56, - 53, 53, 124, 53, 130, 199, 53, 134, 59, 196, - 46, 216, 196, 196, 196, 196, 196, 46, 53, 187, - 136, 150, 72, 127, 128, 141, 178, 187, 238, 247, - 248, 249, 232, 47, 47, 53, 53, 124, 261, 253, - 259, 124, 255, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 50, 253, 261, 261, 63, 109, 187, 201, - 202, 261, 52, 56, 264, 261, 133, 261, 264, 264, - 53, 264, 53, 251, 261, 176, 221, 46, 182, 207, - 211, 140, 154, 212, 124, 124, 127, 141, 151, 155, - 156, 172, 248, 249, 179, 230, 103, 187, 124, 47, - 60, 68, 82, 86, 98, 102, 123, 127, 141, 146, - 190, 223, 224, 225, 226, 227, 228, 229, 230, 233, - 237, 248, 249, 257, 260, 261, 53, 124, 59, 60, - 45, 55, 261, 53, 55, 56, 264, 134, 124, 230, - 60, 52, 47, 124, 217, 218, 46, 46, 46, 52, - 52, 47, 127, 213, 59, 60, 59, 99, 108, 127, - 149, 156, 47, 124, 124, 59, 250, 60, 52, 60, - 261, 52, 123, 58, 44, 52, 59, 258, 263, 46, - 142, 261, 261, 199, 52, 53, 134, 59, 47, 56, - 183, 212, 212, 134, 134, 187, 142, 261, 124, 263, - 47, 46, 250, 251, 60, 261, 60, 261, 72, 261, - 253, 261, 200, 143, 60, 45, 253, 53, 251, 218, - 47, 127, 186, 47, 47, 53, 53, 124, 60, 157, - 190, 191, 194, 71, 90, 127, 239, 240, 60, 53, - 53, 52, 45, 55, 53, 60, 264, 47, 128, 141, - 144, 252, 53, 69, 111, 184, 60, 46, 264, 264, - 264, 59, 59, 75, 126, 47, 240, 190, 229, 46, - 253, 261, 60, 52, 184, 52, 60, 158, 52, 52, - 52, 46, 46, 72, 79, 93, 99, 110, 111, 125, - 78, 234, 53, 45, 253, 60, 134, 104, 127, 128, - 159, 160, 162, 187, 223, 224, 227, 228, 248, 249, - 261, 261, 261, 243, 241, 59, 59, 229, 33, 34, - 43, 47, 52, 54, 66, 67, 68, 77, 81, 112, - 113, 123, 146, 188, 190, 235, 236, 262, 60, 53, - 53, 91, 124, 163, 164, 46, 187, 47, 53, 53, - 53, 47, 127, 47, 242, 261, 46, 251, 261, 261, - 261, 187, 261, 261, 58, 123, 52, 258, 55, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 44, 50, 51, 52, - 57, 62, 258, 263, 60, 60, 52, 60, 161, 124, - 124, 124, 146, 244, 257, 55, 52, 63, 77, 167, - 168, 171, 245, 246, 261, 60, 53, 53, 124, 253, - 230, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 50, 253, 261, 261, 202, 261, 256, 158, 60, 60, - 60, 60, 52, 124, 63, 77, 170, 171, 261, 55, - 47, 245, 64, 65, 261, 53, 45, 55, 261, 53, - 55, 264, 53, 47, 253, 127, 53, 56, 64, 65, - 244, 261, 261, 261, 261, 52, 46, 53, 60, 169, - 171, 261, 261, 127, 45, 253, 165, 53, 56, 60, - 53, 47, 166, 167, 171, 55, 124, 60 + 122, 127, 128, 129, 140, 143, 148, 149, 154, 175, + 178, 184, 189, 191, 196, 198, 199, 200, 201, 202, + 203, 204, 214, 215, 216, 219, 222, 227, 232, 233, + 235, 264, 267, 270, 71, 72, 79, 90, 93, 99, + 110, 111, 123, 124, 48, 49, 285, 46, 285, 46, + 124, 285, 285, 70, 75, 76, 80, 83, 84, 85, + 93, 95, 96, 101, 106, 81, 129, 196, 60, 111, + 52, 60, 147, 60, 147, 271, 52, 44, 285, 44, + 124, 60, 44, 52, 52, 113, 124, 234, 52, 113, + 234, 131, 63, 109, 123, 196, 210, 211, 52, 113, + 124, 196, 124, 111, 124, 196, 110, 123, 124, 191, + 196, 124, 124, 127, 128, 196, 215, 124, 124, 124, + 196, 215, 52, 135, 136, 46, 46, 127, 244, 33, + 34, 43, 46, 52, 54, 63, 66, 67, 68, 81, + 112, 113, 123, 124, 148, 197, 199, 202, 272, 273, + 274, 281, 282, 123, 281, 211, 281, 205, 206, 285, + 124, 130, 133, 134, 275, 281, 131, 281, 50, 51, + 286, 47, 56, 281, 286, 47, 22, 23, 26, 27, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 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, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 132, 56, 286, 281, 286, 52, + 124, 179, 228, 124, 185, 60, 60, 205, 205, 124, + 124, 141, 155, 205, 124, 124, 272, 53, 127, 137, + 138, 150, 176, 46, 281, 281, 281, 133, 275, 81, + 196, 199, 202, 281, 281, 58, 59, 123, 52, 58, + 277, 53, 56, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 44, 50, 51, 52, 57, 62, 277, 285, 45, 286, + 45, 192, 207, 59, 45, 56, 56, 53, 53, 124, + 53, 131, 210, 53, 135, 59, 205, 46, 229, 205, + 46, 46, 205, 205, 46, 53, 87, 88, 94, 139, + 56, 152, 181, 245, 47, 47, 53, 53, 124, 281, + 272, 278, 124, 274, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 50, 272, 281, 281, 63, 109, 196, + 212, 213, 281, 52, 124, 209, 281, 134, 281, 286, + 286, 53, 286, 53, 269, 281, 180, 234, 46, 186, + 217, 223, 142, 156, 220, 124, 196, 138, 127, 128, + 143, 153, 157, 158, 174, 196, 266, 267, 72, 127, + 143, 182, 252, 264, 266, 267, 246, 281, 53, 124, + 59, 60, 45, 55, 281, 53, 55, 56, 286, 135, + 56, 208, 265, 60, 52, 47, 124, 230, 231, 46, + 225, 225, 52, 52, 225, 59, 60, 124, 99, 108, + 196, 127, 151, 158, 124, 183, 244, 103, 47, 60, + 68, 82, 86, 98, 102, 123, 127, 143, 148, 199, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 247, + 251, 266, 267, 276, 279, 46, 144, 281, 281, 210, + 52, 53, 124, 286, 244, 135, 59, 47, 56, 187, + 127, 218, 226, 224, 135, 135, 221, 144, 59, 124, + 285, 124, 47, 59, 268, 177, 124, 60, 52, 60, + 281, 52, 123, 58, 44, 52, 59, 277, 280, 285, + 145, 60, 45, 272, 53, 269, 231, 190, 196, 47, + 47, 53, 53, 47, 60, 281, 159, 199, 200, 203, + 268, 269, 60, 47, 46, 281, 60, 281, 72, 281, + 272, 281, 211, 47, 128, 143, 146, 270, 53, 127, + 188, 193, 195, 124, 46, 286, 286, 286, 60, 253, + 53, 53, 52, 45, 55, 53, 60, 286, 69, 111, + 191, 47, 194, 60, 160, 52, 52, 52, 71, 90, + 127, 255, 256, 199, 243, 46, 272, 281, 60, 52, + 191, 52, 60, 104, 127, 128, 161, 162, 164, 196, + 236, 238, 241, 242, 266, 267, 281, 281, 281, 59, + 59, 75, 126, 254, 256, 78, 248, 53, 45, 272, + 60, 135, 91, 124, 165, 166, 46, 196, 47, 53, + 53, 53, 46, 46, 79, 72, 93, 99, 110, 111, + 125, 47, 243, 33, 34, 43, 47, 52, 54, 66, + 67, 68, 77, 81, 112, 113, 123, 148, 197, 199, + 249, 250, 283, 284, 60, 53, 53, 52, 60, 163, + 124, 124, 124, 259, 257, 59, 59, 281, 281, 281, + 196, 281, 281, 58, 123, 52, 277, 55, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 44, 50, 51, 52, 57, + 62, 277, 285, 60, 60, 275, 160, 60, 60, 60, + 47, 127, 260, 47, 258, 281, 46, 269, 53, 53, + 124, 272, 244, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 50, 272, 281, 281, 213, 281, 53, 47, + 148, 261, 276, 55, 52, 63, 77, 169, 170, 173, + 262, 263, 281, 60, 281, 53, 45, 55, 281, 53, + 55, 286, 46, 60, 52, 124, 63, 77, 172, 173, + 281, 55, 47, 262, 64, 65, 281, 281, 52, 167, + 272, 127, 53, 56, 64, 65, 261, 281, 281, 45, + 272, 47, 168, 169, 53, 60, 171, 173, 281, 281, + 127, 53, 55, 53, 56, 60, 124, 173, 60 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ @@ -1984,51 +2026,53 @@ static const yytype_int16 yyr1[] = 122, 122, 122, 122, 122, 122, 122, 123, 123, 123, 123, 123, 123, 123, 124, 124, 125, 125, 125, 125, 125, 126, 126, 127, 127, 128, 128, 129, 129, 129, - 129, 129, 130, 130, 130, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 132, 132, 133, 134, 134, 135, 135, 136, 136, - 137, 137, 137, 137, 139, 140, 138, 141, 141, 141, - 141, 142, 143, 143, 144, 144, 145, 145, 146, 148, - 149, 147, 150, 150, 151, 151, 151, 151, 153, 154, - 152, 155, 155, 157, 156, 158, 158, 159, 159, 159, - 159, 159, 159, 159, 161, 160, 162, 162, 163, 163, - 164, 165, 165, 166, 167, 167, 168, 168, 169, 169, - 170, 170, 170, 170, 171, 171, 171, 171, 171, 172, - 172, 172, 173, 175, 176, 174, 177, 177, 178, 178, - 178, 178, 178, 179, 181, 182, 180, 180, 180, 183, - 183, 185, 184, 186, 186, 186, 187, 187, 187, 187, - 187, 188, 188, 189, 189, 190, 191, 192, 192, 193, - 194, 194, 194, 194, 194, 194, 194, 194, 194, 194, - 194, 195, 195, 195, 196, 196, 197, 198, 198, 199, - 199, 199, 199, 200, 200, 200, 201, 201, 201, 202, - 202, 203, 203, 203, 203, 203, 204, 204, 204, 204, - 206, 207, 205, 208, 210, 211, 209, 212, 212, 213, - 215, 214, 216, 214, 217, 217, 218, 219, 220, 221, - 221, 222, 222, 222, 222, 223, 223, 223, 224, 225, - 226, 226, 227, 227, 228, 229, 229, 229, 229, 229, - 229, 229, 229, 231, 230, 232, 232, 233, 234, 234, - 235, 235, 236, 236, 237, 237, 237, 237, 238, 239, - 239, 240, 240, 240, 240, 241, 241, 242, 243, 243, - 244, 244, 245, 246, 246, 247, 248, 248, 249, 250, - 250, 251, 252, 253, 253, 254, 254, 255, 255, 255, - 256, 256, 256, 257, 257, 259, 258, 260, 260, 260, - 260, 260, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 261, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 262, 262, 262, 262, 262, 262, 262, 262, 262, 262, - 263, 263, 264, 264 + 129, 130, 130, 131, 131, 131, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 132, 133, 133, 134, 135, 136, 135, 137, 137, + 138, 138, 139, 139, 139, 139, 141, 142, 140, 143, + 143, 143, 143, 144, 145, 145, 146, 146, 147, 147, + 148, 150, 151, 149, 152, 152, 153, 153, 153, 153, + 155, 156, 154, 157, 157, 159, 158, 160, 160, 161, + 161, 161, 161, 161, 161, 161, 163, 162, 164, 164, + 165, 165, 166, 167, 167, 168, 169, 169, 170, 170, + 171, 171, 172, 172, 172, 172, 173, 173, 173, 173, + 173, 174, 174, 174, 176, 177, 175, 179, 180, 178, + 181, 181, 182, 182, 182, 182, 182, 183, 185, 186, + 187, 188, 184, 184, 184, 189, 190, 190, 192, 191, + 193, 193, 194, 193, 195, 196, 196, 196, 196, 196, + 197, 197, 198, 198, 199, 200, 201, 201, 202, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 204, 204, 204, 205, 205, 207, 208, 206, 209, 209, + 210, 210, 210, 210, 211, 211, 211, 212, 212, 212, + 213, 213, 214, 214, 214, 214, 214, 215, 215, 215, + 215, 217, 218, 216, 220, 221, 219, 223, 224, 222, + 225, 225, 226, 228, 227, 229, 227, 230, 230, 231, + 232, 233, 234, 234, 235, 235, 235, 235, 236, 236, + 237, 237, 238, 239, 240, 240, 241, 241, 242, 243, + 243, 243, 243, 243, 243, 243, 243, 245, 244, 246, + 246, 247, 248, 248, 249, 249, 250, 250, 251, 251, + 251, 251, 253, 254, 252, 255, 255, 256, 256, 256, + 256, 257, 257, 258, 259, 259, 260, 261, 261, 262, + 263, 263, 265, 264, 266, 266, 267, 268, 268, 269, + 271, 270, 272, 272, 273, 273, 274, 274, 274, 275, + 275, 275, 276, 276, 278, 277, 279, 279, 279, 279, + 280, 280, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 282, 282, 282, 282, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 284, 284, 284, 284, 285, 285, 286, 286 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ @@ -2038,7 +2082,7 @@ static const yytype_int8 yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 2, 2, 5, 5, - 5, 4, 0, 4, 2, 1, 1, 1, 1, 1, + 4, 1, 1, 0, 4, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -2047,42 +2091,44 @@ static const yytype_int8 yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 3, 3, 0, 1, 1, 3, 4, 6, - 1, 1, 1, 0, 0, 0, 9, 7, 6, 9, - 8, 3, 0, 2, 1, 1, 0, 3, 1, 0, - 0, 8, 0, 2, 1, 1, 1, 1, 0, 0, - 9, 1, 2, 0, 8, 0, 2, 1, 1, 1, - 1, 1, 1, 1, 0, 5, 0, 2, 2, 1, - 7, 0, 2, 4, 1, 1, 5, 3, 1, 3, - 3, 3, 1, 1, 1, 3, 3, 1, 1, 10, - 10, 10, 7, 0, 0, 9, 0, 2, 1, 1, - 1, 1, 1, 1, 0, 0, 9, 4, 4, 0, - 2, 0, 7, 3, 4, 6, 1, 1, 1, 1, - 1, 1, 1, 1, 2, 1, 4, 4, 4, 4, - 1, 1, 1, 1, 1, 4, 4, 4, 6, 6, - 6, 1, 1, 1, 0, 1, 3, 1, 3, 1, - 1, 1, 1, 0, 1, 3, 1, 1, 1, 1, - 3, 1, 2, 2, 2, 2, 1, 1, 1, 1, - 0, 0, 9, 7, 0, 0, 9, 0, 2, 4, - 0, 7, 0, 8, 1, 3, 3, 4, 4, 1, - 3, 4, 4, 4, 4, 5, 8, 4, 1, 2, - 2, 3, 5, 7, 7, 1, 1, 1, 1, 1, - 1, 1, 1, 0, 5, 0, 2, 7, 0, 2, - 3, 2, 1, 1, 1, 1, 1, 1, 6, 1, - 2, 5, 5, 7, 6, 0, 2, 5, 0, 4, - 1, 4, 5, 1, 2, 7, 5, 4, 7, 0, - 2, 1, 2, 0, 1, 1, 3, 1, 3, 1, - 0, 1, 3, 1, 2, 0, 3, 1, 1, 2, - 4, 6, 1, 1, 1, 1, 1, 1, 2, 4, + 1, 1, 1, 3, 3, 0, 0, 2, 1, 3, + 4, 6, 1, 1, 1, 0, 0, 0, 9, 7, + 6, 9, 8, 3, 0, 2, 1, 1, 0, 3, + 1, 0, 0, 8, 0, 2, 1, 1, 1, 1, + 0, 0, 9, 1, 2, 0, 8, 0, 2, 1, + 1, 1, 1, 1, 1, 1, 0, 5, 0, 2, + 2, 1, 7, 0, 2, 4, 1, 1, 5, 3, + 1, 3, 3, 3, 1, 1, 1, 3, 3, 1, + 1, 10, 10, 10, 0, 0, 9, 0, 0, 9, + 0, 2, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 11, 1, 4, 4, 0, 2, 0, 7, + 3, 4, 0, 2, 6, 1, 1, 1, 1, 1, + 1, 1, 1, 2, 1, 4, 4, 4, 4, 1, + 1, 1, 1, 1, 4, 4, 4, 6, 6, 6, + 1, 1, 1, 0, 1, 0, 0, 5, 1, 3, + 1, 1, 1, 1, 0, 1, 3, 1, 1, 1, + 1, 3, 1, 2, 2, 2, 2, 1, 1, 1, + 1, 0, 0, 9, 0, 0, 9, 0, 0, 9, + 0, 2, 4, 0, 7, 0, 8, 1, 3, 3, + 4, 4, 1, 3, 4, 4, 4, 4, 1, 4, + 5, 8, 1, 2, 2, 3, 5, 7, 7, 1, + 1, 1, 1, 1, 1, 1, 1, 0, 5, 0, + 2, 7, 0, 2, 3, 2, 1, 1, 1, 1, + 1, 1, 0, 0, 8, 1, 2, 5, 5, 7, + 6, 0, 2, 5, 0, 2, 3, 1, 4, 5, + 1, 2, 0, 8, 5, 4, 7, 0, 2, 1, + 0, 3, 0, 1, 1, 3, 1, 3, 1, 0, + 1, 3, 1, 2, 0, 3, 1, 1, 2, 2, + 3, 5, 1, 1, 1, 1, 1, 1, 2, 4, 6, 3, 3, 3, 2, 2, 2, 2, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 5, 7, 4, 4, 4, 1, 1, 1, - 1, 1, 1, 2, 4, 6, 3, 2, 2, 2, - 2, 2, 3, 2, 3, 3, 3, 3, 3, 3, - 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 5, 7, 4, 4, 4, - 1, 1, 1, 1 + 3, 3, 5, 4, 1, 0, 7, 4, 4, 1, + 1, 1, 1, 1, 1, 2, 4, 6, 3, 2, + 2, 2, 2, 2, 3, 2, 3, 3, 3, 3, + 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 5, 4, 1, + 0, 7, 4, 4, 1, 1, 1, 1 }; @@ -2780,1571 +2826,1595 @@ yyparse (void) case 3: #line 244 "p4parser.y" {} -#line 2784 "p4parser.tab.c" +#line 2830 "p4parser.tab.c" break; case 5: #line 249 "p4parser.y" {} -#line 2790 "p4parser.tab.c" +#line 2836 "p4parser.tab.c" break; case 6: #line 250 "p4parser.y" {} -#line 2796 "p4parser.tab.c" +#line 2842 "p4parser.tab.c" break; case 7: #line 254 "p4parser.y" {} -#line 2802 "p4parser.tab.c" +#line 2848 "p4parser.tab.c" break; case 8: #line 255 "p4parser.y" {} -#line 2808 "p4parser.tab.c" +#line 2854 "p4parser.tab.c" break; case 9: #line 256 "p4parser.y" {} -#line 2814 "p4parser.tab.c" +#line 2860 "p4parser.tab.c" break; case 10: #line 257 "p4parser.y" {} -#line 2820 "p4parser.tab.c" +#line 2866 "p4parser.tab.c" break; case 11: #line 258 "p4parser.y" {} -#line 2826 "p4parser.tab.c" +#line 2872 "p4parser.tab.c" break; case 12: #line 259 "p4parser.y" {} -#line 2832 "p4parser.tab.c" +#line 2878 "p4parser.tab.c" break; case 13: #line 260 "p4parser.y" {} -#line 2838 "p4parser.tab.c" +#line 2884 "p4parser.tab.c" break; case 14: #line 261 "p4parser.y" {} -#line 2844 "p4parser.tab.c" +#line 2890 "p4parser.tab.c" break; case 15: #line 262 "p4parser.y" {} -#line 2850 "p4parser.tab.c" +#line 2896 "p4parser.tab.c" break; case 16: #line 263 "p4parser.y" {} -#line 2856 "p4parser.tab.c" +#line 2902 "p4parser.tab.c" break; case 17: #line 267 "p4parser.y" {} -#line 2862 "p4parser.tab.c" +#line 2908 "p4parser.tab.c" break; case 18: #line 268 "p4parser.y" {} -#line 2868 "p4parser.tab.c" +#line 2914 "p4parser.tab.c" break; case 19: #line 269 "p4parser.y" {} -#line 2874 "p4parser.tab.c" +#line 2920 "p4parser.tab.c" break; case 20: #line 270 "p4parser.y" {} -#line 2880 "p4parser.tab.c" +#line 2926 "p4parser.tab.c" break; case 21: #line 271 "p4parser.y" {} -#line 2886 "p4parser.tab.c" +#line 2932 "p4parser.tab.c" break; case 22: #line 272 "p4parser.y" {} -#line 2892 "p4parser.tab.c" +#line 2938 "p4parser.tab.c" break; case 23: #line 273 "p4parser.y" {} -#line 2898 "p4parser.tab.c" +#line 2944 "p4parser.tab.c" break; case 24: #line 277 "p4parser.y" {} -#line 2904 "p4parser.tab.c" +#line 2950 "p4parser.tab.c" break; case 25: #line 278 "p4parser.y" {} -#line 2910 "p4parser.tab.c" +#line 2956 "p4parser.tab.c" break; case 26: #line 282 "p4parser.y" {} -#line 2916 "p4parser.tab.c" +#line 2962 "p4parser.tab.c" break; case 27: #line 283 "p4parser.y" {} -#line 2922 "p4parser.tab.c" +#line 2968 "p4parser.tab.c" break; case 28: #line 284 "p4parser.y" {} -#line 2928 "p4parser.tab.c" +#line 2974 "p4parser.tab.c" break; case 29: #line 285 "p4parser.y" {} -#line 2934 "p4parser.tab.c" +#line 2980 "p4parser.tab.c" break; case 30: #line 286 "p4parser.y" {} -#line 2940 "p4parser.tab.c" +#line 2986 "p4parser.tab.c" break; case 31: #line 290 "p4parser.y" {} -#line 2946 "p4parser.tab.c" +#line 2992 "p4parser.tab.c" break; case 32: #line 291 "p4parser.y" {} -#line 2952 "p4parser.tab.c" +#line 2998 "p4parser.tab.c" break; case 33: #line 295 "p4parser.y" {} -#line 2958 "p4parser.tab.c" +#line 3004 "p4parser.tab.c" break; case 34: #line 296 "p4parser.y" {} -#line 2964 "p4parser.tab.c" +#line 3010 "p4parser.tab.c" break; case 35: #line 300 "p4parser.y" {} -#line 2970 "p4parser.tab.c" +#line 3016 "p4parser.tab.c" break; case 36: #line 301 "p4parser.y" {} -#line 2976 "p4parser.tab.c" +#line 3022 "p4parser.tab.c" break; case 37: #line 306 "p4parser.y" {} -#line 2982 "p4parser.tab.c" +#line 3028 "p4parser.tab.c" break; case 38: #line 308 "p4parser.y" {} -#line 2988 "p4parser.tab.c" +#line 3034 "p4parser.tab.c" break; case 39: #line 310 "p4parser.y" {} -#line 2994 "p4parser.tab.c" - break; - - case 40: -#line 312 "p4parser.y" - {} -#line 3000 "p4parser.tab.c" - break; - - case 41: -#line 316 "p4parser.y" - {} -#line 3006 "p4parser.tab.c" - break; - - case 42: -#line 320 "p4parser.y" - {} -#line 3012 "p4parser.tab.c" +#line 3040 "p4parser.tab.c" break; case 43: #line 322 "p4parser.y" - {} -#line 3018 "p4parser.tab.c" + {} +#line 3046 "p4parser.tab.c" break; case 44: #line 324 "p4parser.y" {} -#line 3024 "p4parser.tab.c" +#line 3052 "p4parser.tab.c" break; case 45: -#line 328 "p4parser.y" - {} -#line 3030 "p4parser.tab.c" +#line 326 "p4parser.y" + {} +#line 3058 "p4parser.tab.c" break; case 46: -#line 329 "p4parser.y" +#line 330 "p4parser.y" {} -#line 3036 "p4parser.tab.c" +#line 3064 "p4parser.tab.c" break; case 47: -#line 330 "p4parser.y" +#line 331 "p4parser.y" {} -#line 3042 "p4parser.tab.c" +#line 3070 "p4parser.tab.c" break; case 48: -#line 331 "p4parser.y" +#line 332 "p4parser.y" {} -#line 3048 "p4parser.tab.c" +#line 3076 "p4parser.tab.c" break; case 49: -#line 332 "p4parser.y" +#line 333 "p4parser.y" {} -#line 3054 "p4parser.tab.c" +#line 3082 "p4parser.tab.c" break; case 50: -#line 333 "p4parser.y" +#line 334 "p4parser.y" {} -#line 3060 "p4parser.tab.c" +#line 3088 "p4parser.tab.c" break; case 51: -#line 334 "p4parser.y" +#line 335 "p4parser.y" {} -#line 3066 "p4parser.tab.c" +#line 3094 "p4parser.tab.c" break; case 52: -#line 335 "p4parser.y" +#line 336 "p4parser.y" {} -#line 3072 "p4parser.tab.c" +#line 3100 "p4parser.tab.c" break; case 53: -#line 336 "p4parser.y" +#line 337 "p4parser.y" {} -#line 3078 "p4parser.tab.c" +#line 3106 "p4parser.tab.c" break; case 54: -#line 337 "p4parser.y" +#line 338 "p4parser.y" {} -#line 3084 "p4parser.tab.c" +#line 3112 "p4parser.tab.c" break; case 55: -#line 338 "p4parser.y" +#line 339 "p4parser.y" {} -#line 3090 "p4parser.tab.c" +#line 3118 "p4parser.tab.c" break; case 56: -#line 339 "p4parser.y" +#line 340 "p4parser.y" {} -#line 3096 "p4parser.tab.c" +#line 3124 "p4parser.tab.c" break; case 57: -#line 340 "p4parser.y" +#line 341 "p4parser.y" {} -#line 3102 "p4parser.tab.c" +#line 3130 "p4parser.tab.c" break; case 58: -#line 341 "p4parser.y" +#line 342 "p4parser.y" {} -#line 3108 "p4parser.tab.c" +#line 3136 "p4parser.tab.c" break; case 59: -#line 342 "p4parser.y" +#line 343 "p4parser.y" {} -#line 3114 "p4parser.tab.c" +#line 3142 "p4parser.tab.c" break; case 60: -#line 343 "p4parser.y" +#line 344 "p4parser.y" {} -#line 3120 "p4parser.tab.c" +#line 3148 "p4parser.tab.c" break; case 61: -#line 344 "p4parser.y" +#line 345 "p4parser.y" {} -#line 3126 "p4parser.tab.c" +#line 3154 "p4parser.tab.c" break; case 62: -#line 345 "p4parser.y" +#line 346 "p4parser.y" {} -#line 3132 "p4parser.tab.c" +#line 3160 "p4parser.tab.c" break; case 63: -#line 346 "p4parser.y" +#line 347 "p4parser.y" {} -#line 3138 "p4parser.tab.c" +#line 3166 "p4parser.tab.c" break; case 64: -#line 347 "p4parser.y" +#line 348 "p4parser.y" {} -#line 3144 "p4parser.tab.c" +#line 3172 "p4parser.tab.c" break; case 65: -#line 348 "p4parser.y" +#line 349 "p4parser.y" {} -#line 3150 "p4parser.tab.c" +#line 3178 "p4parser.tab.c" break; case 66: -#line 349 "p4parser.y" +#line 350 "p4parser.y" {} -#line 3156 "p4parser.tab.c" +#line 3184 "p4parser.tab.c" break; case 67: -#line 350 "p4parser.y" +#line 351 "p4parser.y" {} -#line 3162 "p4parser.tab.c" +#line 3190 "p4parser.tab.c" break; case 68: -#line 351 "p4parser.y" +#line 352 "p4parser.y" {} -#line 3168 "p4parser.tab.c" +#line 3196 "p4parser.tab.c" break; case 69: -#line 352 "p4parser.y" +#line 353 "p4parser.y" {} -#line 3174 "p4parser.tab.c" +#line 3202 "p4parser.tab.c" break; case 70: -#line 353 "p4parser.y" +#line 354 "p4parser.y" {} -#line 3180 "p4parser.tab.c" +#line 3208 "p4parser.tab.c" break; case 71: -#line 354 "p4parser.y" +#line 355 "p4parser.y" {} -#line 3186 "p4parser.tab.c" +#line 3214 "p4parser.tab.c" break; case 72: -#line 355 "p4parser.y" +#line 356 "p4parser.y" {} -#line 3192 "p4parser.tab.c" +#line 3220 "p4parser.tab.c" break; case 73: -#line 356 "p4parser.y" +#line 357 "p4parser.y" {} -#line 3198 "p4parser.tab.c" +#line 3226 "p4parser.tab.c" break; case 74: -#line 357 "p4parser.y" +#line 358 "p4parser.y" {} -#line 3204 "p4parser.tab.c" +#line 3232 "p4parser.tab.c" break; case 75: -#line 358 "p4parser.y" +#line 359 "p4parser.y" {} -#line 3210 "p4parser.tab.c" +#line 3238 "p4parser.tab.c" break; case 76: -#line 359 "p4parser.y" +#line 360 "p4parser.y" {} -#line 3216 "p4parser.tab.c" +#line 3244 "p4parser.tab.c" break; case 77: -#line 360 "p4parser.y" +#line 361 "p4parser.y" {} -#line 3222 "p4parser.tab.c" +#line 3250 "p4parser.tab.c" break; case 78: -#line 361 "p4parser.y" +#line 362 "p4parser.y" {} -#line 3228 "p4parser.tab.c" +#line 3256 "p4parser.tab.c" break; case 79: -#line 362 "p4parser.y" +#line 363 "p4parser.y" {} -#line 3234 "p4parser.tab.c" +#line 3262 "p4parser.tab.c" break; case 80: -#line 363 "p4parser.y" +#line 364 "p4parser.y" {} -#line 3240 "p4parser.tab.c" +#line 3268 "p4parser.tab.c" break; case 81: -#line 364 "p4parser.y" +#line 365 "p4parser.y" {} -#line 3246 "p4parser.tab.c" +#line 3274 "p4parser.tab.c" break; case 82: -#line 365 "p4parser.y" +#line 366 "p4parser.y" {} -#line 3252 "p4parser.tab.c" +#line 3280 "p4parser.tab.c" break; case 83: -#line 366 "p4parser.y" +#line 367 "p4parser.y" {} -#line 3258 "p4parser.tab.c" +#line 3286 "p4parser.tab.c" break; case 84: -#line 367 "p4parser.y" +#line 368 "p4parser.y" {} -#line 3264 "p4parser.tab.c" +#line 3292 "p4parser.tab.c" break; case 85: -#line 368 "p4parser.y" +#line 369 "p4parser.y" {} -#line 3270 "p4parser.tab.c" +#line 3298 "p4parser.tab.c" break; case 86: -#line 369 "p4parser.y" +#line 370 "p4parser.y" {} -#line 3276 "p4parser.tab.c" +#line 3304 "p4parser.tab.c" break; case 87: -#line 370 "p4parser.y" +#line 371 "p4parser.y" {} -#line 3282 "p4parser.tab.c" +#line 3310 "p4parser.tab.c" break; case 88: -#line 371 "p4parser.y" +#line 372 "p4parser.y" {} -#line 3288 "p4parser.tab.c" +#line 3316 "p4parser.tab.c" break; case 89: -#line 372 "p4parser.y" +#line 373 "p4parser.y" {} -#line 3294 "p4parser.tab.c" +#line 3322 "p4parser.tab.c" break; case 90: -#line 373 "p4parser.y" - {} -#line 3300 "p4parser.tab.c" +#line 374 "p4parser.y" + {} +#line 3328 "p4parser.tab.c" break; case 91: #line 375 "p4parser.y" - {} -#line 3306 "p4parser.tab.c" + {} +#line 3334 "p4parser.tab.c" break; case 92: -#line 376 "p4parser.y" +#line 377 "p4parser.y" {} -#line 3312 "p4parser.tab.c" +#line 3340 "p4parser.tab.c" break; case 93: -#line 377 "p4parser.y" +#line 378 "p4parser.y" {} -#line 3318 "p4parser.tab.c" +#line 3346 "p4parser.tab.c" break; case 94: -#line 378 "p4parser.y" +#line 379 "p4parser.y" {} -#line 3324 "p4parser.tab.c" +#line 3352 "p4parser.tab.c" break; case 95: -#line 379 "p4parser.y" +#line 380 "p4parser.y" {} -#line 3330 "p4parser.tab.c" +#line 3358 "p4parser.tab.c" break; case 96: -#line 380 "p4parser.y" +#line 381 "p4parser.y" {} -#line 3336 "p4parser.tab.c" +#line 3364 "p4parser.tab.c" break; case 97: -#line 381 "p4parser.y" +#line 382 "p4parser.y" {} -#line 3342 "p4parser.tab.c" +#line 3370 "p4parser.tab.c" break; case 98: -#line 382 "p4parser.y" +#line 383 "p4parser.y" {} -#line 3348 "p4parser.tab.c" +#line 3376 "p4parser.tab.c" break; case 99: -#line 383 "p4parser.y" +#line 384 "p4parser.y" {} -#line 3354 "p4parser.tab.c" +#line 3382 "p4parser.tab.c" break; case 100: -#line 384 "p4parser.y" +#line 385 "p4parser.y" {} -#line 3360 "p4parser.tab.c" +#line 3388 "p4parser.tab.c" break; case 101: -#line 385 "p4parser.y" +#line 386 "p4parser.y" {} -#line 3366 "p4parser.tab.c" +#line 3394 "p4parser.tab.c" break; case 102: -#line 386 "p4parser.y" +#line 387 "p4parser.y" {} -#line 3372 "p4parser.tab.c" +#line 3400 "p4parser.tab.c" break; case 103: -#line 387 "p4parser.y" +#line 388 "p4parser.y" {} -#line 3378 "p4parser.tab.c" +#line 3406 "p4parser.tab.c" break; case 104: -#line 388 "p4parser.y" +#line 389 "p4parser.y" {} -#line 3384 "p4parser.tab.c" +#line 3412 "p4parser.tab.c" break; case 105: -#line 389 "p4parser.y" +#line 390 "p4parser.y" {} -#line 3390 "p4parser.tab.c" +#line 3418 "p4parser.tab.c" break; case 106: -#line 390 "p4parser.y" +#line 391 "p4parser.y" {} -#line 3396 "p4parser.tab.c" +#line 3424 "p4parser.tab.c" break; - case 108: + case 107: #line 392 "p4parser.y" {} -#line 3402 "p4parser.tab.c" +#line 3430 "p4parser.tab.c" break; case 109: -#line 393 "p4parser.y" +#line 394 "p4parser.y" {} -#line 3408 "p4parser.tab.c" +#line 3436 "p4parser.tab.c" break; case 110: -#line 394 "p4parser.y" +#line 395 "p4parser.y" {} -#line 3414 "p4parser.tab.c" +#line 3442 "p4parser.tab.c" break; case 111: -#line 395 "p4parser.y" +#line 396 "p4parser.y" {} -#line 3420 "p4parser.tab.c" +#line 3448 "p4parser.tab.c" break; case 112: -#line 396 "p4parser.y" +#line 397 "p4parser.y" {} -#line 3426 "p4parser.tab.c" +#line 3454 "p4parser.tab.c" break; case 113: -#line 397 "p4parser.y" +#line 398 "p4parser.y" {} -#line 3432 "p4parser.tab.c" +#line 3460 "p4parser.tab.c" break; case 114: -#line 398 "p4parser.y" +#line 399 "p4parser.y" {} -#line 3438 "p4parser.tab.c" +#line 3466 "p4parser.tab.c" break; case 115: -#line 399 "p4parser.y" +#line 400 "p4parser.y" {} -#line 3444 "p4parser.tab.c" +#line 3472 "p4parser.tab.c" break; case 116: -#line 400 "p4parser.y" +#line 401 "p4parser.y" {} -#line 3450 "p4parser.tab.c" +#line 3478 "p4parser.tab.c" break; case 117: -#line 401 "p4parser.y" +#line 402 "p4parser.y" {} -#line 3456 "p4parser.tab.c" +#line 3484 "p4parser.tab.c" break; case 118: -#line 402 "p4parser.y" +#line 403 "p4parser.y" {} -#line 3462 "p4parser.tab.c" +#line 3490 "p4parser.tab.c" break; case 119: -#line 403 "p4parser.y" +#line 404 "p4parser.y" {} -#line 3468 "p4parser.tab.c" +#line 3496 "p4parser.tab.c" break; case 120: -#line 404 "p4parser.y" +#line 405 "p4parser.y" {} -#line 3474 "p4parser.tab.c" +#line 3502 "p4parser.tab.c" break; case 121: -#line 405 "p4parser.y" +#line 406 "p4parser.y" {} -#line 3480 "p4parser.tab.c" +#line 3508 "p4parser.tab.c" break; case 122: -#line 406 "p4parser.y" +#line 407 "p4parser.y" {} -#line 3486 "p4parser.tab.c" +#line 3514 "p4parser.tab.c" break; case 123: -#line 407 "p4parser.y" +#line 408 "p4parser.y" {} -#line 3492 "p4parser.tab.c" +#line 3520 "p4parser.tab.c" break; case 124: -#line 408 "p4parser.y" +#line 409 "p4parser.y" {} -#line 3498 "p4parser.tab.c" +#line 3526 "p4parser.tab.c" break; case 125: -#line 409 "p4parser.y" +#line 410 "p4parser.y" {} -#line 3504 "p4parser.tab.c" +#line 3532 "p4parser.tab.c" break; case 126: -#line 410 "p4parser.y" +#line 411 "p4parser.y" {} -#line 3510 "p4parser.tab.c" +#line 3538 "p4parser.tab.c" break; case 127: -#line 411 "p4parser.y" +#line 412 "p4parser.y" {} -#line 3516 "p4parser.tab.c" +#line 3544 "p4parser.tab.c" break; case 128: -#line 412 "p4parser.y" +#line 413 "p4parser.y" {} -#line 3522 "p4parser.tab.c" +#line 3550 "p4parser.tab.c" break; case 129: -#line 413 "p4parser.y" +#line 414 "p4parser.y" {} -#line 3528 "p4parser.tab.c" +#line 3556 "p4parser.tab.c" break; case 130: -#line 414 "p4parser.y" +#line 415 "p4parser.y" {} -#line 3534 "p4parser.tab.c" +#line 3562 "p4parser.tab.c" break; case 131: -#line 418 "p4parser.y" - {} -#line 3540 "p4parser.tab.c" +#line 416 "p4parser.y" + {} +#line 3568 "p4parser.tab.c" break; case 132: -#line 419 "p4parser.y" - {} -#line 3546 "p4parser.tab.c" +#line 420 "p4parser.y" + {} +#line 3574 "p4parser.tab.c" break; case 133: -#line 423 "p4parser.y" - {} -#line 3552 "p4parser.tab.c" +#line 421 "p4parser.y" + {} +#line 3580 "p4parser.tab.c" break; case 134: -#line 427 "p4parser.y" - {} -#line 3558 "p4parser.tab.c" +#line 425 "p4parser.y" + {} +#line 3586 "p4parser.tab.c" break; case 135: -#line 428 "p4parser.y" +#line 429 "p4parser.y" {} -#line 3564 "p4parser.tab.c" +#line 3592 "p4parser.tab.c" break; case 136: -#line 432 "p4parser.y" - {} -#line 3570 "p4parser.tab.c" +#line 430 "p4parser.y" + { ReenterScope(subparser); } +#line 3598 "p4parser.tab.c" break; case 137: -#line 433 "p4parser.y" - {} -#line 3576 "p4parser.tab.c" +#line 430 "p4parser.y" + { ExitReentrantScope(subparser); } +#line 3604 "p4parser.tab.c" break; case 138: -#line 437 "p4parser.y" - {} -#line 3582 "p4parser.tab.c" +#line 434 "p4parser.y" + {} +#line 3610 "p4parser.tab.c" break; case 139: -#line 438 "p4parser.y" - {} -#line 3588 "p4parser.tab.c" +#line 435 "p4parser.y" + {} +#line 3616 "p4parser.tab.c" break; case 140: -#line 442 "p4parser.y" - {} -#line 3594 "p4parser.tab.c" +#line 439 "p4parser.y" + {} +#line 3622 "p4parser.tab.c" break; case 141: -#line 443 "p4parser.y" - {} -#line 3600 "p4parser.tab.c" +#line 440 "p4parser.y" + {} +#line 3628 "p4parser.tab.c" break; case 142: #line 444 "p4parser.y" - {} -#line 3606 "p4parser.tab.c" + {} +#line 3634 "p4parser.tab.c" break; case 143: #line 445 "p4parser.y" {} -#line 3612 "p4parser.tab.c" +#line 3640 "p4parser.tab.c" break; case 144: -#line 449 "p4parser.y" - {} -#line 3618 "p4parser.tab.c" +#line 446 "p4parser.y" + {} +#line 3646 "p4parser.tab.c" break; case 145: -#line 450 "p4parser.y" - {} -#line 3624 "p4parser.tab.c" +#line 447 "p4parser.y" + {} +#line 3652 "p4parser.tab.c" break; case 146: #line 451 "p4parser.y" - { - saveBaseType(subparser, getNodeAt(subparser, 8)); - bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); - } -#line 3633 "p4parser.tab.c" + {} +#line 3658 "p4parser.tab.c" break; case 147: -#line 459 "p4parser.y" - {} -#line 3639 "p4parser.tab.c" +#line 452 "p4parser.y" + {} +#line 3664 "p4parser.tab.c" break; case 148: -#line 461 "p4parser.y" - {} -#line 3645 "p4parser.tab.c" +#line 453 "p4parser.y" + { + saveBaseType(subparser, getNodeAt(subparser, 8)); + bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); + } +#line 3673 "p4parser.tab.c" break; case 149: -#line 464 "p4parser.y" +#line 461 "p4parser.y" {} -#line 3651 "p4parser.tab.c" +#line 3679 "p4parser.tab.c" break; case 150: -#line 467 "p4parser.y" +#line 463 "p4parser.y" {} -#line 3657 "p4parser.tab.c" +#line 3685 "p4parser.tab.c" break; - case 151: -#line 473 "p4parser.y" + case 153: +#line 472 "p4parser.y" {} -#line 3663 "p4parser.tab.c" +#line 3691 "p4parser.tab.c" break; - case 152: -#line 477 "p4parser.y" + case 154: +#line 476 "p4parser.y" {} -#line 3669 "p4parser.tab.c" +#line 3697 "p4parser.tab.c" break; - case 153: -#line 478 "p4parser.y" + case 155: +#line 477 "p4parser.y" {} -#line 3675 "p4parser.tab.c" +#line 3703 "p4parser.tab.c" break; - case 154: -#line 482 "p4parser.y" + case 156: +#line 481 "p4parser.y" {} -#line 3681 "p4parser.tab.c" +#line 3709 "p4parser.tab.c" break; - case 155: -#line 483 "p4parser.y" + case 157: +#line 482 "p4parser.y" {} -#line 3687 "p4parser.tab.c" +#line 3715 "p4parser.tab.c" break; - case 156: -#line 487 "p4parser.y" + case 158: +#line 486 "p4parser.y" {} -#line 3693 "p4parser.tab.c" +#line 3721 "p4parser.tab.c" break; - case 157: -#line 488 "p4parser.y" + case 159: +#line 487 "p4parser.y" {} -#line 3699 "p4parser.tab.c" +#line 3727 "p4parser.tab.c" break; - case 158: -#line 492 "p4parser.y" + case 160: +#line 491 "p4parser.y" {} -#line 3705 "p4parser.tab.c" +#line 3733 "p4parser.tab.c" break; - case 159: + case 161: #line 498 "p4parser.y" - { EnterScope(subparser); } -#line 3711 "p4parser.tab.c" + { ReenterScope(subparser); } +#line 3739 "p4parser.tab.c" break; - case 160: -#line 499 "p4parser.y" - { ExitScope(subparser); } -#line 3717 "p4parser.tab.c" + case 162: +#line 498 "p4parser.y" + { ExitScope(subparser); } +#line 3745 "p4parser.tab.c" break; - case 161: -#line 500 "p4parser.y" + case 163: +#line 499 "p4parser.y" {} -#line 3723 "p4parser.tab.c" +#line 3751 "p4parser.tab.c" break; - case 162: -#line 505 "p4parser.y" + case 164: +#line 504 "p4parser.y" {} -#line 3729 "p4parser.tab.c" +#line 3757 "p4parser.tab.c" break; - case 163: -#line 506 "p4parser.y" + case 165: +#line 505 "p4parser.y" {} -#line 3735 "p4parser.tab.c" +#line 3763 "p4parser.tab.c" break; - case 164: -#line 510 "p4parser.y" + case 166: +#line 509 "p4parser.y" {} -#line 3741 "p4parser.tab.c" +#line 3769 "p4parser.tab.c" break; - case 165: -#line 511 "p4parser.y" + case 167: +#line 510 "p4parser.y" {} -#line 3747 "p4parser.tab.c" +#line 3775 "p4parser.tab.c" break; - case 166: -#line 512 "p4parser.y" + case 168: +#line 511 "p4parser.y" {} -#line 3753 "p4parser.tab.c" +#line 3781 "p4parser.tab.c" break; - case 167: -#line 513 "p4parser.y" + case 169: +#line 512 "p4parser.y" {} -#line 3759 "p4parser.tab.c" +#line 3787 "p4parser.tab.c" break; - case 168: -#line 518 "p4parser.y" + case 170: +#line 517 "p4parser.y" {} -#line 3765 "p4parser.tab.c" +#line 3793 "p4parser.tab.c" break; - case 169: -#line 519 "p4parser.y" + case 171: +#line 518 "p4parser.y" {} -#line 3771 "p4parser.tab.c" +#line 3799 "p4parser.tab.c" break; - case 170: -#line 520 "p4parser.y" + case 172: +#line 519 "p4parser.y" { saveBaseType(subparser, getNodeAt(subparser, 8)); bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } -#line 3780 "p4parser.tab.c" - break; - - case 171: -#line 527 "p4parser.y" - {} -#line 3786 "p4parser.tab.c" - break; - - case 172: -#line 528 "p4parser.y" - {} -#line 3792 "p4parser.tab.c" +#line 3808 "p4parser.tab.c" break; case 173: -#line 532 "p4parser.y" - {} -#line 3798 "p4parser.tab.c" +#line 526 "p4parser.y" + {} +#line 3814 "p4parser.tab.c" break; case 174: -#line 534 "p4parser.y" +#line 527 "p4parser.y" {} -#line 3804 "p4parser.tab.c" +#line 3820 "p4parser.tab.c" break; case 175: -#line 538 "p4parser.y" - {} -#line 3810 "p4parser.tab.c" +#line 531 "p4parser.y" + {} +#line 3826 "p4parser.tab.c" break; case 176: -#line 539 "p4parser.y" - {} -#line 3816 "p4parser.tab.c" +#line 533 "p4parser.y" + {} +#line 3832 "p4parser.tab.c" break; case 177: -#line 543 "p4parser.y" - {} -#line 3822 "p4parser.tab.c" +#line 537 "p4parser.y" + {} +#line 3838 "p4parser.tab.c" break; case 178: -#line 544 "p4parser.y" - {} -#line 3828 "p4parser.tab.c" +#line 538 "p4parser.y" + {} +#line 3844 "p4parser.tab.c" break; case 179: -#line 545 "p4parser.y" - {} -#line 3834 "p4parser.tab.c" +#line 542 "p4parser.y" + {} +#line 3850 "p4parser.tab.c" break; case 180: -#line 546 "p4parser.y" +#line 543 "p4parser.y" {} -#line 3840 "p4parser.tab.c" +#line 3856 "p4parser.tab.c" break; case 181: -#line 547 "p4parser.y" +#line 544 "p4parser.y" {} -#line 3846 "p4parser.tab.c" +#line 3862 "p4parser.tab.c" break; case 182: -#line 548 "p4parser.y" +#line 545 "p4parser.y" {} -#line 3852 "p4parser.tab.c" +#line 3868 "p4parser.tab.c" break; case 183: -#line 549 "p4parser.y" +#line 546 "p4parser.y" {} -#line 3858 "p4parser.tab.c" +#line 3874 "p4parser.tab.c" break; case 184: -#line 553 "p4parser.y" - {} -#line 3864 "p4parser.tab.c" +#line 547 "p4parser.y" + {} +#line 3880 "p4parser.tab.c" break; case 185: -#line 554 "p4parser.y" - {} -#line 3870 "p4parser.tab.c" +#line 548 "p4parser.y" + {} +#line 3886 "p4parser.tab.c" break; case 186: -#line 558 "p4parser.y" - {} -#line 3876 "p4parser.tab.c" +#line 552 "p4parser.y" + {} +#line 3892 "p4parser.tab.c" break; case 187: -#line 559 "p4parser.y" - {} -#line 3882 "p4parser.tab.c" +#line 553 "p4parser.y" + {} +#line 3898 "p4parser.tab.c" break; case 188: -#line 563 "p4parser.y" - {} -#line 3888 "p4parser.tab.c" +#line 557 "p4parser.y" + {} +#line 3904 "p4parser.tab.c" break; case 189: -#line 564 "p4parser.y" - {} -#line 3894 "p4parser.tab.c" +#line 558 "p4parser.y" + {} +#line 3910 "p4parser.tab.c" break; case 190: -#line 569 "p4parser.y" - {} -#line 3900 "p4parser.tab.c" +#line 562 "p4parser.y" + {} +#line 3916 "p4parser.tab.c" break; case 191: -#line 573 "p4parser.y" - {} -#line 3906 "p4parser.tab.c" +#line 563 "p4parser.y" + {} +#line 3922 "p4parser.tab.c" break; case 192: -#line 574 "p4parser.y" - {} -#line 3912 "p4parser.tab.c" +#line 568 "p4parser.y" + {} +#line 3928 "p4parser.tab.c" break; case 193: -#line 579 "p4parser.y" - {} -#line 3918 "p4parser.tab.c" +#line 572 "p4parser.y" + {} +#line 3934 "p4parser.tab.c" break; case 194: -#line 583 "p4parser.y" - {} -#line 3924 "p4parser.tab.c" +#line 573 "p4parser.y" + {} +#line 3940 "p4parser.tab.c" break; case 195: -#line 584 "p4parser.y" - {} -#line 3930 "p4parser.tab.c" +#line 578 "p4parser.y" + {} +#line 3946 "p4parser.tab.c" break; case 196: -#line 589 "p4parser.y" - {} -#line 3936 "p4parser.tab.c" +#line 582 "p4parser.y" + {} +#line 3952 "p4parser.tab.c" break; case 197: -#line 590 "p4parser.y" - {} -#line 3942 "p4parser.tab.c" +#line 583 "p4parser.y" + {} +#line 3958 "p4parser.tab.c" break; case 198: -#line 594 "p4parser.y" - {} -#line 3948 "p4parser.tab.c" +#line 588 "p4parser.y" + {} +#line 3964 "p4parser.tab.c" break; case 199: -#line 595 "p4parser.y" - {} -#line 3954 "p4parser.tab.c" +#line 589 "p4parser.y" + {} +#line 3970 "p4parser.tab.c" break; case 200: -#line 600 "p4parser.y" - {} -#line 3960 "p4parser.tab.c" +#line 593 "p4parser.y" + {} +#line 3976 "p4parser.tab.c" break; case 201: -#line 601 "p4parser.y" - {} -#line 3966 "p4parser.tab.c" +#line 594 "p4parser.y" + {} +#line 3982 "p4parser.tab.c" break; case 202: -#line 602 "p4parser.y" - {} -#line 3972 "p4parser.tab.c" +#line 599 "p4parser.y" + {} +#line 3988 "p4parser.tab.c" break; case 203: -#line 603 "p4parser.y" - {} -#line 3978 "p4parser.tab.c" +#line 600 "p4parser.y" + {} +#line 3994 "p4parser.tab.c" break; case 204: -#line 607 "p4parser.y" - {} -#line 3984 "p4parser.tab.c" +#line 601 "p4parser.y" + {} +#line 4000 "p4parser.tab.c" break; case 205: -#line 608 "p4parser.y" - {} -#line 3990 "p4parser.tab.c" +#line 602 "p4parser.y" + {} +#line 4006 "p4parser.tab.c" break; case 206: -#line 609 "p4parser.y" - {} -#line 3996 "p4parser.tab.c" +#line 606 "p4parser.y" + {} +#line 4012 "p4parser.tab.c" break; case 207: -#line 610 "p4parser.y" - {} -#line 4002 "p4parser.tab.c" +#line 607 "p4parser.y" + {} +#line 4018 "p4parser.tab.c" break; case 208: -#line 611 "p4parser.y" - {} -#line 4008 "p4parser.tab.c" +#line 608 "p4parser.y" + {} +#line 4024 "p4parser.tab.c" break; case 209: -#line 617 "p4parser.y" - {} -#line 4014 "p4parser.tab.c" +#line 609 "p4parser.y" + {} +#line 4030 "p4parser.tab.c" break; case 210: -#line 620 "p4parser.y" - {} -#line 4020 "p4parser.tab.c" +#line 610 "p4parser.y" + {} +#line 4036 "p4parser.tab.c" break; case 211: -#line 623 "p4parser.y" +#line 616 "p4parser.y" {} -#line 4026 "p4parser.tab.c" +#line 4042 "p4parser.tab.c" break; case 212: -#line 631 "p4parser.y" +#line 619 "p4parser.y" {} -#line 4032 "p4parser.tab.c" +#line 4048 "p4parser.tab.c" break; case 213: -#line 636 "p4parser.y" - {} -#line 4038 "p4parser.tab.c" +#line 622 "p4parser.y" + {} +#line 4054 "p4parser.tab.c" break; case 214: -#line 637 "p4parser.y" - {} -#line 4044 "p4parser.tab.c" +#line 629 "p4parser.y" + { ReenterScope(subparser); } +#line 4060 "p4parser.tab.c" break; case 215: -#line 638 "p4parser.y" - { - saveBaseType(subparser, getNodeAt(subparser, 8)); - bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); - } -#line 4053 "p4parser.tab.c" +#line 631 "p4parser.y" + { ExitScope(subparser); } +#line 4066 "p4parser.tab.c" break; case 216: -#line 645 "p4parser.y" - {} -#line 4059 "p4parser.tab.c" +#line 632 "p4parser.y" + {} +#line 4072 "p4parser.tab.c" break; case 217: -#line 646 "p4parser.y" - {} -#line 4065 "p4parser.tab.c" +#line 637 "p4parser.y" + {} +#line 4078 "p4parser.tab.c" break; case 218: -#line 650 "p4parser.y" - {} -#line 4071 "p4parser.tab.c" +#line 638 "p4parser.y" + {} +#line 4084 "p4parser.tab.c" break; case 219: -#line 651 "p4parser.y" - {} -#line 4077 "p4parser.tab.c" +#line 639 "p4parser.y" + { + saveBaseType(subparser, getNodeAt(subparser, 8)); + bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); + } +#line 4093 "p4parser.tab.c" break; case 220: -#line 652 "p4parser.y" - {} -#line 4083 "p4parser.tab.c" +#line 646 "p4parser.y" + {} +#line 4099 "p4parser.tab.c" break; case 221: +#line 647 "p4parser.y" + {} +#line 4105 "p4parser.tab.c" + break; + + case 222: +#line 651 "p4parser.y" + {} +#line 4111 "p4parser.tab.c" + break; + + case 223: +#line 652 "p4parser.y" + {} +#line 4117 "p4parser.tab.c" + break; + + case 224: #line 653 "p4parser.y" {} -#line 4089 "p4parser.tab.c" +#line 4123 "p4parser.tab.c" break; - case 222: + case 225: #line 654 "p4parser.y" {} -#line 4095 "p4parser.tab.c" +#line 4129 "p4parser.tab.c" break; - case 223: -#line 658 "p4parser.y" + case 226: +#line 655 "p4parser.y" + {} +#line 4135 "p4parser.tab.c" + break; + + case 227: +#line 659 "p4parser.y" {} -#line 4101 "p4parser.tab.c" +#line 4141 "p4parser.tab.c" break; - case 224: -#line 665 "p4parser.y" + case 228: +#line 666 "p4parser.y" { saveBaseType(subparser, getNodeAt(subparser, 2)); bindIdent(subparser, getNodeAt(subparser, 2), getNodeAt(subparser, 1)); } -#line 4110 "p4parser.tab.c" +#line 4150 "p4parser.tab.c" break; - case 225: -#line 669 "p4parser.y" + case 229: +#line 670 "p4parser.y" {} -#line 4116 "p4parser.tab.c" +#line 4156 "p4parser.tab.c" break; - case 229: -#line 676 "p4parser.y" + case 230: +#line 671 "p4parser.y" + { ReenterScope(subparser); } +#line 4162 "p4parser.tab.c" + break; + + case 231: +#line 671 "p4parser.y" + { ExitScope(subparser); } +#line 4168 "p4parser.tab.c" + break; + + case 236: +#line 681 "p4parser.y" {} -#line 4122 "p4parser.tab.c" +#line 4174 "p4parser.tab.c" break; - case 230: -#line 677 "p4parser.y" + case 237: +#line 682 "p4parser.y" {} -#line 4128 "p4parser.tab.c" +#line 4180 "p4parser.tab.c" break; - case 231: -#line 682 "p4parser.y" + case 238: +#line 687 "p4parser.y" {} -#line 4134 "p4parser.tab.c" +#line 4186 "p4parser.tab.c" break; - case 232: -#line 683 "p4parser.y" + case 239: +#line 688 "p4parser.y" {} -#line 4140 "p4parser.tab.c" +#line 4192 "p4parser.tab.c" break; - case 233: -#line 687 "p4parser.y" + case 240: +#line 692 "p4parser.y" {} -#line 4146 "p4parser.tab.c" +#line 4198 "p4parser.tab.c" break; - case 234: -#line 688 "p4parser.y" + case 241: +#line 693 "p4parser.y" {} -#line 4152 "p4parser.tab.c" +#line 4204 "p4parser.tab.c" + break; + + case 242: +#line 694 "p4parser.y" + {} +#line 4210 "p4parser.tab.c" break; - case 235: -#line 690 "p4parser.y" + case 243: +#line 695 "p4parser.y" {} -#line 4158 "p4parser.tab.c" +#line 4216 "p4parser.tab.c" break; - case 236: -#line 696 "p4parser.y" + case 245: +#line 705 "p4parser.y" {} -#line 4164 "p4parser.tab.c" +#line 4222 "p4parser.tab.c" break; - case 237: -#line 697 "p4parser.y" + case 246: +#line 706 "p4parser.y" {} -#line 4170 "p4parser.tab.c" +#line 4228 "p4parser.tab.c" break; - case 238: -#line 698 "p4parser.y" + case 247: +#line 707 "p4parser.y" {} -#line 4176 "p4parser.tab.c" +#line 4234 "p4parser.tab.c" break; - case 239: -#line 699 "p4parser.y" + case 248: +#line 708 "p4parser.y" {} -#line 4182 "p4parser.tab.c" +#line 4240 "p4parser.tab.c" break; - case 240: -#line 700 "p4parser.y" + case 249: +#line 709 "p4parser.y" {} -#line 4188 "p4parser.tab.c" +#line 4246 "p4parser.tab.c" break; - case 241: -#line 704 "p4parser.y" + case 250: +#line 713 "p4parser.y" {} -#line 4194 "p4parser.tab.c" +#line 4252 "p4parser.tab.c" break; - case 242: -#line 705 "p4parser.y" + case 251: +#line 714 "p4parser.y" {} -#line 4200 "p4parser.tab.c" +#line 4258 "p4parser.tab.c" break; - case 243: -#line 709 "p4parser.y" + case 252: +#line 718 "p4parser.y" {} -#line 4206 "p4parser.tab.c" +#line 4264 "p4parser.tab.c" break; - case 244: -#line 710 "p4parser.y" + case 253: +#line 719 "p4parser.y" {} -#line 4212 "p4parser.tab.c" +#line 4270 "p4parser.tab.c" break; - case 245: -#line 714 "p4parser.y" + case 254: +#line 723 "p4parser.y" {} -#line 4218 "p4parser.tab.c" +#line 4276 "p4parser.tab.c" break; - case 246: -#line 718 "p4parser.y" + case 255: +#line 727 "p4parser.y" {} -#line 4224 "p4parser.tab.c" +#line 4282 "p4parser.tab.c" break; - case 247: -#line 722 "p4parser.y" + case 256: +#line 731 "p4parser.y" {} -#line 4230 "p4parser.tab.c" +#line 4288 "p4parser.tab.c" break; - case 248: -#line 723 "p4parser.y" + case 257: +#line 732 "p4parser.y" {} -#line 4236 "p4parser.tab.c" +#line 4294 "p4parser.tab.c" break; - case 249: -#line 727 "p4parser.y" + case 258: +#line 736 "p4parser.y" {} -#line 4242 "p4parser.tab.c" +#line 4300 "p4parser.tab.c" break; - case 250: -#line 731 "p4parser.y" + case 259: +#line 740 "p4parser.y" {} -#line 4248 "p4parser.tab.c" +#line 4306 "p4parser.tab.c" break; - case 251: -#line 732 "p4parser.y" + case 260: +#line 741 "p4parser.y" {} -#line 4254 "p4parser.tab.c" +#line 4312 "p4parser.tab.c" break; - case 252: -#line 733 "p4parser.y" + case 261: +#line 742 "p4parser.y" {} -#line 4260 "p4parser.tab.c" +#line 4318 "p4parser.tab.c" break; - case 253: -#line 734 "p4parser.y" + case 262: +#line 743 "p4parser.y" {} -#line 4266 "p4parser.tab.c" +#line 4324 "p4parser.tab.c" break; - case 254: -#line 735 "p4parser.y" + case 263: +#line 744 "p4parser.y" {} -#line 4272 "p4parser.tab.c" +#line 4330 "p4parser.tab.c" break; - case 255: -#line 737 "p4parser.y" + case 264: +#line 746 "p4parser.y" {} -#line 4278 "p4parser.tab.c" +#line 4336 "p4parser.tab.c" break; - case 256: -#line 739 "p4parser.y" + case 265: +#line 748 "p4parser.y" {} -#line 4284 "p4parser.tab.c" +#line 4342 "p4parser.tab.c" break; - case 257: -#line 741 "p4parser.y" + case 266: +#line 750 "p4parser.y" {} -#line 4290 "p4parser.tab.c" +#line 4348 "p4parser.tab.c" break; - case 258: -#line 744 "p4parser.y" + case 267: +#line 753 "p4parser.y" {} -#line 4296 "p4parser.tab.c" +#line 4354 "p4parser.tab.c" break; - case 259: -#line 746 "p4parser.y" + case 268: +#line 755 "p4parser.y" {} -#line 4302 "p4parser.tab.c" +#line 4360 "p4parser.tab.c" break; - case 260: -#line 748 "p4parser.y" + case 269: +#line 757 "p4parser.y" {} -#line 4308 "p4parser.tab.c" +#line 4366 "p4parser.tab.c" break; - case 261: -#line 752 "p4parser.y" + case 270: +#line 761 "p4parser.y" {} -#line 4314 "p4parser.tab.c" +#line 4372 "p4parser.tab.c" break; - case 262: -#line 753 "p4parser.y" + case 271: +#line 762 "p4parser.y" {} -#line 4320 "p4parser.tab.c" +#line 4378 "p4parser.tab.c" break; - case 263: -#line 754 "p4parser.y" + case 272: +#line 763 "p4parser.y" {} -#line 4326 "p4parser.tab.c" +#line 4384 "p4parser.tab.c" break; - case 264: -#line 759 "p4parser.y" + case 273: +#line 768 "p4parser.y" {} -#line 4332 "p4parser.tab.c" +#line 4390 "p4parser.tab.c" break; - case 265: -#line 760 "p4parser.y" + case 274: +#line 769 "p4parser.y" {} -#line 4338 "p4parser.tab.c" +#line 4396 "p4parser.tab.c" break; - case 266: -#line 764 "p4parser.y" - {} -#line 4344 "p4parser.tab.c" + case 275: +#line 773 "p4parser.y" + { EnterScope(subparser); } +#line 4402 "p4parser.tab.c" break; - case 267: -#line 768 "p4parser.y" + case 276: +#line 773 "p4parser.y" + { ExitReentrantScope(subparser); } +#line 4408 "p4parser.tab.c" + break; + + case 277: +#line 773 "p4parser.y" + {} +#line 4414 "p4parser.tab.c" + break; + + case 278: +#line 777 "p4parser.y" { // ASK possible to get the production name? (typeParameterList) // // saveBaseType(subparser, getNodeAt(subparser, 12)); @@ -4352,1321 +4422,1382 @@ yyparse (void) bindIdent(subparser, null, getNodeAt(subparser, 1), true); // } } -#line 4356 "p4parser.tab.c" +#line 4426 "p4parser.tab.c" break; - case 268: -#line 775 "p4parser.y" + case 279: +#line 784 "p4parser.y" { bindIdent(subparser, null, getNodeAt(subparser, 1), true); } -#line 4364 "p4parser.tab.c" +#line 4434 "p4parser.tab.c" break; - case 269: -#line 781 "p4parser.y" + case 280: +#line 790 "p4parser.y" {} -#line 4370 "p4parser.tab.c" +#line 4440 "p4parser.tab.c" break; - case 270: -#line 782 "p4parser.y" + case 281: +#line 791 "p4parser.y" {} -#line 4376 "p4parser.tab.c" +#line 4446 "p4parser.tab.c" break; - case 271: -#line 784 "p4parser.y" + case 282: +#line 793 "p4parser.y" {} -#line 4382 "p4parser.tab.c" +#line 4452 "p4parser.tab.c" break; - case 272: -#line 785 "p4parser.y" + case 283: +#line 794 "p4parser.y" {} -#line 4388 "p4parser.tab.c" +#line 4458 "p4parser.tab.c" break; - case 273: -#line 789 "p4parser.y" + case 284: +#line 798 "p4parser.y" {} -#line 4394 "p4parser.tab.c" +#line 4464 "p4parser.tab.c" break; - case 274: -#line 790 "p4parser.y" + case 285: +#line 799 "p4parser.y" {} -#line 4400 "p4parser.tab.c" +#line 4470 "p4parser.tab.c" break; - case 275: -#line 791 "p4parser.y" + case 286: +#line 800 "p4parser.y" {} -#line 4406 "p4parser.tab.c" +#line 4476 "p4parser.tab.c" break; - case 276: -#line 795 "p4parser.y" + case 287: +#line 804 "p4parser.y" {} -#line 4412 "p4parser.tab.c" +#line 4482 "p4parser.tab.c" break; - case 277: -#line 796 "p4parser.y" + case 288: +#line 805 "p4parser.y" {} -#line 4418 "p4parser.tab.c" +#line 4488 "p4parser.tab.c" break; - case 278: -#line 797 "p4parser.y" + case 289: +#line 806 "p4parser.y" {} -#line 4424 "p4parser.tab.c" +#line 4494 "p4parser.tab.c" break; - case 279: -#line 803 "p4parser.y" + case 290: +#line 812 "p4parser.y" {} -#line 4430 "p4parser.tab.c" +#line 4500 "p4parser.tab.c" break; - case 280: -#line 804 "p4parser.y" + case 291: +#line 813 "p4parser.y" {} -#line 4436 "p4parser.tab.c" +#line 4506 "p4parser.tab.c" break; - case 281: -#line 808 "p4parser.y" + case 292: +#line 817 "p4parser.y" {} -#line 4442 "p4parser.tab.c" +#line 4512 "p4parser.tab.c" break; - case 282: -#line 809 "p4parser.y" + case 293: +#line 818 "p4parser.y" {} -#line 4448 "p4parser.tab.c" +#line 4518 "p4parser.tab.c" break; - case 283: -#line 810 "p4parser.y" + case 294: +#line 819 "p4parser.y" {} -#line 4454 "p4parser.tab.c" +#line 4524 "p4parser.tab.c" break; - case 284: -#line 811 "p4parser.y" + case 295: +#line 820 "p4parser.y" {} -#line 4460 "p4parser.tab.c" +#line 4530 "p4parser.tab.c" break; - case 285: -#line 812 "p4parser.y" + case 296: +#line 821 "p4parser.y" {} -#line 4466 "p4parser.tab.c" +#line 4536 "p4parser.tab.c" break; - case 286: -#line 816 "p4parser.y" + case 297: +#line 825 "p4parser.y" {} -#line 4472 "p4parser.tab.c" +#line 4542 "p4parser.tab.c" break; - case 287: -#line 817 "p4parser.y" + case 298: +#line 826 "p4parser.y" {} -#line 4478 "p4parser.tab.c" +#line 4548 "p4parser.tab.c" break; - case 288: -#line 818 "p4parser.y" + case 299: +#line 827 "p4parser.y" {} -#line 4484 "p4parser.tab.c" +#line 4554 "p4parser.tab.c" break; - case 289: -#line 819 "p4parser.y" + case 300: +#line 828 "p4parser.y" {} -#line 4490 "p4parser.tab.c" +#line 4560 "p4parser.tab.c" break; - case 290: -#line 823 "p4parser.y" - {} -#line 4496 "p4parser.tab.c" + case 301: +#line 833 "p4parser.y" + { ReenterScope(subparser); } +#line 4566 "p4parser.tab.c" break; - case 291: -#line 823 "p4parser.y" - {} -#line 4502 "p4parser.tab.c" + case 302: +#line 834 "p4parser.y" + { ExitScope(subparser); } +#line 4572 "p4parser.tab.c" break; - case 292: -#line 825 "p4parser.y" + case 303: +#line 836 "p4parser.y" { saveBaseType(subparser, getNodeAt(subparser, 8)); bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } -#line 4511 "p4parser.tab.c" +#line 4581 "p4parser.tab.c" break; - case 293: -#line 834 "p4parser.y" + case 304: +#line 844 "p4parser.y" + { ReenterScope(subparser); } +#line 4587 "p4parser.tab.c" + break; + + case 305: +#line 846 "p4parser.y" + { ExitScope(subparser); } +#line 4593 "p4parser.tab.c" + break; + + case 306: +#line 847 "p4parser.y" { - saveBaseType(subparser, getNodeAt(subparser, 6)); - bindIdent(subparser, getNodeAt(subparser, 6), getNodeAt(subparser, 5)); + saveBaseType(subparser, getNodeAt(subparser, 8)); + bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } -#line 4520 "p4parser.tab.c" +#line 4602 "p4parser.tab.c" break; - case 294: -#line 841 "p4parser.y" - {} -#line 4526 "p4parser.tab.c" + case 307: +#line 855 "p4parser.y" + { ReenterScope(subparser); } +#line 4608 "p4parser.tab.c" break; - case 295: -#line 841 "p4parser.y" - {} -#line 4532 "p4parser.tab.c" + case 308: +#line 857 "p4parser.y" + { ExitScope(subparser); } +#line 4614 "p4parser.tab.c" break; - case 296: -#line 842 "p4parser.y" - { + case 309: +#line 857 "p4parser.y" + { saveBaseType(subparser, getNodeAt(subparser, 8)); bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } -#line 4541 "p4parser.tab.c" +#line 4623 "p4parser.tab.c" break; - case 297: -#line 849 "p4parser.y" + case 310: +#line 864 "p4parser.y" {} -#line 4547 "p4parser.tab.c" +#line 4629 "p4parser.tab.c" break; - case 298: -#line 850 "p4parser.y" + case 311: +#line 865 "p4parser.y" {} -#line 4553 "p4parser.tab.c" +#line 4635 "p4parser.tab.c" break; - case 299: -#line 854 "p4parser.y" + case 312: +#line 869 "p4parser.y" {} -#line 4559 "p4parser.tab.c" +#line 4641 "p4parser.tab.c" break; - case 300: -#line 859 "p4parser.y" + case 313: +#line 874 "p4parser.y" {} -#line 4565 "p4parser.tab.c" +#line 4647 "p4parser.tab.c" break; - case 301: -#line 860 "p4parser.y" + case 314: +#line 875 "p4parser.y" { saveBaseType(subparser, getNodeAt(subparser, 6)); bindIdent(subparser, getNodeAt(subparser, 6), getNodeAt(subparser, 5)); } -#line 4574 "p4parser.tab.c" +#line 4656 "p4parser.tab.c" break; - case 302: -#line 864 "p4parser.y" + case 315: +#line 879 "p4parser.y" {} -#line 4580 "p4parser.tab.c" +#line 4662 "p4parser.tab.c" break; - case 303: -#line 865 "p4parser.y" + case 316: +#line 880 "p4parser.y" { saveBaseType(subparser, getNodeAt(subparser, 7)); bindIdent(subparser, getNodeAt(subparser, 7), getNodeAt(subparser, 5)); } -#line 4589 "p4parser.tab.c" +#line 4671 "p4parser.tab.c" break; - case 304: -#line 872 "p4parser.y" + case 317: +#line 887 "p4parser.y" {} -#line 4595 "p4parser.tab.c" +#line 4677 "p4parser.tab.c" break; - case 305: -#line 873 "p4parser.y" + case 318: +#line 888 "p4parser.y" {} -#line 4601 "p4parser.tab.c" +#line 4683 "p4parser.tab.c" break; - case 306: -#line 877 "p4parser.y" + case 319: +#line 892 "p4parser.y" {} -#line 4607 "p4parser.tab.c" +#line 4689 "p4parser.tab.c" break; - case 307: -#line 882 "p4parser.y" + case 320: +#line 897 "p4parser.y" {} -#line 4613 "p4parser.tab.c" +#line 4695 "p4parser.tab.c" break; - case 308: -#line 887 "p4parser.y" + case 321: +#line 902 "p4parser.y" {} -#line 4619 "p4parser.tab.c" +#line 4701 "p4parser.tab.c" break; - case 309: -#line 892 "p4parser.y" + case 322: +#line 907 "p4parser.y" {} -#line 4625 "p4parser.tab.c" +#line 4707 "p4parser.tab.c" break; - case 310: -#line 893 "p4parser.y" + case 323: +#line 908 "p4parser.y" {} -#line 4631 "p4parser.tab.c" +#line 4713 "p4parser.tab.c" break; - case 311: -#line 897 "p4parser.y" + case 324: +#line 912 "p4parser.y" { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } -#line 4640 "p4parser.tab.c" +#line 4722 "p4parser.tab.c" break; - case 312: -#line 901 "p4parser.y" + case 325: +#line 916 "p4parser.y" { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } -#line 4649 "p4parser.tab.c" +#line 4731 "p4parser.tab.c" break; - case 313: -#line 905 "p4parser.y" + case 326: +#line 920 "p4parser.y" { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } -#line 4658 "p4parser.tab.c" +#line 4740 "p4parser.tab.c" break; - case 314: -#line 909 "p4parser.y" + case 327: +#line 924 "p4parser.y" { saveBaseType(subparser, getNodeAt(subparser, 3)); bindIdent(subparser, getNodeAt(subparser, 3), getNodeAt(subparser, 1)); } -#line 4667 "p4parser.tab.c" +#line 4749 "p4parser.tab.c" break; - case 315: -#line 920 "p4parser.y" + case 328: +#line 935 "p4parser.y" {} -#line 4673 "p4parser.tab.c" +#line 4755 "p4parser.tab.c" break; - case 316: -#line 923 "p4parser.y" + case 329: +#line 937 "p4parser.y" {} -#line 4679 "p4parser.tab.c" +#line 4761 "p4parser.tab.c" break; - case 317: -#line 926 "p4parser.y" + case 330: +#line 942 "p4parser.y" {} -#line 4685 "p4parser.tab.c" +#line 4767 "p4parser.tab.c" break; - case 318: -#line 931 "p4parser.y" + case 331: +#line 944 "p4parser.y" + {} +#line 4773 "p4parser.tab.c" + break; + + case 332: +#line 948 "p4parser.y" {} -#line 4691 "p4parser.tab.c" +#line 4779 "p4parser.tab.c" break; - case 319: -#line 935 "p4parser.y" + case 333: +#line 952 "p4parser.y" {} -#line 4697 "p4parser.tab.c" +#line 4785 "p4parser.tab.c" break; - case 320: -#line 939 "p4parser.y" + case 334: +#line 956 "p4parser.y" {} -#line 4703 "p4parser.tab.c" +#line 4791 "p4parser.tab.c" break; - case 321: -#line 940 "p4parser.y" + case 335: +#line 957 "p4parser.y" {} -#line 4709 "p4parser.tab.c" +#line 4797 "p4parser.tab.c" break; - case 322: -#line 945 "p4parser.y" + case 336: +#line 962 "p4parser.y" {} -#line 4715 "p4parser.tab.c" +#line 4803 "p4parser.tab.c" break; - case 323: -#line 947 "p4parser.y" + case 337: +#line 964 "p4parser.y" {} -#line 4721 "p4parser.tab.c" +#line 4809 "p4parser.tab.c" break; - case 324: -#line 952 "p4parser.y" + case 338: +#line 969 "p4parser.y" {} -#line 4727 "p4parser.tab.c" +#line 4815 "p4parser.tab.c" break; - case 325: -#line 956 "p4parser.y" + case 339: +#line 973 "p4parser.y" {} -#line 4733 "p4parser.tab.c" +#line 4821 "p4parser.tab.c" break; - case 326: -#line 957 "p4parser.y" + case 340: +#line 974 "p4parser.y" {} -#line 4739 "p4parser.tab.c" +#line 4827 "p4parser.tab.c" break; - case 327: -#line 958 "p4parser.y" + case 341: +#line 975 "p4parser.y" {} -#line 4745 "p4parser.tab.c" +#line 4833 "p4parser.tab.c" break; - case 328: -#line 959 "p4parser.y" + case 342: +#line 976 "p4parser.y" {} -#line 4751 "p4parser.tab.c" +#line 4839 "p4parser.tab.c" break; - case 329: -#line 960 "p4parser.y" + case 343: +#line 977 "p4parser.y" {} -#line 4757 "p4parser.tab.c" +#line 4845 "p4parser.tab.c" break; - case 330: -#line 961 "p4parser.y" + case 344: +#line 978 "p4parser.y" {} -#line 4763 "p4parser.tab.c" +#line 4851 "p4parser.tab.c" break; - case 331: -#line 962 "p4parser.y" + case 345: +#line 979 "p4parser.y" {} -#line 4769 "p4parser.tab.c" +#line 4857 "p4parser.tab.c" break; - case 332: -#line 963 "p4parser.y" + case 346: +#line 980 "p4parser.y" {} -#line 4775 "p4parser.tab.c" +#line 4863 "p4parser.tab.c" break; - case 333: -#line 967 "p4parser.y" + case 347: +#line 984 "p4parser.y" {} -#line 4781 "p4parser.tab.c" +#line 4869 "p4parser.tab.c" break; - case 334: -#line 968 "p4parser.y" + case 348: +#line 985 "p4parser.y" {} -#line 4787 "p4parser.tab.c" +#line 4875 "p4parser.tab.c" break; - case 335: -#line 972 "p4parser.y" + case 349: +#line 989 "p4parser.y" {} -#line 4793 "p4parser.tab.c" +#line 4881 "p4parser.tab.c" break; - case 336: -#line 973 "p4parser.y" + case 350: +#line 990 "p4parser.y" {} -#line 4799 "p4parser.tab.c" +#line 4887 "p4parser.tab.c" break; - case 337: -#line 977 "p4parser.y" + case 351: +#line 994 "p4parser.y" {} -#line 4805 "p4parser.tab.c" +#line 4893 "p4parser.tab.c" break; - case 338: -#line 981 "p4parser.y" + case 352: +#line 998 "p4parser.y" {} -#line 4811 "p4parser.tab.c" +#line 4899 "p4parser.tab.c" break; - case 339: -#line 982 "p4parser.y" + case 353: +#line 999 "p4parser.y" {} -#line 4817 "p4parser.tab.c" +#line 4905 "p4parser.tab.c" break; - case 340: -#line 986 "p4parser.y" + case 354: +#line 1003 "p4parser.y" {} -#line 4823 "p4parser.tab.c" +#line 4911 "p4parser.tab.c" break; - case 341: -#line 987 "p4parser.y" + case 355: +#line 1004 "p4parser.y" {} -#line 4829 "p4parser.tab.c" +#line 4917 "p4parser.tab.c" break; - case 342: -#line 991 "p4parser.y" + case 356: +#line 1008 "p4parser.y" {} -#line 4835 "p4parser.tab.c" +#line 4923 "p4parser.tab.c" break; - case 343: -#line 992 "p4parser.y" + case 357: +#line 1009 "p4parser.y" {} -#line 4841 "p4parser.tab.c" +#line 4929 "p4parser.tab.c" break; - case 344: -#line 996 "p4parser.y" + case 358: +#line 1013 "p4parser.y" {} -#line 4847 "p4parser.tab.c" +#line 4935 "p4parser.tab.c" break; - case 345: -#line 997 "p4parser.y" + case 359: +#line 1014 "p4parser.y" {} -#line 4853 "p4parser.tab.c" +#line 4941 "p4parser.tab.c" break; - case 346: -#line 998 "p4parser.y" + case 360: +#line 1015 "p4parser.y" {} -#line 4859 "p4parser.tab.c" +#line 4947 "p4parser.tab.c" break; - case 347: -#line 999 "p4parser.y" + case 361: +#line 1016 "p4parser.y" {} -#line 4865 "p4parser.tab.c" +#line 4953 "p4parser.tab.c" break; - case 348: -#line 1007 "p4parser.y" + case 362: +#line 1023 "p4parser.y" + { EnterScope(subparser); } +#line 4959 "p4parser.tab.c" + break; + + case 363: +#line 1023 "p4parser.y" + { ExitScope(subparser); } +#line 4965 "p4parser.tab.c" + break; + + case 364: +#line 1024 "p4parser.y" {} -#line 4871 "p4parser.tab.c" +#line 4971 "p4parser.tab.c" break; - case 349: -#line 1011 "p4parser.y" + case 365: +#line 1028 "p4parser.y" {} -#line 4877 "p4parser.tab.c" +#line 4977 "p4parser.tab.c" break; - case 350: -#line 1012 "p4parser.y" + case 366: +#line 1029 "p4parser.y" {} -#line 4883 "p4parser.tab.c" +#line 4983 "p4parser.tab.c" break; - case 351: -#line 1017 "p4parser.y" + case 367: +#line 1034 "p4parser.y" {} -#line 4889 "p4parser.tab.c" +#line 4989 "p4parser.tab.c" break; - case 352: -#line 1019 "p4parser.y" + case 368: +#line 1036 "p4parser.y" {} -#line 4895 "p4parser.tab.c" +#line 4995 "p4parser.tab.c" break; - case 353: -#line 1021 "p4parser.y" + case 369: +#line 1038 "p4parser.y" {} -#line 4901 "p4parser.tab.c" +#line 5001 "p4parser.tab.c" break; - case 354: -#line 1023 "p4parser.y" + case 370: +#line 1040 "p4parser.y" {} -#line 4907 "p4parser.tab.c" +#line 5007 "p4parser.tab.c" break; - case 355: -#line 1027 "p4parser.y" + case 371: +#line 1044 "p4parser.y" {} -#line 4913 "p4parser.tab.c" +#line 5013 "p4parser.tab.c" break; - case 356: -#line 1028 "p4parser.y" + case 372: +#line 1045 "p4parser.y" {} -#line 4919 "p4parser.tab.c" +#line 5019 "p4parser.tab.c" break; - case 357: -#line 1033 "p4parser.y" + case 373: +#line 1050 "p4parser.y" {} -#line 4925 "p4parser.tab.c" +#line 5025 "p4parser.tab.c" break; - case 358: -#line 1037 "p4parser.y" + case 374: +#line 1054 "p4parser.y" {} -#line 4931 "p4parser.tab.c" +#line 5031 "p4parser.tab.c" break; - case 359: -#line 1039 "p4parser.y" + case 375: +#line 1056 "p4parser.y" {} -#line 4937 "p4parser.tab.c" +#line 5037 "p4parser.tab.c" break; - case 360: -#line 1044 "p4parser.y" + case 377: +#line 1065 "p4parser.y" {} -#line 4943 "p4parser.tab.c" +#line 5043 "p4parser.tab.c" break; - case 361: -#line 1046 "p4parser.y" + case 378: +#line 1067 "p4parser.y" {} -#line 4949 "p4parser.tab.c" +#line 5049 "p4parser.tab.c" break; - case 362: -#line 1051 "p4parser.y" + case 379: +#line 1072 "p4parser.y" {} -#line 4955 "p4parser.tab.c" +#line 5055 "p4parser.tab.c" break; - case 363: -#line 1055 "p4parser.y" + case 380: +#line 1076 "p4parser.y" {} -#line 4961 "p4parser.tab.c" +#line 5061 "p4parser.tab.c" break; - case 364: -#line 1056 "p4parser.y" + case 381: +#line 1077 "p4parser.y" {} -#line 4967 "p4parser.tab.c" +#line 5067 "p4parser.tab.c" break; - case 365: -#line 1062 "p4parser.y" - { - saveBaseType(subparser, getNodeAt(subparser, 6)); - bindIdent(subparser, getNodeAt(subparser, 6), getNodeAt(subparser, 5)); + case 382: +#line 1083 "p4parser.y" + { EnterScope(subparser); } +#line 5073 "p4parser.tab.c" + break; + + case 383: +#line 1083 "p4parser.y" + { + saveBaseType(subparser, getNodeAt(subparser, 7)); + bindIdent(subparser, getNodeAt(subparser, 7), getNodeAt(subparser, 6)); + ExitScope(subparser); } -#line 4976 "p4parser.tab.c" +#line 5083 "p4parser.tab.c" break; - case 366: -#line 1071 "p4parser.y" + case 384: +#line 1093 "p4parser.y" { saveBaseType(subparser, getNodeAt(subparser, 4)); bindIdent(subparser, getNodeAt(subparser, 4), getNodeAt(subparser, 3)); } -#line 4985 "p4parser.tab.c" +#line 5092 "p4parser.tab.c" break; - case 367: -#line 1075 "p4parser.y" + case 385: +#line 1097 "p4parser.y" { saveBaseType(subparser, getNodeAt(subparser, 4)); bindIdent(subparser, getNodeAt(subparser, 4), getNodeAt(subparser, 3)); } -#line 4994 "p4parser.tab.c" +#line 5101 "p4parser.tab.c" break; - case 368: -#line 1083 "p4parser.y" + case 386: +#line 1105 "p4parser.y" {} -#line 5000 "p4parser.tab.c" +#line 5107 "p4parser.tab.c" break; - case 369: -#line 1087 "p4parser.y" + case 387: +#line 1109 "p4parser.y" {} -#line 5006 "p4parser.tab.c" +#line 5113 "p4parser.tab.c" break; - case 370: -#line 1088 "p4parser.y" + case 388: +#line 1110 "p4parser.y" {} -#line 5012 "p4parser.tab.c" +#line 5119 "p4parser.tab.c" break; - case 371: -#line 1092 "p4parser.y" + case 389: +#line 1114 "p4parser.y" {} -#line 5018 "p4parser.tab.c" +#line 5125 "p4parser.tab.c" break; - case 372: -#line 1098 "p4parser.y" - {} -#line 5024 "p4parser.tab.c" + case 390: +#line 1120 "p4parser.y" + { ReenterScope(subparser); } +#line 5131 "p4parser.tab.c" break; - case 373: -#line 1102 "p4parser.y" + case 391: +#line 1120 "p4parser.y" + { ExitScope(subparser); } +#line 5137 "p4parser.tab.c" + break; + + case 392: +#line 1124 "p4parser.y" {} -#line 5030 "p4parser.tab.c" +#line 5143 "p4parser.tab.c" break; - case 374: -#line 1103 "p4parser.y" + case 393: +#line 1125 "p4parser.y" {} -#line 5036 "p4parser.tab.c" +#line 5149 "p4parser.tab.c" break; - case 375: -#line 1107 "p4parser.y" + case 394: +#line 1129 "p4parser.y" {} -#line 5042 "p4parser.tab.c" +#line 5155 "p4parser.tab.c" break; - case 376: -#line 1108 "p4parser.y" + case 395: +#line 1130 "p4parser.y" {} -#line 5048 "p4parser.tab.c" +#line 5161 "p4parser.tab.c" break; - case 377: -#line 1112 "p4parser.y" + case 396: +#line 1134 "p4parser.y" {} -#line 5054 "p4parser.tab.c" +#line 5167 "p4parser.tab.c" break; - case 378: -#line 1113 "p4parser.y" + case 397: +#line 1135 "p4parser.y" {} -#line 5060 "p4parser.tab.c" +#line 5173 "p4parser.tab.c" break; - case 379: -#line 1114 "p4parser.y" + case 398: +#line 1136 "p4parser.y" {} -#line 5066 "p4parser.tab.c" +#line 5179 "p4parser.tab.c" break; - case 380: -#line 1118 "p4parser.y" + case 399: +#line 1140 "p4parser.y" {} -#line 5072 "p4parser.tab.c" +#line 5185 "p4parser.tab.c" break; - case 381: -#line 1119 "p4parser.y" + case 400: +#line 1141 "p4parser.y" {} -#line 5078 "p4parser.tab.c" +#line 5191 "p4parser.tab.c" break; - case 382: -#line 1120 "p4parser.y" + case 401: +#line 1142 "p4parser.y" {} -#line 5084 "p4parser.tab.c" +#line 5197 "p4parser.tab.c" break; - case 383: -#line 1124 "p4parser.y" + case 402: +#line 1146 "p4parser.y" {} -#line 5090 "p4parser.tab.c" +#line 5203 "p4parser.tab.c" break; - case 384: -#line 1125 "p4parser.y" + case 403: +#line 1147 "p4parser.y" {} -#line 5096 "p4parser.tab.c" +#line 5209 "p4parser.tab.c" break; - case 385: -#line 1129 "p4parser.y" + case 404: +#line 1151 "p4parser.y" {} -#line 5102 "p4parser.tab.c" +#line 5215 "p4parser.tab.c" break; - case 386: -#line 1129 "p4parser.y" + case 405: +#line 1151 "p4parser.y" {} -#line 5108 "p4parser.tab.c" +#line 5221 "p4parser.tab.c" break; - case 387: -#line 1133 "p4parser.y" + case 406: +#line 1155 "p4parser.y" {} -#line 5114 "p4parser.tab.c" +#line 5227 "p4parser.tab.c" break; - case 388: -#line 1134 "p4parser.y" + case 407: +#line 1156 "p4parser.y" {} -#line 5120 "p4parser.tab.c" +#line 5233 "p4parser.tab.c" break; - case 389: -#line 1135 "p4parser.y" + case 408: +#line 1157 "p4parser.y" {} -#line 5126 "p4parser.tab.c" +#line 5239 "p4parser.tab.c" break; - case 390: -#line 1136 "p4parser.y" - {} -#line 5132 "p4parser.tab.c" + case 409: +#line 1158 "p4parser.y" + {} +#line 5245 "p4parser.tab.c" break; - case 391: -#line 1137 "p4parser.y" - {} -#line 5138 "p4parser.tab.c" + case 410: +#line 1162 "p4parser.y" + {} +#line 5251 "p4parser.tab.c" break; - case 392: -#line 1141 "p4parser.y" + case 411: +#line 1163 "p4parser.y" + {} +#line 5257 "p4parser.tab.c" + break; + + case 412: +#line 1166 "p4parser.y" {} -#line 5144 "p4parser.tab.c" +#line 5263 "p4parser.tab.c" break; - case 393: -#line 1142 "p4parser.y" + case 413: +#line 1167 "p4parser.y" {} -#line 5150 "p4parser.tab.c" +#line 5269 "p4parser.tab.c" break; - case 394: -#line 1143 "p4parser.y" + case 414: +#line 1168 "p4parser.y" {} -#line 5156 "p4parser.tab.c" +#line 5275 "p4parser.tab.c" break; - case 395: -#line 1144 "p4parser.y" + case 415: +#line 1169 "p4parser.y" {} -#line 5162 "p4parser.tab.c" +#line 5281 "p4parser.tab.c" break; - case 396: -#line 1145 "p4parser.y" + case 416: +#line 1170 "p4parser.y" {} -#line 5168 "p4parser.tab.c" +#line 5287 "p4parser.tab.c" break; - case 397: -#line 1146 "p4parser.y" + case 417: +#line 1171 "p4parser.y" {} -#line 5174 "p4parser.tab.c" +#line 5293 "p4parser.tab.c" break; - case 398: -#line 1147 "p4parser.y" + case 418: +#line 1172 "p4parser.y" {} -#line 5180 "p4parser.tab.c" +#line 5299 "p4parser.tab.c" break; - case 399: -#line 1148 "p4parser.y" + case 419: +#line 1173 "p4parser.y" {} -#line 5186 "p4parser.tab.c" +#line 5305 "p4parser.tab.c" break; - case 400: -#line 1149 "p4parser.y" + case 420: +#line 1174 "p4parser.y" {} -#line 5192 "p4parser.tab.c" +#line 5311 "p4parser.tab.c" break; - case 401: -#line 1150 "p4parser.y" + case 421: +#line 1175 "p4parser.y" {} -#line 5198 "p4parser.tab.c" +#line 5317 "p4parser.tab.c" break; - case 402: -#line 1151 "p4parser.y" + case 422: +#line 1176 "p4parser.y" {} -#line 5204 "p4parser.tab.c" +#line 5323 "p4parser.tab.c" break; - case 403: -#line 1152 "p4parser.y" + case 423: +#line 1177 "p4parser.y" {} -#line 5210 "p4parser.tab.c" +#line 5329 "p4parser.tab.c" break; - case 404: -#line 1153 "p4parser.y" + case 424: +#line 1178 "p4parser.y" {} -#line 5216 "p4parser.tab.c" +#line 5335 "p4parser.tab.c" break; - case 405: -#line 1154 "p4parser.y" + case 425: +#line 1179 "p4parser.y" {} -#line 5222 "p4parser.tab.c" +#line 5341 "p4parser.tab.c" break; - case 406: -#line 1155 "p4parser.y" + case 426: +#line 1180 "p4parser.y" {} -#line 5228 "p4parser.tab.c" +#line 5347 "p4parser.tab.c" break; - case 407: -#line 1156 "p4parser.y" + case 427: +#line 1181 "p4parser.y" {} -#line 5234 "p4parser.tab.c" +#line 5353 "p4parser.tab.c" break; - case 408: -#line 1158 "p4parser.y" + case 428: +#line 1183 "p4parser.y" {} -#line 5240 "p4parser.tab.c" +#line 5359 "p4parser.tab.c" break; - case 409: -#line 1160 "p4parser.y" + case 429: +#line 1185 "p4parser.y" {} -#line 5246 "p4parser.tab.c" +#line 5365 "p4parser.tab.c" break; - case 410: -#line 1161 "p4parser.y" + case 430: +#line 1186 "p4parser.y" {} -#line 5252 "p4parser.tab.c" +#line 5371 "p4parser.tab.c" break; - case 411: -#line 1162 "p4parser.y" + case 431: +#line 1187 "p4parser.y" {} -#line 5258 "p4parser.tab.c" +#line 5377 "p4parser.tab.c" break; - case 412: -#line 1163 "p4parser.y" + case 432: +#line 1188 "p4parser.y" {} -#line 5264 "p4parser.tab.c" +#line 5383 "p4parser.tab.c" break; - case 413: -#line 1164 "p4parser.y" + case 433: +#line 1189 "p4parser.y" {} -#line 5270 "p4parser.tab.c" +#line 5389 "p4parser.tab.c" break; - case 414: -#line 1165 "p4parser.y" + case 434: +#line 1190 "p4parser.y" {} -#line 5276 "p4parser.tab.c" +#line 5395 "p4parser.tab.c" break; - case 415: -#line 1166 "p4parser.y" + case 435: +#line 1191 "p4parser.y" {} -#line 5282 "p4parser.tab.c" +#line 5401 "p4parser.tab.c" break; - case 416: -#line 1167 "p4parser.y" + case 436: +#line 1192 "p4parser.y" {} -#line 5288 "p4parser.tab.c" +#line 5407 "p4parser.tab.c" break; - case 417: -#line 1168 "p4parser.y" + case 437: +#line 1193 "p4parser.y" {} -#line 5294 "p4parser.tab.c" +#line 5413 "p4parser.tab.c" break; - case 418: -#line 1169 "p4parser.y" + case 438: +#line 1194 "p4parser.y" {} -#line 5300 "p4parser.tab.c" +#line 5419 "p4parser.tab.c" break; - case 419: -#line 1171 "p4parser.y" + case 439: +#line 1196 "p4parser.y" {} -#line 5306 "p4parser.tab.c" +#line 5425 "p4parser.tab.c" break; - case 420: -#line 1172 "p4parser.y" + case 440: +#line 1197 "p4parser.y" {} -#line 5312 "p4parser.tab.c" +#line 5431 "p4parser.tab.c" break; - case 421: -#line 1173 "p4parser.y" + case 441: +#line 1198 "p4parser.y" {} -#line 5318 "p4parser.tab.c" +#line 5437 "p4parser.tab.c" break; - case 422: -#line 1175 "p4parser.y" + case 442: +#line 1200 "p4parser.y" {} -#line 5324 "p4parser.tab.c" +#line 5443 "p4parser.tab.c" break; - case 423: -#line 1176 "p4parser.y" + case 443: +#line 1201 "p4parser.y" {} -#line 5330 "p4parser.tab.c" +#line 5449 "p4parser.tab.c" break; - case 424: -#line 1178 "p4parser.y" + case 444: +#line 1203 "p4parser.y" {} -#line 5336 "p4parser.tab.c" +#line 5455 "p4parser.tab.c" break; - case 425: -#line 1179 "p4parser.y" + case 445: +#line 1204 "p4parser.y" {} -#line 5342 "p4parser.tab.c" +#line 5461 "p4parser.tab.c" break; - case 426: -#line 1180 "p4parser.y" + case 446: +#line 1205 "p4parser.y" {} -#line 5348 "p4parser.tab.c" +#line 5467 "p4parser.tab.c" break; - case 427: -#line 1181 "p4parser.y" + case 447: +#line 1206 "p4parser.y" {} -#line 5354 "p4parser.tab.c" +#line 5473 "p4parser.tab.c" break; - case 428: -#line 1182 "p4parser.y" + case 448: +#line 1207 "p4parser.y" {} -#line 5360 "p4parser.tab.c" +#line 5479 "p4parser.tab.c" break; - case 429: -#line 1183 "p4parser.y" + case 449: +#line 1208 "p4parser.y" {} -#line 5366 "p4parser.tab.c" +#line 5485 "p4parser.tab.c" break; - case 430: -#line 1184 "p4parser.y" + case 450: +#line 1209 "p4parser.y" {} -#line 5372 "p4parser.tab.c" +#line 5491 "p4parser.tab.c" break; - case 431: -#line 1185 "p4parser.y" + case 451: +#line 1210 "p4parser.y" {} -#line 5378 "p4parser.tab.c" +#line 5497 "p4parser.tab.c" break; - case 432: -#line 1186 "p4parser.y" + case 452: +#line 1211 "p4parser.y" {} -#line 5384 "p4parser.tab.c" +#line 5503 "p4parser.tab.c" break; - case 433: -#line 1188 "p4parser.y" - {} -#line 5390 "p4parser.tab.c" + case 453: +#line 1212 "p4parser.y" + {} +#line 5509 "p4parser.tab.c" break; - case 434: -#line 1190 "p4parser.y" + case 454: +#line 1213 "p4parser.y" + {} +#line 5515 "p4parser.tab.c" + break; + + case 456: +#line 1217 "p4parser.y" {} -#line 5396 "p4parser.tab.c" +#line 5521 "p4parser.tab.c" break; - case 435: -#line 1192 "p4parser.y" + case 457: +#line 1219 "p4parser.y" {} -#line 5402 "p4parser.tab.c" +#line 5527 "p4parser.tab.c" break; - case 436: -#line 1193 "p4parser.y" - {} -#line 5408 "p4parser.tab.c" + case 458: +#line 1221 "p4parser.y" + {} +#line 5533 "p4parser.tab.c" break; - case 437: -#line 1197 "p4parser.y" + case 459: +#line 1225 "p4parser.y" {} -#line 5414 "p4parser.tab.c" +#line 5539 "p4parser.tab.c" break; - case 438: -#line 1198 "p4parser.y" + case 460: +#line 1226 "p4parser.y" {} -#line 5420 "p4parser.tab.c" +#line 5545 "p4parser.tab.c" break; - case 439: -#line 1199 "p4parser.y" + case 461: +#line 1227 "p4parser.y" {} -#line 5426 "p4parser.tab.c" +#line 5551 "p4parser.tab.c" break; - case 440: -#line 1200 "p4parser.y" + case 462: +#line 1228 "p4parser.y" {} -#line 5432 "p4parser.tab.c" +#line 5557 "p4parser.tab.c" break; - case 441: -#line 1201 "p4parser.y" + case 463: +#line 1229 "p4parser.y" {} -#line 5438 "p4parser.tab.c" +#line 5563 "p4parser.tab.c" break; - case 442: -#line 1202 "p4parser.y" + case 464: +#line 1230 "p4parser.y" {} -#line 5444 "p4parser.tab.c" +#line 5569 "p4parser.tab.c" break; - case 443: -#line 1203 "p4parser.y" + case 465: +#line 1231 "p4parser.y" {} -#line 5450 "p4parser.tab.c" +#line 5575 "p4parser.tab.c" break; - case 444: -#line 1204 "p4parser.y" + case 466: +#line 1232 "p4parser.y" {} -#line 5456 "p4parser.tab.c" +#line 5581 "p4parser.tab.c" break; - case 445: -#line 1205 "p4parser.y" + case 467: +#line 1233 "p4parser.y" {} -#line 5462 "p4parser.tab.c" +#line 5587 "p4parser.tab.c" break; - case 446: -#line 1206 "p4parser.y" + case 468: +#line 1234 "p4parser.y" {} -#line 5468 "p4parser.tab.c" +#line 5593 "p4parser.tab.c" break; - case 447: -#line 1207 "p4parser.y" + case 469: +#line 1235 "p4parser.y" {} -#line 5474 "p4parser.tab.c" +#line 5599 "p4parser.tab.c" break; - case 448: -#line 1208 "p4parser.y" + case 470: +#line 1236 "p4parser.y" {} -#line 5480 "p4parser.tab.c" +#line 5605 "p4parser.tab.c" break; - case 449: -#line 1209 "p4parser.y" + case 471: +#line 1237 "p4parser.y" {} -#line 5486 "p4parser.tab.c" +#line 5611 "p4parser.tab.c" break; - case 450: -#line 1210 "p4parser.y" + case 472: +#line 1238 "p4parser.y" {} -#line 5492 "p4parser.tab.c" +#line 5617 "p4parser.tab.c" break; - case 451: -#line 1212 "p4parser.y" + case 473: +#line 1240 "p4parser.y" {} -#line 5498 "p4parser.tab.c" +#line 5623 "p4parser.tab.c" break; - case 452: -#line 1214 "p4parser.y" + case 474: +#line 1242 "p4parser.y" {} -#line 5504 "p4parser.tab.c" +#line 5629 "p4parser.tab.c" break; - case 453: -#line 1215 "p4parser.y" + case 475: +#line 1243 "p4parser.y" {} -#line 5510 "p4parser.tab.c" +#line 5635 "p4parser.tab.c" break; - case 454: -#line 1216 "p4parser.y" + case 476: +#line 1244 "p4parser.y" {} -#line 5516 "p4parser.tab.c" +#line 5641 "p4parser.tab.c" break; - case 455: -#line 1217 "p4parser.y" + case 477: +#line 1245 "p4parser.y" {} -#line 5522 "p4parser.tab.c" +#line 5647 "p4parser.tab.c" break; - case 456: -#line 1218 "p4parser.y" + case 478: +#line 1246 "p4parser.y" {} -#line 5528 "p4parser.tab.c" +#line 5653 "p4parser.tab.c" break; - case 457: -#line 1219 "p4parser.y" + case 479: +#line 1247 "p4parser.y" {} -#line 5534 "p4parser.tab.c" +#line 5659 "p4parser.tab.c" break; - case 458: -#line 1220 "p4parser.y" + case 480: +#line 1248 "p4parser.y" {} -#line 5540 "p4parser.tab.c" +#line 5665 "p4parser.tab.c" break; - case 459: -#line 1221 "p4parser.y" + case 481: +#line 1249 "p4parser.y" {} -#line 5546 "p4parser.tab.c" +#line 5671 "p4parser.tab.c" break; - case 460: -#line 1222 "p4parser.y" + case 482: +#line 1250 "p4parser.y" {} -#line 5552 "p4parser.tab.c" +#line 5677 "p4parser.tab.c" break; - case 461: -#line 1223 "p4parser.y" + case 483: +#line 1251 "p4parser.y" {} -#line 5558 "p4parser.tab.c" +#line 5683 "p4parser.tab.c" break; - case 462: -#line 1225 "p4parser.y" + case 484: +#line 1253 "p4parser.y" {} -#line 5564 "p4parser.tab.c" +#line 5689 "p4parser.tab.c" break; - case 463: -#line 1226 "p4parser.y" + case 485: +#line 1254 "p4parser.y" {} -#line 5570 "p4parser.tab.c" +#line 5695 "p4parser.tab.c" break; - case 464: -#line 1227 "p4parser.y" + case 486: +#line 1255 "p4parser.y" {} -#line 5576 "p4parser.tab.c" +#line 5701 "p4parser.tab.c" break; - case 465: -#line 1229 "p4parser.y" + case 487: +#line 1257 "p4parser.y" {} -#line 5582 "p4parser.tab.c" +#line 5707 "p4parser.tab.c" break; - case 466: -#line 1230 "p4parser.y" + case 488: +#line 1258 "p4parser.y" {} -#line 5588 "p4parser.tab.c" +#line 5713 "p4parser.tab.c" break; - case 467: -#line 1231 "p4parser.y" + case 489: +#line 1259 "p4parser.y" {} -#line 5594 "p4parser.tab.c" +#line 5719 "p4parser.tab.c" break; - case 468: -#line 1232 "p4parser.y" + case 490: +#line 1260 "p4parser.y" {} -#line 5600 "p4parser.tab.c" +#line 5725 "p4parser.tab.c" break; - case 469: -#line 1233 "p4parser.y" + case 491: +#line 1261 "p4parser.y" {} -#line 5606 "p4parser.tab.c" +#line 5731 "p4parser.tab.c" break; - case 470: -#line 1234 "p4parser.y" + case 492: +#line 1262 "p4parser.y" {} -#line 5612 "p4parser.tab.c" +#line 5737 "p4parser.tab.c" break; - case 471: -#line 1235 "p4parser.y" + case 493: +#line 1263 "p4parser.y" {} -#line 5618 "p4parser.tab.c" +#line 5743 "p4parser.tab.c" break; - case 472: -#line 1236 "p4parser.y" + case 494: +#line 1264 "p4parser.y" {} -#line 5624 "p4parser.tab.c" +#line 5749 "p4parser.tab.c" break; - case 473: -#line 1237 "p4parser.y" + case 495: +#line 1265 "p4parser.y" {} -#line 5630 "p4parser.tab.c" +#line 5755 "p4parser.tab.c" break; - case 474: -#line 1238 "p4parser.y" + case 496: +#line 1266 "p4parser.y" {} -#line 5636 "p4parser.tab.c" +#line 5761 "p4parser.tab.c" break; - case 475: -#line 1239 "p4parser.y" + case 497: +#line 1267 "p4parser.y" {} -#line 5642 "p4parser.tab.c" +#line 5767 "p4parser.tab.c" break; - case 476: -#line 1241 "p4parser.y" - {} -#line 5648 "p4parser.tab.c" + case 498: +#line 1268 "p4parser.y" + {} +#line 5773 "p4parser.tab.c" break; - case 477: -#line 1243 "p4parser.y" + case 499: +#line 1269 "p4parser.y" + {} +#line 5779 "p4parser.tab.c" + break; + + case 501: +#line 1273 "p4parser.y" {} -#line 5654 "p4parser.tab.c" +#line 5785 "p4parser.tab.c" break; - case 478: -#line 1245 "p4parser.y" + case 502: +#line 1275 "p4parser.y" {} -#line 5660 "p4parser.tab.c" +#line 5791 "p4parser.tab.c" break; - case 479: -#line 1246 "p4parser.y" - {} -#line 5666 "p4parser.tab.c" + case 503: +#line 1277 "p4parser.y" + {} +#line 5797 "p4parser.tab.c" break; -#line 5670 "p4parser.tab.c" +#line 5801 "p4parser.tab.c" default: break; } @@ -5898,7 +6029,7 @@ yyparse (void) #endif return yyresult; } -#line 1274 "p4parser.y" +#line 1305 "p4parser.y" /** True when statistics should be output. */ diff --git a/src/superc/p4parser/p4parser.y b/src/superc/p4parser/p4parser.y index 83570382..de55c5a0 100644 --- a/src/superc/p4parser/p4parser.y +++ b/src/superc/p4parser/p4parser.y @@ -235,7 +235,7 @@ a syntax error causing a spurious error cascade, which isn't too bad. track of which identifiers represent types, and which represent namespaces. */ -start: +start: /** complete **/ program; @@ -306,14 +306,16 @@ annotation: /** complete **/ {} | AT name L_PAREN annotationBody R_PAREN {} - | AT name L_BRACKET expressionList R_BRACKET + | AT name L_BRACKET structuredAnnotationBody R_BRACKET {} - | AT name L_BRACKET kvList R_BRACKET - {} - // Experimental: backwards compatibility with P4-14 pragmas (which - // themselves are experimental!) + // Experimental as per P4C lexer (https://github.com/p4lang/p4c/blob/4a40ce4a15957de76e3a161c3778f1f0b6ac5780/frontends/parsers/p4/p4parser.ypp) + // For backward compatibility with p4-14 | PRAGMA name annotationBody END_PRAGMA - {} + ; + +structuredAnnotationBody + : expressionList + | kvList ; annotationBody: /** complete, list **/ @@ -425,7 +427,7 @@ kvPair: /** complete **/ parameterList: /** complete, list **/ %empty {} - | nonEmptyParameterList {} + | { ReenterScope(subparser); } nonEmptyParameterList { ExitReentrantScope(subparser); } ; nonEmptyParameterList: /** complete, list **/ @@ -459,13 +461,10 @@ instantiation: /** complete **/ {} | typeRef L_PAREN argumentList R_PAREN name SEMICOLON {} - /* experimental */ | annotations typeRef L_PAREN argumentList R_PAREN name ASSIGN objInitializer SEMICOLON - {} - /* experimental */ + | typeRef L_PAREN argumentList R_PAREN name ASSIGN objInitializer SEMICOLON - {} - ; + ; /* experimental; includes the following 3 productions */ objInitializer: @@ -495,8 +494,8 @@ dotPrefix: /**************************** PARSER ******************************/ parserDeclaration: /** complete **/ - parserTypeDeclaration optConstructorParameters { EnterScope(subparser); } - L_BRACE parserLocalElements parserStates { ExitScope(subparser); } R_BRACE + parserTypeDeclaration optConstructorParameters + L_BRACE { ReenterScope(subparser); } parserLocalElements parserStates { ExitScope(subparser); } R_BRACE {} ; @@ -627,7 +626,9 @@ valueSetDeclaration: /** complete **/ controlDeclaration: /** complete **/ controlTypeDeclaration optConstructorParameters - L_BRACE controlLocalDeclarations APPLY controlBody R_BRACE + L_BRACE { ReenterScope(subparser); } + controlLocalDeclarations APPLY controlBody + { ExitScope(subparser); } R_BRACE {} ; @@ -667,9 +668,13 @@ externDeclaration: /** complete **/ bindIdent(subparser, getNodeAt(subparser, 2), getNodeAt(subparser, 1)); } optTypeParameters {} - L_BRACE methodPrototypes R_BRACE - | optAnnotations EXTERN functionPrototype SEMICOLON - | optAnnotations EXTERN name SEMICOLON + L_BRACE { ReenterScope(subparser); } methodPrototypes { ExitScope(subparser); } R_BRACE + | externFunctionDeclaration + | optAnnotations EXTERN name SEMICOLON // not present in latest language specification + ; + +externFunctionDeclaration: /** complete **/ + optAnnotations EXTERN functionPrototype SEMICOLON ; methodPrototypes: /** complete, list **/ @@ -686,10 +691,14 @@ functionPrototype: methodPrototype: /** complete **/ optAnnotations functionPrototype SEMICOLON {} | optAnnotations ABSTRACT functionPrototype SEMICOLON {} // experimental - | optAnnotations TYPE_IDENTIFIER L_PAREN parameterList R_PAREN SEMICOLON // constructor + | constructorMethodPrototype {} {} ; +constructorMethodPrototype: /** complete **/ + optAnnotations TYPE_IDENTIFIER L_PAREN parameterList R_PAREN SEMICOLON // constructor + ; + /************************** TYPES ****************************/ typeRef: /** complete **/ @@ -761,7 +770,7 @@ optTypeParameters: /** complete **/ ; typeParameters: /** complete **/ - l_angle typeParameterList r_angle {} + l_angle { EnterScope(subparser); } typeParameterList { ExitReentrantScope(subparser); } r_angle {} ; typeParameterList: /** complete, list **/ @@ -820,8 +829,10 @@ derivedTypeDeclaration: /** complete **/ ; headerTypeDeclaration: /** complete **/ - optAnnotations HEADER name {} optTypeParameters {} - L_BRACE structFieldList R_BRACE + optAnnotations HEADER name optTypeParameters + L_BRACE { ReenterScope(subparser); } + structFieldList { ExitScope(subparser); } + R_BRACE { saveBaseType(subparser, getNodeAt(subparser, 8)); bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); @@ -830,16 +841,20 @@ headerTypeDeclaration: /** complete **/ structTypeDeclaration: /** complete **/ optAnnotations STRUCT name optTypeParameters - L_BRACE structFieldList R_BRACE + L_BRACE { ReenterScope(subparser); } + structFieldList + { ExitScope(subparser); } R_BRACE { - saveBaseType(subparser, getNodeAt(subparser, 6)); - bindIdent(subparser, getNodeAt(subparser, 6), getNodeAt(subparser, 5)); + saveBaseType(subparser, getNodeAt(subparser, 8)); + bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } ; headerUnionDeclaration: /** complete **/ - optAnnotations HEADER_UNION name {} optTypeParameters {} - L_BRACE structFieldList R_BRACE { + optAnnotations HEADER_UNION name optTypeParameters + L_BRACE { ReenterScope(subparser); } + structFieldList + { ExitScope(subparser); } R_BRACE { saveBaseType(subparser, getNodeAt(subparser, 8)); bindIdent(subparser, getNodeAt(subparser, 8), getNodeAt(subparser, 7)); } @@ -916,15 +931,17 @@ typedefDeclaration: /** complete **/ assignmentOrMethodCallStatement: /** complete **/ // These rules are overly permissive, but they avoid some conflicts - lvalue L_PAREN argumentList R_PAREN SEMICOLON + methodCallStatements {} - - | lvalue l_angle typeArgumentList r_angle L_PAREN argumentList R_PAREN SEMICOLON - {} - | lvalue ASSIGN expression SEMICOLON {} + ; +methodCallStatements: + lvalue L_PAREN argumentList R_PAREN SEMICOLON + {} + | lvalue l_angle typeArgumentList r_angle L_PAREN argumentList R_PAREN SEMICOLON + {} ; emptyStatement: /** complete **/ @@ -1003,7 +1020,7 @@ statementOrDeclaration: /** complete **/ tableDeclaration: /** complete **/ optAnnotations - TABLE name L_BRACE tablePropertyList R_BRACE + TABLE name L_BRACE { EnterScope(subparser); } tablePropertyList { ExitScope(subparser); } R_BRACE {} ; @@ -1017,7 +1034,7 @@ tableProperty: /** complete **/ {} | ACTIONS ASSIGN L_BRACE actionList R_BRACE {} - | optAnnotations optCONST ENTRIES ASSIGN L_BRACE entriesList R_BRACE + | optAnnotations CONST ENTRIES ASSIGN L_BRACE entriesList R_BRACE // updated optCONST to CONST as per new specs {} | optAnnotations optCONST nonTableKwName ASSIGN initializer SEMICOLON {} @@ -1035,10 +1052,14 @@ keyElement: /** complete **/ actionList: /** complete, list **/ %empty {} - | actionList optAnnotations actionRef SEMICOLON + | actionList action {} ; +action: /** complete **/ + optAnnotations actionRef SEMICOLON + ; + actionRef: /** complete **/ prefixedNonTypeName {} @@ -1059,9 +1080,10 @@ entriesList: /** complete, list **/ /************************* ACTION ********************************/ actionDeclaration: /** complete **/ - optAnnotations ACTION name L_PAREN parameterList R_PAREN blockStatement { - saveBaseType(subparser, getNodeAt(subparser, 6)); - bindIdent(subparser, getNodeAt(subparser, 6), getNodeAt(subparser, 5)); + optAnnotations ACTION name L_PAREN parameterList R_PAREN { EnterScope(subparser); } blockStatement { + saveBaseType(subparser, getNodeAt(subparser, 7)); + bindIdent(subparser, getNodeAt(subparser, 7), getNodeAt(subparser, 6)); + ExitScope(subparser); } ; @@ -1095,10 +1117,10 @@ initializer: /** complete **/ /**************** Expressions ****************/ functionDeclaration: /** complete **/ - functionPrototype blockStatement {} + functionPrototype { ReenterScope(subparser); } blockStatement { ExitScope(subparser); } ; -argumentList: /** complete, list **/ +argumentList: /** complete **/ %empty {} | nonEmptyArgList {} ; @@ -1133,10 +1155,13 @@ lvalue: /** complete **/ prefixedNonTypeName {} | THIS {} // experimental | lvalue dot_name %prec DOT {} - | lvalue L_BRACKET expression R_BRACKET {} - | lvalue L_BRACKET expression COLON expression R_BRACKET {} + | lvalue lvalueExpression {} ; +lvalueExpression: /** complete **/ + L_BRACKET expression R_BRACKET {} + | L_BRACKET expression COLON expression R_BRACKET {} + expression: /** complete, list **/ INTEGER {} | STRING_LITERAL {} @@ -1184,13 +1209,16 @@ expression: /** complete, list **/ | expression AND expression {} | expression OR expression {} | expression QUESTION expression COLON expression {} + | L_PAREN typeRef R_PAREN expression %prec PREFIX {} + | invokingExpression {} + ; +invokingExpression: /** complete, list **/ | expression l_angle realTypeArgumentList r_angle L_PAREN argumentList R_PAREN {} | expression L_PAREN argumentList R_PAREN {} | namedType L_PAREN argumentList R_PAREN {} - | L_PAREN typeRef R_PAREN expression %prec PREFIX {} ; nonBraceExpression: /** complete, list **/ @@ -1237,13 +1265,16 @@ nonBraceExpression: /** complete, list **/ | nonBraceExpression AND expression {} | nonBraceExpression OR expression {} | nonBraceExpression QUESTION expression COLON expression {} + | L_PAREN typeRef R_PAREN expression %prec PREFIX {} + | invokingNonBraceExpression {} + ; +invokingNonBraceExpression: /** complete, list **/ | nonBraceExpression l_angle realTypeArgumentList r_angle L_PAREN argumentList R_PAREN {} | nonBraceExpression L_PAREN argumentList R_PAREN {} | namedType L_PAREN argumentList R_PAREN {} - | L_PAREN typeRef R_PAREN expression %prec PREFIX {} ; intOrStr: diff --git a/src/superc/p4parser/tmp/README b/src/superc/p4parser/tmp/README new file mode 100644 index 00000000..c2be7a04 --- /dev/null +++ b/src/superc/p4parser/tmp/README @@ -0,0 +1 @@ +This folder is needed for GraphViz to store temporary files when creating call graphs for P4 \ No newline at end of file