From: Chris Lattner Date: Sun, 18 Nov 2007 08:46:26 +0000 (+0000) Subject: Replace the original flex lexer with a hand writen one. This X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=8e3a8e0452695643d04c21e15c94b802aef81bae;p=oota-llvm.git Replace the original flex lexer with a hand writen one. This drops a dependency on flex and lets us make future progress more easily. Yay for 2 fewer .cvs files to make silly conflicts with. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@44213 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/AsmParser/LLLexer.cpp b/lib/AsmParser/LLLexer.cpp new file mode 100644 index 00000000000..310ea5b052a --- /dev/null +++ b/lib/AsmParser/LLLexer.cpp @@ -0,0 +1,826 @@ +//===- LLLexer.cpp - Lexer for .ll Files ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by Chris Lattner and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// Implement the Lexer for .ll files. +// +//===----------------------------------------------------------------------===// + +#include "LLLexer.h" +#include "ParserInternals.h" +#include "llvm/Support/MemoryBuffer.h" + +#include +#include "llvmAsmParser.h" +using namespace llvm; + +//===----------------------------------------------------------------------===// +// Helper functions. +//===----------------------------------------------------------------------===// + +// atoull - Convert an ascii string of decimal digits into the unsigned long +// long representation... this does not have to do input error checking, +// because we know that the input will be matched by a suitable regex... +// +static uint64_t atoull(const char *Buffer, const char *End) { + uint64_t Result = 0; + for (; Buffer != End; Buffer++) { + uint64_t OldRes = Result; + Result *= 10; + Result += *Buffer-'0'; + if (Result < OldRes) { // Uh, oh, overflow detected!!! + GenerateError("constant bigger than 64 bits detected!"); + return 0; + } + } + return Result; +} + +static uint64_t HexIntToVal(const char *Buffer, const char *End) { + uint64_t Result = 0; + for (; Buffer != End; ++Buffer) { + uint64_t OldRes = Result; + Result *= 16; + char C = *Buffer; + if (C >= '0' && C <= '9') + Result += C-'0'; + else if (C >= 'A' && C <= 'F') + Result += C-'A'+10; + else if (C >= 'a' && C <= 'f') + Result += C-'a'+10; + + if (Result < OldRes) { // Uh, oh, overflow detected!!! + GenerateError("constant bigger than 64 bits detected!"); + return 0; + } + } + return Result; +} + +// HexToFP - Convert the ascii string in hexadecimal format to the floating +// point representation of it. +// +static double HexToFP(const char *Buffer, const char *End) { + return BitsToDouble(HexIntToVal(Buffer, End)); // Cast Hex constant to double +} + +static void HexToIntPair(const char *Buffer, const char *End, uint64_t Pair[2]){ + Pair[0] = 0; + for (int i=0; i<16; i++, Buffer++) { + assert(Buffer != End); + Pair[0] *= 16; + char C = *Buffer; + if (C >= '0' && C <= '9') + Pair[0] += C-'0'; + else if (C >= 'A' && C <= 'F') + Pair[0] += C-'A'+10; + else if (C >= 'a' && C <= 'f') + Pair[0] += C-'a'+10; + } + Pair[1] = 0; + for (int i=0; i<16 && Buffer != End; i++, Buffer++) { + Pair[1] *= 16; + char C = *Buffer; + if (C >= '0' && C <= '9') + Pair[1] += C-'0'; + else if (C >= 'A' && C <= 'F') + Pair[1] += C-'A'+10; + else if (C >= 'a' && C <= 'f') + Pair[1] += C-'a'+10; + } + if (*Buffer) + GenerateError("constant bigger than 128 bits detected!"); +} + +// UnEscapeLexed - Run through the specified buffer and change \xx codes to the +// appropriate character. +static void UnEscapeLexed(std::string &Str) { + if (Str.empty()) return; + + char *Buffer = &Str[0], *EndBuffer = Buffer+Str.size(); + char *BOut = Buffer; + for (char *BIn = Buffer; BIn != EndBuffer; ) { + if (BIn[0] == '\\') { + if (BIn < EndBuffer-1 && BIn[1] == '\\') { + *BOut++ = '\\'; // Two \ becomes one + BIn += 2; + } else if (BIn < EndBuffer-2 && isxdigit(BIn[1]) && isxdigit(BIn[2])) { + char Tmp = BIn[3]; BIn[3] = 0; // Terminate string + *BOut = (char)strtol(BIn+1, 0, 16); // Convert to number + BIn[3] = Tmp; // Restore character + BIn += 3; // Skip over handled chars + ++BOut; + } else { + *BOut++ = *BIn++; + } + } else { + *BOut++ = *BIn++; + } + } + Str.resize(BOut-Buffer); +} + +/// isLabelChar - Return true for [-a-zA-Z$._0-9]. +static bool isLabelChar(char C) { + return isalnum(C) || C == '-' || C == '$' || C == '.' || C == '_'; +} + + +/// isLabelTail - Return true if this pointer points to a valid end of a label. +static const char *isLabelTail(const char *CurPtr) { + while (1) { + if (CurPtr[0] == ':') return CurPtr+1; + if (!isLabelChar(CurPtr[0])) return 0; + ++CurPtr; + } +} + + + +//===----------------------------------------------------------------------===// +// Lexer definition. +//===----------------------------------------------------------------------===// + +// FIXME: REMOVE THIS. +#define YYEOF 0 +#define YYERROR -2 + +LLLexer::LLLexer(MemoryBuffer *StartBuf) : CurLineNo(1), CurBuf(StartBuf) { + CurPtr = CurBuf->getBufferStart(); +} + +std::string LLLexer::getFilename() const { + return CurBuf->getBufferIdentifier(); +} + +int LLLexer::getNextChar() { + char CurChar = *CurPtr++; + switch (CurChar) { + default: return (unsigned char)CurChar; + case 0: + // A nul character in the stream is either the end of the current buffer or + // a random nul in the file. Disambiguate that here. + if (CurPtr-1 != CurBuf->getBufferEnd()) + return 0; // Just whitespace. + + // Otherwise, return end of file. + --CurPtr; // Another call to lex will return EOF again. + return EOF; + case '\n': + case '\r': + // Handle the newline character by ignoring it and incrementing the line + // count. However, be careful about 'dos style' files with \n\r in them. + // Only treat a \n\r or \r\n as a single line. + if ((*CurPtr == '\n' || (*CurPtr == '\r')) && + *CurPtr != CurChar) + ++CurPtr; // Eat the two char newline sequence. + + ++CurLineNo; + return '\n'; + } +} + + +int LLLexer::LexToken() { + TokStart = CurPtr; + + int CurChar = getNextChar(); + + switch (CurChar) { + default: + // Handle letters: [a-zA-Z_] + if (isalpha(CurChar) || CurChar == '_') + return LexIdentifier(); + + return CurChar; + case EOF: return YYEOF; + case 0: + case ' ': + case '\t': + case '\n': + case '\r': + // Ignore whitespace. + return LexToken(); + case '+': return LexPositive(); + case '@': return LexAt(); + case '%': return LexPercent(); + case '"': return LexQuote(); + case '.': + if (const char *Ptr = isLabelTail(CurPtr)) { + CurPtr = Ptr; + llvmAsmlval.StrVal = new std::string(TokStart, CurPtr-1); + return LABELSTR; + } + if (CurPtr[0] == '.' && CurPtr[1] == '.') { + CurPtr += 2; + return DOTDOTDOT; + } + return '.'; + case '$': + if (const char *Ptr = isLabelTail(CurPtr)) { + CurPtr = Ptr; + llvmAsmlval.StrVal = new std::string(TokStart, CurPtr-1); + return LABELSTR; + } + return '$'; + case ';': + SkipLineComment(); + return LexToken(); + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + case '-': + return LexDigitOrNegative(); + } +} + +void LLLexer::SkipLineComment() { + while (1) { + if (CurPtr[0] == '\n' || CurPtr[0] == '\r' || getNextChar() == EOF) + return; + } +} + +/// LexAt - Lex all tokens that start with an @ character: +/// AtStringConstant @\"[^\"]*\" +/// GlobalVarName @[-a-zA-Z$._][-a-zA-Z$._0-9]* +/// GlobalVarID @[0-9]+ +int LLLexer::LexAt() { + // Handle AtStringConstant: @\"[^\"]*\" + if (CurPtr[0] == '"') { + ++CurPtr; + + while (1) { + int CurChar = getNextChar(); + + if (CurChar == EOF) { + GenerateError("End of file in global variable name"); + return YYERROR; + } + if (CurChar == '"') { + llvmAsmlval.StrVal = new std::string(TokStart+2, CurPtr-1); + UnEscapeLexed(*llvmAsmlval.StrVal); + return ATSTRINGCONSTANT; + } + } + } + + // Handle GlobalVarName: @[-a-zA-Z$._][-a-zA-Z$._0-9]* + if (isalpha(CurPtr[0]) || CurPtr[0] == '-' || CurPtr[0] == '$' || + CurPtr[0] == '.' || CurPtr[0] == '_') { + ++CurPtr; + while (isalnum(CurPtr[0]) || CurPtr[0] == '-' || CurPtr[0] == '$' || + CurPtr[0] == '.' || CurPtr[0] == '_') + ++CurPtr; + + llvmAsmlval.StrVal = new std::string(TokStart+1, CurPtr); // Skip @ + return GLOBALVAR; + } + + // Handle GlobalVarID: @[0-9]+ + if (isdigit(CurPtr[0])) { + for (++CurPtr; isdigit(CurPtr[0]); ++CurPtr); + + uint64_t Val = atoull(TokStart+1, CurPtr); + if ((unsigned)Val != Val) + GenerateError("Invalid value number (too large)!"); + llvmAsmlval.UIntVal = unsigned(Val); + return GLOBALVAL_ID; + } + + return '@'; +} + + +/// LexPercent - Lex all tokens that start with a % character: +/// PctStringConstant %\"[^\"]*\" +/// LocalVarName %[-a-zA-Z$._][-a-zA-Z$._0-9]* +/// LocalVarID %[0-9]+ +int LLLexer::LexPercent() { + // Handle PctStringConstant: %\"[^\"]*\" + if (CurPtr[0] == '"') { + ++CurPtr; + + while (1) { + int CurChar = getNextChar(); + + if (CurChar == EOF) { + GenerateError("End of file in local variable name"); + return YYERROR; + } + if (CurChar == '"') { + llvmAsmlval.StrVal = new std::string(TokStart+2, CurPtr-1); + UnEscapeLexed(*llvmAsmlval.StrVal); + return PCTSTRINGCONSTANT; + } + } + } + + // Handle LocalVarName: %[-a-zA-Z$._][-a-zA-Z$._0-9]* + if (isalpha(CurPtr[0]) || CurPtr[0] == '-' || CurPtr[0] == '$' || + CurPtr[0] == '.' || CurPtr[0] == '_') { + ++CurPtr; + while (isalnum(CurPtr[0]) || CurPtr[0] == '-' || CurPtr[0] == '$' || + CurPtr[0] == '.' || CurPtr[0] == '_') + ++CurPtr; + + llvmAsmlval.StrVal = new std::string(TokStart+1, CurPtr); // Skip % + return LOCALVAR; + } + + // Handle LocalVarID: %[0-9]+ + if (isdigit(CurPtr[0])) { + for (++CurPtr; isdigit(CurPtr[0]); ++CurPtr); + + uint64_t Val = atoull(TokStart+1, CurPtr); + if ((unsigned)Val != Val) + GenerateError("Invalid value number (too large)!"); + llvmAsmlval.UIntVal = unsigned(Val); + return LOCALVAL_ID; + } + + return '%'; +} + +/// LexQuote - Lex all tokens that start with a " character: +/// QuoteLabel "[^"]+": +/// StringConstant "[^"]*" +int LLLexer::LexQuote() { + while (1) { + int CurChar = getNextChar(); + + if (CurChar == EOF) { + GenerateError("End of file in quoted string"); + return YYERROR; + } + + if (CurChar != '"') continue; + + if (CurPtr[0] != ':') { + llvmAsmlval.StrVal = new std::string(TokStart+1, CurPtr-1); + UnEscapeLexed(*llvmAsmlval.StrVal); + return STRINGCONSTANT; + } + + ++CurPtr; + llvmAsmlval.StrVal = new std::string(TokStart+1, CurPtr-2); + UnEscapeLexed(*llvmAsmlval.StrVal); + return LABELSTR; + } +} + +static bool JustWhitespaceNewLine(const char *&Ptr) { + const char *ThisPtr = Ptr; + while (*ThisPtr == ' ' || *ThisPtr == '\t') + ++ThisPtr; + if (*ThisPtr == '\n' || *ThisPtr == '\r') { + Ptr = ThisPtr; + return true; + } + return false; +} + + +/// LexIdentifier: Handle several related productions: +/// Label [-a-zA-Z$._0-9]+: +/// IntegerType i[0-9]+ +/// Keyword sdiv, float, ... +/// HexIntConstant [us]0x[0-9A-Fa-f]+ +int LLLexer::LexIdentifier() { + const char *StartChar = CurPtr; + const char *IntEnd = CurPtr[-1] == 'i' ? 0 : StartChar; + const char *KeywordEnd = 0; + + for (; isLabelChar(*CurPtr); ++CurPtr) { + // If we decide this is an integer, remember the end of the sequence. + if (!IntEnd && !isdigit(*CurPtr)) IntEnd = CurPtr; + if (!KeywordEnd && !isalnum(*CurPtr) && *CurPtr != '_') KeywordEnd = CurPtr; + } + + // If we stopped due to a colon, this really is a label. + if (*CurPtr == ':') { + llvmAsmlval.StrVal = new std::string(StartChar-1, CurPtr++); + return LABELSTR; + } + + // Otherwise, this wasn't a label. If this was valid as an integer type, + // return it. + if (IntEnd == 0) IntEnd = CurPtr; + if (IntEnd != StartChar) { + CurPtr = IntEnd; + uint64_t NumBits = atoull(StartChar, CurPtr); + if (NumBits < IntegerType::MIN_INT_BITS || + NumBits > IntegerType::MAX_INT_BITS) { + GenerateError("Bitwidth for integer type out of range!"); + return YYERROR; + } + const Type* Ty = IntegerType::get(NumBits); + llvmAsmlval.PrimType = Ty; + return INTTYPE; + } + + // Otherwise, this was a letter sequence. See which keyword this is. + if (KeywordEnd == 0) KeywordEnd = CurPtr; + CurPtr = KeywordEnd; + --StartChar; + unsigned Len = CurPtr-StartChar; +#define KEYWORD(STR, TOK) \ + if (Len == strlen(STR) && !memcmp(StartChar, STR, strlen(STR))) return TOK; + + KEYWORD("begin", BEGINTOK); + KEYWORD("end", ENDTOK); + KEYWORD("true", TRUETOK); + KEYWORD("false", FALSETOK); + KEYWORD("declare", DECLARE); + KEYWORD("define", DEFINE); + KEYWORD("global", GLOBAL); + KEYWORD("constant", CONSTANT); + + KEYWORD("internal", INTERNAL); + KEYWORD("linkonce", LINKONCE); + KEYWORD("weak", WEAK); + KEYWORD("appending", APPENDING); + KEYWORD("dllimport", DLLIMPORT); + KEYWORD("dllexport", DLLEXPORT); + KEYWORD("hidden", HIDDEN); + KEYWORD("protected", PROTECTED); + KEYWORD("extern_weak", EXTERN_WEAK); + KEYWORD("external", EXTERNAL); + KEYWORD("thread_local", THREAD_LOCAL); + KEYWORD("zeroinitializer", ZEROINITIALIZER); + KEYWORD("undef", UNDEF); + KEYWORD("null", NULL_TOK); + KEYWORD("to", TO); + KEYWORD("tail", TAIL); + KEYWORD("target", TARGET); + KEYWORD("triple", TRIPLE); + KEYWORD("deplibs", DEPLIBS); + KEYWORD("datalayout", DATALAYOUT); + KEYWORD("volatile", VOLATILE); + KEYWORD("align", ALIGN); + KEYWORD("section", SECTION); + KEYWORD("alias", ALIAS); + KEYWORD("module", MODULE); + KEYWORD("asm", ASM_TOK); + KEYWORD("sideeffect", SIDEEFFECT); + + KEYWORD("cc", CC_TOK); + KEYWORD("ccc", CCC_TOK); + KEYWORD("fastcc", FASTCC_TOK); + KEYWORD("coldcc", COLDCC_TOK); + KEYWORD("x86_stdcallcc", X86_STDCALLCC_TOK); + KEYWORD("x86_fastcallcc", X86_FASTCALLCC_TOK); + + KEYWORD("signext", SIGNEXT); + KEYWORD("zeroext", ZEROEXT); + KEYWORD("inreg", INREG); + KEYWORD("sret", SRET); + KEYWORD("nounwind", NOUNWIND); + KEYWORD("noreturn", NORETURN); + KEYWORD("noalias", NOALIAS); + KEYWORD("byval", BYVAL); + KEYWORD("nest", NEST); + KEYWORD("pure", PURE); + KEYWORD("const", CONST); + + KEYWORD("type", TYPE); + KEYWORD("opaque", OPAQUE); + + KEYWORD("eq" , EQ); + KEYWORD("ne" , NE); + KEYWORD("slt", SLT); + KEYWORD("sgt", SGT); + KEYWORD("sle", SLE); + KEYWORD("sge", SGE); + KEYWORD("ult", ULT); + KEYWORD("ugt", UGT); + KEYWORD("ule", ULE); + KEYWORD("uge", UGE); + KEYWORD("oeq", OEQ); + KEYWORD("one", ONE); + KEYWORD("olt", OLT); + KEYWORD("ogt", OGT); + KEYWORD("ole", OLE); + KEYWORD("oge", OGE); + KEYWORD("ord", ORD); + KEYWORD("uno", UNO); + KEYWORD("ueq", UEQ); + KEYWORD("une", UNE); +#undef KEYWORD + + // Keywords for types. +#define TYPEKEYWORD(STR, LLVMTY, TOK) \ + if (Len == strlen(STR) && !memcmp(StartChar, STR, strlen(STR))) { \ + llvmAsmlval.PrimType = LLVMTY; return TOK; } + TYPEKEYWORD("void", Type::VoidTy, VOID); + TYPEKEYWORD("float", Type::FloatTy, FLOAT); + TYPEKEYWORD("double", Type::DoubleTy, DOUBLE); + TYPEKEYWORD("x86_fp80", Type::X86_FP80Ty, X86_FP80); + TYPEKEYWORD("fp128", Type::FP128Ty, FP128); + TYPEKEYWORD("ppc_fp128", Type::PPC_FP128Ty, PPC_FP128); + TYPEKEYWORD("label", Type::LabelTy, LABEL); +#undef TYPEKEYWORD + + // Handle special forms for autoupgrading. Drop these in LLVM 3.0. This is + // to avoid conflicting with the sext/zext instructions, below. + if (Len == 4 && !memcmp(StartChar, "sext", 4)) { + // Scan CurPtr ahead, seeing if there is just whitespace before the newline. + if (JustWhitespaceNewLine(CurPtr)) + return SIGNEXT; + } else if (Len == 4 && !memcmp(StartChar, "zext", 4)) { + // Scan CurPtr ahead, seeing if there is just whitespace before the newline. + if (JustWhitespaceNewLine(CurPtr)) + return ZEROEXT; + } + + // Keywords for instructions. +#define INSTKEYWORD(STR, type, Enum, TOK) \ + if (Len == strlen(STR) && !memcmp(StartChar, STR, strlen(STR))) { \ + llvmAsmlval.type = Instruction::Enum; return TOK; } + + INSTKEYWORD("add", BinaryOpVal, Add, ADD); + INSTKEYWORD("sub", BinaryOpVal, Sub, SUB); + INSTKEYWORD("mul", BinaryOpVal, Mul, MUL); + INSTKEYWORD("udiv", BinaryOpVal, UDiv, UDIV); + INSTKEYWORD("sdiv", BinaryOpVal, SDiv, SDIV); + INSTKEYWORD("fdiv", BinaryOpVal, FDiv, FDIV); + INSTKEYWORD("urem", BinaryOpVal, URem, UREM); + INSTKEYWORD("srem", BinaryOpVal, SRem, SREM); + INSTKEYWORD("frem", BinaryOpVal, FRem, FREM); + INSTKEYWORD("shl", BinaryOpVal, Shl, SHL); + INSTKEYWORD("lshr", BinaryOpVal, LShr, LSHR); + INSTKEYWORD("ashr", BinaryOpVal, AShr, ASHR); + INSTKEYWORD("and", BinaryOpVal, And, AND); + INSTKEYWORD("or", BinaryOpVal, Or , OR ); + INSTKEYWORD("xor", BinaryOpVal, Xor, XOR); + INSTKEYWORD("icmp", OtherOpVal, ICmp, ICMP); + INSTKEYWORD("fcmp", OtherOpVal, FCmp, FCMP); + + INSTKEYWORD("phi", OtherOpVal, PHI, PHI_TOK); + INSTKEYWORD("call", OtherOpVal, Call, CALL); + INSTKEYWORD("trunc", CastOpVal, Trunc, TRUNC); + INSTKEYWORD("zext", CastOpVal, ZExt, ZEXT); + INSTKEYWORD("sext", CastOpVal, SExt, SEXT); + INSTKEYWORD("fptrunc", CastOpVal, FPTrunc, FPTRUNC); + INSTKEYWORD("fpext", CastOpVal, FPExt, FPEXT); + INSTKEYWORD("uitofp", CastOpVal, UIToFP, UITOFP); + INSTKEYWORD("sitofp", CastOpVal, SIToFP, SITOFP); + INSTKEYWORD("fptoui", CastOpVal, FPToUI, FPTOUI); + INSTKEYWORD("fptosi", CastOpVal, FPToSI, FPTOSI); + INSTKEYWORD("inttoptr", CastOpVal, IntToPtr, INTTOPTR); + INSTKEYWORD("ptrtoint", CastOpVal, PtrToInt, PTRTOINT); + INSTKEYWORD("bitcast", CastOpVal, BitCast, BITCAST); + INSTKEYWORD("select", OtherOpVal, Select, SELECT); + INSTKEYWORD("va_arg", OtherOpVal, VAArg , VAARG); + INSTKEYWORD("ret", TermOpVal, Ret, RET); + INSTKEYWORD("br", TermOpVal, Br, BR); + INSTKEYWORD("switch", TermOpVal, Switch, SWITCH); + INSTKEYWORD("invoke", TermOpVal, Invoke, INVOKE); + INSTKEYWORD("unwind", TermOpVal, Unwind, UNWIND); + INSTKEYWORD("unreachable", TermOpVal, Unreachable, UNREACHABLE); + + INSTKEYWORD("malloc", MemOpVal, Malloc, MALLOC); + INSTKEYWORD("alloca", MemOpVal, Alloca, ALLOCA); + INSTKEYWORD("free", MemOpVal, Free, FREE); + INSTKEYWORD("load", MemOpVal, Load, LOAD); + INSTKEYWORD("store", MemOpVal, Store, STORE); + INSTKEYWORD("getelementptr", MemOpVal, GetElementPtr, GETELEMENTPTR); + + INSTKEYWORD("extractelement", OtherOpVal, ExtractElement, EXTRACTELEMENT); + INSTKEYWORD("insertelement", OtherOpVal, InsertElement, INSERTELEMENT); + INSTKEYWORD("shufflevector", OtherOpVal, ShuffleVector, SHUFFLEVECTOR); +#undef INSTKEYWORD + + // Check for [us]0x[0-9A-Fa-f]+ which are Hexadecimal constant generated by + // the CFE to avoid forcing it to deal with 64-bit numbers. + if ((TokStart[0] == 'u' || TokStart[0] == 's') && + TokStart[1] == '0' && TokStart[2] == 'x' && isxdigit(TokStart[3])) { + int len = CurPtr-TokStart-3; + uint32_t bits = len * 4; + APInt Tmp(bits, TokStart+3, len, 16); + uint32_t activeBits = Tmp.getActiveBits(); + if (activeBits > 0 && activeBits < bits) + Tmp.trunc(activeBits); + if (Tmp.getBitWidth() > 64) { + llvmAsmlval.APIntVal = new APInt(Tmp); + return TokStart[0] == 's' ? ESAPINTVAL : EUAPINTVAL; + } else if (TokStart[0] == 's') { + llvmAsmlval.SInt64Val = Tmp.getSExtValue(); + return ESINT64VAL; + } else { + llvmAsmlval.UInt64Val = Tmp.getZExtValue(); + return EUINT64VAL; + } + } + + // Finally, if this is "cc1234", return this as just "cc". + if (TokStart[0] == 'c' && TokStart[1] == 'c') { + CurPtr = TokStart+2; + return CC_TOK; + } + + // Finally, if this isn't known, return just a single character. + CurPtr = TokStart+1; + return TokStart[0]; +} + + +/// Lex0x: Handle productions that start with 0x, knowing that it matches and +/// that this is not a label: +/// HexFPConstant 0x[0-9A-Fa-f]+ +/// HexFP80Constant 0xK[0-9A-Fa-f]+ +/// HexFP128Constant 0xL[0-9A-Fa-f]+ +/// HexPPC128Constant 0xM[0-9A-Fa-f]+ +int LLLexer::Lex0x() { + CurPtr = TokStart + 2; + + char Kind; + if (CurPtr[0] >= 'K' && CurPtr[0] <= 'M') { + Kind = *CurPtr++; + } else { + Kind = 'J'; + } + + if (!isxdigit(CurPtr[0])) { + // Bad token, return it as just zero. + CurPtr = TokStart+1; + return '0'; + } + + while (isxdigit(CurPtr[0])) + ++CurPtr; + + if (Kind == 'J') { + // HexFPConstant - Floating point constant represented in IEEE format as a + // hexadecimal number for when exponential notation is not precise enough. + // Float and double only. + llvmAsmlval.FPVal = new APFloat(HexToFP(TokStart+2, CurPtr)); + return FPVAL; + } + + uint64_t Pair[2]; + HexToIntPair(TokStart+3, CurPtr, Pair); + switch (Kind) { + default: assert(0 && "Unknown kind!"); + case 'K': + // F80HexFPConstant - x87 long double in hexadecimal format (10 bytes) + llvmAsmlval.FPVal = new APFloat(APInt(80, 2, Pair)); + return FPVAL; + case 'L': + // F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes) + llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair), true); + return FPVAL; + case 'M': + // PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes) + llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair)); + return FPVAL; + } +} + +/// LexIdentifier: Handle several related productions: +/// Label [-a-zA-Z$._0-9]+: +/// NInteger -[0-9]+ +/// FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)? +/// PInteger [0-9]+ +/// HexFPConstant 0x[0-9A-Fa-f]+ +/// HexFP80Constant 0xK[0-9A-Fa-f]+ +/// HexFP128Constant 0xL[0-9A-Fa-f]+ +/// HexPPC128Constant 0xM[0-9A-Fa-f]+ +int LLLexer::LexDigitOrNegative() { + // If the letter after the negative is a number, this is probably a label. + if (!isdigit(TokStart[0]) && !isdigit(CurPtr[0])) { + // Okay, this is not a number after the -, it's probably a label. + if (const char *End = isLabelTail(CurPtr)) { + llvmAsmlval.StrVal = new std::string(TokStart, End-1); + CurPtr = End; + return LABELSTR; + } + + return CurPtr[-1]; + } + + // At this point, it is either a label, int or fp constant. + + // Skip digits, we have at least one. + for (; isdigit(CurPtr[0]); ++CurPtr); + + // Check to see if this really is a label afterall, e.g. "-1:". + if (isLabelChar(CurPtr[0]) || CurPtr[0] == ':') { + if (const char *End = isLabelTail(CurPtr)) { + llvmAsmlval.StrVal = new std::string(TokStart, End-1); + CurPtr = End; + return LABELSTR; + } + } + + // If the next character is a '.', then it is a fp value, otherwise its + // integer. + if (CurPtr[0] != '.') { + if (TokStart[0] == '0' && TokStart[1] == 'x') + return Lex0x(); + unsigned Len = CurPtr-TokStart; + uint32_t numBits = ((Len * 64) / 19) + 2; + APInt Tmp(numBits, TokStart, Len, 10); + if (TokStart[0] == '-') { + uint32_t minBits = Tmp.getMinSignedBits(); + if (minBits > 0 && minBits < numBits) + Tmp.trunc(minBits); + if (Tmp.getBitWidth() > 64) { + llvmAsmlval.APIntVal = new APInt(Tmp); + return ESAPINTVAL; + } else { + llvmAsmlval.SInt64Val = Tmp.getSExtValue(); + return ESINT64VAL; + } + } else { + uint32_t activeBits = Tmp.getActiveBits(); + if (activeBits > 0 && activeBits < numBits) + Tmp.trunc(activeBits); + if (Tmp.getBitWidth() > 64) { + llvmAsmlval.APIntVal = new APInt(Tmp); + return EUAPINTVAL; + } else { + llvmAsmlval.UInt64Val = Tmp.getZExtValue(); + return EUINT64VAL; + } + } + } + + ++CurPtr; + + // Skip over [0-9]*([eE][-+]?[0-9]+)? + while (isdigit(CurPtr[0])) ++CurPtr; + + if (CurPtr[0] == 'e' || CurPtr[0] == 'E') { + if (isdigit(CurPtr[1]) || + ((CurPtr[1] == '-' || CurPtr[1] == '+') && isdigit(CurPtr[2]))) { + CurPtr += 2; + while (isdigit(CurPtr[0])) ++CurPtr; + } + } + + llvmAsmlval.FPVal = new APFloat(atof(TokStart)); + return FPVAL; +} + +/// FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)? +int LLLexer::LexPositive() { + // If the letter after the negative is a number, this is probably not a + // label. + if (!isdigit(CurPtr[0])) + return CurPtr[-1]; + + // Skip digits. + for (++CurPtr; isdigit(CurPtr[0]); ++CurPtr); + + // At this point, we need a '.'. + if (CurPtr[0] != '.') { + CurPtr = TokStart+1; + return TokStart[0]; + } + + ++CurPtr; + + // Skip over [0-9]*([eE][-+]?[0-9]+)? + while (isdigit(CurPtr[0])) ++CurPtr; + + if (CurPtr[0] == 'e' || CurPtr[0] == 'E') { + if (isdigit(CurPtr[1]) || + ((CurPtr[1] == '-' || CurPtr[1] == '+') && isdigit(CurPtr[2]))) { + CurPtr += 2; + while (isdigit(CurPtr[0])) ++CurPtr; + } + } + + llvmAsmlval.FPVal = new APFloat(atof(TokStart)); + return FPVAL; +} + + +//===----------------------------------------------------------------------===// +// Define the interface to this file. +//===----------------------------------------------------------------------===// + +static LLLexer *TheLexer; + +void InitLLLexer(llvm::MemoryBuffer *MB) { + assert(TheLexer == 0 && "LL Lexer isn't reentrant yet"); + TheLexer = new LLLexer(MB); +} + +int llvmAsmlex() { + return TheLexer->LexToken(); +} +const char *LLLgetTokenStart() { return TheLexer->getTokStart(); } +unsigned LLLgetTokenLength() { return TheLexer->getTokLength(); } +std::string LLLgetFilename() { return TheLexer->getFilename(); } +unsigned LLLgetLineNo() { return TheLexer->getLineNo(); } + +void FreeLexer() { + delete TheLexer; + TheLexer = 0; +} diff --git a/lib/AsmParser/LLLexer.h b/lib/AsmParser/LLLexer.h new file mode 100644 index 00000000000..eaf32203bbf --- /dev/null +++ b/lib/AsmParser/LLLexer.h @@ -0,0 +1,57 @@ +//===- LLLexer.h - Lexer for LLVM Assembly Files ----------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by Chris Lattner and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This class represents the Lexer for .ll files. +// +//===----------------------------------------------------------------------===// + +#ifndef LIB_ASMPARSER_LLLEXER_H +#define LIB_ASMPARSER_LLLEXER_H + +#include +#include +#include + +namespace llvm { + class MemoryBuffer; + + class LLLexer { + const char *CurPtr; + unsigned CurLineNo; + MemoryBuffer *CurBuf; + + const char *TokStart; + + std::string TheError; + public: + LLLexer(MemoryBuffer *StartBuf); + ~LLLexer() {} + + const char *getTokStart() const { return TokStart; } + unsigned getTokLength() const { return CurPtr-TokStart; } + unsigned getLineNo() const { return CurLineNo; } + std::string getFilename() const; + int LexToken(); + + const std::string getError() const { return TheError; } + + private: + int getNextChar(); + void SkipLineComment(); + int LexIdentifier(); + int LexDigitOrNegative(); + int LexPositive(); + int LexAt(); + int LexPercent(); + int LexQuote(); + int Lex0x(); + }; +} // end namespace llvm + +#endif diff --git a/lib/AsmParser/Lexer.cpp.cvs b/lib/AsmParser/Lexer.cpp.cvs deleted file mode 100644 index 4522aa84c37..00000000000 --- a/lib/AsmParser/Lexer.cpp.cvs +++ /dev/null @@ -1,3310 +0,0 @@ -#line 2 "Lexer.cpp" - -#line 4 "Lexer.cpp" - -#define YY_INT_ALIGNED short int - -/* A lexical scanner generated by flex */ - -#define FLEX_SCANNER -#define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 33 -#if YY_FLEX_SUBMINOR_VERSION > 0 -#define FLEX_BETA -#endif - -/* First, we deal with platform-specific or compiler-specific issues. */ - -/* begin standard C headers. */ -#include -#include -#include -#include - -/* end standard C headers. */ - -/* flex integer type definitions */ - -#ifndef FLEXINT_H -#define FLEXINT_H - -/* C99 systems have . Non-C99 systems may or may not. */ - -#if __STDC_VERSION__ >= 199901L - -/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. - */ -#ifndef __STDC_LIMIT_MACROS -#define __STDC_LIMIT_MACROS 1 -#endif - -#include -typedef int8_t flex_int8_t; -typedef uint8_t flex_uint8_t; -typedef int16_t flex_int16_t; -typedef uint16_t flex_uint16_t; -typedef int32_t flex_int32_t; -typedef uint32_t flex_uint32_t; -#else -typedef signed char flex_int8_t; -typedef short int flex_int16_t; -typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; -typedef unsigned short int flex_uint16_t; -typedef unsigned int flex_uint32_t; -#endif /* ! C99 */ - -/* Limits of integral types. */ -#ifndef INT8_MIN -#define INT8_MIN (-128) -#endif -#ifndef INT16_MIN -#define INT16_MIN (-32767-1) -#endif -#ifndef INT32_MIN -#define INT32_MIN (-2147483647-1) -#endif -#ifndef INT8_MAX -#define INT8_MAX (127) -#endif -#ifndef INT16_MAX -#define INT16_MAX (32767) -#endif -#ifndef INT32_MAX -#define INT32_MAX (2147483647) -#endif -#ifndef UINT8_MAX -#define UINT8_MAX (255U) -#endif -#ifndef UINT16_MAX -#define UINT16_MAX (65535U) -#endif -#ifndef UINT32_MAX -#define UINT32_MAX (4294967295U) -#endif - -#endif /* ! FLEXINT_H */ - -#ifdef __cplusplus - -/* The "const" storage-class-modifier is valid. */ -#define YY_USE_CONST - -#else /* ! __cplusplus */ - -#if __STDC__ - -#define YY_USE_CONST - -#endif /* __STDC__ */ -#endif /* ! __cplusplus */ - -#ifdef YY_USE_CONST -#define yyconst const -#else -#define yyconst -#endif - -/* Returned upon end-of-file. */ -#define YY_NULL 0 - -/* Promotes a possibly negative, possibly signed char to an unsigned - * integer for use as an array index. If the signed char is negative, - * we want to instead treat it as an 8-bit unsigned char, hence the - * double cast. - */ -#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) - -/* Enter a start condition. This macro really ought to take a parameter, - * but we do it the disgusting crufty way forced on us by the ()-less - * definition of BEGIN. - */ -#define BEGIN (yy_start) = 1 + 2 * - -/* Translate the current start state into a value that can be later handed - * to BEGIN to return to the state. The YYSTATE alias is for lex - * compatibility. - */ -#define YY_START (((yy_start) - 1) / 2) -#define YYSTATE YY_START - -/* Action number for EOF rule of a given start state. */ -#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) - -/* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE llvmAsmrestart(llvmAsmin ) - -#define YY_END_OF_BUFFER_CHAR 0 - -/* Size of default input buffer. */ -#ifndef YY_BUF_SIZE -#define YY_BUF_SIZE (16384*64) -#endif - -/* The state buf must be large enough to hold one state per character in the main buffer. - */ -#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) - -#ifndef YY_TYPEDEF_YY_BUFFER_STATE -#define YY_TYPEDEF_YY_BUFFER_STATE -typedef struct yy_buffer_state *YY_BUFFER_STATE; -#endif - -extern int llvmAsmleng; - -extern FILE *llvmAsmin, *llvmAsmout; - -#define EOB_ACT_CONTINUE_SCAN 0 -#define EOB_ACT_END_OF_FILE 1 -#define EOB_ACT_LAST_MATCH 2 - - /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires - * access to the local variable yy_act. Since yyless() is a macro, it would break - * existing scanners that call yyless() from OUTSIDE llvmAsmlex. - * One obvious solution it to make yy_act a global. I tried that, and saw - * a 5% performance hit in a non-llvmAsmlineno scanner, because yy_act is - * normally declared as a register variable-- so it is not worth it. - */ - #define YY_LESS_LINENO(n) \ - do { \ - int yyl;\ - for ( yyl = n; yyl < llvmAsmleng; ++yyl )\ - if ( llvmAsmtext[yyl] == '\n' )\ - --llvmAsmlineno;\ - }while(0) - -/* Return all but the first "n" matched characters back to the input stream. */ -#define yyless(n) \ - do \ - { \ - /* Undo effects of setting up llvmAsmtext. */ \ - int yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg);\ - *yy_cp = (yy_hold_char); \ - YY_RESTORE_YY_MORE_OFFSET \ - (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ - YY_DO_BEFORE_ACTION; /* set up llvmAsmtext again */ \ - } \ - while ( 0 ) - -#define unput(c) yyunput( c, (yytext_ptr) ) - -/* The following is because we cannot portably get our hands on size_t - * (without autoconf's help, which isn't available because we want - * flex-generated scanners to compile on their own). - */ - -#ifndef YY_TYPEDEF_YY_SIZE_T -#define YY_TYPEDEF_YY_SIZE_T -typedef unsigned int yy_size_t; -#endif - -#ifndef YY_STRUCT_YY_BUFFER_STATE -#define YY_STRUCT_YY_BUFFER_STATE -struct yy_buffer_state - { - FILE *yy_input_file; - - char *yy_ch_buf; /* input buffer */ - char *yy_buf_pos; /* current position in input buffer */ - - /* Size of input buffer in bytes, not including room for EOB - * characters. - */ - yy_size_t yy_buf_size; - - /* Number of characters read into yy_ch_buf, not including EOB - * characters. - */ - int yy_n_chars; - - /* Whether we "own" the buffer - i.e., we know we created it, - * and can realloc() it to grow it, and should free() it to - * delete it. - */ - int yy_is_our_buffer; - - /* Whether this is an "interactive" input source; if so, and - * if we're using stdio for input, then we want to use getc() - * instead of fread(), to make sure we stop fetching input after - * each newline. - */ - int yy_is_interactive; - - /* Whether we're considered to be at the beginning of a line. - * If so, '^' rules will be active on the next match, otherwise - * not. - */ - int yy_at_bol; - - int yy_bs_lineno; /**< The line count. */ - int yy_bs_column; /**< The column count. */ - - /* Whether to try to fill the input buffer when we reach the - * end of it. - */ - int yy_fill_buffer; - - int yy_buffer_status; - -#define YY_BUFFER_NEW 0 -#define YY_BUFFER_NORMAL 1 - /* When an EOF's been seen but there's still some text to process - * then we mark the buffer as YY_EOF_PENDING, to indicate that we - * shouldn't try reading from the input source any more. We might - * still have a bunch of tokens to match, though, because of - * possible backing-up. - * - * When we actually see the EOF, we change the status to "new" - * (via llvmAsmrestart()), so that the user can continue scanning by - * just pointing llvmAsmin at a new input file. - */ -#define YY_BUFFER_EOF_PENDING 2 - - }; -#endif /* !YY_STRUCT_YY_BUFFER_STATE */ - -/* Stack of input buffers. */ -static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ -static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ -static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ - -/* We provide macros for accessing buffer states in case in the - * future we want to put the buffer states in a more general - * "scanner state". - * - * Returns the top of the stack, or NULL. - */ -#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ - ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ - : NULL) - -/* Same as previous macro, but useful when we know that the buffer stack is not - * NULL or when we need an lvalue. For internal use only. - */ -#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] - -/* yy_hold_char holds the character lost when llvmAsmtext is formed. */ -static char yy_hold_char; -static int yy_n_chars; /* number of characters read into yy_ch_buf */ -int llvmAsmleng; - -/* Points to current character in buffer. */ -static char *yy_c_buf_p = (char *) 0; -static int yy_init = 0; /* whether we need to initialize */ -static int yy_start = 0; /* start state number */ - -/* Flag which is used to allow llvmAsmwrap()'s to do buffer switches - * instead of setting up a fresh llvmAsmin. A bit of a hack ... - */ -static int yy_did_buffer_switch_on_eof; - -void llvmAsmrestart (FILE *input_file ); -void llvmAsm_switch_to_buffer (YY_BUFFER_STATE new_buffer ); -YY_BUFFER_STATE llvmAsm_create_buffer (FILE *file,int size ); -void llvmAsm_delete_buffer (YY_BUFFER_STATE b ); -void llvmAsm_flush_buffer (YY_BUFFER_STATE b ); -void llvmAsmpush_buffer_state (YY_BUFFER_STATE new_buffer ); -void llvmAsmpop_buffer_state (void ); - -static void llvmAsmensure_buffer_stack (void ); -static void llvmAsm_load_buffer_state (void ); -static void llvmAsm_init_buffer (YY_BUFFER_STATE b,FILE *file ); - -#define YY_FLUSH_BUFFER llvmAsm_flush_buffer(YY_CURRENT_BUFFER ) - -YY_BUFFER_STATE llvmAsm_scan_buffer (char *base,yy_size_t size ); -YY_BUFFER_STATE llvmAsm_scan_string (yyconst char *yy_str ); -YY_BUFFER_STATE llvmAsm_scan_bytes (yyconst char *bytes,int len ); - -void *llvmAsmalloc (yy_size_t ); -void *llvmAsmrealloc (void *,yy_size_t ); -void llvmAsmfree (void * ); - -#define yy_new_buffer llvmAsm_create_buffer - -#define yy_set_interactive(is_interactive) \ - { \ - if ( ! YY_CURRENT_BUFFER ){ \ - llvmAsmensure_buffer_stack (); \ - YY_CURRENT_BUFFER_LVALUE = \ - llvmAsm_create_buffer(llvmAsmin,YY_BUF_SIZE ); \ - } \ - YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ - } - -#define yy_set_bol(at_bol) \ - { \ - if ( ! YY_CURRENT_BUFFER ){\ - llvmAsmensure_buffer_stack (); \ - YY_CURRENT_BUFFER_LVALUE = \ - llvmAsm_create_buffer(llvmAsmin,YY_BUF_SIZE ); \ - } \ - YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ - } - -#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) - -/* Begin user sect3 */ - -#define llvmAsmwrap(n) 1 -#define YY_SKIP_YYWRAP - -typedef unsigned char YY_CHAR; - -FILE *llvmAsmin = (FILE *) 0, *llvmAsmout = (FILE *) 0; - -typedef int yy_state_type; - -extern int llvmAsmlineno; - -int llvmAsmlineno = 1; - -extern char *llvmAsmtext; -#define yytext_ptr llvmAsmtext - -static yy_state_type yy_get_previous_state (void ); -static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); -static int yy_get_next_buffer (void ); -static void yy_fatal_error (yyconst char msg[] ); - -/* Done after the current pattern has been matched and before the - * corresponding action - sets up llvmAsmtext. - */ -#define YY_DO_BEFORE_ACTION \ - (yytext_ptr) = yy_bp; \ - llvmAsmleng = (size_t) (yy_cp - yy_bp); \ - (yy_hold_char) = *yy_cp; \ - *yy_cp = '\0'; \ - (yy_c_buf_p) = yy_cp; - -#define YY_NUM_RULES 154 -#define YY_END_OF_BUFFER 155 -/* This struct is not used in this scanner, - but its presence is necessary. */ -struct yy_trans_info - { - flex_int32_t yy_verify; - flex_int32_t yy_nxt; - }; -static yyconst flex_int16_t yy_accept[609] = - { 0, - 0, 0, 155, 153, 152, 152, 153, 153, 153, 153, - 153, 153, 142, 142, 1, 153, 153, 153, 153, 153, - 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, - 153, 153, 153, 153, 153, 153, 153, 153, 0, 139, - 0, 137, 0, 135, 145, 0, 143, 0, 147, 142, - 0, 1, 0, 136, 146, 0, 0, 0, 0, 0, - 0, 0, 121, 0, 0, 38, 0, 0, 0, 0, - 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 66, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 85, 0, 0, 0, 0, 0, 0, - - 0, 80, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 139, 0, 141, - 135, 147, 22, 147, 0, 148, 0, 0, 0, 0, - 140, 136, 67, 0, 0, 79, 0, 0, 36, 0, - 0, 0, 0, 39, 0, 0, 0, 0, 0, 0, - 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, - - 0, 0, 0, 94, 99, 97, 98, 96, 95, 0, - 100, 104, 0, 0, 0, 0, 120, 0, 0, 0, - 0, 0, 89, 87, 76, 0, 0, 0, 0, 88, - 86, 0, 0, 68, 0, 0, 0, 0, 0, 0, - 0, 0, 102, 93, 91, 0, 92, 90, 0, 103, - 101, 0, 0, 0, 0, 0, 0, 0, 0, 81, - 0, 0, 138, 147, 0, 0, 0, 147, 149, 150, - 151, 0, 0, 0, 0, 78, 0, 0, 0, 105, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 83, 72, 0, 0, 0, 0, 0, - - 128, 75, 0, 0, 0, 82, 0, 0, 0, 0, - 0, 0, 0, 129, 77, 0, 0, 52, 0, 0, - 0, 24, 0, 0, 0, 0, 53, 144, 71, 0, - 0, 108, 0, 0, 0, 0, 74, 47, 0, 0, - 26, 0, 0, 0, 4, 0, 64, 70, 0, 0, - 0, 0, 73, 0, 57, 0, 12, 0, 0, 107, - 147, 34, 32, 0, 0, 2, 0, 51, 0, 54, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, - 0, 58, 61, 110, 0, 0, 0, 0, 0, 0, - 46, 0, 0, 0, 0, 63, 0, 0, 0, 0, - - 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, - 0, 0, 0, 0, 130, 0, 0, 0, 0, 106, - 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 56, 127, 0, 0, 41, 0, 0, 0, 7, - 0, 0, 0, 59, 0, 0, 40, 114, 113, 0, - 0, 8, 16, 0, 0, 0, 123, 0, 126, 35, - 0, 0, 0, 65, 0, 0, 0, 0, 118, 0, - 0, 0, 112, 122, 27, 0, 28, 111, 0, 124, - 119, 0, 0, 0, 0, 0, 0, 0, 117, 0, - 0, 6, 29, 0, 0, 0, 0, 0, 109, 0, - - 0, 0, 0, 0, 50, 0, 0, 0, 0, 0, - 33, 0, 0, 44, 0, 0, 0, 0, 0, 0, - 45, 0, 0, 9, 0, 0, 0, 0, 19, 0, - 0, 0, 10, 115, 11, 49, 48, 0, 0, 116, - 0, 0, 0, 0, 31, 0, 60, 0, 0, 13, - 0, 15, 14, 0, 0, 0, 0, 62, 17, 0, - 0, 0, 0, 0, 0, 0, 30, 0, 0, 0, - 0, 0, 37, 0, 0, 0, 0, 0, 18, 0, - 0, 0, 0, 0, 125, 0, 0, 0, 0, 0, - 0, 0, 20, 0, 0, 0, 0, 131, 133, 134, - - 0, 42, 0, 132, 43, 0, 21, 0 - } ; - -static yyconst flex_int32_t yy_ec[256] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, - 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 2, 1, 4, 1, 5, 6, 1, 1, 1, - 1, 1, 7, 1, 8, 9, 1, 10, 11, 12, - 13, 13, 13, 14, 13, 15, 13, 16, 17, 1, - 1, 1, 1, 18, 19, 19, 19, 19, 20, 19, - 5, 5, 5, 5, 21, 22, 23, 5, 5, 5, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 1, 1, 1, 1, 24, 1, 25, 26, 27, 28, - - 29, 30, 31, 32, 33, 5, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1 - } ; - -static yyconst flex_int32_t yy_meta[50] = - { 0, - 1, 1, 2, 3, 4, 1, 5, 6, 4, 7, - 7, 7, 7, 7, 7, 8, 1, 1, 4, 9, - 4, 4, 4, 4, 4, 4, 4, 4, 9, 4, - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, - 4, 4, 4, 4, 4, 4, 4, 4, 4 - } ; - -static yyconst flex_int16_t yy_base[620] = - { 0, - 0, 0, 1387, 1388, 1388, 1388, 1382, 1369, 46, 52, - 58, 66, 74, 1337, 0, 87, 76, 79, 78, 94, - 77, 106, 109, 63, 138, 130, 141, 140, 151, 155, - 110, 190, 179, 227, 145, 114, 38, 144, 1379, 1388, - 1366, 1388, 1377, 0, 234, 260, 266, 119, 304, 1333, - 324, 0, 1375, 0, 272, 146, 175, 148, 39, 161, - 185, 64, 1362, 36, 124, 186, 189, 93, 212, 219, - 165, 187, 1361, 198, 224, 196, 234, 191, 278, 236, - 214, 272, 274, 226, 275, 284, 277, 121, 276, 280, - 288, 281, 306, 35, 315, 326, 290, 339, 341, 279, - - 342, 332, 346, 347, 348, 349, 350, 289, 353, 355, - 360, 356, 357, 365, 373, 381, 367, 378, 382, 387, - 390, 1360, 393, 222, 396, 395, 398, 397, 401, 405, - 403, 423, 420, 429, 361, 407, 409, 1359, 1370, 1388, - 0, 429, 1357, 0, 452, 448, 462, 483, 504, 1368, - 1388, 0, 1355, 510, 441, 1354, 470, 464, 1353, 445, - 509, 512, 469, 1352, 511, 504, 522, 505, 467, 526, - 527, 426, 1351, 528, 506, 529, 468, 283, 533, 406, - 534, 535, 538, 536, 537, 543, 539, 546, 548, 550, - 552, 554, 564, 566, 568, 569, 570, 1350, 572, 571, - - 573, 575, 576, 1349, 1348, 1347, 1346, 1345, 1344, 579, - 1343, 1342, 581, 580, 583, 584, 1341, 617, 594, 591, - 587, 592, 1340, 1339, 1338, 408, 604, 585, 602, 1337, - 1336, 605, 608, 1335, 609, 622, 634, 635, 637, 638, - 639, 640, 1334, 1333, 1332, 642, 1331, 1330, 643, 1329, - 1328, 644, 645, 646, 654, 653, 658, 650, 647, 1327, - 661, 670, 1388, 667, 681, 680, 690, 693, 0, 0, - 0, 686, 687, 688, 689, 1326, 690, 691, 694, 1325, - 692, 693, 695, 696, 698, 701, 702, 704, 706, 707, - 717, 709, 716, 1324, 1323, 715, 729, 721, 723, 730, - - 1322, 1321, 731, 734, 739, 1320, 738, 735, 736, 737, - 744, 745, 741, 1319, 1318, 746, 747, 1317, 740, 754, - 755, 1316, 756, 765, 767, 769, 1315, 0, 1314, 770, - 771, 786, 774, 776, 777, 778, 1313, 1312, 783, 793, - 1311, 794, 797, 795, 1310, 798, 1309, 1308, 799, 801, - 802, 800, 1307, 803, 1306, 805, 1305, 808, 810, 830, - 841, 1304, 1303, 820, 812, 1302, 818, 1301, 831, 841, - 843, 826, 833, 845, 825, 847, 849, 853, 854, 1300, - 856, 1299, 1298, 1297, 858, 859, 857, 860, 861, 863, - 1296, 864, 866, 869, 868, 1295, 872, 871, 877, 879, - - 883, 885, 886, 889, 894, 896, 895, 897, 914, 1388, - 903, 904, 898, 907, 1294, 909, 906, 908, 910, 1293, - 914, 1292, 915, 916, 919, 921, 927, 931, 932, 935, - 953, 1388, 1291, 942, 941, 1290, 943, 944, 947, 1289, - 945, 948, 951, 1288, 946, 952, 1287, 1286, 1285, 961, - 949, 1284, 1283, 953, 965, 957, 1282, 967, 1281, 1280, - 962, 975, 977, 1279, 490, 980, 981, 982, 1278, 983, - 985, 986, 1273, 1270, 1267, 987, 1255, 1252, 989, 1240, - 1237, 990, 991, 993, 994, 997, 1001, 1004, 1227, 1008, - 1010, 1224, 1221, 1011, 1012, 1014, 1015, 1016, 1214, 1020, - - 1019, 1021, 1022, 1026, 1202, 1027, 1030, 1045, 1043, 1023, - 1201, 1028, 1046, 1200, 1049, 1051, 1052, 1031, 1061, 1053, - 1199, 1054, 1062, 1198, 1063, 1066, 1067, 1069, 1197, 1070, - 1071, 1072, 1196, 1195, 1194, 1193, 1192, 1074, 1075, 1190, - 1083, 1079, 1076, 1078, 1189, 1084, 1187, 1097, 1086, 1185, - 1080, 1184, 1183, 1099, 1100, 1101, 1102, 1181, 1180, 1104, - 1105, 1109, 1110, 1112, 1111, 1114, 1179, 1116, 1117, 1118, - 1125, 1119, 1163, 1124, 1126, 1131, 1135, 1136, 1161, 1127, - 1142, 1143, 1144, 1148, 819, 1149, 1145, 1153, 1151, 1152, - 1147, 1157, 775, 1160, 1162, 1158, 1159, 601, 364, 362, - - 1165, 282, 1175, 173, 126, 1178, 90, 1388, 1219, 1225, - 1232, 1241, 1248, 1257, 1263, 1272, 1278, 1281, 1286 - } ; - -static yyconst flex_int16_t yy_def[620] = - { 0, - 608, 1, 608, 608, 608, 608, 609, 610, 611, 608, - 610, 610, 610, 13, 612, 613, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 609, 608, - 610, 608, 614, 615, 608, 608, 13, 610, 610, 13, - 49, 612, 616, 617, 608, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 25, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 608, 614, 608, - 615, 618, 610, 49, 610, 51, 49, 49, 49, 616, - 608, 617, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 49, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 608, 618, 619, 608, 145, 145, 147, 148, - 149, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 218, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 608, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - - 610, 610, 610, 610, 610, 610, 610, 610, 608, 608, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 608, 608, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, - - 610, 610, 610, 610, 610, 610, 610, 0, 608, 608, - 608, 608, 608, 608, 608, 608, 608, 608, 608 - } ; - -static yyconst flex_int16_t yy_nxt[1438] = - { 0, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 14, 14, 14, 14, 4, 15, 16, 8, 8, - 8, 8, 8, 8, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 8, 26, 27, 28, 29, 30, 8, - 31, 32, 33, 34, 35, 36, 37, 8, 38, 43, - 42, 42, 135, 42, 42, 45, 45, 45, 45, 45, - 45, 46, 46, 46, 46, 46, 46, 47, 47, 47, - 47, 47, 47, 42, 48, 136, 199, 157, 42, 42, - 162, 42, 49, 50, 50, 50, 50, 50, 50, 42, - 53, 42, 42, 42, 42, 83, 55, 55, 55, 55, - - 55, 55, 65, 56, 66, 42, 161, 61, 42, 42, - 57, 62, 58, 72, 59, 67, 73, 60, 68, 63, - 51, 42, 69, 74, 42, 42, 64, 143, 70, 42, - 75, 71, 76, 77, 42, 167, 42, 81, 108, 42, - 78, 42, 134, 82, 79, 42, 80, 84, 84, 84, - 84, 84, 84, 42, 87, 42, 42, 193, 163, 42, - 42, 42, 88, 42, 85, 91, 42, 89, 94, 132, - 42, 90, 137, 153, 86, 156, 42, 95, 92, 97, - 42, 98, 133, 96, 93, 99, 103, 100, 42, 101, - 42, 102, 158, 104, 42, 105, 159, 106, 107, 109, - - 42, 42, 42, 120, 42, 42, 42, 154, 172, 155, - 121, 42, 164, 42, 173, 160, 122, 110, 111, 123, - 112, 113, 114, 165, 115, 166, 124, 42, 179, 42, - 116, 177, 117, 118, 42, 119, 109, 42, 168, 42, - 174, 169, 42, 45, 45, 45, 45, 45, 45, 42, - 170, 42, 41, 171, 125, 126, 184, 127, 175, 128, - 241, 129, 41, 130, 183, 176, 178, 131, 142, 46, - 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, - 47, 55, 55, 55, 55, 55, 55, 42, 180, 42, - 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, - - 194, 186, 192, 42, 42, 42, 181, 209, 197, 185, - 187, 195, 41, 144, 144, 144, 144, 144, 144, 42, - 182, 42, 196, 145, 188, 189, 190, 295, 191, 204, - 42, 217, 145, 146, 146, 146, 146, 146, 146, 200, - 198, 42, 146, 146, 147, 148, 149, 42, 146, 146, - 146, 146, 146, 146, 42, 201, 42, 42, 202, 211, - 203, 42, 42, 42, 42, 42, 210, 205, 42, 207, - 42, 42, 42, 213, 259, 42, 42, 42, 212, 42, - 42, 206, 42, 208, 223, 214, 220, 219, 42, 215, - 216, 225, 227, 42, 221, 228, 42, 42, 224, 218, - - 226, 230, 42, 234, 233, 42, 222, 229, 42, 232, - 42, 42, 42, 42, 235, 231, 42, 297, 42, 236, - 42, 42, 42, 42, 42, 239, 244, 237, 242, 247, - 238, 254, 249, 250, 243, 42, 240, 333, 42, 246, - 245, 42, 251, 248, 42, 252, 255, 260, 265, 261, - 253, 289, 256, 258, 257, 262, 42, 265, 266, 267, - 42, 268, 268, 268, 268, 268, 268, 42, 41, 41, - 41, 269, 269, 269, 269, 269, 269, 277, 274, 42, - 269, 269, 42, 42, 42, 42, 269, 269, 269, 269, - 269, 269, 270, 270, 270, 270, 270, 270, 275, 285, - - 508, 270, 270, 280, 276, 42, 294, 270, 270, 270, - 270, 270, 270, 271, 271, 271, 271, 271, 271, 42, - 42, 42, 271, 271, 42, 42, 42, 42, 271, 271, - 271, 271, 271, 271, 272, 278, 279, 42, 281, 284, - 273, 42, 42, 42, 42, 282, 283, 292, 42, 42, - 42, 42, 42, 42, 42, 287, 290, 296, 42, 288, - 286, 42, 304, 42, 303, 42, 301, 42, 291, 42, - 305, 293, 299, 302, 307, 300, 308, 306, 309, 42, - 298, 42, 312, 42, 42, 42, 42, 42, 42, 311, - 42, 42, 310, 314, 42, 42, 42, 313, 42, 42, - - 42, 320, 42, 316, 324, 319, 42, 42, 315, 42, - 322, 321, 327, 317, 318, 331, 42, 42, 323, 42, - 42, 335, 325, 42, 42, 326, 328, 328, 328, 328, - 328, 328, 334, 330, 332, 328, 328, 42, 329, 336, - 337, 328, 328, 328, 328, 328, 328, 338, 339, 42, - 42, 340, 42, 42, 42, 42, 341, 42, 42, 42, - 42, 42, 42, 343, 342, 42, 345, 347, 42, 42, - 358, 350, 351, 42, 346, 344, 42, 352, 354, 349, - 355, 353, 356, 357, 348, 42, 265, 266, 266, 361, - 361, 361, 361, 361, 361, 265, 608, 41, 359, 608, - - 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, - 42, 42, 360, 42, 364, 367, 42, 42, 369, 42, - 372, 42, 42, 363, 42, 365, 366, 362, 368, 371, - 42, 42, 42, 374, 373, 370, 42, 380, 42, 376, - 377, 379, 381, 383, 42, 42, 42, 378, 375, 42, - 42, 42, 42, 42, 42, 42, 42, 382, 389, 42, - 42, 42, 42, 384, 385, 388, 386, 390, 391, 42, - 42, 42, 400, 387, 394, 392, 393, 395, 397, 396, - 42, 399, 42, 398, 42, 42, 42, 409, 410, 42, - 42, 42, 42, 42, 404, 405, 401, 408, 42, 403, - - 402, 42, 407, 411, 412, 413, 406, 414, 42, 42, - 42, 415, 42, 42, 42, 42, 42, 42, 42, 416, - 42, 418, 417, 42, 420, 42, 423, 42, 421, 419, - 422, 431, 432, 42, 42, 42, 424, 427, 429, 434, - 42, 42, 430, 425, 433, 42, 42, 426, 42, 428, - 361, 361, 361, 361, 361, 361, 42, 436, 42, 435, - 42, 440, 42, 442, 42, 437, 439, 438, 42, 42, - 441, 42, 42, 42, 42, 42, 42, 444, 42, 42, - 446, 42, 447, 42, 42, 443, 42, 42, 451, 445, - 448, 449, 42, 450, 42, 452, 457, 459, 42, 453, - - 42, 42, 455, 461, 42, 460, 454, 456, 458, 42, - 42, 42, 42, 42, 464, 409, 410, 463, 42, 42, - 466, 42, 42, 42, 42, 42, 462, 465, 467, 42, - 42, 42, 468, 471, 42, 476, 42, 470, 477, 469, - 474, 479, 42, 480, 472, 473, 42, 42, 475, 481, - 42, 483, 478, 482, 431, 432, 42, 42, 42, 42, - 42, 42, 42, 42, 42, 484, 42, 42, 42, 496, - 497, 487, 42, 485, 488, 492, 42, 42, 486, 490, - 42, 501, 42, 489, 500, 494, 493, 499, 495, 502, - 42, 491, 42, 504, 498, 42, 42, 42, 42, 503, - - 42, 42, 42, 505, 42, 42, 42, 519, 42, 42, - 515, 512, 42, 507, 513, 506, 42, 510, 511, 42, - 516, 520, 509, 42, 517, 42, 42, 42, 514, 42, - 42, 42, 518, 522, 42, 42, 42, 42, 42, 521, - 523, 42, 42, 42, 530, 42, 42, 525, 531, 529, - 524, 526, 527, 532, 535, 533, 538, 537, 42, 528, - 42, 42, 534, 536, 42, 540, 42, 42, 42, 42, - 547, 539, 541, 546, 542, 544, 42, 42, 42, 548, - 545, 42, 42, 543, 42, 42, 42, 42, 558, 42, - 42, 42, 550, 42, 42, 42, 549, 554, 42, 42, - - 557, 42, 559, 563, 555, 561, 551, 556, 552, 553, - 564, 560, 42, 562, 42, 42, 42, 42, 566, 42, - 42, 565, 567, 568, 42, 42, 42, 42, 569, 42, - 572, 42, 42, 42, 42, 574, 576, 571, 578, 42, - 42, 42, 42, 570, 575, 577, 42, 573, 584, 579, - 42, 42, 580, 582, 585, 589, 581, 42, 42, 42, - 42, 583, 42, 42, 42, 586, 42, 42, 42, 587, - 588, 595, 42, 42, 42, 42, 42, 42, 42, 591, - 42, 592, 593, 594, 590, 596, 601, 597, 602, 599, - 42, 605, 598, 42, 42, 42, 42, 600, 42, 42, - - 42, 604, 42, 606, 42, 42, 603, 42, 42, 42, - 42, 42, 42, 42, 42, 42, 42, 42, 607, 39, - 39, 39, 39, 39, 39, 39, 39, 39, 41, 42, - 41, 41, 41, 41, 44, 44, 42, 44, 44, 42, - 44, 52, 42, 52, 52, 52, 52, 52, 52, 52, - 54, 54, 42, 54, 54, 42, 54, 139, 139, 139, - 139, 139, 139, 139, 139, 139, 141, 42, 141, 141, - 42, 141, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 152, 42, 152, 152, 42, 152, 264, 42, 264, - 361, 361, 361, 42, 42, 42, 42, 42, 42, 42, - - 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, - 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, - 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, - 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, - 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, - 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, - 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, - 42, 151, 42, 140, 263, 42, 42, 42, 151, 41, - 140, 42, 138, 41, 42, 40, 608, 3, 608, 608, - 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, - - 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, - 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, - 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, - 608, 608, 608, 608, 608, 608, 608 - } ; - -static yyconst flex_int16_t yy_chk[1438] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, - 94, 64, 37, 37, 59, 9, 9, 9, 9, 9, - 9, 10, 10, 10, 10, 10, 10, 11, 11, 11, - 11, 11, 11, 11, 12, 37, 94, 59, 24, 62, - 64, 12, 13, 13, 13, 13, 13, 13, 13, 13, - 16, 17, 21, 19, 18, 24, 16, 16, 16, 16, - - 16, 16, 19, 17, 19, 607, 62, 18, 68, 20, - 17, 18, 17, 21, 17, 19, 21, 17, 20, 18, - 13, 22, 20, 21, 23, 31, 18, 48, 20, 36, - 22, 20, 22, 22, 48, 68, 88, 23, 31, 65, - 22, 605, 36, 23, 22, 26, 22, 25, 25, 25, - 25, 25, 25, 25, 26, 28, 27, 88, 65, 38, - 35, 56, 26, 58, 25, 27, 29, 26, 28, 35, - 30, 26, 38, 56, 25, 58, 60, 28, 27, 29, - 71, 29, 35, 28, 27, 29, 30, 29, 604, 29, - 57, 29, 60, 30, 33, 30, 60, 30, 30, 32, - - 61, 66, 72, 33, 67, 32, 78, 57, 71, 57, - 33, 76, 66, 74, 72, 61, 33, 32, 32, 33, - 32, 32, 32, 67, 32, 67, 33, 69, 78, 81, - 32, 76, 32, 32, 70, 32, 34, 124, 69, 75, - 74, 69, 34, 45, 45, 45, 45, 45, 45, 77, - 69, 80, 84, 70, 34, 34, 81, 34, 75, 34, - 124, 34, 84, 34, 80, 75, 77, 34, 46, 46, - 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, - 47, 55, 55, 55, 55, 55, 55, 82, 79, 83, - 85, 89, 87, 79, 100, 90, 92, 602, 178, 86, - - 89, 83, 87, 91, 108, 97, 79, 100, 92, 82, - 85, 90, 47, 49, 49, 49, 49, 49, 49, 49, - 79, 93, 91, 49, 86, 86, 86, 178, 86, 97, - 95, 108, 49, 51, 51, 51, 51, 51, 51, 95, - 93, 96, 51, 51, 51, 51, 51, 102, 51, 51, - 51, 51, 51, 51, 98, 95, 99, 101, 95, 102, - 96, 103, 104, 105, 106, 107, 101, 98, 109, 99, - 110, 112, 113, 104, 135, 111, 135, 600, 103, 599, - 114, 98, 117, 99, 112, 105, 111, 110, 115, 106, - 107, 113, 114, 118, 111, 114, 116, 119, 112, 109, - - 113, 115, 120, 118, 117, 121, 111, 114, 123, 116, - 126, 125, 128, 127, 119, 115, 129, 180, 131, 120, - 130, 180, 136, 226, 137, 123, 127, 120, 125, 129, - 121, 131, 130, 130, 126, 133, 123, 226, 132, 128, - 127, 172, 130, 129, 134, 130, 132, 136, 142, 137, - 130, 172, 133, 134, 133, 137, 155, 142, 145, 145, - 160, 145, 145, 145, 145, 145, 145, 145, 146, 146, - 146, 147, 147, 147, 147, 147, 147, 160, 155, 158, - 147, 147, 169, 177, 163, 157, 147, 147, 147, 147, - 147, 147, 148, 148, 148, 148, 148, 148, 157, 169, - - 465, 148, 148, 163, 158, 465, 177, 148, 148, 148, - 148, 148, 148, 149, 149, 149, 149, 149, 149, 166, - 168, 175, 149, 149, 161, 154, 165, 162, 149, 149, - 149, 149, 149, 149, 154, 161, 162, 167, 165, 168, - 154, 170, 171, 174, 176, 166, 167, 175, 179, 181, - 182, 184, 185, 183, 187, 171, 174, 179, 186, 171, - 170, 188, 185, 189, 184, 190, 183, 191, 174, 192, - 186, 176, 182, 183, 188, 182, 189, 187, 190, 193, - 181, 194, 192, 195, 196, 197, 200, 199, 201, 191, - 202, 203, 190, 194, 210, 214, 213, 193, 215, 216, - - 228, 201, 221, 196, 213, 200, 220, 222, 195, 219, - 203, 202, 216, 197, 199, 221, 598, 229, 210, 227, - 232, 228, 214, 233, 235, 215, 218, 218, 218, 218, - 218, 218, 227, 220, 222, 218, 218, 236, 219, 229, - 232, 218, 218, 218, 218, 218, 218, 232, 233, 237, - 238, 235, 239, 240, 241, 242, 236, 246, 249, 252, - 253, 254, 259, 238, 237, 258, 240, 241, 256, 255, - 259, 249, 252, 257, 240, 239, 261, 253, 255, 246, - 256, 254, 257, 258, 242, 262, 264, 265, 265, 266, - 266, 266, 266, 266, 266, 264, 267, 267, 261, 268, - - 268, 272, 273, 274, 275, 277, 278, 281, 282, 279, - 283, 284, 262, 285, 274, 278, 286, 287, 281, 288, - 284, 289, 290, 273, 292, 275, 277, 272, 279, 283, - 296, 293, 291, 286, 285, 282, 298, 292, 299, 288, - 289, 291, 293, 297, 297, 300, 303, 290, 287, 304, - 308, 309, 310, 307, 305, 319, 313, 296, 304, 311, - 312, 316, 317, 298, 299, 303, 299, 305, 307, 320, - 321, 323, 319, 300, 310, 308, 309, 311, 313, 312, - 324, 317, 325, 316, 326, 330, 331, 332, 332, 333, - 593, 334, 335, 336, 324, 325, 320, 331, 339, 323, - - 321, 332, 330, 333, 334, 335, 326, 336, 340, 342, - 344, 339, 343, 346, 349, 352, 350, 351, 354, 340, - 356, 343, 342, 358, 346, 359, 351, 365, 349, 344, - 350, 360, 360, 367, 585, 364, 352, 358, 359, 365, - 375, 372, 359, 354, 364, 360, 369, 356, 373, 358, - 361, 361, 361, 361, 361, 361, 370, 369, 371, 367, - 374, 373, 376, 375, 377, 370, 372, 371, 378, 379, - 374, 381, 387, 385, 386, 388, 389, 377, 390, 392, - 379, 393, 381, 395, 394, 376, 398, 397, 388, 378, - 385, 386, 399, 387, 400, 389, 395, 398, 401, 390, - - 402, 403, 393, 400, 404, 399, 392, 394, 397, 405, - 407, 406, 408, 413, 403, 409, 409, 402, 411, 412, - 405, 417, 414, 418, 416, 419, 401, 404, 406, 421, - 423, 424, 407, 412, 425, 418, 426, 411, 419, 408, - 416, 423, 427, 424, 413, 414, 428, 429, 417, 425, - 430, 427, 421, 426, 431, 431, 435, 434, 437, 438, - 441, 445, 439, 442, 451, 427, 443, 446, 454, 445, - 445, 430, 456, 428, 434, 439, 450, 461, 429, 437, - 455, 454, 458, 435, 451, 442, 441, 450, 443, 455, - 462, 438, 463, 458, 446, 466, 467, 468, 470, 456, - - 471, 472, 476, 461, 479, 482, 483, 484, 484, 485, - 476, 470, 486, 463, 471, 462, 487, 467, 468, 488, - 479, 485, 466, 490, 482, 491, 494, 495, 472, 496, - 497, 498, 483, 487, 501, 500, 502, 503, 510, 486, - 488, 504, 506, 512, 498, 507, 518, 491, 500, 497, - 490, 494, 495, 501, 504, 502, 508, 507, 509, 496, - 508, 513, 503, 506, 515, 510, 516, 517, 520, 522, - 519, 509, 512, 518, 513, 516, 519, 523, 525, 520, - 517, 526, 527, 515, 528, 530, 531, 532, 538, 538, - 539, 543, 523, 544, 542, 551, 522, 528, 541, 546, - - 532, 549, 539, 544, 530, 542, 525, 531, 526, 527, - 546, 541, 548, 543, 554, 555, 556, 557, 549, 560, - 561, 548, 551, 554, 562, 563, 565, 564, 555, 566, - 560, 568, 569, 570, 572, 562, 564, 557, 566, 574, - 571, 575, 580, 556, 563, 565, 576, 561, 574, 568, - 577, 578, 569, 571, 575, 580, 570, 581, 582, 583, - 587, 572, 591, 584, 586, 576, 589, 590, 588, 577, - 578, 587, 592, 596, 597, 594, 579, 595, 573, 582, - 601, 583, 584, 586, 581, 588, 594, 589, 595, 591, - 603, 601, 590, 606, 567, 559, 558, 592, 553, 552, - - 550, 597, 547, 603, 545, 540, 596, 537, 536, 535, - 534, 533, 529, 524, 521, 514, 511, 505, 606, 609, - 609, 609, 609, 609, 609, 609, 609, 609, 610, 499, - 610, 610, 610, 610, 611, 611, 493, 611, 611, 492, - 611, 612, 489, 612, 612, 612, 612, 612, 612, 612, - 613, 613, 481, 613, 613, 480, 613, 614, 614, 614, - 614, 614, 614, 614, 614, 614, 615, 478, 615, 615, - 477, 615, 616, 616, 616, 616, 616, 616, 616, 616, - 616, 617, 475, 617, 617, 474, 617, 618, 473, 618, - 619, 619, 619, 469, 464, 460, 459, 457, 453, 452, - - 449, 448, 447, 444, 440, 436, 433, 422, 420, 415, - 396, 391, 384, 383, 382, 380, 368, 366, 363, 362, - 357, 355, 353, 348, 347, 345, 341, 338, 337, 329, - 327, 322, 318, 315, 314, 306, 302, 301, 295, 294, - 280, 276, 260, 251, 250, 248, 247, 245, 244, 243, - 234, 231, 230, 225, 224, 223, 217, 212, 211, 209, - 208, 207, 206, 205, 204, 198, 173, 164, 159, 156, - 153, 150, 143, 139, 138, 122, 73, 63, 53, 50, - 43, 41, 39, 14, 8, 7, 3, 608, 608, 608, - 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, - - 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, - 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, - 608, 608, 608, 608, 608, 608, 608, 608, 608, 608, - 608, 608, 608, 608, 608, 608, 608 - } ; - -/* Table of booleans, true if rule could match eol. */ -static yyconst flex_int32_t yy_rule_can_match_eol[155] = - { 0, -0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, - 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, }; - -static yy_state_type yy_last_accepting_state; -static char *yy_last_accepting_cpos; - -extern int llvmAsm_flex_debug; -int llvmAsm_flex_debug = 0; - -/* The intent behind this definition is that it'll catch - * any uses of REJECT which flex missed. - */ -#define REJECT reject_used_but_not_detected -#define yymore() yymore_used_but_not_detected -#define YY_MORE_ADJ 0 -#define YY_RESTORE_YY_MORE_OFFSET -char *llvmAsmtext; -#line 1 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -/*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===// -// -// The LLVM Compiler Infrastructure -// -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file implements the flex scanner for LLVM assembly languages files. -// -//===----------------------------------------------------------------------===*/ -#line 28 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -#include "ParserInternals.h" -#include "llvm/Module.h" -#include "llvm/Support/MathExtras.h" -#include -#include "llvmAsmParser.h" -#include -#include - -void set_scan_file(FILE * F){ - llvmAsm_switch_to_buffer(llvmAsm_create_buffer(F,YY_BUF_SIZE ) ); -} -void set_scan_string (const char * str) { - llvmAsm_scan_string (str); -} - -// Construct a token value for a non-obsolete token -#define RET_TOK(type, Enum, sym) \ - llvmAsmlval.type = Instruction::Enum; \ - return sym - -// Construct a token value for an obsolete token -#define RET_TY(CTYPE, SYM) \ - llvmAsmlval.PrimType = CTYPE;\ - return SYM - -namespace llvm { - -// TODO: All of the static identifiers are figured out by the lexer, -// these should be hashed to reduce the lexer size - - -// atoull - Convert an ascii string of decimal digits into the unsigned long -// long representation... this does not have to do input error checking, -// because we know that the input will be matched by a suitable regex... -// -static uint64_t atoull(const char *Buffer) { - uint64_t Result = 0; - for (; *Buffer; Buffer++) { - uint64_t OldRes = Result; - Result *= 10; - Result += *Buffer-'0'; - if (Result < OldRes) // Uh, oh, overflow detected!!! - GenerateError("constant bigger than 64 bits detected!"); - } - return Result; -} - -static uint64_t HexIntToVal(const char *Buffer) { - uint64_t Result = 0; - for (; *Buffer; ++Buffer) { - uint64_t OldRes = Result; - Result *= 16; - char C = *Buffer; - if (C >= '0' && C <= '9') - Result += C-'0'; - else if (C >= 'A' && C <= 'F') - Result += C-'A'+10; - else if (C >= 'a' && C <= 'f') - Result += C-'a'+10; - - if (Result < OldRes) // Uh, oh, overflow detected!!! - GenerateError("constant bigger than 64 bits detected!"); - } - return Result; -} - -// HexToFP - Convert the ascii string in hexadecimal format to the floating -// point representation of it. -// -static double HexToFP(const char *Buffer) { - return BitsToDouble(HexIntToVal(Buffer)); // Cast Hex constant to double -} - -static void HexToIntPair(const char *Buffer, uint64_t Pair[2]) { - Pair[0] = 0; - for (int i=0; i<16; i++, Buffer++) { - assert(*Buffer); - Pair[0] *= 16; - char C = *Buffer; - if (C >= '0' && C <= '9') - Pair[0] += C-'0'; - else if (C >= 'A' && C <= 'F') - Pair[0] += C-'A'+10; - else if (C >= 'a' && C <= 'f') - Pair[0] += C-'a'+10; - } - Pair[1] = 0; - for (int i=0; i<16 && *Buffer; i++, Buffer++) { - Pair[1] *= 16; - char C = *Buffer; - if (C >= '0' && C <= '9') - Pair[1] += C-'0'; - else if (C >= 'A' && C <= 'F') - Pair[1] += C-'A'+10; - else if (C >= 'a' && C <= 'f') - Pair[1] += C-'a'+10; - } - if (*Buffer) - GenerateError("constant bigger than 128 bits detected!"); -} - -// UnEscapeLexed - Run through the specified buffer and change \xx codes to the -// appropriate character. -char *UnEscapeLexed(char *Buffer, char* EndBuffer) { - char *BOut = Buffer; - for (char *BIn = Buffer; *BIn; ) { - if (BIn[0] == '\\') { - if (BIn < EndBuffer-1 && BIn[1] == '\\') { - *BOut++ = '\\'; // Two \ becomes one - BIn += 2; - } else if (BIn < EndBuffer-2 && isxdigit(BIn[1]) && isxdigit(BIn[2])) { - char Tmp = BIn[3]; BIn[3] = 0; // Terminate string - *BOut = (char)strtol(BIn+1, 0, 16); // Convert to number - BIn[3] = Tmp; // Restore character - BIn += 3; // Skip over handled chars - ++BOut; - } else { - *BOut++ = *BIn++; - } - } else { - *BOut++ = *BIn++; - } - } - return BOut; -} - -} // End llvm namespace - -using namespace llvm; - -#define YY_NEVER_INTERACTIVE 1 -/* Comments start with a ; and go till end of line */ -/* Local Values and Type identifiers start with a % sign */ -/* Global Value identifiers start with an @ sign */ -/* Label identifiers end with a colon */ -/* Quoted names can contain any character except " and \ */ -/* LocalVarID/GlobalVarID: match an unnamed local variable slot ID. */ -/* Integer types are specified with i and a bitwidth */ -/* E[PN]Integer: match positive and negative literal integer values. */ -/* FPConstant - A Floating point constant. Float and double only. - */ -/* HexFPConstant - Floating point constant represented in IEEE format as a - * hexadecimal number for when exponential notation is not precise enough. - * Float and double only. - */ -/* F80HexFPConstant - x87 long double in hexadecimal format (10 bytes) - */ -/* F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes) - */ -/* PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes) - */ -/* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing - * it to deal with 64 bit numbers. - */ -/* WSNL - shorthand for whitespace followed by newline */ -#line 1168 "Lexer.cpp" - -#define INITIAL 0 - -#ifndef YY_NO_UNISTD_H -/* Special case for "unistd.h", since it is non-ANSI. We include it way - * down here because we want the user's section 1 to have been scanned first. - * The user has a chance to override it with an option. - */ -#include -#endif - -#ifndef YY_EXTRA_TYPE -#define YY_EXTRA_TYPE void * -#endif - -static int yy_init_globals (void ); - -/* Macros after this point can all be overridden by user definitions in - * section 1. - */ - -#ifndef YY_SKIP_YYWRAP -#ifdef __cplusplus -extern "C" int llvmAsmwrap (void ); -#else -extern int llvmAsmwrap (void ); -#endif -#endif - - static inline void yyunput (int c,char *buf_ptr ); - -#ifndef yytext_ptr -static void yy_flex_strncpy (char *,yyconst char *,int ); -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * ); -#endif - -#ifndef YY_NO_INPUT - -#ifdef __cplusplus -static int yyinput (void ); -#else -static int input (void ); -#endif - -#endif - -/* Amount of stuff to slurp up with each read. */ -#ifndef YY_READ_BUF_SIZE -#define YY_READ_BUF_SIZE 8192 -#endif - -/* Copy whatever the last rule matched to the standard output. */ -#ifndef ECHO -/* This used to be an fputs(), but since the string might contain NUL's, - * we now use fwrite(). - */ -#define ECHO (void) fwrite( llvmAsmtext, llvmAsmleng, 1, llvmAsmout ) -#endif - -/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, - * is returned in "result". - */ -#ifndef YY_INPUT -#define YY_INPUT(buf,result,max_size) \ - if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ - { \ - int c = '*'; \ - size_t n; \ - for ( n = 0; n < max_size && \ - (c = getc( llvmAsmin )) != EOF && c != '\n'; ++n ) \ - buf[n] = (char) c; \ - if ( c == '\n' ) \ - buf[n++] = (char) c; \ - if ( c == EOF && ferror( llvmAsmin ) ) \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - result = n; \ - } \ - else \ - { \ - errno=0; \ - while ( (result = fread(buf, 1, max_size, llvmAsmin))==0 && ferror(llvmAsmin)) \ - { \ - if( errno != EINTR) \ - { \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - break; \ - } \ - errno=0; \ - clearerr(llvmAsmin); \ - } \ - }\ -\ - -#endif - -/* No semi-colon after return; correct usage is to write "yyterminate();" - - * we don't want an extra ';' after the "return" because that will cause - * some compilers to complain about unreachable statements. - */ -#ifndef yyterminate -#define yyterminate() return YY_NULL -#endif - -/* Number of entries by which start-condition stack grows. */ -#ifndef YY_START_STACK_INCR -#define YY_START_STACK_INCR 25 -#endif - -/* Report a fatal error. */ -#ifndef YY_FATAL_ERROR -#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) -#endif - -/* end tables serialization structures and prototypes */ - -/* Default declaration of generated scanner - a define so the user can - * easily add parameters. - */ -#ifndef YY_DECL -#define YY_DECL_IS_OURS 1 - -extern int llvmAsmlex (void); - -#define YY_DECL int llvmAsmlex (void) -#endif /* !YY_DECL */ - -/* Code executed at the beginning of each rule, after llvmAsmtext and llvmAsmleng - * have been set up. - */ -#ifndef YY_USER_ACTION -#define YY_USER_ACTION -#endif - -/* Code executed at the end of each rule. */ -#ifndef YY_BREAK -#define YY_BREAK break; -#endif - -#define YY_RULE_SETUP \ - YY_USER_ACTION - -/** The main scanner function which does all the work. - */ -YY_DECL -{ - register yy_state_type yy_current_state; - register char *yy_cp, *yy_bp; - register int yy_act; - -#line 221 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" - - -#line 1324 "Lexer.cpp" - - if ( !(yy_init) ) - { - (yy_init) = 1; - -#ifdef YY_USER_INIT - YY_USER_INIT; -#endif - - if ( ! (yy_start) ) - (yy_start) = 1; /* first start state */ - - if ( ! llvmAsmin ) - llvmAsmin = stdin; - - if ( ! llvmAsmout ) - llvmAsmout = stdout; - - if ( ! YY_CURRENT_BUFFER ) { - llvmAsmensure_buffer_stack (); - YY_CURRENT_BUFFER_LVALUE = - llvmAsm_create_buffer(llvmAsmin,YY_BUF_SIZE ); - } - - llvmAsm_load_buffer_state( ); - } - - while ( 1 ) /* loops until end-of-file is reached */ - { - yy_cp = (yy_c_buf_p); - - /* Support of llvmAsmtext. */ - *yy_cp = (yy_hold_char); - - /* yy_bp points to the position in yy_ch_buf of the start of - * the current run. - */ - yy_bp = yy_cp; - - yy_current_state = (yy_start); -yy_match: - do - { - register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 609 ) - yy_c = yy_meta[(unsigned int) yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - ++yy_cp; - } - while ( yy_current_state != 608 ); - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - -yy_find_action: - yy_act = yy_accept[yy_current_state]; - - YY_DO_BEFORE_ACTION; - - if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) - { - int yyl; - for ( yyl = 0; yyl < llvmAsmleng; ++yyl ) - if ( llvmAsmtext[yyl] == '\n' ) - - llvmAsmlineno++; -; - } - -do_action: /* This label is used only to access EOF actions. */ - - switch ( yy_act ) - { /* beginning of action switch */ - case 0: /* must back up */ - /* undo the effects of YY_DO_BEFORE_ACTION */ - *yy_cp = (yy_hold_char); - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - goto yy_find_action; - -case 1: -YY_RULE_SETUP -#line 223 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ /* Ignore comments for now */ } - YY_BREAK -case 2: -YY_RULE_SETUP -#line 225 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return BEGINTOK; } - YY_BREAK -case 3: -YY_RULE_SETUP -#line 226 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return ENDTOK; } - YY_BREAK -case 4: -YY_RULE_SETUP -#line 227 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return TRUETOK; } - YY_BREAK -case 5: -YY_RULE_SETUP -#line 228 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return FALSETOK; } - YY_BREAK -case 6: -YY_RULE_SETUP -#line 229 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return DECLARE; } - YY_BREAK -case 7: -YY_RULE_SETUP -#line 230 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return DEFINE; } - YY_BREAK -case 8: -YY_RULE_SETUP -#line 231 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return GLOBAL; } - YY_BREAK -case 9: -YY_RULE_SETUP -#line 232 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return CONSTANT; } - YY_BREAK -case 10: -YY_RULE_SETUP -#line 233 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return INTERNAL; } - YY_BREAK -case 11: -YY_RULE_SETUP -#line 234 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return LINKONCE; } - YY_BREAK -case 12: -YY_RULE_SETUP -#line 235 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return WEAK; } - YY_BREAK -case 13: -YY_RULE_SETUP -#line 236 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return APPENDING; } - YY_BREAK -case 14: -YY_RULE_SETUP -#line 237 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return DLLIMPORT; } - YY_BREAK -case 15: -YY_RULE_SETUP -#line 238 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return DLLEXPORT; } - YY_BREAK -case 16: -YY_RULE_SETUP -#line 239 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return HIDDEN; } - YY_BREAK -case 17: -YY_RULE_SETUP -#line 240 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return PROTECTED; } - YY_BREAK -case 18: -YY_RULE_SETUP -#line 241 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return EXTERN_WEAK; } - YY_BREAK -case 19: -YY_RULE_SETUP -#line 242 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return EXTERNAL; } - YY_BREAK -case 20: -YY_RULE_SETUP -#line 243 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return THREAD_LOCAL; } - YY_BREAK -case 21: -YY_RULE_SETUP -#line 244 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return ZEROINITIALIZER; } - YY_BREAK -case 22: -YY_RULE_SETUP -#line 245 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return DOTDOTDOT; } - YY_BREAK -case 23: -YY_RULE_SETUP -#line 246 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return UNDEF; } - YY_BREAK -case 24: -YY_RULE_SETUP -#line 247 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return NULL_TOK; } - YY_BREAK -case 25: -YY_RULE_SETUP -#line 248 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return TO; } - YY_BREAK -case 26: -YY_RULE_SETUP -#line 249 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return TAIL; } - YY_BREAK -case 27: -YY_RULE_SETUP -#line 250 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return TARGET; } - YY_BREAK -case 28: -YY_RULE_SETUP -#line 251 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return TRIPLE; } - YY_BREAK -case 29: -YY_RULE_SETUP -#line 252 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return DEPLIBS; } - YY_BREAK -case 30: -YY_RULE_SETUP -#line 253 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return DATALAYOUT; } - YY_BREAK -case 31: -YY_RULE_SETUP -#line 254 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return VOLATILE; } - YY_BREAK -case 32: -YY_RULE_SETUP -#line 255 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return ALIGN; } - YY_BREAK -case 33: -YY_RULE_SETUP -#line 256 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return SECTION; } - YY_BREAK -case 34: -YY_RULE_SETUP -#line 257 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return ALIAS; } - YY_BREAK -case 35: -YY_RULE_SETUP -#line 258 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return MODULE; } - YY_BREAK -case 36: -YY_RULE_SETUP -#line 259 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return ASM_TOK; } - YY_BREAK -case 37: -YY_RULE_SETUP -#line 260 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return SIDEEFFECT; } - YY_BREAK -case 38: -YY_RULE_SETUP -#line 262 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return CC_TOK; } - YY_BREAK -case 39: -YY_RULE_SETUP -#line 263 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return CCC_TOK; } - YY_BREAK -case 40: -YY_RULE_SETUP -#line 264 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return FASTCC_TOK; } - YY_BREAK -case 41: -YY_RULE_SETUP -#line 265 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return COLDCC_TOK; } - YY_BREAK -case 42: -YY_RULE_SETUP -#line 266 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return X86_STDCALLCC_TOK; } - YY_BREAK -case 43: -YY_RULE_SETUP -#line 267 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return X86_FASTCALLCC_TOK; } - YY_BREAK -case 44: -YY_RULE_SETUP -#line 269 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return SIGNEXT; } - YY_BREAK -case 45: -YY_RULE_SETUP -#line 270 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return ZEROEXT; } - YY_BREAK -case 46: -YY_RULE_SETUP -#line 271 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return INREG; } - YY_BREAK -case 47: -YY_RULE_SETUP -#line 272 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return SRET; } - YY_BREAK -case 48: -YY_RULE_SETUP -#line 273 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return NOUNWIND; } - YY_BREAK -case 49: -YY_RULE_SETUP -#line 274 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return NORETURN; } - YY_BREAK -case 50: -YY_RULE_SETUP -#line 275 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return NOALIAS; } - YY_BREAK -case 51: -YY_RULE_SETUP -#line 276 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return BYVAL; } - YY_BREAK -case 52: -YY_RULE_SETUP -#line 277 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return NEST; } - YY_BREAK -case 53: -YY_RULE_SETUP -#line 278 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return PURE; } - YY_BREAK -case 54: -YY_RULE_SETUP -#line 279 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return CONST; } - YY_BREAK -case 55: -*yy_cp = (yy_hold_char); /* undo effects of setting up llvmAsmtext */ -(yy_c_buf_p) = yy_cp -= 1; -YY_DO_BEFORE_ACTION; /* set up llvmAsmtext again */ -YY_RULE_SETUP -#line 280 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ // For auto-upgrade only, drop in LLVM 3.0 - return SIGNEXT; } - YY_BREAK -case 56: -*yy_cp = (yy_hold_char); /* undo effects of setting up llvmAsmtext */ -(yy_c_buf_p) = yy_cp -= 1; -YY_DO_BEFORE_ACTION; /* set up llvmAsmtext again */ -YY_RULE_SETUP -#line 282 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ // For auto-upgrade only, drop in LLVM 3.0 - return ZEROEXT; } - YY_BREAK -case 57: -YY_RULE_SETUP -#line 285 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TY(Type::VoidTy, VOID); } - YY_BREAK -case 58: -YY_RULE_SETUP -#line 286 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TY(Type::FloatTy, FLOAT); } - YY_BREAK -case 59: -YY_RULE_SETUP -#line 287 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TY(Type::DoubleTy,DOUBLE);} - YY_BREAK -case 60: -YY_RULE_SETUP -#line 288 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TY(Type::X86_FP80Ty, X86_FP80);} - YY_BREAK -case 61: -YY_RULE_SETUP -#line 289 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TY(Type::FP128Ty, FP128);} - YY_BREAK -case 62: -YY_RULE_SETUP -#line 290 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TY(Type::PPC_FP128Ty, PPC_FP128);} - YY_BREAK -case 63: -YY_RULE_SETUP -#line 291 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TY(Type::LabelTy, LABEL); } - YY_BREAK -case 64: -YY_RULE_SETUP -#line 292 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return TYPE; } - YY_BREAK -case 65: -YY_RULE_SETUP -#line 293 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return OPAQUE; } - YY_BREAK -case 66: -YY_RULE_SETUP -#line 294 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ uint64_t NumBits = atoull(llvmAsmtext+1); - if (NumBits < IntegerType::MIN_INT_BITS || - NumBits > IntegerType::MAX_INT_BITS) - GenerateError("Bitwidth for integer type out of range!"); - const Type* Ty = IntegerType::get(NumBits); - RET_TY(Ty, INTTYPE); - } - YY_BREAK -case 67: -YY_RULE_SETUP -#line 302 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, Add, ADD); } - YY_BREAK -case 68: -YY_RULE_SETUP -#line 303 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, Sub, SUB); } - YY_BREAK -case 69: -YY_RULE_SETUP -#line 304 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, Mul, MUL); } - YY_BREAK -case 70: -YY_RULE_SETUP -#line 305 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, UDiv, UDIV); } - YY_BREAK -case 71: -YY_RULE_SETUP -#line 306 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, SDiv, SDIV); } - YY_BREAK -case 72: -YY_RULE_SETUP -#line 307 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, FDiv, FDIV); } - YY_BREAK -case 73: -YY_RULE_SETUP -#line 308 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, URem, UREM); } - YY_BREAK -case 74: -YY_RULE_SETUP -#line 309 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, SRem, SREM); } - YY_BREAK -case 75: -YY_RULE_SETUP -#line 310 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, FRem, FREM); } - YY_BREAK -case 76: -YY_RULE_SETUP -#line 311 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, Shl, SHL); } - YY_BREAK -case 77: -YY_RULE_SETUP -#line 312 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, LShr, LSHR); } - YY_BREAK -case 78: -YY_RULE_SETUP -#line 313 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, AShr, ASHR); } - YY_BREAK -case 79: -YY_RULE_SETUP -#line 314 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, And, AND); } - YY_BREAK -case 80: -YY_RULE_SETUP -#line 315 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, Or , OR ); } - YY_BREAK -case 81: -YY_RULE_SETUP -#line 316 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(BinaryOpVal, Xor, XOR); } - YY_BREAK -case 82: -YY_RULE_SETUP -#line 317 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(OtherOpVal, ICmp, ICMP); } - YY_BREAK -case 83: -YY_RULE_SETUP -#line 318 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(OtherOpVal, FCmp, FCMP); } - YY_BREAK -case 84: -YY_RULE_SETUP -#line 320 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return EQ; } - YY_BREAK -case 85: -YY_RULE_SETUP -#line 321 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return NE; } - YY_BREAK -case 86: -YY_RULE_SETUP -#line 322 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return SLT; } - YY_BREAK -case 87: -YY_RULE_SETUP -#line 323 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return SGT; } - YY_BREAK -case 88: -YY_RULE_SETUP -#line 324 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return SLE; } - YY_BREAK -case 89: -YY_RULE_SETUP -#line 325 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return SGE; } - YY_BREAK -case 90: -YY_RULE_SETUP -#line 326 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return ULT; } - YY_BREAK -case 91: -YY_RULE_SETUP -#line 327 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return UGT; } - YY_BREAK -case 92: -YY_RULE_SETUP -#line 328 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return ULE; } - YY_BREAK -case 93: -YY_RULE_SETUP -#line 329 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return UGE; } - YY_BREAK -case 94: -YY_RULE_SETUP -#line 330 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return OEQ; } - YY_BREAK -case 95: -YY_RULE_SETUP -#line 331 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return ONE; } - YY_BREAK -case 96: -YY_RULE_SETUP -#line 332 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return OLT; } - YY_BREAK -case 97: -YY_RULE_SETUP -#line 333 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return OGT; } - YY_BREAK -case 98: -YY_RULE_SETUP -#line 334 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return OLE; } - YY_BREAK -case 99: -YY_RULE_SETUP -#line 335 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return OGE; } - YY_BREAK -case 100: -YY_RULE_SETUP -#line 336 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return ORD; } - YY_BREAK -case 101: -YY_RULE_SETUP -#line 337 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return UNO; } - YY_BREAK -case 102: -YY_RULE_SETUP -#line 338 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return UEQ; } - YY_BREAK -case 103: -YY_RULE_SETUP -#line 339 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return UNE; } - YY_BREAK -case 104: -YY_RULE_SETUP -#line 341 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(OtherOpVal, PHI, PHI_TOK); } - YY_BREAK -case 105: -YY_RULE_SETUP -#line 342 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(OtherOpVal, Call, CALL); } - YY_BREAK -case 106: -YY_RULE_SETUP -#line 343 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, Trunc, TRUNC); } - YY_BREAK -case 107: -YY_RULE_SETUP -#line 344 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, ZExt, ZEXT); } - YY_BREAK -case 108: -YY_RULE_SETUP -#line 345 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, SExt, SEXT); } - YY_BREAK -case 109: -YY_RULE_SETUP -#line 346 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, FPTrunc, FPTRUNC); } - YY_BREAK -case 110: -YY_RULE_SETUP -#line 347 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, FPExt, FPEXT); } - YY_BREAK -case 111: -YY_RULE_SETUP -#line 348 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, UIToFP, UITOFP); } - YY_BREAK -case 112: -YY_RULE_SETUP -#line 349 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, SIToFP, SITOFP); } - YY_BREAK -case 113: -YY_RULE_SETUP -#line 350 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, FPToUI, FPTOUI); } - YY_BREAK -case 114: -YY_RULE_SETUP -#line 351 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, FPToSI, FPTOSI); } - YY_BREAK -case 115: -YY_RULE_SETUP -#line 352 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, IntToPtr, INTTOPTR); } - YY_BREAK -case 116: -YY_RULE_SETUP -#line 353 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, PtrToInt, PTRTOINT); } - YY_BREAK -case 117: -YY_RULE_SETUP -#line 354 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(CastOpVal, BitCast, BITCAST); } - YY_BREAK -case 118: -YY_RULE_SETUP -#line 355 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(OtherOpVal, Select, SELECT); } - YY_BREAK -case 119: -YY_RULE_SETUP -#line 356 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(OtherOpVal, VAArg , VAARG); } - YY_BREAK -case 120: -YY_RULE_SETUP -#line 357 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(TermOpVal, Ret, RET); } - YY_BREAK -case 121: -YY_RULE_SETUP -#line 358 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(TermOpVal, Br, BR); } - YY_BREAK -case 122: -YY_RULE_SETUP -#line 359 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(TermOpVal, Switch, SWITCH); } - YY_BREAK -case 123: -YY_RULE_SETUP -#line 360 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(TermOpVal, Invoke, INVOKE); } - YY_BREAK -case 124: -YY_RULE_SETUP -#line 361 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(TermOpVal, Unwind, UNWIND); } - YY_BREAK -case 125: -YY_RULE_SETUP -#line 362 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(TermOpVal, Unreachable, UNREACHABLE); } - YY_BREAK -case 126: -YY_RULE_SETUP -#line 364 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(MemOpVal, Malloc, MALLOC); } - YY_BREAK -case 127: -YY_RULE_SETUP -#line 365 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(MemOpVal, Alloca, ALLOCA); } - YY_BREAK -case 128: -YY_RULE_SETUP -#line 366 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(MemOpVal, Free, FREE); } - YY_BREAK -case 129: -YY_RULE_SETUP -#line 367 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(MemOpVal, Load, LOAD); } - YY_BREAK -case 130: -YY_RULE_SETUP -#line 368 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(MemOpVal, Store, STORE); } - YY_BREAK -case 131: -YY_RULE_SETUP -#line 369 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); } - YY_BREAK -case 132: -YY_RULE_SETUP -#line 371 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); } - YY_BREAK -case 133: -YY_RULE_SETUP -#line 372 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); } - YY_BREAK -case 134: -YY_RULE_SETUP -#line 373 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); } - YY_BREAK -case 135: -YY_RULE_SETUP -#line 376 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ - llvmAsmlval.StrVal = new std::string(llvmAsmtext+1); // Skip % - return LOCALVAR; - } - YY_BREAK -case 136: -YY_RULE_SETUP -#line 380 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ - llvmAsmlval.StrVal = new std::string(llvmAsmtext+1); // Skip @ - return GLOBALVAR; - } - YY_BREAK -case 137: -YY_RULE_SETUP -#line 384 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ - llvmAsmtext[llvmAsmleng-1] = 0; // nuke colon - llvmAsmlval.StrVal = new std::string(llvmAsmtext); - return LABELSTR; - } - YY_BREAK -case 138: -/* rule 138 can match eol */ -YY_RULE_SETUP -#line 389 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ - llvmAsmtext[llvmAsmleng-2] = 0; // nuke colon, end quote - const char* EndChar = UnEscapeLexed(llvmAsmtext+1, llvmAsmtext+llvmAsmleng); - llvmAsmlval.StrVal = - new std::string(llvmAsmtext+1, EndChar - llvmAsmtext - 1); - return LABELSTR; - } - YY_BREAK -case 139: -/* rule 139 can match eol */ -YY_RULE_SETUP -#line 397 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ llvmAsmtext[llvmAsmleng-1] = 0; // nuke end quote - const char* EndChar = UnEscapeLexed(llvmAsmtext+1, llvmAsmtext+llvmAsmleng); - llvmAsmlval.StrVal = - new std::string(llvmAsmtext+1, EndChar - llvmAsmtext - 1); - return STRINGCONSTANT; - } - YY_BREAK -case 140: -/* rule 140 can match eol */ -YY_RULE_SETUP -#line 403 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ - llvmAsmtext[llvmAsmleng-1] = 0; // nuke end quote - const char* EndChar = - UnEscapeLexed(llvmAsmtext+2, llvmAsmtext+llvmAsmleng); - llvmAsmlval.StrVal = - new std::string(llvmAsmtext+2, EndChar - llvmAsmtext - 2); - return ATSTRINGCONSTANT; - } - YY_BREAK -case 141: -/* rule 141 can match eol */ -YY_RULE_SETUP -#line 411 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ - llvmAsmtext[llvmAsmleng-1] = 0; // nuke end quote - const char* EndChar = - UnEscapeLexed(llvmAsmtext+2, llvmAsmtext+llvmAsmleng); - llvmAsmlval.StrVal = - new std::string(llvmAsmtext+2, EndChar - llvmAsmtext - 2); - return PCTSTRINGCONSTANT; - } - YY_BREAK -case 142: -YY_RULE_SETUP -#line 419 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ - uint32_t numBits = ((llvmAsmleng * 64) / 19) + 1; - APInt Tmp(numBits, llvmAsmtext, llvmAsmleng, 10); - uint32_t activeBits = Tmp.getActiveBits(); - if (activeBits > 0 && activeBits < numBits) - Tmp.trunc(activeBits); - if (Tmp.getBitWidth() > 64) { - llvmAsmlval.APIntVal = new APInt(Tmp); - return EUAPINTVAL; - } else { - llvmAsmlval.UInt64Val = Tmp.getZExtValue(); - return EUINT64VAL; - } - } - YY_BREAK -case 143: -YY_RULE_SETUP -#line 433 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ - uint32_t numBits = (((llvmAsmleng-1) * 64) / 19) + 2; - APInt Tmp(numBits, llvmAsmtext, llvmAsmleng, 10); - uint32_t minBits = Tmp.getMinSignedBits(); - if (minBits > 0 && minBits < numBits) - Tmp.trunc(minBits); - if (Tmp.getBitWidth() > 64) { - llvmAsmlval.APIntVal = new APInt(Tmp); - return ESAPINTVAL; - } else { - llvmAsmlval.SInt64Val = Tmp.getSExtValue(); - return ESINT64VAL; - } - } - YY_BREAK -case 144: -YY_RULE_SETUP -#line 448 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ int len = llvmAsmleng - 3; - uint32_t bits = len * 4; - APInt Tmp(bits, llvmAsmtext+3, len, 16); - uint32_t activeBits = Tmp.getActiveBits(); - if (activeBits > 0 && activeBits < bits) - Tmp.trunc(activeBits); - if (Tmp.getBitWidth() > 64) { - llvmAsmlval.APIntVal = new APInt(Tmp); - return llvmAsmtext[0] == 's' ? ESAPINTVAL : EUAPINTVAL; - } else if (llvmAsmtext[0] == 's') { - llvmAsmlval.SInt64Val = Tmp.getSExtValue(); - return ESINT64VAL; - } else { - llvmAsmlval.UInt64Val = Tmp.getZExtValue(); - return EUINT64VAL; - } - } - YY_BREAK -case 145: -YY_RULE_SETUP -#line 466 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ - uint64_t Val = atoull(llvmAsmtext+1); - if ((unsigned)Val != Val) - GenerateError("Invalid value number (too large)!"); - llvmAsmlval.UIntVal = unsigned(Val); - return LOCALVAL_ID; - } - YY_BREAK -case 146: -YY_RULE_SETUP -#line 473 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ - uint64_t Val = atoull(llvmAsmtext+1); - if ((unsigned)Val != Val) - GenerateError("Invalid value number (too large)!"); - llvmAsmlval.UIntVal = unsigned(Val); - return GLOBALVAL_ID; - } - YY_BREAK -case 147: -YY_RULE_SETUP -#line 481 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ llvmAsmlval.FPVal = new APFloat(atof(llvmAsmtext)); return FPVAL; } - YY_BREAK -case 148: -YY_RULE_SETUP -#line 482 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ llvmAsmlval.FPVal = new APFloat(HexToFP(llvmAsmtext+2)); - return FPVAL; - } - YY_BREAK -case 149: -YY_RULE_SETUP -#line 485 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ uint64_t Pair[2]; - HexToIntPair(llvmAsmtext+3, Pair); - llvmAsmlval.FPVal = new APFloat(APInt(80, 2, Pair)); - return FPVAL; - } - YY_BREAK -case 150: -YY_RULE_SETUP -#line 490 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ uint64_t Pair[2]; - HexToIntPair(llvmAsmtext+3, Pair); - llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair), true); - return FPVAL; - } - YY_BREAK -case 151: -YY_RULE_SETUP -#line 495 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ uint64_t Pair[2]; - HexToIntPair(llvmAsmtext+3, Pair); - llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair)); - return FPVAL; - } - YY_BREAK -case YY_STATE_EOF(INITIAL): -#line 501 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ - /* Make sure to free the internal buffers for flex when we are - * done reading our input! - */ - llvmAsm_delete_buffer(YY_CURRENT_BUFFER); - return EOF; - } - YY_BREAK -case 152: -/* rule 152 can match eol */ -YY_RULE_SETUP -#line 509 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ /* Ignore whitespace */ } - YY_BREAK -case 153: -YY_RULE_SETUP -#line 510 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -{ return llvmAsmtext[0]; } - YY_BREAK -case 154: -YY_RULE_SETUP -#line 512 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" -YY_FATAL_ERROR( "flex scanner jammed" ); - YY_BREAK -#line 2315 "Lexer.cpp" - - case YY_END_OF_BUFFER: - { - /* Amount of text matched not including the EOB char. */ - int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; - - /* Undo the effects of YY_DO_BEFORE_ACTION. */ - *yy_cp = (yy_hold_char); - YY_RESTORE_YY_MORE_OFFSET - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) - { - /* We're scanning a new file or input source. It's - * possible that this happened because the user - * just pointed llvmAsmin at a new source and called - * llvmAsmlex(). If so, then we have to assure - * consistency between YY_CURRENT_BUFFER and our - * globals. Here is the right place to do so, because - * this is the first action (other than possibly a - * back-up) that will match for the new input source. - */ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - YY_CURRENT_BUFFER_LVALUE->yy_input_file = llvmAsmin; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; - } - - /* Note that here we test for yy_c_buf_p "<=" to the position - * of the first EOB in the buffer, since yy_c_buf_p will - * already have been incremented past the NUL character - * (since all states make transitions on EOB to the - * end-of-buffer state). Contrast this with the test - * in input(). - */ - if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) - { /* This was really a NUL. */ - yy_state_type yy_next_state; - - (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( ); - - /* Okay, we're now positioned to make the NUL - * transition. We couldn't have - * yy_get_previous_state() go ahead and do it - * for us because it doesn't know how to deal - * with the possibility of jamming (and we don't - * want to build jamming into it because then it - * will run more slowly). - */ - - yy_next_state = yy_try_NUL_trans( yy_current_state ); - - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - - if ( yy_next_state ) - { - /* Consume the NUL. */ - yy_cp = ++(yy_c_buf_p); - yy_current_state = yy_next_state; - goto yy_match; - } - - else - { - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - goto yy_find_action; - } - } - - else switch ( yy_get_next_buffer( ) ) - { - case EOB_ACT_END_OF_FILE: - { - (yy_did_buffer_switch_on_eof) = 0; - - if ( llvmAsmwrap( ) ) - { - /* Note: because we've taken care in - * yy_get_next_buffer() to have set up - * llvmAsmtext, we can now set up - * yy_c_buf_p so that if some total - * hoser (like flex itself) wants to - * call the scanner after we return the - * YY_NULL, it'll still work - another - * YY_NULL will get returned. - */ - (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; - - yy_act = YY_STATE_EOF(YY_START); - goto do_action; - } - - else - { - if ( ! (yy_did_buffer_switch_on_eof) ) - YY_NEW_FILE; - } - break; - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = - (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( ); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_match; - - case EOB_ACT_LAST_MATCH: - (yy_c_buf_p) = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; - - yy_current_state = yy_get_previous_state( ); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_find_action; - } - break; - } - - default: - YY_FATAL_ERROR( - "fatal flex scanner internal error--no action found" ); - } /* end of action switch */ - } /* end of scanning one token */ -} /* end of llvmAsmlex */ - -/* yy_get_next_buffer - try to read in a new buffer - * - * Returns a code representing an action: - * EOB_ACT_LAST_MATCH - - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position - * EOB_ACT_END_OF_FILE - end of file - */ -static int yy_get_next_buffer (void) -{ - register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - register char *source = (yytext_ptr); - register int number_to_move, i; - int ret_val; - - if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) - YY_FATAL_ERROR( - "fatal flex scanner internal error--end of buffer missed" ); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) - { /* Don't try to fill the buffer, so this is an EOF. */ - if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) - { - /* We matched a single character, the EOB, so - * treat this as a final EOF. - */ - return EOB_ACT_END_OF_FILE; - } - - else - { - /* We matched some text prior to the EOB, first - * process it. - */ - return EOB_ACT_LAST_MATCH; - } - } - - /* Try to read more data. */ - - /* First move last chars to start of buffer. */ - number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; - - for ( i = 0; i < number_to_move; ++i ) - *(dest++) = *(source++); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) - /* don't do the read, it's not guaranteed to return an EOF, - * just force an EOF - */ - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; - - else - { - int num_to_read = - YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; - - while ( num_to_read <= 0 ) - { /* Not enough room in the buffer - grow it. */ - - /* just a shorter name for the current buffer */ - YY_BUFFER_STATE b = YY_CURRENT_BUFFER; - - int yy_c_buf_p_offset = - (int) ((yy_c_buf_p) - b->yy_ch_buf); - - if ( b->yy_is_our_buffer ) - { - int new_size = b->yy_buf_size * 2; - - if ( new_size <= 0 ) - b->yy_buf_size += b->yy_buf_size / 8; - else - b->yy_buf_size *= 2; - - b->yy_ch_buf = (char *) - /* Include room in for 2 EOB chars. */ - llvmAsmrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); - } - else - /* Can't grow it, we don't own it. */ - b->yy_ch_buf = 0; - - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( - "fatal error - scanner input buffer overflow" ); - - (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; - - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - - number_to_move - 1; - - } - - if ( num_to_read > YY_READ_BUF_SIZE ) - num_to_read = YY_READ_BUF_SIZE; - - /* Read in more data. */ - YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), - (yy_n_chars), num_to_read ); - - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - if ( (yy_n_chars) == 0 ) - { - if ( number_to_move == YY_MORE_ADJ ) - { - ret_val = EOB_ACT_END_OF_FILE; - llvmAsmrestart(llvmAsmin ); - } - - else - { - ret_val = EOB_ACT_LAST_MATCH; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = - YY_BUFFER_EOF_PENDING; - } - } - - else - ret_val = EOB_ACT_CONTINUE_SCAN; - - (yy_n_chars) += number_to_move; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; - - (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; - - return ret_val; -} - -/* yy_get_previous_state - get the state just before the EOB char was reached */ - - static yy_state_type yy_get_previous_state (void) -{ - register yy_state_type yy_current_state; - register char *yy_cp; - - yy_current_state = (yy_start); - - for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) - { - register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 609 ) - yy_c = yy_meta[(unsigned int) yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - } - - return yy_current_state; -} - -/* yy_try_NUL_trans - try to make a transition on the NUL character - * - * synopsis - * next_state = yy_try_NUL_trans( current_state ); - */ - static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) -{ - register int yy_is_jam; - register char *yy_cp = (yy_c_buf_p); - - register YY_CHAR yy_c = 1; - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 609 ) - yy_c = yy_meta[(unsigned int) yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - yy_is_jam = (yy_current_state == 608); - - return yy_is_jam ? 0 : yy_current_state; -} - - static inline void yyunput (int c, register char * yy_bp ) -{ - register char *yy_cp; - - yy_cp = (yy_c_buf_p); - - /* undo effects of setting up llvmAsmtext */ - *yy_cp = (yy_hold_char); - - if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) - { /* need to shift things up to make room */ - /* +2 for EOB chars. */ - register int number_to_move = (yy_n_chars) + 2; - register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ - YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; - register char *source = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; - - while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) - *--dest = *--source; - - yy_cp += (int) (dest - source); - yy_bp += (int) (dest - source); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; - - if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) - YY_FATAL_ERROR( "flex scanner push-back overflow" ); - } - - *--yy_cp = (char) c; - - if ( c == '\n' ){ - --llvmAsmlineno; - } - - (yytext_ptr) = yy_bp; - (yy_hold_char) = *yy_cp; - (yy_c_buf_p) = yy_cp; -} - -#ifndef YY_NO_INPUT -#ifdef __cplusplus - static int yyinput (void) -#else - static int input (void) -#endif - -{ - int c; - - *(yy_c_buf_p) = (yy_hold_char); - - if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) - { - /* yy_c_buf_p now points to the character we want to return. - * If this occurs *before* the EOB characters, then it's a - * valid NUL; if not, then we've hit the end of the buffer. - */ - if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) - /* This was really a NUL. */ - *(yy_c_buf_p) = '\0'; - - else - { /* need more input */ - int offset = (yy_c_buf_p) - (yytext_ptr); - ++(yy_c_buf_p); - - switch ( yy_get_next_buffer( ) ) - { - case EOB_ACT_LAST_MATCH: - /* This happens because yy_g_n_b() - * sees that we've accumulated a - * token and flags that we need to - * try matching the token before - * proceeding. But for input(), - * there's no matching to consider. - * So convert the EOB_ACT_LAST_MATCH - * to EOB_ACT_END_OF_FILE. - */ - - /* Reset buffer status. */ - llvmAsmrestart(llvmAsmin ); - - /*FALLTHROUGH*/ - - case EOB_ACT_END_OF_FILE: - { - if ( llvmAsmwrap( ) ) - return EOF; - - if ( ! (yy_did_buffer_switch_on_eof) ) - YY_NEW_FILE; -#ifdef __cplusplus - return yyinput(); -#else - return input(); -#endif - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = (yytext_ptr) + offset; - break; - } - } - } - - c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ - *(yy_c_buf_p) = '\0'; /* preserve llvmAsmtext */ - (yy_hold_char) = *++(yy_c_buf_p); - - if ( c == '\n' ) - - llvmAsmlineno++; -; - - return c; -} -#endif /* ifndef YY_NO_INPUT */ - -/** Immediately switch to a different input stream. - * @param input_file A readable stream. - * - * @note This function does not reset the start condition to @c INITIAL . - */ - void llvmAsmrestart (FILE * input_file ) -{ - - if ( ! YY_CURRENT_BUFFER ){ - llvmAsmensure_buffer_stack (); - YY_CURRENT_BUFFER_LVALUE = - llvmAsm_create_buffer(llvmAsmin,YY_BUF_SIZE ); - } - - llvmAsm_init_buffer(YY_CURRENT_BUFFER,input_file ); - llvmAsm_load_buffer_state( ); -} - -/** Switch to a different input buffer. - * @param new_buffer The new input buffer. - * - */ - void llvmAsm_switch_to_buffer (YY_BUFFER_STATE new_buffer ) -{ - - /* TODO. We should be able to replace this entire function body - * with - * llvmAsmpop_buffer_state(); - * llvmAsmpush_buffer_state(new_buffer); - */ - llvmAsmensure_buffer_stack (); - if ( YY_CURRENT_BUFFER == new_buffer ) - return; - - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - YY_CURRENT_BUFFER_LVALUE = new_buffer; - llvmAsm_load_buffer_state( ); - - /* We don't actually know whether we did this switch during - * EOF (llvmAsmwrap()) processing, but the only time this flag - * is looked at is after llvmAsmwrap() is called, so it's safe - * to go ahead and always set it. - */ - (yy_did_buffer_switch_on_eof) = 1; -} - -static void llvmAsm_load_buffer_state (void) -{ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; - llvmAsmin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; - (yy_hold_char) = *(yy_c_buf_p); -} - -/** Allocate and initialize an input buffer state. - * @param file A readable stream. - * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. - * - * @return the allocated buffer state. - */ - YY_BUFFER_STATE llvmAsm_create_buffer (FILE * file, int size ) -{ - YY_BUFFER_STATE b; - - b = (YY_BUFFER_STATE) llvmAsmalloc(sizeof( struct yy_buffer_state ) ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in llvmAsm_create_buffer()" ); - - b->yy_buf_size = size; - - /* yy_ch_buf has to be 2 characters longer than the size given because - * we need to put in 2 end-of-buffer characters. - */ - b->yy_ch_buf = (char *) llvmAsmalloc(b->yy_buf_size + 2 ); - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in llvmAsm_create_buffer()" ); - - b->yy_is_our_buffer = 1; - - llvmAsm_init_buffer(b,file ); - - return b; -} - -/** Destroy the buffer. - * @param b a buffer created with llvmAsm_create_buffer() - * - */ - void llvmAsm_delete_buffer (YY_BUFFER_STATE b ) -{ - - if ( ! b ) - return; - - if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ - YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; - - if ( b->yy_is_our_buffer ) - llvmAsmfree((void *) b->yy_ch_buf ); - - llvmAsmfree((void *) b ); -} - -/* Initializes or reinitializes a buffer. - * This function is sometimes called more than once on the same buffer, - * such as during a llvmAsmrestart() or at EOF. - */ - static void llvmAsm_init_buffer (YY_BUFFER_STATE b, FILE * file ) - -{ - int oerrno = errno; - - llvmAsm_flush_buffer(b ); - - b->yy_input_file = file; - b->yy_fill_buffer = 1; - - /* If b is the current buffer, then llvmAsm_init_buffer was _probably_ - * called from llvmAsmrestart() or through yy_get_next_buffer. - * In that case, we don't want to reset the lineno or column. - */ - if (b != YY_CURRENT_BUFFER){ - b->yy_bs_lineno = 1; - b->yy_bs_column = 0; - } - - b->yy_is_interactive = 0; - - errno = oerrno; -} - -/** Discard all buffered characters. On the next scan, YY_INPUT will be called. - * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. - * - */ - void llvmAsm_flush_buffer (YY_BUFFER_STATE b ) -{ - if ( ! b ) - return; - - b->yy_n_chars = 0; - - /* We always need two end-of-buffer characters. The first causes - * a transition to the end-of-buffer state. The second causes - * a jam in that state. - */ - b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; - b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; - - b->yy_buf_pos = &b->yy_ch_buf[0]; - - b->yy_at_bol = 1; - b->yy_buffer_status = YY_BUFFER_NEW; - - if ( b == YY_CURRENT_BUFFER ) - llvmAsm_load_buffer_state( ); -} - -/** Pushes the new state onto the stack. The new state becomes - * the current state. This function will allocate the stack - * if necessary. - * @param new_buffer The new state. - * - */ -void llvmAsmpush_buffer_state (YY_BUFFER_STATE new_buffer ) -{ - if (new_buffer == NULL) - return; - - llvmAsmensure_buffer_stack(); - - /* This block is copied from llvmAsm_switch_to_buffer. */ - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - /* Only push if top exists. Otherwise, replace top. */ - if (YY_CURRENT_BUFFER) - (yy_buffer_stack_top)++; - YY_CURRENT_BUFFER_LVALUE = new_buffer; - - /* copied from llvmAsm_switch_to_buffer. */ - llvmAsm_load_buffer_state( ); - (yy_did_buffer_switch_on_eof) = 1; -} - -/** Removes and deletes the top of the stack, if present. - * The next element becomes the new top. - * - */ -void llvmAsmpop_buffer_state (void) -{ - if (!YY_CURRENT_BUFFER) - return; - - llvmAsm_delete_buffer(YY_CURRENT_BUFFER ); - YY_CURRENT_BUFFER_LVALUE = NULL; - if ((yy_buffer_stack_top) > 0) - --(yy_buffer_stack_top); - - if (YY_CURRENT_BUFFER) { - llvmAsm_load_buffer_state( ); - (yy_did_buffer_switch_on_eof) = 1; - } -} - -/* Allocates the stack if it does not exist. - * Guarantees space for at least one push. - */ -static void llvmAsmensure_buffer_stack (void) -{ - int num_to_alloc; - - if (!(yy_buffer_stack)) { - - /* First allocation is just for 2 elements, since we don't know if this - * scanner will even need a stack. We use 2 instead of 1 to avoid an - * immediate realloc on the next call. - */ - num_to_alloc = 1; - (yy_buffer_stack) = (struct yy_buffer_state**)llvmAsmalloc - (num_to_alloc * sizeof(struct yy_buffer_state*) - ); - - memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); - - (yy_buffer_stack_max) = num_to_alloc; - (yy_buffer_stack_top) = 0; - return; - } - - if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ - - /* Increase the buffer to prepare for a possible push. */ - int grow_size = 8 /* arbitrary grow size */; - - num_to_alloc = (yy_buffer_stack_max) + grow_size; - (yy_buffer_stack) = (struct yy_buffer_state**)llvmAsmrealloc - ((yy_buffer_stack), - num_to_alloc * sizeof(struct yy_buffer_state*) - ); - - /* zero only the new slots.*/ - memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); - (yy_buffer_stack_max) = num_to_alloc; - } -} - -/** Setup the input buffer state to scan directly from a user-specified character buffer. - * @param base the character buffer - * @param size the size in bytes of the character buffer - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE llvmAsm_scan_buffer (char * base, yy_size_t size ) -{ - YY_BUFFER_STATE b; - - if ( size < 2 || - base[size-2] != YY_END_OF_BUFFER_CHAR || - base[size-1] != YY_END_OF_BUFFER_CHAR ) - /* They forgot to leave room for the EOB's. */ - return 0; - - b = (YY_BUFFER_STATE) llvmAsmalloc(sizeof( struct yy_buffer_state ) ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in llvmAsm_scan_buffer()" ); - - b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ - b->yy_buf_pos = b->yy_ch_buf = base; - b->yy_is_our_buffer = 0; - b->yy_input_file = 0; - b->yy_n_chars = b->yy_buf_size; - b->yy_is_interactive = 0; - b->yy_at_bol = 1; - b->yy_fill_buffer = 0; - b->yy_buffer_status = YY_BUFFER_NEW; - - llvmAsm_switch_to_buffer(b ); - - return b; -} - -/** Setup the input buffer state to scan a string. The next call to llvmAsmlex() will - * scan from a @e copy of @a str. - * @param str a NUL-terminated string to scan - * - * @return the newly allocated buffer state object. - * @note If you want to scan bytes that may contain NUL values, then use - * llvmAsm_scan_bytes() instead. - */ -YY_BUFFER_STATE llvmAsm_scan_string (yyconst char * yystr ) -{ - - return llvmAsm_scan_bytes(yystr,strlen(yystr) ); -} - -/** Setup the input buffer state to scan the given bytes. The next call to llvmAsmlex() will - * scan from a @e copy of @a bytes. - * @param bytes the byte buffer to scan - * @param len the number of bytes in the buffer pointed to by @a bytes. - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE llvmAsm_scan_bytes (yyconst char * yybytes, int _yybytes_len ) -{ - YY_BUFFER_STATE b; - char *buf; - yy_size_t n; - int i; - - /* Get memory for full buffer, including space for trailing EOB's. */ - n = _yybytes_len + 2; - buf = (char *) llvmAsmalloc(n ); - if ( ! buf ) - YY_FATAL_ERROR( "out of dynamic memory in llvmAsm_scan_bytes()" ); - - for ( i = 0; i < _yybytes_len; ++i ) - buf[i] = yybytes[i]; - - buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - - b = llvmAsm_scan_buffer(buf,n ); - if ( ! b ) - YY_FATAL_ERROR( "bad buffer in llvmAsm_scan_bytes()" ); - - /* It's okay to grow etc. this buffer, and we should throw it - * away when we're done. - */ - b->yy_is_our_buffer = 1; - - return b; -} - -#ifndef YY_EXIT_FAILURE -#define YY_EXIT_FAILURE 2 -#endif - -static void yy_fatal_error (yyconst char* msg ) -{ - (void) fprintf( stderr, "%s\n", msg ); - exit( YY_EXIT_FAILURE ); -} - -/* Redefine yyless() so it works in section 3 code. */ - -#undef yyless -#define yyless(n) \ - do \ - { \ - /* Undo effects of setting up llvmAsmtext. */ \ - int yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg);\ - llvmAsmtext[llvmAsmleng] = (yy_hold_char); \ - (yy_c_buf_p) = llvmAsmtext + yyless_macro_arg; \ - (yy_hold_char) = *(yy_c_buf_p); \ - *(yy_c_buf_p) = '\0'; \ - llvmAsmleng = yyless_macro_arg; \ - } \ - while ( 0 ) - -/* Accessor methods (get/set functions) to struct members. */ - -/** Get the current line number. - * - */ -int llvmAsmget_lineno (void) -{ - - return llvmAsmlineno; -} - -/** Get the input stream. - * - */ -FILE *llvmAsmget_in (void) -{ - return llvmAsmin; -} - -/** Get the output stream. - * - */ -FILE *llvmAsmget_out (void) -{ - return llvmAsmout; -} - -/** Get the length of the current token. - * - */ -int llvmAsmget_leng (void) -{ - return llvmAsmleng; -} - -/** Get the current token. - * - */ - -char *llvmAsmget_text (void) -{ - return llvmAsmtext; -} - -/** Set the current line number. - * @param line_number - * - */ -void llvmAsmset_lineno (int line_number ) -{ - - llvmAsmlineno = line_number; -} - -/** Set the input stream. This does not discard the current - * input buffer. - * @param in_str A readable stream. - * - * @see llvmAsm_switch_to_buffer - */ -void llvmAsmset_in (FILE * in_str ) -{ - llvmAsmin = in_str ; -} - -void llvmAsmset_out (FILE * out_str ) -{ - llvmAsmout = out_str ; -} - -int llvmAsmget_debug (void) -{ - return llvmAsm_flex_debug; -} - -void llvmAsmset_debug (int bdebug ) -{ - llvmAsm_flex_debug = bdebug ; -} - -static int yy_init_globals (void) -{ - /* Initialization is the same as for the non-reentrant scanner. - * This function is called from llvmAsmlex_destroy(), so don't allocate here. - */ - - /* We do not touch llvmAsmlineno unless the option is enabled. */ - llvmAsmlineno = 1; - - (yy_buffer_stack) = 0; - (yy_buffer_stack_top) = 0; - (yy_buffer_stack_max) = 0; - (yy_c_buf_p) = (char *) 0; - (yy_init) = 0; - (yy_start) = 0; - -/* Defined in main.c */ -#ifdef YY_STDINIT - llvmAsmin = stdin; - llvmAsmout = stdout; -#else - llvmAsmin = (FILE *) 0; - llvmAsmout = (FILE *) 0; -#endif - - /* For future reference: Set errno on error, since we are called by - * llvmAsmlex_init() - */ - return 0; -} - -/* llvmAsmlex_destroy is for both reentrant and non-reentrant scanners. */ -int llvmAsmlex_destroy (void) -{ - - /* Pop the buffer stack, destroying each element. */ - while(YY_CURRENT_BUFFER){ - llvmAsm_delete_buffer(YY_CURRENT_BUFFER ); - YY_CURRENT_BUFFER_LVALUE = NULL; - llvmAsmpop_buffer_state(); - } - - /* Destroy the stack itself. */ - llvmAsmfree((yy_buffer_stack) ); - (yy_buffer_stack) = NULL; - - /* Reset the globals. This is important in a non-reentrant scanner so the next time - * llvmAsmlex() is called, initialization will occur. */ - yy_init_globals( ); - - return 0; -} - -/* - * Internal utility routines. - */ - -#ifndef yytext_ptr -static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) -{ - register int i; - for ( i = 0; i < n; ++i ) - s1[i] = s2[i]; -} -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen (yyconst char * s ) -{ - register int n; - for ( n = 0; s[n]; ++n ) - ; - - return n; -} -#endif - -void *llvmAsmalloc (yy_size_t size ) -{ - return (void *) malloc( size ); -} - -void *llvmAsmrealloc (void * ptr, yy_size_t size ) -{ - /* The cast to (char *) in the following accommodates both - * implementations that use char* generic pointers, and those - * that use void* generic pointers. It works with the latter - * because both ANSI C and C++ allow castless assignment from - * any pointer type to void*, and deal with argument conversions - * as though doing an assignment. - */ - return (void *) realloc( (char *) ptr, size ); -} - -void llvmAsmfree (void * ptr ) -{ - free( (char *) ptr ); /* see llvmAsmrealloc() for (char *) cast */ -} - -#define YYTABLES_NAME "yytables" - -#line 512 "/home/asl/proj/llvm/src/lib/AsmParser/Lexer.l" - - - diff --git a/lib/AsmParser/Lexer.l b/lib/AsmParser/Lexer.l deleted file mode 100644 index 98a21cabaaa..00000000000 --- a/lib/AsmParser/Lexer.l +++ /dev/null @@ -1,512 +0,0 @@ -/*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===// -// -// The LLVM Compiler Infrastructure -// -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file implements the flex scanner for LLVM assembly languages files. -// -//===----------------------------------------------------------------------===*/ - -%option prefix="llvmAsm" -%option yylineno -%option nostdinit -%option never-interactive -%option batch -%option noyywrap -%option nodefault -%option 8bit -%option outfile="Lexer.cpp" -%option ecs -%option noreject -%option noyymore - -%{ -#include "ParserInternals.h" -#include "llvm/Module.h" -#include "llvm/Support/MathExtras.h" -#include -#include "llvmAsmParser.h" -#include -#include - -void set_scan_file(FILE * F){ - yy_switch_to_buffer(yy_create_buffer( F, YY_BUF_SIZE ) ); -} -void set_scan_string (const char * str) { - yy_scan_string (str); -} - -// Construct a token value for a non-obsolete token -#define RET_TOK(type, Enum, sym) \ - llvmAsmlval.type = Instruction::Enum; \ - return sym - -// Construct a token value for an obsolete token -#define RET_TY(CTYPE, SYM) \ - llvmAsmlval.PrimType = CTYPE;\ - return SYM - -namespace llvm { - -// TODO: All of the static identifiers are figured out by the lexer, -// these should be hashed to reduce the lexer size - - -// atoull - Convert an ascii string of decimal digits into the unsigned long -// long representation... this does not have to do input error checking, -// because we know that the input will be matched by a suitable regex... -// -static uint64_t atoull(const char *Buffer) { - uint64_t Result = 0; - for (; *Buffer; Buffer++) { - uint64_t OldRes = Result; - Result *= 10; - Result += *Buffer-'0'; - if (Result < OldRes) // Uh, oh, overflow detected!!! - GenerateError("constant bigger than 64 bits detected!"); - } - return Result; -} - -static uint64_t HexIntToVal(const char *Buffer) { - uint64_t Result = 0; - for (; *Buffer; ++Buffer) { - uint64_t OldRes = Result; - Result *= 16; - char C = *Buffer; - if (C >= '0' && C <= '9') - Result += C-'0'; - else if (C >= 'A' && C <= 'F') - Result += C-'A'+10; - else if (C >= 'a' && C <= 'f') - Result += C-'a'+10; - - if (Result < OldRes) // Uh, oh, overflow detected!!! - GenerateError("constant bigger than 64 bits detected!"); - } - return Result; -} - -// HexToFP - Convert the ascii string in hexadecimal format to the floating -// point representation of it. -// -static double HexToFP(const char *Buffer) { - return BitsToDouble(HexIntToVal(Buffer)); // Cast Hex constant to double -} - -static void HexToIntPair(const char *Buffer, uint64_t Pair[2]) { - Pair[0] = 0; - for (int i=0; i<16; i++, Buffer++) { - assert(*Buffer); - Pair[0] *= 16; - char C = *Buffer; - if (C >= '0' && C <= '9') - Pair[0] += C-'0'; - else if (C >= 'A' && C <= 'F') - Pair[0] += C-'A'+10; - else if (C >= 'a' && C <= 'f') - Pair[0] += C-'a'+10; - } - Pair[1] = 0; - for (int i=0; i<16 && *Buffer; i++, Buffer++) { - Pair[1] *= 16; - char C = *Buffer; - if (C >= '0' && C <= '9') - Pair[1] += C-'0'; - else if (C >= 'A' && C <= 'F') - Pair[1] += C-'A'+10; - else if (C >= 'a' && C <= 'f') - Pair[1] += C-'a'+10; - } - if (*Buffer) - GenerateError("constant bigger than 128 bits detected!"); -} - -// UnEscapeLexed - Run through the specified buffer and change \xx codes to the -// appropriate character. -char *UnEscapeLexed(char *Buffer, char* EndBuffer) { - char *BOut = Buffer; - for (char *BIn = Buffer; *BIn; ) { - if (BIn[0] == '\\') { - if (BIn < EndBuffer-1 && BIn[1] == '\\') { - *BOut++ = '\\'; // Two \ becomes one - BIn += 2; - } else if (BIn < EndBuffer-2 && isxdigit(BIn[1]) && isxdigit(BIn[2])) { - char Tmp = BIn[3]; BIn[3] = 0; // Terminate string - *BOut = (char)strtol(BIn+1, 0, 16); // Convert to number - BIn[3] = Tmp; // Restore character - BIn += 3; // Skip over handled chars - ++BOut; - } else { - *BOut++ = *BIn++; - } - } else { - *BOut++ = *BIn++; - } - } - return BOut; -} - -} // End llvm namespace - -using namespace llvm; - -#define YY_NEVER_INTERACTIVE 1 -%} - - - -/* Comments start with a ; and go till end of line */ -Comment ;.* - -/* Local Values and Type identifiers start with a % sign */ -LocalVarName %[-a-zA-Z$._][-a-zA-Z$._0-9]* - -/* Global Value identifiers start with an @ sign */ -GlobalVarName @[-a-zA-Z$._][-a-zA-Z$._0-9]* - -/* Label identifiers end with a colon */ -Label [-a-zA-Z$._0-9]+: -QuoteLabel \"[^\"]+\": - -/* Quoted names can contain any character except " and \ */ -StringConstant \"[^\"]*\" -AtStringConstant @\"[^\"]*\" -PctStringConstant %\"[^\"]*\" - -/* LocalVarID/GlobalVarID: match an unnamed local variable slot ID. */ -LocalVarID %[0-9]+ -GlobalVarID @[0-9]+ - -/* Integer types are specified with i and a bitwidth */ -IntegerType i[0-9]+ - -/* E[PN]Integer: match positive and negative literal integer values. */ -PInteger [0-9]+ -NInteger -[0-9]+ - -/* FPConstant - A Floating point constant. Float and double only. - */ -FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)? - -/* HexFPConstant - Floating point constant represented in IEEE format as a - * hexadecimal number for when exponential notation is not precise enough. - * Float and double only. - */ -HexFPConstant 0x[0-9A-Fa-f]+ - -/* F80HexFPConstant - x87 long double in hexadecimal format (10 bytes) - */ -HexFP80Constant 0xK[0-9A-Fa-f]+ - -/* F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes) - */ -HexFP128Constant 0xL[0-9A-Fa-f]+ - -/* PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes) - */ -HexPPC128Constant 0xM[0-9A-Fa-f]+ - -/* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing - * it to deal with 64 bit numbers. - */ -HexIntConstant [us]0x[0-9A-Fa-f]+ - -/* WSNL - shorthand for whitespace followed by newline */ -WSNL [ \r\t]*$ -%% - -{Comment} { /* Ignore comments for now */ } - -begin { return BEGINTOK; } -end { return ENDTOK; } -true { return TRUETOK; } -false { return FALSETOK; } -declare { return DECLARE; } -define { return DEFINE; } -global { return GLOBAL; } -constant { return CONSTANT; } -internal { return INTERNAL; } -linkonce { return LINKONCE; } -weak { return WEAK; } -appending { return APPENDING; } -dllimport { return DLLIMPORT; } -dllexport { return DLLEXPORT; } -hidden { return HIDDEN; } -protected { return PROTECTED; } -extern_weak { return EXTERN_WEAK; } -external { return EXTERNAL; } -thread_local { return THREAD_LOCAL; } -zeroinitializer { return ZEROINITIALIZER; } -\.\.\. { return DOTDOTDOT; } -undef { return UNDEF; } -null { return NULL_TOK; } -to { return TO; } -tail { return TAIL; } -target { return TARGET; } -triple { return TRIPLE; } -deplibs { return DEPLIBS; } -datalayout { return DATALAYOUT; } -volatile { return VOLATILE; } -align { return ALIGN; } -section { return SECTION; } -alias { return ALIAS; } -module { return MODULE; } -asm { return ASM_TOK; } -sideeffect { return SIDEEFFECT; } - -cc { return CC_TOK; } -ccc { return CCC_TOK; } -fastcc { return FASTCC_TOK; } -coldcc { return COLDCC_TOK; } -x86_stdcallcc { return X86_STDCALLCC_TOK; } -x86_fastcallcc { return X86_FASTCALLCC_TOK; } - -signext { return SIGNEXT; } -zeroext { return ZEROEXT; } -inreg { return INREG; } -sret { return SRET; } -nounwind { return NOUNWIND; } -noreturn { return NORETURN; } -noalias { return NOALIAS; } -byval { return BYVAL; } -nest { return NEST; } -pure { return PURE; } -const { return CONST; } -sext{WSNL} { // For auto-upgrade only, drop in LLVM 3.0 - return SIGNEXT; } -zext{WSNL} { // For auto-upgrade only, drop in LLVM 3.0 - return ZEROEXT; } - -void { RET_TY(Type::VoidTy, VOID); } -float { RET_TY(Type::FloatTy, FLOAT); } -double { RET_TY(Type::DoubleTy,DOUBLE);} -x86_fp80 { RET_TY(Type::X86_FP80Ty, X86_FP80);} -fp128 { RET_TY(Type::FP128Ty, FP128);} -ppc_fp128 { RET_TY(Type::PPC_FP128Ty, PPC_FP128);} -label { RET_TY(Type::LabelTy, LABEL); } -type { return TYPE; } -opaque { return OPAQUE; } -{IntegerType} { uint64_t NumBits = atoull(yytext+1); - if (NumBits < IntegerType::MIN_INT_BITS || - NumBits > IntegerType::MAX_INT_BITS) - GenerateError("Bitwidth for integer type out of range!"); - const Type* Ty = IntegerType::get(NumBits); - RET_TY(Ty, INTTYPE); - } - -add { RET_TOK(BinaryOpVal, Add, ADD); } -sub { RET_TOK(BinaryOpVal, Sub, SUB); } -mul { RET_TOK(BinaryOpVal, Mul, MUL); } -udiv { RET_TOK(BinaryOpVal, UDiv, UDIV); } -sdiv { RET_TOK(BinaryOpVal, SDiv, SDIV); } -fdiv { RET_TOK(BinaryOpVal, FDiv, FDIV); } -urem { RET_TOK(BinaryOpVal, URem, UREM); } -srem { RET_TOK(BinaryOpVal, SRem, SREM); } -frem { RET_TOK(BinaryOpVal, FRem, FREM); } -shl { RET_TOK(BinaryOpVal, Shl, SHL); } -lshr { RET_TOK(BinaryOpVal, LShr, LSHR); } -ashr { RET_TOK(BinaryOpVal, AShr, ASHR); } -and { RET_TOK(BinaryOpVal, And, AND); } -or { RET_TOK(BinaryOpVal, Or , OR ); } -xor { RET_TOK(BinaryOpVal, Xor, XOR); } -icmp { RET_TOK(OtherOpVal, ICmp, ICMP); } -fcmp { RET_TOK(OtherOpVal, FCmp, FCMP); } - -eq { return EQ; } -ne { return NE; } -slt { return SLT; } -sgt { return SGT; } -sle { return SLE; } -sge { return SGE; } -ult { return ULT; } -ugt { return UGT; } -ule { return ULE; } -uge { return UGE; } -oeq { return OEQ; } -one { return ONE; } -olt { return OLT; } -ogt { return OGT; } -ole { return OLE; } -oge { return OGE; } -ord { return ORD; } -uno { return UNO; } -ueq { return UEQ; } -une { return UNE; } - -phi { RET_TOK(OtherOpVal, PHI, PHI_TOK); } -call { RET_TOK(OtherOpVal, Call, CALL); } -trunc { RET_TOK(CastOpVal, Trunc, TRUNC); } -zext { RET_TOK(CastOpVal, ZExt, ZEXT); } -sext { RET_TOK(CastOpVal, SExt, SEXT); } -fptrunc { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); } -fpext { RET_TOK(CastOpVal, FPExt, FPEXT); } -uitofp { RET_TOK(CastOpVal, UIToFP, UITOFP); } -sitofp { RET_TOK(CastOpVal, SIToFP, SITOFP); } -fptoui { RET_TOK(CastOpVal, FPToUI, FPTOUI); } -fptosi { RET_TOK(CastOpVal, FPToSI, FPTOSI); } -inttoptr { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); } -ptrtoint { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); } -bitcast { RET_TOK(CastOpVal, BitCast, BITCAST); } -select { RET_TOK(OtherOpVal, Select, SELECT); } -va_arg { RET_TOK(OtherOpVal, VAArg , VAARG); } -ret { RET_TOK(TermOpVal, Ret, RET); } -br { RET_TOK(TermOpVal, Br, BR); } -switch { RET_TOK(TermOpVal, Switch, SWITCH); } -invoke { RET_TOK(TermOpVal, Invoke, INVOKE); } -unwind { RET_TOK(TermOpVal, Unwind, UNWIND); } -unreachable { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); } - -malloc { RET_TOK(MemOpVal, Malloc, MALLOC); } -alloca { RET_TOK(MemOpVal, Alloca, ALLOCA); } -free { RET_TOK(MemOpVal, Free, FREE); } -load { RET_TOK(MemOpVal, Load, LOAD); } -store { RET_TOK(MemOpVal, Store, STORE); } -getelementptr { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); } - -extractelement { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); } -insertelement { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); } -shufflevector { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); } - - -{LocalVarName} { - llvmAsmlval.StrVal = new std::string(yytext+1); // Skip % - return LOCALVAR; - } -{GlobalVarName} { - llvmAsmlval.StrVal = new std::string(yytext+1); // Skip @ - return GLOBALVAR; - } -{Label} { - yytext[yyleng-1] = 0; // nuke colon - llvmAsmlval.StrVal = new std::string(yytext); - return LABELSTR; - } -{QuoteLabel} { - yytext[yyleng-2] = 0; // nuke colon, end quote - const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng); - llvmAsmlval.StrVal = - new std::string(yytext+1, EndChar - yytext - 1); - return LABELSTR; - } - -{StringConstant} { yytext[yyleng-1] = 0; // nuke end quote - const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng); - llvmAsmlval.StrVal = - new std::string(yytext+1, EndChar - yytext - 1); - return STRINGCONSTANT; - } -{AtStringConstant} { - yytext[yyleng-1] = 0; // nuke end quote - const char* EndChar = - UnEscapeLexed(yytext+2, yytext+yyleng); - llvmAsmlval.StrVal = - new std::string(yytext+2, EndChar - yytext - 2); - return ATSTRINGCONSTANT; - } -{PctStringConstant} { - yytext[yyleng-1] = 0; // nuke end quote - const char* EndChar = - UnEscapeLexed(yytext+2, yytext+yyleng); - llvmAsmlval.StrVal = - new std::string(yytext+2, EndChar - yytext - 2); - return PCTSTRINGCONSTANT; - } -{PInteger} { - uint32_t numBits = ((yyleng * 64) / 19) + 1; - APInt Tmp(numBits, yytext, yyleng, 10); - uint32_t activeBits = Tmp.getActiveBits(); - if (activeBits > 0 && activeBits < numBits) - Tmp.trunc(activeBits); - if (Tmp.getBitWidth() > 64) { - llvmAsmlval.APIntVal = new APInt(Tmp); - return EUAPINTVAL; - } else { - llvmAsmlval.UInt64Val = Tmp.getZExtValue(); - return EUINT64VAL; - } - } -{NInteger} { - uint32_t numBits = (((yyleng-1) * 64) / 19) + 2; - APInt Tmp(numBits, yytext, yyleng, 10); - uint32_t minBits = Tmp.getMinSignedBits(); - if (minBits > 0 && minBits < numBits) - Tmp.trunc(minBits); - if (Tmp.getBitWidth() > 64) { - llvmAsmlval.APIntVal = new APInt(Tmp); - return ESAPINTVAL; - } else { - llvmAsmlval.SInt64Val = Tmp.getSExtValue(); - return ESINT64VAL; - } - } - -{HexIntConstant} { int len = yyleng - 3; - uint32_t bits = len * 4; - APInt Tmp(bits, yytext+3, len, 16); - uint32_t activeBits = Tmp.getActiveBits(); - if (activeBits > 0 && activeBits < bits) - Tmp.trunc(activeBits); - if (Tmp.getBitWidth() > 64) { - llvmAsmlval.APIntVal = new APInt(Tmp); - return yytext[0] == 's' ? ESAPINTVAL : EUAPINTVAL; - } else if (yytext[0] == 's') { - llvmAsmlval.SInt64Val = Tmp.getSExtValue(); - return ESINT64VAL; - } else { - llvmAsmlval.UInt64Val = Tmp.getZExtValue(); - return EUINT64VAL; - } - } - -{LocalVarID} { - uint64_t Val = atoull(yytext+1); - if ((unsigned)Val != Val) - GenerateError("Invalid value number (too large)!"); - llvmAsmlval.UIntVal = unsigned(Val); - return LOCALVAL_ID; - } -{GlobalVarID} { - uint64_t Val = atoull(yytext+1); - if ((unsigned)Val != Val) - GenerateError("Invalid value number (too large)!"); - llvmAsmlval.UIntVal = unsigned(Val); - return GLOBALVAL_ID; - } - -{FPConstant} { llvmAsmlval.FPVal = new APFloat(atof(yytext)); return FPVAL; } -{HexFPConstant} { llvmAsmlval.FPVal = new APFloat(HexToFP(yytext+2)); - return FPVAL; - } -{HexFP80Constant} { uint64_t Pair[2]; - HexToIntPair(yytext+3, Pair); - llvmAsmlval.FPVal = new APFloat(APInt(80, 2, Pair)); - return FPVAL; - } -{HexFP128Constant} { uint64_t Pair[2]; - HexToIntPair(yytext+3, Pair); - llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair), true); - return FPVAL; - } -{HexPPC128Constant} { uint64_t Pair[2]; - HexToIntPair(yytext+3, Pair); - llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair)); - return FPVAL; - } - -<> { - /* Make sure to free the internal buffers for flex when we are - * done reading our input! - */ - yy_delete_buffer(YY_CURRENT_BUFFER); - return EOF; - } - -[ \r\t\n] { /* Ignore whitespace */ } -. { return yytext[0]; } - -%% diff --git a/lib/AsmParser/Lexer.l.cvs b/lib/AsmParser/Lexer.l.cvs deleted file mode 100644 index 98a21cabaaa..00000000000 --- a/lib/AsmParser/Lexer.l.cvs +++ /dev/null @@ -1,512 +0,0 @@ -/*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===// -// -// The LLVM Compiler Infrastructure -// -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file implements the flex scanner for LLVM assembly languages files. -// -//===----------------------------------------------------------------------===*/ - -%option prefix="llvmAsm" -%option yylineno -%option nostdinit -%option never-interactive -%option batch -%option noyywrap -%option nodefault -%option 8bit -%option outfile="Lexer.cpp" -%option ecs -%option noreject -%option noyymore - -%{ -#include "ParserInternals.h" -#include "llvm/Module.h" -#include "llvm/Support/MathExtras.h" -#include -#include "llvmAsmParser.h" -#include -#include - -void set_scan_file(FILE * F){ - yy_switch_to_buffer(yy_create_buffer( F, YY_BUF_SIZE ) ); -} -void set_scan_string (const char * str) { - yy_scan_string (str); -} - -// Construct a token value for a non-obsolete token -#define RET_TOK(type, Enum, sym) \ - llvmAsmlval.type = Instruction::Enum; \ - return sym - -// Construct a token value for an obsolete token -#define RET_TY(CTYPE, SYM) \ - llvmAsmlval.PrimType = CTYPE;\ - return SYM - -namespace llvm { - -// TODO: All of the static identifiers are figured out by the lexer, -// these should be hashed to reduce the lexer size - - -// atoull - Convert an ascii string of decimal digits into the unsigned long -// long representation... this does not have to do input error checking, -// because we know that the input will be matched by a suitable regex... -// -static uint64_t atoull(const char *Buffer) { - uint64_t Result = 0; - for (; *Buffer; Buffer++) { - uint64_t OldRes = Result; - Result *= 10; - Result += *Buffer-'0'; - if (Result < OldRes) // Uh, oh, overflow detected!!! - GenerateError("constant bigger than 64 bits detected!"); - } - return Result; -} - -static uint64_t HexIntToVal(const char *Buffer) { - uint64_t Result = 0; - for (; *Buffer; ++Buffer) { - uint64_t OldRes = Result; - Result *= 16; - char C = *Buffer; - if (C >= '0' && C <= '9') - Result += C-'0'; - else if (C >= 'A' && C <= 'F') - Result += C-'A'+10; - else if (C >= 'a' && C <= 'f') - Result += C-'a'+10; - - if (Result < OldRes) // Uh, oh, overflow detected!!! - GenerateError("constant bigger than 64 bits detected!"); - } - return Result; -} - -// HexToFP - Convert the ascii string in hexadecimal format to the floating -// point representation of it. -// -static double HexToFP(const char *Buffer) { - return BitsToDouble(HexIntToVal(Buffer)); // Cast Hex constant to double -} - -static void HexToIntPair(const char *Buffer, uint64_t Pair[2]) { - Pair[0] = 0; - for (int i=0; i<16; i++, Buffer++) { - assert(*Buffer); - Pair[0] *= 16; - char C = *Buffer; - if (C >= '0' && C <= '9') - Pair[0] += C-'0'; - else if (C >= 'A' && C <= 'F') - Pair[0] += C-'A'+10; - else if (C >= 'a' && C <= 'f') - Pair[0] += C-'a'+10; - } - Pair[1] = 0; - for (int i=0; i<16 && *Buffer; i++, Buffer++) { - Pair[1] *= 16; - char C = *Buffer; - if (C >= '0' && C <= '9') - Pair[1] += C-'0'; - else if (C >= 'A' && C <= 'F') - Pair[1] += C-'A'+10; - else if (C >= 'a' && C <= 'f') - Pair[1] += C-'a'+10; - } - if (*Buffer) - GenerateError("constant bigger than 128 bits detected!"); -} - -// UnEscapeLexed - Run through the specified buffer and change \xx codes to the -// appropriate character. -char *UnEscapeLexed(char *Buffer, char* EndBuffer) { - char *BOut = Buffer; - for (char *BIn = Buffer; *BIn; ) { - if (BIn[0] == '\\') { - if (BIn < EndBuffer-1 && BIn[1] == '\\') { - *BOut++ = '\\'; // Two \ becomes one - BIn += 2; - } else if (BIn < EndBuffer-2 && isxdigit(BIn[1]) && isxdigit(BIn[2])) { - char Tmp = BIn[3]; BIn[3] = 0; // Terminate string - *BOut = (char)strtol(BIn+1, 0, 16); // Convert to number - BIn[3] = Tmp; // Restore character - BIn += 3; // Skip over handled chars - ++BOut; - } else { - *BOut++ = *BIn++; - } - } else { - *BOut++ = *BIn++; - } - } - return BOut; -} - -} // End llvm namespace - -using namespace llvm; - -#define YY_NEVER_INTERACTIVE 1 -%} - - - -/* Comments start with a ; and go till end of line */ -Comment ;.* - -/* Local Values and Type identifiers start with a % sign */ -LocalVarName %[-a-zA-Z$._][-a-zA-Z$._0-9]* - -/* Global Value identifiers start with an @ sign */ -GlobalVarName @[-a-zA-Z$._][-a-zA-Z$._0-9]* - -/* Label identifiers end with a colon */ -Label [-a-zA-Z$._0-9]+: -QuoteLabel \"[^\"]+\": - -/* Quoted names can contain any character except " and \ */ -StringConstant \"[^\"]*\" -AtStringConstant @\"[^\"]*\" -PctStringConstant %\"[^\"]*\" - -/* LocalVarID/GlobalVarID: match an unnamed local variable slot ID. */ -LocalVarID %[0-9]+ -GlobalVarID @[0-9]+ - -/* Integer types are specified with i and a bitwidth */ -IntegerType i[0-9]+ - -/* E[PN]Integer: match positive and negative literal integer values. */ -PInteger [0-9]+ -NInteger -[0-9]+ - -/* FPConstant - A Floating point constant. Float and double only. - */ -FPConstant [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)? - -/* HexFPConstant - Floating point constant represented in IEEE format as a - * hexadecimal number for when exponential notation is not precise enough. - * Float and double only. - */ -HexFPConstant 0x[0-9A-Fa-f]+ - -/* F80HexFPConstant - x87 long double in hexadecimal format (10 bytes) - */ -HexFP80Constant 0xK[0-9A-Fa-f]+ - -/* F128HexFPConstant - IEEE 128-bit in hexadecimal format (16 bytes) - */ -HexFP128Constant 0xL[0-9A-Fa-f]+ - -/* PPC128HexFPConstant - PowerPC 128-bit in hexadecimal format (16 bytes) - */ -HexPPC128Constant 0xM[0-9A-Fa-f]+ - -/* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing - * it to deal with 64 bit numbers. - */ -HexIntConstant [us]0x[0-9A-Fa-f]+ - -/* WSNL - shorthand for whitespace followed by newline */ -WSNL [ \r\t]*$ -%% - -{Comment} { /* Ignore comments for now */ } - -begin { return BEGINTOK; } -end { return ENDTOK; } -true { return TRUETOK; } -false { return FALSETOK; } -declare { return DECLARE; } -define { return DEFINE; } -global { return GLOBAL; } -constant { return CONSTANT; } -internal { return INTERNAL; } -linkonce { return LINKONCE; } -weak { return WEAK; } -appending { return APPENDING; } -dllimport { return DLLIMPORT; } -dllexport { return DLLEXPORT; } -hidden { return HIDDEN; } -protected { return PROTECTED; } -extern_weak { return EXTERN_WEAK; } -external { return EXTERNAL; } -thread_local { return THREAD_LOCAL; } -zeroinitializer { return ZEROINITIALIZER; } -\.\.\. { return DOTDOTDOT; } -undef { return UNDEF; } -null { return NULL_TOK; } -to { return TO; } -tail { return TAIL; } -target { return TARGET; } -triple { return TRIPLE; } -deplibs { return DEPLIBS; } -datalayout { return DATALAYOUT; } -volatile { return VOLATILE; } -align { return ALIGN; } -section { return SECTION; } -alias { return ALIAS; } -module { return MODULE; } -asm { return ASM_TOK; } -sideeffect { return SIDEEFFECT; } - -cc { return CC_TOK; } -ccc { return CCC_TOK; } -fastcc { return FASTCC_TOK; } -coldcc { return COLDCC_TOK; } -x86_stdcallcc { return X86_STDCALLCC_TOK; } -x86_fastcallcc { return X86_FASTCALLCC_TOK; } - -signext { return SIGNEXT; } -zeroext { return ZEROEXT; } -inreg { return INREG; } -sret { return SRET; } -nounwind { return NOUNWIND; } -noreturn { return NORETURN; } -noalias { return NOALIAS; } -byval { return BYVAL; } -nest { return NEST; } -pure { return PURE; } -const { return CONST; } -sext{WSNL} { // For auto-upgrade only, drop in LLVM 3.0 - return SIGNEXT; } -zext{WSNL} { // For auto-upgrade only, drop in LLVM 3.0 - return ZEROEXT; } - -void { RET_TY(Type::VoidTy, VOID); } -float { RET_TY(Type::FloatTy, FLOAT); } -double { RET_TY(Type::DoubleTy,DOUBLE);} -x86_fp80 { RET_TY(Type::X86_FP80Ty, X86_FP80);} -fp128 { RET_TY(Type::FP128Ty, FP128);} -ppc_fp128 { RET_TY(Type::PPC_FP128Ty, PPC_FP128);} -label { RET_TY(Type::LabelTy, LABEL); } -type { return TYPE; } -opaque { return OPAQUE; } -{IntegerType} { uint64_t NumBits = atoull(yytext+1); - if (NumBits < IntegerType::MIN_INT_BITS || - NumBits > IntegerType::MAX_INT_BITS) - GenerateError("Bitwidth for integer type out of range!"); - const Type* Ty = IntegerType::get(NumBits); - RET_TY(Ty, INTTYPE); - } - -add { RET_TOK(BinaryOpVal, Add, ADD); } -sub { RET_TOK(BinaryOpVal, Sub, SUB); } -mul { RET_TOK(BinaryOpVal, Mul, MUL); } -udiv { RET_TOK(BinaryOpVal, UDiv, UDIV); } -sdiv { RET_TOK(BinaryOpVal, SDiv, SDIV); } -fdiv { RET_TOK(BinaryOpVal, FDiv, FDIV); } -urem { RET_TOK(BinaryOpVal, URem, UREM); } -srem { RET_TOK(BinaryOpVal, SRem, SREM); } -frem { RET_TOK(BinaryOpVal, FRem, FREM); } -shl { RET_TOK(BinaryOpVal, Shl, SHL); } -lshr { RET_TOK(BinaryOpVal, LShr, LSHR); } -ashr { RET_TOK(BinaryOpVal, AShr, ASHR); } -and { RET_TOK(BinaryOpVal, And, AND); } -or { RET_TOK(BinaryOpVal, Or , OR ); } -xor { RET_TOK(BinaryOpVal, Xor, XOR); } -icmp { RET_TOK(OtherOpVal, ICmp, ICMP); } -fcmp { RET_TOK(OtherOpVal, FCmp, FCMP); } - -eq { return EQ; } -ne { return NE; } -slt { return SLT; } -sgt { return SGT; } -sle { return SLE; } -sge { return SGE; } -ult { return ULT; } -ugt { return UGT; } -ule { return ULE; } -uge { return UGE; } -oeq { return OEQ; } -one { return ONE; } -olt { return OLT; } -ogt { return OGT; } -ole { return OLE; } -oge { return OGE; } -ord { return ORD; } -uno { return UNO; } -ueq { return UEQ; } -une { return UNE; } - -phi { RET_TOK(OtherOpVal, PHI, PHI_TOK); } -call { RET_TOK(OtherOpVal, Call, CALL); } -trunc { RET_TOK(CastOpVal, Trunc, TRUNC); } -zext { RET_TOK(CastOpVal, ZExt, ZEXT); } -sext { RET_TOK(CastOpVal, SExt, SEXT); } -fptrunc { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); } -fpext { RET_TOK(CastOpVal, FPExt, FPEXT); } -uitofp { RET_TOK(CastOpVal, UIToFP, UITOFP); } -sitofp { RET_TOK(CastOpVal, SIToFP, SITOFP); } -fptoui { RET_TOK(CastOpVal, FPToUI, FPTOUI); } -fptosi { RET_TOK(CastOpVal, FPToSI, FPTOSI); } -inttoptr { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); } -ptrtoint { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); } -bitcast { RET_TOK(CastOpVal, BitCast, BITCAST); } -select { RET_TOK(OtherOpVal, Select, SELECT); } -va_arg { RET_TOK(OtherOpVal, VAArg , VAARG); } -ret { RET_TOK(TermOpVal, Ret, RET); } -br { RET_TOK(TermOpVal, Br, BR); } -switch { RET_TOK(TermOpVal, Switch, SWITCH); } -invoke { RET_TOK(TermOpVal, Invoke, INVOKE); } -unwind { RET_TOK(TermOpVal, Unwind, UNWIND); } -unreachable { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); } - -malloc { RET_TOK(MemOpVal, Malloc, MALLOC); } -alloca { RET_TOK(MemOpVal, Alloca, ALLOCA); } -free { RET_TOK(MemOpVal, Free, FREE); } -load { RET_TOK(MemOpVal, Load, LOAD); } -store { RET_TOK(MemOpVal, Store, STORE); } -getelementptr { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); } - -extractelement { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); } -insertelement { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); } -shufflevector { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); } - - -{LocalVarName} { - llvmAsmlval.StrVal = new std::string(yytext+1); // Skip % - return LOCALVAR; - } -{GlobalVarName} { - llvmAsmlval.StrVal = new std::string(yytext+1); // Skip @ - return GLOBALVAR; - } -{Label} { - yytext[yyleng-1] = 0; // nuke colon - llvmAsmlval.StrVal = new std::string(yytext); - return LABELSTR; - } -{QuoteLabel} { - yytext[yyleng-2] = 0; // nuke colon, end quote - const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng); - llvmAsmlval.StrVal = - new std::string(yytext+1, EndChar - yytext - 1); - return LABELSTR; - } - -{StringConstant} { yytext[yyleng-1] = 0; // nuke end quote - const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng); - llvmAsmlval.StrVal = - new std::string(yytext+1, EndChar - yytext - 1); - return STRINGCONSTANT; - } -{AtStringConstant} { - yytext[yyleng-1] = 0; // nuke end quote - const char* EndChar = - UnEscapeLexed(yytext+2, yytext+yyleng); - llvmAsmlval.StrVal = - new std::string(yytext+2, EndChar - yytext - 2); - return ATSTRINGCONSTANT; - } -{PctStringConstant} { - yytext[yyleng-1] = 0; // nuke end quote - const char* EndChar = - UnEscapeLexed(yytext+2, yytext+yyleng); - llvmAsmlval.StrVal = - new std::string(yytext+2, EndChar - yytext - 2); - return PCTSTRINGCONSTANT; - } -{PInteger} { - uint32_t numBits = ((yyleng * 64) / 19) + 1; - APInt Tmp(numBits, yytext, yyleng, 10); - uint32_t activeBits = Tmp.getActiveBits(); - if (activeBits > 0 && activeBits < numBits) - Tmp.trunc(activeBits); - if (Tmp.getBitWidth() > 64) { - llvmAsmlval.APIntVal = new APInt(Tmp); - return EUAPINTVAL; - } else { - llvmAsmlval.UInt64Val = Tmp.getZExtValue(); - return EUINT64VAL; - } - } -{NInteger} { - uint32_t numBits = (((yyleng-1) * 64) / 19) + 2; - APInt Tmp(numBits, yytext, yyleng, 10); - uint32_t minBits = Tmp.getMinSignedBits(); - if (minBits > 0 && minBits < numBits) - Tmp.trunc(minBits); - if (Tmp.getBitWidth() > 64) { - llvmAsmlval.APIntVal = new APInt(Tmp); - return ESAPINTVAL; - } else { - llvmAsmlval.SInt64Val = Tmp.getSExtValue(); - return ESINT64VAL; - } - } - -{HexIntConstant} { int len = yyleng - 3; - uint32_t bits = len * 4; - APInt Tmp(bits, yytext+3, len, 16); - uint32_t activeBits = Tmp.getActiveBits(); - if (activeBits > 0 && activeBits < bits) - Tmp.trunc(activeBits); - if (Tmp.getBitWidth() > 64) { - llvmAsmlval.APIntVal = new APInt(Tmp); - return yytext[0] == 's' ? ESAPINTVAL : EUAPINTVAL; - } else if (yytext[0] == 's') { - llvmAsmlval.SInt64Val = Tmp.getSExtValue(); - return ESINT64VAL; - } else { - llvmAsmlval.UInt64Val = Tmp.getZExtValue(); - return EUINT64VAL; - } - } - -{LocalVarID} { - uint64_t Val = atoull(yytext+1); - if ((unsigned)Val != Val) - GenerateError("Invalid value number (too large)!"); - llvmAsmlval.UIntVal = unsigned(Val); - return LOCALVAL_ID; - } -{GlobalVarID} { - uint64_t Val = atoull(yytext+1); - if ((unsigned)Val != Val) - GenerateError("Invalid value number (too large)!"); - llvmAsmlval.UIntVal = unsigned(Val); - return GLOBALVAL_ID; - } - -{FPConstant} { llvmAsmlval.FPVal = new APFloat(atof(yytext)); return FPVAL; } -{HexFPConstant} { llvmAsmlval.FPVal = new APFloat(HexToFP(yytext+2)); - return FPVAL; - } -{HexFP80Constant} { uint64_t Pair[2]; - HexToIntPair(yytext+3, Pair); - llvmAsmlval.FPVal = new APFloat(APInt(80, 2, Pair)); - return FPVAL; - } -{HexFP128Constant} { uint64_t Pair[2]; - HexToIntPair(yytext+3, Pair); - llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair), true); - return FPVAL; - } -{HexPPC128Constant} { uint64_t Pair[2]; - HexToIntPair(yytext+3, Pair); - llvmAsmlval.FPVal = new APFloat(APInt(128, 2, Pair)); - return FPVAL; - } - -<> { - /* Make sure to free the internal buffers for flex when we are - * done reading our input! - */ - yy_delete_buffer(YY_CURRENT_BUFFER); - return EOF; - } - -[ \r\t\n] { /* Ignore whitespace */ } -. { return yytext[0]; } - -%% diff --git a/lib/AsmParser/Makefile b/lib/AsmParser/Makefile index 75ae34542a8..b76412a3a03 100644 --- a/lib/AsmParser/Makefile +++ b/lib/AsmParser/Makefile @@ -10,8 +10,7 @@ LEVEL = ../.. LIBRARYNAME := LLVMAsmParser BUILD_ARCHIVE = 1 -EXTRA_DIST := Lexer.cpp.cvs Lexer.l.cvs \ - llvmAsmParser.cpp.cvs llvmAsmParser.h.cvs llvmAsmParser.y.cvs +EXTRA_DIST := llvmAsmParser.cpp.cvs llvmAsmParser.h.cvs llvmAsmParser.y.cvs include $(LEVEL)/Makefile.common @@ -24,4 +23,4 @@ CompileCommonOpts := $(filter-out -Wno-long-long,$(CompileCommonOpts)) # Make the object code file for the lexer depend upon the header file generated # by the Bison parser. This prevents the Lexer from being compiled before the # header file it needs is built. -$(ObjDir)/Lexer.o: $(PROJ_SRC_DIR)/llvmAsmParser.h +$(ObjDir)/LLLexer.o: $(PROJ_SRC_DIR)/llvmAsmParser.h diff --git a/lib/AsmParser/Parser.cpp b/lib/AsmParser/Parser.cpp index b7921f83058..6dbb60f135c 100644 --- a/lib/AsmParser/Parser.cpp +++ b/lib/AsmParser/Parser.cpp @@ -13,38 +13,37 @@ #include "ParserInternals.h" #include "llvm/Module.h" +#include "llvm/Support/MemoryBuffer.h" using namespace llvm; ParseError* TheParseError = 0; /// FIXME: Not threading friendly Module *llvm::ParseAssemblyFile(const std::string &Filename, ParseError* Err) { - FILE *F = stdin; - - if (Filename != "-") { - F = fopen(Filename.c_str(), "r"); - - if (F == 0) { - if (Err) - Err->setError(Filename,"Could not open file '" + Filename + "'"); - return 0; - } + std::string ErrorStr; + MemoryBuffer *F = MemoryBuffer::getFileOrSTDIN(&Filename[0], Filename.size(), + &ErrorStr); + if (F == 0) { + if (Err) + Err->setError(Filename, "Could not open input file '" + Filename + "'"); + return 0; } - + TheParseError = Err; - Module *Result = RunVMAsmParser(Filename, F); - - if (F != stdin) - fclose(F); - + Module *Result = RunVMAsmParser(F); + delete F; return Result; } -Module *llvm::ParseAssemblyString( - const char * AsmString, Module * M, ParseError* Err) -{ +Module *llvm::ParseAssemblyString(const char *AsmString, Module *M, + ParseError *Err) { TheParseError = Err; - return RunVMAsmParser(AsmString, M); + MemoryBuffer *F = MemoryBuffer::getMemBuffer(AsmString, + AsmString+strlen(AsmString), + ""); + Module *Result = RunVMAsmParser(F); + delete F; + return Result; } @@ -54,9 +53,8 @@ Module *llvm::ParseAssemblyString( void ParseError::setError(const std::string &filename, - const std::string &message, - int lineNo, int colNo) -{ + const std::string &message, + int lineNo, int colNo) { Filename = filename; Message = message; LineNo = lineNo; diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index 80a5692e11e..a50eb938213 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -23,37 +23,25 @@ #include "llvm/Assembly/Parser.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/APFloat.h" +namespace llvm { class MemoryBuffer; } // Global variables exported from the lexer... -extern int llvmAsmlineno; /// FIXME: Not threading friendly extern llvm::ParseError* TheParseError; /// FIXME: Not threading friendly -extern std::string &llvmAsmTextin; - // functions exported from the lexer -void set_scan_file(FILE * F); -void set_scan_string (const char * str); - -// Globals exported by the parser... -extern char* llvmAsmtext; -extern int llvmAsmleng; +void InitLLLexer(llvm::MemoryBuffer *MB); +const char *LLLgetTokenStart(); +unsigned LLLgetTokenLength(); +std::string LLLgetFilename(); +unsigned LLLgetLineNo(); +void FreeLexer(); namespace llvm { class Module; -// Globals exported by the parser... -extern std::string CurFilename; /// FIXME: Not threading friendly - -// RunVMAsmParser - Parse a file and return Module -Module *RunVMAsmParser(const std::string &Filename, FILE *F); - -// Parse a string directly -Module *RunVMAsmParser(const char * AsmString, Module * M); - -// UnEscapeLexed - Run through the specified buffer and change \xx codes to the -// appropriate character. -char *UnEscapeLexed(char *Buffer); +// RunVMAsmParser - Parse a buffer and return Module +Module *RunVMAsmParser(llvm::MemoryBuffer *MB); // GenerateError - Wrapper around the ParseException class that automatically // fills in file line number and column number and options info. diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index 3525567cf2c..599300d30f5 100644 --- a/lib/AsmParser/llvmAsmParser.y +++ b/lib/AsmParser/llvmAsmParser.y @@ -29,9 +29,6 @@ #include #include #include -#ifndef NDEBUG -#define YYDEBUG 1 -#endif // The following is a gross hack. In order to rid the libAsmParser library of // exceptions, we have to have a way of getting the yyparse function to go into @@ -51,15 +48,6 @@ static bool TriggerError = false; int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit int yylex(); // declaration" of xxx warnings. int yyparse(); - -namespace llvm { - std::string CurFilename; -#if YYDEBUG -static cl::opt -Debug("debug-yacc", cl::desc("Print yacc debug state changes"), - cl::Hidden, cl::init(false)); -#endif -} using namespace llvm; static Module *ParserResult; @@ -513,7 +501,7 @@ static Value *getVal(const Type *Ty, const ValID &ID) { // Remember where this forward reference came from. FIXME, shouldn't we try // to recycle these things?? CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID, - llvmAsmlineno))); + LLLgetLineNo()))); if (inFunctionScope()) InsertValue(V, CurFun.LateResolveValues); @@ -945,22 +933,11 @@ static PATypeHolder HandleUpRefs(const Type *ty) { // static Module* RunParser(Module * M); -Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) { - set_scan_file(F); - - CurFilename = Filename; - return RunParser(new Module(CurFilename)); -} - -Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) { - set_scan_string(AsmString); - - CurFilename = "from_memory"; - if (M == NULL) { - return RunParser(new Module (CurFilename)); - } else { - return RunParser(M); - } +Module *llvm::RunVMAsmParser(llvm::MemoryBuffer *MB) { + InitLLLexer(MB); + Module *M = RunParser(new Module(LLLgetFilename())); + FreeLexer(); + return M; } %} @@ -3118,13 +3095,7 @@ MemoryInst : MALLOC Types OptCAlign { // common code from the two 'RunVMAsmParser' functions static Module* RunParser(Module * M) { - - llvmAsmlineno = 1; // Reset the current line number... CurModule.CurrentModule = M; -#if YYDEBUG - yydebug = Debug; -#endif - // Check to make sure the parser succeeded if (yyparse()) { if (ParserResult) @@ -3176,21 +3147,21 @@ static Module* RunParser(Module * M) { } void llvm::GenerateError(const std::string &message, int LineNo) { - if (LineNo == -1) LineNo = llvmAsmlineno; + if (LineNo == -1) LineNo = LLLgetLineNo(); // TODO: column number in exception if (TheParseError) - TheParseError->setError(CurFilename, message, LineNo); + TheParseError->setError(LLLgetFilename(), message, LineNo); TriggerError = 1; } int yyerror(const char *ErrorMsg) { - std::string where - = std::string((CurFilename == "-") ? std::string("") : CurFilename) - + ":" + utostr((unsigned) llvmAsmlineno) + ": "; + std::string where = LLLgetFilename() + ":" + utostr(LLLgetLineNo()) + ": "; std::string errMsg = where + "error: " + std::string(ErrorMsg); - if (yychar != YYEMPTY && yychar != 0) - errMsg += " while reading token: '" + std::string(llvmAsmtext, llvmAsmleng)+ - "'"; + if (yychar != YYEMPTY && yychar != 0) { + errMsg += " while reading token: '"; + errMsg += std::string(LLLgetTokenStart(), + LLLgetTokenStart()+LLLgetTokenLength()) + "'"; + } GenerateError(errMsg); return 0; }