else
charsCopied = _snwprintf_s(pTextValueCursor, cchTextValueCursor, _TRUNCATE, L" | %s", mdName);
- // if an error or truncation occured, stop copying
+ // if an error or truncation occurred, stop copying
if(charsCopied == -1)
{
cchTextValueCursor = 0;
COMMAND: analyzeoom.
!AnalyzeOOM
-!AnalyzeOOM displays the info of the last OOM occured on an allocation request to
+!AnalyzeOOM displays the info of the last OOM occurred on an allocation request to
the GC heap (in Server GC it displays OOM, if any, on each GC heap).
To see the managed exception(s) use the !Threads command which will show you
0:011> !ao
---------Heap 2 ---------
-Managed OOM occured after GC #28 (Requested to allocate 1234 bytes)
+Managed OOM occurred after GC #28 (Requested to allocate 1234 bytes)
Reason: Didn't have enough memory to commit
Detail: SOH: Didn't have enough memory to grow the internal GC datastructures (800000 bytes) -
on GC entry available commit space was 500 MB
---------Heap 4 ---------
-Managed OOM occured after GC #12 (Requested to allocate 100000 bytes)
+Managed OOM occurred after GC #12 (Requested to allocate 100000 bytes)
Reason: Didn't have enough memory to allocate an LOH segment
Detail: LOH: Failed to reserve memory (16777216 bytes)
value1 = (value1 << 32) | value2;
endptr1 = endptr2;
}
- // if the hex number was specified as 000006fbf9b70f50, an overflow occured
+ // if the hex number was specified as 000006fbf9b70f50, an overflow occurred
else if (ULONG_MAX == value1 && errno == ERANGE)
{
if (!strncmp(ptr, "0x", 2))
COMMAND: analyzeoom.
!AnalyzeOOM
-!AnalyzeOOM displays the info of the last OOM occured on an allocation request to
+!AnalyzeOOM displays the info of the last OOM occurred on an allocation request to
the GC heap (in Server GC it displays OOM, if any, on each GC heap).
To see the managed exception(s) use the !Threads command which will show you
0:011> !ao
---------Heap 2 ---------
-Managed OOM occured after GC #28 (Requested to allocate 1234 bytes)
+Managed OOM occurred after GC #28 (Requested to allocate 1234 bytes)
Reason: Didn't have enough memory to commit
Detail: SOH: Didn't have enough memory to grow the internal GC datastructures (800000 bytes) -
on GC entry available commit space was 500 MB
---------Heap 4 ---------
-Managed OOM occured after GC #12 (Requested to allocate 100000 bytes)
+Managed OOM occurred after GC #12 (Requested to allocate 100000 bytes)
Reason: Didn't have enough memory to allocate an LOH segment
Detail: LOH: Failed to reserve memory (16777216 bytes)
void PrintOOMInfo(DacpOomData* oomData)
{
- ExtOut("Managed OOM occured after GC #%d (Requested to allocate %d bytes)\n",
+ ExtOut("Managed OOM occurred after GC #%d (Requested to allocate %d bytes)\n",
oomData->gc_index, oomData->alloc_size);
if ((oomData->reason == oom_budget) ||
IF_FAIL_GO(FUSION_E_REF_DEF_MISMATCH);
}
- // Up-stack expects S_OK when we don't find any candidate assemblies and no fatal error occured (ie, no S_FALSE)
+ // Up-stack expects S_OK when we don't find any candidate assemblies and no fatal error occurred (ie, no S_FALSE)
hr = S_OK;
Exit:
return hr;
NewHolder<FailureCacheEntry> pFailureCacheEntry;
SAFE_NEW(pFailureCacheEntry, FailureCacheEntry);
- // No error occured; report the original error
+ // No error occurred; report the original error
hr = hrBindingResult;
pFailureCacheEntry->GetAssemblyNameOrPath().Set(assemblyNameorPath);
}
HRESULT hrCallback = S_OK;
- // It's possible a ICorDebugProcess::Detach() may have occured by now.
+ // It's possible a ICorDebugProcess::Detach() may have occurred by now.
{
// @dbgtodo shim: eventually the entire RCET should be considered outside the RS.
PUBLIC_CALLBACK_IN_THIS_SCOPE0_NO_LOCK(this);
_ASSERTE(pAppDomain != NULL);
- // For some exceptions very early in startup (eg, TypeLoad), this may have occured before we
+ // For some exceptions very early in startup (eg, TypeLoad), this may have occurred before we
// even executed jitted code on the thread. We may have not received a CreateThread yet.
// In V2, we detected this and sent a LogMessage on a random thread.
// In V3, we lazily create the CordbThread objects (possibly before the CreateThread event),
// countBytes - number of bytes in pRawRecord buffer.
// format - format of pRawRecord
// dwFlags - flags providing auxillary info for exception record.
-// dwThreadId - thread that exception occured on.
+// dwThreadId - thread that exception occurred on.
// pCallback - callback to dispatch potential managed events on.
// pContinueStatus - Continuation status for exception. This dictates what
// to pass to kernel32!ContinueDebugEvent().
// Triage a 1st-chance exception when the CLR is initialized.
//
// Arguments:
-// pUnmanagedThread - thread that the event has occured on.
-// pEvent - native debug event for the exception that occured that this is triaging.
+// pUnmanagedThread - thread that the event has occurred on.
+// pEvent - native debug event for the exception that occurred that this is triaging.
//
// Return Value:
// Reaction for how to handle this event.
// Triage a 2nd-chance exception when the CLR is initialized.
//
// Arguments:
-// pUnmanagedThread - thread that the event has occured on.
-// pEvent - native debug event for the exception that occured that this is triaging.
+// pUnmanagedThread - thread that the event has occurred on.
+// pEvent - native debug event for the exception that occurred that this is triaging.
//
// Return Value:
// Reaction for how to handle this event.
if (dwNo2ndChance)
{
- CONSISTENCY_CHECK_MSGF(false, ("2nd chance exception occured on LS thread=0x%x, code=0x%08x, address=0x%p\n"
+ CONSISTENCY_CHECK_MSGF(false, ("2nd chance exception occurred on LS thread=0x%x, code=0x%08x, address=0x%p\n"
"This assert is firing b/c you explicitly requested it by having the 'DbgNo2ndChance' knob enabled.\n"
"Disable it to avoid asserts on 2nd chance.",
pUnmanagedThread->m_id,
// Triage a win32 Debug event to get a reaction
//
// Arguments:
-// pUnmanagedThread - thread that the event has occured on.
-// pEvent - native debug event for the exception that occured that this is triaging.
+// pUnmanagedThread - thread that the event has occurred on.
+// pEvent - native debug event for the exception that occurred that this is triaging.
//
// Return Value:
// Reaction for how to handle this event.
return m_pCallback3;
}
-// Returns OS Thread Id that this event occured on, 0 if no thread affinity.
+// Returns OS Thread Id that this event occurred on, 0 if no thread affinity.
DWORD ManagedEvent::GetOSTid()
{
return m_dwThreadId;
#endif //EnC_SUPPORTED
// DebuggerController::DispatchPatchOrSingleStep - Ask any patches that are active at a given
-// address if they want to do anything about the exception that's occured there. How: For the given
+// address if they want to do anything about the exception that's occurred there. How: For the given
// address, go through the list of patches & see if any of them are interested (by invoking their
// DebuggerController's TriggerPatch). Put any DCs that are interested into a queue and then calls
// SendEvent on each.
if (fAttaching)
{
JitAttach(pThread, pExceptionInfo, managedEventNeeded, FALSE);
- // If the jit-attach occured, CORDebuggerAttached() may now be true and we can
+ // If the jit-attach occurred, CORDebuggerAttached() may now be true and we can
// just act as if a debugger was always attached.
}
/*
* RecordFuncEvalException
*
- * Helper function records the details of an exception that occured during a FuncEval
+ * Helper function records the details of an exception that occurred during a FuncEval
* Note that this should be called from within the target domain of the FuncEval.
*
* Parameters:
RecordFuncEvalException( pDE, ppException);
}
// Note: we need to catch all exceptioins here because they all get reported as the result of
- // the funceval. If a ThreadAbort occured other than for a funcEval abort, we'll re-throw it manually.
+ // the funceval. If a ThreadAbort occurred other than for a funcEval abort, we'll re-throw it manually.
EX_END_CATCH(SwallowAllExceptions);
// Restore context
RecordFuncEvalException( pDE, ppException);
}
// Note: we need to catch all exceptioins here because they all get reported as the result of
- // the funceval. If a ThreadAbort occured other than for a funcEval abort, we'll re-throw it manually.
+ // the funceval. If a ThreadAbort occurred other than for a funcEval abort, we'll re-throw it manually.
EX_END_CATCH(SwallowAllExceptions);
GCPROTECT_END();
SS_Opening_NC, // Session is being formed but no connection is established yet
SS_Opening, // Session is being formed, the low level connection is in place
SS_Open, // Session is fully formed and normal transport messages can be sent and received
- SS_Resync_NC, // A low level connection error is occured and we're attempting to re-form the link
+ SS_Resync_NC, // A low level connection error is occurred and we're attempting to re-form the link
SS_Resync, // We're trying to resynchronize high level state over the new connection
};
extern void DECLSPEC_NORETURN ThrowOutOfMemory();
//*****************************************************************************
-// Called for errors that might have occured.
+// Called for errors that might have occurred.
//*****************************************************************************
FARPROC __stdcall CorDelayErrorHook( // Always 0.
- unsigned dliNotify, // What event has occured, dli* flag.
+ unsigned dliNotify, // What event has occurred, dli* flag.
DelayLoadInfo *pdli) // Description of the event.
{
// A library failed to load. This is always a bad thing.
//*****************************************************************************
void _FailLoadLib(
- unsigned dliNotify, // What event has occured, dli* flag.
+ unsigned dliNotify, // What event has occurred, dli* flag.
DelayLoadInfo *pdli) // Description of the event.
{
STATIC_CONTRACT_NOTHROW;
// A library failed to load. This is always a bad thing.
//*****************************************************************************
void _FailGetProc(
- unsigned dliNotify, // What event has occured, dli* flag.
+ unsigned dliNotify, // What event has occurred, dli* flag.
DelayLoadInfo *pdli) // Description of the event.
{
STATIC_CONTRACT_NOTHROW;
// load event that occurs while the application is running.
//*****************************************************************************
FARPROC __stdcall CorDelayLoadHook( // Always 0.
- unsigned dliNotify, // What event has occured, dli* flag.
+ unsigned dliNotify, // What event has occurred, dli* flag.
DelayLoadInfo *pdli) // Description of the event.
{
#ifdef _DEBUG
}
// Process any mark stack overflow that may have resulted from scanning handles (or if we didn't need to
- // scan any handles at all this is the processing of overflows that may have occured prior to this method
+ // scan any handles at all this is the processing of overflows that may have occurred prior to this method
// invocation).
process_mark_overflow(condemned_gen_number);
}
// If you get this assertion, someone updated a GC poitner in the heap without
// using the write barrier. To find out who, check the value of
// dd_collection_count (dynamic_data_of (0)). Also
- // note the value of 'ptr'. Rerun the App that the previous GC just occured.
+ // note the value of 'ptr'. Rerun the App that the previous GC just occurred.
// Then put a data breakpoint for the value of 'ptr' Then check every write
// to pointer between the two GCs. The last one is not using the write barrier.
// Clients should not make any assumption about whether the controller is a process or appdomain (though they can
// always QI to find out).
// Call continue on this to resume the debuggee.
- // - pThread - managed thread on which the debug event occured. If the MDA occurred on an unmanaged thread then
+ // - pThread - managed thread on which the debug event occurred. If the MDA occurred on an unmanaged thread then
// this will be null. Get the OS thread ID from the MDA object itself.
// - pMDA is an object containing MDA information.
// Suggested usage is that the client does not keep a reference to the MDA object after returning from this callback
* will return TRUE if there are currently managed callbacks
* queued for any thread.
*
- * Note that once debug events have been queued, they've already occured,
+ * Note that once debug events have been queued, they've already occurred,
* and so the debugger must drain the entire queue to be sure of the state
* of the debuggee. For example, if the queue contains 2 debug events on thread X,
* and the debugger suspends thread X after the 1st debug event and then calls continue,
HRESULT GetEventKind([out]CorDebugDebugEventKind *pDebugEventKind);
/*
- * Gets the thread on which the event occured
+ * Gets the thread on which the event occurred
*/
HRESULT GetThread([out]ICorDebugThread **ppThread);
}
*/
#define COMPlusThrowNonLocalized(key, msg) throw msg
-// Set if fatal error (like stack overflow or out of memory) occured in this process.
+// Set if fatal error (like stack overflow or out of memory) occurred in this process.
extern HRESULT g_hrFatalError;
#endif //CLR_STANDALONE_BINDER
return hr;
}
-// Set if fatal error (like stack overflow or out of memory) occured in this process.
+// Set if fatal error (like stack overflow or out of memory) occurred in this process.
GVAL_DECL(HRESULT, g_hrFatalError);
#endif // !CLR_STANDALONE_BINDER
class SOIntolerantTransitionHandler
{
private:
- bool m_exceptionOccured;
+ bool m_exceptionOccurred;
void * m_pPreviousHandler;
public:
void SetNoException()
{
- m_exceptionOccured = false;
+ m_exceptionOccurred = false;
}
bool DidExceptionOccur()
{
- return m_exceptionOccured;
+ return m_exceptionOccurred;
}
};
unsigned int m_depth; // How deep is this guard in the list of guards for this thread?
BOOL m_fProtectedStackPage; // TRUE if we protected a stack page with PAGE_NOACCESS.
BOOL m_fEHInProgress; // Is an EH in progress? This is cleared on a catch.
- BOOL m_exceptionOccured; // Did an exception occur through this probe?
+ BOOL m_exceptionOccurred; // Did an exception occur through this probe?
protected:
BaseStackGuardGeneric()
m_eInitialized(cPartialInit), m_fDisabled(FALSE),
m_isBoundaryGuard(FALSE),
m_fEHInProgress(FALSE),
- m_exceptionOccured(FALSE)
+ m_exceptionOccurred(FALSE)
{
STATIC_CONTRACT_LEAF;
}
void SetNoException()
{
- m_exceptionOccured = FALSE;
+ m_exceptionOccurred = FALSE;
}
BOOL DidExceptionOccur()
{
- return m_exceptionOccured;
+ return m_exceptionOccurred;
}
BOOL Enabled()
#ifndef FEATURE_CORECLR
#include <delayimp.h>
-extern FARPROC __stdcall ShimDelayLoadHook(unsigned dliNotify, // What event has occured, dli* flag.
+extern FARPROC __stdcall ShimDelayLoadHook(unsigned dliNotify, // What event has occurred, dli* flag.
DelayLoadInfo *pdli); // Description of the event.
//and one for safe mode
-extern FARPROC __stdcall ShimSafeModeDelayLoadHook(unsigned dliNotify, // What event has occured, dli* flag.
+extern FARPROC __stdcall ShimSafeModeDelayLoadHook(unsigned dliNotify, // What event has occurred, dli* flag.
DelayLoadInfo *pdli); // Description of the event.
#endif
return S_OK;
ErrExit:
- // An error occured.
+ // An error occurred.
return hr;
} // HRESULT CImportTlb::CompareSigsIgnoringRetType()
/**
* Retrieves the current state of the dirty property.
*
- * A key is marked as dirty if any operation has occured that modifies the
+ * A key is marked as dirty if any operation has occurred that modifies the
* contents of the key.
*
* @return <b>true</b> if the key has been modified.
// that no jit allocations etc. will occur, but don't allocate memory unless
// you can deal with the failure and still free the handle).
// The boolean returned should be true for success and false if a
- // catastrophic error occured and you wish to trigger a diagnostic for
+ // catastrophic error occurred and you wish to trigger a diagnostic for
// debugging purposes (the SafeHandleCriticalFailure MDA).
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
protected abstract bool ReleaseHandle();
private static Guid s_iidIErrorInfo = new Guid(0x1CF2B120, 0x547D, 0x101B, 0x8E, 0x65, 0x08, 0x00, 0x2B, 0x2B, 0xD1, 0x19);
/// <summary>
- /// Report that an exception has occured which went user unhandled. This allows the global error handler
+ /// Report that an exception has occurred which went user unhandled. This allows the global error handler
/// for the application to be invoked to process the error.
/// </summary>
/// <returns>true if the error was reported, false if not (ie running on Win8)</returns>
// Do the signature verification. A TRUE result means that the signature was valid. A FALSE
// result either means an invalid signature or some other error, so we need to check the last
- // error to see which occured.
+ // error to see which occurred.
if (UnsafeNativeMethods.CryptVerifySignature(hashHandle,
signatureValue,
signatureValue.Length,
{
// Remove the entry from the array.
// This call includes a full memory fence which prevents potential reorderings of the reads below
- bool deregisterOccured = TryDeregister();
+ bool deregisterOccurred = TryDeregister();
// We guarantee that we will not return if the callback is being executed (assuming we are not currently called by the callback itself)
// We achieve this by the following rules:
var tokenSource = callbackInfo.CancellationTokenSource;
if (tokenSource.IsCancellationRequested && //running callbacks has commenced.
!tokenSource.IsCancellationCompleted && //running callbacks hasn't finished
- !deregisterOccured && //deregistration failed (ie the callback is missing from the list)
+ !deregisterOccurred && //deregistration failed (ie the callback is missing from the list)
tokenSource.ThreadIDExecutingCallbacks != Thread.CurrentThread.ManagedThreadId) //the executingThreadID is not this threadID.
{
// Callback execution is in progress, the executing thread is different to us and has taken the callback for execution
}
/// <summary>
- /// A simple helper to determine whether disposal has occured.
+ /// A simple helper to determine whether disposal has occurred.
/// </summary>
internal bool IsDisposed
{
// only removes the item at the specified index if it is still the expected one.
// Returns the prevailing value.
- // The remove occured successfully if the return value == expected element
+ // The remove occurred successfully if the return value == expected element
// otherwise the remove did not occur.
internal T SafeAtomicRemove(int index, T expectedElement)
{
STRSAFE_E_END_OF_FILE
- this return value indicates an error or end-of-file condition,
- use feof or ferror to determine which one has occured.
+ use feof or ferror to determine which one has occurred.
STRSAFE_E_INSUFFICIENT_BUFFER /
HRESULT_CODE(hr) == ERROR_INSUFFICIENT_BUFFER
STRSAFE_E_END_OF_FILE
- this return value indicates an error or end-of-file condition,
- use feof or ferror to determine which one has occured.
+ use feof or ferror to determine which one has occurred.
STRSAFE_E_INSUFFICIENT_BUFFER /
HRESULT_CODE(hr) == ERROR_INSUFFICIENT_BUFFER
STRSAFE_E_END_OF_FILE
- this return value indicates an error or end-of-file condition,
- use feof or ferror to determine which one has occured.
+ use feof or ferror to determine which one has occurred.
STRSAFE_E_INSUFFICIENT_BUFFER /
HRESULT_CODE(hr) == ERROR_INSUFFICIENT_BUFFER
STRSAFE_E_END_OF_FILE
- this return value indicates an error or end-of-file condition,
- use feof or ferror to determine which one has occured.
+ use feof or ferror to determine which one has occurred.
STRSAFE_E_INSUFFICIENT_BUFFER /
HRESULT_CODE(hr) == ERROR_INSUFFICIENT_BUFFER
}
else
{
- ERROR( "An error occured while converting mode to ANSI.\n" );
+ ERROR( "An error occurred while converting mode to ANSI.\n" );
}
}
else
{
- ERROR( "An error occured while converting"
+ ERROR( "An error occurred while converting"
" fileName to ANSI string.\n" );
}
LOGEXIT("_wfopen returning FILE* %p\n", filePtr);
if ((dir != NULL) && WideCharToMultiByte( CP_ACP, 0, dir, -1, Dir,
_MAX_DIR, NULL, NULL ) == 0 )
{
- ASSERT( "An error occured while converting dir to multibyte."
+ ASSERT( "An error occurred while converting dir to multibyte."
"Possible error: Length of dir is greater than _MAX_DIR.\n" );
goto error;
}
if ((fname != NULL) && WideCharToMultiByte( CP_ACP, 0, fname, -1, FileName,
_MAX_FNAME, NULL, NULL ) == 0 )
{
- ASSERT( "An error occured while converting fname to multibyte."
+ ASSERT( "An error occurred while converting fname to multibyte."
"Possible error: Length of fname is greater than _MAX_FNAME.\n" );
goto error;
}
if ((ext != NULL) && WideCharToMultiByte( CP_ACP, 0, ext, -1, Ext,
_MAX_EXT, NULL, NULL ) == 0 )
{
- ASSERT( "An error occured while converting ext to multibyte."
+ ASSERT( "An error occurred while converting ext to multibyte."
"Possible error: Length of ext is greater than _MAX_EXT.\n" );
goto error;
}
if ( MultiByteToWideChar( CP_ACP, 0, Path, -1, path, _MAX_PATH ) == 0 )
{
- ASSERT( "An error occured while converting the back wide char."
+ ASSERT( "An error occurred while converting the back wide char."
"Possible error: The length of combined path is greater "
"than _MAX_PATH.\n" );
goto error;
/* See if strtod failed. */
if ( RetVal == 0.0 && ScanStop == lpStringRep )
{
- ASSERT( "An error occured in the conversion.\n" );
+ ASSERT( "An error occurred in the conversion.\n" );
lpEndOfExpression = (LPWSTR)nptr;
}
}
if ( 0 == MultiByteToWideChar( CP_ACP, 0, TempBuffer, -1,
lpBuffer, dwRetVal + 1 ) )
{
- ASSERT( "An error occured while converting the string to wide.\n" );
+ ASSERT( "An error occurred while converting the string to wide.\n" );
SetLastError( ERROR_INTERNAL_ERROR );
dwRetVal = 0;
}
Pointer to string with the fullpath to the librotor_pal.so being
used.
- NULL if error occured.
+ NULL if error occurred.
Notes:
The string returned by this function is owned by the OS.
LocalFree( lpReturnString );
}
}
- else /* Error, something occured. */
+ else /* Error, something occurred. */
{
if ( lpReturnString )
{
=======================================
This test case is written according to the MSDN doc: testing gethostbyaddr
with an invalid type, an error WSAEAFNOSUPPORT is expected, the test result is:
-no error occured with PAL library.
-no error occured with win32 base library.
+no error occurred with PAL library.
+no error occurred with win32 base library.
networking/gethostbyaddr/gethostbyaddr_neg3
=======================================
This test case is written according to the MSDN doc: testing gethostbyaddr
with a small len parameter, an error WSAEFAULT is expected, the test result is:
-no error occured with PAL library
+no error occurred with PAL library
and correct hostent struct data is retrieved
-no error occured with win32 base library
+no error occurred with win32 base library
and correct hostent struct data is retrieved
close a non-blocking stream socket with SO_LINGER setting to a nonzero
time-out value, an error WSAEWOULDBLOCK is expected, the test result is:
-no error occured with PAL library
+no error occurred with PAL library
-no error occured with win32 base library
+no error occurred with win32 base library
networking/send_recv/recv_neg7
Description
= Tests the PAL implementation of the ferror function.
= Open a file, and read some characters. Check that ferror states that
-= no error has occured. Then close the file pointer. Attempt to read
+= no error has occurred. Then close the file pointer. Attempt to read
= some more. Check ferror now, and it should indicate that an error has
-= occured.
+= occurred.
if (buf[numchars] != (char)-1)
{
- Fail("ERROR: overflow occured in scanning character(s) from \"%s\" "
+ Fail("ERROR: overflow occurred in scanning character(s) from \"%s\" "
"using \"%s\".\nExpected %d character(s)\n", inputstr, formatstr,
numchars);
}
if (buf[numchars] != (WCHAR)-1)
{
- Fail("ERROR: overflow occured in scanning wide character(s) from \"%s\" "
+ Fail("ERROR: overflow occurred in scanning wide character(s) from \"%s\" "
"using \"%s\".\nExpected %d character(s)\n", inputstr, formatstr,
numchars);
}
if (buf[4] != (char)-1)
{
- Fail("ERROR: overflow occured in scanning float from \"%s\" "
+ Fail("ERROR: overflow occurred in scanning float from \"%s\" "
"using \"%s\".\n", inputstr, formatstr);
}
if (buf[numchars] != (char)-1)
{
- Fail("ERROR: overflow occured in scanning character(s) from \"%s\" "
+ Fail("ERROR: overflow occurred in scanning character(s) from \"%s\" "
"using \"%s\".\nExpected %d character(s)\n",
convertC(inputstr), convertC(formatstr), numchars);
}
if (buf[numchars] != (WCHAR)-1)
{
- Fail("ERROR: overflow occured in scanning wide character(s) from \"%s\" "
+ Fail("ERROR: overflow occurred in scanning wide character(s) from \"%s\" "
"using \"%s\".\nExpected %d character(s)\n",
convertC(inputstr), convertC(formatstr), numchars);
}
if (buf[4] != (char)-1)
{
- Fail("ERROR: overflow occured in scanning float from \"%s\" "
+ Fail("ERROR: overflow occurred in scanning float from \"%s\" "
"using \"%s\".\n", convertC(inputstr), convertC(formatstr));
}
if(NULL != FileMappingHandle || ERROR_FILE_INVALID != GetLastError())
- {//no error occured
+ {//no error occurred
Trace("\nFailed to call CreateFileMapping API for a negative test!\n");
err = CloseHandle(FileHandle);
if(0 == err)
/* Exchanged, these should be equal now */
if(BaseVariableToManipulate != ValueToExchange)
{
- Fail("ERROR: A successful compare and exchange should have occured, "
+ Fail("ERROR: A successful compare and exchange should have occurred, "
"making the variable have the value of %d, as opposed to the "
"current value of %d.",
ValueToExchange,BaseVariableToManipulate);
if(BaseVariableToManipulate != ValueToExchange)
{
#ifdef PLATFORM_UNIX
- Fail("ERROR: A successful compare and exchange should have occured, "
+ Fail("ERROR: A successful compare and exchange should have occurred, "
"making the variable have the value of %ll, as opposed to the "
"current value of %ll.",
ValueToExchange,BaseVariableToManipulate);
#else
- Fail("ERROR: A successful compare and exchange should have occured, "
+ Fail("ERROR: A successful compare and exchange should have occurred, "
"making the variable have the value of %I64, as opposed to the "
"current value of %d.",
ValueToExchange,BaseVariableToManipulate);
if( NULL != pFile )
{
Trace("\nFailed to call fopen to open a not exist for reading, "
- "an error is expected, but no error occured\n");
+ "an error is expected, but no error occurred\n");
if( EOF == fclose( pFile ) )
{
else
{
/* Check to ensure the parameter hasn't changed. The
- function shouldn't have occured yet.
+ function shouldn't have occurred yet.
*/
if (dwResumeThreadTestParameter != 0)
{
{
delete[] m_lastErrorMessage;
}
- m_errorOccured = true;
+ m_errorOccurred = true;
m_lastErrorMessage = new WCHAR[wcslen(pwzMessage) + 1];
if (m_lastErrorMessage == nullptr)
{
// Process Response Files
ProcessResponseArgs();
- if (m_errorOccured)
+ if (m_errorOccurred)
return false;
// Now convert to an argc/argv form for remaining processing.
*pargc2 = newArgc;
*pppargv2 = m_rgArgs;
- return !m_errorOccured;
+ return !m_errorOccurred;
}
//
WCHAR szFilename[MAX_LONGPATH];
for (WStrList * listCurArg = m_listArgs;
- listCurArg != NULL && !m_errorOccured;
+ listCurArg != NULL && !m_errorOccurred;
listCurArg = listCurArg->next)
{
WCHAR * szArg = listCurArg->arg;
ConsoleArgs() :
m_rgArgs(NULL),
m_listArgs(NULL),
- m_errorOccured(false),
+ m_errorOccurred(false),
m_lastErrorMessage(nullptr)
{
};
LPCWSTR ErrorMessage()
{
- if (m_errorOccured)
+ if (m_errorOccurred)
{
return m_lastErrorMessage;
}
LPWSTR * m_rgArgs;
WStrList * m_listArgs;
- bool m_errorOccured;
+ bool m_errorOccurred;
LPCWSTR m_lastErrorMessage;
};
#define MAX_EXCEPTION_MSG 200
-// Set if fatal error (like stack overflow or out of memory) occured in this process.
+// Set if fatal error (like stack overflow or out of memory) occurred in this process.
GVAL_IMPL_INIT(HRESULT, g_hrFatalError, S_OK);
// Helper function to get an exception object from outside the exception. In
NOINLINE void SOIntolerantTransitionHandler::CtorImpl()
{
- m_exceptionOccured = true;
+ m_exceptionOccurred = true;
m_pPreviousHandler = ClrFlsGetValue(TlsIdx_SOIntolerantTransitionHandler);
g_fpSetSOIntolerantTransitionMarker();
}
// limit. Checking for the guard page being present is too much overhead during
// exception handling (if you can believe that) and impacts perf.
- if (m_exceptionOccured)
+ if (m_exceptionOccurred)
{
g_fpCheckForSOInSOIntolerantCode();
}
// check for context propagation
if (bRetVal && pSpec->GetParentLoadContext() == LOADCTX_TYPE_LOADFROM && pAssembly->GetFile()->GetLoadContext() == LOADCTX_TYPE_DEFAULT)
{
- // LoadFrom propagation occured, store it in a way reachable by Load() (the "post-policy" one)
+ // LoadFrom propagation occurred, store it in a way reachable by Load() (the "post-policy" one)
AssemblySpec loadSpec;
loadSpec.CopyFrom(pSpec);
loadSpec.SetParentAssembly(NULL);
// If the caller and target method are non-null and the same, then this means that we're checking to see
// if the method has access to itself in order to validate that it has access to its parameter types,
// containing type, and return type. In this case, throw a more informative TypeAccessException to
- // describe the error that occured (for instance, "this method doesn't have access to one of its
+ // describe the error that occurred (for instance, "this method doesn't have access to one of its
// parameter types", rather than "this method doesn't have access to itself").
// We only want to do this if we know the exact type that caused the problem, otherwise fall back to
// throwing the standard MethodAccessException.
// Throws if a load error has occurred
void ThrowIfError(FileLoadLevel targetLevel) DAC_EMPTY();
- // Checks that a load error has not occured before the given level
+ // Checks that a load error has not occurred before the given level
CHECK CheckNoError(FileLoadLevel targetLevel) DAC_EMPTY_RET(CHECK::OK());
// IsNotified means that the profiler API notification has been delivered
// probably inside of mscorwks
//
// Note that while there may be an actual managed exception that
- // occured, we can live without the managed bucket parameters. For
+ // occurred, we can live without the managed bucket parameters. For
// exceptions coming from within mscorwks.dll, the native bucket
// parameters will do just fine.
UINT_PTR address = reinterpret_cast<UINT_PTR>(pExceptionRecord->ExceptionAddress);
// An exception code of EXCEPTION_COMPLUS indicates a managed exception
- // has occured (most likely due to executing a "throw" instruction).
+ // has occurred (most likely due to executing a "throw" instruction).
//
// Also, a hardware level exception may not have an exception code of
// EXCEPTION_COMPLUS. In this case, an exception address that resides in
- // managed code indicates a managed exception has occured.
+ // managed code indicates a managed exception has occurred.
return (IsComPlusException(pExceptionRecord) ||
(ExecutionManager::IsManagedCode((PCODE)address)));
}
//
// This needs to be done before the check for TSNC_ProcessedUnhandledException because it is perfectly
// legitimate (though rare) for the debugger to be inspecting exceptions which are nested in finally
- // clauses that run after an unhandled exception has already occured on the thread
+ // clauses that run after an unhandled exception has already occurred on the thread
if ((pThread != NULL) && pThread->IsExceptionInProgress())
{
LOG((LF_EH, LL_INFO1000, "InternalUnhandledExceptionFilter_Worker: Set unhandled exception flag at %p\n",
* Returns whether this is an exception the EE knows how to intercept and continue from.
*
* Parameters:
- * pThread - The thread the exception occured on.
+ * pThread - The thread the exception occurred on.
*
* Returns:
* TRUE if the exception on the thread is interceptable or not.
// to fixup the state before any other part of the system uses it (we do it here since only the debugger
// uses single step functionality).
- // First ask the emulation itself whether this exception occured while single stepping was enabled. If so
+ // First ask the emulation itself whether this exception occurred while single stepping was enabled. If so
// it will fix up the context to be consistent again and return true. If so and the exception was
// EXCEPTION_BREAKPOINT then we translate it to EXCEPTION_SINGLE_STEP (otherwise we leave it be, e.g. the
// instruction stepped caused an access violation). since this is called from our VEH there might not
// not already have one allocated. Thus, if we OOM during the setting up of the
// thread, the log buffer will not be allocated and this will try to do so. Thus,
// all STRESS_LOGs in here need to be after you have guaranteed the allocation has
- // already occured.
+ // already occurred.
//
Thread *pThread;
// not already have one allocated. Thus, if we OOM during the setting up of the
// thread, the log buffer will not be allocated and this will try to do so. Thus,
// all STRESS_LOGs in here need to be after you have guaranteed the allocation has
- // already occured.
+ // already occurred.
//
PEXCEPTION_RECORD pExceptionRecord = pExceptionInfo->ExceptionRecord;
// not already have one allocated. Thus, if we OOM during the setting up of the
// thread, the log buffer will not be allocated and this will try to do so. Thus,
// all STRESS_LOGs in here need to be after you have guaranteed the allocation has
- // already occured.
+ // already occurred.
//
// Handle special cases which are common amongst all filters.
if (breakOnSO != 0)
{
- _ASSERTE(!"SO occured");
+ _ASSERTE(!"SO occurred");
}
#endif
// relies on transition frame, we still cannot let an exception be handled
// by an unprotected managed frame.
//
- // This code below checks to see if a SO has occured outside of managed code.
+ // This code below checks to see if a SO has occurred outside of managed code.
// If it has, and if we don't have a transition frame higher up the stack, then
// we don't handle the SO.
if (!(dwExceptionFlags & EXCEPTION_UNWINDING))
// Reference to the topmost handler we saw during an SO that goes past us
PTR_EXCEPTION_REGISTRATION_RECORD m_pTopMostHandlerDuringSO;
- LPVOID m_dEsp; // Esp when fault occured, OR esp to restore on endcatch
+ LPVOID m_dEsp; // Esp when fault occurred, OR esp to restore on endcatch
StackTraceInfo m_StackTraceInfo;
FRAME_ATTR_OUT_OF_LINE = 2, // The exception out of line (IP of the frame is not correct)
FRAME_ATTR_FAULTED = 4, // Exception caused by Win32 fault
FRAME_ATTR_RESUMABLE = 8, // We may resume from this frame
- FRAME_ATTR_CAPTURE_DEPTH_2 = 0x10, // This is a helperMethodFrame and the capture occured at depth 2
+ FRAME_ATTR_CAPTURE_DEPTH_2 = 0x10, // This is a helperMethodFrame and the capture occurred at depth 2
FRAME_ATTR_EXACT_DEPTH = 0x20, // This is a helperMethodFrame and a jit helper, but only crawl to the given depth
FRAME_ATTR_NO_THREAD_ABORT = 0x40, // This is a helperMethodFrame that should not trigger thread aborts on entry
};
"setting up the proper exception handling.\n\n"
"Get a good unmanaged stack trace for this thread. All FS:0 records are on the stack, "
"so you can see who installed the last handler. Somewhere between that function and "
- "where the thread is now is where the bad transition occured.\n\n"
+ "where the thread is now is where the bad transition occurred.\n\n"
"A little extra info: FS:0 = 0x%p, pEHR->Handler = 0x%p\n",
GetRegdisplaySP(pCF->GetRegisterSet()),
pFunction ->m_pszDebugClassName,
{
// If we ever get here in preemptive mode, we're in trouble. We've
// changed the thread's IP to point at a little function that throws ... if
- // the thread were to be in preemptive mode and a GC occured, the stack
+ // the thread were to be in preemptive mode and a GC occurred, the stack
// crawl would have been all messed up (becuase we have no frame that points
// us back to the right place in managed code).
_ASSERTE(disabled);
#endif // MDA_SUPPORTED
#ifdef FEATURE_COMINTEROP
- LogInterop(W("An exception occured during release"));
+ LogInterop(W("An exception occurred during release"));
LogInteropLeak(pUnk);
#endif // FEATURE_COMINTEROP
{
_ASSERTE(!"Access violation while Jitting!");
// If you set the debugger to catch access violations and 'go'
- // you will get back to the point at which the access violation occured
+ // you will get back to the point at which the access violation occurred
result = EXCEPTION_CONTINUE_EXECUTION;
}
else
in SafeHandle cleanup.
CAUSE:
- An unexpected error occured while cleaning up temporary structures. Review all SafeHandle destructor / finalizer implementations and
+ An unexpected error occurred while cleaning up temporary structures. Review all SafeHandle destructor / finalizer implementations and
custom-marshaler implementations for errors.
OUTPUT:
_ASSERTE(Thread::IsObjRefValid(&objref));
VALIDATEOBJECT(m_asObj);
// If this assert fires, you probably did not protect
- // your OBJECTREF and a GC might have occured. To
+ // your OBJECTREF and a GC might have occurred. To
// where the possible GC was, set a breakpoint in Thread::TriggersGC
_ASSERTE(Thread::IsObjRefValid(this));
_ASSERTE(Thread::IsObjRefValid(&objref));
VALIDATEOBJECT(m_asObj);
// If this assert fires, you probably did not protect
- // your OBJECTREF and a GC might have occured. To
+ // your OBJECTREF and a GC might have occurred. To
// where the possible GC was, set a breakpoint in Thread::TriggersGC
_ASSERTE(Thread::IsObjRefValid(this));
VALIDATEOBJECT(m_asObj);
// If this assert fires, you probably did not protect
- // your OBJECTREF and a GC might have occured. To
+ // your OBJECTREF and a GC might have occurred. To
// where the possible GC was, set a breakpoint in Thread::TriggersGC
_ASSERTE(Thread::IsObjRefValid(this));
VALIDATEOBJECT(m_asObj);
// If this assert fires, you probably did not protect
- // your OBJECTREF and a GC might have occured. To
+ // your OBJECTREF and a GC might have occurred. To
// where the possible GC was, set a breakpoint in Thread::TriggersGC
_ASSERTE(Thread::IsObjRefValid(this));
STRINGREF refStr = (STRINGREF) *pSrc;
refStr = m_cbInterface->AllocateString(refStr);
- // Get dest addr again, as a GC might have occured
+ // Get dest addr again, as a GC might have occurred
pDest = (OBJECTREF *)(m_newObject->GetData() + dstOffset);
_ASSERTE(GetAppDomain()==m_toDomain);
SetObjectReference(pDest, refStr, GetAppDomain());
return EXCEPTION_CONTINUE_EXECUTION;
}
- // Record the fact that an exception occured while running the try code.
+ // Record the fact that an exception occurred while running the try code.
ECWGC_Param *pParam= (ECWGC_Param *)pv;
pParam->fExceptionThrownInTryCode = TRUE;
// ExecuteCodeWithGuaranteedCleanup ensures that we will call the backout code delegate even if an SO occurs. We do this by calling the
// try delegate from within an EX_TRY/EX_CATCH block that will catch any thrown exceptions and thus cause the stack to be unwound. This
// guarantees that the backout delegate is called with at least DEFAULT_ENTRY_PROBE_SIZE pages of stack. After the backout delegate is called,
-// we re-raise any exceptions that occured inside the try delegate. Note that any CER that uses large or arbitraty amounts of stack in
+// we re-raise any exceptions that occurred inside the try delegate. Note that any CER that uses large or arbitraty amounts of stack in
// it's try block must use ExecuteCodeWithGuaranteedCleanup.
//
// ExecuteCodeWithGuaranteedCleanup also guarantees that the backount code will be run before any filters higher up on the stack. This
// later when the runtime is suspended.
//
//BUGBUG: Its not clear to me why it is safe to hold ReJitInfo* lists
- // outside the table locks. If an AppDomain unload occured I don't see anything
+ // outside the table locks. If an AppDomain unload occurred I don't see anything
// that prevents them from being deleted. If this is a bug it is a pre-existing
// condition and nobody has reported it as an issue yet. AppDomainExit probably
// needs to synchronize with something.
// * methodDef - The MethodDef in the module/MethodDef identifier pair for the method which
// had an error during rejit
// * pMD - If available, the specific method instance which had an error during rejit
-// * hrStatus - HRESULT for the rejit error that occured
+// * hrStatus - HRESULT for the rejit error that occurred
// * pErrors - the list of error records that this method will append to
//
// Return Value:
//
// Arguments:
// * pReJitInfo - The method which had an error during rejit
-// * hrStatus - HRESULT for the rejit error that occured
+// * hrStatus - HRESULT for the rejit error that occurred
// * pErrors - the list of error records that this method will append to
//
// Return Value:
// This method can't have a contract because leaving the table lock
// below decrements GCNoTrigger count. Contracts always revert these changes
// at the end of the method but we need the decremented count to flow out of the
- // method. The balancing increment occured in the constructor.
+ // method. The balancing increment occurred in the constructor.
STATIC_CONTRACT_NOTHROW;
STATIC_CONTRACT_GC_TRIGGERS; // NOTRIGGER until we leave the lock
STATIC_CONTRACT_CAN_TAKE_LOCK;
// This method can't have a contract because leaving the table lock
// below decrements GCNoTrigger count. Contracts always revert these changes
// at the end of the method but we need the decremented count to flow out of the
- // method. The balancing increment occured in the constructor.
+ // method. The balancing increment occurred in the constructor.
STATIC_CONTRACT_NOTHROW;
STATIC_CONTRACT_GC_TRIGGERS; // NOTRIGGER until we leave the lock
STATIC_CONTRACT_CAN_TAKE_LOCK;
// size_t's too big on 64-bit platforms so we check for overflow
if(n > (size_t)(1<<31)) ThrowOutOfMemory();
#else
- if(n == (size_t)-1) ThrowOutOfMemory(); // overflow occured
+ if(n == (size_t)-1) ThrowOutOfMemory(); // overflow occurred
#endif
void *retval = alloc->UnsafeAllocNoThrow((unsigned)n);
// size_t's too big on 64-bit platforms so we check for overflow
if(n > (size_t)(1<<31)) return NULL;
#else
- if(n == (size_t)-1) return NULL; // overflow occured
+ if(n == (size_t)-1) return NULL; // overflow occurred
#endif
return alloc->UnsafeAllocNoThrow((unsigned)n);
// We should only ever get in this situation on a probe from managed code. From within the EE,
// we will never let our probe point get this close. Either way, we'd rip the process if a hard
- // SO occured.
+ // SO occurred.
UINT_PTR stackGuarantee = pThread->GetStackGuarantee();
BOOL fRet;
- // Temporarily initialize the exception occured flag
- m_exceptionOccured = FALSE;
+ // Temporarily initialize the exception occurred flag
+ m_exceptionOccurred = FALSE;
// Code below checks if there's a Thread, and exits immediately if not.
// So the rest of the function rightly assumes there is a Thread
// Mark that we're initialized (and didn't get interupted from an exception)
m_eInitialized = cInit;
- // Initialize the exception occured flag
- m_exceptionOccured = TRUE;
+ // Initialize the exception occurred flag
+ m_exceptionOccurred = TRUE;
// setup flag to tell if we're unwinding due to an exception
m_fEHInProgress = FALSE;
// if we aren't being unwound during EH, then we shouldn't have our EHInProgress bit set. That
// means we caught the exception in the EE and didn't call RestoreGuard or we missed a SO-tolerant
- // transition out of the EE and the exception occured above us.
+ // transition out of the EE and the exception occurred above us.
_ASSERTE(m_fEHInProgress == FALSE);
// we should only ever be popping ourselves if we are not on the EH unwind path
m_eInitialized = cInit;
// setup flag to tell if we're unwinding due to an exception
- m_exceptionOccured = TRUE;
+ m_exceptionOccurred = TRUE;
SetCurrentGuard(this);
}
// Caveats:
//
// 1) If there is less than a context on the stack on the EH path, we will miss the fact that
- // an exception occured
+ // an exception occurred
//
// 2) If the CRT uses near the size of a context before calling the destructor in the normal case,
// we will assume we've got an exception and ASSERT.
// Caveats:
//
// 1) If there is less than a context on the stack on the EH path, we will miss the fact that
- // an exception occured
+ // an exception occurred
//
// 2) If the CRT uses near the size of a context before calling the destructor in the normal case,
// we will assume we've got an exception and ASSERT.
}
-// Return whether or not a timeout occured. TRUE=>we waited successfully
+// Return whether or not a timeout occurred. TRUE=>we waited successfully
DWORD Thread::Wait(HANDLE *objs, int cntObjs, INT32 timeOut, PendingSync *syncInfo)
{
WRAPPER_NO_CONTRACT;
return dwResult;
}
-// Return whether or not a timeout occured. TRUE=>we waited successfully
+// Return whether or not a timeout occurred. TRUE=>we waited successfully
DWORD Thread::Wait(CLREvent *pEvent, INT32 timeOut, PendingSync *syncInfo)
{
WRAPPER_NO_CONTRACT;
...); // Error arguments.
//=====================================================================
-// Displays the messaage box or logs the message, corresponding to the last COM+ error occured
+// Displays the messaage box or logs the message, corresponding to the last COM+ error occurred
void VMDumpCOMErrors(HRESULT hrErr);
HRESULT LoadMscorsn();
}
catch (ApplicationException) //This is the expected behavior.
{
- Console.WriteLine("correct exception occured.");
+ Console.WriteLine("correct exception occurred.");
}
catch (Exception e)
{
projects / platform / upstream / coreclr.git / commitdiff