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
// 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.
// 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(
// 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
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. [...]
// -- 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)) {
// -- 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
// -- 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();
// 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
= 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)) {
// [...] 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(),
// 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();
}
// 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).
// 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
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();
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();
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();
}
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
//
// 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
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?
// 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();
projects / clang / commitdiff