Updated these tests so that they use the new temporary directory as opposed

[oota-llvm.git] / lib / AsmParser / ParserInternals.h

diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h
index fe422d07443da4fb181340a21f6177b73f0193f1..667c08b24206dae3a2559529a7f92636377af72f 100644 (file)
--- a/lib/AsmParser/ParserInternals.h
+++ b/lib/AsmParser/ParserInternals.h
@@ -8,28 +8,25 @@
 #ifndef PARSER_INTERNALS_H
 #define PARSER_INTERNALS_H
 
-#include <stdio.h>
-#define __STDC_LIMIT_MACROS
-
-#include "llvm/InstrTypes.h"
-#include "llvm/BasicBlock.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/Constants.h"
 #include "llvm/iOther.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Assembly/Parser.h"
-#include "llvm/Support/StringExtras.h"
+#include "Support/StringExtras.h"
 
 class Module;
 
 // Global variables exported from the lexer...
-extern FILE *llvmAsmin;
+extern std::FILE *llvmAsmin;
 extern int llvmAsmlineno;
 
 // Globals exported by the parser...
-extern string CurFilename;
-Module *RunVMAsmParser(const string &Filename, FILE *F);
+extern std::string CurFilename;
+Module *RunVMAsmParser(const std::string &Filename, FILE *F);
 
+extern char* llvmAsmtext;
+extern int   llvmAsmleng;
 
 // 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
@@ -47,7 +44,7 @@ char *UnEscapeLexed(char *Buffer, bool AllowNull = false);
 // This also helps me because I keep typing 'throw new ParseException' instead 
 // of just 'throw ParseException'... sigh...
 //
-static inline void ThrowException(const string &message,
+static inline void ThrowException(const std::string &message,
                                  int LineNo = -1) {
   if (LineNo == -1) LineNo = llvmAsmlineno;
   // TODO: column number in exception
@@ -64,8 +61,8 @@ static inline void ThrowException(const string &message,
 //
 struct ValID {
   enum {
-    NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstStringVal, 
-    ConstFPVal, ConstNullVal
+    NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal,
+    ConstantVal,
   } Type;
 
   union {
@@ -74,6 +71,7 @@ struct ValID {
     int64_t  ConstPool64; // Constant pool reference.  This is the value
     uint64_t UConstPool64;// Unsigned constant pool reference.
     double   ConstPoolFP; // Floating point constant pool reference
+    Constant *ConstantValue; // Fully resolved constant for ConstantVal case.
   };
 
   static ValID create(int Num) {
@@ -92,10 +90,6 @@ struct ValID {
     ValID D; D.Type = ConstUIntVal; D.UConstPool64 = Val; return D;
   }
 
-  static ValID create_conststr(char *Name) {
-    ValID D; D.Type = ConstStringVal; D.Name = Name; return D;
-  }
-
   static ValID create(double Val) {
     ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D;
   }
@@ -104,30 +98,38 @@ struct ValID {
     ValID D; D.Type = ConstNullVal; return D;
   }
 
+  static ValID create(Constant *Val) {
+    ValID D; D.Type = ConstantVal; D.ConstantValue = Val; return D;
+  }
+
   inline void destroy() const {
-    if (Type == NameVal || Type == ConstStringVal)
+    if (Type == NameVal)
       free(Name);    // Free this strdup'd memory...
   }
 
   inline ValID copy() const {
-    if (Type != NameVal && Type != ConstStringVal) return *this;
+    if (Type != NameVal) return *this;
     ValID Result = *this;
     Result.Name = strdup(Name);
     return Result;
   }
 
-  inline string getName() const {
+  inline std::string getName() const {
     switch (Type) {
-    case NumberVal     : return string("#") + itostr(Num);
+    case NumberVal     : return std::string("#") + itostr(Num);
     case NameVal       : return Name;
-    case ConstStringVal: return string("\"") + Name + string("\"");
     case ConstFPVal    : return ftostr(ConstPoolFP);
     case ConstNullVal  : return "null";
     case ConstUIntVal  :
-    case ConstSIntVal  : return string("%") + itostr(ConstPool64);
+    case ConstSIntVal  : return std::string("%") + itostr(ConstPool64);
+    case ConstantVal:
+      if (ConstantValue == ConstantBool::True) return "true";
+      if (ConstantValue == ConstantBool::False) return "false";
+      return "<constant expression>";
     default:
       assert(0 && "Unknown value!");
       abort();
+      return "";
     }
   }
 
@@ -135,12 +137,12 @@ struct ValID {
     if (Type != V.Type) return Type < V.Type;
     switch (Type) {
     case NumberVal:     return Num < V.Num;
-    case ConstStringVal:
     case NameVal:       return strcmp(Name, V.Name) < 0;
     case ConstSIntVal:  return ConstPool64  < V.ConstPool64;
     case ConstUIntVal:  return UConstPool64 < V.UConstPool64;
     case ConstFPVal:    return ConstPoolFP  < V.ConstPoolFP;
     case ConstNullVal:  return false;
+    case ConstantVal:   return ConstantValue < V.ConstantValue;
     default:  assert(0 && "Unknown value type!"); return false;
     }
   }
@@ -163,18 +165,19 @@ public:
 struct InstPlaceHolderHelper : public Instruction {
   InstPlaceHolderHelper(const Type *Ty) : Instruction(Ty, UserOp1, "") {}
 
-  virtual Instruction *clone() const { abort(); }
+  virtual Instruction *clone() const { abort(); return 0; }
   virtual const char *getOpcodeName() const { return "placeholder"; }
 };
 
 struct BBPlaceHolderHelper : public BasicBlock {
   BBPlaceHolderHelper(const Type *Ty) : BasicBlock() {
-    assert(Ty->isLabelType());
+    assert(Ty == Type::LabelTy);
   }
 };
 
-struct MethPlaceHolderHelper : public Method {
-  MethPlaceHolderHelper(const Type *Ty) : Method(cast<const MethodType>(Ty)) {}
+struct MethPlaceHolderHelper : public Function {
+  MethPlaceHolderHelper(const Type *Ty)
+    : Function(cast<FunctionType>(Ty), InternalLinkage) {}
 };
 
 typedef PlaceholderValue<InstPlaceHolderHelper>  ValuePlaceHolder;
@@ -183,8 +186,8 @@ typedef PlaceholderValue<BBPlaceHolderHelper>    BBPlaceHolder;
 static inline ValID &getValIDFromPlaceHolder(const Value *Val) {
   const Type *Ty = Val->getType();
   if (isa<PointerType>(Ty) &&
-      isa<MethodType>(cast<PointerType>(Ty)->getValueType()))
-    Ty = cast<PointerType>(Ty)->getValueType();
+      isa<FunctionType>(cast<PointerType>(Ty)->getElementType()))
+    Ty = cast<PointerType>(Ty)->getElementType();
 
   switch (Ty->getPrimitiveID()) {
   case Type::LabelTyID:  return ((BBPlaceHolder*)Val)->getDef();
@@ -195,8 +198,8 @@ static inline ValID &getValIDFromPlaceHolder(const Value *Val) {
 static inline int getLineNumFromPlaceHolder(const Value *Val) {
   const Type *Ty = Val->getType();
   if (isa<PointerType>(Ty) &&
-      isa<MethodType>(cast<PointerType>(Ty)->getValueType()))
-    Ty = cast<PointerType>(Ty)->getValueType();
+      isa<FunctionType>(cast<PointerType>(Ty)->getElementType()))
+    Ty = cast<PointerType>(Ty)->getElementType();
 
   switch (Ty->getPrimitiveID()) {
   case Type::LabelTyID:  return ((BBPlaceHolder*)Val)->getLineNum();