[cfe-commits] [PATCH] 7bit-ize

NAKAMURA Takumi geek4civic at gmail.com
Wed Jan 26 21:47:56 PST 2011


Hello.

Some source files contain utf8 characters. I would like to apply this
if we should better get rid of utf8, thank you.

...Takumi
-------------- next part --------------
From d602455c60ec48e0baad5b9fa2a8bfdee80c7c6f Mon Sep 17 00:00:00 2001
From: NAKAMURA Takumi <geek4civic at gmail.com>
Date: Thu, 6 Jan 2011 15:43:06 +0900
Subject: [PATCH 1/2] 7bit-ize.

---
 lib/Analysis/PrintfFormatString.cpp |    2 +-
 lib/Sema/SemaExprCXX.cpp            |   18 +++++++++---------
 lib/Sema/SemaInit.cpp               |    6 +++---
 lib/Sema/SemaLookup.cpp             |    4 ++--
 lib/Sema/SemaOverload.cpp           |    8 ++++----
 lib/Sema/SemaStmt.cpp               |    2 +-
 lib/Sema/SemaTemplate.cpp           |   12 ++++++------
 lib/Sema/SemaTemplateDeduction.cpp  |   16 ++++++++--------
 lib/StaticAnalyzer/BasicStore.cpp   |    4 ++--
 9 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/lib/Analysis/PrintfFormatString.cpp b/lib/Analysis/PrintfFormatString.cpp
index 82ab14d..4eea2bc 100644
--- a/lib/Analysis/PrintfFormatString.cpp
+++ b/lib/Analysis/PrintfFormatString.cpp
@@ -454,7 +454,7 @@ bool PrintfSpecifier::fixType(QualType QT) {
 
 void PrintfSpecifier::toString(llvm::raw_ostream &os) const {
   // Whilst some features have no defined order, we are using the order
-  // appearing in the C99 standard (ISO/IEC 9899:1999 (E) ยค7.19.6.1)
+  // appearing in the C99 standard (ISO/IEC 9899:1999 (E) 7.19.6.1)
   os << "%";
 
   // Positional args
diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index acdc15f..7e0cb8a 100644
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -78,13 +78,13 @@ ParsedType Sema::getDestructorName(SourceLocation TildeLoc,
     //   If a pseudo-destructor-name (5.2.4) contains a nested-name-specifier, 
     //   the type-names are looked up as types in the scope designated by the
     //   nested-name-specifier. In a qualified-id of the form:
-    // 
-    //     ::[opt] nested-name-specifier  ? class-name 
+    //
+    //     ::[opt] nested-name-specifier  ~ class-name
     //
     //   where the nested-name-specifier designates a namespace scope, and in
     //   a qualified-id of the form:
     //
-    //     ::opt nested-name-specifier class-name ::  ? class-name 
+    //     ::opt nested-name-specifier class-name ::  ~ class-name
     //
     //   the class-names are looked up as types in the scope designated by 
     //   the nested-name-specifier.
@@ -1017,10 +1017,10 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
 
   // C++ [expr.new]p8:
   //   If the allocated type is a non-array type, the allocation
-  //   function?s name is operator new and the deallocation function?s
+  //   function's name is operator new and the deallocation function's
   //   name is operator delete. If the allocated type is an array
-  //   type, the allocation function?s name is operator new[] and the
-  //   deallocation function?s name is operator delete[].
+  //   type, the allocation function's name is operator new[] and the
+  //   deallocation function's name is operator delete[].
   DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
                                         IsArray ? OO_Array_New : OO_New);
   DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName(
@@ -1061,12 +1061,12 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
   // C++ [expr.new]p19:
   //
   //   If the new-expression begins with a unary :: operator, the
-  //   deallocation function?s name is looked up in the global
+  //   deallocation function's name is looked up in the global
   //   scope. Otherwise, if the allocated type is a class type T or an
-  //   array thereof, the deallocation function?s name is looked up in
+  //   array thereof, the deallocation function's name is looked up in
   //   the scope of T. If this lookup fails to find the name, or if
   //   the allocated type is not a class type or array thereof, the
-  //   deallocation function?s name is looked up in the global scope.
+  //   deallocation function's name is looked up in the global scope.
   LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName);
   if (AllocElemType->isRecordType() && !UseGlobal) {
     CXXRecordDecl *RD
diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index b34fe2f..a2a087a 100644
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -2651,8 +2651,8 @@ static void TryReferenceInitialization(Sema &S,
     Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
     return;
   }
-    
-  //      - Otherwise, a temporary of type ?cv1 T1? is created and initialized
+
+  //      - Otherwise, a temporary of type "cv1 T1" is created and initialized
   //        from the initializer expression using the rules for a non-reference
   //        copy initialization (8.5). The reference is then bound to the 
   //        temporary. [...]
@@ -2850,7 +2850,7 @@ static void TryValueInitialization(Sema &S,
       
       // -- if T is a (possibly cv-qualified) non-union class type
       //    without a user-provided constructor, then the object is
-      //    zero-initialized and, if T?s implicitly-declared default
+      //    zero-initialized and, if T's implicitly-declared default
       //    constructor is non-trivial, that constructor is called.
       if ((ClassDecl->getTagKind() == TTK_Class ||
            ClassDecl->getTagKind() == TTK_Struct)) {
diff --git a/lib/Sema/SemaLookup.cpp b/lib/Sema/SemaLookup.cpp
index 161908e..3b7fa0a 100644
--- a/lib/Sema/SemaLookup.cpp
+++ b/lib/Sema/SemaLookup.cpp
@@ -1759,7 +1759,7 @@ addAssociatedClassesAndNamespaces(AssociatedLookup &Result,
 
   // -- If T is a template-id, its associated namespaces and classes are
   //    the namespace in which the template is defined; for member
-  //    templates, the member template?s class; the namespaces and classes
+  //    templates, the member template's class; the namespaces and classes
   //    associated with the types of the template arguments provided for
   //    template type parameters (excluding template template parameters); the
   //    namespaces in which any template template arguments are defined; and
@@ -1886,7 +1886,7 @@ addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType Ty) {
 
     //     -- If T is an enumeration type, its associated namespace is
     //        the namespace in which it is defined. If it is class
-    //        member, its associated class is the member?s class; else
+    //        member, its associated class is the member's class; else
     //        it has no associated class.
     case Type::Enum: {
       EnumDecl *Enum = cast<EnumType>(T)->getDecl();
diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index f33f42d..1e8f315 100644
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -3242,9 +3242,9 @@ TryObjectArgumentInitialization(Sema &S, QualType OrigFromType,
   //   For non-static member functions, the type of the implicit object 
   //   parameter is
   //
-  //     ? "lvalue reference to cv X" for functions declared without a 
-  //       ref-qualifier or with the & ref-qualifier
-  //     ? "rvalue reference to cv X" for functions declared with the && 
+  //     - "lvalue reference to cv X" for functions declared without a
+  //        ref-qualifier or with the & ref-qualifier
+  //     - "rvalue reference to cv X" for functions declared with the &&
   //        ref-qualifier
   //
   // where X is the class of which the function is a member and cv is the 
@@ -3623,7 +3623,7 @@ Sema::AddOverloadCandidate(FunctionDecl *Function,
     = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
   assert(Proto && "Functions without a prototype cannot be overloaded");
   assert(!Function->getDescribedFunctionTemplate() &&
-         "Use AddTemp?lateOverloadCandidate for function templates");
+         "Use AddTemplateOverloadCandidate for function templates");
 
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
     if (!isa<CXXConstructorDecl>(Method)) {
diff --git a/lib/Sema/SemaStmt.cpp b/lib/Sema/SemaStmt.cpp
index 72d28e6..f4fe647 100644
--- a/lib/Sema/SemaStmt.cpp
+++ b/lib/Sema/SemaStmt.cpp
@@ -1168,7 +1168,7 @@ Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
     
     //   [...] If overload resolution fails, or if the type of the first 
     //   parameter of the selected constructor is not an rvalue reference
-    //   to the object?s type (possibly cv-qualified), overload resolution 
+    //   to the object's type (possibly cv-qualified), overload resolution
     //   is performed again, considering the object as an lvalue.
     if (Seq.getKind() != InitializationSequence::FailedSequence) {
       for (InitializationSequence::step_iterator Step = Seq.step_begin(),
diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp
index 1d2de0f..133b29b 100644
--- a/lib/Sema/SemaTemplate.cpp
+++ b/lib/Sema/SemaTemplate.cpp
@@ -3868,9 +3868,9 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
 
   // C++0x [temp.arg.template]p3:
   //   A template-argument matches a template template-parameter (call it P)
-  //   when each of the template parameters in the template-parameter-list of 
-  //   the template-argument?s corresponding class template or template alias
-  //   (call it A) matches the corresponding template parameter in the 
+  //   when each of the template parameters in the template-parameter-list of
+  //   the template-argument's corresponding class template or template alias
+  //   (call it A) matches the corresponding template parameter in the
   //   template-parameter-list of P. [...]
   TemplateParameterList::iterator NewParm = New->begin();
   TemplateParameterList::iterator NewParmEnd = New->end();
@@ -3896,9 +3896,9 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
     }
     
     // C++0x [temp.arg.template]p3:
-    //   [...] When P?s template- parameter-list contains a template parameter
-    //   pack (14.5.3), the template parameter pack will match zero or more 
-    //   template parameters or template parameter packs in the 
+    //   [...] When P's template- parameter-list contains a template parameter
+    //   pack (14.5.3), the template parameter pack will match zero or more
+    //   template parameters or template parameter packs in the
     //   template-parameter-list of A with the same type and form as the
     //   template parameter pack in P (ignoring whether those template
     //   parameters are template parameter packs).
diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp
index fd12ccf..1cad333 100644
--- a/lib/Sema/SemaTemplateDeduction.cpp
+++ b/lib/Sema/SemaTemplateDeduction.cpp
@@ -913,7 +913,7 @@ DeduceTemplateArguments(Sema &S,
       //   which case the type of Pi is changed to be the template parameter 
       //   type (i.e., T&& is changed to simply T). [ Note: As a result, when
       //   Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be
-      //   deduced as X&. ? end note ]
+      //   deduced as X&. - end note ]
       TDF &= ~TDF_TopLevelParameterTypeList;
       
       if (const RValueReferenceType *ParamRef
@@ -2439,7 +2439,7 @@ static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S,
                                                       Expr *Arg,
                                                       unsigned &TDF) {
   // C++0x [temp.deduct.call]p3:
-  //   If P is a cv-qualified type, the top level cv-qualifiers of P?s type
+  //   If P is a cv-qualified type, the top level cv-qualifiers of P's type
   //   are ignored for type deduction.
   if (ParamType.getCVRQualifiers())
     ParamType = ParamType.getLocalUnqualifiedType();
@@ -2495,7 +2495,7 @@ static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S,
     else if (ArgType->isFunctionType())
       ArgType = S.Context.getPointerType(ArgType);
     else {
-      // - If A is a cv-qualified type, the top level cv-qualifiers of A?s
+      // - If A is a cv-qualified type, the top level cv-qualifiers of A's
       //   type are ignored for type deduction.
       if (ArgType.getCVRQualifiers())
         ArgType = ArgType.getUnqualifiedType();
@@ -2858,12 +2858,12 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
     else if (P->isFunctionType())
       P = Context.getPointerType(P);
     //   - If P is a cv-qualified type, the top level cv-qualifiers of
-    //     P?s type are ignored for type deduction.
+    //     P's type are ignored for type deduction.
     else
       P = P.getUnqualifiedType();
 
     // C++0x [temp.deduct.conv]p3:
-    //   If A is a cv-qualified type, the top level cv-qualifiers of A?s
+    //   If A is a cv-qualified type, the top level cv-qualifiers of A's
     //   type are ignored for type deduction.
     A = A.getUnqualifiedType();
   }
@@ -2893,7 +2893,7 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
   if (ToType->isReferenceType())
     TDF |= TDF_ParamWithReferenceType;
   //     - The deduced A can be another pointer or pointer to member
-  //       type that can be converted to A via a quali?cation
+  //       type that can be converted to A via a qualification
   //       conversion.
   //
   // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when
@@ -2963,7 +2963,7 @@ static void MaybeAddImplicitObjectParameterType(ASTContext &Context,
   //
   //   For non-static member functions, the type of the implicit
   //   object parameter is
-  //     ? "lvalue reference to cv X" for functions declared without a
+  //     - "lvalue reference to cv X" for functions declared without a
   //       ref-qualifier or with the & ref-qualifier
   //     - "rvalue reference to cv X" for functions declared with the
   //       && ref-qualifier
@@ -3067,7 +3067,7 @@ static bool isAtLeastAsSpecializedAs(Sema &S,
     break;
     
   case TPOC_Other:
-    //   - In other contexts (14.6.6.2) the function template?s function type 
+    //   - In other contexts (14.6.6.2) the function template's function type
     //     is used.
     // FIXME: Don't we actually want to perform the adjustments on the parameter
     // types?
diff --git a/lib/StaticAnalyzer/BasicStore.cpp b/lib/StaticAnalyzer/BasicStore.cpp
index 0254ba7..64de19d 100644
--- a/lib/StaticAnalyzer/BasicStore.cpp
+++ b/lib/StaticAnalyzer/BasicStore.cpp
@@ -459,8 +459,8 @@ Store BasicStoreManager::BindDeclInternal(Store store, const VarRegion* VR,
       // C99: 6.7.8 Initialization
       //  If an object that has static storage duration is not initialized
       //  explicitly, then:
-      //   ?if it has pointer type, it is initialized to a null pointer;
-      //   ?if it has arithmetic type, it is initialized to (positive or
+      //   -if it has pointer type, it is initialized to a null pointer;
+      //   -if it has arithmetic type, it is initialized to (positive or
       //     unsigned) zero;
       if (!InitVal) {
         QualType T = VD->getType();
-- 
1.7.1.GIT

-------------- next part --------------
A non-text attachment was scrubbed...
Name: 0002-Fix-whitespace.patch.txt.gz
Type: application/x-gzip
Size: 112489 bytes
Desc: not available
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20110127/8dc5a9c0/attachment.bin>


More information about the cfe-commits mailing list