]> granicus.if.org Git - clang/commitdiff
7bit-ize.
authorNAKAMURA Takumi <geek4civic@gmail.com>
Thu, 27 Jan 2011 07:09:49 +0000 (07:09 +0000)
committerNAKAMURA Takumi <geek4civic@gmail.com>
Thu, 27 Jan 2011 07:09:49 +0000 (07:09 +0000)
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@124363 91177308-0d34-0410-b5e6-96231b3b80d8

lib/Analysis/PrintfFormatString.cpp
lib/Sema/SemaExprCXX.cpp
lib/Sema/SemaInit.cpp
lib/Sema/SemaLookup.cpp
lib/Sema/SemaOverload.cpp
lib/Sema/SemaStmt.cpp
lib/Sema/SemaTemplate.cpp
lib/Sema/SemaTemplateDeduction.cpp
lib/StaticAnalyzer/BasicStore.cpp

index 82ab14dbed6ec3c1f438bac30e08cd0b0bc86715..4eea2bc2392d45d74d65865dfc70357c68503965 100644 (file)
@@ -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
index acdc15fdf2836fbef96bf4c923d76db899021f41..7e0cb8a433f0d3494e39b3f13c7577b44bdfc25e 100644 (file)
@@ -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 functions name is operator new[] and the
-  //   deallocation functions 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 functions 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 functions 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 functions 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
index b34fe2ff284c04976e49155a2c2928e055f48f88..a2a087a55e97d6639cfa671758e7306030b00f92 100644 (file)
@@ -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 Ts 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)) {
index 161908e200701ce03c5bf6bbeed82a7434604a82..3b7fa0a3ac28f9d8e55ac473b9e74b57114920c7 100644 (file)
@@ -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 templates 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 members 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();
index f33f42d85649fa5b388803d9508baef9f06a86de..1e8f315c95c78a756be850cbf9d693fc35ba3fa8 100644 (file)
@@ -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 AddTemplateOverloadCandidate for function templates");
+         "Use AddTemplateOverloadCandidate for function templates");
 
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
     if (!isa<CXXConstructorDecl>(Method)) {
index 72d28e6ca0be240881ead90cc1f0fde569b20d35..f4fe6479abf460a99635190689b6386c96bf9232 100644 (file)
@@ -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(),
index 1d2de0fb523a343ff26b2b726e79514669168c26..133b29bad0a7ec4861767b0f53082d51a1d40a77 100644 (file)
@@ -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-arguments 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 Ps 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).
index fd12ccf0f28a215c87a40fd899af3829c8833e67..1cad33360ff4377bc6f585a714a8428ce33f864c 100644 (file)
@@ -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 Ps 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 As
+      // - 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
-    //     Ps 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 As
+    //   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 qualication
+  //       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?
index 0254ba777a48d272846b3c282689a709ef7b45af..64de19da5396d9d18d2b2d65041f97aa7f92b549 100644 (file)
@@ -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();