constants in this class.
"""
- # An unknown error occured
+ # An unknown error occurred
ERROR_UNKNOWN = 0
# The database could not be loaded
// Get location past ';'
EndLoc = EndLoc.getLocWithOffset(1);
SourceLocation BeginOfSetterDclLoc = Setter->getLocStart();
- // FIXME. This assumes that setter decl; is immediately preceeded by eoln.
+ // FIXME. This assumes that setter decl; is immediately preceded by eoln.
// It is trying to remove the setter method decl. line entirely.
BeginOfSetterDclLoc = BeginOfSetterDclLoc.getLocWithOffset(-1);
commit.remove(SourceRange(BeginOfSetterDclLoc, EndLoc));
/*IsDecl*/true);
if (!EndOfEnumDclLoc.isInvalid()) {
SourceLocation BeginOfEnumDclLoc = EnumDcl->getLocStart();
- // FIXME. This assumes that enum decl; is immediately preceeded by eoln.
+ // FIXME. This assumes that enum decl; is immediately preceded by eoln.
// It is trying to remove the enum decl. lines entirely.
BeginOfEnumDclLoc = BeginOfEnumDclLoc.getLocWithOffset(-1);
commit.remove(SourceRange(BeginOfEnumDclLoc, EndOfEnumDclLoc));
if (FI.getFileCharacteristic() == SrcMgr::C_ExternCSystem)
return true;
if (FI.getFileCharacteristic() == SrcMgr::C_System) {
- // This file is in a system header directory. Continue with commiting change
- // only if it is a user specified system directory because user put a
- // .system_framework file in the framework directory.
+ // This file is in a system header directory. Continue committing
+ // change only if it's a user-specified system directory because user
+ // put a .system_framework file in the framework directory.
StringRef Directory(file->getDir()->getName());
size_t Ix = Directory.rfind(".framework");
if (Ix == StringRef::npos)
return new (C, ID) VarTemplateDecl(EmptyShell());
}
-// TODO: Unify accross class, function and variable templates?
+// TODO: Unify across class, function and variable templates?
// May require moving this and Common to RedeclarableTemplateDecl.
void VarTemplateDecl::LoadLazySpecializations() const {
Common *CommonPtr = getCommonPtr();
//
// * The alignment of bitfields in unions is ignored when computing the
// alignment of the union.
-// * The existance of zero-width bitfield that occurs after anything other than
+// * The existence of zero-width bitfield that occurs after anything other than
// a non-zero length bitfield is ignored.
// * The Itanium equivalent vtable pointers are split into a vfptr (virtual
// function pointer) and a vbptr (virtual base pointer). They can each be
/// \brief Initializes size and alignment and honors some flags.
void initializeLayout(const RecordDecl *RD);
/// \brief Initialized C++ layout, compute alignment and virtual alignment and
- /// existance of vfptrs and vbptrs. Alignment is needed before the vfptr is
+ /// existence of vfptrs and vbptrs. Alignment is needed before the vfptr is
/// laid out.
void initializeCXXLayout(const CXXRecordDecl *RD);
void layoutVFPtr(const CXXRecordDecl *RD);
Bases.insert(std::make_pair(RD, BaseOffset));
Size = BaseOffset + Layout->getDataSize();
// Note: we don't update alignment here because it was accounted
- // for during initalization.
+ // for during initialization.
LastBaseWasEmpty = false;
LastNonVirtualBaseHasVBPtr = Layout->hasVBPtr();
}
/// ensure that the original expression is a valid mutex expression.
///
/// NDeref returns the number of Derefence and AddressOf operations
- /// preceeding the Expr; this is used to decide whether to pretty-print
+ /// preceding the Expr; this is used to decide whether to pretty-print
/// SExprs with . or ->.
unsigned buildSExpr(const Expr *Exp, CallingContext* CallCtx,
int* NDeref = 0) {
return 0;
// Compute the index of the requested diagnostic in the static table.
- // 1. Add the number of diagnostics in each category preceeding the
+ // 1. Add the number of diagnostics in each category preceding the
// diagnostic and of the category the diagnostic is in. This gives us
// the offset of the category in the table.
// 2. Subtract the number of IDs in each category from our ID. This gives us
return CodeGenFunction(CGM).GenerateCopyHelperFunction(blockInfo);
}
-/// Build the helper function to dipose of a block.
+/// Build the helper function to dispose of a block.
static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM,
const CGBlockInfo &blockInfo) {
return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo);
return true;
// Producing an alias to a base class ctor/dtor can degrade debug quality
- // as the debugger cannot tell them appart.
+ // as the debugger cannot tell them apart.
if (getCodeGenOpts().OptimizationLevel == 0)
return true;
if (!getCodeGenOpts().CXXCtorDtorAliases)
return true;
- // The alias will use the linkage of the referrent. If we can't
+ // The alias will use the linkage of the referent. If we can't
// support aliases with that linkage, fail.
llvm::GlobalValue::LinkageTypes Linkage = getFunctionLinkage(AliasDecl);
llvm::PointerType *AliasType
= getTypes().GetFunctionType(AliasDecl)->getPointerTo();
- // Find the referrent. Some aliases might require a bitcast, in
+ // Find the referent. Some aliases might require a bitcast, in
// which case the caller is responsible for ensuring the soundness
// of these semantics.
llvm::GlobalValue *Ref = cast<llvm::GlobalValue>(GetAddrOfGlobal(TargetDecl));
if (llvm::GlobalValue::isDiscardableIfUnused(Linkage) &&
(TargetLinkage != llvm::GlobalValue::AvailableExternallyLinkage ||
!TargetDecl.getDecl()->hasAttr<AlwaysInlineAttr>())) {
- // FIXME: An extern template instanciation will create functions with
+ // FIXME: An extern template instantiation will create functions with
// linkage "AvailableExternally". In libc++, some classes also define
// members with attribute "AlwaysInline" and expect no reference to
// be generated. It is desirable to reenable this optimisation after
}
/// EmitAutoVarAlloca - Emit the alloca and debug information for a
-/// local variable. Does not emit initalization or destruction.
+/// local variable. Does not emit initialization or destruction.
CodeGenFunction::AutoVarEmission
CodeGenFunction::EmitAutoVarAlloca(const VarDecl &D) {
QualType Ty = D.getType();
llvm::Constant::getNullValue(RegisterAlias->getType()));
Builder.CreateCondBr(HasRegisterAlias, AliasBB, NoAliasBB);
- // The true branch (has alias registration fucntion):
+ // The true branch (has alias registration function):
Builder.SetInsertPoint(AliasBB);
// Emit alias registration calls:
for (std::vector<ClassAliasPair>::iterator iter = ClassAliases.begin();
if (!Packed && D->hasAttr<PackedAttr>())
return false;
- assert(!D->isBitField() && "Bitfields should be laid out seperately.");
+ assert(!D->isBitField() && "Bitfields should be laid out separately.");
CheckZeroInitializable(D->getType());
// In this ABI, every virtual function takes a pointer to one of the
// subobjects that first defines it as the 'this' parameter, rather than a
- // pointer to ther final overrider subobject. Thus, we need to adjust it back
+ // pointer to the final overrider subobject. Thus, we need to adjust it back
// to the final overrider subobject before use.
// See comments in the MicrosoftVFTableContext implementation for the details.
/// However, some platforms make the conventions identical except
/// for passing additional out-of-band information to a variadic
/// function: for example, x86-64 passes the number of SSE
- /// arguments in %al. On these platforms, it is desireable to
+ /// arguments in %al. On these platforms, it is desirable to
/// call unprototyped functions using the variadic convention so
/// that unprototyped calls to varargs functions still succeed.
///
D.Diag(diag::err_drv_argument_not_allowed_with)
<< lastArgumentForKind(D, Args, NeedsLeakDetection)
<< lastArgumentForKind(D, Args, NeedsMsanRt);
- // FIXME: Currenly -fsanitize=leak is silently ignored in the presence of
+ // FIXME: Currently -fsanitize=leak is silently ignored in the presence of
// -fsanitize=address. Perhaps it should print an error, or perhaps
// -f(-no)sanitize=leak should change whether leak detection is enabled by
// default in ASan?
// Check whether the target provides libc++.
StringRef where;
- // Complain about targetting iOS < 5.0 in any way.
+ // Complain about targeting iOS < 5.0 in any way.
if (isTargetIPhoneOS() && isIPhoneOSVersionLT(5, 0))
where = "iOS 5.0";
// <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
// debatable, but is the reality today. We need to search this tree even
// when we have a sysroot somewhere else. It is the responsibility of
- // whomever is doing the cross build targetting a sysroot using a GCC
+ // whomever is doing the cross build targeting a sysroot using a GCC
// installation that is *not* within the system root to ensure two things:
//
// 1) Any DSOs that are linked in from this tree or from the install path
if (OpenMP) {
CmdArgs.push_back("-lgomp");
- // FIXME: Exclude this for platforms whith libgomp that doesn't require
- // librt. Most modern Linux platfroms require it, but some may not.
+ // FIXME: Exclude this for platforms with libgomp that don't require
+ // librt. Most modern Linux platforms require it, but some may not.
CmdArgs.push_back("-lrt");
}
LeadingWhitespace[LineIndex] =
Lines[LineIndex].begin() - Lines[LineIndex - 1].end();
- // Adjust the start column uniformly accross all lines.
+ // Adjust the start column uniformly across all lines.
StartOfLineColumn[LineIndex] = std::max<int>(
0,
encoding::columnWidthWithTabs(Whitespace, 0, Style.TabWidth, Encoding) +
const ColumnFormat *Format = getColumnFormat(RemainingCodePoints);
// If no ColumnFormat can be used, the braced list would generally be
// bin-packed. Add a severe penalty to this so that column layouts are
- // prefered if possible.
+ // preferred if possible.
if (!Format)
return 10000;
class AnnotatedLine;
/// \brief A wrapper around a \c Token storing information about the
-/// whitespace characters preceeding it.
+/// whitespace characters preceding it.
struct FormatToken {
FormatToken()
: NewlinesBefore(0), HasUnescapedNewline(false), LastNewlineOffset(0),
/// Token.
bool HasUnescapedNewline;
- /// \brief The range of the whitespace immediately preceeding the \c Token.
+ /// \brief The range of the whitespace immediately preceding the \c Token.
SourceRange WhitespaceRange;
/// \brief The offset just past the last '\n' in this token's leading
unsigned StartOfTokenColumn,
bool InPPDirective = false);
- /// \brief Adds information about an unchangable token's whitespace.
+ /// \brief Adds information about an unchangeable token's whitespace.
///
/// Needs to be called for every token for which \c replaceWhitespace
/// was not called.
Diags.Report(diag::err_drv_invalid_value)
<< A->getAsString(Args) << A->getValue();
else {
- // Valid standard, check to make sure language and standard are compatable.
+ // Valid standard, check to make sure language and standard are
+ // compatible.
const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
switch (IK) {
case IK_C:
llvm::MemoryBuffer *InputBuffer =
llvm::MemoryBuffer::getMemBufferCopy(HeaderContents,
Module::getModuleInputBufferName());
- // Ownership of InputBuffer will be transfered to the SourceManager.
+ // Ownership of InputBuffer will be transferred to the SourceManager.
setCurrentInput(FrontendInputFile(InputBuffer, getCurrentFileKind(),
Module->IsSystem));
return true;
if (!EnsureStartOfWord
// Check if string literal starts a new word.
|| P == Begin || isWhitespace(P[-1])
- // Or it could be preceeded by the start of a comment.
+ // Or it could be preceded by the start of a comment.
|| (P > (Begin + 1) && (P[-1] == '/' || P[-1] == '*')
&& P[-2] == '/'))
return true;
assert((Tok.is(tok::l_brace) || Tok.is(tok::kw_try) ||
Tok.is(tok::colon)) &&
"Inline objective-c method not starting with '{' or 'try' or ':'");
- // Enter a scope for the method or c-fucntion body.
+ // Enter a scope for the method or c-function body.
ParseScope BodyScope(this,
parseMethod
? Scope::ObjCMethodScope|Scope::FnScope|Scope::DeclScope
///
/// [Borland] try-block:
/// 'try' compound-statement seh-except-block
-/// 'try' compound-statment seh-finally-block
+/// 'try' compound-statement seh-finally-block
///
StmtResult Parser::ParseCXXTryBlockCommon(SourceLocation TryLoc, bool FnTry) {
if (Tok.isNot(tok::l_brace))
//
//===----------------------------------------------------------------------===//
//
-// This file defines the HTMLRewriter clas, which is used to translate the
+// This file defines the HTMLRewriter class, which is used to translate the
// text of a source file into prettified HTML.
//
//===----------------------------------------------------------------------===//
RewriteInclude();
for (unsigned i = 0, e = FunctionDefinitionsSeen.size(); i < e; i++) {
- // translation of function bodies were postponed untill all class and
+ // translation of function bodies were postponed until all class and
// their extensions and implementations are seen. This is because, we
- // cannot build grouping structs for bitfields untill they are all seen.
+ // cannot build grouping structs for bitfields until they are all seen.
FunctionDecl *FDecl = FunctionDefinitionsSeen[i];
HandleTopLevelSingleDecl(FDecl);
}
Expr *LHS, Expr *RHS) {
QualType LHSType;
// PropertyRef on LHS type need be directly obtained from
- // its declaration as it has a PsuedoType.
+ // its declaration as it has a PseudoType.
ObjCPropertyRefExpr *PRE
= dyn_cast<ObjCPropertyRefExpr>(LHS->IgnoreParens());
if (PRE && !PRE->isImplicitProperty()) {
//
// When we see foo we don't know if after the typedef we will get 'A' or '*A'
// for example. If 'A', foo will have external linkage. If we have '*A',
-// foo will have no linkage. Since we can't know untill we get to the end
+// foo will have no linkage. Since we can't know until we get to the end
// of the typedef, this function finds out if D might have non-external linkage.
// Callers should verify at the end of the TU if it D has external linkage or
// not.
<< getRedeclDiagFromTagKind(OldTag);
Diag(Redecl->getLocation(), diag::note_previous_use);
- // If there is a previous defintion, suggest a fix-it.
+ // If there is a previous definition, suggest a fix-it.
if (Previous->getDefinition()) {
Diag(NewTagLoc, diag::note_struct_class_suggestion)
<< getRedeclDiagFromTagKind(Redecl->getTagKind())
SynthesizedFunctionScope Scope(*this, Conv);
DiagnosticErrorTrap Trap(Diags);
- // Retreive the static invoker...
+ // Retrieve the static invoker...
CXXMethodDecl *Invoker = Lambda->getLambdaStaticInvoker();
// ... and get the corresponding specialization for a generic lambda.
if (Lambda->isGenericLambda()) {
NameInfo.getLoc(), Ty, VK, FoundD, TemplateArgs);
} else {
assert(!TemplateArgs && "No template arguments for non-variable"
- " template specialization referrences");
+ " template specialization references");
E = DeclRefExpr::Create(
Context,
SS ? SS->getWithLocInContext(Context) : NestedNameSpecifierLoc(),
// delayed parsing --- except for trailing return types in C++11.
// And if an id-expression referring to a field occurs in a
// context that lacks a 'this' value, it's ill-formed --- except,
- // agian, in C++11, where such references are allowed in an
+ // again, in C++11, where such references are allowed in an
// unevaluated context. So C++11 introduces some new complexity.
//
// For the record, since __alignof__ on expressions is a GCC
}
void Sema::CheckTollFreeBridgeCast(QualType castType, Expr *castExpr) {
- // warn in presense of __bridge casting to or from a toll free bridge cast.
+ // warn in presence of __bridge casting to or from a toll free bridge cast.
ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExpr->getType());
ARCConversionTypeClass castACTC = classifyTypeForARCConversion(castType);
if (castACTC == ACTC_retainable && exprACTC == ACTC_coreFoundation) {
// Generates an error report, indicating that the function whose name is given
// will perform a zero byte allocation.
-// Returns false if an error occured, true otherwise.
+// Returns false if an error occurred, true otherwise.
bool UnixAPIChecker::ReportZeroByteAllocation(CheckerContext &C,
ProgramStateRef falseState,
const Expr *arg,
// Peel off the ternary operator.
if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(Ex)) {
- // Find a node where the branching occured and find out which branch
+ // Find a node where the branching occurred and find out which branch
// we took (true/false) by looking at the ExplodedGraph.
const ExplodedNode *NI = N;
do {
assert(Entry->empty());
assert(Entry->succ_size() == 1);
- // Get the solitary sucessor.
+ // Get the solitary successor.
const CFGBlock *Succ = *(Entry->succ_begin());
// Construct an edge representing the starting location in the callee.
# 3. Come up with an alternate mechanism to define all the toolchain
# information that compiler-rt would need to build libraries for all the
# requested targets. This might be a simple short term solution, but is
-# likely to be unwieldly and irritating to maintain in the long term.
+# likely to be unwieldy and irritating to maintain in the long term.
ifneq ($(LLVM_CROSS_COMPILING),1)
ifneq ($(CLANG_NO_RUNTIME),1)
ifeq ($(shell test -d $(COMPILERRT_SRC_ROOT) && echo OK),OK)
NSDate* global_x;
-// Test to see if we supresss an error when we store the pointer
+// Test to see if we suppress an error when we store the pointer
// to a global.
CFAbsoluteTime f3() {
NSDate* global_x;
-// Test to see if we supresss an error when we store the pointer
+// Test to see if we suppress an error when we store the pointer
// to a global.
CFAbsoluteTime f3() {
public:
void pop_front() {
// Fake use-after-free.
- // No warning is expected as we are suppressing warning comming
+ // No warning is expected as we are suppressing warning coming
// out of std::list.
int z = 0;
z = 5/z;
public:
void push_back(int c) {
// Fake error trigger.
- // No warning is expected as we are suppressing warning comming
+ // No warning is expected as we are suppressing warning coming
// out of std::basic_string.
int z = 0;
z = 5/z;
return *res; // no warning
}
-int testReferenceSuccesfulCast() {
+int testReferenceSuccessfulCast() {
B rb;
B &b = dynamic_cast<B&>(rb);
int *x = 0;
void from_cf() {
id obj1 = (__bridge_transfer id)CFCreateSomething(); // expected-warning{{never read}}
id obj2 = (__bridge_transfer NSString*)CFCreateString();
- [obj2 self]; // Add a use, to show we can use the object after it has been transfered.
+ [obj2 self]; // Add a use, to show we can use the object after it has been transferred.
id obj3 = (__bridge id)CFGetSomething();
[obj3 self]; // Add a use, to show we can use the object after it has been bridged.
id obj4 = (__bridge NSString*)CFGetString(); // expected-warning{{never read}}
NSDate* global_x;
-// Test to see if we supresss an error when we store the pointer
+// Test to see if we suppress an error when we store the pointer
// to a global.
CFAbsoluteTime f3() {
// CHECK:[[V2:%[a-z0-9]+]] = bitcast i64* [[V]] to i8*
// CHECK: call void @f(i8* [[V2]])
- struct x v5 = va_arg (ap, struct x); // typical agregate type
+ struct x v5 = va_arg (ap, struct x); // typical aggregate type
f(&v5);
// CHECK: [[I:%[a-z0-9]+]] = load i8** [[AP]]
// CHECK: [[I2:%[a-z0-9]+]] = bitcast i8* [[I]] to %struct.x**
// CHECK: [[V2:%[a-z0-9]+]] = bitcast %struct.x* [[V]] to i8*
// CHECK: call void @f(i8* [[V2]])
- int* v6 = va_arg (ap, int[4]); // an unusual agregate type
+ int* v6 = va_arg (ap, int[4]); // an unusual aggregate type
f(v6);
// CHECK: [[I:%[a-z0-9]+]] = load i8** [[AP]]
// CHECK: [[I2:%[a-z0-9]+]] = bitcast i8* [[I]] to [4 x i32]**
// The 'a' variants ask for the v-table first.
// The 'b' variants ask for the v-table second.
// The 'c' variants ask for the v-table third.
-// We do a separate CHECK-LATE pass because the RTTI defintion gets
+// We do a separate CHECK-LATE pass because the RTTI definition gets
// changed after the fact, which causes reordering of the globals.
// These are not separated into namespaces because the way that Sema
// The 'a' variants ask for the v-table first.
// The 'b' variants ask for the v-table second.
// The 'c' variants ask for the v-table third.
-// We do a separate CHECK-LATE pass because the RTTI defintion gets
+// We do a separate CHECK-LATE pass because the RTTI definition gets
// changed after the fact, which causes reordering of the globals.
// These are not separated into namespaces because the way that Sema
// CHECK-NEXT: [[ALLOC:%.*]] = bitcast
// CHECK-NEXT: [[INIT:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* [[ALLOC]],
- // Initialization of return value, occuring within full-expression.
+ // Initialization of return value, occurring within full-expression.
// Retain/release elided.
// CHECK-NEXT: bitcast
// CHECK-NEXT: [[INIT:%.*]] = bitcast
// CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [[WEAK_T]]* [[WEAKX]], i32 0, i32 3
// CHECK-NEXT: store i32 28, i32* [[T3]]
- // Copy and dipose helpers.
+ // Copy and dispose helpers.
// CHECK-NEXT: [[T4:%.*]] = getelementptr inbounds [[WEAK_T]]* [[WEAKX]], i32 0, i32 4
// CHECK-NEXT: store i8* bitcast (void (i8*, i8*)* @__Block_byref_object_copy_{{.*}} to i8*), i8** [[T4]]
// CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [[WEAK_T]]* [[WEAKX]], i32 0, i32 5
// RUN: | FileCheck %s --check-prefix=CHECK-NO-PIE
//
// Darwin is a beautiful and unique snowflake when it comes to these flags.
-// When targetting a 32-bit darwin system, the -fno-* flag variants work and
+// When targeting a 32-bit darwin system, the -fno-* flag variants work and
// disable PIC, but any other flag enables PIC (*not* PIE) even if the flag
// specifies PIE. On 64-bit targets, there is simply nothing you can do, there
// is no PIE, there is only PIC when it comes to compilation.
// CHECK-CC1: VarDecl:{ResultType A *}{TypedText a}
// CHECK-CC1: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )}
-// Test case for fix comitted in r145441.
+// Test case for fix committed in r145441.
// RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:9:20 %s -fms-compatibility | FileCheck -check-prefix=CHECK-CC1 %s
// RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:10:24 %s | FileCheck -check-prefix=CHECK-CC2 %s
// RUN: %clang_cc1 -fsyntax-only -Wsemicolon-before-method-body -verify %s
// RUN: %clang_cc1 -fsyntax-only -Wsemicolon-before-method-body -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
-// Allow optional semicolon in objc method definiton after method prototype,
+// Allow optional semicolon in objc method definition after method prototype,
// warn about it and suggest a fixit.
@interface NSObject
}
// Test comparison of short to unsigned. If tautological compare does not
-// trigger, then the signed comparision warning will.
+// trigger, then the signed comparison warning will.
void test4(short s) {
// A is max short plus 1. All zero and positive shorts are smaller than it.
// All negative shorts are cast towards the max unsigned range. Relation
A a;
};
-constexpr A a; // ok, zero initialization preceeds static initialization
+constexpr A a; // ok, zero initialization precedes static initialization
void f() {
constexpr A a; // expected-error {{constant expression}} expected-note {{in call to 'A()'}}
}
namespace test12 {
struct A { A(); A(const A&); ~A(); };
- void test(A a) { // expected-note {{jump enters lifetime of block}} FIXME: wierd location
+ void test(A a) { // expected-note {{jump enters lifetime of block}} FIXME: weird location
goto lbl; // expected-error {{goto into protected scope}}
(void) ^{ (void) a; };
lbl:
A a20{a20}; // expected-warning {{variable 'a20' is uninitialized when used within its own initialization}}
A a21 = {a21}; // expected-warning {{variable 'a21' is uninitialized when used within its own initialization}}
- // FIXME: Make the local uninitialized warning consistant with the global
+ // FIXME: Make the local uninitialized warning consistent with the global
// uninitialized checking.
A *a22 = new A(a22->count); // expected-warning {{variable 'a22' is uninitialized when used within its own initialization}}
A *a23 = new A(a23->ONE); // expected-warning {{variable 'a23' is uninitialized when used within its own initialization}}
@end
// Test 2. rdar://problem/11150919
-int test2(id obj, int state) { // expected-note {{jump enters lifetime of block}} FIXME: wierd location
+int test2(id obj, int state) { // expected-note {{jump enters lifetime of block}} FIXME: weird location
switch (state) {
case 0:
(void) ^{ (void) obj; };
@property id prop;
@property __strong id strong_prop;
@property (strong) id strong_attr_prop;
-@property (strong) __strong id realy_strong_attr_prop;
+@property (strong) __strong id really_strong_attr_prop;
+ (id) alloc;
- (id) init;
- (id) implicit;
f.prop = [[Baz alloc] init];
f.strong_prop = [[Baz alloc] init];
f.strong_attr_prop = [[Baz alloc] init];
- f.realy_strong_attr_prop = [[Baz alloc] init];
+ f.really_strong_attr_prop = [[Baz alloc] init];
f.implicit = [[Baz alloc] init];
}
// RUN: %clang_cc1 -triple x86_64-apple-macosx10.8.0 -fsyntax-only -verify %s
-// This test case shows that 'availablity' and 'deprecated' does not inherit
+// This test case shows that 'availability' and 'deprecated' do not inherit
// when a property is redeclared in a subclass. This is intentional.
@interface NSObject @end
return container.pieces; // expected-warning {{type of property 'pieces' does not match type of accessor 'pieces'}}
}
-- (id)firstPeice
+- (id)firstPiece
{
return container.first;
}
template <class T>
class Base {
public:
- bool base_fun(void* p) { return false; } // expected-note {{must qualify identifier to find this declaration in dependent base clas}}
+ bool base_fun(void* p) { return false; } // expected-note {{must qualify identifier to find this declaration in dependent base class}}
operator T*() const { return 0; }
};
extern "C" {
-// FIXME: do something more usefull with the error message
+// FIXME: do something more useful with the error message
CXCompilationDatabase
clang_CompilationDatabase_fromDirectory(const char *BuildDir,
CXCompilationDatabase_Error *ErrorCode)
my ($h, $f) = tempfile("report-XXXXXX", SUFFIX => ".plist",
DIR => $HtmlDir);
$ResultFile = $f;
- # If the HtmlDir is not set, we sould clean up the plist files.
+ # If the HtmlDir is not set, we should clean up the plist files.
if (!defined $HtmlDir || -z $HtmlDir) {
$CleanupFile = $f;
}
// This code is more common than we thought; if we
// layout this correctly the semicolon will go into
- // its own line, which is undesireable.
+ // its own line, which is undesirable.
verifyFormat("namespace {};");
verifyFormat("namespace {\n"
"class A {};\n"
" aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
// Here a line could be saved by splitting the second initializer onto two
- // lines, but that is not desireable.
+ // lines, but that is not desirable.
verifyFormat("Constructor()\n"
" : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
" aaaaaaaaaaa(aaaaaaaaaaa),\n"
<tr>
<td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#81">81</a></td>
<td>NAD</td>
- <td>Null pointers and C compatability</td>
+ <td>Null pointers and C compatibility</td>
<td class="na" align="center">N/A</td>
</tr>
<tr>
projects / clang / commitdiff