Retro68/gcc/libphobos/libdruntime/core/exception.d
Wolfgang Thaller 6fbf4226da gcc-9.1
2019-06-20 20:10:10 +02:00

722 lines
20 KiB
D

/**
* The exception module defines all system-level exceptions and provides a
* mechanism to alter system-level error handling.
*
* Copyright: Copyright Sean Kelly 2005 - 2013.
* License: Distributed under the
* $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0).
* (See accompanying file LICENSE)
* Authors: Sean Kelly and Jonathan M Davis
* Source: $(DRUNTIMESRC core/_exception.d)
*/
/* NOTE: This file has been patched from the original DMD distribution to
* work with the GDC compiler.
*/
module core.exception;
/**
* Thrown on a range error.
*/
class RangeError : Error
{
@safe pure nothrow this( string file = __FILE__, size_t line = __LINE__, Throwable next = null )
{
super( "Range violation", file, line, next );
}
}
unittest
{
{
auto re = new RangeError();
assert(re.file == __FILE__);
assert(re.line == __LINE__ - 2);
assert(re.next is null);
assert(re.msg == "Range violation");
}
{
auto re = new RangeError("hello", 42, new Exception("It's an Exception!"));
assert(re.file == "hello");
assert(re.line == 42);
assert(re.next !is null);
assert(re.msg == "Range violation");
}
}
/**
* Thrown on an assert error.
*/
class AssertError : Error
{
@safe pure nothrow this( string file, size_t line )
{
this(cast(Throwable)null, file, line);
}
@safe pure nothrow this( Throwable next, string file = __FILE__, size_t line = __LINE__ )
{
this( "Assertion failure", file, line, next);
}
@safe pure nothrow this( string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null )
{
super( msg, file, line, next );
}
}
unittest
{
{
auto ae = new AssertError("hello", 42);
assert(ae.file == "hello");
assert(ae.line == 42);
assert(ae.next is null);
assert(ae.msg == "Assertion failure");
}
{
auto ae = new AssertError(new Exception("It's an Exception!"));
assert(ae.file == __FILE__);
assert(ae.line == __LINE__ - 2);
assert(ae.next !is null);
assert(ae.msg == "Assertion failure");
}
{
auto ae = new AssertError(new Exception("It's an Exception!"), "hello", 42);
assert(ae.file == "hello");
assert(ae.line == 42);
assert(ae.next !is null);
assert(ae.msg == "Assertion failure");
}
{
auto ae = new AssertError("msg");
assert(ae.file == __FILE__);
assert(ae.line == __LINE__ - 2);
assert(ae.next is null);
assert(ae.msg == "msg");
}
{
auto ae = new AssertError("msg", "hello", 42);
assert(ae.file == "hello");
assert(ae.line == 42);
assert(ae.next is null);
assert(ae.msg == "msg");
}
{
auto ae = new AssertError("msg", "hello", 42, new Exception("It's an Exception!"));
assert(ae.file == "hello");
assert(ae.line == 42);
assert(ae.next !is null);
assert(ae.msg == "msg");
}
}
/**
* Thrown on finalize error.
*/
class FinalizeError : Error
{
TypeInfo info;
this( TypeInfo ci, Throwable next, string file = __FILE__, size_t line = __LINE__ ) @safe pure nothrow @nogc
{
this(ci, file, line, next);
}
this( TypeInfo ci, string file = __FILE__, size_t line = __LINE__, Throwable next = null ) @safe pure nothrow @nogc
{
super( "Finalization error", file, line, next );
super.info = SuppressTraceInfo.instance;
info = ci;
}
override string toString() const @safe
{
return "An exception was thrown while finalizing an instance of " ~ info.toString();
}
}
unittest
{
ClassInfo info = new ClassInfo;
info.name = "testInfo";
{
auto fe = new FinalizeError(info);
assert(fe.file == __FILE__);
assert(fe.line == __LINE__ - 2);
assert(fe.next is null);
assert(fe.msg == "Finalization error");
assert(fe.info == info);
}
{
auto fe = new FinalizeError(info, new Exception("It's an Exception!"));
assert(fe.file == __FILE__);
assert(fe.line == __LINE__ - 2);
assert(fe.next !is null);
assert(fe.msg == "Finalization error");
assert(fe.info == info);
}
{
auto fe = new FinalizeError(info, "hello", 42);
assert(fe.file == "hello");
assert(fe.line == 42);
assert(fe.next is null);
assert(fe.msg == "Finalization error");
assert(fe.info == info);
}
{
auto fe = new FinalizeError(info, "hello", 42, new Exception("It's an Exception!"));
assert(fe.file == "hello");
assert(fe.line == 42);
assert(fe.next !is null);
assert(fe.msg == "Finalization error");
assert(fe.info == info);
}
}
/**
* Thrown on hidden function error.
* $(RED Deprecated.
* This feature is not longer part of the language.)
*/
deprecated class HiddenFuncError : Error
{
@safe pure nothrow this( ClassInfo ci )
{
super( "Hidden method called for " ~ ci.name );
}
}
deprecated unittest
{
ClassInfo info = new ClassInfo;
info.name = "testInfo";
{
auto hfe = new HiddenFuncError(info);
assert(hfe.next is null);
assert(hfe.msg == "Hidden method called for testInfo");
}
}
/**
* Thrown on an out of memory error.
*/
class OutOfMemoryError : Error
{
this(string file = __FILE__, size_t line = __LINE__, Throwable next = null ) @safe pure nothrow @nogc
{
this(true, file, line, next);
}
this(bool trace, string file = __FILE__, size_t line = __LINE__, Throwable next = null ) @safe pure nothrow @nogc
{
super("Memory allocation failed", file, line, next);
if (!trace)
this.info = SuppressTraceInfo.instance;
}
override string toString() const @trusted
{
return msg.length ? (cast()this).superToString() : "Memory allocation failed";
}
// kludge to call non-const super.toString
private string superToString() @trusted
{
return super.toString();
}
}
unittest
{
{
auto oome = new OutOfMemoryError();
assert(oome.file == __FILE__);
assert(oome.line == __LINE__ - 2);
assert(oome.next is null);
assert(oome.msg == "Memory allocation failed");
assert(oome.toString.length);
}
{
auto oome = new OutOfMemoryError("hello", 42, new Exception("It's an Exception!"));
assert(oome.file == "hello");
assert(oome.line == 42);
assert(oome.next !is null);
assert(oome.msg == "Memory allocation failed");
}
}
/**
* Thrown on an invalid memory operation.
*
* An invalid memory operation error occurs in circumstances when the garbage
* collector has detected an operation it cannot reliably handle. The default
* D GC is not re-entrant, so this can happen due to allocations done from
* within finalizers called during a garbage collection cycle.
*/
class InvalidMemoryOperationError : Error
{
this(string file = __FILE__, size_t line = __LINE__, Throwable next = null ) @safe pure nothrow @nogc
{
super( "Invalid memory operation", file, line, next );
this.info = SuppressTraceInfo.instance;
}
override string toString() const @trusted
{
return msg.length ? (cast()this).superToString() : "Invalid memory operation";
}
// kludge to call non-const super.toString
private string superToString() @trusted
{
return super.toString();
}
}
unittest
{
{
auto oome = new InvalidMemoryOperationError();
assert(oome.file == __FILE__);
assert(oome.line == __LINE__ - 2);
assert(oome.next is null);
assert(oome.msg == "Invalid memory operation");
assert(oome.toString.length);
}
{
auto oome = new InvalidMemoryOperationError("hello", 42, new Exception("It's an Exception!"));
assert(oome.file == "hello");
assert(oome.line == 42);
assert(oome.next !is null);
assert(oome.msg == "Invalid memory operation");
}
}
/**
* Thrown on a switch error.
*/
class SwitchError : Error
{
@safe pure nothrow this( string file = __FILE__, size_t line = __LINE__, Throwable next = null )
{
super( "No appropriate switch clause found", file, line, next );
}
}
unittest
{
{
auto se = new SwitchError();
assert(se.file == __FILE__);
assert(se.line == __LINE__ - 2);
assert(se.next is null);
assert(se.msg == "No appropriate switch clause found");
}
{
auto se = new SwitchError("hello", 42, new Exception("It's an Exception!"));
assert(se.file == "hello");
assert(se.line == 42);
assert(se.next !is null);
assert(se.msg == "No appropriate switch clause found");
}
}
/**
* Thrown on a unicode conversion error.
*/
class UnicodeException : Exception
{
size_t idx;
this( string msg, size_t idx, string file = __FILE__, size_t line = __LINE__, Throwable next = null ) @safe pure nothrow
{
super( msg, file, line, next );
this.idx = idx;
}
}
unittest
{
{
auto ue = new UnicodeException("msg", 2);
assert(ue.file == __FILE__);
assert(ue.line == __LINE__ - 2);
assert(ue.next is null);
assert(ue.msg == "msg");
assert(ue.idx == 2);
}
{
auto ue = new UnicodeException("msg", 2, "hello", 42, new Exception("It's an Exception!"));
assert(ue.file == "hello");
assert(ue.line == 42);
assert(ue.next !is null);
assert(ue.msg == "msg");
assert(ue.idx == 2);
}
}
///////////////////////////////////////////////////////////////////////////////
// Overrides
///////////////////////////////////////////////////////////////////////////////
// NOTE: One assert handler is used for all threads. Thread-local
// behavior should occur within the handler itself. This delegate
// is __gshared for now based on the assumption that it will only
// set by the main thread during program initialization.
private __gshared AssertHandler _assertHandler = null;
/**
Gets/sets assert hander. null means the default handler is used.
*/
alias AssertHandler = void function(string file, size_t line, string msg) nothrow;
/// ditto
@property AssertHandler assertHandler() @trusted nothrow @nogc
{
return _assertHandler;
}
/// ditto
@property void assertHandler(AssertHandler handler) @trusted nothrow @nogc
{
_assertHandler = handler;
}
/**
* Overrides the default assert hander with a user-supplied version.
* $(RED Deprecated.
* Please use $(LREF assertHandler) instead.)
*
* Params:
* h = The new assert handler. Set to null to use the default handler.
*/
deprecated void setAssertHandler( AssertHandler h ) @trusted nothrow @nogc
{
assertHandler = h;
}
///////////////////////////////////////////////////////////////////////////////
// Overridable Callbacks
///////////////////////////////////////////////////////////////////////////////
/**
* A callback for assert errors in D. The user-supplied assert handler will
* be called if one has been supplied, otherwise an $(LREF AssertError) will be
* thrown.
*
* Params:
* file = The name of the file that signaled this error.
* line = The line number on which this error occurred.
*/
extern (C) void onAssertError( string file = __FILE__, size_t line = __LINE__ ) nothrow
{
if ( _assertHandler is null )
throw new AssertError( file, line );
_assertHandler( file, line, null);
}
/**
* A callback for assert errors in D. The user-supplied assert handler will
* be called if one has been supplied, otherwise an $(LREF AssertError) will be
* thrown.
*
* Params:
* file = The name of the file that signaled this error.
* line = The line number on which this error occurred.
* msg = An error message supplied by the user.
*/
extern (C) void onAssertErrorMsg( string file, size_t line, string msg ) nothrow
{
if ( _assertHandler is null )
throw new AssertError( msg, file, line );
_assertHandler( file, line, msg );
}
/**
* A callback for unittest errors in D. The user-supplied unittest handler
* will be called if one has been supplied, otherwise the error will be
* written to stderr.
*
* Params:
* file = The name of the file that signaled this error.
* line = The line number on which this error occurred.
* msg = An error message supplied by the user.
*/
extern (C) void onUnittestErrorMsg( string file, size_t line, string msg ) nothrow
{
onAssertErrorMsg( file, line, msg );
}
///////////////////////////////////////////////////////////////////////////////
// Internal Error Callbacks
///////////////////////////////////////////////////////////////////////////////
/**
* A callback for array bounds errors in D. A $(LREF RangeError) will be thrown.
*
* Params:
* file = The name of the file that signaled this error.
* line = The line number on which this error occurred.
*
* Throws:
* $(LREF RangeError).
*/
extern (C) void onRangeError( string file = __FILE__, size_t line = __LINE__ ) @safe pure nothrow
{
throw new RangeError( file, line, null );
}
/**
* A callback for finalize errors in D. A $(LREF FinalizeError) will be thrown.
*
* Params:
* info = The TypeInfo instance for the object that failed finalization.
* e = The exception thrown during finalization.
* file = The name of the file that signaled this error.
* line = The line number on which this error occurred.
*
* Throws:
* $(LREF FinalizeError).
*/
extern (C) void onFinalizeError( TypeInfo info, Throwable e, string file = __FILE__, size_t line = __LINE__ ) @trusted nothrow
{
// This error is thrown during a garbage collection, so no allocation must occur while
// generating this object. So we use a preallocated instance
throw staticError!FinalizeError(info, e, file, line);
}
/**
* A callback for hidden function errors in D. A $(LREF HiddenFuncError) will be
* thrown.
* $(RED Deprecated.
* This feature is not longer part of the language.)
*
* Throws:
* $(LREF HiddenFuncError).
*/
deprecated extern (C) void onHiddenFuncError( Object o ) @safe pure nothrow
{
throw new HiddenFuncError( typeid(o) );
}
/**
* A callback for out of memory errors in D. An $(LREF OutOfMemoryError) will be
* thrown.
*
* Throws:
* $(LREF OutOfMemoryError).
*/
extern (C) void onOutOfMemoryError(void* pretend_sideffect = null) @trusted pure nothrow @nogc /* dmd @@@BUG11461@@@ */
{
// NOTE: Since an out of memory condition exists, no allocation must occur
// while generating this object.
throw staticError!OutOfMemoryError();
}
extern (C) void onOutOfMemoryErrorNoGC() @trusted nothrow @nogc
{
// suppress stacktrace until they are @nogc
throw staticError!OutOfMemoryError(false);
}
/**
* A callback for invalid memory operations in D. An
* $(LREF InvalidMemoryOperationError) will be thrown.
*
* Throws:
* $(LREF InvalidMemoryOperationError).
*/
extern (C) void onInvalidMemoryOperationError(void* pretend_sideffect = null) @trusted pure nothrow @nogc /* dmd @@@BUG11461@@@ */
{
// The same restriction applies as for onOutOfMemoryError. The GC is in an
// undefined state, thus no allocation must occur while generating this object.
throw staticError!InvalidMemoryOperationError();
}
/**
* A callback for switch errors in D. A $(LREF SwitchError) will be thrown.
*
* Params:
* file = The name of the file that signaled this error.
* line = The line number on which this error occurred.
*
* Throws:
* $(LREF SwitchError).
*/
extern (C) void onSwitchError( string file = __FILE__, size_t line = __LINE__ ) @safe pure nothrow
{
throw new SwitchError( file, line, null );
}
/**
* A callback for unicode errors in D. A $(LREF UnicodeException) will be thrown.
*
* Params:
* msg = Information about the error.
* idx = String index where this error was detected.
* file = The name of the file that signaled this error.
* line = The line number on which this error occurred.
*
* Throws:
* $(LREF UnicodeException).
*/
extern (C) void onUnicodeError( string msg, size_t idx, string file = __FILE__, size_t line = __LINE__ ) @safe pure
{
throw new UnicodeException( msg, idx, file, line );
}
/***********************************
* These functions must be defined for any D program linked
* against this library.
*/
/+
extern (C) void onAssertError(string file, size_t line);
extern (C) void onAssertErrorMsg(string file, size_t line, string msg);
extern (C) void onUnittestErrorMsg(string file, size_t line, string msg);
extern (C) void onRangeError(string file, size_t line);
extern (C) void onHiddenFuncError(Object o);
extern (C) void onSwitchError(string file, size_t line);
+/
/***********************************
* Function calls to these are generated by the compiler and inserted into
* the object code.
*/
extern (C)
{
// Use ModuleInfo to get file name for "m" versions
/* One of these three is called upon an assert() fail.
*/
void _d_assertp(immutable(char)* file, uint line)
{
import core.stdc.string : strlen;
onAssertError(file[0 .. strlen(file)], line);
}
void _d_assert_msg(string msg, string file, uint line)
{
onAssertErrorMsg(file, line, msg);
}
void _d_assert(string file, uint line)
{
onAssertError(file, line);
}
/* One of these three is called upon an assert() fail inside of a unittest block
*/
void _d_unittestp(immutable(char)* file, uint line)
{
import core.stdc.string : strlen;
_d_unittest(file[0 .. strlen(file)], line);
}
void _d_unittest_msg(string msg, string file, uint line)
{
onUnittestErrorMsg(file, line, msg);
}
void _d_unittest(string file, uint line)
{
_d_unittest_msg("unittest failure", file, line);
}
/* Called when an array index is out of bounds
*/
void _d_arrayboundsp(immutable(char*) file, uint line)
{
import core.stdc.string : strlen;
onRangeError(file[0 .. strlen(file)], line);
}
void _d_arraybounds(string file, uint line)
{
onRangeError(file, line);
}
/* Called when a switch statement has no DefaultStatement, yet none of the cases match
*/
void _d_switch_errorm(immutable(ModuleInfo)* m, uint line)
{
onSwitchError(m.name, line);
}
void _d_switch_error(string file, uint line)
{
onSwitchError(file, line);
}
}
// TLS storage shared for all errors, chaining might create circular reference
private void[128] _store;
// only Errors for now as those are rarely chained
private T staticError(T, Args...)(auto ref Args args)
if (is(T : Error))
{
// pure hack, what we actually need is @noreturn and allow to call that in pure functions
static T get()
{
static assert(__traits(classInstanceSize, T) <= _store.length,
T.stringof ~ " is too large for staticError()");
_store[0 .. __traits(classInstanceSize, T)] = typeid(T).initializer[];
return cast(T) _store.ptr;
}
auto res = (cast(T function() @trusted pure nothrow @nogc) &get)();
res.__ctor(args);
return res;
}
// Suppress traceinfo generation when the GC cannot be used. Workaround for
// Bugzilla 14993. We should make stack traces @nogc instead.
package class SuppressTraceInfo : Throwable.TraceInfo
{
override int opApply(scope int delegate(ref const(char[]))) const { return 0; }
override int opApply(scope int delegate(ref size_t, ref const(char[]))) const { return 0; }
override string toString() const { return null; }
static SuppressTraceInfo instance() @trusted @nogc pure nothrow
{
static immutable SuppressTraceInfo it = new SuppressTraceInfo;
return cast(SuppressTraceInfo)it;
}
}