diff --git a/llvm/lib/AsmParser/Lexer.l b/llvm/lib/AsmParser/Lexer.l
index 997b620529b0..7183e0e3ce2f 100644
--- a/llvm/lib/AsmParser/Lexer.l
+++ b/llvm/lib/AsmParser/Lexer.l
@@ -101,29 +101,20 @@ static double HexToFP(const char *Buffer) {
 
 
 // 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 exception to be thrown.
-//
-// 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) {
+// appropriate character.
+char *UnEscapeLexed(char *Buffer) {
   char *BOut = Buffer;
   for (char *BIn = Buffer; *BIn; ) {
     if (BIn[0] == '\\' && 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
-      if (!AllowNull && !*BOut)
-        GenerateError("String literal cannot accept \\00 escape!");
-
-      BIn[3] = Tmp;                  // Restore character
-      BIn += 3;                      // Skip over handled chars
+      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++;
     }
   }
-
   return BOut;
 }
 
@@ -321,51 +312,49 @@ shufflevector   { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
 
 
 {LocalVarName}  {
-                  UnEscapeLexed(yytext+1);
-                  llvmAsmlval.StrVal = strdup(yytext+1);             // Skip %
+                  llvmAsmlval.StrVal = new std::string(yytext+1);   // Skip %
                   return LOCALVAR;
                 }
 {GlobalVarName} {
-                  UnEscapeLexed(yytext+1);
-                  llvmAsmlval.StrVal = strdup(yytext+1);             // Skip @
+                  llvmAsmlval.StrVal = new std::string(yytext+1);   // Skip @
                   return GLOBALVAR;
                 }
 {Label}         {
-                  yytext[strlen(yytext)-1] = 0;  // nuke colon
-                  UnEscapeLexed(yytext);
-                  llvmAsmlval.StrVal = strdup(yytext);
+                  yytext[yyleng-1] = 0;            // nuke colon
+                  llvmAsmlval.StrVal = new std::string(yytext);
                   return LABELSTR;
                 }
 {QuoteLabel}    {
-                  yytext[strlen(yytext)-2] = 0;  // nuke colon, end quote
-                  UnEscapeLexed(yytext+1);
-                  llvmAsmlval.StrVal = strdup(yytext+1);
+                  yytext[yyleng-2] = 0;  // nuke colon, end quote
+                  const char* EndChar = UnEscapeLexed(yytext+1);
+                  llvmAsmlval.StrVal = 
+                    new std::string(yytext+1, EndChar - yytext - 1);
                   return LABELSTR;
                 }
 
-{StringConstant} { // Note that we cannot unescape a string constant here!  The
-                   // string constant might contain a \00 which would not be
-                   // understood by the string stuff.  It is valid to make a
-                   // [sbyte] c"Hello World\00" constant, for example.
-                   //
-                   yytext[strlen(yytext)-1] = 0;           // nuke end quote
-                   llvmAsmlval.StrVal = strdup(yytext+1);  // Nuke start quote
+{StringConstant} { yytext[yyleng-1] = 0;           // nuke end quote
+                   const char* EndChar = UnEscapeLexed(yytext+1);
+                   llvmAsmlval.StrVal = 
+                     new std::string(yytext+1, EndChar - yytext - 1);
                    return STRINGCONSTANT;
                  }
 {AtStringConstant} {
-                     yytext[strlen(yytext)-1] = 0;           // nuke end quote
-                     llvmAsmlval.StrVal = strdup(yytext+2);  // Nuke @, quote
+                     yytext[yyleng-1] = 0;         // nuke end quote
+                     const char* EndChar = UnEscapeLexed(yytext+2);
+                     llvmAsmlval.StrVal = 
+                       new std::string(yytext+2, EndChar - yytext - 2);
                      return ATSTRINGCONSTANT;
                    }
-
 {PctStringConstant} {
-                     yytext[strlen(yytext)-1] = 0;           // nuke end quote
-                     llvmAsmlval.StrVal = strdup(yytext+2);  // Nuke %, quote
+                     yytext[yyleng-1] = 0;           // nuke end quote
+                     const char* EndChar = UnEscapeLexed(yytext+2);
+                     llvmAsmlval.StrVal = 
+                       new std::string(yytext+2, EndChar - yytext - 2);
                      return PCTSTRINGCONSTANT;
                    }
-{PInteger}      { int len = strlen(yytext); 
-                  uint32_t numBits = ((len * 64) / 19) + 1;
-                  APInt Tmp(numBits, yytext, len, 10);
+{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);
@@ -377,9 +366,9 @@ shufflevector   { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
                     return EUINT64VAL;
                   }
                 }
-{NInteger}      { int len = strlen(yytext); 
-                  uint32_t numBits = (((len-1) * 64) / 19) + 2;
-                  APInt Tmp(numBits, yytext, len, 10);
+{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);
@@ -392,7 +381,7 @@ shufflevector   { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
                   }
                 }
 
-{HexIntConstant} { int len = strlen(yytext+3) - 3;
+{HexIntConstant} { int len = yyleng - 3;
                    uint32_t bits = len * 4;
                    APInt Tmp(bits, yytext+3, len, 16);
                    uint32_t activeBits = Tmp.getActiveBits();
diff --git a/llvm/lib/AsmParser/ParserInternals.h b/llvm/lib/AsmParser/ParserInternals.h
index 2b50cf6d5540..e315902c31f4 100644
--- a/llvm/lib/AsmParser/ParserInternals.h
+++ b/llvm/lib/AsmParser/ParserInternals.h
@@ -40,28 +40,22 @@ extern char* llvmAsmtext;
 extern int   llvmAsmleng;
 
 namespace llvm {
+class Module;
 
 // Globals exported by the parser...
 extern std::string CurFilename;   /// FIXME: Not threading friendly
 
-class Module;
+// 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.  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);
+// appropriate character.  
+char *UnEscapeLexed(char *Buffer);
 
-
-// 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
@@ -96,7 +90,7 @@ 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
@@ -110,11 +104,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) {
@@ -156,7 +150,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;
   }
@@ -164,7 +158,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;
   }
 
@@ -172,8 +166,8 @@ struct ValID {
     switch (Type) {
     case LocalID       : return '%' + utostr(Num);
     case GlobalID      : return '@' + utostr(Num);
-    case LocalName     : return Name;
-    case GlobalName    : return Name;
+    case LocalName     : return *Name;
+    case GlobalName    : return *Name;
     case ConstFPVal    : return ftostr(ConstPoolFP);
     case ConstNullVal  : return "null";
     case ConstUndefVal : return "undef";
@@ -197,7 +191,7 @@ 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;
@@ -215,7 +209,7 @@ 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;
@@ -240,7 +234,7 @@ typedef std::vector<TypeWithAttrs> TypeWithAttrsList;
 struct ArgListEntry {
   uint16_t Attrs;
   llvm::PATypeHolder *Ty;
-  char *Name;
+  std::string *Name;
 };
 
 typedef std::vector<struct ArgListEntry> ArgListType;
diff --git a/llvm/lib/AsmParser/llvmAsmParser.y b/llvm/lib/AsmParser/llvmAsmParser.y
index 30a1fe6ffb19..01d67ed98036 100644
--- a/llvm/lib/AsmParser/llvmAsmParser.y
+++ b/llvm/lib/AsmParser/llvmAsmParser.y
@@ -282,7 +282,7 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
       return CurModule.Types[D.Num];
     break;
   case ValID::LocalName:                 // Is it a named definition?
-    if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
+    if (const Type *N = CurModule.CurrentModule->getTypeByName(D.getName())) {
       D.destroy();  // Free old strdup'd memory...
       return N;
     }
@@ -360,7 +360,7 @@ static Value *getExistingVal(const Type *Ty, const ValID &D) {
     if (!inFunctionScope()) 
       return 0;
     ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
-    Value *N = SymTab.lookup(D.Name);
+    Value *N = SymTab.lookup(D.getName());
     if (N == 0) 
       return 0;
     if (N->getType() != Ty)
@@ -371,7 +371,7 @@ static Value *getExistingVal(const Type *Ty, const ValID &D) {
   }
   case ValID::GlobalName: {                // Is it a named definition?
     ValueSymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable();
-    Value *N = SymTab.lookup(D.Name);
+    Value *N = SymTab.lookup(D.getName());
     if (N == 0) 
       return 0;
     if (N->getType() != Ty)
@@ -550,7 +550,7 @@ static BasicBlock *defineBBVal(const ValID &ID) {
   
   // We haven't seen this BB before and its first mention is a definition. 
   // Just create it and return it.
-  std::string Name (ID.Type == ValID::LocalName ? ID.Name : "");
+  std::string Name (ID.Type == ValID::LocalName ? ID.getName() : "");
   BB = new BasicBlock(Name, CurFun.CurrentFunction);
   if (ID.Type == ValID::LocalID) {
     assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
@@ -572,7 +572,7 @@ static BasicBlock *getBBVal(const ValID &ID) {
   if (BBI != CurFun.BBForwardRefs.end()) {
     BB = BBI->second;
   } if (ID.Type == ValID::LocalName) {
-    std::string Name = ID.Name;
+    std::string Name = ID.getName();
     Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name);
     if (N)
       if (N->getType()->getTypeID() == Type::LabelTyID)
@@ -603,7 +603,7 @@ static BasicBlock *getBBVal(const ValID &ID) {
   // Otherwise, this block has not been seen before, create it.
   std::string Name;
   if (ID.Type == ValID::LocalName)
-    Name = ID.Name;
+    Name = ID.getName();
   BB = new BasicBlock(Name, CurFun.CurrentFunction);
 
   // Insert it in the forward refs map.
@@ -675,10 +675,12 @@ ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers) {
 // name is not null) things referencing Name can be resolved.  Otherwise, things
 // refering to the number can be resolved.  Do this now.
 //
-static void ResolveTypeTo(char *Name, const Type *ToTy) {
+static void ResolveTypeTo(std::string *Name, const Type *ToTy) {
   ValID D;
-  if (Name) D = ValID::createLocalName(Name);
-  else      D = ValID::createLocalID(CurModule.Types.size());
+  if (Name)
+    D = ValID::createLocalName(*Name);
+  else      
+    D = ValID::createLocalID(CurModule.Types.size());
 
   std::map<ValID, PATypeHolder>::iterator I =
     CurModule.LateResolveTypes.find(D);
@@ -692,10 +694,10 @@ static void ResolveTypeTo(char *Name, const Type *ToTy) {
 // null potentially, in which case this is a noop.  The string passed in is
 // assumed to be a malloc'd string buffer, and is free'd by this function.
 //
-static void setValueName(Value *V, char *NameStr) {
+static void setValueName(Value *V, std::string *NameStr) {
   if (!NameStr) return;
-  std::string Name(NameStr);      // Copy string
-  free(NameStr);                  // Free old string
+  std::string Name(*NameStr);      // Copy string
+  delete NameStr;                  // Free old string
 
   if (V->getType() == Type::VoidTy) {
     GenerateError("Can't assign name '" + Name+"' to value with void type");
@@ -717,7 +719,7 @@ static void setValueName(Value *V, char *NameStr) {
 /// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
 /// this is a declaration, otherwise it is a definition.
 static GlobalVariable *
-ParseGlobalVariable(char *NameStr,
+ParseGlobalVariable(std::string *NameStr,
                     GlobalValue::LinkageTypes Linkage,
                     GlobalValue::VisibilityTypes Visibility,
                     bool isConstantGlobal, const Type *Ty,
@@ -731,15 +733,15 @@ ParseGlobalVariable(char *NameStr,
 
   std::string Name;
   if (NameStr) {
-    Name = NameStr;      // Copy string
-    free(NameStr);       // Free old string
+    Name = *NameStr;      // Copy string
+    delete NameStr;       // Free old string
   }
 
   // See if this global value was forward referenced.  If so, recycle the
   // object.
   ValID ID;
   if (!Name.empty()) {
-    ID = ValID::createGlobalName((char*)Name.c_str());
+    ID = ValID::createGlobalName(Name);
   } else {
     ID = ValID::createGlobalID(CurModule.Values.size());
   }
@@ -792,12 +794,12 @@ ParseGlobalVariable(char *NameStr,
 // This function returns true if the type has already been defined, but is
 // allowed to be redefined in the specified context.  If the name is a new name
 // for the type plane, it is inserted and false is returned.
-static bool setTypeName(const Type *T, char *NameStr) {
+static bool setTypeName(const Type *T, std::string *NameStr) {
   assert(!inFunctionScope() && "Can't give types function-local names!");
   if (NameStr == 0) return false;
  
-  std::string Name(NameStr);      // Copy string
-  free(NameStr);                  // Free old string
+  std::string Name(*NameStr);      // Copy string
+  delete NameStr;                  // Free old string
 
   // We don't allow assigning names to void type
   if (T == Type::VoidTy) {
@@ -987,8 +989,8 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) {
   double                            FPVal;
   bool                              BoolVal;
 
-  char                             *StrVal;   // This memory is strdup'd!
-  llvm::ValID                       ValIDVal; // strdup'd memory maybe!
+  std::string                      *StrVal;   // This memory must be deleted
+  llvm::ValID                       ValIDVal;
 
   llvm::Instruction::BinaryOps      BinaryOpVal;
   llvm::Instruction::TermOps        TermOpVal;
@@ -1051,13 +1053,15 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) {
 %token <PrimType> FLOAT DOUBLE LABEL
 %token TYPE
 
+
 %token<StrVal> LOCALVAR GLOBALVAR LABELSTR 
 %token<StrVal> STRINGCONSTANT ATSTRINGCONSTANT PCTSTRINGCONSTANT
 %type <StrVal> LocalName OptLocalName OptLocalAssign
 %type <StrVal> GlobalName OptGlobalAssign GlobalAssign
-%type <UIntVal> OptAlign OptCAlign
 %type <StrVal> OptSection SectionString
 
+%type <UIntVal> OptAlign OptCAlign
+
 %token ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK
 %token DECLARE DEFINE GLOBAL CONSTANT SECTION ALIAS VOLATILE THREAD_LOCAL
 %token TO DOTDOTDOT NULL_TOK UNDEF INTERNAL LINKONCE WEAK APPENDING
@@ -1139,7 +1143,7 @@ FPredicates
 IntType :  INTTYPE;
 FPType   : FLOAT | DOUBLE;
 
-LocalName : LOCALVAR | STRINGCONSTANT | PCTSTRINGCONSTANT
+LocalName : LOCALVAR | STRINGCONSTANT | PCTSTRINGCONSTANT ;
 OptLocalName : LocalName | /*empty*/ { $$ = 0; };
 
 /// OptLocalAssign - Value producing statements have an optional assignment
@@ -1153,7 +1157,7 @@ OptLocalAssign : LocalName '=' {
     CHECK_FOR_ERROR
   };
 
-GlobalName : GLOBALVAR | ATSTRINGCONSTANT;
+GlobalName : GLOBALVAR | ATSTRINGCONSTANT ;
 
 OptGlobalAssign : GlobalAssign
   | /*empty*/ {
@@ -1262,8 +1266,8 @@ OptCAlign : /*empty*/            { $$ = 0; } |
 
 
 SectionString : SECTION STRINGCONSTANT {
-  for (unsigned i = 0, e = strlen($2); i != e; ++i)
-    if ($2[i] == '"' || $2[i] == '\\')
+  for (unsigned i = 0, e = $2->length(); i != e; ++i)
+    if ((*$2)[i] == '"' || (*$2)[i] == '\\')
       GEN_ERROR("Invalid character in section name");
   $$ = $2;
   CHECK_FOR_ERROR
@@ -1278,8 +1282,8 @@ OptSection : /*empty*/ { $$ = 0; } |
 GlobalVarAttributes : /* empty */ {} |
                      ',' GlobalVarAttribute GlobalVarAttributes {};
 GlobalVarAttribute : SectionString {
-    CurGV->setSection($1);
-    free($1);
+    CurGV->setSection(*$1);
+    delete $1;
     CHECK_FOR_ERROR
   } 
   | ALIGN EUINT64VAL {
@@ -1561,21 +1565,19 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
 
     int NumElements = ATy->getNumElements();
     const Type *ETy = ATy->getElementType();
-    char *EndStr = UnEscapeLexed($3, true);
-    if (NumElements != -1 && NumElements != (EndStr-$3))
+    if (NumElements != -1 && NumElements != int($3->length()))
       GEN_ERROR("Can't build string constant of size " + 
-                     itostr((int)(EndStr-$3)) +
+                     itostr((int)($3->length())) +
                      " when array has size " + itostr(NumElements) + "");
     std::vector<Constant*> Vals;
     if (ETy == Type::Int8Ty) {
-      for (unsigned char *C = (unsigned char *)$3; 
-        C != (unsigned char*)EndStr; ++C)
-      Vals.push_back(ConstantInt::get(ETy, *C));
+      for (unsigned i = 0; i < $3->length(); ++i)
+        Vals.push_back(ConstantInt::get(ETy, (*$3)[i]));
     } else {
-      free($3);
+      delete $3;
       GEN_ERROR("Cannot build string arrays of non byte sized elements");
     }
-    free($3);
+    delete $3;
     $$ = ConstantArray::get(ATy, Vals);
     delete $1;
     CHECK_FOR_ERROR
@@ -1759,7 +1761,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
       } else {
         std::string Name;
         if ($2.Type == ValID::GlobalName)
-          Name = $2.Name;
+          Name = $2.getName();
         else if ($2.Type != ValID::GlobalID)
           GEN_ERROR("Invalid reference to global");
 
@@ -2089,13 +2091,17 @@ Definition
     CHECK_FOR_ERROR
   }
   | OptGlobalAssign GVVisibilityStyle ALIAS AliasLinkage AliaseeRef {
-    std::string Name($1);
+    std::string Name;
+    if ($1) {
+      Name = *$1;
+      delete $1;
+    }
     if (Name.empty())
       GEN_ERROR("Alias name cannot be empty");
     
     Constant* Aliasee = $5;
     if (Aliasee == 0)
-      GEN_ERROR(std::string("Invalid aliasee for alias: ") + $1);
+      GEN_ERROR(std::string("Invalid aliasee for alias: ") + Name);
 
     GlobalAlias* GA = new GlobalAlias(Aliasee->getType(), $4, Name, Aliasee,
                                       CurModule.CurrentModule);
@@ -2114,36 +2120,33 @@ Definition
 
 AsmBlock : STRINGCONSTANT {
   const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
-  char *EndStr = UnEscapeLexed($1, true);
-  std::string NewAsm($1, EndStr);
-  free($1);
-
   if (AsmSoFar.empty())
-    CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
+    CurModule.CurrentModule->setModuleInlineAsm(*$1);
   else
-    CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
+    CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+*$1);
+  delete $1;
   CHECK_FOR_ERROR
 };
 
 TargetDefinition : TRIPLE '=' STRINGCONSTANT {
-    CurModule.CurrentModule->setTargetTriple($3);
-    free($3);
+    CurModule.CurrentModule->setTargetTriple(*$3);
+    delete $3;
   }
   | DATALAYOUT '=' STRINGCONSTANT {
-    CurModule.CurrentModule->setDataLayout($3);
-    free($3);
+    CurModule.CurrentModule->setDataLayout(*$3);
+    delete $3;
   };
 
 LibrariesDefinition : '[' LibList ']';
 
 LibList : LibList ',' STRINGCONSTANT {
-          CurModule.CurrentModule->addLibrary($3);
-          free($3);
+          CurModule.CurrentModule->addLibrary(*$3);
+          delete $3;
           CHECK_FOR_ERROR
         }
         | STRINGCONSTANT {
-          CurModule.CurrentModule->addLibrary($1);
-          free($1);
+          CurModule.CurrentModule->addLibrary(*$1);
+          delete $1;
           CHECK_FOR_ERROR
         }
         | /* empty: end of list */ {
@@ -2205,9 +2208,8 @@ ArgList : ArgListH {
 
 FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')' 
                   OptFuncAttrs OptSection OptAlign {
-  UnEscapeLexed($3);
-  std::string FunctionName($3);
-  free($3);  // Free strdup'd memory!
+  std::string FunctionName(*$3);
+  delete $3;  // Free strdup'd memory!
   
   // Check the function result for abstractness if this is a define. We should
   // have no abstract types at this point
@@ -2296,8 +2298,8 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')'
   Fn->setCallingConv($1);
   Fn->setAlignment($9);
   if ($8) {
-    Fn->setSection($8);
-    free($8);
+    Fn->setSection(*$8);
+    delete $8;
   }
 
   // Add all of the arguments we parsed to the function...
@@ -2314,7 +2316,7 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')'
     for (ArgListType::iterator I = $5->begin(); 
          I != $5->end() && ArgIt != ArgEnd; ++I, ++ArgIt) {
       delete I->Ty;                          // Delete the typeholder...
-      setValueName(ArgIt, I->Name);          // Insert arg into symtab...
+      setValueName(ArgIt, I->Name);       // Insert arg into symtab...
       CHECK_FOR_ERROR
       InsertValue(ArgIt);
       Idx++;
@@ -2426,13 +2428,9 @@ ConstValueRef : ESINT64VAL {    // A reference to a direct constant
     CHECK_FOR_ERROR
   }
   | ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT {
-    char *End = UnEscapeLexed($3, true);
-    std::string AsmStr = std::string($3, End);
-    End = UnEscapeLexed($5, true);
-    std::string Constraints = std::string($5, End);
-    $$ = ValID::createInlineAsm(AsmStr, Constraints, $2);
-    free($3);
-    free($5);
+    $$ = ValID::createInlineAsm(*$3, *$5, $2);
+    delete $3;
+    delete $5;
     CHECK_FOR_ERROR
   };
 
@@ -2448,11 +2446,13 @@ SymbolicValueRef : LOCALVAL_ID {  // Is it an integer reference...?
     CHECK_FOR_ERROR
   }
   | LocalName {                   // Is it a named reference...?
-    $$ = ValID::createLocalName($1);
+    $$ = ValID::createLocalName(*$1);
+    delete $1;
     CHECK_FOR_ERROR
   }
   | GlobalName {                   // Is it a named reference...?
-    $$ = ValID::createGlobalName($1);
+    $$ = ValID::createGlobalName(*$1);
+    delete $1;
     CHECK_FOR_ERROR
   };
 
@@ -2508,8 +2508,10 @@ InstructionList : InstructionList Inst {
     CHECK_FOR_ERROR
   }
   | LABELSTR {             // Labelled (named) basic block
-    $$ = defineBBVal(ValID::createLocalName($1));
+    $$ = defineBBVal(ValID::createLocalName(*$1));
+    delete $1;
     CHECK_FOR_ERROR
+
   };
 
 BBTerminatorInst : RET ResolvedVal {              // Return with a result...