if (hr == S_FALSE)
{
// Another bind interfered. We need to retry the entire bind.
- // This by design loops as long as needed because by constuction we eventually
+ // This by design loops as long as needed because by construction we eventually
// will succeed or fail the bind.
bindResult.Reset();
goto Retry;
if (hr == S_FALSE)
{
// Another bind interfered. We need to retry entire bind.
- // This by design loops as long as needed because by constuction we eventually
+ // This by design loops as long as needed because by construction we eventually
// will succeed or fail the bind.
bindResult.Reset();
goto Retry;
if (hr == S_FALSE)
{
// Another bind interfered. We need to retry entire bind.
- // This by design loops as long as needed because by constuction we eventually
+ // This by design loops as long as needed because by construction we eventually
// will succeed or fail the bind.
bindResult.Reset();
goto Retry;
}
else {
thousandsSepPos = (INT32 *)thousands.AllocThrows(bufferLen2 * sizeof(INT32));
- // We need this array to figure out where to insert the thousands seperator. We would have to traverse the string
- // backwords. PIC formatting always traverses forwards. These indices are precomputed to tell us where to insert
- // the thousands seperator so we can get away with traversing forwards. Note we only have to compute upto digPos.
+ // We need this array to figure out where to insert the thousands separator. We would have to traverse the string
+ // backwards. PIC formatting always traverses forwards. These indices are precomputed to tell us where to insert
+ // the thousands separator so we can get away with traversing forwards. Note we only have to compute up to digPos.
// The max is not bound since you can have formatting strings of the form "000,000..", and this
// should handle that case too.
// Allocate temp buffer - gotta deal with Schertz' 500 MB strings.
// Some computations like when you specify Int32.MaxValue-2 %'s and each percent is setup to be Int32.MaxValue in length
- // will generate a result that will be larget than an unsigned int can hold. This is to protect against overflow.
+ // will generate a result that will be largest than an unsigned int can hold. This is to protect against overflow.
UINT64 tempLen = str->GetStringLength() + maxStrIncLen + 10; // Include a healthy amount of temp space.
if (tempLen > 0x7FFFFFFF)
COMPlusThrowOM(); // if we overflow
unsigned int bufferLen = (UINT)tempLen;
if (bufferLen < 250) // Stay under 512 bytes
- bufferLen = 250; // This is to prevent unneccessary calls to resize
+ bufferLen = 250; // This is to prevent unnecessary calls to resize
buffer = (wchar *) buf.AllocThrows(bufferLen* sizeof(WCHAR));
dst = buffer;
case '.':
{
if (digPos != 0 || decimalWritten) {
- // For compatability, don't echo repeated decimals
+ // For compatibility, don't echo repeated decimals
break;
}
// If the format has trailing zeros or the format has a decimal and digits remain
#endif
//
-// We implicitely assume these methods are not going to do a LoadLibrary
+// We implicitly assume these methods are not going to do a LoadLibrary
//
/**
* This function returns a pointer to this table that we use in System.Globalization.EncodingTable.
- * No error checking of any sort is performed. Range checking is entirely the responsiblity of the managed
+ * No error checking of any sort is performed. Range checking is entirely the responsibility of the managed
* code.
*/
FCIMPL0(EncodingDataItem *, COMNlsInfo::nativeGetEncodingTableDataPointer)
/**
* This function returns a pointer to this table that we use in System.Globalization.EncodingTable.
- * No error checking of any sort is performed. Range checking is entirely the responsiblity of the managed
+ * No error checking of any sort is performed. Range checking is entirely the responsibility of the managed
* code.
*/
FCIMPL0(CodePageDataItem *, COMNlsInfo::nativeGetCodePageTableDataPointer)
}
else
{
- print "Unknonw argument '$nextArg'\n";
+ print "Unknown argument '$nextArg'\n";
Usage();
}
}
{
print "Usage: applydefines [options]\n";
print "\t-s <file>\t: the source file to process\n";
- print "\t-f <file>\t: the file contatining #define setings\n";
+ print "\t-f <file>\t: the file containing #define settings\n";
print "\t-o <file>\t: the output file\n";
print "\t-d <name>=<Value>\t: additional define\n";
// CORECLR_HOST_AUTHENTICATION_KEY_NONGEN
hr = host->Authenticate(CORECLR_HOST_AUTHENTICATION_KEY);
if (FAILED(hr)) {
- log << W("Failed autenticate. ") << hr << Logger::endl;
+ log << W("Failed authenticate. ") << hr << Logger::endl;
return false;
}
// CORECLR_HOST_AUTHENTICATION_KEY_NONGEN
hr = host->Authenticate(CORECLR_HOST_AUTHENTICATION_KEY);
if (FAILED(hr)) {
- log << W("Failed autenticate. ") << hr << Logger::endl;
+ log << W("Failed authenticate. ") << hr << Logger::endl;
return false;
}
}
/*
- * If we have a legacy target, it means we're providing compatability for code that used
+ * If we have a legacy target, it means we're providing compatibility for code that used
* the old ICLRDataTarget interfaces. There are still a few things (like metadata location,
- * GetImageBase, and VirtualAlloc) that the implementation may use which we haven't superceded
+ * GetImageBase, and VirtualAlloc) that the implementation may use which we haven't superseded
* in ICorDebugDataTarget, so we still need access to the old target interfaces.
* Any functionality that does exist in ICorDebugDataTarget is accessed from that interface
* using the DataTargetAdapter on top of the legacy interface (to unify the calling code).
// The implementation of ASSERT accesses this via code:DacTargetConsistencyAssertsEnabled
//
// By default, this is disabled, unless COMPLUS_DbgDACEnableAssert is set (see code:ClrDataAccess::ClrDataAccess).
-// This is necessary for compatability. For example, SOS expects to be able to scan for
+// This is necessary for compatibility. For example, SOS expects to be able to scan for
// valid MethodTables etc. (which may cause ASSERTs), and also doesn't want ASSERTs when working
// with targets with corrupted memory.
//
ULONG32 methodSize = static_cast<ULONG32>(PEDecoder::ComputeILMethodSize(methAddr));
// Sometimes when reading from dumps and inspect NGEN images, but we end up reading metadata from IL image
- // the method RVA could not match and we could read from a random address that will translate in inconsistend
+ // the method RVA could not match and we could read from a random address that will translate in inconsistent
// IL code header. If we see the size of the code bigger than 64 Megs we are probably reading a bad IL code header.
// For details see issue DevDiv 273199.
if (methodSize > 0x4000000)
// Eg., if we used std::map, we could have efficient lookups and ordered
// enumerations. However, we do need to be careful about exposing new invariants
// through ICorDebug that customers may depend on, which could place a long-term
-// compatability burden on us. We could have a simple generic data structure
+// compatibility burden on us. We could have a simple generic data structure
// (eg. built on std::hash_map and std::list) which provided efficient look-up
// and both in-order and random enumeration.
//
// Prior to V3, we used to keep track of a per-appdomain attached status.
// Debuggers were required to explicitly attach to every AppDomain, so this
// did not provide any actual functionality. In V3, there is no longer any
-// concept of per-AppDomain attach/detach. This API is provided for compatability.
+// concept of per-AppDomain attach/detach. This API is provided for compatibility.
//
HRESULT CordbAppDomain::IsAttached(BOOL *pfAttached)
// Prior to V3, we used to keep track of a per-appdomain attached status.
// Debuggers were required to explicitly attach to every AppDomain, so this
// did not provide any actual functionality. In V3, there is no longer any
-// concept of per-AppDomain attach/detach. This API is provided for compatability.
+// concept of per-AppDomain attach/detach. This API is provided for compatibility.
//
HRESULT CordbAppDomain::Attach()
// not happen unless the target is corrupt.
//
// Notes:
-// In-memory assemblies do not have a filename. In that case, for compatability
+// In-memory assemblies do not have a filename. In that case, for compatibility
// this returns success and the string "<unknown>". We may want to change this
// behavior in the future.
//
// In the dump case we may not have the backing memory for this. In such a case
// we construct an empty ILCode object and leave the signatureToken as mdSignatureNil.
- // It may also be the case that the memory we read from the dump be inconsistend (huge method size)
+ // It may also be the case that the memory we read from the dump be inconsistent (huge method size)
// and we also fallback on creating an empty ILCode object.
// See issue DD 273199 for cases where IL and NGEN metadata mismatch (different RVAs).
ALLOW_DATATARGET_MISSING_OR_INCONSISTENT_MEMORY(
Member function behavior of a neutered COM object:
1. AddRef(), Release(), QueryInterface() work as normal.
- a. This gives folks who are responsable for pairing a Release() with
- an AddRef() a chance to dereferance thier pointer and call Release()
+ a. This gives folks who are responsible for pairing a Release() with
+ an AddRef() a chance to dereference their pointer and call Release()
when they are informed, explicitly or implicitly, that the object is neutered.
2. Any other member function will return an error code unless documented.
- a. If a member fuction returns information when the COM object is
+ a. If a member function returns information when the COM object is
neutered then the semantics of that function need to be documented.
- (ie. If an AppDomain is unloaded and you have a referance to the COM
+ (ie. If an AppDomain is unloaded and you have a reference to the COM
object representing the AppDomain, how _should_ it behave? That behavior
should be documented)
Postcondions of Neuter():
- 1. All circular referances (aka back-pointers) are "broken". They are broken
- by calling Release() on all "Weak Referances" to the object. If you're a purist,
+ 1. All circular references (aka back-pointers) are "broken". They are broken
+ by calling Release() on all "Weak References" to the object. If you're a purist,
these pointers should also be NULLed out.
- a. Weak Referances/Strong Referances:
+ a. Weak References/Strong References:
i. If any objects are not "reachable" from the root (ie. stack or from global pointers)
they should be reclaimed. If they are not, they are leaked and there is an issue.
ii. There must be a partial order on the objects such that if A < B then:
- 1. A has a referance to B. This referance is a "strong referance"
+ 1. A has a reference to B. This reference is a "strong reference"
2. A, and thus B, is reachable from the root
- iii. If a referance belongs in the partial order then it is a "strong referance" else
- it is a weak referance.
+ iii. If a reference belongs in the partial order then it is a "strong reference" else
+ it is a weak reference.
*** 2. Sufficient conditions to ensure no COM objects are leaked: ***
a. When Neuter() is invoked:
- i. Calles Release on all its weak referances.
- ii. Then, for each strong referance:
+ i. Calles Release on all its weak references.
+ ii. Then, for each strong reference:
1. invoke Neuter()
2. invoke Release()
iii. If it's derived from a CordbXXX class, call Neuter() on the base class.
a. Members of IUknown, AddRef(), Release(), QueryInterfac()
b. Those documented to have functionality when the object is neutered.
i. Neuter() still works w/o error. If it is invoke a second time it will have already
- released all its strong and weak referances so it could just return.
+ released all its strong and weak references so it could just return.
Alternate design ideas:
Which one should call Release()? For now we have CordbFunction call Release() on CordbCode.
DESIGN: It is not a necessary condition in that Neuter() invoke Release() on all
- it's strong referances. Instead, it would be sufficent to ensure all object are released, that
+ it's strong references. Instead, it would be sufficient to ensure all object are released, that
each object call Release() on all its strong pointers in its destructor.
1. This might be done if its necessary for some member to return "tombstone"
information after the object has been netuered() which involves the siblings (wrt poset)
1. Assert that it's done after NeuterStrongPointers()
2. That would introduce a bunch of functions... but it would be clear.
- DESIGN: CordbBase could provide a function to register strong and weak referances. That way CordbBase
+ DESIGN: CordbBase could provide a function to register strong and weak references. That way CordbBase
could implement a general version of ReleaseWeak/ReleaseStrong/NeuterStrongPointers(). This
would provide a very error resistant framework for extending the object model plus it would
be very explicit about what is going on.
One thing that might trip this is idea up is that if an object has two parents,
- like the CordbCode might, then either both objects call Neuter or one is referance
+ like the CordbCode might, then either both objects call Neuter or one is reference
is made weak.
Our implementation:
- The graph fromed by the strong referances must remain acyclic.
+ The graph formed by the strong references must remain acyclic.
It's up to the developer (YOU!) to ensure that each Neuter
function maintains that invariant.
CordbModule
CordbClass
CordbFunction
- CordbCode (Can we assert a thread will not referance
+ CordbCode (Can we assert a thread will not reference
the same CordbCode as a CordbFunction?)
CordbThread
CordbChains
<TODO>TODO: Some Neuter functions have not yet been implemented due to time restrictions.</TODO>
- <TODO>TODO: Some weak referances never have AddRef() called on them. If that's cool then
+ <TODO>TODO: Some weak references never have AddRef() called on them. If that's cool then
it should be stated in the documentation. Else it should be changed.</TODO>
*/
// - this also means we absolutely can't send IPC events (since that requires a CordbProcess)
// 3) The only safe data are blittalbe embedded fields (eg, a pid or stack range)
//
-// Any usage of this macro should clearly specificy why this is safe.
+// Any usage of this macro should clearly specify why this is safe.
#define OK_IF_NEUTERED(pThis) \
int _____Neuter_Status_Already_Marked; \
_____Neuter_Status_Already_Marked = 0;
// Neuter outstanding CordbChainEnums, CordbFrameEnums, some CordbTypeEnums, and some CordbValueEnums.
m_RefreshStackNeuterList.NeuterAndClear(GetProcess());
- m_fContextFresh = false; // invalide the cached active CONTEXT
+ m_fContextFresh = false; // invalidate the cached active CONTEXT
m_vmLeftSideContext = VMPTR_CONTEXT::NullPtr(); // set the LS pointer to the active CONTEXT to NULL
m_fFramesFresh = false; // invalidate the cached stack trace (frames & chains)
m_userState = kInvalidUserState; // clear the cached user state
// This event is used to trigger the ICorDebugManagedCallback::UpdateModuleSymbols
// callback. That callback is defined to pass a PDB stream, and so we still use this
- // only for legacy compatability reasons when we've actually got PDB symbols.
+ // only for legacy compatibility reasons when we've actually got PDB symbols.
// New clients know they must request a new symbol reader after ClassLoad events.
if (pRuntimeModule->GetInMemorySymbolStreamFormat() != eSymbolFormatPDB)
return; // Non-PDB symbols
//
// Notes:
// This is taken exactly from the IXClrData definition.
- // This is provided for V3 compatability to support Interop-debugging.
+ // This is provided for V3 compatibility to support Interop-debugging.
// This should eventually be deprecated.
//
virtual
//
//
// Return Value:
- // true if the adddress is a CLR stub.
+ // true if the address is a CLR stub.
//
// Notes:
// This is used to implement ICorDebugProcess::IsTransitionStub
OUT SequencePoints * pSequencePoints) = 0;
//
- // Return the filter CONTEXT on the LS. Once we move entirely over to the new managed pipepline
+ // Return the filter CONTEXT on the LS. Once we move entirely over to the new managed pipeline
// built on top of the Win32 debugging API, this won't be necessary.
//
// Arguments:
// Notes:
// This will produce a VMPTR_OBJECTHANDLE regardless of whether handle is
// valid.
- // Ideally we'd be using only strongly-typed variables on the RS, and then this would be unnecessary
+ // Ideally we'd be using only strongly-typed variables on the RS, and then this would be unnecessary
virtual
VMPTR_OBJECTHANDLE GetVmObjectHandle(CORDB_ADDRESS handleAddress) = 0;
#if defined(DBG_TARGET_WIN64)
// 64-bit needs this padding to make the handles after this aligned.
- // But x86 can't have this padding b/c it breaks binary compatability between v1.1 and v2.0.
+ // But x86 can't have this padding b/c it breaks binary compatibility between v1.1 and v2.0.
ULONG padding4;
#endif // DBG_TARGET_WIN64
RemoteHANDLE m_rightSideEventAvailable;
RemoteHANDLE m_rightSideEventRead;
- // @dbgtodo inspection - this is where LSEA and LSER used to be. We need to the padding to maintain binary compatability.
+ // @dbgtodo inspection - this is where LSEA and LSER used to be. We need to the padding to maintain binary compatibility.
// Eventually, we expect to remove this whole block.
RemoteHANDLE m_paddingObsoleteLSEA;
RemoteHANDLE m_paddingObsoleteLSER;
#if defined(DBG_TARGET_WIN64)
// 64-bit needs this padding to make the handles after this aligned.
- // But x86 can't have this padding b/c it breaks binary compatability between v1.1 and v2.0.
+ // But x86 can't have this padding b/c it breaks binary compatibility between v1.1 and v2.0.
ULONG padding4;
#endif // DBG_TARGET_WIN64
class MSLAYOUT EmbeddedIPCString
{
public:
- // Set, caller responsiblity that wcslen(pData) < nMaxLengthIncludingNull
+ // Set, caller responsibility that wcslen(pData) < nMaxLengthIncludingNull
void SetString(const WCHAR * pData)
{
// If the string doesn't fit into the buffer, that's an issue (and so this is a real
<HRESULT NumericValue="0x80131346">
<SymbolicName>CORDBG_E_DEBUGGING_NOT_POSSIBLE</SymbolicName>
<Message>"Debugging is not possible due to an incompatibility within the CLR implementation."</Message>
- <Comment> Debugging isn't possible due to an incompatability within the CLR implementation. </Comment>
+ <Comment> Debugging isn't possible due to an incompatibility within the CLR implementation. </Comment>
</HRESULT>
<HRESULT NumericValue="0x80131347">
{
ULONG32 oldOffset; // Old IL offset relative to beginning of function
ULONG32 newOffset; // New IL offset relative to beginning of function
- BOOL fAccurate; //put here for compatability with the Debugger structure.
+ BOOL fAccurate; //put here for compatibility with the Debugger structure.
} COR_IL_MAP;
cpp_quote("#endif //_COR_IL_MAP")
}
else
{
- // Check type compatability of the this argument
+ // Check type compatibility of the this argument
typeInfo tiDeclaredThis = verMakeTypeInfo(methodClassHnd);
if (tiDeclaredThis.IsValueClass())
tiDeclaredThis.MakeByRef();
popCount++;
// If it is null, we assume we can access it (since it will AV shortly)
- // If it is anything but a refernce class, there is no hierarchy, so
+ // If it is anything but a reference class, there is no hierarchy, so
// again, we don't need the precise instance class to compute 'protected' access
if (tiThis.IsType(TI_REF))
instanceClassHnd = tiThis.GetClassHandleForObjRef();
- // Check type compatability of the this argument
+ // Check type compatibility of the this argument
typeInfo tiDeclaredThis = verMakeTypeInfo(pResolvedToken->hClass);
if (tiDeclaredThis.IsValueClass())
tiDeclaredThis.MakeByRef();
if (TypeFromToken(tk) == mdtMethodDef)
{
if (tk == mdMethodDefNil)
- { // Backward compatability with CLR 2.0 implementation
+ { // Backward compatibility with CLR 2.0 implementation
if (pulCodeRVA != NULL)
*pulCodeRVA = 0;
if (pdwImplFlags != NULL)
goto ErrExit;
}
if (td == mdTypeDefNil)
- { // Backward compatability with CLR 2.0 implementation
+ { // Backward compatibility with CLR 2.0 implementation
if (pdwTypeDefFlags != NULL)
*pdwTypeDefFlags = 0;
if (ptkExtends != NULL)
goto ErrExit;
}
if (tr == mdTypeRefNil)
- { // Backward compatability with CLR 2.0 implementation
+ { // Backward compatibility with CLR 2.0 implementation
if (ptkResolutionScope != NULL)
*ptkResolutionScope = mdTokenNil;
if (pchTypeRef != NULL)
// type in Assembly A upon A's request:
// TypeInAssemblyA.DoWork() { AssemblyB.Create<InternalTypeInAssemblyA>();}
// TypeInAssemblyB.Create<T>() {return new T();}
- // This violates type safety but we saw multiple user apps that have put a dependency on it. So for compatability we allow this if
+ // This violates type safety but we saw multiple user apps that have put a dependency on it. So for compatibility we allow this if
// the SL app was built against SL2/3.
// Note that in SL2/3 it is possible for app code to instantiate public transparent types with public critical default constructors.
// Fortunately we don't have such types in out platform assemblies.
// effectively hidden from most users, who just see the 3-state DateTimeKind
// enumeration.
//
- // For compatability, DateTime does not serialize the Kind data when used in
+ // For compatibility, DateTime does not serialize the Kind data when used in
// binary serialization.
//
// For a description of various calendar issues, look at
foundDateData = true;
break;
default:
- // Ignore other fields for forward compatability.
+ // Ignore other fields for forward compatibility.
break;
}
}
}
// A version of ToBinary that uses the real representation and does not adjust local times. This is needed for
- // scenarios where the serialized data must maintain compatability
+ // scenarios where the serialized data must maintain compatibility
internal static DateTime FromBinaryRaw(Int64 dateData) {
Int64 ticks = dateData & (Int64)TicksMask;
if (ticks < MinTicks || ticks > MaxTicks)
}
// Return the underlying data, without adjust local times to the right time zone. Needed if performance
- // or compatability are important.
+ // or compatibility are important.
internal Int64 ToBinaryRaw() {
return (Int64)dateData;
}
}
Contract.EndContractBlock();
- // RoundtripKind does not make sense for DateTimeOffset; ignore this flag for backward compatability with DateTime
+ // RoundtripKind does not make sense for DateTimeOffset; ignore this flag for backward compatibility with DateTime
style &= ~DateTimeStyles.RoundtripKind;
// AssumeLocal is also ignored as that is what we do by default with DateTimeOffset.Parse
return false;
}
- // For V2 compatability, handle deprecated alternate sorts
+ // For V2 compatibility, handle deprecated alternate sorts
string cultureName = this.sRealName;
switch (AnsiToLower(cultureName))
// CHANGE FROM Whidbey
//
// We have deprecated CultureTypes.FrameworkCultures.
- // When this enum is used, we will enumerate Whidbey framework cultures (for compatability).
+ // When this enum is used, we will enumerate Whidbey framework cultures (for compatibility).
//
// We have deprecated CultureTypes.WindowsOnlyCultures.
// Call nativeEnumCultureNames() to get a string array of culture names based on the specified
// enumeration type.
//
- // nativeEnumCulturNames is a QCall. We need to use a reference to return the string array
+ // nativeEnumCultureNames is a QCall. We need to use a reference to return the string array
// allocated from the QCall. That ref has to be wrapped as object handle.
// See vm\qcall.h for details in QCall.
//
int n2 = raw.GetNumber(1);
String pattern = dtfi.ShortDatePattern;
- // For compatability, don't throw if we can't determine the order, but default to YMD instead
+ // For compatibility, don't throw if we can't determine the order, but default to YMD instead
int order;
if (GetYearMonthDayOrder(pattern, dtfi, out order) && order == ORDER_YDM) {
if (SetDateYMD(ref result, raw.year, n2, n1)) {
#if !FEATURE_CORECLR
// Check if NumberFormatInfo was not set up ambiguously for parsing as number and currency
// eg. if the NumberDecimalSeparator and the NumberGroupSeparator were the same. This check
- // is solely for backwards compatability / version tolerant serialization
+ // is solely for backwards compatibility / version tolerant serialization
[OptionalField(VersionAdded = 1)]
internal bool validForParseAsNumber = true; // NEVER USED, DO NOT USE THIS! (Serialized in Whidbey/Everett)
[OptionalField(VersionAdded = 1)]
}
private static Boolean TrailingZeros(String s, Int32 index) {
- // For compatability, we need to allow trailing zeros at the end of a number string
+ // For compatibility, we need to allow trailing zeros at the end of a number string
for (int i = index; i < s.Length; i++) {
if (s[i] != '\0') {
return false;
[OptionalField(VersionAdded = 3)]
private bool m_isUncShare;
- // legacy field from v1.x, not used in v2 and beyond. Retained purely for serialization compatability.
+ // legacy field from v1.x, not used in v2 and beyond. Retained purely for serialization compatibility.
private String m_fullurl;
capacityPresent = true;
break;
default:
- // Ignore other fields for forward compatability.
+ // Ignore other fields for forward compatibility.
break;
}
#include "corexcep.h"
// These functions provide limited support for corrupting exceptions
-// outside the VM folder. Its limited since we dont have access to the
+// outside the VM folder. Its limited since we don't have access to the
// throwable.
//
// These functions are also wrapped by the corresponding CEHelper
wszPathName,
&wszFileName);
- // Calculate the index while the buffer is open and the string poiner is stable.
+ // Calculate the index while the buffer is open and the string pointer is stable.
if (dwLengthWritten != 0 && dwLengthWritten < dwLengthRequired && pdwFilePartIdx != NULL)
*pdwFilePartIdx = static_cast<DWORD>(wszFileName - wszPathName);
//
// Notes:
// This fetches PDBs from the host and caches them so that they are available for when the debugger attaches.
-// This lets Arrowhead tools run against Whidbey hosts in a compatability mode.
+// This lets Arrowhead tools run against Whidbey hosts in a compatibility mode.
// We expect to add a hosting knob that will allow a host to disable this eager fetching and not run in
// compat mode.
void Module::FetchPdbsFromHost()
//*****************************************************************************
// This is the call point to make a DLL that is already loaded into our address
// space run. There will be other code to actually have us load a DLL due to a
-// class referance.
+// class reference.
//*****************************************************************************
BOOL STDMETHODCALLTYPE ExecuteDLL(HINSTANCE hInst,
DWORD dwReason,
}
public:
- // This method is purely for backward compatability of COM Interop, and its
+ // This method is purely for backward compatibility of COM Interop, and its
// implementation can be found in ClassCompat.cpp
InteropMethodTableData *BuildInteropVTable(AllocMemTracker *pamTracker);
InteropMethodTableData *BuildInteropVTableForArray(AllocMemTracker *pamTracker);
}
CONTRACTL_END;
- // Force to ApplicationException for compatability with previous versions. We would
+ // Force to ApplicationException for compatibility with previous versions. We would
// prefer a "Win32Exception" here.
EX_THROW(EEMessageException, (kApplicationException, hr, 0 /* resid*/,
NULL /* szArg1 */, NULL /* szArg2 */, NULL /* szArg3 */, NULL /* szArg4 */,
// Treat base class as an initial member.
cbAdjustedParentLayoutNativeSize = pParentLayoutInfo->GetNativeSize();
// If the parent was originally a zero-sized explicit type but
- // got bumped up to a size of 1 for compatability reasons, then
+ // got bumped up to a size of 1 for compatibility reasons, then
// we need to remove the padding, but ONLY for inheritance situations.
if (pParentLayoutInfo->IsZeroSized()) {
CONSISTENCY_CHECK(cbAdjustedParentLayoutNativeSize == 1);
// try to load a type, so that type system will not try to test type
// loadability in the current AppDomain. However,
// ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE does not prevent callers from
- // loading a type. It is profiler's responsiblity not to attempt to load
+ // loading a type. It is profiler's responsibility not to attempt to load
// a type in unsupported ways (e.g. from a non-EE thread). It doesn't
// impact retail builds, in which contracts are not available.
ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE();
// ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE also defines FAULT_FORBID, which
// causes Scanruntime to flag a fault violation in AssemblySpec::InitializeSpec,
- // which is defined as FAULTS. It only happneds in a type-loading path, which
+ // which is defined as FAULTS. It only happens in a type-loading path, which
// is not supported on a non-EE thread. Suppressing a contract violation in an
- // unsupported execution path is more preferable than casuing AV when calling
+ // unsupported execution path is more preferable than causing AV when calling
// GetClassFromTokenAndTypeArgs on a non-EE thread in a check build. See Dev10
// 682526 for more details.
FAULT_NOT_FATAL();
//
// ZapNode that points into middle of other ZapNode. It is used to create
-// pointers into datastructures that are not convinient to split into smaller zap nodes.
+// pointers into datastructures that are not convenient to split into smaller zap nodes.
//
// ======================================================================================
projects / platform / upstream / coreclr.git / commitdiff