llvm.org GIT mirror llvm / 832254e
Changes to support making the shift instructions be true BinaryOperators. This feature is needed in order to support shifts of more than 255 bits on large integer types. This changes the syntax for llvm assembly to make shl, ashr and lshr instructions look like a binary operator: shl i32 %X, 1 instead of shl i32 %X, i8 1 Additionally, this should help a few passes perform additional optimizations. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33776 91177308-0d34-0410-b5e6-96231b3b80d8 Reid Spencer 12 years ago
72 changed file(s) with 8176 addition(s) and 7547 deletion(s). Raw diff Collapse all Expand all
441441 Constant *C1, Constant *C2);
442442 static Constant *getCompareTy(unsigned short pred, Constant *C1,
443443 Constant *C2);
444 static Constant *getShiftTy(const Type *Ty,
445 unsigned Opcode, Constant *C1, Constant *C2);
446444 static Constant *getSelectTy(const Type *Ty,
447445 Constant *C1, Constant *C2, Constant *C3);
448446 static Constant *getGetElementPtrTy(const Type *Ty, Constant *C,
113113 HANDLE_BINARY_INST(14, SRem , BinaryOperator)
114114 HANDLE_BINARY_INST(15, FRem , BinaryOperator)
115115
116 // Logical operators...
117 HANDLE_BINARY_INST(16, And , BinaryOperator)
118 HANDLE_BINARY_INST(17, Or , BinaryOperator)
119 HANDLE_BINARY_INST(18, Xor , BinaryOperator)
120 LAST_BINARY_INST(18)
116 // Logical operators (integer operands)
117 HANDLE_BINARY_INST(16, Shl , BinaryOperator) // Shift left (logical)
118 HANDLE_BINARY_INST(17, LShr , BinaryOperator) // Shift right (logical)
119 HANDLE_BINARY_INST(18, AShr , BinaryOperator) // shift right (arithmetic)
120 HANDLE_BINARY_INST(19, And , BinaryOperator)
121 HANDLE_BINARY_INST(20, Or , BinaryOperator)
122 HANDLE_BINARY_INST(21, Xor , BinaryOperator)
123 LAST_BINARY_INST(21)
121124
122125 // Memory operators...
123 FIRST_MEMORY_INST(19)
124 HANDLE_MEMORY_INST(19, Malloc, MallocInst) // Heap management instructions
125 HANDLE_MEMORY_INST(20, Free , FreeInst )
126 HANDLE_MEMORY_INST(21, Alloca, AllocaInst) // Stack management
127 HANDLE_MEMORY_INST(22, Load , LoadInst ) // Memory manipulation instrs
128 HANDLE_MEMORY_INST(23, Store , StoreInst )
129 HANDLE_MEMORY_INST(24, GetElementPtr, GetElementPtrInst)
130 LAST_MEMORY_INST(24)
126 FIRST_MEMORY_INST(22)
127 HANDLE_MEMORY_INST(22, Malloc, MallocInst) // Heap management instructions
128 HANDLE_MEMORY_INST(23, Free , FreeInst )
129 HANDLE_MEMORY_INST(24, Alloca, AllocaInst) // Stack management
130 HANDLE_MEMORY_INST(25, Load , LoadInst ) // Memory manipulation instrs
131 HANDLE_MEMORY_INST(26, Store , StoreInst )
132 HANDLE_MEMORY_INST(27, GetElementPtr, GetElementPtrInst)
133 LAST_MEMORY_INST(27)
131134
132135 // Cast operators ...
133136 // NOTE: The order matters here because CastInst::isEliminableCastPair
134137 // NOTE: (see Instructions.cpp) encodes a table based on this ordering.
135 FIRST_CAST_INST(25)
136 HANDLE_CAST_INST(25, Trunc , TruncInst ) // Truncate integers
137 HANDLE_CAST_INST(26, ZExt , ZExtInst ) // Zero extend integers
138 HANDLE_CAST_INST(27, SExt , SExtInst ) // Sign extend integers
139 HANDLE_CAST_INST(28, FPToUI , FPToUIInst ) // floating point -> UInt
140 HANDLE_CAST_INST(29, FPToSI , FPToSIInst ) // floating point -> SInt
141 HANDLE_CAST_INST(30, UIToFP , UIToFPInst ) // UInt -> floating point
142 HANDLE_CAST_INST(31, SIToFP , SIToFPInst ) // SInt -> floating point
143 HANDLE_CAST_INST(32, FPTrunc , FPTruncInst ) // Truncate floating point
144 HANDLE_CAST_INST(33, FPExt , FPExtInst ) // Extend floating point
145 HANDLE_CAST_INST(34, PtrToInt, PtrToIntInst) // Pointer -> Integer
146 HANDLE_CAST_INST(35, IntToPtr, IntToPtrInst) // Integer -> Pointer
147 HANDLE_CAST_INST(36, BitCast , BitCastInst ) // Type cast
148 LAST_CAST_INST(36)
138 FIRST_CAST_INST(28)
139 HANDLE_CAST_INST(28, Trunc , TruncInst ) // Truncate integers
140 HANDLE_CAST_INST(29, ZExt , ZExtInst ) // Zero extend integers
141 HANDLE_CAST_INST(30, SExt , SExtInst ) // Sign extend integers
142 HANDLE_CAST_INST(31, FPToUI , FPToUIInst ) // floating point -> UInt
143 HANDLE_CAST_INST(32, FPToSI , FPToSIInst ) // floating point -> SInt
144 HANDLE_CAST_INST(33, UIToFP , UIToFPInst ) // UInt -> floating point
145 HANDLE_CAST_INST(34, SIToFP , SIToFPInst ) // SInt -> floating point
146 HANDLE_CAST_INST(35, FPTrunc , FPTruncInst ) // Truncate floating point
147 HANDLE_CAST_INST(36, FPExt , FPExtInst ) // Extend floating point
148 HANDLE_CAST_INST(37, PtrToInt, PtrToIntInst) // Pointer -> Integer
149 HANDLE_CAST_INST(38, IntToPtr, IntToPtrInst) // Integer -> Pointer
150 HANDLE_CAST_INST(39, BitCast , BitCastInst ) // Type cast
151 LAST_CAST_INST(39)
149152
150153 // Other operators...
151 FIRST_OTHER_INST(37)
152 HANDLE_OTHER_INST(37, ICmp , ICmpInst ) // Integer comparison instruction
153 HANDLE_OTHER_INST(38, FCmp , FCmpInst ) // Floating point comparison instr.
154 HANDLE_OTHER_INST(39, PHI , PHINode ) // PHI node instruction
155 HANDLE_OTHER_INST(40, Call , CallInst ) // Call a function
156 HANDLE_OTHER_INST(41, Shl , ShiftInst ) // Shift Left operations (logical)
157 HANDLE_OTHER_INST(42, LShr , ShiftInst ) // Logical Shift right (unsigned)
158 HANDLE_OTHER_INST(43, AShr , ShiftInst ) // Arithmetic shift right (signed)
154 FIRST_OTHER_INST(40)
155 HANDLE_OTHER_INST(40, ICmp , ICmpInst ) // Integer comparison instruction
156 HANDLE_OTHER_INST(41, FCmp , FCmpInst ) // Floating point comparison instr.
157 HANDLE_OTHER_INST(42, PHI , PHINode ) // PHI node instruction
158 HANDLE_OTHER_INST(43, Call , CallInst ) // Call a function
159159 HANDLE_OTHER_INST(44, Select , SelectInst ) // select instruction
160160 HANDLE_OTHER_INST(45, UserOp1, Instruction) // May be used internally in a pass
161161 HANDLE_OTHER_INST(46, UserOp2, Instruction) // Internal to passes only
128128 return getOpcode() >= BinaryOpsBegin && getOpcode() < BinaryOpsEnd;
129129 }
130130
131 /// @brief Determine if the Opcode is one of the shift instructions.
132 static inline bool isShift(unsigned Opcode) {
133 return Opcode >= Shl && Opcode <= AShr;
134 }
135
136 /// @brief Determine if the instruction's opcode is one of the shift
137 /// instructions.
138 inline bool isShift() { return isShift(getOpcode()); }
139
140 /// isLogicalShift - Return true if this is a logical shift left or a logical
141 /// shift right.
142 inline bool isLogicalShift() {
143 return getOpcode() == Shl || getOpcode() == LShr;
144 }
145
146 /// isLogicalShift - Return true if this is a logical shift left or a logical
147 /// shift right.
148 inline bool isArithmeticShift() {
149 return getOpcode() == AShr;
150 }
151
131152 /// @brief Determine if the OpCode is one of the CastInst instructions.
132153 static inline bool isCast(unsigned OpCode) {
133154 return OpCode >= CastOpsBegin && OpCode < CastOpsEnd;
759759 }
760760 };
761761
762
763 //===----------------------------------------------------------------------===//
764 // ShiftInst Class
765 //===----------------------------------------------------------------------===//
766
767 /// ShiftInst - This class represents left and right shift instructions.
768 ///
769 class ShiftInst : public Instruction {
770 Use Ops[2];
771 ShiftInst(const ShiftInst &SI)
772 : Instruction(SI.getType(), SI.getOpcode(), Ops, 2) {
773 Ops[0].init(SI.Ops[0], this);
774 Ops[1].init(SI.Ops[1], this);
775 }
776 void init(OtherOps Opcode, Value *S, Value *SA) {
777 assert((Opcode == Shl || Opcode == LShr || Opcode == AShr) &&
778 "ShiftInst Opcode invalid!");
779 Ops[0].init(S, this);
780 Ops[1].init(SA, this);
781 }
782
783 public:
784 ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name = "",
785 Instruction *InsertBefore = 0)
786 : Instruction(S->getType(), Opcode, Ops, 2, Name, InsertBefore) {
787 init(Opcode, S, SA);
788 }
789 ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name,
790 BasicBlock *InsertAtEnd)
791 : Instruction(S->getType(), Opcode, Ops, 2, Name, InsertAtEnd) {
792 init(Opcode, S, SA);
793 }
794
795 OtherOps getOpcode() const {
796 return static_cast(Instruction::getOpcode());
797 }
798
799 /// Transparently provide more efficient getOperand methods.
800 Value *getOperand(unsigned i) const {
801 assert(i < 2 && "getOperand() out of range!");
802 return Ops[i];
803 }
804 void setOperand(unsigned i, Value *Val) {
805 assert(i < 2 && "setOperand() out of range!");
806 Ops[i] = Val;
807 }
808 unsigned getNumOperands() const { return 2; }
809
810 /// isLogicalShift - Return true if this is a logical shift left or a logical
811 /// shift right.
812 bool isLogicalShift() const {
813 unsigned opcode = getOpcode();
814 return opcode == Instruction::Shl || opcode == Instruction::LShr;
815 }
816
817
818 /// isArithmeticShift - Return true if this is a sign-extending shift right
819 /// operation.
820 bool isArithmeticShift() const {
821 return !isLogicalShift();
822 }
823
824
825 virtual ShiftInst *clone() const;
826
827 // Methods for support type inquiry through isa, cast, and dyn_cast:
828 static inline bool classof(const ShiftInst *) { return true; }
829 static inline bool classof(const Instruction *I) {
830 return (I->getOpcode() == Instruction::LShr) |
831 (I->getOpcode() == Instruction::AShr) |
832 (I->getOpcode() == Instruction::Shl);
833 }
834 static inline bool classof(const Value *V) {
835 return isa(V) && classof(cast(V));
836 }
837 };
838
839762 //===----------------------------------------------------------------------===//
840763 // SelectInst Class
841764 //===----------------------------------------------------------------------===//
189189 RetTy visitBitCastInst(BitCastInst &I) { DELEGATE(CastInst); }
190190 RetTy visitSelectInst(SelectInst &I) { DELEGATE(Instruction); }
191191 RetTy visitCallInst(CallInst &I) { DELEGATE(Instruction); }
192 RetTy visitShiftInst(ShiftInst &I) { DELEGATE(Instruction); }
193192 RetTy visitVAArgInst(VAArgInst &I) { DELEGATE(Instruction); }
194193 RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);}
195194 RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction); }
165165 }
166166
167167 template
168 inline BinaryOp_match
169 ShiftInst> m_Shl(const LHS &L, const RHS &R) {
170 return BinaryOp_match(L, R);
171 }
172
173 template
174 inline BinaryOp_match
175 ShiftInst> m_LShr(const LHS &L, const RHS &R) {
176 return BinaryOp_match(L, R);
177 }
178
179 template
180 inline BinaryOp_match
181 ShiftInst> m_AShr(const LHS &L, const RHS &R) {
182 return BinaryOp_match(L, R);
168 inline BinaryOp_match m_Shl(const LHS &L,
169 const RHS &R) {
170 return BinaryOp_match(L, R);
171 }
172
173 template
174 inline BinaryOp_match m_LShr(const LHS &L,
175 const RHS &R) {
176 return BinaryOp_match(L, R);
177 }
178
179 template
180 inline BinaryOp_match m_AShr(const LHS &L,
181 const RHS &R) {
182 return BinaryOp_match(L, R);
183183 }
184184
185185 //===----------------------------------------------------------------------===//
186186 // Matchers for either AShr or LShr .. for convenience
187187 //
188 templateShiftInst>
188 templateBinaryOperator>
189189 struct Shr_match {
190190 LHS_t L;
191191 RHS_t R;
247247 };
248248
249249 template
250 inline BinaryOpClass_match
251 m_Shift(Instruction::OtherOps &Op, const LHS &L, const RHS &R) {
250 inline BinaryOpClass_match
251 m_Shift(Instruction::BinaryOps &Op, const LHS &L, const RHS &R) {
252252 return BinaryOpClass_match
253 ShiftInst, Instruction::OtherOps>(Op, L, R);
254 }
255
256 template
257 inline BinaryOpClass_match
253 BinaryOperator, Instruction::BinaryOps>(Op, L, R);
254 }
255
256 template
257 inline BinaryOpClass_match
258258 m_Shift(const LHS &L, const RHS &R) {
259 Instruction::OtherOps Op;
259 Instruction::BinaryOps Op;
260260 return BinaryOpClass_match
261 ShiftInst, Instruction::OtherOps>(Op, L, R);
261 BinaryOperator, Instruction::BinaryOps>(Op, L, R);
262262 }
263263
264264 //===----------------------------------------------------------------------===//
215215 case Instruction::FCmp:
216216 return ConstantExpr::getCompare(cast(I)->getPredicate(), Ops[0],
217217 Ops[1]);
218 case Instruction::Shl:
219 case Instruction::LShr:
220 case Instruction::AShr:
221 return ConstantExpr::get(Opc, Ops[0], Ops[1]);
222218 case Instruction::Trunc:
223219 case Instruction::ZExt:
224220 case Instruction::SExt:
775775 case Instruction::Unwind:
776776 case Instruction::Unreachable:
777777 case Instruction::Free:
778 case Instruction::Shl:
779 case Instruction::LShr:
780 case Instruction::AShr:
781778 case Instruction::ICmp:
782779 case Instruction::FCmp:
783780 return;
17351735 /// CanConstantFold - Return true if we can constant fold an instruction of the
17361736 /// specified type, assuming that all operands were constants.
17371737 static bool CanConstantFold(const Instruction *I) {
1738 if (isa(I) || isa<ShiftInst>(I) || isa<CmpInst>(I) ||
1738 if (isa(I) || isa<CmpInst>(I) ||
17391739 isa(I) || isa(I) || isa(I))
17401740 return true;
17411741
None #line 2 "Lexer.cpp"
1
2 #line 4 "Lexer.cpp"
3
4 #define YY_INT_ALIGNED short int
5
6 /* A lexical scanner generated by flex */
0 #define yy_create_buffer llvmAsm_create_buffer
1 #define yy_delete_buffer llvmAsm_delete_buffer
2 #define yy_scan_buffer llvmAsm_scan_buffer
3 #define yy_scan_string llvmAsm_scan_string
4 #define yy_scan_bytes llvmAsm_scan_bytes
5 #define yy_flex_debug llvmAsm_flex_debug
6 #define yy_init_buffer llvmAsm_init_buffer
7 #define yy_flush_buffer llvmAsm_flush_buffer
8 #define yy_load_buffer_state llvmAsm_load_buffer_state
9 #define yy_switch_to_buffer llvmAsm_switch_to_buffer
10 #define yyin llvmAsmin
11 #define yyleng llvmAsmleng
12 #define yylex llvmAsmlex
13 #define yyout llvmAsmout
14 #define yyrestart llvmAsmrestart
15 #define yytext llvmAsmtext
16 #define yylineno llvmAsmlineno
17
18 #line 20 "Lexer.cpp"
19 /* A lexical scanner generated by flex*/
20
21 /* Scanner skeleton version:
22 * $Header$
23 */
724
825 #define FLEX_SCANNER
926 #define YY_FLEX_MAJOR_VERSION 2
1027 #define YY_FLEX_MINOR_VERSION 5
11 #define YY_FLEX_SUBMINOR_VERSION 33
12 #if YY_FLEX_SUBMINOR_VERSION > 0
13 #define FLEX_BETA
14 #endif
15
16 /* First, we deal with platform-specific or compiler-specific issues. */
17
18 /* begin standard C headers. */
28
1929 #include
20 #include
21 #include <errno.h>
30 #include <unistd.h>
31
32
33 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
34 #ifdef c_plusplus
35 #ifndef __cplusplus
36 #define __cplusplus
37 #endif
38 #endif
39
40
41 #ifdef __cplusplus
42
2243 #include
2344
24 /* end standard C headers. */
25
26 /* flex integer type definitions */
27
28 #ifndef FLEXINT_H
29 #define FLEXINT_H
30
31 /* C99 systems have . Non-C99 systems may or may not. */
32
33 #if __STDC_VERSION__ >= 199901L
34
35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
36 * if you want the limit (max/min) macros for int types.
37 */
38 #ifndef __STDC_LIMIT_MACROS
39 #define __STDC_LIMIT_MACROS 1
40 #endif
41
42 #include
43 typedef int8_t flex_int8_t;
44 typedef uint8_t flex_uint8_t;
45 typedef int16_t flex_int16_t;
46 typedef uint16_t flex_uint16_t;
47 typedef int32_t flex_int32_t;
48 typedef uint32_t flex_uint32_t;
49 #else
50 typedef signed char flex_int8_t;
51 typedef short int flex_int16_t;
52 typedef int flex_int32_t;
53 typedef unsigned char flex_uint8_t;
54 typedef unsigned short int flex_uint16_t;
55 typedef unsigned int flex_uint32_t;
56 #endif /* ! C99 */
57
58 /* Limits of integral types. */
59 #ifndef INT8_MIN
60 #define INT8_MIN (-128)
61 #endif
62 #ifndef INT16_MIN
63 #define INT16_MIN (-32767-1)
64 #endif
65 #ifndef INT32_MIN
66 #define INT32_MIN (-2147483647-1)
67 #endif
68 #ifndef INT8_MAX
69 #define INT8_MAX (127)
70 #endif
71 #ifndef INT16_MAX
72 #define INT16_MAX (32767)
73 #endif
74 #ifndef INT32_MAX
75 #define INT32_MAX (2147483647)
76 #endif
77 #ifndef UINT8_MAX
78 #define UINT8_MAX (255U)
79 #endif
80 #ifndef UINT16_MAX
81 #define UINT16_MAX (65535U)
82 #endif
83 #ifndef UINT32_MAX
84 #define UINT32_MAX (4294967295U)
85 #endif
86
87 #endif /* ! FLEXINT_H */
88
89 #ifdef __cplusplus
45 /* Use prototypes in function declarations. */
46 #define YY_USE_PROTOS
9047
9148 /* The "const" storage-class-modifier is valid. */
9249 #define YY_USE_CONST
9552
9653 #if __STDC__
9754
55 #define YY_USE_PROTOS
9856 #define YY_USE_CONST
9957
10058 #endif /* __STDC__ */
10159 #endif /* ! __cplusplus */
10260
61 #ifdef __TURBOC__
62 #pragma warn -rch
63 #pragma warn -use
64 #include
65 #include
66 #define YY_USE_CONST
67 #define YY_USE_PROTOS
68 #endif
69
10370 #ifdef YY_USE_CONST
10471 #define yyconst const
10572 #else
10673 #define yyconst
74 #endif
75
76
77 #ifdef YY_USE_PROTOS
78 #define YY_PROTO(proto) proto
79 #else
80 #define YY_PROTO(proto) ()
10781 #endif
10882
10983 /* Returned upon end-of-file. */
12094 * but we do it the disgusting crufty way forced on us by the ()-less
12195 * definition of BEGIN.
12296 */
123 #define BEGIN (yy_start) = 1 + 2 *
97 #define BEGIN yy_start = 1 + 2 *
12498
12599 /* Translate the current start state into a value that can be later handed
126100 * to BEGIN to return to the state. The YYSTATE alias is for lex
127101 * compatibility.
128102 */
129 #define YY_START (((yy_start) - 1) / 2)
103 #define YY_START ((yy_start - 1) / 2)
130104 #define YYSTATE YY_START
131105
132106 /* Action number for EOF rule of a given start state. */
133107 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
134108
135109 /* Special action meaning "start processing a new file". */
136 #define YY_NEW_FILE llvmAsmrestart(llvmAsmin )
110 #define YY_NEW_FILE yyrestart( yyin )
137111
138112 #define YY_END_OF_BUFFER_CHAR 0
139113
140114 /* Size of default input buffer. */
141 #ifndef YY_BUF_SIZE
142115 #define YY_BUF_SIZE (16384*64)
143 #endif
144
145 /* The state buf must be large enough to hold one state per character in the main buffer.
146 */
147 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
148
149 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
150 #define YY_TYPEDEF_YY_BUFFER_STATE
116
151117 typedef struct yy_buffer_state *YY_BUFFER_STATE;
152 #endif
153
154 extern int llvmAsmleng;
155
156 extern FILE *llvmAsmin, *llvmAsmout;
118
119 extern int yyleng;
120 extern FILE *yyin, *yyout;
157121
158122 #define EOB_ACT_CONTINUE_SCAN 0
159123 #define EOB_ACT_END_OF_FILE 1
160124 #define EOB_ACT_LAST_MATCH 2
161125
162 /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
163 * access to the local variable yy_act. Since yyless() is a macro, it would break
164 * existing scanners that call yyless() from OUTSIDE llvmAsmlex.
165 * One obvious solution it to make yy_act a global. I tried that, and saw
166 * a 5% performance hit in a non-llvmAsmlineno scanner, because yy_act is
167 * normally declared as a register variable-- so it is not worth it.
168 */
169 #define YY_LESS_LINENO(n) \
170 do { \
171 int yyl;\
172 for ( yyl = n; yyl < llvmAsmleng; ++yyl )\
173 if ( llvmAsmtext[yyl] == '\n' )\
174 --llvmAsmlineno;\
175 }while(0)
176
177 /* Return all but the first "n" matched characters back to the input stream. */
126 /* The funky do-while in the following #define is used to turn the definition
127 * int a single C statement (which needs a semi-colon terminator). This
128 * avoids problems with code like:
129 *
130 * if ( condition_holds )
131 * yyless( 5 );
132 * else
133 * do_something_else();
134 *
135 * Prior to using the do-while the compiler would get upset at the
136 * "else" because it interpreted the "if" statement as being all
137 * done when it reached the ';' after the yyless() call.
138 */
139
140 /* Return all but the first 'n' matched characters back to the input stream. */
141
178142 #define yyless(n) \
179143 do \
180144 { \
181 /* Undo effects of setting up llvmAsmtext. */ \
182 int yyless_macro_arg = (n); \
183 YY_LESS_LINENO(yyless_macro_arg);\
184 *yy_cp = (yy_hold_char); \
145 /* Undo effects of setting up yytext. */ \
146 *yy_cp = yy_hold_char; \
185147 YY_RESTORE_YY_MORE_OFFSET \
186 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
187 YY_DO_BEFORE_ACTION; /* set up llvmAsmtext again */ \
148 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
149 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
188150 } \
189151 while ( 0 )
190152
191 #define unput(c) yyunput( c, (yytext_ptr) )
153 #define unput(c) yyunput( c, yytext_ptr )
154
155 /* Some routines like yy_flex_realloc() are emitted as static but are
156 not called by all lexers. This generates warnings in some compilers,
157 notably GCC. Arrange to suppress these. */
158 #ifdef __GNUC__
159 #define YY_MAY_BE_UNUSED __attribute__((unused))
160 #else
161 #define YY_MAY_BE_UNUSED
162 #endif
192163
193164 /* The following is because we cannot portably get our hands on size_t
194165 * (without autoconf's help, which isn't available because we want
195166 * flex-generated scanners to compile on their own).
196167 */
197
198 #ifndef YY_TYPEDEF_YY_SIZE_T
199 #define YY_TYPEDEF_YY_SIZE_T
200168 typedef unsigned int yy_size_t;
201 #endif
202
203 #ifndef YY_STRUCT_YY_BUFFER_STATE
204 #define YY_STRUCT_YY_BUFFER_STATE
169
170
205171 struct yy_buffer_state
206172 {
207173 FILE *yy_input_file;
238204 */
239205 int yy_at_bol;
240206
241 int yy_bs_lineno; /**< The line count. */
242 int yy_bs_column; /**< The column count. */
243
244207 /* Whether to try to fill the input buffer when we reach the
245208 * end of it.
246209 */
247210 int yy_fill_buffer;
248211
249212 int yy_buffer_status;
250
251213 #define YY_BUFFER_NEW 0
252214 #define YY_BUFFER_NORMAL 1
253215 /* When an EOF's been seen but there's still some text to process
257219 * possible backing-up.
258220 *
259221 * When we actually see the EOF, we change the status to "new"
260 * (via llvmAsmrestart()), so that the user can continue scanning by
261 * just pointing llvmAsmin at a new input file.
222 * (via yyrestart()), so that the user can continue scanning by
223 * just pointing yyin at a new input file.
262224 */
263225 #define YY_BUFFER_EOF_PENDING 2
264
265226 };
266 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
267
268 /* Stack of input buffers. */
269 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
270 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
271 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
227
228 static YY_BUFFER_STATE yy_current_buffer = 0;
272229
273230 /* We provide macros for accessing buffer states in case in the
274231 * future we want to put the buffer states in a more general
275232 * "scanner state".
276 *
277 * Returns the top of the stack, or NULL.
278233 */
279 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
280 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
281 : NULL)
282
283 /* Same as previous macro, but useful when we know that the buffer stack is not
284 * NULL or when we need an lvalue. For internal use only.
285 */
286 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
287
288 /* yy_hold_char holds the character lost when llvmAsmtext is formed. */
234 #define YY_CURRENT_BUFFER yy_current_buffer
235
236
237 /* yy_hold_char holds the character lost when yytext is formed. */
289238 static char yy_hold_char;
239
290240 static int yy_n_chars; /* number of characters read into yy_ch_buf */
291 int llvmAsmleng;
241
242
243 int yyleng;
292244
293245 /* Points to current character in buffer. */
294246 static char *yy_c_buf_p = (char *) 0;
295 static int yy_init = 0; /* whether we need to initialize */
247 static int yy_init = 1; /* whether we need to initialize */
296248 static int yy_start = 0; /* start state number */
297249
298 /* Flag which is used to allow llvmAsmwrap()'s to do buffer switches
299 * instead of setting up a fresh llvmAsmin. A bit of a hack ...
250 /* Flag which is used to allow yywrap()'s to do buffer switches
251 * instead of setting up a fresh yyin. A bit of a hack ...
300252 */
301253 static int yy_did_buffer_switch_on_eof;
302254
303 void llvmAsmrestart (FILE *input_file );
304 void llvmAsm_switch_to_buffer (YY_BUFFER_STATE new_buffer );
305 YY_BUFFER_STATE llvmAsm_create_buffer (FILE *file,int size );
306 void llvmAsm_delete_buffer (YY_BUFFER_STATE b );
307 void llvmAsm_flush_buffer (YY_BUFFER_STATE b );
308 void llvmAsmpush_buffer_state (YY_BUFFER_STATE new_buffer );
309 void llvmAsmpop_buffer_state (void );
310
311 static void llvmAsmensure_buffer_stack (void );
312 static void llvmAsm_load_buffer_state (void );
313 static void llvmAsm_init_buffer (YY_BUFFER_STATE b,FILE *file );
314
315 #define YY_FLUSH_BUFFER llvmAsm_flush_buffer(YY_CURRENT_BUFFER )
316
317 YY_BUFFER_STATE llvmAsm_scan_buffer (char *base,yy_size_t size );
318 YY_BUFFER_STATE llvmAsm_scan_string (yyconst char *yy_str );
319 YY_BUFFER_STATE llvmAsm_scan_bytes (yyconst char *bytes,int len );
320
321 void *llvmAsmalloc (yy_size_t );
322 void *llvmAsmrealloc (void *,yy_size_t );
323 void llvmAsmfree (void * );
324
325 #define yy_new_buffer llvmAsm_create_buffer
255 void yyrestart YY_PROTO(( FILE *input_file ));
256
257 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
258 void yy_load_buffer_state YY_PROTO(( void ));
259 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
260 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
261 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
262 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
263 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
264
265 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
266 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
267 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
268
269 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
270 static inline void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) YY_MAY_BE_UNUSED;
271 static void yy_flex_free YY_PROTO(( void * ));
272
273 #define yy_new_buffer yy_create_buffer
326274
327275 #define yy_set_interactive(is_interactive) \
328276 { \
329 if ( ! YY_CURRENT_BUFFER ){ \
330 llvmAsmensure_buffer_stack (); \
331 YY_CURRENT_BUFFER_LVALUE = \
332 llvmAsm_create_buffer(llvmAsmin,YY_BUF_SIZE ); \
333 } \
334 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
277 if ( ! yy_current_buffer ) \
278 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
279 yy_current_buffer->yy_is_interactive = is_interactive; \
335280 }
336281
337282 #define yy_set_bol(at_bol) \
338283 { \
339 if ( ! YY_CURRENT_BUFFER ){\
340 llvmAsmensure_buffer_stack (); \
341 YY_CURRENT_BUFFER_LVALUE = \
342 llvmAsm_create_buffer(llvmAsmin,YY_BUF_SIZE ); \
343 } \
344 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
284 if ( ! yy_current_buffer ) \
285 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
286 yy_current_buffer->yy_at_bol = at_bol; \
345287 }
346288
347 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
348
349 /* Begin user sect3 */
350
351 #define llvmAsmwrap(n) 1
289 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
290
291
292 #define YY_USES_REJECT
293
294 #define yywrap() 1
352295 #define YY_SKIP_YYWRAP
353
354296 typedef unsigned char YY_CHAR;
355
356 FILE *llvmAsmin = (FILE *) 0, *llvmAsmout = (FILE *) 0;
357
297 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
358298 typedef int yy_state_type;
359
360 extern int llvmAsmlineno;
361
362 int llvmAsmlineno = 1;
363
364 extern char *llvmAsmtext;
365 #define yytext_ptr llvmAsmtext
366
367 static yy_state_type yy_get_previous_state (void );
368 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
369 static int yy_get_next_buffer (void );
370 static void yy_fatal_error (yyconst char msg[] );
299 extern int yylineno;
300 int yylineno = 1;
301 extern char *yytext;
302 #define yytext_ptr yytext
303
304 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
305 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
306 static int yy_get_next_buffer YY_PROTO(( void ));
307 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
371308
372309 /* Done after the current pattern has been matched and before the
373 * corresponding action - sets up llvmAsmtext.
310 * corresponding action - sets up yytext.
374311 */
375312 #define YY_DO_BEFORE_ACTION \
376 (yytext_ptr) = yy_bp; \
377 llvmAsmleng = (size_t) (yy_cp - yy_bp); \
378 (yy_hold_char) = *yy_cp; \
313 yytext_ptr = yy_bp; \
314 yyleng = (int) (yy_cp - yy_bp); \
315 yy_hold_char = *yy_cp; \
379316 *yy_cp = '\0'; \
380 (yy_c_buf_p) = yy_cp;
317 yy_c_buf_p = yy_cp;
381318
382319 #define YY_NUM_RULES 134
383320 #define YY_END_OF_BUFFER 135
384 /* This struct is not used in this scanner,
385 but its presence is necessary. */
386 struct yy_trans_info
387 {
388 flex_int32_t yy_verify;
389 flex_int32_t yy_nxt;
390 };
391 static yyconst flex_int16_t yy_accept[539] =
321 static yyconst short int yy_acclist[215] =
392322 { 0,
393 0, 0, 135, 133, 132, 132, 133, 133, 133, 133,
394 133, 133, 125, 125, 1, 133, 133, 133, 133, 133,
395 133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
396 133, 133, 133, 133, 133, 133, 133, 133, 0, 123,
397 0, 121, 119, 128, 0, 126, 0, 130, 125, 0,
398 1, 0, 120, 129, 0, 0, 0, 0, 0, 0,
399 0, 105, 0, 36, 0, 0, 0, 0, 0, 0,
400 63, 0, 0, 0, 0, 0, 0, 0, 0, 0,
401 0, 48, 0, 0, 0, 0, 0, 0, 0, 0,
402 0, 0, 64, 0, 0, 0, 0, 0, 0, 59,
403
404 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
405 0, 0, 0, 0, 0, 24, 0, 0, 0, 0,
406 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
407 0, 123, 119, 130, 21, 130, 0, 131, 0, 124,
408 120, 49, 0, 0, 58, 0, 0, 34, 0, 0,
409 0, 37, 0, 0, 0, 0, 0, 0, 0, 0,
410 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
411 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
412 0, 0, 0, 0, 0, 51, 0, 73, 78, 76,
413 77, 75, 74, 0, 79, 83, 0, 104, 0, 0,
414
415 0, 0, 0, 68, 66, 100, 0, 0, 0, 67,
416 65, 0, 0, 50, 0, 0, 0, 0, 0, 0,
417 0, 81, 72, 70, 0, 71, 69, 0, 82, 80,
418 0, 0, 0, 0, 0, 0, 0, 0, 60, 0,
419 0, 122, 130, 0, 0, 0, 130, 0, 0, 0,
420 102, 0, 0, 84, 0, 0, 0, 0, 0, 0,
421 0, 0, 0, 0, 0, 0, 0, 62, 54, 0,
422 0, 0, 0, 112, 57, 0, 0, 0, 61, 0,
423 0, 0, 0, 0, 0, 0, 0, 113, 101, 0,
424 0, 23, 0, 0, 127, 53, 0, 0, 87, 0,
425
426 0, 0, 56, 89, 0, 0, 25, 0, 0, 4,
427 0, 46, 52, 0, 0, 0, 0, 55, 0, 42,
428 0, 12, 0, 0, 86, 130, 31, 0, 0, 2,
429 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
430 0, 0, 5, 0, 43, 91, 0, 0, 0, 0,
431 0, 0, 0, 88, 0, 0, 0, 0, 45, 0,
432 0, 0, 0, 0, 0, 0, 0, 0, 0, 114,
433 0, 0, 0, 85, 0, 22, 0, 0, 0, 0,
434 0, 0, 0, 111, 0, 0, 39, 0, 0, 0,
435 7, 0, 0, 0, 44, 0, 0, 38, 95, 94,
436
437 0, 0, 8, 16, 0, 0, 0, 0, 107, 0,
438 110, 33, 47, 0, 0, 99, 0, 0, 93, 106,
439 26, 27, 92, 0, 108, 103, 0, 0, 0, 0,
440 0, 98, 0, 0, 6, 28, 0, 0, 0, 0,
441 0, 90, 0, 0, 0, 0, 0, 0, 0, 32,
442 0, 0, 0, 0, 0, 0, 0, 0, 9, 0,
443 0, 0, 0, 18, 0, 0, 0, 0, 10, 96,
444 11, 97, 0, 0, 0, 30, 0, 0, 0, 13,
445 0, 15, 14, 0, 0, 0, 0, 0, 0, 0,
446 0, 0, 0, 0, 29, 0, 0, 0, 0, 0,
447
448 0, 35, 0, 0, 0, 0, 17, 0, 0, 0,
449 0, 0, 109, 0, 0, 0, 0, 0, 0, 0,
450 0, 0, 0, 0, 0, 115, 0, 117, 118, 0,
451 40, 0, 116, 19, 41, 0, 20, 0
323 135, 133, 134, 132, 133, 134, 132, 134, 133, 134,
324 133, 134, 133, 134, 133, 134, 133, 134, 133, 134,
325 125, 133, 134, 125, 133, 134, 1, 133, 134, 133,
326 134, 133, 134, 133, 134, 133, 134, 133, 134, 133,
327 134, 133, 134, 133, 134, 133, 134, 133, 134, 133,
328 134, 133, 134, 133, 134, 133, 134, 133, 134, 133,
329 134, 133, 134, 133, 134, 133, 134, 133, 134, 133,
330 134, 133, 134, 133, 134, 123, 121, 119, 128, 126,
331 130, 125, 1, 120, 129, 105, 36, 68, 50, 69,
332 64, 24, 123, 119, 130, 21, 130, 131, 124, 120,
333
334 51, 63, 34, 37, 3, 53, 78, 83, 81, 82,
335 80, 79, 84, 88, 104, 73, 71, 60, 72, 70,
336 52, 86, 77, 75, 76, 74, 87, 85, 65, 122,
337 130, 130, 62, 89, 67, 56, 112, 59, 66, 113,
338 61, 23, 127, 55, 92, 58, 43, 25, 4, 48,
339 54, 57, 44, 12, 91, 130, 31, 2, 5, 45,
340 94, 42, 47, 114, 90, 22, 111, 39, 7, 46,
341 38, 98, 97, 8, 16, 107, 110, 33, 49, 102,
342 96, 106, 26, 27, 95, 108, 103, 101, 6, 28,
343 93, 32, 9, 18, 10, 99, 11, 100, 30, 13,
344
345 15, 14, 29, 35, 17, 109, 115, 117, 118, 40,
346 116, 19, 41, 20
452347 } ;
453348
454 static yyconst flex_int32_t yy_ec[256] =
349 static yyconst short int yy_accept[540] =
350 { 0,
351 1, 1, 1, 2, 4, 7, 9, 11, 13, 15,
352 17, 19, 21, 24, 27, 30, 32, 34, 36, 38,
353 40, 42, 44, 46, 48, 50, 52, 54, 56, 58,
354 60, 62, 64, 66, 68, 70, 72, 74, 76, 76,
355 77, 77, 78, 79, 80, 80, 81, 81, 82, 83,
356 83, 84, 84, 85, 86, 86, 86, 86, 86, 86,
357 86, 86, 87, 87, 88, 88, 88, 88, 88, 88,
358 88, 89, 89, 89, 89, 89, 89, 89, 89, 89,
359 89, 89, 90, 90, 90, 90, 90, 90, 90, 90,
360 90, 90, 90, 91, 91, 91, 91, 91, 91, 91,
361
362 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
363 92, 92, 92, 92, 92, 92, 93, 93, 93, 93,
364 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
365 93, 93, 94, 95, 96, 97, 98, 98, 99, 99,
366 100, 101, 102, 102, 102, 103, 103, 103, 104, 104,
367 104, 104, 105, 105, 105, 105, 105, 105, 105, 105,
368 105, 106, 106, 106, 106, 106, 106, 106, 106, 106,
369 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
370 106, 106, 106, 106, 106, 106, 107, 107, 108, 109,
371 110, 111, 112, 113, 113, 114, 115, 115, 116, 116,
372
373 116, 116, 116, 116, 117, 118, 119, 119, 119, 119,
374 120, 121, 121, 121, 122, 122, 122, 122, 122, 122,
375 122, 122, 123, 124, 125, 125, 126, 127, 127, 128,
376 129, 129, 129, 129, 129, 129, 129, 129, 129, 130,
377 130, 130, 131, 132, 132, 132, 132, 133, 133, 133,
378 133, 134, 134, 134, 135, 135, 135, 135, 135, 135,
379 135, 135, 135, 135, 135, 135, 135, 135, 136, 137,
380 137, 137, 137, 137, 138, 139, 139, 139, 139, 140,
381 140, 140, 140, 140, 140, 140, 140, 140, 141, 142,
382 142, 142, 143, 143, 143, 144, 145, 145, 145, 146,
383
384 146, 146, 146, 147, 148, 148, 148, 149, 149, 149,
385 150, 150, 151, 152, 152, 152, 152, 152, 153, 153,
386 154, 154, 155, 155, 155, 156, 157, 158, 158, 158,
387 159, 159, 159, 159, 159, 159, 159, 159, 159, 159,
388 159, 159, 159, 160, 160, 161, 162, 162, 162, 162,
389 162, 162, 162, 162, 163, 163, 163, 163, 163, 164,
390 164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
391 165, 165, 165, 165, 166, 166, 167, 167, 167, 167,
392 167, 167, 167, 167, 168, 168, 168, 169, 169, 169,
393 169, 170, 170, 170, 170, 171, 171, 171, 172, 173,
394
395 174, 174, 174, 175, 176, 176, 176, 176, 176, 177,
396 177, 178, 179, 180, 180, 180, 181, 181, 181, 182,
397 183, 184, 185, 186, 186, 187, 188, 188, 188, 188,
398 188, 188, 189, 189, 189, 190, 191, 191, 191, 191,
399 191, 191, 192, 192, 192, 192, 192, 192, 192, 192,
400 193, 193, 193, 193, 193, 193, 193, 193, 193, 194,
401 194, 194, 194, 194, 195, 195, 195, 195, 195, 196,
402 197, 198, 199, 199, 199, 199, 200, 200, 200, 200,
403 201, 201, 202, 203, 203, 203, 203, 203, 203, 203,
404 203, 203, 203, 203, 203, 204, 204, 204, 204, 204,
405
406 204, 204, 205, 205, 205, 205, 205, 206, 206, 206,
407 206, 206, 206, 207, 207, 207, 207, 207, 207, 207,
408 207, 207, 207, 207, 207, 207, 208, 208, 209, 210,
409 210, 211, 211, 212, 213, 214, 214, 215, 215
410 } ;
411
412 static yyconst int yy_ec[256] =
455413 { 0,
456414 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
457415 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
483441 1, 1, 1, 1, 1
484442 } ;
485443
486 static yyconst flex_int32_t yy_meta[45] =
444 static yyconst int yy_meta[45] =
487445 { 0,
488446 1, 1, 2, 3, 4, 1, 1, 4, 4, 4,
489447 4, 4, 4, 5, 1, 1, 4, 4, 4, 4,
492450 4, 4, 4, 4
493451 } ;
494452
495 static yyconst flex_int16_t yy_base[547] =
453 static yyconst short int yy_base[547] =
496454 { 0,
497455 0, 0, 1173, 1174, 1174, 1174, 1168, 1157, 35, 39,
498456 43, 49, 55, 61, 0, 72, 64, 67, 66, 86,
556514 254, 1054, 1057, 220, 1061, 167
557515 } ;
558516
559 static yyconst flex_int16_t yy_def[547] =
517 static yyconst short int yy_def[547] =
560518 { 0,
561519 538, 1, 538, 538, 538, 538, 539, 540, 541, 538,
562520 540, 540, 540, 540, 542, 543, 540, 540, 540, 540,
620578 538, 538, 538, 538, 538, 538
621579 } ;
622580
623 static yyconst flex_int16_t yy_nxt[1219] =
581 static yyconst short int yy_nxt[1219] =
624582 { 0,
625583 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
626584 14, 14, 14, 4, 15, 16, 8, 8, 8, 17,
758716 538, 538, 538, 538, 538, 538, 538, 538
759717 } ;
760718
761 static yyconst flex_int16_t yy_chk[1219] =
719 static yyconst short int yy_chk[1219] =
762720 { 0,
763721 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
764722 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
896854 538, 538, 538, 538, 538, 538, 538, 538
897855 } ;
898856
899 /* Table of booleans, true if rule could match eol. */
900 static yyconst flex_int32_t yy_rule_can_match_eol[135] =
901 { 0,
902 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
903 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
904 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
905 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
906 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
907 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
908 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, };
909
910 static yy_state_type yy_last_accepting_state;
911 static char *yy_last_accepting_cpos;
912
913 extern int llvmAsm_flex_debug;
914 int llvmAsm_flex_debug = 0;
915
916 /* The intent behind this definition is that it'll catch
917 * any uses of REJECT which flex missed.
918 */
919 #define REJECT reject_used_but_not_detected
857 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
858 static char *yy_full_match;
859 static int yy_lp;
860 #define REJECT \
861 { \
862 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
863 yy_cp = yy_full_match; /* restore poss. backed-over text */ \
864 ++yy_lp; \
865 goto find_rule; \
866 }
920867 #define yymore() yymore_used_but_not_detected
921868 #define YY_MORE_ADJ 0
922869 #define YY_RESTORE_YY_MORE_OFFSET
923 char *llvmAsmtext;
924 #line 1 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
870 char *yytext;
871 #line 1 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
872 #define INITIAL 0
925873 /*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===//
926874 //
927875 // The LLVM Compiler Infrastructure
934882 // This file implements the flex scanner for LLVM assembly languages files.
935883 //
936884 //===----------------------------------------------------------------------===*/
937 #line 28 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
885 #define YY_NEVER_INTERACTIVE 1
886 #line 28 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
938887 #include "ParserInternals.h"
939888 #include "llvm/Module.h"
940889 #include
943892 #include
944893
945894 void set_scan_file(FILE * F){
946 llvmAsm_switch_to_buffer(llvmAsm_create_buffer(F,YY_BUF_SIZE ) );
895 yy_switch_to_buffer(yy_create_buffer( F, YY_BUF_SIZE ) );
947896 }
948897 void set_scan_string (const char * str) {
949 llvmAsm_scan_string (str);
898 yy_scan_string (str);
950899 }
951900
952901 // Construct a token value for a non-obsolete token
10671016 /* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
10681017 * it to deal with 64 bit numbers.
10691018 */
1070 #line 1072 "Lexer.cpp"
1071
1072 #define INITIAL 0
1073
1074 #ifndef YY_NO_UNISTD_H
1075 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1076 * down here because we want the user's section 1 to have been scanned first.
1077 * The user has a chance to override it with an option.
1078 */
1079 #include
1080 #endif
1081
1082 #ifndef YY_EXTRA_TYPE
1083 #define YY_EXTRA_TYPE void *
1084 #endif
1085
1086 static int yy_init_globals (void );
1019 #line 1021 "Lexer.cpp"
10871020
10881021 /* Macros after this point can all be overridden by user definitions in
10891022 * section 1.
10911024
10921025 #ifndef YY_SKIP_YYWRAP
10931026 #ifdef __cplusplus
1094 extern "C" int llvmAsmwrap (void );
1095 #else
1096 extern int llvmAsmwrap (void );
1097 #endif
1098 #endif
1099
1100 static inline void yyunput (int c,char *buf_ptr );
1101
1027 extern "C" int yywrap YY_PROTO(( void ));
1028 #else
1029 extern int yywrap YY_PROTO(( void ));
1030 #endif
1031 #endif
1032
1033 #ifndef YY_NO_UNPUT
1034 static inline void yyunput YY_PROTO(( int c, char *buf_ptr ));
1035 #endif
1036
11021037 #ifndef yytext_ptr
1103 static void yy_flex_strncpy (char *,yyconst char *,int );
1038 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
11041039 #endif
11051040
11061041 #ifdef YY_NEED_STRLEN
1107 static int yy_flex_strlen (yyconst char * );
1042 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
11081043 #endif
11091044
11101045 #ifndef YY_NO_INPUT
1111
11121046 #ifdef __cplusplus
1113 static int yyinput (void );
1114 #else
1115 static int input (void );
1116 #endif
1117
1047 static int yyinput YY_PROTO(( void ));
1048 #else
1049 static int input YY_PROTO(( void ));
1050 #endif
1051 #endif
1052
1053 #if YY_STACK_USED
1054 static int yy_start_stack_ptr = 0;
1055 static int yy_start_stack_depth = 0;
1056 static int *yy_start_stack = 0;
1057 #ifndef YY_NO_PUSH_STATE
1058 static void yy_push_state YY_PROTO(( int new_state ));
1059 #endif
1060 #ifndef YY_NO_POP_STATE
1061 static void yy_pop_state YY_PROTO(( void ));
1062 #endif
1063 #ifndef YY_NO_TOP_STATE
1064 static int yy_top_state YY_PROTO(( void ));
1065 #endif
1066
1067 #else
1068 #define YY_NO_PUSH_STATE 1
1069 #define YY_NO_POP_STATE 1
1070 #define YY_NO_TOP_STATE 1
1071 #endif
1072
1073 #ifdef YY_MALLOC_DECL
1074 YY_MALLOC_DECL
1075 #else
1076 #if __STDC__
1077 #ifndef __cplusplus
1078 #include
1079 #endif
1080 #else
1081 /* Just try to get by without declaring the routines. This will fail
1082 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
1083 * or sizeof(void*) != sizeof(int).
1084 */
1085 #endif
11181086 #endif
11191087
11201088 /* Amount of stuff to slurp up with each read. */
11231091 #endif
11241092
11251093 /* Copy whatever the last rule matched to the standard output. */
1094
11261095 #ifndef ECHO
11271096 /* This used to be an fputs(), but since the string might contain NUL's,
11281097 * we now use fwrite().
11291098 */
1130 #define ECHO (void) fwrite( llvmAsmtext, llvmAsmleng, 1, llvmAsmout )
1099 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
11311100 #endif
11321101
11331102 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
11351104 */
11361105 #ifndef YY_INPUT
11371106 #define YY_INPUT(buf,result,max_size) \
1138 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1107 if ( yy_current_buffer->yy_is_interactive ) \
11391108 { \
1140 int c = '*'; \
1141 size_t n; \
1109 int c = '*', n; \
11421110 for ( n = 0; n < max_size && \
1143 (c = getc( llvmAsmin )) != EOF && c != '\n'; ++n ) \
1111 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
11441112 buf[n] = (char) c; \
11451113 if ( c == '\n' ) \
11461114 buf[n++] = (char) c; \
1147 if ( c == EOF && ferror( llvmAsmin ) ) \
1115 if ( c == EOF && ferror( yyin ) ) \
11481116 YY_FATAL_ERROR( "input in flex scanner failed" ); \
11491117 result = n; \
11501118 } \
1151 else \
1152 { \
1153 errno=0; \
1154 while ( (result = fread(buf, 1, max_size, llvmAsmin))==0 && ferror(llvmAsmin)) \
1155 { \
1156 if( errno != EINTR) \
1157 { \
1158 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1159 break; \
1160 } \
1161 errno=0; \
1162 clearerr(llvmAsmin); \
1163 } \
1164 }\
1165 \
1166
1119 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1120 && ferror( yyin ) ) \
1121 YY_FATAL_ERROR( "input in flex scanner failed" );
11671122 #endif
11681123
11691124 /* No semi-colon after return; correct usage is to write "yyterminate();" -
11841139 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
11851140 #endif
11861141
1187 /* end tables serialization structures and prototypes */
1188
11891142 /* Default declaration of generated scanner - a define so the user can
11901143 * easily add parameters.
11911144 */
11921145 #ifndef YY_DECL
1193 #define YY_DECL_IS_OURS 1
1194
1195 extern int llvmAsmlex (void);
1196
1197 #define YY_DECL int llvmAsmlex (void)
1198 #endif /* !YY_DECL */
1199
1200 /* Code executed at the beginning of each rule, after llvmAsmtext and llvmAsmleng
1146 #define YY_DECL int yylex YY_PROTO(( void ))
1147 #endif
1148
1149 /* Code executed at the beginning of each rule, after yytext and yyleng
12011150 * have been set up.
12021151 */
12031152 #ifndef YY_USER_ACTION
12121161 #define YY_RULE_SETUP \
12131162 YY_USER_ACTION
12141163
1215 /** The main scanner function which does all the work.
1216 */
12171164 YY_DECL
1218 {
1165 {
12191166 register yy_state_type yy_current_state;
1220 register char *yy_cp, *yy_bp;
1167 register char *yy_cp = NULL, *yy_bp = NULL;
12211168 register int yy_act;
1222
1223 #line 189 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1224
1225
1226 #line 1228 "Lexer.cpp"
1227
1228 if ( !(yy_init) )
1169
1170 #line 189 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1171
1172
1173 #line 1175 "Lexer.cpp"
1174
1175 if ( yy_init )
12291176 {
1230 (yy_init) = 1;
1177 yy_init = 0;
12311178
12321179 #ifdef YY_USER_INIT
12331180 YY_USER_INIT;
12341181 #endif
12351182
1236 if ( ! (yy_start) )
1237 (yy_start) = 1; /* first start state */
1238
1239 if ( ! llvmAsmin )
1240 llvmAsmin = stdin;
1241
1242 if ( ! llvmAsmout )
1243 llvmAsmout = stdout;
1244
1245 if ( ! YY_CURRENT_BUFFER ) {
1246 llvmAsmensure_buffer_stack ();
1247 YY_CURRENT_BUFFER_LVALUE =
1248 llvmAsm_create_buffer(llvmAsmin,YY_BUF_SIZE );
1249 }
1250
1251 llvmAsm_load_buffer_state( );
1183 if ( ! yy_start )
1184 yy_start = 1; /* first start state */
1185
1186 if ( ! yyin )
1187 yyin = stdin;
1188
1189 if ( ! yyout )
1190 yyout = stdout;
1191
1192 if ( ! yy_current_buffer )
1193 yy_current_buffer =
1194 yy_create_buffer( yyin, YY_BUF_SIZE );
1195
1196 yy_load_buffer_state();
12521197 }
12531198
12541199 while ( 1 ) /* loops until end-of-file is reached */
12551200 {
1256 yy_cp = (yy_c_buf_p);
1257
1258 /* Support of llvmAsmtext. */
1259 *yy_cp = (yy_hold_char);
1201 yy_cp = yy_c_buf_p;
1202
1203 /* Support of yytext. */
1204 *yy_cp = yy_hold_char;
12601205
12611206 /* yy_bp points to the position in yy_ch_buf of the start of
12621207 * the current run.
12631208 */
12641209 yy_bp = yy_cp;
12651210
1266 yy_current_state = (yy_start);
1211 yy_current_state = yy_start;
1212 yy_state_ptr = yy_state_buf;
1213 *yy_state_ptr++ = yy_current_state;
12671214 yy_match:
12681215 do
12691216 {
12701217 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1271 if ( yy_accept[yy_current_state] )
1272 {
1273 (yy_last_accepting_state) = yy_current_state;
1274 (yy_last_accepting_cpos) = yy_cp;
1275 }
12761218 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
12771219 {
12781220 yy_current_state = (int) yy_def[yy_current_state];
12801222 yy_c = yy_meta[(unsigned int) yy_c];
12811223 }
12821224 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1225 *yy_state_ptr++ = yy_current_state;
12831226 ++yy_cp;
12841227 }
12851228 while ( yy_current_state != 538 );
1286 yy_cp = (yy_last_accepting_cpos);
1287 yy_current_state = (yy_last_accepting_state);
12881229
12891230 yy_find_action:
1290 yy_act = yy_accept[yy_current_state];
1231 yy_current_state = *--yy_state_ptr;
1232 yy_lp = yy_accept[yy_current_state];
1233 find_rule: /* we branch to this label when backing up */
1234 for ( ; ; ) /* until we find what rule we matched */
1235 {
1236 if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
1237 {
1238 yy_act = yy_acclist[yy_lp];
1239 {
1240 yy_full_match = yy_cp;
1241 break;
1242 }
1243 }
1244 --yy_cp;
1245 yy_current_state = *--yy_state_ptr;
1246 yy_lp = yy_accept[yy_current_state];
1247 }
12911248
12921249 YY_DO_BEFORE_ACTION;
12931250
1294 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1251 if ( yy_act != YY_END_OF_BUFFER )
12951252 {
12961253 int yyl;
1297 for ( yyl = 0; yyl < llvmAsmleng; ++yyl )
1298 if ( llvmAsmtext[yyl] == '\n' )
1299
1300 llvmAsmlineno++;
1301 ;
1254 for ( yyl = 0; yyl < yyleng; ++yyl )
1255 if ( yytext[yyl] == '\n' )
1256 ++yylineno;
13021257 }
13031258
13041259 do_action: /* This label is used only to access EOF actions. */
1260
13051261
13061262 switch ( yy_act )
13071263 { /* beginning of action switch */
1308 case 0: /* must back up */
1309 /* undo the effects of YY_DO_BEFORE_ACTION */
1310 *yy_cp = (yy_hold_char);
1311 yy_cp = (yy_last_accepting_cpos);
1312 yy_current_state = (yy_last_accepting_state);
1313 goto yy_find_action;
1314
13151264 case 1:
13161265 YY_RULE_SETUP
1317 #line 191 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1266 #line 191 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13181267 { /* Ignore comments for now */ }
13191268 YY_BREAK
13201269 case 2:
13211270 YY_RULE_SETUP
1322 #line 193 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1271 #line 193 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13231272 { return BEGINTOK; }
13241273 YY_BREAK
13251274 case 3:
13261275 YY_RULE_SETUP
1327 #line 194 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1276 #line 194 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13281277 { return ENDTOK; }
13291278 YY_BREAK
13301279 case 4:
13311280 YY_RULE_SETUP
1332 #line 195 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1281 #line 195 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13331282 { return TRUETOK; }
13341283 YY_BREAK
13351284 case 5:
13361285 YY_RULE_SETUP
1337 #line 196 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1286 #line 196 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13381287 { return FALSETOK; }
13391288 YY_BREAK
13401289 case 6:
13411290 YY_RULE_SETUP
1342 #line 197 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1291 #line 197 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13431292 { return DECLARE; }
13441293 YY_BREAK
13451294 case 7:
13461295 YY_RULE_SETUP
1347 #line 198 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1296 #line 198 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13481297 { return DEFINE; }
13491298 YY_BREAK
13501299 case 8:
13511300 YY_RULE_SETUP
1352 #line 199 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1301 #line 199 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13531302 { return GLOBAL; }
13541303 YY_BREAK
13551304 case 9:
13561305 YY_RULE_SETUP
1357 #line 200 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1306 #line 200 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13581307 { return CONSTANT; }
13591308 YY_BREAK
13601309 case 10:
13611310 YY_RULE_SETUP
1362 #line 201 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1311 #line 201 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13631312 { return INTERNAL; }
13641313 YY_BREAK
13651314 case 11:
13661315 YY_RULE_SETUP
1367 #line 202 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1316 #line 202 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13681317 { return LINKONCE; }
13691318 YY_BREAK
13701319 case 12:
13711320 YY_RULE_SETUP
1372 #line 203 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1321 #line 203 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13731322 { return WEAK; }
13741323 YY_BREAK
13751324 case 13:
13761325 YY_RULE_SETUP
1377 #line 204 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1326 #line 204 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13781327 { return APPENDING; }
13791328 YY_BREAK
13801329 case 14:
13811330 YY_RULE_SETUP
1382 #line 205 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1331 #line 205 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13831332 { return DLLIMPORT; }
13841333 YY_BREAK
13851334 case 15:
13861335 YY_RULE_SETUP
1387 #line 206 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1336 #line 206 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13881337 { return DLLEXPORT; }
13891338 YY_BREAK
13901339 case 16:
13911340 YY_RULE_SETUP
1392 #line 207 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1341 #line 207 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13931342 { return HIDDEN; }
13941343 YY_BREAK
13951344 case 17:
13961345 YY_RULE_SETUP
1397 #line 208 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1346 #line 208 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
13981347 { return EXTERN_WEAK; }
13991348 YY_BREAK
14001349 case 18:
14011350 YY_RULE_SETUP
1402 #line 209 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1351 #line 209 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14031352 { return EXTERNAL; }
14041353 YY_BREAK
14051354 case 19:
14061355 YY_RULE_SETUP
1407 #line 210 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1356 #line 210 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14081357 { return IMPLEMENTATION; }
14091358 YY_BREAK
14101359 case 20:
14111360 YY_RULE_SETUP
1412 #line 211 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1361 #line 211 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14131362 { return ZEROINITIALIZER; }
14141363 YY_BREAK
14151364 case 21:
14161365 YY_RULE_SETUP
1417 #line 212 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1366 #line 212 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14181367 { return DOTDOTDOT; }
14191368 YY_BREAK
14201369 case 22:
14211370 YY_RULE_SETUP
1422 #line 213 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1371 #line 213 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14231372 { return UNDEF; }
14241373 YY_BREAK
14251374 case 23:
14261375 YY_RULE_SETUP
1427 #line 214 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1376 #line 214 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14281377 { return NULL_TOK; }
14291378 YY_BREAK
14301379 case 24:
14311380 YY_RULE_SETUP
1432 #line 215 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1381 #line 215 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14331382 { return TO; }
14341383 YY_BREAK
14351384 case 25:
14361385 YY_RULE_SETUP
1437 #line 216 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1386 #line 216 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14381387 { return TAIL; }
14391388 YY_BREAK
14401389 case 26:
14411390 YY_RULE_SETUP
1442 #line 217 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1391 #line 217 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14431392 { return TARGET; }
14441393 YY_BREAK
14451394 case 27:
14461395 YY_RULE_SETUP
1447 #line 218 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1396 #line 218 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14481397 { return TRIPLE; }
14491398 YY_BREAK
14501399 case 28:
14511400 YY_RULE_SETUP
1452 #line 219 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1401 #line 219 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14531402 { return DEPLIBS; }
14541403 YY_BREAK
14551404 case 29:
14561405 YY_RULE_SETUP
1457 #line 220 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1406 #line 220 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14581407 { return DATALAYOUT; }
14591408 YY_BREAK
14601409 case 30:
14611410 YY_RULE_SETUP
1462 #line 221 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1411 #line 221 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14631412 { return VOLATILE; }
14641413 YY_BREAK
14651414 case 31:
14661415 YY_RULE_SETUP
1467 #line 222 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1416 #line 222 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14681417 { return ALIGN; }
14691418 YY_BREAK
14701419 case 32:
14711420 YY_RULE_SETUP
1472 #line 223 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1421 #line 223 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14731422 { return SECTION; }
14741423 YY_BREAK
14751424 case 33:
14761425 YY_RULE_SETUP
1477 #line 224 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1426 #line 224 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14781427 { return MODULE; }
14791428 YY_BREAK
14801429 case 34:
14811430 YY_RULE_SETUP
1482 #line 225 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1431 #line 225 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14831432 { return ASM_TOK; }
14841433 YY_BREAK
14851434 case 35:
14861435 YY_RULE_SETUP
1487 #line 226 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1436 #line 226 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14881437 { return SIDEEFFECT; }
14891438 YY_BREAK
14901439 case 36:
14911440 YY_RULE_SETUP
1492 #line 228 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1441 #line 228 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14931442 { return CC_TOK; }
14941443 YY_BREAK
14951444 case 37:
14961445 YY_RULE_SETUP
1497 #line 229 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1446 #line 229 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
14981447 { return CCC_TOK; }
14991448 YY_BREAK
15001449 case 38:
15011450 YY_RULE_SETUP
1502 #line 230 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1451 #line 230 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15031452 { return FASTCC_TOK; }
15041453 YY_BREAK
15051454 case 39:
15061455 YY_RULE_SETUP
1507 #line 231 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1456 #line 231 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15081457 { return COLDCC_TOK; }
15091458 YY_BREAK
15101459 case 40:
15111460 YY_RULE_SETUP
1512 #line 232 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1461 #line 232 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15131462 { return X86_STDCALLCC_TOK; }
15141463 YY_BREAK
15151464 case 41:
15161465 YY_RULE_SETUP
1517 #line 233 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1466 #line 233 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15181467 { return X86_FASTCALLCC_TOK; }
15191468 YY_BREAK
15201469 case 42:
15211470 YY_RULE_SETUP
1522 #line 235 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1471 #line 235 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1472 { return INREG; }
1473 YY_BREAK
1474 case 43:
1475 YY_RULE_SETUP
1476 #line 236 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1477 { return SRET; }
1478 YY_BREAK
1479 case 44:
1480 YY_RULE_SETUP
1481 #line 238 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15231482 { RET_TY(Type::VoidTy, VOID); }
15241483 YY_BREAK
1525 case 43:
1526 YY_RULE_SETUP
1527 #line 236 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1484 case 45:
1485 YY_RULE_SETUP
1486 #line 239 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15281487 { RET_TY(Type::FloatTy, FLOAT); }
15291488 YY_BREAK
1530 case 44:
1531 YY_RULE_SETUP
1532 #line 237 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1489 case 46:
1490 YY_RULE_SETUP
1491 #line 240 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15331492 { RET_TY(Type::DoubleTy,DOUBLE);}
15341493 YY_BREAK
1535 case 45:
1536 YY_RULE_SETUP
1537 #line 238 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1494 case 47:
1495 YY_RULE_SETUP
1496 #line 241 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15381497 { RET_TY(Type::LabelTy, LABEL); }
15391498 YY_BREAK
1540 case 46:
1541 YY_RULE_SETUP
1542 #line 239 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1499 case 48:
1500 YY_RULE_SETUP
1501 #line 242 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15431502 { return TYPE; }
15441503 YY_BREAK
1545 case 47:
1546 YY_RULE_SETUP
1547 #line 240 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1504 case 49:
1505 YY_RULE_SETUP
1506 #line 243 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15481507 { return OPAQUE; }
15491508 YY_BREAK
1550 case 48:
1551 YY_RULE_SETUP
1552 #line 241 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1553 { uint64_t NumBits = atoull(llvmAsmtext+1);
1509 case 50:
1510 YY_RULE_SETUP
1511 #line 244 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1512 { uint64_t NumBits = atoull(yytext+1);
15541513 if (NumBits < IntegerType::MIN_INT_BITS ||
15551514 NumBits > IntegerType::MAX_INT_BITS)
15561515 GenerateError("Bitwidth for integer type out of range!");
15581517 RET_TY(Ty, INTTYPE);
15591518 }
15601519 YY_BREAK
1561 case 49:
1562 YY_RULE_SETUP
1563 #line 249 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1520 case 51:
1521 YY_RULE_SETUP
1522 #line 252 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15641523 { RET_TOK(BinaryOpVal, Add, ADD); }
15651524 YY_BREAK
1566 case 50:
1567 YY_RULE_SETUP
1568 #line 250 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1525 case 52:
1526 YY_RULE_SETUP
1527 #line 253 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15691528 { RET_TOK(BinaryOpVal, Sub, SUB); }
15701529 YY_BREAK
1571 case 51:
1572 YY_RULE_SETUP
1573 #line 251 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1530 case 53:
1531 YY_RULE_SETUP
1532 #line 254 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15741533 { RET_TOK(BinaryOpVal, Mul, MUL); }
15751534 YY_BREAK
1576 case 52:
1577 YY_RULE_SETUP
1578 #line 252 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1535 case 54:
1536 YY_RULE_SETUP
1537 #line 255 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15791538 { RET_TOK(BinaryOpVal, UDiv, UDIV); }
15801539 YY_BREAK
1581 case 53:
1582 YY_RULE_SETUP
1583 #line 253 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1540 case 55:
1541 YY_RULE_SETUP
1542 #line 256 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15841543 { RET_TOK(BinaryOpVal, SDiv, SDIV); }
15851544 YY_BREAK
1586 case 54:
1587 YY_RULE_SETUP
1588 #line 254 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1545 case 56:
1546 YY_RULE_SETUP
1547 #line 257 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15891548 { RET_TOK(BinaryOpVal, FDiv, FDIV); }
15901549 YY_BREAK
1591 case 55:
1592 YY_RULE_SETUP
1593 #line 255 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1550 case 57:
1551 YY_RULE_SETUP
1552 #line 258 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15941553 { RET_TOK(BinaryOpVal, URem, UREM); }
15951554 YY_BREAK
1596 case 56:
1597 YY_RULE_SETUP
1598 #line 256 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1555 case 58:
1556 YY_RULE_SETUP
1557 #line 259 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
15991558 { RET_TOK(BinaryOpVal, SRem, SREM); }
16001559 YY_BREAK
1601 case 57:
1602 YY_RULE_SETUP
1603 #line 257 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1560 case 59:
1561 YY_RULE_SETUP
1562 #line 260 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16041563 { RET_TOK(BinaryOpVal, FRem, FREM); }
16051564 YY_BREAK
1606 case 58:
1607 YY_RULE_SETUP
1608 #line 258 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1565 case 60:
1566 YY_RULE_SETUP
1567 #line 261 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1568 { RET_TOK(BinaryOpVal, Shl, SHL); }
1569 YY_BREAK
1570 case 61:
1571 YY_RULE_SETUP
1572 #line 262 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1573 { RET_TOK(BinaryOpVal, LShr, LSHR); }
1574 YY_BREAK
1575 case 62:
1576 YY_RULE_SETUP
1577 #line 263 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1578 { RET_TOK(BinaryOpVal, AShr, ASHR); }
1579 YY_BREAK
1580 case 63:
1581 YY_RULE_SETUP
1582 #line 264 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16091583 { RET_TOK(BinaryOpVal, And, AND); }
16101584 YY_BREAK
1611 case 59:
1612 YY_RULE_SETUP
1613 #line 259 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1585 case 64:
1586 YY_RULE_SETUP
1587 #line 265 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16141588 { RET_TOK(BinaryOpVal, Or , OR ); }
16151589 YY_BREAK
1616 case 60:
1617 YY_RULE_SETUP
1618 #line 260 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1590 case 65:
1591 YY_RULE_SETUP
1592 #line 266 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16191593 { RET_TOK(BinaryOpVal, Xor, XOR); }
16201594 YY_BREAK
1621 case 61:
1622 YY_RULE_SETUP
1623 #line 261 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1595 case 66:
1596 YY_RULE_SETUP
1597 #line 267 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16241598 { RET_TOK(OtherOpVal, ICmp, ICMP); }
16251599 YY_BREAK
1626 case 62:
1627 YY_RULE_SETUP
1628 #line 262 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1600 case 67:
1601 YY_RULE_SETUP
1602 #line 268 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16291603 { RET_TOK(OtherOpVal, FCmp, FCMP); }
16301604 YY_BREAK
1631 case 63:
1632 YY_RULE_SETUP
1633 #line 263 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1605 case 68:
1606 YY_RULE_SETUP
1607 #line 270 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16341608 { return EQ; }
16351609 YY_BREAK
1636 case 64:
1637 YY_RULE_SETUP
1638 #line 264 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1610 case 69:
1611 YY_RULE_SETUP
1612 #line 271 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16391613 { return NE; }
16401614 YY_BREAK
1641 case 65:
1642 YY_RULE_SETUP
1643 #line 265 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1615 case 70:
1616 YY_RULE_SETUP
1617 #line 272 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16441618 { return SLT; }
16451619 YY_BREAK
1646 case 66:
1647 YY_RULE_SETUP
1648 #line 266 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1620 case 71:
1621 YY_RULE_SETUP
1622 #line 273 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16491623 { return SGT; }
16501624 YY_BREAK
1651 case 67:
1652 YY_RULE_SETUP
1653 #line 267 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1625 case 72:
1626 YY_RULE_SETUP
1627 #line 274 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16541628 { return SLE; }
16551629 YY_BREAK
1656 case 68:
1657 YY_RULE_SETUP
1658 #line 268 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1630 case 73:
1631 YY_RULE_SETUP
1632 #line 275 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16591633 { return SGE; }
16601634 YY_BREAK
1661 case 69:
1662 YY_RULE_SETUP
1663 #line 269 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1635 case 74:
1636 YY_RULE_SETUP
1637 #line 276 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16641638 { return ULT; }
16651639 YY_BREAK
1666 case 70:
1667 YY_RULE_SETUP
1668 #line 270 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1640 case 75:
1641 YY_RULE_SETUP
1642 #line 277 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16691643 { return UGT; }
16701644 YY_BREAK
1671 case 71:
1672 YY_RULE_SETUP
1673 #line 271 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1645 case 76:
1646 YY_RULE_SETUP
1647 #line 278 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16741648 { return ULE; }
16751649 YY_BREAK
1676 case 72:
1677 YY_RULE_SETUP
1678 #line 272 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1650 case 77:
1651 YY_RULE_SETUP
1652 #line 279 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16791653 { return UGE; }
16801654 YY_BREAK
1681 case 73:
1682 YY_RULE_SETUP
1683 #line 273 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1655 case 78:
1656 YY_RULE_SETUP
1657 #line 280 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16841658 { return OEQ; }
16851659 YY_BREAK
1686 case 74:
1687 YY_RULE_SETUP
1688 #line 274 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1660 case 79:
1661 YY_RULE_SETUP
1662 #line 281 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16891663 { return ONE; }
16901664 YY_BREAK
1691 case 75:
1692 YY_RULE_SETUP
1693 #line 275 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1665 case 80:
1666 YY_RULE_SETUP
1667 #line 282 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16941668 { return OLT; }
16951669 YY_BREAK
1696 case 76:
1697 YY_RULE_SETUP
1698 #line 276 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1670 case 81:
1671 YY_RULE_SETUP
1672 #line 283 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
16991673 { return OGT; }
17001674 YY_BREAK
1701 case 77:
1702 YY_RULE_SETUP
1703 #line 277 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1675 case 82:
1676 YY_RULE_SETUP
1677 #line 284 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17041678 { return OLE; }
17051679 YY_BREAK
1706 case 78:
1707 YY_RULE_SETUP
1708 #line 278 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1680 case 83:
1681 YY_RULE_SETUP
1682 #line 285 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17091683 { return OGE; }
17101684 YY_BREAK
1711 case 79:
1712 YY_RULE_SETUP
1713 #line 279 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1685 case 84:
1686 YY_RULE_SETUP
1687 #line 286 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17141688 { return ORD; }
17151689 YY_BREAK
1716 case 80:
1717 YY_RULE_SETUP
1718 #line 280 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1690 case 85:
1691 YY_RULE_SETUP
1692 #line 287 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17191693 { return UNO; }
17201694 YY_BREAK
1721 case 81:
1722 YY_RULE_SETUP
1723 #line 281 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1695 case 86:
1696 YY_RULE_SETUP
1697 #line 288 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17241698 { return UEQ; }
17251699 YY_BREAK
1726 case 82:
1727 YY_RULE_SETUP
1728 #line 282 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1700 case 87:
1701 YY_RULE_SETUP
1702 #line 289 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17291703 { return UNE; }
17301704 YY_BREAK
1731 case 83:
1732 YY_RULE_SETUP
1733 #line 284 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1705 case 88:
1706 YY_RULE_SETUP
1707 #line 291 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17341708 { RET_TOK(OtherOpVal, PHI, PHI_TOK); }
17351709 YY_BREAK
1736 case 84:
1737 YY_RULE_SETUP
1738 #line 285 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1710 case 89:
1711 YY_RULE_SETUP
1712 #line 292 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17391713 { RET_TOK(OtherOpVal, Call, CALL); }
17401714 YY_BREAK
1741 case 85:
1742 YY_RULE_SETUP
1743 #line 286 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1715 case 90:
1716 YY_RULE_SETUP
1717 #line 293 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17441718 { RET_TOK(CastOpVal, Trunc, TRUNC); }
17451719 YY_BREAK
1746 case 86:
1747 YY_RULE_SETUP
1748 #line 287 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1720 case 91:
1721 YY_RULE_SETUP
1722 #line 294 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17491723 { RET_TOK(CastOpVal, ZExt, ZEXT); }
17501724 YY_BREAK
1751 case 87:
1752 YY_RULE_SETUP
1753 #line 288 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1725 case 92:
1726 YY_RULE_SETUP
1727 #line 295 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17541728 { RET_TOK(CastOpVal, SExt, SEXT); }
17551729 YY_BREAK
1756 case 88:
1757 YY_RULE_SETUP
1758 #line 289 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1759 { return INREG; }
1760 YY_BREAK
1761 case 89:
1762 YY_RULE_SETUP
1763 #line 290 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1764 { return SRET; }
1765 YY_BREAK
1766 case 90:
1767 YY_RULE_SETUP
1768 #line 291 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1730 case 93:
1731 YY_RULE_SETUP
1732 #line 296 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17691733 { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); }
17701734 YY_BREAK
1771 case 91:
1772 YY_RULE_SETUP
1773 #line 292 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1735 case 94:
1736 YY_RULE_SETUP
1737 #line 297 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17741738 { RET_TOK(CastOpVal, FPExt, FPEXT); }
17751739 YY_BREAK
1776 case 92:
1777 YY_RULE_SETUP
1778 #line 293 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1740 case 95:
1741 YY_RULE_SETUP
1742 #line 298 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17791743 { RET_TOK(CastOpVal, UIToFP, UITOFP); }
17801744 YY_BREAK
1781 case 93:
1782 YY_RULE_SETUP
1783 #line 294 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1745 case 96:
1746 YY_RULE_SETUP
1747 #line 299 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17841748 { RET_TOK(CastOpVal, SIToFP, SITOFP); }
17851749 YY_BREAK
1786 case 94:
1787 YY_RULE_SETUP
1788 #line 295 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1750 case 97:
1751 YY_RULE_SETUP
1752 #line 300 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17891753 { RET_TOK(CastOpVal, FPToUI, FPTOUI); }
17901754 YY_BREAK
1791 case 95:
1792 YY_RULE_SETUP
1793 #line 296 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1755 case 98:
1756 YY_RULE_SETUP
1757 #line 301 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17941758 { RET_TOK(CastOpVal, FPToSI, FPTOSI); }
17951759 YY_BREAK
1796 case 96:
1797 YY_RULE_SETUP
1798 #line 297 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1760 case 99:
1761 YY_RULE_SETUP
1762 #line 302 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
17991763 { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); }
18001764 YY_BREAK
1801 case 97:
1802 YY_RULE_SETUP
1803 #line 298 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1765 case 100:
1766 YY_RULE_SETUP
1767 #line 303 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18041768 { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); }
18051769 YY_BREAK
1806 case 98:
1807 YY_RULE_SETUP
1808 #line 299 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1770 case 101:
1771 YY_RULE_SETUP
1772 #line 304 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18091773 { RET_TOK(CastOpVal, BitCast, BITCAST); }
18101774 YY_BREAK
1811 case 99:
1812 YY_RULE_SETUP
1813 #line 300 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1775 case 102:
1776 YY_RULE_SETUP
1777 #line 305 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18141778 { RET_TOK(OtherOpVal, Select, SELECT); }
18151779 YY_BREAK
1816 case 100:
1817 YY_RULE_SETUP
1818 #line 301 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1819 { RET_TOK(OtherOpVal, Shl, SHL); }
1820 YY_BREAK
1821 case 101:
1822 YY_RULE_SETUP
1823 #line 302 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1824 { RET_TOK(OtherOpVal, LShr, LSHR); }
1825 YY_BREAK
1826 case 102:
1827 YY_RULE_SETUP
1828 #line 303 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1829 { RET_TOK(OtherOpVal, AShr, ASHR); }
1830 YY_BREAK
18311780 case 103:
18321781 YY_RULE_SETUP
1833 #line 304 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1782 #line 306 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18341783 { RET_TOK(OtherOpVal, VAArg , VAARG); }
18351784 YY_BREAK
18361785 case 104:
18371786 YY_RULE_SETUP
1838 #line 305 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1787 #line 307 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18391788 { RET_TOK(TermOpVal, Ret, RET); }
18401789 YY_BREAK
18411790 case 105:
18421791 YY_RULE_SETUP
1843 #line 306 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1792 #line 308 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18441793 { RET_TOK(TermOpVal, Br, BR); }
18451794 YY_BREAK
18461795 case 106:
18471796 YY_RULE_SETUP
1848 #line 307 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1797 #line 309 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18491798 { RET_TOK(TermOpVal, Switch, SWITCH); }
18501799 YY_BREAK
18511800 case 107:
18521801 YY_RULE_SETUP
1853 #line 308 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1802 #line 310 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18541803 { RET_TOK(TermOpVal, Invoke, INVOKE); }
18551804 YY_BREAK
18561805 case 108:
18571806 YY_RULE_SETUP
1858 #line 309 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1807 #line 311 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18591808 { RET_TOK(TermOpVal, Unwind, UNWIND); }
18601809 YY_BREAK
18611810 case 109:
18621811 YY_RULE_SETUP
1863 #line 310 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1812 #line 312 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18641813 { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
18651814 YY_BREAK
18661815 case 110:
18671816 YY_RULE_SETUP
1868 #line 312 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1817 #line 314 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18691818 { RET_TOK(MemOpVal, Malloc, MALLOC); }
18701819 YY_BREAK
18711820 case 111:
18721821 YY_RULE_SETUP
1873 #line 313 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1822 #line 315 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18741823 { RET_TOK(MemOpVal, Alloca, ALLOCA); }
18751824 YY_BREAK
18761825 case 112:
18771826 YY_RULE_SETUP
1878 #line 314 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1827 #line 316 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18791828 { RET_TOK(MemOpVal, Free, FREE); }
18801829 YY_BREAK
18811830 case 113:
18821831 YY_RULE_SETUP
1883 #line 315 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1832 #line 317 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18841833 { RET_TOK(MemOpVal, Load, LOAD); }
18851834 YY_BREAK
18861835 case 114:
18871836 YY_RULE_SETUP
1888 #line 316 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1837 #line 318 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18891838 { RET_TOK(MemOpVal, Store, STORE); }
18901839 YY_BREAK
18911840 case 115:
18921841 YY_RULE_SETUP
1893 #line 317 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1842 #line 319 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18941843 { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
18951844 YY_BREAK
18961845 case 116:
18971846 YY_RULE_SETUP
1898 #line 319 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1847 #line 321 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
18991848 { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
19001849 YY_BREAK
19011850 case 117:
19021851 YY_RULE_SETUP
1903 #line 320 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1852 #line 322 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
19041853 { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
19051854 YY_BREAK
19061855 case 118:
19071856 YY_RULE_SETUP
1908 #line 321 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1857 #line 323 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
19091858 { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
19101859 YY_BREAK
19111860 case 119:
19121861 YY_RULE_SETUP
1913 #line 324 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1862 #line 326 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
19141863 {
1915 UnEscapeLexed(llvmAsmtext+1);
1916 llvmAsmlval.StrVal = strdup(llvmAsmtext+1); // Skip %
1864 UnEscapeLexed(yytext+1);
1865 llvmAsmlval.StrVal = strdup(yytext+1); // Skip %
19171866 return LOCALVAR;
19181867 }
19191868 YY_BREAK
19201869 case 120:
19211870 YY_RULE_SETUP
1922 #line 329 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1871 #line 331 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
19231872 {
1924 UnEscapeLexed(llvmAsmtext+1);
1925 llvmAsmlval.StrVal = strdup(llvmAsmtext+1); // Skip @
1873 UnEscapeLexed(yytext+1);
1874 llvmAsmlval.StrVal = strdup(yytext+1); // Skip @
19261875 return GLOBALVAR;
19271876 }
19281877 YY_BREAK
19291878 case 121:
19301879 YY_RULE_SETUP
1931 #line 334 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1880 #line 336 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
19321881 {
1933 llvmAsmtext[strlen(llvmAsmtext)-1] = 0; // nuke colon
1934 UnEscapeLexed(llvmAsmtext);
1935 llvmAsmlval.StrVal = strdup(llvmAsmtext);
1882 yytext[strlen(yytext)-1] = 0; // nuke colon
1883 UnEscapeLexed(yytext);
1884 llvmAsmlval.StrVal = strdup(yytext);
19361885 return LABELSTR;
19371886 }
19381887 YY_BREAK
19391888 case 122:
1940 /* rule 122 can match eol */
1941 YY_RULE_SETUP
1942 #line 340 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1889 YY_RULE_SETUP
1890 #line 342 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
19431891 {
1944 llvmAsmtext[strlen(llvmAsmtext)-2] = 0; // nuke colon, end quote
1945 UnEscapeLexed(llvmAsmtext+1);
1946 llvmAsmlval.StrVal = strdup(llvmAsmtext+1);
1892 yytext[strlen(yytext)-2] = 0; // nuke colon, end quote
1893 UnEscapeLexed(yytext+1);
1894 llvmAsmlval.StrVal = strdup(yytext+1);
19471895 return LABELSTR;
19481896 }
19491897 YY_BREAK
19501898 case 123:
1951 /* rule 123 can match eol */
1952 YY_RULE_SETUP
1953 #line 347 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1899 YY_RULE_SETUP
1900 #line 349 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
19541901 { // Note that we cannot unescape a string constant here! The
19551902 // string constant might contain a \00 which would not be
19561903 // understood by the string stuff. It is valid to make a
19571904 // [sbyte] c"Hello World\00" constant, for example.
19581905 //
1959 llvmAsmtext[strlen(llvmAsmtext)-1] = 0; // nuke end quote
1960 llvmAsmlval.StrVal = strdup(llvmAsmtext+1); // Nuke start quote
1906 yytext[strlen(yytext)-1] = 0; // nuke end quote
1907 llvmAsmlval.StrVal = strdup(yytext+1); // Nuke start quote
19611908 return STRINGCONSTANT;
19621909 }
19631910 YY_BREAK
19641911 case 124:
1965 /* rule 124 can match eol */
1966 YY_RULE_SETUP
1967 #line 356 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1912 YY_RULE_SETUP
1913 #line 358 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
19681914 {
1969 llvmAsmtext[strlen(llvmAsmtext)-1] = 0; // nuke end quote
1970 llvmAsmlval.StrVal = strdup(llvmAsmtext+2); // Nuke @, quote
1915 yytext[strlen(yytext)-1] = 0; // nuke end quote
1916 llvmAsmlval.StrVal = strdup(yytext+2); // Nuke @, quote
19711917 return ATSTRINGCONSTANT;
19721918 }
19731919 YY_BREAK
19741920 case 125:
19751921 YY_RULE_SETUP
1976 #line 364 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1977 { llvmAsmlval.UInt64Val = atoull(llvmAsmtext); return EUINT64VAL; }
1922 #line 366 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1923 { llvmAsmlval.UInt64Val = atoull(yytext); return EUINT64VAL; }
19781924 YY_BREAK
19791925 case 126:
19801926 YY_RULE_SETUP
1981 #line 365 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1927 #line 367 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
19821928 {
1983 uint64_t Val = atoull(llvmAsmtext+1);
1929 uint64_t Val = atoull(yytext+1);
19841930 // +1: we have bigger negative range
19851931 if (Val > (uint64_t)INT64_MAX+1)
19861932 GenerateError("Constant too large for signed 64 bits!");
19901936 YY_BREAK
19911937 case 127:
19921938 YY_RULE_SETUP
1993 #line 373 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1939 #line 375 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
19941940 {
1995 llvmAsmlval.UInt64Val = HexIntToVal(llvmAsmtext+3);
1996 return llvmAsmtext[0] == 's' ? ESINT64VAL : EUINT64VAL;
1941 llvmAsmlval.UInt64Val = HexIntToVal(yytext+3);
1942 return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
19971943 }
19981944 YY_BREAK
19991945 case 128:
20001946 YY_RULE_SETUP
2001 #line 378 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1947 #line 380 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
20021948 {
2003 uint64_t Val = atoull(llvmAsmtext+1);
1949 uint64_t Val = atoull(yytext+1);
20041950 if ((unsigned)Val != Val)
20051951 GenerateError("Invalid value number (too large)!");
20061952 llvmAsmlval.UIntVal = unsigned(Val);
20091955 YY_BREAK
20101956 case 129:
20111957 YY_RULE_SETUP
2012 #line 385 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1958 #line 387 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
20131959 {
2014 uint64_t Val = atoull(llvmAsmtext+1);
1960 uint64_t Val = atoull(yytext+1);
20151961 if ((unsigned)Val != Val)
20161962 GenerateError("Invalid value number (too large)!");
20171963 llvmAsmlval.UIntVal = unsigned(Val);
20201966 YY_BREAK
20211967 case 130:
20221968 YY_RULE_SETUP
2023 #line 393 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
2024 { llvmAsmlval.FPVal = atof(llvmAsmtext); return FPVAL; }
1969 #line 395 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1970 { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
20251971 YY_BREAK
20261972 case 131:
20271973 YY_RULE_SETUP
2028 #line 394 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
2029 { llvmAsmlval.FPVal = HexToFP(llvmAsmtext); return FPVAL; }
1974 #line 396 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1975 { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
20301976 YY_BREAK
20311977 case YY_STATE_EOF(INITIAL):
2032 #line 396 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1978 #line 398 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
20331979 {
20341980 /* Make sure to free the internal buffers for flex when we are
20351981 * done reading our input!
20361982 */
2037 llvmAsm_delete_buffer(YY_CURRENT_BUFFER);
1983 yy_delete_buffer(YY_CURRENT_BUFFER);
20381984 return EOF;
20391985 }
20401986 YY_BREAK
20411987 case 132:
2042 /* rule 132 can match eol */
2043 YY_RULE_SETUP
2044 #line 404 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1988 YY_RULE_SETUP
1989 #line 406 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
20451990 { /* Ignore whitespace */ }
20461991 YY_BREAK
20471992 case 133:
20481993 YY_RULE_SETUP
2049 #line 405 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
2050 { return llvmAsmtext[0]; }
1994 #line 407 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1995 { return yytext[0]; }
20511996 YY_BREAK
20521997 case 134:
20531998 YY_RULE_SETUP
2054 #line 407 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l"
1999 #line 409 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
20552000 YY_FATAL_ERROR( "flex scanner jammed" );
20562001 YY_BREAK
2057 #line 2059 "Lexer.cpp"
2002 #line 2004 "Lexer.cpp"
20582003
20592004 case YY_END_OF_BUFFER:
20602005 {
20612006 /* Amount of text matched not including the EOB char. */
2062 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2007 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
20632008
20642009 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2065 *yy_cp = (yy_hold_char);
2010 *yy_cp = yy_hold_char;
20662011 YY_RESTORE_YY_MORE_OFFSET
20672012
2068 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2013 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
20692014 {
20702015 /* We're scanning a new file or input source. It's
20712016 * possible that this happened because the user
2072 * just pointed llvmAsmin at a new source and called
2073 * llvmAsmlex(). If so, then we have to assure
2074 * consistency between YY_CURRENT_BUFFER and our
2017 * just pointed yyin at a new source and called
2018 * yylex(). If so, then we have to assure
2019 * consistency between yy_current_buffer and our
20752020 * globals. Here is the right place to do so, because
20762021 * this is the first action (other than possibly a
20772022 * back-up) that will match for the new input source.
20782023 */
2079 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2080 YY_CURRENT_BUFFER_LVALUE->yy_input_file = llvmAsmin;
2081 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2024 yy_n_chars = yy_current_buffer->yy_n_chars;
2025 yy_current_buffer->yy_input_file = yyin;
2026 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
20822027 }
20832028
20842029 /* Note that here we test for yy_c_buf_p "<=" to the position
20882033 * end-of-buffer state). Contrast this with the test
20892034 * in input().
20902035 */
2091 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2036 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
20922037 { /* This was really a NUL. */
20932038 yy_state_type yy_next_state;
20942039
2095 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2096
2097 yy_current_state = yy_get_previous_state( );
2040 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
2041
2042 yy_current_state = yy_get_previous_state();
20982043
20992044 /* Okay, we're now positioned to make the NUL
21002045 * transition. We couldn't have
21072052
21082053 yy_next_state = yy_try_NUL_trans( yy_current_state );
21092054
2110 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2055 yy_bp = yytext_ptr + YY_MORE_ADJ;
21112056
21122057 if ( yy_next_state )
21132058 {
21142059 /* Consume the NUL. */
2115 yy_cp = ++(yy_c_buf_p);
2060 yy_cp = ++yy_c_buf_p;
21162061 yy_current_state = yy_next_state;
21172062 goto yy_match;
21182063 }
21192064
21202065 else
21212066 {
2122 yy_cp = (yy_last_accepting_cpos);
2123 yy_current_state = (yy_last_accepting_state);
2067 yy_cp = yy_c_buf_p;
21242068 goto yy_find_action;
21252069 }
21262070 }
21272071
2128 else switch ( yy_get_next_buffer( ) )
2072 else switch ( yy_get_next_buffer() )
21292073 {
21302074 case EOB_ACT_END_OF_FILE:
21312075 {
2132 (yy_did_buffer_switch_on_eof) = 0;
2133
2134 if ( llvmAsmwrap( ) )
2076 yy_did_buffer_switch_on_eof = 0;
2077
2078 if ( yywrap() )
21352079 {
21362080 /* Note: because we've taken care in
21372081 * yy_get_next_buffer() to have set up
2138 * llvmAsmtext, we can now set up
2082 * yytext, we can now set up
21392083 * yy_c_buf_p so that if some total
21402084 * hoser (like flex itself) wants to
21412085 * call the scanner after we return the
21422086 * YY_NULL, it'll still work - another
21432087 * YY_NULL will get returned.
21442088 */
2145 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2089 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
21462090
21472091 yy_act = YY_STATE_EOF(YY_START);
21482092 goto do_action;
21502094
21512095 else
21522096 {
2153 if ( ! (yy_did_buffer_switch_on_eof) )
2097 if ( ! yy_did_buffer_switch_on_eof )
21542098 YY_NEW_FILE;
21552099 }
21562100 break;
21572101 }
21582102
21592103 case EOB_ACT_CONTINUE_SCAN:
2160 (yy_c_buf_p) =
2161 (yytext_ptr) + yy_amount_of_matched_text;
2162
2163 yy_current_state = yy_get_previous_state( );
2164
2165 yy_cp = (yy_c_buf_p);
2166 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2104 yy_c_buf_p =
2105 yytext_ptr + yy_amount_of_matched_text;
2106
2107 yy_current_state = yy_get_previous_state();
2108
2109 yy_cp = yy_c_buf_p;
2110 yy_bp = yytext_ptr + YY_MORE_ADJ;
21672111 goto yy_match;
21682112
21692113 case EOB_ACT_LAST_MATCH:
2170 (yy_c_buf_p) =
2171 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2172
2173 yy_current_state = yy_get_previous_state( );
2174
2175 yy_cp = (yy_c_buf_p);
2176 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2114 yy_c_buf_p =
2115 &yy_current_buffer->yy_ch_buf[yy_n_chars];
2116
2117 yy_current_state = yy_get_previous_state();
2118
2119 yy_cp = yy_c_buf_p;
2120 yy_bp = yytext_ptr + YY_MORE_ADJ;
21772121 goto yy_find_action;
21782122 }
21792123 break;
21842128 "fatal flex scanner internal error--no action found" );
21852129 } /* end of action switch */
21862130 } /* end of scanning one token */
2187 } /* end of llvmAsmlex */
2131 } /* end of yylex */
2132
21882133
21892134 /* yy_get_next_buffer - try to read in a new buffer
21902135 *
21932138 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
21942139 * EOB_ACT_END_OF_FILE - end of file
21952140 */
2196 static int yy_get_next_buffer (void)
2197 {
2198 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2199 register char *source = (yytext_ptr);
2141
2142 static int yy_get_next_buffer()
2143 {
2144 register char *dest = yy_current_buffer->yy_ch_buf;
2145 register char *source = yytext_ptr;
22002146 register int number_to_move, i;
22012147 int ret_val;
22022148
2203 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2149 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
22042150 YY_FATAL_ERROR(
22052151 "fatal flex scanner internal error--end of buffer missed" );
22062152
2207 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2153 if ( yy_current_buffer->yy_fill_buffer == 0 )
22082154 { /* Don't try to fill the buffer, so this is an EOF. */
2209 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2155 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
22102156 {
22112157 /* We matched a single character, the EOB, so
22122158 * treat this as a final EOF.
22262172 /* Try to read more data. */
22272173
22282174 /* First move last chars to start of buffer. */
2229 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2175 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
22302176
22312177 for ( i = 0; i < number_to_move; ++i )
22322178 *(dest++) = *(source++);
22332179
2234 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2180 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
22352181 /* don't do the read, it's not guaranteed to return an EOF,
22362182 * just force an EOF
22372183 */
2238 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2184 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
22392185
22402186 else
22412187 {
2242 int num_to_read =
2243 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2188 int num_to_read =
2189 yy_current_buffer->yy_buf_size - number_to_move - 1;
22442190
22452191 while ( num_to_read <= 0 )
22462192 { /* Not enough room in the buffer - grow it. */
2193 #ifdef YY_USES_REJECT
2194 YY_FATAL_ERROR(
2195 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2196 #else
22472197
22482198 /* just a shorter name for the current buffer */
2249 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
2199 YY_BUFFER_STATE b = yy_current_buffer;
22502200
22512201 int yy_c_buf_p_offset =
2252 (int) ((yy_c_buf_p) - b->yy_ch_buf);
2202 (int) (yy_c_buf_p - b->yy_ch_buf);
22532203
22542204 if ( b->yy_is_our_buffer )
22552205 {
22622212
22632213 b->yy_ch_buf = (char *)
22642214 /* Include room in for 2 EOB chars. */
2265 llvmAsmrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
2215 yy_flex_realloc( (void *) b->yy_ch_buf,
2216 b->yy_buf_size + 2 );
22662217 }
22672218 else
22682219 /* Can't grow it, we don't own it. */
22722223 YY_FATAL_ERROR(
22732224 "fatal error - scanner input buffer overflow" );
22742225
2275 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2276
2277 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2226 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2227
2228 num_to_read = yy_current_buffer->yy_buf_size -
22782229 number_to_move - 1;
2279
2230 #endif
22802231 }
22812232
22822233 if ( num_to_read > YY_READ_BUF_SIZE )
22832234 num_to_read = YY_READ_BUF_SIZE;
22842235
22852236 /* Read in more data. */
2286 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2287 (yy_n_chars), num_to_read );
2288
2289 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2237 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2238 yy_n_chars, num_to_read );
2239
2240 yy_current_buffer->yy_n_chars = yy_n_chars;
22902241 }
22912242
2292 if ( (yy_n_chars) == 0 )
2243 if ( yy_n_chars == 0 )
22932244 {
22942245 if ( number_to_move == YY_MORE_ADJ )
22952246 {
22962247 ret_val = EOB_ACT_END_OF_FILE;
2297 llvmAsmrestart(llvmAsmin );
2248 yyrestart( yyin );
22982249 }
22992250
23002251 else
23012252 {
23022253 ret_val = EOB_ACT_LAST_MATCH;
2303 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2254 yy_current_buffer->yy_buffer_status =
23042255 YY_BUFFER_EOF_PENDING;
23052256 }
23062257 }
23082259 else
23092260 ret_val = EOB_ACT_CONTINUE_SCAN;
23102261
2311 (yy_n_chars) += number_to_move;
2312 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2313 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2314
2315 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2262 yy_n_chars += number_to_move;
2263 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2264 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2265
2266 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
23162267
23172268 return ret_val;
2318 }
2269 }
2270
23192271
23202272 /* yy_get_previous_state - get the state just before the EOB char was reached */
23212273
2322 static yy_state_type yy_get_previous_state (void)
2323 {
2274 static yy_state_type yy_get_previous_state()
2275 {
23242276 register yy_state_type yy_current_state;
23252277 register char *yy_cp;
2326
2327 yy_current_state = (yy_start);
2328
2329 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2278
2279 yy_current_state = yy_start;
2280 yy_state_ptr = yy_state_buf;
2281 *yy_state_ptr++ = yy_current_state;
2282
2283 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
23302284 {
23312285 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2332 if ( yy_accept[yy_current_state] )
2333 {
2334 (yy_last_accepting_state) = yy_current_state;
2335 (yy_last_accepting_cpos) = yy_cp;
2336 }
23372286 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
23382287 {
23392288 yy_current_state = (int) yy_def[yy_current_state];
23412290 yy_c = yy_meta[(unsigned int) yy_c];
23422291 }
23432292 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2293 *yy_state_ptr++ = yy_current_state;
23442294 }
23452295
23462296 return yy_current_state;
2347 }
2297 }
2298
23482299
23492300 /* yy_try_NUL_trans - try to make a transition on the NUL character
23502301 *
23512302 * synopsis
23522303 * next_state = yy_try_NUL_trans( current_state );
23532304 */
2354 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
2355 {
2305
2306 #ifdef YY_USE_PROTOS
2307 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2308 #else
2309 static yy_state_type yy_try_NUL_trans( yy_current_state )
2310 yy_state_type yy_current_state;
2311 #endif
2312 {
23562313 register int yy_is_jam;
2357 register char *yy_cp = (yy_c_buf_p);
23582314
23592315 register YY_CHAR yy_c = 1;
2360 if ( yy_accept[yy_current_state] )
2361 {
2362 (yy_last_accepting_state) = yy_current_state;
2363 (yy_last_accepting_cpos) = yy_cp;
2364 }
23652316 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
23662317 {
23672318 yy_current_state = (int) yy_def[yy_current_state];
23702321 }
23712322 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
23722323 yy_is_jam = (yy_current_state == 538);
2324 if ( ! yy_is_jam )
2325 *yy_state_ptr++ = yy_current_state;
23732326
23742327 return yy_is_jam ? 0 : yy_current_state;
2375 }
2376
2377 static inline void yyunput (int c, register char * yy_bp )
2378 {
2379 register char *yy_cp;
2380
2381 yy_cp = (yy_c_buf_p);
2382
2383 /* undo effects of setting up llvmAsmtext */
2384 *yy_cp = (yy_hold_char);
2385
2386 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2328 }
2329
2330
2331 #ifndef YY_NO_UNPUT
2332 #ifdef YY_USE_PROTOS
2333 static inline void yyunput( int c, register char *yy_bp )
2334 #else
2335 static inline void yyunput( c, yy_bp )
2336 int c;
2337 register char *yy_bp;
2338 #endif
2339 {
2340 register char *yy_cp = yy_c_buf_p;
2341
2342 /* undo effects of setting up yytext */
2343 *yy_cp = yy_hold_char;
2344
2345 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
23872346 { /* need to shift things up to make room */
23882347 /* +2 for EOB chars. */
2389 register int number_to_move = (yy_n_chars) + 2;
2390 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2391 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2348 register int number_to_move = yy_n_chars + 2;
2349 register char *dest = &yy_current_buffer->yy_ch_buf[
2350 yy_current_buffer->yy_buf_size + 2];
23922351 register char *source =
2393 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2394
2395 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2352 &yy_current_buffer->yy_ch_buf[number_to_move];
2353
2354 while ( source > yy_current_buffer->yy_ch_buf )
23962355 *--dest = *--source;
23972356
23982357 yy_cp += (int) (dest - source);
23992358 yy_bp += (int) (dest - source);
2400 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2401 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2402
2403 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2359 yy_current_buffer->yy_n_chars =
2360 yy_n_chars = yy_current_buffer->yy_buf_size;
2361
2362 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
24042363 YY_FATAL_ERROR( "flex scanner push-back overflow" );
24052364 }
24062365
24072366 *--yy_cp = (char) c;
24082367
2409 if ( c == '\n' ){
2410 --llvmAsmlineno;
2411 }
2412
2413 (yytext_ptr) = yy_bp;
2414 (yy_hold_char) = *yy_cp;
2415 (yy_c_buf_p) = yy_cp;
2416 }
2368 if ( c == '\n' )
2369 --yylineno;
2370
2371 yytext_ptr = yy_bp;
2372 yy_hold_char = *yy_cp;
2373 yy_c_buf_p = yy_cp;
2374 }
2375 #endif /* ifndef YY_NO_UNPUT */
2376
24172377
24182378 #ifndef YY_NO_INPUT
24192379 #ifdef __cplusplus
2420 static int yyinput (void)
2421 #else
2422 static int input (void)
2423 #endif
2424
2425 {
2380 static int yyinput()
2381 #else
2382 static int input()
2383 #endif
2384 {
24262385 int c;
2427
2428 *(yy_c_buf_p) = (yy_hold_char);
2429
2430 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2386
2387 *yy_c_buf_p = yy_hold_char;
2388
2389 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
24312390 {
24322391 /* yy_c_buf_p now points to the character we want to return.
24332392 * If this occurs *before* the EOB characters, then it's a
24342393 * valid NUL; if not, then we've hit the end of the buffer.
24352394 */
2436 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2395 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
24372396 /* This was really a NUL. */
2438 *(yy_c_buf_p) = '\0';
2397 *yy_c_buf_p = '\0';
24392398
24402399 else
24412400 { /* need more input */
2442 int offset = (yy_c_buf_p) - (yytext_ptr);
2443 ++(yy_c_buf_p);
2444
2445 switch ( yy_get_next_buffer( ) )
2401 int offset = yy_c_buf_p - yytext_ptr;
2402 ++yy_c_buf_p;
2403
2404 switch ( yy_get_next_buffer() )
24462405 {
24472406 case EOB_ACT_LAST_MATCH:
24482407 /* This happens because yy_g_n_b()
24562415 */
24572416
24582417 /* Reset buffer status. */
2459 llvmAsmrestart(llvmAsmin );
2460
2461 /*FALLTHROUGH*/
2418 yyrestart( yyin );
2419
2420 /* fall through */
24622421
24632422 case EOB_ACT_END_OF_FILE:
24642423 {
2465 if ( llvmAsmwrap( ) )
2424 if ( yywrap() )
24662425 return EOF;
24672426
2468 if ( ! (yy_did_buffer_switch_on_eof) )
2427 if ( ! yy_did_buffer_switch_on_eof )
24692428 YY_NEW_FILE;
24702429 #ifdef __cplusplus
24712430 return yyinput();
24752434 }
24762435
24772436 case EOB_ACT_CONTINUE_SCAN:
2478 (yy_c_buf_p) = (yytext_ptr) + offset;
2437 yy_c_buf_p = yytext_ptr + offset;
24792438 break;
24802439 }
24812440 }
24822441 }
24832442
2484 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
2485 *(yy_c_buf_p) = '\0'; /* preserve llvmAsmtext */
2486 (yy_hold_char) = *++(yy_c_buf_p);
2443 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
2444 *yy_c_buf_p = '\0'; /* preserve yytext */
2445 yy_hold_char = *++yy_c_buf_p;
24872446
24882447 if ( c == '\n' )
2489
2490 llvmAsmlineno++;
2491 ;
2448 ++yylineno;
24922449
24932450 return c;
2494 }
2495 #endif /* ifndef YY_NO_INPUT */
2496
2497 /** Immediately switch to a different input stream.
2498 * @param input_file A readable stream.
2499 *
2500 * @note This function does not reset the start condition to @c INITIAL .
2501 */
2502 void llvmAsmrestart (FILE * input_file )
2503 {
2504
2505 if ( ! YY_CURRENT_BUFFER ){
2506 llvmAsmensure_buffer_stack ();
2507 YY_CURRENT_BUFFER_LVALUE =
2508 llvmAsm_create_buffer(llvmAsmin,YY_BUF_SIZE );
25092451 }
2510
2511 llvmAsm_init_buffer(YY_CURRENT_BUFFER,input_file );
2512 llvmAsm_load_buffer_state( );
2513 }
2514
2515 /** Switch to a different input buffer.
2516 * @param new_buffer The new input buffer.
2517 *
2518 */
2519 void llvmAsm_switch_to_buffer (YY_BUFFER_STATE new_buffer )
2520 {
2521
2522 /* TODO. We should be able to replace this entire function body
2523 * with
2524 * llvmAsmpop_buffer_state();
2525 * llvmAsmpush_buffer_state(new_buffer);
2526 */
2527 llvmAsmensure_buffer_stack ();
2528 if ( YY_CURRENT_BUFFER == new_buffer )
2452 #endif /* YY_NO_INPUT */
2453
2454 #ifdef YY_USE_PROTOS
2455 void yyrestart( FILE *input_file )
2456 #else
2457 void yyrestart( input_file )
2458 FILE *input_file;
2459 #endif
2460 {
2461 if ( ! yy_current_buffer )
2462 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2463
2464 yy_init_buffer( yy_current_buffer, input_file );
2465 yy_load_buffer_state();
2466 }
2467
2468
2469 #ifdef YY_USE_PROTOS
2470 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2471 #else
2472 void yy_switch_to_buffer( new_buffer )
2473 YY_BUFFER_STATE new_buffer;
2474 #endif
2475 {
2476 if ( yy_current_buffer == new_buffer )
25292477 return;
25302478
2531 if ( YY_CURRENT_BUFFER )
2479 if ( yy_current_buffer )
25322480 {
25332481 /* Flush out information for old buffer. */
2534 *(yy_c_buf_p) = (yy_hold_char);
2535 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2536 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2482 *yy_c_buf_p = yy_hold_char;
2483 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2484 yy_current_buffer->yy_n_chars = yy_n_chars;
25372485 }
25382486
2539 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2540 llvmAsm_load_buffer_state( );
2487 yy_current_buffer = new_buffer;
2488 yy_load_buffer_state();
25412489
25422490 /* We don't actually know whether we did this switch during
2543 * EOF (llvmAsmwrap()) processing, but the only time this flag
2544 * is looked at is after llvmAsmwrap() is called, so it's safe
2491 * EOF (yywrap()) processing, but the only time this flag
2492 * is looked at is after yywrap() is called, so it's safe
25452493 * to go ahead and always set it.
25462494 */
2547 (yy_did_buffer_switch_on_eof) = 1;
2548 }
2549
2550 static void llvmAsm_load_buffer_state (void)
2551 {
2552 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2553 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2554 llvmAsmin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2555 (yy_hold_char) = *(yy_c_buf_p);
2556 }
2557
2558 /** Allocate and initialize an input buffer state.
2559 * @param file A readable stream.
2560 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2561 *
2562 * @return the allocated buffer state.
2563 */
2564 YY_BUFFER_STATE llvmAsm_create_buffer (FILE * file, int size )
2565 {
2495 yy_did_buffer_switch_on_eof = 1;
2496 }
2497
2498
2499 #ifdef YY_USE_PROTOS
2500 void yy_load_buffer_state( void )
2501 #else
2502 void yy_load_buffer_state()
2503 #endif
2504 {
2505 yy_n_chars = yy_current_buffer->yy_n_chars;
2506 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2507 yyin = yy_current_buffer->yy_input_file;
2508 yy_hold_char = *yy_c_buf_p;
2509 }
2510
2511
2512 #ifdef YY_USE_PROTOS
2513 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2514 #else
2515 YY_BUFFER_STATE yy_create_buffer( file, size )
2516 FILE *file;
2517 int size;
2518 #endif
2519 {
25662520 YY_BUFFER_STATE b;
2567
2568 b = (YY_BUFFER_STATE) llvmAsmalloc(sizeof( struct yy_buffer_state ) );
2521
2522 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
25692523 if ( ! b )
2570 YY_FATAL_ERROR( "out of dynamic memory in llvmAsm_create_buffer()" );
2524 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
25712525
25722526 b->yy_buf_size = size;
25732527
25742528 /* yy_ch_buf has to be 2 characters longer than the size given because
25752529 * we need to put in 2 end-of-buffer characters.
25762530 */
2577 b->yy_ch_buf = (char *) llvmAsmalloc(b->yy_buf_size + 2 );
2531 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
25782532 if ( ! b->yy_ch_buf )
2579 YY_FATAL_ERROR( "out of dynamic memory in llvmAsm_create_buffer()" );
2533 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
25802534
25812535 b->yy_is_our_buffer = 1;
25822536
2583 llvmAsm_init_buffer(b,file );
2537 yy_init_buffer( b, file );
25842538
25852539 return b;
2586 }
2587
2588 /** Destroy the buffer.
2589 * @param b a buffer created with llvmAsm_create_buffer()
2590 *
2591 */
2592 void llvmAsm_delete_buffer (YY_BUFFER_STATE b )
2593 {
2594
2540 }
2541
2542
2543 #ifdef YY_USE_PROTOS
2544 void yy_delete_buffer( YY_BUFFER_STATE b )
2545 #else
2546 void yy_delete_buffer( b )
2547 YY_BUFFER_STATE b;
2548 #endif
2549 {
25952550 if ( ! b )
25962551 return;
25972552
2598 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2599 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2553 if ( b == yy_current_buffer )
2554 yy_current_buffer = (YY_BUFFER_STATE) 0;
26002555
26012556 if ( b->yy_is_our_buffer )
2602 llvmAsmfree((void *) b->yy_ch_buf );
2603
2604 llvmAsmfree((void *) b );
2605 }
2606
2607 /* Initializes or reinitializes a buffer.
2608 * This function is sometimes called more than once on the same buffer,
2609 * such as during a llvmAsmrestart() or at EOF.
2610 */
2611 static void llvmAsm_init_buffer (YY_BUFFER_STATE b, FILE * file )
2612
2613 {
2614 int oerrno = errno;
2615
2616 llvmAsm_flush_buffer(b );
2557 yy_flex_free( (void *) b->yy_ch_buf );
2558
2559 yy_flex_free( (void *) b );
2560 }
2561
2562
2563
2564 #ifdef YY_USE_PROTOS
2565 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2566 #else
2567 void yy_init_buffer( b, file )
2568 YY_BUFFER_STATE b;
2569 FILE *file;
2570 #endif
2571
2572
2573 {
2574 yy_flush_buffer( b );
26172575
26182576 b->yy_input_file = file;
26192577 b->yy_fill_buffer = 1;
26202578
2621 /* If b is the current buffer, then llvmAsm_init_buffer was _probably_
2622 * called from llvmAsmrestart() or through yy_get_next_buffer.
2623 * In that case, we don't want to reset the lineno or column.
2624 */
2625 if (b != YY_CURRENT_BUFFER){
2626 b->yy_bs_lineno = 1;
2627 b->yy_bs_column = 0;
2628 }
2629
2630 b->yy_is_interactive = 0;
2631
2632 errno = oerrno;
2633 }
2634
2635 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2636 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2637 *
2638 */
2639 void llvmAsm_flush_buffer (YY_BUFFER_STATE b )
2640 {
2641 if ( ! b )
2579 #if YY_ALWAYS_INTERACTIVE
2580 b->yy_is_interactive = 1;
2581 #else
2582 #if YY_NEVER_INTERACTIVE
2583 b->yy_is_interactive = 0;
2584 #else
2585 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2586 #endif
2587 #endif
2588 }
2589
2590
2591 #ifdef YY_USE_PROTOS
2592 void yy_flush_buffer( YY_BUFFER_STATE b )
2593 #else
2594 void yy_flush_buffer( b )
2595 YY_BUFFER_STATE b;
2596 #endif
2597
2598 {
2599 if ( ! b )
26422600 return;
26432601
26442602 b->yy_n_chars = 0;
26552613 b->yy_at_bol = 1;
26562614 b->yy_buffer_status = YY_BUFFER_NEW;
26572615
2658 if ( b == YY_CURRENT_BUFFER )
2659 llvmAsm_load_buffer_state( );
2660 }
2661
2662 /** Pushes the new state onto the stack. The new state becomes
2663 * the current state. This function will allocate the stack
2664 * if necessary.
2665 * @param new_buffer The new state.
2666 *
2667 */
2668 void llvmAsmpush_buffer_state (YY_BUFFER_STATE new_buffer )
2669 {
2670 if (new_buffer == NULL)
2671 return;
2672
2673 llvmAsmensure_buffer_stack();
2674
2675 /* This block is copied from llvmAsm_switch_to_buffer. */
2676 if ( YY_CURRENT_BUFFER )
2677 {
2678 /* Flush out information for old buffer. */
2679 *(yy_c_buf_p) = (yy_hold_char);
2680 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2681 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2682 }
2683
2684 /* Only push if top exists. Otherwise, replace top. */
2685 if (YY_CURRENT_BUFFER)
2686 (yy_buffer_stack_top)++;
2687 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2688
2689 /* copied from llvmAsm_switch_to_buffer. */
2690 llvmAsm_load_buffer_state( );
2691 (yy_did_buffer_switch_on_eof) = 1;
2692 }
2693
2694 /** Removes and deletes the top of the stack, if present.
2695 * The next element becomes the new top.
2696 *
2697 */
2698 void llvmAsmpop_buffer_state (void)
2699 {
2700 if (!YY_CURRENT_BUFFER)
2701 return;
2702
2703 llvmAsm_delete_buffer(YY_CURRENT_BUFFER );
2704 YY_CURRENT_BUFFER_LVALUE = NULL;
2705 if ((yy_buffer_stack_top) > 0)
2706 --(yy_buffer_stack_top);
2707
2708 if (YY_CURRENT_BUFFER) {
2709 llvmAsm_load_buffer_state( );
2710 (yy_did_buffer_switch_on_eof) = 1;
2616 if ( b == yy_current_buffer )
2617 yy_load_buffer_state();
27112618 }
2712 }
2713
2714 /* Allocates the stack if it does not exist.
2715 * Guarantees space for at least one push.
2716 */
2717 static void llvmAsmensure_buffer_stack (void)
2718 {
2719 int num_to_alloc;
2720
2721 if (!(yy_buffer_stack)) {
2722
2723 /* First allocation is just for 2 elements, since we don't know if this
2724 * scanner will even need a stack. We use 2 instead of 1 to avoid an
2725 * immediate realloc on the next call.
2726 */
2727 num_to_alloc = 1;
2728 (yy_buffer_stack) = (struct yy_buffer_state**)llvmAsmalloc
2729 (num_to_alloc * sizeof(struct yy_buffer_state*)
2730 );
2731
2732 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2733
2734 (yy_buffer_stack_max) = num_to_alloc;
2735 (yy_buffer_stack_top) = 0;
2736 return;
2737 }
2738
2739 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2740
2741 /* Increase the buffer to prepare for a possible push. */
2742 int grow_size = 8 /* arbitrary grow size */;
2743
2744 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2745 (yy_buffer_stack) = (struct yy_buffer_state**)llvmAsmrealloc
2746 ((yy_buffer_stack),
2747 num_to_alloc * sizeof(struct yy_buffer_state*)
2748