1 files changed, 35 insertions, 35 deletions

diff --git a/include/clang/Lex/Token.h b/include/clang/Lex/Token.h
index 2c8f2ad3f2b62..8acdb30cc705a 100644
--- a/include/clang/Lex/Token.h
+++ b/include/clang/Lex/Token.h
@@ -62,14 +62,14 @@ class Token {
 
   /// Kind - The actual flavor of token this is.
   ///
-  unsigned Kind : 8;  // DON'T make Kind a 'tok::TokenKind'; 
+  unsigned Kind : 8;  // DON'T make Kind a 'tok::TokenKind';
                       // MSVC will treat it as a signed char and
                       // TokenKinds > 127 won't be handled correctly.
-  
+
   /// Flags - Bits we track about this token, members of the TokenFlags enum.
   unsigned Flags : 8;
 public:
-    
+
   // Various flags set per token:
   enum TokenFlags {
     StartOfLine   = 0x01,  // At start of line or only after whitespace.
@@ -80,7 +80,7 @@ public:
 
   tok::TokenKind getKind() const { return (tok::TokenKind)Kind; }
   void setKind(tok::TokenKind K) { Kind = K; }
-  
+
   /// is/isNot - Predicates to check if this token is a specific kind, as in
   /// "if (Tok.is(tok::l_brace)) {...}".
   bool is(tok::TokenKind K) const { return Kind == (unsigned) K; }
@@ -94,12 +94,12 @@ public:
            is(tok::angle_string_literal);
   }
 
-  bool isAnnotation() const { 
-    return is(tok::annot_typename) || 
+  bool isAnnotation() const {
+    return is(tok::annot_typename) ||
            is(tok::annot_cxxscope) ||
            is(tok::annot_template_id);
   }
-  
+
   /// getLocation - Return a source location identifier for the specified
   /// offset in the current file.
   SourceLocation getLocation() const { return Loc; }
@@ -132,11 +132,11 @@ public:
     setLocation(R.getBegin());
     setAnnotationEndLoc(R.getEnd());
   }
-  
+
   const char *getName() const {
     return tok::getTokenName( (tok::TokenKind) Kind);
   }
-  
+
   /// startToken - Reset all flags to cleared.
   ///
   void startToken() {
@@ -145,7 +145,7 @@ public:
     PtrData = 0;
     Loc = SourceLocation();
   }
-  
+
   IdentifierInfo *getIdentifierInfo() const {
     assert(!isAnnotation() && "Used IdentInfo on annotation token!");
     if (isLiteral()) return 0;
@@ -154,7 +154,7 @@ public:
   void setIdentifierInfo(IdentifierInfo *II) {
     PtrData = (void*) II;
   }
-  
+
   /// getLiteralData - For a literal token (numeric constant, string, etc), this
   /// returns a pointer to the start of it in the text buffer if known, null
   /// otherwise.
@@ -166,7 +166,7 @@ public:
     assert(isLiteral() && "Cannot set literal data of non-literal");
     PtrData = (void*)Ptr;
   }
-  
+
   void *getAnnotationValue() const {
     assert(isAnnotation() && "Used AnnotVal on non-annotation token");
     return PtrData;
@@ -175,17 +175,17 @@ public:
     assert(isAnnotation() && "Used AnnotVal on non-annotation token");
     PtrData = val;
   }
-  
+
   /// setFlag - Set the specified flag.
   void setFlag(TokenFlags Flag) {
     Flags |= Flag;
   }
-  
+
   /// clearFlag - Unset the specified flag.
   void clearFlag(TokenFlags Flag) {
     Flags &= ~Flag;
   }
-  
+
   /// getFlags - Return the internal represtation of the flags.
   ///  Only intended for low-level operations such as writing tokens to
   //   disk.
@@ -195,32 +195,32 @@ public:
 
   /// setFlagValue - Set a flag to either true or false.
   void setFlagValue(TokenFlags Flag, bool Val) {
-    if (Val) 
+    if (Val)
       setFlag(Flag);
     else
       clearFlag(Flag);
   }
-  
+
   /// isAtStartOfLine - Return true if this token is at the start of a line.
   ///
   bool isAtStartOfLine() const { return (Flags & StartOfLine) ? true : false; }
-  
+
   /// hasLeadingSpace - Return true if this token has whitespace before it.
   ///
   bool hasLeadingSpace() const { return (Flags & LeadingSpace) ? true : false; }
-  
+
   /// isExpandDisabled - Return true if this identifier token should never
   /// be expanded in the future, due to C99 6.10.3.4p2.
   bool isExpandDisabled() const {
     return (Flags & DisableExpand) ? true : false;
   }
-  
-  /// isObjCAtKeyword - Return true if we have an ObjC keyword identifier. 
+
+  /// isObjCAtKeyword - Return true if we have an ObjC keyword identifier.
   bool isObjCAtKeyword(tok::ObjCKeywordKind objcKey) const;
-  
+
   /// getObjCKeywordID - Return the ObjC keyword kind.
   tok::ObjCKeywordKind getObjCKeywordID() const;
-  
+
   /// needsCleaning - Return true if this token has trigraphs or escaped
   /// newlines in it.
   ///
@@ -233,15 +233,15 @@ struct PPConditionalInfo {
   /// IfLoc - Location where the conditional started.
   ///
   SourceLocation IfLoc;
-  
+
   /// WasSkipping - True if this was contained in a skipping directive, e.g.
   /// in a "#if 0" block.
   bool WasSkipping;
-  
+
   /// FoundNonSkip - True if we have emitted tokens already, and now we're in
   /// an #else block or something.  Only useful in Skipping blocks.
   bool FoundNonSkip;
-  
+
   /// FoundElse - True if we've seen a #else in this block.  If so,
   /// #elif/#else directives are not allowed.
   bool FoundElse;
@@ -263,41 +263,41 @@ struct TemplateIdAnnotation {
 
   /// The declaration of the template corresponding to the
   /// template-name. This is an Action::DeclTy*.
-  void *Template; 
+  void *Template;
 
   /// The kind of template that Template refers to.
   TemplateNameKind Kind;
 
   /// The location of the '<' before the template argument
-  /// list. 
+  /// list.
   SourceLocation LAngleLoc;
 
   /// The location of the '>' after the template argument
-  /// list. 
+  /// list.
   SourceLocation RAngleLoc;
 
   /// NumArgs - The number of template arguments.
-  unsigned NumArgs; 
+  unsigned NumArgs;
 
   /// \brief Retrieves a pointer to the template arguments
   void **getTemplateArgs() { return (void **)(this + 1); }
 
   /// \brief Retrieves a pointer to the array of template argument
   /// locations.
-  SourceLocation *getTemplateArgLocations() { 
+  SourceLocation *getTemplateArgLocations() {
     return (SourceLocation *)(getTemplateArgs() + NumArgs);
   }
 
   /// \brief Retrieves a pointer to the array of flags that states
   /// whether the template arguments are types.
-  bool *getTemplateArgIsType() { 
+  bool *getTemplateArgIsType() {
     return (bool *)(getTemplateArgLocations() + NumArgs);
   }
 
   static TemplateIdAnnotation* Allocate(unsigned NumArgs) {
-    TemplateIdAnnotation *TemplateId 
-      = (TemplateIdAnnotation *)std::malloc(sizeof(TemplateIdAnnotation) + 
-                                            sizeof(void*) * NumArgs + 
+    TemplateIdAnnotation *TemplateId
+      = (TemplateIdAnnotation *)std::malloc(sizeof(TemplateIdAnnotation) +
+                                            sizeof(void*) * NumArgs +
                                             sizeof(SourceLocation) * NumArgs +
                                             sizeof(bool) * NumArgs);
     TemplateId->NumArgs = NumArgs;