diff options
34 files changed, 1320 insertions, 1630 deletions
diff --git a/include/llvm/Function.h b/include/llvm/Function.h index 3d75db8a03..2ffd5eaacd 100644 --- a/include/llvm/Function.h +++ b/include/llvm/Function.h @@ -27,7 +27,6 @@ namespace llvm { class FunctionType; -class ParamAttrsList; // Traits for intrusive list of instructions... template<> struct ilist_traits<BasicBlock> @@ -69,7 +68,7 @@ private: BasicBlockListType BasicBlocks; ///< The basic blocks mutable ArgumentListType ArgumentList; ///< The formal arguments ValueSymbolTable *SymTab; ///< Symbol table of args/instructions - const ParamAttrsList *ParamAttrs; ///< Parameter attributes + PAListPtr ParamAttrs; ///< Parameter attributes // The Calling Convention is stored in Value::SubclassData. /*unsigned CallingConvention;*/ @@ -145,16 +144,11 @@ public: SubclassData = (SubclassData & 1) | (CC << 1); } - /// Obtains a constant pointer to the ParamAttrsList object which holds the - /// parameter attributes information, if any. - /// @returns 0 if no parameter attributes have been set. - /// @brief Get the parameter attributes. - const ParamAttrsList *getParamAttrs() const { return ParamAttrs; } - - /// Sets the parameter attributes for this Function. To construct a - /// ParamAttrsList, see ParameterAttributes.h - /// @brief Set the parameter attributes. - void setParamAttrs(const ParamAttrsList *attrs); + /// getParamAttrs - Return the parameter attributes for this function. + const PAListPtr &getParamAttrs() const { return ParamAttrs; } + + /// setParamAttrs - Set the parameter attributes for this Function. + void setParamAttrs(const PAListPtr &attrs) { ParamAttrs = attrs; } /// hasCollector/getCollector/setCollector/clearCollector - The name of the /// garbage collection algorithm to use during code generation. diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index 3aa8d6879c..d29e11ca27 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -30,7 +30,6 @@ class PointerType; class VectorType; class ConstantRange; class APInt; -class ParamAttrsList; //===----------------------------------------------------------------------===// // AllocationInst Class @@ -851,7 +850,7 @@ public: /// class CallInst : public Instruction { - const ParamAttrsList *ParamAttrs; ///< parameter attributes for call + PAListPtr ParamAttrs; ///< parameter attributes for call CallInst(const CallInst &CI); void init(Value *Func, Value* const *Params, unsigned NumParams); void init(Value *Func, Value *Actual1, Value *Actual2); @@ -927,16 +926,12 @@ public: SubclassData = (SubclassData & 1) | (CC << 1); } - /// Obtains a pointer to the ParamAttrsList object which holds the - /// parameter attributes information, if any. - /// @returns 0 if no attributes have been set. - /// @brief Get the parameter attributes. - const ParamAttrsList *getParamAttrs() const { return ParamAttrs; } + /// getParamAttrs - Return the PAListPtr for the parameter attributes of this + /// call. + const PAListPtr &getParamAttrs() const { return ParamAttrs; } - /// Sets the parameter attributes for this CallInst. To construct a - /// ParamAttrsList, see ParameterAttributes.h - /// @brief Set the parameter attributes. - void setParamAttrs(const ParamAttrsList *attrs); + /// setParamAttrs - Sets the parameter attributes for this CallInst. + void setParamAttrs(const PAListPtr &Attrs) { ParamAttrs = Attrs; } /// @brief Determine whether the call or the callee has the given attribute. bool paramHasAttr(uint16_t i, unsigned attr) const; @@ -1678,7 +1673,7 @@ private: /// calling convention of the call. /// class InvokeInst : public TerminatorInst { - const ParamAttrsList *ParamAttrs; + PAListPtr ParamAttrs; InvokeInst(const InvokeInst &BI); void init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException, Value* const *Args, unsigned NumArgs); @@ -1745,16 +1740,13 @@ public: SubclassData = CC; } - /// Obtains a pointer to the ParamAttrsList object which holds the - /// parameter attributes information, if any. - /// @returns 0 if no attributes have been set. - /// @brief Get the parameter attributes. - const ParamAttrsList *getParamAttrs() const { return ParamAttrs; } + /// getParamAttrs - Return the parameter attribute list for this invoke. + /// + const PAListPtr &getParamAttrs() const { return ParamAttrs; } - /// Sets the parameter attributes for this InvokeInst. To construct a - /// ParamAttrsList, see ParameterAttributes.h - /// @brief Set the parameter attributes. - void setParamAttrs(const ParamAttrsList *attrs); + /// setParamAttrs - Set the parameter attribute list for this invoke. + /// + void setParamAttrs(const PAListPtr &Attrs) { ParamAttrs = Attrs; } /// @brief Determine whether the call or the callee has the given attribute. bool paramHasAttr(uint16_t i, ParameterAttributes attr) const; diff --git a/include/llvm/Intrinsics.h b/include/llvm/Intrinsics.h index d3aed6b7cf..2027383dbf 100644 --- a/include/llvm/Intrinsics.h +++ b/include/llvm/Intrinsics.h @@ -22,7 +22,7 @@ class Type; class FunctionType; class Function; class Module; -class ParamAttrsList; +class PAListPtr; /// Intrinsic Namespace - This namespace contains an enum with a value for /// every intrinsic/builtin function known by LLVM. These enum values are @@ -49,7 +49,7 @@ namespace Intrinsic { /// Intrinsic::getParamAttrs(ID) - Return the attributes for an intrinsic. /// - const ParamAttrsList *getParamAttrs(ID id); + PAListPtr getParamAttrs(ID id); /// Intrinsic::getDeclaration(M, ID) - Create or insert an LLVM Function /// declaration for an intrinsic, and return it. diff --git a/include/llvm/ParamAttrsList.h b/include/llvm/ParamAttrsList.h deleted file mode 100644 index 00e9707beb..0000000000 --- a/include/llvm/ParamAttrsList.h +++ /dev/null @@ -1,226 +0,0 @@ -//===-- llvm/ParamAttrsList.h - List and Vector of ParamAttrs ---*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file contains classes used to represent the parameter attributes -// associated with functions and their calls. -// -// The implementation of ParamAttrsList is in VMCore/ParameterAttributes.cpp. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_PARAM_ATTRS_LIST_H -#define LLVM_PARAM_ATTRS_LIST_H - -#include "llvm/ParameterAttributes.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/FoldingSet.h" - -namespace llvm { - -/// @brief A vector of attribute/index pairs. -typedef SmallVector<ParamAttrsWithIndex,4> ParamAttrsVector; - -/// This class represents a list of attribute/index pairs for parameter -/// attributes. Each entry in the list contains the index of a function -/// parameter and the associated ParameterAttributes. If a parameter's index is -/// not present in the list, then no attributes are set for that parameter. The -/// list may also be empty, but this does not occur in practice. An item in -/// the list with an index of 0 refers to the function as a whole or its result. -/// To construct a ParamAttrsList, you must first fill a ParamAttrsVector with -/// the attribute/index pairs you wish to set. The list of attributes can be -/// turned into a string of mnemonics suitable for LLVM Assembly output. -/// Various accessors are provided to obtain information about the attributes. -/// Note that objects of this class are "uniqued". The \p get method can return -/// the pointer of an existing and identical instance. Consequently, reference -/// counting is necessary in order to determine when the last reference to a -/// ParamAttrsList of a given shape is dropped. Users of this class should use -/// the addRef and dropRef methods to add/drop references. When the reference -/// count goes to zero, the ParamAttrsList object is deleted. -/// This class is used by Function, CallInst and InvokeInst to represent their -/// sets of parameter attributes. -/// @brief A List of ParameterAttributes. -class ParamAttrsList : public FoldingSetNode { - /// @name Construction - /// @{ - private: - // ParamAttrsList is uniqued, these should not be publicly available - void operator=(const ParamAttrsList &); // Do not implement - ParamAttrsList(const ParamAttrsList &); // Do not implement - ~ParamAttrsList(); // Private implementation - - /// Only the \p get method can invoke this when it wants to create a - /// new instance. - /// @brief Construct an ParamAttrsList from a ParamAttrsVector - explicit ParamAttrsList(const ParamAttrsVector &attrVec); - - public: - /// This method ensures the uniqueness of ParamAttrsList instances. The - /// argument is a vector of attribute/index pairs as represented by the - /// ParamAttrsWithIndex structure. The index values must be in strictly - /// increasing order and ParamAttr::None is not allowed. The vector is - /// used to construct the ParamAttrsList instance. If an instance with - /// identical vector pairs exists, it will be returned instead of creating - /// a new instance. - /// @brief Get a ParamAttrsList instance. - static const ParamAttrsList *get(const ParamAttrsVector &attrVec); - - /// Returns the ParamAttrsList obtained by modifying PAL using the supplied - /// list of attribute/index pairs. Any existing attributes for the given - /// index are replaced by the given attributes. If there were no attributes - /// then the new ones are inserted. Attributes can be deleted by replacing - /// them with ParamAttr::None. Index values must be strictly increasing. - /// @brief Get a new ParamAttrsList instance by modifying an existing one. - static const ParamAttrsList *getModified(const ParamAttrsList *PAL, - const ParamAttrsVector &modVec); - - /// @brief Add the specified attributes to those in PAL at index idx. - static const ParamAttrsList *includeAttrs(const ParamAttrsList *PAL, - uint16_t idx, - ParameterAttributes attrs); - - /// @brief Remove the specified attributes from those in PAL at index idx. - static const ParamAttrsList *excludeAttrs(const ParamAttrsList *PAL, - uint16_t idx, - ParameterAttributes attrs); - - /// @} - /// @name Accessors - /// @{ - public: - /// The parameter attributes for the \p indexth parameter are returned. - /// The 0th parameter refers to the return type of the function. Note that - /// the \p param_index is an index into the function's parameters, not an - /// index into this class's list of attributes. The result of getParamIndex - /// is always suitable input to this function. - /// @returns The all the ParameterAttributes for the \p indexth parameter - /// as a uint16_t of enumeration values OR'd together. - /// @brief Get the attributes for a parameter - ParameterAttributes getParamAttrs(uint16_t param_index) const; - - /// This checks to see if the \p ith function parameter has the parameter - /// attribute given by \p attr set. - /// @returns true if the parameter attribute is set - /// @brief Determine if a ParameterAttributes is set - bool paramHasAttr(uint16_t i, ParameterAttributes attr) const { - return getParamAttrs(i) & attr; - } - - /// This extracts the alignment for the \p ith function parameter. - /// @returns 0 if unknown, else the alignment in bytes - /// @brief Extract the Alignment - uint16_t getParamAlignment(uint16_t i) const { - return (getParamAttrs(i) & ParamAttr::Alignment) >> 16; - } - - /// This returns whether the given attribute is set for at least one - /// parameter or for the return value. - /// @returns true if the parameter attribute is set somewhere - /// @brief Determine if a ParameterAttributes is set somewhere - bool hasAttrSomewhere(ParameterAttributes attr) const; - - /// The set of ParameterAttributes set in Attributes is converted to a - /// string of equivalent mnemonics. This is, presumably, for writing out - /// the mnemonics for the assembly writer. - /// @brief Convert parameter attribute bits to text - static std::string getParamAttrsText(ParameterAttributes Attributes); - - /// The \p Indexth parameter attribute is converted to string. - /// @brief Get the text for the parmeter attributes for one parameter. - std::string getParamAttrsTextByIndex(uint16_t Index) const { - return getParamAttrsText(getParamAttrs(Index)); - } - - /// @brief Comparison operator for ParamAttrsList - bool operator < (const ParamAttrsList& that) const { - if (this->attrs.size() < that.attrs.size()) - return true; - if (this->attrs.size() > that.attrs.size()) - return false; - for (unsigned i = 0; i < attrs.size(); ++i) { - if (attrs[i].index < that.attrs[i].index) - return true; - if (attrs[i].index > that.attrs[i].index) - return false; - if (attrs[i].attrs < that.attrs[i].attrs) - return true; - if (attrs[i].attrs > that.attrs[i].attrs) - return false; - } - return false; - } - - /// Returns the parameter index of a particular parameter attribute in this - /// list of attributes. Note that the attr_index is an index into this - /// class's list of attributes, not the index of a parameter. The result - /// is the index of the parameter. Clients generally should not use this - /// method. It is used internally by LLVM. - /// @brief Get a parameter index - uint16_t getParamIndex(unsigned attr_index) const { - return attrs[attr_index].index; - } - - ParameterAttributes getParamAttrsAtIndex(unsigned attr_index) const { - return attrs[attr_index].attrs; - } - - /// Determines how many parameter attributes are set in this ParamAttrsList. - /// This says nothing about how many parameters the function has. It also - /// says nothing about the highest parameter index that has attributes. - /// Clients generally should not use this method. It is used internally by - /// LLVM. - /// @returns the number of parameter attributes in this ParamAttrsList. - /// @brief Return the number of parameter attributes this type has. - unsigned size() const { return attrs.size(); } - - /// @brief Return the number of references to this ParamAttrsList. - unsigned numRefs() const { return refCount; } - - /// @} - /// @name Mutators - /// @{ - public: - /// Classes retaining references to ParamAttrsList objects should call this - /// method to increment the reference count. This ensures that the - /// ParamAttrsList object will not disappear until the class drops it. - /// @brief Add a reference to this instance. - void addRef() const { refCount++; } - - /// Classes retaining references to ParamAttrsList objects should call this - /// method to decrement the reference count and possibly delete the - /// ParamAttrsList object. This ensures that ParamAttrsList objects are - /// cleaned up only when the last reference to them is dropped. - /// @brief Drop a reference to this instance. - void dropRef() const { - assert(refCount != 0 && "dropRef without addRef"); - if (--refCount == 0) - delete this; - } - - /// @} - /// @name Implementation Details - /// @{ - public: - void Profile(FoldingSetNodeID &ID) const { - Profile(ID, attrs); - } - static void Profile(FoldingSetNodeID &ID, const ParamAttrsVector &Attrs); - void dump() const; - - /// @} - /// @name Data - /// @{ - private: - ParamAttrsVector attrs; ///< The list of attributes - mutable unsigned refCount; ///< The number of references to this object - /// @} -}; - -} // End llvm namespace - -#endif diff --git a/include/llvm/ParameterAttributes.h b/include/llvm/ParameterAttributes.h index 3de5f0537a..4a68a7d7b6 100644 --- a/include/llvm/ParameterAttributes.h +++ b/include/llvm/ParameterAttributes.h @@ -15,12 +15,14 @@ #ifndef LLVM_PARAMETER_ATTRIBUTES_H #define LLVM_PARAMETER_ATTRIBUTES_H -#include "llvm/Support/DataTypes.h" -#include <cassert> +#include <string> namespace llvm { class Type; +/// ParameterAttributes - A bitset of attributes for a parameter. +typedef unsigned ParameterAttributes; + namespace ParamAttr { /// Function parameters and results can have attributes to indicate how they @@ -28,9 +30,7 @@ namespace ParamAttr { /// lists the attributes that can be associated with parameters or function /// results. /// @brief Function parameter attributes. - -/// @brief A more friendly way to reference the attributes. -typedef uint32_t Attributes; +typedef ParameterAttributes Attributes; const Attributes None = 0; ///< No attributes have been set const Attributes ZExt = 1<<0; ///< Zero extended before/after call @@ -64,33 +64,141 @@ const Attributes MutuallyIncompatible[3] = { }; /// @brief Which attributes cannot be applied to a type. -Attributes typeIncompatible (const Type *Ty); +Attributes typeIncompatible(const Type *Ty); /// This turns an int alignment (a power of 2, normally) into the /// form used internally in ParameterAttributes. -ParamAttr::Attributes inline constructAlignmentFromInt(uint32_t i) { +ParamAttr::Attributes inline constructAlignmentFromInt(unsigned i) { return (i << 16); } +/// The set of ParameterAttributes set in Attributes is converted to a +/// string of equivalent mnemonics. This is, presumably, for writing out +/// the mnemonics for the assembly writer. +/// @brief Convert parameter attribute bits to text +std::string getAsString(ParameterAttributes Attrs); } // end namespace ParamAttr -/// @brief A more friendly way to reference the attributes. -typedef ParamAttr::Attributes ParameterAttributes; /// This is just a pair of values to associate a set of parameter attributes /// with a parameter index. -/// @brief ParameterAttributes with a parameter index. struct ParamAttrsWithIndex { - ParameterAttributes attrs; ///< The attributes that are set, or'd together - uint16_t index; ///< Index of the parameter for which the attributes apply + ParameterAttributes Attrs; ///< The attributes that are set, or'd together. + unsigned Index; ///< Index of the parameter for which the attributes apply. - static ParamAttrsWithIndex get(uint16_t idx, ParameterAttributes attrs) { + static ParamAttrsWithIndex get(unsigned Idx, ParameterAttributes Attrs) { ParamAttrsWithIndex P; - P.index = idx; - P.attrs = attrs; + P.Index = Idx; + P.Attrs = Attrs; return P; } }; + +//===----------------------------------------------------------------------===// +// PAListPtr Smart Pointer +//===----------------------------------------------------------------------===// + +class ParamAttributeListImpl; + +/// PAListPtr - This class manages the ref count for the opaque +/// ParamAttributeListImpl object and provides accessors for it. +class PAListPtr { + /// PAList - The parameter attributes that we are managing. This can be null + /// to represent the empty parameter attributes list. + ParamAttributeListImpl *PAList; +public: + PAListPtr() : PAList(0) {} + PAListPtr(const PAListPtr &P); + const PAListPtr &operator=(const PAListPtr &RHS); + ~PAListPtr(); + + //===--------------------------------------------------------------------===// + // Parameter Attribute List Construction and Mutation + //===--------------------------------------------------------------------===// + + /// get - Return a ParamAttrs list with the specified parameter in it. + static PAListPtr get(const ParamAttrsWithIndex *Attr, unsigned NumAttrs); + + /// get - Return a ParamAttr list with the parameters specified by the + /// consequtive random access iterator range. + template <typename Iter> + static PAListPtr get(const Iter &I, const Iter &E) { + if (I == E) return PAListPtr(); // Empty list. + return get(&*I, E-I); + } + + /// addAttr - Add the specified attribute at the specified index to this + /// attribute list. Since parameter attribute lists are immutable, this + /// returns the new list. + PAListPtr addAttr(unsigned Idx, ParameterAttributes Attrs) const; + + /// removeAttr - Remove the specified attribute at the specified index from + /// this attribute list. Since parameter attribute lists are immutable, this + /// returns the new list. + PAListPtr removeAttr(unsigned Idx, ParameterAttributes Attrs) const; + + //===--------------------------------------------------------------------===// + // Parameter Attribute List Accessors + //===--------------------------------------------------------------------===// + + /// getParamAttrs - The parameter attributes for the specified parameter are + /// returned. Parameters for the result are denoted with Idx = 0. + ParameterAttributes getParamAttrs(unsigned Idx) const; + + /// paramHasAttr - Return true if the specified parameter index has the + /// specified attribute set. + bool paramHasAttr(unsigned Idx, ParameterAttributes Attr) const { + return getParamAttrs(Idx) & Attr; + } + + /// getParamAlignment - Return the alignment for the specified function + /// parameter. + unsigned getParamAlignment(unsigned Idx) const { + return (getParamAttrs(Idx) & ParamAttr::Alignment) >> 16; + } + + /// hasAttrSomewhere - Return true if the specified attribute is set for at + /// least one parameter or for the return value. + bool hasAttrSomewhere(ParameterAttributes Attr) const; + + /// operator< - Provide an ordering for parameter attribute lists. + bool operator==(const PAListPtr &RHS) const { return PAList == RHS.PAList; } + bool operator!=(const PAListPtr &RHS) const { return PAList != RHS.PAList; } + + void dump() const; + + //===--------------------------------------------------------------------===// + // Parameter Attribute List Introspection + //===--------------------------------------------------------------------===// + + /// getRawPointer - Return a raw pointer that uniquely identifies this + /// parameter attribute list. + void *getRawPointer() const { + return PAList; + } + + // Parameter attributes are stored as a dense set of slots, where there is one + // slot for each argument that has an attribute. This allows walking over the + // dense set instead of walking the sparse list of attributes. + + /// isEmpty - Return true if no parameters have an attribute. + /// + bool isEmpty() const { + return PAList == 0; + } + + /// getNumSlots - Return the number of slots used in this attribute list. + /// This is the number of arguments that have an attribute set on them + /// (including the function itself). + unsigned getNumSlots() const; + + /// getSlot - Return the ParamAttrsWithIndex at the specified slot. This + /// holds a parameter number plus a set of attributes. + const ParamAttrsWithIndex &getSlot(unsigned Slot) const; + +private: + explicit PAListPtr(ParamAttributeListImpl *L); +}; } // End llvm namespace diff --git a/include/llvm/Support/CallSite.h b/include/llvm/Support/CallSite.h index 3bd4ef256c..6a6bcf185b 100644 --- a/include/llvm/Support/CallSite.h +++ b/include/llvm/Support/CallSite.h @@ -28,7 +28,6 @@ namespace llvm { class CallInst; class InvokeInst; -class ParamAttrsList; class CallSite { Instruction *I; @@ -62,8 +61,8 @@ public: /// getParamAttrs/setParamAttrs - get or set the parameter attributes of /// the call. - const ParamAttrsList *getParamAttrs() const; - void setParamAttrs(const ParamAttrsList *PAL); + const PAListPtr &getParamAttrs() const; + void setParamAttrs(const PAListPtr &PAL); /// paramHasAttr - whether the call or the callee has the given attribute. bool paramHasAttr(uint16_t i, ParameterAttributes attr) const; diff --git a/lib/AsmParser/llvmAsmParser.cpp.cvs b/lib/AsmParser/llvmAsmParser.cpp.cvs index c0de61723e..56c36db13d 100644 --- a/lib/AsmParser/llvmAsmParser.cpp.cvs +++ b/lib/AsmParser/llvmAsmParser.cpp.cvs @@ -380,7 +380,7 @@ /* Copy the first part of user declarations. */ -#line 14 "/home/nicholas/llvm-commit/lib/AsmParser/llvmAsmParser.y" +#line 14 "/Users/sabre/llvm/lib/AsmParser/llvmAsmParser.y" #include "ParserInternals.h" #include "llvm/CallingConv.h" @@ -395,7 +395,6 @@ #include "llvm/ADT/STLExtras.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/Streams.h" -#include "llvm/ParamAttrsList.h" #include <algorithm> #include <list> #include <map> @@ -1338,7 +1337,7 @@ Module *llvm::RunVMAsmParser(llvm::MemoryBuffer *MB) { #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE -#line 951 "/home/nicholas/llvm-commit/lib/AsmParser/llvmAsmParser.y" +#line 950 "/Users/sabre/llvm/lib/AsmParser/llvmAsmParser.y" { llvm::Module *ModuleVal; llvm::Function *FunctionVal; @@ -1385,8 +1384,8 @@ typedef union YYSTYPE llvm::ICmpInst::Predicate IPredicate; llvm::FCmpInst::Predicate FPredicate; } -/* Line 187 of yacc.c. */ -#line 1390 "llvmAsmParser.tab.c" +/* Line 193 of yacc.c. */ +#line 1389 "llvmAsmParser.tab.c" YYSTYPE; # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 @@ -1399,7 +1398,7 @@ typedef union YYSTYPE /* Line 216 of yacc.c. */ -#line 1403 "llvmAsmParser.tab.c" +#line 1402 "llvmAsmParser.tab.c" #ifdef short # undef short @@ -1449,7 +1448,7 @@ typedef short int yytype_int16; #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) #ifndef YY_ -# if YYENABLE_NLS +# if defined YYENABLE_NLS && YYENABLE_NLS # if ENABLE_NLS # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ # define YY_(msgid) dgettext ("bison-runtime", msgid) @@ -1829,39 +1828,39 @@ static const yytype_int16 yyrhs[] = /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 1113, 1113, 1113, 1113, 1113, 1113, 1113, 1113, 1113, - 1113, 1114, 1114, 1114, 1114, 1114, 1114, 1115, 1115, 1115, - 1115, 1115, 1115, 1116, 1116, 1116, 1116, 1116, 1116, 1119, - 1119, 1120, 1120, 1121, 1121, 1122, 1122, 1123, 1123, 1127, - 1127, 1128, 1128, 1129, 1129, 1130, 1130, 1131, 1131, 1132, - 1132, 1133, 1133, 1134, 1135, 1140, 1141, 1141, 1141, 1141, - 1141, 1143, 1143, 1143, 1144, 1144, 1146, 1147, 1151, 1155, - 1160, 1160, 1162, 1163, 1168, 1174, 1175, 1176, 1177, 1178, - 1182, 1183, 1184, 1188, 1189, 1190, 1191, 1195, 1196, 1197, - 1201, 1202, 1203, 1204, 1205, 1209, 1210, 1211, 1214, 1215, - 1216, 1217, 1218, 1219, 1220, 1227, 1228, 1229, 1230, 1231, - 1232, 1233, 1234, 1235, 1236, 1240, 1241, 1246, 1247, 1248, - 1249, 1250, 1251, 1254, 1255, 1260, 1261, 1268, 1269, 1275, - 1276, 1285, 1293, 1294, 1299, 1300, 1301, 1306, 1319, 1319, - 1319, 1319, 1319, 1319, 1319, 1322, 1326, 1330, 1337, 1342, - 1350, 1380, 1405, 1410, 1420, 1430, 1434, 1444, 1451, 1460, - 1467, 1472, 1477, 1484, 1485, 1492, 1499, 1507, 1513, 1525, - 1553, 1569, 1596, 1624, 1650, 1670, 1696, 1716, 1728, 1735, - 1801, 1811, 1821, 1827, 1837, 1843, 1853, 1858, 1863, 1876, - 1888, 1910, 1918, 1924, 1935, 1940, 1945, 1951, 1957, 1966, - 1970, 1978, 1978, 1981, 1981, 1984, 1996, 2017, 2022, 2030, - 2031, 2035, 2035, 2039, 2039, 2042, 2045, 2069, 2081, 2080, - 2092, 2091, 2101, 2100, 2111, 2151, 2154, 2160, 2170, 2174, - 2179, 2181, 2186, 2191, 2200, 2210, 2221, 2225, 2234, 2243, - 2248, 2382, 2382, 2384, 2393, 2393, 2395, 2400, 2412, 2416, - 2421, 2425, 2429, 2433, 2437, 2441, 2445, 2449, 2453, 2478, - 2482, 2492, 2496, 2500, 2505, 2512, 2512, 2518, 2527, 2532, - 2537, 2541, 2550, 2559, 2568, 2572, 2576, 2581, 2588, 2595, - 2599, 2604, 2614, 2633, 2642, 2733, 2737, 2744, 2755, 2768, - 2778, 2789, 2799, 2810, 2818, 2828, 2835, 2838, 2839, 2846, - 2850, 2855, 2871, 2888, 2902, 2916, 2928, 2936, 2943, 2949, - 2955, 2961, 2976, 3074, 3079, 3083, 3090, 3097, 3105, 3112, - 3120, 3128, 3142, 3159, 3167 + 0, 1112, 1112, 1112, 1112, 1112, 1112, 1112, 1112, 1112, + 1112, 1113, 1113, 1113, 1113, 1113, 1113, 1114, 1114, 1114, + 1114, 1114, 1114, 1115, 1115, 1115, 1115, 1115, 1115, 1118, + 1118, 1119, 1119, 1120, 1120, 1121, 1121, 1122, 1122, 1126, + 1126, 1127, 1127, 1128, 1128, 1129, 1129, 1130, 1130, 1131, |