Changeset 04273e9
- Timestamp:
- Aug 8, 2016, 5:29:03 PM (6 years ago)
- Branches:
- aaron-thesis, arm-eh, cleanup-dtors, ctor, 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:
- 03da511
- Parents:
- 0853178 (diff), 7bf7fb9 (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:
-
- 2 added
- 21 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/aaron_comp_II/comp_II.tex
r0853178 r04273e9 84 84 \section{Introduction} 85 85 86 \CFA\footnote{Pronounced ``C-for-all'', and written \CFA, CFA, or \CFL.} is an evolutionary modernization of the C programming language currently being designed and built at the University of Waterloo by a team led by Peter Buhr. 87 \CFA adds multiple features to C, including name overloading, user-defined operators, parametric-polymorphic routines, and type constructors and destructors, among others. 88 These features make \CFA significantly more powerful and expressive than C, but impose a significant compile-time cost to support, particularly in the expression resolver, which must evaluate the typing rules of a much more complex type system. 89 The primary goal of this proposed research project is to develop a sufficiently performant expression resolution algorithm, experimentally validate its performance, and integrate it into \Index*{CFA-CC}, the \CFA reference compiler. 90 Secondary goals of this project include the development of various new language features for \CFA; parametric-polymorphic (``generic'') types have already been designed and implemented, and reference types and user-defined conversions are under design consideration. 91 The experimental performance-testing architecture for resolution algorithms will also be used to determine the compile-time cost of adding such new features to the \CFA type system. 92 More broadly, this research should provide valuable data for implementers of compilers for other programming languages with similarly powerful static type systems. 86 \CFA\footnote{Pronounced ``C-for-all'', and written \CFA or \CFL.} is an evolutionary modernization of the C programming language currently being designed and built at the University of Waterloo by a team led by Peter Buhr. 87 \CFA both fixes existing design problems and adds multiple new features to C, including name overloading, user-defined operators, parametric-polymorphic routines, and type constructors and destructors, among others. 88 The new features make \CFA significantly more powerful and expressive than C, but impose a significant compile-time cost, particularly in the expression resolver, which must evaluate the typing rules of a much more complex type-system. 89 90 The primary goal of this research project is to develop a sufficiently performant expression resolution algorithm, experimentally validate its performance, and integrate it into CFA, the \CFA reference compiler. 91 Secondary goals of this project include the development of various new language features for \CFA: parametric-polymorphic (``generic'') types have already been designed and implemented, and reference types and user-defined conversions are under design consideration. 92 An experimental performance-testing architecture for resolution algorithms is under development to determine the relative performance of different expression resolution algorithms, as well as the compile-time cost of adding various new features to the \CFA type-system. 93 More broadly, this research should provide valuable data for implementers of compilers for other programming languages with similarly powerful static type-systems. 93 94 94 95 \section{\CFA} 95 96 96 To make the scope of the proposed expression resolution problem more explicit, it is necessary to define the features of both C and \CFA (both current and proposed) which affect this algorithm. 97 In some cases the interactions of multiple features make expression resolution a significantly more complex problem than any individual feature would; in others a feature which does not by itself add any complexity to expression resolution will trigger previously rare edge cases much more frequently. 97 To make the scope of the proposed expression resolution problem more explicit, it is necessary to define the features of both C and \CFA (both current and proposed) that affect this algorithm. 98 In some cases the interactions of multiple features make expression resolution a significantly more complex problem than any individual feature would; in other cases a feature that does not by itself add any complexity to expression resolution triggers previously rare edge cases more frequently. 99 100 It is important to note that \CFA is not an object-oriented language. 101 \CFA does have a system of (possibly implicit) type conversions derived from C's type conversions; while these conversions may be thought of as something like an inheritance hierarchy the underlying semantics are significantly different and such an analogy is loose at best. 102 Particularly, \CFA has no concept of ``subclass'', and thus no need to integrate an inheritance-based form of polymorphism with its parametric and overloading-based polymorphism. 103 The graph structure of the \CFA type conversions is also markedly different than an inheritance graph; it has neither a top nor a bottom type, and does not satisfy the lattice properties typical of inheritance graphs. 98 104 99 105 \subsection{Polymorphic Functions} … … 101 107 Such functions are written using a ©forall© clause (which gives the language its name): 102 108 \begin{lstlisting} 103 forall(otype T) 109 ®forall(otype T)® 104 110 T identity(T x) { 105 111 return x; … … 110 116 The ©identity© function above can be applied to any complete object type (or ``©otype©''). 111 117 The type variable ©T© is transformed into a set of additional implicit parameters to ©identity© which encode sufficient information about ©T© to create and return a variable of that type. 112 The current \CFA implementation passes the size and alignment of the type represented by an ©otype© parameter, as well as an assignment operator, constructor, copy constructor \&destructor.118 The current \CFA implementation passes the size and alignment of the type represented by an ©otype© parameter, as well as an assignment operator, constructor, copy constructor and destructor. 113 119 114 120 Since bare polymorphic types do not provide a great range of available operations, \CFA also provides a \emph{type assertion} mechanism to provide further information about a type: 115 121 \begin{lstlisting} 116 forall(otype T | { T twice(T); })122 forall(otype T ®| { T twice(T); }®) 117 123 T four_times(T x) { 118 124 return twice( twice(x) ); … … 137 143 Finding appropriate functions to satisfy type assertions is essentially a recursive case of expression resolution, as it takes a name (that of the type assertion) and attempts to match it to a suitable declaration in the current scope. 138 144 If a polymorphic function can be used to satisfy one of its own type assertions, this recursion may not terminate, as it is possible that function will be examined as a candidate for its own type assertion unboundedly repeatedly. 139 To avoid infinite loops, the current \Index*{CFA-CC} compiler imposes a fixed limit on the possible depth of recursion, similar to that employed by most \Index*[C++]{\CC} compilers for template expansion; this restriction means that there are some semantically well-typed expressions which cannot be resolved by {CFA-CC}.145 To avoid infinite loops, the current CFA compiler imposes a fixed limit on the possible depth of recursion, similar to that employed by most \CC compilers for template expansion; this restriction means that there are some semantically well-typed expressions which cannot be resolved by CFA. 140 146 One area of potential improvement this project proposes to investigate is the possibility of using the compiler's knowledge of the current set of declarations to more precicely determine when further type assertion satisfaction recursion will not produce a well-typed expression. 147 148 \subsubsection{Traits} 149 \CFA provides \emph{traits} as a means to name a group of type assertions, as in the example below: 150 \begin{lstlisting} 151 trait has_magnitude(otype T) { 152 bool ?<?(T, T); // comparison operator for T 153 T -?(T); // negation operator for T 154 void ?{}(T*, zero_t); // constructor from 0 literal 155 }; 156 157 forall(otype M | has_magnitude(M)) 158 M abs( M m ) { 159 M zero = 0; // uses zero_t constructor from trait 160 return m < zero ? -m : m; 161 } 162 163 forall(otype M | has_magnitude(M)) 164 M max_magnitude( M a, M b ) { 165 M aa = abs(a), ab = abs(b); 166 return aa < ab ? b : a; 167 } 168 \end{lstlisting} 169 170 Semantically, a trait is merely a named list of type assertions, but they can be used in many of the same situations where an interface in Java or an abstract base class in \CC would be used. 171 Unlike Java interfaces or \CC base classes, \CFA types do not explicitly state any inheritance relationship to traits they satisfy; this can be considered a form of structural inheritance, similar to interface implementation in Go, as opposed to the nominal inheritance model of Java and \CC. 172 % TODO talk about modelling of nominal inheritance with structural inheritance, possibility of investigating some resolver algorithms that require nominal 141 173 142 174 \subsection{Name Overloading} … … 174 206 Open research questions on this topic include whether a conversion graph can be generated that represents each allowable conversion in C with a unique minimal-length path, such that the path lengths accurately represent the relative costs of the conversions, whether such a graph representation can be usefully augmented to include user-defined types as well as built-in types, and whether the graph can be efficiently represented and included in the expression resolver. 175 207 176 \subsection{Constructors \&Destructors}208 \subsection{Constructors and Destructors} 177 209 Rob Shluntz, a current member of the \CFA research team, has added constructors and destructors to \CFA. 178 210 Each type has an overridable default-generated zero-argument constructor, copy constructor, assignment operator, and destructor; for struct types these functions each call their equivalents on each field of the struct. … … 180 212 181 213 \subsection{Generic Types} 182 The author hasadded a generic type capability to \CFA, designed to efficiently and naturally integrate with \CFA's existing polymorphic functions.214 I have already added a generic type capability to \CFA, designed to efficiently and naturally integrate with \CFA's existing polymorphic functions. 183 215 A generic type can be declared by placing a ©forall© specifier on a struct or union declaration, and instantiated using a parenthesized list of types after the type name: 184 216 \begin{lstlisting} … … 195 227 \end{lstlisting} 196 228 For \emph{concrete} generic types, that is, those where none of the type parameters depend on polymorphic type variables (like ©pair(const char*, int)© above), the struct is essentially template expanded to a new struct type; for \emph{polymorphic} generic types (such as ©pair(const char*, T)© above), member access is handled by a runtime calculation of the field offset, based on the size and alignment information of the polymorphic parameter type. 197 The default-generated constructors, destructor \&assignment operator for a generic type are polymorphic functions with the same list of type parameters as the generic type definition.198 199 Aside from giving users the ability to create more parameterized types than just the built-in pointer, array \&function types, the combination of generic types with polymorphic functions and implicit conversions makes the edge case where a polymorphic function can match its own assertions much more common, as follows:229 The default-generated constructors, destructor and assignment operator for a generic type are polymorphic functions with the same list of type parameters as the generic type definition. 230 231 Aside from giving users the ability to create more parameterized types than just the built-in pointer, array and function types, the combination of generic types with polymorphic functions and implicit conversions makes the edge case where a polymorphic function can match its own assertions much more common, as follows: 200 232 \begin{itemize} 201 233 \item Given an expression in an untyped context, such as a top-level function call with no assignment of return values, apply a polymorphic implicit conversion to the expression that can produce multiple types (the built-in conversion from ©void*© to any other pointer type is one, but not the only). … … 221 253 222 254 \subsection{Reference Types} 223 The author, in collaboration with the rest of the \CFA research team, has been designing \emph{reference types} for \CFA.255 I have been designing \emph{reference types} for \CFA, in collaboration with the rest of the \CFA research team. 224 256 Given some type ©T©, a ©T&© (``reference to ©T©'') is essentially an automatically dereferenced pointer; with these semantics most of the C standard's discussions of lvalues can be expressed in terms of references instead, with the benefit of being able to express the difference between the reference and non-reference version of a type in user code. 225 257 References preserve C's existing qualifier-dropping lvalue-to-rvalue conversion (\eg a ©const volatile int&© can be implicitly converted to a bare ©int©); the reference proposal also adds a rvalue-to-lvalue conversion to \CFA, implemented by storing the value in a new compiler-generated temporary and passing a reference to the temporary. … … 229 261 230 262 \subsection{Literal Types} 231 Another proposal currently under consideration for the \CFA type 263 Another proposal currently under consideration for the \CFA type-system is assigning special types to the literal values ©0© and ©1©.%, say ©zero_t© and ©one_t©. 232 264 Implicit conversions from these types would allow ©0© and ©1© to be considered as values of many different types, depending on context, allowing expression desugarings like ©if ( x ) {}© $\Rightarrow$ ©if ( x != 0 ) {}© to be implemented efficiently and precicely. 233 265 This is a generalization of C's existing behaviour of treating ©0© as either an integer zero or a null pointer constant, and treating either of those values as boolean false. … … 248 280 Expression resolution is somewhat unavoidably exponential in $p$, the number of function parameters, and $d$, the depth of the expression tree, but these values are fixed by the user programmer, and generally bounded by reasonably small constants. 249 281 $k$, on the other hand, is mostly dependent on the representation of types in the system and the efficiency of type assertion checking; if a candidate argument combination can be compared to a function parameter list in linear time in the length of the list (\ie $k = 1$), then the $p^{k \cdot d}$ term is linear in the input size of the source code for the expression, otherwise the resolution algorithm will exibit sub-linear performance scaling on code containing more-deeply nested expressions. 250 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 282 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. 251 283 252 284 The research goal of this project is to develop a performant expression resolver for \CFA; this analysis suggests two primary areas of investigation to accomplish that end. 253 The first is efficient argument-parameter matching; Bilson\cite{Bilson03} mentions significant optimization opportunities available in the current literature to improve on the existing {CFA-CC}compiler.285 The first is efficient argument-parameter matching; Bilson\cite{Bilson03} mentions significant optimization opportunities available in the current literature to improve on the existing CFA compiler. 254 286 %TODO: look up and lit review 255 287 The second, and likely more fruitful, area of investigation is heuristics and algorithmic approaches to reduce the number of argument interpretations considered in the common case; given the large ($p+1$) exponent on number of interpretations considered in the runtime analysis, even small reductions here could have a significant effect on overall resolver runtime. … … 299 331 Another approach would be to generate a set of possible implicit conversions for each set of interpretations of a given argument. 300 332 This would have the benefit of detecting ambiguous interpretations of arguments at the level of the argument rather than its containing call, would also never find more than one interpretation of the argument with a given type, and would re-use calculation of implicit conversions between function candidates. 301 On the other hand, this approach may unncessarily generate argument interpretations that will never match a parameter, wasting work. 333 On the other hand, this approach may unncessarily generate argument interpretations that will never match a parameter, wasting work. 334 Further, in the presence of tuple types this approach may lead to a combinatorial explosion of argument interpretations considered, unless the tuple can be considered as a sequence of elements rather than a unified whole. 302 335 303 336 \subsection{Candidate Set Generation} 304 Cormack\cite{Cormack81}, Baker\cite{Baker82} \&Bilson\cite{Bilson03} all generate the complete set of candidate argument interpretations before attempting to match the containing function call expression.337 Cormack\cite{Cormack81}, Baker\cite{Baker82} and Bilson\cite{Bilson03} all generate the complete set of candidate argument interpretations before attempting to match the containing function call expression. 305 338 However, given that the top-level expression interpretation that is ultimately chosen will be the minimal-cost valid interpretation, any consideration of non-minimal-cost interpretations is in some sense wasted work. 306 339 If we assume that user programmers will generally write function calls with relatively low-cost interpretations, a possible work-saving heuristic is to generate only the lowest-cost argument interpretations first, attempt to find a valid top-level interpretation using them, and only if that fails generate the higher-cost argument interpretations. 307 340 308 341 \subsubsection{Eager} 309 Within the eager approach taken by Cormack, Baker \&Bilson, there are still variants to explore.310 Cormack \&Baker do not account for implict conversions, and thus do not account for the possibility of multiple valid interpretations with distinct costs; Bilson, on the other hand, sorts the list of interpretations to aid in finding minimal-cost interpretations.342 Within the eager approach taken by Cormack, Baker and Bilson, there are still variants to explore. 343 Cormack and Baker do not account for implict conversions, and thus do not account for the possibility of multiple valid interpretations with distinct costs; Bilson, on the other hand, sorts the list of interpretations to aid in finding minimal-cost interpretations. 311 344 Sorting the lists of argument or function call interpretations by cost at some point during resolution may provide useful opportunities to short-circuit expression evaluation when a minimal-cost interpretation is found, though it is not clear if this short-circuiting behaviour would justify the cost of the sort. 312 345 … … 315 348 However, if user programmers actually use relatively few implicit conversions, then the ``on arguments'' approach to implicit conversions will generate a large number of high-cost interpretations which may never be used. 316 349 The essence of the lazy approach to candidate set generation is to wrap the matching algorithm into the element generator of a lazy list type, only generating as few elements at a time as possible to ensure that the next-smallest-cost interpretation has been generated. 317 Assuming that argument interpretations are provided to the parameter matching algorithm in sorted order, a sorted list of function call interpretations can be produced by generating combinations of arguments sorted by total cost\footnote{ The author has developed a lazy $n$-way combination generation algorithm that canperform this task.}, then generating function call interpretations in the order suggested by this list.350 Assuming that argument interpretations are provided to the parameter matching algorithm in sorted order, a sorted list of function call interpretations can be produced by generating combinations of arguments sorted by total cost\footnote{I have already developed a lazy $n$-way combination generation algorithm to perform this task.}, then generating function call interpretations in the order suggested by this list. 318 351 Note that the function call interpretation chosen may have costs of its own, for instance polymorphic type binding, so in some cases a number of argument combinations (any combination whose marginal cost does not exceed the cost of the function call interpretation itself) may need to be considered to determine the next-smallest-cost function call interpretation. 319 352 Ideally, this candidate generation approach will lead to very few unused candidates being generated (in the expected case where the user programmer has, in fact, provided a validly-typable program), but this research project will need to determine whether or not the overheads of lazy generation exceed the benefit produced from considering fewer interpretations. … … 333 366 %\subsection{Parameter-Directed} 334 367 %\textbf{TODO: Richard's algorithm isn't Baker (Cormack?), disentangle from this section \ldots}. 335 %The expression resolution algorithm used by the existing iteration of {CFA-CC}is based on Baker's\cite{Baker82} algorithm for overload resolution in Ada.368 %The expression resolution algorithm used by the existing iteration of CFA is based on Baker's\cite{Baker82} algorithm for overload resolution in Ada. 336 369 %The essential idea of this algorithm is to first find the possible interpretations of the most deeply nested subexpressions, then to use these interpretations to recursively generate valid interpretations of their superexpressions. 337 370 %To simplify matters, the only expressions considered in this discussion of the algorithm are function application and literal expressions; other expression types can generally be considered to be variants of one of these for the purposes of the resolver, \eg variables are essentially zero-argument functions. … … 341 374 %\textbf{TODO: Figure} 342 375 % 343 %Baker's algorithm was designed to account for name overloading; Richard Bilson\cite{Bilson03} extended this algorithm to also handle polymorphic functions, implicit conversions \&multiple return types when designing the original \CFA compiler.376 %Baker's algorithm was designed to account for name overloading; Richard Bilson\cite{Bilson03} extended this algorithm to also handle polymorphic functions, implicit conversions and multiple return types when designing the original \CFA compiler. 344 377 %The core of the algorithm is a function which Baker refers to as $gen\_calls$. 345 378 %$gen\_calls$ takes as arguments the name of a function $f$ and a list containing the set of possible subexpression interpretations $S_j$ for each argument of the function and returns a set of possible interpretations of calling that function on those arguments. … … 363 396 \section{Proposal} 364 397 Baker\cite{Baker82} discussed various expression resolution algorithms that could handle name overloading, but left experimental comparison of those algorithms to future work; Bilson\cite{Bilson03} described one extension of Baker's algorithm to handle implicit conversions, but did not fully explore the space of algorithmic approaches to handle both overloaded names and implicit conversions. 365 This project is intended to experimentally test a number of expression resolution algorithms which are powerful enough to handle the \CFA type 398 This project is intended to experimentally test a number of expression resolution algorithms which are powerful enough to handle the \CFA type-system, including both name overloading and implicit conversions. 366 399 This comparison will close Baker's open research question, as well as potentially improving on Bilson's \CFA compiler. 367 400 368 Rather than testing all of these algorithms in-place in the \CFA compiler, a resolver prototype will be developed which acts on a simplified input language encapsulating the essential details of the \CFA type 401 Rather than testing all of these algorithms in-place in the \CFA compiler, a resolver prototype will be developed which acts on a simplified input language encapsulating the essential details of the \CFA type-system\footnote{Note that this simplified input language is not required to be a usable programming language.}. 369 402 Multiple variants of this resolver prototype will be implemented, each encapsulating a different expression resolution variant, sharing as much code as feasible. 370 403 These variants will be instrumented to test runtime performance, and run on a variety of input files; the input files may be generated programmatically or from exisiting code in \CFA or similar languages. 371 These experimental results will allow the research team to determine the algorithm likely to be most performant in practical use, and replace {CFA-CC}'s existing expression resolver with that code.404 These experimental results will allow the research team to determine the algorithm likely to be most performant in practical use, and replace CFA's existing expression resolver with that code. 372 405 The experimental results will also provide some empirical sense of the compile-time cost of various language features by comparing the results of the most performant resolver variant that supports the feature with the most performant resolver variant that doesn't, a useful capability to guide language design. 373 406 374 This proposed project should provide valuable data on how to implement a performant compiler for modern programming languages such as \CFA with powerful static type 407 This proposed project should provide valuable data on how to implement a performant compiler for modern programming languages such as \CFA with powerful static type-systems, specifically targeting the feature interaction between name overloading and implicit conversions. 375 408 376 409 \appendix … … 379 412 \begin{center} 380 413 \begin{tabular}{ | r @{--} l | p{4in} | } 381 \hline May 2015 & April 2016 & Project familiarization and generic types design \&implementation. \\382 \hline May 2016 & April 2017 & Design \&implement resolver prototype and run performance experiments. \\383 \hline May 2017 & August 2017 & Integrate new language features and best-performing resolver prototype into {CFA-CC}. \\384 \hline September 2017 & January 2018 & Thesis writing \&defense. \\414 \hline May 2015 & April 2016 & Project familiarization and generic types design and implementation. \\ 415 \hline May 2016 & April 2017 & Design and implement resolver prototype and run performance experiments. \\ 416 \hline May 2017 & August 2017 & Integrate new language features and best-performing resolver prototype into CFA. \\ 417 \hline September 2017 & January 2018 & Thesis writing and defense. \\ 385 418 \hline 386 419 \end{tabular} -
doc/working/resolver_design.md
r0853178 r04273e9 37 37 38 38 An alternate possibility would be to only count two-arg constructors 39 `void ?{} ( To*, From )` as unsafe conversions; under this semantics, safe and 39 `void ?{} ( To*, From )` as unsafe conversions; under this semantics, safe and 40 40 explicit conversions should also have a compiler-enforced restriction to 41 41 ensure that they are two-arg functions (this restriction may be valuable … … 69 69 two chains of conversions, one among the signed integral types, another among 70 70 the unsigned, and to use monomorphic conversions to allow conversions between 71 signed and unsigned integer types). 71 signed and unsigned integer types). 72 72 73 73 ### Implementation Details ### … … 509 509 A variant of the above scheme would be to fix a maximum depth of polymorphic 510 510 type variables (16 seems like a reasonable choice) at which a parameter would 511 be considered to be effectively monomorphic, and to subtract the value 511 be considered to be effectively monomorphic, and to subtract the value 512 512 described above from that maximum, clamping the result to a minimum of 0. 513 513 Under this scheme, assuming a maximum value of 4, `int` has value 0, `T` has … … 577 577 specifying the (completely arbitrary) maximum depth as part of the language or 578 578 allowing the compiler to refuse to accept otherwise well-typed deeply-nested 579 polymorphic types. 579 polymorphic types. 580 580 581 581 For purposes of determining polymorphism, the list of return types of a … … 951 951 `sizeof`, `alignof`, and `offsetof` expressions have at most a single 952 952 interpretation, of type `size_t`. 953 `sizeof` and `alignof` expressions take either a type or an expression as a 954 a n argument; if the argument is a type, it must be a complete type which is955 not afunction type, if an expression, the expression must have a single953 `sizeof` and `alignof` expressions take either a type or an expression as an 954 argument; if the argument is a type, it must be a complete type which is not a 955 function type, if an expression, the expression must have a single 956 956 interpretation, the type of which conforms to the same rules. 957 957 `offsetof` takes two arguments, a type and a member name; the type must be … … 1620 1620 = delete; 1621 1621 } 1622 1623 ## Appendix E: Features to Add in Resolver Re-write ## 1624 * Reference types 1625 * Special types for 0 and 1 literals 1626 * Expression type for return statement that resolves similarly to ?=? 1627 - This is to get rid of the kludge in the box pass that effectively 1628 re-implements the resolver poorly. -
src/GenPoly/Box.cc
r0853178 r04273e9 62 62 63 63 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars ); 64 65 /// Abstracts type equality for a list of parameter types66 struct TypeList {67 TypeList() : params() {}68 TypeList( const std::list< Type* > &_params ) : params() { cloneAll(_params, params); }69 TypeList( std::list< Type* > &&_params ) : params( _params ) {}70 71 TypeList( const TypeList &that ) : params() { cloneAll(that.params, params); }72 TypeList( TypeList &&that ) : params( std::move( that.params ) ) {}73 74 /// Extracts types from a list of TypeExpr*75 TypeList( const std::list< TypeExpr* >& _params ) : params() {76 for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) {77 params.push_back( (*param)->get_type()->clone() );78 }79 }80 81 TypeList& operator= ( const TypeList &that ) {82 deleteAll( params );83 84 params.clear();85 cloneAll( that.params, params );86 87 return *this;88 }89 90 TypeList& operator= ( TypeList &&that ) {91 deleteAll( params );92 93 params = std::move( that.params );94 95 return *this;96 }97 98 ~TypeList() { deleteAll( params ); }99 100 bool operator== ( const TypeList& that ) const {101 if ( params.size() != that.params.size() ) return false;102 103 SymTab::Indexer dummy;104 for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {105 if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false;106 }107 return true;108 }109 110 std::list< Type* > params; ///< Instantiation parameters111 };112 113 /// Maps a key and a TypeList to the some value, accounting for scope114 template< typename Key, typename Value >115 class InstantiationMap {116 /// Wraps value for a specific (Key, TypeList) combination117 typedef std::pair< TypeList, Value* > Instantiation;118 /// List of TypeLists paired with their appropriate values119 typedef std::vector< Instantiation > ValueList;120 /// Underlying map type; maps keys to a linear list of corresponding TypeLists and values121 typedef ScopedMap< Key*, ValueList > InnerMap;122 123 InnerMap instantiations; ///< instantiations124 125 public:126 /// Starts a new scope127 void beginScope() { instantiations.beginScope(); }128 129 /// Ends a scope130 void endScope() { instantiations.endScope(); }131 132 /// Gets the value for the (key, typeList) pair, returns NULL on none such.133 Value *lookup( Key *key, const std::list< TypeExpr* >& params ) const {134 TypeList typeList( params );135 136 // scan scopes for matches to the key137 for ( typename InnerMap::const_iterator insts = instantiations.find( key ); insts != instantiations.end(); insts = instantiations.findNext( insts, key ) ) {138 for ( typename ValueList::const_reverse_iterator inst = insts->second.rbegin(); inst != insts->second.rend(); ++inst ) {139 if ( inst->first == typeList ) return inst->second;140 }141 }142 // no matching instantiations found143 return 0;144 }145 146 /// Adds a value for a (key, typeList) pair to the current scope147 void insert( Key *key, const std::list< TypeExpr* > ¶ms, Value *value ) {148 instantiations[ key ].push_back( Instantiation( TypeList( params ), value ) );149 }150 };151 64 152 65 /// Adds layout-generation functions to polymorphic types … … 239 152 }; 240 153 241 /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately242 class GenericInstantiator : public DeclMutator {243 /// Map of (generic type, parameter list) pairs to concrete type instantiations244 InstantiationMap< AggregateDecl, AggregateDecl > instantiations;245 /// Namer for concrete types246 UniqueName typeNamer;247 248 public:249 GenericInstantiator() : DeclMutator(), instantiations(), typeNamer("_conc_") {}250 251 virtual Type* mutate( StructInstType *inst );252 virtual Type* mutate( UnionInstType *inst );253 254 // virtual Expression* mutate( MemberExpr *memberExpr );255 256 virtual void doBeginScope();257 virtual void doEndScope();258 private:259 /// Wrap instantiation lookup for structs260 StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)instantiations.lookup( inst->get_baseStruct(), typeSubs ); }261 /// Wrap instantiation lookup for unions262 UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)instantiations.lookup( inst->get_baseUnion(), typeSubs ); }263 /// Wrap instantiation insertion for structs264 void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { instantiations.insert( inst->get_baseStruct(), typeSubs, decl ); }265 /// Wrap instantiation insertion for unions266 void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { instantiations.insert( inst->get_baseUnion(), typeSubs, decl ); }267 };268 269 154 /// Replaces member and size/align/offsetof expressions on polymorphic generic types with calculated expressions. 270 155 /// * Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference … … 354 239 Pass1 pass1; 355 240 Pass2 pass2; 356 GenericInstantiator instantiator;357 241 PolyGenericCalculator polyCalculator; 358 242 Pass3 pass3; … … 361 245 mutateTranslationUnit/*All*/( translationUnit, pass1 ); 362 246 mutateTranslationUnit/*All*/( translationUnit, pass2 ); 363 instantiator.mutateDeclarationList( translationUnit );364 247 mutateTranslationUnit/*All*/( translationUnit, polyCalculator ); 365 248 mutateTranslationUnit/*All*/( translationUnit, pass3 ); … … 889 772 arg++; 890 773 } else { 891 // /xxx - should this be an assertion?774 // xxx - should this be an assertion? 892 775 throw SemanticError( "unbound type variable: " + tyParm->first + " in application ", appExpr ); 893 776 } // if … … 902 785 std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin(); 903 786 std::list< Expression* >::const_iterator fnArg = arg; 904 std::set< std::string > seenTypes; // < names for generic types we've seen787 std::set< std::string > seenTypes; ///< names for generic types we've seen 905 788 906 789 // a polymorphic return type may need to be added to the argument list … … 1042 925 /// this gets rid of warnings from gcc. 1043 926 void addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars ) { 1044 Type * newType = formal->clone();1045 if ( getFunctionType( newType ) ) {927 if ( getFunctionType( formal ) ) { 928 Type * newType = formal->clone(); 1046 929 newType = ScrubTyVars::scrub( newType, tyVars ); 1047 930 actual = new CastExpr( actual, newType ); … … 1775 1658 } 1776 1659 1777 //////////////////////////////////////// GenericInstantiator //////////////////////////////////////////////////1778 1779 /// Makes substitutions of params into baseParams; returns true if all parameters substituted for a concrete type1780 bool makeSubstitutions( const std::list< TypeDecl* >& baseParams, const std::list< Expression* >& params, std::list< TypeExpr* >& out ) {1781 bool allConcrete = true; // will finish the substitution list even if they're not all concrete1782 1783 // substitute concrete types for given parameters, and incomplete types for placeholders1784 std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin();1785 std::list< Expression* >::const_iterator param = params.begin();1786 for ( ; baseParam != baseParams.end() && param != params.end(); ++baseParam, ++param ) {1787 // switch ( (*baseParam)->get_kind() ) {1788 // case TypeDecl::Any: { // any type is a valid substitution here; complete types can be used to instantiate generics1789 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );1790 assert(paramType && "Aggregate parameters should be type expressions");1791 out.push_back( paramType->clone() );1792 // check that the substituted type isn't a type variable itself1793 if ( dynamic_cast< TypeInstType* >( paramType->get_type() ) ) {1794 allConcrete = false;1795 }1796 // break;1797 // }1798 // case TypeDecl::Dtype: // dtype can be consistently replaced with void [only pointers, which become void*]1799 // out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );1800 // break;1801 // case TypeDecl::Ftype: // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]1802 // out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );1803 // break;1804 // }1805 }1806 1807 // if any parameters left over, not done1808 if ( baseParam != baseParams.end() ) return false;1809 // // if not enough parameters given, substitute remaining incomplete types for placeholders1810 // for ( ; baseParam != baseParams.end(); ++baseParam ) {1811 // switch ( (*baseParam)->get_kind() ) {1812 // case TypeDecl::Any: // no more substitutions here, fail early1813 // return false;1814 // case TypeDecl::Dtype: // dtype can be consistently replaced with void [only pointers, which become void*]1815 // out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );1816 // break;1817 // case TypeDecl::Ftype: // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]1818 // out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );1819 // break;1820 // }1821 // }1822 1823 return allConcrete;1824 }1825 1826 /// Substitutes types of members of in according to baseParams => typeSubs, appending the result to out1827 void substituteMembers( const std::list< Declaration* >& in, const std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs,1828 std::list< Declaration* >& out ) {1829 // substitute types into new members1830 TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );1831 for ( std::list< Declaration* >::const_iterator member = in.begin(); member != in.end(); ++member ) {1832 Declaration *newMember = (*member)->clone();1833 subs.apply(newMember);1834 out.push_back( newMember );1835 }1836 }1837 1838 Type* GenericInstantiator::mutate( StructInstType *inst ) {1839 // mutate subtypes1840 Type *mutated = Mutator::mutate( inst );1841 inst = dynamic_cast< StructInstType* >( mutated );1842 if ( ! inst ) return mutated;1843 1844 // exit early if no need for further mutation1845 if ( inst->get_parameters().empty() ) return inst;1846 assert( inst->get_baseParameters() && "Base struct has parameters" );1847 1848 // check if type can be concretely instantiated; put substitutions into typeSubs1849 std::list< TypeExpr* > typeSubs;1850 if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) {1851 deleteAll( typeSubs );1852 return inst;1853 }1854 1855 // make concrete instantiation of generic type1856 StructDecl *concDecl = lookup( inst, typeSubs );1857 if ( ! concDecl ) {1858 // set concDecl to new type, insert type declaration into statements to add1859 concDecl = new StructDecl( typeNamer.newName( inst->get_name() ) );1860 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );1861 DeclMutator::addDeclaration( concDecl );1862 insert( inst, typeSubs, concDecl );1863 }1864 StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() );1865 newInst->set_baseStruct( concDecl );1866 1867 deleteAll( typeSubs );1868 delete inst;1869 return newInst;1870 }1871 1872 Type* GenericInstantiator::mutate( UnionInstType *inst ) {1873 // mutate subtypes1874 Type *mutated = Mutator::mutate( inst );1875 inst = dynamic_cast< UnionInstType* >( mutated );1876 if ( ! inst ) return mutated;1877 1878 // exit early if no need for further mutation1879 if ( inst->get_parameters().empty() ) return inst;1880 assert( inst->get_baseParameters() && "Base union has parameters" );1881 1882 // check if type can be concretely instantiated; put substitutions into typeSubs1883 std::list< TypeExpr* > typeSubs;1884 if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) {1885 deleteAll( typeSubs );1886 return inst;1887 }1888 1889 // make concrete instantiation of generic type1890 UnionDecl *concDecl = lookup( inst, typeSubs );1891 if ( ! concDecl ) {1892 // set concDecl to new type, insert type declaration into statements to add1893 concDecl = new UnionDecl( typeNamer.newName( inst->get_name() ) );1894 substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );1895 DeclMutator::addDeclaration( concDecl );1896 insert( inst, typeSubs, concDecl );1897 }1898 UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() );1899 newInst->set_baseUnion( concDecl );1900 1901 deleteAll( typeSubs );1902 delete inst;1903 return newInst;1904 }1905 1906 // /// Gets the base struct or union declaration for a member expression; NULL if not applicable1907 // AggregateDecl* getMemberBaseDecl( MemberExpr *memberExpr ) {1908 // // get variable for member aggregate1909 // VariableExpr *varExpr = dynamic_cast< VariableExpr* >( memberExpr->get_aggregate() );1910 // if ( ! varExpr ) return NULL;1911 //1912 // // get object for variable1913 // ObjectDecl *objectDecl = dynamic_cast< ObjectDecl* >( varExpr->get_var() );1914 // if ( ! objectDecl ) return NULL;1915 //1916 // // get base declaration from object type1917 // Type *objectType = objectDecl->get_type();1918 // StructInstType *structType = dynamic_cast< StructInstType* >( objectType );1919 // if ( structType ) return structType->get_baseStruct();1920 // UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType );1921 // if ( unionType ) return unionType->get_baseUnion();1922 //1923 // return NULL;1924 // }1925 //1926 // /// Finds the declaration with the given name, returning decls.end() if none such1927 // std::list< Declaration* >::const_iterator findDeclNamed( const std::list< Declaration* > &decls, const std::string &name ) {1928 // for( std::list< Declaration* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {1929 // if ( (*decl)->get_name() == name ) return decl;1930 // }1931 // return decls.end();1932 // }1933 //1934 // Expression* Instantiate::mutate( MemberExpr *memberExpr ) {1935 // // mutate, exiting early if no longer MemberExpr1936 // Expression *expr = Mutator::mutate( memberExpr );1937 // memberExpr = dynamic_cast< MemberExpr* >( expr );1938 // if ( ! memberExpr ) return expr;1939 //1940 // // get declaration of member and base declaration of member, exiting early if not found1941 // AggregateDecl *memberBase = getMemberBaseDecl( memberExpr );1942 // if ( ! memberBase ) return memberExpr;1943 // DeclarationWithType *memberDecl = memberExpr->get_member();1944 // std::list< Declaration* >::const_iterator baseIt = findDeclNamed( memberBase->get_members(), memberDecl->get_name() );1945 // if ( baseIt == memberBase->get_members().end() ) return memberExpr;1946 // DeclarationWithType *baseDecl = dynamic_cast< DeclarationWithType* >( *baseIt );1947 // if ( ! baseDecl ) return memberExpr;1948 //1949 // // check if stated type of the member is not the type of the member's declaration; if so, need a cast1950 // // this *SHOULD* be safe, I don't think anything but the void-replacements I put in for dtypes would make it past the typechecker1951 // SymTab::Indexer dummy;1952 // if ( ResolvExpr::typesCompatible( memberDecl->get_type(), baseDecl->get_type(), dummy ) ) return memberExpr;1953 // else return new CastExpr( memberExpr, memberDecl->get_type() );1954 // }1955 1956 void GenericInstantiator::doBeginScope() {1957 DeclMutator::doBeginScope();1958 instantiations.beginScope();1959 }1960 1961 void GenericInstantiator::doEndScope() {1962 DeclMutator::doEndScope();1963 instantiations.endScope();1964 }1965 1966 1660 ////////////////////////////////////////// PolyGenericCalculator //////////////////////////////////////////////////// 1967 1661 … … 2107 1801 findGeneric( objectType ); // ensure layout for this type is available 2108 1802 1803 // replace member expression with dynamically-computed layout expression 2109 1804 Expression *newMemberExpr = 0; 2110 1805 if ( StructInstType *structType = dynamic_cast< StructInstType* >( objectType ) ) { -
src/GenPoly/module.mk
r0853178 r04273e9 23 23 GenPoly/CopyParams.cc \ 24 24 GenPoly/FindFunction.cc \ 25 GenPoly/DeclMutator.cc 25 GenPoly/DeclMutator.cc \ 26 GenPoly/InstantiateGeneric.cc -
src/Makefile.in
r0853178 r04273e9 121 121 GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \ 122 122 GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT) \ 123 GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) \ 123 124 InitTweak/driver_cfa_cpp-GenInit.$(OBJEXT) \ 124 125 InitTweak/driver_cfa_cpp-FixInit.$(OBJEXT) \ … … 377 378 GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \ 378 379 GenPoly/CopyParams.cc GenPoly/FindFunction.cc \ 379 GenPoly/DeclMutator.cc InitTweak/GenInit.cc \380 InitTweak/ FixInit.cc InitTweak/FixGlobalInit.cc \381 InitTweak/ InitTweak.cc Parser/parser.yy Parser/lex.ll\382 Parser/ TypedefTable.cc Parser/ParseNode.cc \383 Parser/ DeclarationNode.cc Parser/ExpressionNode.cc \384 Parser/ StatementNode.cc Parser/InitializerNode.cc \385 Parser/ TypeData.cc Parser/LinkageSpec.cc \386 Parser/ parseutility.cc Parser/Parser.cc \380 GenPoly/DeclMutator.cc GenPoly/InstantiateGeneric.cc \ 381 InitTweak/GenInit.cc InitTweak/FixInit.cc \ 382 InitTweak/FixGlobalInit.cc InitTweak/InitTweak.cc \ 383 Parser/parser.yy Parser/lex.ll Parser/TypedefTable.cc \ 384 Parser/ParseNode.cc Parser/DeclarationNode.cc \ 385 Parser/ExpressionNode.cc Parser/StatementNode.cc \ 386 Parser/InitializerNode.cc Parser/TypeData.cc \ 387 Parser/LinkageSpec.cc Parser/parseutility.cc Parser/Parser.cc \ 387 388 ResolvExpr/AlternativeFinder.cc ResolvExpr/Alternative.cc \ 388 389 ResolvExpr/Unify.cc ResolvExpr/PtrsAssignable.cc \ … … 585 586 GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \ 586 587 GenPoly/$(DEPDIR)/$(am__dirstamp) 588 GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT): \ 589 GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp) 587 590 InitTweak/$(am__dirstamp): 588 591 @$(MKDIR_P) InitTweak … … 828 831 -rm -f GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) 829 832 -rm -f GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) 833 -rm -f GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) 830 834 -rm -f GenPoly/driver_cfa_cpp-Lvalue.$(OBJEXT) 831 835 -rm -f GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT) … … 937 941 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Po@am__quote@ 938 942 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-GenPoly.Po@am__quote@ 943 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po@am__quote@ 939 944 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Lvalue.Po@am__quote@ 940 945 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po@am__quote@ … … 1388 1393 @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi` 1389 1394 1395 GenPoly/driver_cfa_cpp-InstantiateGeneric.o: GenPoly/InstantiateGeneric.cc 1396 @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc 1397 @am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po 1398 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/InstantiateGeneric.cc' object='GenPoly/driver_cfa_cpp-InstantiateGeneric.o' libtool=no @AMDEPBACKSLASH@ 1399 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ 1400 @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc 1401 1402 GenPoly/driver_cfa_cpp-InstantiateGeneric.obj: GenPoly/InstantiateGeneric.cc 1403 @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.obj `if test -f 'GenPoly/InstantiateGeneric.cc'; then $(CYGPATH_W) 'GenPoly/InstantiateGeneric.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/InstantiateGeneric.cc'; fi` 1404 @am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po 1405 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/InstantiateGeneric.cc' object='GenPoly/driver_cfa_cpp-InstantiateGeneric.obj' libtool=no @AMDEPBACKSLASH@ 1406 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ 1407 @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.obj `if test -f 'GenPoly/InstantiateGeneric.cc'; then $(CYGPATH_W) 'GenPoly/InstantiateGeneric.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/InstantiateGeneric.cc'; fi` 1408 1390 1409 InitTweak/driver_cfa_cpp-GenInit.o: InitTweak/GenInit.cc 1391 1410 @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-GenInit.o -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-GenInit.Tpo -c -o InitTweak/driver_cfa_cpp-GenInit.o `test -f 'InitTweak/GenInit.cc' || echo '$(srcdir)/'`InitTweak/GenInit.cc -
src/Parser/DeclarationNode.cc
r0853178 r04273e9 10 10 // Created On : Sat May 16 12:34:05 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jul 12 20:49:31201613 // Update Count : 16 412 // Last Modified On : Sun Aug 7 08:01:55 2016 13 // Update Count : 165 14 14 // 15 15 … … 49 49 newnode->name = name; 50 50 newnode->storageClasses = storageClasses; 51 newnode->bitfieldWidth = maybeClone( bitfieldWidth ); 51 //PAB newnode->bitfieldWidth = maybeClone( bitfieldWidth ); 52 newnode->bitfieldWidth = bitfieldWidth; 52 53 newnode->hasEllipsis = hasEllipsis; 53 54 newnode->initializer = initializer; -
src/Parser/ExpressionNode.cc
r0853178 r04273e9 10 10 // Created On : Sat May 16 13:17:07 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Aug 5 07:56:23201613 // Update Count : 37512 // Last Modified On : Sun Aug 7 09:23:12 2016 13 // Update Count : 437 14 14 // 15 15 16 16 #include <cassert> 17 17 #include <cctype> 18 #include <climits> 19 #include <cstdio> 18 20 #include <algorithm> 19 21 #include <sstream> 20 #include <cstdio>21 22 22 23 #include "ParseNode.h" … … 37 38 ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ), extension( other.extension ) { 38 39 if ( other.argName ) { 40 std::cout << "ExpressionNode" << std::endl; 39 41 argName = other.argName->clone(); 40 42 } else { … … 83 85 } 84 86 85 // CommaExprNode *ExpressionNode::add_to_list( ExpressionNode *exp ) { 86 // return new CommaExprNode( this, exp ); 87 // } 88 89 //############################################################################## 90 91 ConstantNode::ConstantNode( ConstantExpr *expr ) : expr( expr ) { 92 } // ConstantNode::ConstantNode 93 94 ConstantNode *ConstantNode::appendstr( const std::string *newValue ) { 95 assert( newValue != 0 ); 96 97 string value = expr->get_constant()->get_value(); 98 99 // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string. 100 value.insert( value.length() - 1, newValue->substr( 1, newValue->length() - 2 ) ); 101 expr->get_constant()->set_value( value ); 102 103 delete newValue; // allocated by lexer 104 return this; 105 } 106 107 void ConstantNode::printOneLine( std::ostream &os, int indent ) const { 108 // os << string( indent, ' ' ); 109 // printDesignation( os ); 110 111 // switch ( type ) { 112 // case Integer: 113 // case Float: 114 // os << value ; 115 // break; 116 // case Character: 117 // os << "'" << value << "'"; 118 // break; 119 // case String: 120 // os << '"' << value << '"'; 121 // break; 122 // } // switch 123 124 // os << ' '; 125 } 126 127 void ConstantNode::print( std::ostream &os, int indent ) const { 128 printOneLine( os, indent ); 129 os << endl; 130 } 131 132 Expression *ConstantNode::build() const { 133 return expr->clone(); 134 } 135 136 //############################################################################## 137 138 VarRefNode::VarRefNode() : isLabel( false ) {} 139 140 VarRefNode::VarRefNode( const string *name_, bool labelp ) : ExpressionNode( name_ ), isLabel( labelp ) {} 87 //############################################################################## 88 89 // Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns: 90 // 91 // prefix action constant action suffix 92 // 93 // Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty: 94 // 95 // constant BEGIN CONT ... 96 // <CONT>(...)? BEGIN 0 ... // possible empty suffix 97 // 98 // because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their 99 // type. 100 101 static Type::Qualifiers emptyQualifiers; // no qualifiers on constants 102 103 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; } 104 static inline bool checkL( char c ) { return c == 'l' || c == 'L'; } 105 static inline bool checkF( char c ) { return c == 'f' || c == 'F'; } 106 static inline bool checkD( char c ) { return c == 'd' || c == 'D'; } 107 static inline bool checkI( char c ) { return c == 'i' || c == 'I'; } 108 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; } 109 110 ConstantNode *build_constantInteger( std::string & str ) { 111 static const BasicType::Kind kind[2][3] = { 112 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt }, 113 { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt }, 114 }; 115 bool dec = true, Unsigned = false; // decimal, unsigned constant 116 int size; // 0 => int, 1 => long, 2 => long long 117 unsigned long long v; // converted integral value 118 size_t last = str.length() - 1; // last character of constant 119 120 if ( str[0] == '0' ) { // octal/hex constant ? 121 dec = false; 122 if ( last != 0 && checkX( str[1] ) ) { // hex constant ? 123 sscanf( (char *)str.c_str(), "%llx", &v ); 124 //printf( "%llx %llu\n", v, v ); 125 } else { // octal constant 126 sscanf( (char *)str.c_str(), "%llo", &v ); 127 //printf( "%llo %llu\n", v, v ); 128 } // if 129 } else { // decimal constant ? 130 sscanf( (char *)str.c_str(), "%llu", &v ); 131 //printf( "%llu %llu\n", v, v ); 132 } // if 133 134 if ( v <= INT_MAX ) { // signed int 135 size = 0; 136 } else if ( v <= UINT_MAX && ! dec ) { // unsigned int 137 size = 0; 138 Unsigned = true; // unsigned 139 } else if ( v <= LONG_MAX ) { // signed long int 140 size = 1; 141 } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int 142 size = 1; 143 Unsigned = true; // unsigned long int 144 } else if ( v <= LLONG_MAX ) { // signed long long int 145 size = 2; 146 } else { // unsigned long long int 147 size = 2; 148 Unsigned = true; // unsigned long long int 149 } // if 150 151 if ( checkU( str[last] ) ) { // suffix 'u' ? 152 Unsigned = true; 153 if ( last > 0 && checkL( str[last - 1] ) ) { // suffix 'l' ? 154 size = 1; 155 if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ? 156 size = 2; 157 } // if 158 } // if 159 } else if ( checkL( str[ last ] ) ) { // suffix 'l' ? 160 size = 1; 161 if ( last > 0 && checkL( str[last - 1] ) ) { // suffix 'll' ? 162 size = 2; 163 if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ? 164 Unsigned = true; 165 } // if 166 } else { 167 if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ? 168 Unsigned = true; 169 } // if 170 } // if 171 } // if 172 173 return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ) ) ); 174 } // build_constantInteger 175 176 ConstantNode *build_constantFloat( std::string & str ) { 177 static const BasicType::Kind kind[2][3] = { 178 { BasicType::Float, BasicType::Double, BasicType::LongDouble }, 179 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, 180 }; 181 182 bool complx = false; // real, complex 183 int size = 1; // 0 => float, 1 => double (default), 2 => long double 184 // floating-point constant has minimum of 2 characters: 1. or .1 185 size_t last = str.length() - 1; 186 187 if ( checkI( str[last] ) ) { // imaginary ? 188 complx = true; 189 last -= 1; // backup one character 190 } // if 191 192 if ( checkF( str[last] ) ) { // float ? 193 size = 0; 194 } else if ( checkD( str[last] ) ) { // double ? 195 size = 1; 196 } else if ( checkL( str[last] ) ) { // long double ? 197 size = 2; 198 } // if 199 if ( ! complx && checkI( str[last - 1] ) ) { // imaginary ? 200 complx = true; 201 } // if 202 203 return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ) ) ); 204 } // build_constantFloat 205 206 ConstantNode *build_constantChar( std::string & str ) { 207 return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ) ) ); 208 } // build_constantChar 209 210 ConstantNode *build_constantStr( std::string & str ) { 211 // string should probably be a primitive type 212 ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ), 213 new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ), 214 toString( str.size()+1-2 ) ) ), // +1 for '\0' and -2 for '"' 215 false, false ); 216 return new ConstantNode( new ConstantExpr( Constant( at, str ) ) ); 217 } // build_constantStr 218 219 //############################################################################## 220 221 //Expression *build_varref( ExpressionNode expr ) { 222 // return new NameExpr( get_name(), maybeBuild<Expression>( get_argName() ) ); 223 //} 224 225 VarRefNode::VarRefNode( const string *name, bool labelp ) : ExpressionNode( name ), isLabel( labelp ) {} 141 226 142 227 VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) { … … 171 256 double value; 172 257 if ( ss >> value ) { 173 // this is a floating point constant. It MUST be 174 // ".0" or ".1", otherwise the program is invalid 258 // this is a floating point constant. It MUST be ".0" or ".1", otherwise the program is invalid 175 259 if ( ! (var->get_name() == ".0" || var->get_name() == ".1") ) { 176 260 throw SemanticError( "invalid designator name: " + var->get_name() ); … … 201 285 202 286 if ( isArrayIndex ) { 203 // need to traverse entire structure and change any instances of 0 or 1 to 204 // ConstantExpr 287 // need to traverse entire structure and change any instances of 0 or 1 to ConstantExpr 205 288 DesignatorFixer fixer; 206 289 ret = ret->acceptMutator( fixer ); … … 238 321 //############################################################################## 239 322 240 static const char *opName[] = { 241 "TupleC", "Comma", "TupleFieldSel", // "TuplePFieldSel", // n-adic 242 // triadic 243 "Cond", "NCond", 323 static const char *OperName[] = { 244 324 // diadic 245 "SizeOf", "AlignOf", "OffsetOf", " Attr", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",325 "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&", 246 326 "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?", 247 327 "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?", 248 "?[?]", " FieldSel", "PFieldSel", "...",328 "?[?]", "...", 249 329 // monadic 250 330 "+?", "-?", "AddressOf", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "&&" 251 331 }; 252 332 253 OperatorNode::OperatorNode( Type t ) : type( t ) {} 254 255 OperatorNode::OperatorNode( const OperatorNode &other ) : ExpressionNode( other ), type( other.type ) { 256 } 257 258 OperatorNode::~OperatorNode() {} 259 260 OperatorNode::Type OperatorNode::get_type( void ) const { 261 return type; 262 } 263 264 void OperatorNode::printOneLine( std::ostream &os, int indent ) const { 265 printDesignation( os ); 266 os << opName[ type ] << ' '; 267 } 268 269 void OperatorNode::print( std::ostream &os, int indent ) const{ 270 printDesignation( os ); 271 os << string( indent, ' ' ) << "Operator: " << opName[type] << endl; 272 return; 273 } 274 275 const char *OperatorNode::get_typename( void ) const{ 276 return opName[ type ]; 277 } 278 279 //############################################################################## 280 281 CompositeExprNode::CompositeExprNode() : ExpressionNode(), function( 0 ), arguments( 0 ) { 282 } 283 284 CompositeExprNode::CompositeExprNode( const string *name_ ) : ExpressionNode( name_ ), function( 0 ), arguments( 0 ) { 285 } 286 287 CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *args ): 288 function( f ), arguments( args ) { 289 } 290 291 CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2): 292 function( f ), arguments( arg1 ) { 293 arguments->set_link( arg2 ); 294 } 295 296 CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ), arguments( 0 ) { 297 ParseNode *cur = other.arguments; 298 while ( cur ) { 299 if ( arguments ) { 300 arguments->set_link( cur->clone() ); 301 } else { 302 arguments = ( ExpressionNode*)cur->clone(); 303 } // if 304 cur = cur->get_link(); 305 } 306 } 307 308 CompositeExprNode::~CompositeExprNode() { 309 delete function; 310 delete arguments; 311 } 312 333 //############################################################################## 313 334 314 335 Expression *build_cast( TypeValueNode * arg, ExpressionNode *expr_node ) { … … 369 390 } 370 391 371 Expression *build_opr1( OperatorNode::Type op, ExpressionNode *expr_node ) { 392 Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ) { 393 std::list<Expression *> args; 394 args.push_back( maybeBuild<Expression>(expr_node) ); 395 return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); 396 } 397 Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ) { 372 398 std::list<Expression *> args; 373 399 args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node) ) ); 374 return new UntypedExpr( new NameExpr( opName[op ] ), args );375 } 376 Expression *build_ opr2( OperatorNode::Typeop, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {400 return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); 401 } 402 Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) { 377 403 std::list<Expression *> args; 378 404 args.push_back( maybeBuild<Expression>(expr_node1) ); 379 405 args.push_back( maybeBuild<Expression>(expr_node2) ); 380 return new UntypedExpr( new NameExpr( opName[ op ] ), args ); 406 return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); 407 } 408 Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) { 409 std::list<Expression *> args; 410 args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node1) ) ); 411 args.push_back( maybeBuild<Expression>(expr_node2) ); 412 return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); 381 413 } 382 414 … … 389 421 } 390 422 391 CompositeExprNode2::CompositeExprNode2( Expression *expr ) : expr( expr ) {} 392 CompositeExprNode2::CompositeExprNode2( const CompositeExprNode2 &other ) : expr( other.expr->clone() ) {} 393 CompositeExprNode2::~CompositeExprNode2() { delete expr; } 394 void CompositeExprNode2::print( std::ostream &, int indent ) const { assert( false ); } 395 void CompositeExprNode2::printOneLine( std::ostream &, int indent ) const { assert( false ); } 396 397 398 Expression *CompositeExprNode::build() const { 399 OperatorNode *op; 423 Expression *build_attr( VarRefNode *var, ExpressionNode * expr ) { 424 if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( expr ) ) { 425 return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType() ); 426 } else { 427 return new AttrExpr( maybeBuild<Expression>(var), maybeBuild<Expression>(expr) ); 428 } // if 429 } 430 431 Expression *build_tuple( ExpressionNode * expr ) { 432 TupleExpr *ret = new TupleExpr(); 433 buildList( expr, ret->get_exprs() ); 434 return ret; 435 } 436 437 Expression *build_func( ExpressionNode * function, ExpressionNode * expr ) { 400 438 std::list<Expression *> args; 401 439 402 buildList( get_args(), args ); 403 404 if ( ! ( op = dynamic_cast<OperatorNode *>( function ) ) ) { // function as opposed to operator 405 return new UntypedExpr( maybeBuild<Expression>(function), args, maybeBuild< Expression >( get_argName() )); 406 } // if 407 408 switch ( op->get_type() ) { 409 case OperatorNode::Assign: 410 case OperatorNode::MulAssn: 411 case OperatorNode::DivAssn: 412 case OperatorNode::ModAssn: 413 case OperatorNode::PlusAssn: 414 case OperatorNode::MinusAssn: 415 case OperatorNode::LSAssn: 416 case OperatorNode::RSAssn: 417 case OperatorNode::AndAssn: 418 case OperatorNode::ERAssn: 419 case OperatorNode::OrAssn: 420 assert( ! args.empty() ); 421 args.front() = new AddressExpr( args.front() ); 422 case OperatorNode::UnPlus: 423 case OperatorNode::UnMinus: 424 case OperatorNode::PointTo: 425 case OperatorNode::Neg: 426 case OperatorNode::BitNeg: 427 case OperatorNode::LabelAddress: 428 return new UntypedExpr( new NameExpr( opName[ op->get_type() ] ), args ); 429 430 case OperatorNode::Attr: 431 { 432 VarRefNode *var = dynamic_cast<VarRefNode *>( get_args() ); 433 assert( var ); 434 if ( ! get_args()->get_link() ) { 435 return new AttrExpr( maybeBuild<Expression>(var), ( Expression*)0); 436 } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link() ) ) { 437 return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType() ); 438 } else { 439 return new AttrExpr( maybeBuild<Expression>(var), args.back() ); 440 } // if 441 } 442 case OperatorNode::Cond: 443 { 444 assert( args.size() == 3); 445 std::list< Expression * >::const_iterator i = args.begin(); 446 Expression *arg1 = notZeroExpr( *i++ ); 447 Expression *arg2 = *i++; 448 Expression *arg3 = *i++; 449 return new ConditionalExpr( arg1, arg2, arg3 ); 450 } 451 case OperatorNode::NCond: 452 throw UnimplementedError( "GNU 2-argument conditional expression" ); 453 // Tuples 454 case OperatorNode::TupleC: 455 { 456 TupleExpr *ret = new TupleExpr(); 457 std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) ); 458 return ret; 459 } 460 default: 461 assert( ((void)"CompositeExprNode::build", false) ); 462 return 0; 463 } // switch 464 } 465 466 void CompositeExprNode::printOneLine( std::ostream &os, int indent ) const { 467 printDesignation( os ); 468 os << "( "; 469 function->printOneLine( os, indent ); 470 for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) { 471 cur->printOneLine( os, indent ); 472 } // for 473 os << ") "; 474 } 475 476 void CompositeExprNode::print( std::ostream &os, int indent ) const { 477 printDesignation( os ); 478 os << string( indent, ' ' ) << "Application of: " << endl; 479 function->print( os, indent + ParseNode::indent_by ); 480 481 os << string( indent, ' ' ) ; 482 if ( arguments ) { 483 os << "... on arguments: " << endl; 484 arguments->printList( os, indent + ParseNode::indent_by ); 485 } else 486 os << "... on no arguments: " << endl; 487 } 488 489 void CompositeExprNode::set_function( ExpressionNode *f ) { 490 function = f; 491 } 492 493 void CompositeExprNode::set_args( ExpressionNode *args ) { 494 arguments = args; 495 } 496 497 ExpressionNode *CompositeExprNode::get_function( void ) const { 498 return function; 499 } 500 501 ExpressionNode *CompositeExprNode::get_args( void ) const { 502 return arguments; 503 } 504 505 void CompositeExprNode::add_arg( ExpressionNode *arg ) { 506 if ( arguments ) 507 arguments->set_link( arg ); 508 else 509 set_args( arg ); 440 buildList( expr, args ); 441 return new UntypedExpr( maybeBuild<Expression>(function), args, nullptr ); 442 } 443 444 Expression *build_range( ExpressionNode * low, ExpressionNode *high ) { 445 Expression *low_cexpr = maybeBuild<Expression>( low ); 446 Expression *high_cexpr = maybeBuild<Expression>( high ); 447 return new RangeExpr( low_cexpr, high_cexpr ); 510 448 } 511 449 … … 698 636 } 699 637 700 ExpressionNode *flattenCommas( ExpressionNode *list ) {701 if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {702 OperatorNode *op;703 if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) ) {704 if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )705 composite->add_arg( next );706 return flattenCommas( composite->get_args() );707 } // if708 } // if709 710 if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )711 list->set_next( flattenCommas( next ) );712 713 return list;714 }715 716 ExpressionNode *tupleContents( ExpressionNode *tuple ) {717 if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) {718 OperatorNode *op = 0;719 if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) )720 return composite->get_args();721 } // if722 return tuple;723 }724 725 638 // Local Variables: // 726 639 // tab-width: 4 // -
src/Parser/ParseNode.cc
r0853178 r04273e9 10 10 // Created On : Sat May 16 13:26:29 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : S un Jul 24 02:17:01 201613 // Update Count : 9 012 // Last Modified On : Sat Aug 6 08:26:11 2016 13 // Update Count : 93 14 14 // 15 15 16 #include <climits>17 16 #include "ParseNode.h" 18 17 using namespace std; 19 20 // Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns:21 //22 // prefix action constant action suffix23 //24 // Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty:25 //26 // constant BEGIN CONT ...27 // <CONT>(...)? BEGIN 0 ... // possible empty suffix28 //29 // because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their30 // type.31 32 static Type::Qualifiers emptyQualifiers; // no qualifiers on constants33 34 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }35 static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }36 static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }37 static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }38 static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }39 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }40 41 ConstantNode *makeConstantInteger( std::string & str ) {42 static const BasicType::Kind kind[2][3] = {43 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },44 { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },45 };46 bool dec = true, Unsigned = false; // decimal, unsigned constant47 int size; // 0 => int, 1 => long, 2 => long long48 unsigned long long v; // converted integral value49 size_t last = str.length() - 1; // last character of constant50 51 if ( str[0] == '0' ) { // octal/hex constant ?52 dec = false;53 if ( last != 0 && checkX( str[1] ) ) { // hex constant ?54 sscanf( (char *)str.c_str(), "%llx", &v );55 //printf( "%llx %llu\n", v, v );56 } else { // octal constant57 sscanf( (char *)str.c_str(), "%llo", &v );58 //printf( "%llo %llu\n", v, v );59 } // if60 } else { // decimal constant ?61 sscanf( (char *)str.c_str(), "%llu", &v );62 //printf( "%llu %llu\n", v, v );63 } // if64 65 if ( v <= INT_MAX ) { // signed int66 size = 0;67 } else if ( v <= UINT_MAX && ! dec ) { // unsigned int68 size = 0;69 Unsigned = true; // unsigned70 } else if ( v <= LONG_MAX ) { // signed long int71 size = 1;72 } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int73 size = 1;74 Unsigned = true; // unsigned long int75 } else if ( v <= LLONG_MAX ) { // signed long long int76 size = 2;77 } else { // unsigned long long int78 size = 2;79 Unsigned = true; // unsigned long long int80 } // if81 82 if ( checkU( str[last] ) ) { // suffix 'u' ?83 Unsigned = true;84 if ( last > 0 && checkL( str[last - 1] ) ) { // suffix 'l' ?85 size = 1;86 if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ?87 size = 2;88 } // if89 } // if90 } else if ( checkL( str[ last ] ) ) { // suffix 'l' ?91 size = 1;92 if ( last > 0 && checkL( str[last - 1] ) ) { // suffix 'll' ?93 size = 2;94 if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ?95 Unsigned = true;96 } // if97 } else {98 if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ?99 Unsigned = true;100 } // if101 } // if102 } // if103 104 return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ), nullptr ) );105 } // makeConstantInteger106 107 ConstantNode *makeConstantFloat( std::string & str ) {108 static const BasicType::Kind kind[2][3] = {109 { BasicType::Float, BasicType::Double, BasicType::LongDouble },110 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },111 };112 113 bool complx = false; // real, complex114 int size = 1; // 0 => float, 1 => double (default), 2 => long double115 // floating-point constant has minimum of 2 characters: 1. or .1116 size_t last = str.length() - 1;117 118 if ( checkI( str[last] ) ) { // imaginary ?119 complx = true;120 last -= 1; // backup one character121 } // if122 123 if ( checkF( str[last] ) ) { // float ?124 size = 0;125 } else if ( checkD( str[last] ) ) { // double ?126 size = 1;127 } else if ( checkL( str[last] ) ) { // long double ?128 size = 2;129 } // if130 if ( ! complx && checkI( str[last - 1] ) ) { // imaginary ?131 complx = true;132 } // if133 134 return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ), nullptr ) );135 } // makeConstantFloat136 137 ConstantNode *makeConstantChar( std::string & str ) {138 return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ), nullptr ) );139 } // makeConstantChar140 141 ConstantNode *makeConstantStr( std::string & str ) {142 // string should probably be a primitive type143 ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ),144 new ConstantExpr(145 Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ),146 toString( str.size()+1-2 ) ) ), // +1 for '\0' and -2 for '"'147 false, false );148 return new ConstantNode( new ConstantExpr( Constant( at, str ), nullptr ) );149 } // makeConstantStr150 151 18 152 19 // Builder -
src/Parser/ParseNode.h
r0853178 r04273e9 10 10 // Created On : Sat May 16 13:28:16 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Fri Aug 5 07:49:32201613 // Update Count : 28812 // Last Modified On : Sun Aug 7 09:37:16 2016 13 // Update Count : 333 14 14 // 15 15 … … 30 30 #include "SynTree/Label.h" 31 31 32 class ExpressionNode;33 class CompositeExprNode;34 class CommaExprNode;35 32 class StatementNode; 36 33 class CompoundStmtNode; … … 56 53 void set_name( const std::string &newValue ) { name = newValue; } 57 54 58 virtual void print( std::ostream & , int indent = 0 ) const;59 virtual void printList( std::ostream & , int indent = 0 ) const;55 virtual void print( std::ostream &os, int indent = 0 ) const; 56 virtual void printList( std::ostream &os, int indent = 0 ) const; 60 57 61 58 ParseNode &operator,( ParseNode &); … … 68 65 ParseNode *mkList( ParseNode & ); 69 66 67 //############################################################################## 68 70 69 class ExpressionNode : public ParseNode { 71 70 public: … … 73 72 ExpressionNode( const std::string * ); 74 73 ExpressionNode( const ExpressionNode &other ); 75 virtual ~ExpressionNode() { delete argName; } // cannot delete argName because it might be referenced elsewhere74 virtual ~ExpressionNode() { delete argName; } 76 75 77 76 virtual ExpressionNode *clone() const = 0; 78 79 // virtual CommaExprNode *add_to_list( ExpressionNode * );80 77 81 78 ExpressionNode *get_argName() const { return argName; } … … 85 82 ExpressionNode *set_extension( bool exten ) { extension = exten; return this; } 86 83 87 virtual void print( std::ostream & , int indent = 0) const = 0;88 virtual void printOneLine( std::ostream & , int indent = 0) const = 0;84 virtual void print( std::ostream &os, int indent = 0) const = 0; 85 virtual void printOneLine( std::ostream &os, int indent = 0) const = 0; 89 86 90 87 virtual Expression *build() const = 0; 91 88 protected: 92 void printDesignation ( std::ostream & , int indent = 0) const;89 void printDesignation ( std::ostream &os, int indent = 0) const; 93 90 private: 94 91 ExpressionNode *argName = 0; … … 109 106 }; 110 107 108 //############################################################################## 109 111 110 // NullExprNode is used in tuples as a place-holder where a tuple component is omitted e.g., [ 2, , 3 ] 112 111 class NullExprNode : public ExpressionNode { … … 116 115 virtual NullExprNode *clone() const; 117 116 118 virtual void print( std::ostream & , int indent = 0) const;119 virtual void printOneLine( std::ostream & , int indent = 0) const;117 virtual void print( std::ostream &os, int indent = 0) const; 118 virtual void printOneLine( std::ostream &os, int indent = 0) const; 120 119 121 120 virtual Expression *build() const; 122 121 }; 123 122 123 //############################################################################## 124 124 125 class ConstantNode : public ExpressionNode { 125 126 public: 126 enum Type { Integer, Float, Character, String }; 127 128 ConstantNode( ConstantExpr * ); 129 ConstantNode( const ConstantNode &other ) : expr( other.expr->clone() ) {}; 130 ~ConstantNode() { delete expr; } 131 132 virtual ConstantNode *clone() const { return new ConstantNode( *this ); } 133 virtual void print( std::ostream &, int indent = 0) const; 134 virtual void printOneLine( std::ostream &, int indent = 0) const; 135 136 ConstantNode *appendstr( const std::string *newValue ); 137 138 Expression *build() const; 127 ConstantNode( ConstantExpr *expr ) : expr( expr ) {} 128 ConstantNode( const ConstantNode &other ) : expr( other.expr->clone() ) {} 129 virtual ~ConstantNode() {} 130 131 virtual ConstantNode *clone() const { assert( false ); return new ConstantNode( *this ); } 132 133 ConstantExpr *get_expr() const { return expr; } 134 135 virtual void print( std::ostream &os, int indent = 0 ) const {} 136 virtual void printOneLine( std::ostream &os, int indent = 0 ) const {} 137 138 Expression *build() const { return expr; } 139 139 private: 140 140 ConstantExpr *expr; 141 141 }; 142 142 143 ConstantNode *makeConstantInteger( std::string & ); 144 ConstantNode *makeConstantFloat( std::string & ); 145 ConstantNode *makeConstantChar( std::string & ); 146 ConstantNode *makeConstantStr( std::string & ); 143 ConstantNode *build_constantInteger( std::string &str ); 144 ConstantNode *build_constantFloat( std::string &str ); 145 ConstantNode *build_constantChar( std::string &str ); 146 ConstantNode *build_constantStr( std::string &str ); 147 148 //############################################################################## 147 149 148 150 class VarRefNode : public ExpressionNode { 149 151 public: 150 VarRefNode();151 152 VarRefNode( const std::string *, bool isLabel = false ); 152 153 VarRefNode( const VarRefNode &other ); … … 156 157 virtual VarRefNode *clone() const { return new VarRefNode( *this ); } 157 158 158 virtual void print( std::ostream & , int indent = 0 ) const;159 virtual void printOneLine( std::ostream & , int indent = 0 ) const;159 virtual void print( std::ostream &os, int indent = 0 ) const; 160 virtual void printOneLine( std::ostream &os, int indent = 0 ) const; 160 161 private: 161 162 bool isLabel; 162 163 }; 164 165 //############################################################################## 163 166 164 167 class DesignatorNode : public ExpressionNode { … … 170 173 virtual DesignatorNode *clone() const { return new DesignatorNode( *this ); } 171 174 172 virtual void print( std::ostream & , int indent = 0 ) const;173 virtual void printOneLine( std::ostream & , int indent = 0 ) const;175 virtual void print( std::ostream &os, int indent = 0 ) const; 176 virtual void printOneLine( std::ostream &os, int indent = 0 ) const; 174 177 private: 175 178 bool isArrayIndex; 176 179 }; 180 181 //############################################################################## 177 182 178 183 class TypeValueNode : public ExpressionNode { … … 187 192 virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); } 188 193 189 virtual void print( std::ostream & , int indent = 0) const;190 virtual void printOneLine( std::ostream & , int indent = 0) const;194 virtual void print( std::ostream &os, int indent = 0) const; 195 virtual void printOneLine( std::ostream &os, int indent = 0) const; 191 196 private: 192 197 DeclarationNode *decl; 193 198 }; 194 199 195 class OperatorNode : public ExpressionNode { 196 public: 197 enum Type { TupleC, Comma, TupleFieldSel, // n-adic 198 // triadic 199 Cond, NCond, 200 // diadic 201 SizeOf, AlignOf, OffsetOf, Attr, Plus, Minus, Mul, Div, Mod, Or, And, 202 BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq, 203 Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn, 204 Index, FieldSel, PFieldSel, Range, 205 // monadic 206 UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress, 207 Ctor, Dtor, 208 }; 209 210 OperatorNode( Type t ); 211 OperatorNode( const OperatorNode &other ); 212 virtual ~OperatorNode(); 213 214 virtual OperatorNode *clone() const { return new OperatorNode( *this ); } 215 216 Type get_type() const; 217 const char *get_typename() const; 218 219 virtual void print( std::ostream &, int indent = 0) const; 220 virtual void printOneLine( std::ostream &, int indent = 0) const; 221 222 virtual Expression *build() const { return 0; } 223 private: 224 Type type; 200 //############################################################################## 201 202 class CompositeExprNode : public ExpressionNode { 203 public: 204 CompositeExprNode( Expression *expr ) : expr( expr ) {} 205 CompositeExprNode( const CompositeExprNode &other ) : expr( other.expr->clone() ) {} 206 virtual ~CompositeExprNode() {} 207 208 CompositeExprNode *clone() const { assert( false ); return new CompositeExprNode( *this ); } 209 210 Expression *build() const { return expr; } 211 212 void print( std::ostream &os, int indent = 0 ) const {} 213 void printOneLine( std::ostream &os, int indent = 0 ) const {} 214 private: 215 Expression *expr; 216 }; 217 218 enum class OperKinds { 219 // diadic 220 SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And, 221 BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq, 222 Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn, 223 Index, Range, 224 // monadic 225 UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress, 226 Ctor, Dtor, 225 227 }; 226 228 … … 234 236 Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ); 235 237 Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ); 236 Expression *build_opr1( OperatorNode::Type op, ExpressionNode *expr_node ); 237 Expression *build_opr2( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ); 238 Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ); 239 Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ); 240 Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ); 241 Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ); 238 242 Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ); 239 243 Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ); 240 241 class CompositeExprNode2 : public ExpressionNode { 242 public: 243 CompositeExprNode2( Expression *expr ); 244 CompositeExprNode2( const CompositeExprNode2 &other ); 245 virtual ~CompositeExprNode2(); 246 247 virtual CompositeExprNode2 *clone() const { return new CompositeExprNode2( *this ); } 248 virtual Expression *build() const { return expr->clone(); } 249 250 virtual void print( std::ostream &, int indent = 0) const; 251 virtual void printOneLine( std::ostream &, int indent = 0) const; 252 private: 253 Expression *expr; 254 }; 255 256 class CompositeExprNode : public ExpressionNode { 257 public: 258 CompositeExprNode(); 259 CompositeExprNode( const std::string * ); 260 CompositeExprNode( ExpressionNode *f, ExpressionNode *args = 0 ); 261 CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 ); 262 CompositeExprNode( const CompositeExprNode &other ); 263 virtual ~CompositeExprNode(); 264 265 virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); } 266 virtual Expression *build() const; 267 268 virtual void print( std::ostream &, int indent = 0) const; 269 virtual void printOneLine( std::ostream &, int indent = 0) const; 270 271 void set_function( ExpressionNode * ); 272 void set_args( ExpressionNode * ); 273 274 void add_arg( ExpressionNode * ); 275 276 ExpressionNode *get_function() const; 277 ExpressionNode *get_args() const; 278 private: 279 ExpressionNode *function; 280 ExpressionNode *arguments; 281 }; 244 Expression *build_attr( VarRefNode *var, ExpressionNode * expr = 0 ); 245 Expression *build_tuple( ExpressionNode * expr = 0 ); 246 Expression *build_func( ExpressionNode * function, ExpressionNode * expr ); 247 Expression *build_range( ExpressionNode * low, ExpressionNode *high ); 248 249 //############################################################################## 282 250 283 251 class AsmExprNode : public ExpressionNode { … … 290 258 virtual Expression *build() const; 291 259 292 virtual void print( std::ostream & , int indent = 0) const;293 virtual void printOneLine( std::ostream & , int indent = 0) const;260 virtual void print( std::ostream &os, int indent = 0) const; 261 virtual void printOneLine( std::ostream &os, int indent = 0) const; 294 262 295 263 ExpressionNode *get_inout() const { return inout; }; … … 307 275 }; 308 276 277 //############################################################################## 278 309 279 class LabelNode : public ExpressionNode { 310 280 public: … … 312 282 virtual LabelNode *clone() const { return new LabelNode( *this ); } 313 283 314 virtual void print( std::ostream & , int indent = 0) const;315 virtual void printOneLine( std::ostream & , int indent = 0) const;284 virtual void print( std::ostream &os, int indent = 0) const; 285 virtual void printOneLine( std::ostream &os, int indent = 0) const; 316 286 317 287 const std::list< Label > &get_labels() const { return labels; }; … … 320 290 std::list< Label > labels; 321 291 }; 292 293 //############################################################################## 322 294 323 295 class ForCtlExprNode : public ExpressionNode { … … 334 306 virtual Expression *build() const; 335 307 336 virtual void print( std::ostream & , int indent = 0 ) const;337 virtual void printOneLine( std::ostream & , int indent = 0 ) const;308 virtual void print( std::ostream &os, int indent = 0 ) const; 309 virtual void printOneLine( std::ostream &os, int indent = 0 ) const; 338 310 private: 339 311 StatementNode *init; … … 341 313 ExpressionNode *change; 342 314 }; 315 316 //############################################################################## 343 317 344 318 class ValofExprNode : public ExpressionNode { … … 352 326 353 327 StatementNode *get_body() const { return body; } 354 void print( std::ostream & , int indent = 0 ) const;355 void printOneLine( std::ostream & , int indent = 0 ) const;328 void print( std::ostream &os, int indent = 0 ) const; 329 void printOneLine( std::ostream &os, int indent = 0 ) const; 356 330 Expression *build() const; 357 331 … … 359 333 StatementNode *body; 360 334 }; 335 336 //############################################################################## 361 337 362 338 class TypeData; … … 433 409 434 410 DeclarationNode *clone() const; 435 void print( std::ostream & , int indent = 0 ) const;436 void printList( std::ostream & , int indent = 0 ) const;411 void print( std::ostream &os, int indent = 0 ) const; 412 void printList( std::ostream &os, int indent = 0 ) const; 437 413 438 414 Declaration *build() const; … … 468 444 }; // DeclarationNode 469 445 446 //############################################################################## 447 470 448 class StatementNode : public ParseNode { 471 449 public: … … 507 485 StatementNode *append_last_case( StatementNode * ); 508 486 509 void print( std::ostream & , int indent = 0) const;487 void print( std::ostream &os, int indent = 0) const; 510 488 virtual StatementNode *clone() const; 511 489 virtual Statement *build() const; … … 521 499 }; // StatementNode 522 500 501 //############################################################################## 502 523 503 class CompoundStmtNode : public StatementNode { 524 504 public: … … 530 510 void add_statement( StatementNode * ); 531 511 532 void print( std::ostream & , int indent = 0 ) const;512 void print( std::ostream &os, int indent = 0 ) const; 533 513 virtual Statement *build() const; 534 514 private: 535 515 StatementNode *first, *last; 536 516 }; 517 518 //############################################################################## 537 519 538 520 class AsmStmtNode : public StatementNode { … … 541 523 ~AsmStmtNode(); 542 524 543 void print( std::ostream & , int indent = 0 ) const;525 void print( std::ostream &os, int indent = 0 ) const; 544 526 Statement *build() const; 545 527 private: … … 551 533 }; 552 534 535 //############################################################################## 536 553 537 class InitializerNode : public ParseNode { 554 538 public: … … 567 551 InitializerNode *next_init() const { return kids; } 568 552 569 void print( std::ostream & , int indent = 0 ) const;553 void print( std::ostream &os, int indent = 0 ) const; 570 554 void printOneLine( std::ostream & ) const; 571 555 … … 579 563 }; 580 564 565 //############################################################################## 566 581 567 class CompoundLiteralNode : public ExpressionNode { 582 568 public: … … 593 579 CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; } 594 580 595 void print( std::ostream & , int indent = 0 ) const;596 void printOneLine( std::ostream & , int indent = 0 ) const;581 void print( std::ostream &os, int indent = 0 ) const; 582 void printOneLine( std::ostream &os, int indent = 0 ) const; 597 583 598 584 virtual Expression *build() const; … … 631 617 void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList ); 632 618 633 // in ExpressionNode.cc634 ExpressionNode *flattenCommas( ExpressionNode *list );635 ExpressionNode *tupleContents( ExpressionNode *tuple );636 637 619 #endif // PARSENODE_H 638 620 -
src/Parser/StatementNode.cc
r0853178 r04273e9 10 10 // Created On : Sat May 16 14:59:41 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue Jul 12 17:21:02201613 // Update Count : 13 312 // Last Modified On : Sun Aug 7 06:42:38 2016 13 // Update Count : 135 14 14 // 15 15 … … 106 106 return this; 107 107 } 108 109 // StatementNode *StatementNode::add_controlexp( ExpressionNode *e ) {110 // if ( control && e )111 // control->add_to_list( e ); // xxx - check this112 // return this;113 // }114 108 115 109 StatementNode *StatementNode::append_block( StatementNode *stmt ) { … … 176 170 } // if 177 171 if ( block ) { 178 os << string( indent + ParseNode::indent_by, ' ' ) << " Branches of execution: " << endl;172 os << string( indent + ParseNode::indent_by, ' ' ) << "Cases: " << endl; 179 173 block->printList( os, indent + 2 * ParseNode::indent_by ); 180 174 } // if -
src/Parser/TypeData.cc
r0853178 r04273e9 10 10 // Created On : Sat May 16 15:12:51 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Wed Jul 13 18:03:29201613 // Update Count : 5 612 // Last Modified On : Sun Aug 7 07:51:48 2016 13 // Update Count : 58 14 14 // 15 15 … … 182 182 break; 183 183 case Array: 184 newtype->array->dimension = maybeClone( array->dimension ); 184 //PAB newtype->array->dimension = maybeClone( array->dimension ); 185 newtype->array->dimension = array->dimension; 185 186 newtype->array->isVarLen = array->isVarLen; 186 187 newtype->array->isStatic = array->isStatic; -
src/Parser/parser.cc
r0853178 r04273e9 89 89 TypedefTable typedefTable; 90 90 91 void appendStr( std::string &to, std::string *from ) { 92 // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string. 93 to.insert( to.length() - 1, from->substr( 1, from->length() - 2 ) ); 94 } // appendStr 95 91 96 92 97 /* Line 268 of yacc.c */ 93 #line 9 4"Parser/parser.cc"98 #line 99 "Parser/parser.cc" 94 99 95 100 /* Enabling traces. */ … … 342 347 343 348 /* Line 293 of yacc.c */ 344 #line 11 0"parser.yy"349 #line 115 "parser.yy" 345 350 346 351 Token tok; … … 354 359 LabelNode *label; 355 360 InitializerNode *in; 356 Oper atorNode::Typeop;361 OperKinds op; 357 362 bool flag; 358 363 … … 360 365 361 366 /* Line 293 of yacc.c */ 362 #line 36 3"Parser/parser.cc"367 #line 368 "Parser/parser.cc" 363 368 } YYSTYPE; 364 369 # define YYSTYPE_IS_TRIVIAL 1 … … 372 377 373 378 /* Line 343 of yacc.c */ 374 #line 3 75"Parser/parser.cc"379 #line 380 "Parser/parser.cc" 375 380 376 381 #ifdef short … … 589 594 590 595 /* YYFINAL -- State number of the termination state. */ 591 #define YYFINAL 25 2596 #define YYFINAL 251 592 597 /* YYLAST -- Last index in YYTABLE. */ 593 #define YYLAST 1 2080598 #define YYLAST 10969 594 599 595 600 /* YYNTOKENS -- Number of terminals. */ … … 598 603 #define YYNNTS 241 599 604 /* YYNRULES -- Number of rules. */ 600 #define YYNRULES 75 5605 #define YYNRULES 754 601 606 /* YYNRULES -- Number of states. */ 602 #define YYNSTATES 157 9607 #define YYNSTATES 1577 603 608 604 609 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ … … 663 668 172, 175, 178, 181, 184, 187, 190, 195, 202, 204, 664 669 209, 214, 217, 222, 224, 226, 228, 230, 232, 234, 665 236, 2 38, 243, 248, 250, 254, 258, 262, 264, 268,666 272, 27 4, 278, 282, 284, 288, 292, 296, 300, 302,667 30 6, 310, 312, 316, 318, 322, 324, 328, 330, 334,668 33 6, 340, 342, 348, 353, 359, 361, 363, 367, 371,669 37 4, 375, 377, 380, 386, 393, 401, 403, 407, 409,670 411, 413, 415, 417, 419, 421, 423, 425, 427, 429,671 43 3, 434, 436, 438, 440, 442, 444, 446, 448, 450,672 45 2, 459, 464, 467, 475, 477, 481, 483, 486, 488,673 4 91, 493, 496, 499, 505, 513, 519, 529, 535, 545,674 547, 5 51, 553, 555, 559, 563, 566, 568, 571, 574,675 57 5, 577, 580, 584, 585, 587, 590, 594, 598, 603,676 60 4, 606, 608, 611, 617, 625, 632, 639, 644, 648,677 65 3, 656, 660, 663, 667, 671, 675, 679, 685, 689,678 69 3, 698, 700, 706, 713, 719, 726, 736, 747, 757,679 76 8, 771, 773, 776, 779, 782, 784, 791, 800, 811,680 8 24, 839, 840, 842, 843, 845, 847, 851, 856, 864,681 86 5, 867, 871, 873, 877, 879, 881, 883, 887, 889,682 8 91, 893, 897, 898, 900, 904, 909, 911, 915, 917,683 919, 923, 927, 931, 935, 93 9, 942, 946, 953, 957,684 96 1, 966, 968, 971, 974, 978, 984, 993, 1001, 1009,685 10 15, 1025, 1028, 1031, 1037, 1041, 1047, 1052, 1056, 1061,686 10 66, 1074, 1078, 1082, 1086, 1090, 1095, 1102, 1104, 1106,687 110 8, 1110, 1112, 1114, 1116, 1118, 1119, 1121, 1123, 1126,688 112 8, 1130, 1132, 1134, 1136, 1138, 1140, 1141, 1147, 1149,689 1152, 115 6, 1158, 1161, 1163, 1165, 1167, 1169, 1171, 1173,690 117 5, 1177, 1179, 1181, 1183, 1185, 1187, 1189, 1191, 1193,691 119 5, 1197, 1199, 1201, 1203, 1205, 1207, 1210, 1213, 1217,692 12 21, 1223, 1227, 1229, 1232, 1235, 1238, 1243, 1248, 1253,693 125 8, 1260, 1263, 1266, 1270, 1272, 1275, 1278, 1280, 1283,694 1286, 12 90, 1292, 1295, 1298, 1300, 1302, 1307, 1310, 1311,695 13 18, 1326, 1329, 1332, 1335, 1336, 1339, 1342, 1346, 1349,696 135 3, 1355, 1358, 1362, 1365, 1368, 1373, 1374, 1376, 1379,697 138 2, 1384, 1385, 1387, 1390, 1393, 1399, 1402, 1403, 1411,698 141 4, 1419, 1420, 1423, 1424, 1426, 1428, 1430, 1436, 1442,699 144 8, 1450, 1456, 1462, 1472, 1474, 1480, 1481, 1483, 1485,700 14 91, 1493, 1495, 1501, 1507, 1509, 1513, 1517, 1522, 1524,701 152 6, 1528, 1530, 1533, 1535, 1539, 1543, 1545, 1548, 1550,702 155 4, 1556, 1558, 1560, 1562, 1564, 1566, 1568, 1570, 1572,703 157 4, 1576, 1579, 1581, 1583, 1585, 1588, 1589, 1592, 1595,704 159 7, 1602, 1603, 1605, 1608, 1612, 1617, 1620, 1623, 1625,705 162 8, 1630, 1633, 1639, 1645, 1653, 1660, 1662, 1665, 1668,706 167 2, 1674, 1677, 1680, 1685, 1688, 1693, 1694, 1699, 1702,707 170 4, 1706, 1708, 1709, 1712, 1718, 1724, 1738, 1740, 1742,708 1746, 17 50, 1753, 1757, 1761, 1764, 1769, 1771, 1778, 1788,709 17 89, 1801, 1803, 1807, 1811, 1815, 1817, 1819, 1825, 1828,710 183 4, 1835, 1837, 1839, 1843, 1844, 1846, 1848, 1850, 1852,711 185 3, 1860, 1863, 1865, 1868, 1873, 1876, 1880, 1884, 1888,712 189 3, 1899, 1905, 1911, 1918, 1920, 1922, 1924, 1928, 1929,713 193 5, 1936, 1938, 1940, 1943, 1950, 1952, 1956, 1957, 1959,714 196 4, 1966, 1968, 1970, 1972, 1975, 1977, 1980, 1983, 1985,715 198 9, 1992, 1996, 2000, 2003, 2008, 2013, 2017, 2026, 2030,716 203 3, 2035, 2038, 2045, 2054, 2058, 2061, 2065, 2069, 2074,717 2079, 208 3, 2085, 2087, 2089, 2094, 2101, 2105, 2108, 2112,718 211 6, 2121, 2126, 2130, 2133, 2135, 2138, 2141, 2143, 2147,719 2150, 2154, 215 8, 2161, 2166, 2171, 2175, 2182, 2191, 2195,720 219 8, 2200, 2203, 2206, 2209, 2213, 2217, 2220, 2225, 2230,721 223 4, 2241, 2250, 2254, 2257, 2259, 2262, 2265, 2267, 2269,722 2272, 2276, 22 80, 2283, 2288, 2295, 2304, 2306, 2309, 2312,723 231 4, 2317, 2320, 2324, 2328, 2330, 2335, 2340, 2344, 2350,724 2359, 236 3, 2366, 2370, 2372, 2378, 2384, 2391, 2398, 2400,725 240 3, 2406, 2408, 2411, 2414, 2418, 2422, 2424, 2429, 2434,726 24 38, 2444, 2453, 2457, 2459, 2462, 2464, 2467, 2474, 2480,727 24 87, 2495, 2503, 2505, 2508, 2511, 2513, 2516, 2519, 2523,728 252 7, 2529, 2534, 2539, 2543, 2552, 2556, 2558, 2560, 2563,729 256 5, 2567, 2570, 2574, 2577, 2581, 2584, 2588, 2592, 2595,730 2600, 260 4, 2607, 2611, 2614, 2619, 2623, 2626, 2633, 2640,731 26 47, 2655, 2657, 2660, 2662, 2664, 2666, 2669, 2673, 2676,732 26 80, 2683, 2687, 2691, 2696, 2699, 2703, 2708, 2711, 2717,733 272 3, 2730, 2737, 2738, 2740, 2741670 236, 241, 246, 248, 252, 256, 260, 262, 266, 270, 671 272, 276, 280, 282, 286, 290, 294, 298, 300, 304, 672 308, 310, 314, 316, 320, 322, 326, 328, 332, 334, 673 338, 340, 346, 351, 357, 359, 361, 365, 368, 369, 674 371, 373, 375, 377, 379, 381, 383, 385, 387, 389, 675 391, 393, 396, 402, 409, 417, 419, 423, 425, 429, 676 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 677 455, 460, 463, 471, 473, 477, 479, 482, 484, 487, 678 489, 492, 495, 501, 509, 515, 525, 531, 541, 543, 679 547, 549, 551, 555, 559, 562, 564, 567, 570, 571, 680 573, 576, 580, 581, 583, 586, 590, 594, 599, 600, 681 602, 604, 607, 613, 621, 628, 635, 640, 644, 649, 682 652, 656, 659, 663, 667, 671, 675, 681, 685, 689, 683 694, 696, 702, 709, 715, 722, 732, 743, 753, 764, 684 767, 769, 772, 775, 778, 780, 787, 796, 807, 820, 685 835, 836, 838, 839, 841, 843, 847, 852, 860, 861, 686 863, 867, 869, 873, 875, 877, 879, 883, 885, 887, 687 889, 893, 894, 896, 900, 905, 907, 911, 913, 915, 688 919, 923, 927, 931, 935, 938, 942, 949, 953, 957, 689 962, 964, 967, 970, 974, 980, 989, 997, 1005, 1011, 690 1021, 1024, 1027, 1033, 1037, 1043, 1048, 1052, 1057, 1062, 691 1070, 1074, 1078, 1082, 1086, 1091, 1098, 1100, 1102, 1104, 692 1106, 1108, 1110, 1112, 1114, 1115, 1117, 1119, 1122, 1124, 693 1126, 1128, 1130, 1132, 1134, 1136, 1137, 1143, 1145, 1148, 694 1152, 1154, 1157, 1159, 1161, 1163, 1165, 1167, 1169, 1171, 695 1173, 1175, 1177, 1179, 1181, 1183, 1185, 1187, 1189, 1191, 696 1193, 1195, 1197, 1199, 1201, 1203, 1206, 1209, 1213, 1217, 697 1219, 1223, 1225, 1228, 1231, 1234, 1239, 1244, 1249, 1254, 698 1256, 1259, 1262, 1266, 1268, 1271, 1274, 1276, 1279, 1282, 699 1286, 1288, 1291, 1294, 1296, 1298, 1303, 1306, 1307, 1314, 700 1322, 1325, 1328, 1331, 1332, 1335, 1338, 1342, 1345, 1349, 701 1351, 1354, 1358, 1361, 1364, 1369, 1370, 1372, 1375, 1378, 702 1380, 1381, 1383, 1386, 1389, 1395, 1398, 1399, 1407, 1410, 703 1415, 1416, 1419, 1420, 1422, 1424, 1426, 1432, 1438, 1444, 704 1446, 1452, 1458, 1468, 1470, 1476, 1477, 1479, 1481, 1487, 705 1489, 1491, 1497, 1503, 1505, 1509, 1513, 1518, 1520, 1522, 706 1524, 1526, 1529, 1531, 1535, 1539, 1541, 1544, 1546, 1550, 707 1552, 1554, 1556, 1558, 1560, 1562, 1564, 1566, 1568, 1570, 708 1572, 1575, 1577, 1579, 1581, 1584, 1585, 1588, 1591, 1593, 709 1598, 1599, 1601, 1604, 1608, 1613, 1616, 1619, 1621, 1624, 710 1626, 1629, 1635, 1641, 1649, 1656, 1658, 1661, 1664, 1668, 711 1670, 1673, 1676, 1681, 1684, 1689, 1690, 1695, 1698, 1700, 712 1702, 1704, 1705, 1708, 1714, 1720, 1734, 1736, 1738, 1742, 713 1746, 1749, 1753, 1757, 1760, 1765, 1767, 1774, 1784, 1785, 714 1797, 1799, 1803, 1807, 1811, 1813, 1815, 1821, 1824, 1830, 715 1831, 1833, 1835, 1839, 1840, 1842, 1844, 1846, 1848, 1849, 716 1856, 1859, 1861, 1864, 1869, 1872, 1876, 1880, 1884, 1889, 717 1895, 1901, 1907, 1914, 1916, 1918, 1920, 1924, 1925, 1931, 718 1932, 1934, 1936, 1939, 1946, 1948, 1952, 1953, 1955, 1960, 719 1962, 1964, 1966, 1968, 1971, 1973, 1976, 1979, 1981, 1985, 720 1988, 1992, 1996, 1999, 2004, 2009, 2013, 2022, 2026, 2029, 721 2031, 2034, 2041, 2050, 2054, 2057, 2061, 2065, 2070, 2075, 722 2079, 2081, 2083, 2085, 2090, 2097, 2101, 2104, 2108, 2112, 723 2117, 2122, 2126, 2129, 2131, 2134, 2137, 2139, 2143, 2146, 724 2150, 2154, 2157, 2162, 2167, 2171, 2178, 2187, 2191, 2194, 725 2196, 2199, 2202, 2205, 2209, 2213, 2216, 2221, 2226, 2230, 726 2237, 2246, 2250, 2253, 2255, 2258, 2261, 2263, 2265, 2268, 727 2272, 2276, 2279, 2284, 2291, 2300, 2302, 2305, 2308, 2310, 728 2313, 2316, 2320, 2324, 2326, 2331, 2336, 2340, 2346, 2355, 729 2359, 2362, 2366, 2368, 2374, 2380, 2387, 2394, 2396, 2399, 730 2402, 2404, 2407, 2410, 2414, 2418, 2420, 2425, 2430, 2434, 731 2440, 2449, 2453, 2455, 2458, 2460, 2463, 2470, 2476, 2483, 732 2491, 2499, 2501, 2504, 2507, 2509, 2512, 2515, 2519, 2523, 733 2525, 2530, 2535, 2539, 2548, 2552, 2554, 2556, 2559, 2561, 734 2563, 2566, 2570, 2573, 2577, 2580, 2584, 2588, 2591, 2596, 735 2600, 2603, 2607, 2610, 2615, 2619, 2622, 2629, 2636, 2643, 736 2651, 2653, 2656, 2658, 2660, 2662, 2665, 2669, 2672, 2676, 737 2679, 2683, 2687, 2692, 2695, 2699, 2704, 2707, 2713, 2719, 738 2726, 2733, 2734, 2736, 2737 734 739 }; 735 740 … … 749 754 144, 115, -1, 145, -1, 144, 116, 145, -1, -1, 750 755 164, -1, 139, 117, 164, -1, 111, 134, 164, 135, 751 112, 117, 164, -1, 111, 134, 164, 116, 16 7, 135,756 112, 117, 164, -1, 111, 134, 164, 116, 168, 135, 752 757 112, 117, 164, -1, 147, -1, 146, 116, 147, -1, 753 758 139, -1, 139, 113, 147, -1, 139, 113, 111, 134, … … 759 764 110, -1, 76, -1, 76, 109, 276, 110, -1, 76, 760 765 109, 145, 110, -1, 66, 148, -1, 66, 109, 275, 761 110, -1, 118, -1, 119, -1, 94, -1, 120, -1, 762 121, -1, 122, -1, 123, -1, 148, -1, 109, 275, 763 110, 151, -1, 109, 275, 110, 166, -1, 151, -1, 764 152, 118, 151, -1, 152, 124, 151, -1, 152, 125, 765 151, -1, 152, -1, 153, 120, 152, -1, 153, 121, 766 152, -1, 153, -1, 154, 88, 153, -1, 154, 89, 767 153, -1, 154, -1, 155, 126, 154, -1, 155, 127, 768 154, -1, 155, 90, 154, -1, 155, 91, 154, -1, 769 155, -1, 156, 92, 155, -1, 156, 93, 155, -1, 770 156, -1, 157, 119, 156, -1, 157, -1, 158, 128, 771 157, -1, 158, -1, 159, 129, 158, -1, 159, -1, 772 160, 94, 159, -1, 160, -1, 161, 95, 160, -1, 773 161, -1, 161, 130, 169, 117, 162, -1, 161, 130, 774 117, 162, -1, 161, 130, 169, 117, 166, -1, 162, 775 -1, 162, -1, 148, 131, 164, -1, 148, 168, 164, 776 -1, 166, 373, -1, -1, 164, -1, 111, 112, -1, 777 111, 134, 164, 135, 112, -1, 111, 134, 116, 167, 778 135, 112, -1, 111, 134, 164, 116, 167, 135, 112, 779 -1, 165, -1, 167, 116, 165, -1, 97, -1, 98, 780 -1, 99, -1, 100, -1, 101, -1, 102, -1, 103, 781 -1, 104, -1, 105, -1, 106, -1, 164, -1, 169, 782 116, 164, -1, -1, 169, -1, 172, -1, 173, -1, 783 177, -1, 178, -1, 190, -1, 192, -1, 193, -1, 784 198, -1, 128, 143, 114, 144, 115, 132, -1, 72, 785 117, 312, 171, -1, 114, 115, -1, 114, 134, 134, 786 209, 174, 135, 115, -1, 175, -1, 174, 134, 175, 787 -1, 212, -1, 40, 212, -1, 308, -1, 171, 135, 788 -1, 171, -1, 176, 171, -1, 170, 132, -1, 41, 789 109, 169, 110, 171, -1, 41, 109, 169, 110, 171, 790 42, 171, -1, 43, 109, 169, 110, 183, -1, 43, 791 109, 169, 110, 114, 134, 205, 184, 115, -1, 53, 792 109, 169, 110, 183, -1, 53, 109, 169, 110, 114, 793 134, 205, 186, 115, -1, 163, -1, 163, 96, 163, 794 -1, 310, -1, 179, -1, 180, 116, 179, -1, 44, 795 180, 117, -1, 45, 117, -1, 181, -1, 182, 181, 796 -1, 182, 171, -1, -1, 185, -1, 182, 176, -1, 797 185, 182, 176, -1, -1, 187, -1, 182, 189, -1, 798 182, 176, 188, -1, 187, 182, 189, -1, 187, 182, 799 176, 188, -1, -1, 189, -1, 56, -1, 56, 132, 800 -1, 47, 109, 169, 110, 171, -1, 46, 171, 47, 801 109, 169, 110, 132, -1, 48, 109, 134, 191, 110, 802 171, -1, 170, 135, 132, 170, 132, 170, -1, 212, 803 170, 132, 170, -1, 51, 72, 132, -1, 51, 118, 804 169, 132, -1, 50, 132, -1, 50, 72, 132, -1, 805 49, 132, -1, 49, 72, 132, -1, 52, 170, 132, 806 -1, 61, 165, 132, -1, 62, 165, 132, -1, 62, 807 165, 63, 164, 132, -1, 57, 173, 194, -1, 57, 808 173, 196, -1, 57, 173, 194, 196, -1, 195, -1, 809 58, 109, 96, 110, 173, -1, 195, 58, 109, 96, 810 110, 173, -1, 59, 109, 96, 110, 173, -1, 195, 811 59, 109, 96, 110, 173, -1, 58, 109, 134, 134, 812 197, 135, 110, 173, 135, -1, 195, 58, 109, 134, 813 134, 197, 135, 110, 173, 135, -1, 59, 109, 134, 814 134, 197, 135, 110, 173, 135, -1, 195, 59, 109, 815 134, 134, 197, 135, 110, 173, 135, -1, 60, 173, 816 -1, 225, -1, 225, 309, -1, 225, 357, -1, 366, 817 139, -1, 366, -1, 64, 199, 109, 141, 110, 132, 818 -1, 64, 199, 109, 141, 117, 200, 110, 132, -1, 819 64, 199, 109, 141, 117, 200, 117, 200, 110, 132, 820 -1, 64, 199, 109, 141, 117, 200, 117, 200, 117, 821 203, 110, 132, -1, 64, 199, 51, 109, 141, 117, 822 117, 200, 117, 203, 117, 204, 110, 132, -1, -1, 823 11, -1, -1, 201, -1, 202, -1, 201, 116, 202, 824 -1, 141, 109, 163, 110, -1, 111, 163, 112, 141, 825 109, 163, 110, -1, -1, 141, -1, 203, 116, 141, 826 -1, 139, -1, 204, 116, 139, -1, 135, -1, 206, 827 -1, 212, -1, 206, 134, 212, -1, 135, -1, 208, 828 -1, 222, -1, 208, 134, 222, -1, -1, 210, -1, 829 29, 211, 132, -1, 210, 29, 211, 132, -1, 274, 830 -1, 211, 116, 274, -1, 213, -1, 222, -1, 214, 831 135, 132, -1, 219, 135, 132, -1, 216, 135, 132, 832 -1, 293, 135, 132, -1, 296, 135, 132, -1, 215, 833 277, -1, 231, 215, 277, -1, 214, 135, 116, 134, 834 272, 277, -1, 367, 272, 311, -1, 370, 272, 311, 835 -1, 227, 370, 272, 311, -1, 217, -1, 227, 217, 836 -1, 231, 217, -1, 231, 227, 217, -1, 216, 135, 837 116, 134, 272, -1, 111, 112, 272, 109, 134, 260, 838 135, 110, -1, 370, 272, 109, 134, 260, 135, 110, 839 -1, 218, 272, 109, 134, 260, 135, 110, -1, 111, 840 134, 262, 135, 112, -1, 111, 134, 262, 135, 116, 841 134, 263, 135, 112, -1, 3, 215, -1, 3, 217, 842 -1, 219, 135, 116, 134, 139, -1, 3, 225, 309, 843 -1, 220, 135, 116, 134, 309, -1, 227, 3, 225, 844 309, -1, 225, 3, 309, -1, 225, 3, 227, 309, 845 -1, 3, 139, 131, 164, -1, 221, 135, 116, 134, 846 139, 131, 164, -1, 223, 135, 132, -1, 220, 135, 847 132, -1, 221, 135, 132, -1, 240, 135, 132, -1, 848 224, 309, 311, 277, -1, 223, 116, 312, 309, 311, 849 277, -1, 236, -1, 240, -1, 242, -1, 283, -1, 850 237, -1, 241, -1, 243, -1, 284, -1, -1, 227, 851 -1, 228, -1, 227, 228, -1, 229, -1, 314, -1, 852 10, -1, 12, -1, 11, -1, 14, -1, 67, -1, 853 -1, 13, 109, 230, 286, 110, -1, 232, -1, 227, 854 232, -1, 231, 227, 232, -1, 233, -1, 232, 233, 855 -1, 234, -1, 5, -1, 7, -1, 4, -1, 6, 856 -1, 8, -1, 9, -1, 69, -1, 71, -1, 16, 857 -1, 21, -1, 20, -1, 18, -1, 19, -1, 17, 858 -1, 22, -1, 23, -1, 15, -1, 25, -1, 26, 859 -1, 27, -1, 24, -1, 237, -1, 231, 237, -1, 860 236, 233, -1, 236, 233, 227, -1, 236, 233, 237, 861 -1, 238, -1, 226, 239, 226, -1, 235, -1, 227, 862 235, -1, 238, 228, -1, 238, 235, -1, 28, 109, 863 276, 110, -1, 28, 109, 169, 110, -1, 78, 109, 864 276, 110, -1, 78, 109, 169, 110, -1, 241, -1, 865 231, 241, -1, 240, 233, -1, 240, 233, 227, -1, 866 244, -1, 227, 244, -1, 241, 228, -1, 243, -1, 867 231, 243, -1, 242, 233, -1, 242, 233, 227, -1, 868 74, -1, 227, 74, -1, 243, 228, -1, 245, -1, 869 256, -1, 247, 114, 248, 115, -1, 247, 274, -1, 870 -1, 247, 274, 246, 114, 248, 115, -1, 247, 109, 871 292, 110, 114, 248, 115, -1, 247, 285, -1, 31, 872 312, -1, 32, 312, -1, -1, 248, 249, -1, 250, 873 132, -1, 40, 250, 132, -1, 251, 132, -1, 40, 874 251, 132, -1, 366, -1, 366, 274, -1, 250, 116, 875 274, -1, 250, 116, -1, 225, 252, -1, 251, 116, 876 312, 252, -1, -1, 254, -1, 318, 253, -1, 331, 877 253, -1, 357, -1, -1, 254, -1, 117, 163, -1, 878 30, 312, -1, 255, 114, 258, 372, 115, -1, 255, 879 274, -1, -1, 255, 274, 257, 114, 258, 372, 115, 880 -1, 274, 259, -1, 258, 116, 274, 259, -1, -1, 881 131, 163, -1, -1, 261, -1, 263, -1, 262, -1, 882 262, 135, 116, 134, 263, -1, 263, 135, 116, 134, 883 96, -1, 262, 135, 116, 134, 96, -1, 267, -1, 884 263, 135, 116, 134, 267, -1, 262, 135, 116, 134, 885 267, -1, 262, 135, 116, 134, 263, 135, 116, 134, 886 267, -1, 268, -1, 263, 135, 116, 134, 268, -1, 887 -1, 265, -1, 266, -1, 266, 135, 116, 134, 96, 888 -1, 270, -1, 269, -1, 266, 135, 116, 134, 270, 889 -1, 266, 135, 116, 134, 269, -1, 269, -1, 362, 890 272, 373, -1, 370, 272, 373, -1, 227, 370, 272, 891 373, -1, 217, -1, 270, -1, 362, -1, 370, -1, 892 227, 370, -1, 371, -1, 224, 336, 373, -1, 224, 893 340, 373, -1, 224, -1, 224, 351, -1, 139, -1, 894 271, 116, 139, -1, 137, -1, 74, -1, 75, -1, 895 138, -1, 74, -1, 75, -1, 139, -1, 74, -1, 896 75, -1, 366, -1, 225, -1, 225, 357, -1, 366, 897 -1, 371, -1, 225, -1, 225, 345, -1, -1, 131, 898 278, -1, 107, 278, -1, 164, -1, 114, 279, 372, 899 115, -1, -1, 278, -1, 280, 278, -1, 279, 116, 900 278, -1, 279, 116, 280, 278, -1, 281, 117, -1, 901 274, 117, -1, 282, -1, 281, 282, -1, 80, -1, 902 113, 274, -1, 111, 134, 164, 135, 112, -1, 111, 903 134, 310, 135, 112, -1, 111, 134, 163, 96, 163, 904 135, 112, -1, 113, 111, 134, 146, 135, 112, -1, 905 284, -1, 231, 284, -1, 283, 233, -1, 283, 233, 906 227, -1, 285, -1, 227, 285, -1, 284, 228, -1, 907 75, 109, 292, 110, -1, 287, 373, -1, 286, 116, 908 287, 373, -1, -1, 289, 274, 288, 290, -1, 225, 909 336, -1, 33, -1, 35, -1, 34, -1, -1, 290, 910 291, -1, 129, 274, 109, 292, 110, -1, 129, 114, 911 134, 298, 115, -1, 129, 109, 134, 286, 135, 110, 912 114, 134, 298, 115, 109, 292, 110, -1, 276, -1, 913 164, -1, 292, 116, 276, -1, 292, 116, 164, -1, 914 33, 294, -1, 232, 33, 294, -1, 293, 116, 294, 915 -1, 295, 290, -1, 295, 290, 131, 276, -1, 274, 916 -1, 273, 109, 134, 286, 135, 110, -1, 36, 274, 917 109, 134, 286, 135, 110, 114, 115, -1, -1, 36, 918 274, 109, 134, 286, 135, 110, 114, 297, 298, 115, 919 -1, 299, -1, 298, 134, 299, -1, 300, 135, 132, 920 -1, 301, 135, 132, -1, 215, -1, 217, -1, 300, 921 135, 116, 134, 272, -1, 225, 309, -1, 301, 135, 922 116, 134, 309, -1, -1, 303, -1, 305, -1, 303, 923 134, 305, -1, -1, 303, -1, 212, -1, 307, -1, 924 198, -1, -1, 5, 82, 306, 114, 304, 115, -1, 925 40, 305, -1, 308, -1, 323, 173, -1, 327, 134, 926 207, 173, -1, 216, 173, -1, 224, 323, 173, -1, 927 227, 323, 173, -1, 231, 323, 173, -1, 231, 227, 928 323, 173, -1, 224, 327, 134, 207, 173, -1, 227, 929 327, 134, 207, 173, -1, 231, 327, 134, 207, 173, 930 -1, 231, 227, 327, 134, 207, 173, -1, 318, -1, 931 331, -1, 323, -1, 163, 123, 163, -1, -1, 64, 932 109, 141, 110, 312, -1, -1, 313, -1, 314, -1, 933 313, 314, -1, 39, 109, 109, 315, 110, 110, -1, 934 316, -1, 315, 116, 316, -1, -1, 317, -1, 317, 935 109, 170, 110, -1, 272, -1, 234, -1, 235, -1, 936 228, -1, 319, 312, -1, 320, -1, 321, 312, -1, 937 322, 312, -1, 137, -1, 109, 319, 110, -1, 149, 938 318, -1, 149, 227, 318, -1, 109, 320, 110, -1, 939 319, 349, -1, 109, 320, 110, 349, -1, 109, 321, 940 110, 350, -1, 109, 321, 110, -1, 109, 320, 110, 941 109, 134, 264, 135, 110, -1, 109, 322, 110, -1, 942 324, 312, -1, 325, -1, 326, 312, -1, 319, 109, 943 134, 264, 135, 110, -1, 109, 325, 110, 109, 134, 944 264, 135, 110, -1, 109, 324, 110, -1, 149, 323, 945 -1, 149, 227, 323, -1, 109, 325, 110, -1, 109, 946 325, 110, 349, -1, 109, 326, 110, 350, -1, 109, 947 326, 110, -1, 328, -1, 329, -1, 330, -1, 319, 948 109, 271, 110, -1, 109, 329, 110, 109, 271, 110, 949 -1, 109, 328, 110, -1, 149, 327, -1, 149, 227, 950 327, -1, 109, 329, 110, -1, 109, 329, 110, 349, 951 -1, 109, 330, 110, 350, -1, 109, 330, 110, -1, 952 332, 312, -1, 333, -1, 334, 312, -1, 335, 312, 953 -1, 341, -1, 109, 332, 110, -1, 149, 331, -1, 954 149, 227, 331, -1, 109, 333, 110, -1, 332, 349, 955 -1, 109, 333, 110, 349, -1, 109, 334, 110, 350, 956 -1, 109, 334, 110, -1, 332, 109, 134, 264, 135, 957 110, -1, 109, 333, 110, 109, 134, 264, 135, 110, 958 -1, 109, 335, 110, -1, 319, 312, -1, 337, -1, 959 338, 312, -1, 339, 312, -1, 149, 336, -1, 149, 960 227, 336, -1, 109, 337, 110, -1, 319, 355, -1, 961 109, 337, 110, 349, -1, 109, 338, 110, 350, -1, 962 109, 338, 110, -1, 319, 109, 134, 264, 135, 110, 963 -1, 109, 337, 110, 109, 134, 264, 135, 110, -1, 964 109, 339, 110, -1, 341, 312, -1, 342, -1, 343, 965 312, -1, 344, 312, -1, 74, -1, 75, -1, 149, 966 340, -1, 149, 227, 340, -1, 109, 342, 110, -1, 967 341, 355, -1, 109, 342, 110, 355, -1, 341, 109, 968 134, 264, 135, 110, -1, 109, 342, 110, 109, 134, 969 264, 135, 110, -1, 346, -1, 347, 312, -1, 348, 970 312, -1, 149, -1, 149, 227, -1, 149, 345, -1, 971 149, 227, 345, -1, 109, 346, 110, -1, 349, -1, 972 109, 346, 110, 349, -1, 109, 347, 110, 350, -1, 973 109, 347, 110, -1, 109, 134, 264, 135, 110, -1, 974 109, 346, 110, 109, 134, 264, 135, 110, -1, 109, 975 348, 110, -1, 111, 112, -1, 111, 112, 350, -1, 976 350, -1, 111, 134, 164, 135, 112, -1, 111, 134, 977 118, 135, 112, -1, 350, 111, 134, 164, 135, 112, 978 -1, 350, 111, 134, 118, 135, 112, -1, 352, -1, 979 353, 312, -1, 354, 312, -1, 149, -1, 149, 227, 980 -1, 149, 351, -1, 149, 227, 351, -1, 109, 352, 981 110, -1, 355, -1, 109, 352, 110, 355, -1, 109, 982 353, 110, 350, -1, 109, 353, 110, -1, 109, 134, 983 264, 135, 110, -1, 109, 352, 110, 109, 134, 264, 984 135, 110, -1, 109, 354, 110, -1, 356, -1, 356, 985 350, -1, 350, -1, 111, 112, -1, 111, 134, 227, 986 118, 135, 112, -1, 111, 134, 227, 135, 112, -1, 987 111, 134, 227, 164, 135, 112, -1, 111, 134, 7, 988 226, 164, 135, 112, -1, 111, 134, 227, 7, 164, 989 135, 112, -1, 358, -1, 359, 312, -1, 360, 312, 990 -1, 149, -1, 149, 227, -1, 149, 357, -1, 149, 991 227, 357, -1, 109, 358, 110, -1, 349, -1, 109, 992 358, 110, 349, -1, 109, 359, 110, 350, -1, 109, 993 359, 110, -1, 109, 358, 110, 109, 134, 264, 135, 994 110, -1, 109, 360, 110, -1, 362, -1, 370, -1, 995 227, 370, -1, 363, -1, 364, -1, 149, 225, -1, 996 227, 149, 225, -1, 149, 371, -1, 227, 149, 371, 997 -1, 149, 361, -1, 227, 149, 361, -1, 111, 112, 998 225, -1, 365, 225, -1, 111, 112, 350, 225, -1, 999 365, 350, 225, -1, 350, 225, -1, 111, 112, 363, 1000 -1, 365, 363, -1, 111, 112, 350, 363, -1, 365, 1001 350, 363, -1, 350, 363, -1, 111, 134, 227, 118, 1002 135, 112, -1, 111, 134, 227, 164, 135, 112, -1, 1003 111, 134, 231, 164, 135, 112, -1, 111, 134, 231, 1004 227, 164, 135, 112, -1, 370, -1, 227, 370, -1, 1005 367, -1, 368, -1, 369, -1, 149, 225, -1, 227, 1006 149, 225, -1, 149, 371, -1, 227, 149, 371, -1, 1007 149, 366, -1, 227, 149, 366, -1, 111, 112, 225, 1008 -1, 111, 112, 350, 225, -1, 350, 225, -1, 111, 1009 112, 368, -1, 111, 112, 350, 368, -1, 350, 368, 1010 -1, 111, 134, 263, 135, 112, -1, 111, 112, 109, 1011 260, 110, -1, 370, 109, 134, 260, 135, 110, -1, 1012 218, 109, 134, 260, 135, 110, -1, -1, 116, -1, 1013 -1, 131, 164, -1 766 110, -1, 118, -1, 119, -1, 120, -1, 121, -1, 767 122, -1, 123, -1, 148, -1, 109, 275, 110, 151, 768 -1, 109, 275, 110, 167, -1, 151, -1, 152, 118, 769 151, -1, 152, 124, 151, -1, 152, 125, 151, -1, 770 152, -1, 153, 120, 152, -1, 153, 121, 152, -1, 771 153, -1, 154, 88, 153, -1, 154, 89, 153, -1, 772 154, -1, 155, 126, 154, -1, 155, 127, 154, -1, 773 155, 90, 154, -1, 155, 91, 154, -1, 155, -1, 774 156, 92, 155, -1, 156, 93, 155, -1, 156, -1, 775 157, 119, 156, -1, 157, -1, 158, 128, 157, -1, 776 158, -1, 159, 129, 158, -1, 159, -1, 160, 94, 777 159, -1, 160, -1, 161, 95, 160, -1, 161, -1, 778 161, 130, 169, 117, 162, -1, 161, 130, 117, 162, 779 -1, 161, 130, 169, 117, 167, -1, 162, -1, 162, 780 -1, 148, 166, 164, -1, 167, 373, -1, -1, 164, 781 -1, 131, -1, 97, -1, 98, -1, 99, -1, 100, 782 -1, 101, -1, 102, -1, 103, -1, 104, -1, 105, 783 -1, 106, -1, 111, 112, -1, 111, 134, 164, 135, 784 112, -1, 111, 134, 116, 168, 135, 112, -1, 111, 785 134, 164, 116, 168, 135, 112, -1, 165, -1, 168, 786 116, 165, -1, 164, -1, 169, 116, 164, -1, -1, 787 169, -1, 172, -1, 173, -1, 177, -1, 178, -1, 788 190, -1, 192, -1, 193, -1, 198, -1, 128, 143, 789 114, 144, 115, 132, -1, 72, 117, 312, 171, -1, 790 114, 115, -1, 114, 134, 134, 209, 174, 135, 115, 791 -1, 175, -1, 174, 134, 175, -1, 212, -1, 40, 792 212, -1, 308, -1, 171, 135, -1, 171, -1, 176, 793 171, -1, 170, 132, -1, 41, 109, 169, 110, 171, 794 -1, 41, 109, 169, 110, 171, 42, 171, -1, 43, 795 109, 169, 110, 183, -1, 43, 109, 169, 110, 114, 796 134, 205, 184, 115, -1, 53, 109, 169, 110, 183, 797 -1, 53, 109, 169, 110, 114, 134, 205, 186, 115, 798 -1, 163, -1, 163, 96, 163, -1, 310, -1, 179, 799 -1, 180, 116, 179, -1, 44, 180, 117, -1, 45, 800 117, -1, 181, -1, 182, 181, -1, 182, 171, -1, 801 -1, 185, -1, 182, 176, -1, 185, 182, 176, -1, 802 -1, 187, -1, 182, 189, -1, 182, 176, 188, -1, 803 187, 182, 189, -1, 187, 182, 176, 188, -1, -1, 804 189, -1, 56, -1, 56, 132, -1, 47, 109, 169, 805 110, 171, -1, 46, 171, 47, 109, 169, 110, 132, 806 -1, 48, 109, 134, 191, 110, 171, -1, 170, 135, 807 132, 170, 132, 170, -1, 212, 170, 132, 170, -1, 808 51, 72, 132, -1, 51, 118, 169, 132, -1, 50, 809 132, -1, 50, 72, 132, -1, 49, 132, -1, 49, 810 72, 132, -1, 52, 170, 132, -1, 61, 165, 132, 811 -1, 62, 165, 132, -1, 62, 165, 63, 164, 132, 812 -1, 57, 173, 194, -1, 57, 173, 196, -1, 57, 813 173, 194, 196, -1, 195, -1, 58, 109, 96, 110, 814 173, -1, 195, 58, 109, 96, 110, 173, -1, 59, 815 109, 96, 110, 173, -1, 195, 59, 109, 96, 110, 816 173, -1, 58, 109, 134, 134, 197, 135, 110, 173, 817 135, -1, 195, 58, 109, 134, 134, 197, 135, 110, 818 173, 135, -1, 59, 109, 134, 134, 197, 135, 110, 819 173, 135, -1, 195, 59, 109, 134, 134, 197, 135, 820 110, 173, 135, -1, 60, 173, -1, 225, -1, 225, 821 309, -1, 225, 357, -1, 366, 139, -1, 366, -1, 822 64, 199, 109, 141, 110, 132, -1, 64, 199, 109, 823 141, 117, 200, 110, 132, -1, 64, 199, 109, 141, 824 117, 200, 117, 200, 110, 132, -1, 64, 199, 109, 825 141, 117, 200, 117, 200, 117, 203, 110, 132, -1, 826 64, 199, 51, 109, 141, 117, 117, 200, 117, 203, 827 117, 204, 110, 132, -1, -1, 11, -1, -1, 201, 828 -1, 202, -1, 201, 116, 202, -1, 141, 109, 163, 829 110, -1, 111, 163, 112, 141, 109, 163, 110, -1, 830 -1, 141, -1, 203, 116, 141, -1, 139, -1, 204, 831 116, 139, -1, 135, -1, 206, -1, 212, -1, 206, 832 134, 212, -1, 135, -1, 208, -1, 222, -1, 208, 833 134, 222, -1, -1, 210, -1, 29, 211, 132, -1, 834 210, 29, 211, 132, -1, 274, -1, 211, 116, 274, 835 -1, 213, -1, 222, -1, 214, 135, 132, -1, 219, 836 135, 132, -1, 216, 135, 132, -1, 293, 135, 132, 837 -1, 296, 135, 132, -1, 215, 277, -1, 231, 215, 838 277, -1, 214, 135, 116, 134, 272, 277, -1, 367, 839 272, 311, -1, 370, 272, 311, -1, 227, 370, 272, 840 311, -1, 217, -1, 227, 217, -1, 231, 217, -1, 841 231, 227, 217, -1, 216, 135, 116, 134, 272, -1, 842 111, 112, 272, 109, 134, 260, 135, 110, -1, 370, 843 272, 109, 134, 260, 135, 110, -1, 218, 272, 109, 844 134, 260, 135, 110, -1, 111, 134, 262, 135, 112, 845 -1, 111, 134, 262, 135, 116, 134, 263, 135, 112, 846 -1, 3, 215, -1, 3, 217, -1, 219, 135, 116, 847 134, 139, -1, 3, 225, 309, -1, 220, 135, 116, 848 134, 309, -1, 227, 3, 225, 309, -1, 225, 3, 849 309, -1, 225, 3, 227, 309, -1, 3, 139, 131, 850 164, -1, 221, 135, 116, 134, 139, 131, 164, -1, 851 223, 135, 132, -1, 220, 135, 132, -1, 221, 135, 852 132, -1, 240, 135, 132, -1, 224, 309, 311, 277, 853 -1, 223, 116, 312, 309, 311, 277, -1, 236, -1, 854 240, -1, 242, -1, 283, -1, 237, -1, 241, -1, 855 243, -1, 284, -1, -1, 227, -1, 228, -1, 227, 856 228, -1, 229, -1, 314, -1, 10, -1, 12, -1, 857 11, -1, 14, -1, 67, -1, -1, 13, 109, 230, 858 286, 110, -1, 232, -1, 227, 232, -1, 231, 227, 859 232, -1, 233, -1, 232, 233, -1, 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, 231, 237, -1, 236, 233, -1, 236, 865 233, 227, -1, 236, 233, 237, -1, 238, -1, 226, 866 239, 226, -1, 235, -1, 227, 235, -1, 238, 228, 867 -1, 238, 235, -1, 28, 109, 276, 110, -1, 28, 868 109, 169, 110, -1, 78, 109, 276, 110, -1, 78, 869 109, 169, 110, -1, 241, -1, 231, 241, -1, 240, 870 233, -1, 240, 233, 227, -1, 244, -1, 227, 244, 871 -1, 241, 228, -1, 243, -1, 231, 243, -1, 242, 872 233, -1, 242, 233, 227, -1, 74, -1, 227, 74, 873 -1, 243, 228, -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, 225, 252, -1, 251, 116, 312, 252, -1, -1, 881 254, -1, 318, 253, -1, 331, 253, -1, 357, -1, 882 -1, 254, -1, 117, 163, -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, 163, -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, 227, 370, 272, 373, -1, 217, -1, 896 270, -1, 362, -1, 370, -1, 227, 370, -1, 371, 897 -1, 224, 336, 373, -1, 224, 340, 373, -1, 224, 898 -1, 224, 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 225, -1, 225, 357, -1, 366, -1, 371, -1, 225, 902 -1, 225, 345, -1, -1, 131, 278, -1, 107, 278, 903 -1, 164, -1, 114, 279, 372, 115, -1, -1, 278, 904 -1, 280, 278, -1, 279, 116, 278, -1, 279, 116, 905 280, 278, -1, 281, 117, -1, 274, 117, -1, 282, 906 -1, 281, 282, -1, 80, -1, 113, 274, -1, 111, 907 134, 164, 135, 112, -1, 111, 134, 310, 135, 112, 908 -1, 111, 134, 163, 96, 163, 135, 112, -1, 113, 909 111, 134, 146, 135, 112, -1, 284, -1, 231, 284, 910 -1, 283, 233, -1, 283, 233, 227, -1, 285, -1, 911 227, 285, -1, 284, 228, -1, 75, 109, 292, 110, 912 -1, 287, 373, -1, 286, 116, 287, 373, -1, -1, 913 289, 274, 288, 290, -1, 225, 336, -1, 33, -1, 914 35, -1, 34, -1, -1, 290, 291, -1, 129, 274, 915 109, 292, 110, -1, 129, 114, 134, 298, 115, -1, 916 129, 109, 134, 286, 135, 110, 114, 134, 298, 115, 917 109, 292, 110, -1, 276, -1, 164, -1, 292, 116, 918 276, -1, 292, 116, 164, -1, 33, 294, -1, 232, 919 33, 294, -1, 293, 116, 294, -1, 295, 290, -1, 920 295, 290, 131, 276, -1, 274, -1, 273, 109, 134, 921 286, 135, 110, -1, 36, 274, 109, 134, 286, 135, 922 110, 114, 115, -1, -1, 36, 274, 109, 134, 286, 923 135, 110, 114, 297, 298, 115, -1, 299, -1, 298, 924 134, 299, -1, 300, 135, 132, -1, 301, 135, 132, 925 -1, 215, -1, 217, -1, 300, 135, 116, 134, 272, 926 -1, 225, 309, -1, 301, 135, 116, 134, 309, -1, 927 -1, 303, -1, 305, -1, 303, 134, 305, -1, -1, 928 303, -1, 212, -1, 307, -1, 198, -1, -1, 5, 929 82, 306, 114, 304, 115, -1, 40, 305, -1, 308, 930 -1, 323, 173, -1, 327, 134, 207, 173, -1, 216, 931 173, -1, 224, 323, 173, -1, 227, 323, 173, -1, 932 231, 323, 173, -1, 231, 227, 323, 173, -1, 224, 933 327, 134, 207, 173, -1, 227, 327, 134, 207, 173, 934 -1, 231, 327, 134, 207, 173, -1, 231, 227, 327, 935 134, 207, 173, -1, 318, -1, 331, -1, 323, -1, 936 163, 123, 163, -1, -1, 64, 109, 141, 110, 312, 937 -1, -1, 313, -1, 314, -1, 313, 314, -1, 39, 938 109, 109, 315, 110, 110, -1, 316, -1, 315, 116, 939 316, -1, -1, 317, -1, 317, 109, 170, 110, -1, 940 272, -1, 234, -1, 235, -1, 228, -1, 319, 312, 941 -1, 320, -1, 321, 312, -1, 322, 312, -1, 137, 942 -1, 109, 319, 110, -1, 149, 318, -1, 149, 227, 943 318, -1, 109, 320, 110, -1, 319, 349, -1, 109, 944 320, 110, 349, -1, 109, 321, 110, 350, -1, 109, 945 321, 110, -1, 109, 320, 110, 109, 134, 264, 135, 946 110, -1, 109, 322, 110, -1, 324, 312, -1, 325, 947 -1, 326, 312, -1, 319, 109, 134, 264, 135, 110, 948 -1, 109, 325, 110, 109, 134, 264, 135, 110, -1, 949 109, 324, 110, -1, 149, 323, -1, 149, 227, 323, 950 -1, 109, 325, 110, -1, 109, 325, 110, 349, -1, 951 109, 326, 110, 350, -1, 109, 326, 110, -1, 328, 952 -1, 329, -1, 330, -1, 319, 109, 271, 110, -1, 953 109, 329, 110, 109, 271, 110, -1, 109, 328, 110, 954 -1, 149, 327, -1, 149, 227, 327, -1, 109, 329, 955 110, -1, 109, 329, 110, 349, -1, 109, 330, 110, 956 350, -1, 109, 330, 110, -1, 332, 312, -1, 333, 957 -1, 334, 312, -1, 335, 312, -1, 341, -1, 109, 958 332, 110, -1, 149, 331, -1, 149, 227, 331, -1, 959 109, 333, 110, -1, 332, 349, -1, 109, 333, 110, 960 349, -1, 109, 334, 110, 350, -1, 109, 334, 110, 961 -1, 332, 109, 134, 264, 135, 110, -1, 109, 333, 962 110, 109, 134, 264, 135, 110, -1, 109, 335, 110, 963 -1, 319, 312, -1, 337, -1, 338, 312, -1, 339, 964 312, -1, 149, 336, -1, 149, 227, 336, -1, 109, 965 337, 110, -1, 319, 355, -1, 109, 337, 110, 349, 966 -1, 109, 338, 110, 350, -1, 109, 338, 110, -1, 967 319, 109, 134, 264, 135, 110, -1, 109, 337, 110, 968 109, 134, 264, 135, 110, -1, 109, 339, 110, -1, 969 341, 312, -1, 342, -1, 343, 312, -1, 344, 312, 970 -1, 74, -1, 75, -1, 149, 340, -1, 149, 227, 971 340, -1, 109, 342, 110, -1, 341, 355, -1, 109, 972 342, 110, 355, -1, 341, 109, 134, 264, 135, 110, 973 -1, 109, 342, 110, 109, 134, 264, 135, 110, -1, 974 346, -1, 347, 312, -1, 348, 312, -1, 149, -1, 975 149, 227, -1, 149, 345, -1, 149, 227, 345, -1, 976 109, 346, 110, -1, 349, -1, 109, 346, 110, 349, 977 -1, 109, 347, 110, 350, -1, 109, 347, 110, -1, 978 109, 134, 264, 135, 110, -1, 109, 346, 110, 109, 979 134, 264, 135, 110, -1, 109, 348, 110, -1, 111, 980 112, -1, 111, 112, 350, -1, 350, -1, 111, 134, 981 164, 135, 112, -1, 111, 134, 118, 135, 112, -1, 982 350, 111, 134, 164, 135, 112, -1, 350, 111, 134, 983 118, 135, 112, -1, 352, -1, 353, 312, -1, 354, 984 312, -1, 149, -1, 149, 227, -1, 149, 351, -1, 985 149, 227, 351, -1, 109, 352, 110, -1, 355, -1, 986 109, 352, 110, 355, -1, 109, 353, 110, 350, -1, 987 109, 353, 110, -1, 109, 134, 264, 135, 110, -1, 988 109, 352, 110, 109, 134, 264, 135, 110, -1, 109, 989 354, 110, -1, 356, -1, 356, 350, -1, 350, -1, 990 111, 112, -1, 111, 134, 227, 118, 135, 112, -1, 991 111, 134, 227, 135, 112, -1, 111, 134, 227, 164, 992 135, 112, -1, 111, 134, 7, 226, 164, 135, 112, 993 -1, 111, 134, 227, 7, 164, 135, 112, -1, 358, 994 -1, 359, 312, -1, 360, 312, -1, 149, -1, 149, 995 227, -1, 149, 357, -1, 149, 227, 357, -1, 109, 996 358, 110, -1, 349, -1, 109, 358, 110, 349, -1, 997 109, 359, 110, 350, -1, 109, 359, 110, -1, 109, 998 358, 110, 109, 134, 264, 135, 110, -1, 109, 360, 999 110, -1, 362, -1, 370, -1, 227, 370, -1, 363, 1000 -1, 364, -1, 149, 225, -1, 227, 149, 225, -1, 1001 149, 371, -1, 227, 149, 371, -1, 149, 361, -1, 1002 227, 149, 361, -1, 111, 112, 225, -1, 365, 225, 1003 -1, 111, 112, 350, 225, -1, 365, 350, 225, -1, 1004 350, 225, -1, 111, 112, 363, -1, 365, 363, -1, 1005 111, 112, 350, 363, -1, 365, 350, 363, -1, 350, 1006 363, -1, 111, 134, 227, 118, 135, 112, -1, 111, 1007 134, 227, 164, 135, 112, -1, 111, 134, 231, 164, 1008 135, 112, -1, 111, 134, 231, 227, 164, 135, 112, 1009 -1, 370, -1, 227, 370, -1, 367, -1, 368, -1, 1010 369, -1, 149, 225, -1, 227, 149, 225, -1, 149, 1011 371, -1, 227, 149, 371, -1, 149, 366, -1, 227, 1012 149, 366, -1, 111, 112, 225, -1, 111, 112, 350, 1013 225, -1, 350, 225, -1, 111, 112, 368, -1, 111, 1014 112, 350, 368, -1, 350, 368, -1, 111, 134, 263, 1015 135, 112, -1, 111, 112, 109, 260, 110, -1, 370, 1016 109, 134, 260, 135, 110, -1, 218, 109, 134, 260, 1017 135, 110, -1, -1, 116, -1, -1, 131, 164, -1 1014 1018 }; 1015 1019 … … 1017 1021 static const yytype_uint16 yyrline[] = 1018 1022 { 1019 0, 29 2, 292, 298, 307, 308, 309, 313, 314, 315,1020 3 19, 320, 324, 325, 329, 330, 334, 335, 341, 343,1021 3 45, 347, 352, 353, 359, 363, 365, 366, 368, 369,1022 3 71, 373, 375, 383, 384, 390, 391, 392, 397, 399,1023 4 04, 405, 409, 413, 415, 417, 419, 424, 427, 429,1024 4 31, 436, 439, 441, 443, 445, 447, 449, 451, 453,1025 4 55, 457, 459, 466, 467, 469, 473, 474, 475, 476,1026 480, 481, 483, 488, 489, 491, 493, 498, 499, 501,1027 5 06, 507, 509, 514, 515, 517, 519, 521, 526, 527,1028 5 29, 534, 535, 540, 541, 546, 547, 552, 553, 558,1029 5 59, 564, 565, 568, 570, 575, 580, 581, 583, 585,1030 591, 592, 598, 600, 602, 604, 609, 610, 615, 616,1031 6 17, 618, 619, 620, 621, 622, 623, 624, 628, 629,1032 6 36, 637, 643, 644, 645, 646, 647, 648, 649, 650,1033 6 51, 661, 668, 670, 680, 681, 686, 688, 694, 696,1034 7 00, 701, 706, 711, 714, 716, 718, 728, 730, 741,1035 7 42, 744, 748, 750, 754, 755, 760, 761, 765, 770,1036 7 71, 775, 777, 783, 784, 788, 790, 792, 794, 800,1037 8 01, 805, 807, 812, 814, 816, 821, 823, 828, 830,1038 8 34, 837, 841, 844, 848, 850, 854, 856, 863, 865,1039 8 67, 876, 878, 880, 882, 884, 889, 891, 893, 895,1040 9 00, 913, 914, 919, 921, 926, 930, 932, 934, 936,1041 9 38, 944, 945, 951, 952, 956, 957, 962, 964, 970,1042 9 71, 973, 978, 980, 987, 989, 993, 994, 999, 1001,1043 10 05, 1006, 1010, 1012, 1016, 1017, 1021, 1022, 1026, 1027,1044 10 42, 1043, 1044, 1045, 1046, 1050, 1055, 1062, 1072, 1077,1045 1 082, 1090, 1095, 1100, 1105, 1110, 1118, 1140, 1145, 1152,1046 11 54, 1161, 1166, 1171, 1182, 1187, 1192, 1197, 1202, 1211,1047 12 16, 1224, 1225, 1226, 1227, 1233, 1238, 1246, 1247, 1248,1048 12 49, 1253, 1254, 1255, 1256, 1261, 1262, 1271, 1272, 1277,1049 1 278, 1283, 1285, 1287, 1289, 1291, 1294, 1293, 1305, 1306,1050 13 08, 1318, 1319, 1324, 1328, 1330, 1332, 1334, 1336, 1338,1051 13 40, 1342, 1347, 1349, 1351, 1353, 1355, 1357, 1359, 1361,1052 13 63, 1365, 1367, 1369, 1371, 1377, 1378, 1380, 1382, 1384,1053 1 389, 1390, 1396, 1397, 1399, 1401, 1406, 1408, 1410, 1412,1054 14 17, 1418, 1420, 1422, 1427, 1428, 1430, 1435, 1436, 1438,1055 14 40, 1445, 1447, 1449, 1454, 1455, 1459, 1461, 1467, 1466,1056 14 70, 1472, 1477, 1479, 1485, 1486, 1491, 1492, 1494, 1495,1057 15 04, 1505, 1507, 1509, 1514, 1516, 1522, 1523, 1525, 1528,1058 15 31, 1536, 1537, 1542, 1547, 1551, 1553, 1559, 1558, 1565,1059 15 67, 1573, 1574, 1582, 1583, 1587, 1588, 1589, 1591, 1593,1060 16 00, 1601, 1603, 1605, 1610, 1611, 1617, 1618, 1622, 1623,1061 16 28, 1629, 1630, 1632, 1640, 1641, 1643, 1646, 1648, 1652,1062 16 53, 1654, 1656, 1658, 1662, 1667, 1675, 1676, 1685, 1687,1063 1 692, 1693, 1694, 1698, 1699, 1700, 1704, 1705, 1706, 1710,1064 17 11, 1712, 1717, 1718, 1719, 1720, 1726, 1727, 1729, 1734,1065 17 35, 1740, 1741, 1742, 1743, 1744, 1759, 1760, 1765, 1766,1066 17 74, 1776, 1778, 1781, 1783, 1785, 1808, 1809, 1811, 1813,1067 18 18, 1819, 1821, 1826, 1831, 1832, 1838, 1837, 1841, 1845,1068 18 47, 1849, 1855, 1856, 1861, 1866, 1868, 1873, 1875, 1876,1069 1 878, 1883, 1885, 1887, 1892, 1894, 1899, 1904, 1912, 1918,1070 19 17, 1931, 1932, 1937, 1938, 1942, 1947, 1952, 1960, 1965,1071 19 76, 1977, 1988, 1989, 1995, 1996, 2000, 2001, 2002, 2005,1072 20 04, 2015, 2024, 2030, 2036, 2045, 2051, 2057, 2063, 2069,1073 2 077, 2083, 2091, 2097, 2106, 2107, 2108, 2112, 2116, 2118,1074 21 23, 2124, 2128, 2129, 2134, 2140, 2141, 2144, 2146, 2147,1075 21 51, 2152, 2153, 2154, 2188, 2190, 2191, 2193, 2198, 2203,1076 22 08, 2210, 2212, 2217, 2219, 2221, 2223, 2228, 2230, 2239,1077 22 41, 2242, 2247, 2249, 2251, 2256, 2258, 2260, 2265, 2267,1078 22 69, 2278, 2279, 2280, 2284, 2286, 2288, 2293, 2295, 2297,1079 23 02, 2304, 2306, 2321, 2323, 2324, 2326, 2331, 2332, 2337,1080 23 39, 2341, 2346, 2348, 2350, 2352, 2357, 2359, 2361, 2371,1081 23 73, 2374, 2376, 2381, 2383, 2385, 2390, 2392, 2394, 2396,1082 24 01, 2403, 2405, 2436, 2438, 2439, 2441, 2446, 2451, 2459,1083 24 61, 2463, 2468, 2470, 2475, 2477, 2491, 2492, 2494, 2499,1084 25 01, 2503, 2505, 2507, 2512, 2513, 2515, 2517, 2522, 2524,1085 25 26, 2532, 2534, 2536, 2540, 2542, 2544, 2546, 2560, 2561,1086 25 63, 2568, 2570, 2572, 2574, 2576, 2581, 2582, 2584, 2586,1087 2 591, 2593, 2595, 2601, 2602, 2604, 2613, 2616, 2618, 2621,1088 26 23, 2625, 2638, 2639, 2641, 2646, 2648, 2650, 2652, 2654,1089 26 59, 2660, 2662, 2664, 2669, 2671, 2679, 2680, 2681, 2686,1090 2 687, 2691, 2693, 2695, 2697, 2699, 2701, 2708, 2710, 2712,1091 27 14, 2716, 2718, 2720, 2722, 2724, 2726, 2731, 2733, 2735,1092 27 40, 2766, 2767, 2769, 2773, 2774, 2778, 2780, 2782, 2784,1093 2 786, 2788, 2795, 2797, 2799, 2801, 2803, 2805, 2810, 2815,1094 28 17, 2819, 2837, 2839, 2844, 28451023 0, 296, 296, 302, 311, 312, 313, 317, 318, 319, 1024 323, 324, 328, 329, 333, 334, 338, 339, 350, 352, 1025 354, 356, 361, 362, 368, 372, 374, 375, 377, 378, 1026 380, 382, 384, 393, 394, 400, 401, 402, 407, 409, 1027 414, 415, 419, 423, 425, 427, 429, 434, 437, 439, 1028 441, 446, 459, 461, 463, 465, 467, 469, 471, 473, 1029 475, 477, 479, 486, 487, 493, 494, 495, 496, 500, 1030 501, 503, 508, 509, 511, 513, 518, 519, 521, 526, 1031 527, 529, 534, 535, 537, 539, 541, 546, 547, 549, 1032 554, 555, 560, 561, 566, 567, 572, 573, 578, 579, 1033 584, 585, 588, 590, 595, 600, 601, 603, 609, 610, 1034 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 1035 624, 630, 632, 634, 636, 641, 642, 647, 648, 654, 1036 655, 661, 662, 663, 664, 665, 666, 667, 668, 669, 1037 679, 686, 688, 698, 699, 704, 706, 712, 714, 718, 1038 719, 724, 729, 732, 734, 736, 746, 748, 759, 760, 1039 762, 766, 768, 772, 773, 778, 779, 783, 788, 789, 1040 793, 795, 801, 802, 806, 808, 810, 812, 818, 819, 1041 823, 825, 830, 832, 834, 839, 841, 846, 848, 852, 1042 855, 859, 862, 866, 868, 872, 874, 881, 883, 885, 1043 894, 896, 898, 900, 902, 907, 909, 911, 913, 918, 1044 931, 932, 937, 939, 944, 948, 950, 952, 954, 956, 1045 962, 963, 969, 970, 974, 975, 980, 982, 988, 989, 1046 991, 996, 998, 1005, 1007, 1011, 1012, 1017, 1019, 1023, 1047 1024, 1028, 1030, 1034, 1035, 1039, 1040, 1044, 1045, 1060, 1048 1061, 1062, 1063, 1064, 1068, 1073, 1080, 1090, 1095, 1100, 1049 1108, 1113, 1118, 1123, 1128, 1136, 1158, 1163, 1170, 1172, 1050 1179, 1184, 1189, 1200, 1205, 1210, 1215, 1220, 1229, 1234, 1051 1242, 1243, 1244, 1245, 1251, 1256, 1264, 1265, 1266, 1267, 1052 1271, 1272, 1273, 1274, 1279, 1280, 1289, 1290, 1295, 1296, 1053 1301, 1303, 1305, 1307, 1309, 1312, 1311, 1323, 1324, 1326, 1054 1336, 1337, 1342, 1346, 1348, 1350, 1352, 1354, 1356, 1358, 1055 1360, 1365, 1367, 1369, 1371, 1373, 1375, 1377, 1379, 1381, 1056 1383, 1385, 1387, 1389, 1395, 1396, 1398, 1400, 1402, 1407, 1057 1408, 1414, 1415, 1417, 1419, 1424, 1426, 1428, 1430, 1435, 1058 1436, 1438, 1440, 1445, 1446, 1448, 1453, 1454, 1456, 1458, 1059 1463, 1465, 1467, 1472, 1473, 1477, 1479, 1485, 1484, 1488, 1060 1490, 1495, 1497, 1503, 1504, 1509, 1510, 1512, 1513, 1522, 1061 1523, 1525, 1527, 1532, 1534, 1540, 1541, 1543, 1546, 1549, 1062 1554, 1555, 1560, 1565, 1569, 1571, 1577, 1576, 1583, 1585, 1063 1591, 1592, 1600, 1601, 1605, 1606, 1607, 1609, 1611, 1618, 1064 1619, 1621, 1623, 1628, 1629, 1635, 1636, 1640, 1641, 1646, 1065 1647, 1648, 1650, 1658, 1659, 1661, 1664, 1666, 1670, 1671, 1066 1672, 1674, 1676, 1680, 1685, 1693, 1694, 1703, 1705, 1710, 1067 1711, 1712, 1716, 1717, 1718, 1722, 1723, 1724, 1728, 1729, 1068 1730, 1735, 1736, 1737, 1738, 1744, 1745, 1747, 1752, 1753, 1069 1758, 1759, 1760, 1761, 1762, 1777, 1778, 1783, 1784, 1792, 1070 1794, 1796, 1799, 1801, 1803, 1826, 1827, 1829, 1831, 1836, 1071 1837, 1839, 1844, 1849, 1850, 1856, 1855, 1859, 1863, 1865, 1072 1867, 1873, 1874, 1879, 1884, 1886, 1891, 1893, 1894, 1896, 1073 1901, 1903, 1905, 1910, 1912, 1917, 1922, 1930, 1936, 1935, 1074 1949, 1950, 1955, 1956, 1960, 1965, 1970, 1978, 1983, 1994, 1075 1995, 2006, 2007, 2013, 2014, 2018, 2019, 2020, 2023, 2022, 1076 2033, 2042, 2048, 2054, 2063, 2069, 2075, 2081, 2087, 2095, 1077 2101, 2109, 2115, 2124, 2125, 2126, 2130, 2134, 2136, 2141, 1078 2142, 2146, 2147, 2152, 2158, 2159, 2162, 2164, 2165, 2169, 1079 2170, 2171, 2172, 2206, 2208, 2209, 2211, 2216, 2221, 2226, 1080 2228, 2230, 2235, 2237, 2239, 2241, 2246, 2248, 2257, 2259, 1081 2260, 2265, 2267, 2269, 2274, 2276, 2278, 2283, 2285, 2287, 1082 2296, 2297, 2298, 2302, 2304, 2306, 2311, 2313, 2315, 2320, 1083 2322, 2324, 2339, 2341, 2342, 2344, 2349, 2350, 2355, 2357, 1084 2359, 2364, 2366, 2368, 2370, 2375, 2377, 2379, 2389, 2391, 1085 2392, 2394, 2399, 2401, 2403, 2408, 2410, 2412, 2414, 2419, 1086 2421, 2423, 2454, 2456, 2457, 2459, 2464, 2469, 2477, 2479, 1087 2481, 2486, 2488, 2493, 2495, 2509, 2510, 2512, 2517, 2519, 1088 2521, 2523, 2525, 2530, 2531, 2533, 2535, 2540, 2542, 2544, 1089 2550, 2552, 2554, 2558, 2560, 2562, 2564, 2578, 2579, 2581, 1090 2586, 2588, 2590, 2592, 2594, 2599, 2600, 2602, 2604, 2609, 1091 2611, 2613, 2619, 2620, 2622, 2631, 2634, 2636, 2639, 2641, 1092 2643, 2656, 2657, 2659, 2664, 2666, 2668, 2670, 2672, 2677, 1093 2678, 2680, 2682, 2687, 2689, 2697, 2698, 2699, 2704, 2705, 1094 2709, 2711, 2713, 2715, 2717, 2719, 2726, 2728, 2730, 2732, 1095 2734, 2736, 2738, 2740, 2742, 2744, 2749, 2751, 2753, 2758, 1096 2784, 2785, 2787, 2791, 2792, 2796, 2798, 2800, 2802, 2804, 1097 2806, 2813, 2815, 2817, 2819, 2821, 2823, 2828, 2833, 2835, 1098 2837, 2855, 2857, 2862, 2863 1095 1099 }; 1096 1100 #endif … … 1130 1134 "logical_AND_expression", "logical_OR_expression", 1131 1135 "conditional_expression", "constant_expression", "assignment_expression", 1132 "assignment_expression_opt", " tuple", "tuple_expression_list",1133 " assignment_operator", "comma_expression", "comma_expression_opt",1136 "assignment_expression_opt", "assignment_operator", "tuple", 1137 "tuple_expression_list", "comma_expression", "comma_expression_opt", 1134 1138 "statement", "labeled_statement", "compound_statement", 1135 1139 "block_item_list", "block_item", "statement_list", … … 1240 1244 146, 146, 147, 147, 147, 147, 147, 148, 148, 148, 1241 1245 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 1242 148, 148, 148, 149, 149, 1 49, 150, 150, 150, 150,1243 151, 151, 15 1, 152, 152, 152, 152, 153, 153, 153,1244 154, 154, 15 4, 155, 155, 155, 155, 155, 156, 156,1245 15 6, 157, 157, 158, 158, 159, 159, 160, 160, 161,1246 16 1, 162, 162, 162, 162, 163, 164, 164, 164, 164,1247 16 5, 165, 166, 166, 166, 166, 167, 167, 168, 168,1248 16 8, 168, 168, 168, 168, 168, 168, 168, 169, 169,1249 170, 17 0, 171, 171, 171, 171, 171, 171, 171, 171,1250 17 1, 172, 173, 173, 174, 174, 175, 175, 175, 175,1251 176, 17 6, 177, 178, 178, 178, 178, 178, 178, 179,1252 179, 1 79, 180, 180, 181, 181, 182, 182, 183, 184,1253 18 4, 185, 185, 186, 186, 187, 187, 187, 187, 188,1254 18 8, 189, 189, 190, 190, 190, 191, 191, 192, 192,1255 192, 192, 192, 192, 192, 192, 192, 19 2, 193, 193,1256 19 3, 194, 194, 194, 194, 194, 195, 195, 195, 195,1257 19 6, 197, 197, 197, 197, 197, 198, 198, 198, 198,1258 19 8, 199, 199, 200, 200, 201, 201, 202, 202, 203,1259 203, 20 3, 204, 204, 205, 205, 206, 206, 207, 207,1260 208, 20 8, 209, 209, 210, 210, 211, 211, 212, 212,1261 213, 213, 213, 213, 21 3, 214, 214, 214, 215, 215,1262 21 5, 216, 216, 216, 216, 216, 217, 217, 217, 218,1263 21 8, 219, 219, 219, 220, 220, 220, 220, 220, 221,1264 22 1, 222, 222, 222, 222, 223, 223, 224, 224, 224,1265 22 4, 225, 225, 225, 225, 226, 226, 227, 227, 228,1266 22 8, 229, 229, 229, 229, 229, 230, 229, 231, 231,1267 23 1, 232, 232, 233, 234, 234, 234, 234, 234, 234,1268 234, 23 4, 235, 235, 235, 235, 235, 235, 235, 235,1269 235, 235, 235, 235, 23 5, 236, 236, 236, 236, 236,1270 237, 23 7, 238, 238, 238, 238, 239, 239, 239, 239,1271 240, 240, 240, 24 0, 241, 241, 241, 242, 242, 242,1272 24 2, 243, 243, 243, 244, 244, 245, 245, 246, 245,1273 245, 24 5, 247, 247, 248, 248, 249, 249, 249, 249,1274 250, 250, 250, 25 0, 251, 251, 252, 252, 252, 252,1275 25 2, 253, 253, 254, 255, 256, 256, 257, 256, 258,1276 25 8, 259, 259, 260, 260, 261, 261, 261, 261, 261,1277 262, 262, 262, 26 2, 263, 263, 264, 264, 265, 265,1278 266, 266, 266, 26 6, 267, 267, 267, 267, 267, 268,1279 268, 268, 268, 26 8, 269, 269, 270, 270, 271, 271,1280 272, 272, 27 2, 273, 273, 273, 274, 274, 274, 275,1281 275, 27 5, 276, 276, 276, 276, 277, 277, 277, 278,1282 27 8, 279, 279, 279, 279, 279, 280, 280, 281, 281,1283 282, 282, 282, 282, 282, 28 2, 283, 283, 283, 283,1284 284, 284, 28 4, 285, 286, 286, 288, 287, 287, 289,1285 289, 2 89, 290, 290, 291, 291, 291, 292, 292, 292,1286 29 2, 293, 293, 293, 294, 294, 295, 295, 296, 297,1287 29 6, 298, 298, 299, 299, 300, 300, 300, 301, 301,1288 302, 30 2, 303, 303, 304, 304, 305, 305, 305, 306,1289 305, 30 5, 307, 307, 307, 308, 308, 308, 308, 308,1290 308, 308, 308, 30 8, 309, 309, 309, 310, 311, 311,1291 312, 31 2, 313, 313, 314, 315, 315, 316, 316, 316,1292 317, 317, 317, 31 7, 318, 318, 318, 318, 319, 319,1293 320, 320, 32 0, 321, 321, 321, 321, 322, 322, 323,1294 323, 32 3, 324, 324, 324, 325, 325, 325, 326, 326,1295 32 6, 327, 327, 327, 328, 328, 328, 329, 329, 329,1296 330, 330, 33 0, 331, 331, 331, 331, 332, 332, 333,1297 333, 33 3, 334, 334, 334, 334, 335, 335, 335, 336,1298 336, 336, 33 6, 337, 337, 337, 338, 338, 338, 338,1299 339, 339, 3 39, 340, 340, 340, 340, 341, 341, 342,1300 342, 34 2, 343, 343, 344, 344, 345, 345, 345, 346,1301 346, 346, 346, 34 6, 347, 347, 347, 347, 348, 348,1302 34 8, 349, 349, 349, 350, 350, 350, 350, 351, 351,1303 35 1, 352, 352, 352, 352, 352, 353, 353, 353, 353,1304 354, 354, 35 4, 355, 355, 355, 356, 356, 356, 356,1305 356, 35 6, 357, 357, 357, 358, 358, 358, 358, 358,1306 359, 359, 359, 3 59, 360, 360, 361, 361, 361, 362,1307 36 2, 363, 363, 363, 363, 363, 363, 364, 364, 364,1308 364, 364, 364, 364, 364, 364, 36 4, 365, 365, 365,1309 36 5, 366, 366, 366, 367, 367, 368, 368, 368, 368,1310 368, 36 8, 369, 369, 369, 369, 369, 369, 370, 371,1311 371, 37 1, 372, 372, 373, 3731246 148, 148, 148, 149, 149, 150, 150, 150, 150, 151, 1247 151, 151, 152, 152, 152, 152, 153, 153, 153, 154, 1248 154, 154, 155, 155, 155, 155, 155, 156, 156, 156, 1249 157, 157, 158, 158, 159, 159, 160, 160, 161, 161, 1250 162, 162, 162, 162, 163, 164, 164, 164, 165, 165, 1251 166, 166, 166, 166, 166, 166, 166, 166, 166, 166, 1252 166, 167, 167, 167, 167, 168, 168, 169, 169, 170, 1253 170, 171, 171, 171, 171, 171, 171, 171, 171, 171, 1254 172, 173, 173, 174, 174, 175, 175, 175, 175, 176, 1255 176, 177, 178, 178, 178, 178, 178, 178, 179, 179, 1256 179, 180, 180, 181, 181, 182, 182, 183, 184, 184, 1257 185, 185, 186, 186, 187, 187, 187, 187, 188, 188, 1258 189, 189, 190, 190, 190, 191, 191, 192, 192, 192, 1259 192, 192, 192, 192, 192, 192, 192, 193, 193, 193, 1260 194, 194, 194, 194, 194, 195, 195, 195, 195, 196, 1261 197, 197, 197, 197, 197, 198, 198, 198, 198, 198, 1262 199, 199, 200, 200, 201, 201, 202, 202, 203, 203, 1263 203, 204, 204, 205, 205, 206, 206, 207, 207, 208, 1264 208, 209, 209, 210, 210, 211, 211, 212, 212, 213, 1265 213, 213, 213, 213, 214, 214, 214, 215, 215, 215, 1266 216, 216, 216, 216, 216, 217, 217, 217, 218, 218, 1267 219, 219, 219, 220, 220, 220, 220, 220, 221, 221, 1268 222, 222, 222, 222, 223, 223, 224, 224, 224, 224, 1269 225, 225, 225, 225, 226, 226, 227, 227, 228, 228, 1270 229, 229, 229, 229, 229, 230, 229, 231, 231, 231, 1271 232, 232, 233, 234, 234, 234, 234, 234, 234, 234, 1272 234, 235, 235, 235, 235, 235, 235, 235, 235, 235, 1273 235, 235, 235, 235, 236, 236, 236, 236, 236, 237, 1274 237, 238, 238, 238, 238, 239, 239, 239, 239, 240, 1275 240, 240, 240, 241, 241, 241, 242, 242, 242, 242, 1276 243, 243, 243, 244, 244, 245, 245, 246, 245, 245, 1277 245, 247, 247, 248, 248, 249, 249, 249, 249, 250, 1278 250, 250, 250, 251, 251, 252, 252, 252, 252, 252, 1279 253, 253, 254, 255, 256, 256, 257, 256, 258, 258, 1280 259, 259, 260, 260, 261, 261, 261, 261, 261, 262, 1281 262, 262, 262, 263, 263, 264, 264, 265, 265, 266, 1282 266, 266, 266, 267, 267, 267, 267, 267, 268, 268, 1283 268, 268, 268, 269, 269, 270, 270, 271, 271, 272, 1284 272, 272, 273, 273, 273, 274, 274, 274, 275, 275, 1285 275, 276, 276, 276, 276, 277, 277, 277, 278, 278, 1286 279, 279, 279, 279, 279, 280, 280, 281, 281, 282, 1287 282, 282, 282, 282, 282, 283, 283, 283, 283, 284, 1288 284, 284, 285, 286, 286, 288, 287, 287, 289, 289, 1289 289, 290, 290, 291, 291, 291, 292, 292, 292, 292, 1290 293, 293, 293, 294, 294, 295, 295, 296, 297, 296, 1291 298, 298, 299, 299, 300, 300, 300, 301, 301, 302, 1292 302, 303, 303, 304, 304, 305, 305, 305, 306, 305, 1293 305, 307, 307, 307, 308, 308, 308, 308, 308, 308, 1294 308, 308, 308, 309, 309, 309, 310, 311, 311, 312, 1295 312, 313, 313, 314, 315, 315, 316, 316, 316, 317, 1296 317, 317, 317, 318, 318, 318, 318, 319, 319, 320, 1297 320, 320, 321, 321, 321, 321, 322, 322, 323, 323, 1298 323, 324, 324, 324, 325, 325, 325, 326, 326, 326, 1299 327, 327, 327, 328, 328, 328, 329, 329, 329, 330, 1300 330, 330, 331, 331, 331, 331, 332, 332, 333, 333, 1301 333, 334, 334, 334, 334, 335, 335, 335, 336, 336, 1302 336, 336, 337, 337, 337, 338, 338, 338, 338, 339, 1303 339, 339, 340, 340, 340, 340, 341, 341, 342, 342, 1304 342, 343, 343, 344, 344, 345, 345, 345, 346, 346, 1305 346, 346, 346, 347, 347, 347, 347, 348, 348, 348, 1306 349, 349, 349, 350, 350, 350, 350, 351, 351, 351, 1307 352, 352, 352, 352, 352, 353, 353, 353, 353, 354, 1308 354, 354, 355, 355, 355, 356, 356, 356, 356, 356, 1309 356, 357, 357, 357, 358, 358, 358, 358, 358, 359, 1310 359, 359, 359, 360, 360, 361, 361, 361, 362, 362, 1311 363, 363, 363, 363, 363, 363, 364, 364, 364, 364, 1312 364, 364, 364, 364, 364, 364, 365, 365, 365, 365, 1313 366, 366, 366, 367, 367, 368, 368, 368, 368, 368, 1314 368, 369, 369, 369, 369, 369, 369, 370, 371, 371, 1315 371, 372, 372, 373, 373 1312 1316 }; 1313 1317 … … 1322 1326 2, 2, 2, 2, 2, 2, 4, 6, 1, 4, 1323 1327 4, 2, 4, 1, 1, 1, 1, 1, 1, 1, 1324 1, 4, 4, 1, 3, 3, 3, 1, 3, 3, 1325 1, 3, 3, 1, 3, 3, 3, 3, 1, 3, 1326 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 1327 3, 1, 5, 4, 5, 1, 1, 3, 3, 2, 1328 0, 1, 2, 5, 6, 7, 1, 3, 1, 1, 1329 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1330 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1331 6, 4, 2, 7, 1, 3, 1, 2, 1, 2, 1332 1, 2, 2, 5, 7, 5, 9, 5, 9, 1, 1333 3, 1, 1, 3, 3, 2, 1, 2, 2, 0, 1334 1, 2, 3, 0, 1, 2, 3, 3, 4, 0, 1335 1, 1, 2, 5, 7, 6, 6, 4, 3, 4, 1336 2, 3, 2, 3, 3, 3, 3, 5, 3, 3, 1337 4, 1, 5, 6, 5, 6, 9, 10, 9, 10, 1338 2, 1, 2, 2, 2, 1, 6, 8, 10, 12, 1339 14, 0, 1, 0, 1, 1, 3, 4, 7, 0, 1340 1, 3, 1, 3, 1, 1, 1, 3, 1, 1, 1341 1, 3, 0, 1, 3, 4, 1, 3, 1, 1, 1342 3, 3, 3, 3, 3, 2, 3, 6, 3, 3, 1343 4, 1, 2, 2, 3, 5, 8, 7, 7, 5, 1344 9, 2, 2, 5, 3, 5, 4, 3, 4, 4, 1345 7, 3, 3, 3, 3, 4, 6, 1, 1, 1, 1346 1, 1, 1, 1, 1, 0, 1, 1, 2, 1, 1347 1, 1, 1, 1, 1, 1, 0, 5, 1, 2, 1348 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1328 4, 4, 1, 3, 3, 3, 1, 3, 3, 1, 1329 3, 3, 1, 3, 3, 3, 3, 1, 3, 3, 1330 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1331 1, 5, 4, 5, 1, 1, 3, 2, 0, 1, 1349 1332 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1350 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 1351 1, 3, 1, 2, 2, 2, 4, 4, 4, 4, 1352 1, 2, 2, 3, 1, 2, 2, 1, 2, 2, 1353 3, 1, 2, 2, 1, 1, 4, 2, 0, 6, 1354 7, 2, 2, 2, 0, 2, 2, 3, 2, 3, 1355 1, 2, 3, 2, 2, 4, 0, 1, 2, 2, 1356 1, 0, 1, 2, 2, 5, 2, 0, 7, 2, 1357 4, 0, 2, 0, 1, 1, 1, 5, 5, 5, 1358 1, 5, 5, 9, 1, 5, 0, 1, 1, 5, 1359 1, 1, 5, 5, 1, 3, 3, 4, 1, 1, 1360 1, 1, 2, 1, 3, 3, 1, 2, 1, 3, 1333 1, 2, 5, 6, 7, 1, 3, 1, 3, 0, 1334 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 1335 4, 2, 7, 1, 3, 1, 2, 1, 2, 1, 1336 2, 2, 5, 7, 5, 9, 5, 9, 1, 3, 1337 1, 1, 3, 3, 2, 1, 2, 2, 0, 1, 1338 2, 3, 0, 1, 2, 3, 3, 4, 0, 1, 1339 1, 2, 5, 7, 6, 6, 4, 3, 4, 2, 1340 3, 2, 3, 3, 3, 3, 5, 3, 3, 4, 1341 1, 5, 6, 5, 6, 9, 10, 9, 10, 2, 1342 1, 2, 2, 2, 1, 6, 8, 10, 12, 14, 1343 0, 1, 0, 1, 1, 3, 4, 7, 0, 1, 1344 3, 1, 3, 1, 1, 1, 3, 1, 1, 1, 1345 3, 0, 1, 3, 4, 1, 3, 1, 1, 3, 1346 3, 3, 3, 3, 2, 3, 6, 3, 3, 4, 1347 1, 2, 2, 3, 5, 8, 7, 7, 5, 9, 1348 2, 2, 5, 3, 5, 4, 3, 4, 4, 7, 1349 3, 3, 3, 3, 4, 6, 1, 1, 1, 1, 1350 1, 1, 1, 1, 0, 1, 1, 2, 1, 1, 1351 1, 1, 1, 1, 1, 0, 5, 1, 2, 3, 1352 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1361 1353 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1362 1, 2, 1, 1, 1, 2, 0, 2, 2, 1, 1363 4, 0, 1, 2, 3, 4, 2, 2, 1, 2, 1364 1, 2, 5, 5, 7, 6, 1, 2, 2, 3, 1365 1, 2, 2, 4, 2, 4, 0, 4, 2, 1, 1366 1, 1, 0, 2, 5, 5, 13, 1, 1, 3, 1367 3, 2, 3, 3, 2, 4, 1, 6, 9, 0, 1368 11, 1, 3, 3, 3, 1, 1, 5, 2, 5, 1369 0, 1, 1, 3, 0, 1, 1, 1, 1, 0, 1370 6, 2, 1, 2, 4, 2, 3, 3, 3, 4, 1371 5, 5, 5, 6, 1, 1, 1, 3, 0, 5, 1372 0, 1, 1, 2, 6, 1, 3, 0, 1, 4, 1373 1, 1, 1, 1, 2, 1, 2, 2, 1, 3, 1374 2, 3, 3, 2, 4, 4, 3, 8, 3, 2, 1375 1, 2, 6, 8, 3, 2, 3, 3, 4, 4, 1376 3, 1, 1, 1, 4, 6, 3, 2, 3, 3, 1377 4, 4, 3, 2, 1, 2, 2, 1, 3, 2, 1378 3, 3, 2, 4, 4, 3, 6, 8, 3, 2, 1379 1, 2, 2, 2, 3, 3, 2, 4, 4, 3, 1380 6, 8, 3, 2, 1, 2, 2, 1, 1, 2, 1381 3, 3, 2, 4, 6, 8, 1, 2, 2, 1, 1382 2, 2, 3, 3, 1, 4, 4, 3, 5, 8, 1383 3, 2, 3, 1, 5, 5, 6, 6, 1, 2, 1384 2, 1, 2, 2, 3, 3, 1, 4, 4, 3, 1385 5, 8, 3, 1, 2, 1, 2, 6, 5, 6, 1386 7, 7, 1, 2, 2, 1, 2, 2, 3, 3, 1387 1, 4, 4, 3, 8, 3, 1, 1, 2, 1, 1388 1, 2, 3, 2, 3, 2, 3, 3, 2, 4, 1389 3, 2, 3, 2, 4, 3, 2, 6, 6, 6, 1390 7, 1, 2, 1, 1, 1, 2, 3, 2, 3, 1391 2, 3, 3, 4, 2, 3, 4, 2, 5, 5, 1392 6, 6, 0, 1, 0, 2 1354 1, 1, 1, 1, 1, 2, 2, 3, 3, 1, 1355 3, 1, 2, 2, 2, 4, 4, 4, 4, 1, 1356 2, 2, 3, 1, 2, 2, 1, 2, 2, 3, 1357 1, 2, 2, 1, 1, 4, 2, 0, 6, 7, 1358 2, 2, 2, 0, 2, 2, 3, 2, 3, 1, 1359 2, 3, 2, 2, 4, 0, 1, 2, 2, 1, 1360 0, 1, 2, 2, 5, 2, 0, 7, 2, 4, 1361 0, 2, 0, 1, 1, 1, 5, 5, 5, 1, 1362 5, 5, 9, 1, 5, 0, 1, 1, 5, 1, 1363 1, 5, 5, 1, 3, 3, 4, 1, 1, 1, 1364 1, 2, 1, 3, 3, 1, 2, 1, 3, 1, 1365 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1366 2, 1, 1, 1, 2, 0, 2, 2, 1, 4, 1367 0, 1, 2, 3, 4, 2, 2, 1, 2, 1, 1368 2, 5, 5, 7, 6, 1, 2, 2, 3, 1, 1369 2, 2, 4, 2, 4, 0, 4, 2, 1, 1, 1370 1, 0, 2, 5, 5, 13, 1, 1, 3, 3, 1371 2, 3, 3, 2, 4, 1, 6, 9, 0, 11, 1372 1, 3, 3, 3, 1, 1, 5, 2, 5, 0, 1373 1, 1, 3, 0, 1, 1, 1, 1, 0, 6, 1374 2, 1, 2, 4, 2, 3, 3, 3, 4, 5, 1375 5, 5, 6, 1, 1, 1, 3, 0, 5, 0, 1376 1, 1, 2, 6, 1, 3, 0, 1, 4, 1, 1377 1, 1, 1, 2, 1, 2, 2, 1, 3, 2, 1378 3, 3, 2, 4, 4, 3, 8, 3, 2, 1, 1379 2, 6, 8, 3, 2, 3, 3, 4, 4, 3, 1380 1, 1, 1, 4, 6, 3, 2, 3, 3, 4, 1381 4, 3, 2, 1, 2, 2, 1, 3, 2, 3, 1382 3, 2, 4, 4, 3, 6, 8, 3, 2, 1, 1383 2, 2, 2, 3, 3, 2, 4, 4, 3, 6, 1384 8, 3, 2, 1, 2, 2, 1, 1, 2, 3, 1385 3, 2, 4, 6, 8, 1, 2, 2, 1, 2, 1386 2, 3, 3, 1, 4, 4, 3, 5, 8, 3, 1387 2, 3, 1, 5, 5, 6, 6, 1, 2, 2, 1388 1, 2, 2, 3, 3, 1, 4, 4, 3, 5, 1389 8, 3, 1, 2, 1, 2, 6, 5, 6, 7, 1390 7, 1, 2, 2, 1, 2, 2, 3, 3, 1, 1391 4, 4, 3, 8, 3, 1, 1, 2, 1, 1, 1392 2, 3, 2, 3, 2, 3, 3, 2, 4, 3, 1393 2, 3, 2, 4, 3, 2, 6, 6, 6, 7, 1394 1, 2, 1, 1, 1, 2, 3, 2, 3, 2, 1395 3, 3, 4, 2, 3, 4, 2, 5, 5, 6, 1396 6, 0, 1, 0, 2 1393 1397 }; 1394 1398 … … 1398 1402 static const yytype_uint16 yydefact[] = 1399 1403 { 1400 29 5, 295, 316, 314, 317, 315, 318, 319, 301, 303,1401 30 2, 0, 304, 330, 322, 327, 325, 326, 324, 323,1402 32 8, 329, 334, 331, 332, 333, 550, 550, 550, 0,1403 0, 0, 29 5, 221, 305, 320, 321, 7, 361, 0,1404 8, 14, 15, 65, 0, 2, 63, 64, 568, 9,1405 295, 528, 526, 248, 3, 456, 3, 261, 0, 3,1406 3, 3, 249, 3, 0, 0, 0, 296, 297, 299,1407 295, 308, 311, 313, 342, 287, 335, 340, 288, 350,1408 289, 357, 354, 364, 0, 0, 365, 290, 476, 480,1409 3, 3, 0, 2, 522, 527, 532, 300, 0, 0,1410 5 50, 580, 550, 2, 591, 592, 593, 295, 0, 734,1411 735, 0, 12, 0, 13, 295, 271, 272, 0, 296,1412 291, 292, 293, 294, 529, 306, 394, 551, 552, 372,1413 373, 12, 447, 448, 11, 443, 446, 0, 506, 501,1414 4 92, 447, 448, 0, 0, 531, 222, 0, 295, 0,1415 0, 0, 0, 0, 0, 0, 0, 295, 295, 2,1416 0, 736, 296, 585, 597, 740, 733, 731, 738, 0,1417 0, 0, 255, 2, 0, 535, 441, 442, 440, 0,1418 0, 0, 0, 550, 0, 637, 638, 0, 0, 548,1419 54 4, 550, 565, 550, 550, 546, 2, 545, 550, 604,1420 5 50, 550, 607, 0, 0, 0, 295, 295, 314, 362,1421 2, 295, 262, 298, 309, 343, 355, 481, 0, 2,1422 0, 456, 263, 296, 336, 351, 358, 477, 0, 2,1423 0, 312, 337, 344, 345, 0, 352, 356, 359, 363,1424 448, 295, 374, 367, 371, 0, 396, 478, 482, 0,1425 0, 0, 1, 295, 2, 533, 579, 581, 295, 2,1426 744, 296, 747, 548, 548, 0, 296, 0, 0, 274,1427 5 50, 546, 2, 295, 0, 0, 295, 553, 2, 504,1428 2, 557, 0, 0, 0, 0, 0, 0, 18, 58,1429 4, 5, 6, 16, 0, 0, 295, 2, 66, 67,1430 68, 69, 48, 19, 49, 22, 47, 70, 295, 0,1431 7 3, 77, 80, 83, 88, 91, 93, 95, 97, 99,1432 10 1, 106, 498, 754, 454, 497, 0, 452, 453, 0,1433 5 69, 584, 587, 590, 596, 599, 602, 361, 0, 2,1434 742, 0, 295, 745, 2, 63, 295, 3, 428, 0,1435 436, 296, 295, 308, 335, 288, 350, 357, 3, 3,1436 41 0, 414, 424, 429, 476, 295, 430, 709, 710, 295,1437 43 1, 433, 295, 2, 586, 598, 732, 2, 2, 250,1438 2, 461, 0, 459, 458, 457, 142, 2, 2, 252,1439 2, 2, 251, 2, 282, 2, 283, 0, 281, 0,1440 0, 0, 0, 0, 0, 0, 0, 0, 570, 609,1441 0, 456, 2, 564, 573, 663, 566, 567, 536, 295,1442 2, 603, 612, 605, 606, 0, 277, 295, 295, 341,1443 296, 0, 296, 0, 295, 737, 741, 739, 537, 295,1444 548, 256, 264, 310, 0, 2, 538, 295, 502, 338,1445 339, 284, 353, 360, 0, 295, 0, 752, 401, 0,1446 479, 503, 253, 254, 523, 295, 438, 0, 295, 238,1447 0, 2, 240, 0, 296, 0, 258, 2, 259, 279,1448 0, 0, 2, 295, 548, 295, 489, 491, 490, 0,1449 0, 754, 0, 295, 0, 295, 493, 295, 563, 561,1450 5 62, 560, 0, 555, 558, 0, 0, 295, 55, 295,1451 70, 50, 295, 61, 295, 295, 53, 54, 2, 128,1452 0, 0, 450, 0, 449, 731, 112, 295, 17, 0,1453 29, 30, 35, 2, 0, 35, 118, 119, 120, 121,1454 1 22, 123, 124, 125, 126, 127, 0, 0, 51, 52,1404 294, 294, 315, 313, 316, 314, 317, 318, 300, 302, 1405 301, 0, 303, 329, 321, 326, 324, 325, 323, 322, 1406 327, 328, 333, 330, 331, 332, 549, 549, 549, 0, 1407 0, 0, 294, 220, 304, 319, 320, 7, 360, 0, 1408 8, 14, 15, 0, 2, 63, 64, 567, 9, 294, 1409 527, 525, 247, 3, 455, 3, 260, 0, 3, 3, 1410 3, 248, 3, 0, 0, 0, 295, 296, 298, 294, 1411 307, 310, 312, 341, 286, 334, 339, 287, 349, 288, 1412 356, 353, 363, 0, 0, 364, 289, 475, 479, 3, 1413 3, 0, 2, 521, 526, 531, 299, 0, 0, 549, 1414 579, 549, 2, 590, 591, 592, 294, 0, 733, 734, 1415 0, 12, 0, 13, 294, 270, 271, 0, 295, 290, 1416 291, 292, 293, 528, 305, 393, 550, 551, 371, 372, 1417 12, 446, 447, 11, 442, 445, 0, 505, 500, 491, 1418 446, 447, 0, 0, 530, 221, 0, 294, 0, 0, 1419 0, 0, 0, 0, 0, 0, 294, 294, 2, 0, 1420 735, 295, 584, 596, 739, 732, 730, 737, 0, 0, 1421 0, 254, 2, 0, 534, 440, 441, 439, 0, 0, 1422 0, 0, 549, 0, 636, 637, 0, 0, 547, 543, 1423 549, 564, 549, 549, 545, 2, 544, 549, 603, 549, 1424 549, 606, 0, 0, 0, 294, 294, 313, 361, 2, 1425 294, 261, 297, 308, 342, 354, 480, 0, 2, 0, 1426 455, 262, 295, 335, 350, 357, 476, 0, 2, 0, 1427 311, 336, 343, 344, 0, 351, 355, 358, 362, 447, 1428 294, 373, 366, 370, 0, 395, 477, 481, 0, 0, 1429 0, 1, 294, 2, 532, 578, 580, 294, 2, 743, 1430 295, 746, 547, 547, 0, 295, 0, 0, 273, 549, 1431 545, 2, 294, 0, 0, 294, 552, 2, 503, 2, 1432 556, 0, 0, 0, 0, 0, 0, 18, 58, 4, 1433 5, 6, 16, 0, 0, 294, 2, 65, 66, 67, 1434 68, 48, 19, 49, 22, 47, 69, 294, 0, 72, 1435 76, 79, 82, 87, 90, 92, 94, 96, 98, 100, 1436 105, 497, 753, 453, 496, 0, 451, 452, 0, 568, 1437 583, 586, 589, 595, 598, 601, 360, 0, 2, 741, 1438 0, 294, 744, 2, 63, 294, 3, 427, 0, 435, 1439 295, 294, 307, 334, 287, 349, 356, 3, 3, 409, 1440 413, 423, 428, 475, 294, 429, 708, 709, 294, 430, 1441 432, 294, 2, 585, 597, 731, 2, 2, 249, 2, 1442 460, 0, 458, 457, 456, 141, 2, 2, 251, 2, 1443 2, 250, 2, 281, 2, 282, 0, 280, 0, 0, 1444 0, 0, 0, 0, 0, 0, 0, 569, 608, 0, 1445 455, 2, 563, 572, 662, 565, 566, 535, 294, 2, 1446 602, 611, 604, 605, 0, 276, 294, 294, 340, 295, 1447 0, 295, 0, 294, 736, 740, 738, 536, 294, 547, 1448 255, 263, 309, 0, 2, 537, 294, 501, 337, 338, 1449 283, 352, 359, 0, 294, 0, 751, 400, 0, 478, 1450 502, 252, 253, 522, 294, 437, 0, 294, 237, 0, 1451 2, 239, 0, 295, 0, 257, 2, 258, 278, 0, 1452 0, 2, 294, 547, 294, 488, 490, 489, 0, 0, 1453 753, 0, 294, 0, 294, 492, 294, 562, 560, 561, 1454 559, 0, 554, 557, 0, 0, 294, 55, 294, 69, 1455 50, 294, 61, 294, 294, 53, 54, 2, 127, 0, 1456 0, 449, 0, 448, 730, 121, 294, 17, 0, 29, 1457 30, 35, 2, 0, 35, 111, 112, 113, 114, 115, 1458 116, 117, 118, 119, 120, 110, 0, 51, 52, 0, 1455 1459 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1456 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,1457 109, 2, 649, 455, 646, 550, 550, 654, 483, 295,1458 2, 588, 589, 0, 600, 601, 0, 2, 743, 746,1459 112, 295, 0, 2, 711, 296, 715, 706, 707, 713,1460 0, 2, 2, 671, 550, 754, 620, 550, 550, 754,1461 550, 634, 550, 550, 685, 437, 668, 550, 550, 676,1462 683, 295, 432, 296, 0, 0, 295, 721, 296, 726,1463 7 54, 718, 295, 723, 754, 295, 295, 295, 0, 112,1464 0, 18, 5, 2, 0, 19, 0, 462, 752, 0,1465 0, 468, 242, 0, 295, 0, 0, 0, 548, 572,1466 57 6, 578, 608, 611, 615, 618, 571, 610, 0, 285,1467 661, 0, 295, 278, 0, 0, 0, 0, 276, 2,1468 0, 260, 539, 295, 0, 0, 295, 2, 366, 386,1469 375, 0, 0, 380, 374, 753, 0, 0, 399, 0,1470 296, 3, 417, 3, 421, 420, 594, 0, 534, 295,1471 63, 3, 295, 436, 296, 3, 430, 431, 2, 0,1472 0, 0, 488, 307, 295, 484, 486, 3, 2, 2,1473 0, 505, 3, 0, 557, 130, 0, 0, 223, 0,1474 0, 0, 2, 0, 0, 36, 0, 0, 112, 295,1475 20, 0, 21, 0, 695, 700, 451, 692, 550, 550,1476 0, 110, 3, 2, 27, 2, 0, 33, 0, 2,1477 25, 0, 107, 108, 74, 75, 76, 78, 79, 81,1478 8 2, 86, 87, 84, 85, 89, 90, 92, 94, 96,1479 98, 100, 0, 0, 755, 295, 0, 0, 0, 650,1480 6 51, 647, 648, 500, 499, 295, 0, 295, 717, 295,1481 722, 296, 295, 665, 295, 295, 708, 664, 2, 295,1482 0, 0, 0, 0, 0, 0, 0, 0, 686, 0,1483 6 72, 623, 639, 673, 2, 619, 626, 434, 621, 622,1484 435, 2, 633, 642, 635, 636, 669, 670, 684, 712,1485 7 16, 714, 754, 269, 2, 748, 2, 425, 720, 725,1486 4 26, 0, 404, 3, 3, 3, 3, 456, 3,0,1487 2, 471, 467, 753, 0, 463, 470, 2, 466, 469,1488 0, 295, 243, 265, 3, 273, 275, 0, 456, 2,1489 574, 575, 2, 613, 614, 0, 662, 540, 3, 347,1490 34 6, 349, 348, 295, 541, 0, 542, 374, 0, 0,1491 295, 295, 0, 0, 695, 384, 387, 391, 550, 391,1492 3 90, 383, 376, 550, 378, 381, 295, 401, 395, 105,1493 402, 752, 0, 0, 439, 241, 0, 0, 3, 2,1494 671, 432, 0, 530, 0, 754, 492, 0, 295, 295,1495 295, 0, 554, 556, 131, 0, 0, 216, 0, 0,1496 0, 224, 225, 56, 0, 62, 295, 0, 60, 59,1497 0, 2, 129, 0, 0, 0, 696, 697, 693, 694,1498 461, 71, 72, 111, 116, 3, 110, 0, 0, 0,1499 24, 35, 3, 0, 32, 103, 0, 3, 653, 657,1500 660, 652, 3, 595, 3, 719, 724, 2, 63, 295,1501 3, 3, 296, 0, 3, 625, 629, 632, 641, 675,1502 679, 682, 295, 3, 624, 640, 674, 295, 295, 427,1503 295, 295, 749, 0, 0, 0, 0, 257, 0, 105,1504 0, 3, 3, 0, 464, 0, 460, 0, 0, 246,1505 295, 0, 0, 130, 0, 0, 0, 0, 0, 130,1506 0, 0, 110, 110, 18, 2, 0, 0, 3, 132,1507 1 33, 2, 144, 134, 135, 136, 137, 138, 139, 146,1508 148, 0, 0, 0, 286, 295, 295, 550, 0, 543,1509 295, 377, 379, 0, 393, 696, 388, 392, 389, 382,1510 3 86, 369, 400, 0, 582, 2, 667, 666, 0, 672,1511 2, 485, 487, 507, 3, 515, 516, 0, 2, 511,1512 3, 3, 0, 0, 559, 223, 0, 0, 0, 223,1513 0, 0, 3, 37, 112, 699, 703, 705, 698, 752,1514 110, 0, 3, 664, 42, 3, 40, 3, 34, 0,1515 3, 102, 104, 0, 2, 655, 656, 0, 0, 295,1516 0, 0, 0, 3, 641, 0, 2, 627, 628, 2,1517 6 43, 2, 677, 678, 0, 0, 63, 0, 3, 3,1518 3, 3, 412, 411, 415, 2, 2, 751, 750, 113,1519 0, 0, 0, 0, 3, 465, 3, 0, 244, 147,1520 3, 296, 295, 0, 0, 0, 0, 2, 0, 192,1521 0, 190, 0, 0, 0, 0, 0, 0, 0, 550,1522 1 12, 0, 152, 149, 295, 0, 0, 268, 280, 3,1523 3, 549, 616, 370, 385, 398, 295, 267, 295, 0,1524 518, 495, 295, 0, 0, 494, 509, 0, 0, 0,1525 2 17, 0, 226, 57, 110, 0, 2, 701, 702, 0,1526 117, 114, 0, 0, 0, 0, 0, 0, 23, 0,1527 658, 295, 583, 266, 727, 728, 729, 0, 680, 295,1528 295, 295, 3, 3, 0, 688, 0, 0, 0, 0,1529 295, 295, 3, 547, 472, 473, 0, 0, 247, 296,1530 0, 0, 0, 0, 295, 193, 191, 188, 0, 194,1531 0, 0, 0, 0, 198, 201, 199, 195, 0, 196,1532 1 30, 35, 145, 143, 245, 0, 0, 419, 423, 422,1533 0, 512, 2, 513, 2, 514, 508, 295, 229, 0,1534 22 7, 0, 229, 3, 664, 295, 31, 115, 2, 45,1535 2, 43, 41, 28, 113, 26, 3, 730, 3, 3,1536 3, 0, 0, 687, 689, 630, 644, 270, 2, 409,1537 3, 408, 0, 475, 472, 130, 0, 0, 130, 3,1538 0, 130, 189, 0, 2, 2, 210, 200, 0,0,1539 0, 141, 0, 577, 617, 2, 0, 0, 2, 230,1540 0, 0, 218, 0, 0, 0, 3, 0, 0, 0,1541 0, 0, 0, 690, 691, 295, 0, 474, 153, 0,1542 0, 2, 166, 130, 155, 0, 183, 0, 130, 0,1543 2, 157, 0, 2, 0, 2, 2, 2, 197, 32,1544 295, 517, 519, 510, 0, 0, 0, 0, 115, 38,1545 0, 3, 3, 659, 631, 645, 681, 413, 130, 159,1546 16 2, 0, 161, 165, 3, 168, 167, 0, 130, 185,1547 130, 3, 0, 295, 0, 295, 0, 2, 0, 2,1548 140, 2, 231, 232, 0, 228, 219, 0, 704, 0,1549 0, 154, 0, 0, 164, 234, 169, 2, 236, 184,1550 0, 187, 173, 202, 3, 211, 215, 204, 3, 0,1551 29 5, 0, 295, 0, 0, 0, 39, 46, 44, 160,1552 163, 130, 0, 170, 295, 130, 130, 0, 174, 0,1553 0, 695, 212, 213, 214, 0, 203, 3, 205, 3,1554 2 95, 220, 233, 150, 171, 156, 130, 237, 186, 181,1555 1 79, 175, 158, 130, 0, 696, 0, 0, 0, 0,1556 1 51, 172, 182, 176, 180, 179, 177, 3, 3, 0,1557 0, 496, 178, 206, 208, 3, 3, 207, 2091460 0, 0, 0, 0, 0, 0, 0, 0, 0, 107, 1461 2, 648, 454, 645, 549, 549, 653, 482, 294, 2, 1462 587, 588, 0, 599, 600, 0, 2, 742, 745, 121, 1463 294, 0, 2, 710, 295, 714, 705, 706, 712, 0, 1464 2, 2, 670, 549, 753, 619, 549, 549, 753, 549, 1465 633, 549, 549, 684, 436, 667, 549, 549, 675, 682, 1466 294, 431, 295, 0, 0, 294, 720, 295, 725, 753, 1467 717, 294, 722, 753, 294, 294, 294, 0, 121, 0, 1468 18, 5, 2, 0, 19, 0, 461, 751, 0, 0, 1469 467, 241, 0, 294, 0, 0, 0, 547, 571, 575, 1470 577, 607, 610, 614, 617, 570, 609, 0, 284, 660, 1471 0, 294, 277, 0, 0, 0, 0, 275, 2, 0, 1472 259, 538, 294, 0, 0, 294, 2, 365, 385, 374, 1473 0, 0, 379, 373, 752, 0, 0, 398, 0, 295, 1474 3, 416, 3, 420, 419, 593, 0, 533, 294, 63, 1475 3, 294, 435, 295, 3, 429, 430, 2, 0, 0, 1476 0, 487, 306, 294, 483, 485, 3, 2, 2, 0, 1477 504, 3, 0, 556, 129, 0, 0, 222, 0, 0, 1478 0, 2, 0, 0, 36, 0, 0, 121, 294, 20, 1479 0, 21, 0, 694, 699, 450, 691, 549, 549, 0, 1480 108, 3, 2, 27, 2, 0, 33, 0, 2, 25, 1481 0, 106, 73, 74, 75, 77, 78, 80, 81, 85, 1482 86, 83, 84, 88, 89, 91, 93, 95, 97, 99, 1483 0, 0, 754, 294, 0, 0, 0, 649, 650, 646, 1484 647, 499, 498, 294, 0, 294, 716, 294, 721, 295, 1485 294, 664, 294, 294, 707, 663, 2, 294, 0, 0, 1486 0, 0, 0, 0, 0, 0, 685, 0, 671, 622, 1487 638, 672, 2, 618, 625, 433, 620, 621, 434, 2, 1488 632, 641, 634, 635, 668, 669, 683, 711, 715, 713, 1489 753, 268, 2, 747, 2, 424, 719, 724, 425, 0, 1490 403, 3, 3, 3, 3, 455, 3, 0, 2, 470, 1491 466, 752, 0, 462, 469, 2, 465, 468, 0, 294, 1492 242, 264, 3, 272, 274, 0, 455, 2, 573, 574, 1493 2, 612, 613, 0, 661, 539, 3, 346, 345, 348, 1494 347, 294, 540, 0, 541, 373, 0, 0, 294, 294, 1495 0, 0, 694, 383, 386, 390, 549, 390, 389, 382, 1496 375, 549, 377, 380, 294, 400, 394, 104, 401, 751, 1497 0, 0, 438, 240, 0, 0, 3, 2, 670, 431, 1498 0, 529, 0, 753, 491, 0, 294, 294, 294, 0, 1499 553, 555, 130, 0, 0, 215, 0, 0, 0, 223, 1500 224, 56, 0, 62, 294, 0, 60, 59, 0, 2, 1501 128, 0, 0, 0, 695, 696, 692, 693, 460, 70, 1502 71, 109, 125, 3, 108, 0, 0, 0, 24, 35, 1503 3, 0, 32, 102, 0, 3, 652, 656, 659, 651, 1504 3, 594, 3, 718, 723, 2, 63, 294, 3, 3, 1505 295, 0, 3, 624, 628, 631, 640, 674, 678, 681, 1506 294, 3, 623, 639, 673, 294, 294, 426, 294, 294, 1507 748, 0, 0, 0, 0, 256, 0, 104, 0, 3, 1508 3, 0, 463, 0, 459, 0, 0, 245, 294, 0, 1509 0, 129, 0, 0, 0, 0, 0, 129, 0, 0, 1510 108, 108, 18, 2, 0, 0, 3, 131, 132, 2, 1511 143, 133, 134, 135, 136, 137, 138, 145, 147, 0, 1512 0, 0, 285, 294, 294, 549, 0, 542, 294, 376, 1513 378, 0, 392, 695, 387, 391, 388, 381, 385, 368, 1514 399, 0, 581, 2, 666, 665, 0, 671, 2, 484, 1515 486, 506, 3, 514, 515, 0, 2, 510, 3, 3, 1516 0, 0, 558, 222, 0, 0, 0, 222, 0, 0, 1517 3, 37, 121, 698, 702, 704, 697, 751, 108, 0, 1518 3, 663, 42, 3, 40, 3, 34, 0, 3, 101, 1519 103, 0, 2, 654, 655, 0, 0, 294, 0, 0, 1520 0, 3, 640, 0, 2, 626, 627, 2, 642, 2, 1521 676, 677, 0, 0, 63, 0, 3, 3, 3, 3, 1522 411, 410, 414, 2, 2, 750, 749, 122, 0, 0, 1523 0, 0, 3, 464, 3, 0, 243, 146, 3, 295, 1524 294, 0, 0, 0, 0, 2, 0, 191, 0, 189, 1525 0, 0, 0, 0, 0, 0, 0, 549, 121, 0, 1526 151, 148, 294, 0, 0, 267, 279, 3, 3, 548, 1527 615, 369, 384, 397, 294, 266, 294, 0, 517, 494, 1528 294, 0, 0, 493, 508, 0, 0, 0, 216, 0, 1529 225, 57, 108, 0, 2, 700, 701, 0, 126, 123, 1530 0, 0, 0, 0, 0, 0, 23, 0, 657, 294, 1531 582, 265, 726, 727, 728, 0, 679, 294, 294, 294, 1532 3, 3, 0, 687, 0, 0, 0, 0, 294, 294, 1533 3, 546, 471, 472, 0, 0, 246, 295, 0, 0, 1534 0, 0, 294, 192, 190, 187, 0, 193, 0, 0, 1535 0, 0, 197, 200, 198, 194, 0, 195, 129, 35, 1536 144, 142, 244, 0, 0, 418, 422, 421, 0, 511, 1537 2, 512, 2, 513, 507, 294, 228, 0, 226, 0, 1538 228, 3, 663, 294, 31, 124, 2, 45, 2, 43, 1539 41, 28, 122, 26, 3, 729, 3, 3, 3, 0, 1540 0, 686, 688, 629, 643, 269, 2, 408, 3, 407, 1541 0, 474, 471, 129, 0, 0, 129, 3, 0, 129, 1542 188, 0, 2, 2, 209, 199, 0, 0, 0, 140, 1543 0, 576, 616, 2, 0, 0, 2, 229, 0, 0, 1544 217, 0, 0, 0, 3, 0, 0, 0, 0, 0, 1545 0, 689, 690, 294, 0, 473, 152, 0, 0, 2, 1546 165, 129, 154, 0, 182, 0, 129, 0, 2, 156, 1547 0, 2, 0, 2, 2, 2, 196, 32, 294, 516, 1548 518, 509, 0, 0, 0, 0, 124, 38, 0, 3, 1549 3, 658, 630, 644, 680, 412, 129, 158, 161, 0, 1550 160, 164, 3, 167, 166, 0, 129, 184, 129, 3, 1551 0, 294, 0, 294, 0, 2, 0, 2, 139, 2, 1552 230, 231, 0, 227, 218, 0, 703, 0, 0, 153, 1553 0, 0, 163, 233, 168, 2, 235, 183, 0, 186, 1554 172, 201, 3, 210, 214, 203, 3, 0, 294, 0, 1555 294, 0, 0, 0, 39, 46, 44, 159, 162, 129, 1556 0, 169, 294, 129, 129, 0, 173, 0, 0, 694, 1557 211, 212, 213, 0, 202, 3, 204, 3, 294, 219, 1558 232, 149, 170, 155, 129, 236, 185, 180, 178, 174, 1559 157, 129, 0, 695, 0, 0, 0, 0, 150, 171, 1560 181, 175, 179, 178, 176, 3, 3, 0, 0, 495, 1561 177, 205, 207, 3, 3, 206, 208 1558 1562 }; 1559 1563 … … 1561 1565 static const yytype_int16 yydefgoto[] = 1562 1566 { 1563 -1, 81 9, 469, 302, 48, 135, 136, 303, 304, 305,1564 30 6, 766, 767, 1145, 1146, 307, 382, 309, 310, 311,1565 31 2, 313, 314, 315, 316, 317, 318, 319, 320, 321,1566 10 40, 519, 984, 323, 985, 547, 954, 1067, 1543, 1069,1567 10 70, 1071, 1072, 1544, 1073, 1074, 1460, 1461, 1422, 1423,1568 142 4, 1522, 1523, 1527, 1528, 1563, 1564, 1075, 1380, 1076,1569 107 7, 1314, 1315, 1316, 1504, 1078, 147, 960, 961, 962,1570 1 400, 1484, 1496, 1497, 470, 471, 881, 882, 1048, 52,1571 5 3, 54, 55, 56, 348, 160, 59, 60, 61, 62,1572 6 3, 350, 65, 66, 266, 68, 69, 276, 352, 353,1573 7 2, 73, 74, 75, 120, 77, 206, 355, 121, 80,1574 12 2, 82, 83, 456, 84, 455, 690, 691, 692, 915,1575 109 6, 916, 85, 86, 459, 457, 698, 861, 862, 358,1576 35 9, 701, 702, 703, 360, 361, 362, 363, 467, 341,1577 13 7, 138, 523, 325, 172, 647, 648, 649, 650, 651,1578 8 7, 123, 89, 490, 491, 946, 492, 279, 496, 326,1579 90, 139, 140, 91, 1337, 1118, 1119, 1120, 1121, 92,1580 9 3, 719, 94, 275, 95, 96, 189, 1042, 681, 413,1581 12 7, 97, 502, 503, 504, 190, 270, 192, 193, 194,1582 27 1, 100, 101, 102, 103, 104, 105, 106, 197, 198,1583 19 9, 200, 201, 831, 606, 607, 608, 609, 202, 611,1584 61 2, 613, 573, 574, 575, 576, 755, 107, 615, 616,1585 61 7, 618, 619, 620, 977, 757, 758, 759, 596, 366,1586 36 7, 368, 369, 327, 166, 109, 110, 111, 371, 696,1587 5 701567 -1, 817, 468, 301, 47, 134, 135, 302, 303, 304, 1568 305, 765, 766, 1143, 1144, 306, 381, 308, 309, 310, 1569 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 1570 1038, 518, 982, 546, 322, 983, 952, 1065, 1541, 1067, 1571 1068, 1069, 1070, 1542, 1071, 1072, 1458, 1459, 1420, 1421, 1572 1422, 1520, 1521, 1525, 1526, 1561, 1562, 1073, 1378, 1074, 1573 1075, 1312, 1313, 1314, 1502, 1076, 146, 958, 959, 960, 1574 1398, 1482, 1494, 1495, 469, 470, 879, 880, 1046, 51, 1575 52, 53, 54, 55, 347, 159, 58, 59, 60, 61, 1576 62, 349, 64, 65, 265, 67, 68, 275, 351, 352, 1577 71, 72, 73, 74, 119, 76, 205, 354, 120, 79, 1578 121, 81, 82, 455, 83, 454, 689, 690, 691, 913, 1579 1094, 914, 84, 85, 458, 456, 697, 859, 860, 357, 1580 358, 700, 701, 702, 359, 360, 361, 362, 466, 340, 1581 136, 137, 522, 324, 171, 646, 647, 648, 649, 650, 1582 86, 122, 88, 489, 490, 944, 491, 278, 495, 325, 1583 89, 138, 139, 90, 1335, 1116, 1117, 1118, 1119, 91, 1584 92, 718, 93, 274, 94, 95, 188, 1040, 680, 412, 1585 126, 96, 501, 502, 503, 189, 269, 191, 192, 193, 1586 270, 99, 100, 101, 102, 103, 104, 105, 196, 197, 1587 198, 199, 200, 829, 605, 606, 607, 608, 201, 610, 1588 611, 612, 572, 573, 574, 575, 754, 106, 614, 615, 1589 616, 617, 618, 619, 975, 756, 757, 758, 595, 365, 1590 366, 367, 368, 326, 165, 108, 109, 110, 370, 695, 1591 569 1588 1592 }; 1589 1593 1590 1594 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1591 1595 STATE-NUM. */ 1592 #define YYPACT_NINF -1 4141596 #define YYPACT_NINF -1315 1593 1597 static const yytype_int16 yypact[] = 1594 1598 { 1595 4857, 9883, -1414, 35, -1414, -1414, -1414, -1414, -1414, -1414,1596 -1 414, 142, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414,1597 -1 414, -1414, -1414, -1414, -1414, -1414, 98, 98, 98, 1334,1598 684, 153, 7496, 290, -1414, -1414, -1414, -1414, -1414, 204,1599 -1 414, -1414, -1414, -1414, 901, 229, -1414, -1414, -1414, -1414,1600 9565, -1414, -1414, -1414, -1414, -15, 301, -1414, 1624, -1414,1601 -1 414, -1414, -1414, 302, 1806, 471, 143, 7613, -1414, -1414,1602 9603, 1367, -1414, -1414, -1414, 1721, 510, 3394, 1032, 1137,1603 1 721, 1303, -1414, -1414, 1174, 1520, -1414, 1721, 1532, -1414,1604 385, -1414, 421, 523, -1414, -1414, -1414, -1414, 460, 301,1605 98, -1414, 98, -1414, -1414, -1414, -1414, 10414, 1624, -1414,1606 -1414, 1624, -1414, 447, -1414, 10444, -1414, -1414, 2082, 10554,1607 -1414, 399, 399, 399, -1414, -1414, -1414, 98, -1414, -1414,1608 -1414, 544, 555, 575, -1414, -1414, -1414, 617, -1414, -1414,1609 -1 414, -1414, -1414, 621, 629, -1414, -1414, 11, 9069, 3253,1610 578, 492, 499, 631, 635, 642, 647, 9853, 7015, 649,1611 656, -1414, 9713, -1414, -1414, -1414, -1414, 661, -1414, 193,1612 3 453, 3453, -1414, 667, 251, -1414, -1414, -1414, -1414, 692,1613 32 7, 346, 368, 98, 673, -1414, -1414, 1806, 3136, 748,1614 -1414, 12, -1414, 98, 98, 301, -1414, -1414, 75, -1414,1615 98, 98, -1414, 3167, 711, 722, 399, 6806, -1414, -1414,1616 726, 9565, -1414, -1414, 1721, -1414, -1414, -1414, 301, -1414,1617 1624, -15, -1414, 7963, -1414, 399, 399, 399, 301, -1414,1618 1334, -1414, 5769, -1414, -1414, 709, 399, -1414, 399, -1414,1619 204, 9069, -1414, 763, -1414, 684, 765, 399, -1414, 1334,1620 7 50, 766, -1414, 7496, 705, -1414, -1414, -1414, 9532, -1414,1621 -1414, 10864, -1414, 748, 63, 6244, 10554, 2082, 3167, -1414,1622 85, -1414, -1414, 10444, 1624, 804, 7644, -1414, -1414, 319,1623 -1414, 11778, 782, 851, 4657, 828, 4994, 11639, -1414, 839,1624 -1 414, -1414, -1414, -1414, 11658, 11658, 8841, 844, -1414, -1414,1625 -1 414, -1414, -1414, -1414, 869, -1414, 759, 2440, 9183, 4994,1626 -1414, 593, 571, 645, 313, 861, 842, 858, 843, 911,1627 -20, -1414, -1414, 876, 326, -1414, 83, -1414, -1414, 3253,1628 -1 414, -1414, 139, 900, -1414, 422, 900, 905, 204, -1414,1629 -1414, 909, 10414, -1414, 912, 917, 9297, -1414, -1414, 1382,1630 2358, 8427, 6806, 1721, -1414, 1721, 399, 399, -1414, -1414,1631 -1 414, -1414, -1414, -1414, 399, 10414, 1624, -1414, -1414, 10584,1632 1776, -1414, 10304, -1414, -1414, -1414, -1414, -1414, -1414, -1414,1633 936, 11446, 4994, -1414, -1414, -1414, -1414, -1414, -1414, -1414,1634 -1 414, -1414, -1414, -1414, -1414, -1414, -1414, 2082, -1414, 836,1635 947, 962, 963, 923, 965, 970, 972, 3136, -1414, -1414,1636 959, -15, 975, -1414, -1414, 978, -1414, -1414, -1414, 9532,1637 -1 414, -1414, -1414, -1414, -1414, 3167, -1414, 9069, 9069, -1414,1638 399, 2082, 6926, 1624, 8543, -1414, -1414, -1414, -1414, 9532,1639 63, -1414, -1414, 1721, 301, -1414, -1414, 9532, -1414, 6689,1640 -1 414, -1414, 399, 399, 271, 10023, 907, 977, 960, 988,1641 399, -1414, -1414, -1414, -1414, 10980, -1414, 500, 6556, -1414,1642 301, 990, -1414, 2082, 11860, 11504, -1414, -1414, -1414, -1414,1643 935, 3167, -1414, 8659, 748, 6228, -1414, -1414, -1414, 1482,1644 550, 876, 684, 7644, 1180, 10444, -1414, 7644, -1414, -1414,1645 -1 414, -1414, 561, -1414, 997, 851, -13, 8841, -1414, 10694,1646 -1 414, -1414, 8841, -1414, 8955, 8841, -1414, -1414, 996, -1414,1647 585, 1003, 455, 1017, -1414, -1414, 9993, 6037, -1414, 419,1648 -1 414, -1414, 11562, -1414, 469, 11562, -1414, -1414, -1414, -1414,1649 -1 414, -1414, -1414, -1414, -1414, -1414, 6244, 6244, -1414, -1414,1650 4994, 4994, 4994, 4994, 4994, 4994, 4994, 4994, 4994, 4994,1651 4994, 4994, 4994, 4994, 4994, 4994, 4994, 4994, 3735, 6244,1652 -1414, 326, 1049, -1414, -1414, 98, 98, -1414, -1414, 9069,1653 -1 414, -1414, 978, 705, -1414, 978, 11581, -1414, -1414, -1414,1654 3645, 6037, 1016, 1018, -1414, 10554, -1414, -1414, 661, -1414,1655 1020, 1157, 1025, 2611, 95, 876, -1414, 98, 98, 876,1656 134, -1414, 98, 98, 978, -1414, -1414, 98, 98, -1414,1657 900, 10724, 1624, 12005, 69, 227, 10724, -1414, 10864, -1414,1658 876, -1414, 10414, -1414, 218, 8079, 8079, 8079, 1624, -1414,1659 5555, 1012, 260, 936, 778, 1021, 1024, -1414, 1026, 3453,1660 343, -1414, 1115, 1624, 8079, 705, 2082, 705, 748, 534,1661 900, -1414, -1414, 596, 900, -1414, -1414, -1414, 851, -1414,1662 900, 301, 10980, -1414, 687, 1042, 700, 1043, -1414, 1044,1663 301, -1414, -1414, 9532, 301, 1041, 10694, 1045, -1414, 2066,1664 -1414, 408, 416, 684, -1414, 684, 1047, 4994, -1414, 684,1665 12005, -1414, -1414, 1053, -1414, -1414, -1414, 705, -1414, 11933,1666 917, -1414, 8079, 489, 8427, -1414, -1414, 661, 1055, 1056,1667 1482, 3284, -1414, -1414, 7644, -1414, -1414, 1038, -1414, -1414,1668 1064, -1414, 1038, 1070, 11778, 6244, 93, 1051, 138, 1074,1669 10 58, 1075, 844, 1069, 1077, -1414, 1079, 1081, 10133, 6775,1670 -1414, 6244, -1414, 455, 1974, -1414, -1414, -1414, 98, 98,1671 6104, 6244, 1076, -1414, -1414, 936, 707, -1414, 6244, -1414,1672 -1414, 677, -1414, -1414, -1414, -1414, -1414, 593, 593, 571,1673 571, 645, 645, 645, 645, 313, 313, 861, 842, 858,1674 843, 911, 4994, 847, -1414, 10980, 1083, 1084, 1088, 1049,1675 -1 414, -1414, -1414, -1414, -1414, 10980, 717, 8079, -1414, 10414,1676 -1414, 7135, 9411, -1414, 10304, 7015, -1414, -1414, 1157, 10980,1677 945, 1089, 1090, 1095, 1096, 1099, 1100, 1105, -1414, 4392,1678 2611, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414,1679 -1 414, -1414, -1414, -1414, -1414, -1414, -1414, -1414, 978, -1414,1680 -1414, -1414, 876, -1414, -1414, -1414, -1414, -1414, -1414, -1414,1681 -1 414, 1112, -1414, 1113, 1118, -1414, -1414, -15, 1076, 5555,1682 -1 414, -1414, -1414, 11446, 1116, -1414, -1414, -1414, -1414, -1414,1683 684, 6369, 1201, -1414, -1414, -1414, -1414, 1103, -15, -1414,1684 -1 414, 978, -1414, -1414, 978, 126, 978, -1414, -1414, -1414,1685 -1 414, -1414, -1414, 9743, -1414, 301, -1414, -1414, 438, 452,1686 10584, 7255, 2372, 4994, 2870, -1414, -1414, 1127, 39, 1127,1687 -1 414, 684, -1414, 98, -1414, -1414, 10163, 960, -1414, -1414,1688 -1414, 977, 1143, 1131, -1414, -1414, 1150, 1153, -1414, 489,1689 1995, -1414, 363, -1414, 3284, 876, -1414, 1160, 7644, 10834,1690 9069, 1161, -1414, -1414, 1151, 1162, 1156, -1414, 4994, 120,1691 279, 1163, -1414, 1166, 705, 1166, 6037, 6244, -1414, -1414,1692 1166, 1165, -1414, 1176, 1182, 1185, 1974, -1414, -1414, -1414,1693 11446, -1414, -1414, -1414, -1414, 1168, 6244, 1188, 705, 5555,1694 -1 414, 11562, -1414, 705, -1414, -1414, 6244, -1414, 614, 900,1695 -1 414, -1414, -1414, -1414, -1414, -1414, -1414, 936, 917, 9297,1696 -1414, -1414, 7375, 1187, -1414, 758, 900, -1414, 785, 797,1697 900, -1414, 399, 5912, -1414, -1414, -1414, 10980, 10980, -1414,1698 8543, 8543, -1414, 1186, 1189, 1191, 1199, -1414, 1206, 439,1699 119, 1076, -1414, 705, -1414, 3453, -1414, 6244, 480, -1414,1700 6655, 1211, 1212, 11388, 1213, 1217, -6, 58, 117, 6244,1701 1221, 301, 6244, 6244, 1215, 1222, 610, 1203, -1414, -1414,1702 -1 414, 1218, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414,1703 -1414, 684, 1226, 6244, -1414, 10980, 10980, 98, 1228, -1414,1704 10273, -1414, -1414, 864, -1414, 2870, -1414, -1414, -1414, -1414,1705 2066, -1414, -1414, 1230, -1414, -1414, -1414, -1414, 1231, 1995,1706 -1414, -1414, 1223, -1414, 1038, -1414, -1414, 2082, 1235, -1414,1707 -1414, -1414, 744, 1237, -1414, 138, 1245, 4994, 1232, 138,1708 138, 1250, 1246, -1414, 9993, 825, 900, -1414, -1414, 1026,1709 6244, 1251, 1168, 536, 161, 1261, -1414, 1246, -1414, 1254,1710 1261, -1414, -1414, 1257, -1414, -1414, 978, 1270, 1271, 6895,1711 12 72, 1275, 1280, -1414, -1414, 1283, -1414, -1414, 978, -1414,1712 -1 414, -1414, -1414, 978, 6244, 6244, 917, 1282, -1414, -1414,1713 -1 414, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -1414,1714 4994, 4994, 1284, 1286, 1261, -1414, -1414, 684, -1414, -1414,1715 -1414, 5291, 10834, 6244, 6244, 1335, 6244, -1414, 1263, -1414,1716 12 67, -1414, 1281, 6244, 1288, 6244, 1039, 1290, 28, 98,1717 5165, 856, -1414, -1414, 6369, 1287, 488, -1414, -1414, -1414,1718 -1 414, -1414, -1414, -1414, -1414, -1414, 11206, -1414, 8659, 1304,1719 -1414, -1414, 10834, 490, 498, -1414, 1301, 1306, 851, 1317,1720 -1 414, 418, -1414, -1414, 6244, 1316, -1414, -1414, 978, 1314,1721 -1414, -1414, 1318, 589, 691, 705, 1320, 1322, -1414, 1329,1722 -1 414, 10980, -1414, -1414, -1414, -1414, -1414, 1330, -1414, 10980,1723 10980, 10980, -1414, -1414, 1332, -1414, 1333, 1336, 1339, 517,1724 8195, 8311, -1414, -1414, 123, -1414, 1343, 1348, -1414, 8775,1725 755, 768, 1342, 770, 6525, -1414, -1414, -1414, 508, -1414,1726 777, 1352, 1353, 301, 1403, 933, -1414, -1414, 6244, -1414,1727 11388, 11562, -1414, -1414, -1414, 1359, 1364, -1414, -1414, -1414,1728 1363, -1414, -1414, -1414, -1414, -1414, -1414, 10834, 851, 273,1729 -1414, 1347, 851, 1168, 268, 10980, -1414, -1414, -1414, -1414,1730 -1 414, -1414, -1414, -1414, 1365, -1414, -1414, -1414, -1414, -1414,1731 -1414, 1368, 1371, -1414, -1414, -1414, -1414, -1414, -1414, -1414,1732 13 75, -1414, 1374, -1414, -1414, 11388, 91, 6244, 11388, -1414,1733 1385, 6244, -1414, 288, 1402, 1405, -1414, -1414, 1390, 1393,1734 1376, -1414, 882, -1414, -1414, -1414, 1624, 2082, 1388, 869,1735 884, 4994, -1414, 803, 1394, 6244, -1414, 705, 705, 1399,1736 1 406, 1407, 1409, -1414, -1414, 8543, 1397, -1414, 1473, 4994,1737 1404, -1414, -1414, 11299, -1414, 811, -1414, 1395, 11388, 1401,1738 -1414, -1414, 1410, -1414, 1412, -1414, 1433, 1441, -1414, 1415,1739 10834, -1414, -1414, -1414, 851, 705, 1429, 1417, 1436, -1414,1740 1 446, 1261, 1261, -1414, -1414, -1414, -1414, -1414, 11388, 278,1741 -1 414, 910, -1414, -1414, 7730, -1414, -1414, 1435, 6244, -1414,1742 6244, 7730, 301, 10694, 301, 10694, 1462, -1414, 1463, -1414,1743 -1414, 1460, 869, -1414, 812, -1414, -1414, 6244, -1414, 1465,1744 1466, -1414, 4994, 4994, -1414, -1414, 1007, 37, -1414, -1414,1745 1 447, -1414, 1007, -1414, -1414, 2485, 705, -1414, -1414, 301,1746 10694, 301, 10694, 1472, 1450, 705, -1414, -1414, -1414, -1414,1747 -1414, 11299, 1468, 1007, 7847, 6244, 11210, 1475, 1007, 1477,1748 2485, 2994, -1414, -1414, -1414, 1495, -1414, -1414, -1414, -1414,1749 9069, -1414, -1414, -1414, 11077, -1414, 11299, -1414, -1414, 1476,1750 10984, -1414, -1414, 11210, 301, 2994, 301, 1502, 1506, 813,1751 -1 414, 11077, -1414, -1414, -1414, 10984, -1414, -1414, -1414, 301,1752 301, -1414, -1414, -1414, -1414, -1414, -1414, -1414, -14141599 5006, 8237, -1315, 89, -1315, -1315, -1315, -1315, -1315, -1315, 1600 -1315, 194, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, 1601 -1315, -1315, -1315, -1315, -1315, -1315, 314, 314, 314, 792, 1602 787, 234, 7780, 219, -1315, -1315, -1315, -1315, -1315, 257, 1603 -1315, -1315, -1315, 912, 264, -1315, -1315, -1315, -1315, 6920, 1604 -1315, -1315, -1315, -1315, 120, 272, -1315, 823, -1315, -1315, 1605 -1315, -1315, 302, 1619, 420, 112, 3706, -1315, -1315, 9405, 1606 1262, -1315, -1315, -1315, 675, 440, 7333, 1133, 1444, 675, 1607 1669, -1315, -1315, 482, 771, -1315, 675, 1807, -1315, 386, 1608 -1315, 507, 517, -1315, -1315, -1315, -1315, 426, 272, 314, 1609 -1315, 314, -1315, -1315, -1315, -1315, 8871, 823, -1315, -1315, 1610 823, -1315, 415, -1315, 8985, -1315, -1315, 1777, 9099, -1315, 1611 428, 428, 428, -1315, -1315, -1315, 314, -1315, -1315, -1315, 1612 454, 468, 490, -1315, -1315, -1315, 500, -1315, -1315, -1315, 1613 -1315, -1315, 504, 509, -1315, -1315, 76, 8833, 2235, 669, 1614 439, 450, 519, 522, 537, 567, 8121, 7182, 529, 581, 1615 -1315, 9443, -1315, -1315, -1315, -1315, 595, -1315, 216, 3771, 1616 3771, -1315, 603, 313, -1315, -1315, -1315, -1315, 605, 316, 1617 320, 345, 314, 589, -1315, -1315, 1619, 2809, 664, -1315, 1618 49, -1315, 314, 314, 272, -1315, -1315, 87, -1315, 314, 1619 314, -1315, 3249, 632, 636, 428, 7093, -1315, -1315, 646, 1620 6920, -1315, -1315, 675, -1315, -1315, -1315, 272, -1315, 823, 1621 120, -1315, 7972, -1315, 428, 428, 428, 272, -1315, 792, 1622 -1315, 5155, -1315, -1315, 635, 428, -1315, 428, -1315, 257, 1623 8833, -1315, 657, -1315, 787, 660, 428, -1315, 792, 679, 1624 704, -1315, 7780, 574, -1315, -1315, -1315, 9296, -1315, -1315, 1625 6389, -1315, 664, 74, 5169, 9099, 1777, 3249, -1315, 97, 1626 -1315, -1315, 8985, 823, 708, 9849, -1315, -1315, 539, -1315, 1627 10667, 680, 762, 10451, 751, 10470, 10528, -1315, 764, -1315, 1628 -1315, -1315, -1315, 10547, 10547, 8605, 778, -1315, -1315, -1315, 1629 -1315, -1315, -1315, 801, -1315, 969, 2181, 8947, 10470, -1315, 1630 339, 731, 846, 265, 890, 795, 797, 810, 836, 33, 1631 -1315, -1315, 812, 497, -1315, 59, -1315, -1315, 2235, -1315, 1632 -1315, 588, 835, -1315, 622, 835, 847, 257, -1315, -1315, 1633 863, 8871, -1315, 854, 878, 9061, -1315, -1315, 765, 1714, 1634 8320, 7093, 675, -1315, 675, 428, 428, -1315, -1315, -1315, 1635 -1315, -1315, -1315, 428, 8871, 823, -1315, -1315, 9213, 843, 1636 -1315, 8757, -1315, -1315, -1315, -1315, -1315, -1315, -1315, 886, 1637 3575, 10470, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, 1638 -1315, -1315, -1315, -1315, -1315, -1315, 1777, -1315, 793, 865, 1639 884, 894, 869, 902, 905, 909, 2809, -1315, -1315, 918, 1640 120, 935, -1315, -1315, 927, -1315, -1315, -1315, 9296, -1315, 1641 -1315, -1315, -1315, -1315, 3249, -1315, 8833, 8833, -1315, 428, 1642 1777, 7213, 823, 8393, -1315, -1315, -1315, -1315, 9296, 74, 1643 -1315, -1315, 675, 272, -1315, -1315, 9296, -1315, 6557, -1315, 1644 -1315, 428, 428, 295, 9519, 937, 942, 934, 955, 428, 1645 -1315, -1315, -1315, -1315, 9927, -1315, 540, 6680, -1315, 272, 1646 963, -1315, 1777, 10749, 5888, -1315, -1315, -1315, -1315, 899, 1647 3249, -1315, 8466, 664, 7663, -1315, -1315, -1315, 1232, 551, 1648 812, 787, 9849, 591, 8985, -1315, 9849, -1315, -1315, -1315, 1649 -1315, 576, -1315, 980, 762, 283, 8605, -1315, 9699, -1315, 1650 -1315, 8605, -1315, 8719, 8605, -1315, -1315, 987, -1315, 599, 1651 996, 706, 999, -1315, -1315, 6048, 6769, -1315, 137, -1315, 1652 -1315, 6053, -1315, 286, 6053, -1315, -1315, -1315, -1315, -1315, 1653 -1315, -1315, -1315, -1315, -1315, -1315, 5169, -1315, -1315, 10470, 1654 10470, 10470, 10470, 10470, 10470, 10470, 10470, 10470, 10470, 10470, 1655 10470, 10470, 10470, 10470, 10470, 10470, 10470, 4672, 5169, -1315, 1656 497, 1307, -1315, -1315, 314, 314, -1315, -1315, 8833, -1315, 1657 -1315, 927, 574, -1315, 927, 10393, -1315, -1315, -1315, 9329, 1658 6769, 1002, 1007, -1315, 9099, -1315, -1315, 595, -1315, 1019, 1659 941, 1024, 1647, 103, 812, -1315, 314, 314, 812, 133, 1660 -1315, 314, 314, 927, -1315, -1315, 314, 314, -1315, 835, 1661 9781, 823, 10894, 412, 469, 9781, -1315, 6389, -1315, 812, 1662 -1315, 8871, -1315, 191, 5383, 5383, 5383, 823, -1315, 4873, 1663 979, 513, 886, 151, 1028, 1030, -1315, 1036, 3771, 531, 1664 -1315, 1124, 823, 5383, 574, 1777, 574, 664, 782, 835, 1665 -1315, -1315, 802, 835, -1315, -1315, -1315, 762, -1315, 835, 1666 272, 9927, -1315, 606, 1050, 616, 1051, -1315, 1052, 272, 1667 -1315, -1315, 9296, 272, 1054, 9699, 1053, -1315, 1508, -1315, 1668 360, 367, 787, -1315, 787, 1056, 10470, -1315, 787, 10894, 1669 -1315, -1315, 1059, -1315, -1315, -1315, 574, -1315, 10822, 878, 1670 -1315, 5383, 769, 8320, -1315, -1315, 595, 1057, 1058, 1232, 1671 3288, -1315, -1315, 9849, -1315, -1315, 1065, -1315, -1315, 1066, 1672 -1315, 1065, 1064, 10667, 5169, 121, 1034, 100, 1074, 1071, 1673 1075, 778, 1072, 1078, -1315, 1080, 1082, 9557, 6889, -1315, 1674 5169, -1315, 706, 2222, -1315, -1315, -1315, 314, 314, 5021, 1675 5169, 1079, -1315, -1315, 886, 619, -1315, 5169, -1315, -1315, 1676 971, -1315, -1315, -1315, -1315, 339, 339, 731, 731, 846, 1677 846, 846, 846, 265, 265, 890, 795, 797, 810, 836, 1678 10470, 975, -1315, 9927, 1084, 1086, 1087, 1307, -1315, -1315, 1679 -1315, -1315, -1315, 9927, 639, 5383, -1315, 8871, -1315, 7302, 1680 9175, -1315, 8757, 7182, -1315, -1315, 941, 9927, 923, 1093, 1681 1097, 1098, 1101, 1104, 1109, 1110, -1315, 3448, 1647, -1315, 1682 -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, 1683 -1315, -1315, -1315, -1315, -1315, -1315, 927, -1315, -1315, -1315, 1684 812, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, 1111, 1685 -1315, 1115, 1116, -1315, -1315, 120, 1079, 4873, -1315, -1315, 1686 -1315, 3575, 1113, -1315, -1315, -1315, -1315, -1315, 787, 6479, 1687 1200, -1315, -1315, -1315, -1315, 1100, 120, -1315, -1315, 927, 1688 -1315, -1315, 927, 146, 927, -1315, -1315, -1315, -1315, -1315, 1689 -1315, 9481, -1315, 272, -1315, -1315, 380, 387, 9213, 7422, 1690 1947, 10470, 2081, -1315, -1315, 1121, 77, 1121, -1315, 787, 1691 -1315, 314, -1315, -1315, 9630, 934, -1315, -1315, -1315, 942, 1692 1122, 1117, -1315, -1315, 1129, 1130, -1315, 769, 2444, -1315, 1693 476, -1315, 3288, 812, -1315, 1135, 9849, 9811, 8833, 1136, 1694 -1315, -1315, 1127, 1137, 1131, -1315, 10470, 134, 293, 1138, 1695 -1315, 1142, 574, 1142, 6769, 5169, -1315, -1315, 1142, 1139, 1696 -1315, 1150, 1152, 1153, 2222, -1315, -1315, -1315, 3575, -1315, 1697 -1315, -1315, -1315, 1156, 5169, 1140, 574, 4873, -1315, 6053, 1698 -1315, 574, -1315, -1315, 5169, -1315, 842, 835, -1315, -1315, 1699 -1315, -1315, -1315, -1315, -1315, 886, 878, 9061, -1315, -1315, 1700 7542, 1163, -1315, 882, 835, -1315, 892, 926, 835, -1315, 1701 428, 4553, -1315, -1315, -1315, 9927, 9927, -1315, 8393, 8393, 1702 -1315, 1161, 1164, 1169, 1172, -1315, 1171, 527, 41, 1079, 1703 -1315, 574, -1315, 3771, -1315, 5169, 423, -1315, 6649, 1175, 1704 1177, 10335, 1178, 1181, 9, 73, 48, 5169, 1182, 272, 1705 5169, 5169, 1132, 1180, 489, 1162, -1315, -1315, -1315, 1184, 1706 -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, 787, 1707 1183, 5169, -1315, 9927, 9927, 314, 1186, -1315, 9668, -1315, 1708 -1315, 984, -1315, 2081, -1315, -1315, -1315, -1315, 1508, -1315, 1709 -1315, 1188, -1315, -1315, -1315, -1315, 1191, 2444, -1315, -1315, 1710 1185, -1315, 1065, -1315, -1315, 1777, 1194, -1315, -1315, -1315, 1711 640, 1198, -1315, 100, 1201, 10470, 1195, 100, 100, 1213, 1712 1214, -1315, 6048, 959, 835, -1315, -1315, 1036, 5169, 1217, 1713 1156, 654, 46, 1216, -1315, 1214, -1315, 1222, 1216, -1315, 1714 -1315, 1226, -1315, -1315, 927, 1229, 1230, 7062, 1231, 1235, 1715 1237, -1315, -1315, 1242, -1315, -1315, 927, -1315, -1315, -1315, 1716 -1315, 927, 5169, 5169, 878, 1244, -1315, -1315, -1315, -1315, 1717 -1315, -1315, -1315, -1315, -1315, -1315, -1315, -1315, 10470, 10470, 1718 1246, 1253, 1216, -1315, -1315, 787, -1315, -1315, -1315, 4813, 1719 9811, 5169, 5169, 1321, 5169, -1315, 1239, -1315, 1247, -1315, 1720 1248, 5169, 1250, 5169, 986, 1252, 81, 314, 9367, 1069, 1721 -1315, -1315, 6479, 1261, 436, -1315, -1315, -1315, -1315, -1315, 1722 -1315, -1315, -1315, -1315, 10153, -1315, 8466, 1268, -1315, -1315, 1723 9811, 437, 451, -1315, 1270, 1271, 762, 1280, -1315, 352, 1724 -1315, -1315, 5169, 1281, -1315, -1315, 927, 1277, -1315, -1315, 1725 1284, 301, 375, 574, 1285, 1288, -1315, 1290, -1315, 9927, 1726 -1315, -1315, -1315, -1315, -1315, 1291, -1315, 9927, 9927, 9927, 1727 -1315, -1315, 1293, -1315, 1295, 1298, 1299, 590, 8088, 8204, 1728 -1315, -1315, 304, -1315, 1302, 1303, -1315, 8539, 652, 671, 1729 1308, 690, 6255, -1315, -1315, -1315, 471, -1315, 711, 1310, 1730 1311, 272, 1363, 1043, -1315, -1315, 5169, -1315, 10335, 6053, 1731 -1315, -1315, -1315, 1317, 1318, -1315, -1315, -1315, 1316, -1315, 1732 -1315, -1315, -1315, -1315, -1315, 9811, 762, 155, -1315, 1300, 1733 762, 1156, 297, 9927, -1315, -1315, -1315, -1315, -1315, -1315, 1734 -1315, -1315, 1314, -1315, -1315, -1315, -1315, -1315, -1315, 1323, 1735 1324, -1315, -1315, -1315, -1315, -1315, -1315, -1315, 1329, -1315, 1736 1330, -1315, -1315, 10335, 135, 5169, 10335, -1315, 1333, 5169, 1737 -1315, 281, 1344, 1348, -1315, -1315, 1340, 1343, 1331, -1315, 1738 988, -1315, -1315, -1315, 823, 1777, 1338, 801, 995, 10470, 1739 -1315, 713, 1349, 5169, -1315, 574, 574, 1350, 1355, 1356, 1740 1358, -1315, -1315, 8393, 1359, -1315, 1430, 10470, 1360, -1315, 1741 -1315, 10246, -1315, 722, -1315, 1347, 10335, 1352, -1315, -1315, 1742 1366, -1315, 1370, -1315, 1385, 1386, -1315, 1354, 9811, -1315, 1743 -1315, -1315, 762, 574, 1382, 1364, 1381, -1315, 1389, 1216, 1744 1216, -1315, -1315, -1315, -1315, -1315, 10335, 197, -1315, 1000, 1745 -1315, -1315, 7897, -1315, -1315, 1368, 5169, -1315, 5169, 7897, 1746 272, 9699, 272, 9699, 1391, -1315, 1392, -1315, -1315, 1390, 1747 801, -1315, 776, -1315, -1315, 5169, -1315, 1394, 1395, -1315, 1748 10470, 10470, -1315, -1315, 1077, 85, -1315, -1315, 1372, -1315, 1749 1077, -1315, -1315, 2494, 574, -1315, -1315, 272, 9699, 272, 1750 9699, 1403, 1383, 574, -1315, -1315, -1315, -1315, -1315, 10246, 1751 1401, 1077, 5739, 5169, 10157, 1402, 1077, 1408, 2494, 2404, 1752 -1315, -1315, -1315, 1409, -1315, -1315, -1315, -1315, 8833, -1315, 1753 -1315, -1315, 10024, -1315, 10246, -1315, -1315, 1388, 9931, -1315, 1754 -1315, 10157, 272, 2404, 272, 1413, 1414, 857, -1315, 10024, 1755 -1315, -1315, -1315, 9931, -1315, -1315, -1315, 272, 272, -1315, 1756 -1315, -1315, -1315, -1315, -1315, -1315, -1315 1753 1757 }; 1754 1758 … … 1756 1760 static const yytype_int16 yypgoto[] = 1757 1761 { 1758 -1 414, 4377, 3077, -1414, 1645, -1414, 305, 958, -11, -1414,1759 552, -530, -487, -944, -142, 3604, 0, -1414, 1277, 511,1760 5 29, 298, 549, 1057, 1060, 1054, 1062, 1065, -1414, -211,1761 - 327, 5116, -961, -725, -952, -1414, -200, -594, 572, -1414,1762 1 379, -1414, 397, -1413, -1414, -1414, 129, -1414, -1160, -935,1763 246, -1414, -1414, -1414, -1414, 68, -1131, -1414, -1414, -1414,1764 -1 414, -1414, -1414, 321, -1152, 33, -1414, -696, -1414, 506,1765 2 96, -1414, 169, -1414, -339, -1414, -1414, -1414, 558, -728,1766 -1 414, -1414, 19, -974, 177, 2303, -1414, -1414, -1414, -91,1767 -1 414, 166, 269, -194, 1705, 3615, -1414, -1414, 36, 224,1768 628, -235, 1694, -1414, 1557, -1414, -1414, 200, 2163, -1414,1769 2 278, 185, -1414, -1414, -1414, -607, -1414, 956, 957, 545,1770 725, -320, -1414, -1414, -1414, 950, 719, -493, -1414, -472,1771 -35 5, 1296, -1414, -1414, -899, -946, 440, 524, 1067, 168,1772 -1 414, 1040, 317, -281, -198, -141, 672, 781, -1414, 1005,1773 -1 414, 2834, 55, -450, 932, -1414, -1414, 712, -1414, -228,1774 -1 414, 104, -1414, -1414, -1414, -1285, 420, -1414, -1414, -1414,1775 1 178, -1414, 31, -1414, -1414, -862, -94, -1364, -152, 1641,1776 -1 414, 3733, -1414, 927, -1414, -170, 493, -184, -183, -181,1777 7, - 42, -36, -33, 1610, 4, 10, 14, -143, -177,1778 -1 72, -162, -161, -319, -513, -508, -498, -547, -310, -528,1779 -1 414, -1414, -511, 1101, 1102, 1110, 1575, 4802, -565, -560,1780 -5 59, -541, -551, -1414, -506, -744, -736, -732, -593, -267,1781 - 227, -1414, -1414, 624, 294, -85, -1414, 3753, 44, -634,1782 - 1731762 -1315, 4470, 3041, -1315, 39, -1315, 2507, 957, -207, -1315, 1763 461, -523, -489, -955, -200, 5636, 0, -1315, 72, 572, 1764 580, 245, 566, 964, 967, 968, 966, 976, -1315, 1601, 1765 -609, 5067, -949, -1315, -712, -938, 430, -728, 512, -1315, 1766 1697, -1315, 311, -1200, -1315, -1315, 43, -1315, -1142, -1154, 1767 154, -1315, -1315, -1315, -1315, -26, -1161, -1315, -1315, -1315, 1768 -1315, -1315, -1315, 231, -1202, 53, -1315, -908, -1315, 416, 1769 205, -1315, 78, -1315, -367, -1315, -1315, -1315, 470, -824, 1770 -1315, -1315, 13, -940, 465, 2639, -1315, -1315, -1315, -107, 1771 -1315, 102, 269, -201, 1635, 4179, -1315, -1315, 5, 449, 1772 756, -259, 1489, -1315, 1725, -1315, -1315, 52, 2057, -1315, 1773 2147, 612, -1315, -1315, -1315, -616, -1315, 866, 867, 456, 1774 631, 158, -1315, -1315, -1315, 858, 633, -514, -1315, -544, 1775 -359, 1913, -1315, -1315, -928, -991, 1380, 1398, 990, 324, 1776 -1315, 171, 457, -332, -192, -147, 584, 695, -1315, 919, 1777 -1315, 2794, 1328, -442, 850, -1315, -1315, 625, -1315, -238, 1778 -1315, -94, -1315, -1315, -1315, -1246, 330, -1315, -1315, -1315, 1779 1091, -1315, 35, -1315, -1315, -834, -97, -1314, -130, 1985, 1780 -1315, 3026, -1315, 844, -1315, -170, 1212, -183, -173, -167, 1781 7, -35, -34, -33, 936, 18, 55, 61, -143, -159, 1782 -156, -153, -151, -323, -535, -528, -526, -542, -318, -520, 1783 -1315, -1315, -512, 1006, 1009, 1011, 2067, 4895, -560, -543, 1784 -538, -536, -484, -1315, -481, -740, -737, -736, -586, -304, 1785 -339, -1315, -1315, 856, 707, -88, -1315, 3848, 29, -599, 1786 -291 1783 1787 }; 1784 1788 … … 1786 1790 positive, shift that token. If negative, reduce the rule which 1787 1791 number is the opposite. If YYTABLE_NINF, syntax error. */ 1788 #define YYTABLE_NINF -52 61792 #define YYTABLE_NINF -525 1789 1793 static const yytype_int16 yytable[] = 1790 1794 { 1791 50, 115, 151, 400, 401, 771, 402, 99, 152, 973, 1792 403, 153, 429, 454, 874, 404, 756, 974, 408, 1080, 1793 116, 975, 262, 441, 269, 405, 406, 744, 850, 384, 1794 385, 605, 50, 51, 1142, 982, 70, 411, 833, 99, 1795 610, 825, 826, 727, 149, 409, 499, 732, 154, 1150, 1796 50, 31, 1398, 836, 155, 1462, 832, 163, 156, 843, 1797 827, 800, 282, 145, 188, 51, 1208, 211, 70, 528, 1798 50, 195, 343, 824, 218, 567, 1200, 228, 31, 597, 1799 671, -235, -235, 400, 401, 1184, 402, 926, 821, 221, 1800 403, 1318, 170, 822, 168, 404, 520, 737, 408, 1194, 1801 680, 1217, 1218, 823, 738, 405, 406, 115, 684, 426, 1802 568, 476, 478, 1550, 31, 115, 171, 124, 268, 273, 1803 283, 254, 217, 412, 31, 409, 1209, 410, 715, 1462, 1804 1210, 1182, 1183, 1561, 31, 1419, 1420, 31, 629, 244, 1805 1565, 955, 633, 865, 866, 151, 675, 677, 308, 149, 1806 412, 152, -235, 1079, 153, 1481, 163, 115, 346, 168, 1807 1319, 884, 211, 863, 863, 863, 64, 472, 973, 374, 1808 722, 204, 477, 31, 217, 528, 974, 57, 117, 1260, 1809 975, 853, 863, 920, 420, 854, 412, 188, 188, 1212, 1810 1211, 154, 328, 578, 482, 163, 412, 155, 64, 579, 1811 78, 156, 528, 268, 834, 1421, 602, 821, 528, 57, 1812 956, 50, 822, 669, 731, 1190, 716, 217, 163, 938, 1813 293, 205, 823, 211, 71, 151, 179, 674, 676, 1127, 1814 444, 152, 78, 746, 153, 1213, 1087, 666, -113, -113, 1815 863, 308, 1191, 841, 212, 602, 1263, 222, 580, 958, 1816 412, 125, 216, 50, -113, 437, 71, 589, 825, 826, 1817 99, 273, 144, 1466, 667, 1026, 273, 268, 268, 836, 1818 118, 1152, 506, 115, 1264, 163, 263, 827, 217, 264, 1819 864, 864, 864, 1025, 464, 328, 51, 343, 1001, 70, 1820 1013, 214, 1184, 610, 108, 108, 308, 1103, 804, 864, 1821 1090, 146, 1343, 658, 216, 821, 113, 520, 308, 378, 1822 822, 666, 520, 148, 1004, 520, 217, 437, 725, 161, 1823 823, 217, 1199, 1508, 572, 379, 108, 477, 472, 149, 1824 1200, 673, 1419, 1420, 448, 863, 374, 678, 667, 855, 1825 -470, 157, 115, 856, 905, 1184, 346, 216, 472, 569, 1826 603, 621, 168, 461, 597, 528, 472, 864, 1537, 597, 1827 1539, 1466, 1080, 810, 108, 626, 1466, 388, 793, 626, 1828 930, -470, 115, -470, 1492, 833, 260, -470, -113, 825, 1829 826, 685, 1401, 389, 161, 1405, 1466, 579, 440, 1128, 1830 599, 1182, 1183, 1466, 715, 1551, 1129, 268, 827, -113, 1831 442, 1191, 1430, 557, 558, 859, 217, 188, 216, 8, 1832 9, 10, 11, 12, 374, 173, 850, 324, 183, 64, 1833 43, 252, 1566, 876, 473, 268, 340, 308, 308, 1247, 1834 57, 268, 837, 1251, 626, 571, 840, 412, 31, 559, 1835 560, 343, 484, 391, 46, 47, 216, 443, 494, 501, 1836 495, 216, 864, 78, 877, 115, 644, 857, 78, 392, 1837 878, 860, 393, 1451, 1452, 1214, 34, 1170, 1172, 1184, 1838 1138, 328, 328, 268, 203, 855, 431, 71, 394, 1110, 1839 435, 268, 716, 626, 395, 50, 929, 217, 374, 721, 1840 1200, 112, 99, 98, 736, 115, 1079, 1200, 1114, 499, 1841 396, 249, 41, 42, 1148, 1259, 888, 308, 875, 115, 1842 324, 1024, 308, -291, 308, 308, 1457, 179, 51, 917, 1843 610, 70, 754, -521, 921, 98, 115, 346, 1341, 217, 1844 763, 583, 923, 412, 630, 1342, 216, 150, 634, 328, 1845 922, 112, 435, 98, 1026, 489, 919, 108, 924, 43, 1846 1200, -106, 41, 42, 921, -106, 715, 191, 328, 466, 1847 98, 1521, 886, 98, 753, 522, 412, 1526, 923, 254, 1848 1091, 572, 572, 46, 47, 214, 1381, 161, 265, 308, 1849 769, 995, 1006, 43, 1092, 473, 1094, 810, 1546, 1138, 1850 626, 346, 472, 1553, 920, 621, 1197, 1097, 939, 1097, 1851 602, 603, 331, 603, 1197, 473, 1332, 46, 47, 332, 1852 706, 588, 1198, 473, 1334, 594, 707, 216, 935, 78, 1853 1324, 626, 1333, 328, 751, 1024, 626, 812, 621, 1367, 1854 1335, 1126, 626, 1368, 627, 626, 626, 626, 631, 78, 1855 1382, 340, 98, 889, 716, 412, -113, 78, -113, 713, 1856 217, 64, -113, -10, 626, 98, 268, 895, 1039, 216, 1857 723, 112, 57, 343, -444, 851, 724, -113, -113, 1037, 1858 599, 733, 41, 42, 165, 1181, 810, 734, 217, 1029, 1859 399, 191, 288, 217, -445, 78, 115, 254, 330, 914, 1860 1084, 553, 554, 41, 42, 750, 324, 324, 214, 231, 1861 1348, 751, 929, 232, 98, 892, 236, 412, 238, 71, 1862 1379, 550, 626, 940, 621, 247, 98, 551, 552, 515, 1863 721, 721, 1122, 1154, 689, 412, 278, 959, 400, 401, 1864 280, 402, 1044, 555, 556, 403, 1498, 118, 281, 165, 1865 404, 333, 597, 1498, 408, 334, 98, 929, 115, 346, 1866 405, 406, 335, 754, 754, 217, 112, 336, 141, 142, 1867 480, 372, 489, 112, 324, 373, 489, 41, 42, 217, 1868 377, 409, 1111, 113, 41, 42, 522, 112, 522, 108, 1869 216, 522, 386, 324, 522, 1151, 973, 1429, 41, 42, 1870 852, 1392, 994, 991, 974, 340, 1547, 899, 975, 572, 1871 1249, 390, 1350, 751, 715, 398, 867, 626, 216, 626, 1872 901, 1009, 410, 216, 626, 346, 751, 990, 603, 743, 1873 427, 883, 98, 991, 739, 343, 740, 1003, 1174, 741, 1874 603, 428, 747, 707, 764, 436, 1039, 743, 433, 770, 1875 743, 451, 231, 604, 529, 530, 531, 443, 324, 473, 1876 112, 812, 141, 142, 1245, 781, 782, 783, 784, 808, 1877 579, 41, 42, 1292, 1293, 1375, 217, 1166, 532, 412, 1878 533, 751, 534, 535, 1500, 473, 1501, -368, 1376, -397, 1879 1378, 308, 462, 78, 751, 216, 751, 1383, 466, 870, 1880 849, 505, 716, 751, 1169, 594, 602, 436, 463, 216, 1881 191, 858, 501, 626, 1195, 704, 1171, 810, 602, 78, 1882 115, 346, 914, 1447, 914, 713, 929, 70, 485, 1444, 1883 524, 1467, 1514, 1571, 214, 666, 115, 751, 1515, 579, 1884 917, 1548, 165, 293, 1256, 1370, 412, 509, 214, 940, 1885 940, 529, 530, 531, 721, 254, 330, 412, 514, 115, 1886 308, 528, 667, 561, 562, 689, 526, 919, 49, 114, 1887 885, 563, 887, 751, 996, 532, 346, 533, 1115, 534, 1888 1321, 716, 565, 37, 330, 412, 754, 40, 98, 929, 1889 929, 231, 604, 236, 41, 42, 564, 114, 114, 705, 1890 49, 1388, 1389, 489, 328, 43, 216, 1439, 991, 1533, 1891 1444, 1445, 49, 1300, 1301, 566, 1303, 569, 49, 346, 1892 44, 339, 934, 1308, -441, 1310, 49, 340, 587, 46, 1893 47, 694, 49, 1240, 590, 49, 1493, 1494, 49, -3, 1894 626, 626, 420, 662, 412, 214, 2, 208, 4, 5, 1895 6, 7, 114, 114, 482, 330, 412, 64, 639, 1138, 1896 308, 1419, 1420, 851, 834, 330, 602, 659, 57, 8, 1897 9, 10, 11, 12, 777, 778, 49, 217, 668, 49, 1898 143, 231, 660, 661, 1446, 663, 49, 713, 1005, 693, 1899 664, 78, 665, 808, 779, 780, 1202, 670, 31, 259, 1900 115, 697, 1459, 695, 820, 914, 604, 1311, 1312, 1313, 1901 914, 35, 699, 36, -239, 71, 735, 49, 748, 940, 1902 785, 786, 704, 752, 959, 49, 34, 268, 959, 959, 1903 49, 1349, 1351, 1352, 243, 246, 1116, 760, 813, -12, 1904 814, 524, 817, 524, 626, 343, 524, 828, -13, 524, 1905 -292, 872, 873, 43, 880, 49, 49, 8, 9, 10, 1906 11, 12, 900, 902, 724, 907, 903, 910, 571, 346, 1907 412, 49, 928, -418, -3, 1519, 1459, 46, 47, 49, 1908 -525, 943, 808, 950, 964, 108, 31, 1425, 49, 340, 1909 952, 49, 918, 957, 963, 965, 967, 968, 114, 969, 1910 929, 970, 986, 998, 999, 689, 705, 216, 1000, 1015, 1911 1016, 273, 115, 114, 34, 1017, 1018, 114, 929, 1019, 1912 1020, 49, 114, 820, 604, 1021, 473, 489, 1117, 324, 1913 115, 221, 1032, -406, 308, 49, 49, 57, -405, 37, 1914 1081, 1046, 49, 40, 1083, 704, 443, 1339, 626, 49, 1915 41, 42, 115, 108, 913, 704, 112, 1105, 141, 240, 1916 78, 43, 112, 1104, 141, 142, 217, 41, 42, 704, 1917 70, 1115, 1106, 41, 42, 1107, 818, 751, 602, 1131, 1918 1113, 1123, 1124, 1125, 71, 46, 47, 1134, 849, 1130, 1919 980, 929, 929, 241, 1140, 458, 1135, 49, 242, 728, 1920 626, 626, 1136, 1144, 729, 1137, 743, 1164, 1144, 273, 1921 1143, 1187, 1185, 1442, 308, 1186, -293, 49, 49, 1188, 1922 693, 820, 1559, 8, 9, 10, 11, 12, 1189, 705, 1923 1203, 1204, 1206, 604, 49, 713, 1207, 1399, 49, 705, 1924 1215, 1399, 1219, -3, 1220, 1222, 1227, 115, 1232, 645, 1925 1202, 1237, 31, 705, 108, 1235, 400, 401, 1144, 402, 1926 1241, 1246, 494, 403, 217, 49, 1115, 1248, 404, 689, 1927 1253, 408, 1254, 1261, 1250, 49, 1268, 1270, 405, 406, 1928 34, 2, 208, 4, 5, 6, 7, 1265, 212, 222, 1929 1272, 1273, 1302, 49, 1274, 666, 216, 1275, 409, 49, 1930 64, 49, 1276, 1278, 1285, 1305, 1294, 268, 1295, 1306, 1931 230, 57, 1323, 808, 713, 1093, 131, 918, 132, 133, 1932 134, 1532, 667, 1307, 1330, 626, 1336, 41, 42, 1116, 1933 1309, 646, 1317, 1338, 78, 214, 114, 1340, 1344, 1346, 1934 1347, 49, 1353, 1482, 1354, 175, 35, 604, 36, 49, 1935 115, 1355, 1357, 49, 1363, 1364, 1365, 49, 71, 1366, 1936 114, 1377, 114, 1068, 37, 1373, 176, 177, 40, 1115, 1937 1374, 1384, 1385, 1313, 115, 41, 42, 704, 704, 1393, 1938 473, 115, 645, 115, 1394, 115, 442, 1395, 255, 1402, 1939 1413, 57, 1405, 1414, 216, -407, 1417, 114, 151, 340, 1940 645, 373, 114, 645, 152, 1428, 108, 153, 1432, 1436, 1941 1202, 1434, 1437, 1443, 78, 1531, 1448, 1202, 1438, 1453, 1942 115, 1117, 115, 1368, 1116, 1458, 1454, 1455, 108, 1456, 1943 1472, 1463, 1474, 443, 115, 704, 704, 1468, 71, 1476, 1944 1531, 1531, 726, 1470, 730, -294, 108, 1478, 163, 1485, 1945 308, 114, 8, 9, 10, 11, 12, 1480, 49, 1486, 1946 693, 705, 705, 1487, 37, 1531, 1488, 76, 40, 49, 1947 1202, 49, 374, 511, 1441, 41, 42, 1499, 1144, 1144, 1948 1144, 31, 1509, 1511, 418, 1513, 43, 1517, 1518, 1525, 1949 49, 1540, 1541, 1545, 328, 548, 549, 1554, 918, 76, 1950 1552, 720, 112, 918, 141, 142, 49, 438, 108, 34, 1951 46, 47, 114, 41, 42, 1556, 1117, 446, 1562, 705, 1952 705, 49, 1569, 114, 49, 114, 1570, 1116, 1221, 789, 1953 787, 1322, 1520, 548, 788, 1205, 743, 224, 790, 1431, 1954 473, 108, 791, 1572, 245, 1387, 1252, 473, 1403, 1226, 1955 1502, 57, 908, 909, 1098, 1234, 1102, 49, 57, 931, 1956 806, 114, 1139, 114, 1045, 879, 945, 114, 1112, 548, 1957 164, 953, 1331, 718, 78, 114, 0, 126, 129, 130, 1958 0, 78, 796, 797, 196, 521, 1328, 219, 49, 49, 1959 229, 798, 0, 0, 871, 0, 0, 0, 71, 0, 1960 473, 0, 49, 0, 0, 71, 37, 0, 176, 177, 1961 40, 57, 0, 178, 0, 67, 119, 41, 42, 1117, 1962 0, 704, 1144, 1144, 693, 354, 0, 0, 0, 704, 1963 704, 704, 0, 0, 78, 2, 208, 4, 5, 6, 1964 7, 0, 0, 925, 108, 927, 0, 67, 0, 458, 1965 0, 256, 1505, 257, 1505, 0, 0, 0, 71, 0, 1966 1483, 0, 0, 178, 0, 162, 178, 0, 108, 164, 1967 1329, 215, 0, 0, 0, 108, 414, 0, 0, 0, 1968 0, 234, 375, 422, 0, 223, 49, 0, 0, 1505, 1969 0, 1505, 0, 0, 0, 704, 0, 0, 49, 450, 1970 35, 0, 36, 0, 0, 705, 1068, 0, 164, 0, 1971 0, 0, 178, 705, 705, 705, 0, 0, 0, 324, 1972 76, 1534, 261, 215, 0, 76, 0, 0, 108, 0, 1973 1542, 164, 0, 682, 397, 0, 0, 774, 775, 776, 1974 0, 645, 0, 445, 416, 417, 0, 0, 114, 421, 1975 0, 423, 424, 0, 0, 414, 0, 0, 37, 708, 1976 176, 177, 40, 0, 329, 0, 215, 0, 0, 41, 1977 42, 49, 261, 351, 0, 178, 0, 0, 0, 705, 1978 49, 0, 49, 0, 0, 0, 0, 0, 37, 114, 1979 185, 186, 40, 0, 0, 377, 521, 0, 0, 41, 1980 42, 521, 1391, 407, 521, 0, 0, 0, 0, 577, 1981 43, 0, 49, 0, 0, 0, 0, 581, 425, 224, 1982 584, 430, 432, 646, 0, 187, 162, 215, 0, 178, 1983 1049, 0, 114, 0, 46, 47, 178, 0, 0, 0, 1984 0, 0, 0, 0, 0, 0, 0, 449, 645, 375, 1985 0, 452, 0, 453, 0, 0, 114, 1418, 0, 645, 1986 1426, 114, 460, 0, 0, 215, 0, 0, 67, 0, 1987 215, 1099, 0, 474, 0, 0, 0, 0, 898, 0, 1988 0, 0, 0, 481, 414, 500, 76, 0, 422, 0, 1989 0, 432, 0, 0, 8, 9, 10, 11, 12, 0, 1990 0, 354, 0, 0, 178, 1465, 76, 0, 0, 0, 1991 1469, 114, 0, 0, 76, 8, 9, 10, 11, 12, 1992 0, 178, 0, 31, 0, 178, 0, 375, 0, 0, 1993 646, 0, 354, 480, 0, 0, 0, 0, 0, 0, 1994 1491, 0, 0, 0, 31, 0, 0, 981, 0, 114, 1995 354, 34, 76, 0, 0, 215, 0, 261, 0, 0, 1996 897, 595, 0, 49, 0, 414, 0, 623, 49, 904, 1997 0, 0, 34, 906, 0, 0, 0, 0, 43, 0, 1998 628, 0, 0, 0, 628, 49, 0, 261, 178, 0,