X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FParserInternals.h;h=298dd8c19023fbeda71884efd31052c0af1b21cd;hb=caf746aa5a836bc3401049235c6d7d41c5921502;hp=1bc744bc4bba3b0a2dd0649b0cc3eb77956febce;hpb=b2d17860906ad6c1a2ac7b9564c7145d4cf2409f;p=oota-llvm.git diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index 1bc744bc4bb..298dd8c1902 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -2,8 +2,8 @@ // // 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 is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -17,50 +17,33 @@ #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" +#include "llvm/ParameterAttributes.h" #include "llvm/Function.h" #include "llvm/Instructions.h" #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 { - -// Globals exported by the parser... -extern std::string CurFilename; /// FIXME: Not threading friendly - class Module; -Module *RunVMAsmParser(const std::string &Filename, FILE *F); - -// Parse a string directly -Module *RunVMAsmParser(const char * AsmString, Module * M); +// RunVMAsmParser - Parse a buffer and return Module +Module *RunVMAsmParser(llvm::MemoryBuffer *MB); -// UnEscapeLexed - Run through the specified buffer and change \xx codes to the -// appropriate character. If AllowNull is set to false, a \00 value will cause -// an error. -// -// If AllowNull is set to true, the return value of the function points to the -// last character of the string in memory. -// -char *UnEscapeLexed(char *Buffer, bool AllowNull = false); - - -// ThrowException - Wrapper around the ParseException class that automatically +// GenerateError - Wrapper around the ParseException class that automatically // fills in file line number and column number and options info. // // This also helps me because I keep typing 'throw new ParseException' instead @@ -95,13 +78,13 @@ struct ValID { union { unsigned Num; // If it's a numeric reference like %1234 - char *Name; // If it's a named reference. Memory must be free'd. + std::string *Name; // If it's a named reference. Memory must be deleted. int64_t ConstPool64; // Constant pool reference. This is the value uint64_t UConstPool64;// Unsigned constant pool reference. - double ConstPoolFP; // Floating point constant pool reference + APFloat *ConstPoolFP; // Floating point constant pool reference Constant *ConstantValue; // Fully resolved constant for ConstantVal case. InlineAsmDescriptor *IAD; - }; + }; static ValID createLocalID(unsigned Num) { ValID D; D.Type = LocalID; D.Num = Num; return D; @@ -109,11 +92,11 @@ struct ValID { static ValID createGlobalID(unsigned Num) { ValID D; D.Type = GlobalID; D.Num = Num; return D; } - static ValID createLocalName(char *Name) { - ValID D; D.Type = LocalName; D.Name = Name; return D; + static ValID createLocalName(const std::string &Name) { + ValID D; D.Type = LocalName; D.Name = new std::string(Name); return D; } - static ValID createGlobalName(char *Name) { - ValID D; D.Type = GlobalName; D.Name = Name; return D; + static ValID createGlobalName(const std::string &Name) { + ValID D; D.Type = GlobalName; D.Name = new std::string(Name); return D; } static ValID create(int64_t Val) { @@ -124,7 +107,7 @@ struct ValID { ValID D; D.Type = ConstUIntVal; D.UConstPool64 = Val; return D; } - static ValID create(double Val) { + static ValID create(APFloat *Val) { ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D; } @@ -155,7 +138,7 @@ struct ValID { inline void destroy() const { if (Type == LocalName || Type == GlobalName) - free(Name); // Free this strdup'd memory. + delete Name; // Free this strdup'd memory. else if (Type == InlineAsmVal) delete IAD; } @@ -163,7 +146,7 @@ struct ValID { inline ValID copy() const { if (Type != LocalName && Type != GlobalName) return *this; ValID Result = *this; - Result.Name = strdup(Name); + Result.Name = new std::string(*Name); return Result; } @@ -171,9 +154,9 @@ struct ValID { switch (Type) { case LocalID : return '%' + utostr(Num); case GlobalID : return '@' + utostr(Num); - case LocalName : return Name; - case GlobalName : return Name; - case ConstFPVal : return ftostr(ConstPoolFP); + case LocalName : return *Name; + case GlobalName : return *Name; + case ConstFPVal : return ftostr(*ConstPoolFP); case ConstNullVal : return "null"; case ConstUndefVal : return "undef"; case ConstZeroVal : return "zeroinitializer"; @@ -196,10 +179,11 @@ struct ValID { case LocalID: case GlobalID: return Num < V.Num; case LocalName: - case GlobalName: return strcmp(Name, V.Name) < 0; + case GlobalName: return *Name < *V.Name; case ConstSIntVal: return ConstPool64 < V.ConstPool64; case ConstUIntVal: return UConstPool64 < V.UConstPool64; - case ConstFPVal: return ConstPoolFP < V.ConstPoolFP; + case ConstFPVal: return ConstPoolFP->compare(*V.ConstPoolFP) == + APFloat::cmpLessThan; case ConstNullVal: return false; case ConstUndefVal: return false; case ConstZeroVal: return false; @@ -207,29 +191,50 @@ struct ValID { default: assert(0 && "Unknown value type!"); return false; } } + + bool operator==(const ValID &V) const { + if (Type == V.Type) { + switch (Type) { + case LocalID: + case GlobalID: return Num == V.Num; + case LocalName: + case GlobalName: return *Name == *(V.Name); + case ConstSIntVal: return ConstPool64 == V.ConstPool64; + case ConstUIntVal: return UConstPool64 == V.UConstPool64; + case ConstFPVal: return ConstPoolFP->compare(*V.ConstPoolFP) == + APFloat::cmpEqual; + case ConstantVal: return ConstantValue == V.ConstantValue; + case ConstNullVal: return true; + case ConstUndefVal: return true; + case ConstZeroVal: return true; + default: assert(0 && "Unknown value type!"); return false; + } + } + return false; + } }; struct TypeWithAttrs { llvm::PATypeHolder *Ty; - FunctionType::ParameterAttributes Attrs; + ParameterAttributes Attrs; }; typedef std::vector TypeWithAttrsList; struct ArgListEntry { - FunctionType::ParameterAttributes Attrs; + ParameterAttributes Attrs; llvm::PATypeHolder *Ty; - char *Name; + std::string *Name; }; typedef std::vector ArgListType; -struct ValueRefListEntry { +struct ParamListEntry { Value *Val; - FunctionType::ParameterAttributes Attrs; + ParameterAttributes Attrs; }; -typedef std::vector ValueRefList; +typedef std::vector ParamList; } // End llvm namespace