github
/
duktape
mirror of https://github.com/svaarala/duktape.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7564 Commits
65 Branches
60 Tags
84 MiB
Tree: 04411af116
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '04411af116'
${ noResults }
duktape/src-input/duk_error.h

474 lines
20 KiB
Raw Normal View History

error header
12 years ago
/*
* Error handling macros, assertion macro, error codes.
simplify panic handling, use DUK_OPT_PANIC_HANDLER instead of DUK_PANIC_HANDLER, add a message to fatal error handler
11 years ago
*
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn't and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it's mostly pointless) and change the "ctx" argument to "udata" (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it's unsafe to actually use the "ctx" to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
* There are three types of 'errors':
simplify panic handling, use DUK_OPT_PANIC_HANDLER instead of DUK_PANIC_HANDLER, add a message to fatal error handler
11 years ago
*
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn't and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it's mostly pointless) and change the "ctx" argument to "udata" (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it's unsafe to actually use the "ctx" to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
* 1. Ordinary errors relative to a thread, cause a longjmp, catchable.
* 2. Fatal errors relative to a heap, cause fatal handler to be called.
* 3. Fatal errors without context, cause the default (not heap specific)
* fatal handler to be called.
simplify panic handling, use DUK_OPT_PANIC_HANDLER instead of DUK_PANIC_HANDLER, add a message to fatal error handler
11 years ago
*
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn't and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it's mostly pointless) and change the "ctx" argument to "udata" (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it's unsafe to actually use the "ctx" to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
* Fatal errors without context are used by debug code such as assertions.
* By providing a fatal error handler for a Duktape heap, user code can
* avoid fatal errors without context in non-debug builds.
error header
12 years ago
*/
fix include guard names, don't use leading underscores as they are reserved
12 years ago
#ifndef DUK_ERROR_H_INCLUDED
#define DUK_ERROR_H_INCLUDED
error header
12 years ago
/*
remove pretty pointless DUK_ERR_OK and DUK_ERR_FAIL defines, which were also easy to confuse with other DUK_ERR_xxx defines
11 years ago
* Error codes: defined in duktape.h
error header
12 years ago
*
* Error codes are used as a shorthand to throw exceptions from inside
* the implementation. The appropriate Ecmascript object is constructed
simplify panic handling, use DUK_OPT_PANIC_HANDLER instead of DUK_PANIC_HANDLER, add a message to fatal error handler
11 years ago
* based on the code. Ecmascript code throws objects directly. The error
* codes are defined in the public API header because they are also used
* by calling code.
error header
12 years ago
*/
/*
simplify panic handling, use DUK_OPT_PANIC_HANDLER instead of DUK_PANIC_HANDLER, add a message to fatal error handler
11 years ago
* Normal error
*
error header
12 years ago
* Normal error is thrown with a longjmp() through the current setjmp()
* catchpoint record in the duk_heap. The 'curr_thread' of the duk_heap
* identifies the throwing thread.
Code policy issue fix trivia
10 years ago
*
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep 'thr' in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
* Error formatting is usually unnecessary. The error macros provide a
* zero argument version (no formatting) and separate macros for small
* argument counts. Variadic macros are not used to avoid portability
* issues and avoid the need for stash-based workarounds when they're not
* available. Vararg calls are avoided for non-formatted error calls
* because vararg call sites are larger than normal, and there are a lot
* of call sites with no formatting.
*
* Note that special formatting provided by debug macros is NOT available.
error header
12 years ago
*
* The _RAW variants allow the caller to specify file and line. This makes
* it easier to write checked calls which want to use the call site of the
* checked function, not the error macro call inside the checked function.
*/
Relocate error throwing helpers to duk_error.h
9 years ago
#if defined(DUK_USE_VERBOSE_ERRORS)
error header
12 years ago
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep 'thr' in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
/* Because there are quite many call sites, pack error code (require at most
* 8-bit) into a single argument.
*/
#define DUK_ERROR(thr,err,msg) do { \
duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
duk_err_handle_error((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
} while (0)
#define DUK_ERROR_RAW(thr,file,line,err,msg) do { \
duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
duk_err_handle_error((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
} while (0)
error header
12 years ago
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
#define DUK_ERROR_FMT1(thr,err,fmt,arg1) do { \
duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
} while (0)
#define DUK_ERROR_RAW_FMT1(thr,file,line,err,fmt,arg1) do { \
duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
} while (0)
error header
12 years ago
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
#define DUK_ERROR_FMT2(thr,err,fmt,arg1,arg2) do { \
duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
} while (0)
#define DUK_ERROR_RAW_FMT2(thr,file,line,err,fmt,arg1,arg2) do { \
duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
} while (0)
error header
12 years ago
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
#define DUK_ERROR_FMT3(thr,err,fmt,arg1,arg2,arg3) do { \
duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \
} while (0)
#define DUK_ERROR_RAW_FMT3(thr,file,line,err,fmt,arg1,arg2,arg3) do { \
duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \
} while (0)
error header
12 years ago
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
#define DUK_ERROR_FMT4(thr,err,fmt,arg1,arg2,arg3,arg4) do { \
duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3), (arg4)); \
} while (0)
#define DUK_ERROR_RAW_FMT4(thr,file,line,err,fmt,arg1,arg2,arg3,arg4) do { \
duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3), (arg4)); \
} while (0)
error header
12 years ago
#else /* DUK_USE_VERBOSE_ERRORS */
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
#define DUK_ERROR(thr,err,msg) duk_err_handle_error((thr), (err))
#define DUK_ERROR_RAW(thr,file,line,err,msg) duk_err_handle_error((thr), (err))
error header
12 years ago
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
#define DUK_ERROR_FMT1(thr,err,fmt,arg1) DUK_ERROR((thr),(err),(fmt))
#define DUK_ERROR_RAW_FMT1(thr,file,line,err,fmt,arg1) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
error header
12 years ago
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
#define DUK_ERROR_FMT2(thr,err,fmt,arg1,arg2) DUK_ERROR((thr),(err),(fmt))
#define DUK_ERROR_RAW_FMT2(thr,file,line,err,fmt,arg1,arg2) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
error header
12 years ago
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
#define DUK_ERROR_FMT3(thr,err,fmt,arg1,arg2,arg3) DUK_ERROR((thr),(err),(fmt))
#define DUK_ERROR_RAW_FMT3(thr,file,line,err,fmt,arg1,arg2,arg3) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
error header
12 years ago
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
#define DUK_ERROR_FMT4(thr,err,fmt,arg1,arg2,arg3,arg4) DUK_ERROR((thr),(err),(fmt))
#define DUK_ERROR_RAW_FMT4(thr,file,line,err,fmt,arg1,arg2,arg3,arg4) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
error header
12 years ago
#endif /* DUK_USE_VERBOSE_ERRORS */
/*
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn&#39;t and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it&#39;s mostly pointless) and change the &#34;ctx&#34; argument to &#34;udata&#34; (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it&#39;s unsafe to actually use the &#34;ctx&#34; to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
* Fatal error without context
simplify panic handling, use DUK_OPT_PANIC_HANDLER instead of DUK_PANIC_HANDLER, add a message to fatal error handler
11 years ago
*
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn&#39;t and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it&#39;s mostly pointless) and change the &#34;ctx&#34; argument to &#34;udata&#34; (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it&#39;s unsafe to actually use the &#34;ctx&#34; to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
* The macro is an expression to make it compatible with DUK_ASSERT_EXPR().
simplify panic handling, use DUK_OPT_PANIC_HANDLER instead of DUK_PANIC_HANDLER, add a message to fatal error handler
11 years ago
*/
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn&#39;t and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it&#39;s mostly pointless) and change the &#34;ctx&#34; argument to &#34;udata&#34; (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it&#39;s unsafe to actually use the &#34;ctx&#34; to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
#define DUK_FATAL_WITHOUT_CONTEXT(msg) \
duk_default_fatal_handler(NULL, (msg))
simplify panic handling, use DUK_OPT_PANIC_HANDLER instead of DUK_PANIC_HANDLER, add a message to fatal error handler
11 years ago
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
/*
* Error throwing helpers
*
* The goal is to provide verbose and configurable error messages. Call
* sites should be clean in source code and compile to a small footprint.
* Small footprint is also useful for performance because small cold paths
* reduce code cache pressure. Adding macros here only makes sense if there
* are enough call sites to get concrete benefits.
Verbose errors also for return shorthand
8 years ago
*
* DUK_ERROR_xxx() macros are generic and can be used anywhere.
*
* DUK_DCERROR_xxx() macros can only be used in Duktape/C functions where
* the "return DUK_RET_xxx;" shorthand is available for low memory targets.
* The DUK_DCERROR_xxx() macros always either throw or perform a
* 'return DUK_RET_xxx' from the calling function.
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
*/
#if defined(DUK_USE_VERBOSE_ERRORS)
/* Verbose errors with key/value summaries (non-paranoid) or without key/value
* summaries (paranoid, for some security sensitive environments), the paranoid
* vs. non-paranoid distinction affects only a few specific errors.
*/
#if defined(DUK_USE_PARANOID_ERRORS)
#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,idx,expectname,lowmemstr) do { \
duk_err_require_type_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (idx), (expectname)); \
} while (0)
#else /* DUK_USE_PARANOID_ERRORS */
#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,idx,expectname,lowmemstr) do { \
duk_err_require_type_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (idx), (expectname)); \
} while (0)
#endif /* DUK_USE_PARANOID_ERRORS */
#define DUK_ERROR_INTERNAL(thr) do { \
duk_err_error_internal((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
} while (0)
#define DUK_ERROR_ALLOC_FAILED(thr) do { \
duk_err_error_alloc_failed((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
} while (0)
#define DUK_ERROR_UNSUPPORTED(thr) do { \
DUK_ERROR((thr), DUK_ERR_ERROR, DUK_STR_UNSUPPORTED); \
} while (0)
#define DUK_ERROR_ERROR(thr,msg) do { \
duk_err_error((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
} while (0)
#define DUK_ERROR_RANGE_INDEX(thr,idx) do { \
duk_err_range_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (idx)); \
} while (0)
#define DUK_ERROR_RANGE_PUSH_BEYOND(thr) do { \
duk_err_range_push_beyond((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
} while (0)
Verbose errors also for return shorthand
8 years ago
#define DUK_ERROR_RANGE_INVALID_ARGS(thr) do { \
DUK_ERROR_RANGE((thr), DUK_STR_INVALID_ARGS); \
} while (0)
#define DUK_DCERROR_RANGE_INVALID_ARGS(thr) do { \
DUK_ERROR_RANGE_INVALID_ARGS((thr)); \
return 0; \
} while (0)
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
#define DUK_ERROR_RANGE_INVALID_COUNT(thr) do { \
DUK_ERROR_RANGE((thr), DUK_STR_INVALID_COUNT); \
} while (0)
Verbose errors also for return shorthand
8 years ago
#define DUK_ERROR_RANGE_INVALID_LENGTH(thr) do { \
DUK_ERROR_RANGE((thr), DUK_STR_INVALID_LENGTH); \
} while (0)
#define DUK_DCERROR_RANGE_INVALID_LENGTH(thr) do { \
DUK_ERROR_RANGE_INVALID_LENGTH((thr)); \
return 0; \
} while (0)
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
#define DUK_ERROR_RANGE(thr,msg) do { \
duk_err_range((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
} while (0)
#define DUK_ERROR_EVAL(thr,msg) do { \
DUK_ERROR((thr), DUK_ERR_EVAL_ERROR, (msg)); \
} while (0)
#define DUK_ERROR_REFERENCE(thr,msg) do { \
DUK_ERROR((thr), DUK_ERR_REFERENCE_ERROR, (msg)); \
} while (0)
#define DUK_ERROR_SYNTAX(thr,msg) do { \
DUK_ERROR((thr), DUK_ERR_SYNTAX_ERROR, (msg)); \
} while (0)
#define DUK_ERROR_TYPE_INVALID_ARGS(thr) do { \
duk_err_type_invalid_args((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
} while (0)
Verbose errors also for return shorthand
8 years ago
#define DUK_DCERROR_TYPE_INVALID_ARGS(thr) do { \
DUK_ERROR_TYPE_INVALID_ARGS((thr)); \
return 0; \
} while (0)
Allow bound function as Thread initial function
8 years ago
#define DUK_ERROR_TYPE_INVALID_STATE(thr) do { \
duk_err_type_invalid_state((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
} while (0)
#define DUK_DCERROR_TYPE_INVALID_STATE(thr) do { \
DUK_ERROR_TYPE_INVALID_STATE((thr)); \
return 0; \
} while (0)
Use &#39;ownKeys&#39; trap for for-in (ES7), enum check * Remove &#39;enumerate&#39; trap. * Use &#39;ownKeys&#39; trap for &#34;for-in&#34; too, as specified in ES7. * Add enumerability check for &#39;ownKeys&#39; result when used in for-in or Object.keys(). Because there&#39;s no support for &#39;getOwnPropertyDescriptor&#39; trap yet, the check will always operate directly on the target object.
8 years ago
#define DUK_ERROR_TYPE_INVALID_TRAP_RESULT(thr) do { \
duk_err_type_invalid_trap_result((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
} while (0)
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
#define DUK_ERROR_TYPE(thr,msg) do { \
DUK_ERROR((thr), DUK_ERR_TYPE_ERROR, (msg)); \
} while (0)
#define DUK_ERROR_URI(thr,msg) do { \
DUK_ERROR((thr), DUK_ERR_URI_ERROR, (msg)); \
} while (0)
#else /* DUK_USE_VERBOSE_ERRORS */
/* Non-verbose errors for low memory targets: no file, line, or message. */
#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,idx,expectname,lowmemstr) do { \
duk_err_type((thr)); \
} while (0)
#define DUK_ERROR_INTERNAL(thr) do { \
duk_err_error((thr)); \
} while (0)
#define DUK_ERROR_ALLOC_FAILED(thr) do { \
duk_err_error((thr)); \
} while (0)
#define DUK_ERROR_UNSUPPORTED(thr) do { \
duk_err_error((thr)); \
} while (0)
#define DUK_ERROR_ERROR(thr,msg) do { \
duk_err_error((thr)); \
} while (0)
#define DUK_ERROR_RANGE_INDEX(thr,idx) do { \
duk_err_range((thr)); \
} while (0)
#define DUK_ERROR_RANGE_PUSH_BEYOND(thr) do { \
duk_err_range((thr)); \
} while (0)
Verbose errors also for return shorthand
8 years ago
#define DUK_ERROR_RANGE_INVALID_ARGS(thr) do { \
duk_err_range((thr)); \
} while (0)
#define DUK_DCERROR_RANGE_INVALID_ARGS(thr) do { \
DUK_UNREF((thr)); \
return DUK_RET_RANGE_ERROR; \
} while (0)
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
#define DUK_ERROR_RANGE_INVALID_COUNT(thr) do { \
duk_err_range((thr)); \
} while (0)
Verbose errors also for return shorthand
8 years ago
#define DUK_ERROR_RANGE_INVALID_LENGTH(thr) do { \
duk_err_range((thr)); \
} while (0)
#define DUK_DCERROR_RANGE_INVALID_LENGTH(thr) do { \
DUK_UNREF((thr)); \
return DUK_RET_RANGE_ERROR; \
} while (0)
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
#define DUK_ERROR_RANGE(thr,msg) do { \
duk_err_range((thr)); \
} while (0)
#define DUK_ERROR_EVAL(thr,msg) do { \
duk_err_eval((thr)); \
} while (0)
#define DUK_ERROR_REFERENCE(thr,msg) do { \
duk_err_reference((thr)); \
} while (0)
#define DUK_ERROR_SYNTAX(thr,msg) do { \
duk_err_syntax((thr)); \
} while (0)
#define DUK_ERROR_TYPE_INVALID_ARGS(thr) do { \
duk_err_type((thr)); \
} while (0)
Allow bound function as Thread initial function
8 years ago
#define DUK_DCERROR_TYPE_INVALID_ARGS(thr) do { \
DUK_UNREF((thr)); \
return DUK_RET_TYPE_ERROR; \
} while (0)
#define DUK_ERROR_TYPE_INVALID_STATE(thr) do { \
Use &#39;ownKeys&#39; trap for for-in (ES7), enum check * Remove &#39;enumerate&#39; trap. * Use &#39;ownKeys&#39; trap for &#34;for-in&#34; too, as specified in ES7. * Add enumerability check for &#39;ownKeys&#39; result when used in for-in or Object.keys(). Because there&#39;s no support for &#39;getOwnPropertyDescriptor&#39; trap yet, the check will always operate directly on the target object.
8 years ago
duk_err_type((thr)); \
} while (0)
Allow bound function as Thread initial function
8 years ago
#define DUK_DCERROR_TYPE_INVALID_STATE(thr) do { \
Verbose errors also for return shorthand
8 years ago
DUK_UNREF((thr)); \
return DUK_RET_TYPE_ERROR; \
} while (0)
Allow bound function as Thread initial function
8 years ago
#define DUK_ERROR_TYPE_INVALID_TRAP_RESULT(thr) do { \
duk_err_type((thr)); \
} while (0)
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
#define DUK_ERROR_TYPE(thr,msg) do { \
duk_err_type((thr)); \
} while (0)
#define DUK_ERROR_URI(thr,msg) do { \
duk_err_uri((thr)); \
} while (0)
#endif /* DUK_USE_VERBOSE_ERRORS */
simplify panic handling, use DUK_OPT_PANIC_HANDLER instead of DUK_PANIC_HANDLER, add a message to fatal error handler
11 years ago
/*
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn&#39;t and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it&#39;s mostly pointless) and change the &#34;ctx&#34; argument to &#34;udata&#34; (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it&#39;s unsafe to actually use the &#34;ctx&#34; to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
* Assert macro: failure causes a fatal error.
*
* NOTE: since the assert macro doesn't take a heap/context argument, there's
* no way to look up a heap/context specific fatal error handler which may have
* been given by the application. Instead, assertion failures always use the
* internal default fatal error handler; it can be replaced via duk_config.h
* and then applies to all Duktape heaps.
error header
12 years ago
*/
Relocate error throwing helpers to duk_error.h
9 years ago
#if defined(DUK_USE_ASSERTIONS)
error header
12 years ago
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn&#39;t and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it&#39;s mostly pointless) and change the &#34;ctx&#34; argument to &#34;udata&#34; (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it&#39;s unsafe to actually use the &#34;ctx&#34; to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
/* The message should be a compile time constant without formatting (less risk);
error header
12 years ago
* we don't care about assertion text size because they're not used in production
* builds.
*/
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_ASSERT(x) do { \
error header
12 years ago
if (!(x)) { \
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn&#39;t and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it&#39;s mostly pointless) and change the &#34;ctx&#34; argument to &#34;udata&#34; (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it&#39;s unsafe to actually use the &#34;ctx&#34; to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
DUK_FATAL_WITHOUT_CONTEXT("assertion failed: " #x \
use gmtime_r() only when we believe it is available, otherwise use gmtime(); make __FILE__, __LINE__, and __func__ indirect and disable use of __func__ in VBCC (not available); other trivia
11 years ago
" (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"); \
error header
12 years ago
} \
} while (0)
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn&#39;t and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it&#39;s mostly pointless) and change the &#34;ctx&#34; argument to &#34;udata&#34; (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it&#39;s unsafe to actually use the &#34;ctx&#34; to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
/* Assertion compatible inside a comma expression, evaluates to void. */
Implement Node.js Buffer and TypedArray support
10 years ago
#define DUK_ASSERT_EXPR(x) \
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn&#39;t and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it&#39;s mostly pointless) and change the &#34;ctx&#34; argument to &#34;udata&#34; (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it&#39;s unsafe to actually use the &#34;ctx&#34; to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
((void) ((x) ? 0 : (DUK_FATAL_WITHOUT_CONTEXT("assertion failed: " #x \
Implement Node.js Buffer and TypedArray support
10 years ago
" (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"), 0)))
error header
12 years ago
#else /* DUK_USE_ASSERTIONS */
Implement Node.js Buffer and TypedArray support
10 years ago
#define DUK_ASSERT(x) do { /* assertion omitted */ } while (0)
#define DUK_ASSERT_EXPR(x) ((void) 0)
error header
12 years ago
#endif /* DUK_USE_ASSERTIONS */
add DUK_ASSERT_DISABLE() to allow always true asserts to be disabled in a self-documenting way, type cleanup
11 years ago
/* this variant is used when an assert would generate a compile warning by
* being always true (e.g. >= 0 comparison for an unsigned value
*/
Implement Node.js Buffer and TypedArray support
10 years ago
#define DUK_ASSERT_DISABLE(x) do { /* assertion disabled */ } while (0)
add DUK_ASSERT_DISABLE() to allow always true asserts to be disabled in a self-documenting way, type cleanup
11 years ago
error header
12 years ago
/*
* Assertion helpers
*/
#if defined(DUK_USE_ASSERTIONS) && defined(DUK_USE_REFERENCE_COUNTING)
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h) do { \
error header
12 years ago
DUK_ASSERT((h) == NULL || DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) (h)) > 0); \
} while (0)
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv) do { \
error header
12 years ago
if ((tv) != NULL && DUK_TVAL_IS_HEAP_ALLOCATED((tv))) { \
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(DUK_TVAL_GET_HEAPHDR((tv))) > 0); \
} \
} while (0)
#else
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h) /* no refcount check */
#define DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv) /* no refcount check */
error header
12 years ago
#endif
Internal typing fixes (mostly error code)
11 years ago
#define DUK_ASSERT_TOP(ctx,n) DUK_ASSERT((duk_idx_t) duk_get_top((ctx)) == (duk_idx_t) (n))
error header
12 years ago
rework duk_double_union and duk_tval macros; doubles are now normalized using a union which should be strict aliasing compatible
11 years ago
#if defined(DUK_USE_ASSERTIONS) && defined(DUK_USE_PACKED_TVAL)
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval) do { \
Add NaN normalization asserts to duk_tval macros
9 years ago
duk_double_union duk__assert_tmp_du; \
duk__assert_tmp_du.d = (dval); \
DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&duk__assert_tmp_du)); \
rework duk_double_union and duk_tval macros; doubles are now normalized using a union which should be strict aliasing compatible
11 years ago
} while (0)
#else
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval) /* nop */
rework duk_double_union and duk_tval macros; doubles are now normalized using a union which should be strict aliasing compatible
11 years ago
#endif
Add prototype dense array fast paths for push/pop Add minimal fast paths for Array.prototype operations like push() and pop(), triggered when the &#39;this&#39; binding is an Array which has its array part still present. This is the most common case and user code will expect for example Array.prototype.push() to be relatively fast. The main purpose of this commit is to figure out the necessary internal helpers for fast paths. More fast paths will be added separately.
9 years ago
#define DUK_ASSERT_VS_SPACE(thr) \
DUK_ASSERT(thr->valstack_top < thr->valstack_end)
error header
12 years ago
/*
* Helper for valstack space
*
internal macro renames, XXX -&gt; DUK__XXX
11 years ago
* Caller of DUK_ASSERT_VALSTACK_SPACE() estimates the number of free stack entries
error header
12 years ago
* required for its own use, and any child calls which are not (a) Duktape API calls
* or (b) Duktape calls which involve extending the valstack (e.g. getter call).
*/
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_VALSTACK_ASSERT_EXTRA 5 /* this is added to checks to allow for Duktape
Indent trivia
10 years ago
* API calls in addition to function's own use
*/
error header
12 years ago
#if defined(DUK_USE_ASSERTIONS)
internal macro renames, XXX -&gt; DUK__XXX
11 years ago
#define DUK_ASSERT_VALSTACK_SPACE(thr,n) do { \
error header
12 years ago
DUK_ASSERT((thr) != NULL); \
DUK_ASSERT((thr)->valstack_end - (thr)->valstack_top >= (n) + DUK_VALSTACK_ASSERT_EXTRA); \
} while (0)
#else
internal macro renames, XXX -&gt; DUK__XXX
11 years ago
#define DUK_ASSERT_VALSTACK_SPACE(thr,n) /* no valstack space check */
error header
12 years ago
#endif
/*
* Prototypes
*/
Relocate error throwing helpers to duk_error.h
9 years ago
#if defined(DUK_USE_VERBOSE_ERRORS)
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *msg));
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_fmt(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *fmt, ...));
error header
12 years ago
#else /* DUK_USE_VERBOSE_ERRORS */
Symbol visibility changes for code and headers
10 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code));
error header
12 years ago
#endif /* DUK_USE_VERBOSE_ERRORS */
Relocate error throwing helpers to duk_error.h
9 years ago
#if defined(DUK_USE_VERBOSE_ERRORS)
Symbol visibility changes for code and headers
10 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code, const char *msg, const char *filename, duk_int_t line));
error header
12 years ago
#else
Symbol visibility changes for code and headers
10 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code));
error header
12 years ago
#endif
Symbol visibility changes for code and headers
10 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc));
error header
12 years ago
replace Duktape.errhnd with Duktape.errthrow; add Duktape.errcreate so that user can also add an error handler for creating errors (which may be useful than errthrow); move errhandler calling to duk_error_augment.c; reorganize DUK_USE_xxx flags around error handlers
11 years ago
#if defined(DUK_USE_AUGMENT_ERROR_CREATE)
Symbol visibility changes for code and headers
10 years ago
DUK_INTERNAL_DECL void duk_err_augment_error_create(duk_hthread *thr, duk_hthread *thr_callstack, const char *filename, duk_int_t line, duk_bool_t noblame_fileline);
error header
12 years ago
#endif
replace Duktape.errhnd with Duktape.errthrow; add Duktape.errcreate so that user can also add an error handler for creating errors (which may be useful than errthrow); move errhandler calling to duk_error_augment.c; reorganize DUK_USE_xxx flags around error handlers
11 years ago
#if defined(DUK_USE_AUGMENT_ERROR_THROW)
Symbol visibility changes for code and headers
10 years ago
DUK_INTERNAL_DECL void duk_err_augment_error_throw(duk_hthread *thr);
add a DUK_USE_ERRHANDLER define
11 years ago
#endif
error header
12 years ago
Relocate error throwing helpers to duk_error.h
9 years ago
#if defined(DUK_USE_VERBOSE_ERRORS)
#if defined(DUK_USE_PARANOID_ERRORS)
Avoid &#39;index&#39; as variable/argument name
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t idx, const char *expect_name));
Relocate error throwing helpers to duk_error.h
9 years ago
#else
Avoid &#39;index&#39; as variable/argument name
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t idx, const char *expect_name));
Relocate error throwing helpers to duk_error.h
9 years ago
#endif
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_error_internal(duk_hthread *thr, const char *filename, duk_int_t linenumber));
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_error_alloc_failed(duk_hthread *thr, const char *filename, duk_int_t linenumber));
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_error(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message));
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t idx));
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range_push_beyond(duk_hthread *thr, const char *filename, duk_int_t linenumber));
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message));
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_type_invalid_args(duk_hthread *thr, const char *filename, duk_int_t linenumber));
Allow bound function as Thread initial function
8 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_type_invalid_state(duk_hthread *thr, const char *filename, duk_int_t linenumber));
Use &#39;ownKeys&#39; trap for for-in (ES7), enum check * Remove &#39;enumerate&#39; trap. * Use &#39;ownKeys&#39; trap for &#34;for-in&#34; too, as specified in ES7. * Add enumerability check for &#39;ownKeys&#39; result when used in for-in or Object.keys(). Because there&#39;s no support for &#39;getOwnPropertyDescriptor&#39; trap yet, the check will always operate directly on the target object.
8 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_type_invalid_trap_result(duk_hthread *thr, const char *filename, duk_int_t linenumber));
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
#else /* DUK_VERBOSE_ERRORS */
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_error(duk_hthread *thr));
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range(duk_hthread *thr));
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_eval(duk_hthread *thr));
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_reference(duk_hthread *thr));
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_syntax(duk_hthread *thr));
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_type(duk_hthread *thr));
Remove Duktape specific error subtypes These don&#39;t play well with the API currently: the Duktape specific error codes don&#39;t have Ecmascript Error class counterparts so they don&#39;t get represented usefully as Ecmascript objects (e.g. AllocError is a plain Error from Ecmascript point of view). There&#39;s no real need for Duktape specific error code. Some of the codes had become unused; a couple were used but Ecmascript standard types can be used instead. Also minor error message tweaking.
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_uri(duk_hthread *thr));
Reduce error call site footprint, internal changes * Use shared error macros and shared error handler to reduce the size of call sites of common errors. * Make zero argument DUK_ERROR() calls non-vararg calls to reduce call site footprint. Non-vararg calls have smaller call sites and because there are a lot of call sites, this turns out to be significant. * Remove variadic macros from internal DUK_ERROR() macro set and add separate macros for argument counts 0 to 4; this is more portable and requires less conditional code, and works well when a non-vararg call is used for most error call sites. * Rework macro / function argument order for the error path, try to keep &#39;thr&#39; in the same argument slot to avoid unnecessary register moves. * Pack linenumber and error code into a single 32-bit argument when possible, removes one more constant load from the call site. * Convert some internal errors to RangeErrors when the underlying cause is an implementation limit (such as a compiler temp limit) rather than an actual unexpected internal situation. * Simplify and share a few error messages to reduce string count.
9 years ago
#endif /* DUK_VERBOSE_ERRORS */
Relocate error throwing helpers to duk_error.h
9 years ago
Symbol visibility changes for code and headers
10 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_longjmp(duk_hthread *thr));
error header
12 years ago
Remove panic handling, use fatal errors instead Instead of having a separate panic concept which previously differed from fatal error handling in that there was no context attached to the error, use fatal errors also for call sites which previously used the panic handler. Because these call sites are context-free (DUK_ASSERT() failures) simply call the Duktape-wide default fatal error handler instead of the user fatal error handler. For heap creation errors (self test failures) the udata is available; for assertion it isn&#39;t and NULL is used instead. Add a config option to replace the Duktape-wide fatal error handler; the default one just segfaults on purpose, to avoid creating postability issues by depending on e.g. abort(). Remove the error code from the fatal error function signature (it&#39;s mostly pointless) and change the &#34;ctx&#34; argument to &#34;udata&#34; (heap userdata) which is less confusing than an arbitrary context related to the heap (especially because it&#39;s unsafe to actually use the &#34;ctx&#34; to e.g. call into the Duktape API). The fatal error signature change also affects the duk_fatal() API call, which loses the error code argument.
9 years ago
DUK_NORETURN(DUK_INTERNAL_DECL void duk_default_fatal_handler(void *udata, const char *msg));
error header
12 years ago
Symbol visibility changes for code and headers
10 years ago
DUK_INTERNAL_DECL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_int_t lj_type);
error header
12 years ago
Symbol visibility changes for code and headers
10 years ago
DUK_INTERNAL_DECL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t err_code);
error header
12 years ago
fix include guard names, don&#39;t use leading underscores as they are reserved
12 years ago
#endif /* DUK_ERROR_H_INCLUDED */