Changeset 7756647
- Timestamp:
- Oct 13, 2016, 2:45:17 PM (6 years ago)
- Branches:
- aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
- Children:
- 848ce71
- Parents:
- ac9ca96 (diff), d58a39a0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Files:
-
- 11 added
- 20 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/aaron_comp_II/comp_II.tex
rac9ca96 r7756647 400 400 401 401 \section{Expression Resolution} 402 \subsection{Analysis} 402 403 The expression resolution problem is determining an optimal match between some combination of argument interpretations and the parameter list of some overloaded instance of a function; the argument interpretations are produced by recursive invocations of expression resolution, where the base case is zero-argument functions (which are, for purposes of this discussion, semantically equivalent to named variables or constant literal expressions). 403 404 Assuming that the matching between a function's parameter list and a combination of argument interpretations can be done in $\bigO{p^k}$ time, where $p$ is the number of parameters and $k$ is some positive number, if there are $\bigO{i}$ valid interpretations for each subexpression, there will be $\bigO{i}$ candidate functions and $\bigO{i^p}$ possible argument combinations for each expression, so for a single recursive call expression resolution takes $\bigO{i^{p+1} \cdot p^k}$ time if it must compare all combinations, or $\bigO{i(p+1) \cdot p^k}$ time if argument-parameter matches can be chosen independently of each other. … … 409 410 The number of valid interpretations of any subexpression, $i$, is bounded by the number of types in the system, which is possibly infinite, though practical resolution algorithms for \CFA must be able to place some finite bound on $i$, possibly at the expense of type-system completeness. 410 411 412 \subsection{Expression Costs} 413 The expression resolution problem involves minimization of a cost function; loosely defined, this cost function is the number of implicit conversions in the top-level expression interpretation. 414 With more specificity, the \emph{cost} of a particular expression interpretation is a lexicographically-ordered tuple, where each element of the tuple corresponds to a particular kind of conversion. 415 In \CFA today, cost is a three-tuple including the number of unsafe conversions, the number of polymorphic parameter bindings, and the number of safe conversions. 416 These counts include conversions used in subexpression interpretations, as well as those necessary to satisfy the type assertions of any polymorphic functions included in the interpretation. 417 418 \begin{lstlisting} 419 void f(char, long); // $f_1$ - cost (2, 0, 1) 420 forall(otype T) void f(T, long); // $f_2$ - cost (0, 1, 1) 421 void f(long, long); // $f_{3a}$ - cost (0, 0, 2) 422 void f(int, float); // $f_{3b}$ - cost (0, 0, 2) 423 void f(int, long); // $f_4$ - cost (0, 0, 1) 424 425 f(7, 11); 426 \end{lstlisting} 427 428 In the example above, the expression resolves to $f_4$. 429 $f_1$ has an unsafe conversion (from ©int© to ©char©), and is thus the highest cost, followed by $f_2$, which has a polymorphic binding (from ©int© to ©T©). 430 Neither $f_{3a}$, $f_{3b}$, or $f_4$ match exactly with the type of the call expression (©void (*)(int, int)©), each involving safe conversions, but in this case $f_4$ is cheaper than $f_{3a}$, because it converts fewer arguments, and is also cheaper than $f_{3b}$, because ©long© is a closer match for ©int© than ©float© is. 431 If the declaration of $f_4$ was missing, the expression would be ambiguous, because the two single-step ©int©-to-©long© conversions in $f_{3a}$ cost the same as the one double-step ©int©-to-©float© conversion in $f_{3b}$. 432 433 In the course of this project I may modify the cost tuple,\footnote{I have considered adding an element to distinguish between cast expressions used as conversions and those used as type ascriptions, and another element to differentiate interpretations based on closer qualifier matches. The existing costing of polymorphic functions could also be made more precice than a bare count of parameter bindings.} but the essential nature of the cost calculation should remain the same. 434 435 \subsection{Objectives} 411 436 The research goal of this project is to develop a performant expression resolver for \CFA; this analysis suggests three primary areas of investigation to accomplish that end. 412 437 The first area of investigation is efficient argument-parameter matching; Bilson~\cite{Bilson03} mentions significant optimization opportunities available in the current literature to improve on the existing CFA compiler. -
src/Common/SemanticError.h
rac9ca96 r7756647 10 10 // Created On : Mon May 18 07:44:20 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon Jun 8 14:38:53 201513 // Update Count : 412 // Last Modified On : Sat Sep 24 15:13:42 2016 13 // Update Count : 5 14 14 // 15 15 … … 46 46 } 47 47 48 49 48 #endif // SEMANTICERROR_H 50 49 -
src/Common/module.mk
rac9ca96 r7756647 11 11 ## Created On : Mon Jun 1 17:49:17 2015 12 12 ## Last Modified By : Peter A. Buhr 13 ## Last Modified On : T hu Aug 18 13:29:04201614 ## Update Count : 213 ## Last Modified On : Tue Sep 27 11:06:38 2016 14 ## Update Count : 4 15 15 ############################################################################### 16 16 17 17 SRC += Common/SemanticError.cc \ 18 18 Common/UniqueName.cc \ 19 Common/DebugMalloc.cc \ 19 20 Common/Assert.cc -
src/Common/utility.h
rac9ca96 r7756647 10 10 // Created On : Mon May 18 07:44:20 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Jun 8 17:33:59201613 // Update Count : 2 212 // Last Modified On : Fri Sep 23 11:46:47 2016 13 // Update Count : 28 14 14 // 15 15 … … 25 25 #include <sstream> 26 26 #include <string> 27 #include <cassert> 27 28 28 29 template< typename T > … … 101 102 } // if 102 103 } // for 103 }104 105 static inline std::string assign_strptr( const std::string *str ) {106 if ( str == 0 ) {107 return "";108 } else {109 std::string tmp;110 tmp = *str;111 delete str;112 return tmp;113 } // if114 104 } 115 105 … … 141 131 142 132 template < typename T > 143 void toString_single 133 void toString_single( std::ostream & os, const T & value ) { 144 134 os << value; 145 135 } 146 136 147 137 template < typename T, typename... Params > 148 void toString_single 138 void toString_single( std::ostream & os, const T & value, const Params & ... params ) { 149 139 os << value; 150 140 toString_single( os, params ... ); … … 152 142 153 143 template < typename ... Params > 154 std::string toString 144 std::string toString( const Params & ... params ) { 155 145 std::ostringstream os; 156 146 toString_single( os, params... ); -
src/Makefile.am
rac9ca96 r7756647 11 11 ## Created On : Sun May 31 08:51:46 2015 12 12 ## Last Modified By : Peter A. Buhr 13 ## Last Modified On : Sat Aug 20 11:13:12 201614 ## Update Count : 7 113 ## Last Modified On : Sat Sep 24 15:03:52 2016 14 ## Update Count : 73 15 15 ############################################################################### 16 16 … … 40 40 cfa_cpplib_PROGRAMS = driver/cfa-cpp 41 41 driver_cfa_cpp_SOURCES = ${SRC} 42 driver_cfa_cpp_LDADD = ${LEXLIB} # yywrap42 driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap 43 43 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include 44 44 -
src/Makefile.in
rac9ca96 r7756647 98 98 Common/driver_cfa_cpp-SemanticError.$(OBJEXT) \ 99 99 Common/driver_cfa_cpp-UniqueName.$(OBJEXT) \ 100 Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) \ 100 101 Common/driver_cfa_cpp-Assert.$(OBJEXT) \ 101 102 ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT) \ … … 358 359 CodeGen/CodeGenerator.cc CodeGen/GenType.cc \ 359 360 CodeGen/FixNames.cc CodeGen/OperatorTable.cc \ 360 Common/SemanticError.cc Common/UniqueName.cc Common/Assert.cc \ 361 Common/SemanticError.cc Common/UniqueName.cc \ 362 Common/DebugMalloc.cc Common/Assert.cc \ 361 363 ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \ 362 364 ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \ … … 412 414 cfa_cpplibdir = ${libdir} 413 415 driver_cfa_cpp_SOURCES = ${SRC} 414 driver_cfa_cpp_LDADD = ${LEXLIB} # yywrap416 driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap 415 417 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include 416 418 all: $(BUILT_SOURCES) … … 512 514 Common/$(DEPDIR)/$(am__dirstamp) 513 515 Common/driver_cfa_cpp-UniqueName.$(OBJEXT): Common/$(am__dirstamp) \ 516 Common/$(DEPDIR)/$(am__dirstamp) 517 Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT): Common/$(am__dirstamp) \ 514 518 Common/$(DEPDIR)/$(am__dirstamp) 515 519 Common/driver_cfa_cpp-Assert.$(OBJEXT): Common/$(am__dirstamp) \ … … 784 788 -rm -f CodeGen/driver_cfa_cpp-OperatorTable.$(OBJEXT) 785 789 -rm -f Common/driver_cfa_cpp-Assert.$(OBJEXT) 790 -rm -f Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) 786 791 -rm -f Common/driver_cfa_cpp-SemanticError.$(OBJEXT) 787 792 -rm -f Common/driver_cfa_cpp-UniqueName.$(OBJEXT) … … 889 894 @AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/driver_cfa_cpp-OperatorTable.Po@am__quote@ 890 895 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-Assert.Po@am__quote@ 896 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po@am__quote@ 891 897 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-SemanticError.Po@am__quote@ 892 898 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@ … … 1125 1131 @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-UniqueName.obj `if test -f 'Common/UniqueName.cc'; then $(CYGPATH_W) 'Common/UniqueName.cc'; else $(CYGPATH_W) '$(srcdir)/Common/UniqueName.cc'; fi` 1126 1132 1133 Common/driver_cfa_cpp-DebugMalloc.o: Common/DebugMalloc.cc 1134 @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-DebugMalloc.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo -c -o Common/driver_cfa_cpp-DebugMalloc.o `test -f 'Common/DebugMalloc.cc' || echo '$(srcdir)/'`Common/DebugMalloc.cc 1135 @am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po 1136 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.o' libtool=no @AMDEPBACKSLASH@ 1137 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ 1138 @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.o `test -f 'Common/DebugMalloc.cc' || echo '$(srcdir)/'`Common/DebugMalloc.cc 1139 1140 Common/driver_cfa_cpp-DebugMalloc.obj: Common/DebugMalloc.cc 1141 @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-DebugMalloc.obj -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi` 1142 @am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po 1143 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.obj' libtool=no @AMDEPBACKSLASH@ 1144 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ 1145 @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi` 1146 1127 1147 Common/driver_cfa_cpp-Assert.o: Common/Assert.cc 1128 1148 @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-Assert.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-Assert.Tpo -c -o Common/driver_cfa_cpp-Assert.o `test -f 'Common/Assert.cc' || echo '$(srcdir)/'`Common/Assert.cc -
src/Parser/DeclarationNode.cc
rac9ca96 r7756647 10 10 // Created On : Sat May 16 12:34:05 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Sep 14 23:13:28 201613 // Update Count : 50212 // Last Modified On : Mon Oct 3 18:03:08 2016 13 // Update Count : 651 14 14 // 15 15 … … 31 31 32 32 // These must remain in the same order as the corresponding DeclarationNode enumerations. 33 const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };34 const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };35 const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };36 const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };37 const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };38 const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };39 const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" };40 const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };41 const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };33 const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" }; 34 const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" }; 35 const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" }; 36 const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" }; 37 const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" }; 38 const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" }; 39 const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" }; 40 const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" }; 41 const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" }; 42 42 43 43 UniqueName DeclarationNode::anonymous( "__anonymous" ); … … 46 46 47 47 DeclarationNode::DeclarationNode() : 48 type( 0),48 type( nullptr ), 49 49 storageClass( NoStorageClass ), 50 50 isInline( false ), 51 51 isNoreturn( false ), 52 bitfieldWidth( 0),53 initializer( 0),52 bitfieldWidth( nullptr ), 53 initializer( nullptr ), 54 54 hasEllipsis( false ), 55 55 linkage( ::linkage ), 56 56 extension( false ) { 57 variable.tyClass = DeclarationNode::Otype; 57 58 // variable.name = nullptr; 59 variable.tyClass = NoTypeClass; 58 60 variable.assertions = nullptr; 59 61 62 // attr.name = nullptr; 60 63 attr.expr = nullptr; 61 64 attr.type = nullptr; … … 63 66 64 67 DeclarationNode::~DeclarationNode() { 68 // delete attr.name; 65 69 delete attr.expr; 66 70 delete attr.type; 71 72 // delete variable.name; 73 delete variable.assertions; 74 67 75 delete type; 68 76 delete bitfieldWidth; … … 70 78 } 71 79 72 DeclarationNode * DeclarationNode::clone() const {73 DeclarationNode * newnode = new DeclarationNode;80 DeclarationNode * DeclarationNode::clone() const { 81 DeclarationNode * newnode = new DeclarationNode; 74 82 newnode->type = maybeClone( type ); 75 newnode->name = name ;83 newnode->name = name ? new string( *name ) : nullptr; 76 84 newnode->storageClass = storageClass; 77 85 newnode->isInline = isInline; … … 83 91 newnode->linkage = linkage; 84 92 93 // newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr; 94 newnode->variable.tyClass = variable.tyClass; 85 95 newnode->variable.assertions = maybeClone( variable.assertions ); 86 newnode->variable.name = variable.name; 87 newnode->variable.tyClass = variable.tyClass; 88 96 97 // newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr; 89 98 newnode->attr.expr = maybeClone( attr.expr ); 90 99 newnode->attr.type = maybeClone( attr.type ); … … 98 107 void DeclarationNode::print( std::ostream &os, int indent ) const { 99 108 os << string( indent, ' ' ); 100 if ( name == "" ) { 109 if ( name ) { 110 os << *name << ": "; 111 } else { 101 112 os << "unnamed: "; 102 } else {103 os << name << ": ";104 113 } // if 105 114 106 115 if ( linkage != LinkageSpec::Cforall ) { 107 os << LinkageSpec:: toString( linkage ) << " ";116 os << LinkageSpec::linkageName( linkage ) << " "; 108 117 } // if 109 118 … … 122 131 } // if 123 132 124 if ( initializer != 0) {133 if ( initializer ) { 125 134 os << endl << string( indent + 2, ' ' ) << "with initializer "; 126 135 initializer->printOneLine( os ); … … 139 148 } 140 149 141 DeclarationNode *DeclarationNode::newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle ) { 142 DeclarationNode *newnode = new DeclarationNode; 143 newnode->name = assign_strptr( name ); 144 150 DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) { 151 DeclarationNode * newnode = new DeclarationNode; 152 newnode->name = name; 145 153 newnode->type = new TypeData( TypeData::Function ); 146 154 newnode->type->function.params = param; 147 155 newnode->type->function.newStyle = newStyle; 148 156 newnode->type->function.body = body; 149 typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID ); 157 // ignore unnamed routine declarations: void p( int (*)(int) ); 158 if ( newnode->name ) { 159 typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID ); 160 } // if 150 161 151 162 if ( body ) { … … 155 166 if ( ret ) { 156 167 newnode->type->base = ret->type; 157 ret->type = 0;168 ret->type = nullptr; 158 169 delete ret; 159 170 } // if … … 163 174 164 175 DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) { 165 DeclarationNode * newnode = new DeclarationNode;176 DeclarationNode * newnode = new DeclarationNode; 166 177 newnode->type = new TypeData(); 167 178 newnode->type->qualifiers[ q ] = 1; … … 169 180 } // DeclarationNode::newQualifier 170 181 171 DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) {172 DeclarationNode * newnode = new DeclarationNode;182 DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) { 183 DeclarationNode * newnode = new DeclarationNode; 173 184 newnode->type = new TypeData( TypeData::Unknown ); 174 185 newnode->type->forall = forall; … … 177 188 178 189 DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) { 179 DeclarationNode *newnode = new DeclarationNode; 180 //switch (sc) { 181 // case Inline: newnode->isInline = true; break; 182 // case Noreturn: newnode->isNoreturn = true; break; 183 // default: newnode->storageClass = sc; break; 184 //} 190 DeclarationNode * newnode = new DeclarationNode; 185 191 newnode->storageClass = sc; 186 192 return newnode; … … 188 194 189 195 DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) { 190 DeclarationNode * newnode = new DeclarationNode;196 DeclarationNode * newnode = new DeclarationNode; 191 197 newnode->type = new TypeData( TypeData::Basic ); 192 198 newnode->type->basictype = bt; … … 195 201 196 202 DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) { 197 DeclarationNode * newnode = new DeclarationNode;203 DeclarationNode * newnode = new DeclarationNode; 198 204 newnode->type = new TypeData( TypeData::Basic ); 199 205 newnode->type->complextype = ct; … … 202 208 203 209 DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) { 204 DeclarationNode * newnode = new DeclarationNode;210 DeclarationNode * newnode = new DeclarationNode; 205 211 newnode->type = new TypeData( TypeData::Basic ); 206 212 newnode->type->signedness = sn; … … 209 215 210 216 DeclarationNode * DeclarationNode::newLength( Length lnth ) { 211 DeclarationNode * newnode = new DeclarationNode;217 DeclarationNode * newnode = new DeclarationNode; 212 218 newnode->type = new TypeData( TypeData::Basic ); 213 219 newnode->type->length = lnth; … … 215 221 } // DeclarationNode::newLength 216 222 217 DeclarationNode * DeclarationNode::newFromTypedef( st d::string *name ) {218 DeclarationNode * newnode = new DeclarationNode;223 DeclarationNode * DeclarationNode::newFromTypedef( string * name ) { 224 DeclarationNode * newnode = new DeclarationNode; 219 225 newnode->type = new TypeData( TypeData::SymbolicInst ); 220 newnode->type->symbolic.name = assign_strptr( name );226 newnode->type->symbolic.name = name; 221 227 newnode->type->symbolic.isTypedef = true; 222 newnode->type->symbolic.params = 0;228 newnode->type->symbolic.params = nullptr; 223 229 return newnode; 224 230 } // DeclarationNode::newFromTypedef 225 231 226 DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const st d::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body ) {227 DeclarationNode * newnode = new DeclarationNode;232 DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) { 233 DeclarationNode * newnode = new DeclarationNode; 228 234 newnode->type = new TypeData( TypeData::Aggregate ); 229 235 newnode->type->aggregate.kind = kind; 230 newnode->type->aggregate.name = assign_strptr( name ); 231 if ( newnode->type->aggregate.name == "" ) { // anonymous aggregate ? 232 newnode->type->aggregate.name = anonymous.newName(); 236 if ( name ) { 237 newnode->type->aggregate.name = name; 238 } else { // anonymous aggregate ? 239 newnode->type->aggregate.name = new string( anonymous.newName() ); 233 240 } // if 234 241 newnode->type->aggregate.actuals = actuals; … … 238 245 } // DeclarationNode::newAggregate 239 246 240 DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) { 241 DeclarationNode *newnode = new DeclarationNode; 242 newnode->name = assign_strptr( name ); 247 DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants ) { 248 DeclarationNode * newnode = new DeclarationNode; 243 249 newnode->type = new TypeData( TypeData::Enum ); 244 newnode->type->enumeration.name = newnode->name; 245 if ( newnode->type->enumeration.name == "" ) { // anonymous enumeration ? 246 newnode->type->enumeration.name = DeclarationNode::anonymous.newName(); 250 if ( name ) { 251 newnode->type->enumeration.name = name; 252 } else { // anonymous aggregate ? 253 newnode->type->enumeration.name = new string( anonymous.newName() ); 247 254 } // if 248 255 newnode->type->enumeration.constants = constants; … … 250 257 } // DeclarationNode::newEnum 251 258 252 DeclarationNode * DeclarationNode::newEnumConstant( std::string *name, ExpressionNode *constant ) {253 DeclarationNode * newnode = new DeclarationNode;254 newnode->name = assign_strptr( name );259 DeclarationNode * DeclarationNode::newEnumConstant( string * name, ExpressionNode * constant ) { 260 DeclarationNode * newnode = new DeclarationNode; 261 newnode->name = name; 255 262 newnode->enumeratorValue.reset( constant ); 256 typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );263 typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID ); 257 264 return newnode; 258 265 } // DeclarationNode::newEnumConstant 259 266 260 DeclarationNode * DeclarationNode::newName( std::string *name ) {261 DeclarationNode * newnode = new DeclarationNode;262 newnode->name = assign_strptr( name );267 DeclarationNode * DeclarationNode::newName( string * name ) { 268 DeclarationNode * newnode = new DeclarationNode; 269 newnode->name = name; 263 270 return newnode; 264 271 } // DeclarationNode::newName 265 272 266 DeclarationNode * DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) {267 DeclarationNode * newnode = new DeclarationNode;273 DeclarationNode * DeclarationNode::newFromTypeGen( string * name, ExpressionNode * params ) { 274 DeclarationNode * newnode = new DeclarationNode; 268 275 newnode->type = new TypeData( TypeData::SymbolicInst ); 269 newnode->type->symbolic.name = assign_strptr( name );276 newnode->type->symbolic.name = name; 270 277 newnode->type->symbolic.isTypedef = false; 271 278 newnode->type->symbolic.actuals = params; … … 273 280 } // DeclarationNode::newFromTypeGen 274 281 275 DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) { 276 DeclarationNode *newnode = new DeclarationNode; 277 newnode->name = assign_strptr( name ); 278 newnode->type = new TypeData( TypeData::Variable ); 282 DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, string * name ) { 283 DeclarationNode * newnode = new DeclarationNode; 284 newnode->type = nullptr; 285 assert( ! newnode->name ); 286 // newnode->variable.name = name; 287 newnode->name = name; 279 288 newnode->variable.tyClass = tc; 280 newnode->variable. name = newnode->name;289 newnode->variable.assertions = nullptr; 281 290 return newnode; 282 291 } // DeclarationNode::newTypeParam 283 292 284 DeclarationNode * DeclarationNode::newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {285 DeclarationNode * newnode = new DeclarationNode;293 DeclarationNode * DeclarationNode::newTrait( const string * name, DeclarationNode * params, DeclarationNode * asserts ) { 294 DeclarationNode * newnode = new DeclarationNode; 286 295 newnode->type = new TypeData( TypeData::Aggregate ); 296 newnode->type->aggregate.name = name; 287 297 newnode->type->aggregate.kind = Trait; 288 298 newnode->type->aggregate.params = params; 289 299 newnode->type->aggregate.fields = asserts; 290 newnode->type->aggregate.name = assign_strptr( name );291 300 return newnode; 292 301 } // DeclarationNode::newTrait 293 302 294 DeclarationNode * DeclarationNode::newTraitUse( std::string *name, ExpressionNode *params ) {295 DeclarationNode * newnode = new DeclarationNode;303 DeclarationNode * DeclarationNode::newTraitUse( const string * name, ExpressionNode * params ) { 304 DeclarationNode * newnode = new DeclarationNode; 296 305 newnode->type = new TypeData( TypeData::AggregateInst ); 297 306 newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate ); 298 307 newnode->type->aggInst.aggregate->aggregate.kind = Trait; 299 newnode->type->aggInst.aggregate->aggregate.name = assign_strptr( name );308 newnode->type->aggInst.aggregate->aggregate.name = name; 300 309 newnode->type->aggInst.params = params; 301 310 return newnode; 302 311 } // DeclarationNode::newTraitUse 303 312 304 DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) { 305 DeclarationNode *newnode = new DeclarationNode; 306 newnode->name = assign_strptr( name ); 313 DeclarationNode * DeclarationNode::newTypeDecl( string * name, DeclarationNode * typeParams ) { 314 DeclarationNode * newnode = new DeclarationNode; 307 315 newnode->type = new TypeData( TypeData::Symbolic ); 308 316 newnode->type->symbolic.isTypedef = false; 309 317 newnode->type->symbolic.params = typeParams; 310 newnode->type->symbolic.name = n ewnode->name;318 newnode->type->symbolic.name = name; 311 319 return newnode; 312 320 } // DeclarationNode::newTypeDecl 313 321 314 DeclarationNode * DeclarationNode::newPointer( DeclarationNode *qualifiers ) {315 DeclarationNode * newnode = new DeclarationNode;322 DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers ) { 323 DeclarationNode * newnode = new DeclarationNode; 316 324 newnode->type = new TypeData( TypeData::Pointer ); 317 325 return newnode->addQualifiers( qualifiers ); 318 326 } // DeclarationNode::newPointer 319 327 320 DeclarationNode * DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {321 DeclarationNode * newnode = new DeclarationNode;328 DeclarationNode * DeclarationNode::newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic ) { 329 DeclarationNode * newnode = new DeclarationNode; 322 330 newnode->type = new TypeData( TypeData::Array ); 323 331 newnode->type->array.dimension = size; 324 332 newnode->type->array.isStatic = isStatic; 325 if ( newnode->type->array.dimension == 0 || newnode->type->array.dimension->isExpressionType<ConstantExpr *>() ) {333 if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType<ConstantExpr * >() ) { 326 334 newnode->type->array.isVarLen = false; 327 335 } else { … … 331 339 } // DeclarationNode::newArray 332 340 333 DeclarationNode * DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {334 DeclarationNode * newnode = new DeclarationNode;341 DeclarationNode * DeclarationNode::newVarArray( DeclarationNode * qualifiers ) { 342 DeclarationNode * newnode = new DeclarationNode; 335 343 newnode->type = new TypeData( TypeData::Array ); 336 newnode->type->array.dimension = 0;344 newnode->type->array.dimension = nullptr; 337 345 newnode->type->array.isStatic = false; 338 346 newnode->type->array.isVarLen = true; … … 340 348 } 341 349 342 DeclarationNode * DeclarationNode::newBitfield( ExpressionNode *size ) {343 DeclarationNode * newnode = new DeclarationNode;350 DeclarationNode * DeclarationNode::newBitfield( ExpressionNode * size ) { 351 DeclarationNode * newnode = new DeclarationNode; 344 352 newnode->bitfieldWidth = size; 345 353 return newnode; 346 354 } 347 355 348 DeclarationNode * DeclarationNode::newTuple( DeclarationNode *members ) {349 DeclarationNode * newnode = new DeclarationNode;356 DeclarationNode * DeclarationNode::newTuple( DeclarationNode * members ) { 357 DeclarationNode * newnode = new DeclarationNode; 350 358 newnode->type = new TypeData( TypeData::Tuple ); 351 359 newnode->type->tuple = members; … … 353 361 } 354 362 355 DeclarationNode * DeclarationNode::newTypeof( ExpressionNode *expr ) {356 DeclarationNode * newnode = new DeclarationNode;363 DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr ) { 364 DeclarationNode * newnode = new DeclarationNode; 357 365 newnode->type = new TypeData( TypeData::Typeof ); 358 366 newnode->type->typeexpr = expr; … … 361 369 362 370 DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) { 363 DeclarationNode * newnode = new DeclarationNode;371 DeclarationNode * newnode = new DeclarationNode; 364 372 newnode->type = new TypeData( TypeData::Builtin ); 365 373 newnode->builtin = bt; … … 367 375 } // DeclarationNode::newBuiltinType 368 376 369 DeclarationNode *DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) { 370 DeclarationNode *newnode = new DeclarationNode; 371 newnode->type = new TypeData( TypeData::Attr ); 372 newnode->attr.name = assign_strptr( name ); 377 DeclarationNode * DeclarationNode::newAttr( string * name, ExpressionNode * expr ) { 378 DeclarationNode * newnode = new DeclarationNode; 379 newnode->type = nullptr; 380 // newnode->attr.name = name; 381 newnode->name = name; 373 382 newnode->attr.expr = expr; 374 383 return newnode; 375 384 } 376 385 377 DeclarationNode *DeclarationNode::newAttr( std::string *name, DeclarationNode *type ) { 378 DeclarationNode *newnode = new DeclarationNode; 379 newnode->type = new TypeData( TypeData::Attr ); 380 newnode->attr.name = assign_strptr( name ); 386 DeclarationNode * DeclarationNode::newAttr( string * name, DeclarationNode * type ) { 387 DeclarationNode * newnode = new DeclarationNode; 388 newnode->type = nullptr; 389 // newnode->attr.name = name; 390 newnode->name = name; 381 391 newnode->attr.type = type; 382 392 return newnode; … … 389 399 } // appendError 390 400 391 void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData *dst ) {401 void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) { 392 402 TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization 393 403 … … 401 411 } // DeclarationNode::checkQualifiers 402 412 403 void DeclarationNode::checkStorageClasses( DeclarationNode * q ) {413 void DeclarationNode::checkStorageClasses( DeclarationNode * q ) { 404 414 if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) { 405 415 if ( storageClass == q->storageClass ) { // duplicate qualifier … … 413 423 } // DeclarationNode::copyStorageClasses 414 424 415 DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode *q ) {425 DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) { 416 426 isInline = isInline || q->isInline; 417 427 isNoreturn = isNoreturn || q->isNoreturn; … … 424 434 } // DeclarationNode::copyStorageClasses 425 435 426 static void addQualifiersToType( TypeData *&src, TypeData * dst ) {436 static void addQualifiersToType( TypeData *&src, TypeData * dst ) { 427 437 if ( src->forall && dst->kind == TypeData::Function ) { 428 438 if ( dst->forall ) { … … 431 441 dst->forall = src->forall; 432 442 } // if 433 src->forall = 0;443 src->forall = nullptr; 434 444 } // if 435 445 if ( dst->base ) { … … 437 447 } else if ( dst->kind == TypeData::Function ) { 438 448 dst->base = src; 439 src = 0;449 src = nullptr; 440 450 } else { 441 451 dst->qualifiers |= src->qualifiers; … … 443 453 } // addQualifiersToType 444 454 445 DeclarationNode * DeclarationNode::addQualifiers( DeclarationNode *q ) {446 if ( ! q ) return this;455 DeclarationNode * DeclarationNode::addQualifiers( DeclarationNode * q ) { 456 if ( ! q ) { delete q; return this; } 447 457 448 458 checkStorageClasses( q ); 449 459 copyStorageClasses( q ); 450 460 451 if ( ! q->type ) { delete q; return this; } 461 if ( ! q->type ) { 462 delete q; 463 return this; 464 } // if 452 465 453 466 if ( ! type ) { 454 // type = new TypeData; 455 type = q->type; 467 type = q->type; // reuse this structure 468 q->type = nullptr; 469 delete q; 456 470 return this; 457 471 } // if … … 467 481 type->aggregate.params = q->type->forall; 468 482 // change implicit typedef from TYPEDEFname to TYPEGENname 469 typedefTable.changeKind( type->aggregate.name, TypedefTable::TG );483 typedefTable.changeKind( *type->aggregate.name, TypedefTable::TG ); 470 484 } else { 471 485 type->forall = q->type->forall; 472 486 } // if 473 487 } // if 474 q->type->forall = 0;488 q->type->forall = nullptr; 475 489 } // if 476 490 delete q; … … 485 499 dst->forall = src->forall; 486 500 } // if 487 src->forall = 0;501 src->forall = nullptr; 488 502 } // if 489 503 if ( dst->base ) { … … 494 508 src->qualifiers |= dst->qualifiers; 495 509 dst = src; 496 src = 0;510 src = nullptr; 497 511 break; 498 512 case TypeData::Basic: … … 504 518 dst->basictype = src->basictype; 505 519 } else if ( src->basictype != DeclarationNode::NoBasicType ) 506 throw SemanticError( st d::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );520 throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src ); 507 521 508 522 if ( dst->complextype == DeclarationNode::NoComplexType ) { 509 523 dst->complextype = src->complextype; 510 524 } else if ( src->complextype != DeclarationNode::NoComplexType ) 511 throw SemanticError( st d::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );525 throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src ); 512 526 513 527 if ( dst->signedness == DeclarationNode::NoSignedness ) { 514 528 dst->signedness = src->signedness; 515 529 } else if ( src->signedness != DeclarationNode::NoSignedness ) 516 throw SemanticError( st d::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );530 throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src ); 517 531 518 532 if ( dst->length == DeclarationNode::NoLength ) { … … 521 535 dst->length = DeclarationNode::LongLong; 522 536 } else if ( src->length != DeclarationNode::NoLength ) 523 throw SemanticError( st d::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );537 throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src ); 524 538 } // if 525 539 break; … … 534 548 } // if 535 549 dst->base->qualifiers |= src->qualifiers; 536 src = 0;550 src = nullptr; 537 551 break; 538 552 default: … … 542 556 dst->forall = src->forall; 543 557 } // if 544 src->forall = 0;558 src->forall = nullptr; 545 559 dst->base = src; 546 src = 0;560 src = nullptr; 547 561 } // switch 548 562 } // switch … … 550 564 } 551 565 552 DeclarationNode * DeclarationNode::addType( DeclarationNode *o ) {566 DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) { 553 567 if ( o ) { 554 568 checkStorageClasses( o ); … … 566 580 type = o->type; 567 581 } // if 568 o->type = 0;582 o->type = nullptr; 569 583 } else { 570 584 addTypeToType( o->type, type ); … … 584 598 } 585 599 586 DeclarationNode * DeclarationNode::addTypedef() {587 TypeData * newtype = new TypeData( TypeData::Symbolic );588 newtype->symbolic.params = 0;600 DeclarationNode * DeclarationNode::addTypedef() { 601 TypeData * newtype = new TypeData( TypeData::Symbolic ); 602 newtype->symbolic.params = nullptr; 589 603 newtype->symbolic.isTypedef = true; 590 newtype->symbolic.name = name ;604 newtype->symbolic.name = name ? new string( *name ) : nullptr; 591 605 newtype->base = type; 592 606 type = newtype; … … 594 608 } 595 609 596 DeclarationNode *DeclarationNode::addAssertions( DeclarationNode *assertions ) { 610 DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) { 611 if ( variable.tyClass != NoTypeClass ) { 612 if ( variable.assertions ) { 613 variable.assertions->appendList( assertions ); 614 } else { 615 variable.assertions = assertions; 616 } // if 617 return this; 618 } // if 619 597 620 assert( type ); 598 621 switch ( type->kind ) { … … 604 627 } // if 605 628 break; 606 case TypeData::Variable:607 if ( variable.assertions ) {608 variable.assertions->appendList( assertions );609 } else {610 variable.assertions = assertions;611 } // if612 break;613 629 default: 614 630 assert( false ); … … 618 634 } 619 635 620 DeclarationNode *DeclarationNode::addName( std::string *newname ) { 621 name = assign_strptr( newname ); 622 return this; 623 } 624 625 DeclarationNode *DeclarationNode::addBitfield( ExpressionNode *size ) { 636 DeclarationNode * DeclarationNode::addName( string * newname ) { 637 assert( ! name ); 638 name = newname; 639 return this; 640 } 641 642 DeclarationNode * DeclarationNode::addBitfield( ExpressionNode * size ) { 626 643 bitfieldWidth = size; 627 644 return this; 628 645 } 629 646 630 DeclarationNode * DeclarationNode::addVarArgs() {647 DeclarationNode * DeclarationNode::addVarArgs() { 631 648 assert( type ); 632 649 hasEllipsis = true; … … 634 651 } 635 652 636 DeclarationNode * DeclarationNode::addFunctionBody( StatementNode *body ) {653 DeclarationNode * DeclarationNode::addFunctionBody( StatementNode * body ) { 637 654 assert( type ); 638 655 assert( type->kind == TypeData::Function ); 639 assert( type->function.body == 0);656 assert( ! type->function.body ); 640 657 type->function.body = body; 641 658 type->function.hasBody = true; … … 643 660 } 644 661 645 DeclarationNode * DeclarationNode::addOldDeclList( DeclarationNode *list ) {662 DeclarationNode * DeclarationNode::addOldDeclList( DeclarationNode * list ) { 646 663 assert( type ); 647 664 assert( type->kind == TypeData::Function ); 648 assert( type->function.oldDeclList == 0);665 assert( ! type->function.oldDeclList ); 649 666 type->function.oldDeclList = list; 650 667 return this; 651 668 } 652 669 653 static void setBase( TypeData *&type, TypeData * newType ) {670 static void setBase( TypeData *&type, TypeData * newType ) { 654 671 if ( type ) { 655 TypeData * prevBase = type;656 TypeData * curBase = type->base;657 while ( curBase != 0) {672 TypeData * prevBase = type; 673 TypeData * curBase = type->base; 674 while ( curBase != nullptr ) { 658 675 prevBase = curBase; 659 676 curBase = curBase->base; … … 665 682 } 666 683 667 DeclarationNode * DeclarationNode::addPointer( DeclarationNode *p ) {684 DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) { 668 685 if ( p ) { 669 686 assert( p->type->kind == TypeData::Pointer ); 670 687 setBase( type, p->type ); 671 p->type = 0;688 p->type = nullptr; 672 689 delete p; 673 690 } // if … … 675 692 } 676 693 677 DeclarationNode * DeclarationNode::addArray( DeclarationNode *a ) {694 DeclarationNode * DeclarationNode::addArray( DeclarationNode * a ) { 678 695 if ( a ) { 679 696 assert( a->type->kind == TypeData::Array ); 680 697 setBase( type, a->type ); 681 a->type = 0;698 a->type = nullptr; 682 699 delete a; 683 700 } // if … … 685 702 } 686 703 687 DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode *p ) {704 DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode * p ) { 688 705 if ( p ) { 689 706 assert( p->type->kind == TypeData::Pointer ); … … 703 720 p->type->base = type; 704 721 } // switch 705 type = 0;722 type = nullptr; 706 723 } // if 707 724 delete this; … … 712 729 } 713 730 714 static TypeData * findLast( TypeData *a ) {731 static TypeData * findLast( TypeData * a ) { 715 732 assert( a ); 716 TypeData * cur = a;733 TypeData * cur = a; 717 734 while ( cur->base ) { 718 735 cur = cur->base; … … 721 738 } 722 739 723 DeclarationNode * DeclarationNode::addNewArray( DeclarationNode *a ) {740 DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) { 724 741 if ( a ) { 725 742 assert( a->type->kind == TypeData::Array ); 726 TypeData * lastArray = findLast( a->type );743 TypeData * lastArray = findLast( a->type ); 727 744 if ( type ) { 728 745 switch ( type->kind ) { … … 739 756 lastArray->base = type; 740 757 } // switch 741 type = 0;758 type = nullptr; 742 759 } // if 743 760 delete this; … … 748 765 } 749 766 750 DeclarationNode * DeclarationNode::addParamList( DeclarationNode *params ) {751 TypeData * ftype = new TypeData( TypeData::Function );767 DeclarationNode * DeclarationNode::addParamList( DeclarationNode * params ) { 768 TypeData * ftype = new TypeData( TypeData::Function ); 752 769 ftype->function.params = params; 753 770 setBase( type, ftype ); … … 755 772 } 756 773 757 static TypeData * addIdListToType( TypeData *type, DeclarationNode *ids ) {774 static TypeData * addIdListToType( TypeData * type, DeclarationNode * ids ) { 758 775 if ( type ) { 759 776 if ( type->kind != TypeData::Function ) { … … 764 781 return type; 765 782 } else { 766 TypeData * newtype = new TypeData( TypeData::Function );783 TypeData * newtype = new TypeData( TypeData::Function ); 767 784 newtype->function.idList = ids; 768 785 return newtype; 769 786 } // if 770 } 771 772 DeclarationNode * DeclarationNode::addIdList( DeclarationNode *ids ) {787 } // addIdListToType 788 789 DeclarationNode * DeclarationNode::addIdList( DeclarationNode * ids ) { 773 790 type = addIdListToType( type, ids ); 774 791 return this; 775 792 } 776 793 777 DeclarationNode *DeclarationNode::addInitializer( InitializerNode *init ) { 778 //assert 794 DeclarationNode * DeclarationNode::addInitializer( InitializerNode * init ) { 779 795 initializer = init; 780 796 return this; 781 797 } 782 798 783 DeclarationNode *DeclarationNode::cloneBaseType( string *newName ) { 784 DeclarationNode *newnode = new DeclarationNode; 785 TypeData *srcType = type; 786 while ( srcType->base ) { 787 srcType = srcType->base; 788 } // while 789 newnode->type = maybeClone( srcType ); 790 if ( newnode->type->kind == TypeData::AggregateInst ) { 791 // don't duplicate members 792 if ( newnode->type->aggInst.aggregate->kind == TypeData::Enum ) { 793 delete newnode->type->aggInst.aggregate->enumeration.constants; 794 newnode->type->aggInst.aggregate->enumeration.constants = 0; 795 } else { 796 assert( newnode->type->aggInst.aggregate->kind == TypeData::Aggregate ); 797 delete newnode->type->aggInst.aggregate->aggregate.fields; 798 newnode->type->aggInst.aggregate->aggregate.fields = 0; 799 } // if 800 } // if 801 newnode->type->forall = maybeClone( type->forall ); 802 assert( storageClass == NoStorageClass ); 803 newnode->copyStorageClasses( this ); 804 newnode->name = assign_strptr( newName ); 805 return newnode; 806 } 807 808 DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) { 809 if ( o ) { 810 o->copyStorageClasses( this ); 811 if ( type ) { 812 TypeData *srcType = type; 813 while ( srcType->base ) { 814 srcType = srcType->base; 815 } // while 816 TypeData *newType = srcType->clone(); 817 if ( newType->kind == TypeData::AggregateInst ) { 818 // don't duplicate members 819 if ( newType->aggInst.aggregate->kind == TypeData::Enum ) { 820 delete newType->aggInst.aggregate->enumeration.constants; 821 newType->aggInst.aggregate->enumeration.constants = 0; 822 } else { 823 assert( newType->aggInst.aggregate->kind == TypeData::Aggregate ); 824 delete newType->aggInst.aggregate->aggregate.fields; 825 newType->aggInst.aggregate->aggregate.fields = 0; 826 } // if 827 } // if 828 newType->forall = maybeClone( type->forall ); 829 if ( ! o->type ) { 830 o->type = newType; 831 } else { 832 addTypeToType( newType, o->type ); 833 delete newType; 834 } // if 835 } // if 836 } // if 837 return o; 838 } 839 840 DeclarationNode *DeclarationNode::cloneType( string *newName ) { 841 DeclarationNode *newnode = new DeclarationNode; 799 DeclarationNode * DeclarationNode::cloneType( string * newName ) { 800 DeclarationNode * newnode = new DeclarationNode; 842 801 newnode->type = maybeClone( type ); 843 802 assert( storageClass == NoStorageClass ); 844 803 newnode->copyStorageClasses( this ); 845 newnode->name = assign_strptr( newName ); 846 return newnode; 847 } 848 849 DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) { 850 if ( o ) { 851 assert( storageClass == NoStorageClass ); 852 o->copyStorageClasses( this ); 853 if ( type ) { 854 TypeData *newType = type->clone(); 855 if ( ! o->type ) { 856 o->type = newType; 804 assert( newName ); 805 newnode->name = newName; 806 return newnode; 807 } 808 809 DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o ) { 810 if ( ! o ) return nullptr; 811 812 o->copyStorageClasses( this ); 813 if ( type ) { 814 TypeData * srcType = type; 815 816 while ( srcType->base ) { 817 srcType = srcType->base; 818 } // while 819 820 TypeData * newType = srcType->clone(); 821 if ( newType->kind == TypeData::AggregateInst ) { 822 // don't duplicate members 823 if ( newType->aggInst.aggregate->kind == TypeData::Enum ) { 824 delete newType->aggInst.aggregate->enumeration.constants; 825 newType->aggInst.aggregate->enumeration.constants = nullptr; 857 826 } else { 858 addTypeToType( newType, o->type ); 859 delete newType; 827 assert( newType->aggInst.aggregate->kind == TypeData::Aggregate ); 828 delete newType->aggInst.aggregate->aggregate.fields; 829 newType->aggInst.aggregate->aggregate.fields = nullptr; 860 830 } // if 861 831 } // if 862 } // if 863 delete o; 832 833 newType->forall = maybeClone( type->forall ); 834 if ( ! o->type ) { 835 o->type = newType; 836 } else { 837 addTypeToType( newType, o->type ); 838 delete newType; 839 } // if 840 } // if 864 841 return o; 865 842 } 866 843 867 DeclarationNode * DeclarationNode::extractAggregate() const {844 DeclarationNode * DeclarationNode::extractAggregate() const { 868 845 if ( type ) { 869 TypeData * ret = typeextractAggregate( type );846 TypeData * ret = typeextractAggregate( type ); 870 847 if ( ret ) { 871 DeclarationNode * newnode = new DeclarationNode;848 DeclarationNode * newnode = new DeclarationNode; 872 849 newnode->type = ret; 873 850 return newnode; 874 851 } // if 875 852 } // if 876 return 0;877 } 878 879 void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList ) {853 return nullptr; 854 } 855 856 void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList ) { 880 857 SemanticError errors; 881 858 std::back_insert_iterator< std::list< Declaration * > > out( outputList ); 882 const DeclarationNode *cur = firstNode; 859 const DeclarationNode * cur = firstNode; 860 883 861 while ( cur ) { 884 862 try { 885 if ( DeclarationNode * extr = cur->extractAggregate() ) {863 if ( DeclarationNode * extr = cur->extractAggregate() ) { 886 864 // handle the case where a structure declaration is contained within an object or type declaration 887 Declaration * decl = extr->build();865 Declaration * decl = extr->build(); 888 866 if ( decl ) { 889 * out++ = decl;867 * out++ = decl; 890 868 } // if 891 869 delete extr; 892 870 } // if 893 Declaration *decl = cur->build(); 871 872 Declaration * decl = cur->build(); 894 873 if ( decl ) { 895 * out++ = decl;874 * out++ = decl; 896 875 } // if 897 876 } catch( SemanticError &e ) { … … 900 879 cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); 901 880 } // while 881 902 882 if ( ! errors.isEmpty() ) { 903 883 throw errors; 904 884 } // if 905 } 906 907 void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) {885 } // buildList 886 887 void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) { 908 888 SemanticError errors; 909 889 std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList ); 910 const DeclarationNode * cur = firstNode;890 const DeclarationNode * cur = firstNode; 911 891 while ( cur ) { 912 892 try { 913 Declaration * decl = cur->build();893 Declaration * decl = cur->build(); 914 894 if ( decl ) { 915 if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {916 * out++ = dwt;917 } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {918 StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );919 * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0);895 if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) { 896 * out++ = dwt; 897 } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) { 898 StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() ); 899 * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr ); 920 900 delete agg; 921 } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {922 UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );923 * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0);901 } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) { 902 UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() ); 903 * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr ); 924 904 } // if 925 905 } // if … … 932 912 throw errors; 933 913 } // if 934 } 935 936 void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList ) {914 } // buildList 915 916 void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList ) { 937 917 SemanticError errors; 938 918 std::back_insert_iterator< std::list< Type * > > out( outputList ); 939 const DeclarationNode *cur = firstNode; 919 const DeclarationNode * cur = firstNode; 920 940 921 while ( cur ) { 941 922 try { 942 * out++ = cur->buildType();923 * out++ = cur->buildType(); 943 924 } catch( SemanticError &e ) { 944 925 errors.append( e ); … … 946 927 cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); 947 928 } // while 929 948 930 if ( ! errors.isEmpty() ) { 949 931 throw errors; 950 932 } // if 951 } 952 953 Declaration * DeclarationNode::build() const {933 } // buildTypeList 934 935 Declaration * DeclarationNode::build() const { 954 936 if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this ); 937 938 // if ( variable.name ) { 939 if ( variable.tyClass != NoTypeClass ) { 940 static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype }; 941 // TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] ); 942 TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] ); 943 buildList( variable.assertions, ret->get_assertions() ); 944 return ret; 945 } // if 946 955 947 if ( type ) { 956 if ( type->kind == TypeData::Variable ) { 957 static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype }; 958 TypeDecl * ret = new TypeDecl( variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ variable.tyClass ] ); 959 buildList( variable.assertions, ret->get_assertions() ); 960 return ret; 961 } else { 962 return buildDecl( type, name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension ); 963 } // if 964 } // if 948 return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension ); 949 } // if 950 965 951 if ( ! isInline && ! isNoreturn ) { 966 return (new ObjectDecl( name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension ); 967 } // if 952 assertf( name, "ObjectDecl are assumed to have names\n" ); 953 return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_extension( extension ); 954 } // if 955 968 956 throw SemanticError( "invalid function specifier ", this ); 969 957 } 970 958 971 Type * DeclarationNode::buildType() const {959 Type * DeclarationNode::buildType() const { 972 960 assert( type ); 961 962 if ( attr.expr ) { 963 // return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() ); 964 return new AttrType( buildQualifiers( type ), *name, attr.expr->build() ); 965 } else if ( attr.type ) { 966 // return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() ); 967 return new AttrType( buildQualifiers( type ), *name, attr.type->buildType() ); 968 } // if 973 969 974 970 switch ( type->kind ) { 975 971 case TypeData::Enum: 976 return new EnumInstType( buildQualifiers( type ), type->enumeration.name );972 return new EnumInstType( buildQualifiers( type ), *type->enumeration.name ); 977 973 case TypeData::Aggregate: { 978 ReferenceToType * ret;974 ReferenceToType * ret; 979 975 switch ( type->aggregate.kind ) { 980 976 case DeclarationNode::Struct: 981 ret = new StructInstType( buildQualifiers( type ), type->aggregate.name );977 ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name ); 982 978 break; 983 979 case DeclarationNode::Union: 984 ret = new UnionInstType( buildQualifiers( type ), type->aggregate.name );980 ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name ); 985 981 break; 986 982 case DeclarationNode::Trait: 987 ret = new TraitInstType( buildQualifiers( type ), type->aggregate.name );983 ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name ); 988 984 break; 989 985 default: … … 994 990 } 995 991 case TypeData::Symbolic: { 996 TypeInstType * ret = new TypeInstType( buildQualifiers( type ),type->symbolic.name, false );992 TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false ); 997 993 buildList( type->symbolic.actuals, ret->get_parameters() ); 998 return ret;999 }1000 case TypeData::Attr: {1001 assert( type->kind == TypeData::Attr );1002 // assert( type->attr );1003 AttrType * ret;1004 if ( attr.expr ) {1005 ret = new AttrType( buildQualifiers( type ), attr.name, attr.expr->build() );1006 } else {1007 assert( attr.type );1008 ret = new AttrType( buildQualifiers( type ), attr.name, attr.type->buildType() );1009 } // if1010 994 return ret; 1011 995 } -
src/Parser/ExpressionNode.cc
rac9ca96 r7756647 10 10 // Created On : Sat May 16 13:17:07 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Thu Aug 25 21:39:40201613 // Update Count : 50 312 // Last Modified On : Fri Sep 16 16:27:44 2016 13 // Update Count : 508 14 14 // 15 15 … … 31 31 32 32 using namespace std; 33 34 ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.get_name() ), extension( other.extension ) {}35 33 36 34 //############################################################################## -
src/Parser/InitializerNode.cc
rac9ca96 r7756647 10 10 // Created On : Sat May 16 13:20:24 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon Aug 15 18:27:02201613 // Update Count : 2 012 // Last Modified On : Sat Oct 1 23:09:51 2016 13 // Update Count : 21 14 14 // 15 15 … … 23 23 24 24 InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des ) 25 : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {25 : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { 26 26 if ( aggrp ) 27 27 kids = dynamic_cast< InitializerNode * >( get_next() ); … … 32 32 33 33 InitializerNode::InitializerNode( InitializerNode *init, bool aggrp, ExpressionNode *des ) 34 : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {34 : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { 35 35 if ( init != 0 ) 36 36 set_last( init ); … … 79 79 80 80 Initializer *InitializerNode::build() const { 81 // if ( get_expression() == 0 ) return 0; // XXX (?)82 83 81 if ( aggregate ) { 84 //assert( next_init() != 0 );85 86 82 std::list< Initializer * > initlist; 87 83 buildList< Initializer, InitializerNode >( next_init(), initlist ); -
src/Parser/LinkageSpec.cc
rac9ca96 r7756647 10 10 // Created On : Sat May 16 13:22:09 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Sun Aug 21 12:32:53201613 // Update Count : 1712 // Last Modified On : Sun Oct 2 23:16:21 2016 13 // Update Count : 23 14 14 // 15 15 … … 17 17 #include <string> 18 18 #include <cassert> 19 using namespace std; 19 20 20 21 #include "LinkageSpec.h" 21 22 #include "Common/SemanticError.h" 22 23 23 LinkageSpec::Spec LinkageSpec:: fromString( const std::string &spec ) {24 std::unique_ptr<const std::string> guard(&spec);// allocated by lexer25 if ( spec == "\"Cforall\"" ) {24 LinkageSpec::Spec LinkageSpec::linkageCheck( const string * spec ) { 25 unique_ptr<const string> guard( spec ); // allocated by lexer 26 if ( *spec == "\"Cforall\"" ) { 26 27 return Cforall; 27 } else if ( spec == "\"C\"" ) {28 } else if ( *spec == "\"C\"" ) { 28 29 return C; 29 30 } else { 30 throw SemanticError( "Invalid linkage specifier " + spec );31 throw SemanticError( "Invalid linkage specifier " + *spec ); 31 32 } // if 32 33 } 33 34 34 st d::string LinkageSpec::toString( LinkageSpec::Spec linkage ) {35 assert( linkage >= 0&& linkage < LinkageSpec::NoOfSpecs );35 string LinkageSpec::linkageName( LinkageSpec::Spec linkage ) { 36 assert( 0 <= linkage && linkage < LinkageSpec::NoOfSpecs ); 36 37 static const char *linkageKinds[LinkageSpec::NoOfSpecs] = { 37 38 "intrinsic", "Cforall", "C", "automatically generated", "compiler built-in", … … 41 42 42 43 bool LinkageSpec::isDecoratable( Spec spec ) { 43 assert( spec >= 0&& spec < LinkageSpec::NoOfSpecs );44 assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs ); 44 45 static bool decoratable[LinkageSpec::NoOfSpecs] = { 45 46 // Intrinsic, Cforall, C, AutoGen, Compiler … … 50 51 51 52 bool LinkageSpec::isGeneratable( Spec spec ) { 52 assert( spec >= 0&& spec < LinkageSpec::NoOfSpecs );53 assert( 0 <= spec && spec < LinkageSpec::NoOfSpecs ); 53 54 static bool generatable[LinkageSpec::NoOfSpecs] = { 54 55 // Intrinsic, Cforall, C, AutoGen, Compiler -
src/Parser/LinkageSpec.h
rac9ca96 r7756647 10 10 // Created On : Sat May 16 13:24:28 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Sat Aug 20 19:22:23201613 // Update Count : 812 // Last Modified On : Sat Oct 1 23:03:17 2016 13 // Update Count : 11 14 14 // 15 15 … … 29 29 }; 30 30 31 static Spec fromString( const std::string &);32 static std::string toString( Spec );31 static Spec linkageCheck( const std::string * ); 32 static std::string linkageName( Spec ); 33 33 34 34 static bool isDecoratable( Spec ); -
src/Parser/ParseNode.cc
rac9ca96 r7756647 10 10 // Created On : Sat May 16 13:26:29 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Aug 17 23:14:16201613 // Update Count : 12 612 // Last Modified On : Sat Oct 1 23:10:43 2016 13 // Update Count : 127 14 14 // 15 15 … … 20 20 21 21 std::ostream & operator<<( std::ostream & out, const ParseNode * node ) { 22 23 22 node->print( out ); 23 return out; 24 24 } 25 25 -
src/Parser/ParseNode.h
rac9ca96 r7756647 10 10 // Created On : Sat May 16 13:28:16 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon Sep 12 08:00:05201613 // Update Count : 6 0312 // Last Modified On : Mon Oct 3 18:03:08 2016 13 // Update Count : 636 14 14 // 15 15 … … 41 41 public: 42 42 ParseNode() {}; 43 ParseNode( const std::string * name ) : name( * name ) { assert( false ); delete name; } 44 ParseNode( const std::string &name ) : name( name ) { assert( false ); } 45 virtual ~ParseNode() { delete next; }; 43 virtual ~ParseNode() { delete next; delete name; }; 46 44 virtual ParseNode * clone() const = 0; 47 45 48 46 ParseNode * get_next() const { return next; } 49 47 ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; } 48 50 49 ParseNode * get_last() { 51 50 ParseNode * current; 52 for ( current = this; current->get_next() != 0; current = current->get_next() );51 for ( current = this; current->get_next() != nullptr; current = current->get_next() ); 53 52 return current; 54 53 } 55 54 ParseNode * set_last( ParseNode * newlast ) { 56 if ( newlast != 0) get_last()->set_next( newlast );55 if ( newlast != nullptr ) get_last()->set_next( newlast ); 57 56 return this; 58 57 } 59 60 const std::string &get_name() const { return name; }61 void set_name( const std::string &newValue ) { name = newValue; }62 58 63 59 virtual void print( std::ostream &os, int indent = 0 ) const {} 64 60 virtual void printList( std::ostream &os, int indent = 0 ) const {} 65 private: 61 66 62 static int indent_by; 67 63 68 64 ParseNode * next = nullptr; 69 std::string name;65 std::string * name = nullptr; 70 66 }; // ParseNode 71 67 … … 74 70 class InitializerNode : public ParseNode { 75 71 public: 76 InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = 0);77 InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = 0);72 InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr ); 73 InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr ); 78 74 ~InitializerNode(); 79 75 virtual InitializerNode * clone() const { assert( false ); return nullptr; } … … 106 102 public: 107 103 ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {} 108 ExpressionNode( Expression * expr, const std::string * name ) : ParseNode( name ), expr( expr ) {}109 104 ExpressionNode( const ExpressionNode &other ); 110 105 virtual ~ExpressionNode() {} … … 183 178 Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node ); 184 179 Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node ); 185 Expression * build_tuple( ExpressionNode * expr_node = 0);180 Expression * build_tuple( ExpressionNode * expr_node = nullptr ); 186 181 Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ); 187 182 Expression * build_range( ExpressionNode * low, ExpressionNode * high ); … … 203 198 enum Signedness { Signed, Unsigned, NoSignedness }; 204 199 enum Length { Short, Long, LongLong, NoLength }; 205 enum Aggregate { Struct, Union, Trait };206 enum TypeClass { Otype, Dtype, Ftype };200 enum Aggregate { Struct, Union, Trait, NoAggregate }; 201 enum TypeClass { Otype, Dtype, Ftype, NoTypeClass }; 207 202 enum BuiltinType { Valist }; 208 203 … … 219 214 static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false ); 220 215 static DeclarationNode * newQualifier( Qualifier ); 221 static DeclarationNode * newForall( DeclarationNode * );216 static DeclarationNode * newForall( DeclarationNode * ); 222 217 static DeclarationNode * newStorageClass( StorageClass ); 223 218 static DeclarationNode * newBasicType( BasicType ); … … 226 221 static DeclarationNode * newLength( Length lnth ); 227 222 static DeclarationNode * newBuiltinType( BuiltinType ); 228 static DeclarationNode * newFromTypedef( std::string * );223 static DeclarationNode * newFromTypedef( std::string * ); 229 224 static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ); 230 225 static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants ); 231 226 static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant ); 232 static DeclarationNode * newName( std::string * );227 static DeclarationNode * newName( std::string * ); 233 228 static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params ); 234 static DeclarationNode * newTypeParam( TypeClass, std::string * );235 static DeclarationNode * newTrait( std::string * name, DeclarationNode * params, DeclarationNode * asserts );236 static DeclarationNode * newTraitUse( std::string * name, ExpressionNode * params );229 static DeclarationNode * newTypeParam( TypeClass, std::string * ); 230 static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts ); 231 static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params ); 237 232 static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams ); 238 233 static DeclarationNode * newPointer( DeclarationNode * qualifiers ); … … 249 244 DeclarationNode * clone() const; 250 245 251 DeclarationNode * addQualifiers( DeclarationNode * );246 DeclarationNode * addQualifiers( DeclarationNode * ); 252 247 void checkQualifiers( const TypeData *, const TypeData * ); 253 void checkStorageClasses( DeclarationNode * q);254 DeclarationNode * copyStorageClasses( DeclarationNode * );255 DeclarationNode * addType( DeclarationNode * );248 void checkStorageClasses( DeclarationNode * ); 249 DeclarationNode * copyStorageClasses( DeclarationNode * ); 250 DeclarationNode * addType( DeclarationNode * ); 256 251 DeclarationNode * addTypedef(); 257 DeclarationNode * addAssertions( DeclarationNode * );258 DeclarationNode * addName( std::string * );252 DeclarationNode * addAssertions( DeclarationNode * ); 253 DeclarationNode * addName( std::string * ); 259 254 DeclarationNode * addBitfield( ExpressionNode * size ); 260 255 DeclarationNode * addVarArgs(); … … 270 265 271 266 DeclarationNode * cloneType( std::string * newName ); 272 DeclarationNode * cloneType( DeclarationNode * existing );273 DeclarationNode * cloneType( int ) { return cloneType( ( std::string *)0 ); }274 DeclarationNode * cloneBaseType( std::string * newName );275 267 DeclarationNode * cloneBaseType( DeclarationNode * newdecl ); 276 268 … … 286 278 287 279 bool get_hasEllipsis() const; 288 const std::string &get_name() const { return name; }289 280 LinkageSpec::Spec get_linkage() const { return linkage; } 290 281 DeclarationNode * extractAggregate() const; … … 295 286 DeclarationNode * set_extension( bool exten ) { extension = exten; return this; } 296 287 public: 297 // StorageClass buildStorageClass() const;298 // bool buildFuncSpecifier( StorageClass key ) const;299 300 288 struct Variable_t { 289 // const std::string * name; 301 290 DeclarationNode::TypeClass tyClass; 302 std::string name;303 291 DeclarationNode * assertions; 304 292 }; … … 306 294 307 295 struct Attr_t { 308 std::stringname;296 // const std::string * name; 309 297 ExpressionNode * expr; 310 298 DeclarationNode * type; … … 315 303 316 304 TypeData * type; 317 std::string name;318 305 StorageClass storageClass; 319 306 bool isInline, isNoreturn; … … 331 318 332 319 Type * buildType( TypeData * type ); 333 //Type::Qualifiers buildQualifiers( const TypeData::Qualifiers & qualifiers );334 320 335 321 static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) { … … 393 379 Statement * build_finally( StatementNode * stmt ); 394 380 Statement * build_compound( StatementNode * first ); 395 Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = 0, ExpressionNode * input = 0, ExpressionNode * clobber = 0, LabelNode * gotolabels = 0);381 Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr ); 396 382 397 383 //############################################################################## -
src/Parser/TypeData.cc
rac9ca96 r7756647 10 10 // Created On : Sat May 16 15:12:51 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon Sep 12 21:11:22201613 // Update Count : 37712 // Last Modified On : Sat Sep 24 11:14:26 2016 13 // Update Count : 415 14 14 // 15 15 … … 24 24 #include "SynTree/Statement.h" 25 25 #include "SynTree/Initializer.h" 26 27 TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) { 26 using namespace std; 27 28 TypeData::TypeData( Kind k ) : kind( k ), base( nullptr ), forall( nullptr ) { 28 29 switch ( kind ) { 29 30 case Unknown: … … 37 38 case Array: 38 39 // array = new Array_t; 39 array.dimension = 0;40 array.dimension = nullptr; 40 41 array.isVarLen = false; 41 42 array.isStatic = false; … … 43 44 case Function: 44 45 // function = new Function_t; 45 function.params = 0;46 function.idList = 0;47 function.oldDeclList = 0;48 function.body = 0;46 function.params = nullptr; 47 function.idList = nullptr; 48 function.oldDeclList = nullptr; 49 function.body = nullptr; 49 50 function.hasBody = false; 50 51 function.newStyle = false; … … 52 53 case Aggregate: 53 54 // aggregate = new Aggregate_t; 54 aggregate.params = 0; 55 aggregate.actuals = 0; 56 aggregate.fields = 0; 55 aggregate.name = nullptr; 56 aggregate.params = nullptr; 57 aggregate.actuals = nullptr; 58 aggregate.fields = nullptr; 57 59 break; 58 60 case AggregateInst: 59 61 // aggInst = new AggInst_t; 60 aggInst.aggregate = 0;61 aggInst.params = 0;62 aggInst.aggregate = nullptr; 63 aggInst.params = nullptr; 62 64 break; 63 65 case Enum: 64 66 // enumeration = new Enumeration_t; 65 enumeration.constants = 0; 67 enumeration.name = nullptr; 68 enumeration.constants = nullptr; 66 69 break; 67 70 case Symbolic: 68 71 case SymbolicInst: 69 72 // symbolic = new Symbolic_t; 70 symbolic.params = 0; 71 symbolic.actuals = 0; 72 symbolic.assertions = 0; 73 break; 74 case Variable: 75 // variable = new Variable_t; 76 // variable.tyClass = DeclarationNode::Type; 77 // variable.assertions = 0; 73 symbolic.name = nullptr; 74 symbolic.params = nullptr; 75 symbolic.actuals = nullptr; 76 symbolic.assertions = nullptr; 78 77 break; 79 78 case Tuple: … … 84 83 // typeexpr = new Typeof_t; 85 84 typeexpr = nullptr; 86 break;87 case Attr:88 // attr = new Attr_t;89 // attr.expr = nullptr;90 // attr.type = nullptr;91 85 break; 92 86 case Builtin: … … 121 115 break; 122 116 case Aggregate: 117 delete aggregate.name; 123 118 delete aggregate.params; 124 119 delete aggregate.actuals; … … 132 127 break; 133 128 case Enum: 129 delete enumeration.name; 134 130 delete enumeration.constants; 135 131 // delete enumeration; … … 137 133 case Symbolic: 138 134 case SymbolicInst: 135 delete symbolic.name; 139 136 delete symbolic.params; 140 137 delete symbolic.actuals; … … 142 139 // delete symbolic; 143 140 break; 144 case Variable:145 // delete variable.assertions;146 // delete variable;147 break;148 141 case Tuple: 149 142 // delete tuple->members; … … 153 146 // delete typeexpr->expr; 154 147 delete typeexpr; 155 break;156 case Attr:157 // delete attr.expr;158 // delete attr.type;159 // delete attr;160 148 break; 161 149 case Builtin: … … 197 185 break; 198 186 case Aggregate: 187 newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr; 199 188 newtype->aggregate.params = maybeClone( aggregate.params ); 200 189 newtype->aggregate.actuals = maybeClone( aggregate.actuals ); 201 190 newtype->aggregate.fields = maybeClone( aggregate.fields ); 202 newtype->aggregate.name = aggregate.name;203 191 newtype->aggregate.kind = aggregate.kind; 204 192 newtype->aggregate.body = aggregate.body; … … 209 197 break; 210 198 case Enum: 211 newtype->enumeration.name = enumeration.name ;199 newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr; 212 200 newtype->enumeration.constants = maybeClone( enumeration.constants ); 213 201 break; 214 202 case Symbolic: 215 203 case SymbolicInst: 204 newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr; 216 205 newtype->symbolic.params = maybeClone( symbolic.params ); 217 206 newtype->symbolic.actuals = maybeClone( symbolic.actuals ); 218 207 newtype->symbolic.assertions = maybeClone( symbolic.assertions ); 219 208 newtype->symbolic.isTypedef = symbolic.isTypedef; 220 newtype->symbolic.name = symbolic.name;221 break;222 case Variable:223 assert( false );224 // newtype->variable.assertions = maybeClone( variable.assertions );225 // newtype->variable.name = variable.name;226 // newtype->variable.tyClass = variable.tyClass;227 209 break; 228 210 case Tuple: … … 231 213 case Typeof: 232 214 newtype->typeexpr = maybeClone( typeexpr ); 233 break;234 case Attr:235 assert( false );236 // newtype->attr.expr = maybeClone( attr.expr );237 // newtype->attr.type = maybeClone( attr.type );238 215 break; 239 216 case Builtin: … … 245 222 } // TypeData::clone 246 223 247 void TypeData::print( std::ostream &os, int indent ) const { 248 using std::endl; 249 using std::string; 250 224 void TypeData::print( ostream &os, int indent ) const { 251 225 for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) { 252 226 if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' '; … … 326 300 break; 327 301 case Aggregate: 328 os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << aggregate.name << endl;302 os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl; 329 303 if ( aggregate.params ) { 330 304 os << string( indent + 2, ' ' ) << "with type parameters " << endl; … … 363 337 break; 364 338 case SymbolicInst: 365 os << "instance of type " << symbolic.name;339 os << "instance of type " << *symbolic.name; 366 340 if ( symbolic.actuals ) { 367 341 os << " with parameters" << endl; … … 389 363 } // if 390 364 break; 391 case Variable:392 // os << DeclarationNode::typeClassName[ variable.tyClass ] << " variable ";393 // if ( variable.assertions ) {394 // os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;395 // variable.assertions->printList( os, indent + 4 );396 // os << string( indent + 2, ' ' );397 // } // if398 break;399 365 case Tuple: 400 366 os << "tuple "; … … 409 375 typeexpr->print( os, indent + 2 ); 410 376 } // if 411 break;412 case Attr:413 // os << "attribute type decl " << attr.name << " applied to ";414 // if ( attr.expr ) {415 // attr.expr->print( os, indent + 2 );416 // } // if417 // if ( attr.type ) {418 // attr.type->print( os, indent + 2 );419 // } // if420 377 break; 421 378 case Builtin: … … 437 394 // add dtor: void ^?{}(T *) 438 395 FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false ); 439 dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0) );440 td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, 0, false, false ) );396 dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); 397 td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) ); 441 398 442 399 // add copy ctor: void ?{}(T *, T) 443 400 FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false ); 444 copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0) );445 copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0) );446 td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, 0, false, false ) );401 copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); 402 copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); 403 td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) ); 447 404 448 405 // add default ctor: void ?{}(T *) 449 406 FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false ); 450 ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0) );451 td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, 0, false, false ) );407 ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); 408 td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) ); 452 409 453 410 // add assignment operator: T * ?=?(T *, T) 454 411 FunctionType * assignType = new FunctionType( Type::Qualifiers(), false ); 455 assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), td ) ), 0) );456 assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0) );457 assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), td->get_name(), td ), 0) );458 td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false, false ) );412 assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) ); 413 assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); 414 assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) ); 415 td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) ); 459 416 } // if 460 417 } // for … … 488 445 case TypeData::Builtin: 489 446 return new VarArgsType( buildQualifiers( td ) ); 490 case TypeData::Attr:491 assert( false );492 return buildAttr( td );493 447 case TypeData::Symbolic: 494 448 case TypeData::Enum: 495 449 case TypeData::Aggregate: 496 case TypeData::Variable:497 450 assert( false ); 498 451 } // switch 499 return 0;452 return nullptr; 500 453 } // typebuild 501 454 502 455 TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) { 503 TypeData * ret = 0;456 TypeData * ret = nullptr; 504 457 505 458 switch ( td->kind ) { … … 551 504 case DeclarationNode::Bool: 552 505 if ( td->signedness != DeclarationNode::NoSignedness ) { 553 throw SemanticError( st d::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );506 throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); 554 507 } // if 555 508 if ( td->length != DeclarationNode::NoLength ) { 556 throw SemanticError( st d::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );509 throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); 557 510 } // if 558 511 … … 567 520 568 521 if ( td->length != DeclarationNode::NoLength ) { 569 throw SemanticError( st d::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );522 throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); 570 523 } // if 571 524 … … 597 550 FloatingPoint: ; 598 551 if ( td->signedness != DeclarationNode::NoSignedness ) { 599 throw SemanticError( st d::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );552 throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); 600 553 } // if 601 554 if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) { 602 throw SemanticError( st d::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );555 throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); 603 556 } // if 604 557 if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) { … … 657 610 switch ( td->aggregate.kind ) { 658 611 case DeclarationNode::Struct: 659 at = new StructDecl( td->aggregate.name );612 at = new StructDecl( *td->aggregate.name ); 660 613 buildForall( td->aggregate.params, at->get_parameters() ); 661 614 break; 662 615 case DeclarationNode::Union: 663 at = new UnionDecl( td->aggregate.name );616 at = new UnionDecl( *td->aggregate.name ); 664 617 buildForall( td->aggregate.params, at->get_parameters() ); 665 618 break; 666 619 case DeclarationNode::Trait: 667 at = new TraitDecl( td->aggregate.name );620 at = new TraitDecl( *td->aggregate.name ); 668 621 buildList( td->aggregate.params, at->get_parameters() ); 669 622 break; … … 683 636 ReferenceToType * ret; 684 637 if ( td->aggInst.aggregate->kind == TypeData::Enum ) { 685 ret = new EnumInstType( buildQualifiers( td ), td->aggInst.aggregate->enumeration.name );638 ret = new EnumInstType( buildQualifiers( td ), *td->aggInst.aggregate->enumeration.name ); 686 639 } else { 687 640 assert( td->aggInst.aggregate->kind == TypeData::Aggregate ); 688 641 switch ( td->aggInst.aggregate->aggregate.kind ) { 689 642 case DeclarationNode::Struct: 690 ret = new StructInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name ); 643 assert( td->aggInst.aggregate->aggregate.name ); 644 ret = new StructInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name ); 691 645 break; 692 646 case DeclarationNode::Union: 693 ret = new UnionInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );647 ret = new UnionInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name ); 694 648 break; 695 649 case DeclarationNode::Trait: 696 ret = new TraitInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );650 ret = new TraitInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name ); 697 651 break; 698 652 default: … … 705 659 } // buildAggInst 706 660 707 NamedTypeDecl * buildSymbolic( const TypeData * td, const st d::string & name, DeclarationNode::StorageClass sc ) {661 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc ) { 708 662 assert( td->kind == TypeData::Symbolic ); 709 663 NamedTypeDecl * ret; … … 719 673 } // buildSymbolic 720 674 721 TypeDecl * buildVariable( const TypeData * td ) {722 assert( false );723 return nullptr;724 // assert( td->kind == TypeData::Variable );725 // static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };726 727 // TypeDecl * ret = new TypeDecl( td->variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ td->variable.tyClass ] );728 // buildList( td->variable.assertions, ret->get_assertions() );729 // return ret;730 } // buildSymbolic731 732 675 EnumDecl * buildEnum( const TypeData * td ) { 733 676 assert( td->kind == TypeData::Enum ); 734 EnumDecl * ret = new EnumDecl( td->enumeration.name );677 EnumDecl * ret = new EnumDecl( *td->enumeration.name ); 735 678 buildList( td->enumeration.constants, ret->get_members() ); 736 std::list< Declaration * >::iterator members = ret->get_members().begin();679 list< Declaration * >::iterator members = ret->get_members().begin(); 737 680 for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) { 738 681 if ( cur->has_enumeratorValue() ) { 739 682 ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members); 740 member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), std::list< Expression * >() ) );683 member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) ); 741 684 } // if 742 685 } // for … … 746 689 TypeInstType * buildSymbolicInst( const TypeData * td ) { 747 690 assert( td->kind == TypeData::SymbolicInst ); 748 TypeInstType * ret = new TypeInstType( buildQualifiers( td ), td->symbolic.name, false );691 TypeInstType * ret = new TypeInstType( buildQualifiers( td ), *td->symbolic.name, false ); 749 692 buildList( td->symbolic.actuals, ret->get_parameters() ); 750 693 buildForall( td->forall, ret->get_forall() ); … … 767 710 } // buildTypeof 768 711 769 AttrType * buildAttr( const TypeData * td ) { 770 assert( false ); 771 return nullptr; 772 // assert( td->kind == TypeData::Attr ); 773 // // assert( td->attr ); 774 // AttrType * ret; 775 // if ( td->attr.expr ) { 776 // ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.expr->build() ); 777 // } else { 778 // assert( td->attr.type ); 779 // ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.type->buildType() ); 780 // } // if 781 // return ret; 782 } // buildAttr 783 784 Declaration * buildDecl( const TypeData * td, std::string name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) { 712 Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) { 785 713 if ( td->kind == TypeData::Function ) { 786 714 FunctionDecl * decl; … … 792 720 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn ); 793 721 } else { 794 // std::list< Label > ls;795 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( std::list< Label >() ), isInline, isNoreturn );722 // list< Label > ls; 723 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( list< Label >() ), isInline, isNoreturn ); 796 724 } // if 797 725 } else { 798 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), 0, isInline, isNoreturn );799 } // if 800 for ( DeclarationNode * cur = td->function.idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {801 if ( cur-> get_name() != "") {802 decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name());726 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), nullptr, isInline, isNoreturn ); 727 } // if 728 for ( DeclarationNode * cur = td->function.idList; cur != nullptr; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) { 729 if ( cur->name ) { 730 decl->get_oldIdents().insert( decl->get_oldIdents().end(), *cur->name ); 803 731 } // if 804 732 } // for … … 811 739 } else if ( td->kind == TypeData::Symbolic ) { 812 740 return buildSymbolic( td, name, sc ); 813 } else if ( td->kind == TypeData::Variable ) {814 assert( false );815 return buildVariable( td );816 741 } else { 817 return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, std::list< Attribute * >(), isInline, isNoreturn );742 return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, list< Attribute * >(), isInline, isNoreturn ); 818 743 } // if 819 return 0;744 return nullptr; 820 745 } // buildDecl 821 746 … … 833 758 break; 834 759 default: 835 ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base, "", DeclarationNode::NoStorageClass, 0, false, false, LinkageSpec::Cforall ) ) );760 ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base, "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall ) ) ); 836 761 } // switch 837 762 } else { 838 ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0) );763 ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) ); 839 764 } // if 840 765 return ft; -
src/Parser/TypeData.h
rac9ca96 r7756647 10 10 // Created On : Sat May 16 15:18:36 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon Sep 12 17:15:49201613 // Update Count : 1 2912 // Last Modified On : Mon Oct 3 12:34:08 2016 13 // Update Count : 142 14 14 // 15 15 … … 23 23 24 24 struct TypeData { 25 enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst,26 Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr};25 enum Kind { Basic, Pointer, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic, 26 SymbolicInst, Tuple, Typeof, Builtin, Unknown }; 27 27 28 28 struct Aggregate_t { 29 29 DeclarationNode::Aggregate kind; 30 std::stringname;30 const std::string * name; 31 31 DeclarationNode * params; 32 ExpressionNode 32 ExpressionNode * actuals; // holds actual parameters later applied to AggInst 33 33 DeclarationNode * fields; 34 34 bool body; … … 47 47 48 48 struct Enumeration_t { 49 std::stringname;49 const std::string * name; 50 50 DeclarationNode * constants; 51 51 }; … … 61 61 62 62 struct Symbolic_t { 63 std::stringname;63 const std::string * name; 64 64 bool isTypedef; // false => TYPEGENname, true => TYPEDEFname 65 65 DeclarationNode * params; … … 88 88 DeclarationNode * tuple; 89 89 ExpressionNode * typeexpr; 90 // Attr_t attr;91 90 // DeclarationNode::BuiltinType builtin; 92 91 … … 111 110 TupleType * buildTuple( const TypeData * ); 112 111 TypeofType * buildTypeof( const TypeData * ); 113 AttrType * buildAttr( const TypeData * ); 114 Declaration * buildDecl( const TypeData *, std::string, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = 0 ); 112 Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = nullptr ); 115 113 FunctionType * buildFunction( const TypeData * ); 116 114 -
src/Parser/parser.cc
rac9ca96 r7756647 82 82 #include "TypeData.h" 83 83 #include "LinkageSpec.h" 84 using namespace std; 84 85 85 86 extern DeclarationNode * parseTree; … … 87 88 extern TypedefTable typedefTable; 88 89 89 st d::stack< LinkageSpec::Spec > linkageStack;90 91 void appendStr( st d::string *to, std::string *from ) {90 stack< LinkageSpec::Spec > linkageStack; 91 92 void appendStr( string *to, string *from ) { 92 93 // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string. 93 94 to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) ); … … 96 97 97 98 /* Line 268 of yacc.c */ 98 #line 99"Parser/parser.cc"99 #line 100 "Parser/parser.cc" 99 100 100 101 /* Enabling traces. */ … … 347 348 348 349 /* Line 293 of yacc.c */ 349 #line 11 5"parser.yy"350 #line 116 "parser.yy" 350 351 351 352 Token tok; … … 367 368 368 369 /* Line 293 of yacc.c */ 369 #line 37 0"Parser/parser.cc"370 #line 371 "Parser/parser.cc" 370 371 } YYSTYPE; 371 372 # define YYSTYPE_IS_TRIVIAL 1 … … 379 380 380 381 /* Line 343 of yacc.c */ 381 #line 38 2"Parser/parser.cc"382 #line 383 "Parser/parser.cc" 382 383 383 384 #ifdef short … … 598 599 #define YYFINAL 250 599 600 /* YYLAST -- Last index in YYTABLE. */ 600 #define YYLAST 108 63601 #define YYLAST 10888 601 602 602 603 /* YYNTOKENS -- Number of terminals. */ 603 604 #define YYNTOKENS 133 604 605 /* YYNNTS -- Number of nonterminals. */ 605 #define YYNNTS 24 1606 #define YYNNTS 242 606 607 /* YYNRULES -- Number of rules. */ 607 #define YYNRULES 75 1608 #define YYNRULES 754 608 609 /* YYNRULES -- Number of states. */ 609 #define YYNSTATES 155 5610 #define YYNSTATES 1558 610 611 611 612 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ … … 666 667 17, 19, 21, 23, 25, 27, 29, 31, 33, 36, 667 668 38, 40, 44, 48, 50, 57, 62, 66, 74, 78, 668 8 6, 89, 92, 100, 105, 107, 111, 112, 114, 116,669 120, 12 2, 126, 134, 138, 146, 148, 150, 152, 155,670 158, 16 1, 164, 167, 170, 175, 178, 183, 190, 192,671 19 7, 202, 204, 206, 208, 210, 212, 214, 216, 221,672 22 6, 228, 232, 236, 240, 242, 246, 250, 252, 256,673 2 60, 262, 266, 270, 274, 278, 280, 284, 288, 290,674 29 4, 296, 300, 302, 306, 308, 312, 314, 318, 320,675 32 6, 331, 337, 339, 341, 345, 348, 349, 351, 353,676 35 5, 357, 359, 361, 363, 365, 367, 369, 371, 373,677 37 5, 378, 384, 391, 399, 401, 405, 407, 411, 412,678 41 4, 416, 418, 420, 422, 424, 426, 428, 430, 437,679 4 42, 445, 453, 455, 459, 461, 464, 466, 469, 471,680 474, 477, 4 83, 491, 497, 507, 513, 523, 525, 529,681 531, 533, 537, 5 41, 544, 546, 549, 552, 553, 555,682 5 58, 562, 563, 565, 568, 572, 576, 581, 582, 584,683 58 6, 589, 595, 603, 610, 617, 622, 626, 631, 634,684 63 8, 641, 645, 649, 653, 657, 663, 667, 671, 676,685 67 8, 684, 691, 697, 704, 714, 725, 735, 746, 749,686 7 51, 754, 757, 760, 762, 769, 778, 789, 802, 817,687 818, 820, 821, 823, 825, 829, 834, 842, 843, 845,688 8 49, 851, 855, 857, 859, 861, 865, 867, 869, 871,689 875, 87 6, 878, 882, 887, 889, 893, 895, 897, 901,690 90 5, 909, 913, 917, 920, 924, 931, 935, 939, 944,691 94 6, 949, 952, 956, 962, 971, 979, 987, 993, 1003,692 1006, 1009, 1015, 1019, 1025, 1030, 1034, 1039, 1044, 1052,693 10 56, 1060, 1064, 1068, 1073, 1080, 1082, 1084, 1086, 1088,694 109 0, 1092, 1094, 1096, 1097, 1099, 1101, 1104, 1106, 1108,695 111 0, 1112, 1114, 1116, 1118, 1119, 1125, 1127, 1130, 1134,696 113 6, 1139, 1141, 1143, 1145, 1147, 1149, 1151, 1153, 1155,697 115 7, 1159, 1161, 1163, 1165, 1167, 1169, 1171, 1173, 1175,698 117 7, 1179, 1181, 1183, 1186, 1189, 1193, 1197, 1199, 1203,699 1205, 120 8, 1211, 1214, 1219, 1224, 1229, 1234, 1236, 1239,700 1242, 124 6, 1248, 1251, 1254, 1256, 1259, 1262, 1266, 1268,701 127 1, 1274, 1276, 1278, 1283, 1286, 1287, 1294, 1302, 1305,702 130 8, 1311, 1312, 1315, 1318, 1322, 1325, 1329, 1331, 1334,703 133 8, 1341, 1344, 1349, 1350, 1352, 1355, 1358, 1360, 1361,704 136 3, 1366, 1369, 1375, 1378, 1379, 1387, 1390, 1395, 1396,705 139 9, 1400, 1402, 1404, 1406, 1412, 1418, 1424, 1426, 1432,706 143 8, 1448, 1450, 1456, 1457, 1459, 1461, 1467, 1469, 1471,707 147 7, 1483, 1485, 1489, 1493, 1498, 1500, 1502, 1504, 1506,708 15 09, 1511, 1515, 1519, 1521, 1524, 1526, 1530, 1532, 1534,709 153 6, 1538, 1540, 1542, 1544, 1546, 1548, 1550, 1552, 1555,710 155 7, 1559, 1561, 1564, 1565, 1568, 1571, 1573, 1578, 1579,711 1581, 158 4, 1588, 1593, 1596, 1599, 1601, 1604, 1607, 1613,712 161 9, 1627, 1634, 1636, 1639, 1642, 1646, 1648, 1651, 1654,713 165 9, 1662, 1667, 1668, 1673, 1676, 1678, 1680, 1682, 1683,714 168 6, 1692, 1698, 1712, 1714, 1716, 1720, 1724, 1727, 1731,715 173 5, 1738, 1743, 1745, 1752, 1762, 1763, 1775, 1777, 1781,716 178 5, 1789, 1791, 1793, 1799, 1802, 1808, 1809, 1811, 1813,717 1817, 181 8, 1820, 1822, 1824, 1826, 1827, 1834, 1837, 1839,718 1842, 184 7, 1850, 1854, 1858, 1862, 1867, 1873, 1879, 1885,719 18 92, 1894, 1896, 1898, 1902, 1903, 1909, 1910, 1912, 1914,720 191 7, 1924, 1926, 1930, 1931, 1933, 1938, 1940, 1942, 1944,721 194 6, 1949, 1951, 1954, 1957, 1959, 1963, 1966, 1970, 1974,722 197 7, 1982, 1987, 1991, 2000, 2004, 2007, 2009, 2012, 2019,723 20 28, 2032, 2035, 2039, 2043, 2048, 2053, 2057, 2059, 2061,724 206 3, 2068, 2075, 2079, 2082, 2086, 2090, 2095, 2100, 2104,725 210 7, 2109, 2112, 2115, 2117, 2121, 2124, 2128, 2132, 2135,726 21 40, 2145, 2149, 2156, 2165, 2169, 2172, 2174, 2177, 2180,727 218 3, 2187, 2191, 2194, 2199, 2204, 2208, 2215, 2224, 2228,728 22 31, 2233, 2236, 2239, 2241, 2243, 2246, 2250, 2254, 2257,729 22 62, 2269, 2278, 2280, 2283, 2286, 2288, 2291, 2294, 2298,730 2 302, 2304, 2309, 2314, 2318, 2324, 2333, 2337, 2340, 2344,731 234 6, 2352, 2358, 2365, 2372, 2374, 2377, 2380, 2382, 2385,732 2388, 239 2, 2396, 2398, 2403, 2408, 2412, 2418, 2427, 2431,733 24 33, 2436, 2438, 2441, 2448, 2454, 2461, 2469, 2477, 2479,734 24 82, 2485, 2487, 2490, 2493, 2497, 2501, 2503, 2508, 2513,735 251 7, 2526, 2530, 2532, 2534, 2537, 2539, 2541, 2544, 2548,736 25 51, 2555, 2558, 2562, 2566, 2569, 2574, 2578, 2581, 2585,737 258 8, 2593, 2597, 2600, 2607, 2614, 2621, 2629, 2631, 2634,738 263 6, 2638, 2640, 2643, 2647, 2650, 2654, 2657, 2661, 2665,739 26 70, 2673, 2677, 2682, 2685, 2691, 2697, 2704, 2711, 2712,740 271 4, 2715669 82, 90, 93, 96, 104, 109, 111, 115, 116, 118, 670 120, 124, 126, 130, 138, 142, 150, 152, 154, 156, 671 158, 160, 163, 166, 169, 172, 175, 178, 183, 186, 672 191, 198, 200, 205, 210, 212, 214, 216, 218, 220, 673 222, 224, 229, 234, 236, 240, 244, 248, 250, 254, 674 258, 260, 264, 268, 270, 274, 278, 282, 286, 288, 675 292, 296, 298, 302, 304, 308, 310, 314, 316, 320, 676 322, 326, 328, 334, 339, 345, 347, 349, 353, 356, 677 357, 359, 361, 363, 365, 367, 369, 371, 373, 375, 678 377, 379, 381, 383, 386, 392, 399, 407, 409, 413, 679 415, 419, 420, 422, 424, 426, 428, 430, 432, 434, 680 436, 438, 445, 450, 453, 461, 463, 467, 469, 472, 681 474, 477, 479, 482, 485, 491, 499, 505, 515, 521, 682 531, 533, 537, 539, 541, 545, 549, 552, 554, 557, 683 560, 561, 563, 566, 570, 571, 573, 576, 580, 584, 684 589, 590, 592, 594, 597, 603, 611, 618, 625, 630, 685 634, 639, 642, 646, 649, 653, 657, 661, 665, 671, 686 675, 679, 684, 686, 692, 699, 705, 712, 722, 733, 687 743, 754, 757, 759, 762, 765, 768, 770, 777, 786, 688 797, 810, 825, 826, 828, 829, 831, 833, 837, 842, 689 850, 851, 853, 857, 859, 863, 865, 867, 869, 873, 690 875, 877, 879, 883, 884, 886, 890, 895, 897, 901, 691 903, 905, 909, 913, 917, 921, 925, 928, 932, 939, 692 943, 947, 952, 954, 957, 960, 964, 970, 979, 987, 693 995, 1001, 1011, 1014, 1017, 1023, 1027, 1033, 1038, 1042, 694 1047, 1052, 1060, 1064, 1068, 1072, 1076, 1081, 1088, 1090, 695 1092, 1094, 1096, 1098, 1100, 1102, 1104, 1105, 1107, 1109, 696 1112, 1114, 1116, 1118, 1120, 1122, 1124, 1126, 1127, 1133, 697 1135, 1138, 1142, 1144, 1147, 1149, 1151, 1153, 1155, 1157, 698 1159, 1161, 1163, 1165, 1167, 1169, 1171, 1173, 1175, 1177, 699 1179, 1181, 1183, 1185, 1187, 1189, 1191, 1194, 1197, 1201, 700 1205, 1207, 1211, 1213, 1216, 1219, 1222, 1227, 1232, 1237, 701 1242, 1244, 1247, 1250, 1254, 1256, 1259, 1262, 1264, 1267, 702 1270, 1274, 1276, 1279, 1282, 1284, 1286, 1291, 1294, 1295, 703 1302, 1310, 1313, 1316, 1319, 1320, 1323, 1326, 1330, 1333, 704 1337, 1339, 1342, 1346, 1349, 1352, 1357, 1358, 1360, 1363, 705 1366, 1368, 1369, 1371, 1374, 1377, 1383, 1386, 1387, 1395, 706 1398, 1403, 1404, 1407, 1408, 1410, 1412, 1414, 1420, 1426, 707 1432, 1434, 1440, 1446, 1456, 1458, 1464, 1465, 1467, 1469, 708 1475, 1477, 1479, 1485, 1491, 1493, 1497, 1501, 1506, 1508, 709 1510, 1512, 1514, 1517, 1519, 1523, 1527, 1529, 1532, 1534, 710 1538, 1540, 1542, 1544, 1546, 1548, 1550, 1552, 1554, 1556, 711 1558, 1560, 1563, 1565, 1567, 1569, 1572, 1573, 1576, 1579, 712 1581, 1586, 1587, 1589, 1592, 1596, 1601, 1604, 1607, 1609, 713 1612, 1615, 1621, 1627, 1635, 1642, 1644, 1647, 1650, 1654, 714 1656, 1659, 1662, 1667, 1670, 1675, 1676, 1681, 1684, 1686, 715 1688, 1690, 1691, 1694, 1700, 1706, 1720, 1722, 1724, 1728, 716 1732, 1735, 1739, 1743, 1746, 1751, 1753, 1760, 1770, 1771, 717 1783, 1785, 1789, 1793, 1797, 1799, 1801, 1807, 1810, 1816, 718 1817, 1819, 1821, 1825, 1826, 1828, 1830, 1832, 1834, 1835, 719 1842, 1845, 1847, 1850, 1855, 1858, 1862, 1866, 1870, 1875, 720 1881, 1887, 1893, 1900, 1902, 1904, 1906, 1910, 1911, 1917, 721 1918, 1920, 1922, 1925, 1932, 1934, 1938, 1939, 1941, 1946, 722 1948, 1950, 1952, 1954, 1957, 1959, 1962, 1965, 1967, 1971, 723 1974, 1978, 1982, 1985, 1990, 1995, 1999, 2008, 2012, 2015, 724 2017, 2020, 2027, 2036, 2040, 2043, 2047, 2051, 2056, 2061, 725 2065, 2067, 2069, 2071, 2076, 2083, 2087, 2090, 2094, 2098, 726 2103, 2108, 2112, 2115, 2117, 2120, 2123, 2125, 2129, 2132, 727 2136, 2140, 2143, 2148, 2153, 2157, 2164, 2173, 2177, 2180, 728 2182, 2185, 2188, 2191, 2195, 2199, 2202, 2207, 2212, 2216, 729 2223, 2232, 2236, 2239, 2241, 2244, 2247, 2249, 2251, 2254, 730 2258, 2262, 2265, 2270, 2277, 2286, 2288, 2291, 2294, 2296, 731 2299, 2302, 2306, 2310, 2312, 2317, 2322, 2326, 2332, 2341, 732 2345, 2348, 2352, 2354, 2360, 2366, 2373, 2380, 2382, 2385, 733 2388, 2390, 2393, 2396, 2400, 2404, 2406, 2411, 2416, 2420, 734 2426, 2435, 2439, 2441, 2444, 2446, 2449, 2456, 2462, 2469, 735 2477, 2485, 2487, 2490, 2493, 2495, 2498, 2501, 2505, 2509, 736 2511, 2516, 2521, 2525, 2534, 2538, 2540, 2542, 2545, 2547, 737 2549, 2552, 2556, 2559, 2563, 2566, 2570, 2574, 2577, 2582, 738 2586, 2589, 2593, 2596, 2601, 2605, 2608, 2615, 2622, 2629, 739 2637, 2639, 2642, 2644, 2646, 2648, 2651, 2655, 2658, 2662, 740 2665, 2669, 2673, 2678, 2681, 2685, 2690, 2693, 2699, 2705, 741 2712, 2719, 2720, 2722, 2723 741 742 }; 742 743 … … 744 745 static const yytype_int16 yyrhs[] = 745 746 { 746 30 2, 0, -1, -1, -1, 79, -1, 80, -1, 81,747 303, 0, -1, -1, -1, 79, -1, 80, -1, 81, 747 748 -1, 72, -1, 76, -1, 140, -1, 72, -1, 76, 748 749 -1, 72, -1, 140, -1, 83, -1, 84, -1, 142, 749 750 -1, 82, -1, 142, 82, -1, 72, -1, 140, -1, 750 109, 17 0, 110, -1, 109, 174, 110, -1, 143, -1,751 144, 111, 134, 16 5, 135, 112, -1, 144, 109, 145,751 109, 171, 110, -1, 109, 175, 110, -1, 143, -1, 752 144, 111, 134, 166, 135, 112, -1, 144, 109, 145, 752 753 110, -1, 144, 113, 139, -1, 144, 113, 111, 134, 753 147, 135, 112, -1, 144, 85, 139, -1, 144, 85, 754 111, 134, 147, 135, 112, -1, 144, 86, -1, 144, 755 87, -1, 109, 275, 110, 114, 279, 372, 115, -1, 756 144, 114, 145, 115, -1, 146, -1, 145, 116, 146, 757 -1, -1, 165, -1, 148, -1, 147, 116, 148, -1, 758 139, -1, 139, 113, 148, -1, 139, 113, 111, 134, 759 147, 135, 112, -1, 139, 85, 148, -1, 139, 85, 760 111, 134, 147, 135, 112, -1, 144, -1, 136, -1, 761 141, -1, 40, 152, -1, 150, 152, -1, 151, 152, 762 -1, 86, 149, -1, 87, 149, -1, 37, 149, -1, 763 37, 109, 275, 110, -1, 66, 149, -1, 66, 109, 764 275, 110, -1, 38, 109, 275, 116, 139, 110, -1, 765 76, -1, 76, 109, 146, 110, -1, 76, 109, 276, 766 110, -1, 117, -1, 118, -1, 119, -1, 120, -1, 767 121, -1, 122, -1, 149, -1, 109, 275, 110, 152, 768 -1, 109, 275, 110, 168, -1, 152, -1, 153, 117, 769 152, -1, 153, 123, 152, -1, 153, 124, 152, -1, 770 153, -1, 154, 119, 153, -1, 154, 120, 153, -1, 771 154, -1, 155, 88, 154, -1, 155, 89, 154, -1, 772 155, -1, 156, 125, 155, -1, 156, 126, 155, -1, 773 156, 90, 155, -1, 156, 91, 155, -1, 156, -1, 774 157, 92, 156, -1, 157, 93, 156, -1, 157, -1, 775 158, 118, 157, -1, 158, -1, 159, 127, 158, -1, 776 159, -1, 160, 128, 159, -1, 160, -1, 161, 94, 777 160, -1, 161, -1, 162, 95, 161, -1, 162, -1, 778 162, 129, 170, 130, 163, -1, 162, 129, 130, 163, 779 -1, 162, 129, 170, 130, 168, -1, 163, -1, 163, 780 -1, 149, 167, 165, -1, 168, 373, -1, -1, 165, 781 -1, 131, -1, 107, -1, 97, -1, 98, -1, 99, 782 -1, 100, -1, 101, -1, 102, -1, 103, -1, 104, 783 -1, 105, -1, 106, -1, 111, 112, -1, 111, 134, 784 165, 135, 112, -1, 111, 134, 116, 169, 135, 112, 785 -1, 111, 134, 165, 116, 169, 135, 112, -1, 166, 786 -1, 169, 116, 166, -1, 165, -1, 170, 116, 165, 787 -1, -1, 170, -1, 173, -1, 174, -1, 178, -1, 788 179, -1, 191, -1, 193, -1, 194, -1, 199, -1, 789 127, 144, 114, 145, 115, 132, -1, 72, 130, 312, 790 172, -1, 114, 115, -1, 114, 134, 134, 210, 175, 791 135, 115, -1, 176, -1, 175, 134, 176, -1, 213, 792 -1, 40, 213, -1, 308, -1, 172, 135, -1, 172, 793 -1, 177, 172, -1, 171, 132, -1, 41, 109, 170, 794 110, 172, -1, 41, 109, 170, 110, 172, 42, 172, 795 -1, 43, 109, 170, 110, 184, -1, 43, 109, 170, 796 110, 114, 134, 206, 185, 115, -1, 53, 109, 170, 797 110, 184, -1, 53, 109, 170, 110, 114, 134, 206, 798 187, 115, -1, 164, -1, 164, 96, 164, -1, 310, 799 -1, 180, -1, 181, 116, 180, -1, 44, 181, 130, 800 -1, 45, 130, -1, 182, -1, 183, 182, -1, 183, 801 172, -1, -1, 186, -1, 183, 177, -1, 186, 183, 802 177, -1, -1, 188, -1, 183, 190, -1, 183, 177, 803 189, -1, 188, 183, 190, -1, 188, 183, 177, 189, 804 -1, -1, 190, -1, 56, -1, 56, 132, -1, 47, 805 109, 170, 110, 172, -1, 46, 172, 47, 109, 170, 806 110, 132, -1, 48, 109, 134, 192, 110, 172, -1, 807 171, 135, 132, 171, 132, 171, -1, 213, 171, 132, 808 171, -1, 51, 72, 132, -1, 51, 117, 170, 132, 809 -1, 50, 132, -1, 50, 72, 132, -1, 49, 132, 810 -1, 49, 72, 132, -1, 52, 171, 132, -1, 61, 811 166, 132, -1, 62, 166, 132, -1, 62, 166, 63, 812 165, 132, -1, 57, 174, 195, -1, 57, 174, 197, 813 -1, 57, 174, 195, 197, -1, 196, -1, 58, 109, 814 96, 110, 174, -1, 196, 58, 109, 96, 110, 174, 815 -1, 59, 109, 96, 110, 174, -1, 196, 59, 109, 816 96, 110, 174, -1, 58, 109, 134, 134, 198, 135, 817 110, 174, 135, -1, 196, 58, 109, 134, 134, 198, 818 135, 110, 174, 135, -1, 59, 109, 134, 134, 198, 819 135, 110, 174, 135, -1, 196, 59, 109, 134, 134, 820 198, 135, 110, 174, 135, -1, 60, 174, -1, 226, 821 -1, 226, 309, -1, 226, 357, -1, 366, 139, -1, 822 366, -1, 64, 200, 109, 141, 110, 132, -1, 64, 823 200, 109, 141, 130, 201, 110, 132, -1, 64, 200, 824 109, 141, 130, 201, 130, 201, 110, 132, -1, 64, 825 200, 109, 141, 130, 201, 130, 201, 130, 204, 110, 826 132, -1, 64, 200, 51, 109, 141, 130, 130, 201, 827 130, 204, 130, 205, 110, 132, -1, -1, 11, -1, 828 -1, 202, -1, 203, -1, 202, 116, 203, -1, 141, 829 109, 164, 110, -1, 111, 164, 112, 141, 109, 164, 830 110, -1, -1, 141, -1, 204, 116, 141, -1, 139, 831 -1, 205, 116, 139, -1, 135, -1, 207, -1, 213, 832 -1, 207, 134, 213, -1, 135, -1, 209, -1, 223, 833 -1, 209, 134, 223, -1, -1, 211, -1, 29, 212, 834 132, -1, 211, 29, 212, 132, -1, 274, -1, 212, 835 116, 274, -1, 214, -1, 223, -1, 215, 135, 132, 836 -1, 220, 135, 132, -1, 217, 135, 132, -1, 293, 837 135, 132, -1, 296, 135, 132, -1, 216, 277, -1, 838 232, 216, 277, -1, 215, 135, 116, 134, 272, 277, 839 -1, 367, 272, 311, -1, 370, 272, 311, -1, 228, 840 370, 272, 311, -1, 218, -1, 228, 218, -1, 232, 841 218, -1, 232, 228, 218, -1, 217, 135, 116, 134, 842 272, -1, 111, 112, 272, 109, 134, 260, 135, 110, 843 -1, 370, 272, 109, 134, 260, 135, 110, -1, 219, 844 272, 109, 134, 260, 135, 110, -1, 111, 134, 262, 845 135, 112, -1, 111, 134, 262, 135, 116, 134, 263, 846 135, 112, -1, 3, 216, -1, 3, 218, -1, 220, 847 135, 116, 134, 139, -1, 3, 226, 309, -1, 221, 848 135, 116, 134, 309, -1, 228, 3, 226, 309, -1, 849 226, 3, 309, -1, 226, 3, 228, 309, -1, 3, 850 139, 131, 165, -1, 222, 135, 116, 134, 139, 131, 851 165, -1, 224, 135, 132, -1, 221, 135, 132, -1, 852 222, 135, 132, -1, 240, 135, 132, -1, 225, 309, 853 311, 277, -1, 224, 116, 312, 309, 311, 277, -1, 854 236, -1, 240, -1, 242, -1, 283, -1, 237, -1, 855 241, -1, 243, -1, 284, -1, -1, 228, -1, 229, 856 -1, 228, 229, -1, 230, -1, 314, -1, 10, -1, 857 12, -1, 11, -1, 14, -1, 67, -1, -1, 13, 858 109, 231, 286, 110, -1, 233, -1, 228, 233, -1, 859 232, 228, 233, -1, 234, -1, 233, 234, -1, 5, 860 -1, 7, -1, 4, -1, 6, -1, 8, -1, 9, 861 -1, 69, -1, 71, -1, 16, -1, 21, -1, 20, 862 -1, 18, -1, 19, -1, 17, -1, 22, -1, 23, 863 -1, 15, -1, 25, -1, 26, -1, 27, -1, 24, 864 -1, 237, -1, 232, 237, -1, 236, 234, -1, 236, 865 234, 228, -1, 236, 234, 237, -1, 238, -1, 227, 866 239, 227, -1, 235, -1, 228, 235, -1, 238, 229, 867 -1, 238, 235, -1, 28, 109, 276, 110, -1, 28, 868 109, 170, 110, -1, 78, 109, 276, 110, -1, 78, 869 109, 170, 110, -1, 241, -1, 232, 241, -1, 240, 870 234, -1, 240, 234, 228, -1, 244, -1, 228, 244, 871 -1, 241, 229, -1, 243, -1, 232, 243, -1, 242, 872 234, -1, 242, 234, 228, -1, 74, -1, 228, 74, 873 -1, 243, 229, -1, 245, -1, 256, -1, 247, 114, 874 248, 115, -1, 247, 274, -1, -1, 247, 274, 246, 875 114, 248, 115, -1, 247, 109, 292, 110, 114, 248, 876 115, -1, 247, 285, -1, 31, 312, -1, 32, 312, 877 -1, -1, 248, 249, -1, 250, 132, -1, 40, 250, 878 132, -1, 251, 132, -1, 40, 251, 132, -1, 366, 879 -1, 366, 274, -1, 250, 116, 274, -1, 250, 116, 880 -1, 226, 252, -1, 251, 116, 312, 252, -1, -1, 881 254, -1, 318, 253, -1, 331, 253, -1, 357, -1, 882 -1, 254, -1, 130, 164, -1, 30, 312, -1, 255, 883 114, 258, 372, 115, -1, 255, 274, -1, -1, 255, 884 274, 257, 114, 258, 372, 115, -1, 274, 259, -1, 885 258, 116, 274, 259, -1, -1, 131, 164, -1, -1, 886 261, -1, 263, -1, 262, -1, 262, 135, 116, 134, 887 263, -1, 263, 135, 116, 134, 96, -1, 262, 135, 888 116, 134, 96, -1, 267, -1, 263, 135, 116, 134, 889 267, -1, 262, 135, 116, 134, 267, -1, 262, 135, 890 116, 134, 263, 135, 116, 134, 267, -1, 268, -1, 891 263, 135, 116, 134, 268, -1, -1, 265, -1, 266, 892 -1, 266, 135, 116, 134, 96, -1, 270, -1, 269, 893 -1, 266, 135, 116, 134, 270, -1, 266, 135, 116, 894 134, 269, -1, 269, -1, 362, 272, 373, -1, 370, 895 272, 373, -1, 228, 370, 272, 373, -1, 218, -1, 896 270, -1, 362, -1, 370, -1, 228, 370, -1, 371, 897 -1, 225, 336, 373, -1, 225, 340, 373, -1, 225, 898 -1, 225, 351, -1, 139, -1, 271, 116, 139, -1, 899 137, -1, 74, -1, 75, -1, 138, -1, 74, -1, 900 75, -1, 139, -1, 74, -1, 75, -1, 366, -1, 901 226, -1, 226, 357, -1, 366, -1, 371, -1, 226, 902 -1, 226, 345, -1, -1, 131, 278, -1, 107, 278, 903 -1, 165, -1, 114, 279, 372, 115, -1, -1, 278, 904 -1, 280, 278, -1, 279, 116, 278, -1, 279, 116, 905 280, 278, -1, 281, 130, -1, 274, 130, -1, 282, 906 -1, 281, 282, -1, 113, 274, -1, 111, 134, 165, 907 135, 112, -1, 111, 134, 310, 135, 112, -1, 111, 908 134, 164, 96, 164, 135, 112, -1, 113, 111, 134, 909 147, 135, 112, -1, 284, -1, 232, 284, -1, 283, 910 234, -1, 283, 234, 228, -1, 285, -1, 228, 285, 911 -1, 284, 229, -1, 75, 109, 292, 110, -1, 287, 912 373, -1, 286, 116, 287, 373, -1, -1, 289, 274, 913 288, 290, -1, 226, 336, -1, 33, -1, 35, -1, 914 34, -1, -1, 290, 291, -1, 128, 274, 109, 292, 915 110, -1, 128, 114, 134, 298, 115, -1, 128, 109, 916 134, 286, 135, 110, 114, 134, 298, 115, 109, 292, 917 110, -1, 276, -1, 165, -1, 292, 116, 276, -1, 918 292, 116, 165, -1, 33, 294, -1, 233, 33, 294, 919 -1, 293, 116, 294, -1, 295, 290, -1, 295, 290, 920 131, 276, -1, 274, -1, 273, 109, 134, 286, 135, 921 110, -1, 36, 274, 109, 134, 286, 135, 110, 114, 922 115, -1, -1, 36, 274, 109, 134, 286, 135, 110, 923 114, 297, 298, 115, -1, 299, -1, 298, 134, 299, 924 -1, 300, 135, 132, -1, 301, 135, 132, -1, 216, 925 -1, 218, -1, 300, 135, 116, 134, 272, -1, 226, 926 309, -1, 301, 135, 116, 134, 309, -1, -1, 303, 927 -1, 305, -1, 303, 134, 305, -1, -1, 303, -1, 928 213, -1, 307, -1, 199, -1, -1, 5, 82, 306, 929 114, 304, 115, -1, 40, 305, -1, 308, -1, 323, 930 174, -1, 327, 134, 208, 174, -1, 217, 174, -1, 931 225, 323, 174, -1, 228, 323, 174, -1, 232, 323, 932 174, -1, 232, 228, 323, 174, -1, 225, 327, 134, 933 208, 174, -1, 228, 327, 134, 208, 174, -1, 232, 934 327, 134, 208, 174, -1, 232, 228, 327, 134, 208, 935 174, -1, 318, -1, 331, -1, 323, -1, 164, 122, 936 164, -1, -1, 64, 109, 142, 110, 312, -1, -1, 937 313, -1, 314, -1, 313, 314, -1, 39, 109, 109, 938 315, 110, 110, -1, 316, -1, 315, 116, 316, -1, 939 -1, 317, -1, 317, 109, 171, 110, -1, 272, -1, 940 234, -1, 235, -1, 229, -1, 319, 312, -1, 320, 941 -1, 321, 312, -1, 322, 312, -1, 137, -1, 109, 942 319, 110, -1, 150, 318, -1, 150, 228, 318, -1, 943 109, 320, 110, -1, 319, 349, -1, 109, 320, 110, 944 349, -1, 109, 321, 110, 350, -1, 109, 321, 110, 945 -1, 109, 320, 110, 109, 134, 264, 135, 110, -1, 946 109, 322, 110, -1, 324, 312, -1, 325, -1, 326, 947 312, -1, 319, 109, 134, 264, 135, 110, -1, 109, 948 325, 110, 109, 134, 264, 135, 110, -1, 109, 324, 949 110, -1, 150, 323, -1, 150, 228, 323, -1, 109, 950 325, 110, -1, 109, 325, 110, 349, -1, 109, 326, 951 110, 350, -1, 109, 326, 110, -1, 328, -1, 329, 952 -1, 330, -1, 319, 109, 271, 110, -1, 109, 329, 953 110, 109, 271, 110, -1, 109, 328, 110, -1, 150, 954 327, -1, 150, 228, 327, -1, 109, 329, 110, -1, 955 109, 329, 110, 349, -1, 109, 330, 110, 350, -1, 956 109, 330, 110, -1, 332, 312, -1, 333, -1, 334, 957 312, -1, 335, 312, -1, 341, -1, 109, 332, 110, 958 -1, 150, 331, -1, 150, 228, 331, -1, 109, 333, 959 110, -1, 332, 349, -1, 109, 333, 110, 349, -1, 960 109, 334, 110, 350, -1, 109, 334, 110, -1, 332, 961 109, 134, 264, 135, 110, -1, 109, 333, 110, 109, 962 134, 264, 135, 110, -1, 109, 335, 110, -1, 319, 963 312, -1, 337, -1, 338, 312, -1, 339, 312, -1, 964 150, 336, -1, 150, 228, 336, -1, 109, 337, 110, 965 -1, 319, 355, -1, 109, 337, 110, 349, -1, 109, 966 338, 110, 350, -1, 109, 338, 110, -1, 319, 109, 967 134, 264, 135, 110, -1, 109, 337, 110, 109, 134, 968 264, 135, 110, -1, 109, 339, 110, -1, 341, 312, 969 -1, 342, -1, 343, 312, -1, 344, 312, -1, 74, 970 -1, 75, -1, 150, 340, -1, 150, 228, 340, -1, 971 109, 342, 110, -1, 341, 355, -1, 109, 342, 110, 972 355, -1, 341, 109, 134, 264, 135, 110, -1, 109, 973 342, 110, 109, 134, 264, 135, 110, -1, 346, -1, 974 347, 312, -1, 348, 312, -1, 150, -1, 150, 228, 975 -1, 150, 345, -1, 150, 228, 345, -1, 109, 346, 976 110, -1, 349, -1, 109, 346, 110, 349, -1, 109, 977 347, 110, 350, -1, 109, 347, 110, -1, 109, 134, 978 264, 135, 110, -1, 109, 346, 110, 109, 134, 264, 979 135, 110, -1, 109, 348, 110, -1, 111, 112, -1, 980 111, 112, 350, -1, 350, -1, 111, 134, 165, 135, 981 112, -1, 111, 134, 117, 135, 112, -1, 350, 111, 982 134, 165, 135, 112, -1, 350, 111, 134, 117, 135, 983 112, -1, 352, -1, 353, 312, -1, 354, 312, -1, 984 150, -1, 150, 228, -1, 150, 351, -1, 150, 228, 985 351, -1, 109, 352, 110, -1, 355, -1, 109, 352, 986 110, 355, -1, 109, 353, 110, 350, -1, 109, 353, 987 110, -1, 109, 134, 264, 135, 110, -1, 109, 352, 988 110, 109, 134, 264, 135, 110, -1, 109, 354, 110, 989 -1, 356, -1, 356, 350, -1, 350, -1, 111, 112, 990 -1, 111, 134, 228, 117, 135, 112, -1, 111, 134, 991 228, 135, 112, -1, 111, 134, 228, 165, 135, 112, 992 -1, 111, 134, 7, 227, 165, 135, 112, -1, 111, 993 134, 228, 7, 165, 135, 112, -1, 358, -1, 359, 994 312, -1, 360, 312, -1, 150, -1, 150, 228, -1, 995 150, 357, -1, 150, 228, 357, -1, 109, 358, 110, 996 -1, 349, -1, 109, 358, 110, 349, -1, 109, 359, 997 110, 350, -1, 109, 359, 110, -1, 109, 358, 110, 998 109, 134, 264, 135, 110, -1, 109, 360, 110, -1, 999 362, -1, 370, -1, 228, 370, -1, 363, -1, 364, 1000 -1, 150, 226, -1, 228, 150, 226, -1, 150, 371, 1001 -1, 228, 150, 371, -1, 150, 361, -1, 228, 150, 1002 361, -1, 111, 112, 226, -1, 365, 226, -1, 111, 1003 112, 350, 226, -1, 365, 350, 226, -1, 350, 226, 1004 -1, 111, 112, 363, -1, 365, 363, -1, 111, 112, 1005 350, 363, -1, 365, 350, 363, -1, 350, 363, -1, 1006 111, 134, 228, 117, 135, 112, -1, 111, 134, 228, 1007 165, 135, 112, -1, 111, 134, 232, 165, 135, 112, 1008 -1, 111, 134, 232, 228, 165, 135, 112, -1, 370, 1009 -1, 228, 370, -1, 367, -1, 368, -1, 369, -1, 1010 150, 226, -1, 228, 150, 226, -1, 150, 371, -1, 1011 228, 150, 371, -1, 150, 366, -1, 228, 150, 366, 1012 -1, 111, 112, 226, -1, 111, 112, 350, 226, -1, 1013 350, 226, -1, 111, 112, 368, -1, 111, 112, 350, 1014 368, -1, 350, 368, -1, 111, 134, 263, 135, 112, 1015 -1, 111, 112, 109, 260, 110, -1, 370, 109, 134, 1016 260, 135, 110, -1, 219, 109, 134, 260, 135, 110, 1017 -1, -1, 116, -1, -1, 131, 165, -1 754 147, 135, 112, -1, 144, 113, 79, -1, 144, 85, 755 139, -1, 144, 85, 111, 134, 147, 135, 112, -1, 756 144, 86, -1, 144, 87, -1, 109, 276, 110, 114, 757 280, 373, 115, -1, 144, 114, 145, 115, -1, 146, 758 -1, 145, 116, 146, -1, -1, 166, -1, 148, -1, 759 147, 116, 148, -1, 149, -1, 149, 113, 148, -1, 760 149, 113, 111, 134, 147, 135, 112, -1, 149, 85, 761 148, -1, 149, 85, 111, 134, 147, 135, 112, -1, 762 139, -1, 79, -1, 144, -1, 136, -1, 141, -1, 763 40, 153, -1, 151, 153, -1, 152, 153, -1, 86, 764 150, -1, 87, 150, -1, 37, 150, -1, 37, 109, 765 276, 110, -1, 66, 150, -1, 66, 109, 276, 110, 766 -1, 38, 109, 276, 116, 139, 110, -1, 76, -1, 767 76, 109, 146, 110, -1, 76, 109, 277, 110, -1, 768 117, -1, 118, -1, 119, -1, 120, -1, 121, -1, 769 122, -1, 150, -1, 109, 276, 110, 153, -1, 109, 770 276, 110, 169, -1, 153, -1, 154, 117, 153, -1, 771 154, 123, 153, -1, 154, 124, 153, -1, 154, -1, 772 155, 119, 154, -1, 155, 120, 154, -1, 155, -1, 773 156, 88, 155, -1, 156, 89, 155, -1, 156, -1, 774 157, 125, 156, -1, 157, 126, 156, -1, 157, 90, 775 156, -1, 157, 91, 156, -1, 157, -1, 158, 92, 776 157, -1, 158, 93, 157, -1, 158, -1, 159, 118, 777 158, -1, 159, -1, 160, 127, 159, -1, 160, -1, 778 161, 128, 160, -1, 161, -1, 162, 94, 161, -1, 779 162, -1, 163, 95, 162, -1, 163, -1, 163, 129, 780 171, 130, 164, -1, 163, 129, 130, 164, -1, 163, 781 129, 171, 130, 169, -1, 164, -1, 164, -1, 150, 782 168, 166, -1, 169, 374, -1, -1, 166, -1, 131, 783 -1, 107, -1, 97, -1, 98, -1, 99, -1, 100, 784 -1, 101, -1, 102, -1, 103, -1, 104, -1, 105, 785 -1, 106, -1, 111, 112, -1, 111, 134, 166, 135, 786 112, -1, 111, 134, 116, 170, 135, 112, -1, 111, 787 134, 166, 116, 170, 135, 112, -1, 167, -1, 170, 788 116, 167, -1, 166, -1, 171, 116, 166, -1, -1, 789 171, -1, 174, -1, 175, -1, 179, -1, 180, -1, 790 192, -1, 194, -1, 195, -1, 200, -1, 127, 144, 791 114, 145, 115, 132, -1, 72, 130, 313, 173, -1, 792 114, 115, -1, 114, 134, 134, 211, 176, 135, 115, 793 -1, 177, -1, 176, 134, 177, -1, 214, -1, 40, 794 214, -1, 309, -1, 173, 135, -1, 173, -1, 178, 795 173, -1, 172, 132, -1, 41, 109, 171, 110, 173, 796 -1, 41, 109, 171, 110, 173, 42, 173, -1, 43, 797 109, 171, 110, 185, -1, 43, 109, 171, 110, 114, 798 134, 207, 186, 115, -1, 53, 109, 171, 110, 185, 799 -1, 53, 109, 171, 110, 114, 134, 207, 188, 115, 800 -1, 165, -1, 165, 96, 165, -1, 311, -1, 181, 801 -1, 182, 116, 181, -1, 44, 182, 130, -1, 45, 802 130, -1, 183, -1, 184, 183, -1, 184, 173, -1, 803 -1, 187, -1, 184, 178, -1, 187, 184, 178, -1, 804 -1, 189, -1, 184, 191, -1, 184, 178, 190, -1, 805 189, 184, 191, -1, 189, 184, 178, 190, -1, -1, 806 191, -1, 56, -1, 56, 132, -1, 47, 109, 171, 807 110, 173, -1, 46, 173, 47, 109, 171, 110, 132, 808 -1, 48, 109, 134, 193, 110, 173, -1, 172, 135, 809 132, 172, 132, 172, -1, 214, 172, 132, 172, -1, 810 51, 72, 132, -1, 51, 117, 171, 132, -1, 50, 811 132, -1, 50, 72, 132, -1, 49, 132, -1, 49, 812 72, 132, -1, 52, 172, 132, -1, 61, 167, 132, 813 -1, 62, 167, 132, -1, 62, 167, 63, 166, 132, 814 -1, 57, 175, 196, -1, 57, 175, 198, -1, 57, 815 175, 196, 198, -1, 197, -1, 58, 109, 96, 110, 816 175, -1, 197, 58, 109, 96, 110, 175, -1, 59, 817 109, 96, 110, 175, -1, 197, 59, 109, 96, 110, 818 175, -1, 58, 109, 134, 134, 199, 135, 110, 175, 819 135, -1, 197, 58, 109, 134, 134, 199, 135, 110, 820 175, 135, -1, 59, 109, 134, 134, 199, 135, 110, 821 175, 135, -1, 197, 59, 109, 134, 134, 199, 135, 822 110, 175, 135, -1, 60, 175, -1, 227, -1, 227, 823 310, -1, 227, 358, -1, 367, 139, -1, 367, -1, 824 64, 201, 109, 141, 110, 132, -1, 64, 201, 109, 825 141, 130, 202, 110, 132, -1, 64, 201, 109, 141, 826 130, 202, 130, 202, 110, 132, -1, 64, 201, 109, 827 141, 130, 202, 130, 202, 130, 205, 110, 132, -1, 828 64, 201, 51, 109, 141, 130, 130, 202, 130, 205, 829 130, 206, 110, 132, -1, -1, 11, -1, -1, 203, 830 -1, 204, -1, 203, 116, 204, -1, 141, 109, 165, 831 110, -1, 111, 165, 112, 141, 109, 165, 110, -1, 832 -1, 141, -1, 205, 116, 141, -1, 139, -1, 206, 833 116, 139, -1, 135, -1, 208, -1, 214, -1, 208, 834 134, 214, -1, 135, -1, 210, -1, 224, -1, 210, 835 134, 224, -1, -1, 212, -1, 29, 213, 132, -1, 836 212, 29, 213, 132, -1, 275, -1, 213, 116, 275, 837 -1, 215, -1, 224, -1, 216, 135, 132, -1, 221, 838 135, 132, -1, 218, 135, 132, -1, 294, 135, 132, 839 -1, 297, 135, 132, -1, 217, 278, -1, 233, 217, 840 278, -1, 216, 135, 116, 134, 273, 278, -1, 368, 841 273, 312, -1, 371, 273, 312, -1, 229, 371, 273, 842 312, -1, 219, -1, 229, 219, -1, 233, 219, -1, 843 233, 229, 219, -1, 218, 135, 116, 134, 273, -1, 844 111, 112, 273, 109, 134, 261, 135, 110, -1, 371, 845 273, 109, 134, 261, 135, 110, -1, 220, 273, 109, 846 134, 261, 135, 110, -1, 111, 134, 263, 135, 112, 847 -1, 111, 134, 263, 135, 116, 134, 264, 135, 112, 848 -1, 3, 217, -1, 3, 219, -1, 221, 135, 116, 849 134, 139, -1, 3, 227, 310, -1, 222, 135, 116, 850 134, 310, -1, 229, 3, 227, 310, -1, 227, 3, 851 310, -1, 227, 3, 229, 310, -1, 3, 139, 131, 852 166, -1, 223, 135, 116, 134, 139, 131, 166, -1, 853 225, 135, 132, -1, 222, 135, 132, -1, 223, 135, 854 132, -1, 241, 135, 132, -1, 226, 310, 312, 278, 855 -1, 225, 116, 313, 310, 312, 278, -1, 237, -1, 856 241, -1, 243, -1, 284, -1, 238, -1, 242, -1, 857 244, -1, 285, -1, -1, 229, -1, 230, -1, 229, 858 230, -1, 231, -1, 315, -1, 10, -1, 12, -1, 859 11, -1, 14, -1, 67, -1, -1, 13, 109, 232, 860 287, 110, -1, 234, -1, 229, 234, -1, 233, 229, 861 234, -1, 235, -1, 234, 235, -1, 5, -1, 7, 862 -1, 4, -1, 6, -1, 8, -1, 9, -1, 69, 863 -1, 71, -1, 16, -1, 21, -1, 20, -1, 18, 864 -1, 19, -1, 17, -1, 22, -1, 23, -1, 15, 865 -1, 25, -1, 26, -1, 27, -1, 24, -1, 238, 866 -1, 233, 238, -1, 237, 235, -1, 237, 235, 229, 867 -1, 237, 235, 238, -1, 239, -1, 228, 240, 228, 868 -1, 236, -1, 229, 236, -1, 239, 230, -1, 239, 869 236, -1, 28, 109, 277, 110, -1, 28, 109, 171, 870 110, -1, 78, 109, 277, 110, -1, 78, 109, 171, 871 110, -1, 242, -1, 233, 242, -1, 241, 235, -1, 872 241, 235, 229, -1, 245, -1, 229, 245, -1, 242, 873 230, -1, 244, -1, 233, 244, -1, 243, 235, -1, 874 243, 235, 229, -1, 74, -1, 229, 74, -1, 244, 875 230, -1, 246, -1, 257, -1, 248, 114, 249, 115, 876 -1, 248, 275, -1, -1, 248, 275, 247, 114, 249, 877 115, -1, 248, 109, 293, 110, 114, 249, 115, -1, 878 248, 286, -1, 31, 313, -1, 32, 313, -1, -1, 879 249, 250, -1, 251, 132, -1, 40, 251, 132, -1, 880 252, 132, -1, 40, 252, 132, -1, 367, -1, 367, 881 275, -1, 251, 116, 275, -1, 251, 116, -1, 227, 882 253, -1, 252, 116, 313, 253, -1, -1, 255, -1, 883 319, 254, -1, 332, 254, -1, 358, -1, -1, 255, 884 -1, 130, 165, -1, 30, 313, -1, 256, 114, 259, 885 373, 115, -1, 256, 275, -1, -1, 256, 275, 258, 886 114, 259, 373, 115, -1, 275, 260, -1, 259, 116, 887 275, 260, -1, -1, 131, 165, -1, -1, 262, -1, 888 264, -1, 263, -1, 263, 135, 116, 134, 264, -1, 889 264, 135, 116, 134, 96, -1, 263, 135, 116, 134, 890 96, -1, 268, -1, 264, 135, 116, 134, 268, -1, 891 263, 135, 116, 134, 268, -1, 263, 135, 116, 134, 892 264, 135, 116, 134, 268, -1, 269, -1, 264, 135, 893 116, 134, 269, -1, -1, 266, -1, 267, -1, 267, 894 135, 116, 134, 96, -1, 271, -1, 270, -1, 267, 895 135, 116, 134, 271, -1, 267, 135, 116, 134, 270, 896 -1, 270, -1, 363, 273, 374, -1, 371, 273, 374, 897 -1, 229, 371, 273, 374, -1, 219, -1, 271, -1, 898 363, -1, 371, -1, 229, 371, -1, 372, -1, 226, 899 337, 374, -1, 226, 341, 374, -1, 226, -1, 226, 900 352, -1, 139, -1, 272, 116, 139, -1, 137, -1, 901 74, -1, 75, -1, 138, -1, 74, -1, 75, -1, 902 139, -1, 74, -1, 75, -1, 367, -1, 227, -1, 903 227, 358, -1, 367, -1, 372, -1, 227, -1, 227, 904 346, -1, -1, 131, 279, -1, 107, 279, -1, 166, 905 -1, 114, 280, 373, 115, -1, -1, 279, -1, 281, 906 279, -1, 280, 116, 279, -1, 280, 116, 281, 279, 907 -1, 282, 130, -1, 275, 130, -1, 283, -1, 282, 908 283, -1, 113, 275, -1, 111, 134, 166, 135, 112, 909 -1, 111, 134, 311, 135, 112, -1, 111, 134, 165, 910 96, 165, 135, 112, -1, 113, 111, 134, 147, 135, 911 112, -1, 285, -1, 233, 285, -1, 284, 235, -1, 912 284, 235, 229, -1, 286, -1, 229, 286, -1, 285, 913 230, -1, 75, 109, 293, 110, -1, 288, 374, -1, 914 287, 116, 288, 374, -1, -1, 290, 275, 289, 291, 915 -1, 227, 337, -1, 33, -1, 35, -1, 34, -1, 916 -1, 291, 292, -1, 128, 275, 109, 293, 110, -1, 917 128, 114, 134, 299, 115, -1, 128, 109, 134, 287, 918 135, 110, 114, 134, 299, 115, 109, 293, 110, -1, 919 277, -1, 166, -1, 293, 116, 277, -1, 293, 116, 920 166, -1, 33, 295, -1, 234, 33, 295, -1, 294, 921 116, 295, -1, 296, 291, -1, 296, 291, 131, 277, 922 -1, 275, -1, 274, 109, 134, 287, 135, 110, -1, 923 36, 275, 109, 134, 287, 135, 110, 114, 115, -1, 924 -1, 36, 275, 109, 134, 287, 135, 110, 114, 298, 925 299, 115, -1, 300, -1, 299, 134, 300, -1, 301, 926 135, 132, -1, 302, 135, 132, -1, 217, -1, 219, 927 -1, 301, 135, 116, 134, 273, -1, 227, 310, -1, 928 302, 135, 116, 134, 310, -1, -1, 304, -1, 306, 929 -1, 304, 134, 306, -1, -1, 304, -1, 214, -1, 930 308, -1, 200, -1, -1, 5, 82, 307, 114, 305, 931 115, -1, 40, 306, -1, 309, -1, 324, 175, -1, 932 328, 134, 209, 175, -1, 218, 175, -1, 226, 324, 933 175, -1, 229, 324, 175, -1, 233, 324, 175, -1, 934 233, 229, 324, 175, -1, 226, 328, 134, 209, 175, 935 -1, 229, 328, 134, 209, 175, -1, 233, 328, 134, 936 209, 175, -1, 233, 229, 328, 134, 209, 175, -1, 937 319, -1, 332, -1, 324, -1, 165, 122, 165, -1, 938 -1, 64, 109, 142, 110, 313, -1, -1, 314, -1, 939 315, -1, 314, 315, -1, 39, 109, 109, 316, 110, 940 110, -1, 317, -1, 316, 116, 317, -1, -1, 318, 941 -1, 318, 109, 172, 110, -1, 273, -1, 235, -1, 942 236, -1, 230, -1, 320, 313, -1, 321, -1, 322, 943 313, -1, 323, 313, -1, 137, -1, 109, 320, 110, 944 -1, 151, 319, -1, 151, 229, 319, -1, 109, 321, 945 110, -1, 320, 350, -1, 109, 321, 110, 350, -1, 946 109, 322, 110, 351, -1, 109, 322, 110, -1, 109, 947 321, 110, 109, 134, 265, 135, 110, -1, 109, 323, 948 110, -1, 325, 313, -1, 326, -1, 327, 313, -1, 949 320, 109, 134, 265, 135, 110, -1, 109, 326, 110, 950 109, 134, 265, 135, 110, -1, 109, 325, 110, -1, 951 151, 324, -1, 151, 229, 324, -1, 109, 326, 110, 952 -1, 109, 326, 110, 350, -1, 109, 327, 110, 351, 953 -1, 109, 327, 110, -1, 329, -1, 330, -1, 331, 954 -1, 320, 109, 272, 110, -1, 109, 330, 110, 109, 955 272, 110, -1, 109, 329, 110, -1, 151, 328, -1, 956 151, 229, 328, -1, 109, 330, 110, -1, 109, 330, 957 110, 350, -1, 109, 331, 110, 351, -1, 109, 331, 958 110, -1, 333, 313, -1, 334, -1, 335, 313, -1, 959 336, 313, -1, 342, -1, 109, 333, 110, -1, 151, 960 332, -1, 151, 229, 332, -1, 109, 334, 110, -1, 961 333, 350, -1, 109, 334, 110, 350, -1, 109, 335, 962 110, 351, -1, 109, 335, 110, -1, 333, 109, 134, 963 265, 135, 110, -1, 109, 334, 110, 109, 134, 265, 964 135, 110, -1, 109, 336, 110, -1, 320, 313, -1, 965 338, -1, 339, 313, -1, 340, 313, -1, 151, 337, 966 -1, 151, 229, 337, -1, 109, 338, 110, -1, 320, 967 356, -1, 109, 338, 110, 350, -1, 109, 339, 110, 968 351, -1, 109, 339, 110, -1, 320, 109, 134, 265, 969 135, 110, -1, 109, 338, 110, 109, 134, 265, 135, 970 110, -1, 109, 340, 110, -1, 342, 313, -1, 343, 971 -1, 344, 313, -1, 345, 313, -1, 74, -1, 75, 972 -1, 151, 341, -1, 151, 229, 341, -1, 109, 343, 973 110, -1, 342, 356, -1, 109, 343, 110, 356, -1, 974 342, 109, 134, 265, 135, 110, -1, 109, 343, 110, 975 109, 134, 265, 135, 110, -1, 347, -1, 348, 313, 976 -1, 349, 313, -1, 151, -1, 151, 229, -1, 151, 977 346, -1, 151, 229, 346, -1, 109, 347, 110, -1, 978 350, -1, 109, 347, 110, 350, -1, 109, 348, 110, 979 351, -1, 109, 348, 110, -1, 109, 134, 265, 135, 980 110, -1, 109, 347, 110, 109, 134, 265, 135, 110, 981 -1, 109, 349, 110, -1, 111, 112, -1, 111, 112, 982 351, -1, 351, -1, 111, 134, 166, 135, 112, -1, 983 111, 134, 117, 135, 112, -1, 351, 111, 134, 166, 984 135, 112, -1, 351, 111, 134, 117, 135, 112, -1, 985 353, -1, 354, 313, -1, 355, 313, -1, 151, -1, 986 151, 229, -1, 151, 352, -1, 151, 229, 352, -1, 987 109, 353, 110, -1, 356, -1, 109, 353, 110, 356, 988 -1, 109, 354, 110, 351, -1, 109, 354, 110, -1, 989 109, 134, 265, 135, 110, -1, 109, 353, 110, 109, 990 134, 265, 135, 110, -1, 109, 355, 110, -1, 357, 991 -1, 357, 351, -1, 351, -1, 111, 112, -1, 111, 992 134, 229, 117, 135, 112, -1, 111, 134, 229, 135, 993 112, -1, 111, 134, 229, 166, 135, 112, -1, 111, 994 134, 7, 228, 166, 135, 112, -1, 111, 134, 229, 995 7, 166, 135, 112, -1, 359, -1, 360, 313, -1, 996 361, 313, -1, 151, -1, 151, 229, -1, 151, 358, 997 -1, 151, 229, 358, -1, 109, 359, 110, -1, 350, 998 -1, 109, 359, 110, 350, -1, 109, 360, 110, 351, 999 -1, 109, 360, 110, -1, 109, 359, 110, 109, 134, 1000 265, 135, 110, -1, 109, 361, 110, -1, 363, -1, 1001 371, -1, 229, 371, -1, 364, -1, 365, -1, 151, 1002 227, -1, 229, 151, 227, -1, 151, 372, -1, 229, 1003 151, 372, -1, 151, 362, -1, 229, 151, 362, -1, 1004 111, 112, 227, -1, 366, 227, -1, 111, 112, 351, 1005 227, -1, 366, 351, 227, -1, 351, 227, -1, 111, 1006 112, 364, -1, 366, 364, -1, 111, 112, 351, 364, 1007 -1, 366, 351, 364, -1, 351, 364, -1, 111, 134, 1008 229, 117, 135, 112, -1, 111, 134, 229, 166, 135, 1009 112, -1, 111, 134, 233, 166, 135, 112, -1, 111, 1010 134, 233, 229, 166, 135, 112, -1, 371, -1, 229, 1011 371, -1, 368, -1, 369, -1, 370, -1, 151, 227, 1012 -1, 229, 151, 227, -1, 151, 372, -1, 229, 151, 1013 372, -1, 151, 367, -1, 229, 151, 367, -1, 111, 1014 112, 227, -1, 111, 112, 351, 227, -1, 351, 227, 1015 -1, 111, 112, 369, -1, 111, 112, 351, 369, -1, 1016 351, 369, -1, 111, 134, 264, 135, 112, -1, 111, 1017 112, 109, 261, 110, -1, 371, 109, 134, 261, 135, 1018 110, -1, 220, 109, 134, 261, 135, 110, -1, -1, 1019 116, -1, -1, 131, 166, -1 1018 1020 }; 1019 1021 … … 1021 1023 static const yytype_uint16 yyrline[] = 1022 1024 { 1023 0, 30 0, 300, 304, 311, 312, 313, 317, 318, 319,1024 32 3, 324, 328, 329, 333, 334, 338, 342, 343, 354,1025 35 6, 358, 360, 365, 366, 372, 376, 378, 380, 382,1026 38 4, 386, 388, 390, 399, 400, 406, 407, 411, 412,1027 416, 420, 42 2, 424, 426, 431, 434, 436, 438, 443,1028 4 56, 458, 460, 462, 464, 466, 468, 470, 472, 474,1029 47 6, 483, 484, 490, 491, 492, 493, 497, 498, 500,1030 50 5, 506, 508, 510, 515, 516, 518, 523, 524, 526,1031 53 1, 532, 534, 536, 538, 543, 544, 546, 551, 552,1032 55 7, 558, 563, 564, 569, 570, 575, 576, 581, 582,1033 585, 5 87, 592, 597, 598, 600, 606, 607, 611, 612,1034 61 3, 614, 615, 616, 617, 618, 619, 620, 621, 622,1035 62 8, 630, 632, 634, 639, 640, 645, 646, 652, 653,1036 65 9, 660, 661, 662, 663, 664, 665, 666, 667, 677,1037 6 84, 686, 696, 697, 702, 704, 710, 712, 716, 717,1038 72 2, 727, 730, 732, 734, 744, 746, 757, 758, 760,1039 76 4, 766, 770, 771, 776, 777, 781, 786, 787, 791,1040 79 3, 799, 800, 804, 806, 808, 810, 816, 817, 821,1041 82 3, 828, 830, 832, 837, 839, 844, 846, 850, 853,1042 85 7, 860, 864, 866, 868, 870, 875, 877, 879, 884,1043 886, 888, 89 0, 892, 897, 899, 901, 903, 908, 920,1044 9 21, 926, 928, 933, 937, 939, 941, 943, 945, 951,1045 952, 95 8, 959, 963, 964, 969, 971, 977, 978, 980,1046 98 5, 990, 1000, 1002, 1006, 1007, 1012, 1014, 1018, 1019,1047 1023, 102 5, 1029, 1030, 1034, 1035, 1039, 1040, 1055, 1056,1048 10 57, 1058, 1059, 1063, 1068, 1075, 1085, 1090, 1095, 1103,1049 1 108, 1113, 1118, 1123, 1131, 1153, 1158, 1165, 1167, 1174,1050 117 9, 1184, 1195, 1200, 1205, 1210, 1215, 1224, 1229, 1237,1051 123 8, 1239, 1240, 1246, 1251, 1259, 1260, 1261, 1262, 1266,1052 12 67, 1268, 1269, 1274, 1275, 1284, 1285, 1290, 1291, 1296,1053 129 8, 1300, 1302, 1304, 1307, 1306, 1318, 1319, 1321, 1331,1054 13 32, 1337, 1339, 1341, 1343, 1345, 1348, 1350, 1353, 1358,1055 13 60, 1362, 1364, 1366, 1368, 1370, 1372, 1374, 1376, 1378,1056 138 0, 1382, 1388, 1389, 1391, 1393, 1395, 1400, 1401, 1407,1057 140 8, 1410, 1412, 1417, 1419, 1421, 1423, 1428, 1429, 1431,1058 143 3, 1438, 1439, 1441, 1446, 1447, 1449, 1451, 1456, 1458,1059 1460, 1465, 146 6, 1470, 1472, 1478, 1477, 1481, 1483, 1488,1060 1490, 149 6, 1497, 1502, 1503, 1505, 1506, 1515, 1516, 1518,1061 152 0, 1525, 1527, 1533, 1534, 1536, 1539, 1542, 1547, 1548,1062 155 3, 1558, 1562, 1564, 1570, 1569, 1576, 1578, 1584, 1585,1063 15 93, 1594, 1598, 1599, 1600, 1602, 1604, 1611, 1612, 1614,1064 16 16, 1621, 1622, 1628, 1629, 1633, 1634, 1639, 1640, 1641,1065 164 3, 1651, 1652, 1654, 1657, 1659, 1663, 1664, 1665, 1667,1066 16 69, 1673, 1678, 1686, 1687, 1696, 1698, 1703, 1704, 1705,1067 17 09, 1710, 1711, 1715, 1716, 1717, 1721, 1722, 1723, 1728,1068 17 29, 1730, 1731, 1737, 1738, 1740, 1745, 1746, 1751, 1752,1069 175 3, 1754, 1755, 1770, 1771, 1776, 1777, 1783, 1785, 1788,1070 179 0, 1792, 1815, 1816, 1818, 1820, 1825, 1826, 1828, 1833,1071 183 8, 1839, 1845, 1844, 1848, 1852, 1854, 1856, 1862, 1863,1072 186 8, 1873, 1875, 1880, 1882, 1883, 1885, 1890, 1892, 1894,1073 1899, 1901, 190 6, 1911, 1919, 1925, 1924, 1938, 1939, 1944,1074 194 5, 1949, 1954, 1959, 1967, 1972, 1983, 1984, 1989, 1990,1075 199 6, 1997, 2001, 2002, 2003, 2006, 2005, 2016, 2025, 2031,1076 20 37, 2046, 2052, 2058, 2064, 2070, 2078, 2084, 2092, 2098,1077 2 107, 2108, 2109, 2113, 2117, 2119, 2124, 2125, 2129, 2130,1078 213 5, 2141, 2142, 2145, 2147, 2148, 2152, 2153, 2154, 2155,1079 21 89, 2191, 2192, 2194, 2199, 2204, 2209, 2211, 2213, 2218,1080 2220, 2222, 222 4, 2229, 2231, 2240, 2242, 2243, 2248, 2250,1081 2252, 2257, 2259, 2261, 2266, 2268, 2270, 227 9, 2280, 2281,1082 228 5, 2287, 2289, 2294, 2296, 2298, 2303, 2305, 2307, 2322,1083 23 24, 2325, 2327, 2332, 2333, 2338, 2340, 2342, 2347, 2349,1084 2351, 235 3, 2358, 2360, 2362, 2372, 2374, 2375, 2377, 2382,1085 2384, 2386, 2391, 2393, 2395, 2 397, 2402, 2404, 2406, 2437,1086 24 39, 2440, 2442, 2447, 2452, 2460, 2462, 2464, 2469, 2471,1087 247 6, 2478, 2492, 2493, 2495, 2500, 2502, 2504, 2506, 2508,1088 2513, 251 4, 2516, 2518, 2523, 2525, 2527, 2533, 2535, 2537,1089 254 1, 2543, 2545, 2547, 2561, 2562, 2564, 2569, 2571, 2573,1090 257 5, 2577, 2582, 2583, 2585, 2587, 2592, 2594, 2596, 2602,1091 2603, 2605, 261 4, 2617, 2619, 2622, 2624, 2626, 2639, 2640,1092 26 42, 2647, 2649, 2651, 2653, 2655, 2660, 2661, 2663, 2665,1093 2670, 2672, 26 80, 2681, 2682, 2687, 2688, 2692, 2694, 2696,1094 2 698, 2700, 2702, 2709, 2711, 2713, 2715, 2717, 2719, 2721,1095 272 3, 2725, 2727, 2732, 2734, 2736, 2741, 2767, 2768, 2770,1096 277 4, 2775, 2779, 2781, 2783, 2785, 2787, 2789, 2796, 2798,1097 2 800, 2802, 2804, 2806, 2811, 2816, 2818, 2820, 2838, 2840,1098 28 45, 28461025 0, 302, 302, 306, 313, 314, 315, 319, 320, 321, 1026 325, 326, 330, 331, 335, 336, 340, 344, 345, 356, 1027 358, 360, 362, 367, 368, 374, 378, 380, 382, 384, 1028 386, 388, 390, 392, 394, 403, 404, 410, 411, 415, 1029 416, 420, 424, 426, 428, 430, 435, 436, 440, 443, 1030 445, 447, 452, 465, 467, 469, 471, 473, 475, 477, 1031 479, 481, 483, 485, 492, 493, 499, 500, 501, 502, 1032 506, 507, 509, 514, 515, 517, 519, 524, 525, 527, 1033 532, 533, 535, 540, 541, 543, 545, 547, 552, 553, 1034 555, 560, 561, 566, 567, 572, 573, 578, 579, 584, 1035 585, 590, 591, 594, 596, 601, 606, 607, 609, 615, 1036 616, 620, 621, 622, 623, 624, 625, 626, 627, 628, 1037 629, 630, 631, 637, 639, 641, 643, 648, 649, 654, 1038 655, 661, 662, 668, 669, 670, 671, 672, 673, 674, 1039 675, 676, 686, 693, 695, 705, 706, 711, 713, 719, 1040 721, 725, 726, 731, 736, 739, 741, 743, 753, 755, 1041 766, 767, 769, 773, 775, 779, 780, 785, 786, 790, 1042 795, 796, 800, 802, 808, 809, 813, 815, 817, 819, 1043 825, 826, 830, 832, 837, 839, 841, 846, 848, 853, 1044 855, 859, 862, 866, 869, 873, 875, 877, 879, 884, 1045 886, 888, 893, 895, 897, 899, 901, 906, 908, 910, 1046 912, 917, 929, 930, 935, 937, 942, 946, 948, 950, 1047 952, 954, 960, 961, 967, 968, 972, 973, 978, 980, 1048 986, 987, 989, 994, 999, 1009, 1011, 1015, 1016, 1021, 1049 1023, 1027, 1028, 1032, 1034, 1038, 1039, 1043, 1044, 1048, 1050 1049, 1064, 1065, 1066, 1067, 1068, 1072, 1077, 1084, 1094, 1051 1099, 1104, 1112, 1117, 1122, 1127, 1132, 1140, 1162, 1167, 1052 1174, 1176, 1183, 1188, 1193, 1204, 1209, 1214, 1219, 1224, 1053 1233, 1238, 1246, 1247, 1248, 1249, 1255, 1260, 1268, 1269, 1054 1270, 1271, 1275, 1276, 1277, 1278, 1283, 1284, 1293, 1294, 1055 1299, 1300, 1305, 1307, 1309, 1311, 1313, 1316, 1315, 1327, 1056 1328, 1330, 1340, 1341, 1346, 1348, 1350, 1352, 1354, 1357, 1057 1359, 1362, 1367, 1369, 1371, 1373, 1375, 1377, 1379, 1381, 1058 1383, 1385, 1387, 1389, 1391, 1397, 1398, 1400, 1402, 1404, 1059 1409, 1410, 1416, 1417, 1419, 1421, 1426, 1428, 1430, 1432, 1060 1437, 1438, 1440, 1442, 1447, 1448, 1450, 1455, 1456, 1458, 1061 1460, 1465, 1467, 1469, 1474, 1475, 1479, 1481, 1487, 1486, 1062 1490, 1492, 1497, 1499, 1505, 1506, 1511, 1512, 1514, 1515, 1063 1524, 1525, 1527, 1529, 1534, 1536, 1542, 1543, 1545, 1548, 1064 1551, 1556, 1557, 1562, 1567, 1571, 1573, 1579, 1578, 1585, 1065 1587, 1593, 1594, 1602, 1603, 1607, 1608, 1609, 1611, 1613, 1066 1620, 1621, 1623, 1625, 1630, 1631, 1637, 1638, 1642, 1643, 1067 1648, 1649, 1650, 1652, 1660, 1661, 1663, 1666, 1668, 1672, 1068 1673, 1674, 1676, 1678, 1682, 1687, 1695, 1696, 1705, 1707, 1069 1712, 1713, 1714, 1718, 1719, 1720, 1724, 1725, 1726, 1730, 1070 1731, 1732, 1737, 1738, 1739, 1740, 1746, 1747, 1749, 1754, 1071 1755, 1760, 1761, 1762, 1763, 1764, 1779, 1780, 1785, 1786, 1072 1792, 1794, 1797, 1799, 1801, 1824, 1825, 1827, 1829, 1834, 1073 1835, 1837, 1842, 1847, 1848, 1854, 1853, 1857, 1861, 1863, 1074 1865, 1871, 1872, 1877, 1882, 1884, 1889, 1891, 1892, 1894, 1075 1899, 1901, 1903, 1908, 1910, 1915, 1920, 1928, 1934, 1933, 1076 1947, 1948, 1953, 1954, 1958, 1963, 1968, 1976, 1981, 1992, 1077 1993, 1998, 1999, 2005, 2006, 2010, 2011, 2012, 2015, 2014, 1078 2025, 2034, 2040, 2046, 2055, 2061, 2067, 2073, 2079, 2087, 1079 2093, 2101, 2107, 2116, 2117, 2118, 2122, 2126, 2128, 2133, 1080 2134, 2138, 2139, 2144, 2150, 2151, 2154, 2156, 2157, 2161, 1081 2162, 2163, 2164, 2198, 2200, 2201, 2203, 2208, 2213, 2218, 1082 2220, 2222, 2227, 2229, 2231, 2233, 2238, 2240, 2249, 2251, 1083 2252, 2257, 2259, 2261, 2266, 2268, 2270, 2275, 2277, 2279, 1084 2288, 2289, 2290, 2294, 2296, 2298, 2303, 2305, 2307, 2312, 1085 2314, 2316, 2331, 2333, 2334, 2336, 2341, 2342, 2347, 2349, 1086 2351, 2356, 2358, 2360, 2362, 2367, 2369, 2371, 2381, 2383, 1087 2384, 2386, 2391, 2393, 2395, 2400, 2402, 2404, 2406, 2411, 1088 2413, 2415, 2446, 2448, 2449, 2451, 2456, 2461, 2469, 2471, 1089 2473, 2478, 2480, 2485, 2487, 2501, 2502, 2504, 2509, 2511, 1090 2513, 2515, 2517, 2522, 2523, 2525, 2527, 2532, 2534, 2536, 1091 2542, 2544, 2546, 2550, 2552, 2554, 2556, 2570, 2571, 2573, 1092 2578, 2580, 2582, 2584, 2586, 2591, 2592, 2594, 2596, 2601, 1093 2603, 2605, 2611, 2612, 2614, 2623, 2626, 2628, 2631, 2633, 1094 2635, 2648, 2649, 2651, 2656, 2658, 2660, 2662, 2664, 2669, 1095 2670, 2672, 2674, 2679, 2681, 2689, 2690, 2691, 2696, 2697, 1096 2701, 2703, 2705, 2707, 2709, 2711, 2718, 2720, 2722, 2724, 1097 2726, 2728, 2730, 2732, 2734, 2736, 2741, 2743, 2745, 2750, 1098 2776, 2777, 2779, 2783, 2784, 2788, 2790, 2792, 2794, 2796, 1099 2798, 2805, 2807, 2809, 2811, 2813, 2815, 2820, 2825, 2827, 1100 2829, 2847, 2849, 2854, 2855 1099 1101 }; 1100 1102 #endif … … 1128 1130 "string_literal", "string_literal_list", "primary_expression", 1129 1131 "postfix_expression", "argument_expression_list", "argument_expression", 1130 "field_list", "field", " unary_expression", "ptrref_operator",1131 " unary_operator", "cast_expression", "multiplicative_expression",1132 " additive_expression", "shift_expression", "relational_expression",1133 " equality_expression", "AND_expression", "exclusive_OR_expression",1134 " inclusive_OR_expression", "logical_AND_expression",1135 "logical_ OR_expression", "conditional_expression", "constant_expression",1136 " assignment_expression", "assignment_expression_opt",1137 "assignment_ operator", "tuple", "tuple_expression_list",1138 " comma_expression", "comma_expression_opt", "statement",1139 " labeled_statement", "compound_statement", "block_item_list",1140 "block_item ", "statement_list", "expression_statement",1141 " selection_statement", "case_value", "case_value_list", "case_label",1142 "case_ label_list", "case_clause", "switch_clause_list_opt",1143 "switch_clause_list ", "choose_clause_list_opt", "choose_clause_list",1144 " fall_through_opt", "fall_through", "iteration_statement",1145 " for_control_expression", "jump_statement", "exception_statement",1146 " handler_list", "handler_clause", "finally_clause",1147 " exception_declaration", "asm_statement", "asm_volatile_opt",1148 "asm_ operands_opt", "asm_operands_list", "asm_operand",1149 "asm_ clobbers_list_opt", "label_list", "declaration_list_opt",1150 "declaration_list ", "old_declaration_list_opt", "old_declaration_list",1151 " local_label_declaration_opt", "local_label_declaration_list",1152 "local_label_ list", "declaration", "new_declaration",1153 "new_ variable_declaration", "new_variable_specifier",1132 "field_list", "field", "field_name", "unary_expression", 1133 "ptrref_operator", "unary_operator", "cast_expression", 1134 "multiplicative_expression", "additive_expression", "shift_expression", 1135 "relational_expression", "equality_expression", "AND_expression", 1136 "exclusive_OR_expression", "inclusive_OR_expression", 1137 "logical_AND_expression", "logical_OR_expression", 1138 "conditional_expression", "constant_expression", "assignment_expression", 1139 "assignment_expression_opt", "assignment_operator", "tuple", 1140 "tuple_expression_list", "comma_expression", "comma_expression_opt", 1141 "statement", "labeled_statement", "compound_statement", 1142 "block_item_list", "block_item", "statement_list", 1143 "expression_statement", "selection_statement", "case_value", 1144 "case_value_list", "case_label", "case_label_list", "case_clause", 1145 "switch_clause_list_opt", "switch_clause_list", "choose_clause_list_opt", 1146 "choose_clause_list", "fall_through_opt", "fall_through", 1147 "iteration_statement", "for_control_expression", "jump_statement", 1148 "exception_statement", "handler_list", "handler_clause", 1149 "finally_clause", "exception_declaration", "asm_statement", 1150 "asm_volatile_opt", "asm_operands_opt", "asm_operands_list", 1151 "asm_operand", "asm_clobbers_list_opt", "label_list", 1152 "declaration_list_opt", "declaration_list", "old_declaration_list_opt", 1153 "old_declaration_list", "local_label_declaration_opt", 1154 "local_label_declaration_list", "local_label_list", "declaration", 1155 "new_declaration", "new_variable_declaration", "new_variable_specifier", 1154 1156 "new_function_declaration", "new_function_specifier", 1155 1157 "new_function_return", "new_typedef_declaration", "typedef_declaration", … … 1241 1243 138, 138, 139, 139, 140, 140, 141, 142, 142, 143, 1242 1244 143, 143, 143, 144, 144, 144, 144, 144, 144, 144, 1243 144, 144, 144, 144, 14 5, 145, 146, 146, 147, 147,1244 14 8, 148, 148, 148, 148, 149, 149, 149, 149, 149,1245 1 49, 149, 149, 149, 149, 149, 149, 149, 149, 149,1246 1 49, 150, 150, 151, 151, 151, 151, 152, 152, 152,1247 153, 153, 153, 15 3, 154, 154, 154, 155, 155, 155,1248 156, 156, 156, 15 6, 156, 157, 157, 157, 158, 158,1249 15 9, 159, 160, 160, 161, 161, 162, 162, 163, 163,1250 163, 16 3, 164, 165, 165, 165, 166, 166, 167, 167,1251 167, 16 7, 167, 167, 167, 167, 167, 167, 167, 167,1252 168, 168, 168, 16 8, 169, 169, 170, 170, 171, 171,1253 17 2, 172, 172, 172, 172, 172, 172, 172, 172, 173,1254 17 4, 174, 175, 175, 176, 176, 176, 176, 177, 177,1255 17 8, 179, 179, 179, 179, 179, 179, 180, 180, 180,1256 181, 181, 18 2, 182, 183, 183, 184, 185, 185, 186,1257 186, 18 7, 187, 188, 188, 188, 188, 189, 189, 190,1258 190, 19 1, 191, 191, 192, 192, 193, 193, 193, 193,1259 19 3, 193, 193, 193, 193, 193, 194, 194, 194, 195,1260 195, 195, 19 5, 195, 196, 196, 196, 196, 197, 198,1261 19 8, 198, 198, 198, 199, 199, 199, 199, 199, 200,1262 200, 20 1, 201, 202, 202, 203, 203, 204, 204, 204,1263 205, 205, 20 6, 206, 207, 207, 208, 208, 209, 209,1264 2 10, 210, 211, 211, 212, 212, 213, 213, 214, 214,1265 214, 21 4, 214, 215, 215, 215, 216, 216, 216, 217,1266 217, 217, 21 7, 217, 218, 218, 218, 219, 219, 220,1267 220, 220, 221, 221, 221, 22 1, 221, 222, 222, 223,1268 223, 223, 22 3, 224, 224, 225, 225, 225, 225, 226,1269 226, 226, 22 6, 227, 227, 228, 228, 229, 229, 230,1270 230, 230, 23 0, 230, 231, 230, 232, 232, 232, 233,1271 233, 23 4, 234, 234, 234, 234, 234, 234, 234, 235,1272 235, 235, 23 5, 235, 235, 235, 235, 235, 235, 235,1273 23 5, 235, 236, 236, 236, 236, 236, 237, 237, 238,1274 238, 238, 23 8, 239, 239, 239, 239, 240, 240, 240,1275 24 0, 241, 241, 241, 242, 242, 242, 242, 243, 243,1276 243, 244, 244, 24 5, 245, 246, 245, 245, 245, 247,1277 24 7, 248, 248, 249, 249, 249, 249, 250, 250, 250,1278 25 0, 251, 251, 252, 252, 252, 252, 252, 253, 253,1279 25 4, 255, 256, 256, 257, 256, 258, 258, 259, 259,1280 2 60, 260, 261, 261, 261, 261, 261, 262, 262, 262,1281 26 2, 263, 263, 264, 264, 265, 265, 266, 266, 266,1282 26 6, 267, 267, 267, 267, 267, 268, 268, 268, 268,1283 26 8, 269, 269, 270, 270, 271, 271, 272, 272, 272,1245 144, 144, 144, 144, 144, 145, 145, 146, 146, 147, 1246 147, 148, 148, 148, 148, 148, 149, 149, 150, 150, 1247 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 1248 150, 150, 150, 150, 151, 151, 152, 152, 152, 152, 1249 153, 153, 153, 154, 154, 154, 154, 155, 155, 155, 1250 156, 156, 156, 157, 157, 157, 157, 157, 158, 158, 1251 158, 159, 159, 160, 160, 161, 161, 162, 162, 163, 1252 163, 164, 164, 164, 164, 165, 166, 166, 166, 167, 1253 167, 168, 168, 168, 168, 168, 168, 168, 168, 168, 1254 168, 168, 168, 169, 169, 169, 169, 170, 170, 171, 1255 171, 172, 172, 173, 173, 173, 173, 173, 173, 173, 1256 173, 173, 174, 175, 175, 176, 176, 177, 177, 177, 1257 177, 178, 178, 179, 180, 180, 180, 180, 180, 180, 1258 181, 181, 181, 182, 182, 183, 183, 184, 184, 185, 1259 186, 186, 187, 187, 188, 188, 189, 189, 189, 189, 1260 190, 190, 191, 191, 192, 192, 192, 193, 193, 194, 1261 194, 194, 194, 194, 194, 194, 194, 194, 194, 195, 1262 195, 195, 196, 196, 196, 196, 196, 197, 197, 197, 1263 197, 198, 199, 199, 199, 199, 199, 200, 200, 200, 1264 200, 200, 201, 201, 202, 202, 203, 203, 204, 204, 1265 205, 205, 205, 206, 206, 207, 207, 208, 208, 209, 1266 209, 210, 210, 211, 211, 212, 212, 213, 213, 214, 1267 214, 215, 215, 215, 215, 215, 216, 216, 216, 217, 1268 217, 217, 218, 218, 218, 218, 218, 219, 219, 219, 1269 220, 220, 221, 221, 221, 222, 222, 222, 222, 222, 1270 223, 223, 224, 224, 224, 224, 225, 225, 226, 226, 1271 226, 226, 227, 227, 227, 227, 228, 228, 229, 229, 1272 230, 230, 231, 231, 231, 231, 231, 232, 231, 233, 1273 233, 233, 234, 234, 235, 235, 235, 235, 235, 235, 1274 235, 235, 236, 236, 236, 236, 236, 236, 236, 236, 1275 236, 236, 236, 236, 236, 237, 237, 237, 237, 237, 1276 238, 238, 239, 239, 239, 239, 240, 240, 240, 240, 1277 241, 241, 241, 241, 242, 242, 242, 243, 243, 243, 1278 243, 244, 244, 244, 245, 245, 246, 246, 247, 246, 1279 246, 246, 248, 248, 249, 249, 250, 250, 250, 250, 1280 251, 251, 251, 251, 252, 252, 253, 253, 253, 253, 1281 253, 254, 254, 255, 256, 257, 257, 258, 257, 259, 1282 259, 260, 260, 261, 261, 262, 262, 262, 262, 262, 1283 263, 263, 263, 263, 264, 264, 265, 265, 266, 266, 1284 267, 267, 267, 267, 268, 268, 268, 268, 268, 269, 1285 269, 269, 269, 269, 270, 270, 271, 271, 272, 272, 1284 1286 273, 273, 273, 274, 274, 274, 275, 275, 275, 276, 1285 276, 276, 27 6, 277, 277, 277, 278, 278, 279, 279,1286 279, 2 79, 279, 280, 280, 281, 281, 282, 282, 282,1287 28 2, 282, 283, 283, 283, 283, 284, 284, 284, 285,1288 28 6, 286, 288, 287, 287, 289, 289, 289, 290, 290,1289 29 1, 291, 291, 292, 292, 292, 292, 293, 293, 293,1290 294, 294, 29 5, 295, 296, 297, 296, 298, 298, 299,1291 299, 300, 300, 300, 301, 301, 302, 302, 303, 303,1292 30 4, 304, 305, 305, 305, 306, 305, 305, 307, 307,1293 30 7, 308, 308, 308, 308, 308, 308, 308, 308, 308,1294 309, 309, 309, 310, 31 1, 311, 312, 312, 313, 313,1295 31 4, 315, 315, 316, 316, 316, 317, 317, 317, 317,1296 318, 318, 318, 31 8, 319, 319, 320, 320, 320, 321,1297 321, 321, 32 1, 322, 322, 323, 323, 323, 324, 324,1287 276, 276, 277, 277, 277, 277, 278, 278, 278, 279, 1288 279, 280, 280, 280, 280, 280, 281, 281, 282, 282, 1289 283, 283, 283, 283, 283, 284, 284, 284, 284, 285, 1290 285, 285, 286, 287, 287, 289, 288, 288, 290, 290, 1291 290, 291, 291, 292, 292, 292, 293, 293, 293, 293, 1292 294, 294, 294, 295, 295, 296, 296, 297, 298, 297, 1293 299, 299, 300, 300, 301, 301, 301, 302, 302, 303, 1294 303, 304, 304, 305, 305, 306, 306, 306, 307, 306, 1295 306, 308, 308, 308, 309, 309, 309, 309, 309, 309, 1296 309, 309, 309, 310, 310, 310, 311, 312, 312, 313, 1297 313, 314, 314, 315, 316, 316, 317, 317, 317, 318, 1298 318, 318, 318, 319, 319, 319, 319, 320, 320, 321, 1299 321, 321, 322, 322, 322, 322, 323, 323, 324, 324, 1298 1300 324, 325, 325, 325, 326, 326, 326, 327, 327, 327, 1299 1301 328, 328, 328, 329, 329, 329, 330, 330, 330, 331, 1300 331, 331, 33 1, 332, 332, 333, 333, 333, 334, 334,1301 334, 33 4, 335, 335, 335, 336, 336, 336, 336, 337,1302 337, 337, 338, 338, 338, 33 8, 339, 339, 339, 340,1303 340, 340, 34 0, 341, 341, 342, 342, 342, 343, 343,1304 34 4, 344, 345, 345, 345, 346, 346, 346, 346, 346,1305 347, 347, 347, 34 7, 348, 348, 348, 349, 349, 349,1306 350, 350, 350, 35 0, 351, 351, 351, 352, 352, 352,1307 35 2, 352, 353, 353, 353, 353, 354, 354, 354, 355,1308 355, 355, 356, 356, 356, 35 6, 356, 356, 357, 357,1309 357, 358, 358, 358, 35 8, 358, 359, 359, 359, 359,1310 360, 360, 36 1, 361, 361, 362, 362, 363, 363, 363,1311 36 3, 363, 363, 364, 364, 364, 364, 364, 364, 364,1312 36 4, 364, 364, 365, 365, 365, 365, 366, 366, 366,1313 367, 367, 36 8, 368, 368, 368, 368, 368, 369, 369,1314 369, 3 69, 369, 369, 370, 371, 371, 371, 372, 372,1315 37 3, 3731302 331, 331, 332, 332, 332, 332, 333, 333, 334, 334, 1303 334, 335, 335, 335, 335, 336, 336, 336, 337, 337, 1304 337, 337, 338, 338, 338, 339, 339, 339, 339, 340, 1305 340, 340, 341, 341, 341, 341, 342, 342, 343, 343, 1306 343, 344, 344, 345, 345, 346, 346, 346, 347, 347, 1307 347, 347, 347, 348, 348, 348, 348, 349, 349, 349, 1308 350, 350, 350, 351, 351, 351, 351, 352, 352, 352, 1309 353, 353, 353, 353, 353, 354, 354, 354, 354, 355, 1310 355, 355, 356, 356, 356, 357, 357, 357, 357, 357, 1311 357, 358, 358, 358, 359, 359, 359, 359, 359, 360, 1312 360, 360, 360, 361, 361, 362, 362, 362, 363, 363, 1313 364, 364, 364, 364, 364, 364, 365, 365, 365, 365, 1314 365, 365, 365, 365, 365, 365, 366, 366, 366, 366, 1315 367, 367, 367, 368, 368, 369, 369, 369, 369, 369, 1316 369, 370, 370, 370, 370, 370, 370, 371, 372, 372, 1317 372, 373, 373, 374, 374 1316 1318 }; 1317 1319 … … 1321 1323 0, 2, 0, 0, 1, 1, 1, 1, 1, 1, 1322 1324 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1323 1, 3, 3, 1, 6, 4, 3, 7, 3, 7,1324 2, 2, 7, 4, 1, 3, 0, 1, 1, 3,1325 1, 3, 7, 3, 7, 1, 1, 1, 2, 2,1326 2, 2, 2, 2, 4, 2, 4, 6, 1, 4,1327 4, 1, 1, 1, 1, 1, 1, 1, 4, 4,1328 1, 3, 3, 3, 1, 3, 3, 1, 3, 3,1329 1, 3, 3, 3, 3, 1, 3, 3, 1, 3,1330 1, 3, 1, 3, 1, 3, 1, 3, 1, 5,1331 4, 5, 1, 1, 3, 2, 0, 1, 1, 1,1325 1, 3, 3, 1, 6, 4, 3, 7, 3, 3, 1326 7, 2, 2, 7, 4, 1, 3, 0, 1, 1, 1327 3, 1, 3, 7, 3, 7, 1, 1, 1, 1, 1328 1, 2, 2, 2, 2, 2, 2, 4, 2, 4, 1329 6, 1, 4, 4, 1, 1, 1, 1, 1, 1, 1330 1, 4, 4, 1, 3, 3, 3, 1, 3, 3, 1331 1, 3, 3, 1, 3, 3, 3, 3, 1, 3, 1332 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 1333 3, 1, 5, 4, 5, 1, 1, 3, 2, 0, 1332 1334 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1333 2, 5, 6, 7, 1, 3, 1, 3, 0, 1,1334 1, 1, 1, 1, 1, 1, 1, 1, 6, 4,1335 2, 7, 1, 3, 1, 2, 1, 2, 1, 2,1336 2, 5, 7, 5, 9, 5, 9, 1, 3, 1,1337 1, 3, 3, 2, 1, 2, 2, 0, 1, 2,1338 3, 0, 1, 2, 3, 3, 4, 0, 1, 1,1339 2, 5, 7, 6, 6, 4, 3, 4, 2, 3,1340 2, 3, 3, 3, 3, 5, 3, 3, 4, 1,1341 5, 6, 5, 6, 9, 10, 9, 10, 2, 1,1342 2, 2, 2, 1, 6, 8, 10, 12, 14,0,1343 1, 0, 1, 1, 3, 4, 7, 0, 1, 3,1344 1, 3, 1, 1, 1, 3, 1, 1, 1, 3,1345 0, 1, 3, 4, 1, 3, 1, 1, 3, 3,1346 3, 3, 3, 2, 3, 6, 3, 3, 4, 1,1347 2, 2, 3, 5, 8, 7, 7, 5, 9, 2,1348 2, 5, 3, 5, 4, 3, 4, 4, 7, 3,1349 3, 3, 3, 4, 6, 1, 1, 1, 1, 1,1350 1, 1, 1, 0, 1, 1, 2, 1, 1, 1,1351 1, 1, 1, 1, 0, 5, 1, 2, 3, 1,1352 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,1335 1, 1, 1, 2, 5, 6, 7, 1, 3, 1, 1336 3, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1337 1, 6, 4, 2, 7, 1, 3, 1, 2, 1, 1338 2, 1, 2, 2, 5, 7, 5, 9, 5, 9, 1339 1, 3, 1, 1, 3, 3, 2, 1, 2, 2, 1340 0, 1, 2, 3, 0, 1, 2, 3, 3, 4, 1341 0, 1, 1, 2, 5, 7, 6, 6, 4, 3, 1342 4, 2, 3, 2, 3, 3, 3, 3, 5, 3, 1343 3, 4, 1, 5, 6, 5, 6, 9, 10, 9, 1344 10, 2, 1, 2, 2, 2, 1, 6, 8, 10, 1345 12, 14, 0, 1, 0, 1, 1, 3, 4, 7, 1346 0, 1, 3, 1, 3, 1, 1, 1, 3, 1, 1347 1, 1, 3, 0, 1, 3, 4, 1, 3, 1, 1348 1, 3, 3, 3, 3, 3, 2, 3, 6, 3, 1349 3, 4, 1, 2, 2, 3, 5, 8, 7, 7, 1350 5, 9, 2, 2, 5, 3, 5, 4, 3, 4, 1351 4, 7, 3, 3, 3, 3, 4, 6, 1, 1, 1352 1, 1, 1, 1, 1, 1, 0, 1, 1, 2, 1353 1, 1, 1, 1, 1, 1, 1, 0, 5, 1, 1354 2, 3, 1, 2, 1, 1, 1, 1, 1, 1, 1353 1355 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1354 1, 1, 1, 2, 2, 3, 3, 1, 3, 1,1355 2, 2, 2, 4, 4, 4, 4, 1, 2, 2,1356 3, 1, 2, 2, 1, 2, 2, 3, 1, 2,1357 2, 1, 1, 4, 2, 0, 6, 7, 2, 2,1358 2, 0, 2, 2, 3, 2, 3, 1, 2, 3,1359 2, 2, 4, 0, 1, 2, 2, 1, 0, 1,1360 2, 2, 5, 2, 0, 7, 2, 4, 0, 2,1361 0, 1, 1, 1, 5, 5, 5, 1, 5, 5,1362 9, 1, 5, 0, 1, 1, 5, 1, 1, 5,1363 5, 1, 3, 3, 4, 1, 1, 1, 1, 2,1364 1, 3, 3, 1, 2, 1, 3, 1, 1, 1,1365 1, 1, 1, 1, 1, 1, 1, 1, 2, 1,1366 1, 1, 2, 0, 2, 2, 1, 4, 0, 1,1367 2, 3, 4, 2, 2, 1, 2, 2, 5, 5,1368 7, 6, 1, 2, 2, 3, 1, 2, 2, 4,1369 2, 4, 0, 4, 2, 1, 1, 1, 0, 2,1370 5, 5, 13, 1, 1, 3, 3, 2, 3, 3,1371 2, 4, 1, 6, 9, 0, 11, 1, 3, 3,1372 3, 1, 1, 5, 2, 5, 0, 1, 1, 3,1373 0, 1, 1, 1, 1, 0, 6, 2, 1, 2,1374 4, 2, 3, 3, 3, 4, 5, 5, 5, 6,1375 1, 1, 1, 3, 0, 5, 0, 1, 1, 2,1376 6, 1, 3, 0, 1, 4, 1, 1, 1, 1,1377 2, 1, 2, 2, 1, 3, 2, 3, 3, 2,1378 4, 4, 3, 8, 3, 2, 1, 2, 6, 8,1379 3, 2, 3, 3, 4, 4, 3, 1, 1, 1,1380 4, 6, 3, 2, 3, 3, 4, 4, 3, 2,1381 1, 2, 2, 1, 3, 2, 3, 3, 2, 4,1382 4, 3, 6, 8, 3, 2, 1, 2, 2, 2,1383 3, 3, 2, 4, 4, 3, 6, 8, 3, 2,1384 1, 2, 2, 1, 1, 2, 3, 3, 2, 4,1385 6, 8, 1, 2, 2, 1, 2, 2, 3, 3,1386 1, 4, 4, 3, 5, 8, 3, 2, 3, 1,1387 5, 5, 6, 6, 1, 2, 2, 1, 2, 2,1388 3, 3, 1, 4, 4, 3, 5, 8, 3, 1,1389 2, 1, 2, 6, 5, 6, 7, 7, 1, 2,1390 2, 1, 2, 2, 3, 3, 1, 4, 4, 3,1391 8, 3, 1, 1, 2, 1, 1, 2, 3, 2,1392 3, 2, 3, 3, 2, 4, 3, 2, 3, 2,1393 4, 3, 2, 6, 6, 6, 7, 1, 2, 1,1394 1, 1, 2, 3, 2, 3, 2, 3, 3, 4,1395 2, 3, 4, 2, 5, 5, 6, 6, 0, 1,1396 0, 21356 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 1357 1, 3, 1, 2, 2, 2, 4, 4, 4, 4, 1358 1, 2, 2, 3, 1, 2, 2, 1, 2, 2, 1359 3, 1, 2, 2, 1, 1, 4, 2, 0, 6, 1360 7, 2, 2, 2, 0, 2, 2, 3, 2, 3, 1361 1, 2, 3, 2, 2, 4, 0, 1, 2, 2, 1362 1, 0, 1, 2, 2, 5, 2, 0, 7, 2, 1363 4, 0, 2, 0, 1, 1, 1, 5, 5, 5, 1364 1, 5, 5, 9, 1, 5, 0, 1, 1, 5, 1365 1, 1, 5, 5, 1, 3, 3, 4, 1, 1, 1366 1, 1, 2, 1, 3, 3, 1, 2, 1, 3, 1367 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1368 1, 2, 1, 1, 1, 2, 0, 2, 2, 1, 1369 4, 0, 1, 2, 3, 4, 2, 2, 1, 2, 1370 2, 5, 5, 7, 6, 1, 2, 2, 3, 1, 1371 2, 2, 4, 2, 4, 0, 4, 2, 1, 1, 1372 1, 0, 2, 5, 5, 13, 1, 1, 3, 3, 1373 2, 3, 3, 2, 4, 1, 6, 9, 0, 11, 1374 1, 3, 3, 3, 1, 1, 5, 2, 5, 0, 1375 1, 1, 3, 0, 1, 1, 1, 1, 0, 6, 1376 2, 1, 2, 4, 2, 3, 3, 3, 4, 5, 1377 5, 5, 6, 1, 1, 1, 3, 0, 5, 0, 1378 1, 1, 2, 6, 1, 3, 0, 1, 4, 1, 1379 1, 1, 1, 2, 1, 2, 2, 1, 3, 2, 1380 3, 3, 2, 4, 4, 3, 8, 3, 2, 1, 1381 2, 6, 8, 3, 2, 3, 3, 4, 4, 3, 1382 1, 1, 1, 4, 6, 3, 2, 3, 3, 4, 1383 4, 3, 2, 1, 2, 2, 1, 3, 2, 3, 1384 3, 2, 4, 4, 3, 6, 8, 3, 2, 1, 1385 2, 2, 2, 3, 3, 2, 4, 4, 3, 6, 1386 8, 3, 2, 1, 2, 2, 1, 1, 2, 3, 1387 3, 2, 4, 6, 8, 1, 2, 2, 1, 2, 1388 2, 3, 3, 1, 4, 4, 3, 5, 8, 3, 1389 2, 3, 1, 5, 5, 6, 6, 1, 2, 2, 1390 1, 2, 2, 3, 3, 1, 4, 4, 3, 5, 1391 8, 3, 1, 2, 1, 2, 6, 5, 6, 7, 1392 7, 1, 2, 2, 1, 2, 2, 3, 3, 1, 1393 4, 4, 3, 8, 3, 1, 1, 2, 1, 1, 1394 2, 3, 2, 3, 2, 3, 3, 2, 4, 3, 1395 2, 3, 2, 4, 3, 2, 6, 6, 6, 7, 1396 1, 2, 1, 1, 1, 2, 3, 2, 3, 2, 1397 3, 3, 4, 2, 3, 4, 2, 5, 5, 6, 1398 6, 0, 1, 0, 2 1397 1399 }; 1398 1400 … … 1402 1404 static const yytype_uint16 yydefact[] = 1403 1405 { 1404 29 3, 293, 313, 311, 314, 312, 315, 316, 299, 301,1405 30 0, 0, 302, 327, 319, 324, 322, 323, 321, 320,1406 32 5, 326, 331, 328, 329, 330, 546, 546, 546, 0,1407 0, 0, 29 3, 219, 303, 317, 318, 7, 358, 0,1408 8, 14, 15, 0, 2, 6 1, 62, 564, 9, 293,1409 52 4, 522, 246, 3, 453, 3, 259, 0, 3, 3,1410 3, 2 47, 3, 0, 0, 0, 294, 295, 297, 293,1411 30 6, 309, 339, 285, 332, 337, 286, 347, 287, 354,1412 35 1, 361, 0, 0, 362, 288, 472, 476, 3, 3,1413 0, 2, 5 18, 523, 528, 298, 0, 0, 546, 576,1414 54 6, 2, 587, 588, 589, 293, 0, 730, 731, 0,1415 12, 0, 13, 29 3, 269, 270, 0, 294, 289, 290,1416 29 1, 292, 525, 304, 391, 547, 548, 369, 370, 12,1417 44 4, 445, 11, 440, 443, 0, 502, 497, 488, 444,1418 44 5, 0, 0, 527, 220, 0, 293, 0, 0, 0,1419 0, 0, 0, 0, 0, 29 3, 293, 2, 0, 732,1420 29 4, 581, 593, 736, 729, 727, 734, 0, 0, 0,1421 25 3, 2, 0, 531, 438, 439, 437, 0, 0, 0,1422 0, 54 6, 0, 633, 634, 0, 0, 544, 540, 546,1423 56 1, 546, 546, 542, 2, 541, 546, 600, 546, 546,1424 60 3, 0, 0, 0, 293, 293, 311, 359, 2, 293,1425 26 0, 296, 307, 340, 352, 477, 0, 2, 0, 453,1426 26 1, 294, 333, 348, 355, 473, 0, 2, 0, 310,1427 33 4, 341, 342, 0, 349, 353, 356, 360, 445, 293,1428 37 1, 364, 368, 0, 393, 474, 478, 0, 0, 0,1429 1, 29 3, 2, 529, 575, 577, 293, 2, 740, 294,1430 74 3, 544, 544, 0, 294, 0, 0, 272, 546, 542,1431 2, 29 3, 0, 0, 293, 549, 2, 500, 2, 553,1432 0, 0, 0, 0, 0, 0, 19, 58, 4, 5,1433 6, 17, 0, 0, 29 3, 2, 63, 64, 65, 66,1434 4 6, 20, 47, 16, 23, 45, 67, 293, 0, 70,1435 7 4, 77, 80, 85, 88, 90, 92, 94, 96, 98,1436 10 3, 494, 750, 451, 493, 0, 449, 450, 0, 565,1437 58 0, 583, 586, 592, 595, 598, 358, 0, 2, 738,1438 0, 29 3, 741, 2, 61, 293, 3, 425, 0, 433,1439 29 4, 293, 306, 332, 286, 347, 354, 3, 3, 407,1440 41 1, 421, 426, 472, 293, 427, 705, 706, 293, 428,1441 43 0, 293, 2, 582, 594, 728, 2, 2, 248, 2,1442 4 58, 0, 456, 455, 454, 140, 2, 2, 250, 2,1443 2, 2 49, 2, 280, 2, 281, 0, 279, 0, 0,1444 0, 0, 0, 0, 0, 0, 0, 56 6, 605, 0,1445 45 3, 2, 560, 569, 659, 562, 563, 532, 293, 2,1446 599, 608, 601, 602, 0, 275, 293, 293, 338, 294,1447 0, 29 4, 0, 293, 733, 737, 735, 533, 293, 544,1448 25 4, 262, 308, 0, 2, 534, 293, 498, 335, 336,1449 28 2, 350, 357, 0, 293, 0, 748, 398, 0, 475,1450 499, 251, 252, 519, 293, 435, 0, 293, 236, 0,1451 2, 2 38, 0, 294, 0, 256, 2, 257, 277, 0,1452 0, 2, 29 3, 544, 293, 485, 487, 486, 0, 0,1453 75 0, 0, 293, 0, 293, 489, 293, 559, 557, 558,1454 55 6, 0, 551, 554, 0, 0, 293, 53, 293, 67,1455 48, 293, 55, 293, 293, 51, 52, 2, 126, 0,1456 0, 4 47, 0, 446, 727, 120, 293, 18, 0, 30,1457 3 1, 36, 2, 0, 36, 110, 111, 112, 113, 114,1458 11 5, 116, 117, 118, 119, 109, 108, 0, 49, 50,1406 296, 296, 316, 314, 317, 315, 318, 319, 302, 304, 1407 303, 0, 305, 330, 322, 327, 325, 326, 324, 323, 1408 328, 329, 334, 331, 332, 333, 549, 549, 549, 0, 1409 0, 0, 296, 222, 306, 320, 321, 7, 361, 0, 1410 8, 14, 15, 0, 2, 64, 65, 567, 9, 296, 1411 527, 525, 249, 3, 456, 3, 262, 0, 3, 3, 1412 3, 250, 3, 0, 0, 0, 297, 298, 300, 296, 1413 309, 312, 342, 288, 335, 340, 289, 350, 290, 357, 1414 354, 364, 0, 0, 365, 291, 475, 479, 3, 3, 1415 0, 2, 521, 526, 531, 301, 0, 0, 549, 579, 1416 549, 2, 590, 591, 592, 296, 0, 733, 734, 0, 1417 12, 0, 13, 296, 272, 273, 0, 297, 292, 293, 1418 294, 295, 528, 307, 394, 550, 551, 372, 373, 12, 1419 447, 448, 11, 443, 446, 0, 505, 500, 491, 447, 1420 448, 0, 0, 530, 223, 0, 296, 0, 0, 0, 1421 0, 0, 0, 0, 0, 296, 296, 2, 0, 735, 1422 297, 584, 596, 739, 732, 730, 737, 0, 0, 0, 1423 256, 2, 0, 534, 441, 442, 440, 0, 0, 0, 1424 0, 549, 0, 636, 637, 0, 0, 547, 543, 549, 1425 564, 549, 549, 545, 2, 544, 549, 603, 549, 549, 1426 606, 0, 0, 0, 296, 296, 314, 362, 2, 296, 1427 263, 299, 310, 343, 355, 480, 0, 2, 0, 456, 1428 264, 297, 336, 351, 358, 476, 0, 2, 0, 313, 1429 337, 344, 345, 0, 352, 356, 359, 363, 448, 296, 1430 374, 367, 371, 0, 396, 477, 481, 0, 0, 0, 1431 1, 296, 2, 532, 578, 580, 296, 2, 743, 297, 1432 746, 547, 547, 0, 297, 0, 0, 275, 549, 545, 1433 2, 296, 0, 0, 296, 552, 2, 503, 2, 556, 1434 0, 0, 0, 0, 0, 0, 19, 61, 4, 5, 1435 6, 17, 0, 0, 296, 2, 66, 67, 68, 69, 1436 49, 20, 50, 16, 23, 48, 70, 296, 0, 73, 1437 77, 80, 83, 88, 91, 93, 95, 97, 99, 101, 1438 106, 497, 753, 454, 496, 0, 452, 453, 0, 568, 1439 583, 586, 589, 595, 598, 601, 361, 0, 2, 741, 1440 0, 296, 744, 2, 64, 296, 3, 428, 0, 436, 1441 297, 296, 309, 335, 289, 350, 357, 3, 3, 410, 1442 414, 424, 429, 475, 296, 430, 708, 709, 296, 431, 1443 433, 296, 2, 585, 597, 731, 2, 2, 251, 2, 1444 461, 0, 459, 458, 457, 143, 2, 2, 253, 2, 1445 2, 252, 2, 283, 2, 284, 0, 282, 0, 0, 1446 0, 0, 0, 0, 0, 0, 0, 569, 608, 0, 1447 456, 2, 563, 572, 662, 565, 566, 535, 296, 2, 1448 602, 611, 604, 605, 0, 278, 296, 296, 341, 297, 1449 0, 297, 0, 296, 736, 740, 738, 536, 296, 547, 1450 257, 265, 311, 0, 2, 537, 296, 501, 338, 339, 1451 285, 353, 360, 0, 296, 0, 751, 401, 0, 478, 1452 502, 254, 255, 522, 296, 438, 0, 296, 239, 0, 1453 2, 241, 0, 297, 0, 259, 2, 260, 280, 0, 1454 0, 2, 296, 547, 296, 488, 490, 489, 0, 0, 1455 753, 0, 296, 0, 296, 492, 296, 562, 560, 561, 1456 559, 0, 554, 557, 0, 0, 296, 56, 296, 70, 1457 51, 296, 58, 296, 296, 54, 55, 2, 129, 0, 1458 0, 450, 0, 449, 730, 123, 296, 18, 0, 31, 1459 32, 37, 2, 0, 37, 113, 114, 115, 116, 117, 1460 118, 119, 120, 121, 122, 112, 111, 0, 52, 53, 1459 1461 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1460 1462 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1461 10 5, 2, 645, 452, 642, 546, 546, 650, 479, 293,1462 2, 58 4, 585, 0, 596, 597, 0, 2, 739, 742,1463 12 0, 293, 0, 2, 707, 294, 711, 702, 703, 709,1464 0, 2, 2, 6 67, 546, 750, 616, 546, 546, 750,1465 54 6, 630, 546, 546, 681, 434, 664, 546, 546, 672,1466 6 79, 293, 429, 294, 0, 0, 293, 717, 294, 722,1467 75 0, 714, 293, 719, 750, 293, 293, 293, 0, 120,1468 0, 19, 2, 0, 20, 0, 4 59, 748, 0, 0,1469 46 5, 240, 0, 293, 0, 0, 0, 544, 568, 572,1470 57 4, 604, 607, 611, 614, 567, 606, 0, 283, 657,1471 0, 29 3, 276, 0, 0, 0, 0, 274, 2, 0,1472 2 58, 535, 293, 0, 0, 293, 2, 363, 383, 372,1473 0, 0, 3 77, 371, 749, 0, 0, 396, 0, 294,1474 3, 41 4, 3, 418, 417, 590, 0, 530, 293, 61,1475 3, 29 3, 433, 294, 3, 427, 428, 2, 0, 0,1476 0, 48 4, 305, 293, 480, 482, 3, 2, 2, 0,1477 50 1, 3, 0, 553, 128, 0, 0, 221, 0, 0,1478 0, 0, 3 7, 0, 0, 120, 293, 21, 0, 22,1479 0, 69 1, 696, 448, 688, 546, 546, 0, 106, 3,1480 2, 2 8, 0, 34, 0, 2, 26, 0, 104, 71,1481 7 2, 73, 75, 76, 78, 79, 83, 84, 81, 82,1482 8 6, 87, 89, 91, 93, 95, 97, 0, 0, 751,1483 293, 0, 0, 0, 646, 647, 643, 644, 496, 495,1484 293, 0, 293, 713, 293, 718, 294, 293, 661, 293,1485 29 3, 704, 660, 2, 293, 0, 0, 0, 0, 0,1486 0, 0, 0, 682, 0, 668, 619, 635, 669,2,1487 615, 622, 431, 617, 618, 432, 2, 629, 638, 631,1488 63 2, 665, 666, 680, 708, 712, 710, 750, 267, 2,1489 744, 2, 422, 716, 721, 423, 0, 401, 3, 3,1490 3, 3, 453, 3, 0, 2, 467, 464, 749, 0,1491 460, 2, 463, 466, 0, 293, 241, 263, 3, 271,1492 27 3, 0, 453, 2, 570, 571, 2, 609, 610, 0,1493 658, 536, 3, 344, 343, 346, 345, 293, 537,0,1494 538, 371, 0, 0, 293, 293, 0, 0, 691, 381,1495 384, 38 8, 546, 388, 387, 380, 373, 546, 375, 378,1496 293, 398, 392, 102, 399, 748, 0, 0, 436, 239,1497 0, 0, 3, 2, 667, 429, 0, 526, 0, 750,1498 488, 0, 293, 293, 293, 0, 550, 552, 129, 0,1499 0, 214, 0, 0, 0, 222, 223, 54, 0, 56,1500 59, 6 0, 0, 2, 127, 0, 0, 0, 692, 693,1501 6 89, 690, 458, 68, 69, 107, 124, 3, 106, 0,1502 0, 25, 36, 3, 0, 33, 100, 0, 3, 649,1503 65 3, 656, 648, 3, 591, 3, 715, 720, 2, 61,1504 293, 3, 3, 294, 0, 3, 621, 625, 628, 637,1505 6 71, 675, 678, 293, 3, 620, 636, 670, 293, 293,1506 424, 293, 293, 745, 0, 0, 0, 0, 255, 0,1507 102, 0, 3, 3, 0, 461, 0, 457,0, 0,1508 244, 293, 0, 0, 128, 0, 0, 0, 0, 0,1509 128, 0, 0, 106, 106, 19, 2, 0, 0, 3,1510 130, 131, 2, 142, 132, 133, 134, 135, 136, 137,1511 14 4, 146, 0, 0, 0, 284, 293, 293, 546, 0,1512 539, 293, 374, 376, 0, 390, 692, 385, 389, 386,1513 3 79, 383, 366, 397, 0, 578, 2, 663, 662, 0,1514 668, 2, 481, 483, 503, 3, 511, 512, 0, 2,1515 507, 3, 3, 0, 0, 555, 221, 0, 0, 0,1516 221, 0, 0, 120, 695, 699, 701, 694, 748, 106,1517 0, 3, 660, 40, 3, 38, 35, 0, 3, 99,1518 101, 0, 2, 651, 652, 0, 0, 293, 0, 0,1519 0, 3, 637, 0, 2, 623, 624, 2, 639, 2,1520 673, 674, 0, 0, 61, 0, 3, 3, 3, 3,1521 409, 408, 412, 2, 2, 747, 746, 121, 0, 0,1522 0, 0, 3, 462, 3, 0, 242, 145, 3, 294,1523 293, 0, 0, 0, 0, 2, 0, 190, 0, 188,1524 0, 0, 0, 0, 0, 0, 0, 546, 120, 0,1525 150, 147, 293, 0, 0, 266, 278, 3, 3, 545,1526 612, 367, 382, 395, 293, 265, 293, 0, 514, 491,1527 293, 0, 0, 490, 505, 0, 0, 0, 215, 0,1528 224, 57, 2, 697, 698, 0, 125, 122, 0, 0,1529 0, 0, 0, 24, 0, 654, 293, 579, 264, 723,1530 724, 725, 0, 676, 293, 293, 293, 3, 3, 0,1531 684, 0, 0, 0, 0, 293, 293, 3, 543, 121,1532 469, 0, 0, 245, 294, 0, 0, 0, 0, 293,1533 191, 189, 186, 0, 192, 0, 0, 0, 0, 196,1534 199, 197, 193, 0, 194, 128, 36, 143, 141, 243,1535 0, 0, 416, 420, 419, 0, 508, 2, 509, 2,1536 510, 504, 293, 227, 0, 225, 0, 227, 293, 32,1537 123, 2, 43, 2, 41, 39, 29, 27, 3, 726,1538 3, 3, 3, 0, 0, 683, 685, 626, 640, 268,1539 2, 406, 3, 405, 0, 471, 468, 128, 0, 0,1540 1 28, 3, 0, 128, 187, 0, 2, 2, 208, 198,1541 0, 0, 0, 139, 0, 573, 613, 2, 0, 0,1542 2, 228, 0, 0, 216, 0, 3, 0, 0, 0,1543 0, 0, 0, 686, 687, 293, 0, 470, 151, 0,1544 0, 2, 164, 128, 153, 0, 181, 0, 128, 0,1545 2, 155, 0, 2, 0, 2, 2, 2, 195, 33,1546 293, 513, 515, 506, 0, 0, 0, 0, 0, 3,1547 3, 655, 627, 641, 677, 410, 128, 157, 160, 0,1548 1 59, 163, 3, 166, 165, 0, 128, 183, 128, 3,1549 0, 293, 0, 293, 0, 2, 0, 2, 138, 2,1550 229, 230, 0, 226, 217, 700, 0, 0, 152, 0,1551 0, 1 62, 232, 167, 2, 234, 182, 0, 185, 171,1552 200, 3, 209, 213, 202, 3, 0, 293, 0, 293,1553 0, 0, 0, 44, 42, 158, 161, 128, 0, 168,1554 293, 128, 128, 0, 172, 0, 0, 691, 210, 211,1555 212, 0, 201, 3, 203, 3, 293, 218, 231, 148,1556 169, 154, 128, 235, 184, 179, 177, 173, 156, 128,1557 0, 692, 0, 0, 0, 0, 149, 170, 180, 174,1558 17 8, 177, 175, 3, 3, 0, 0, 492, 176, 204,1559 206, 3, 3, 205, 2071463 108, 2, 648, 455, 645, 549, 549, 653, 482, 296, 1464 2, 587, 588, 0, 599, 600, 0, 2, 742, 745, 1465 123, 296, 0, 2, 710, 297, 714, 705, 706, 712, 1466 0, 2, 2, 670, 549, 753, 619, 549, 549, 753, 1467 549, 633, 549, 549, 684, 437, 667, 549, 549, 675, 1468 682, 296, 432, 297, 0, 0, 296, 720, 297, 725, 1469 753, 717, 296, 722, 753, 296, 296, 296, 0, 123, 1470 0, 19, 2, 0, 20, 0, 462, 751, 0, 0, 1471 468, 243, 0, 296, 0, 0, 0, 547, 571, 575, 1472 577, 607, 610, 614, 617, 570, 609, 0, 286, 660, 1473 0, 296, 279, 0, 0, 0, 0, 277, 2, 0, 1474 261, 538, 296, 0, 0, 296, 2, 366, 386, 375, 1475 0, 0, 380, 374, 752, 0, 0, 399, 0, 297, 1476 3, 417, 3, 421, 420, 593, 0, 533, 296, 64, 1477 3, 296, 436, 297, 3, 430, 431, 2, 0, 0, 1478 0, 487, 308, 296, 483, 485, 3, 2, 2, 0, 1479 504, 3, 0, 556, 131, 0, 0, 224, 0, 0, 1480 0, 0, 38, 0, 0, 123, 296, 21, 0, 22, 1481 0, 694, 699, 451, 691, 549, 549, 0, 109, 3, 1482 2, 29, 0, 35, 0, 28, 2, 26, 0, 107, 1483 74, 75, 76, 78, 79, 81, 82, 86, 87, 84, 1484 85, 89, 90, 92, 94, 96, 98, 100, 0, 0, 1485 754, 296, 0, 0, 0, 649, 650, 646, 647, 499, 1486 498, 296, 0, 296, 716, 296, 721, 297, 296, 664, 1487 296, 296, 707, 663, 2, 296, 0, 0, 0, 0, 1488 0, 0, 0, 0, 685, 0, 671, 622, 638, 672, 1489 2, 618, 625, 434, 620, 621, 435, 2, 632, 641, 1490 634, 635, 668, 669, 683, 711, 715, 713, 753, 270, 1491 2, 747, 2, 425, 719, 724, 426, 0, 404, 3, 1492 3, 3, 3, 456, 3, 0, 2, 470, 467, 752, 1493 0, 463, 2, 466, 469, 0, 296, 244, 266, 3, 1494 274, 276, 0, 456, 2, 573, 574, 2, 612, 613, 1495 0, 661, 539, 3, 347, 346, 349, 348, 296, 540, 1496 0, 541, 374, 0, 0, 296, 296, 0, 0, 694, 1497 384, 387, 391, 549, 391, 390, 383, 376, 549, 378, 1498 381, 296, 401, 395, 105, 402, 751, 0, 0, 439, 1499 242, 0, 0, 3, 2, 670, 432, 0, 529, 0, 1500 753, 491, 0, 296, 296, 296, 0, 553, 555, 132, 1501 0, 0, 217, 0, 0, 0, 225, 226, 57, 0, 1502 59, 62, 63, 0, 2, 130, 0, 0, 0, 695, 1503 696, 692, 693, 461, 71, 72, 110, 127, 3, 109, 1504 0, 0, 25, 37, 3, 0, 34, 103, 0, 3, 1505 652, 656, 659, 651, 3, 594, 3, 718, 723, 2, 1506 64, 296, 3, 3, 297, 0, 3, 624, 628, 631, 1507 640, 674, 678, 681, 296, 3, 623, 639, 673, 296, 1508 296, 427, 296, 296, 748, 0, 0, 0, 0, 258, 1509 0, 105, 0, 3, 3, 0, 464, 0, 460, 0, 1510 0, 247, 296, 0, 0, 131, 0, 0, 0, 0, 1511 0, 131, 0, 0, 109, 109, 19, 2, 0, 0, 1512 3, 133, 134, 2, 145, 135, 136, 137, 138, 139, 1513 140, 147, 149, 0, 0, 0, 287, 296, 296, 549, 1514 0, 542, 296, 377, 379, 0, 393, 695, 388, 392, 1515 389, 382, 386, 369, 400, 0, 581, 2, 666, 665, 1516 0, 671, 2, 484, 486, 506, 3, 514, 515, 0, 1517 2, 510, 3, 3, 0, 0, 558, 224, 0, 0, 1518 0, 224, 0, 0, 123, 698, 702, 704, 697, 751, 1519 109, 0, 3, 663, 47, 46, 3, 39, 41, 36, 1520 0, 3, 102, 104, 0, 2, 654, 655, 0, 0, 1521 296, 0, 0, 0, 3, 640, 0, 2, 626, 627, 1522 2, 642, 2, 676, 677, 0, 0, 64, 0, 3, 1523 3, 3, 3, 412, 411, 415, 2, 2, 750, 749, 1524 124, 0, 0, 0, 0, 3, 465, 3, 0, 245, 1525 148, 3, 297, 296, 0, 0, 0, 0, 2, 0, 1526 193, 0, 191, 0, 0, 0, 0, 0, 0, 0, 1527 549, 123, 0, 153, 150, 296, 0, 0, 269, 281, 1528 3, 3, 548, 615, 370, 385, 398, 296, 268, 296, 1529 0, 517, 494, 296, 0, 0, 493, 508, 0, 0, 1530 0, 218, 0, 227, 60, 2, 700, 701, 0, 128, 1531 125, 0, 0, 0, 0, 0, 24, 0, 657, 296, 1532 582, 267, 726, 727, 728, 0, 679, 296, 296, 296, 1533 3, 3, 0, 687, 0, 0, 0, 0, 296, 296, 1534 3, 546, 124, 472, 0, 0, 248, 297, 0, 0, 1535 0, 0, 296, 194, 192, 189, 0, 195, 0, 0, 1536 0, 0, 199, 202, 200, 196, 0, 197, 131, 37, 1537 146, 144, 246, 0, 0, 419, 423, 422, 0, 511, 1538 2, 512, 2, 513, 507, 296, 230, 0, 228, 0, 1539 230, 296, 33, 126, 40, 30, 2, 44, 2, 42, 1540 27, 3, 729, 3, 3, 3, 0, 0, 686, 688, 1541 629, 643, 271, 2, 409, 3, 408, 0, 474, 471, 1542 131, 0, 0, 131, 3, 0, 131, 190, 0, 2, 1543 2, 211, 201, 0, 0, 0, 142, 0, 576, 616, 1544 2, 0, 0, 2, 231, 0, 0, 219, 0, 3, 1545 0, 0, 0, 0, 0, 0, 689, 690, 296, 0, 1546 473, 154, 0, 0, 2, 167, 131, 156, 0, 184, 1547 0, 131, 0, 2, 158, 0, 2, 0, 2, 2, 1548 2, 198, 34, 296, 516, 518, 509, 0, 0, 0, 1549 0, 0, 3, 3, 658, 630, 644, 680, 413, 131, 1550 160, 163, 0, 162, 166, 3, 169, 168, 0, 131, 1551 186, 131, 3, 0, 296, 0, 296, 0, 2, 0, 1552 2, 141, 2, 232, 233, 0, 229, 220, 703, 0, 1553 0, 155, 0, 0, 165, 235, 170, 2, 237, 185, 1554 0, 188, 174, 203, 3, 212, 216, 205, 3, 0, 1555 296, 0, 296, 0, 0, 0, 45, 43, 161, 164, 1556 131, 0, 171, 296, 131, 131, 0, 175, 0, 0, 1557 694, 213, 214, 215, 0, 204, 3, 206, 3, 296, 1558 221, 234, 151, 172, 157, 131, 238, 187, 182, 180, 1559 176, 159, 131, 0, 695, 0, 0, 0, 0, 152, 1560 173, 183, 177, 181, 180, 178, 3, 3, 0, 0, 1561 495, 179, 207, 209, 3, 3, 208, 210 1560 1562 }; 1561 1563 … … 1563 1565 static const yytype_int16 yydefgoto[] = 1564 1566 { 1565 -1, 81 4, 468, 300, 47, 133, 134, 301, 302, 303,1566 304, 305, 762, 763, 113 4, 1135, 306, 381, 308, 309,1567 3 10, 311, 312, 313, 314, 315, 316, 317, 318, 319,1568 3 20, 1031, 518, 976, 547, 322, 977, 948, 1058, 1519,1569 1 060, 1061, 1062, 1063, 1520, 1064, 1065, 1438, 1439, 1402,1570 140 3, 1404, 1498, 1499, 1503, 1504, 1539, 1540, 1066, 1362,1571 1 067, 1068, 1299, 1300, 1301, 1481, 1069, 145, 954, 955,1572 956, 1382, 1462, 1473, 1474, 469, 470, 875, 876, 1039,1573 51, 52, 53, 54, 55, 347, 158, 58, 59, 60,1574 6 1, 62, 349, 64, 65, 264, 67, 68, 274, 351,1575 35 2, 71, 72, 73, 118, 75, 204, 354, 119, 78,1576 120, 80, 81, 455, 82, 454, 689, 690, 691, 909,1577 1087, 910, 83, 84, 458, 456, 697, 856, 857, 858,1578 859, 700, 701, 702, 359, 360, 361, 362, 466, 340,1579 135, 136, 522, 324, 170, 646, 647, 648, 649, 650,1580 85, 121, 87, 489, 490, 940, 491, 277, 495, 325,1581 88, 137, 138, 89, 1322, 1109, 1110, 1111, 1112, 90,1582 9 1, 718, 92, 273, 93, 94, 187, 1033, 680, 412,1583 125, 95, 501, 502, 503, 188, 268, 190, 191, 192,1584 269, 98, 99, 100, 101, 102, 103, 104, 195, 196,1585 19 7, 198, 199, 826, 606, 607, 608, 609, 200, 611,1586 61 2, 613, 573, 574, 575, 576, 752, 105, 615, 616,1587 61 7, 618, 619, 620, 969, 754, 755, 756, 596, 365,1588 36 6, 367, 368, 326, 164, 107, 108, 109, 370, 695,1589 5701567 -1, 815, 468, 300, 47, 133, 134, 301, 302, 303, 1568 304, 305, 762, 763, 1136, 1137, 1138, 306, 381, 308, 1569 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 1570 319, 320, 1032, 518, 977, 547, 322, 978, 949, 1059, 1571 1522, 1061, 1062, 1063, 1064, 1523, 1065, 1066, 1441, 1442, 1572 1405, 1406, 1407, 1501, 1502, 1506, 1507, 1542, 1543, 1067, 1573 1365, 1068, 1069, 1302, 1303, 1304, 1484, 1070, 145, 955, 1574 956, 957, 1385, 1465, 1476, 1477, 469, 470, 876, 877, 1575 1040, 51, 52, 53, 54, 55, 347, 158, 58, 59, 1576 60, 61, 62, 349, 64, 65, 264, 67, 68, 274, 1577 351, 352, 71, 72, 73, 118, 75, 204, 354, 119, 1578 78, 120, 80, 81, 455, 82, 454, 689, 690, 691, 1579 910, 1088, 911, 83, 84, 458, 456, 697, 857, 858, 1580 859, 860, 700, 701, 702, 359, 360, 361, 362, 466, 1581 340, 135, 136, 522, 324, 170, 646, 647, 648, 649, 1582 650, 85, 121, 87, 489, 490, 941, 491, 277, 495, 1583 325, 88, 137, 138, 89, 1325, 1110, 1111, 1112, 1113, 1584 90, 91, 718, 92, 273, 93, 94, 187, 1034, 680, 1585 412, 125, 95, 501, 502, 503, 188, 268, 190, 191, 1586 192, 269, 98, 99, 100, 101, 102, 103, 104, 195, 1587 196, 197, 198, 199, 827, 606, 607, 608, 609, 200, 1588 611, 612, 613, 573, 574, 575, 576, 752, 105, 615, 1589 616, 617, 618, 619, 620, 970, 754, 755, 756, 596, 1590 365, 366, 367, 368, 326, 164, 107, 108, 109, 370, 1591 695, 570 1590 1592 }; 1591 1593 1592 1594 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1593 1595 STATE-NUM. */ 1594 #define YYPACT_NINF -13 231596 #define YYPACT_NINF -1338 1595 1597 static const yytype_int16 yypact[] = 1596 1598 { 1597 7329, 8828, -1323, 37, -1323, -1323, -1323, -1323, -1323, -1323,1598 -13 23, 109, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323,1599 -13 23, -1323, -1323, -1323, -1323, -1323, 85, 85, 85, 873,1600 7 33, 178, 7561, 370, -1323, -1323, -1323, -1323, -1323, 191,1601 -13 23, -1323, -1323, 614, 225, -1323, -1323, -1323, -1323, 4615,1602 -13 23, -1323, -1323, -1323, 229, 285, -1323, 934, -1323, -1323,1603 -13 23, -1323, 435, 1196, 579, 110, 7677, -1323, -1323, 4858,1604 1 038, -1323, -1323, 580, 596, 6761, 1021, 875, 580, 1103,1605 -13 23, -1323, 1317, 308, -1323, 580, 1224, -1323, 495, -1323,1606 616, 623, -1323, -1323, -1323, -1323, 547, 285, 85, -1323,1607 85, -1323, -1323, -1323, -1323, 9174, 934, -1323, -1323, 934,1608 -13 23, 551, -1323, 9403, -1323, -1323, 1899, 9436, -1323, 844,1609 844, 844, -1323, -1323, -1323, 85, -1323, -1323, -1323, 584,1610 608, 632, -1323, -1323, -1323, 646, -1323, -1323, -1323, -1323,1611 -13 23, 664, 687, -1323, -1323, -28, 8797, 2908, 117, 701,1612 717, 726, 771, 786, 799, 8715, 6849, 731, 757, -1323,1613 5600, -1323, -1323, -1323, -1323, 804, -1323, 223, 5225, 5225,1614 -13 23, 802, 365, -1323, -1323, -1323, -1323, 816, 443, 480,1615 534, 85, 827, -1323, -1323, 1196, 4341, 868, -1323, 50,1616 -13 23, 85, 85, 285, -1323, -1323, 61, -1323, 85, 85,1617 -13 23, 4647, 857, 864, 844, 6523, -1323, -1323, 869, 4615,1618 -13 23, -1323, 580, -1323, -1323, -1323, 285, -1323, 934, 229,1619 -13 23, 7868, -1323, 844, 844, 844, 285, -1323, 873, -1323,1620 5676, -1323, -1323, 852, 844, -1323, 844, -1323, 191, 8797,1621 -13 23, 884, -1323, 733, 890, 844, -1323, 873, 888, 892,1622 -13 23, 7561, 631, -1323, -1323, -1323, 9256, -1323, -1323, 9621,1623 -13 23, 868, 151, 10214, 9436, 1899, 4647, -1323, 88, -1323,1624 -13 23, 9403, 934, 891, 7708, -1323, -1323, 347, -1323, 10561,1625 922, 956, 10347, 945, 10366, 10423, -1323, 954, -1323, -1323,1626 -13 23, -1323, 10442, 10442, 8571, 952, -1323, -1323, -1323, -1323,1627 -13 23, -1323, -1323, 988, -1323, 966, 1946, 8910, 10366, -1323,1628 756, 338, 485, 411, 635, 955, 947, 957, 984, 237,1629 -13 23, -1323, 962, 647, -1323, 302, -1323, -1323, 2908, -1323,1630 -13 23, 235, 985, -1323, 312, 985, 989, 191, -1323, -1323,1631 9 90, 9174, -1323, 999, 1006, 9023, -1323, -1323, 1335, 2030,1632 8 286, 6523, 580, -1323, 580, 844, 844, -1323, -1323, -1323,1633 -13 23, -1323, -1323, 844, 9174, 934, -1323, -1323, 9474, 1575,1634 -13 23, 8017, -1323, -1323, -1323, -1323, -1323, -1323, -1323, 1008,1635 5 958, 10366, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323,1636 -13 23, -1323, -1323, -1323, -1323, -1323, 1899, -1323, 973, 991,1637 99 2, 1012, 978, 1017, 1018, 1020, 4341, -1323, -1323, 1029,1638 229, 1031, -1323, -1323, 1033, -1323, -1323, -1323, 9256, -1323,1639 -13 23, -1323, -1323, -1323, 4647, -1323, 8797, 8797, -1323, 844,1640 1899, 6642, 934, 8359, -1323, -1323, -1323, -1323, 9256, 151,1641 -13 23, -1323, 580, 285, -1323, -1323, 9256, -1323, 5770, -1323,1642 -13 23, 844, 844, 337, 8204, 1032, 1036, 1023, 1042, 844,1643 -13 23, -1323, -1323, -1323, 9660, -1323, 367, 6404, -1323, 285,1644 1044, -13 23, 1899, 10643, 10271, -1323, -1323, -1323, -1323, 1015,1645 4647, -1323, 8432, 868, 7445, -1323, -1323, -1323, 843, 436,1646 9 62, 733, 7708, 1341, 9403, -1323, 7708, -1323, -1323, -1323,1647 -13 23, 508, -1323, 1051, 956, 248, 8571, -1323, 9512, -1323,1648 -13 23, 8571, -1323, 8684, 8571, -1323, -1323, 1049, -1323, 606,1649 10 57, 682, 1059, -1323, -1323, 3527, 6492, -1323, 362, -1323,1650 -13 23, 10214, -1323, 368, 10214, -1323, -1323, -1323, -1323, -1323,1651 -13 23, -1323, -1323, -1323, -1323, -1323, -1323, 10214, -1323, -1323,1652 103 66, 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366, 10366,1653 103 66, 10366, 10366, 10366, 10366, 10366, 10366, 10366, 3593, 10214,1654 -13 23, 647, 1677, -1323, -1323, 85, 85, -1323, -1323, 8797,1655 -13 23, -1323, 1033, 631, -1323, 1033, 10290, -1323, -1323, -1323,1656 5 046, 6492, 1060, 1063, -1323, 9436, -1323, -1323, 804, -1323,1657 106 7, 750, 1068, 2627, 125, 962, -1323, 85, 85, 962,1658 132, -1323, 85, 85, 1033, -1323, -1323, 85, 85, -1323,1659 9 85, 9545, 934, 10788, 532, 656, 9545, -1323, 9621, -1323,1660 9 62, -1323, 9174, -1323, 238, 7983, 7983, 7983, 934, -1323,1661 5791, 1047, 1008, 493, 1058, 1061, -1323, 1076, 5225, 528,1662 -13 23, 1165, 934, 7983, 631, 1899, 631, 868, 430, 985,1663 -13 23, -1323, 536, 985, -1323, -1323, -1323, 956, -1323, 985,1664 2 85, 9660, -1323, 619, 1086, 633, 1088, -1323, 1087, 285,1665 -13 23, -1323, 9256, 285, 1089, 9512, 1092, -1323, 1065, -1323,1666 5 38, 552, 733, -1323, 733, 1085, 10366, -1323, 733, 10788,1667 -13 23, -1323, 1096, -1323, -1323, -1323, 631, -1323, 10716, 1006,1668 -13 23, 7983, 703, 8286, -1323, -1323, 804, 1095, 1098, 843,1669 5016, -1323, -1323, 7708, -1323, -1323, 1091, -1323, -1323, 1102,1670 -13 23, 1091, 1104, 10561, 10214, 1090, 1093, 94, 1109, 1107,1671 11 11, 1114, -1323, 1118, 1129, 9365, 6611, -1323, 10214, -1323,1672 682, 1717, -1323, -1323, -1323, 85, 85, 10157, 10214, 1125,1673 -13 23, -1323, 653, -1323, 10214, -1323, -1323, 736, -1323, -1323,1674 -13 23, -1323, 756, 756, 338, 338, 485, 485, 485, 485,1675 411, 411, 635, 955, 947, 957, 984, 10366, 260, -1323,1676 9660, 1132, 1136, 1137, 1677, -1323, -1323, -1323, -1323, -1323,1677 9660, 708, 7983, -1323, 9174, -1323, 6968, 9136, -1323, 8017,1678 6849, -1323, -1323, 750, 9660, 1022, 1140, 1141, 1142, 1143,1679 11 46, 1149, 1154, -1323, 3715, 2627, -1323, -1323, -1323, -1323,1680 -13 23, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323,1681 -13 23, -1323, -1323, 1033, -1323, -1323, -1323, 962, -1323, -1323,1682 -13 23, -1323, -1323, -1323, -1323, -1323, 1155, -1323, 1157, 1159,1683 -1323, -1323, 229, 1125, 5791, -1323, -1323, -1323, 5958, 1158,1684 -1323, -1323, -1323, -1323, 733, 6174, 1248, -1323, -1323, -1323,1685 -13 23, 1151, 229, -1323, -1323, 1033, -1323, -1323, 1033, 84,1686 1033, -1323, -1323, -1323, -1323, -1323, -1323, 9327, -1323, 285,1687 -1323, -1323, 559, 562, 9474, 7087, 2137, 10366, 3114, -1323,1688 -13 23, 1156, 51, 1156, -1323, 733, -1323, 85, -1323, -1323,1689 8941, 1023, -1323, -1323, -1323, 1036, 1175, 1171, -1323, -1323,1690 1178, 1181, -1323, 703, 1901, -1323, 672, -1323, 5016, 962,1691 -1323, 1184, 7708, 9583, 8797, 1185, -1323, -1323, 1180, 1187,1692 1 170, -1323, 10366, 1197, 326, 1194, -1323, 1202, 631, 1202,1693 -1323, -1323, 1202, 1199, -1323, 1208, 1210, 1211, 1717, -1323,1694 -13 23, -1323, 5958, -1323, -1323, -1323, -1323, 1209, 10214, 1212,1695 631, -1323, 10214, -1323, 631, -1323, -1323, 10214, -1323, 558,1696 9 85, -1323, -1323, -1323, -1323, -1323, -1323, -1323, 1008, 1006,1697 9023, -1323, -1323, 7206, 1218, -1323, 674, 985, -1323, 813,1698 861, 985, -1323, 844, 4029, -1323, -1323, -1323, 9660, 9660,1699 -1323, 8359, 8359, -1323, 1215, 1216, 1225, 1230, -1323, 1232,1700 685, 82, 1125, -1323, 631, -1323, 5225, -1323, 10214, 564,1701 -1323, 6373, 1236, 1240, 10100, 1242, 1243, 70, 79, 96,1702 10214, 1244, 285, 10214, 10214, 1227, 1249, 522, 1222, -1323,1703 -13 23, -1323, 1250, -1323, -1323, -1323, -1323, -1323, -1323, -1323,1704 -13 23, -1323, 733, 1254, 10214, -1323, 9660, 9660, 85, 1257,1705 -1323, 9054, -1323, -1323, 752, -1323, 3114, -1323, -1323, -1323,1706 -13 23, 1065, -1323, -1323, 1255, -1323, -1323, -1323, -1323, 1258,1707 1 901, -1323, -1323, 1245, -1323, 1091, -1323, -1323, 1899, 1260,1708 -1323, -1323, -1323, 713, 1264, -1323, 94, 1269, 10366, 1252,1709 94, 94, 1262, 3527, 879, 985, -1323, -1323, 1076, 10214,1710 1273, 1209, 358, 204, 1270, -1323, -1323, 1275, 1270, -1323,1711 -1323, 1278, -1323, -1323, 1033, 1280, 1284, 6730, 1285, 1290,1712 1291, -1323, -1323, 1286, -1323, -1323, 1033, -1323, -1323, -1323,1713 -13 23, 1033, 10214, 10214, 1006, 1294, -1323, -1323, -1323, -1323,1714 -13 23, -1323, -1323, -1323, -1323, -1323, -1323, -1323, 10366, 10366,1715 1300, 1302, 1270, -1323, -1323, 733, -1323, -1323, -1323, 5213,1716 9583, 10214, 10214, 1374, 10214, -1323, 1295, -1323, 1296, -1323,1717 1297, 10214, 1301, 10214, 1105, 1304, 12, 85, 9289, 1625,1718 -1323, -1323, 6174, 1322, 573, -1323, -1323, -1323, -1323, -1323,1719 -13 23, -1323, -1323, -1323, 9920, -1323, 8432, 1330, -1323, -1323,1720 9583, 576, 602, -1323, 1331, 1315, 956, 1337, -1323, 329,1721 -1323, -1323, -1323, -1323, 1033, 1339, -1323, -1323, 1320, 486,1722 509, 631, 1340, -1323, 1344, -1323, 9660, -1323, -1323, -1323,1723 -13 23, -1323, 1347, -1323, 9660, 9660, 9660, -1323, -1323, 1348,1724 -13 23, 1351, 1354, 1355, 716, 8056, 8171, -1323, -1323, 529,1725 -13 23, 1357, 1362, -1323, 8505, 721, 730, 1358, 761, 3837,1726 -1323, -1323, -1323, 605, -1323, 766, 1366, 1367, 285, 1419,1727 834, -1323, -1323, 10214, -1323, 10100, 10214, -1323, -1323, -1323,1728 1370, 1375, -1323, -1323, -1323, 1372, -1323, -1323, -1323, -1323,1729 -13 23, -1323, 9583, 956, 1379, -1323, 1352, 956, 9660, -1323,1730 -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323, -1323,1731 -13 23, -1323, -1323, 1378, 1382, -1323, -1323, -1323, -1323, -1323,1732 -13 23, -1323, 1387, -1323, 1386, -1323, -1323, 10100, 289, 10214,1733 101 00, -1323, 1389, 10214, -1323, 318, 1405, 1406, -1323, -1323,1734 1 399, 1400, 1380, -1323, 821, -1323, -1323, -1323, 934, 1899,1735 1396, -1323, 402, 10366, -1323, 785, -1323, 631, 631, 1407,1736 1408, 1413, 1415, -1323, -1323, 8359, 1414, -1323, 1490, 10366,1737 1385, -1323, -1323, 10012, -1323, 800, -1323, 1402, 10100, 1403,1738 -1323, -1323, 1426, -1323, 1427, -1323, 1445, 1446, -1323, 1411,1739 9583, -1323, -1323, -1323, 956, 631, 1434, 1417, 1435, 1270,1740 1 270, -1323, -1323, -1323, -1323, -1323, 10100, 107, -1323, 433,1741 -1323, -1323, 7793, -1323, -1323, 1418, 10214, -1323, 10214, 7793,