1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
package haxe;
import flash.errors.Error;
@:coreApi
class Exception extends NativeException {
public var message(get,never):String;
public var stack(get,never):CallStack;
public var previous(get,never):Null<Exception>;
public var native(get,never):Any;
@:noCompletion var __exceptionStack:Null<CallStack>;
@:noCompletion var __nativeStack:String;
@:noCompletion @:ifFeature("haxe.Exception.get_stack") var __skipStack:Int;
@:noCompletion var __nativeException:Error;
@:noCompletion var __previousException:Null<Exception>;
static function caught(value:Any):Exception {
if(Std.is(value, Exception)) {
return value;
} else if(Std.isOfType(value, Error)) {
return new Exception((value:Error).message, null, value);
} else {
return new ValueException(value, null, value);
}
}
static function thrown(value:Any):Any {
if(Std.isOfType(value, Exception)) {
return (value:Exception).native;
} else if(Std.isOfType(value, Error)) {
return value;
} else {
var e = new ValueException(value);
e.__shiftStack();
return e;
}
}
public function new(message:String, ?previous:Exception, ?native:Any) {
super(message);
__previousException = previous;
if(native != null && Std.isOfType(native, Error)) {
__nativeException = native;
__nativeStack = NativeStackTrace.normalize((native:Error).getStackTrace());
} else {
__nativeException = cast this;
__nativeStack = NativeStackTrace.callStack();
}
}
function unwrap():Any {
return __nativeException;
}
public function toString():String {
return message;
}
public function details():String {
return inline CallStack.exceptionToString(this);
}
@:noCompletion
@:ifFeature("haxe.Exception.get_stack")
inline function __shiftStack():Void {
__skipStack++;
}
function get_message():String {
return (cast this:Error).message;
}
function get_previous():Null<Exception> {
return __previousException;
}
final function get_native():Any {
return __nativeException;
}
function get_stack():CallStack {
return switch __exceptionStack {
case null:
__exceptionStack = NativeStackTrace.toHaxe(__nativeStack, __skipStack);
case s: s;
}
}
}
@:dox(hide)
@:native('flash.errors.Error')
extern class NativeException {
@:noCompletion @:flash.property private var errorID(get,never):Int;
// @:noCompletion private var message:Dynamic;
@:noCompletion private var name:Dynamic;
@:noCompletion private function new(?message:Dynamic, id:Dynamic = 0):Void;
@:noCompletion private function getStackTrace():String;
@:noCompletion private function get_errorID():Int;
}
|
