Remove tabs, and whitespace cleanups.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@81346 91177308-0d34-0410-b5e6-96231b3b80d8

12 files changed, 425 insertions, 425 deletions

diff --git a/include/clang/Basic/Builtins.h b/include/clang/Basic/Builtins.h
index cd05bccfb4..07f091a58a 100644
--- a/include/clang/Basic/Builtins.h
+++ b/include/clang/Basic/Builtins.h
@@ -67,40 +67,40 @@ public:
   /// \brief Popular the vector with the names of all of the builtins.
   void GetBuiltinNames(llvm::SmallVectorImpl<const char *> &Names,
                        bool NoBuiltins);
-  
+
   /// Builtin::GetName - Return the identifier name for the specified builtin,
   /// e.g. "__builtin_abs".
   const char *GetName(unsigned ID) const {
     return GetRecord(ID).Name;
   }
-  
+
   /// GetTypeString - Get the type descriptor string for the specified builtin.
   const char *GetTypeString(unsigned ID) const {
     return GetRecord(ID).Type;
   }
-  
+
   /// isConst - Return true if this function has no side effects and doesn't
   /// read memory.
   bool isConst(unsigned ID) const {
     return strchr(GetRecord(ID).Attributes, 'c') != 0;
   }
-  
+
   /// isNoThrow - Return true if we know this builtin never throws an exception.
   bool isNoThrow(unsigned ID) const {
     return strchr(GetRecord(ID).Attributes, 'n') != 0;
   }
-  
+
   /// isNoReturn - Return true if we know this builtin never returns.
   bool isNoReturn(unsigned ID) const {
     return strchr(GetRecord(ID).Attributes, 'r') != 0;
   }
-  
+
   /// isLibFunction - Return true if this is a builtin for a libc/libm function,
   /// with a "__builtin_" prefix (e.g. __builtin_abs).
   bool isLibFunction(unsigned ID) const {
     return strchr(GetRecord(ID).Attributes, 'F') != 0;
   }
-  
+
   /// \brief Determines whether this builtin is a predefined libc/libm
   /// function, such as "malloc", where we know the signature a
   /// priori.
@@ -124,7 +124,7 @@ public:
   bool hasVAListUse(unsigned ID) const {
     return strpbrk(GetRecord(ID).Type, "Aa") != 0;
   }
-  
+
   /// isConstWithoutErrno - Return true if this function has no side
   /// effects and doesn't read memory, except for possibly errno. Such
   /// functions can be const when the MathErrno lang option is
diff --git a/include/clang/Basic/ConvertUTF.h b/include/clang/Basic/ConvertUTF.h
index 823a7030c2..4da2ad7572 100644
--- a/include/clang/Basic/ConvertUTF.h
+++ b/include/clang/Basic/ConvertUTF.h
@@ -8,9 +8,9 @@
  *==------------------------------------------------------------------------==*/
 /*
  * Copyright 2001-2004 Unicode, Inc.
- * 
+ *
  * Disclaimer
- * 
+ *
  * This source code is provided as is by Unicode, Inc. No claims are
  * made as to fitness for any particular purpose. No warranties of any
  * kind are expressed or implied. The recipient agrees to determine
@@ -18,9 +18,9 @@
  * purchased on magnetic or optical media from Unicode, Inc., the
  * sole remedy for any claim will be exchange of defective media
  * within 90 days of receipt.
- * 
+ *
  * Limitations on Rights to Redistribute This Code
- * 
+ *
  * Unicode, Inc. hereby grants the right to freely use the information
  * supplied in this file in the creation of products supporting the
  * Unicode Standard, and to make copies of this file in any form
@@ -41,7 +41,7 @@
 
     Each routine converts the text between *sourceStart and sourceEnd,
     putting the result into the buffer between *targetStart and
-    targetEnd. Note: the end pointers are *after* the last item: e.g. 
+    targetEnd. Note: the end pointers are *after* the last item: e.g.
     *(sourceEnd - 1) is the last item.
 
     The return result indicates whether the conversion was successful,
@@ -79,7 +79,7 @@
         sequence is malformed.  When "sourceIllegal" is returned, the source
         value will point to the illegal value that caused the problem. E.g.,
         in UTF-8 when a sequence is malformed, it points to the start of the
-        malformed sequence.  
+        malformed sequence.
 
     Author: Mark E. Davis, 1994.
     Rev History: Rick McGowan, fixes & updates May 2001.
@@ -125,28 +125,28 @@ extern "C" {
 #endif
 
 ConversionResult ConvertUTF8toUTF16 (
-  const UTF8** sourceStart, const UTF8* sourceEnd, 
+  const UTF8** sourceStart, const UTF8* sourceEnd,
   UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
 
 #ifdef CLANG_NEEDS_THESE_ONE_DAY
 ConversionResult ConvertUTF16toUTF8 (
-  const UTF16** sourceStart, const UTF16* sourceEnd, 
+  const UTF16** sourceStart, const UTF16* sourceEnd,
   UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
 
 ConversionResult ConvertUTF8toUTF32 (
-  const UTF8** sourceStart, const UTF8* sourceEnd, 
+  const UTF8** sourceStart, const UTF8* sourceEnd,
   UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
 
 ConversionResult ConvertUTF32toUTF8 (
-  const UTF32** sourceStart, const UTF32* sourceEnd, 
+  const UTF32** sourceStart, const UTF32* sourceEnd,
   UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
 
 ConversionResult ConvertUTF16toUTF32 (
-  const UTF16** sourceStart, const UTF16* sourceEnd, 
+  const UTF16** sourceStart, const UTF16* sourceEnd,
   UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
 
 ConversionResult ConvertUTF32toUTF16 (
-  const UTF32** sourceStart, const UTF32* sourceEnd, 
+  const UTF32** sourceStart, const UTF32* sourceEnd,
   UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
 #endif
 
diff --git a/include/clang/Basic/Diagnostic.h b/include/clang/Basic/Diagnostic.h
index be52939c18..dc854b1830 100644
--- a/include/clang/Basic/Diagnostic.h
+++ b/include/clang/Basic/Diagnostic.h
@@ -30,7 +30,7 @@ namespace clang {
   class LangOptions;
   class PartialDiagnostic;
   class SourceRange;
-  
+
   // Import the diagnostic enums themselves.
   namespace diag {
     // Start position for diagnostics.
@@ -46,7 +46,7 @@ namespace clang {
     };
 
     class CustomDiagInfo;
-    
+
     /// diag::kind - All of the diagnostics that can be emitted by the frontend.
     typedef unsigned kind;
 
@@ -57,7 +57,7 @@ namespace clang {
       NUM_BUILTIN_COMMON_DIAGNOSTICS
 #undef DIAG
     };
-      
+
     /// Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs
     /// to either MAP_IGNORE (nothing), MAP_WARNING (emit a warning), MAP_ERROR
     /// (emit as an error).  It allows clients to map errors to
@@ -69,13 +69,13 @@ namespace clang {
       MAP_WARNING = 2,     //< Map this diagnostic to a warning.
       MAP_ERROR   = 3,     //< Map this diagnostic to an error.
       MAP_FATAL   = 4,     //< Map this diagnostic to a fatal error.
-      
+
       /// Map this diagnostic to "warning", but make it immune to -Werror.  This
       /// happens when you specify -Wno-error=foo.
       MAP_WARNING_NO_WERROR = 5
     };
   }
-  
+
 /// \brief Annotates a diagnostic with some code that should be
 /// inserted, removed, or replaced to fix the problem.
 ///
@@ -104,7 +104,7 @@ public:
 
   /// \brief Create a code modification hint that inserts the given
   /// code string at a specific location.
-  static CodeModificationHint CreateInsertion(SourceLocation InsertionLoc, 
+  static CodeModificationHint CreateInsertion(SourceLocation InsertionLoc,
                                               const std::string &Code) {
     CodeModificationHint Hint;
     Hint.InsertionLoc = InsertionLoc;
@@ -122,7 +122,7 @@ public:
 
   /// \brief Create a code modification hint that replaces the given
   /// source range with the given code string.
-  static CodeModificationHint CreateReplacement(SourceRange RemoveRange, 
+  static CodeModificationHint CreateReplacement(SourceRange RemoveRange,
                                                 const std::string &Code) {
     CodeModificationHint Hint;
     Hint.RemoveRange = RemoveRange;
@@ -142,13 +142,13 @@ public:
   enum Level {
     Ignored, Note, Warning, Error, Fatal
   };
-  
+
   /// ExtensionHandling - How do we handle otherwise-unmapped extension?  This
   /// is controlled by -pedantic and -pedantic-errors.
   enum ExtensionHandling {
     Ext_Ignore, Ext_Warn, Ext_Error
   };
-  
+
   enum ArgumentKind {
     ak_std_string,      // std::string
     ak_c_string,        // const char *
@@ -161,10 +161,10 @@ public:
     ak_nestednamespec   // NestedNameSpecifier *
   };
 
-private: 
+private:
   unsigned char AllExtensionsSilenced; // Used by __extension__
   bool IgnoreAllWarnings;        // Ignore all warnings: -w
-  bool WarningsAsErrors;         // Treat warnings like errors: 
+  bool WarningsAsErrors;         // Treat warnings like errors:
   bool SuppressSystemWarnings;   // Suppress warnings in system headers.
   ExtensionHandling ExtBehavior; // Map extensions onto warnings or errors?
   DiagnosticClient *Client;
@@ -183,7 +183,7 @@ private:
   /// fatal error is emitted, and is sticky.
   bool ErrorOccurred;
   bool FatalErrorOccurred;
-  
+
   /// LastDiagLevel - This is the level of the last diagnostic emitted.  This is
   /// used to emit continuation diagnostics with the same level as the
   /// diagnostic that they follow.
@@ -209,16 +209,16 @@ private:
 public:
   explicit Diagnostic(DiagnosticClient *client = 0);
   ~Diagnostic();
-  
+
   //===--------------------------------------------------------------------===//
   //  Diagnostic characterization methods, used by a client to customize how
   //
-  
+
   DiagnosticClient *getClient() { return Client; };
   const DiagnosticClient *getClient() const { return Client; };
-    
 
-  /// pushMappings - Copies the current DiagMappings and pushes the new copy 
+
+  /// pushMappings - Copies the current DiagMappings and pushes the new copy
   /// onto the top of the stack.
   void pushMappings();
 
@@ -234,12 +234,12 @@ public:
   /// ignored.  If this and WarningsAsErrors are both set, then this one wins.
   void setIgnoreAllWarnings(bool Val) { IgnoreAllWarnings = Val; }
   bool getIgnoreAllWarnings() const { return IgnoreAllWarnings; }
-  
+
   /// setWarningsAsErrors - When set to true, any warnings reported are issued
   /// as errors.
   void setWarningsAsErrors(bool Val) { WarningsAsErrors = Val; }
   bool getWarningsAsErrors() const { return WarningsAsErrors; }
-  
+
   /// setSuppressSystemWarnings - When set to true mask warnings that
   /// come from system headers.
   void setSuppressSystemWarnings(bool Val) { SuppressSystemWarnings = Val; }
@@ -251,14 +251,14 @@ public:
   void setExtensionHandlingBehavior(ExtensionHandling H) {
     ExtBehavior = H;
   }
-  
+
   /// AllExtensionsSilenced - This is a counter bumped when an __extension__
   /// block is encountered.  When non-zero, all extension diagnostics are
   /// entirely silenced, no matter how they are mapped.
   void IncrementAllExtensionsSilenced() { ++AllExtensionsSilenced; }
   void DecrementAllExtensionsSilenced() { --AllExtensionsSilenced; }
   bool hasAllExtensionsSilenced() { return AllExtensionsSilenced != 0; }
-  
+
   /// setDiagnosticMapping - This allows the client to specify that certain
   /// warnings are ignored.  Notes can never be mapped, errors can only be
   /// mapped to fatal, and WARNINGs and EXTENSIONs can be mapped arbitrarily.
@@ -269,7 +269,7 @@ public:
            "Cannot map errors!");
     setDiagnosticMappingInternal(Diag, Map, true);
   }
-  
+
   /// setDiagnosticGroupMapping - Change an entire diagnostic group (e.g.
   /// "unknown-pragmas" to have the specified mapping.  This returns true and
   /// ignores the request if "Group" was unknown, false otherwise.
@@ -280,13 +280,13 @@ public:
 
   unsigned getNumErrors() const { return NumErrors; }
   unsigned getNumDiagnostics() const { return NumDiagnostics; }
-  
+
   /// getCustomDiagID - Return an ID for a diagnostic with the specified message
   /// and level.  If this is the first request for this diagnosic, it is
   /// registered and created, otherwise the existing ID is returned.
   unsigned getCustomDiagID(Level L, const char *Message);
-  
-  
+
+
   /// ConvertArgToString - This method converts a diagnostic argument (as an
   /// intptr_t) into the string that represents it.
   void ConvertArgToString(ArgumentKind Kind, intptr_t Val,
@@ -296,12 +296,12 @@ public:
     ArgToStringFn(Kind, Val, Modifier, ModLen, Argument, ArgLen, Output,
                   ArgToStringCookie);
   }
-  
+
   void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie) {
     ArgToStringFn = Fn;
     ArgToStringCookie = Cookie;
   }
-  
+
   //===--------------------------------------------------------------------===//
   // Diagnostic classification and reporting interfaces.
   //
@@ -309,7 +309,7 @@ public:
   /// getDescription - Given a diagnostic ID, return a description of the
   /// issue.
   const char *getDescription(unsigned DiagID) const;
-  
+
   /// isNoteWarningOrExtension - Return true if the unmapped diagnostic
   /// level of the specified diagnostic ID is a Warning or Extension.
   /// This only works on builtin diagnostics, not custom ones, and is not legal to
@@ -319,12 +319,12 @@ public:
   /// \brief Determine whether the given built-in diagnostic ID is a
   /// Note.
   static bool isBuiltinNote(unsigned DiagID);
-  
+
   /// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic
   /// ID is for an extension of some sort.
   ///
   static bool isBuiltinExtensionDiag(unsigned DiagID);
-  
+
   /// getWarningOptionForDiag - Return the lowest-level warning option that
   /// enables the specified diagnostic.  If there is no -Wfoo flag that controls
   /// the diagnostic, this returns null.
@@ -343,8 +343,8 @@ public:
   /// getDiagnosticLevel - Based on the way the client configured the Diagnostic
   /// object, classify the specified diagnostic ID into a Level, consumable by
   /// the DiagnosticClient.
-  Level getDiagnosticLevel(unsigned DiagID) const;  
-  
+  Level getDiagnosticLevel(unsigned DiagID) const;
+
   /// Report - Issue the message to the client.  @c DiagID is a member of the
   /// @c diag::kind enum.  This actually returns aninstance of DiagnosticBuilder
   /// which emits the diagnostics (through @c ProcessDiag) when it is destroyed.
@@ -354,7 +354,7 @@ public:
 
   /// \brief Clear out the current diagnostic.
   void Clear() { CurDiagID = ~0U; }
-  
+
 private:
   /// getDiagnosticMappingInfo - Return the mapping info currently set for the
   /// specified builtin diagnostic.  This returns the high bit encoding, or zero
@@ -363,7 +363,7 @@ private:
     const DiagMappings &currentMappings = DiagMappingsStack.back();
     return (diag::Mapping)((currentMappings[Diag/2] >> (Diag & 1)*4) & 15);
   }
-  
+
   void setDiagnosticMappingInternal(unsigned DiagId, unsigned Map,
                                     bool isUser) const {
     if (isUser) Map |= 8;  // Set the high bit for user mappings.
@@ -372,7 +372,7 @@ private:
     Slot &= ~(15 << Shift);
     Slot |= Map << Shift;
   }
-  
+
   /// getDiagnosticLevel - This is an internal implementation helper used when
   /// DiagClass is already known.
   Level getDiagnosticLevel(unsigned DiagID, unsigned DiagClass) const;
@@ -389,7 +389,7 @@ private:
   /// CurDiagLoc - This is the location of the current diagnostic that is in
   /// flight.
   FullSourceLoc CurDiagLoc;
-  
+
   /// CurDiagID - This is the ID of the current diagnostic that is in flight.
   /// This is set to ~0U when there is no diagnostic in flight.
   unsigned CurDiagID;
@@ -400,7 +400,7 @@ private:
     /// than that almost certainly has to be simplified anyway.
     MaxArguments = 10
   };
-  
+
   /// NumDiagArgs - This contains the number of entries in Arguments.
   signed char NumDiagArgs;
   /// NumRanges - This is the number of ranges in the DiagRanges array.
@@ -413,7 +413,7 @@ private:
   /// values, with one for each argument.  This specifies whether the argument
   /// is in DiagArgumentsStr or in DiagArguments.
   unsigned char DiagArgumentsKind[MaxArguments];
-  
+
   /// DiagArgumentsStr - This holds the values of each string argument for the
   /// current diagnostic.  This value is only used when the corresponding
   /// ArgumentKind is ak_std_string.
@@ -424,11 +424,11 @@ private:
   /// mangled into an intptr_t and the intepretation depends on exactly what
   /// sort of argument kind it is.
   intptr_t DiagArgumentsVal[MaxArguments];
-  
+
   /// DiagRanges - The list of ranges added to this diagnostic.  It currently
   /// only support 10 ranges, could easily be extended if needed.
   const SourceRange *DiagRanges[10];
-  
+
   enum { MaxCodeModificationHints = 3 };
 
   /// CodeModificationHints - If valid, provides a hint with some code
@@ -461,14 +461,14 @@ private:
 class DiagnosticBuilder {
   mutable Diagnostic *DiagObj;
   mutable unsigned NumArgs, NumRanges, NumCodeModificationHints;
-  
+
   void operator=(const DiagnosticBuilder&); // DO NOT IMPLEMENT
   friend class Diagnostic;
   explicit DiagnosticBuilder(Diagnostic *diagObj)
-    : DiagObj(diagObj), NumArgs(0), NumRanges(0), 
+    : DiagObj(diagObj), NumArgs(0), NumRanges(0),
       NumCodeModificationHints(0) {}
 
-public:  
+public:
   /// Copy constructor.  When copied, this "takes" the diagnostic info from the
   /// input and neuters it.
   DiagnosticBuilder(const DiagnosticBuilder &D) {
@@ -485,7 +485,7 @@ public:
 
   /// \brief Create an empty DiagnosticBuilder object that represents
   /// no actual diagnostic.
-  explicit DiagnosticBuilder(SuppressKind) 
+  explicit DiagnosticBuilder(SuppressKind)
     : DiagObj(0), NumArgs(0), NumRanges(0), NumCodeModificationHints(0) { }
 
   /// \brief Force the diagnostic builder to emit the diagnostic now.
@@ -522,7 +522,7 @@ public:
   /// Destructor - The dtor emits the diagnostic if it hasn't already
   /// been emitted.
   ~DiagnosticBuilder() { Emit(); }
-  
+
   /// Operator bool: conversion of DiagnosticBuilder to bool always returns
   /// true.  This allows is to be used in boolean error contexts like:
   /// return Diag(...);
@@ -536,7 +536,7 @@ public:
       DiagObj->DiagArgumentsStr[NumArgs++] = S;
     }
   }
-  
+
   void AddTaggedVal(intptr_t V, Diagnostic::ArgumentKind Kind) const {
     assert(NumArgs < Diagnostic::MaxArguments &&
            "Too many arguments to diagnostic!");
@@ -545,14 +545,14 @@ public:
       DiagObj->DiagArgumentsVal[NumArgs++] = V;
     }
   }
-  
+
   void AddSourceRange(const SourceRange &R) const {
-    assert(NumRanges < 
+    assert(NumRanges <
            sizeof(DiagObj->DiagRanges)/sizeof(DiagObj->DiagRanges[0]) &&
            "Too many arguments to diagnostic!");
     if (DiagObj)
       DiagObj->DiagRanges[NumRanges++] = &R;
-  }    
+  }
 
   void AddCodeModificationHint(const CodeModificationHint &Hint) const {
     assert(NumCodeModificationHints < Diagnostic::MaxCodeModificationHints &&
@@ -597,7 +597,7 @@ inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                   Diagnostic::ak_identifierinfo);
   return DB;
 }
-  
+
 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                            const SourceRange &R) {
   DB.AddSourceRange(R);
@@ -623,7 +623,7 @@ inline DiagnosticBuilder Diagnostic::Report(FullSourceLoc Loc, unsigned DiagID){
 //===----------------------------------------------------------------------===//
 // DiagnosticInfo
 //===----------------------------------------------------------------------===//
-  
+
 /// DiagnosticInfo - This is a little helper class (which is basically a smart
 /// pointer that forward info from Diagnostic) that allows clients to enquire
 /// about the currently in-flight diagnostic.
@@ -631,74 +631,74 @@ class DiagnosticInfo {
   const Diagnostic *DiagObj;
 public:
   explicit DiagnosticInfo(const Diagnostic *DO) : DiagObj(DO) {}
-  
+
   const Diagnostic *getDiags() const { return DiagObj; }
   unsigned getID() const { return DiagObj->CurDiagID; }
   const FullSourceLoc &getLocation() const { return DiagObj->CurDiagLoc; }
-  
+
   unsigned getNumArgs() const { return DiagObj->NumDiagArgs; }
-  
+
   /// getArgKind - Return the kind of the specified index.  Based on the kind
   /// of argument, the accessors below can be used to get the value.
   Diagnostic::ArgumentKind getArgKind(unsigned Idx) const {
     assert(Idx < getNumArgs() && "Argument index out of range!");
     return (Diagnostic::ArgumentKind)DiagObj->DiagArgumentsKind[Idx];
   }
-  
+
   /// getArgStdStr - Return the provided argument string specified by Idx.
   const std::string &getArgStdStr(unsigned Idx) const {
     assert(getArgKind(Idx) == Diagnostic::ak_std_string &&
            "invalid argument accessor!");
     return DiagObj->DiagArgumentsStr[Idx];
   }
-  
+
   /// getArgCStr - Return the specified C string argument.
   const char *getArgCStr(unsigned Idx) const {
     assert(getArgKind(Idx) == Diagnostic::ak_c_string &&
            "invalid argument accessor!");
     return reinterpret_cast<const char*>(DiagObj->DiagArgumentsVal[Idx]);
   }
-  
+
   /// getArgSInt - Return the specified signed integer argument.
   int getArgSInt(unsigned Idx) const {
     assert(getArgKind(Idx) == Diagnostic::ak_sint &&
            "invalid argument accessor!");
     return (int)DiagObj->DiagArgumentsVal[Idx];
   }
-  
+
   /// getArgUInt - Return the specified unsigned integer argument.
   unsigned getArgUInt(unsigned Idx) const {
     assert(getArgKind(Idx) == Diagnostic::ak_uint &&
            "invalid argument accessor!");
     return (unsigned)DiagObj->DiagArgumentsVal[Idx];
   }
-  
+
   /// getArgIdentifier - Return the specified IdentifierInfo argument.
   const IdentifierInfo *getArgIdentifier(unsigned Idx) const {
     assert(getArgKind(Idx) == Diagnostic::ak_identifierinfo &&
            "invalid argument accessor!");
     return reinterpret_cast<IdentifierInfo*>(DiagObj->DiagArgumentsVal[Idx]);
   }
-  
+
   /// getRawArg - Return the specified non-string argument in an opaque form.
   intptr_t getRawArg(unsigned Idx) const {
     assert(getArgKind(Idx) != Diagnostic::ak_std_string &&
            "invalid argument accessor!");
     return DiagObj->DiagArgumentsVal[Idx];
   }
-  
-  
+
+
   /// getNumRanges - Return the number of source ranges associated with this
   /// diagnostic.
   unsigned getNumRanges() const {
     return DiagObj->NumDiagRanges;
   }
-  
+
   const SourceRange &getRange(unsigned Idx) const {
     assert(Idx < DiagObj->NumDiagRanges && "Invalid diagnostic range index!");
     return *DiagObj->DiagRanges[Idx];
   }
-  
+
   unsigned getNumCodeModificationHints() const {
     return DiagObj->NumCodeModificationHints;
   }
@@ -708,7 +708,7 @@ public:
   }
 
   const CodeModificationHint *getCodeModificationHints() const {
-    return DiagObj->NumCodeModificationHints? 
+    return DiagObj->NumCodeModificationHints?
              &DiagObj->CodeModificationHints[0] : 0;
   }
 
@@ -717,20 +717,20 @@ public:
   /// array.
   void FormatDiagnostic(llvm::SmallVectorImpl<char> &OutStr) const;
 };
-  
+
 /// DiagnosticClient - This is an abstract interface implemented by clients of
 /// the front-end, which formats and prints fully processed diagnostics.
 class DiagnosticClient {
 public:
   virtual ~DiagnosticClient();
-  
+
   /// setLangOptions - This is set by clients of diagnostics when they know the
   /// language parameters of the diagnostics that may be sent through.  Note
   /// that this can change over time if a DiagClient has multiple languages sent
   /// through it.  It may also be set to null (e.g. when processing command line
   /// options).
   virtual void setLangOptions(const LangOptions *LO) {}
-  
+
   /// IncludeInDiagnosticCounts - This method (whose default implementation
   ///  returns true) indicates whether the diagnostics handled by this
   ///  DiagnosticClient should be included in the number of diagnostics
diff --git a/include/clang/Basic/FileManager.h b/include/clang/Basic/FileManager.h
index d684449c85..7c9113c497 100644
--- a/include/clang/Basic/FileManager.h
+++ b/include/clang/Basic/FileManager.h
@@ -25,7 +25,7 @@
 
 namespace clang {
 class FileManager;
-  
+
 /// DirectoryEntry - Cached information about one directory on the disk.
 ///
 class DirectoryEntry {
@@ -33,7 +33,7 @@ class DirectoryEntry {
   friend class FileManager;
 public:
   DirectoryEntry() : Name(0) {}
-  const char *getName() const { return Name; } 
+  const char *getName() const { return Name; }
 };
 
 /// FileEntry - Cached information about one file on the disk.
@@ -53,7 +53,7 @@ public:
     : Name(0), Device(device), Inode(inode), FileMode(m) {}
   // Add a default constructor for use with llvm::StringMap
   FileEntry() : Name(0), Device(0), Inode(0), FileMode(0) {}
-  
+
   const char *getName() const { return Name; }
   off_t getSize() const { return Size; }
   unsigned getUID() const { return UID; }
@@ -61,11 +61,11 @@ public:
   dev_t getDevice() const { return Device; }
   time_t getModificationTime() const { return ModTime; }
   mode_t getFileMode() const { return FileMode; }
-  
+
   /// getDir - Return the directory the file lives in.
   ///
   const DirectoryEntry *getDir() const { return Dir; }
-  
+
   bool operator<(const FileEntry& RHS) const {
     return Device < RHS.Device || (Device == RHS.Device && Inode < RHS.Inode);
   }
@@ -85,19 +85,19 @@ public:
 /// execution of the front end.
 class MemorizeStatCalls : public StatSysCallCache {
 public:
-  /// \brief The result of a stat() call. 
+  /// \brief The result of a stat() call.
   ///
   /// The first member is the result of calling stat(). If stat()
   /// found something, the second member is a copy of the stat
   /// structure.
   typedef std::pair<int, struct stat> StatResult;
 
-  /// \brief The set of stat() calls that have been 
+  /// \brief The set of stat() calls that have been
   llvm::StringMap<StatResult, llvm::BumpPtrAllocator> StatCalls;
 
   typedef llvm::StringMap<StatResult, llvm::BumpPtrAllocator>::const_iterator
     iterator;
-  
+
   iterator begin() const { return StatCalls.begin(); }
   iterator end() const { return StatCalls.end(); }
 
@@ -124,22 +124,22 @@ class FileManager {
   ///
   llvm::StringMap<DirectoryEntry*, llvm::BumpPtrAllocator> DirEntries;
   llvm::StringMap<FileEntry*, llvm::BumpPtrAllocator> FileEntries;
-  
+
   /// NextFileUID - Each FileEntry we create is assigned a unique ID #.
   ///
   unsigned NextFileUID;
-  
+
   // Statistics.
   unsigned NumDirLookups, NumFileLookups;
   unsigned NumDirCacheMisses, NumFileCacheMisses;
-  
+
   // Caching.
   llvm::OwningPtr<StatSysCallCache> StatCache;
 
   int stat_cached(const char* path, struct stat* buf) {
     return StatCache.get() ? StatCache->stat(path, buf) : stat(path, buf);
   }
-  
+
 public:
   FileManager();
   ~FileManager();
@@ -150,24 +150,24 @@ public:
   void setStatCache(StatSysCallCache *statCache) {
     StatCache.reset(statCache);
   }
-  
+
   /// getDirectory - Lookup, cache, and verify the specified directory.  This
   /// returns null if the directory doesn't exist.
-  /// 
+  ///
   const DirectoryEntry *getDirectory(const llvm::StringRef &Filename) {
     return getDirectory(Filename.begin(), Filename.end());
   }
   const DirectoryEntry *getDirectory(const char *FileStart,const char *FileEnd);
-  
+
   /// getFile - Lookup, cache, and verify the specified file.  This returns null
   /// if the file doesn't exist.
-  /// 
+  ///
   const FileEntry *getFile(const llvm::StringRef &Filename) {
     return getFile(Filename.begin(), Filename.end());
   }
   const FileEntry *getFile(const char *FilenameStart,
                            const char *FilenameEnd);
-  
+
   void PrintStats() const;
 };
 
diff --git a/include/clang/Basic/IdentifierTable.h b/include/clang/Basic/IdentifierTable.h
index 57cd311631..8512538e45 100644
--- a/include/clang/Basic/IdentifierTable.h
+++ b/include/clang/Basic/IdentifierTable.h
@@ -21,8 +21,8 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
-#include <string> 
-#include <cassert> 
+#include <string>
+#include <cassert>
 
 namespace llvm {
   template <typename T> struct DenseMapInfo;
@@ -38,21 +38,21 @@ namespace clang {
 
   /// IdentifierLocPair - A simple pair of identifier info and location.
   typedef std::pair<IdentifierInfo*, SourceLocation> IdentifierLocPair;
-  
-  
+
+
 /// IdentifierInfo - One of these records is kept for each identifier that
 /// is lexed.  This contains information about whether the token was #define'd,
 /// is a language keyword, or if it is a front-end token of some sort (e.g. a
 /// variable or function name).  The preprocessor keeps this information in a
-/// set, and all tok::identifier tokens have a pointer to one of these.  
+/// set, and all tok::identifier tokens have a pointer to one of these.
 class IdentifierInfo {
   // Note: DON'T make TokenID a 'tok::TokenKind'; MSVC will treat it as a
   //       signed char and TokenKinds > 127 won't be handled correctly.
-  unsigned TokenID            : 8; // Front-end token ID or tok::identifier. 
+  unsigned TokenID            : 8; // Front-end token ID or tok::identifier.
   // Objective-C keyword ('protocol' in '@protocol') or builtin (__builtin_inf).
   // First NUM_OBJC_KEYWORDS values are for Objective-C, the remaining values
   // are for builtins.
-  unsigned ObjCOrBuiltinID    :10; 
+  unsigned ObjCOrBuiltinID    :10;
   bool HasMacro               : 1; // True if there is a #define for this.
   bool IsExtension            : 1; // True if identifier is a lang extension.
   bool IsPoisoned             : 1; // True if identifier is poisoned.
@@ -61,50 +61,50 @@ class IdentifierInfo {
   // 9 bits left in 32-bit word.
   void *FETokenInfo;               // Managed by the language front-end.
   llvm::StringMapEntry<IdentifierInfo*> *Entry;
-  
+
   IdentifierInfo(const IdentifierInfo&);  // NONCOPYABLE.
   void operator=(const IdentifierInfo&);  // NONASSIGNABLE.
 
-  friend class IdentifierTable;  
+  friend class IdentifierTable;
 
 public:
   IdentifierInfo();
 
-  
+
   /// isStr - Return true if this is the identifier for the specified string.
   /// This is intended to be used for string literals only: II->isStr("foo").
   template <std::size_t StrLen>
   bool isStr(const char (&Str)[StrLen]) const {
     return getLength() == StrLen-1 && !memcmp(getName(), Str, StrLen-1);
   }
-  
-  /// getName - Return the actual string for this identifier.  The returned 
+
+  /// getName - Return the actual string for this identifier.  The returned
   /// string is properly null terminated.
   ///
-  const char *getName() const {    
+  const char *getName() const {
     if (Entry) return Entry->getKeyData();
     // FIXME: This is gross. It would be best not to embed specific details
     // of the PTH file format here.
-    // The 'this' pointer really points to a 
+    // The 'this' pointer really points to a
     // std::pair<IdentifierInfo, const char*>, where internal pointer
     // points to the external string data.
     return ((std::pair<IdentifierInfo, const char*>*) this)->second;
   }
-  
+
   /// getLength - Efficiently return the length of this identifier info.
   ///
   unsigned getLength() const {
     if (Entry) return Entry->getKeyLength();
     // FIXME: This is gross. It would be best not to embed specific details
     // of the PTH file format here.
-    // The 'this' pointer really points to a 
+    // The 'this' pointer really points to a
     // std::pair<IdentifierInfo, const char*>, where internal pointer
     // points to the external string data.
     const char* p = ((std::pair<IdentifierInfo, const char*>*) this)->second-2;
     return (((unsigned) p[0])
         | (((unsigned) p[1]) << 8)) - 1;
   }
-  
+
   /// hasMacroDefinition - Return true if this identifier is #defined to some
   /// other value.
   bool hasMacroDefinition() const {
@@ -112,29 +112,29 @@ public:
   }
   void setHasMacroDefinition(bool Val) {
     if (HasMacro == Val) return;
-    
+
     HasMacro = Val;
     if (Val)
       NeedsHandleIdentifier = 1;
     else
       RecomputeNeedsHandleIdentifier();
   }
-  
+
   /// get/setTokenID - If this is a source-language token (e.g. 'for'), this API
   /// can be used to cause the lexer to map identifiers to source-language
   /// tokens.
   tok::TokenKind getTokenID() const { return (tok::TokenKind)TokenID; }
   void setTokenID(tok::TokenKind ID) { TokenID = ID; }
-  
+
   /// getPPKeywordID - Return the preprocessor keyword ID for this identifier.
   /// For example, "define" will return tok::pp_define.
   tok::PPKeywordKind getPPKeywordID() const;
-  
+
   /// getObjCKeywordID - Return the Objective-C keyword ID fo