1 /* 2 * Error handling macros, assertion macro, error codes. 3 * 4 * There are three level of 'errors': 5 * 6 * 1. Ordinary errors, relative to a thread, cause a longjmp, catchable. 7 * 2. Fatal errors, relative to a heap, cause fatal handler to be called. 8 * 3. Panic errors, unrelated to a heap and cause a process exit. 9 * 10 * Panics are used by the default fatal error handler and by debug code 11 * such as assertions. By providing a proper fatal error handler, user 12 * code can avoid panics in non-debug builds. 13 */ 14 15 #ifndef DUK_ERROR_H_INCLUDED 16 #define DUK_ERROR_H_INCLUDED 17 18 /* 19 * Error codes: defined in duktape.h 20 * 21 * Error codes are used as a shorthand to throw exceptions from inside 22 * the implementation. The appropriate Ecmascript object is constructed 23 * based on the code. Ecmascript code throws objects directly. The error 24 * codes are defined in the public API header because they are also used 25 * by calling code. 26 */ 27 28 /* 29 * Normal error 30 * 31 * Normal error is thrown with a longjmp() through the current setjmp() 32 * catchpoint record in the duk_heap. The 'curr_thread' of the duk_heap 33 * identifies the throwing thread. 34 * 35 * Error formatting is usually unnecessary. The error macros provide a 36 * zero argument version (no formatting) and separate macros for small 37 * argument counts. Variadic macros are not used to avoid portability 38 * issues and avoid the need for stash-based workarounds when they're not 39 * available. Vararg calls are avoided for non-formatted error calls 40 * because vararg call sites are larger than normal, and there are a lot 41 * of call sites with no formatting. 42 * 43 * Note that special formatting provided by debug macros is NOT available. 44 * 45 * The _RAW variants allow the caller to specify file and line. This makes 46 * it easier to write checked calls which want to use the call site of the 47 * checked function, not the error macro call inside the checked function. 48 */ 49 50 #if defined(DUK_USE_VERBOSE_ERRORS) 51 52 /* Because there are quite many call sites, pack error code (require at most 53 * 8-bit) into a single argument. 54 */ 55 #define DUK_ERROR(thr,err,msg) do { \ 56 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \ 57 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \ 58 duk_err_handle_error((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \ 59 } while (0) 60 #define DUK_ERROR_RAW(thr,file,line,err,msg) do { \ 61 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \ 62 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \ 63 duk_err_handle_error((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \ 64 } while (0) 65 66 #define DUK_ERROR_FMT1(thr,err,fmt,arg1) do { \ 67 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \ 68 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \ 69 duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \ 70 } while (0) 71 #define DUK_ERROR_RAW_FMT1(thr,file,line,err,fmt,arg1) do { \ 72 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \ 73 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \ 74 duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \ 75 } while (0) 76 77 #define DUK_ERROR_FMT2(thr,err,fmt,arg1,arg2) do { \ 78 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \ 79 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \ 80 duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \ 81 } while (0) 82 #define DUK_ERROR_RAW_FMT2(thr,file,line,err,fmt,arg1,arg2) do { \ 83 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \ 84 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \ 85 duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \ 86 } while (0) 87 88 #define DUK_ERROR_FMT3(thr,err,fmt,arg1,arg2,arg3) do { \ 89 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \ 90 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \ 91 duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \ 92 } while (0) 93 #define DUK_ERROR_RAW_FMT3(thr,file,line,err,fmt,arg1,arg2,arg3) do { \ 94 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \ 95 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \ 96 duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \ 97 } while (0) 98 99 #define DUK_ERROR_FMT4(thr,err,fmt,arg1,arg2,arg3,arg4) do { \ 100 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \ 101 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \ 102 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)); \ 103 } while (0) 104 #define DUK_ERROR_RAW_FMT4(thr,file,line,err,fmt,arg1,arg2,arg3,arg4) do { \ 105 duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \ 106 DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \ 107 duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3), (arg4)); \ 108 } while (0) 109 110 #else /* DUK_USE_VERBOSE_ERRORS */ 111 112 #define DUK_ERROR(thr,err,msg) duk_err_handle_error((thr), (err)) 113 #define DUK_ERROR_RAW(thr,file,line,err,msg) duk_err_handle_error((thr), (err)) 114 115 #define DUK_ERROR_FMT1(thr,err,fmt,arg1) DUK_ERROR((thr),(err),(fmt)) 116 #define DUK_ERROR_RAW_FMT1(thr,file,line,err,fmt,arg1) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt)) 117 118 #define DUK_ERROR_FMT2(thr,err,fmt,arg1,arg2) DUK_ERROR((thr),(err),(fmt)) 119 #define DUK_ERROR_RAW_FMT2(thr,file,line,err,fmt,arg1,arg2) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt)) 120 121 #define DUK_ERROR_FMT3(thr,err,fmt,arg1,arg2,arg3) DUK_ERROR((thr),(err),(fmt)) 122 #define DUK_ERROR_RAW_FMT3(thr,file,line,err,fmt,arg1,arg2,arg3) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt)) 123 124 #define DUK_ERROR_FMT4(thr,err,fmt,arg1,arg2,arg3,arg4) DUK_ERROR((thr),(err),(fmt)) 125 #define DUK_ERROR_RAW_FMT4(thr,file,line,err,fmt,arg1,arg2,arg3,arg4) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt)) 126 127 #endif /* DUK_USE_VERBOSE_ERRORS */ 128 129 /* 130 * Fatal error 131 * 132 * There are no fatal error macros at the moment. There are so few call 133 * sites that the fatal error handler is called directly. 134 */ 135 136 /* 137 * Panic error 138 * 139 * Panic errors are not relative to either a heap or a thread, and cause 140 * DUK_PANIC() macro to be invoked. Unless a user provides DUK_USE_PANIC_HANDLER, 141 * DUK_PANIC() calls a helper which prints out the error and causes a process 142 * exit. 143 * 144 * The user can override the macro to provide custom handling. A macro is 145 * used to allow the user to have inline panic handling if desired (without 146 * causing a potentially risky function call). 147 * 148 * Panics are only used in debug code such as assertions, and by the default 149 * fatal error handler. 150 */ 151 152 #if defined(DUK_USE_PANIC_HANDLER) 153 /* already defined, good */ 154 #define DUK_PANIC(code,msg) DUK_USE_PANIC_HANDLER((code),(msg)) 155 #else 156 #define DUK_PANIC(code,msg) duk_default_panic_handler((code),(msg)) 157 #endif /* DUK_USE_PANIC_HANDLER */ 158 159 /* 160 * Assert macro: failure causes panic. 161 */ 162 163 #if defined(DUK_USE_ASSERTIONS) 164 165 /* the message should be a compile time constant without formatting (less risk); 166 * we don't care about assertion text size because they're not used in production 167 * builds. 168 */ 169 #define DUK_ASSERT(x) do { \ 170 if (!(x)) { \ 171 DUK_PANIC(DUK_ERR_ASSERTION_ERROR, \ 172 "assertion failed: " #x \ 173 " (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"); \ 174 } \ 175 } while (0) 176 177 /* Assertion compatible inside a comma expression, evaluates to void. 178 * Currently not compatible with DUK_USE_PANIC_HANDLER() which may have 179 * a statement block. 180 */ 181 #if defined(DUK_USE_PANIC_HANDLER) 182 /* XXX: resolve macro definition issue or call through a helper function? */ 183 #define DUK_ASSERT_EXPR(x) ((void) 0) 184 #else 185 #define DUK_ASSERT_EXPR(x) \ 186 ((void) ((x) ? 0 : (DUK_PANIC(DUK_ERR_ASSERTION_ERROR, \ 187 "assertion failed: " #x \ 188 " (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"), 0))) 189 #endif 190 191 #else /* DUK_USE_ASSERTIONS */ 192 193 #define DUK_ASSERT(x) do { /* assertion omitted */ } while (0) 194 195 #define DUK_ASSERT_EXPR(x) ((void) 0) 196 197 #endif /* DUK_USE_ASSERTIONS */ 198 199 /* this variant is used when an assert would generate a compile warning by 200 * being always true (e.g. >= 0 comparison for an unsigned value 201 */ 202 #define DUK_ASSERT_DISABLE(x) do { /* assertion disabled */ } while (0) 203 204 /* 205 * Assertion helpers 206 */ 207 208 #if defined(DUK_USE_ASSERTIONS) && defined(DUK_USE_REFERENCE_COUNTING) 209 #define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h) do { \ 210 DUK_ASSERT((h) == NULL || DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) (h)) > 0); \ 211 } while (0) 212 #define DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv) do { \ 213 if ((tv) != NULL && DUK_TVAL_IS_HEAP_ALLOCATED((tv))) { \ 214 DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(DUK_TVAL_GET_HEAPHDR((tv))) > 0); \ 215 } \ 216 } while (0) 217 #else 218 #define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h) /* no refcount check */ 219 #define DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv) /* no refcount check */ 220 #endif 221 222 #define DUK_ASSERT_TOP(ctx,n) DUK_ASSERT((duk_idx_t) duk_get_top((ctx)) == (duk_idx_t) (n)) 223 224 #if defined(DUK_USE_ASSERTIONS) && defined(DUK_USE_PACKED_TVAL) 225 #define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval) do { \ 226 duk_double_union duk__assert_tmp_du; \ 227 duk__assert_tmp_du.d = (dval); \ 228 DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&duk__assert_tmp_du)); \ 229 } while (0) 230 #else 231 #define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval) /* nop */ 232 #endif 233 234 /* 235 * Helper for valstack space 236 * 237 * Caller of DUK_ASSERT_VALSTACK_SPACE() estimates the number of free stack entries 238 * required for its own use, and any child calls which are not (a) Duktape API calls 239 * or (b) Duktape calls which involve extending the valstack (e.g. getter call). 240 */ 241 242 #define DUK_VALSTACK_ASSERT_EXTRA 5 /* this is added to checks to allow for Duktape 243 * API calls in addition to function's own use 244 */ 245 #if defined(DUK_USE_ASSERTIONS) 246 #define DUK_ASSERT_VALSTACK_SPACE(thr,n) do { \ 247 DUK_ASSERT((thr) != NULL); \ 248 DUK_ASSERT((thr)->valstack_end - (thr)->valstack_top >= (n) + DUK_VALSTACK_ASSERT_EXTRA); \ 249 } while (0) 250 #else 251 #define DUK_ASSERT_VALSTACK_SPACE(thr,n) /* no valstack space check */ 252 #endif 253 254 /* 255 * Error throwing helpers 256 * 257 * The goal is to provide verbose and configurable error messages. Call 258 * sites should be clean in source code and compile to a small footprint. 259 * Small footprint is also useful for performance because small cold paths 260 * reduce code cache pressure. Adding macros here only makes sense if there 261 * are enough call sites to get concrete benefits. 262 */ 263 264 #if defined(DUK_USE_VERBOSE_ERRORS) 265 /* Verbose errors with key/value summaries (non-paranoid) or without key/value 266 * summaries (paranoid, for some security sensitive environments), the paranoid 267 * vs. non-paranoid distinction affects only a few specific errors. 268 */ 269 #if defined(DUK_USE_PARANOID_ERRORS) 270 #define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,index,expectname,lowmemstr) do { \ 271 duk_err_require_type_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (index), (expectname)); \ 272 } while (0) 273 #else /* DUK_USE_PARANOID_ERRORS */ 274 #define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,index,expectname,lowmemstr) do { \ 275 duk_err_require_type_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (index), (expectname)); \ 276 } while (0) 277 #endif /* DUK_USE_PARANOID_ERRORS */ 278 279 #define DUK_ERROR_UNIMPLEMENTED(thr,msg) do { \ 280 DUK_ERROR((thr), DUK_ERR_UNIMPLEMENTED_ERROR, (msg)); \ 281 } while (0) 282 #define DUK_ERROR_UNIMPLEMENTED_DEFMSG(thr) do { \ 283 duk_err_unimplemented_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \ 284 } while (0) 285 #define DUK_ERROR_UNSUPPORTED(thr,msg) do { \ 286 DUK_ERROR((thr), DUK_ERR_UNSUPPORTED_ERROR, (msg)); \ 287 } while (0) 288 #if !defined(DUK_USE_BYTECODE_DUMP_SUPPORT) 289 #define DUK_ERROR_UNSUPPORTED_DEFMSG(thr) do { \ 290 duk_err_unsupported_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \ 291 } while (0) 292 #endif 293 #define DUK_ERROR_INTERNAL(thr,msg) do { \ 294 duk_err_internal((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \ 295 } while (0) 296 #define DUK_ERROR_INTERNAL_DEFMSG(thr) do { \ 297 duk_err_internal_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \ 298 } while (0) 299 #define DUK_ERROR_ALLOC(thr,msg) do { \ 300 duk_err_alloc((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \ 301 } while (0) 302 #define DUK_ERROR_ALLOC_DEFMSG(thr) do { \ 303 DUK_ERROR_ALLOC((thr), DUK_STR_ALLOC_FAILED); \ 304 } while (0) 305 /* DUK_ERR_ASSERTION_ERROR: no macros needed */ 306 #define DUK_ERROR_API_INDEX(thr,index) do { \ 307 duk_err_api_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (index)); \ 308 } while (0) 309 #define DUK_ERROR_API(thr,msg) do { \ 310 duk_err_api((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \ 311 } while (0) 312 /* DUK_ERR_UNCAUGHT_ERROR: no macros needed */ 313 /* DUK_ERR_ERROR: no macros needed */ 314 /* DUK_ERR_EVAL: no macros needed */ 315 #define DUK_ERROR_RANGE(thr,msg) do { \ 316 duk_err_range((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \ 317 } while (0) 318 /* DUK_ERR_REFERENCE_ERROR: no macros needed */ 319 #define DUK_ERROR_SYNTAX(thr,msg) do { \ 320 DUK_ERROR((thr), DUK_ERR_SYNTAX_ERROR, (msg)); \ 321 } while (0) 322 #define DUK_ERROR_TYPE(thr,msg) do { \ 323 DUK_ERROR((thr), DUK_ERR_TYPE_ERROR, (msg)); \ 324 } while (0) 325 /* DUK_ERR_URI_ERROR: no macros needed */ 326 #else /* DUK_USE_VERBOSE_ERRORS */ 327 /* Non-verbose errors for low memory targets: no file, line, or message. */ 328 329 #define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,index,expectname,lowmemstr) do { \ 330 duk_err_type((thr)); \ 331 } while (0) 332 333 #define DUK_ERROR_UNIMPLEMENTED(thr,msg) do { \ 334 duk_err_unimplemented((thr)); \ 335 } while (0) 336 #define DUK_ERROR_UNIMPLEMENTED_DEFMSG(thr) do { \ 337 duk_err_unimplemented((thr)); \ 338 } while (0) 339 #define DUK_ERROR_UNSUPPORTED(thr,msg) do { \ 340 duk_err_unsupported((thr)); \ 341 } while (0) 342 #define DUK_ERROR_UNSUPPORTED_DEFMSG(thr) do { \ 343 duk_err_unsupported((thr)); \ 344 } while (0) 345 #define DUK_ERROR_INTERNAL(thr,msg) do { \ 346 duk_err_internal((thr)); \ 347 } while (0) 348 #define DUK_ERROR_INTERNAL_DEFMSG(thr) do { \ 349 duk_err_internal((thr)); \ 350 } while (0) 351 #define DUK_ERROR_ALLOC(thr,msg) do { \ 352 duk_err_alloc((thr)); \ 353 } while (0) 354 #define DUK_ERROR_ALLOC_DEFMSG(thr) do { \ 355 duk_err_alloc((thr)); \ 356 } while (0) 357 #define DUK_ERROR_API_INDEX(thr,index) do { \ 358 duk_err_api((thr)); \ 359 } while (0) 360 #define DUK_ERROR_API(thr,msg) do { \ 361 duk_err_api((thr)); \ 362 } while (0) 363 #define DUK_ERROR_RANGE(thr,msg) do { \ 364 duk_err_range((thr)); \ 365 } while (0) 366 #define DUK_ERROR_SYNTAX(thr,msg) do { \ 367 duk_err_syntax((thr)); \ 368 } while (0) 369 #define DUK_ERROR_TYPE(thr,msg) do { \ 370 duk_err_type((thr)); \ 371 } while (0) 372 #endif /* DUK_USE_VERBOSE_ERRORS */ 373 374 /* 375 * Prototypes 376 */ 377 378 #if defined(DUK_USE_VERBOSE_ERRORS) 379 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)); 380 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, ...)); 381 #else /* DUK_USE_VERBOSE_ERRORS */ 382 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code)); 383 #endif /* DUK_USE_VERBOSE_ERRORS */ 384 385 #if defined(DUK_USE_VERBOSE_ERRORS) 386 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)); 387 #else 388 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code)); 389 #endif 390 391 DUK_NORETURN(DUK_INTERNAL_DECL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc)); 392 393 #if defined(DUK_USE_AUGMENT_ERROR_CREATE) 394 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); 395 #endif 396 #if defined(DUK_USE_AUGMENT_ERROR_THROW) 397 DUK_INTERNAL_DECL void duk_err_augment_error_throw(duk_hthread *thr); 398 #endif 399 400 #if defined(DUK_USE_VERBOSE_ERRORS) 401 #if defined(DUK_USE_PARANOID_ERRORS) 402 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t index, const char *expect_name)); 403 #else 404 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t index, const char *expect_name)); 405 #endif 406 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_api_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t index)); 407 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_api(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message)); 408 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message)); 409 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_unimplemented_defmsg(duk_hthread *thr, const char *filename, duk_int_t linenumber)); 410 #if !defined(DUK_USE_BYTECODE_DUMP_SUPPORT) 411 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_unsupported_defmsg(duk_hthread *thr, const char *filename, duk_int_t linenumber)); 412 #endif 413 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_internal_defmsg(duk_hthread *thr, const char *filename, duk_int_t linenumber)); 414 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_internal(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message)); 415 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_alloc(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message)); 416 #else /* DUK_VERBOSE_ERRORS */ 417 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range(duk_hthread *thr)); 418 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_syntax(duk_hthread *thr)); 419 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_type(duk_hthread *thr)); 420 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_api(duk_hthread *thr)); 421 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_unimplemented(duk_hthread *thr)); 422 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_unsupported(duk_hthread *thr)); 423 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_internal(duk_hthread *thr)); 424 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_alloc(duk_hthread *thr)); 425 #endif /* DUK_VERBOSE_ERRORS */ 426 427 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_longjmp(duk_hthread *thr)); 428 429 DUK_NORETURN(DUK_INTERNAL_DECL void duk_default_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg)); 430 431 #if !defined(DUK_USE_PANIC_HANDLER) 432 DUK_NORETURN(DUK_INTERNAL_DECL void duk_default_panic_handler(duk_errcode_t code, const char *msg)); 433 #endif 434 435 DUK_INTERNAL_DECL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_int_t lj_type); 436 437 DUK_INTERNAL_DECL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t err_code); 438 439 #endif /* DUK_ERROR_H_INCLUDED */ 440
