From 0099530a2288df7c2140dd8992b7310b9f6930a9 Mon Sep 17 00:00:00 2001 From: NAKAMURA Takumi Date: Thu, 27 Jan 2011 07:09:49 +0000 Subject: [PATCH] 7bit-ize. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@124363 91177308-0d34-0410-b5e6-96231b3b80d8 --- 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 82ab14dbed..4eea2bc239 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 acdc15fdf2..7e0cb8a433 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 b34fe2ff28..a2a087a55e 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 161908e200..3b7fa0a3ac 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(T)->getDecl(); diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp index f33f42d856..1e8f315c95 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(Function->getType()->getAs()); 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(Function)) { if (!isa(Method)) { diff --git a/lib/Sema/SemaStmt.cpp b/lib/Sema/SemaStmt.cpp index 72d28e6ca0..f4fe6479ab 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 1d2de0fb52..133b29bad0 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 fd12ccf0f2..1cad33360f 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 qualification + // 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 0254ba777a..64de19da53 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(); -- 2.40.0