| |
| Posted by rikki cattermole in reply to Walter Bright | PermalinkReply |
|
rikki cattermole
Posted in reply to Walter Bright
|
On 10/09/2021 11:57 AM, Walter Bright wrote:
> Momentum seems to be building behind the idea that exception handling is the wrong path.
What I'm interested in atm is weather open-ended exceptions with stack unwinding is the wrong way to go.
Super simple question but I am starting to be of the belief that this is wrong. We need stronger compiler guarantees with compiling backed checks.
Something like this:
Basically every functions gets attributed with a __throws attribute, inferred based upon what it calls, what it catches and what it throws.
Structs only that get moved not copied, with a guarantee that it'll be caught before the thread ends and the stack will unwind due to using regular return's.
What drew me to this is my colorimetry library. I do need compiler guaranteed caught exceptional handling, but I don't want the user to wiggle out of it by using return values. The problem is exceptions need classes and the runtime handling. But I want it to work with -betterC (mixing compiler versions with shared libraries, yeah that won't end well).
With this, I *might* be able to work my way up to a full GUI toolkit. This is the big missing piece right now.
```d
struct NullPointerException {
string message;
string moduleName;
int lineNumber;
this(string message, string moduleName = __MODULE__, int lineNumber == __LINE__) {
this.message = message;
this.moduleName = moduleName;
this.lineNumber = lineNumber;
}
}
void doSomething() /* __throws() */ {
State* state = newState;
try {
state.someComplexProcess();
} catch (scope ref NullPointerException npe) {
// ... stuff here
}
// scope void[NullPointerException.sizeof + size_t.sizeof] __exceptionStorage;
// state.someComplexProcess(__exceptionStorage[]);
// if ((cast(size_t*)&__exceptionStorage[0]) == 1 && scope ref NullPointerException npe = *(cast(NullPointerException*)&__exceptionStorage[size_t.sizeof])) {
// // ... stuff here
// }
}
void someComplexProcess(State* state, /*scope void[] __exceptionStorage */) /* __throws(NullPointerException) */ {
Process process;
process.add(libFunc(state, /* __exceptionStorage */));
}
int libFunc(State* state, /*scope void[] __exceptionStorage */) /* __throws(NullPointerException) */ {
if (state is null) {
throw NullPointerException("State cannot be null");
// if (__exceptionStorage.length < NullPointerException.sizeof + size_t.sizeof)
// assert(0);
// (cast(size_t*)&__exceptionStorage[0]) = 1;
// *(cast(NullPointerException*)&__exceptionStorage[size_t.sizeof]) = NullPointerException("State cannot be null");
// return ReturnType.init;
}
return 0;
}
```
|