Mercurial > code
changeset 391:e2cefd0ee511
Add Js, Duktape wrapper
| author | David Demelier <markand@malikania.fr> |
|---|---|
| date | Mon, 28 Sep 2015 13:18:14 +0200 |
| parents | d7e6d7d1e102 |
| children | 69adcefe73ae 875b5ce19fda |
| files | C++/modules/Js/Js.cpp C++/modules/Js/Js.h C++/tests/Js/main.cpp CMakeLists.txt extern/CMakeLists.txt extern/duktape/CMakeLists.txt extern/duktape/duk_config.h extern/duktape/duktape.c extern/duktape/duktape.h |
| diffstat | 9 files changed, 86557 insertions(+), 2 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/C++/modules/Js/Js.cpp Mon Sep 28 13:18:14 2015 +0200 @@ -0,0 +1,340 @@ +/* + * Js.cpp -- JS API for irccd and Duktape helpers + * + * Copyright (c) 2013, 2014, 2015 David Demelier <markand@malikania.fr> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <cerrno> +#include <cstring> +#include <fstream> +#include <iterator> +#include <memory> +#include <unordered_map> + +#include "Js.h" + +using namespace std::string_literals; + +namespace js { + +namespace { + +ErrorInfo error(ContextPtr ctx, duk_idx_t index) +{ + ErrorInfo error; + + index = duk_normalize_index(ctx, index); + + assertBegin(ctx); + duk_get_prop_string(ctx, index, "name"); + error.name = duk_to_string(ctx, -1); + duk_get_prop_string(ctx, index, "message"); + error.message = duk_to_string(ctx, -1); + duk_get_prop_string(ctx, index, "fileName"); + error.fileName = duk_to_string(ctx, -1); + duk_get_prop_string(ctx, index, "lineNumber"); + error.lineNumber = duk_to_int(ctx, -1); + duk_get_prop_string(ctx, index, "stack"); + error.stack = duk_to_string(ctx, -1); + duk_pop_n(ctx, 5); + assertEquals(ctx); + + return error; +} + +} // !namespace + +/* ------------------------------------------------------------------ + * Context class + * ------------------------------------------------------------------ */ + +Context::Context() + : std::unique_ptr<duk_context, void (*)(duk_context *)>(duk_create_heap_default(), duk_destroy_heap) +{ +} + +/* -------------------------------------------------------- + * Push functions + * -------------------------------------------------------- */ + +void push(ContextPtr ctx, bool value) +{ + duk_push_boolean(ctx, value); +} + +void push(ContextPtr ctx, int value) +{ + duk_push_int(ctx, value); +} + +void push(ContextPtr ctx, double value) +{ + duk_push_number(ctx, value); +} + +void push(ContextPtr ctx, const std::string &value) +{ + duk_push_lstring(ctx, value.c_str(), value.length()); +} + +void push(ContextPtr ctx, const char *value) +{ + duk_push_string(ctx, value); +} + +void push(ContextPtr ctx, const Function &fn) +{ + assert(fn.function); + + duk_push_c_function(ctx, fn.function, fn.nargs); +} + +void push(ContextPtr ctx, const Object &) +{ + duk_push_object(ctx); +} + +void push(ContextPtr ctx, const Array &) +{ + duk_push_array(ctx); +} + +/* -------------------------------------------------------- + * Get functions + * -------------------------------------------------------- */ + +void get(ContextPtr ctx, duk_idx_t index, bool &value) +{ + value = duk_get_boolean(ctx, index); +} + +void get(ContextPtr ctx, duk_idx_t index, int &value) +{ + value = duk_get_int(ctx, index); +} + +void get(ContextPtr ctx, duk_idx_t index, double &value) +{ + value = duk_get_number(ctx, index); +} + +void get(ContextPtr ctx, duk_idx_t index, std::string &value) +{ + duk_size_t size; + const char *text = duk_get_lstring(ctx, index, &size); + + value = std::string{text, size}; +} + +/* -------------------------------------------------------- + * Require functions + * -------------------------------------------------------- */ + +void require(ContextPtr ctx, duk_idx_t index, bool &value) +{ + value = duk_require_boolean(ctx, index); +} + +void require(ContextPtr ctx, duk_idx_t index, int &value) +{ + value = duk_require_int(ctx, index); +} + +void require(ContextPtr ctx, duk_idx_t index, double &value) +{ + value = duk_require_number(ctx, index); +} + +void require(ContextPtr ctx, duk_idx_t index, std::string &value) +{ + duk_size_t size; + const char *text = duk_require_lstring(ctx, index, &size); + + value = std::string{text, size}; +} + +/* -------------------------------------------------------- + * Basic functions + * -------------------------------------------------------- */ + +duk_int_t type(ContextPtr ctx, duk_idx_t index) +{ + return duk_get_type(ctx, index); +} + +int top(ContextPtr ctx) +{ + return duk_get_top(ctx); +} + +void pop(ContextPtr ctx, int count) +{ + assert(count > 0); + + duk_pop_n(ctx, count); +} + +duk_bool_t instanceof(ContextPtr ctx, duk_idx_t idx1, duk_idx_t idx2) +{ + return duk_instanceof(ctx, idx1, idx2); +} + +void call(ContextPtr ctx, duk_idx_t nargs) +{ + duk_call(ctx, nargs); +} + +void pcall(ContextPtr ctx, duk_idx_t nargs) +{ + if (duk_pcall(ctx, nargs) != 0) { + ErrorInfo info = error(ctx, -1); + pop(ctx); + + throw info; + } +} + +/* ------------------------------------------------------------------ + * Eval functions + * ------------------------------------------------------------------ */ + +void eval(ContextPtr ctx) +{ + duk_eval(ctx); +} + +void evalString(ContextPtr ctx, const std::string &name) +{ + duk_eval_string(ctx, name.c_str()); +} + +void evalFile(ContextPtr ctx, const std::string &file) +{ + duk_eval_file(ctx, file.c_str()); +} + +void peval(ContextPtr ctx) +{ + if (duk_peval(ctx) != 0) { + throw error(ctx, -1); + } +} + +void pevalString(ContextPtr ctx, const std::string &script) +{ + if (duk_peval_string(ctx, script.c_str()) != 0) { + ErrorInfo info = error(ctx, -1); + pop(ctx); + + throw info; + } +} + +void pevalFile(ContextPtr ctx, const std::string &file) +{ + if (duk_peval_file(ctx, file.c_str()) != 0) { + ErrorInfo info = error(ctx, -1); + pop(ctx); + + throw info; + } +} + +/* ------------------------------------------------------------------ + * ExceptionAbstract class + * ------------------------------------------------------------------ */ + +ExceptionAbstract::ExceptionAbstract(std::string name, std::string message) + : m_name(std::move(name)) + , m_message(std::move(message)) +{ +} + +const std::string &ExceptionAbstract::name() const noexcept +{ + return m_name; +} + +void ExceptionAbstract::create(ContextPtr ctx) const noexcept +{ + duk_get_global_string(ctx, m_name.c_str()); + duk_push_string(ctx, m_message.c_str()); + duk_new(ctx, 1); +} + +/* ------------------------------------------------------------------ + * Error class + * ------------------------------------------------------------------ */ + +Error::Error(std::string message) + : ExceptionAbstract("Error", std::move(message)) +{ +} + +/* ------------------------------------------------------------------ + * EvalError class + * ------------------------------------------------------------------ */ + +EvalError::EvalError(std::string message) + : ExceptionAbstract("EvalError", std::move(message)) +{ +} + +/* ------------------------------------------------------------------ + * RangeError class + * ------------------------------------------------------------------ */ + +RangeError::RangeError(std::string message) + : ExceptionAbstract("RangeError", std::move(message)) +{ +} + +/* ------------------------------------------------------------------ + * ReferenceError class + * ------------------------------------------------------------------ */ + +ReferenceError::ReferenceError(std::string message) + : ExceptionAbstract("ReferenceError", std::move(message)) +{ +} + +/* ------------------------------------------------------------------ + * SyntaxError class + * ------------------------------------------------------------------ */ + +SyntaxError::SyntaxError(std::string message) + : ExceptionAbstract("SyntaxError", std::move(message)) +{ +} + +/* ------------------------------------------------------------------ + * TypeError class + * ------------------------------------------------------------------ */ + +TypeError::TypeError(std::string message) + : ExceptionAbstract("TypeError", std::move(message)) +{ +} + +/* ------------------------------------------------------------------ + * URIError class + * ------------------------------------------------------------------ */ + +URIError::URIError(std::string message) + : ExceptionAbstract("URIError", std::move(message)) +{ +} + +} // !js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/C++/modules/Js/Js.h Mon Sep 28 13:18:14 2015 +0200 @@ -0,0 +1,680 @@ +/* + * Js.h -- JavaScript wrapper for Duktape + * + * Copyright (c) 2013, 2014, 2015 David Demelier <markand@malikania.fr> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _JS_H_ +#define _JS_H_ + +/** + * @file Js.h + * @brief Bring JavaScript using Duktape + * + * This file provides usual Duktape function renamed and placed into `js` namespace. It also replaces error + * code with exceptions when possible. + * + * For convenience, this file also provides templated functions, overloads and much more. + */ + +#include <cassert> +#include <cerrno> +#include <cstring> +#include <memory> +#include <stack> +#include <string> +#include <vector> + +#include <duktape.h> + +namespace js { + +#if !defined(NDEBUG) +#define assertBegin(ctx) \ + int _topstack = duk_get_top(ctx) +#else +#define assertBegin(ctx) +#endif + +#if !defined(NDEBUG) +#define assertEquals(ctx) \ + assert(_topstack == duk_get_top(ctx)) +#else +#define assertEquals(ctx) +#endif + +#if !defined(NDEBUG) +#define assertEnd(ctx, count) \ + assert(_topstack == (duk_get_top(ctx) - count)) +#else +#define assertEnd(ctx, count) +#endif + +/** + * Typedef for readability. + */ +using ContextPtr = duk_context *; + +/** + * @class Context + * @brief RAII based Duktape handler + * + * This class is implicitly convertible to duk_context for convenience. + */ +class Context : public std::unique_ptr<duk_context, void (*)(duk_context *)> { +private: + /* Move and copy forbidden */ + Context(const Context &) = delete; + Context &operator=(const Context &) = delete; + Context(const Context &&) = delete; + Context &operator=(const Context &&) = delete; + +public: + /** + * Create a Duktape context using defaults. + */ + Context(); + + /** + * Convert the context to the native Duktape/C type. + * + * @return the duk_context + */ + inline operator duk_context *() noexcept + { + return get(); + } + + /** + * Convert the context to the native Duktape/C type. + * + * @return the duk_context + */ + inline operator duk_context *() const noexcept + { + return get(); + } +}; + +/** + * @class Object + * @brief Empty class tag for push() function + */ +class Object { +}; + +/** + * @class Arary + * @brief Empty class tag for push() function + */ +class Array { +}; + +/** + * @class Function + * @brief Duktape/C function definition + */ +class Function { +public: + /** + * The function pointer, must not be null. + */ + duk_c_function function{nullptr}; + + /** + * Number of args that the function takes + */ + duk_idx_t nargs{0}; +}; + +/** + * @class ErrorInfo + * @brief Error description + * + * This class fills the fields got in an Error object. + */ +class ErrorInfo : public std::exception { +public: + std::string name; //!< name of error + std::string message; //!< error message + std::string stack; //!< stack if available + std::string fileName; //!< filename if applicable + int lineNumber{0}; //!< line number if applicable + + /** + * Get the error message. This effectively returns message field. + * + * @return the message + */ + const char *what() const noexcept override + { + return message.c_str(); + } +}; + +/* -------------------------------------------------------- + * Push functions + * -------------------------------------------------------- */ + +/** + * Push a boolean. + * + * @param ctx the context + * @param value the boolean value + */ +void push(ContextPtr ctx, bool value); + +/** + * Push an integer. + * + * @param ctx the context + * @param value the integer value + */ +void push(ContextPtr ctx, int value); + +/** + * Push a real value. + * + * @param ctx the context + * @param value the value + */ +void push(ContextPtr ctx, double value); + +/** + * Push a string. + * + * @param ctx the context + * @param value the string + */ +void push(ContextPtr ctx, const std::string &value); + +/** + * Push a literal or C-string. + * + * @param ctx the context + * @param value the value + */ +void push(ContextPtr ctx, const char *value); + +/** + * Push a Duktape/C function. + * + * @param ctx the context + * @param function the function + */ +void push(ContextPtr ctx, const Function &function); + +/** + * Push an empty object on the stack. + * + * @param ctx the context + * @param object the empty object + */ +void push(ContextPtr ctx, const Object &object); + +/** + * Push an empty array at the top of the stack. + * + * @param ctx the context + * @param array the empty array + */ +void push(ContextPtr ctx, const Array &array); + +/* -------------------------------------------------------- + * Get functions + * -------------------------------------------------------- */ + +/** + * Get a boolean. + * + * @param ctx the context + * @param index the index + * @param value the reference where to store the value + */ +void get(ContextPtr ctx, duk_idx_t index, bool &value); + +/** + * Get an integer. + * + * @param ctx the context + * @param index the index + * @param value the reference where to store the value + */ +void get(ContextPtr ctx, duk_idx_t index, int &value); + +/** + * Get a real. + * + * @param ctx the context + * @param index the index + * @param value the reference where to store the value + */ +void get(ContextPtr ctx, duk_idx_t index, double &value); + +/** + * Get a string. + * + * @param ctx the context + * @param index the index + * @param value the reference where to store the value + */ +void get(ContextPtr ctx, duk_idx_t index, std::string &value); + +/** + * Generic template function to get a value from the stack. + * + * @param ctx the context + * @param index the index + * @return the value + */ +template <typename Type> +inline Type get(ContextPtr ctx, duk_idx_t index) +{ + Type value; + + get(ctx, index, value); + + return value; +} + +/* -------------------------------------------------------- + * Get functions (for object) + * -------------------------------------------------------- */ + +template <typename Type> +inline Type getObject(ContextPtr ctx, duk_idx_t index, const std::string &name) +{ + Type type; + + assertBegin(ctx); + duk_get_prop_string(ctx, index, name.c_str()); + get(ctx, -1, type); + duk_pop(ctx); + assertEquals(ctx); + + return type; +} + +/* -------------------------------------------------------- + * Set functions (for object) + * -------------------------------------------------------- */ + +template <typename Type> +void setObject(ContextPtr ctx, duk_idx_t index, const std::string &name, Type&& value) +{ + index = duk_normalize_index(ctx, index); + + assertBegin(ctx); + push(ctx, std::forward<Type>(value)); + duk_put_prop_string(ctx, index, name.c_str()); + assertEquals(ctx); +} + +/* -------------------------------------------------------- + * Require functions + * -------------------------------------------------------- */ + +/** + * Requires a value or throw an exception if not a boolean. + * + * @param ctx the context + * @param index the index + * @param value the reference where to store the value + */ +void require(ContextPtr ctx, duk_idx_t index, bool &value); + +/** + * Requires a value or throw an exception if not an integer. + * + * @param ctx the context + * @param index the index + * @param value the reference where to store the value + */ +void require(ContextPtr ctx, duk_idx_t index, int &value); + +/** + * Requires a value or throw an exception if not a double. + * + * @param ctx the context + * @param index the index + * @param value the reference where to store the value + */ +void require(ContextPtr ctx, duk_idx_t index, double &value); + +/** + * Requires a value or throw an exception if not a string. + * + * @param ctx the context + * @param index the index + * @param value the reference where to store string + */ +void require(ContextPtr ctx, duk_idx_t index, std::string &value); + +/** + * Generic function to require a value from the stack. + * + * @param ctx the context + * @param index the specified index + * @return the value + */ +template <typename Type> +inline Type require(ContextPtr ctx, duk_idx_t index) +{ + Type value; + + require(ctx, index, value); + + return value; +} + +/* -------------------------------------------------------- + * Basic functions + * -------------------------------------------------------- */ + +/** + * Get the type of the value at the specified index. + * + * @param ctx the context + * @param index the idnex + * @return the type + */ +duk_int_t type(ContextPtr ctx, duk_idx_t index); + +/** + * Get the current stack size. + * + * @param ctx the context + * @return the stack size + */ +int top(ContextPtr ctx); + +/** + * Pop a certain number of values from the top of the stack. + * + * @param ctx the context + * @param count the number of values to pop + * @pre count must be positive + */ +void pop(ContextPtr ctx, int count = 1); + +/** + * Check if idx1 is an instance of idx2. + * + * @param ctx the context + * @param idx1 the value to test + * @param idx2 the instance requested + * @return true if idx1 is instance of idx2 + */ +duk_bool_t instanceof(ContextPtr ctx, duk_idx_t idx1, duk_idx_t idx2); + +/** + * Call the object at the top of the stack. + * + * @param ctx the context + * @param nargs the number of arguments + * @note Non-protected + */ +void call(ContextPtr ctx, duk_idx_t nargs = 0); + +/** + * Call in protected mode the object at the top of the stack. + * + * @param ctx the context + * @param nargs the number of arguments + * @throw ErrorInfo on errors + */ +void pcall(ContextPtr ctx, duk_idx_t nargs = 0); + +/* ------------------------------------------------------------------ + * Eval functions + * ------------------------------------------------------------------ */ + +/** + * Evaluate a non-protected chunk at the top of the stack. + * + * @param ctx + */ +void eval(ContextPtr ctx); + +/** + * Evaluate a non-protected string script. + * + * @param ctx the context + * @param script the script content + */ +void evalString(ContextPtr ctx, const std::string &script); + +/** + * Evaluate a non-protected file. + * + * @param ctx the context + * @param file the file + */ +void evalFile(ContextPtr ctx, const std::string &file); + +/** + * Evaluate a protected chunk. + * + * @param ctx the context + * @throw ErrorInfo the error + */ +void peval(ContextPtr ctx); + +/** + * Evaluate a protected string script. + * + * @param ctx the context + * @param script the script content + * @throw ErrorInfo the error + */ +void pevalString(ContextPtr ctx, const std::string &script); + +/** + * Evaluate a protected file. + * + * @param ctx the context + * @param file the file + * @throw ErrorInfo the error + */ +void pevalFile(ContextPtr ctx, const std::string &file); + +/* ------------------------------------------------------------------ + * Extended functions + * ------------------------------------------------------------------ */ + +/** + * Enumerate an object or an array at the specified index. + * + * @param ctx the context + * @param index the object or array index + * @param flags the optional flags to pass to duk_enum + * @param getvalue set to true if you want to extract the value + * @param func the function to call for each properties + */ +template <typename Func> +void enumerate(ContextPtr ctx, duk_idx_t index, duk_uint_t flags, duk_bool_t getvalue, Func&& func) +{ + assertBegin(ctx); + duk_enum(ctx, index, flags); + + while (duk_next(ctx, -1, getvalue)) { + func(ctx); + duk_pop_n(ctx, 1 + (getvalue ? 1 : 0)); + } + + duk_pop(ctx); + assertEquals(ctx); +} + +/* -------------------------------------------------------- + * Global functions + * -------------------------------------------------------- */ + +/** + * Get a global value. + * + * @param ctx the context + * @param name the name of the global variable + * @return the value + */ +template <typename Type> +inline Type getGlobal(ContextPtr ctx, const std::string &name) +{ + assertBegin(ctx); + duk_get_global_string(ctx, name.c_str()); + Type value = get<Type>(ctx, -1); + duk_pop(ctx); + assertEquals(ctx); + + return value; +} + +/** + * Set a global variable. + * + * @param ctx the context + * @param name the name of the global variable + * @param type the value to set + */ +template <typename Type> +inline void setGlobal(ContextPtr ctx, const std::string &name, Type&& type) +{ + assertBegin(ctx); + push(ctx, std::forward<Type>(type)); + duk_put_global_string(ctx, name.c_str()); + assertEquals(ctx); +} + +/* ------------------------------------------------------------------ + * Exception handling + * ------------------------------------------------------------------ */ + +/** + * @class ExceptionAbstract + * @brief Base class for standard ECMAScript exceptions + * @warning Override the function create for your own exceptions + */ +class ExceptionAbstract { +protected: + std::string m_name; + std::string m_message; + +public: + /** + * Construct an exception of type name with the specified message. + * + * @param name the name (e.g TypeError) + * @param message the message + */ + ExceptionAbstract(std::string name, std::string message); + + /** + * Get the exception type name. + * + * @return the exception type + */ + const std::string &name() const noexcept; + + /** + * Create the exception on the stack. + * + * @note the default implementation search for the global variables + * @param ctx the context + */ + virtual void create(ContextPtr ctx) const noexcept; +}; + +/** + * @class Error + * @brief Base ECMAScript error class + */ +class Error : public ExceptionAbstract { +public: + Error(std::string message); +}; + +/** + * @class EvalError + * @brief Error in eval() function + */ +class EvalError : public ExceptionAbstract { +public: + EvalError(std::string message); +}; + +/** + * @class RangeError + * @brief Value is out of range + */ +class RangeError : public ExceptionAbstract { +public: + RangeError(std::string message); +}; + +/** + * @class ReferenceError + * @brief Trying to use a variable that does not exist + */ +class ReferenceError : public ExceptionAbstract { +public: + ReferenceError(std::string message); +}; + +/** + * @class SyntaxError + * @brief Syntax error in the script + */ +class SyntaxError : public ExceptionAbstract { +public: + SyntaxError(std::string message); +}; + +/** + * @class TypeError + * @brief Invalid type given + */ +class TypeError : public ExceptionAbstract { +public: + TypeError(std::string message); +}; + +/** + * @class URIError + * @brief URI manipulation failure + */ +class URIError : public ExceptionAbstract { +public: + URIError(std::string message); +}; + +/** + * Throw an ECMAScript exception. + * + * @param ctx the context + * @param ex the exception + */ +template <typename Exception> +void raise(ContextPtr ctx, const Exception &ex) +{ + ex.create(ctx); + + duk_push_string(ctx, ex.name().c_str()); + duk_put_prop_string(ctx, -2, "name"); + duk_throw(ctx); +} + +} // !js + +#endif // !_JS_H_
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/C++/tests/Js/main.cpp Mon Sep 28 13:18:14 2015 +0200 @@ -0,0 +1,393 @@ +/* + * TestJsUnicode.cpp -- test irccd JS functions + * + * Copyright (c) 2013, 2014, 2015 David Demelier <markand@malikania.fr> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <gtest/gtest.h> + +#include <Js.h> + +using namespace js; + +/* -------------------------------------------------------- + * Push & get + * -------------------------------------------------------- */ + +TEST(PushAndGet, boolean) +{ + Context context; + + push(context, true); + ASSERT_TRUE(get<bool>(context, -1)); + push(context, false); + ASSERT_FALSE(get<bool>(context, -1)); +} + +TEST(PushAndGet, integer) +{ + Context context; + + push(context, 123); + ASSERT_EQ(123, get<int>(context, -1)); + push(context, 456); + ASSERT_EQ(456, get<int>(context, -1)); +} + +TEST(PushAndGet, number) +{ + Context context; + + push(context, 10.5); + ASSERT_EQ(10.5, get<double>(context, -1)); + push(context, 50.1); + ASSERT_EQ(50.1, get<double>(context, -1)); +} + +TEST(PushAndGet, string) +{ + Context context; + + push(context, "hello world!"); + ASSERT_EQ("hello world!", get<std::string>(context, -1)); +} + +/* -------------------------------------------------------- + * Basics + * -------------------------------------------------------- */ + +TEST(Basics, global) +{ + Context context; + + // boolean + setGlobal(context, "valueBoolean", true); + ASSERT_TRUE(getGlobal<bool>(context, "valueBoolean")); + + // integer + setGlobal(context, "valueInteger", 123); + ASSERT_EQ(123, getGlobal<int>(context, "valueInteger")); +} + +TEST(Basics, top) +{ + Context context; + + int current = top(context); + push(context, true); + ASSERT_EQ(current + 1, top(context)); +} + +TEST(Basics, pop1) +{ + Context context; + + int current = top(context); + push(context, true); + pop(context); + ASSERT_EQ(current, top(context)); +} + +TEST(Basics, pop2) +{ + Context context; + + int current = top(context); + push(context, true); + push(context, true); + pop(context, 2); + ASSERT_EQ(current, top(context)); +} + +TEST(Basics, setObject) +{ + Context context; + + push(context, Object{}); + setObject(context, -1, "x", 123); + ASSERT_EQ(123, getObject<int>(context, -1, "x")); +} + +TEST(Basics, enumerate) +{ + Context context; + + push(context, Object{}); + setObject(context, -1, "x", 123); + setObject(context, -1, "y", 456); + + enumerate(context, -1, 0, true, [] (ContextPtr ctx) { + ASSERT_EQ(DUK_TYPE_STRING, duk_get_type(ctx, -2)); + ASSERT_EQ(DUK_TYPE_NUMBER, duk_get_type(ctx, -1)); + + if (get<std::string>(ctx, -2) == "x") + ASSERT_EQ(123, get<int>(ctx, -1)); + if (get<std::string>(ctx, -2) == "y") + ASSERT_EQ(456, get<int>(ctx, -1)); + }); +} + +TEST(Basics, call) +{ + Context context; + + push(context, Function{[] (ContextPtr ctx) -> duk_ret_t { + setGlobal(ctx, "x", 123); + + return 0; + }}); + call(context); + + ASSERT_EQ(123, getGlobal<int>(context, "x")); +} + +/* ------------------------------------------------------------------ + * Eval + * ------------------------------------------------------------------ */ + +TEST(Eval, simple) +{ + Context context; + + evalString(context, "x = 123;"); + ASSERT_EQ(123, getGlobal<int>(context, "x")); +} + +TEST(Eval, function) +{ + Context context; + + evalString(context, "function f() { x = 123; }; f();"); + ASSERT_EQ(123, getGlobal<int>(context, "x")); +} + +TEST(Eval, cfunction) +{ + Context context; + + setGlobal(context, "f", Function{[] (ContextPtr ctx) -> duk_idx_t { + setGlobal(ctx, "x", 123); + + return 0; + }}); + evalString(context, "f()"); + ASSERT_EQ(123, getGlobal<int>(context, "x")); +} + +/* ------------------------------------------------------------------ + * Protected eval + * ------------------------------------------------------------------ */ + +TEST(Peval, success) +{ + Context context; + + try { + pevalString(context, "x = 1"); + } catch (const ErrorInfo &info) { + FAIL() << "error unexpected: " << info.what(); + } +} + +TEST(Peval, failure) +{ + Context context; + + try { + pevalString(context, "doesnotexists()"); + + FAIL() << "expected exception"; + } catch (const ErrorInfo &) { + } +} + +/* ------------------------------------------------------------------ + * Exception handling + * ------------------------------------------------------------------ */ + +TEST(Exception, error) +{ + Context context; + + setGlobal(context, "f", Function{[] (ContextPtr ctx) -> duk_idx_t { + raise(ctx, Error{"error thrown"}); + + return 0; + }}); + evalString(context, + "try {" + " f();" + "} catch (ex) {" + " name = ex.name;" + " message = ex.message;" + " received = true;" + "}" + ); + + ASSERT_TRUE(getGlobal<bool>(context, "received")); + ASSERT_EQ("Error", getGlobal<std::string>(context, "name")); + ASSERT_EQ("error thrown", getGlobal<std::string>(context, "message")); +} + +TEST(Exception, evalError) +{ + Context context; + + setGlobal(context, "f", Function{[] (ContextPtr ctx) -> duk_idx_t { + raise(ctx, EvalError{"failed"}); + + return 0; + }}); + evalString(context, + "try {" + " f();" + "} catch (ex) {" + " name = ex.name;" + " message = ex.message;" + " received = true;" + "}" + ); + + ASSERT_TRUE(getGlobal<bool>(context, "received")); + ASSERT_EQ("EvalError", getGlobal<std::string>(context, "name")); + ASSERT_EQ("failed", getGlobal<std::string>(context, "message")); +} + +TEST(Exception, rangeError) +{ + Context context; + + setGlobal(context, "f", Function{[] (ContextPtr ctx) -> duk_idx_t { + raise(ctx, RangeError{"e2big"}); + + return 0; + }}); + evalString(context, + "try {" + " f();" + "} catch (ex) {" + " name = ex.name;" + " message = ex.message;" + " received = true;" + "}" + ); + + ASSERT_TRUE(getGlobal<bool>(context, "received")); + ASSERT_EQ("RangeError", getGlobal<std::string>(context, "name")); + ASSERT_EQ("e2big", getGlobal<std::string>(context, "message")); +} + +TEST(Exception, referenceError) +{ + Context context; + + setGlobal(context, "f", Function{[] (ContextPtr ctx) -> duk_idx_t { + raise(ctx, ReferenceError{"does not exists"}); + + return 0; + }}); + evalString(context, + "try {" + " f();" + "} catch (ex) {" + " name = ex.name;" + " message = ex.message;" + " received = true;" + "}" + ); + + ASSERT_TRUE(getGlobal<bool>(context, "received")); + ASSERT_EQ("ReferenceError", getGlobal<std::string>(context, "name")); + ASSERT_EQ("does not exists", getGlobal<std::string>(context, "message")); +} + +TEST(Exception, syntaxError) +{ + Context context; + + setGlobal(context, "f", Function{[] (ContextPtr ctx) -> duk_idx_t { + raise(ctx, SyntaxError{"missing token"}); + + return 0; + }}); + evalString(context, + "try {" + " f();" + "} catch (ex) {" + " name = ex.name;" + " message = ex.message;" + " received = true;" + "}" + ); + + ASSERT_TRUE(getGlobal<bool>(context, "received")); + ASSERT_EQ("SyntaxError", getGlobal<std::string>(context, "name")); + ASSERT_EQ("missing token", getGlobal<std::string>(context, "message")); +} + +TEST(Exception, typeError) +{ + Context context; + + setGlobal(context, "f", Function{[] (ContextPtr ctx) -> duk_idx_t { + raise(ctx, TypeError{"int requested"}); + + return 0; + }}); + evalString(context, + "try {" + " f();" + "} catch (ex) {" + " name = ex.name;" + " message = ex.message;" + " received = true;" + "}" + ); + + ASSERT_TRUE(getGlobal<bool>(context, "received")); + ASSERT_EQ("TypeError", getGlobal<std::string>(context, "name")); + ASSERT_EQ("int requested", getGlobal<std::string>(context, "message")); +} + +TEST(Exception, uriError) +{ + Context context; + + setGlobal(context, "f", Function{[] (ContextPtr ctx) -> duk_idx_t { + raise(ctx, URIError{"invalid scheme"}); + + return 0; + }}); + evalString(context, + "try {" + " f();" + "} catch (ex) {" + " name = ex.name;" + " message = ex.message;" + " received = true;" + "}" + ); + + ASSERT_TRUE(getGlobal<bool>(context, "received")); + ASSERT_EQ("URIError", getGlobal<std::string>(context, "name")); + ASSERT_EQ("invalid scheme", getGlobal<std::string>(context, "message")); +} + +int main(int argc, char **argv) +{ + testing::InitGoogleTest(&argc, argv); + + return RUN_ALL_TESTS(); +}
--- a/CMakeLists.txt Fri Jul 03 13:02:05 2015 +0200 +++ b/CMakeLists.txt Mon Sep 28 13:18:14 2015 +0200 @@ -224,9 +224,9 @@ if (CMAKE_SYSTEM_NAME MATCHES "Linux") target_link_libraries(dynlib dl) endif () - + target_compile_definitions(dynlib PRIVATE EXTENSION=\"${EXTENSION}\") - + add_library(dynlib-plugin MODULE ${code_SOURCE_DIR}/C++/tests/Dynlib/Plugin.cpp) set_target_properties(dynlib-plugin PROPERTIES PREFIX "") target_include_directories(dynlib-plugin PRIVATE ${code_SOURCE_DIR}/C++/modules/Dynlib) @@ -302,6 +302,20 @@ ) # --------------------------------------------------------- +# Js (Duktape) +# --------------------------------------------------------- + +define_module( + TARGET js + NAME Js + DIRECTORY Js + LIBRARIES duktape + SOURCES + ${code_SOURCE_DIR}/C++/modules/Js/Js.cpp + ${code_SOURCE_DIR}/C++/modules/Js/Js.h +) + +# --------------------------------------------------------- # Json # ---------------------------------------------------------
--- a/extern/CMakeLists.txt Fri Jul 03 13:02:05 2015 +0200 +++ b/extern/CMakeLists.txt Mon Sep 28 13:18:14 2015 +0200 @@ -16,4 +16,5 @@ # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. # +add_subdirectory(duktape) add_subdirectory(gtest)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extern/duktape/CMakeLists.txt Mon Sep 28 13:18:14 2015 +0200 @@ -0,0 +1,27 @@ +# +# CMakeLists.txt -- code building for common code +# +# Copyright (c) 2013, 2014, 2015 David Demelier <markand@malikania.fr> +# +# Permission to use, copy, modify, and/or distribute this software for any +# purpose with or without fee is hereby granted, provided that the above +# copyright notice and this permission notice appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +# + +add_library( + duktape + STATIC + duk_config.h + duktape.c + duktape.h +) + +target_include_directories(duktape PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extern/duktape/duk_config.h Mon Sep 28 13:18:14 2015 +0200 @@ -0,0 +1,3224 @@ +/* + * Determine platform features, select feature selection defines + * (e.g. _XOPEN_SOURCE), include system headers, and define DUK_USE_xxx + * defines which are (only) checked in Duktape internal code for + * activated features. Duktape feature selection is based on automatic + * feature detection, user supplied DUK_OPT_xxx defines, and optionally + * a "duk_custom.h" user header (if DUK_OPT_HAVE_CUSTOM_H is defined). + * + * When compiling Duktape, DUK_COMPILING_DUKTAPE is set, and this file + * is included before any system headers are included. Feature selection + * defines (e.g. _XOPEN_SOURCE) are defined here before any system headers + * are included (which is a requirement for system headers to work correctly). + * This file is responsible for including all system headers and contains + * all platform dependent cruft in general. When compiling user code, + * DUK_COMPILING_DUKTAPE is not defined, and we must avoid e.g. defining + * unnecessary feature selection defines. + * + * The general order of handling: + * - Compiler feature detection (require no includes) + * - Intermediate platform detection (-> easier platform defines) + * - Platform detection, system includes, byte order detection, etc + * - ANSI C wrappers (e.g. DUK_MEMCMP), wrappers for constants, etc + * - DUK_USE_xxx defines are resolved based on input defines + * - Duktape Date provider settings + * - Final sanity checks + * + * DUK_F_xxx are internal feature detection macros which should not be + * used outside this header. + * + * Useful resources: + * + * http://sourceforge.net/p/predef/wiki/Home/ + * http://sourceforge.net/p/predef/wiki/Architectures/ + * http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor + * http://en.wikipedia.org/wiki/C_data_types#Fixed-width_integer_types + * + * Preprocessor defines available in a particular GCC: + * + * gcc -dM -E - </dev/null # http://www.brain-dump.org/blog/entry/107 + */ + +#ifndef DUK_CONFIG_H_INCLUDED +#define DUK_CONFIG_H_INCLUDED + +/* + * Compiler features + */ + +#undef DUK_F_C99 +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) +#define DUK_F_C99 +#endif + +#undef DUK_F_CPP +#if defined(__cplusplus) +#define DUK_F_CPP +#endif + +#undef DUK_F_CPP11 +#if defined(__cplusplus) && (__cplusplus >= 201103L) +#define DUK_F_CPP11 +#endif + +/* + * Provides the duk_rdtsc() inline function (if available), limited to + * GCC C99. + * + * See: http://www.mcs.anl.gov/~kazutomo/rdtsc.html + */ + +/* XXX: more accurate detection of what gcc versions work; more inline + * asm versions for other compilers. + */ +#if defined(__GNUC__) && defined(__i386__) && defined(DUK_F_C99) && \ + !defined(__cplusplus) /* unsigned long long not standard */ +static __inline__ unsigned long long duk_rdtsc(void) { + unsigned long long int x; + __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x)); + return x; +} +#define DUK_USE_RDTSC() duk_rdtsc() +#elif defined(__GNUC__) && defined(__x86_64__) && defined(DUK_F_C99) && \ + !defined(__cplusplus) /* unsigned long long not standard */ +static __inline__ unsigned long long duk_rdtsc(void) { + unsigned hi, lo; + __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi)); + return ((unsigned long long) lo) | (((unsigned long long) hi) << 32); +} +#define DUK_USE_RDTSC() duk_rdtsc() +#else +/* not available */ +#undef DUK_USE_RDTSC +#endif + +/* + * Intermediate platform, architecture, and compiler detection. These are + * hopelessly intertwined - e.g. architecture defines depend on compiler etc. + * + * Provide easier defines for platforms and compilers which are often tricky + * or verbose to detect. The intent is not to provide intermediate defines for + * all features; only if existing feature defines are inconvenient. + */ + +/* Intel x86 (32-bit) */ +#if defined(i386) || defined(__i386) || defined(__i386__) || \ + defined(__i486__) || defined(__i586__) || defined(__i686__) || \ + defined(__IA32__) || defined(_M_IX86) || defined(__X86__) || \ + defined(_X86_) || defined(__THW_INTEL__) || defined(__I86__) +#define DUK_F_X86 +#endif + +/* AMD64 (64-bit) */ +#if defined(__amd64__) || defined(__amd64) || \ + defined(__x86_64__) || defined(__x86_64) || \ + defined(_M_X64) || defined(_M_AMD64) +#define DUK_F_X64 +#endif + +/* X32: 64-bit with 32-bit pointers (allows packed tvals). X32 support is + * not very mature yet. + * + * https://sites.google.com/site/x32abi/ + */ +#if defined(DUK_F_X64) && \ + (defined(_ILP32) || defined(__ILP32__)) +#define DUK_F_X32 +/* define only one of: DUK_F_X86, DUK_F_X32, or DUK_F_X64 */ +#undef DUK_F_X64 +#undef DUK_F_X86 +#endif + +/* ARM */ +#if defined(__arm__) || defined(__thumb__) || defined(_ARM) || defined(_M_ARM) +#define DUK_F_ARM +#endif + +/* MIPS */ +/* Related defines: __MIPSEB__, __MIPSEL__, __mips_isa_rev, __LP64__ */ +#if defined(__mips__) || defined(mips) || defined(_MIPS_ISA) || \ + defined(_R3000) || defined(_R4000) || defined(_R5900) || \ + defined(_MIPS_ISA_MIPS1) || defined(_MIPS_ISA_MIPS2) || \ + defined(_MIPS_ISA_MIPS3) || defined(_MIPS_ISA_MIPS4) || \ + defined(__mips) || defined(__MIPS__) +#define DUK_F_MIPS +#if defined(__LP64__) || defined(__mips64) || defined(__mips64__) || \ + defined(__mips_n64) +#define DUK_F_MIPS64 +#else +#define DUK_F_MIPS32 +#endif +#endif + +/* SuperH */ +#if defined(__sh__) || \ + defined(__sh1__) || defined(__SH1__) || \ + defined(__sh2__) || defined(__SH2__) || \ + defined(__sh3__) || defined(__SH3__) || \ + defined(__sh4__) || defined(__SH4__) || \ + defined(__sh5__) || defined(__SH5__) +#define DUK_F_SUPERH +#endif + +/* Motorola 68K. Not defined by VBCC, so user must define one of these + * manually when using VBCC. + */ +#if defined(__m68k__) || defined(M68000) || defined(__MC68K__) +#define DUK_F_M68K +#endif + +/* PowerPC */ +#if defined(__powerpc) || defined(__powerpc__) || defined(__PPC__) +#define DUK_F_PPC +#if defined(__PPC64__) +#define DUK_F_PPC64 +#else +#define DUK_F_PPC32 +#endif +#endif + +/* Linux */ +#if defined(__linux) || defined(__linux__) || defined(linux) +#define DUK_F_LINUX +#endif + +/* FreeBSD */ +#if defined(__FreeBSD__) || defined(__FreeBSD) +#define DUK_F_FREEBSD +#endif + +/* NetBSD */ +#if defined(__NetBSD__) || defined(__NetBSD) +#define DUK_F_NETBSD +#endif + +/* OpenBSD */ +#if defined(__OpenBSD__) || defined(__OpenBSD) +#define DUK_F_OPENBSD +#endif + +/* BSD variant */ +#if defined(DUK_F_FREEBSD) || defined(DUK_F_NETBSD) || defined(DUK_F_OPENBSD) || \ + defined(__bsdi__) || defined(__DragonFly__) +#define DUK_F_BSD +#endif + +/* Generic Unix (includes Cygwin) */ +#if defined(__unix) || defined(__unix__) || defined(unix) || \ + defined(DUK_F_LINUX) || defined(DUK_F_BSD) +#define DUK_F_UNIX +#endif + +/* Cygwin */ +#if defined(__CYGWIN__) +#define DUK_F_CYGWIN +#endif + +/* Windows (32-bit or above) */ +#if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(WIN64) || \ + defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__) +#define DUK_F_WINDOWS +#endif + +#if defined(__APPLE__) +#define DUK_F_APPLE +#endif + +/* Atari ST TOS. __TOS__ defined by PureC (which doesn't work as a target now + * because int is 16-bit, to be fixed). No platform define in VBCC apparently, + * so to use with VBCC, user must define '__TOS__' manually. + */ +#if defined(__TOS__) +#define DUK_F_TOS +#endif + +/* AmigaOS. Neither AMIGA nor __amigaos__ is defined on VBCC, so user must + * define 'AMIGA' manually. + */ +#if defined(AMIGA) || defined(__amigaos__) +#define DUK_F_AMIGAOS +#endif + +/* Flash player (e.g. Crossbridge) */ +#if defined(__FLASHPLAYER__) +#define DUK_F_FLASHPLAYER +#endif + +/* Emscripten (provided explicitly by user), improve if possible */ +#if defined(EMSCRIPTEN) +#define DUK_F_EMSCRIPTEN +#endif + +/* QNX */ +#if defined(__QNX__) +#define DUK_F_QNX +#endif + +/* TI-Nspire (using Ndless) */ +#if defined(_TINSPIRE) +#define DUK_F_TINSPIRE +#endif + +/* GCC and GCC version convenience define. */ +#if defined(__GNUC__) +#define DUK_F_GCC +#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) +/* Convenience, e.g. gcc 4.5.1 == 40501; http://stackoverflow.com/questions/6031819/emulating-gccs-builtin-unreachable */ +#define DUK_F_GCC_VERSION (__GNUC__ * 10000L + __GNUC_MINOR__ * 100L + __GNUC_PATCHLEVEL__) +#else +#error cannot figure out gcc version +#endif +#endif + +/* Clang */ +#if defined(__clang__) +#define DUK_F_CLANG +/* It seems clang also defines __GNUC__, so undo the GCC detection. */ +#if defined(DUK_F_GCC) +#undef DUK_F_GCC +#endif +#if defined(DUK_F_GCC_VERSION) +#undef DUK_F_GCC_VERSION +#endif +#endif + +/* MSVC */ +#if defined(_MSC_VER) +/* MSVC preprocessor defines: http://msdn.microsoft.com/en-us/library/b0084kay.aspx + * _MSC_FULL_VER includes the build number, but it has at least two formats, see e.g. + * BOOST_MSVC_FULL_VER in http://www.boost.org/doc/libs/1_52_0/boost/config/compiler/visualc.hpp + */ +#define DUK_F_MSVC +#if defined(_MSC_FULL_VER) +#if (_MSC_FULL_VER > 100000000) +#define DUK_F_MSVC_FULL_VER _MSC_FULL_VER +#else +#define DUK_F_MSCV_FULL_VER (_MSC_FULL_VER * 10) +#endif +#endif +#endif /* _MSC_VER */ + +/* MinGW */ +#if defined(__MINGW32__) || defined(__MINGW64__) +/* NOTE: Also GCC flags are detected (DUK_F_GCC etc). */ +#define DUK_F_MINGW +#endif + +/* BCC (Bruce's C compiler): this is a "torture target" for compilation */ +#if defined(__BCC__) || defined(__BCC_VERSION__) +#define DUK_F_BCC +#endif + +#if defined(__VBCC__) +#define DUK_F_VBCC +#endif + +/* + * Platform detection, system includes, Date provider selection. + * + * Feature selection (e.g. _XOPEN_SOURCE) must happen before any system + * headers are included. This header should avoid providing any feature + * selection defines when compiling user code (only when compiling Duktape + * itself). If a feature selection option is required for user code to + * compile correctly (e.g. it is needed for type detection), it should + * probably be -checked- here, not defined here. + * + * Date provider selection seems a bit out-of-place here, but since + * the date headers and provider functions are heavily platform + * specific, there's little point in duplicating the platform if-else + * ladder. All platform specific Date provider functions are in + * duk_bi_date.c; here we provide appropriate #defines to enable them, + * and include all the necessary system headers so that duk_bi_date.c + * compiles. Date "providers" are: + * + * NOW = getting current time (required) + * TZO = getting local time offset (required) + * PRS = parse datetime (optional) + * FMT = format datetime (optional) + * + * There's a lot of duplication here, unfortunately, because many + * platforms have similar (but not identical) headers, Date providers, + * etc. The duplication could be removed by more complicated nested + * #ifdefs, but it would then be more difficult to make fixes which + * affect only a specific platform. + * + * XXX: add a way to provide custom functions to provide the critical + * primitives; this would be convenient when porting to unknown platforms + * (rather than muck with Duktape internals). + */ + +#if defined(DUK_COMPILING_DUKTAPE) && \ + (defined(DUK_F_LINUX) || defined(DUK_F_EMSCRIPTEN)) +/* A more recent Emscripten (2014-05) seems to lack "linux" environment + * defines, so check for Emscripten explicitly. + */ +#ifndef _POSIX_C_SOURCE +#define _POSIX_C_SOURCE 200809L +#endif +#ifndef _GNU_SOURCE +#define _GNU_SOURCE /* e.g. getdate_r */ +#endif +#ifndef _XOPEN_SOURCE +#define _XOPEN_SOURCE /* e.g. strptime */ +#endif +#endif + +#if defined(DUK_F_QNX) && defined(DUK_COMPILING_DUKTAPE) +/* See: /opt/qnx650/target/qnx6/usr/include/sys/platform.h */ +#define _XOPEN_SOURCE 600 +#define _POSIX_C_SOURCE 200112L +#endif + +#undef DUK_F_MSVC_CRT_SECURE +#if defined(DUK_F_WINDOWS) && defined(_MSC_VER) +/* http://msdn.microsoft.com/en-us/library/8ef0s5kh.aspx + * http://msdn.microsoft.com/en-us/library/wd3wzwts.aspx + * Seem to be available since VS2005. + */ +#if (_MSC_VER >= 1400) +/* VS2005+, secure CRT functions are preferred. Windows Store applications + * (and probably others) should use these. + */ +#define DUK_F_MSVC_CRT_SECURE +#endif +#if (_MSC_VER < 1700) +/* VS2012+ has stdint.h, < VS2012 does not (but it's available for download). */ +#define DUK_F_NO_STDINT_H +#endif +/* Initial fix: disable secure CRT related warnings when compiling Duktape + * itself (must be defined before including Windows headers). Don't define + * for user code including duktape.h. + */ +#if defined(DUK_COMPILING_DUKTAPE) && !defined(_CRT_SECURE_NO_WARNINGS) +#define _CRT_SECURE_NO_WARNINGS +#endif +#endif /* DUK_F_WINDOWS && _MSC_VER */ + +#if defined(DUK_F_TOS) || defined(DUK_F_BCC) +#define DUK_F_NO_STDINT_H +#endif + +/* Workaround for older C++ compilers before including <inttypes.h>, + * see e.g.: https://sourceware.org/bugzilla/show_bug.cgi?id=15366 + */ +#if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS) +#define __STDC_LIMIT_MACROS +#endif +#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) +#define __STDC_CONSTANT_MACROS +#endif + +#if defined(__APPLE__) +/* Mac OSX, iPhone, Darwin */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include <TargetConditionals.h> +#include <architecture/byte_order.h> +#include <limits.h> +#include <sys/param.h> +#include <sys/time.h> +#include <time.h> +#elif defined(DUK_F_OPENBSD) +/* http://www.monkey.org/openbsd/archive/ports/0401/msg00089.html */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include <sys/types.h> +#include <sys/endian.h> +#include <limits.h> +#include <sys/param.h> +#include <sys/time.h> +#include <time.h> +#elif defined(DUK_F_BSD) +/* other BSD */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include <sys/types.h> +#include <sys/endian.h> +#include <limits.h> +#include <sys/param.h> +#include <sys/time.h> +#include <time.h> +#elif defined(DUK_F_TOS) +/* Atari ST TOS */ +#define DUK_USE_DATE_NOW_TIME +#define DUK_USE_DATE_TZO_GMTIME +/* no parsing (not an error) */ +#define DUK_USE_DATE_FMT_STRFTIME +#include <limits.h> +#include <time.h> +#elif defined(DUK_F_AMIGAOS) +#if defined(DUK_F_M68K) +/* AmigaOS on M68k */ +#define DUK_USE_DATE_NOW_TIME +#define DUK_USE_DATE_TZO_GMTIME +/* no parsing (not an error) */ +#define DUK_USE_DATE_FMT_STRFTIME +#include <limits.h> +#include <time.h> +#elif defined(DUK_F_PPC) +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include <limits.h> +#include <time.h> +#ifndef UINTPTR_MAX +#define UINTPTR_MAX UINT_MAX +#endif +#else +#error AmigaOS but not M68K/PPC, not supported now +#endif +#elif defined(DUK_F_WINDOWS) +/* Windows 32-bit and 64-bit are currently the same. */ +/* MSVC does not have sys/param.h */ +#define DUK_USE_DATE_NOW_WINDOWS +#define DUK_USE_DATE_TZO_WINDOWS +/* Note: PRS and FMT are intentionally left undefined for now. This means + * there is no platform specific date parsing/formatting but there is still + * the ISO 8601 standard format. + */ +#if defined(DUK_COMPILING_DUKTAPE) +#include <windows.h> +#endif +#include <limits.h> +#elif defined(DUK_F_FLASHPLAYER) +/* Crossbridge */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include <endian.h> +#include <limits.h> +#include <sys/param.h> +#include <sys/time.h> +#include <time.h> +#elif defined(DUK_F_QNX) +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include <sys/types.h> +#include <limits.h> +#include <sys/param.h> +#include <sys/time.h> +#include <time.h> +#elif defined(DUK_F_TINSPIRE) +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include <sys/types.h> +#include <limits.h> +#include <sys/param.h> +#include <sys/time.h> +#include <time.h> +#elif defined(DUK_F_LINUX) +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include <sys/types.h> +#if defined(DUK_F_BCC) +/* no endian.h */ +#else +#include <endian.h> +#endif /* DUK_F_BCC */ +#include <limits.h> +#include <sys/param.h> +#include <sys/time.h> +#include <time.h> +#elif defined(__posix) +/* POSIX */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include <sys/types.h> +#include <endian.h> +#include <limits.h> +#include <sys/param.h> +#include <sys/time.h> +#include <time.h> +#elif defined(DUK_F_CYGWIN) +/* Cygwin -- don't use strptime() for now */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_FMT_STRFTIME +#include <sys/types.h> +#include <endian.h> +#include <limits.h> +#include <sys/param.h> +#include <sys/time.h> +#include <time.h> +#else +/* Other UNIX, hopefully others */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include <sys/types.h> +#if defined(DUK_F_BCC) +/* no endian.h */ +#else +#include <endian.h> +#endif /* DUK_F_BCC */ +#include <limits.h> +#include <sys/param.h> +#include <sys/time.h> +#include <time.h> +#endif + +/* Shared includes */ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> /* varargs */ +#include <setjmp.h> +#include <stddef.h> /* e.g. ptrdiff_t */ +#if defined(DUK_F_NO_STDINT_H) +/* stdint.h not available */ +#else +/* Technically C99 (C++11) but found in many systems. Note the workaround + * above for some C++ compilers (__STDC_LIMIT_MACROS etc). + */ +#include <stdint.h> +#endif +#include <math.h> + +#if (defined(DUK_F_C99) || defined(DUK_F_CPP11)) && \ + !defined(DUK_F_BCC) +/* ULL / LL preprocessor constants should be avoided because they're not + * always available. With suitable options, some compilers will support + * 64-bit integer types but won't support ULL / LL preprocessor constants. + * Assume C99/C++11 environments have these. However, BCC is nominally + * C99 but doesn't support these constants. + */ +#define DUK_F_ULL_CONSTS +#endif + +/* + * Detection for specific libc variants (like uclibc) and other libc specific + * features. Potentially depends on the #includes above. + */ + +#if defined(__UCLIBC__) +#define DUK_F_UCLIBC +#endif + +/* + * Wrapper typedefs and constants for integer types, also sanity check types. + * + * C99 typedefs are quite good but not always available, and we want to avoid + * forcibly redefining the C99 typedefs. So, there are Duktape wrappers for + * all C99 typedefs and Duktape code should only use these typedefs. Type + * detection when C99 is not supported is best effort and may end up detecting + * some types incorrectly. + * + * Pointer sizes are a portability problem: pointers to different types may + * have a different size and function pointers are very difficult to manage + * portably. + * + * http://en.wikipedia.org/wiki/C_data_types#Fixed-width_integer_types + * + * Note: there's an interesting corner case when trying to define minimum + * signed integer value constants which leads to the current workaround of + * defining e.g. -0x80000000 as (-0x7fffffffL - 1L). See doc/code-issues.txt + * for a longer discussion. + * + * Note: avoid typecasts and computations in macro integer constants as they + * can then no longer be used in macro relational expressions (such as + * #if DUK_SIZE_MAX < 0xffffffffUL). There is internal code which relies on + * being able to compare DUK_SIZE_MAX against a limit. + */ + +/* XXX: add feature options to force basic types from outside? */ + +#if !defined(INT_MAX) +#error INT_MAX not defined +#endif + +/* Check that architecture is two's complement, standard C allows e.g. + * INT_MIN to be -2**31+1 (instead of -2**31). + */ +#if defined(INT_MAX) && defined(INT_MIN) +#if INT_MAX != -(INT_MIN + 1) +#error platform does not seem complement of two +#endif +#else +#error cannot check complement of two +#endif + +/* Pointer size determination based on architecture. + * XXX: unsure about BCC correctness. + */ +#if defined(DUK_F_X86) || defined(DUK_F_X32) || \ + defined(DUK_F_BCC) || \ + (defined(__WORDSIZE) && (__WORDSIZE == 32)) +#define DUK_F_32BIT_PTRS +#elif defined(DUK_F_X64) || \ + (defined(__WORDSIZE) && (__WORDSIZE == 64)) +#define DUK_F_64BIT_PTRS +#else +/* not sure, not needed with C99 anyway */ +#endif + +/* Intermediate define for 'have inttypes.h' */ +#undef DUK_F_HAVE_INTTYPES +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !(defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC)) +/* vbcc + AmigaOS has C99 but no inttypes.h */ +#define DUK_F_HAVE_INTTYPES +#elif defined(__cplusplus) && (__cplusplus >= 201103L) +/* C++11 apparently ratified stdint.h */ +#define DUK_F_HAVE_INTTYPES +#endif + +/* Basic integer typedefs and limits, preferably from inttypes.h, otherwise + * through automatic detection. + */ +#if defined(DUK_F_HAVE_INTTYPES) +/* C99 or compatible */ + +#define DUK_F_HAVE_64BIT +#include <inttypes.h> + +typedef uint8_t duk_uint8_t; +typedef int8_t duk_int8_t; +typedef uint16_t duk_uint16_t; +typedef int16_t duk_int16_t; +typedef uint32_t duk_uint32_t; +typedef int32_t duk_int32_t; +typedef uint64_t duk_uint64_t; +typedef int64_t duk_int64_t; +typedef uint_least8_t duk_uint_least8_t; +typedef int_least8_t duk_int_least8_t; +typedef uint_least16_t duk_uint_least16_t; +typedef int_least16_t duk_int_least16_t; +typedef uint_least32_t duk_uint_least32_t; +typedef int_least32_t duk_int_least32_t; +typedef uint_least64_t duk_uint_least64_t; +typedef int_least64_t duk_int_least64_t; +typedef uint_fast8_t duk_uint_fast8_t; +typedef int_fast8_t duk_int_fast8_t; +typedef uint_fast16_t duk_uint_fast16_t; +typedef int_fast16_t duk_int_fast16_t; +typedef uint_fast32_t duk_uint_fast32_t; +typedef int_fast32_t duk_int_fast32_t; +typedef uint_fast64_t duk_uint_fast64_t; +typedef int_fast64_t duk_int_fast64_t; +typedef uintptr_t duk_uintptr_t; +typedef intptr_t duk_intptr_t; +typedef uintmax_t duk_uintmax_t; +typedef intmax_t duk_intmax_t; + +#define DUK_UINT8_MIN 0 +#define DUK_UINT8_MAX UINT8_MAX +#define DUK_INT8_MIN INT8_MIN +#define DUK_INT8_MAX INT8_MAX +#define DUK_UINT_LEAST8_MIN 0 +#define DUK_UINT_LEAST8_MAX UINT_LEAST8_MAX +#define DUK_INT_LEAST8_MIN INT_LEAST8_MIN +#define DUK_INT_LEAST8_MAX INT_LEAST8_MAX +#define DUK_UINT_FAST8_MIN 0 +#define DUK_UINT_FAST8_MAX UINT_FAST8_MAX +#define DUK_INT_FAST8_MIN INT_FAST8_MIN +#define DUK_INT_FAST8_MAX INT_FAST8_MAX +#define DUK_UINT16_MIN 0 +#define DUK_UINT16_MAX UINT16_MAX +#define DUK_INT16_MIN INT16_MIN +#define DUK_INT16_MAX INT16_MAX +#define DUK_UINT_LEAST16_MIN 0 +#define DUK_UINT_LEAST16_MAX UINT_LEAST16_MAX +#define DUK_INT_LEAST16_MIN INT_LEAST16_MIN +#define DUK_INT_LEAST16_MAX INT_LEAST16_MAX +#define DUK_UINT_FAST16_MIN 0 +#define DUK_UINT_FAST16_MAX UINT_FAST16_MAX +#define DUK_INT_FAST16_MIN INT_FAST16_MIN +#define DUK_INT_FAST16_MAX INT_FAST16_MAX +#define DUK_UINT32_MIN 0 +#define DUK_UINT32_MAX UINT32_MAX +#define DUK_INT32_MIN INT32_MIN +#define DUK_INT32_MAX INT32_MAX +#define DUK_UINT_LEAST32_MIN 0 +#define DUK_UINT_LEAST32_MAX UINT_LEAST32_MAX +#define DUK_INT_LEAST32_MIN INT_LEAST32_MIN +#define DUK_INT_LEAST32_MAX INT_LEAST32_MAX +#define DUK_UINT_FAST32_MIN 0 +#define DUK_UINT_FAST32_MAX UINT_FAST32_MAX +#define DUK_INT_FAST32_MIN INT_FAST32_MIN +#define DUK_INT_FAST32_MAX INT_FAST32_MAX +#define DUK_UINT64_MIN 0 +#define DUK_UINT64_MAX UINT64_MAX +#define DUK_INT64_MIN INT64_MIN +#define DUK_INT64_MAX INT64_MAX +#define DUK_UINT_LEAST64_MIN 0 +#define DUK_UINT_LEAST64_MAX UINT_LEAST64_MAX +#define DUK_INT_LEAST64_MIN INT_LEAST64_MIN +#define DUK_INT_LEAST64_MAX INT_LEAST64_MAX +#define DUK_UINT_FAST64_MIN 0 +#define DUK_UINT_FAST64_MAX UINT_FAST64_MAX +#define DUK_INT_FAST64_MIN INT_FAST64_MIN +#define DUK_INT_FAST64_MAX INT_FAST64_MAX + +#define DUK_UINTPTR_MIN 0 +#define DUK_UINTPTR_MAX UINTPTR_MAX +#define DUK_INTPTR_MIN INTPTR_MIN +#define DUK_INTPTR_MAX INTPTR_MAX + +#define DUK_UINTMAX_MIN 0 +#define DUK_UINTMAX_MAX UINTMAX_MAX +#define DUK_INTMAX_MIN INTMAX_MIN +#define DUK_INTMAX_MAX INTMAX_MAX + +#define DUK_SIZE_MIN 0 +#define DUK_SIZE_MAX SIZE_MAX +#undef DUK_SIZE_MAX_COMPUTED + +#else /* C99 types */ + +/* When C99 types are not available, we use heuristic detection to get + * the basic 8, 16, 32, and (possibly) 64 bit types. The fast/least + * types are then assumed to be exactly the same for now: these could + * be improved per platform but C99 types are very often now available. + * 64-bit types are not available on all platforms; this is OK at least + * on 32-bit platforms. + * + * This detection code is necessarily a bit hacky and can provide typedefs + * and defines that won't work correctly on some exotic platform. + */ + +#if (defined(CHAR_BIT) && (CHAR_BIT == 8)) || \ + (defined(UCHAR_MAX) && (UCHAR_MAX == 255)) +typedef unsigned char duk_uint8_t; +typedef signed char duk_int8_t; +#else +#error cannot detect 8-bit type +#endif + +#if defined(USHRT_MAX) && (USHRT_MAX == 65535UL) +typedef unsigned short duk_uint16_t; +typedef signed short duk_int16_t; +#elif defined(UINT_MAX) && (UINT_MAX == 65535UL) +/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */ +typedef unsigned int duk_uint16_t; +typedef signed int duk_int16_t; +#else +#error cannot detect 16-bit type +#endif + +#if defined(UINT_MAX) && (UINT_MAX == 4294967295UL) +typedef unsigned int duk_uint32_t; +typedef signed int duk_int32_t; +#elif defined(ULONG_MAX) && (ULONG_MAX == 4294967295UL) +/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */ +typedef unsigned long duk_uint32_t; +typedef signed long duk_int32_t; +#else +#error cannot detect 32-bit type +#endif + +/* 64-bit type detection is a bit tricky. + * + * ULLONG_MAX is a standard define. __LONG_LONG_MAX__ and __ULONG_LONG_MAX__ + * are used by at least GCC (even if system headers don't provide ULLONG_MAX). + * Some GCC variants may provide __LONG_LONG_MAX__ but not __ULONG_LONG_MAX__. + * + * ULL / LL constants are rejected / warned about by some compilers, even if + * the compiler has a 64-bit type and the compiler/system headers provide an + * unsupported constant (ULL/LL)! Try to avoid using ULL / LL constants. + * As a side effect we can only check that e.g. ULONG_MAX is larger than 32 + * bits but can't be sure it is exactly 64 bits. Self tests will catch such + * cases. + */ +#undef DUK_F_HAVE_64BIT +#if !defined(DUK_F_HAVE_64BIT) && defined(ULONG_MAX) +#if (ULONG_MAX > 4294967295UL) +#define DUK_F_HAVE_64BIT +typedef unsigned long duk_uint64_t; +typedef signed long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && defined(ULLONG_MAX) +#if (ULLONG_MAX > 4294967295UL) +#define DUK_F_HAVE_64BIT +typedef unsigned long long duk_uint64_t; +typedef signed long long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && defined(__ULONG_LONG_MAX__) +#if (__ULONG_LONG_MAX__ > 4294967295UL) +#define DUK_F_HAVE_64BIT +typedef unsigned long long duk_uint64_t; +typedef signed long long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && defined(__LONG_LONG_MAX__) +#if (__LONG_LONG_MAX__ > 2147483647L) +#define DUK_F_HAVE_64BIT +typedef unsigned long long duk_uint64_t; +typedef signed long long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && \ + (defined(DUK_F_MINGW) || defined(DUK_F_MSVC)) +/* Both MinGW and MSVC have a 64-bit type. */ +#define DUK_F_HAVE_64BIT +typedef unsigned long duk_uint64_t; +typedef signed long duk_int64_t; +#endif +#if !defined(DUK_F_HAVE_64BIT) +/* cannot detect 64-bit type, not always needed so don't error */ +#endif + +typedef duk_uint8_t duk_uint_least8_t; +typedef duk_int8_t duk_int_least8_t; +typedef duk_uint16_t duk_uint_least16_t; +typedef duk_int16_t duk_int_least16_t; +typedef duk_uint32_t duk_uint_least32_t; +typedef duk_int32_t duk_int_least32_t; +typedef duk_uint8_t duk_uint_fast8_t; +typedef duk_int8_t duk_int_fast8_t; +typedef duk_uint16_t duk_uint_fast16_t; +typedef duk_int16_t duk_int_fast16_t; +typedef duk_uint32_t duk_uint_fast32_t; +typedef duk_int32_t duk_int_fast32_t; +#if defined(DUK_F_HAVE_64BIT) +typedef duk_uint64_t duk_uint_least64_t; +typedef duk_int64_t duk_int_least64_t; +typedef duk_uint64_t duk_uint_fast64_t; +typedef duk_int64_t duk_int_fast64_t; +#endif +#if defined(DUK_F_HAVE_64BIT) +typedef duk_uint64_t duk_uintmax_t; +typedef duk_int64_t duk_intmax_t; +#else +typedef duk_uint32_t duk_uintmax_t; +typedef duk_int32_t duk_intmax_t; +#endif + +/* Note: the funny looking computations for signed minimum 16-bit, 32-bit, and + * 64-bit values are intentional as the obvious forms (e.g. -0x80000000L) are + * -not- portable. See code-issues.txt for a detailed discussion. + */ +#define DUK_UINT8_MIN 0UL +#define DUK_UINT8_MAX 0xffUL +#define DUK_INT8_MIN (-0x80L) +#define DUK_INT8_MAX 0x7fL +#define DUK_UINT_LEAST8_MIN 0UL +#define DUK_UINT_LEAST8_MAX 0xffUL +#define DUK_INT_LEAST8_MIN (-0x80L) +#define DUK_INT_LEAST8_MAX 0x7fL +#define DUK_UINT_FAST8_MIN 0UL +#define DUK_UINT_FAST8_MAX 0xffUL +#define DUK_INT_FAST8_MIN (-0x80L) +#define DUK_INT_FAST8_MAX 0x7fL +#define DUK_UINT16_MIN 0UL +#define DUK_UINT16_MAX 0xffffUL +#define DUK_INT16_MIN (-0x7fffL - 1L) +#define DUK_INT16_MAX 0x7fffL +#define DUK_UINT_LEAST16_MIN 0UL +#define DUK_UINT_LEAST16_MAX 0xffffUL +#define DUK_INT_LEAST16_MIN (-0x7fffL - 1L) +#define DUK_INT_LEAST16_MAX 0x7fffL +#define DUK_UINT_FAST16_MIN 0UL +#define DUK_UINT_FAST16_MAX 0xffffUL +#define DUK_INT_FAST16_MIN (-0x7fffL - 1L) +#define DUK_INT_FAST16_MAX 0x7fffL +#define DUK_UINT32_MIN 0UL +#define DUK_UINT32_MAX 0xffffffffUL +#define DUK_INT32_MIN (-0x7fffffffL - 1L) +#define DUK_INT32_MAX 0x7fffffffL +#define DUK_UINT_LEAST32_MIN 0UL +#define DUK_UINT_LEAST32_MAX 0xffffffffUL +#define DUK_INT_LEAST32_MIN (-0x7fffffffL - 1L) +#define DUK_INT_LEAST32_MAX 0x7fffffffL +#define DUK_UINT_FAST32_MIN 0UL +#define DUK_UINT_FAST32_MAX 0xffffffffUL +#define DUK_INT_FAST32_MIN (-0x7fffffffL - 1L) +#define DUK_INT_FAST32_MAX 0x7fffffffL + +/* 64-bit constants. Since LL / ULL constants are not always available, + * use computed values. These values can't be used in preprocessor + * comparisons; flag them as such. + */ +#if defined(DUK_F_HAVE_64BIT) +#define DUK_UINT64_MIN ((duk_uint64_t) 0) +#define DUK_UINT64_MAX ((duk_uint64_t) -1) +#define DUK_INT64_MIN ((duk_int64_t) (~(DUK_UINT64_MAX >> 1))) +#define DUK_INT64_MAX ((duk_int64_t) (DUK_UINT64_MAX >> 1)) +#define DUK_UINT_LEAST64_MIN DUK_UINT64_MIN +#define DUK_UINT_LEAST64_MAX DUK_UINT64_MAX +#define DUK_INT_LEAST64_MIN DUK_INT64_MIN +#define DUK_INT_LEAST64_MAX DUK_INT64_MAX +#define DUK_UINT_FAST64_MIN DUK_UINT64_MIN +#define DUK_UINT_FAST64_MAX DUK_UINT64_MAX +#define DUK_INT_FAST64_MIN DUK_INT64_MIN +#define DUK_INT_FAST64_MAX DUK_INT64_MAX +#define DUK_UINT64_MIN_COMPUTED +#define DUK_UINT64_MAX_COMPUTED +#define DUK_INT64_MIN_COMPUTED +#define DUK_INT64_MAX_COMPUTED +#define DUK_UINT_LEAST64_MIN_COMPUTED +#define DUK_UINT_LEAST64_MAX_COMPUTED +#define DUK_INT_LEAST64_MIN_COMPUTED +#define DUK_INT_LEAST64_MAX_COMPUTED +#define DUK_UINT_FAST64_MIN_COMPUTED +#define DUK_UINT_FAST64_MAX_COMPUTED +#define DUK_INT_FAST64_MIN_COMPUTED +#define DUK_INT_FAST64_MAX_COMPUTED +#endif + +#if defined(DUK_F_HAVE_64BIT) +#define DUK_UINTMAX_MIN DUK_UINT64_MIN +#define DUK_UINTMAX_MAX DUK_UINT64_MAX +#define DUK_INTMAX_MIN DUK_INT64_MIN +#define DUK_INTMAX_MAX DUK_INT64_MAX +#define DUK_UINTMAX_MIN_COMPUTED +#define DUK_UINTMAX_MAX_COMPUTED +#define DUK_INTMAX_MIN_COMPUTED +#define DUK_INTMAX_MAX_COMPUTED +#else +#define DUK_UINTMAX_MIN 0UL +#define DUK_UINTMAX_MAX 0xffffffffUL +#define DUK_INTMAX_MIN (-0x7fffffffL - 1L) +#define DUK_INTMAX_MAX 0x7fffffffL +#endif + +/* This detection is not very reliable. */ +#if defined(DUK_F_32BIT_PTRS) +typedef duk_int32_t duk_intptr_t; +typedef duk_uint32_t duk_uintptr_t; +#define DUK_UINTPTR_MIN DUK_UINT32_MIN +#define DUK_UINTPTR_MAX DUK_UINT32_MAX +#define DUK_INTPTR_MIN DUK_INT32_MIN +#define DUK_INTPTR_MAX DUK_INT32_MAX +#elif defined(DUK_F_64BIT_PTRS) && defined(DUK_F_HAVE_64BIT) +typedef duk_int64_t duk_intptr_t; +typedef duk_uint64_t duk_uintptr_t; +#define DUK_UINTPTR_MIN DUK_UINT64_MIN +#define DUK_UINTPTR_MAX DUK_UINT64_MAX +#define DUK_INTPTR_MIN DUK_INT64_MIN +#define DUK_INTPTR_MAX DUK_INT64_MAX +#define DUK_UINTPTR_MIN_COMPUTED +#define DUK_UINTPTR_MAX_COMPUTED +#define DUK_INTPTR_MIN_COMPUTED +#define DUK_INTPTR_MAX_COMPUTED +#else +#error cannot determine intptr type +#endif + +/* SIZE_MAX may be missing so use an approximate value for it. */ +#undef DUK_SIZE_MAX_COMPUTED +#if !defined(SIZE_MAX) +#define DUK_SIZE_MAX_COMPUTED +#define SIZE_MAX ((size_t) (-1)) +#endif +#define DUK_SIZE_MIN 0 +#define DUK_SIZE_MAX SIZE_MAX + +#endif /* C99 types */ + +/* A few types are assumed to always exist. */ +typedef size_t duk_size_t; +typedef ptrdiff_t duk_ptrdiff_t; + +/* The best type for an "all around int" in Duktape internals is "at least + * 32 bit signed integer" which is most convenient. Same for unsigned type. + * Prefer 'int' when large enough, as it is almost always a convenient type. + */ +#if defined(UINT_MAX) && (UINT_MAX >= 0xffffffffUL) +typedef int duk_int_t; +typedef unsigned int duk_uint_t; +#define DUK_INT_MIN INT_MIN +#define DUK_INT_MAX INT_MAX +#define DUK_UINT_MIN 0 +#define DUK_UINT_MAX UINT_MAX +#else +typedef duk_int_fast32_t duk_int_t; +typedef duk_uint_fast32_t duk_uint_t; +#define DUK_INT_MIN DUK_INT_FAST32_MIN +#define DUK_INT_MAX DUK_INT_FAST32_MAX +#define DUK_UINT_MIN DUK_UINT_FAST32_MIN +#define DUK_UINT_MAX DUK_UINT_FAST32_MAX +#endif + +/* Same as 'duk_int_t' but guaranteed to be a 'fast' variant if this + * distinction matters for the CPU. These types are used mainly in the + * executor where it might really matter. + */ +typedef duk_int_fast32_t duk_int_fast_t; +typedef duk_uint_fast32_t duk_uint_fast_t; +#define DUK_INT_FAST_MIN DUK_INT_FAST32_MIN +#define DUK_INT_FAST_MAX DUK_INT_FAST32_MAX +#define DUK_UINT_FAST_MIN DUK_UINT_FAST32_MIN +#define DUK_UINT_FAST_MAX DUK_UINT_FAST32_MAX + +/* Small integers (16 bits or more) can fall back to the 'int' type, but + * have a typedef so they are marked "small" explicitly. + */ +typedef int duk_small_int_t; +typedef unsigned int duk_small_uint_t; +#define DUK_SMALL_INT_MIN INT_MIN +#define DUK_SMALL_INT_MAX INT_MAX +#define DUK_SMALL_UINT_MIN 0 +#define DUK_SMALL_UINT_MAX UINT_MAX + +/* Fast variants of small integers, again for really fast paths like the + * executor. + */ +typedef duk_int_fast16_t duk_small_int_fast_t; +typedef duk_uint_fast16_t duk_small_uint_fast_t; +#define DUK_SMALL_INT_FAST_MIN DUK_INT_FAST16_MIN +#define DUK_SMALL_INT_FAST_MAX DUK_INT_FAST16_MAX +#define DUK_SMALL_UINT_FAST_MIN DUK_UINT_FAST16_MIN +#define DUK_SMALL_UINT_FAST_MAX DUK_UINT_FAST16_MAX + +/* Boolean values are represented with the platform 'int'. */ +typedef duk_small_int_t duk_bool_t; +#define DUK_BOOL_MIN DUK_SMALL_INT_MIN +#define DUK_BOOL_MAX DUK_SMALL_INT_MAX + +/* Index values must have at least 32-bit signed range. */ +typedef duk_int_t duk_idx_t; +#define DUK_IDX_MIN DUK_INT_MIN +#define DUK_IDX_MAX DUK_INT_MAX + +/* Array index values, could be exact 32 bits. + * Currently no need for signed duk_arridx_t. + */ +typedef duk_uint_t duk_uarridx_t; +#define DUK_UARRIDX_MIN DUK_UINT_MIN +#define DUK_UARRIDX_MAX DUK_UINT_MAX + +/* Duktape/C function return value, platform int is enough for now to + * represent 0, 1, or negative error code. Must be compatible with + * assigning truth values (e.g. duk_ret_t rc = (foo == bar);). + */ +typedef duk_small_int_t duk_ret_t; +#define DUK_RET_MIN DUK_SMALL_INT_MIN +#define DUK_RET_MAX DUK_SMALL_INT_MAX + +/* Error codes are represented with platform int. High bits are used + * for flags and such, so 32 bits are needed. + */ +typedef duk_int_t duk_errcode_t; +#define DUK_ERRCODE_MIN DUK_INT_MIN +#define DUK_ERRCODE_MAX DUK_INT_MAX + +/* Codepoint type. Must be 32 bits or more because it is used also for + * internal codepoints. The type is signed because negative codepoints + * are used as internal markers (e.g. to mark EOF or missing argument). + * (X)UTF-8/CESU-8 encode/decode take and return an unsigned variant to + * ensure duk_uint32_t casts back and forth nicely. Almost everything + * else uses the signed one. + */ +typedef duk_int_t duk_codepoint_t; +typedef duk_uint_t duk_ucodepoint_t; +#define DUK_CODEPOINT_MIN DUK_INT_MIN +#define DUK_CODEPOINT_MAX DUK_INT_MAX +#define DUK_UCODEPOINT_MIN DUK_UINT_MIN +#define DUK_UCODEPOINT_MAX DUK_UINT_MAX + +/* IEEE float/double typedef. */ +typedef float duk_float_t; +typedef double duk_double_t; + +/* We're generally assuming that we're working on a platform with a 32-bit + * address space. If DUK_SIZE_MAX is a typecast value (which is necessary + * if SIZE_MAX is missing), the check must be avoided because the + * preprocessor can't do a comparison. + */ +#if !defined(DUK_SIZE_MAX) +#error DUK_SIZE_MAX is undefined, probably missing SIZE_MAX +#elif !defined(DUK_SIZE_MAX_COMPUTED) +#if DUK_SIZE_MAX < 0xffffffffUL +/* On some systems SIZE_MAX can be smaller than max unsigned 32-bit value + * which seems incorrect if size_t is (at least) an unsigned 32-bit type. + * However, it doesn't seem useful to error out compilation if this is the + * case. + */ +#endif +#endif + +/* Type for public API calls. */ +typedef struct duk_hthread duk_context; + +/* + * Check whether we should use 64-bit integers + */ + +/* Quite incomplete now. Use 64-bit types if detected (C99 or other detection) + * unless they are known to be unreliable. For instance, 64-bit types are + * available on VBCC but seem to misbehave. + */ +#if defined(DUK_F_HAVE_64BIT) && !defined(DUK_F_VBCC) +#define DUK_USE_64BIT_OPS +#else +#undef DUK_USE_64BIT_OPS +#endif + +/* + * Alignment requirement and support for unaligned accesses + * + * Assume unaligned accesses are not supported unless specifically allowed + * in the target platform. Some platforms may support unaligned accesses + * but alignment to 4 or 8 may still be desirable. + */ + +#undef DUK_USE_UNALIGNED_ACCESSES_POSSIBLE +#undef DUK_USE_ALIGN_BY + +#if defined(DUK_F_EMSCRIPTEN) +/* Required on at least some targets, so use whenever Emscripten used, + * regardless of compilation target. + */ +#define DUK_USE_ALIGN_BY 8 +#elif defined(DUK_F_ARM) +#define DUK_USE_ALIGN_BY 4 +#elif defined(DUK_F_MIPS32) +/* Based on 'make checkalign' there are no alignment requirements on + * Linux MIPS except for doubles, which need align by 4. Alignment + * requirements vary based on target though. + */ +#define DUK_USE_ALIGN_BY 4 +#elif defined(DUK_F_MIPS64) +/* Good default is a bit arbitrary because alignment requirements + * depend on target. See https://github.com/svaarala/duktape/issues/102. + */ +#define DUK_USE_ALIGN_BY 8 +#elif defined(DUK_F_SUPERH) +/* Based on 'make checkalign' there are no alignment requirements on + * Linux SH4, but align by 4 is probably a good basic default. + */ +#define DUK_USE_ALIGN_BY 4 +#elif defined(DUK_F_X86) || defined(DUK_F_X32) || defined(DUK_F_X64) || \ + defined(DUK_F_BCC) +/* XXX: This is technically not guaranteed because it's possible to configure + * an x86 to require aligned accesses with Alignment Check (AC) flag. + */ +#define DUK_USE_ALIGN_BY 1 +#define DUK_USE_UNALIGNED_ACCESSES_POSSIBLE +#else +/* Unknown, use safe default */ +#define DUK_USE_ALIGN_BY 8 +#endif + +/* User forced alignment to 4 or 8. */ +#if defined(DUK_OPT_FORCE_ALIGN) +#undef DUK_USE_ALIGN_BY +#undef DUK_USE_UNALIGNED_ACCESSES_POSSIBLE +#if (DUK_OPT_FORCE_ALIGN == 4) +#define DUK_USE_ALIGN_BY 4 +#elif (DUK_OPT_FORCE_ALIGN == 8) +#define DUK_USE_ALIGN_BY 8 +#else +#error invalid DUK_OPT_FORCE_ALIGN value +#endif +#endif + +/* Compiler specific hackery needed to force struct size to match aligment, + * see e.g. duk_hbuffer.h. + * + * http://stackoverflow.com/questions/11130109/c-struct-size-alignment + * http://stackoverflow.com/questions/10951039/specifying-64-bit-alignment + */ +#if defined(DUK_F_MSVC) +#define DUK_USE_PACK_MSVC_PRAGMA +#elif defined(DUK_F_GCC) +#define DUK_USE_PACK_GCC_ATTR +#elif defined(DUK_F_CLANG) +#define DUK_USE_PACK_CLANG_ATTR +#else +#define DUK_USE_PACK_DUMMY_MEMBER +#endif + +#ifdef DUK_USE_UNALIGNED_ACCESSES_POSSIBLE +#define DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS +#else +#undef DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS +#endif + +/* Object property allocation layout has implications for memory and code + * footprint and generated code size/speed. The best layout also depends + * on whether the platform has alignment requirements or benefits from + * having mostly aligned accesses. + */ +#undef DUK_USE_HOBJECT_LAYOUT_1 +#undef DUK_USE_HOBJECT_LAYOUT_2 +#undef DUK_USE_HOBJECT_LAYOUT_3 +#if defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE) && (DUK_USE_ALIGN_BY == 1) +/* On platforms without any alignment issues, layout 1 is preferable + * because it compiles to slightly less code and provides direct access + * to property keys. + */ +#define DUK_USE_HOBJECT_LAYOUT_1 +#else +/* On other platforms use layout 2, which requires some padding but + * is a bit more natural than layout 3 in ordering the entries. Layout + * 3 is currently not used. + */ +#define DUK_USE_HOBJECT_LAYOUT_2 +#endif + +/* + * Byte order and double memory layout detection + * + * Endianness detection is a major portability hassle because the macros + * and headers are not standardized. There's even variance across UNIX + * platforms. Even with "standard" headers, details like underscore count + * varies between platforms, e.g. both __BYTE_ORDER and _BYTE_ORDER are used + * (Crossbridge has a single underscore, for instance). + * + * The checks below are structured with this in mind: several approaches are + * used, and at the end we check if any of them worked. This allows generic + * approaches to be tried first, and platform/compiler specific hacks tried + * last. As a last resort, the user can force a specific endianness, as it's + * not likely that automatic detection will work on the most exotic platforms. + * + * Duktape supports little and big endian machines. There's also support + * for a hybrid used by some ARM machines where integers are little endian + * but IEEE double values use a mixed order (12345678 -> 43218765). This + * byte order for doubles is referred to as "mixed endian". + */ + +#undef DUK_F_BYTEORDER +#undef DUK_USE_BYTEORDER_FORCED + +/* DUK_F_BYTEORDER is set as an intermediate value when detection + * succeeds, to one of: + * 1 = little endian + * 2 = mixed (arm hybrid) endian + * 3 = big endian + */ + +/* For custom platforms allow user to define byteorder explicitly. + * Since endianness headers are not standardized, this is a useful + * workaround for custom platforms for which endianness detection + * is not directly supported. Perhaps custom hardware is used and + * user cannot submit upstream patches. + */ +#if defined(DUK_OPT_FORCE_BYTEORDER) +#if (DUK_OPT_FORCE_BYTEORDER == 1) +#define DUK_F_BYTEORDER 1 +#elif (DUK_OPT_FORCE_BYTEORDER == 2) +#define DUK_F_BYTEORDER 2 +#elif (DUK_OPT_FORCE_BYTEORDER == 3) +#define DUK_F_BYTEORDER 3 +#else +#error invalid DUK_OPT_FORCE_BYTEORDER value +#endif +#define DUK_USE_BYTEORDER_FORCED +#endif /* DUK_OPT_FORCE_BYTEORDER */ + +/* More or less standard endianness predefines provided by header files. + * The ARM hybrid case is detected by assuming that __FLOAT_WORD_ORDER + * will be big endian, see: http://lists.mysql.com/internals/443. + */ +#if !defined(DUK_F_BYTEORDER) +#if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN) || \ + defined(_BYTE_ORDER) && defined(_LITTLE_ENDIAN) && (_BYTE_ORDER == _LITTLE_ENDIAN) || \ + defined(__LITTLE_ENDIAN__) +/* Integer little endian */ +#if defined(__FLOAT_WORD_ORDER) && defined(__LITTLE_ENDIAN) && (__FLOAT_WORD_ORDER == __LITTLE_ENDIAN) || \ + defined(_FLOAT_WORD_ORDER) && defined(_LITTLE_ENDIAN) && (_FLOAT_WORD_ORDER == _LITTLE_ENDIAN) +#define DUK_F_BYTEORDER 1 +#elif defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \ + defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN) +#define DUK_F_BYTEORDER 2 +#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER) +/* Float word order not known, assume not a hybrid. */ +#define DUK_F_BYTEORDER 1 +#else +/* byte order is little endian but cannot determine IEEE double word order */ +#endif /* float word order */ +#elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN) || \ + defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && (_BYTE_ORDER == _BIG_ENDIAN) || \ + defined(__BIG_ENDIAN__) +/* Integer big endian */ +#if defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \ + defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN) +#define DUK_F_BYTEORDER 3 +#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER) +/* Float word order not known, assume not a hybrid. */ +#define DUK_F_BYTEORDER 3 +#else +/* byte order is big endian but cannot determine IEEE double word order */ +#endif /* float word order */ +#else +/* cannot determine byte order */ +#endif /* integer byte order */ +#endif /* !defined(DUK_F_BYTEORDER) */ + +/* GCC and Clang provide endianness defines as built-in predefines, with + * leading and trailing double underscores (e.g. __BYTE_ORDER__). See + * output of "make gccpredefs" and "make clangpredefs". Clang doesn't + * seem to provide __FLOAT_WORD_ORDER__. + * http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html + */ +#if !defined(DUK_F_BYTEORDER) && defined(__BYTE_ORDER__) +#if defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) +/* Integer little endian */ +#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \ + (__FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__) +#define DUK_F_BYTEORDER 1 +#elif defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \ + (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__) +#define DUK_F_BYTEORDER 2 +#elif !defined(__FLOAT_WORD_ORDER__) +/* Float word order not known, assume not a hybrid. */ +#define DUK_F_BYTEORDER 1 +#else +/* byte order is little endian but cannot determine IEEE double word order */ +#endif /* float word order */ +#elif defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) +/* Integer big endian */ +#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \ + (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__) +#define DUK_F_BYTEORDER 3 +#elif !defined(__FLOAT_WORD_ORDER__) +/* Float word order not known, assume not a hybrid. */ +#define DUK_F_BYTEORDER 3 +#else +/* byte order is big endian but cannot determine IEEE double word order */ +#endif /* float word order */ +#else +/* cannot determine byte order; __ORDER_PDP_ENDIAN__ is related to 32-bit + * integer ordering and is not relevant + */ +#endif /* integer byte order */ +#endif /* !defined(DUK_F_BYTEORDER) && defined(__BYTE_ORDER__) */ + +/* Atari ST TOS */ +#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_TOS) +#define DUK_F_BYTEORDER 3 +#endif + +/* AmigaOS on M68K or PPC */ +#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_AMIGAOS) +#if defined(DUK_F_M68K) || defined(DUK_F_PPC) +#define DUK_F_BYTEORDER 3 +#endif +#endif + +/* On Windows, assume we're little endian. Even Itanium which has a + * configurable endianness runs little endian in Windows. + */ +#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_WINDOWS) +/* XXX: verify that Windows on ARM is little endian for floating point + * values too. + */ +#define DUK_F_BYTEORDER 1 +#endif /* Windows */ + +/* Crossbridge should work with the standard byteorder #ifdefs. It doesn't + * provide _FLOAT_WORD_ORDER but the standard approach now covers that case + * too. This has been left here just in case. + */ +#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_FLASHPLAYER) +#define DUK_F_BYTEORDER 1 +#endif + +/* QNX gcc cross compiler seems to define e.g. __LITTLEENDIAN__ or __BIGENDIAN__: + * $ /opt/qnx650/host/linux/x86/usr/bin/i486-pc-nto-qnx6.5.0-gcc -dM -E - </dev/null | grep -ni endian + * 67:#define __LITTLEENDIAN__ 1 + * $ /opt/qnx650/host/linux/x86/usr/bin/mips-unknown-nto-qnx6.5.0-gcc -dM -E - </dev/null | grep -ni endian + * 81:#define __BIGENDIAN__ 1 + * $ /opt/qnx650/host/linux/x86/usr/bin/arm-unknown-nto-qnx6.5.0-gcc -dM -E - </dev/null | grep -ni endian + * 70:#define __LITTLEENDIAN__ 1 + */ +#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_QNX) +/* XXX: ARM hybrid? */ +#if defined(__LITTLEENDIAN__) +#define DUK_F_BYTEORDER 1 +#elif defined(__BIGENDIAN__) +#define DUK_F_BYTEORDER 3 +#endif +#endif + +/* Bruce's C Compiler (BCC), assume we're on x86. */ +#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_BCC) +#define DUK_F_BYTEORDER 1 +#endif + +/* Check whether or not byte order detection worked based on the intermediate + * define, and define final values. If detection failed, #error out. + */ +#if defined(DUK_F_BYTEORDER) +#if (DUK_F_BYTEORDER == 1) +#define DUK_USE_INTEGER_LE +#define DUK_USE_DOUBLE_LE +#elif (DUK_F_BYTEORDER == 2) +#define DUK_USE_INTEGER_LE /* integer endianness is little on purpose */ +#define DUK_USE_DOUBLE_ME +#elif (DUK_F_BYTEORDER == 3) +#define DUK_USE_INTEGER_BE +#define DUK_USE_DOUBLE_BE +#else +#error unsupported: byte order detection failed (internal error, should not happen) +#endif /* byte order */ +#else +#error unsupported: byte order detection failed +#endif /* defined(DUK_F_BYTEORDER) */ + +/* + * Check whether or not a packed duk_tval representation is possible. + * What's basically required is that pointers are 32-bit values + * (sizeof(void *) == 4). Best effort check, not always accurate. + * If guess goes wrong, crashes may result; self tests also verify + * the guess. + */ + +#undef DUK_USE_PACKED_TVAL_POSSIBLE + +/* Strict C99 case: DUK_UINTPTR_MAX (= UINTPTR_MAX) should be very reliable */ +#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_F_HAVE_INTTYPES) && defined(DUK_UINTPTR_MAX) +#if (DUK_UINTPTR_MAX <= 0xffffffffUL) +#define DUK_USE_PACKED_TVAL_POSSIBLE +#endif +#endif + +/* Non-C99 case, still relying on DUK_UINTPTR_MAX, as long as it is not a computed value */ +#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX) && !defined(DUK_UINTPTR_MAX_COMPUTED) +#if (DUK_UINTPTR_MAX <= 0xffffffffUL) +#define DUK_USE_PACKED_TVAL_POSSIBLE +#endif +#endif + +/* DUK_SIZE_MAX (= SIZE_MAX) is often reliable */ +#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_SIZE_MAX) && !defined(DUK_SIZE_MAX_COMPUTED) +#if DUK_SIZE_MAX <= 0xffffffffUL +#define DUK_USE_PACKED_TVAL_POSSIBLE +#endif +#endif + +/* M68K: packed always possible */ +#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_F_M68K) +#define DUK_USE_PACKED_TVAL_POSSIBLE +#endif + +/* PPC32: packed always possible */ +#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_F_PPC32) +#define DUK_USE_PACKED_TVAL_POSSIBLE +#endif + +/* With Emscripten, force unpacked duk_tval just to be safe, as it seems to + * break at least on Firefox (probably IEEE double arithmetic is not 100% + * supported, especially for NaNs). + */ +#if defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_F_EMSCRIPTEN) +#undef DUK_USE_PACKED_TVAL_POSSIBLE +#endif + +/* Microsoft Visual Studio 2010 on x64 fails the above rules and tries to + * use a packed type. Force unpacked on x64 in general. + */ +#if defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_F_X64) +#undef DUK_USE_PACKED_TVAL_POSSIBLE +#endif + +/* GCC/clang inaccurate math would break compliance and probably duk_tval, + * so refuse to compile. Relax this if -ffast-math is tested to work. + */ +#if defined(__FAST_MATH__) +#error __FAST_MATH__ defined, refusing to compile +#endif + +/* + * Detection of double constants and math related functions. Availability + * of constants and math functions is a significant porting concern. + * + * INFINITY/HUGE_VAL is problematic on GCC-3.3: it causes an overflow warning + * and there is no pragma in GCC-3.3 to disable it. Using __builtin_inf() + * avoids this problem for some reason. + */ + +#define DUK_DOUBLE_2TO32 4294967296.0 +#define DUK_DOUBLE_2TO31 2147483648.0 + +#undef DUK_USE_COMPUTED_INFINITY +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION < 40600) +/* GCC older than 4.6: avoid overflow warnings related to using INFINITY */ +#define DUK_DOUBLE_INFINITY (__builtin_inf()) +#elif defined(INFINITY) +#define DUK_DOUBLE_INFINITY ((double) INFINITY) +#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC) +#define DUK_DOUBLE_INFINITY (1.0 / 0.0) +#else +/* In VBCC (1.0 / 0.0) results in a warning and 0.0 instead of infinity. + * Use a computed infinity (initialized when a heap is created at the + * latest). + */ +extern double duk_computed_infinity; +#define DUK_USE_COMPUTED_INFINITY +#define DUK_DOUBLE_INFINITY duk_computed_infinity +#endif + +#undef DUK_USE_COMPUTED_NAN +#if defined(NAN) +#define DUK_DOUBLE_NAN NAN +#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC) +#define DUK_DOUBLE_NAN (0.0 / 0.0) +#else +/* In VBCC (0.0 / 0.0) results in a warning and 0.0 instead of NaN. + * In MSVC (VS2010 Express) (0.0 / 0.0) results in a compile error. + * Use a computed NaN (initialized when a heap is created at the + * latest). + */ +extern double duk_computed_nan; +#define DUK_USE_COMPUTED_NAN +#define DUK_DOUBLE_NAN duk_computed_nan +#endif + +/* Many platforms are missing fpclassify() and friends, so use replacements + * if necessary. The replacement constants (FP_NAN etc) can be anything but + * match Linux constants now. + */ +#undef DUK_USE_REPL_FPCLASSIFY +#undef DUK_USE_REPL_SIGNBIT +#undef DUK_USE_REPL_ISFINITE +#undef DUK_USE_REPL_ISNAN +#undef DUK_USE_REPL_ISINF + +/* Complex condition broken into separate parts. */ +#undef DUK_F_USE_REPL_ALL +#if !(defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO) && \ + defined(FP_SUBNORMAL) && defined(FP_NORMAL)) +/* Missing some obvious constants. */ +#define DUK_F_USE_REPL_ALL +#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC) +/* VBCC is missing the built-ins even in C99 mode (perhaps a header issue) */ +#define DUK_F_USE_REPL_ALL +#elif defined(DUK_F_FREEBSD) && defined(DUK_F_CLANG) +/* Placeholder fix for (detection is wider than necessary): + * http://llvm.org/bugs/show_bug.cgi?id=17788 + */ +#define DUK_F_USE_REPL_ALL +#elif defined(DUK_F_UCLIBC) +/* At least some uclibc versions have broken floating point math. For + * example, fpclassify() can incorrectly classify certain NaN formats. + * To be safe, use replacements. + */ +#define DUK_F_USE_REPL_ALL +#endif + +#if defined(DUK_F_USE_REPL_ALL) +#define DUK_USE_REPL_FPCLASSIFY +#define DUK_USE_REPL_SIGNBIT +#define DUK_USE_REPL_ISFINITE +#define DUK_USE_REPL_ISNAN +#define DUK_USE_REPL_ISINF +#define DUK_FPCLASSIFY duk_repl_fpclassify +#define DUK_SIGNBIT duk_repl_signbit +#define DUK_ISFINITE duk_repl_isfinite +#define DUK_ISNAN duk_repl_isnan +#define DUK_ISINF duk_repl_isinf +#define DUK_FP_NAN 0 +#define DUK_FP_INFINITE 1 +#define DUK_FP_ZERO 2 +#define DUK_FP_SUBNORMAL 3 +#define DUK_FP_NORMAL 4 +#else +#define DUK_FPCLASSIFY fpclassify +#define DUK_SIGNBIT signbit +#define DUK_ISFINITE isfinite +#define DUK_ISNAN isnan +#define DUK_ISINF isinf +#define DUK_FP_NAN FP_NAN +#define DUK_FP_INFINITE FP_INFINITE +#define DUK_FP_ZERO FP_ZERO +#define DUK_FP_SUBNORMAL FP_SUBNORMAL +#define DUK_FP_NORMAL FP_NORMAL +#endif + +#if defined(DUK_F_USE_REPL_ALL) +#undef DUK_F_USE_REPL_ALL +#endif + +/* Some math functions are C99 only. This is also an issue with some + * embedded environments using uclibc where uclibc has been configured + * not to provide some functions. For now, use replacements whenever + * using uclibc. + */ +#undef DUK_USE_MATH_FMIN +#undef DUK_USE_MATH_FMAX +#undef DUK_USE_MATH_ROUND +#if defined(DUK_F_UCLIBC) +/* uclibc may be missing these */ +#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC) +/* vbcc + AmigaOS may be missing these */ +#elif !defined(DUK_F_C99) && !defined(DUK_F_CPP11) +/* build is not C99 or C++11, play it safe */ +#else +/* C99 or C++11, no known issues */ +#define DUK_USE_MATH_FMIN +#define DUK_USE_MATH_FMAX +#define DUK_USE_MATH_ROUND +#endif + +/* These functions don't currently need replacement but are wrapped for + * completeness. Because these are used as function pointers, they need + * to be defined as concrete C functions (not macros). + */ +#define DUK_FABS fabs +#define DUK_FMIN fmin +#define DUK_FMAX fmax +#define DUK_FLOOR floor +#define DUK_CEIL ceil +#define DUK_FMOD fmod +#define DUK_POW pow +#define DUK_ACOS acos +#define DUK_ASIN asin +#define DUK_ATAN atan +#define DUK_ATAN2 atan2 +#define DUK_SIN sin +#define DUK_COS cos +#define DUK_TAN tan +#define DUK_EXP exp +#define DUK_LOG log +#define DUK_SQRT sqrt + +/* NetBSD 6.0 x86 (at least) has a few problems with pow() semantics, + * see test-bug-netbsd-math-pow.js. Use NetBSD specific workaround. + * (This might be a wider problem; if so, generalize the define name.) + */ +#undef DUK_USE_POW_NETBSD_WORKAROUND +#if defined(DUK_F_NETBSD) +#define DUK_USE_POW_NETBSD_WORKAROUND +#endif + +/* Rely as little as possible on compiler behavior for NaN comparison, + * signed zero handling, etc. Currently never activated but may be needed + * for broken compilers. + */ +#undef DUK_USE_PARANOID_MATH + +/* There was a curious bug where test-bi-date-canceling.js would fail e.g. + * on 64-bit Ubuntu, gcc-4.8.1, -m32, and no -std=c99. Some date computations + * using doubles would be optimized which then broke some corner case tests. + * The problem goes away by adding 'volatile' to the datetime computations. + * Not sure what the actual triggering conditions are, but using this on + * non-C99 systems solves the known issues and has relatively little cost + * on other platforms. See bugs/issue-2e9d9c2d761dabaf8136c0897b91a270d1a47147.yaml. + */ +#undef DUK_USE_PARANOID_DATE_COMPUTATION +#if !defined(DUK_F_C99) +#define DUK_USE_PARANOID_DATE_COMPUTATION +#endif + +/* + * ANSI C string/memory function wrapper defines to allow easier workarounds. + * Also convenience macros like DUK_MEMZERO which may be mapped to existing + * platform function to zero memory (like the deprecated bzero). + * + * For instance, some platforms don't support zero-size memcpy correctly, + * some arcane uclibc versions have a buggy memcpy (but working memmove) + * and so on. Such broken platforms can be dealt with here. + * + * NOTE: ANSI C (various versions) and some implementations require that the + * pointer arguments to memset(), memcpy(), and memmove() be valid values + * even when byte size is 0 (even a NULL pointer is considered invalid in + * this context). Zero-size operations as such are allowed, as long as their + * pointer arguments point to a valid memory area. The DUK_MEMSET(), + * DUK_MEMCPY(), and DUK_MEMMOVE() macros require this same behavior, i.e.: + * (1) pointers must be valid and non-NULL, (2) zero size must otherwise be + * allowed. If these are not fulfilled, a macro wrapper is needed. + * + * http://stackoverflow.com/questions/5243012/is-it-guaranteed-to-be-safe-to-perform-memcpy0-0-0 + * http://lists.cs.uiuc.edu/pipermail/llvmdev/2007-October/011065.html + * + * Not sure what's the required behavior when a pointer points just past the + * end of a buffer, which often happens in practice (e.g. zero size memmoves). + * For example, if allocation size is 3, the following pointer would not + * technically point to a valid memory byte: + * + * <-- alloc --> + * | 0 | 1 | 2 | ..... + * ^-- p=3, points after last valid byte (2) + * + * If this is a practical issue, wrappers are again needed. + */ + +typedef FILE duk_file; +#define DUK_STDIN stdin +#define DUK_STDOUT stdout +#define DUK_STDERR stderr + +/* Special naming to avoid conflict with e.g. DUK_FREE() in duk_heap.h + * (which is unfortunately named). + */ +#define DUK_ANSI_MALLOC malloc +#define DUK_ANSI_REALLOC realloc +#define DUK_ANSI_CALLOC calloc +#define DUK_ANSI_FREE free + +/* Old uclibcs have a broken memcpy so use memmove instead (this is overly + * wide now on purpose): + * http://lists.uclibc.org/pipermail/uclibc-cvs/2008-October/025511.html + */ +#if defined(DUK_F_UCLIBC) +#define DUK_MEMCPY memmove +#else +#define DUK_MEMCPY memcpy +#endif + +#define DUK_MEMMOVE memmove +#define DUK_MEMCMP memcmp +#define DUK_MEMSET memset +#define DUK_STRLEN strlen +#define DUK_STRCMP strcmp +#define DUK_STRNCMP strncmp +#define DUK_PRINTF printf +#define DUK_FPRINTF fprintf +#define DUK_SPRINTF sprintf + +#if defined(DUK_F_MSVC) +/* _snprintf() does NOT NUL terminate on truncation, but Duktape code never + * assumes that. + * http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010 + */ +#define DUK_SNPRINTF _snprintf +#else +#define DUK_SNPRINTF snprintf +#endif + +#define DUK_VSPRINTF vsprintf + +#if defined(DUK_F_MSVC) +#if (_MSC_VER < 1600) +/* Older MSVC version are missing vsnprintf() but have _vsnprintf(). */ +#define DUK_VSNPRINTF _vsnprintf +#else +#define DUK_VSNPRINTF vsnprintf +#endif +#else +#define DUK_VSNPRINTF vsnprintf +#endif /* DUK_F_MSVC */ + +#define DUK_SSCANF sscanf +#define DUK_VSSCANF vsscanf +#define DUK_FOPEN fopen +#define DUK_FCLOSE fclose +#define DUK_FREAD fread +#define DUK_FWRITE fwrite +#define DUK_FSEEK fseek +#define DUK_FTELL ftell +#define DUK_FFLUSH fflush +#define DUK_FPUTC fputc + +#define DUK_MEMZERO(p,n) \ + DUK_MEMSET((p), 0, (n)) + +/* + * Vararg macro wrappers. We need va_copy() which is defined in C99 / C++11, + * so an awkward replacement is needed for pre-C99 / pre-C++11 environments. + * This will quite likely need portability hacks for some non-C99 environments. + */ + +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +/* C99 / C++11 and above: rely on va_copy() which is required. + * Omit parenthesis on macro right side on purpose to minimize differences + * to direct use. + */ +#define DUK_VA_COPY(dest,src) va_copy(dest,src) +#elif defined(DUK_F_GCC) || defined(DUK_F_CLANG) +/* GCC: assume we have __va_copy() in non-C99 mode, which should be correct + * for even quite old GCC versions. Clang matches GCC behavior. + */ +#define DUK_VA_COPY(dest,src) __va_copy(dest,src) +#else +/* Pre-C99: va_list type is implementation dependent. This replacement + * assumes it is a plain value so that a simple assignment will work. + * This is not the case on all platforms (it may be a single-array element, + * for instance). + */ +#define DUK_VA_COPY(dest,src) do { (dest) = (src); } while (0) +#endif + +/* + * Miscellaneous ANSI C or other platform wrappers. + */ + +#define DUK_ABORT abort +#define DUK_EXIT exit + +/* + * Avoiding platform function pointers. + * + * On some platforms built-in functions may be implemented as macros or + * inline functions, so they can't be necessarily addressed by function + * pointers. This is certainly the case with some platform "polyfills" + * which provide missing C99/C++11 functions through macros, and may be + * the case with VS2013 (see GH-17). + */ + +/* This is now the default: the cost in footprint is negligible. */ +#define DUK_USE_AVOID_PLATFORM_FUNCPTRS + +/* + * Macro hackery to convert e.g. __LINE__ to a string without formatting, + * see: http://stackoverflow.com/questions/240353/convert-a-preprocessor-token-to-a-string + */ + +#define DUK_F_STRINGIFY_HELPER(x) #x +#define DUK_MACRO_STRINGIFY(x) DUK_F_STRINGIFY_HELPER(x) + +/* + * Cause segfault macro. + * + * This is optionally used by panic handling to cause the program to segfault + * (instead of e.g. abort()) on panic. Valgrind will then indicate the C + * call stack leading to the panic. + */ + +#define DUK_CAUSE_SEGFAULT() do { \ + *((volatile duk_uint32_t *) NULL) = (duk_uint32_t) 0xdeadbeefUL; \ + } while (0) + +/* + * Macro for suppressing warnings for potentially unreferenced variables. + * The variables can be actually unreferenced or unreferenced in some + * specific cases only; for instance, if a variable is only debug printed, + * it is unreferenced when debug printing is disabled. + * + * (Introduced here because it's potentially compiler specific.) + */ + +#define DUK_UNREF(x) do { \ + (void) (x); \ + } while (0) + +/* + * DUK_NORETURN: macro for declaring a 'noreturn' function. + * Unfortunately the noreturn declaration may appear in various + * places of a function declaration, so the solution is to wrap + * the entire declaration inside the macro. Compiler support + * for using a noreturn declaration on function pointers varies; + * this macro must only be used for actual function declarations. + * + * http://gcc.gnu.org/onlinedocs/gcc-4.3.2//gcc/Function-Attributes.html + * http://clang.llvm.org/docs/LanguageExtensions.html + */ + +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 20500L) +/* since gcc-2.5 */ +#define DUK_NORETURN(decl) decl __attribute__((noreturn)) +#elif defined(__clang__) +/* syntax same as gcc */ +#define DUK_NORETURN(decl) decl __attribute__((noreturn)) +#elif defined(DUK_F_MSVC) +/* http://msdn.microsoft.com/en-us/library/aa235362(VS.60).aspx */ +#define DUK_NORETURN(decl) __declspec(noreturn) decl +#else +/* Don't know how to declare a noreturn function, so don't do it; this + * may cause some spurious compilation warnings (e.g. "variable used + * uninitialized"). + */ +#define DUK_NORETURN(decl) decl +#endif + +/* + * Macro for stating that a certain line cannot be reached. + * + * http://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/Other-Builtins.html#Other-Builtins + * http://clang.llvm.org/docs/LanguageExtensions.html + */ + +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L) +/* since gcc-4.5 */ +#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while(0) +#elif defined(__clang__) && defined(__has_builtin) +#if __has_builtin(__builtin_unreachable) +/* same as gcc */ +#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while(0) +#endif +#else +/* unknown */ +#endif + +#if !defined(DUK_UNREACHABLE) +/* Don't know how to declare unreachable point, so don't do it; this + * may cause some spurious compilation warnings (e.g. "variable used + * uninitialized"). + */ +#define DUK_UNREACHABLE() /* unreachable */ +#endif + +/* + * Likely and unlikely branches. Using these is not at all a clear cut case, + * so the selection is a two-step process: (1) DUK_USE_BRANCH_HINTS is set + * if the architecture, compiler etc make it useful to use the hints, and (2) + * a separate check determines how to do them. + * + * These macros expect the argument to be a relational expression with an + * integer value. If used with pointers, you should use an explicit check + * like: + * + * if (DUK_LIKELY(ptr != NULL)) { ... } + * + * instead of: + * + * if (DUK_LIKELY(ptr)) { ... } + * + * http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html (__builtin_expect) + */ + +/* pretty much a placeholder now */ +#if defined(DUK_F_GCC) +#define DUK_USE_BRANCH_HINTS +#elif defined(DUK_F_CLANG) +#define DUK_USE_BRANCH_HINTS +#else +#undef DUK_USE_BRANCH_HINTS +#endif + +#if defined(DUK_USE_BRANCH_HINTS) +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L) +/* GCC: test not very accurate; enable only in relatively recent builds + * because of bugs in gcc-4.4 (http://lists.debian.org/debian-gcc/2010/04/msg00000.html) + */ +#define DUK_LIKELY(x) __builtin_expect((x), 1) +#define DUK_UNLIKELY(x) __builtin_expect((x), 0) +#elif defined(DUK_F_CLANG) +#define DUK_LIKELY(x) __builtin_expect((x), 1) +#define DUK_UNLIKELY(x) __builtin_expect((x), 0) +#endif +#endif /* DUK_USE_BRANCH_HINTS */ + +#if !defined(DUK_LIKELY) +#define DUK_LIKELY(x) (x) +#endif +#if !defined(DUK_UNLIKELY) +#define DUK_UNLIKELY(x) (x) +#endif + +/* + * Function inlining control + * + * DUK_NOINLINE: avoid inlining a function. + * DUK_INLINE: suggest inlining a function. + * DUK_ALWAYS_INLINE: force inlining for critical functions. + * + * Apply to function definition only (not declaration). + */ + +#if defined(DUK_F_CLANG) && (defined(DUK_F_C99) || defined(DUK_F_CPP11)) +#define DUK_NOINLINE __attribute__((noinline)) +#define DUK_INLINE inline +#define DUK_ALWAYS_INLINE inline __attribute__((always_inline)) +#elif defined(DUK_F_GCC) && defined(DUK_F_GCC_VERSION) && (defined(DUK_F_C99) || defined(DUK_F_CPP11)) +#if (DUK_F_GCC_VERSION >= 30101) +#define DUK_NOINLINE __attribute__((noinline)) +#define DUK_INLINE inline +#define DUK_ALWAYS_INLINE inline __attribute__((always_inline)) +#endif +#endif + +#if !defined(DUK_NOINLINE) +#define DUK_NOINLINE /*nop*/ +#define DUK_INLINE /*nop*/ +#define DUK_ALWAYS_INLINE /*nop*/ +#endif + +/* Temporary workaround for GH-323: avoid inlining control when + * compiling from multiple sources, as it causes compiler trouble. + */ +#if !defined(DUK_SINGLE_FILE) +#undef DUK_NOINLINE +#undef DUK_INLINE +#undef DUK_ALWAYS_INLINE +#define DUK_NOINLINE /*nop*/ +#define DUK_INLINE /*nop*/ +#define DUK_ALWAYS_INLINE /*nop*/ +#endif + +/* + * Symbol visibility macros + * + * To avoid C++ declaration issues (see GH-63): + * + * - Don't use DUK_LOCAL_DECL for local -data symbols- so that you don't + * end up with both a "static" declaration and a definition. + * + * - Wrap any DUK_INTERNAL_DECL with a '#if !defined(DUK_SINGLE_FILE)' + * so that the internal declarations (which would map to "static" in + * a single file distribution) get dropped. + */ + +/* XXX: user override for these? user override for just using the default visibility macros? */ +/* XXX: separate macros for function and data may be necessary at some point. */ + +#if defined(DUK_F_GCC_VERSION) +#if (DUK_F_GCC_VERSION >= 40000) && !(defined(DUK_F_MINGW) || defined(DUK_F_CYGWIN)) +/* Might work on earlier versions too but limit to GCC 4+. + * MinGW should use Windows specific __declspec or no visibility attributes at all, + * otherwise: "warning: visibility attribute not supported in this configuration; ignored". + * Same applies to Cygwin GCC. + */ +#define DUK_F_GCC_SYMBOL_VISIBILITY +#endif +#endif +#if defined(DUK_F_CLANG) && !defined(DUK_F_GCC_SYMBOL_VISIBILITY) +#define DUK_F_GCC_SYMBOL_VISIBILITY +#endif +#if defined(DUK_OPT_DLL_BUILD) && defined(_WIN32) && (defined(_MSC_VER) || defined(__GNUC__)) +/* __declspec(dllexport) and __declspec(dllimport) only for Windows DLL build. + * MSVC: any minimum version? + * MinGW: no minimum version, even gcc-2.95.3 supported dllimport/dllexport. +*/ +#define DUK_F_MSVC_DLL_SYMBOL_VISIBILITY +#endif + +#if defined(DUK_F_GCC_SYMBOL_VISIBILITY) +/* GCC 4+ visibility attributes. */ +#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern +#define DUK_EXTERNAL __attribute__ ((visibility("default"))) +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else +#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern +#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) +#endif +#elif defined(DUK_F_MSVC_DLL_SYMBOL_VISIBILITY) +/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're + * compiling Duktape or the application. + */ +#if defined(DUK_COMPILING_DUKTAPE) +#define DUK_EXTERNAL_DECL extern __declspec(dllexport) +#define DUK_EXTERNAL __declspec(dllexport) +#else +#define DUK_EXTERNAL_DECL extern __declspec(dllimport) +#define DUK_EXTERNAL should_not_happen +#endif +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else +#define DUK_INTERNAL_DECL extern +#define DUK_INTERNAL /*empty*/ +#endif +#else +/* Default visibility. */ +#define DUK_EXTERNAL_DECL extern +#define DUK_EXTERNAL /*empty*/ +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else /* DUK_SINGLE_FILE */ +#define DUK_INTERNAL_DECL extern +#define DUK_INTERNAL /*empty*/ +#endif +#endif + +/* For now, these are shared. */ +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static + +/* + * __FILE__, __LINE__, __func__ are wrapped. Especially __func__ is a + * problem because it is not available even in some compilers which try + * to be C99 compatible (e.g. VBCC with -c99 option). + */ + +#define DUK_FILE_MACRO __FILE__ + +#define DUK_LINE_MACRO __LINE__ + +#if !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) +#define DUK_FUNC_MACRO __func__ +#else +#define DUK_FUNC_MACRO "unknown" +#endif + +/* + * Byteswap macros + * + * These are here so that inline assembly or other platform functions can be + * used if available. + */ + +#define DUK_BSWAP32(x) \ + ((((duk_uint32_t) (x)) >> 24) | \ + ((((duk_uint32_t) (x)) >> 8) & 0xff00UL) | \ + ((((duk_uint32_t) (x)) << 8) & 0xff0000UL) | \ + (((duk_uint32_t) (x)) << 24)) + +#define DUK_BSWAP16(x) \ + ((duk_uint16_t) (x) >> 8) | \ + ((duk_uint16_t) (x) << 8) + +/* + * Architecture string, human readable value exposed in Duktape.env + */ + +#if defined(DUK_F_X86) +#define DUK_USE_ARCH_STRING "x86" +#elif defined(DUK_F_X32) +#define DUK_USE_ARCH_STRING "x32" +#elif defined(DUK_F_X64) +#define DUK_USE_ARCH_STRING "x64" +#elif defined(DUK_F_ARM) +#define DUK_USE_ARCH_STRING "arm" +#elif defined(DUK_F_MIPS32) +#define DUK_USE_ARCH_STRING "mips32" +#elif defined(DUK_F_MIPS64) +#define DUK_USE_ARCH_STRING "mips64" +#elif defined(DUK_F_SUPERH) +#define DUK_USE_ARCH_STRING "sh" +#elif defined(DUK_F_PPC) +#define DUK_USE_ARCH_STRING "ppc" +#elif defined(DUK_F_M68K) +#define DUK_USE_ARCH_STRING "m68k" +#elif defined(DUK_F_FLASHPLAYER) +#define DUK_USE_ARCH_STRING "flashplayer" +#elif defined(DUK_F_EMSCRIPTEN) +#define DUK_USE_ARCH_STRING "emscripten" +#else +#define DUK_USE_ARCH_STRING "unknown" +#endif + +/* + * OS string, human readable value exposed in Duktape.env + */ + +#if defined(DUK_F_LINUX) +#define DUK_USE_OS_STRING "linux" +#elif defined(__APPLE__) +/* http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor */ +#if TARGET_IPHONE_SIMULATOR +#define DUK_USE_OS_STRING "iphone-sim" +#elif TARGET_OS_IPHONE +#define DUK_USE_OS_STRING "iphone" +#elif TARGET_OS_MAC +#define DUK_USE_OS_STRING "ios" +#else +#define DUK_USE_OS_STRING "ios-unknown" +#endif +#elif defined(DUK_F_FREEBSD) +#define DUK_USE_OS_STRING "freebsd" +#elif defined(DUK_F_OPENBSD) +#define DUK_USE_OS_STRING "openbsd" +#elif defined(DUK_F_NETBSD) +#define DUK_USE_OS_STRING "netbsd" +#elif defined(DUK_F_BSD) +#define DUK_USE_OS_STRING "bsd" +#elif defined(DUK_F_UNIX) +#define DUK_USE_OS_STRING "unix" +#elif defined(DUK_F_WINDOWS) +#define DUK_USE_OS_STRING "windows" +#elif defined(DUK_F_TOS) +#define DUK_USE_OS_STRING "tos" +#elif defined(DUK_F_AMIGAOS) +#define DUK_USE_OS_STRING "amigaos" +#elif defined(DUK_F_QNX) +#define DUK_USE_OS_STRING "qnx" +#elif defined(DUK_F_TINSPIRE) +#define DUK_USE_OS_STRING "tinspire" +#else +#define DUK_USE_OS_STRING "unknown" +#endif + +/* + * Compiler string, human readable value exposed in Duktape.env + */ + +#if defined(DUK_F_MINGW) +#define DUK_USE_COMPILER_STRING "mingw" +#elif defined(DUK_F_GCC) +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "g++" +#else +#define DUK_USE_COMPILER_STRING "gcc" +#endif +#elif defined(DUK_F_CLANG) +#define DUK_USE_COMPILER_STRING "clang" +#elif defined(DUK_F_MSVC) +#define DUK_USE_COMPILER_STRING "msvc" +#elif defined(DUK_F_VBCC) +#define DUK_USE_COMPILER_STRING "vbcc" +#else +#define DUK_USE_COMPILER_STRING "unknown" +#endif + +/* + * Target info string + */ + +#if defined(DUK_OPT_TARGET_INFO) +#define DUK_USE_TARGET_INFO DUK_OPT_TARGET_INFO +#else +#define DUK_USE_TARGET_INFO "unknown" +#endif + +/* + * Long control transfer, setjmp/longjmp or alternatives + * + * Signal mask is not saved (when that can be communicated to the platform) + */ + +/* dummy non-zero value to be used as an argument for longjmp(), see man longjmp */ +#define DUK_LONGJMP_DUMMY_VALUE 1 + +#if defined(DUK_OPT_SETJMP) +#define DUK_USE_SETJMP +#elif defined(DUK_OPT_UNDERSCORE_SETJMP) +#define DUK_USE_UNDERSCORE_SETJMP +#elif defined(DUK_OPT_SIGSETJMP) +#define DUK_USE_SIGSETJMP +#elif defined(__APPLE__) +/* Use _setjmp() on Apple by default, see GH-55. */ +#define DUK_USE_UNDERSCORE_SETJMP +#else +/* The most portable default is setjmp(). */ +#define DUK_USE_SETJMP +#endif + +#if defined(DUK_USE_UNDERSCORE_SETJMP) +#define DUK_SETJMP(jb) _setjmp((jb)) +#define DUK_LONGJMP(jb) _longjmp((jb), DUK_LONGJMP_DUMMY_VALUE) +#elif defined(DUK_USE_SIGSETJMP) +#define DUK_SETJMP(jb) sigsetjmp((jb), 0 /*savesigs*/) +#define DUK_LONGJMP(jb) siglongjmp((jb), DUK_LONGJMP_DUMMY_VALUE) +#elif defined(DUK_USE_SETJMP) +#define DUK_SETJMP(jb) setjmp((jb)) +#define DUK_LONGJMP(jb) longjmp((jb), DUK_LONGJMP_DUMMY_VALUE) +#else +#error internal error +#endif + +/* + * Speed/size and other performance options + */ + +/* Use fast ("inline") refcount operations instead of calling out to helpers + * by default. The difference in binary size is small (~1kB on x64). + */ +#define DUK_USE_FAST_REFCOUNT_DEFAULT + +/* Assert for valstack space but don't check for it in non-assert build. + * Valstack overruns (writing beyond checked space) is memory unsafe and + * potentially a segfault. Produces a smaller and faster binary. + * (In practice the speed difference is small with -O3 so default to + * safer behavior for now.) + */ +#undef DUK_USE_VALSTACK_UNSAFE + +/* Catch-all flag which can be used to choose between variant algorithms + * where a speed-size tradeoff exists (e.g. lookup tables). When it really + * matters, specific use flags may be appropriate. + */ +#define DUK_USE_PREFER_SIZE + +/* Use a sliding window for lexer; slightly larger footprint, slightly faster. */ +#define DUK_USE_LEXER_SLIDING_WINDOW + +/* Transparent JSON.stringify() fastpath. */ +#undef DUK_USE_JSON_STRINGIFY_FASTPATH +#if defined(DUK_OPT_JSON_STRINGIFY_FASTPATH) +#define DUK_USE_JSON_STRINGIFY_FASTPATH +#endif + +/* + * Tagged type representation (duk_tval) + */ + +#undef DUK_USE_PACKED_TVAL +#undef DUK_USE_FULL_TVAL + +#if defined(DUK_USE_PACKED_TVAL_POSSIBLE) && !defined(DUK_OPT_NO_PACKED_TVAL) +#define DUK_USE_PACKED_TVAL +#endif + +/* Support for 48-bit signed integer duk_tval with transparent semantics. */ +#undef DUK_USE_FASTINT +#if defined(DUK_OPT_FASTINT) +#if !defined(DUK_F_HAVE_64BIT) +#error DUK_OPT_FASTINT requires 64-bit integer type support at the moment +#endif +#define DUK_USE_FASTINT +#endif + +/* + * Memory management options + */ + +#define DUK_USE_REFERENCE_COUNTING +#define DUK_USE_DOUBLE_LINKED_HEAP +#define DUK_USE_MARK_AND_SWEEP +#define DUK_USE_MS_STRINGTABLE_RESIZE + +#if defined(DUK_OPT_NO_REFERENCE_COUNTING) +#undef DUK_USE_REFERENCE_COUNTING +#undef DUK_USE_DOUBLE_LINKED_HEAP +/* XXX: undef DUK_USE_MS_STRINGTABLE_RESIZE as it is more expensive + * with more frequent mark-and-sweeps? + */ +#endif + +#if defined(DUK_OPT_NO_MARK_AND_SWEEP) +#undef DUK_USE_MARK_AND_SWEEP +#endif + +#if defined(DUK_USE_MARK_AND_SWEEP) +#define DUK_USE_VOLUNTARY_GC +#if defined(DUK_OPT_NO_VOLUNTARY_GC) +#undef DUK_USE_VOLUNTARY_GC +#endif +#endif + +#if !defined(DUK_USE_MARK_AND_SWEEP) && !defined(DUK_USE_REFERENCE_COUNTING) +#error must have either mark-and-sweep or reference counting enabled +#endif + +#if defined(DUK_OPT_NO_MS_STRINGTABLE_RESIZE) +#undef DUK_USE_MS_STRINGTABLE_RESIZE +#endif + +#undef DUK_USE_GC_TORTURE +#if defined(DUK_OPT_GC_TORTURE) +#define DUK_USE_GC_TORTURE +#endif + +/* + * String table options + */ + +#if defined(DUK_OPT_STRTAB_CHAIN) && defined(DUK_OPT_STRTAB_CHAIN_SIZE) +/* Low memory algorithm: separate chaining using arrays, fixed size hash */ +#define DUK_USE_STRTAB_CHAIN +#define DUK_USE_STRTAB_CHAIN_SIZE DUK_OPT_STRTAB_CHAIN_SIZE +#else +/* Default algorithm: open addressing (probing) */ +#define DUK_USE_STRTAB_PROBE +#endif + +/* + * Error handling options + */ + +#define DUK_USE_AUGMENT_ERROR_CREATE +#define DUK_USE_AUGMENT_ERROR_THROW +#define DUK_USE_TRACEBACKS +#define DUK_USE_ERRCREATE +#define DUK_USE_ERRTHROW + +#define DUK_USE_VERBOSE_ERRORS + +#if defined(DUK_OPT_NO_AUGMENT_ERRORS) +#undef DUK_USE_AUGMENT_ERROR_CREATE +#undef DUK_USE_AUGMENT_ERROR_THROW +#undef DUK_USE_TRACEBACKS +#undef DUK_USE_ERRCREATE +#undef DUK_USE_ERRTHROW +#elif defined(DUK_OPT_NO_TRACEBACKS) +#undef DUK_USE_TRACEBACKS +#endif + +#if defined(DUK_OPT_NO_VERBOSE_ERRORS) +#undef DUK_USE_VERBOSE_ERRORS +#endif + +#if defined(DUK_USE_TRACEBACKS) +#if defined(DUK_OPT_TRACEBACK_DEPTH) +#define DUK_USE_TRACEBACK_DEPTH DUK_OPT_TRACEBACK_DEPTH +#else +#define DUK_USE_TRACEBACK_DEPTH 10 +#endif +#endif + +/* Include messages in executor internal errors. */ +#define DUK_USE_VERBOSE_EXECUTOR_ERRORS + +/* + * Execution and debugger options + */ + +#undef DUK_USE_INTERRUPT_COUNTER +#if defined(DUK_OPT_INTERRUPT_COUNTER) +#define DUK_USE_INTERRUPT_COUNTER +#endif + +#undef DUK_USE_EXEC_TIMEOUT_CHECK +#if defined(DUK_OPT_EXEC_TIMEOUT_CHECK) +#define DUK_USE_EXEC_TIMEOUT_CHECK(udata) DUK_OPT_EXEC_TIMEOUT_CHECK((udata)) +#endif + +#undef DUK_USE_DEBUGGER_SUPPORT +#if defined(DUK_OPT_DEBUGGER_SUPPORT) +#define DUK_USE_DEBUGGER_SUPPORT +#endif + +#undef DUK_USE_DEBUGGER_FWD_PRINTALERT +#if defined(DUK_OPT_DEBUGGER_SUPPORT) && defined(DUK_OPT_DEBUGGER_FWD_PRINTALERT) +#define DUK_USE_DEBUGGER_FWD_PRINTALERT +#endif + +#undef DUK_USE_DEBUGGER_FWD_LOGGING +#if defined(DUK_OPT_DEBUGGER_SUPPORT) && defined(DUK_OPT_DEBUGGER_FWD_LOGGING) +#define DUK_USE_DEBUGGER_FWD_LOGGING +#endif + +/* DumpHeap is optional because it's not always needed and has a relatively + * large footprint. + */ +#undef DUK_USE_DEBUGGER_DUMPHEAP +#if defined(DUK_OPT_DEBUGGER_DUMPHEAP) +#define DUK_USE_DEBUGGER_DUMPHEAP +#endif + +/* Debugger transport read/write torture. */ +#undef DUK_USE_DEBUGGER_TRANSPORT_TORTURE +#if defined(DUK_OPT_DEBUGGER_TRANSPORT_TORTURE) +#define DUK_USE_DEBUGGER_TRANSPORT_TORTURE +#endif + +/* For opcodes with indirect indices, check final index against stack size. + * This should not be necessary because the compiler is trusted, and we don't + * bound check non-indirect indices either. + */ +#undef DUK_USE_EXEC_INDIRECT_BOUND_CHECK +#if defined(DUK_OPT_DEBUG) || defined(DUK_OPT_ASSERTIONS) +/* Enabled with debug/assertions just so that any issues can be caught. */ +#define DUK_USE_EXEC_INDIRECT_BOUND_CHECK +#endif + +/* + * Debug printing and assertion options + */ + +#undef DUK_USE_DEBUG +#undef DUK_USE_DPRINT +#undef DUK_USE_DDPRINT +#undef DUK_USE_DDDPRINT +#undef DUK_USE_DPRINT_RDTSC +#undef DUK_USE_ASSERTIONS + +/* Global debug enable. Compile must be clean on C99 regardless of whether or + * not debugging is enabled. On non-C99 platforms compile should be clean with + * debugging disabled but may produce warnings with debugging enabled (related + * to debug macro hackery and such). + */ +#if defined(DUK_OPT_DEBUG) +#define DUK_USE_DEBUG +#endif + +#if defined(DUK_OPT_DEBUG) && defined(DUK_OPT_DPRINT) +#define DUK_USE_DPRINT +#endif +#if defined(DUK_OPT_DEBUG) && defined(DUK_OPT_DDPRINT) +#define DUK_USE_DDPRINT +#endif +#if defined(DUK_OPT_DEBUG) && defined(DUK_OPT_DDDPRINT) +#define DUK_USE_DDDPRINT +#endif + +#undef DUK_USE_DPRINT_COLORS +#if defined(DUK_OPT_DPRINT_COLORS) +#define DUK_USE_DPRINT_COLORS +#endif + +#if defined(DUK_USE_RDTSC) && defined(DUK_OPT_DPRINT_RDTSC) +#define DUK_USE_DPRINT_RDTSC +#else +#undef DUK_USE_DPRINT_RDTSC +#endif + +#if defined(DUK_OPT_ASSERTIONS) +#define DUK_USE_ASSERTIONS +#endif + +/* The static buffer for debug printing is quite large by default, so there + * is an option to shrink it manually for constrained builds. + */ +#if defined(DUK_OPT_DEBUG_BUFSIZE) +#define DUK_USE_DEBUG_BUFSIZE DUK_OPT_DEBUG_BUFSIZE +#else +#define DUK_USE_DEBUG_BUFSIZE 65536L +#endif + +/* + * Ecmascript features / compliance options + */ + +#if defined(DUK_F_BCC) +/* Math built-in is stubbed out on BCC to allow compiler torture testing. */ +#else +#define DUK_USE_MATH_BUILTIN +#endif + +#define DUK_USE_STRICT_DECL +#if defined(DUK_OPT_NO_STRICT_DECL) +#undef DUK_USE_STRICT_DECL +#endif + +#define DUK_USE_REGEXP_SUPPORT +#if defined(DUK_OPT_NO_REGEXP_SUPPORT) +#undef DUK_USE_REGEXP_SUPPORT +#endif + +#undef DUK_USE_STRICT_UTF8_SOURCE +#if defined(DUK_OPT_STRICT_UTF8_SOURCE) +#define DUK_USE_STRICT_UTF8_SOURCE +#endif + +#define DUK_USE_OCTAL_SUPPORT +#if defined(DUK_OPT_NO_OCTAL_SUPPORT) +#undef DUK_USE_OCTAL_SUPPORT +#endif + +#define DUK_USE_SOURCE_NONBMP +#if defined(DUK_OPT_NO_SOURCE_NONBMP) +#undef DUK_USE_SOURCE_NONBMP +#endif + +#define DUK_USE_BROWSER_LIKE +#if defined(DUK_OPT_NO_BROWSER_LIKE) +#undef DUK_USE_BROWSER_LIKE +#endif + +/* E5/E5.1 Section B features. */ +#define DUK_USE_SECTION_B +#if defined(DUK_OPT_NO_SECTION_B) +#undef DUK_USE_SECTION_B +#endif + +/* Non-standard regexp parsing features. */ +#define DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE + +/* Treat function statements (function declarations outside top level of + * Program or FunctionBody) same as normal function declarations. This is + * also V8 behavior. See test-dev-func-decl-outside-top.js. + */ +#define DUK_USE_NONSTD_FUNC_STMT +#if defined(DUK_OPT_NO_NONSTD_FUNC_STMT) +#undef DUK_USE_NONSTD_FUNC_STMT +#endif + +/* Array.prototype.splice() non-standard but real world compatible behavior + * when deleteCount is omitted. + */ +#define DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT +#if defined(DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT) +#undef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT +#endif + +/* Array.prototype.concat() non-standard but real world compatible behavior + * for non-existent trailing elements. + */ +#define DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER +#if defined(DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER) +#undef DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER +#endif + +/* Array.prototype.map() non-standard but real world compatible behavior + * for non-existent trailing elements. + */ +#define DUK_USE_NONSTD_ARRAY_MAP_TRAILER +#if defined(DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER) +#undef DUK_USE_NONSTD_ARRAY_MAP_TRAILER +#endif + +/* Non-standard 'caller' property for function instances, see + * test-bi-function-nonstd-caller-prop.js. + */ +#undef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +#if defined(DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY) +#define DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +#endif + +/* Non-standard Object.prototype.__proto__ (ES6), see + * test-bi-object-proto-__proto__.js. + */ +#define DUK_USE_ES6_OBJECT_PROTO_PROPERTY +#if defined(DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY) +#undef DUK_USE_ES6_OBJECT_PROTO_PROPERTY +#endif + +/* Non-standard Object.setPrototypeOf (ES6), see + * test-bi-object-setprototypeof.js. + */ +#define DUK_USE_ES6_OBJECT_SETPROTOTYPEOF +#if defined(DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF) +#undef DUK_USE_ES6_OBJECT_SETPROTOTYPEOF +#endif + +/* ES6 Proxy object (subset for now). */ +#define DUK_USE_ES6_PROXY +#if defined(DUK_OPT_NO_ES6_PROXY) +#undef DUK_USE_ES6_PROXY +#endif + +/* Record pc-to-line information. */ +#define DUK_USE_PC2LINE +#if defined(DUK_OPT_NO_PC2LINE) +#undef DUK_USE_PC2LINE +#endif + +/* Non-standard function 'source' property. */ +#undef DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY +#if defined(DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY) +#define DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY +#endif + +/* CommonJS modules */ +#define DUK_USE_COMMONJS_MODULES +#if defined(DUK_OPT_NO_COMMONJS_MODULES) +#undef DUK_USE_COMMONJS_MODULES +#endif + +/* Additional key argument to setter/getter calls when triggered by property + * accesses. + */ + +#define DUK_USE_NONSTD_GETTER_KEY_ARGUMENT +#define DUK_USE_NONSTD_SETTER_KEY_ARGUMENT +#if defined(DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT) +#undef DUK_USE_NONSTD_GETTER_KEY_ARGUMENT +#undef DUK_USE_NONSTD_SETTER_KEY_ARGUMENT +#endif + +/* JSON escaping of U+2028 and U+2029. + */ + +#define DUK_USE_NONSTD_JSON_ESC_U2028_U2029 +#if defined(DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029) +#undef DUK_USE_NONSTD_JSON_ESC_U2028_U2029 +#endif + +/* Allow 32-bit codepoints in String.fromCharCode. */ +#define DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT +#if defined(DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT) +#undef DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT +#endif + +/* Non-standard array fast path write behavior: when writing to numeric + * indexes of an Array instance, assume Array.prototype doesn't have + * conflicting properties (e.g. a non-writable property "7"). + */ +#define DUK_USE_NONSTD_ARRAY_WRITE +#if defined(DUK_OPT_NO_NONSTD_ARRAY_WRITE) +#undef DUK_USE_NONSTD_ARRAY_WRITE +#endif + +/* Node.js Buffer and Khronos/ES6 typed array support. */ +#define DUK_USE_BUFFEROBJECT_SUPPORT +#if defined(DUK_OPT_NO_BUFFEROBJECT_SUPPORT) +#undef DUK_USE_BUFFEROBJECT_SUPPORT +#endif + +/* + * Optional C API options + */ + +#define DUK_USE_BYTECODE_DUMP_SUPPORT +#if defined(DUK_OPT_NO_BYTECODE_DUMP_SUPPORT) +#undef DUK_USE_BYTECODE_DUMP_SUPPORT +#endif + +/* + * Tailcalls + */ + +/* Tailcalls are enabled by default. The non-standard function 'caller' + * property feature conflicts with tailcalls quite severely so tailcalls + * are disabled if the 'caller' property is enabled. + */ +#define DUK_USE_TAILCALL +#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) +#undef DUK_USE_TAILCALL +#endif + +/* + * Ecmascript compiler + */ + +/* Ensure final bytecode never exceeds a certain byte size and never uses + * line numbers above a certain limit. This ensures that there is no need + * to deal with unbounded ranges in e.g. pc2line data structures. For now, + * limits are set so that signed 32-bit values can represent line number + * and byte offset with room to spare. + */ +#define DUK_USE_ESBC_LIMITS +#define DUK_USE_ESBC_MAX_LINENUMBER 0x7fff0000L +#define DUK_USE_ESBC_MAX_BYTES 0x7fff0000L + +#undef DUK_USE_SHUFFLE_TORTURE +#if defined(DUK_OPT_SHUFFLE_TORTURE) +#define DUK_USE_SHUFFLE_TORTURE +#endif + +/* + * User panic handler, panic exit behavior for default panic handler + */ + +#undef DUK_USE_PANIC_HANDLER +#if defined(DUK_OPT_PANIC_HANDLER) +#define DUK_USE_PANIC_HANDLER(code,msg) DUK_OPT_PANIC_HANDLER((code),(msg)) +#endif + +#undef DUK_USE_PANIC_ABORT +#undef DUK_USE_PANIC_EXIT +#undef DUK_USE_PANIC_SEGFAULT + +#if defined(DUK_OPT_SEGFAULT_ON_PANIC) +#define DUK_USE_PANIC_SEGFAULT +#else +#define DUK_USE_PANIC_ABORT +#endif + +/* + * File I/O support. This is now used in a few API calls to e.g. push + * a string from file contents or eval a file. For portability it must + * be possible to disable I/O altogether. + */ + +#undef DUK_USE_FILE_IO +#if !defined(DUK_OPT_NO_FILE_IO) +#define DUK_USE_FILE_IO +#endif + +/* + * Optional run-time self tests executed when a heap is created. Some + * platform/compiler issues cannot be determined at compile time. One + * particular example is the bug described in misc/clang_aliasing.c. + */ + +#undef DUK_USE_SELF_TESTS +#if defined(DUK_OPT_SELF_TESTS) +#define DUK_USE_SELF_TESTS +#endif + +/* Double aliasing testcase fails when Emscripten-generated code is run + * on Firefox. This is not fatal because it only affects packed duk_tval + * which we avoid with Emscripten. + */ +#undef DUK_USE_NO_DOUBLE_ALIASING_SELFTEST +#if defined(DUK_F_EMSCRIPTEN) +#define DUK_USE_NO_DOUBLE_ALIASING_SELFTEST +#endif + +/* + * Codecs + */ + +#define DUK_USE_JX +#if defined(DUK_OPT_NO_JX) +#undef DUK_USE_JX +#endif + +#define DUK_USE_JC +#if defined(DUK_OPT_NO_JC) +#undef DUK_USE_JC +#endif + +/* + * InitJS code + */ + +/* Always use the built-in InitJS code for now. */ +#define DUK_USE_BUILTIN_INITJS + +/* User provided InitJS. */ +#undef DUK_USE_USER_INITJS +#if defined(DUK_OPT_USER_INITJS) +#define DUK_USE_USER_INITJS (DUK_OPT_USER_INITJS) +#endif + +/* + * External string data support + * + * Allow duk_hstrings to store data also behind an external pointer (see + * duk_hstring_external). This increases code size slightly but is useful + * in low memory environments where memory is more limited than flash. + */ + +#undef DUK_USE_HSTRING_EXTDATA +#if defined(DUK_OPT_EXTERNAL_STRINGS) +#define DUK_USE_HSTRING_EXTDATA +#endif + +#undef DUK_USE_EXTSTR_INTERN_CHECK +#if defined(DUK_OPT_EXTERNAL_STRINGS) && defined(DUK_OPT_EXTSTR_INTERN_CHECK) +#define DUK_USE_EXTSTR_INTERN_CHECK(udata,ptr,len) DUK_OPT_EXTSTR_INTERN_CHECK((udata), (ptr), (len)) +#endif + +#undef DUK_USE_EXTSTR_FREE +#if defined(DUK_OPT_EXTERNAL_STRINGS) && defined(DUK_OPT_EXTSTR_FREE) +#define DUK_USE_EXTSTR_FREE(udata,ptr) DUK_OPT_EXTSTR_FREE((udata), (ptr)) +#endif + +/* + * Lightweight functions + */ + +/* Force built-ins to use lightfunc function pointers when possible. This + * makes the built-in functions non-compliant with respect to their property + * values and such, but is very useful in low memory environments (can save + * around 14kB of initial RAM footprint). + */ +#undef DUK_USE_LIGHTFUNC_BUILTINS +#if defined(DUK_OPT_LIGHTFUNC_BUILTINS) +#define DUK_USE_LIGHTFUNC_BUILTINS +#endif + +/* + * Pointer compression and 16-bit header fields for low memory environments + */ + +#undef DUK_USE_HEAPPTR16 +#undef DUK_USE_HEAPPTR_ENC16 +#undef DUK_USE_HEAPPTR_DEC16 +#if defined(DUK_OPT_HEAPPTR16) && defined(DUK_OPT_HEAPPTR_ENC16) && defined(DUK_OPT_HEAPPTR_DEC16) +#define DUK_USE_HEAPPTR16 +#define DUK_USE_HEAPPTR_ENC16(udata,ptr) DUK_OPT_HEAPPTR_ENC16((udata),(ptr)) +#define DUK_USE_HEAPPTR_DEC16(udata,ptr) DUK_OPT_HEAPPTR_DEC16((udata),(ptr)) +#endif + +#undef DUK_USE_DATAPTR16 +#undef DUK_USE_DATAPTR_ENC16 +#undef DUK_USE_DATAPTR_DEC16 +#if defined(DUK_OPT_DATAPTR16) && defined(DUK_OPT_DATAPTR_ENC16) && defined(DUK_OPT_DATAPTR_DEC16) +#define DUK_USE_DATAPTR16 +#define DUK_USE_DATAPTR_ENC16(udata,ptr) DUK_OPT_DATAPTR_ENC16((udata),(ptr)) +#define DUK_USE_DATAPTR_DEC16(udata,ptr) DUK_OPT_DATAPTR_DEC16((udata),(ptr)) +#endif + +#undef DUK_USE_FUNCPTR16 +#undef DUK_USE_FUNCPTR_ENC16 +#undef DUK_USE_FUNCPTR_DEC16 +#if defined(DUK_OPT_FUNCPTR16) && defined(DUK_OPT_FUNCPTR_ENC16) && defined(DUK_OPT_FUNCPTR_DEC16) +#define DUK_USE_FUNCPTR16 +#define DUK_USE_FUNCPTR_ENC16(udata,ptr) DUK_OPT_FUNCPTR_ENC16((udata),(ptr)) +#define DUK_USE_FUNCPTR_DEC16(udata,ptr) DUK_OPT_FUNCPTR_DEC16((udata),(ptr)) +#endif + +#undef DUK_USE_REFCOUNT16 +#if defined(DUK_OPT_REFCOUNT16) +#define DUK_USE_REFCOUNT16 +#endif + +#undef DUK_USE_STRHASH16 +#if defined(DUK_OPT_STRHASH16) +#define DUK_USE_STRHASH16 +#endif + +#undef DUK_USE_STRLEN16 +#if defined(DUK_OPT_STRLEN16) +#define DUK_USE_STRLEN16 +#endif + +#undef DUK_USE_BUFLEN16 +#if defined(DUK_OPT_BUFLEN16) +#define DUK_USE_BUFLEN16 +#endif + +#undef DUK_USE_OBJSIZES16 +#if defined(DUK_OPT_OBJSIZES16) +#define DUK_USE_OBJSIZES16 +#endif + +/* For now, hash part is dropped if and only if 16-bit object fields are used. */ +#define DUK_USE_HOBJECT_HASH_PART +#if defined(DUK_USE_OBJSIZES16) +#undef DUK_USE_HOBJECT_HASH_PART +#endif + +/* + * Miscellaneous + */ + +/* Convenience define: 32-bit pointers. 32-bit platforms are an important + * footprint optimization target, and this define allows e.g. struct sizes + * to be organized for compactness. + */ +#undef DUK_USE_32BIT_PTRS +#if defined(DUK_UINTPTR_MAX) && !defined(DUK_UINTPTR_MAX_COMPUTED) +#if DUK_UINTPTR_MAX <= 0xffffffffUL +#define DUK_USE_32BIT_PTRS +#endif +#endif + +#define DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS +#undef DUK_USE_EXPLICIT_NULL_INIT + +#define DUK_USE_ZERO_BUFFER_DATA +#if defined(DUK_OPT_NO_ZERO_BUFFER_DATA) +#undef DUK_USE_ZERO_BUFFER_DATA +#endif + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || (defined(DUK_F_CPP11) && defined(__GNUC__)) +#define DUK_USE_VARIADIC_MACROS +#endif +#if defined(_MSC_VER) && !defined(DUK_USE_VARIADIC_MACROS) +#if (_MSC_VER >= 1400) +/* VS2005+ should have variadic macros even when they're not C99. */ +#define DUK_USE_VARIADIC_MACROS +#endif +#endif + +/* + * Variable size array initialization. + * + * Variable size array at the end of a structure is nonportable. + * There are three alternatives: + * + * 1) C99 (flexible array member): char buf[] + * 2) Compiler specific (e.g. GCC): char buf[0] + * 3) Portable but wastes memory / complicates allocation: char buf[1] + */ + +/* XXX: Currently unused, only hbuffer.h needed this at some point. */ +#undef DUK_USE_FLEX_C99 +#undef DUK_USE_FLEX_ZEROSIZE +#undef DUK_USE_FLEX_ONESIZE +#if defined(DUK_F_C99) +#define DUK_USE_FLEX_C99 +#elif defined(__GNUC__) +#define DUK_USE_FLEX_ZEROSIZE +#else +#define DUK_USE_FLEX_ONESIZE +#endif + +/* + * GCC pragmas + */ + +/* XXX: GCC pragma inside a function fails in some earlier GCC versions (e.g. gcc 4.5). + * This is very approximate but allows clean builds for development right now. + */ +/* http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html */ +#if defined(__GNUC__) && defined(__GNUC_MINOR__) && (__GNUC__ == 4) && (__GNUC_MINOR__ >= 6) +#define DUK_USE_GCC_PRAGMAS +#else +#undef DUK_USE_GCC_PRAGMAS +#endif + +/* + * User declarations + */ + +#if defined(DUK_OPT_DECLARE) +#define DUK_USE_USER_DECLARE() DUK_OPT_DECLARE +#else +#define DUK_USE_USER_DECLARE() /* no user declarations */ +#endif + +/* + * Autogenerated defaults + */ + +#define DUK_USE_COMPILER_RECLIMIT 2500 +#undef DUK_USE_DATE_FORMAT_STRING +#undef DUK_USE_DATE_GET_LOCAL_TZOFFSET +#undef DUK_USE_DATE_GET_NOW +#undef DUK_USE_DATE_PARSE_STRING +#undef DUK_USE_DATE_PRS_GETDATE +#undef DUK_USE_INTEGER_ME +#define DUK_USE_JSON_DECNUMBER_FASTPATH +#define DUK_USE_JSON_DECSTRING_FASTPATH +#define DUK_USE_JSON_DEC_RECLIMIT 1000 +#define DUK_USE_JSON_EATWHITE_FASTPATH +#define DUK_USE_JSON_ENC_RECLIMIT 1000 +#define DUK_USE_JSON_QUOTESTRING_FASTPATH +#undef DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE +#define DUK_USE_MARK_AND_SWEEP_RECLIMIT 256 +#define DUK_USE_NATIVE_CALL_RECLIMIT 1000 +#undef DUK_USE_REFZERO_FINALIZER_TORTURE +#define DUK_USE_REGEXP_COMPILER_RECLIMIT 10000 +#define DUK_USE_REGEXP_EXECUTOR_RECLIMIT 10000 + +/* + * Alternative customization header + * + * If you want to modify the final DUK_USE_xxx flags directly (without + * using the available DUK_OPT_xxx flags), define DUK_OPT_HAVE_CUSTOM_H + * and tweak the final flags there. + */ + +#if defined(DUK_OPT_HAVE_CUSTOM_H) +#include "duk_custom.h" +#endif + +/* + * You may add overriding #define/#undef directives below for + * customization. You of course cannot un-#include or un-typedef + * anything; these require direct changes above. + */ + +/* __OVERRIDE_DEFINES__ */ + +/* + * Date provider selection + * + * User may define DUK_USE_DATE_GET_NOW() etc directly, in which case we'll + * rely on an external provider. If this is not done, revert to previous + * behavior and use Unix/Windows built-in provider. + */ + +#if defined(DUK_COMPILING_DUKTAPE) + +#if defined(DUK_USE_DATE_GET_NOW) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_NOW_GETTIMEOFDAY) +DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now_gettimeofday(duk_context *ctx); +#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_gettimeofday((ctx)) +#elif defined(DUK_USE_DATE_NOW_TIME) +DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now_time(duk_context *ctx); +#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_time((ctx)) +#elif defined(DUK_USE_DATE_NOW_WINDOWS) +DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now_windows(duk_context *ctx); +#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_windows((ctx)) +#else +#error no provider for DUK_USE_DATE_GET_NOW() +#endif + +#if defined(DUK_USE_DATE_GET_LOCAL_TZOFFSET) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_TZO_GMTIME_R) || defined(DUK_USE_DATE_TZO_GMTIME) +DUK_INTERNAL_DECL duk_int_t duk_bi_date_get_local_tzoffset_gmtime(duk_double_t d); +#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_gmtime((d)) +#elif defined(DUK_USE_DATE_TZO_WINDOWS) +DUK_INTERNAL_DECL duk_int_t duk_bi_date_get_local_tzoffset_windows(duk_double_t d); +#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_windows((d)) +#else +#error no provider for DUK_USE_DATE_GET_LOCAL_TZOFFSET() +#endif + +#if defined(DUK_USE_DATE_PARSE_STRING) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_PRS_STRPTIME) +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_parse_string_strptime(duk_context *ctx, const char *str); +#define DUK_USE_DATE_PARSE_STRING(ctx,str) duk_bi_date_parse_string_strptime((ctx), (str)) +#elif defined(DUK_USE_DATE_PRS_GETDATE) +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_parse_string_getdate(duk_context *ctx, const char *str); +#define DUK_USE_DATE_PARSE_STRING(ctx,str) duk_bi_date_parse_string_getdate((ctx), (str)) +#else +/* No provider for DUK_USE_DATE_PARSE_STRING(), fall back to ISO 8601 only. */ +#endif + +#if defined(DUK_USE_DATE_FORMAT_STRING) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_FMT_STRFTIME) +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_format_parts_strftime(duk_context *ctx, duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags); +#define DUK_USE_DATE_FORMAT_STRING(ctx,parts,tzoffset,flags) \ + duk_bi_date_format_parts_strftime((ctx), (parts), (tzoffset), (flags)) +#else +/* No provider for DUK_USE_DATE_FORMAT_STRING(), fall back to ISO 8601 only. */ +#endif + +#endif /* DUK_COMPILING_DUKTAPE */ + +/* + * Sanity check for the final effective internal defines. Also + * double checks user tweaks made by an optional duk_custom.h header. + */ + +/* + * Deprecated feature options. + * + * Catch so that user more easily notices and updates build. + */ + +#if defined(DUK_OPT_NO_FUNC_STMT) +#error DUK_OPT_NO_FUNC_STMT is deprecated, use DUK_OPT_NO_NONSTD_FUNC_STMT +#endif + +#if defined(DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY) +#error DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY is deprecated, use DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY +#endif + +#if defined(DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY) +#error DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY is deprecated, use DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY +#endif + +#if defined(DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT) +#error DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT is deprecated, use DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT +#endif + +#if defined(DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY) +#error DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY is deprecated, use DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY +#endif + +#if defined(DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF) +#error DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF is deprecated, use DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF +#endif + +#if defined(DUK_OPT_NO_JSONX) +#error DUK_OPT_NO_JSONX is deprecated, use DUK_OPT_NO_JX +#endif + +#if defined(DUK_OPT_NO_JSONC) +#error DUK_OPT_NO_JSONC is deprecated, use DUK_OPT_NO_JC +#endif + +/* + * Debug print consistency + */ + +#if defined(DUK_USE_DPRINT) && !defined(DUK_USE_DEBUG) +#error DUK_USE_DPRINT without DUK_USE_DEBUG +#endif + +#if defined(DUK_USE_DDPRINT) && !defined(DUK_USE_DEBUG) +#error DUK_USE_DDPRINT without DUK_USE_DEBUG +#endif + +#if defined(DUK_USE_DDDPRINT) && !defined(DUK_USE_DEBUG) +#error DUK_USE_DDDPRINT without DUK_USE_DEBUG +#endif + +#if defined(DUK_USE_HEAPPTR16) && defined(DUK_USE_DEBUG) +/* Debug code doesn't have access to 'heap' so it cannot decode pointers. */ +#error debug printing cannot currently be used with heap pointer compression +#endif + +/* + * Debugger consistency + */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) +#if !defined(DUK_USE_INTERRUPT_COUNTER) +#error DUK_USE_INTERRUPT_COUNTER is needed when debugger support is enabled +#endif +#if !defined(DUK_USE_PC2LINE) +#error DUK_USE_PC2LINE is needed when debugger support is enabled +#endif +#endif + +/* + * Garbage collection consistency + */ + +#if defined(DUK_USE_REFERENCE_COUNTING) && !defined(DUK_USE_DOUBLE_LINKED_HEAP) +#error DUK_USE_REFERENCE_COUNTING defined without DUK_USE_DOUBLE_LINKED_HEAP +#endif + +#if defined(DUK_USE_GC_TORTURE) && !defined(DUK_USE_MARK_AND_SWEEP) +#error DUK_USE_GC_TORTURE defined without DUK_USE_MARK_AND_SWEEP +#endif + +/* + * Low memory feature consistency + */ + +#if defined(DUK_USE_OBJSIZES16) +#if defined(DUK_USE_HOBJECT_HASH_PART) +#error DUK_USE_OBJSIZES16 assumes DUK_USE_HOBJECT_HASH_PART is not defined +#endif +#endif + +#if defined(DUK_USE_STRTAB_CHAIN) && defined(DUK_USE_STRTAB_PROBE) +#error both DUK_USE_STRTAB_CHAIN and DUK_USE_STRTAB_PROBE defined +#endif +#if !defined(DUK_USE_STRTAB_CHAIN) && !defined(DUK_USE_STRTAB_PROBE) +#error neither DUK_USE_STRTAB_CHAIN nor DUK_USE_STRTAB_PROBE is defined +#endif + +#endif /* DUK_CONFIG_H_INCLUDED */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extern/duktape/duktape.c Mon Sep 28 13:18:14 2015 +0200 @@ -0,0 +1,80352 @@ +/* + * Single source autogenerated distributable for Duktape 1.3.0. + * Git commit 675165f35ea3a5bac34ff4d0a58b007cc2f442dc (v1.3.0). + * + * See Duktape AUTHORS.rst and LICENSE.txt for copyright and + * licensing information. + */ + +/* LICENSE.txt */ +/* +* =============== +* Duktape license +* =============== +* +* (http://opensource.org/licenses/MIT) +* +* Copyright (c) 2013-2015 by Duktape authors (see AUTHORS.rst) +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to deal +* in the Software without restriction, including without limitation the rights +* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +* copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +* THE SOFTWARE. +*/ +/* AUTHORS.rst */ +/* +* =============== +* Duktape authors +* =============== +* +* Copyright +* ========= +* +* Duktape copyrights are held by its authors. Each author has a copyright +* to their contribution, and agrees to irrevocably license the contribution +* under the Duktape ``LICENSE.txt``. +* +* Authors +* ======= +* +* Please include an e-mail address, a link to your GitHub profile, or something +* similar to allow your contribution to be identified accurately. +* +* The following people have contributed code, website contents, or Wiki contents, +* and agreed to irrevocably license their contributions under the Duktape +* ``LICENSE.txt`` (in order of appearance): +* +* * Sami Vaarala <sami.vaarala@iki.fi> +* * Niki Dobrev +* * Andreas \u00d6man <andreas@lonelycoder.com> +* * L\u00e1szl\u00f3 Lang\u00f3 <llango.u-szeged@partner.samsung.com> +* * Legimet <legimet.calc@gmail.com> +* * Karl Skomski <karl@skomski.com> +* * Bruce Pascoe <fatcerberus1@gmail.com> +* +* Other contributions +* =================== +* +* The following people have contributed something other than code (e.g. reported +* bugs, provided ideas, etc; roughly in order of appearance): +* +* * Greg Burns +* * Anthony Rabine +* * Carlos Costa +* * Aur\u00e9lien Bouilland +* * Preet Desai (Pris Matic) +* * judofyr (http://www.reddit.com/user/judofyr) +* * Jason Woofenden +* * Micha\u0142 Przyby\u015b +* * Anthony Howe +* * Conrad Pankoff +* * Jim Schimpf +* * Rajaran Gaunker (https://github.com/zimbabao) +* * Andreas \u00d6man +* * Doug Sanden +* * Josh Engebretson (https://github.com/JoshEngebretson) +* * Remo Eichenberger (https://github.com/remoe) +* * Mamod Mehyar (https://github.com/mamod) +* * David Demelier (https://github.com/markand) +* * Tim Caswell (https://github.com/creationix) +* * Mitchell Blank Jr (https://github.com/mitchblank) +* * https://github.com/yushli +* * Seo Sanghyeon (https://github.com/sanxiyn) +* * Han ChoongWoo (https://github.com/tunz) +* * Joshua Peek (https://github.com/josh) +* * Bruce E. Pascoe (https://github.com/fatcerberus) +* * https://github.com/Kelledin +* * https://github.com/sstruchtrup +* * Michael Drake (https://github.com/tlsa) +* * https://github.com/chris-y +* +* If you are accidentally missing from this list, send me an e-mail +* (``sami.vaarala@iki.fi``) and I'll fix the omission. +*/ +#line 1 "duk_internal.h" +/* + * Top-level include file to be used for all (internal) source files. + * + * Source files should not include individual header files, as they + * have not been designed to be individually included. + */ + +#ifndef DUK_INTERNAL_H_INCLUDED +#define DUK_INTERNAL_H_INCLUDED + +/* + * The 'duktape.h' header provides the public API, but also handles all + * compiler and platform specific feature detection, Duktape feature + * resolution, inclusion of system headers, etc. These have been merged + * because the public API is also dependent on e.g. detecting appropriate + * C types which is quite platform/compiler specific especially for a non-C99 + * build. The public API is also dependent on the resolved feature set. + * + * Some actions taken by the merged header (such as including system headers) + * are not appropriate for building a user application. The define + * DUK_COMPILING_DUKTAPE allows the merged header to skip/include some + * sections depending on what is being built. + */ + +#define DUK_COMPILING_DUKTAPE +#include "duktape.h" + +/* + * User declarations, e.g. prototypes for user functions used by Duktape + * macros. Concretely, if DUK_USE_PANIC_HANDLER is used and the macro + * value calls a user function, it needs to be declared for Duktape + * compilation to avoid warnings. + */ + +DUK_USE_USER_DECLARE() + +/* + * Duktape includes (other than duk_features.h) + * + * The header files expect to be included in an order which satisfies header + * dependencies correctly (the headers themselves don't include any other + * includes). Forward declarations are used to break circular struct/typedef + * dependencies. + */ + +#line 1 "duk_replacements.h" +#ifndef DUK_REPLACEMENTS_H_INCLUDED +#define DUK_REPLACEMENTS_H_INCLUDED + +#ifdef DUK_USE_REPL_FPCLASSIFY +DUK_INTERNAL_DECL int duk_repl_fpclassify(double x); +#endif + +#ifdef DUK_USE_REPL_SIGNBIT +DUK_INTERNAL_DECL int duk_repl_signbit(double x); +#endif + +#ifdef DUK_USE_REPL_ISFINITE +DUK_INTERNAL_DECL int duk_repl_isfinite(double x); +#endif + +#ifdef DUK_USE_REPL_ISNAN +DUK_INTERNAL_DECL int duk_repl_isnan(double x); +#endif + +#ifdef DUK_USE_REPL_ISINF +DUK_INTERNAL_DECL int duk_repl_isinf(double x); +#endif + +#endif /* DUK_REPLACEMENTS_H_INCLUDED */ +#line 1 "duk_jmpbuf.h" +/* + * Wrapper for jmp_buf. + * + * This is used because jmp_buf is an array type for backward compatibility. + * Wrapping jmp_buf in a struct makes pointer references, sizeof, etc, + * behave more intuitively. + * + * http://en.wikipedia.org/wiki/Setjmp.h#Member_types + */ + +#ifndef DUK_JMPBUF_H_INCLUDED +#define DUK_JMPBUF_H_INCLUDED + +struct duk_jmpbuf { +#if defined(DUK_USE_SETJMP) || defined(DUK_USE_UNDERSCORE_SETJMP) + jmp_buf jb; +#elif defined(DUK_USE_SIGSETJMP) + sigjmp_buf jb; +#else +#error internal error, no long control transfer provider +#endif +}; + +#endif /* DUK_JMPBUF_H_INCLUDED */ +#line 1 "duk_forwdecl.h" +/* + * Forward declarations for all Duktape structures. + */ + +#ifndef DUK_FORWDECL_H_INCLUDED +#define DUK_FORWDECL_H_INCLUDED + +/* + * Forward declarations + */ + +struct duk_jmpbuf; + +/* duk_tval intentionally skipped */ +struct duk_heaphdr; +struct duk_heaphdr_string; +struct duk_hstring; +struct duk_hstring_external; +struct duk_hobject; +struct duk_hcompiledfunction; +struct duk_hnativefunction; +struct duk_hthread; +struct duk_hbufferobject; +struct duk_hbuffer; +struct duk_hbuffer_fixed; +struct duk_hbuffer_dynamic; +struct duk_hbuffer_external; + +struct duk_propaccessor; +union duk_propvalue; +struct duk_propdesc; + +struct duk_heap; +struct duk_breakpoint; + +struct duk_activation; +struct duk_catcher; +struct duk_strcache; +struct duk_ljstate; +struct duk_strtab_entry; + +#ifdef DUK_USE_DEBUG +struct duk_fixedbuffer; +#endif + +struct duk_bitdecoder_ctx; +struct duk_bitencoder_ctx; +struct duk_bufwriter_ctx; + +struct duk_token; +struct duk_re_token; +struct duk_lexer_point; +struct duk_lexer_ctx; +struct duk_lexer_codepoint; + +struct duk_compiler_instr; +struct duk_compiler_func; +struct duk_compiler_ctx; + +struct duk_re_matcher_ctx; +struct duk_re_compiler_ctx; + +typedef struct duk_jmpbuf duk_jmpbuf; + +/* duk_tval intentionally skipped */ +typedef struct duk_heaphdr duk_heaphdr; +typedef struct duk_heaphdr_string duk_heaphdr_string; +typedef struct duk_hstring duk_hstring; +typedef struct duk_hstring_external duk_hstring_external; +typedef struct duk_hobject duk_hobject; +typedef struct duk_hcompiledfunction duk_hcompiledfunction; +typedef struct duk_hnativefunction duk_hnativefunction; +typedef struct duk_hbufferobject duk_hbufferobject; +typedef struct duk_hthread duk_hthread; +typedef struct duk_hbuffer duk_hbuffer; +typedef struct duk_hbuffer_fixed duk_hbuffer_fixed; +typedef struct duk_hbuffer_dynamic duk_hbuffer_dynamic; +typedef struct duk_hbuffer_external duk_hbuffer_external; + +typedef struct duk_propaccessor duk_propaccessor; +typedef union duk_propvalue duk_propvalue; +typedef struct duk_propdesc duk_propdesc; + +typedef struct duk_heap duk_heap; +typedef struct duk_breakpoint duk_breakpoint; + +typedef struct duk_activation duk_activation; +typedef struct duk_catcher duk_catcher; +typedef struct duk_strcache duk_strcache; +typedef struct duk_ljstate duk_ljstate; +typedef struct duk_strtab_entry duk_strtab_entry; + +#ifdef DUK_USE_DEBUG +typedef struct duk_fixedbuffer duk_fixedbuffer; +#endif + +typedef struct duk_bitdecoder_ctx duk_bitdecoder_ctx; +typedef struct duk_bitencoder_ctx duk_bitencoder_ctx; +typedef struct duk_bufwriter_ctx duk_bufwriter_ctx; + +typedef struct duk_token duk_token; +typedef struct duk_re_token duk_re_token; +typedef struct duk_lexer_point duk_lexer_point; +typedef struct duk_lexer_ctx duk_lexer_ctx; +typedef struct duk_lexer_codepoint duk_lexer_codepoint; + +typedef struct duk_compiler_instr duk_compiler_instr; +typedef struct duk_compiler_func duk_compiler_func; +typedef struct duk_compiler_ctx duk_compiler_ctx; + +typedef struct duk_re_matcher_ctx duk_re_matcher_ctx; +typedef struct duk_re_compiler_ctx duk_re_compiler_ctx; + +#endif /* DUK_FORWDECL_H_INCLUDED */ +#line 1 "duk_builtins.h" +/* + * Automatically generated by genbuiltins.py, do not edit! + */ + +#ifndef DUK_BUILTINS_H_INCLUDED +#define DUK_BUILTINS_H_INCLUDED + +#if defined(DUK_USE_DOUBLE_LE) +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[2624]; +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_STRDATA_DATA_LENGTH 2624 +#define DUK_STRDATA_MAX_STRLEN 24 + +#define DUK_STRIDX_UC_LOGGER 0 /* 'Logger' */ +#define DUK_STRIDX_UC_THREAD 1 /* 'Thread' */ +#define DUK_STRIDX_UC_POINTER 2 /* 'Pointer' */ +#define DUK_STRIDX_DEC_ENV 3 /* 'DecEnv' */ +#define DUK_STRIDX_OBJ_ENV 4 /* 'ObjEnv' */ +#define DUK_STRIDX_FLOAT64_ARRAY 5 /* 'Float64Array' */ +#define DUK_STRIDX_FLOAT32_ARRAY 6 /* 'Float32Array' */ +#define DUK_STRIDX_UINT32_ARRAY 7 /* 'Uint32Array' */ +#define DUK_STRIDX_INT32_ARRAY 8 /* 'Int32Array' */ +#define DUK_STRIDX_UINT16_ARRAY 9 /* 'Uint16Array' */ +#define DUK_STRIDX_INT16_ARRAY 10 /* 'Int16Array' */ +#define DUK_STRIDX_UINT8_CLAMPED_ARRAY 11 /* 'Uint8ClampedArray' */ +#define DUK_STRIDX_UINT8_ARRAY 12 /* 'Uint8Array' */ +#define DUK_STRIDX_INT8_ARRAY 13 /* 'Int8Array' */ +#define DUK_STRIDX_DATA_VIEW 14 /* 'DataView' */ +#define DUK_STRIDX_ARRAY_BUFFER 15 /* 'ArrayBuffer' */ +#define DUK_STRIDX_UC_BUFFER 16 /* 'Buffer' */ +#define DUK_STRIDX_EMPTY_STRING 17 /* '' */ +#define DUK_STRIDX_GLOBAL 18 /* 'global' */ +#define DUK_STRIDX_UC_ARGUMENTS 19 /* 'Arguments' */ +#define DUK_STRIDX_JSON 20 /* 'JSON' */ +#define DUK_STRIDX_MATH 21 /* 'Math' */ +#define DUK_STRIDX_UC_ERROR 22 /* 'Error' */ +#define DUK_STRIDX_REG_EXP 23 /* 'RegExp' */ +#define DUK_STRIDX_DATE 24 /* 'Date' */ +#define DUK_STRIDX_UC_NUMBER 25 /* 'Number' */ +#define DUK_STRIDX_UC_BOOLEAN 26 /* 'Boolean' */ +#define DUK_STRIDX_UC_STRING 27 /* 'String' */ +#define DUK_STRIDX_ARRAY 28 /* 'Array' */ +#define DUK_STRIDX_UC_FUNCTION 29 /* 'Function' */ +#define DUK_STRIDX_UC_OBJECT 30 /* 'Object' */ +#define DUK_STRIDX_UC_NULL 31 /* 'Null' */ +#define DUK_STRIDX_UC_UNDEFINED 32 /* 'Undefined' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION2 33 /* '{_func:true}' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION1 34 /* '{"_func":true}' */ +#define DUK_STRIDX_JSON_EXT_NEGINF 35 /* '{"_ninf":true}' */ +#define DUK_STRIDX_JSON_EXT_POSINF 36 /* '{"_inf":true}' */ +#define DUK_STRIDX_JSON_EXT_NAN 37 /* '{"_nan":true}' */ +#define DUK_STRIDX_JSON_EXT_UNDEFINED 38 /* '{"_undef":true}' */ +#define DUK_STRIDX_TO_LOG_STRING 39 /* 'toLogString' */ +#define DUK_STRIDX_CLOG 40 /* 'clog' */ +#define DUK_STRIDX_LC_L 41 /* 'l' */ +#define DUK_STRIDX_LC_N 42 /* 'n' */ +#define DUK_STRIDX_LC_FATAL 43 /* 'fatal' */ +#define DUK_STRIDX_LC_ERROR 44 /* 'error' */ +#define DUK_STRIDX_LC_WARN 45 /* 'warn' */ +#define DUK_STRIDX_LC_DEBUG 46 /* 'debug' */ +#define DUK_STRIDX_LC_TRACE 47 /* 'trace' */ +#define DUK_STRIDX_RAW 48 /* 'raw' */ +#define DUK_STRIDX_FMT 49 /* 'fmt' */ +#define DUK_STRIDX_CURRENT 50 /* 'current' */ +#define DUK_STRIDX_RESUME 51 /* 'resume' */ +#define DUK_STRIDX_COMPACT 52 /* 'compact' */ +#define DUK_STRIDX_JC 53 /* 'jc' */ +#define DUK_STRIDX_JX 54 /* 'jx' */ +#define DUK_STRIDX_BASE64 55 /* 'base64' */ +#define DUK_STRIDX_HEX 56 /* 'hex' */ +#define DUK_STRIDX_DEC 57 /* 'dec' */ +#define DUK_STRIDX_ENC 58 /* 'enc' */ +#define DUK_STRIDX_FIN 59 /* 'fin' */ +#define DUK_STRIDX_GC 60 /* 'gc' */ +#define DUK_STRIDX_ACT 61 /* 'act' */ +#define DUK_STRIDX_LC_INFO 62 /* 'info' */ +#define DUK_STRIDX_VERSION 63 /* 'version' */ +#define DUK_STRIDX_ENV 64 /* 'env' */ +#define DUK_STRIDX_MOD_LOADED 65 /* 'modLoaded' */ +#define DUK_STRIDX_MOD_SEARCH 66 /* 'modSearch' */ +#define DUK_STRIDX_ERR_THROW 67 /* 'errThrow' */ +#define DUK_STRIDX_ERR_CREATE 68 /* 'errCreate' */ +#define DUK_STRIDX_COMPILE 69 /* 'compile' */ +#define DUK_STRIDX_INT_REGBASE 70 /* '\x00Regbase' */ +#define DUK_STRIDX_INT_THREAD 71 /* '\x00Thread' */ +#define DUK_STRIDX_INT_HANDLER 72 /* '\x00Handler' */ +#define DUK_STRIDX_INT_FINALIZER 73 /* '\x00Finalizer' */ +#define DUK_STRIDX_INT_CALLEE 74 /* '\x00Callee' */ +#define DUK_STRIDX_INT_MAP 75 /* '\x00Map' */ +#define DUK_STRIDX_INT_ARGS 76 /* '\x00Args' */ +#define DUK_STRIDX_INT_THIS 77 /* '\x00This' */ +#define DUK_STRIDX_INT_PC2LINE 78 /* '\x00Pc2line' */ +#define DUK_STRIDX_INT_SOURCE 79 /* '\x00Source' */ +#define DUK_STRIDX_INT_VARENV 80 /* '\x00Varenv' */ +#define DUK_STRIDX_INT_LEXENV 81 /* '\x00Lexenv' */ +#define DUK_STRIDX_INT_VARMAP 82 /* '\x00Varmap' */ +#define DUK_STRIDX_INT_FORMALS 83 /* '\x00Formals' */ +#define DUK_STRIDX_INT_BYTECODE 84 /* '\x00Bytecode' */ +#define DUK_STRIDX_INT_NEXT 85 /* '\x00Next' */ +#define DUK_STRIDX_INT_TARGET 86 /* '\x00Target' */ +#define DUK_STRIDX_INT_VALUE 87 /* '\x00Value' */ +#define DUK_STRIDX_LC_POINTER 88 /* 'pointer' */ +#define DUK_STRIDX_INT_TRACEDATA 89 /* '\x00Tracedata' */ +#define DUK_STRIDX_LINE_NUMBER 90 /* 'lineNumber' */ +#define DUK_STRIDX_FILE_NAME 91 /* 'fileName' */ +#define DUK_STRIDX_PC 92 /* 'pc' */ +#define DUK_STRIDX_STACK 93 /* 'stack' */ +#define DUK_STRIDX_THROW_TYPE_ERROR 94 /* 'ThrowTypeError' */ +#define DUK_STRIDX_DUKTAPE 95 /* 'Duktape' */ +#define DUK_STRIDX_SET_FLOAT64 96 /* 'setFloat64' */ +#define DUK_STRIDX_SET_FLOAT32 97 /* 'setFloat32' */ +#define DUK_STRIDX_SET_UINT32 98 /* 'setUint32' */ +#define DUK_STRIDX_SET_INT32 99 /* 'setInt32' */ +#define DUK_STRIDX_SET_UINT16 100 /* 'setUint16' */ +#define DUK_STRIDX_SET_INT16 101 /* 'setInt16' */ +#define DUK_STRIDX_SET_UINT8 102 /* 'setUint8' */ +#define DUK_STRIDX_SET_INT8 103 /* 'setInt8' */ +#define DUK_STRIDX_GET_FLOAT64 104 /* 'getFloat64' */ +#define DUK_STRIDX_GET_FLOAT32 105 /* 'getFloat32' */ +#define DUK_STRIDX_GET_UINT32 106 /* 'getUint32' */ +#define DUK_STRIDX_GET_INT32 107 /* 'getInt32' */ +#define DUK_STRIDX_GET_UINT16 108 /* 'getUint16' */ +#define DUK_STRIDX_GET_INT16 109 /* 'getInt16' */ +#define DUK_STRIDX_GET_UINT8 110 /* 'getUint8' */ +#define DUK_STRIDX_GET_INT8 111 /* 'getInt8' */ +#define DUK_STRIDX_SUBARRAY 112 /* 'subarray' */ +#define DUK_STRIDX_BYTES_PER_ELEMENT 113 /* 'BYTES_PER_ELEMENT' */ +#define DUK_STRIDX_BYTE_OFFSET 114 /* 'byteOffset' */ +#define DUK_STRIDX_LC_BUFFER 115 /* 'buffer' */ +#define DUK_STRIDX_IS_VIEW 116 /* 'isView' */ +#define DUK_STRIDX_DATA 117 /* 'data' */ +#define DUK_STRIDX_TYPE 118 /* 'type' */ +#define DUK_STRIDX_WRITE_INT_BE 119 /* 'writeIntBE' */ +#define DUK_STRIDX_WRITE_INT_LE 120 /* 'writeIntLE' */ +#define DUK_STRIDX_WRITE_UINT_BE 121 /* 'writeUIntBE' */ +#define DUK_STRIDX_WRITE_UINT_LE 122 /* 'writeUIntLE' */ +#define DUK_STRIDX_WRITE_DOUBLE_BE 123 /* 'writeDoubleBE' */ +#define DUK_STRIDX_WRITE_DOUBLE_LE 124 /* 'writeDoubleLE' */ +#define DUK_STRIDX_WRITE_FLOAT_BE 125 /* 'writeFloatBE' */ +#define DUK_STRIDX_WRITE_FLOAT_LE 126 /* 'writeFloatLE' */ +#define DUK_STRIDX_WRITE_INT32_BE 127 /* 'writeInt32BE' */ +#define DUK_STRIDX_WRITE_INT32_LE 128 /* 'writeInt32LE' */ +#define DUK_STRIDX_WRITE_UINT32_BE 129 /* 'writeUInt32BE' */ +#define DUK_STRIDX_WRITE_UINT32_LE 130 /* 'writeUInt32LE' */ +#define DUK_STRIDX_WRITE_INT16_BE 131 /* 'writeInt16BE' */ +#define DUK_STRIDX_WRITE_INT16_LE 132 /* 'writeInt16LE' */ +#define DUK_STRIDX_WRITE_UINT16_BE 133 /* 'writeUInt16BE' */ +#define DUK_STRIDX_WRITE_UINT16_LE 134 /* 'writeUInt16LE' */ +#define DUK_STRIDX_WRITE_INT8 135 /* 'writeInt8' */ +#define DUK_STRIDX_WRITE_UINT8 136 /* 'writeUInt8' */ +#define DUK_STRIDX_READ_INT_BE 137 /* 'readIntBE' */ +#define DUK_STRIDX_READ_INT_LE 138 /* 'readIntLE' */ +#define DUK_STRIDX_READ_UINT_BE 139 /* 'readUIntBE' */ +#define DUK_STRIDX_READ_UINT_LE 140 /* 'readUIntLE' */ +#define DUK_STRIDX_READ_DOUBLE_BE 141 /* 'readDoubleBE' */ +#define DUK_STRIDX_READ_DOUBLE_LE 142 /* 'readDoubleLE' */ +#define DUK_STRIDX_READ_FLOAT_BE 143 /* 'readFloatBE' */ +#define DUK_STRIDX_READ_FLOAT_LE 144 /* 'readFloatLE' */ +#define DUK_STRIDX_READ_INT32_BE 145 /* 'readInt32BE' */ +#define DUK_STRIDX_READ_INT32_LE 146 /* 'readInt32LE' */ +#define DUK_STRIDX_READ_UINT32_BE 147 /* 'readUInt32BE' */ +#define DUK_STRIDX_READ_UINT32_LE 148 /* 'readUInt32LE' */ +#define DUK_STRIDX_READ_INT16_BE 149 /* 'readInt16BE' */ +#define DUK_STRIDX_READ_INT16_LE 150 /* 'readInt16LE' */ +#define DUK_STRIDX_READ_UINT16_BE 151 /* 'readUInt16BE' */ +#define DUK_STRIDX_READ_UINT16_LE 152 /* 'readUInt16LE' */ +#define DUK_STRIDX_READ_INT8 153 /* 'readInt8' */ +#define DUK_STRIDX_READ_UINT8 154 /* 'readUInt8' */ +#define DUK_STRIDX_COPY 155 /* 'copy' */ +#define DUK_STRIDX_EQUALS 156 /* 'equals' */ +#define DUK_STRIDX_FILL 157 /* 'fill' */ +#define DUK_STRIDX_WRITE 158 /* 'write' */ +#define DUK_STRIDX_COMPARE 159 /* 'compare' */ +#define DUK_STRIDX_BYTE_LENGTH 160 /* 'byteLength' */ +#define DUK_STRIDX_IS_BUFFER 161 /* 'isBuffer' */ +#define DUK_STRIDX_IS_ENCODING 162 /* 'isEncoding' */ +#define DUK_STRIDX_EXPORTS 163 /* 'exports' */ +#define DUK_STRIDX_ID 164 /* 'id' */ +#define DUK_STRIDX_REQUIRE 165 /* 'require' */ +#define DUK_STRIDX___PROTO__ 166 /* '__proto__' */ +#define DUK_STRIDX_SET_PROTOTYPE_OF 167 /* 'setPrototypeOf' */ +#define DUK_STRIDX_OWN_KEYS 168 /* 'ownKeys' */ +#define DUK_STRIDX_ENUMERATE 169 /* 'enumerate' */ +#define DUK_STRIDX_DELETE_PROPERTY 170 /* 'deleteProperty' */ +#define DUK_STRIDX_HAS 171 /* 'has' */ +#define DUK_STRIDX_PROXY 172 /* 'Proxy' */ +#define DUK_STRIDX_CALLEE 173 /* 'callee' */ +#define DUK_STRIDX_INVALID_DATE 174 /* 'Invalid Date' */ +#define DUK_STRIDX_BRACKETED_ELLIPSIS 175 /* '[...]' */ +#define DUK_STRIDX_NEWLINE_TAB 176 /* '\n\t' */ +#define DUK_STRIDX_SPACE 177 /* ' ' */ +#define DUK_STRIDX_COMMA 178 /* ',' */ +#define DUK_STRIDX_MINUS_ZERO 179 /* '-0' */ +#define DUK_STRIDX_PLUS_ZERO 180 /* '+0' */ +#define DUK_STRIDX_ZERO 181 /* '0' */ +#define DUK_STRIDX_MINUS_INFINITY 182 /* '-Infinity' */ +#define DUK_STRIDX_PLUS_INFINITY 183 /* '+Infinity' */ +#define DUK_STRIDX_INFINITY 184 /* 'Infinity' */ +#define DUK_STRIDX_LC_OBJECT 185 /* 'object' */ +#define DUK_STRIDX_LC_STRING 186 /* 'string' */ +#define DUK_STRIDX_LC_NUMBER 187 /* 'number' */ +#define DUK_STRIDX_LC_BOOLEAN 188 /* 'boolean' */ +#define DUK_STRIDX_LC_UNDEFINED 189 /* 'undefined' */ +#define DUK_STRIDX_STRINGIFY 190 /* 'stringify' */ +#define DUK_STRIDX_TAN 191 /* 'tan' */ +#define DUK_STRIDX_SQRT 192 /* 'sqrt' */ +#define DUK_STRIDX_SIN 193 /* 'sin' */ +#define DUK_STRIDX_ROUND 194 /* 'round' */ +#define DUK_STRIDX_RANDOM 195 /* 'random' */ +#define DUK_STRIDX_POW 196 /* 'pow' */ +#define DUK_STRIDX_MIN 197 /* 'min' */ +#define DUK_STRIDX_MAX 198 /* 'max' */ +#define DUK_STRIDX_LOG 199 /* 'log' */ +#define DUK_STRIDX_FLOOR 200 /* 'floor' */ +#define DUK_STRIDX_EXP 201 /* 'exp' */ +#define DUK_STRIDX_COS 202 /* 'cos' */ +#define DUK_STRIDX_CEIL 203 /* 'ceil' */ +#define DUK_STRIDX_ATAN2 204 /* 'atan2' */ +#define DUK_STRIDX_ATAN 205 /* 'atan' */ +#define DUK_STRIDX_ASIN 206 /* 'asin' */ +#define DUK_STRIDX_ACOS 207 /* 'acos' */ +#define DUK_STRIDX_ABS 208 /* 'abs' */ +#define DUK_STRIDX_SQRT2 209 /* 'SQRT2' */ +#define DUK_STRIDX_SQRT1_2 210 /* 'SQRT1_2' */ +#define DUK_STRIDX_PI 211 /* 'PI' */ +#define DUK_STRIDX_LOG10E 212 /* 'LOG10E' */ +#define DUK_STRIDX_LOG2E 213 /* 'LOG2E' */ +#define DUK_STRIDX_LN2 214 /* 'LN2' */ +#define DUK_STRIDX_LN10 215 /* 'LN10' */ +#define DUK_STRIDX_E 216 /* 'E' */ +#define DUK_STRIDX_MESSAGE 217 /* 'message' */ +#define DUK_STRIDX_NAME 218 /* 'name' */ +#define DUK_STRIDX_INPUT 219 /* 'input' */ +#define DUK_STRIDX_INDEX 220 /* 'index' */ +#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP 221 /* '(?:)' */ +#define DUK_STRIDX_LAST_INDEX 222 /* 'lastIndex' */ +#define DUK_STRIDX_MULTILINE 223 /* 'multiline' */ +#define DUK_STRIDX_IGNORE_CASE 224 /* 'ignoreCase' */ +#define DUK_STRIDX_SOURCE 225 /* 'source' */ +#define DUK_STRIDX_TEST 226 /* 'test' */ +#define DUK_STRIDX_EXEC 227 /* 'exec' */ +#define DUK_STRIDX_TO_GMT_STRING 228 /* 'toGMTString' */ +#define DUK_STRIDX_SET_YEAR 229 /* 'setYear' */ +#define DUK_STRIDX_GET_YEAR 230 /* 'getYear' */ +#define DUK_STRIDX_TO_JSON 231 /* 'toJSON' */ +#define DUK_STRIDX_TO_ISO_STRING 232 /* 'toISOString' */ +#define DUK_STRIDX_TO_UTC_STRING 233 /* 'toUTCString' */ +#define DUK_STRIDX_SET_UTC_FULL_YEAR 234 /* 'setUTCFullYear' */ +#define DUK_STRIDX_SET_FULL_YEAR 235 /* 'setFullYear' */ +#define DUK_STRIDX_SET_UTC_MONTH 236 /* 'setUTCMonth' */ +#define DUK_STRIDX_SET_MONTH 237 /* 'setMonth' */ +#define DUK_STRIDX_SET_UTC_DATE 238 /* 'setUTCDate' */ +#define DUK_STRIDX_SET_DATE 239 /* 'setDate' */ +#define DUK_STRIDX_SET_UTC_HOURS 240 /* 'setUTCHours' */ +#define DUK_STRIDX_SET_HOURS 241 /* 'setHours' */ +#define DUK_STRIDX_SET_UTC_MINUTES 242 /* 'setUTCMinutes' */ +#define DUK_STRIDX_SET_MINUTES 243 /* 'setMinutes' */ +#define DUK_STRIDX_SET_UTC_SECONDS 244 /* 'setUTCSeconds' */ +#define DUK_STRIDX_SET_SECONDS 245 /* 'setSeconds' */ +#define DUK_STRIDX_SET_UTC_MILLISECONDS 246 /* 'setUTCMilliseconds' */ +#define DUK_STRIDX_SET_MILLISECONDS 247 /* 'setMilliseconds' */ +#define DUK_STRIDX_SET_TIME 248 /* 'setTime' */ +#define DUK_STRIDX_GET_TIMEZONE_OFFSET 249 /* 'getTimezoneOffset' */ +#define DUK_STRIDX_GET_UTC_MILLISECONDS 250 /* 'getUTCMilliseconds' */ +#define DUK_STRIDX_GET_MILLISECONDS 251 /* 'getMilliseconds' */ +#define DUK_STRIDX_GET_UTC_SECONDS 252 /* 'getUTCSeconds' */ +#define DUK_STRIDX_GET_SECONDS 253 /* 'getSeconds' */ +#define DUK_STRIDX_GET_UTC_MINUTES 254 /* 'getUTCMinutes' */ +#define DUK_STRIDX_GET_MINUTES 255 /* 'getMinutes' */ +#define DUK_STRIDX_GET_UTC_HOURS 256 /* 'getUTCHours' */ +#define DUK_STRIDX_GET_HOURS 257 /* 'getHours' */ +#define DUK_STRIDX_GET_UTC_DAY 258 /* 'getUTCDay' */ +#define DUK_STRIDX_GET_DAY 259 /* 'getDay' */ +#define DUK_STRIDX_GET_UTC_DATE 260 /* 'getUTCDate' */ +#define DUK_STRIDX_GET_DATE 261 /* 'getDate' */ +#define DUK_STRIDX_GET_UTC_MONTH 262 /* 'getUTCMonth' */ +#define DUK_STRIDX_GET_MONTH 263 /* 'getMonth' */ +#define DUK_STRIDX_GET_UTC_FULL_YEAR 264 /* 'getUTCFullYear' */ +#define DUK_STRIDX_GET_FULL_YEAR 265 /* 'getFullYear' */ +#define DUK_STRIDX_GET_TIME 266 /* 'getTime' */ +#define DUK_STRIDX_TO_LOCALE_TIME_STRING 267 /* 'toLocaleTimeString' */ +#define DUK_STRIDX_TO_LOCALE_DATE_STRING 268 /* 'toLocaleDateString' */ +#define DUK_STRIDX_TO_TIME_STRING 269 /* 'toTimeString' */ +#define DUK_STRIDX_TO_DATE_STRING 270 /* 'toDateString' */ +#define DUK_STRIDX_NOW 271 /* 'now' */ +#define DUK_STRIDX_UTC 272 /* 'UTC' */ +#define DUK_STRIDX_PARSE 273 /* 'parse' */ +#define DUK_STRIDX_TO_PRECISION 274 /* 'toPrecision' */ +#define DUK_STRIDX_TO_EXPONENTIAL 275 /* 'toExponential' */ +#define DUK_STRIDX_TO_FIXED 276 /* 'toFixed' */ +#define DUK_STRIDX_POSITIVE_INFINITY 277 /* 'POSITIVE_INFINITY' */ +#define DUK_STRIDX_NEGATIVE_INFINITY 278 /* 'NEGATIVE_INFINITY' */ +#define DUK_STRIDX_NAN 279 /* 'NaN' */ +#define DUK_STRIDX_MIN_VALUE 280 /* 'MIN_VALUE' */ +#define DUK_STRIDX_MAX_VALUE 281 /* 'MAX_VALUE' */ +#define DUK_STRIDX_SUBSTR 282 /* 'substr' */ +#define DUK_STRIDX_TRIM 283 /* 'trim' */ +#define DUK_STRIDX_TO_LOCALE_UPPER_CASE 284 /* 'toLocaleUpperCase' */ +#define DUK_STRIDX_TO_UPPER_CASE 285 /* 'toUpperCase' */ +#define DUK_STRIDX_TO_LOCALE_LOWER_CASE 286 /* 'toLocaleLowerCase' */ +#define DUK_STRIDX_TO_LOWER_CASE 287 /* 'toLowerCase' */ +#define DUK_STRIDX_SUBSTRING 288 /* 'substring' */ +#define DUK_STRIDX_SPLIT 289 /* 'split' */ +#define DUK_STRIDX_SEARCH 290 /* 'search' */ +#define DUK_STRIDX_REPLACE 291 /* 'replace' */ +#define DUK_STRIDX_MATCH 292 /* 'match' */ +#define DUK_STRIDX_LOCALE_COMPARE 293 /* 'localeCompare' */ +#define DUK_STRIDX_CHAR_CODE_AT 294 /* 'charCodeAt' */ +#define DUK_STRIDX_CHAR_AT 295 /* 'charAt' */ +#define DUK_STRIDX_FROM_CHAR_CODE 296 /* 'fromCharCode' */ +#define DUK_STRIDX_REDUCE_RIGHT 297 /* 'reduceRight' */ +#define DUK_STRIDX_REDUCE 298 /* 'reduce' */ +#define DUK_STRIDX_FILTER 299 /* 'filter' */ +#define DUK_STRIDX_MAP 300 /* 'map' */ +#define DUK_STRIDX_FOR_EACH 301 /* 'forEach' */ +#define DUK_STRIDX_SOME 302 /* 'some' */ +#define DUK_STRIDX_EVERY 303 /* 'every' */ +#define DUK_STRIDX_LAST_INDEX_OF 304 /* 'lastIndexOf' */ +#define DUK_STRIDX_INDEX_OF 305 /* 'indexOf' */ +#define DUK_STRIDX_UNSHIFT 306 /* 'unshift' */ +#define DUK_STRIDX_SPLICE 307 /* 'splice' */ +#define DUK_STRIDX_SORT 308 /* 'sort' */ +#define DUK_STRIDX_SLICE 309 /* 'slice' */ +#define DUK_STRIDX_SHIFT 310 /* 'shift' */ +#define DUK_STRIDX_REVERSE 311 /* 'reverse' */ +#define DUK_STRIDX_PUSH 312 /* 'push' */ +#define DUK_STRIDX_POP 313 /* 'pop' */ +#define DUK_STRIDX_JOIN 314 /* 'join' */ +#define DUK_STRIDX_CONCAT 315 /* 'concat' */ +#define DUK_STRIDX_IS_ARRAY 316 /* 'isArray' */ +#define DUK_STRIDX_LC_ARGUMENTS 317 /* 'arguments' */ +#define DUK_STRIDX_CALLER 318 /* 'caller' */ +#define DUK_STRIDX_BIND 319 /* 'bind' */ +#define DUK_STRIDX_CALL 320 /* 'call' */ +#define DUK_STRIDX_APPLY 321 /* 'apply' */ +#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE 322 /* 'propertyIsEnumerable' */ +#define DUK_STRIDX_IS_PROTOTYPE_OF 323 /* 'isPrototypeOf' */ +#define DUK_STRIDX_HAS_OWN_PROPERTY 324 /* 'hasOwnProperty' */ +#define DUK_STRIDX_VALUE_OF 325 /* 'valueOf' */ +#define DUK_STRIDX_TO_LOCALE_STRING 326 /* 'toLocaleString' */ +#define DUK_STRIDX_TO_STRING 327 /* 'toString' */ +#define DUK_STRIDX_CONSTRUCTOR 328 /* 'constructor' */ +#define DUK_STRIDX_SET 329 /* 'set' */ +#define DUK_STRIDX_GET 330 /* 'get' */ +#define DUK_STRIDX_ENUMERABLE 331 /* 'enumerable' */ +#define DUK_STRIDX_CONFIGURABLE 332 /* 'configurable' */ +#define DUK_STRIDX_WRITABLE 333 /* 'writable' */ +#define DUK_STRIDX_VALUE 334 /* 'value' */ +#define DUK_STRIDX_KEYS 335 /* 'keys' */ +#define DUK_STRIDX_IS_EXTENSIBLE 336 /* 'isExtensible' */ +#define DUK_STRIDX_IS_FROZEN 337 /* 'isFrozen' */ +#define DUK_STRIDX_IS_SEALED 338 /* 'isSealed' */ +#define DUK_STRIDX_PREVENT_EXTENSIONS 339 /* 'preventExtensions' */ +#define DUK_STRIDX_FREEZE 340 /* 'freeze' */ +#define DUK_STRIDX_SEAL 341 /* 'seal' */ +#define DUK_STRIDX_DEFINE_PROPERTIES 342 /* 'defineProperties' */ +#define DUK_STRIDX_DEFINE_PROPERTY 343 /* 'defineProperty' */ +#define DUK_STRIDX_CREATE 344 /* 'create' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES 345 /* 'getOwnPropertyNames' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR 346 /* 'getOwnPropertyDescriptor' */ +#define DUK_STRIDX_GET_PROTOTYPE_OF 347 /* 'getPrototypeOf' */ +#define DUK_STRIDX_PROTOTYPE 348 /* 'prototype' */ +#define DUK_STRIDX_LENGTH 349 /* 'length' */ +#define DUK_STRIDX_ALERT 350 /* 'alert' */ +#define DUK_STRIDX_PRINT 351 /* 'print' */ +#define DUK_STRIDX_UNESCAPE 352 /* 'unescape' */ +#define DUK_STRIDX_ESCAPE 353 /* 'escape' */ +#define DUK_STRIDX_ENCODE_URI_COMPONENT 354 /* 'encodeURIComponent' */ +#define DUK_STRIDX_ENCODE_URI 355 /* 'encodeURI' */ +#define DUK_STRIDX_DECODE_URI_COMPONENT 356 /* 'decodeURIComponent' */ +#define DUK_STRIDX_DECODE_URI 357 /* 'decodeURI' */ +#define DUK_STRIDX_IS_FINITE 358 /* 'isFinite' */ +#define DUK_STRIDX_IS_NAN 359 /* 'isNaN' */ +#define DUK_STRIDX_PARSE_FLOAT 360 /* 'parseFloat' */ +#define DUK_STRIDX_PARSE_INT 361 /* 'parseInt' */ +#define DUK_STRIDX_EVAL 362 /* 'eval' */ +#define DUK_STRIDX_URI_ERROR 363 /* 'URIError' */ +#define DUK_STRIDX_TYPE_ERROR 364 /* 'TypeError' */ +#define DUK_STRIDX_SYNTAX_ERROR 365 /* 'SyntaxError' */ +#define DUK_STRIDX_REFERENCE_ERROR 366 /* 'ReferenceError' */ +#define DUK_STRIDX_RANGE_ERROR 367 /* 'RangeError' */ +#define DUK_STRIDX_EVAL_ERROR 368 /* 'EvalError' */ +#define DUK_STRIDX_BREAK 369 /* 'break' */ +#define DUK_STRIDX_CASE 370 /* 'case' */ +#define DUK_STRIDX_CATCH 371 /* 'catch' */ +#define DUK_STRIDX_CONTINUE 372 /* 'continue' */ +#define DUK_STRIDX_DEBUGGER 373 /* 'debugger' */ +#define DUK_STRIDX_DEFAULT 374 /* 'default' */ +#define DUK_STRIDX_DELETE 375 /* 'delete' */ +#define DUK_STRIDX_DO 376 /* 'do' */ +#define DUK_STRIDX_ELSE 377 /* 'else' */ +#define DUK_STRIDX_FINALLY 378 /* 'finally' */ +#define DUK_STRIDX_FOR 379 /* 'for' */ +#define DUK_STRIDX_LC_FUNCTION 380 /* 'function' */ +#define DUK_STRIDX_IF 381 /* 'if' */ +#define DUK_STRIDX_IN 382 /* 'in' */ +#define DUK_STRIDX_INSTANCEOF 383 /* 'instanceof' */ +#define DUK_STRIDX_NEW 384 /* 'new' */ +#define DUK_STRIDX_RETURN 385 /* 'return' */ +#define DUK_STRIDX_SWITCH 386 /* 'switch' */ +#define DUK_STRIDX_THIS 387 /* 'this' */ +#define DUK_STRIDX_THROW 388 /* 'throw' */ +#define DUK_STRIDX_TRY 389 /* 'try' */ +#define DUK_STRIDX_TYPEOF 390 /* 'typeof' */ +#define DUK_STRIDX_VAR 391 /* 'var' */ +#define DUK_STRIDX_VOID 392 /* 'void' */ +#define DUK_STRIDX_WHILE 393 /* 'while' */ +#define DUK_STRIDX_WITH 394 /* 'with' */ +#define DUK_STRIDX_CLASS 395 /* 'class' */ +#define DUK_STRIDX_CONST 396 /* 'const' */ +#define DUK_STRIDX_ENUM 397 /* 'enum' */ +#define DUK_STRIDX_EXPORT 398 /* 'export' */ +#define DUK_STRIDX_EXTENDS 399 /* 'extends' */ +#define DUK_STRIDX_IMPORT 400 /* 'import' */ +#define DUK_STRIDX_SUPER 401 /* 'super' */ +#define DUK_STRIDX_LC_NULL 402 /* 'null' */ +#define DUK_STRIDX_TRUE 403 /* 'true' */ +#define DUK_STRIDX_FALSE 404 /* 'false' */ +#define DUK_STRIDX_IMPLEMENTS 405 /* 'implements' */ +#define DUK_STRIDX_INTERFACE 406 /* 'interface' */ +#define DUK_STRIDX_LET 407 /* 'let' */ +#define DUK_STRIDX_PACKAGE 408 /* 'package' */ +#define DUK_STRIDX_PRIVATE 409 /* 'private' */ +#define DUK_STRIDX_PROTECTED 410 /* 'protected' */ +#define DUK_STRIDX_PUBLIC 411 /* 'public' */ +#define DUK_STRIDX_STATIC 412 /* 'static' */ +#define DUK_STRIDX_YIELD 413 /* 'yield' */ + +#define DUK_HEAP_STRING_UC_LOGGER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER) +#define DUK_HTHREAD_STRING_UC_LOGGER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER) +#define DUK_HEAP_STRING_UC_THREAD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD) +#define DUK_HTHREAD_STRING_UC_THREAD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD) +#define DUK_HEAP_STRING_UC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER) +#define DUK_HTHREAD_STRING_UC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER) +#define DUK_HEAP_STRING_DEC_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV) +#define DUK_HTHREAD_STRING_DEC_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV) +#define DUK_HEAP_STRING_OBJ_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV) +#define DUK_HTHREAD_STRING_OBJ_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV) +#define DUK_HEAP_STRING_FLOAT64_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT64_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HEAP_STRING_FLOAT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HEAP_STRING_UINT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HTHREAD_STRING_UINT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HEAP_STRING_INT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT32_ARRAY) +#define DUK_HTHREAD_STRING_INT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT32_ARRAY) +#define DUK_HEAP_STRING_UINT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HTHREAD_STRING_UINT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HEAP_STRING_INT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT16_ARRAY) +#define DUK_HTHREAD_STRING_INT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT16_ARRAY) +#define DUK_HEAP_STRING_UINT8_CLAMPED_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_CLAMPED_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HEAP_STRING_UINT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HEAP_STRING_INT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT8_ARRAY) +#define DUK_HTHREAD_STRING_INT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT8_ARRAY) +#define DUK_HEAP_STRING_DATA_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA_VIEW) +#define DUK_HTHREAD_STRING_DATA_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA_VIEW) +#define DUK_HEAP_STRING_ARRAY_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HTHREAD_STRING_ARRAY_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HEAP_STRING_UC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER) +#define DUK_HTHREAD_STRING_UC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER) +#define DUK_HEAP_STRING_EMPTY_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING) +#define DUK_HTHREAD_STRING_EMPTY_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING) +#define DUK_HEAP_STRING_GLOBAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL) +#define DUK_HTHREAD_STRING_GLOBAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL) +#define DUK_HEAP_STRING_UC_ARGUMENTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS) +#define DUK_HTHREAD_STRING_UC_ARGUMENTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS) +#define DUK_HEAP_STRING_JSON(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON) +#define DUK_HTHREAD_STRING_JSON(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON) +#define DUK_HEAP_STRING_MATH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH) +#define DUK_HTHREAD_STRING_MATH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH) +#define DUK_HEAP_STRING_UC_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR) +#define DUK_HTHREAD_STRING_UC_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR) +#define DUK_HEAP_STRING_REG_EXP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP) +#define DUK_HTHREAD_STRING_REG_EXP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP) +#define DUK_HEAP_STRING_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATE) +#define DUK_HTHREAD_STRING_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATE) +#define DUK_HEAP_STRING_UC_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER) +#define DUK_HTHREAD_STRING_UC_NUMBER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER) +#define DUK_HEAP_STRING_UC_BOOLEAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN) +#define DUK_HTHREAD_STRING_UC_BOOLEAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN) +#define DUK_HEAP_STRING_UC_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING) +#define DUK_HTHREAD_STRING_UC_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING) +#define DUK_HEAP_STRING_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY) +#define DUK_HTHREAD_STRING_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY) +#define DUK_HEAP_STRING_UC_FUNCTION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION) +#define DUK_HTHREAD_STRING_UC_FUNCTION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION) +#define DUK_HEAP_STRING_UC_OBJECT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT) +#define DUK_HTHREAD_STRING_UC_OBJECT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT) +#define DUK_HEAP_STRING_UC_NULL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL) +#define DUK_HTHREAD_STRING_UC_NULL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL) +#define DUK_HEAP_STRING_UC_UNDEFINED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED) +#define DUK_HTHREAD_STRING_UC_UNDEFINED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED) +#define DUK_HEAP_STRING_JSON_EXT_FUNCTION2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2) +#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2) +#define DUK_HEAP_STRING_JSON_EXT_FUNCTION1(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1) +#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1) +#define DUK_HEAP_STRING_JSON_EXT_NEGINF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF) +#define DUK_HTHREAD_STRING_JSON_EXT_NEGINF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF) +#define DUK_HEAP_STRING_JSON_EXT_POSINF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF) +#define DUK_HTHREAD_STRING_JSON_EXT_POSINF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF) +#define DUK_HEAP_STRING_JSON_EXT_NAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN) +#define DUK_HTHREAD_STRING_JSON_EXT_NAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN) +#define DUK_HEAP_STRING_JSON_EXT_UNDEFINED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED) +#define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED) +#define DUK_HEAP_STRING_TO_LOG_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOG_STRING) +#define DUK_HTHREAD_STRING_TO_LOG_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOG_STRING) +#define DUK_HEAP_STRING_CLOG(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLOG) +#define DUK_HTHREAD_STRING_CLOG(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLOG) +#define DUK_HEAP_STRING_LC_L(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_L) +#define DUK_HTHREAD_STRING_LC_L(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_L) +#define DUK_HEAP_STRING_LC_N(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_N) +#define DUK_HTHREAD_STRING_LC_N(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_N) +#define DUK_HEAP_STRING_LC_FATAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FATAL) +#define DUK_HTHREAD_STRING_LC_FATAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FATAL) +#define DUK_HEAP_STRING_LC_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ERROR) +#define DUK_HTHREAD_STRING_LC_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ERROR) +#define DUK_HEAP_STRING_LC_WARN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_WARN) +#define DUK_HTHREAD_STRING_LC_WARN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_WARN) +#define DUK_HEAP_STRING_LC_DEBUG(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_DEBUG) +#define DUK_HTHREAD_STRING_LC_DEBUG(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_DEBUG) +#define DUK_HEAP_STRING_LC_TRACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_TRACE) +#define DUK_HTHREAD_STRING_LC_TRACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_TRACE) +#define DUK_HEAP_STRING_RAW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RAW) +#define DUK_HTHREAD_STRING_RAW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RAW) +#define DUK_HEAP_STRING_FMT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FMT) +#define DUK_HTHREAD_STRING_FMT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FMT) +#define DUK_HEAP_STRING_CURRENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CURRENT) +#define DUK_HTHREAD_STRING_CURRENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CURRENT) +#define DUK_HEAP_STRING_RESUME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RESUME) +#define DUK_HTHREAD_STRING_RESUME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RESUME) +#define DUK_HEAP_STRING_COMPACT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPACT) +#define DUK_HTHREAD_STRING_COMPACT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPACT) +#define DUK_HEAP_STRING_JC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC) +#define DUK_HTHREAD_STRING_JC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC) +#define DUK_HEAP_STRING_JX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX) +#define DUK_HTHREAD_STRING_JX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX) +#define DUK_HEAP_STRING_BASE64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64) +#define DUK_HTHREAD_STRING_BASE64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64) +#define DUK_HEAP_STRING_HEX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX) +#define DUK_HTHREAD_STRING_HEX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX) +#define DUK_HEAP_STRING_DEC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC) +#define DUK_HTHREAD_STRING_DEC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC) +#define DUK_HEAP_STRING_ENC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENC) +#define DUK_HTHREAD_STRING_ENC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENC) +#define DUK_HEAP_STRING_FIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FIN) +#define DUK_HTHREAD_STRING_FIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FIN) +#define DUK_HEAP_STRING_GC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GC) +#define DUK_HTHREAD_STRING_GC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GC) +#define DUK_HEAP_STRING_ACT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACT) +#define DUK_HTHREAD_STRING_ACT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACT) +#define DUK_HEAP_STRING_LC_INFO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_INFO) +#define DUK_HTHREAD_STRING_LC_INFO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_INFO) +#define DUK_HEAP_STRING_VERSION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VERSION) +#define DUK_HTHREAD_STRING_VERSION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VERSION) +#define DUK_HEAP_STRING_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV) +#define DUK_HTHREAD_STRING_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV) +#define DUK_HEAP_STRING_MOD_LOADED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_LOADED) +#define DUK_HTHREAD_STRING_MOD_LOADED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_LOADED) +#define DUK_HEAP_STRING_MOD_SEARCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_SEARCH) +#define DUK_HTHREAD_STRING_MOD_SEARCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_SEARCH) +#define DUK_HEAP_STRING_ERR_THROW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW) +#define DUK_HTHREAD_STRING_ERR_THROW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW) +#define DUK_HEAP_STRING_ERR_CREATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE) +#define DUK_HTHREAD_STRING_ERR_CREATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE) +#define DUK_HEAP_STRING_COMPILE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE) +#define DUK_HTHREAD_STRING_COMPILE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE) +#define DUK_HEAP_STRING_INT_REGBASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_REGBASE) +#define DUK_HTHREAD_STRING_INT_REGBASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_REGBASE) +#define DUK_HEAP_STRING_INT_THREAD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THREAD) +#define DUK_HTHREAD_STRING_INT_THREAD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THREAD) +#define DUK_HEAP_STRING_INT_HANDLER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_HANDLER) +#define DUK_HTHREAD_STRING_INT_HANDLER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_HANDLER) +#define DUK_HEAP_STRING_INT_FINALIZER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER) +#define DUK_HTHREAD_STRING_INT_FINALIZER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER) +#define DUK_HEAP_STRING_INT_CALLEE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_CALLEE) +#define DUK_HTHREAD_STRING_INT_CALLEE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_CALLEE) +#define DUK_HEAP_STRING_INT_MAP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP) +#define DUK_HTHREAD_STRING_INT_MAP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP) +#define DUK_HEAP_STRING_INT_ARGS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_ARGS) +#define DUK_HTHREAD_STRING_INT_ARGS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_ARGS) +#define DUK_HEAP_STRING_INT_THIS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THIS) +#define DUK_HTHREAD_STRING_INT_THIS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THIS) +#define DUK_HEAP_STRING_INT_PC2LINE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE) +#define DUK_HTHREAD_STRING_INT_PC2LINE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE) +#define DUK_HEAP_STRING_INT_SOURCE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE) +#define DUK_HTHREAD_STRING_INT_SOURCE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE) +#define DUK_HEAP_STRING_INT_VARENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV) +#define DUK_HTHREAD_STRING_INT_VARENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV) +#define DUK_HEAP_STRING_INT_LEXENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_LEXENV) +#define DUK_HTHREAD_STRING_INT_LEXENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_LEXENV) +#define DUK_HEAP_STRING_INT_VARMAP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP) +#define DUK_HTHREAD_STRING_INT_VARMAP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP) +#define DUK_HEAP_STRING_INT_FORMALS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS) +#define DUK_HTHREAD_STRING_INT_FORMALS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS) +#define DUK_HEAP_STRING_INT_BYTECODE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE) +#define DUK_HTHREAD_STRING_INT_BYTECODE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE) +#define DUK_HEAP_STRING_INT_NEXT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT) +#define DUK_HTHREAD_STRING_INT_NEXT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT) +#define DUK_HEAP_STRING_INT_TARGET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET) +#define DUK_HTHREAD_STRING_INT_TARGET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET) +#define DUK_HEAP_STRING_INT_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE) +#define DUK_HTHREAD_STRING_INT_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE) +#define DUK_HEAP_STRING_LC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER) +#define DUK_HTHREAD_STRING_LC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER) +#define DUK_HEAP_STRING_INT_TRACEDATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA) +#define DUK_HTHREAD_STRING_INT_TRACEDATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA) +#define DUK_HEAP_STRING_LINE_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER) +#define DUK_HTHREAD_STRING_LINE_NUMBER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER) +#define DUK_HEAP_STRING_FILE_NAME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME) +#define DUK_HTHREAD_STRING_FILE_NAME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME) +#define DUK_HEAP_STRING_PC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC) +#define DUK_HTHREAD_STRING_PC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC) +#define DUK_HEAP_STRING_STACK(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK) +#define DUK_HTHREAD_STRING_STACK(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK) +#define DUK_HEAP_STRING_THROW_TYPE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW_TYPE_ERROR) +#define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR) +#define DUK_HEAP_STRING_DUKTAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE) +#define DUK_HTHREAD_STRING_DUKTAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE) +#define DUK_HEAP_STRING_SET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT64) +#define DUK_HTHREAD_STRING_SET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT64) +#define DUK_HEAP_STRING_SET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT32) +#define DUK_HTHREAD_STRING_SET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT32) +#define DUK_HEAP_STRING_SET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT32) +#define DUK_HTHREAD_STRING_SET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT32) +#define DUK_HEAP_STRING_SET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT32) +#define DUK_HTHREAD_STRING_SET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT32) +#define DUK_HEAP_STRING_SET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT16) +#define DUK_HTHREAD_STRING_SET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT16) +#define DUK_HEAP_STRING_SET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT16) +#define DUK_HTHREAD_STRING_SET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT16) +#define DUK_HEAP_STRING_SET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT8) +#define DUK_HTHREAD_STRING_SET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT8) +#define DUK_HEAP_STRING_SET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT8) +#define DUK_HTHREAD_STRING_SET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT8) +#define DUK_HEAP_STRING_GET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT64) +#define DUK_HTHREAD_STRING_GET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT64) +#define DUK_HEAP_STRING_GET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT32) +#define DUK_HTHREAD_STRING_GET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT32) +#define DUK_HEAP_STRING_GET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT32) +#define DUK_HTHREAD_STRING_GET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT32) +#define DUK_HEAP_STRING_GET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT32) +#define DUK_HTHREAD_STRING_GET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT32) +#define DUK_HEAP_STRING_GET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT16) +#define DUK_HTHREAD_STRING_GET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT16) +#define DUK_HEAP_STRING_GET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT16) +#define DUK_HTHREAD_STRING_GET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT16) +#define DUK_HEAP_STRING_GET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT8) +#define DUK_HTHREAD_STRING_GET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT8) +#define DUK_HEAP_STRING_GET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT8) +#define DUK_HTHREAD_STRING_GET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT8) +#define DUK_HEAP_STRING_SUBARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBARRAY) +#define DUK_HTHREAD_STRING_SUBARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBARRAY) +#define DUK_HEAP_STRING_BYTES_PER_ELEMENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HEAP_STRING_BYTE_OFFSET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HTHREAD_STRING_BYTE_OFFSET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HEAP_STRING_LC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER) +#define DUK_HTHREAD_STRING_LC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER) +#define DUK_HEAP_STRING_IS_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_VIEW) +#define DUK_HTHREAD_STRING_IS_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_VIEW) +#define DUK_HEAP_STRING_DATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA) +#define DUK_HTHREAD_STRING_DATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA) +#define DUK_HEAP_STRING_TYPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE) +#define DUK_HTHREAD_STRING_TYPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE) +#define DUK_HEAP_STRING_WRITE_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HTHREAD_STRING_WRITE_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HEAP_STRING_WRITE_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HTHREAD_STRING_WRITE_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HEAP_STRING_WRITE_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HEAP_STRING_WRITE_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HEAP_STRING_WRITE_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HEAP_STRING_WRITE_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HEAP_STRING_WRITE_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HTHREAD_STRING_WRITE_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HEAP_STRING_WRITE_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HTHREAD_STRING_WRITE_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HEAP_STRING_WRITE_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HEAP_STRING_WRITE_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HEAP_STRING_WRITE_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HTHREAD_STRING_WRITE_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HEAP_STRING_WRITE_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HTHREAD_STRING_WRITE_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HEAP_STRING_WRITE_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HEAP_STRING_WRITE_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HEAP_STRING_WRITE_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT8) +#define DUK_HTHREAD_STRING_WRITE_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT8) +#define DUK_HEAP_STRING_WRITE_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT8) +#define DUK_HTHREAD_STRING_WRITE_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT8) +#define DUK_HEAP_STRING_READ_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_BE) +#define DUK_HTHREAD_STRING_READ_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_BE) +#define DUK_HEAP_STRING_READ_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_LE) +#define DUK_HTHREAD_STRING_READ_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_LE) +#define DUK_HEAP_STRING_READ_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_BE) +#define DUK_HTHREAD_STRING_READ_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_BE) +#define DUK_HEAP_STRING_READ_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_LE) +#define DUK_HTHREAD_STRING_READ_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_LE) +#define DUK_HEAP_STRING_READ_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HEAP_STRING_READ_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HEAP_STRING_READ_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HTHREAD_STRING_READ_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HEAP_STRING_READ_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HTHREAD_STRING_READ_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HEAP_STRING_READ_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_BE) +#define DUK_HTHREAD_STRING_READ_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_BE) +#define DUK_HEAP_STRING_READ_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_LE) +#define DUK_HTHREAD_STRING_READ_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_LE) +#define DUK_HEAP_STRING_READ_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HTHREAD_STRING_READ_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HEAP_STRING_READ_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HTHREAD_STRING_READ_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HEAP_STRING_READ_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_BE) +#define DUK_HTHREAD_STRING_READ_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_BE) +#define DUK_HEAP_STRING_READ_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_LE) +#define DUK_HTHREAD_STRING_READ_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_LE) +#define DUK_HEAP_STRING_READ_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HTHREAD_STRING_READ_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HEAP_STRING_READ_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HTHREAD_STRING_READ_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HEAP_STRING_READ_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT8) +#define DUK_HTHREAD_STRING_READ_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT8) +#define DUK_HEAP_STRING_READ_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT8) +#define DUK_HTHREAD_STRING_READ_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT8) +#define DUK_HEAP_STRING_COPY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COPY) +#define DUK_HTHREAD_STRING_COPY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COPY) +#define DUK_HEAP_STRING_EQUALS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EQUALS) +#define DUK_HTHREAD_STRING_EQUALS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EQUALS) +#define DUK_HEAP_STRING_FILL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILL) +#define DUK_HTHREAD_STRING_FILL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILL) +#define DUK_HEAP_STRING_WRITE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE) +#define DUK_HTHREAD_STRING_WRITE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE) +#define DUK_HEAP_STRING_COMPARE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPARE) +#define DUK_HTHREAD_STRING_COMPARE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPARE) +#define DUK_HEAP_STRING_BYTE_LENGTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HTHREAD_STRING_BYTE_LENGTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HEAP_STRING_IS_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_BUFFER) +#define DUK_HTHREAD_STRING_IS_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_BUFFER) +#define DUK_HEAP_STRING_IS_ENCODING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ENCODING) +#define DUK_HTHREAD_STRING_IS_ENCODING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ENCODING) +#define DUK_HEAP_STRING_EXPORTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORTS) +#define DUK_HTHREAD_STRING_EXPORTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORTS) +#define DUK_HEAP_STRING_ID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID) +#define DUK_HTHREAD_STRING_ID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID) +#define DUK_HEAP_STRING_REQUIRE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE) +#define DUK_HTHREAD_STRING_REQUIRE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REQUIRE) +#define DUK_HEAP_STRING___PROTO__(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__) +#define DUK_HTHREAD_STRING___PROTO__(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__) +#define DUK_HEAP_STRING_SET_PROTOTYPE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF) +#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF) +#define DUK_HEAP_STRING_OWN_KEYS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS) +#define DUK_HTHREAD_STRING_OWN_KEYS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS) +#define DUK_HEAP_STRING_ENUMERATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERATE) +#define DUK_HTHREAD_STRING_ENUMERATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERATE) +#define DUK_HEAP_STRING_DELETE_PROPERTY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY) +#define DUK_HTHREAD_STRING_DELETE_PROPERTY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY) +#define DUK_HEAP_STRING_HAS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS) +#define DUK_HTHREAD_STRING_HAS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS) +#define DUK_HEAP_STRING_PROXY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROXY) +#define DUK_HTHREAD_STRING_PROXY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROXY) +#define DUK_HEAP_STRING_CALLEE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE) +#define DUK_HTHREAD_STRING_CALLEE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE) +#define DUK_HEAP_STRING_INVALID_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE) +#define DUK_HTHREAD_STRING_INVALID_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE) +#define DUK_HEAP_STRING_BRACKETED_ELLIPSIS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS) +#define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS) +#define DUK_HEAP_STRING_NEWLINE_TAB(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_TAB) +#define DUK_HTHREAD_STRING_NEWLINE_TAB(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_TAB) +#define DUK_HEAP_STRING_SPACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPACE) +#define DUK_HTHREAD_STRING_SPACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPACE) +#define DUK_HEAP_STRING_COMMA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA) +#define DUK_HTHREAD_STRING_COMMA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA) +#define DUK_HEAP_STRING_MINUS_ZERO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO) +#define DUK_HTHREAD_STRING_MINUS_ZERO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO) +#define DUK_HEAP_STRING_PLUS_ZERO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_ZERO) +#define DUK_HTHREAD_STRING_PLUS_ZERO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_ZERO) +#define DUK_HEAP_STRING_ZERO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ZERO) +#define DUK_HTHREAD_STRING_ZERO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ZERO) +#define DUK_HEAP_STRING_MINUS_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY) +#define DUK_HTHREAD_STRING_MINUS_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY) +#define DUK_HEAP_STRING_PLUS_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_INFINITY) +#define DUK_HTHREAD_STRING_PLUS_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_INFINITY) +#define DUK_HEAP_STRING_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY) +#define DUK_HTHREAD_STRING_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY) +#define DUK_HEAP_STRING_LC_OBJECT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT) +#define DUK_HTHREAD_STRING_LC_OBJECT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT) +#define DUK_HEAP_STRING_LC_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING) +#define DUK_HTHREAD_STRING_LC_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING) +#define DUK_HEAP_STRING_LC_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER) +#define DUK_HTHREAD_STRING_LC_NUMBER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER) +#define DUK_HEAP_STRING_LC_BOOLEAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN) +#define DUK_HTHREAD_STRING_LC_BOOLEAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN) +#define DUK_HEAP_STRING_LC_UNDEFINED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED) +#define DUK_HTHREAD_STRING_LC_UNDEFINED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED) +#define DUK_HEAP_STRING_STRINGIFY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STRINGIFY) +#define DUK_HTHREAD_STRING_STRINGIFY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STRINGIFY) +#define DUK_HEAP_STRING_TAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TAN) +#define DUK_HTHREAD_STRING_TAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TAN) +#define DUK_HEAP_STRING_SQRT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT) +#define DUK_HTHREAD_STRING_SQRT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT) +#define DUK_HEAP_STRING_SIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SIN) +#define DUK_HTHREAD_STRING_SIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SIN) +#define DUK_HEAP_STRING_ROUND(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ROUND) +#define DUK_HTHREAD_STRING_ROUND(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ROUND) +#define DUK_HEAP_STRING_RANDOM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANDOM) +#define DUK_HTHREAD_STRING_RANDOM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANDOM) +#define DUK_HEAP_STRING_POW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POW) +#define DUK_HTHREAD_STRING_POW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POW) +#define DUK_HEAP_STRING_MIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN) +#define DUK_HTHREAD_STRING_MIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN) +#define DUK_HEAP_STRING_MAX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX) +#define DUK_HTHREAD_STRING_MAX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX) +#define DUK_HEAP_STRING_LOG(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG) +#define DUK_HTHREAD_STRING_LOG(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG) +#define DUK_HEAP_STRING_FLOOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOOR) +#define DUK_HTHREAD_STRING_FLOOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOOR) +#define DUK_HEAP_STRING_EXP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXP) +#define DUK_HTHREAD_STRING_EXP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXP) +#define DUK_HEAP_STRING_COS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COS) +#define DUK_HTHREAD_STRING_COS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COS) +#define DUK_HEAP_STRING_CEIL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CEIL) +#define DUK_HTHREAD_STRING_CEIL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CEIL) +#define DUK_HEAP_STRING_ATAN2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN2) +#define DUK_HTHREAD_STRING_ATAN2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN2) +#define DUK_HEAP_STRING_ATAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN) +#define DUK_HTHREAD_STRING_ATAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN) +#define DUK_HEAP_STRING_ASIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ASIN) +#define DUK_HTHREAD_STRING_ASIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ASIN) +#define DUK_HEAP_STRING_ACOS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACOS) +#define DUK_HTHREAD_STRING_ACOS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACOS) +#define DUK_HEAP_STRING_ABS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ABS) +#define DUK_HTHREAD_STRING_ABS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ABS) +#define DUK_HEAP_STRING_SQRT2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT2) +#define DUK_HTHREAD_STRING_SQRT2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT2) +#define DUK_HEAP_STRING_SQRT1_2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT1_2) +#define DUK_HTHREAD_STRING_SQRT1_2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT1_2) +#define DUK_HEAP_STRING_PI(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PI) +#define DUK_HTHREAD_STRING_PI(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PI) +#define DUK_HEAP_STRING_LOG10E(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG10E) +#define DUK_HTHREAD_STRING_LOG10E(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG10E) +#define DUK_HEAP_STRING_LOG2E(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG2E) +#define DUK_HTHREAD_STRING_LOG2E(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG2E) +#define DUK_HEAP_STRING_LN2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN2) +#define DUK_HTHREAD_STRING_LN2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN2) +#define DUK_HEAP_STRING_LN10(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN10) +#define DUK_HTHREAD_STRING_LN10(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN10) +#define DUK_HEAP_STRING_E(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_E) +#define DUK_HTHREAD_STRING_E(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_E) +#define DUK_HEAP_STRING_MESSAGE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE) +#define DUK_HTHREAD_STRING_MESSAGE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE) +#define DUK_HEAP_STRING_NAME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME) +#define DUK_HTHREAD_STRING_NAME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME) +#define DUK_HEAP_STRING_INPUT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT) +#define DUK_HTHREAD_STRING_INPUT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT) +#define DUK_HEAP_STRING_INDEX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX) +#define DUK_HTHREAD_STRING_INDEX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX) +#define DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPED_EMPTY_REGEXP) +#define DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPED_EMPTY_REGEXP) +#define DUK_HEAP_STRING_LAST_INDEX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX) +#define DUK_HTHREAD_STRING_LAST_INDEX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX) +#define DUK_HEAP_STRING_MULTILINE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE) +#define DUK_HTHREAD_STRING_MULTILINE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE) +#define DUK_HEAP_STRING_IGNORE_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE) +#define DUK_HTHREAD_STRING_IGNORE_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE) +#define DUK_HEAP_STRING_SOURCE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE) +#define DUK_HTHREAD_STRING_SOURCE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE) +#define DUK_HEAP_STRING_TEST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TEST) +#define DUK_HTHREAD_STRING_TEST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TEST) +#define DUK_HEAP_STRING_EXEC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXEC) +#define DUK_HTHREAD_STRING_EXEC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXEC) +#define DUK_HEAP_STRING_TO_GMT_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING) +#define DUK_HTHREAD_STRING_TO_GMT_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING) +#define DUK_HEAP_STRING_SET_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_YEAR) +#define DUK_HTHREAD_STRING_SET_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_YEAR) +#define DUK_HEAP_STRING_GET_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_YEAR) +#define DUK_HTHREAD_STRING_GET_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_YEAR) +#define DUK_HEAP_STRING_TO_JSON(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON) +#define DUK_HTHREAD_STRING_TO_JSON(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON) +#define DUK_HEAP_STRING_TO_ISO_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING) +#define DUK_HTHREAD_STRING_TO_ISO_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING) +#define DUK_HEAP_STRING_TO_UTC_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING) +#define DUK_HTHREAD_STRING_TO_UTC_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING) +#define DUK_HEAP_STRING_SET_UTC_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_FULL_YEAR) +#define DUK_HTHREAD_STRING_SET_UTC_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_FULL_YEAR) +#define DUK_HEAP_STRING_SET_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FULL_YEAR) +#define DUK_HTHREAD_STRING_SET_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FULL_YEAR) +#define DUK_HEAP_STRING_SET_UTC_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MONTH) +#define DUK_HTHREAD_STRING_SET_UTC_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MONTH) +#define DUK_HEAP_STRING_SET_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MONTH) +#define DUK_HTHREAD_STRING_SET_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MONTH) +#define DUK_HEAP_STRING_SET_UTC_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_DATE) +#define DUK_HTHREAD_STRING_SET_UTC_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_DATE) +#define DUK_HEAP_STRING_SET_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_DATE) +#define DUK_HTHREAD_STRING_SET_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_DATE) +#define DUK_HEAP_STRING_SET_UTC_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_HOURS) +#define DUK_HTHREAD_STRING_SET_UTC_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_HOURS) +#define DUK_HEAP_STRING_SET_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_HOURS) +#define DUK_HTHREAD_STRING_SET_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_HOURS) +#define DUK_HEAP_STRING_SET_UTC_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MINUTES) +#define DUK_HTHREAD_STRING_SET_UTC_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MINUTES) +#define DUK_HEAP_STRING_SET_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MINUTES) +#define DUK_HTHREAD_STRING_SET_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MINUTES) +#define DUK_HEAP_STRING_SET_UTC_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_SECONDS) +#define DUK_HTHREAD_STRING_SET_UTC_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_SECONDS) +#define DUK_HEAP_STRING_SET_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_SECONDS) +#define DUK_HTHREAD_STRING_SET_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_SECONDS) +#define DUK_HEAP_STRING_SET_UTC_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MILLISECONDS) +#define DUK_HTHREAD_STRING_SET_UTC_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MILLISECONDS) +#define DUK_HEAP_STRING_SET_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MILLISECONDS) +#define DUK_HTHREAD_STRING_SET_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MILLISECONDS) +#define DUK_HEAP_STRING_SET_TIME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_TIME) +#define DUK_HTHREAD_STRING_SET_TIME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_TIME) +#define DUK_HEAP_STRING_GET_TIMEZONE_OFFSET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIMEZONE_OFFSET) +#define DUK_HTHREAD_STRING_GET_TIMEZONE_OFFSET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIMEZONE_OFFSET) +#define DUK_HEAP_STRING_GET_UTC_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MILLISECONDS) +#define DUK_HTHREAD_STRING_GET_UTC_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MILLISECONDS) +#define DUK_HEAP_STRING_GET_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MILLISECONDS) +#define DUK_HTHREAD_STRING_GET_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MILLISECONDS) +#define DUK_HEAP_STRING_GET_UTC_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_SECONDS) +#define DUK_HTHREAD_STRING_GET_UTC_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_SECONDS) +#define DUK_HEAP_STRING_GET_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_SECONDS) +#define DUK_HTHREAD_STRING_GET_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_SECONDS) +#define DUK_HEAP_STRING_GET_UTC_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MINUTES) +#define DUK_HTHREAD_STRING_GET_UTC_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MINUTES) +#define DUK_HEAP_STRING_GET_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MINUTES) +#define DUK_HTHREAD_STRING_GET_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MINUTES) +#define DUK_HEAP_STRING_GET_UTC_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_HOURS) +#define DUK_HTHREAD_STRING_GET_UTC_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_HOURS) +#define DUK_HEAP_STRING_GET_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_HOURS) +#define DUK_HTHREAD_STRING_GET_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_HOURS) +#define DUK_HEAP_STRING_GET_UTC_DAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DAY) +#define DUK_HTHREAD_STRING_GET_UTC_DAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DAY) +#define DUK_HEAP_STRING_GET_DAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DAY) +#define DUK_HTHREAD_STRING_GET_DAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DAY) +#define DUK_HEAP_STRING_GET_UTC_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DATE) +#define DUK_HTHREAD_STRING_GET_UTC_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DATE) +#define DUK_HEAP_STRING_GET_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DATE) +#define DUK_HTHREAD_STRING_GET_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DATE) +#define DUK_HEAP_STRING_GET_UTC_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MONTH) +#define DUK_HTHREAD_STRING_GET_UTC_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MONTH) +#define DUK_HEAP_STRING_GET_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MONTH) +#define DUK_HTHREAD_STRING_GET_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MONTH) +#define DUK_HEAP_STRING_GET_UTC_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_FULL_YEAR) +#define DUK_HTHREAD_STRING_GET_UTC_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_FULL_YEAR) +#define DUK_HEAP_STRING_GET_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FULL_YEAR) +#define DUK_HTHREAD_STRING_GET_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FULL_YEAR) +#define DUK_HEAP_STRING_GET_TIME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIME) +#define DUK_HTHREAD_STRING_GET_TIME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIME) +#define DUK_HEAP_STRING_TO_LOCALE_TIME_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_TIME_STRING) +#define DUK_HTHREAD_STRING_TO_LOCALE_TIME_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_TIME_STRING) +#define DUK_HEAP_STRING_TO_LOCALE_DATE_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_DATE_STRING) +#define DUK_HTHREAD_STRING_TO_LOCALE_DATE_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_DATE_STRING) +#define DUK_HEAP_STRING_TO_TIME_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_TIME_STRING) +#define DUK_HTHREAD_STRING_TO_TIME_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_TIME_STRING) +#define DUK_HEAP_STRING_TO_DATE_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_DATE_STRING) +#define DUK_HTHREAD_STRING_TO_DATE_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_DATE_STRING) +#define DUK_HEAP_STRING_NOW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NOW) +#define DUK_HTHREAD_STRING_NOW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NOW) +#define DUK_HEAP_STRING_UTC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UTC) +#define DUK_HTHREAD_STRING_UTC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UTC) +#define DUK_HEAP_STRING_PARSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE) +#define DUK_HTHREAD_STRING_PARSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE) +#define DUK_HEAP_STRING_TO_PRECISION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_PRECISION) +#define DUK_HTHREAD_STRING_TO_PRECISION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_PRECISION) +#define DUK_HEAP_STRING_TO_EXPONENTIAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_EXPONENTIAL) +#define DUK_HTHREAD_STRING_TO_EXPONENTIAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_EXPONENTIAL) +#define DUK_HEAP_STRING_TO_FIXED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_FIXED) +#define DUK_HTHREAD_STRING_TO_FIXED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_FIXED) +#define DUK_HEAP_STRING_POSITIVE_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POSITIVE_INFINITY) +#define DUK_HTHREAD_STRING_POSITIVE_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POSITIVE_INFINITY) +#define DUK_HEAP_STRING_NEGATIVE_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEGATIVE_INFINITY) +#define DUK_HTHREAD_STRING_NEGATIVE_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEGATIVE_INFINITY) +#define DUK_HEAP_STRING_NAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN) +#define DUK_HTHREAD_STRING_NAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN) +#define DUK_HEAP_STRING_MIN_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN_VALUE) +#define DUK_HTHREAD_STRING_MIN_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN_VALUE) +#define DUK_HEAP_STRING_MAX_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX_VALUE) +#define DUK_HTHREAD_STRING_MAX_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX_VALUE) +#define DUK_HEAP_STRING_SUBSTR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTR) +#define DUK_HTHREAD_STRING_SUBSTR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTR) +#define DUK_HEAP_STRING_TRIM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRIM) +#define DUK_HTHREAD_STRING_TRIM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRIM) +#define DUK_HEAP_STRING_TO_LOCALE_UPPER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_UPPER_CASE) +#define DUK_HTHREAD_STRING_TO_LOCALE_UPPER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_UPPER_CASE) +#define DUK_HEAP_STRING_TO_UPPER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UPPER_CASE) +#define DUK_HTHREAD_STRING_TO_UPPER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UPPER_CASE) +#define DUK_HEAP_STRING_TO_LOCALE_LOWER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_LOWER_CASE) +#define DUK_HTHREAD_STRING_TO_LOCALE_LOWER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_LOWER_CASE) +#define DUK_HEAP_STRING_TO_LOWER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOWER_CASE) +#define DUK_HTHREAD_STRING_TO_LOWER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOWER_CASE) +#define DUK_HEAP_STRING_SUBSTRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTRING) +#define DUK_HTHREAD_STRING_SUBSTRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTRING) +#define DUK_HEAP_STRING_SPLIT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLIT) +#define DUK_HTHREAD_STRING_SPLIT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLIT) +#define DUK_HEAP_STRING_SEARCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEARCH) +#define DUK_HTHREAD_STRING_SEARCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEARCH) +#define DUK_HEAP_STRING_REPLACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REPLACE) +#define DUK_HTHREAD_STRING_REPLACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REPLACE) +#define DUK_HEAP_STRING_MATCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATCH) +#define DUK_HTHREAD_STRING_MATCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATCH) +#define DUK_HEAP_STRING_LOCALE_COMPARE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOCALE_COMPARE) +#define DUK_HTHREAD_STRING_LOCALE_COMPARE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOCALE_COMPARE) +#define DUK_HEAP_STRING_CHAR_CODE_AT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_CODE_AT) +#define DUK_HTHREAD_STRING_CHAR_CODE_AT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_CODE_AT) +#define DUK_HEAP_STRING_CHAR_AT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_AT) +#define DUK_HTHREAD_STRING_CHAR_AT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_AT) +#define DUK_HEAP_STRING_FROM_CHAR_CODE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FROM_CHAR_CODE) +#define DUK_HTHREAD_STRING_FROM_CHAR_CODE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FROM_CHAR_CODE) +#define DUK_HEAP_STRING_REDUCE_RIGHT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE_RIGHT) +#define DUK_HTHREAD_STRING_REDUCE_RIGHT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE_RIGHT) +#define DUK_HEAP_STRING_REDUCE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE) +#define DUK_HTHREAD_STRING_REDUCE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE) +#define DUK_HEAP_STRING_FILTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILTER) +#define DUK_HTHREAD_STRING_FILTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILTER) +#define DUK_HEAP_STRING_MAP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAP) +#define DUK_HTHREAD_STRING_MAP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAP) +#define DUK_HEAP_STRING_FOR_EACH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR_EACH) +#define DUK_HTHREAD_STRING_FOR_EACH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR_EACH) +#define DUK_HEAP_STRING_SOME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOME) +#define DUK_HTHREAD_STRING_SOME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOME) +#define DUK_HEAP_STRING_EVERY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVERY) +#define DUK_HTHREAD_STRING_EVERY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVERY) +#define DUK_HEAP_STRING_LAST_INDEX_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX_OF) +#define DUK_HTHREAD_STRING_LAST_INDEX_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX_OF) +#define DUK_HEAP_STRING_INDEX_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX_OF) +#define DUK_HTHREAD_STRING_INDEX_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX_OF) +#define DUK_HEAP_STRING_UNSHIFT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNSHIFT) +#define DUK_HTHREAD_STRING_UNSHIFT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNSHIFT) +#define DUK_HEAP_STRING_SPLICE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLICE) +#define DUK_HTHREAD_STRING_SPLICE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLICE) +#define DUK_HEAP_STRING_SORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SORT) +#define DUK_HTHREAD_STRING_SORT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SORT) +#define DUK_HEAP_STRING_SLICE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SLICE) +#define DUK_HTHREAD_STRING_SLICE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SLICE) +#define DUK_HEAP_STRING_SHIFT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SHIFT) +#define DUK_HTHREAD_STRING_SHIFT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SHIFT) +#define DUK_HEAP_STRING_REVERSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REVERSE) +#define DUK_HTHREAD_STRING_REVERSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REVERSE) +#define DUK_HEAP_STRING_PUSH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUSH) +#define DUK_HTHREAD_STRING_PUSH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUSH) +#define DUK_HEAP_STRING_POP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POP) +#define DUK_HTHREAD_STRING_POP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POP) +#define DUK_HEAP_STRING_JOIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN) +#define DUK_HTHREAD_STRING_JOIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN) +#define DUK_HEAP_STRING_CONCAT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONCAT) +#define DUK_HTHREAD_STRING_CONCAT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONCAT) +#define DUK_HEAP_STRING_IS_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ARRAY) +#define DUK_HTHREAD_STRING_IS_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ARRAY) +#define DUK_HEAP_STRING_LC_ARGUMENTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS) +#define DUK_HTHREAD_STRING_LC_ARGUMENTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS) +#define DUK_HEAP_STRING_CALLER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER) +#define DUK_HTHREAD_STRING_CALLER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER) +#define DUK_HEAP_STRING_BIND(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BIND) +#define DUK_HTHREAD_STRING_BIND(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BIND) +#define DUK_HEAP_STRING_CALL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALL) +#define DUK_HTHREAD_STRING_CALL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALL) +#define DUK_HEAP_STRING_APPLY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_APPLY) +#define DUK_HTHREAD_STRING_APPLY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_APPLY) +#define DUK_HEAP_STRING_PROPERTY_IS_ENUMERABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROPERTY_IS_ENUMERABLE) +#define DUK_HTHREAD_STRING_PROPERTY_IS_ENUMERABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROPERTY_IS_ENUMERABLE) +#define DUK_HEAP_STRING_IS_PROTOTYPE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_PROTOTYPE_OF) +#define DUK_HTHREAD_STRING_IS_PROTOTYPE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_PROTOTYPE_OF) +#define DUK_HEAP_STRING_HAS_OWN_PROPERTY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS_OWN_PROPERTY) +#define DUK_HTHREAD_STRING_HAS_OWN_PROPERTY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS_OWN_PROPERTY) +#define DUK_HEAP_STRING_VALUE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF) +#define DUK_HTHREAD_STRING_VALUE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF) +#define DUK_HEAP_STRING_TO_LOCALE_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING) +#define DUK_HTHREAD_STRING_TO_LOCALE_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING) +#define DUK_HEAP_STRING_TO_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING) +#define DUK_HTHREAD_STRING_TO_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING) +#define DUK_HEAP_STRING_CONSTRUCTOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR) +#define DUK_HTHREAD_STRING_CONSTRUCTOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR) +#define DUK_HEAP_STRING_SET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET) +#define DUK_HTHREAD_STRING_SET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET) +#define DUK_HEAP_STRING_GET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET) +#define DUK_HTHREAD_STRING_GET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET) +#define DUK_HEAP_STRING_ENUMERABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE) +#define DUK_HTHREAD_STRING_ENUMERABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE) +#define DUK_HEAP_STRING_CONFIGURABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE) +#define DUK_HTHREAD_STRING_CONFIGURABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE) +#define DUK_HEAP_STRING_WRITABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE) +#define DUK_HTHREAD_STRING_WRITABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE) +#define DUK_HEAP_STRING_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE) +#define DUK_HTHREAD_STRING_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE) +#define DUK_HEAP_STRING_KEYS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_KEYS) +#define DUK_HTHREAD_STRING_KEYS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_KEYS) +#define DUK_HEAP_STRING_IS_EXTENSIBLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_EXTENSIBLE) +#define DUK_HTHREAD_STRING_IS_EXTENSIBLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_EXTENSIBLE) +#define DUK_HEAP_STRING_IS_FROZEN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FROZEN) +#define DUK_HTHREAD_STRING_IS_FROZEN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FROZEN) +#define DUK_HEAP_STRING_IS_SEALED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_SEALED) +#define DUK_HTHREAD_STRING_IS_SEALED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_SEALED) +#define DUK_HEAP_STRING_PREVENT_EXTENSIONS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PREVENT_EXTENSIONS) +#define DUK_HTHREAD_STRING_PREVENT_EXTENSIONS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PREVENT_EXTENSIONS) +#define DUK_HEAP_STRING_FREEZE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FREEZE) +#define DUK_HTHREAD_STRING_FREEZE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FREEZE) +#define DUK_HEAP_STRING_SEAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEAL) +#define DUK_HTHREAD_STRING_SEAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEAL) +#define DUK_HEAP_STRING_DEFINE_PROPERTIES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTIES) +#define DUK_HTHREAD_STRING_DEFINE_PROPERTIES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTIES) +#define DUK_HEAP_STRING_DEFINE_PROPERTY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTY) +#define DUK_HTHREAD_STRING_DEFINE_PROPERTY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTY) +#define DUK_HEAP_STRING_CREATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CREATE) +#define DUK_HTHREAD_STRING_CREATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CREATE) +#define DUK_HEAP_STRING_GET_OWN_PROPERTY_NAMES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_NAMES) +#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_NAMES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_NAMES) +#define DUK_HEAP_STRING_GET_OWN_PROPERTY_DESCRIPTOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR) +#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_DESCRIPTOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR) +#define DUK_HEAP_STRING_GET_PROTOTYPE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_PROTOTYPE_OF) +#define DUK_HTHREAD_STRING_GET_PROTOTYPE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_PROTOTYPE_OF) +#define DUK_HEAP_STRING_PROTOTYPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE) +#define DUK_HTHREAD_STRING_PROTOTYPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE) +#define DUK_HEAP_STRING_LENGTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH) +#define DUK_HTHREAD_STRING_LENGTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH) +#define DUK_HEAP_STRING_ALERT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ALERT) +#define DUK_HTHREAD_STRING_ALERT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ALERT) +#define DUK_HEAP_STRING_PRINT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRINT) +#define DUK_HTHREAD_STRING_PRINT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRINT) +#define DUK_HEAP_STRING_UNESCAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNESCAPE) +#define DUK_HTHREAD_STRING_UNESCAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNESCAPE) +#define DUK_HEAP_STRING_ESCAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPE) +#define DUK_HTHREAD_STRING_ESCAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPE) +#define DUK_HEAP_STRING_ENCODE_URI_COMPONENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI_COMPONENT) +#define DUK_HTHREAD_STRING_ENCODE_URI_COMPONENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI_COMPONENT) +#define DUK_HEAP_STRING_ENCODE_URI(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI) +#define DUK_HTHREAD_STRING_ENCODE_URI(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI) +#define DUK_HEAP_STRING_DECODE_URI_COMPONENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI_COMPONENT) +#define DUK_HTHREAD_STRING_DECODE_URI_COMPONENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI_COMPONENT) +#define DUK_HEAP_STRING_DECODE_URI(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI) +#define DUK_HTHREAD_STRING_DECODE_URI(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI) +#define DUK_HEAP_STRING_IS_FINITE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FINITE) +#define DUK_HTHREAD_STRING_IS_FINITE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FINITE) +#define DUK_HEAP_STRING_IS_NAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_NAN) +#define DUK_HTHREAD_STRING_IS_NAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_NAN) +#define DUK_HEAP_STRING_PARSE_FLOAT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_FLOAT) +#define DUK_HTHREAD_STRING_PARSE_FLOAT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_FLOAT) +#define DUK_HEAP_STRING_PARSE_INT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_INT) +#define DUK_HTHREAD_STRING_PARSE_INT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_INT) +#define DUK_HEAP_STRING_EVAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL) +#define DUK_HTHREAD_STRING_EVAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL) +#define DUK_HEAP_STRING_URI_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_URI_ERROR) +#define DUK_HTHREAD_STRING_URI_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_URI_ERROR) +#define DUK_HEAP_STRING_TYPE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE_ERROR) +#define DUK_HTHREAD_STRING_TYPE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE_ERROR) +#define DUK_HEAP_STRING_SYNTAX_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SYNTAX_ERROR) +#define DUK_HTHREAD_STRING_SYNTAX_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SYNTAX_ERROR) +#define DUK_HEAP_STRING_REFERENCE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REFERENCE_ERROR) +#define DUK_HTHREAD_STRING_REFERENCE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REFERENCE_ERROR) +#define DUK_HEAP_STRING_RANGE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANGE_ERROR) +#define DUK_HTHREAD_STRING_RANGE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANGE_ERROR) +#define DUK_HEAP_STRING_EVAL_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL_ERROR) +#define DUK_HTHREAD_STRING_EVAL_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL_ERROR) +#define DUK_HEAP_STRING_BREAK(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK) +#define DUK_HTHREAD_STRING_BREAK(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK) +#define DUK_HEAP_STRING_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE) +#define DUK_HTHREAD_STRING_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE) +#define DUK_HEAP_STRING_CATCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH) +#define DUK_HTHREAD_STRING_CATCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH) +#define DUK_HEAP_STRING_CONTINUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE) +#define DUK_HTHREAD_STRING_CONTINUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE) +#define DUK_HEAP_STRING_DEBUGGER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER) +#define DUK_HTHREAD_STRING_DEBUGGER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER) +#define DUK_HEAP_STRING_DEFAULT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT) +#define DUK_HTHREAD_STRING_DEFAULT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT) +#define DUK_HEAP_STRING_DELETE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE) +#define DUK_HTHREAD_STRING_DELETE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE) +#define DUK_HEAP_STRING_DO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO) +#define DUK_HTHREAD_STRING_DO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO) +#define DUK_HEAP_STRING_ELSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE) +#define DUK_HTHREAD_STRING_ELSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE) +#define DUK_HEAP_STRING_FINALLY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY) +#define DUK_HTHREAD_STRING_FINALLY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY) +#define DUK_HEAP_STRING_FOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR) +#define DUK_HTHREAD_STRING_FOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR) +#define DUK_HEAP_STRING_LC_FUNCTION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION) +#define DUK_HTHREAD_STRING_LC_FUNCTION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION) +#define DUK_HEAP_STRING_IF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF) +#define DUK_HTHREAD_STRING_IF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF) +#define DUK_HEAP_STRING_IN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN) +#define DUK_HTHREAD_STRING_IN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN) +#define DUK_HEAP_STRING_INSTANCEOF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF) +#define DUK_HTHREAD_STRING_INSTANCEOF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF) +#define DUK_HEAP_STRING_NEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW) +#define DUK_HTHREAD_STRING_NEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW) +#define DUK_HEAP_STRING_RETURN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN) +#define DUK_HTHREAD_STRING_RETURN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN) +#define DUK_HEAP_STRING_SWITCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH) +#define DUK_HTHREAD_STRING_SWITCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH) +#define DUK_HEAP_STRING_THIS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS) +#define DUK_HTHREAD_STRING_THIS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS) +#define DUK_HEAP_STRING_THROW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW) +#define DUK_HTHREAD_STRING_THROW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW) +#define DUK_HEAP_STRING_TRY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY) +#define DUK_HTHREAD_STRING_TRY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY) +#define DUK_HEAP_STRING_TYPEOF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF) +#define DUK_HTHREAD_STRING_TYPEOF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF) +#define DUK_HEAP_STRING_VAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR) +#define DUK_HTHREAD_STRING_VAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR) +#define DUK_HEAP_STRING_VOID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID) +#define DUK_HTHREAD_STRING_VOID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID) +#define DUK_HEAP_STRING_WHILE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE) +#define DUK_HTHREAD_STRING_WHILE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE) +#define DUK_HEAP_STRING_WITH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH) +#define DUK_HTHREAD_STRING_WITH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH) +#define DUK_HEAP_STRING_CLASS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS) +#define DUK_HTHREAD_STRING_CLASS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS) +#define DUK_HEAP_STRING_CONST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST) +#define DUK_HTHREAD_STRING_CONST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST) +#define DUK_HEAP_STRING_ENUM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM) +#define DUK_HTHREAD_STRING_ENUM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM) +#define DUK_HEAP_STRING_EXPORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT) +#define DUK_HTHREAD_STRING_EXPORT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT) +#define DUK_HEAP_STRING_EXTENDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS) +#define DUK_HTHREAD_STRING_EXTENDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS) +#define DUK_HEAP_STRING_IMPORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT) +#define DUK_HTHREAD_STRING_IMPORT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT) +#define DUK_HEAP_STRING_SUPER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER) +#define DUK_HTHREAD_STRING_SUPER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER) +#define DUK_HEAP_STRING_LC_NULL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL) +#define DUK_HTHREAD_STRING_LC_NULL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL) +#define DUK_HEAP_STRING_TRUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE) +#define DUK_HTHREAD_STRING_TRUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE) +#define DUK_HEAP_STRING_FALSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE) +#define DUK_HTHREAD_STRING_FALSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE) +#define DUK_HEAP_STRING_IMPLEMENTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS) +#define DUK_HTHREAD_STRING_IMPLEMENTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS) +#define DUK_HEAP_STRING_INTERFACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE) +#define DUK_HTHREAD_STRING_INTERFACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE) +#define DUK_HEAP_STRING_LET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET) +#define DUK_HTHREAD_STRING_LET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET) +#define DUK_HEAP_STRING_PACKAGE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE) +#define DUK_HTHREAD_STRING_PACKAGE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE) +#define DUK_HEAP_STRING_PRIVATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE) +#define DUK_HTHREAD_STRING_PRIVATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE) +#define DUK_HEAP_STRING_PROTECTED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED) +#define DUK_HTHREAD_STRING_PROTECTED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED) +#define DUK_HEAP_STRING_PUBLIC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC) +#define DUK_HTHREAD_STRING_PUBLIC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC) +#define DUK_HEAP_STRING_STATIC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC) +#define DUK_HTHREAD_STRING_STATIC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC) +#define DUK_HEAP_STRING_YIELD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD) +#define DUK_HTHREAD_STRING_YIELD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD) + +#define DUK_HEAP_NUM_STRINGS 414 + +#define DUK_STRIDX_START_RESERVED 369 +#define DUK_STRIDX_START_STRICT_RESERVED 405 +#define DUK_STRIDX_END_RESERVED 414 /* exclusive endpoint */ + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[147]; +DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1952]; +#ifdef DUK_USE_BUILTIN_INITJS +DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187]; +#endif /* DUK_USE_BUILTIN_INITJS */ +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_BUILTINS_DATA_LENGTH 1952 +#ifdef DUK_USE_BUILTIN_INITJS +#define DUK_BUILTIN_INITJS_DATA_LENGTH 187 +#endif /* DUK_USE_BUILTIN_INITJS */ + +#define DUK_BIDX_GLOBAL 0 +#define DUK_BIDX_GLOBAL_ENV 1 +#define DUK_BIDX_OBJECT_CONSTRUCTOR 2 +#define DUK_BIDX_OBJECT_PROTOTYPE 3 +#define DUK_BIDX_FUNCTION_CONSTRUCTOR 4 +#define DUK_BIDX_FUNCTION_PROTOTYPE 5 +#define DUK_BIDX_ARRAY_CONSTRUCTOR 6 +#define DUK_BIDX_ARRAY_PROTOTYPE 7 +#define DUK_BIDX_STRING_CONSTRUCTOR 8 +#define DUK_BIDX_STRING_PROTOTYPE 9 +#define DUK_BIDX_BOOLEAN_CONSTRUCTOR 10 +#define DUK_BIDX_BOOLEAN_PROTOTYPE 11 +#define DUK_BIDX_NUMBER_CONSTRUCTOR 12 +#define DUK_BIDX_NUMBER_PROTOTYPE 13 +#define DUK_BIDX_DATE_CONSTRUCTOR 14 +#define DUK_BIDX_DATE_PROTOTYPE 15 +#define DUK_BIDX_REGEXP_CONSTRUCTOR 16 +#define DUK_BIDX_REGEXP_PROTOTYPE 17 +#define DUK_BIDX_ERROR_CONSTRUCTOR 18 +#define DUK_BIDX_ERROR_PROTOTYPE 19 +#define DUK_BIDX_EVAL_ERROR_CONSTRUCTOR 20 +#define DUK_BIDX_EVAL_ERROR_PROTOTYPE 21 +#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR 22 +#define DUK_BIDX_RANGE_ERROR_PROTOTYPE 23 +#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR 24 +#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE 25 +#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR 26 +#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE 27 +#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR 28 +#define DUK_BIDX_TYPE_ERROR_PROTOTYPE 29 +#define DUK_BIDX_URI_ERROR_CONSTRUCTOR 30 +#define DUK_BIDX_URI_ERROR_PROTOTYPE 31 +#define DUK_BIDX_MATH 32 +#define DUK_BIDX_JSON 33 +#define DUK_BIDX_TYPE_ERROR_THROWER 34 +#define DUK_BIDX_PROXY_CONSTRUCTOR 35 +#define DUK_BIDX_DUKTAPE 36 +#define DUK_BIDX_THREAD_CONSTRUCTOR 37 +#define DUK_BIDX_THREAD_PROTOTYPE 38 +#define DUK_BIDX_BUFFER_CONSTRUCTOR 39 +#define DUK_BIDX_BUFFER_PROTOTYPE 40 +#define DUK_BIDX_POINTER_CONSTRUCTOR 41 +#define DUK_BIDX_POINTER_PROTOTYPE 42 +#define DUK_BIDX_LOGGER_CONSTRUCTOR 43 +#define DUK_BIDX_LOGGER_PROTOTYPE 44 +#define DUK_BIDX_DOUBLE_ERROR 45 +#define DUK_BIDX_ARRAYBUFFER_CONSTRUCTOR 46 +#define DUK_BIDX_ARRAYBUFFER_PROTOTYPE 47 +#define DUK_BIDX_DATAVIEW_CONSTRUCTOR 48 +#define DUK_BIDX_DATAVIEW_PROTOTYPE 49 +#define DUK_BIDX_TYPEDARRAY_PROTOTYPE 50 +#define DUK_BIDX_INT8ARRAY_CONSTRUCTOR 51 +#define DUK_BIDX_INT8ARRAY_PROTOTYPE 52 +#define DUK_BIDX_UINT8ARRAY_CONSTRUCTOR 53 +#define DUK_BIDX_UINT8ARRAY_PROTOTYPE 54 +#define DUK_BIDX_UINT8CLAMPEDARRAY_CONSTRUCTOR 55 +#define DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE 56 +#define DUK_BIDX_INT16ARRAY_CONSTRUCTOR 57 +#define DUK_BIDX_INT16ARRAY_PROTOTYPE 58 +#define DUK_BIDX_UINT16ARRAY_CONSTRUCTOR 59 +#define DUK_BIDX_UINT16ARRAY_PROTOTYPE 60 +#define DUK_BIDX_INT32ARRAY_CONSTRUCTOR 61 +#define DUK_BIDX_INT32ARRAY_PROTOTYPE 62 +#define DUK_BIDX_UINT32ARRAY_CONSTRUCTOR 63 +#define DUK_BIDX_UINT32ARRAY_PROTOTYPE 64 +#define DUK_BIDX_FLOAT32ARRAY_CONSTRUCTOR 65 +#define DUK_BIDX_FLOAT32ARRAY_PROTOTYPE 66 +#define DUK_BIDX_FLOAT64ARRAY_CONSTRUCTOR 67 +#define DUK_BIDX_FLOAT64ARRAY_PROTOTYPE 68 +#define DUK_BIDX_NODEJS_BUFFER_CONSTRUCTOR 69 +#define DUK_BIDX_NODEJS_BUFFER_PROTOTYPE 70 + +#define DUK_NUM_BUILTINS 71 + +#elif defined(DUK_USE_DOUBLE_BE) +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[2624]; +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_STRDATA_DATA_LENGTH 2624 +#define DUK_STRDATA_MAX_STRLEN 24 + +#define DUK_STRIDX_UC_LOGGER 0 /* 'Logger' */ +#define DUK_STRIDX_UC_THREAD 1 /* 'Thread' */ +#define DUK_STRIDX_UC_POINTER 2 /* 'Pointer' */ +#define DUK_STRIDX_DEC_ENV 3 /* 'DecEnv' */ +#define DUK_STRIDX_OBJ_ENV 4 /* 'ObjEnv' */ +#define DUK_STRIDX_FLOAT64_ARRAY 5 /* 'Float64Array' */ +#define DUK_STRIDX_FLOAT32_ARRAY 6 /* 'Float32Array' */ +#define DUK_STRIDX_UINT32_ARRAY 7 /* 'Uint32Array' */ +#define DUK_STRIDX_INT32_ARRAY 8 /* 'Int32Array' */ +#define DUK_STRIDX_UINT16_ARRAY 9 /* 'Uint16Array' */ +#define DUK_STRIDX_INT16_ARRAY 10 /* 'Int16Array' */ +#define DUK_STRIDX_UINT8_CLAMPED_ARRAY 11 /* 'Uint8ClampedArray' */ +#define DUK_STRIDX_UINT8_ARRAY 12 /* 'Uint8Array' */ +#define DUK_STRIDX_INT8_ARRAY 13 /* 'Int8Array' */ +#define DUK_STRIDX_DATA_VIEW 14 /* 'DataView' */ +#define DUK_STRIDX_ARRAY_BUFFER 15 /* 'ArrayBuffer' */ +#define DUK_STRIDX_UC_BUFFER 16 /* 'Buffer' */ +#define DUK_STRIDX_EMPTY_STRING 17 /* '' */ +#define DUK_STRIDX_GLOBAL 18 /* 'global' */ +#define DUK_STRIDX_UC_ARGUMENTS 19 /* 'Arguments' */ +#define DUK_STRIDX_JSON 20 /* 'JSON' */ +#define DUK_STRIDX_MATH 21 /* 'Math' */ +#define DUK_STRIDX_UC_ERROR 22 /* 'Error' */ +#define DUK_STRIDX_REG_EXP 23 /* 'RegExp' */ +#define DUK_STRIDX_DATE 24 /* 'Date' */ +#define DUK_STRIDX_UC_NUMBER 25 /* 'Number' */ +#define DUK_STRIDX_UC_BOOLEAN 26 /* 'Boolean' */ +#define DUK_STRIDX_UC_STRING 27 /* 'String' */ +#define DUK_STRIDX_ARRAY 28 /* 'Array' */ +#define DUK_STRIDX_UC_FUNCTION 29 /* 'Function' */ +#define DUK_STRIDX_UC_OBJECT 30 /* 'Object' */ +#define DUK_STRIDX_UC_NULL 31 /* 'Null' */ +#define DUK_STRIDX_UC_UNDEFINED 32 /* 'Undefined' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION2 33 /* '{_func:true}' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION1 34 /* '{"_func":true}' */ +#define DUK_STRIDX_JSON_EXT_NEGINF 35 /* '{"_ninf":true}' */ +#define DUK_STRIDX_JSON_EXT_POSINF 36 /* '{"_inf":true}' */ +#define DUK_STRIDX_JSON_EXT_NAN 37 /* '{"_nan":true}' */ +#define DUK_STRIDX_JSON_EXT_UNDEFINED 38 /* '{"_undef":true}' */ +#define DUK_STRIDX_TO_LOG_STRING 39 /* 'toLogString' */ +#define DUK_STRIDX_CLOG 40 /* 'clog' */ +#define DUK_STRIDX_LC_L 41 /* 'l' */ +#define DUK_STRIDX_LC_N 42 /* 'n' */ +#define DUK_STRIDX_LC_FATAL 43 /* 'fatal' */ +#define DUK_STRIDX_LC_ERROR 44 /* 'error' */ +#define DUK_STRIDX_LC_WARN 45 /* 'warn' */ +#define DUK_STRIDX_LC_DEBUG 46 /* 'debug' */ +#define DUK_STRIDX_LC_TRACE 47 /* 'trace' */ +#define DUK_STRIDX_RAW 48 /* 'raw' */ +#define DUK_STRIDX_FMT 49 /* 'fmt' */ +#define DUK_STRIDX_CURRENT 50 /* 'current' */ +#define DUK_STRIDX_RESUME 51 /* 'resume' */ +#define DUK_STRIDX_COMPACT 52 /* 'compact' */ +#define DUK_STRIDX_JC 53 /* 'jc' */ +#define DUK_STRIDX_JX 54 /* 'jx' */ +#define DUK_STRIDX_BASE64 55 /* 'base64' */ +#define DUK_STRIDX_HEX 56 /* 'hex' */ +#define DUK_STRIDX_DEC 57 /* 'dec' */ +#define DUK_STRIDX_ENC 58 /* 'enc' */ +#define DUK_STRIDX_FIN 59 /* 'fin' */ +#define DUK_STRIDX_GC 60 /* 'gc' */ +#define DUK_STRIDX_ACT 61 /* 'act' */ +#define DUK_STRIDX_LC_INFO 62 /* 'info' */ +#define DUK_STRIDX_VERSION 63 /* 'version' */ +#define DUK_STRIDX_ENV 64 /* 'env' */ +#define DUK_STRIDX_MOD_LOADED 65 /* 'modLoaded' */ +#define DUK_STRIDX_MOD_SEARCH 66 /* 'modSearch' */ +#define DUK_STRIDX_ERR_THROW 67 /* 'errThrow' */ +#define DUK_STRIDX_ERR_CREATE 68 /* 'errCreate' */ +#define DUK_STRIDX_COMPILE 69 /* 'compile' */ +#define DUK_STRIDX_INT_REGBASE 70 /* '\x00Regbase' */ +#define DUK_STRIDX_INT_THREAD 71 /* '\x00Thread' */ +#define DUK_STRIDX_INT_HANDLER 72 /* '\x00Handler' */ +#define DUK_STRIDX_INT_FINALIZER 73 /* '\x00Finalizer' */ +#define DUK_STRIDX_INT_CALLEE 74 /* '\x00Callee' */ +#define DUK_STRIDX_INT_MAP 75 /* '\x00Map' */ +#define DUK_STRIDX_INT_ARGS 76 /* '\x00Args' */ +#define DUK_STRIDX_INT_THIS 77 /* '\x00This' */ +#define DUK_STRIDX_INT_PC2LINE 78 /* '\x00Pc2line' */ +#define DUK_STRIDX_INT_SOURCE 79 /* '\x00Source' */ +#define DUK_STRIDX_INT_VARENV 80 /* '\x00Varenv' */ +#define DUK_STRIDX_INT_LEXENV 81 /* '\x00Lexenv' */ +#define DUK_STRIDX_INT_VARMAP 82 /* '\x00Varmap' */ +#define DUK_STRIDX_INT_FORMALS 83 /* '\x00Formals' */ +#define DUK_STRIDX_INT_BYTECODE 84 /* '\x00Bytecode' */ +#define DUK_STRIDX_INT_NEXT 85 /* '\x00Next' */ +#define DUK_STRIDX_INT_TARGET 86 /* '\x00Target' */ +#define DUK_STRIDX_INT_VALUE 87 /* '\x00Value' */ +#define DUK_STRIDX_LC_POINTER 88 /* 'pointer' */ +#define DUK_STRIDX_INT_TRACEDATA 89 /* '\x00Tracedata' */ +#define DUK_STRIDX_LINE_NUMBER 90 /* 'lineNumber' */ +#define DUK_STRIDX_FILE_NAME 91 /* 'fileName' */ +#define DUK_STRIDX_PC 92 /* 'pc' */ +#define DUK_STRIDX_STACK 93 /* 'stack' */ +#define DUK_STRIDX_THROW_TYPE_ERROR 94 /* 'ThrowTypeError' */ +#define DUK_STRIDX_DUKTAPE 95 /* 'Duktape' */ +#define DUK_STRIDX_SET_FLOAT64 96 /* 'setFloat64' */ +#define DUK_STRIDX_SET_FLOAT32 97 /* 'setFloat32' */ +#define DUK_STRIDX_SET_UINT32 98 /* 'setUint32' */ +#define DUK_STRIDX_SET_INT32 99 /* 'setInt32' */ +#define DUK_STRIDX_SET_UINT16 100 /* 'setUint16' */ +#define DUK_STRIDX_SET_INT16 101 /* 'setInt16' */ +#define DUK_STRIDX_SET_UINT8 102 /* 'setUint8' */ +#define DUK_STRIDX_SET_INT8 103 /* 'setInt8' */ +#define DUK_STRIDX_GET_FLOAT64 104 /* 'getFloat64' */ +#define DUK_STRIDX_GET_FLOAT32 105 /* 'getFloat32' */ +#define DUK_STRIDX_GET_UINT32 106 /* 'getUint32' */ +#define DUK_STRIDX_GET_INT32 107 /* 'getInt32' */ +#define DUK_STRIDX_GET_UINT16 108 /* 'getUint16' */ +#define DUK_STRIDX_GET_INT16 109 /* 'getInt16' */ +#define DUK_STRIDX_GET_UINT8 110 /* 'getUint8' */ +#define DUK_STRIDX_GET_INT8 111 /* 'getInt8' */ +#define DUK_STRIDX_SUBARRAY 112 /* 'subarray' */ +#define DUK_STRIDX_BYTES_PER_ELEMENT 113 /* 'BYTES_PER_ELEMENT' */ +#define DUK_STRIDX_BYTE_OFFSET 114 /* 'byteOffset' */ +#define DUK_STRIDX_LC_BUFFER 115 /* 'buffer' */ +#define DUK_STRIDX_IS_VIEW 116 /* 'isView' */ +#define DUK_STRIDX_DATA 117 /* 'data' */ +#define DUK_STRIDX_TYPE 118 /* 'type' */ +#define DUK_STRIDX_WRITE_INT_BE 119 /* 'writeIntBE' */ +#define DUK_STRIDX_WRITE_INT_LE 120 /* 'writeIntLE' */ +#define DUK_STRIDX_WRITE_UINT_BE 121 /* 'writeUIntBE' */ +#define DUK_STRIDX_WRITE_UINT_LE 122 /* 'writeUIntLE' */ +#define DUK_STRIDX_WRITE_DOUBLE_BE 123 /* 'writeDoubleBE' */ +#define DUK_STRIDX_WRITE_DOUBLE_LE 124 /* 'writeDoubleLE' */ +#define DUK_STRIDX_WRITE_FLOAT_BE 125 /* 'writeFloatBE' */ +#define DUK_STRIDX_WRITE_FLOAT_LE 126 /* 'writeFloatLE' */ +#define DUK_STRIDX_WRITE_INT32_BE 127 /* 'writeInt32BE' */ +#define DUK_STRIDX_WRITE_INT32_LE 128 /* 'writeInt32LE' */ +#define DUK_STRIDX_WRITE_UINT32_BE 129 /* 'writeUInt32BE' */ +#define DUK_STRIDX_WRITE_UINT32_LE 130 /* 'writeUInt32LE' */ +#define DUK_STRIDX_WRITE_INT16_BE 131 /* 'writeInt16BE' */ +#define DUK_STRIDX_WRITE_INT16_LE 132 /* 'writeInt16LE' */ +#define DUK_STRIDX_WRITE_UINT16_BE 133 /* 'writeUInt16BE' */ +#define DUK_STRIDX_WRITE_UINT16_LE 134 /* 'writeUInt16LE' */ +#define DUK_STRIDX_WRITE_INT8 135 /* 'writeInt8' */ +#define DUK_STRIDX_WRITE_UINT8 136 /* 'writeUInt8' */ +#define DUK_STRIDX_READ_INT_BE 137 /* 'readIntBE' */ +#define DUK_STRIDX_READ_INT_LE 138 /* 'readIntLE' */ +#define DUK_STRIDX_READ_UINT_BE 139 /* 'readUIntBE' */ +#define DUK_STRIDX_READ_UINT_LE 140 /* 'readUIntLE' */ +#define DUK_STRIDX_READ_DOUBLE_BE 141 /* 'readDoubleBE' */ +#define DUK_STRIDX_READ_DOUBLE_LE 142 /* 'readDoubleLE' */ +#define DUK_STRIDX_READ_FLOAT_BE 143 /* 'readFloatBE' */ +#define DUK_STRIDX_READ_FLOAT_LE 144 /* 'readFloatLE' */ +#define DUK_STRIDX_READ_INT32_BE 145 /* 'readInt32BE' */ +#define DUK_STRIDX_READ_INT32_LE 146 /* 'readInt32LE' */ +#define DUK_STRIDX_READ_UINT32_BE 147 /* 'readUInt32BE' */ +#define DUK_STRIDX_READ_UINT32_LE 148 /* 'readUInt32LE' */ +#define DUK_STRIDX_READ_INT16_BE 149 /* 'readInt16BE' */ +#define DUK_STRIDX_READ_INT16_LE 150 /* 'readInt16LE' */ +#define DUK_STRIDX_READ_UINT16_BE 151 /* 'readUInt16BE' */ +#define DUK_STRIDX_READ_UINT16_LE 152 /* 'readUInt16LE' */ +#define DUK_STRIDX_READ_INT8 153 /* 'readInt8' */ +#define DUK_STRIDX_READ_UINT8 154 /* 'readUInt8' */ +#define DUK_STRIDX_COPY 155 /* 'copy' */ +#define DUK_STRIDX_EQUALS 156 /* 'equals' */ +#define DUK_STRIDX_FILL 157 /* 'fill' */ +#define DUK_STRIDX_WRITE 158 /* 'write' */ +#define DUK_STRIDX_COMPARE 159 /* 'compare' */ +#define DUK_STRIDX_BYTE_LENGTH 160 /* 'byteLength' */ +#define DUK_STRIDX_IS_BUFFER 161 /* 'isBuffer' */ +#define DUK_STRIDX_IS_ENCODING 162 /* 'isEncoding' */ +#define DUK_STRIDX_EXPORTS 163 /* 'exports' */ +#define DUK_STRIDX_ID 164 /* 'id' */ +#define DUK_STRIDX_REQUIRE 165 /* 'require' */ +#define DUK_STRIDX___PROTO__ 166 /* '__proto__' */ +#define DUK_STRIDX_SET_PROTOTYPE_OF 167 /* 'setPrototypeOf' */ +#define DUK_STRIDX_OWN_KEYS 168 /* 'ownKeys' */ +#define DUK_STRIDX_ENUMERATE 169 /* 'enumerate' */ +#define DUK_STRIDX_DELETE_PROPERTY 170 /* 'deleteProperty' */ +#define DUK_STRIDX_HAS 171 /* 'has' */ +#define DUK_STRIDX_PROXY 172 /* 'Proxy' */ +#define DUK_STRIDX_CALLEE 173 /* 'callee' */ +#define DUK_STRIDX_INVALID_DATE 174 /* 'Invalid Date' */ +#define DUK_STRIDX_BRACKETED_ELLIPSIS 175 /* '[...]' */ +#define DUK_STRIDX_NEWLINE_TAB 176 /* '\n\t' */ +#define DUK_STRIDX_SPACE 177 /* ' ' */ +#define DUK_STRIDX_COMMA 178 /* ',' */ +#define DUK_STRIDX_MINUS_ZERO 179 /* '-0' */ +#define DUK_STRIDX_PLUS_ZERO 180 /* '+0' */ +#define DUK_STRIDX_ZERO 181 /* '0' */ +#define DUK_STRIDX_MINUS_INFINITY 182 /* '-Infinity' */ +#define DUK_STRIDX_PLUS_INFINITY 183 /* '+Infinity' */ +#define DUK_STRIDX_INFINITY 184 /* 'Infinity' */ +#define DUK_STRIDX_LC_OBJECT 185 /* 'object' */ +#define DUK_STRIDX_LC_STRING 186 /* 'string' */ +#define DUK_STRIDX_LC_NUMBER 187 /* 'number' */ +#define DUK_STRIDX_LC_BOOLEAN 188 /* 'boolean' */ +#define DUK_STRIDX_LC_UNDEFINED 189 /* 'undefined' */ +#define DUK_STRIDX_STRINGIFY 190 /* 'stringify' */ +#define DUK_STRIDX_TAN 191 /* 'tan' */ +#define DUK_STRIDX_SQRT 192 /* 'sqrt' */ +#define DUK_STRIDX_SIN 193 /* 'sin' */ +#define DUK_STRIDX_ROUND 194 /* 'round' */ +#define DUK_STRIDX_RANDOM 195 /* 'random' */ +#define DUK_STRIDX_POW 196 /* 'pow' */ +#define DUK_STRIDX_MIN 197 /* 'min' */ +#define DUK_STRIDX_MAX 198 /* 'max' */ +#define DUK_STRIDX_LOG 199 /* 'log' */ +#define DUK_STRIDX_FLOOR 200 /* 'floor' */ +#define DUK_STRIDX_EXP 201 /* 'exp' */ +#define DUK_STRIDX_COS 202 /* 'cos' */ +#define DUK_STRIDX_CEIL 203 /* 'ceil' */ +#define DUK_STRIDX_ATAN2 204 /* 'atan2' */ +#define DUK_STRIDX_ATAN 205 /* 'atan' */ +#define DUK_STRIDX_ASIN 206 /* 'asin' */ +#define DUK_STRIDX_ACOS 207 /* 'acos' */ +#define DUK_STRIDX_ABS 208 /* 'abs' */ +#define DUK_STRIDX_SQRT2 209 /* 'SQRT2' */ +#define DUK_STRIDX_SQRT1_2 210 /* 'SQRT1_2' */ +#define DUK_STRIDX_PI 211 /* 'PI' */ +#define DUK_STRIDX_LOG10E 212 /* 'LOG10E' */ +#define DUK_STRIDX_LOG2E 213 /* 'LOG2E' */ +#define DUK_STRIDX_LN2 214 /* 'LN2' */ +#define DUK_STRIDX_LN10 215 /* 'LN10' */ +#define DUK_STRIDX_E 216 /* 'E' */ +#define DUK_STRIDX_MESSAGE 217 /* 'message' */ +#define DUK_STRIDX_NAME 218 /* 'name' */ +#define DUK_STRIDX_INPUT 219 /* 'input' */ +#define DUK_STRIDX_INDEX 220 /* 'index' */ +#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP 221 /* '(?:)' */ +#define DUK_STRIDX_LAST_INDEX 222 /* 'lastIndex' */ +#define DUK_STRIDX_MULTILINE 223 /* 'multiline' */ +#define DUK_STRIDX_IGNORE_CASE 224 /* 'ignoreCase' */ +#define DUK_STRIDX_SOURCE 225 /* 'source' */ +#define DUK_STRIDX_TEST 226 /* 'test' */ +#define DUK_STRIDX_EXEC 227 /* 'exec' */ +#define DUK_STRIDX_TO_GMT_STRING 228 /* 'toGMTString' */ +#define DUK_STRIDX_SET_YEAR 229 /* 'setYear' */ +#define DUK_STRIDX_GET_YEAR 230 /* 'getYear' */ +#define DUK_STRIDX_TO_JSON 231 /* 'toJSON' */ +#define DUK_STRIDX_TO_ISO_STRING 232 /* 'toISOString' */ +#define DUK_STRIDX_TO_UTC_STRING 233 /* 'toUTCString' */ +#define DUK_STRIDX_SET_UTC_FULL_YEAR 234 /* 'setUTCFullYear' */ +#define DUK_STRIDX_SET_FULL_YEAR 235 /* 'setFullYear' */ +#define DUK_STRIDX_SET_UTC_MONTH 236 /* 'setUTCMonth' */ +#define DUK_STRIDX_SET_MONTH 237 /* 'setMonth' */ +#define DUK_STRIDX_SET_UTC_DATE 238 /* 'setUTCDate' */ +#define DUK_STRIDX_SET_DATE 239 /* 'setDate' */ +#define DUK_STRIDX_SET_UTC_HOURS 240 /* 'setUTCHours' */ +#define DUK_STRIDX_SET_HOURS 241 /* 'setHours' */ +#define DUK_STRIDX_SET_UTC_MINUTES 242 /* 'setUTCMinutes' */ +#define DUK_STRIDX_SET_MINUTES 243 /* 'setMinutes' */ +#define DUK_STRIDX_SET_UTC_SECONDS 244 /* 'setUTCSeconds' */ +#define DUK_STRIDX_SET_SECONDS 245 /* 'setSeconds' */ +#define DUK_STRIDX_SET_UTC_MILLISECONDS 246 /* 'setUTCMilliseconds' */ +#define DUK_STRIDX_SET_MILLISECONDS 247 /* 'setMilliseconds' */ +#define DUK_STRIDX_SET_TIME 248 /* 'setTime' */ +#define DUK_STRIDX_GET_TIMEZONE_OFFSET 249 /* 'getTimezoneOffset' */ +#define DUK_STRIDX_GET_UTC_MILLISECONDS 250 /* 'getUTCMilliseconds' */ +#define DUK_STRIDX_GET_MILLISECONDS 251 /* 'getMilliseconds' */ +#define DUK_STRIDX_GET_UTC_SECONDS 252 /* 'getUTCSeconds' */ +#define DUK_STRIDX_GET_SECONDS 253 /* 'getSeconds' */ +#define DUK_STRIDX_GET_UTC_MINUTES 254 /* 'getUTCMinutes' */ +#define DUK_STRIDX_GET_MINUTES 255 /* 'getMinutes' */ +#define DUK_STRIDX_GET_UTC_HOURS 256 /* 'getUTCHours' */ +#define DUK_STRIDX_GET_HOURS 257 /* 'getHours' */ +#define DUK_STRIDX_GET_UTC_DAY 258 /* 'getUTCDay' */ +#define DUK_STRIDX_GET_DAY 259 /* 'getDay' */ +#define DUK_STRIDX_GET_UTC_DATE 260 /* 'getUTCDate' */ +#define DUK_STRIDX_GET_DATE 261 /* 'getDate' */ +#define DUK_STRIDX_GET_UTC_MONTH 262 /* 'getUTCMonth' */ +#define DUK_STRIDX_GET_MONTH 263 /* 'getMonth' */ +#define DUK_STRIDX_GET_UTC_FULL_YEAR 264 /* 'getUTCFullYear' */ +#define DUK_STRIDX_GET_FULL_YEAR 265 /* 'getFullYear' */ +#define DUK_STRIDX_GET_TIME 266 /* 'getTime' */ +#define DUK_STRIDX_TO_LOCALE_TIME_STRING 267 /* 'toLocaleTimeString' */ +#define DUK_STRIDX_TO_LOCALE_DATE_STRING 268 /* 'toLocaleDateString' */ +#define DUK_STRIDX_TO_TIME_STRING 269 /* 'toTimeString' */ +#define DUK_STRIDX_TO_DATE_STRING 270 /* 'toDateString' */ +#define DUK_STRIDX_NOW 271 /* 'now' */ +#define DUK_STRIDX_UTC 272 /* 'UTC' */ +#define DUK_STRIDX_PARSE 273 /* 'parse' */ +#define DUK_STRIDX_TO_PRECISION 274 /* 'toPrecision' */ +#define DUK_STRIDX_TO_EXPONENTIAL 275 /* 'toExponential' */ +#define DUK_STRIDX_TO_FIXED 276 /* 'toFixed' */ +#define DUK_STRIDX_POSITIVE_INFINITY 277 /* 'POSITIVE_INFINITY' */ +#define DUK_STRIDX_NEGATIVE_INFINITY 278 /* 'NEGATIVE_INFINITY' */ +#define DUK_STRIDX_NAN 279 /* 'NaN' */ +#define DUK_STRIDX_MIN_VALUE 280 /* 'MIN_VALUE' */ +#define DUK_STRIDX_MAX_VALUE 281 /* 'MAX_VALUE' */ +#define DUK_STRIDX_SUBSTR 282 /* 'substr' */ +#define DUK_STRIDX_TRIM 283 /* 'trim' */ +#define DUK_STRIDX_TO_LOCALE_UPPER_CASE 284 /* 'toLocaleUpperCase' */ +#define DUK_STRIDX_TO_UPPER_CASE 285 /* 'toUpperCase' */ +#define DUK_STRIDX_TO_LOCALE_LOWER_CASE 286 /* 'toLocaleLowerCase' */ +#define DUK_STRIDX_TO_LOWER_CASE 287 /* 'toLowerCase' */ +#define DUK_STRIDX_SUBSTRING 288 /* 'substring' */ +#define DUK_STRIDX_SPLIT 289 /* 'split' */ +#define DUK_STRIDX_SEARCH 290 /* 'search' */ +#define DUK_STRIDX_REPLACE 291 /* 'replace' */ +#define DUK_STRIDX_MATCH 292 /* 'match' */ +#define DUK_STRIDX_LOCALE_COMPARE 293 /* 'localeCompare' */ +#define DUK_STRIDX_CHAR_CODE_AT 294 /* 'charCodeAt' */ +#define DUK_STRIDX_CHAR_AT 295 /* 'charAt' */ +#define DUK_STRIDX_FROM_CHAR_CODE 296 /* 'fromCharCode' */ +#define DUK_STRIDX_REDUCE_RIGHT 297 /* 'reduceRight' */ +#define DUK_STRIDX_REDUCE 298 /* 'reduce' */ +#define DUK_STRIDX_FILTER 299 /* 'filter' */ +#define DUK_STRIDX_MAP 300 /* 'map' */ +#define DUK_STRIDX_FOR_EACH 301 /* 'forEach' */ +#define DUK_STRIDX_SOME 302 /* 'some' */ +#define DUK_STRIDX_EVERY 303 /* 'every' */ +#define DUK_STRIDX_LAST_INDEX_OF 304 /* 'lastIndexOf' */ +#define DUK_STRIDX_INDEX_OF 305 /* 'indexOf' */ +#define DUK_STRIDX_UNSHIFT 306 /* 'unshift' */ +#define DUK_STRIDX_SPLICE 307 /* 'splice' */ +#define DUK_STRIDX_SORT 308 /* 'sort' */ +#define DUK_STRIDX_SLICE 309 /* 'slice' */ +#define DUK_STRIDX_SHIFT 310 /* 'shift' */ +#define DUK_STRIDX_REVERSE 311 /* 'reverse' */ +#define DUK_STRIDX_PUSH 312 /* 'push' */ +#define DUK_STRIDX_POP 313 /* 'pop' */ +#define DUK_STRIDX_JOIN 314 /* 'join' */ +#define DUK_STRIDX_CONCAT 315 /* 'concat' */ +#define DUK_STRIDX_IS_ARRAY 316 /* 'isArray' */ +#define DUK_STRIDX_LC_ARGUMENTS 317 /* 'arguments' */ +#define DUK_STRIDX_CALLER 318 /* 'caller' */ +#define DUK_STRIDX_BIND 319 /* 'bind' */ +#define DUK_STRIDX_CALL 320 /* 'call' */ +#define DUK_STRIDX_APPLY 321 /* 'apply' */ +#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE 322 /* 'propertyIsEnumerable' */ +#define DUK_STRIDX_IS_PROTOTYPE_OF 323 /* 'isPrototypeOf' */ +#define DUK_STRIDX_HAS_OWN_PROPERTY 324 /* 'hasOwnProperty' */ +#define DUK_STRIDX_VALUE_OF 325 /* 'valueOf' */ +#define DUK_STRIDX_TO_LOCALE_STRING 326 /* 'toLocaleString' */ +#define DUK_STRIDX_TO_STRING 327 /* 'toString' */ +#define DUK_STRIDX_CONSTRUCTOR 328 /* 'constructor' */ +#define DUK_STRIDX_SET 329 /* 'set' */ +#define DUK_STRIDX_GET 330 /* 'get' */ +#define DUK_STRIDX_ENUMERABLE 331 /* 'enumerable' */ +#define DUK_STRIDX_CONFIGURABLE 332 /* 'configurable' */ +#define DUK_STRIDX_WRITABLE 333 /* 'writable' */ +#define DUK_STRIDX_VALUE 334 /* 'value' */ +#define DUK_STRIDX_KEYS 335 /* 'keys' */ +#define DUK_STRIDX_IS_EXTENSIBLE 336 /* 'isExtensible' */ +#define DUK_STRIDX_IS_FROZEN 337 /* 'isFrozen' */ +#define DUK_STRIDX_IS_SEALED 338 /* 'isSealed' */ +#define DUK_STRIDX_PREVENT_EXTENSIONS 339 /* 'preventExtensions' */ +#define DUK_STRIDX_FREEZE 340 /* 'freeze' */ +#define DUK_STRIDX_SEAL 341 /* 'seal' */ +#define DUK_STRIDX_DEFINE_PROPERTIES 342 /* 'defineProperties' */ +#define DUK_STRIDX_DEFINE_PROPERTY 343 /* 'defineProperty' */ +#define DUK_STRIDX_CREATE 344 /* 'create' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES 345 /* 'getOwnPropertyNames' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR 346 /* 'getOwnPropertyDescriptor' */ +#define DUK_STRIDX_GET_PROTOTYPE_OF 347 /* 'getPrototypeOf' */ +#define DUK_STRIDX_PROTOTYPE 348 /* 'prototype' */ +#define DUK_STRIDX_LENGTH 349 /* 'length' */ +#define DUK_STRIDX_ALERT 350 /* 'alert' */ +#define DUK_STRIDX_PRINT 351 /* 'print' */ +#define DUK_STRIDX_UNESCAPE 352 /* 'unescape' */ +#define DUK_STRIDX_ESCAPE 353 /* 'escape' */ +#define DUK_STRIDX_ENCODE_URI_COMPONENT 354 /* 'encodeURIComponent' */ +#define DUK_STRIDX_ENCODE_URI 355 /* 'encodeURI' */ +#define DUK_STRIDX_DECODE_URI_COMPONENT 356 /* 'decodeURIComponent' */ +#define DUK_STRIDX_DECODE_URI 357 /* 'decodeURI' */ +#define DUK_STRIDX_IS_FINITE 358 /* 'isFinite' */ +#define DUK_STRIDX_IS_NAN 359 /* 'isNaN' */ +#define DUK_STRIDX_PARSE_FLOAT 360 /* 'parseFloat' */ +#define DUK_STRIDX_PARSE_INT 361 /* 'parseInt' */ +#define DUK_STRIDX_EVAL 362 /* 'eval' */ +#define DUK_STRIDX_URI_ERROR 363 /* 'URIError' */ +#define DUK_STRIDX_TYPE_ERROR 364 /* 'TypeError' */ +#define DUK_STRIDX_SYNTAX_ERROR 365 /* 'SyntaxError' */ +#define DUK_STRIDX_REFERENCE_ERROR 366 /* 'ReferenceError' */ +#define DUK_STRIDX_RANGE_ERROR 367 /* 'RangeError' */ +#define DUK_STRIDX_EVAL_ERROR 368 /* 'EvalError' */ +#define DUK_STRIDX_BREAK 369 /* 'break' */ +#define DUK_STRIDX_CASE 370 /* 'case' */ +#define DUK_STRIDX_CATCH 371 /* 'catch' */ +#define DUK_STRIDX_CONTINUE 372 /* 'continue' */ +#define DUK_STRIDX_DEBUGGER 373 /* 'debugger' */ +#define DUK_STRIDX_DEFAULT 374 /* 'default' */ +#define DUK_STRIDX_DELETE 375 /* 'delete' */ +#define DUK_STRIDX_DO 376 /* 'do' */ +#define DUK_STRIDX_ELSE 377 /* 'else' */ +#define DUK_STRIDX_FINALLY 378 /* 'finally' */ +#define DUK_STRIDX_FOR 379 /* 'for' */ +#define DUK_STRIDX_LC_FUNCTION 380 /* 'function' */ +#define DUK_STRIDX_IF 381 /* 'if' */ +#define DUK_STRIDX_IN 382 /* 'in' */ +#define DUK_STRIDX_INSTANCEOF 383 /* 'instanceof' */ +#define DUK_STRIDX_NEW 384 /* 'new' */ +#define DUK_STRIDX_RETURN 385 /* 'return' */ +#define DUK_STRIDX_SWITCH 386 /* 'switch' */ +#define DUK_STRIDX_THIS 387 /* 'this' */ +#define DUK_STRIDX_THROW 388 /* 'throw' */ +#define DUK_STRIDX_TRY 389 /* 'try' */ +#define DUK_STRIDX_TYPEOF 390 /* 'typeof' */ +#define DUK_STRIDX_VAR 391 /* 'var' */ +#define DUK_STRIDX_VOID 392 /* 'void' */ +#define DUK_STRIDX_WHILE 393 /* 'while' */ +#define DUK_STRIDX_WITH 394 /* 'with' */ +#define DUK_STRIDX_CLASS 395 /* 'class' */ +#define DUK_STRIDX_CONST 396 /* 'const' */ +#define DUK_STRIDX_ENUM 397 /* 'enum' */ +#define DUK_STRIDX_EXPORT 398 /* 'export' */ +#define DUK_STRIDX_EXTENDS 399 /* 'extends' */ +#define DUK_STRIDX_IMPORT 400 /* 'import' */ +#define DUK_STRIDX_SUPER 401 /* 'super' */ +#define DUK_STRIDX_LC_NULL 402 /* 'null' */ +#define DUK_STRIDX_TRUE 403 /* 'true' */ +#define DUK_STRIDX_FALSE 404 /* 'false' */ +#define DUK_STRIDX_IMPLEMENTS 405 /* 'implements' */ +#define DUK_STRIDX_INTERFACE 406 /* 'interface' */ +#define DUK_STRIDX_LET 407 /* 'let' */ +#define DUK_STRIDX_PACKAGE 408 /* 'package' */ +#define DUK_STRIDX_PRIVATE 409 /* 'private' */ +#define DUK_STRIDX_PROTECTED 410 /* 'protected' */ +#define DUK_STRIDX_PUBLIC 411 /* 'public' */ +#define DUK_STRIDX_STATIC 412 /* 'static' */ +#define DUK_STRIDX_YIELD 413 /* 'yield' */ + +#define DUK_HEAP_STRING_UC_LOGGER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER) +#define DUK_HTHREAD_STRING_UC_LOGGER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER) +#define DUK_HEAP_STRING_UC_THREAD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD) +#define DUK_HTHREAD_STRING_UC_THREAD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD) +#define DUK_HEAP_STRING_UC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER) +#define DUK_HTHREAD_STRING_UC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER) +#define DUK_HEAP_STRING_DEC_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV) +#define DUK_HTHREAD_STRING_DEC_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV) +#define DUK_HEAP_STRING_OBJ_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV) +#define DUK_HTHREAD_STRING_OBJ_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV) +#define DUK_HEAP_STRING_FLOAT64_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT64_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HEAP_STRING_FLOAT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HEAP_STRING_UINT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HTHREAD_STRING_UINT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HEAP_STRING_INT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT32_ARRAY) +#define DUK_HTHREAD_STRING_INT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT32_ARRAY) +#define DUK_HEAP_STRING_UINT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HTHREAD_STRING_UINT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HEAP_STRING_INT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT16_ARRAY) +#define DUK_HTHREAD_STRING_INT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT16_ARRAY) +#define DUK_HEAP_STRING_UINT8_CLAMPED_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_CLAMPED_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HEAP_STRING_UINT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HEAP_STRING_INT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT8_ARRAY) +#define DUK_HTHREAD_STRING_INT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT8_ARRAY) +#define DUK_HEAP_STRING_DATA_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA_VIEW) +#define DUK_HTHREAD_STRING_DATA_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA_VIEW) +#define DUK_HEAP_STRING_ARRAY_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HTHREAD_STRING_ARRAY_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HEAP_STRING_UC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER) +#define DUK_HTHREAD_STRING_UC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER) +#define DUK_HEAP_STRING_EMPTY_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING) +#define DUK_HTHREAD_STRING_EMPTY_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING) +#define DUK_HEAP_STRING_GLOBAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL) +#define DUK_HTHREAD_STRING_GLOBAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL) +#define DUK_HEAP_STRING_UC_ARGUMENTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS) +#define DUK_HTHREAD_STRING_UC_ARGUMENTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS) +#define DUK_HEAP_STRING_JSON(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON) +#define DUK_HTHREAD_STRING_JSON(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON) +#define DUK_HEAP_STRING_MATH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH) +#define DUK_HTHREAD_STRING_MATH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH) +#define DUK_HEAP_STRING_UC_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR) +#define DUK_HTHREAD_STRING_UC_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR) +#define DUK_HEAP_STRING_REG_EXP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP) +#define DUK_HTHREAD_STRING_REG_EXP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP) +#define DUK_HEAP_STRING_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATE) +#define DUK_HTHREAD_STRING_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATE) +#define DUK_HEAP_STRING_UC_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER) +#define DUK_HTHREAD_STRING_UC_NUMBER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER) +#define DUK_HEAP_STRING_UC_BOOLEAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN) +#define DUK_HTHREAD_STRING_UC_BOOLEAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN) +#define DUK_HEAP_STRING_UC_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING) +#define DUK_HTHREAD_STRING_UC_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING) +#define DUK_HEAP_STRING_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY) +#define DUK_HTHREAD_STRING_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY) +#define DUK_HEAP_STRING_UC_FUNCTION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION) +#define DUK_HTHREAD_STRING_UC_FUNCTION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION) +#define DUK_HEAP_STRING_UC_OBJECT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT) +#define DUK_HTHREAD_STRING_UC_OBJECT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT) +#define DUK_HEAP_STRING_UC_NULL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL) +#define DUK_HTHREAD_STRING_UC_NULL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL) +#define DUK_HEAP_STRING_UC_UNDEFINED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED) +#define DUK_HTHREAD_STRING_UC_UNDEFINED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED) +#define DUK_HEAP_STRING_JSON_EXT_FUNCTION2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2) +#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2) +#define DUK_HEAP_STRING_JSON_EXT_FUNCTION1(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1) +#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1) +#define DUK_HEAP_STRING_JSON_EXT_NEGINF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF) +#define DUK_HTHREAD_STRING_JSON_EXT_NEGINF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF) +#define DUK_HEAP_STRING_JSON_EXT_POSINF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF) +#define DUK_HTHREAD_STRING_JSON_EXT_POSINF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF) +#define DUK_HEAP_STRING_JSON_EXT_NAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN) +#define DUK_HTHREAD_STRING_JSON_EXT_NAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN) +#define DUK_HEAP_STRING_JSON_EXT_UNDEFINED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED) +#define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED) +#define DUK_HEAP_STRING_TO_LOG_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOG_STRING) +#define DUK_HTHREAD_STRING_TO_LOG_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOG_STRING) +#define DUK_HEAP_STRING_CLOG(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLOG) +#define DUK_HTHREAD_STRING_CLOG(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLOG) +#define DUK_HEAP_STRING_LC_L(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_L) +#define DUK_HTHREAD_STRING_LC_L(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_L) +#define DUK_HEAP_STRING_LC_N(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_N) +#define DUK_HTHREAD_STRING_LC_N(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_N) +#define DUK_HEAP_STRING_LC_FATAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FATAL) +#define DUK_HTHREAD_STRING_LC_FATAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FATAL) +#define DUK_HEAP_STRING_LC_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ERROR) +#define DUK_HTHREAD_STRING_LC_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ERROR) +#define DUK_HEAP_STRING_LC_WARN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_WARN) +#define DUK_HTHREAD_STRING_LC_WARN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_WARN) +#define DUK_HEAP_STRING_LC_DEBUG(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_DEBUG) +#define DUK_HTHREAD_STRING_LC_DEBUG(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_DEBUG) +#define DUK_HEAP_STRING_LC_TRACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_TRACE) +#define DUK_HTHREAD_STRING_LC_TRACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_TRACE) +#define DUK_HEAP_STRING_RAW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RAW) +#define DUK_HTHREAD_STRING_RAW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RAW) +#define DUK_HEAP_STRING_FMT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FMT) +#define DUK_HTHREAD_STRING_FMT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FMT) +#define DUK_HEAP_STRING_CURRENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CURRENT) +#define DUK_HTHREAD_STRING_CURRENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CURRENT) +#define DUK_HEAP_STRING_RESUME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RESUME) +#define DUK_HTHREAD_STRING_RESUME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RESUME) +#define DUK_HEAP_STRING_COMPACT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPACT) +#define DUK_HTHREAD_STRING_COMPACT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPACT) +#define DUK_HEAP_STRING_JC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC) +#define DUK_HTHREAD_STRING_JC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC) +#define DUK_HEAP_STRING_JX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX) +#define DUK_HTHREAD_STRING_JX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX) +#define DUK_HEAP_STRING_BASE64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64) +#define DUK_HTHREAD_STRING_BASE64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64) +#define DUK_HEAP_STRING_HEX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX) +#define DUK_HTHREAD_STRING_HEX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX) +#define DUK_HEAP_STRING_DEC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC) +#define DUK_HTHREAD_STRING_DEC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC) +#define DUK_HEAP_STRING_ENC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENC) +#define DUK_HTHREAD_STRING_ENC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENC) +#define DUK_HEAP_STRING_FIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FIN) +#define DUK_HTHREAD_STRING_FIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FIN) +#define DUK_HEAP_STRING_GC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GC) +#define DUK_HTHREAD_STRING_GC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GC) +#define DUK_HEAP_STRING_ACT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACT) +#define DUK_HTHREAD_STRING_ACT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACT) +#define DUK_HEAP_STRING_LC_INFO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_INFO) +#define DUK_HTHREAD_STRING_LC_INFO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_INFO) +#define DUK_HEAP_STRING_VERSION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VERSION) +#define DUK_HTHREAD_STRING_VERSION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VERSION) +#define DUK_HEAP_STRING_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV) +#define DUK_HTHREAD_STRING_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV) +#define DUK_HEAP_STRING_MOD_LOADED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_LOADED) +#define DUK_HTHREAD_STRING_MOD_LOADED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_LOADED) +#define DUK_HEAP_STRING_MOD_SEARCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_SEARCH) +#define DUK_HTHREAD_STRING_MOD_SEARCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_SEARCH) +#define DUK_HEAP_STRING_ERR_THROW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW) +#define DUK_HTHREAD_STRING_ERR_THROW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW) +#define DUK_HEAP_STRING_ERR_CREATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE) +#define DUK_HTHREAD_STRING_ERR_CREATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE) +#define DUK_HEAP_STRING_COMPILE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE) +#define DUK_HTHREAD_STRING_COMPILE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE) +#define DUK_HEAP_STRING_INT_REGBASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_REGBASE) +#define DUK_HTHREAD_STRING_INT_REGBASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_REGBASE) +#define DUK_HEAP_STRING_INT_THREAD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THREAD) +#define DUK_HTHREAD_STRING_INT_THREAD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THREAD) +#define DUK_HEAP_STRING_INT_HANDLER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_HANDLER) +#define DUK_HTHREAD_STRING_INT_HANDLER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_HANDLER) +#define DUK_HEAP_STRING_INT_FINALIZER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER) +#define DUK_HTHREAD_STRING_INT_FINALIZER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER) +#define DUK_HEAP_STRING_INT_CALLEE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_CALLEE) +#define DUK_HTHREAD_STRING_INT_CALLEE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_CALLEE) +#define DUK_HEAP_STRING_INT_MAP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP) +#define DUK_HTHREAD_STRING_INT_MAP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP) +#define DUK_HEAP_STRING_INT_ARGS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_ARGS) +#define DUK_HTHREAD_STRING_INT_ARGS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_ARGS) +#define DUK_HEAP_STRING_INT_THIS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THIS) +#define DUK_HTHREAD_STRING_INT_THIS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THIS) +#define DUK_HEAP_STRING_INT_PC2LINE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE) +#define DUK_HTHREAD_STRING_INT_PC2LINE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE) +#define DUK_HEAP_STRING_INT_SOURCE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE) +#define DUK_HTHREAD_STRING_INT_SOURCE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE) +#define DUK_HEAP_STRING_INT_VARENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV) +#define DUK_HTHREAD_STRING_INT_VARENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV) +#define DUK_HEAP_STRING_INT_LEXENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_LEXENV) +#define DUK_HTHREAD_STRING_INT_LEXENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_LEXENV) +#define DUK_HEAP_STRING_INT_VARMAP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP) +#define DUK_HTHREAD_STRING_INT_VARMAP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP) +#define DUK_HEAP_STRING_INT_FORMALS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS) +#define DUK_HTHREAD_STRING_INT_FORMALS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS) +#define DUK_HEAP_STRING_INT_BYTECODE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE) +#define DUK_HTHREAD_STRING_INT_BYTECODE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE) +#define DUK_HEAP_STRING_INT_NEXT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT) +#define DUK_HTHREAD_STRING_INT_NEXT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT) +#define DUK_HEAP_STRING_INT_TARGET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET) +#define DUK_HTHREAD_STRING_INT_TARGET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET) +#define DUK_HEAP_STRING_INT_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE) +#define DUK_HTHREAD_STRING_INT_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE) +#define DUK_HEAP_STRING_LC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER) +#define DUK_HTHREAD_STRING_LC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER) +#define DUK_HEAP_STRING_INT_TRACEDATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA) +#define DUK_HTHREAD_STRING_INT_TRACEDATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA) +#define DUK_HEAP_STRING_LINE_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER) +#define DUK_HTHREAD_STRING_LINE_NUMBER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER) +#define DUK_HEAP_STRING_FILE_NAME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME) +#define DUK_HTHREAD_STRING_FILE_NAME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME) +#define DUK_HEAP_STRING_PC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC) +#define DUK_HTHREAD_STRING_PC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC) +#define DUK_HEAP_STRING_STACK(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK) +#define DUK_HTHREAD_STRING_STACK(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK) +#define DUK_HEAP_STRING_THROW_TYPE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW_TYPE_ERROR) +#define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR) +#define DUK_HEAP_STRING_DUKTAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE) +#define DUK_HTHREAD_STRING_DUKTAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE) +#define DUK_HEAP_STRING_SET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT64) +#define DUK_HTHREAD_STRING_SET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT64) +#define DUK_HEAP_STRING_SET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT32) +#define DUK_HTHREAD_STRING_SET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT32) +#define DUK_HEAP_STRING_SET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT32) +#define DUK_HTHREAD_STRING_SET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT32) +#define DUK_HEAP_STRING_SET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT32) +#define DUK_HTHREAD_STRING_SET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT32) +#define DUK_HEAP_STRING_SET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT16) +#define DUK_HTHREAD_STRING_SET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT16) +#define DUK_HEAP_STRING_SET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT16) +#define DUK_HTHREAD_STRING_SET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT16) +#define DUK_HEAP_STRING_SET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT8) +#define DUK_HTHREAD_STRING_SET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT8) +#define DUK_HEAP_STRING_SET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT8) +#define DUK_HTHREAD_STRING_SET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT8) +#define DUK_HEAP_STRING_GET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT64) +#define DUK_HTHREAD_STRING_GET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT64) +#define DUK_HEAP_STRING_GET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT32) +#define DUK_HTHREAD_STRING_GET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT32) +#define DUK_HEAP_STRING_GET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT32) +#define DUK_HTHREAD_STRING_GET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT32) +#define DUK_HEAP_STRING_GET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT32) +#define DUK_HTHREAD_STRING_GET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT32) +#define DUK_HEAP_STRING_GET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT16) +#define DUK_HTHREAD_STRING_GET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT16) +#define DUK_HEAP_STRING_GET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT16) +#define DUK_HTHREAD_STRING_GET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT16) +#define DUK_HEAP_STRING_GET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT8) +#define DUK_HTHREAD_STRING_GET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT8) +#define DUK_HEAP_STRING_GET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT8) +#define DUK_HTHREAD_STRING_GET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT8) +#define DUK_HEAP_STRING_SUBARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBARRAY) +#define DUK_HTHREAD_STRING_SUBARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBARRAY) +#define DUK_HEAP_STRING_BYTES_PER_ELEMENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HEAP_STRING_BYTE_OFFSET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HTHREAD_STRING_BYTE_OFFSET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HEAP_STRING_LC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER) +#define DUK_HTHREAD_STRING_LC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER) +#define DUK_HEAP_STRING_IS_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_VIEW) +#define DUK_HTHREAD_STRING_IS_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_VIEW) +#define DUK_HEAP_STRING_DATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA) +#define DUK_HTHREAD_STRING_DATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA) +#define DUK_HEAP_STRING_TYPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE) +#define DUK_HTHREAD_STRING_TYPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE) +#define DUK_HEAP_STRING_WRITE_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HTHREAD_STRING_WRITE_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HEAP_STRING_WRITE_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HTHREAD_STRING_WRITE_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HEAP_STRING_WRITE_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HEAP_STRING_WRITE_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HEAP_STRING_WRITE_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HEAP_STRING_WRITE_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HEAP_STRING_WRITE_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HTHREAD_STRING_WRITE_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HEAP_STRING_WRITE_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HTHREAD_STRING_WRITE_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HEAP_STRING_WRITE_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HEAP_STRING_WRITE_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HEAP_STRING_WRITE_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HTHREAD_STRING_WRITE_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HEAP_STRING_WRITE_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HTHREAD_STRING_WRITE_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HEAP_STRING_WRITE_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HEAP_STRING_WRITE_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HEAP_STRING_WRITE_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT8) +#define DUK_HTHREAD_STRING_WRITE_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT8) +#define DUK_HEAP_STRING_WRITE_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT8) +#define DUK_HTHREAD_STRING_WRITE_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT8) +#define DUK_HEAP_STRING_READ_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_BE) +#define DUK_HTHREAD_STRING_READ_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_BE) +#define DUK_HEAP_STRING_READ_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_LE) +#define DUK_HTHREAD_STRING_READ_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_LE) +#define DUK_HEAP_STRING_READ_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_BE) +#define DUK_HTHREAD_STRING_READ_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_BE) +#define DUK_HEAP_STRING_READ_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_LE) +#define DUK_HTHREAD_STRING_READ_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_LE) +#define DUK_HEAP_STRING_READ_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HEAP_STRING_READ_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HEAP_STRING_READ_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HTHREAD_STRING_READ_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HEAP_STRING_READ_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HTHREAD_STRING_READ_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HEAP_STRING_READ_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_BE) +#define DUK_HTHREAD_STRING_READ_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_BE) +#define DUK_HEAP_STRING_READ_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_LE) +#define DUK_HTHREAD_STRING_READ_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_LE) +#define DUK_HEAP_STRING_READ_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HTHREAD_STRING_READ_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HEAP_STRING_READ_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HTHREAD_STRING_READ_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HEAP_STRING_READ_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_BE) +#define DUK_HTHREAD_STRING_READ_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_BE) +#define DUK_HEAP_STRING_READ_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_LE) +#define DUK_HTHREAD_STRING_READ_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_LE) +#define DUK_HEAP_STRING_READ_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HTHREAD_STRING_READ_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HEAP_STRING_READ_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HTHREAD_STRING_READ_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HEAP_STRING_READ_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT8) +#define DUK_HTHREAD_STRING_READ_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT8) +#define DUK_HEAP_STRING_READ_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT8) +#define DUK_HTHREAD_STRING_READ_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT8) +#define DUK_HEAP_STRING_COPY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COPY) +#define DUK_HTHREAD_STRING_COPY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COPY) +#define DUK_HEAP_STRING_EQUALS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EQUALS) +#define DUK_HTHREAD_STRING_EQUALS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EQUALS) +#define DUK_HEAP_STRING_FILL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILL) +#define DUK_HTHREAD_STRING_FILL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILL) +#define DUK_HEAP_STRING_WRITE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE) +#define DUK_HTHREAD_STRING_WRITE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE) +#define DUK_HEAP_STRING_COMPARE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPARE) +#define DUK_HTHREAD_STRING_COMPARE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPARE) +#define DUK_HEAP_STRING_BYTE_LENGTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HTHREAD_STRING_BYTE_LENGTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HEAP_STRING_IS_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_BUFFER) +#define DUK_HTHREAD_STRING_IS_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_BUFFER) +#define DUK_HEAP_STRING_IS_ENCODING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ENCODING) +#define DUK_HTHREAD_STRING_IS_ENCODING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ENCODING) +#define DUK_HEAP_STRING_EXPORTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORTS) +#define DUK_HTHREAD_STRING_EXPORTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORTS) +#define DUK_HEAP_STRING_ID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID) +#define DUK_HTHREAD_STRING_ID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID) +#define DUK_HEAP_STRING_REQUIRE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE) +#define DUK_HTHREAD_STRING_REQUIRE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REQUIRE) +#define DUK_HEAP_STRING___PROTO__(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__) +#define DUK_HTHREAD_STRING___PROTO__(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__) +#define DUK_HEAP_STRING_SET_PROTOTYPE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF) +#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF) +#define DUK_HEAP_STRING_OWN_KEYS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS) +#define DUK_HTHREAD_STRING_OWN_KEYS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS) +#define DUK_HEAP_STRING_ENUMERATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERATE) +#define DUK_HTHREAD_STRING_ENUMERATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERATE) +#define DUK_HEAP_STRING_DELETE_PROPERTY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY) +#define DUK_HTHREAD_STRING_DELETE_PROPERTY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY) +#define DUK_HEAP_STRING_HAS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS) +#define DUK_HTHREAD_STRING_HAS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS) +#define DUK_HEAP_STRING_PROXY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROXY) +#define DUK_HTHREAD_STRING_PROXY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROXY) +#define DUK_HEAP_STRING_CALLEE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE) +#define DUK_HTHREAD_STRING_CALLEE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE) +#define DUK_HEAP_STRING_INVALID_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE) +#define DUK_HTHREAD_STRING_INVALID_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE) +#define DUK_HEAP_STRING_BRACKETED_ELLIPSIS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS) +#define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS) +#define DUK_HEAP_STRING_NEWLINE_TAB(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_TAB) +#define DUK_HTHREAD_STRING_NEWLINE_TAB(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_TAB) +#define DUK_HEAP_STRING_SPACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPACE) +#define DUK_HTHREAD_STRING_SPACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPACE) +#define DUK_HEAP_STRING_COMMA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA) +#define DUK_HTHREAD_STRING_COMMA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA) +#define DUK_HEAP_STRING_MINUS_ZERO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO) +#define DUK_HTHREAD_STRING_MINUS_ZERO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO) +#define DUK_HEAP_STRING_PLUS_ZERO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_ZERO) +#define DUK_HTHREAD_STRING_PLUS_ZERO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_ZERO) +#define DUK_HEAP_STRING_ZERO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ZERO) +#define DUK_HTHREAD_STRING_ZERO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ZERO) +#define DUK_HEAP_STRING_MINUS_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY) +#define DUK_HTHREAD_STRING_MINUS_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY) +#define DUK_HEAP_STRING_PLUS_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_INFINITY) +#define DUK_HTHREAD_STRING_PLUS_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_INFINITY) +#define DUK_HEAP_STRING_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY) +#define DUK_HTHREAD_STRING_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY) +#define DUK_HEAP_STRING_LC_OBJECT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT) +#define DUK_HTHREAD_STRING_LC_OBJECT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT) +#define DUK_HEAP_STRING_LC_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING) +#define DUK_HTHREAD_STRING_LC_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING) +#define DUK_HEAP_STRING_LC_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER) +#define DUK_HTHREAD_STRING_LC_NUMBER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER) +#define DUK_HEAP_STRING_LC_BOOLEAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN) +#define DUK_HTHREAD_STRING_LC_BOOLEAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN) +#define DUK_HEAP_STRING_LC_UNDEFINED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED) +#define DUK_HTHREAD_STRING_LC_UNDEFINED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED) +#define DUK_HEAP_STRING_STRINGIFY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STRINGIFY) +#define DUK_HTHREAD_STRING_STRINGIFY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STRINGIFY) +#define DUK_HEAP_STRING_TAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TAN) +#define DUK_HTHREAD_STRING_TAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TAN) +#define DUK_HEAP_STRING_SQRT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT) +#define DUK_HTHREAD_STRING_SQRT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT) +#define DUK_HEAP_STRING_SIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SIN) +#define DUK_HTHREAD_STRING_SIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SIN) +#define DUK_HEAP_STRING_ROUND(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ROUND) +#define DUK_HTHREAD_STRING_ROUND(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ROUND) +#define DUK_HEAP_STRING_RANDOM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANDOM) +#define DUK_HTHREAD_STRING_RANDOM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANDOM) +#define DUK_HEAP_STRING_POW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POW) +#define DUK_HTHREAD_STRING_POW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POW) +#define DUK_HEAP_STRING_MIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN) +#define DUK_HTHREAD_STRING_MIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN) +#define DUK_HEAP_STRING_MAX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX) +#define DUK_HTHREAD_STRING_MAX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX) +#define DUK_HEAP_STRING_LOG(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG) +#define DUK_HTHREAD_STRING_LOG(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG) +#define DUK_HEAP_STRING_FLOOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOOR) +#define DUK_HTHREAD_STRING_FLOOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOOR) +#define DUK_HEAP_STRING_EXP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXP) +#define DUK_HTHREAD_STRING_EXP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXP) +#define DUK_HEAP_STRING_COS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COS) +#define DUK_HTHREAD_STRING_COS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COS) +#define DUK_HEAP_STRING_CEIL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CEIL) +#define DUK_HTHREAD_STRING_CEIL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CEIL) +#define DUK_HEAP_STRING_ATAN2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN2) +#define DUK_HTHREAD_STRING_ATAN2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN2) +#define DUK_HEAP_STRING_ATAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN) +#define DUK_HTHREAD_STRING_ATAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN) +#define DUK_HEAP_STRING_ASIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ASIN) +#define DUK_HTHREAD_STRING_ASIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ASIN) +#define DUK_HEAP_STRING_ACOS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACOS) +#define DUK_HTHREAD_STRING_ACOS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACOS) +#define DUK_HEAP_STRING_ABS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ABS) +#define DUK_HTHREAD_STRING_ABS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ABS) +#define DUK_HEAP_STRING_SQRT2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT2) +#define DUK_HTHREAD_STRING_SQRT2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT2) +#define DUK_HEAP_STRING_SQRT1_2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT1_2) +#define DUK_HTHREAD_STRING_SQRT1_2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT1_2) +#define DUK_HEAP_STRING_PI(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PI) +#define DUK_HTHREAD_STRING_PI(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PI) +#define DUK_HEAP_STRING_LOG10E(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG10E) +#define DUK_HTHREAD_STRING_LOG10E(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG10E) +#define DUK_HEAP_STRING_LOG2E(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG2E) +#define DUK_HTHREAD_STRING_LOG2E(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG2E) +#define DUK_HEAP_STRING_LN2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN2) +#define DUK_HTHREAD_STRING_LN2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN2) +#define DUK_HEAP_STRING_LN10(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN10) +#define DUK_HTHREAD_STRING_LN10(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN10) +#define DUK_HEAP_STRING_E(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_E) +#define DUK_HTHREAD_STRING_E(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_E) +#define DUK_HEAP_STRING_MESSAGE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE) +#define DUK_HTHREAD_STRING_MESSAGE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE) +#define DUK_HEAP_STRING_NAME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME) +#define DUK_HTHREAD_STRING_NAME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME) +#define DUK_HEAP_STRING_INPUT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT) +#define DUK_HTHREAD_STRING_INPUT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT) +#define DUK_HEAP_STRING_INDEX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX) +#define DUK_HTHREAD_STRING_INDEX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX) +#define DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPED_EMPTY_REGEXP) +#define DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPED_EMPTY_REGEXP) +#define DUK_HEAP_STRING_LAST_INDEX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX) +#define DUK_HTHREAD_STRING_LAST_INDEX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX) +#define DUK_HEAP_STRING_MULTILINE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE) +#define DUK_HTHREAD_STRING_MULTILINE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE) +#define DUK_HEAP_STRING_IGNORE_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE) +#define DUK_HTHREAD_STRING_IGNORE_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE) +#define DUK_HEAP_STRING_SOURCE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE) +#define DUK_HTHREAD_STRING_SOURCE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE) +#define DUK_HEAP_STRING_TEST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TEST) +#define DUK_HTHREAD_STRING_TEST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TEST) +#define DUK_HEAP_STRING_EXEC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXEC) +#define DUK_HTHREAD_STRING_EXEC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXEC) +#define DUK_HEAP_STRING_TO_GMT_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING) +#define DUK_HTHREAD_STRING_TO_GMT_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING) +#define DUK_HEAP_STRING_SET_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_YEAR) +#define DUK_HTHREAD_STRING_SET_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_YEAR) +#define DUK_HEAP_STRING_GET_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_YEAR) +#define DUK_HTHREAD_STRING_GET_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_YEAR) +#define DUK_HEAP_STRING_TO_JSON(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON) +#define DUK_HTHREAD_STRING_TO_JSON(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON) +#define DUK_HEAP_STRING_TO_ISO_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING) +#define DUK_HTHREAD_STRING_TO_ISO_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING) +#define DUK_HEAP_STRING_TO_UTC_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING) +#define DUK_HTHREAD_STRING_TO_UTC_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING) +#define DUK_HEAP_STRING_SET_UTC_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_FULL_YEAR) +#define DUK_HTHREAD_STRING_SET_UTC_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_FULL_YEAR) +#define DUK_HEAP_STRING_SET_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FULL_YEAR) +#define DUK_HTHREAD_STRING_SET_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FULL_YEAR) +#define DUK_HEAP_STRING_SET_UTC_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MONTH) +#define DUK_HTHREAD_STRING_SET_UTC_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MONTH) +#define DUK_HEAP_STRING_SET_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MONTH) +#define DUK_HTHREAD_STRING_SET_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MONTH) +#define DUK_HEAP_STRING_SET_UTC_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_DATE) +#define DUK_HTHREAD_STRING_SET_UTC_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_DATE) +#define DUK_HEAP_STRING_SET_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_DATE) +#define DUK_HTHREAD_STRING_SET_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_DATE) +#define DUK_HEAP_STRING_SET_UTC_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_HOURS) +#define DUK_HTHREAD_STRING_SET_UTC_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_HOURS) +#define DUK_HEAP_STRING_SET_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_HOURS) +#define DUK_HTHREAD_STRING_SET_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_HOURS) +#define DUK_HEAP_STRING_SET_UTC_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MINUTES) +#define DUK_HTHREAD_STRING_SET_UTC_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MINUTES) +#define DUK_HEAP_STRING_SET_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MINUTES) +#define DUK_HTHREAD_STRING_SET_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MINUTES) +#define DUK_HEAP_STRING_SET_UTC_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_SECONDS) +#define DUK_HTHREAD_STRING_SET_UTC_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_SECONDS) +#define DUK_HEAP_STRING_SET_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_SECONDS) +#define DUK_HTHREAD_STRING_SET_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_SECONDS) +#define DUK_HEAP_STRING_SET_UTC_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MILLISECONDS) +#define DUK_HTHREAD_STRING_SET_UTC_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MILLISECONDS) +#define DUK_HEAP_STRING_SET_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MILLISECONDS) +#define DUK_HTHREAD_STRING_SET_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MILLISECONDS) +#define DUK_HEAP_STRING_SET_TIME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_TIME) +#define DUK_HTHREAD_STRING_SET_TIME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_TIME) +#define DUK_HEAP_STRING_GET_TIMEZONE_OFFSET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIMEZONE_OFFSET) +#define DUK_HTHREAD_STRING_GET_TIMEZONE_OFFSET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIMEZONE_OFFSET) +#define DUK_HEAP_STRING_GET_UTC_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MILLISECONDS) +#define DUK_HTHREAD_STRING_GET_UTC_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MILLISECONDS) +#define DUK_HEAP_STRING_GET_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MILLISECONDS) +#define DUK_HTHREAD_STRING_GET_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MILLISECONDS) +#define DUK_HEAP_STRING_GET_UTC_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_SECONDS) +#define DUK_HTHREAD_STRING_GET_UTC_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_SECONDS) +#define DUK_HEAP_STRING_GET_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_SECONDS) +#define DUK_HTHREAD_STRING_GET_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_SECONDS) +#define DUK_HEAP_STRING_GET_UTC_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MINUTES) +#define DUK_HTHREAD_STRING_GET_UTC_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MINUTES) +#define DUK_HEAP_STRING_GET_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MINUTES) +#define DUK_HTHREAD_STRING_GET_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MINUTES) +#define DUK_HEAP_STRING_GET_UTC_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_HOURS) +#define DUK_HTHREAD_STRING_GET_UTC_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_HOURS) +#define DUK_HEAP_STRING_GET_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_HOURS) +#define DUK_HTHREAD_STRING_GET_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_HOURS) +#define DUK_HEAP_STRING_GET_UTC_DAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DAY) +#define DUK_HTHREAD_STRING_GET_UTC_DAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DAY) +#define DUK_HEAP_STRING_GET_DAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DAY) +#define DUK_HTHREAD_STRING_GET_DAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DAY) +#define DUK_HEAP_STRING_GET_UTC_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DATE) +#define DUK_HTHREAD_STRING_GET_UTC_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DATE) +#define DUK_HEAP_STRING_GET_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DATE) +#define DUK_HTHREAD_STRING_GET_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DATE) +#define DUK_HEAP_STRING_GET_UTC_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MONTH) +#define DUK_HTHREAD_STRING_GET_UTC_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MONTH) +#define DUK_HEAP_STRING_GET_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MONTH) +#define DUK_HTHREAD_STRING_GET_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MONTH) +#define DUK_HEAP_STRING_GET_UTC_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_FULL_YEAR) +#define DUK_HTHREAD_STRING_GET_UTC_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_FULL_YEAR) +#define DUK_HEAP_STRING_GET_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FULL_YEAR) +#define DUK_HTHREAD_STRING_GET_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FULL_YEAR) +#define DUK_HEAP_STRING_GET_TIME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIME) +#define DUK_HTHREAD_STRING_GET_TIME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIME) +#define DUK_HEAP_STRING_TO_LOCALE_TIME_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_TIME_STRING) +#define DUK_HTHREAD_STRING_TO_LOCALE_TIME_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_TIME_STRING) +#define DUK_HEAP_STRING_TO_LOCALE_DATE_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_DATE_STRING) +#define DUK_HTHREAD_STRING_TO_LOCALE_DATE_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_DATE_STRING) +#define DUK_HEAP_STRING_TO_TIME_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_TIME_STRING) +#define DUK_HTHREAD_STRING_TO_TIME_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_TIME_STRING) +#define DUK_HEAP_STRING_TO_DATE_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_DATE_STRING) +#define DUK_HTHREAD_STRING_TO_DATE_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_DATE_STRING) +#define DUK_HEAP_STRING_NOW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NOW) +#define DUK_HTHREAD_STRING_NOW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NOW) +#define DUK_HEAP_STRING_UTC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UTC) +#define DUK_HTHREAD_STRING_UTC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UTC) +#define DUK_HEAP_STRING_PARSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE) +#define DUK_HTHREAD_STRING_PARSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE) +#define DUK_HEAP_STRING_TO_PRECISION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_PRECISION) +#define DUK_HTHREAD_STRING_TO_PRECISION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_PRECISION) +#define DUK_HEAP_STRING_TO_EXPONENTIAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_EXPONENTIAL) +#define DUK_HTHREAD_STRING_TO_EXPONENTIAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_EXPONENTIAL) +#define DUK_HEAP_STRING_TO_FIXED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_FIXED) +#define DUK_HTHREAD_STRING_TO_FIXED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_FIXED) +#define DUK_HEAP_STRING_POSITIVE_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POSITIVE_INFINITY) +#define DUK_HTHREAD_STRING_POSITIVE_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POSITIVE_INFINITY) +#define DUK_HEAP_STRING_NEGATIVE_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEGATIVE_INFINITY) +#define DUK_HTHREAD_STRING_NEGATIVE_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEGATIVE_INFINITY) +#define DUK_HEAP_STRING_NAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN) +#define DUK_HTHREAD_STRING_NAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN) +#define DUK_HEAP_STRING_MIN_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN_VALUE) +#define DUK_HTHREAD_STRING_MIN_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN_VALUE) +#define DUK_HEAP_STRING_MAX_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX_VALUE) +#define DUK_HTHREAD_STRING_MAX_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX_VALUE) +#define DUK_HEAP_STRING_SUBSTR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTR) +#define DUK_HTHREAD_STRING_SUBSTR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTR) +#define DUK_HEAP_STRING_TRIM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRIM) +#define DUK_HTHREAD_STRING_TRIM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRIM) +#define DUK_HEAP_STRING_TO_LOCALE_UPPER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_UPPER_CASE) +#define DUK_HTHREAD_STRING_TO_LOCALE_UPPER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_UPPER_CASE) +#define DUK_HEAP_STRING_TO_UPPER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UPPER_CASE) +#define DUK_HTHREAD_STRING_TO_UPPER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UPPER_CASE) +#define DUK_HEAP_STRING_TO_LOCALE_LOWER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_LOWER_CASE) +#define DUK_HTHREAD_STRING_TO_LOCALE_LOWER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_LOWER_CASE) +#define DUK_HEAP_STRING_TO_LOWER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOWER_CASE) +#define DUK_HTHREAD_STRING_TO_LOWER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOWER_CASE) +#define DUK_HEAP_STRING_SUBSTRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTRING) +#define DUK_HTHREAD_STRING_SUBSTRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTRING) +#define DUK_HEAP_STRING_SPLIT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLIT) +#define DUK_HTHREAD_STRING_SPLIT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLIT) +#define DUK_HEAP_STRING_SEARCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEARCH) +#define DUK_HTHREAD_STRING_SEARCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEARCH) +#define DUK_HEAP_STRING_REPLACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REPLACE) +#define DUK_HTHREAD_STRING_REPLACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REPLACE) +#define DUK_HEAP_STRING_MATCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATCH) +#define DUK_HTHREAD_STRING_MATCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATCH) +#define DUK_HEAP_STRING_LOCALE_COMPARE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOCALE_COMPARE) +#define DUK_HTHREAD_STRING_LOCALE_COMPARE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOCALE_COMPARE) +#define DUK_HEAP_STRING_CHAR_CODE_AT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_CODE_AT) +#define DUK_HTHREAD_STRING_CHAR_CODE_AT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_CODE_AT) +#define DUK_HEAP_STRING_CHAR_AT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_AT) +#define DUK_HTHREAD_STRING_CHAR_AT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_AT) +#define DUK_HEAP_STRING_FROM_CHAR_CODE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FROM_CHAR_CODE) +#define DUK_HTHREAD_STRING_FROM_CHAR_CODE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FROM_CHAR_CODE) +#define DUK_HEAP_STRING_REDUCE_RIGHT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE_RIGHT) +#define DUK_HTHREAD_STRING_REDUCE_RIGHT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE_RIGHT) +#define DUK_HEAP_STRING_REDUCE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE) +#define DUK_HTHREAD_STRING_REDUCE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE) +#define DUK_HEAP_STRING_FILTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILTER) +#define DUK_HTHREAD_STRING_FILTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILTER) +#define DUK_HEAP_STRING_MAP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAP) +#define DUK_HTHREAD_STRING_MAP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAP) +#define DUK_HEAP_STRING_FOR_EACH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR_EACH) +#define DUK_HTHREAD_STRING_FOR_EACH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR_EACH) +#define DUK_HEAP_STRING_SOME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOME) +#define DUK_HTHREAD_STRING_SOME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOME) +#define DUK_HEAP_STRING_EVERY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVERY) +#define DUK_HTHREAD_STRING_EVERY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVERY) +#define DUK_HEAP_STRING_LAST_INDEX_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX_OF) +#define DUK_HTHREAD_STRING_LAST_INDEX_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX_OF) +#define DUK_HEAP_STRING_INDEX_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX_OF) +#define DUK_HTHREAD_STRING_INDEX_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX_OF) +#define DUK_HEAP_STRING_UNSHIFT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNSHIFT) +#define DUK_HTHREAD_STRING_UNSHIFT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNSHIFT) +#define DUK_HEAP_STRING_SPLICE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLICE) +#define DUK_HTHREAD_STRING_SPLICE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLICE) +#define DUK_HEAP_STRING_SORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SORT) +#define DUK_HTHREAD_STRING_SORT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SORT) +#define DUK_HEAP_STRING_SLICE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SLICE) +#define DUK_HTHREAD_STRING_SLICE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SLICE) +#define DUK_HEAP_STRING_SHIFT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SHIFT) +#define DUK_HTHREAD_STRING_SHIFT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SHIFT) +#define DUK_HEAP_STRING_REVERSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REVERSE) +#define DUK_HTHREAD_STRING_REVERSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REVERSE) +#define DUK_HEAP_STRING_PUSH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUSH) +#define DUK_HTHREAD_STRING_PUSH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUSH) +#define DUK_HEAP_STRING_POP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POP) +#define DUK_HTHREAD_STRING_POP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POP) +#define DUK_HEAP_STRING_JOIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN) +#define DUK_HTHREAD_STRING_JOIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN) +#define DUK_HEAP_STRING_CONCAT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONCAT) +#define DUK_HTHREAD_STRING_CONCAT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONCAT) +#define DUK_HEAP_STRING_IS_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ARRAY) +#define DUK_HTHREAD_STRING_IS_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ARRAY) +#define DUK_HEAP_STRING_LC_ARGUMENTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS) +#define DUK_HTHREAD_STRING_LC_ARGUMENTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS) +#define DUK_HEAP_STRING_CALLER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER) +#define DUK_HTHREAD_STRING_CALLER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER) +#define DUK_HEAP_STRING_BIND(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BIND) +#define DUK_HTHREAD_STRING_BIND(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BIND) +#define DUK_HEAP_STRING_CALL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALL) +#define DUK_HTHREAD_STRING_CALL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALL) +#define DUK_HEAP_STRING_APPLY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_APPLY) +#define DUK_HTHREAD_STRING_APPLY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_APPLY) +#define DUK_HEAP_STRING_PROPERTY_IS_ENUMERABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROPERTY_IS_ENUMERABLE) +#define DUK_HTHREAD_STRING_PROPERTY_IS_ENUMERABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROPERTY_IS_ENUMERABLE) +#define DUK_HEAP_STRING_IS_PROTOTYPE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_PROTOTYPE_OF) +#define DUK_HTHREAD_STRING_IS_PROTOTYPE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_PROTOTYPE_OF) +#define DUK_HEAP_STRING_HAS_OWN_PROPERTY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS_OWN_PROPERTY) +#define DUK_HTHREAD_STRING_HAS_OWN_PROPERTY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS_OWN_PROPERTY) +#define DUK_HEAP_STRING_VALUE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF) +#define DUK_HTHREAD_STRING_VALUE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF) +#define DUK_HEAP_STRING_TO_LOCALE_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING) +#define DUK_HTHREAD_STRING_TO_LOCALE_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING) +#define DUK_HEAP_STRING_TO_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING) +#define DUK_HTHREAD_STRING_TO_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING) +#define DUK_HEAP_STRING_CONSTRUCTOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR) +#define DUK_HTHREAD_STRING_CONSTRUCTOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR) +#define DUK_HEAP_STRING_SET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET) +#define DUK_HTHREAD_STRING_SET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET) +#define DUK_HEAP_STRING_GET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET) +#define DUK_HTHREAD_STRING_GET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET) +#define DUK_HEAP_STRING_ENUMERABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE) +#define DUK_HTHREAD_STRING_ENUMERABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE) +#define DUK_HEAP_STRING_CONFIGURABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE) +#define DUK_HTHREAD_STRING_CONFIGURABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE) +#define DUK_HEAP_STRING_WRITABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE) +#define DUK_HTHREAD_STRING_WRITABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE) +#define DUK_HEAP_STRING_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE) +#define DUK_HTHREAD_STRING_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE) +#define DUK_HEAP_STRING_KEYS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_KEYS) +#define DUK_HTHREAD_STRING_KEYS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_KEYS) +#define DUK_HEAP_STRING_IS_EXTENSIBLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_EXTENSIBLE) +#define DUK_HTHREAD_STRING_IS_EXTENSIBLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_EXTENSIBLE) +#define DUK_HEAP_STRING_IS_FROZEN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FROZEN) +#define DUK_HTHREAD_STRING_IS_FROZEN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FROZEN) +#define DUK_HEAP_STRING_IS_SEALED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_SEALED) +#define DUK_HTHREAD_STRING_IS_SEALED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_SEALED) +#define DUK_HEAP_STRING_PREVENT_EXTENSIONS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PREVENT_EXTENSIONS) +#define DUK_HTHREAD_STRING_PREVENT_EXTENSIONS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PREVENT_EXTENSIONS) +#define DUK_HEAP_STRING_FREEZE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FREEZE) +#define DUK_HTHREAD_STRING_FREEZE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FREEZE) +#define DUK_HEAP_STRING_SEAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEAL) +#define DUK_HTHREAD_STRING_SEAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEAL) +#define DUK_HEAP_STRING_DEFINE_PROPERTIES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTIES) +#define DUK_HTHREAD_STRING_DEFINE_PROPERTIES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTIES) +#define DUK_HEAP_STRING_DEFINE_PROPERTY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTY) +#define DUK_HTHREAD_STRING_DEFINE_PROPERTY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTY) +#define DUK_HEAP_STRING_CREATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CREATE) +#define DUK_HTHREAD_STRING_CREATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CREATE) +#define DUK_HEAP_STRING_GET_OWN_PROPERTY_NAMES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_NAMES) +#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_NAMES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_NAMES) +#define DUK_HEAP_STRING_GET_OWN_PROPERTY_DESCRIPTOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR) +#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_DESCRIPTOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR) +#define DUK_HEAP_STRING_GET_PROTOTYPE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_PROTOTYPE_OF) +#define DUK_HTHREAD_STRING_GET_PROTOTYPE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_PROTOTYPE_OF) +#define DUK_HEAP_STRING_PROTOTYPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE) +#define DUK_HTHREAD_STRING_PROTOTYPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE) +#define DUK_HEAP_STRING_LENGTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH) +#define DUK_HTHREAD_STRING_LENGTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH) +#define DUK_HEAP_STRING_ALERT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ALERT) +#define DUK_HTHREAD_STRING_ALERT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ALERT) +#define DUK_HEAP_STRING_PRINT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRINT) +#define DUK_HTHREAD_STRING_PRINT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRINT) +#define DUK_HEAP_STRING_UNESCAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNESCAPE) +#define DUK_HTHREAD_STRING_UNESCAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNESCAPE) +#define DUK_HEAP_STRING_ESCAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPE) +#define DUK_HTHREAD_STRING_ESCAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPE) +#define DUK_HEAP_STRING_ENCODE_URI_COMPONENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI_COMPONENT) +#define DUK_HTHREAD_STRING_ENCODE_URI_COMPONENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI_COMPONENT) +#define DUK_HEAP_STRING_ENCODE_URI(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI) +#define DUK_HTHREAD_STRING_ENCODE_URI(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI) +#define DUK_HEAP_STRING_DECODE_URI_COMPONENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI_COMPONENT) +#define DUK_HTHREAD_STRING_DECODE_URI_COMPONENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI_COMPONENT) +#define DUK_HEAP_STRING_DECODE_URI(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI) +#define DUK_HTHREAD_STRING_DECODE_URI(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI) +#define DUK_HEAP_STRING_IS_FINITE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FINITE) +#define DUK_HTHREAD_STRING_IS_FINITE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FINITE) +#define DUK_HEAP_STRING_IS_NAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_NAN) +#define DUK_HTHREAD_STRING_IS_NAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_NAN) +#define DUK_HEAP_STRING_PARSE_FLOAT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_FLOAT) +#define DUK_HTHREAD_STRING_PARSE_FLOAT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_FLOAT) +#define DUK_HEAP_STRING_PARSE_INT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_INT) +#define DUK_HTHREAD_STRING_PARSE_INT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_INT) +#define DUK_HEAP_STRING_EVAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL) +#define DUK_HTHREAD_STRING_EVAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL) +#define DUK_HEAP_STRING_URI_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_URI_ERROR) +#define DUK_HTHREAD_STRING_URI_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_URI_ERROR) +#define DUK_HEAP_STRING_TYPE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE_ERROR) +#define DUK_HTHREAD_STRING_TYPE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE_ERROR) +#define DUK_HEAP_STRING_SYNTAX_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SYNTAX_ERROR) +#define DUK_HTHREAD_STRING_SYNTAX_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SYNTAX_ERROR) +#define DUK_HEAP_STRING_REFERENCE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REFERENCE_ERROR) +#define DUK_HTHREAD_STRING_REFERENCE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REFERENCE_ERROR) +#define DUK_HEAP_STRING_RANGE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANGE_ERROR) +#define DUK_HTHREAD_STRING_RANGE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANGE_ERROR) +#define DUK_HEAP_STRING_EVAL_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL_ERROR) +#define DUK_HTHREAD_STRING_EVAL_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL_ERROR) +#define DUK_HEAP_STRING_BREAK(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK) +#define DUK_HTHREAD_STRING_BREAK(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK) +#define DUK_HEAP_STRING_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE) +#define DUK_HTHREAD_STRING_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE) +#define DUK_HEAP_STRING_CATCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH) +#define DUK_HTHREAD_STRING_CATCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH) +#define DUK_HEAP_STRING_CONTINUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE) +#define DUK_HTHREAD_STRING_CONTINUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE) +#define DUK_HEAP_STRING_DEBUGGER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER) +#define DUK_HTHREAD_STRING_DEBUGGER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER) +#define DUK_HEAP_STRING_DEFAULT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT) +#define DUK_HTHREAD_STRING_DEFAULT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT) +#define DUK_HEAP_STRING_DELETE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE) +#define DUK_HTHREAD_STRING_DELETE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE) +#define DUK_HEAP_STRING_DO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO) +#define DUK_HTHREAD_STRING_DO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO) +#define DUK_HEAP_STRING_ELSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE) +#define DUK_HTHREAD_STRING_ELSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE) +#define DUK_HEAP_STRING_FINALLY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY) +#define DUK_HTHREAD_STRING_FINALLY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY) +#define DUK_HEAP_STRING_FOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR) +#define DUK_HTHREAD_STRING_FOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR) +#define DUK_HEAP_STRING_LC_FUNCTION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION) +#define DUK_HTHREAD_STRING_LC_FUNCTION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION) +#define DUK_HEAP_STRING_IF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF) +#define DUK_HTHREAD_STRING_IF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF) +#define DUK_HEAP_STRING_IN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN) +#define DUK_HTHREAD_STRING_IN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN) +#define DUK_HEAP_STRING_INSTANCEOF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF) +#define DUK_HTHREAD_STRING_INSTANCEOF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF) +#define DUK_HEAP_STRING_NEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW) +#define DUK_HTHREAD_STRING_NEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW) +#define DUK_HEAP_STRING_RETURN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN) +#define DUK_HTHREAD_STRING_RETURN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN) +#define DUK_HEAP_STRING_SWITCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH) +#define DUK_HTHREAD_STRING_SWITCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH) +#define DUK_HEAP_STRING_THIS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS) +#define DUK_HTHREAD_STRING_THIS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS) +#define DUK_HEAP_STRING_THROW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW) +#define DUK_HTHREAD_STRING_THROW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW) +#define DUK_HEAP_STRING_TRY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY) +#define DUK_HTHREAD_STRING_TRY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY) +#define DUK_HEAP_STRING_TYPEOF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF) +#define DUK_HTHREAD_STRING_TYPEOF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF) +#define DUK_HEAP_STRING_VAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR) +#define DUK_HTHREAD_STRING_VAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR) +#define DUK_HEAP_STRING_VOID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID) +#define DUK_HTHREAD_STRING_VOID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID) +#define DUK_HEAP_STRING_WHILE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE) +#define DUK_HTHREAD_STRING_WHILE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE) +#define DUK_HEAP_STRING_WITH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH) +#define DUK_HTHREAD_STRING_WITH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH) +#define DUK_HEAP_STRING_CLASS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS) +#define DUK_HTHREAD_STRING_CLASS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS) +#define DUK_HEAP_STRING_CONST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST) +#define DUK_HTHREAD_STRING_CONST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST) +#define DUK_HEAP_STRING_ENUM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM) +#define DUK_HTHREAD_STRING_ENUM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM) +#define DUK_HEAP_STRING_EXPORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT) +#define DUK_HTHREAD_STRING_EXPORT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT) +#define DUK_HEAP_STRING_EXTENDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS) +#define DUK_HTHREAD_STRING_EXTENDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS) +#define DUK_HEAP_STRING_IMPORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT) +#define DUK_HTHREAD_STRING_IMPORT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT) +#define DUK_HEAP_STRING_SUPER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER) +#define DUK_HTHREAD_STRING_SUPER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER) +#define DUK_HEAP_STRING_LC_NULL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL) +#define DUK_HTHREAD_STRING_LC_NULL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL) +#define DUK_HEAP_STRING_TRUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE) +#define DUK_HTHREAD_STRING_TRUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE) +#define DUK_HEAP_STRING_FALSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE) +#define DUK_HTHREAD_STRING_FALSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE) +#define DUK_HEAP_STRING_IMPLEMENTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS) +#define DUK_HTHREAD_STRING_IMPLEMENTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS) +#define DUK_HEAP_STRING_INTERFACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE) +#define DUK_HTHREAD_STRING_INTERFACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE) +#define DUK_HEAP_STRING_LET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET) +#define DUK_HTHREAD_STRING_LET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET) +#define DUK_HEAP_STRING_PACKAGE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE) +#define DUK_HTHREAD_STRING_PACKAGE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE) +#define DUK_HEAP_STRING_PRIVATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE) +#define DUK_HTHREAD_STRING_PRIVATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE) +#define DUK_HEAP_STRING_PROTECTED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED) +#define DUK_HTHREAD_STRING_PROTECTED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED) +#define DUK_HEAP_STRING_PUBLIC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC) +#define DUK_HTHREAD_STRING_PUBLIC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC) +#define DUK_HEAP_STRING_STATIC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC) +#define DUK_HTHREAD_STRING_STATIC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC) +#define DUK_HEAP_STRING_YIELD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD) +#define DUK_HTHREAD_STRING_YIELD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD) + +#define DUK_HEAP_NUM_STRINGS 414 + +#define DUK_STRIDX_START_RESERVED 369 +#define DUK_STRIDX_START_STRICT_RESERVED 405 +#define DUK_STRIDX_END_RESERVED 414 /* exclusive endpoint */ + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[147]; +DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1952]; +#ifdef DUK_USE_BUILTIN_INITJS +DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187]; +#endif /* DUK_USE_BUILTIN_INITJS */ +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_BUILTINS_DATA_LENGTH 1952 +#ifdef DUK_USE_BUILTIN_INITJS +#define DUK_BUILTIN_INITJS_DATA_LENGTH 187 +#endif /* DUK_USE_BUILTIN_INITJS */ + +#define DUK_BIDX_GLOBAL 0 +#define DUK_BIDX_GLOBAL_ENV 1 +#define DUK_BIDX_OBJECT_CONSTRUCTOR 2 +#define DUK_BIDX_OBJECT_PROTOTYPE 3 +#define DUK_BIDX_FUNCTION_CONSTRUCTOR 4 +#define DUK_BIDX_FUNCTION_PROTOTYPE 5 +#define DUK_BIDX_ARRAY_CONSTRUCTOR 6 +#define DUK_BIDX_ARRAY_PROTOTYPE 7 +#define DUK_BIDX_STRING_CONSTRUCTOR 8 +#define DUK_BIDX_STRING_PROTOTYPE 9 +#define DUK_BIDX_BOOLEAN_CONSTRUCTOR 10 +#define DUK_BIDX_BOOLEAN_PROTOTYPE 11 +#define DUK_BIDX_NUMBER_CONSTRUCTOR 12 +#define DUK_BIDX_NUMBER_PROTOTYPE 13 +#define DUK_BIDX_DATE_CONSTRUCTOR 14 +#define DUK_BIDX_DATE_PROTOTYPE 15 +#define DUK_BIDX_REGEXP_CONSTRUCTOR 16 +#define DUK_BIDX_REGEXP_PROTOTYPE 17 +#define DUK_BIDX_ERROR_CONSTRUCTOR 18 +#define DUK_BIDX_ERROR_PROTOTYPE 19 +#define DUK_BIDX_EVAL_ERROR_CONSTRUCTOR 20 +#define DUK_BIDX_EVAL_ERROR_PROTOTYPE 21 +#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR 22 +#define DUK_BIDX_RANGE_ERROR_PROTOTYPE 23 +#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR 24 +#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE 25 +#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR 26 +#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE 27 +#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR 28 +#define DUK_BIDX_TYPE_ERROR_PROTOTYPE 29 +#define DUK_BIDX_URI_ERROR_CONSTRUCTOR 30 +#define DUK_BIDX_URI_ERROR_PROTOTYPE 31 +#define DUK_BIDX_MATH 32 +#define DUK_BIDX_JSON 33 +#define DUK_BIDX_TYPE_ERROR_THROWER 34 +#define DUK_BIDX_PROXY_CONSTRUCTOR 35 +#define DUK_BIDX_DUKTAPE 36 +#define DUK_BIDX_THREAD_CONSTRUCTOR 37 +#define DUK_BIDX_THREAD_PROTOTYPE 38 +#define DUK_BIDX_BUFFER_CONSTRUCTOR 39 +#define DUK_BIDX_BUFFER_PROTOTYPE 40 +#define DUK_BIDX_POINTER_CONSTRUCTOR 41 +#define DUK_BIDX_POINTER_PROTOTYPE 42 +#define DUK_BIDX_LOGGER_CONSTRUCTOR 43 +#define DUK_BIDX_LOGGER_PROTOTYPE 44 +#define DUK_BIDX_DOUBLE_ERROR 45 +#define DUK_BIDX_ARRAYBUFFER_CONSTRUCTOR 46 +#define DUK_BIDX_ARRAYBUFFER_PROTOTYPE 47 +#define DUK_BIDX_DATAVIEW_CONSTRUCTOR 48 +#define DUK_BIDX_DATAVIEW_PROTOTYPE 49 +#define DUK_BIDX_TYPEDARRAY_PROTOTYPE 50 +#define DUK_BIDX_INT8ARRAY_CONSTRUCTOR 51 +#define DUK_BIDX_INT8ARRAY_PROTOTYPE 52 +#define DUK_BIDX_UINT8ARRAY_CONSTRUCTOR 53 +#define DUK_BIDX_UINT8ARRAY_PROTOTYPE 54 +#define DUK_BIDX_UINT8CLAMPEDARRAY_CONSTRUCTOR 55 +#define DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE 56 +#define DUK_BIDX_INT16ARRAY_CONSTRUCTOR 57 +#define DUK_BIDX_INT16ARRAY_PROTOTYPE 58 +#define DUK_BIDX_UINT16ARRAY_CONSTRUCTOR 59 +#define DUK_BIDX_UINT16ARRAY_PROTOTYPE 60 +#define DUK_BIDX_INT32ARRAY_CONSTRUCTOR 61 +#define DUK_BIDX_INT32ARRAY_PROTOTYPE 62 +#define DUK_BIDX_UINT32ARRAY_CONSTRUCTOR 63 +#define DUK_BIDX_UINT32ARRAY_PROTOTYPE 64 +#define DUK_BIDX_FLOAT32ARRAY_CONSTRUCTOR 65 +#define DUK_BIDX_FLOAT32ARRAY_PROTOTYPE 66 +#define DUK_BIDX_FLOAT64ARRAY_CONSTRUCTOR 67 +#define DUK_BIDX_FLOAT64ARRAY_PROTOTYPE 68 +#define DUK_BIDX_NODEJS_BUFFER_CONSTRUCTOR 69 +#define DUK_BIDX_NODEJS_BUFFER_PROTOTYPE 70 + +#define DUK_NUM_BUILTINS 71 + +#elif defined(DUK_USE_DOUBLE_ME) +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[2624]; +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_STRDATA_DATA_LENGTH 2624 +#define DUK_STRDATA_MAX_STRLEN 24 + +#define DUK_STRIDX_UC_LOGGER 0 /* 'Logger' */ +#define DUK_STRIDX_UC_THREAD 1 /* 'Thread' */ +#define DUK_STRIDX_UC_POINTER 2 /* 'Pointer' */ +#define DUK_STRIDX_DEC_ENV 3 /* 'DecEnv' */ +#define DUK_STRIDX_OBJ_ENV 4 /* 'ObjEnv' */ +#define DUK_STRIDX_FLOAT64_ARRAY 5 /* 'Float64Array' */ +#define DUK_STRIDX_FLOAT32_ARRAY 6 /* 'Float32Array' */ +#define DUK_STRIDX_UINT32_ARRAY 7 /* 'Uint32Array' */ +#define DUK_STRIDX_INT32_ARRAY 8 /* 'Int32Array' */ +#define DUK_STRIDX_UINT16_ARRAY 9 /* 'Uint16Array' */ +#define DUK_STRIDX_INT16_ARRAY 10 /* 'Int16Array' */ +#define DUK_STRIDX_UINT8_CLAMPED_ARRAY 11 /* 'Uint8ClampedArray' */ +#define DUK_STRIDX_UINT8_ARRAY 12 /* 'Uint8Array' */ +#define DUK_STRIDX_INT8_ARRAY 13 /* 'Int8Array' */ +#define DUK_STRIDX_DATA_VIEW 14 /* 'DataView' */ +#define DUK_STRIDX_ARRAY_BUFFER 15 /* 'ArrayBuffer' */ +#define DUK_STRIDX_UC_BUFFER 16 /* 'Buffer' */ +#define DUK_STRIDX_EMPTY_STRING 17 /* '' */ +#define DUK_STRIDX_GLOBAL 18 /* 'global' */ +#define DUK_STRIDX_UC_ARGUMENTS 19 /* 'Arguments' */ +#define DUK_STRIDX_JSON 20 /* 'JSON' */ +#define DUK_STRIDX_MATH 21 /* 'Math' */ +#define DUK_STRIDX_UC_ERROR 22 /* 'Error' */ +#define DUK_STRIDX_REG_EXP 23 /* 'RegExp' */ +#define DUK_STRIDX_DATE 24 /* 'Date' */ +#define DUK_STRIDX_UC_NUMBER 25 /* 'Number' */ +#define DUK_STRIDX_UC_BOOLEAN 26 /* 'Boolean' */ +#define DUK_STRIDX_UC_STRING 27 /* 'String' */ +#define DUK_STRIDX_ARRAY 28 /* 'Array' */ +#define DUK_STRIDX_UC_FUNCTION 29 /* 'Function' */ +#define DUK_STRIDX_UC_OBJECT 30 /* 'Object' */ +#define DUK_STRIDX_UC_NULL 31 /* 'Null' */ +#define DUK_STRIDX_UC_UNDEFINED 32 /* 'Undefined' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION2 33 /* '{_func:true}' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION1 34 /* '{"_func":true}' */ +#define DUK_STRIDX_JSON_EXT_NEGINF 35 /* '{"_ninf":true}' */ +#define DUK_STRIDX_JSON_EXT_POSINF 36 /* '{"_inf":true}' */ +#define DUK_STRIDX_JSON_EXT_NAN 37 /* '{"_nan":true}' */ +#define DUK_STRIDX_JSON_EXT_UNDEFINED 38 /* '{"_undef":true}' */ +#define DUK_STRIDX_TO_LOG_STRING 39 /* 'toLogString' */ +#define DUK_STRIDX_CLOG 40 /* 'clog' */ +#define DUK_STRIDX_LC_L 41 /* 'l' */ +#define DUK_STRIDX_LC_N 42 /* 'n' */ +#define DUK_STRIDX_LC_FATAL 43 /* 'fatal' */ +#define DUK_STRIDX_LC_ERROR 44 /* 'error' */ +#define DUK_STRIDX_LC_WARN 45 /* 'warn' */ +#define DUK_STRIDX_LC_DEBUG 46 /* 'debug' */ +#define DUK_STRIDX_LC_TRACE 47 /* 'trace' */ +#define DUK_STRIDX_RAW 48 /* 'raw' */ +#define DUK_STRIDX_FMT 49 /* 'fmt' */ +#define DUK_STRIDX_CURRENT 50 /* 'current' */ +#define DUK_STRIDX_RESUME 51 /* 'resume' */ +#define DUK_STRIDX_COMPACT 52 /* 'compact' */ +#define DUK_STRIDX_JC 53 /* 'jc' */ +#define DUK_STRIDX_JX 54 /* 'jx' */ +#define DUK_STRIDX_BASE64 55 /* 'base64' */ +#define DUK_STRIDX_HEX 56 /* 'hex' */ +#define DUK_STRIDX_DEC 57 /* 'dec' */ +#define DUK_STRIDX_ENC 58 /* 'enc' */ +#define DUK_STRIDX_FIN 59 /* 'fin' */ +#define DUK_STRIDX_GC 60 /* 'gc' */ +#define DUK_STRIDX_ACT 61 /* 'act' */ +#define DUK_STRIDX_LC_INFO 62 /* 'info' */ +#define DUK_STRIDX_VERSION 63 /* 'version' */ +#define DUK_STRIDX_ENV 64 /* 'env' */ +#define DUK_STRIDX_MOD_LOADED 65 /* 'modLoaded' */ +#define DUK_STRIDX_MOD_SEARCH 66 /* 'modSearch' */ +#define DUK_STRIDX_ERR_THROW 67 /* 'errThrow' */ +#define DUK_STRIDX_ERR_CREATE 68 /* 'errCreate' */ +#define DUK_STRIDX_COMPILE 69 /* 'compile' */ +#define DUK_STRIDX_INT_REGBASE 70 /* '\x00Regbase' */ +#define DUK_STRIDX_INT_THREAD 71 /* '\x00Thread' */ +#define DUK_STRIDX_INT_HANDLER 72 /* '\x00Handler' */ +#define DUK_STRIDX_INT_FINALIZER 73 /* '\x00Finalizer' */ +#define DUK_STRIDX_INT_CALLEE 74 /* '\x00Callee' */ +#define DUK_STRIDX_INT_MAP 75 /* '\x00Map' */ +#define DUK_STRIDX_INT_ARGS 76 /* '\x00Args' */ +#define DUK_STRIDX_INT_THIS 77 /* '\x00This' */ +#define DUK_STRIDX_INT_PC2LINE 78 /* '\x00Pc2line' */ +#define DUK_STRIDX_INT_SOURCE 79 /* '\x00Source' */ +#define DUK_STRIDX_INT_VARENV 80 /* '\x00Varenv' */ +#define DUK_STRIDX_INT_LEXENV 81 /* '\x00Lexenv' */ +#define DUK_STRIDX_INT_VARMAP 82 /* '\x00Varmap' */ +#define DUK_STRIDX_INT_FORMALS 83 /* '\x00Formals' */ +#define DUK_STRIDX_INT_BYTECODE 84 /* '\x00Bytecode' */ +#define DUK_STRIDX_INT_NEXT 85 /* '\x00Next' */ +#define DUK_STRIDX_INT_TARGET 86 /* '\x00Target' */ +#define DUK_STRIDX_INT_VALUE 87 /* '\x00Value' */ +#define DUK_STRIDX_LC_POINTER 88 /* 'pointer' */ +#define DUK_STRIDX_INT_TRACEDATA 89 /* '\x00Tracedata' */ +#define DUK_STRIDX_LINE_NUMBER 90 /* 'lineNumber' */ +#define DUK_STRIDX_FILE_NAME 91 /* 'fileName' */ +#define DUK_STRIDX_PC 92 /* 'pc' */ +#define DUK_STRIDX_STACK 93 /* 'stack' */ +#define DUK_STRIDX_THROW_TYPE_ERROR 94 /* 'ThrowTypeError' */ +#define DUK_STRIDX_DUKTAPE 95 /* 'Duktape' */ +#define DUK_STRIDX_SET_FLOAT64 96 /* 'setFloat64' */ +#define DUK_STRIDX_SET_FLOAT32 97 /* 'setFloat32' */ +#define DUK_STRIDX_SET_UINT32 98 /* 'setUint32' */ +#define DUK_STRIDX_SET_INT32 99 /* 'setInt32' */ +#define DUK_STRIDX_SET_UINT16 100 /* 'setUint16' */ +#define DUK_STRIDX_SET_INT16 101 /* 'setInt16' */ +#define DUK_STRIDX_SET_UINT8 102 /* 'setUint8' */ +#define DUK_STRIDX_SET_INT8 103 /* 'setInt8' */ +#define DUK_STRIDX_GET_FLOAT64 104 /* 'getFloat64' */ +#define DUK_STRIDX_GET_FLOAT32 105 /* 'getFloat32' */ +#define DUK_STRIDX_GET_UINT32 106 /* 'getUint32' */ +#define DUK_STRIDX_GET_INT32 107 /* 'getInt32' */ +#define DUK_STRIDX_GET_UINT16 108 /* 'getUint16' */ +#define DUK_STRIDX_GET_INT16 109 /* 'getInt16' */ +#define DUK_STRIDX_GET_UINT8 110 /* 'getUint8' */ +#define DUK_STRIDX_GET_INT8 111 /* 'getInt8' */ +#define DUK_STRIDX_SUBARRAY 112 /* 'subarray' */ +#define DUK_STRIDX_BYTES_PER_ELEMENT 113 /* 'BYTES_PER_ELEMENT' */ +#define DUK_STRIDX_BYTE_OFFSET 114 /* 'byteOffset' */ +#define DUK_STRIDX_LC_BUFFER 115 /* 'buffer' */ +#define DUK_STRIDX_IS_VIEW 116 /* 'isView' */ +#define DUK_STRIDX_DATA 117 /* 'data' */ +#define DUK_STRIDX_TYPE 118 /* 'type' */ +#define DUK_STRIDX_WRITE_INT_BE 119 /* 'writeIntBE' */ +#define DUK_STRIDX_WRITE_INT_LE 120 /* 'writeIntLE' */ +#define DUK_STRIDX_WRITE_UINT_BE 121 /* 'writeUIntBE' */ +#define DUK_STRIDX_WRITE_UINT_LE 122 /* 'writeUIntLE' */ +#define DUK_STRIDX_WRITE_DOUBLE_BE 123 /* 'writeDoubleBE' */ +#define DUK_STRIDX_WRITE_DOUBLE_LE 124 /* 'writeDoubleLE' */ +#define DUK_STRIDX_WRITE_FLOAT_BE 125 /* 'writeFloatBE' */ +#define DUK_STRIDX_WRITE_FLOAT_LE 126 /* 'writeFloatLE' */ +#define DUK_STRIDX_WRITE_INT32_BE 127 /* 'writeInt32BE' */ +#define DUK_STRIDX_WRITE_INT32_LE 128 /* 'writeInt32LE' */ +#define DUK_STRIDX_WRITE_UINT32_BE 129 /* 'writeUInt32BE' */ +#define DUK_STRIDX_WRITE_UINT32_LE 130 /* 'writeUInt32LE' */ +#define DUK_STRIDX_WRITE_INT16_BE 131 /* 'writeInt16BE' */ +#define DUK_STRIDX_WRITE_INT16_LE 132 /* 'writeInt16LE' */ +#define DUK_STRIDX_WRITE_UINT16_BE 133 /* 'writeUInt16BE' */ +#define DUK_STRIDX_WRITE_UINT16_LE 134 /* 'writeUInt16LE' */ +#define DUK_STRIDX_WRITE_INT8 135 /* 'writeInt8' */ +#define DUK_STRIDX_WRITE_UINT8 136 /* 'writeUInt8' */ +#define DUK_STRIDX_READ_INT_BE 137 /* 'readIntBE' */ +#define DUK_STRIDX_READ_INT_LE 138 /* 'readIntLE' */ +#define DUK_STRIDX_READ_UINT_BE 139 /* 'readUIntBE' */ +#define DUK_STRIDX_READ_UINT_LE 140 /* 'readUIntLE' */ +#define DUK_STRIDX_READ_DOUBLE_BE 141 /* 'readDoubleBE' */ +#define DUK_STRIDX_READ_DOUBLE_LE 142 /* 'readDoubleLE' */ +#define DUK_STRIDX_READ_FLOAT_BE 143 /* 'readFloatBE' */ +#define DUK_STRIDX_READ_FLOAT_LE 144 /* 'readFloatLE' */ +#define DUK_STRIDX_READ_INT32_BE 145 /* 'readInt32BE' */ +#define DUK_STRIDX_READ_INT32_LE 146 /* 'readInt32LE' */ +#define DUK_STRIDX_READ_UINT32_BE 147 /* 'readUInt32BE' */ +#define DUK_STRIDX_READ_UINT32_LE 148 /* 'readUInt32LE' */ +#define DUK_STRIDX_READ_INT16_BE 149 /* 'readInt16BE' */ +#define DUK_STRIDX_READ_INT16_LE 150 /* 'readInt16LE' */ +#define DUK_STRIDX_READ_UINT16_BE 151 /* 'readUInt16BE' */ +#define DUK_STRIDX_READ_UINT16_LE 152 /* 'readUInt16LE' */ +#define DUK_STRIDX_READ_INT8 153 /* 'readInt8' */ +#define DUK_STRIDX_READ_UINT8 154 /* 'readUInt8' */ +#define DUK_STRIDX_COPY 155 /* 'copy' */ +#define DUK_STRIDX_EQUALS 156 /* 'equals' */ +#define DUK_STRIDX_FILL 157 /* 'fill' */ +#define DUK_STRIDX_WRITE 158 /* 'write' */ +#define DUK_STRIDX_COMPARE 159 /* 'compare' */ +#define DUK_STRIDX_BYTE_LENGTH 160 /* 'byteLength' */ +#define DUK_STRIDX_IS_BUFFER 161 /* 'isBuffer' */ +#define DUK_STRIDX_IS_ENCODING 162 /* 'isEncoding' */ +#define DUK_STRIDX_EXPORTS 163 /* 'exports' */ +#define DUK_STRIDX_ID 164 /* 'id' */ +#define DUK_STRIDX_REQUIRE 165 /* 'require' */ +#define DUK_STRIDX___PROTO__ 166 /* '__proto__' */ +#define DUK_STRIDX_SET_PROTOTYPE_OF 167 /* 'setPrototypeOf' */ +#define DUK_STRIDX_OWN_KEYS 168 /* 'ownKeys' */ +#define DUK_STRIDX_ENUMERATE 169 /* 'enumerate' */ +#define DUK_STRIDX_DELETE_PROPERTY 170 /* 'deleteProperty' */ +#define DUK_STRIDX_HAS 171 /* 'has' */ +#define DUK_STRIDX_PROXY 172 /* 'Proxy' */ +#define DUK_STRIDX_CALLEE 173 /* 'callee' */ +#define DUK_STRIDX_INVALID_DATE 174 /* 'Invalid Date' */ +#define DUK_STRIDX_BRACKETED_ELLIPSIS 175 /* '[...]' */ +#define DUK_STRIDX_NEWLINE_TAB 176 /* '\n\t' */ +#define DUK_STRIDX_SPACE 177 /* ' ' */ +#define DUK_STRIDX_COMMA 178 /* ',' */ +#define DUK_STRIDX_MINUS_ZERO 179 /* '-0' */ +#define DUK_STRIDX_PLUS_ZERO 180 /* '+0' */ +#define DUK_STRIDX_ZERO 181 /* '0' */ +#define DUK_STRIDX_MINUS_INFINITY 182 /* '-Infinity' */ +#define DUK_STRIDX_PLUS_INFINITY 183 /* '+Infinity' */ +#define DUK_STRIDX_INFINITY 184 /* 'Infinity' */ +#define DUK_STRIDX_LC_OBJECT 185 /* 'object' */ +#define DUK_STRIDX_LC_STRING 186 /* 'string' */ +#define DUK_STRIDX_LC_NUMBER 187 /* 'number' */ +#define DUK_STRIDX_LC_BOOLEAN 188 /* 'boolean' */ +#define DUK_STRIDX_LC_UNDEFINED 189 /* 'undefined' */ +#define DUK_STRIDX_STRINGIFY 190 /* 'stringify' */ +#define DUK_STRIDX_TAN 191 /* 'tan' */ +#define DUK_STRIDX_SQRT 192 /* 'sqrt' */ +#define DUK_STRIDX_SIN 193 /* 'sin' */ +#define DUK_STRIDX_ROUND 194 /* 'round' */ +#define DUK_STRIDX_RANDOM 195 /* 'random' */ +#define DUK_STRIDX_POW 196 /* 'pow' */ +#define DUK_STRIDX_MIN 197 /* 'min' */ +#define DUK_STRIDX_MAX 198 /* 'max' */ +#define DUK_STRIDX_LOG 199 /* 'log' */ +#define DUK_STRIDX_FLOOR 200 /* 'floor' */ +#define DUK_STRIDX_EXP 201 /* 'exp' */ +#define DUK_STRIDX_COS 202 /* 'cos' */ +#define DUK_STRIDX_CEIL 203 /* 'ceil' */ +#define DUK_STRIDX_ATAN2 204 /* 'atan2' */ +#define DUK_STRIDX_ATAN 205 /* 'atan' */ +#define DUK_STRIDX_ASIN 206 /* 'asin' */ +#define DUK_STRIDX_ACOS 207 /* 'acos' */ +#define DUK_STRIDX_ABS 208 /* 'abs' */ +#define DUK_STRIDX_SQRT2 209 /* 'SQRT2' */ +#define DUK_STRIDX_SQRT1_2 210 /* 'SQRT1_2' */ +#define DUK_STRIDX_PI 211 /* 'PI' */ +#define DUK_STRIDX_LOG10E 212 /* 'LOG10E' */ +#define DUK_STRIDX_LOG2E 213 /* 'LOG2E' */ +#define DUK_STRIDX_LN2 214 /* 'LN2' */ +#define DUK_STRIDX_LN10 215 /* 'LN10' */ +#define DUK_STRIDX_E 216 /* 'E' */ +#define DUK_STRIDX_MESSAGE 217 /* 'message' */ +#define DUK_STRIDX_NAME 218 /* 'name' */ +#define DUK_STRIDX_INPUT 219 /* 'input' */ +#define DUK_STRIDX_INDEX 220 /* 'index' */ +#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP 221 /* '(?:)' */ +#define DUK_STRIDX_LAST_INDEX 222 /* 'lastIndex' */ +#define DUK_STRIDX_MULTILINE 223 /* 'multiline' */ +#define DUK_STRIDX_IGNORE_CASE 224 /* 'ignoreCase' */ +#define DUK_STRIDX_SOURCE 225 /* 'source' */ +#define DUK_STRIDX_TEST 226 /* 'test' */ +#define DUK_STRIDX_EXEC 227 /* 'exec' */ +#define DUK_STRIDX_TO_GMT_STRING 228 /* 'toGMTString' */ +#define DUK_STRIDX_SET_YEAR 229 /* 'setYear' */ +#define DUK_STRIDX_GET_YEAR 230 /* 'getYear' */ +#define DUK_STRIDX_TO_JSON 231 /* 'toJSON' */ +#define DUK_STRIDX_TO_ISO_STRING 232 /* 'toISOString' */ +#define DUK_STRIDX_TO_UTC_STRING 233 /* 'toUTCString' */ +#define DUK_STRIDX_SET_UTC_FULL_YEAR 234 /* 'setUTCFullYear' */ +#define DUK_STRIDX_SET_FULL_YEAR 235 /* 'setFullYear' */ +#define DUK_STRIDX_SET_UTC_MONTH 236 /* 'setUTCMonth' */ +#define DUK_STRIDX_SET_MONTH 237 /* 'setMonth' */ +#define DUK_STRIDX_SET_UTC_DATE 238 /* 'setUTCDate' */ +#define DUK_STRIDX_SET_DATE 239 /* 'setDate' */ +#define DUK_STRIDX_SET_UTC_HOURS 240 /* 'setUTCHours' */ +#define DUK_STRIDX_SET_HOURS 241 /* 'setHours' */ +#define DUK_STRIDX_SET_UTC_MINUTES 242 /* 'setUTCMinutes' */ +#define DUK_STRIDX_SET_MINUTES 243 /* 'setMinutes' */ +#define DUK_STRIDX_SET_UTC_SECONDS 244 /* 'setUTCSeconds' */ +#define DUK_STRIDX_SET_SECONDS 245 /* 'setSeconds' */ +#define DUK_STRIDX_SET_UTC_MILLISECONDS 246 /* 'setUTCMilliseconds' */ +#define DUK_STRIDX_SET_MILLISECONDS 247 /* 'setMilliseconds' */ +#define DUK_STRIDX_SET_TIME 248 /* 'setTime' */ +#define DUK_STRIDX_GET_TIMEZONE_OFFSET 249 /* 'getTimezoneOffset' */ +#define DUK_STRIDX_GET_UTC_MILLISECONDS 250 /* 'getUTCMilliseconds' */ +#define DUK_STRIDX_GET_MILLISECONDS 251 /* 'getMilliseconds' */ +#define DUK_STRIDX_GET_UTC_SECONDS 252 /* 'getUTCSeconds' */ +#define DUK_STRIDX_GET_SECONDS 253 /* 'getSeconds' */ +#define DUK_STRIDX_GET_UTC_MINUTES 254 /* 'getUTCMinutes' */ +#define DUK_STRIDX_GET_MINUTES 255 /* 'getMinutes' */ +#define DUK_STRIDX_GET_UTC_HOURS 256 /* 'getUTCHours' */ +#define DUK_STRIDX_GET_HOURS 257 /* 'getHours' */ +#define DUK_STRIDX_GET_UTC_DAY 258 /* 'getUTCDay' */ +#define DUK_STRIDX_GET_DAY 259 /* 'getDay' */ +#define DUK_STRIDX_GET_UTC_DATE 260 /* 'getUTCDate' */ +#define DUK_STRIDX_GET_DATE 261 /* 'getDate' */ +#define DUK_STRIDX_GET_UTC_MONTH 262 /* 'getUTCMonth' */ +#define DUK_STRIDX_GET_MONTH 263 /* 'getMonth' */ +#define DUK_STRIDX_GET_UTC_FULL_YEAR 264 /* 'getUTCFullYear' */ +#define DUK_STRIDX_GET_FULL_YEAR 265 /* 'getFullYear' */ +#define DUK_STRIDX_GET_TIME 266 /* 'getTime' */ +#define DUK_STRIDX_TO_LOCALE_TIME_STRING 267 /* 'toLocaleTimeString' */ +#define DUK_STRIDX_TO_LOCALE_DATE_STRING 268 /* 'toLocaleDateString' */ +#define DUK_STRIDX_TO_TIME_STRING 269 /* 'toTimeString' */ +#define DUK_STRIDX_TO_DATE_STRING 270 /* 'toDateString' */ +#define DUK_STRIDX_NOW 271 /* 'now' */ +#define DUK_STRIDX_UTC 272 /* 'UTC' */ +#define DUK_STRIDX_PARSE 273 /* 'parse' */ +#define DUK_STRIDX_TO_PRECISION 274 /* 'toPrecision' */ +#define DUK_STRIDX_TO_EXPONENTIAL 275 /* 'toExponential' */ +#define DUK_STRIDX_TO_FIXED 276 /* 'toFixed' */ +#define DUK_STRIDX_POSITIVE_INFINITY 277 /* 'POSITIVE_INFINITY' */ +#define DUK_STRIDX_NEGATIVE_INFINITY 278 /* 'NEGATIVE_INFINITY' */ +#define DUK_STRIDX_NAN 279 /* 'NaN' */ +#define DUK_STRIDX_MIN_VALUE 280 /* 'MIN_VALUE' */ +#define DUK_STRIDX_MAX_VALUE 281 /* 'MAX_VALUE' */ +#define DUK_STRIDX_SUBSTR 282 /* 'substr' */ +#define DUK_STRIDX_TRIM 283 /* 'trim' */ +#define DUK_STRIDX_TO_LOCALE_UPPER_CASE 284 /* 'toLocaleUpperCase' */ +#define DUK_STRIDX_TO_UPPER_CASE 285 /* 'toUpperCase' */ +#define DUK_STRIDX_TO_LOCALE_LOWER_CASE 286 /* 'toLocaleLowerCase' */ +#define DUK_STRIDX_TO_LOWER_CASE 287 /* 'toLowerCase' */ +#define DUK_STRIDX_SUBSTRING 288 /* 'substring' */ +#define DUK_STRIDX_SPLIT 289 /* 'split' */ +#define DUK_STRIDX_SEARCH 290 /* 'search' */ +#define DUK_STRIDX_REPLACE 291 /* 'replace' */ +#define DUK_STRIDX_MATCH 292 /* 'match' */ +#define DUK_STRIDX_LOCALE_COMPARE 293 /* 'localeCompare' */ +#define DUK_STRIDX_CHAR_CODE_AT 294 /* 'charCodeAt' */ +#define DUK_STRIDX_CHAR_AT 295 /* 'charAt' */ +#define DUK_STRIDX_FROM_CHAR_CODE 296 /* 'fromCharCode' */ +#define DUK_STRIDX_REDUCE_RIGHT 297 /* 'reduceRight' */ +#define DUK_STRIDX_REDUCE 298 /* 'reduce' */ +#define DUK_STRIDX_FILTER 299 /* 'filter' */ +#define DUK_STRIDX_MAP 300 /* 'map' */ +#define DUK_STRIDX_FOR_EACH 301 /* 'forEach' */ +#define DUK_STRIDX_SOME 302 /* 'some' */ +#define DUK_STRIDX_EVERY 303 /* 'every' */ +#define DUK_STRIDX_LAST_INDEX_OF 304 /* 'lastIndexOf' */ +#define DUK_STRIDX_INDEX_OF 305 /* 'indexOf' */ +#define DUK_STRIDX_UNSHIFT 306 /* 'unshift' */ +#define DUK_STRIDX_SPLICE 307 /* 'splice' */ +#define DUK_STRIDX_SORT 308 /* 'sort' */ +#define DUK_STRIDX_SLICE 309 /* 'slice' */ +#define DUK_STRIDX_SHIFT 310 /* 'shift' */ +#define DUK_STRIDX_REVERSE 311 /* 'reverse' */ +#define DUK_STRIDX_PUSH 312 /* 'push' */ +#define DUK_STRIDX_POP 313 /* 'pop' */ +#define DUK_STRIDX_JOIN 314 /* 'join' */ +#define DUK_STRIDX_CONCAT 315 /* 'concat' */ +#define DUK_STRIDX_IS_ARRAY 316 /* 'isArray' */ +#define DUK_STRIDX_LC_ARGUMENTS 317 /* 'arguments' */ +#define DUK_STRIDX_CALLER 318 /* 'caller' */ +#define DUK_STRIDX_BIND 319 /* 'bind' */ +#define DUK_STRIDX_CALL 320 /* 'call' */ +#define DUK_STRIDX_APPLY 321 /* 'apply' */ +#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE 322 /* 'propertyIsEnumerable' */ +#define DUK_STRIDX_IS_PROTOTYPE_OF 323 /* 'isPrototypeOf' */ +#define DUK_STRIDX_HAS_OWN_PROPERTY 324 /* 'hasOwnProperty' */ +#define DUK_STRIDX_VALUE_OF 325 /* 'valueOf' */ +#define DUK_STRIDX_TO_LOCALE_STRING 326 /* 'toLocaleString' */ +#define DUK_STRIDX_TO_STRING 327 /* 'toString' */ +#define DUK_STRIDX_CONSTRUCTOR 328 /* 'constructor' */ +#define DUK_STRIDX_SET 329 /* 'set' */ +#define DUK_STRIDX_GET 330 /* 'get' */ +#define DUK_STRIDX_ENUMERABLE 331 /* 'enumerable' */ +#define DUK_STRIDX_CONFIGURABLE 332 /* 'configurable' */ +#define DUK_STRIDX_WRITABLE 333 /* 'writable' */ +#define DUK_STRIDX_VALUE 334 /* 'value' */ +#define DUK_STRIDX_KEYS 335 /* 'keys' */ +#define DUK_STRIDX_IS_EXTENSIBLE 336 /* 'isExtensible' */ +#define DUK_STRIDX_IS_FROZEN 337 /* 'isFrozen' */ +#define DUK_STRIDX_IS_SEALED 338 /* 'isSealed' */ +#define DUK_STRIDX_PREVENT_EXTENSIONS 339 /* 'preventExtensions' */ +#define DUK_STRIDX_FREEZE 340 /* 'freeze' */ +#define DUK_STRIDX_SEAL 341 /* 'seal' */ +#define DUK_STRIDX_DEFINE_PROPERTIES 342 /* 'defineProperties' */ +#define DUK_STRIDX_DEFINE_PROPERTY 343 /* 'defineProperty' */ +#define DUK_STRIDX_CREATE 344 /* 'create' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES 345 /* 'getOwnPropertyNames' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR 346 /* 'getOwnPropertyDescriptor' */ +#define DUK_STRIDX_GET_PROTOTYPE_OF 347 /* 'getPrototypeOf' */ +#define DUK_STRIDX_PROTOTYPE 348 /* 'prototype' */ +#define DUK_STRIDX_LENGTH 349 /* 'length' */ +#define DUK_STRIDX_ALERT 350 /* 'alert' */ +#define DUK_STRIDX_PRINT 351 /* 'print' */ +#define DUK_STRIDX_UNESCAPE 352 /* 'unescape' */ +#define DUK_STRIDX_ESCAPE 353 /* 'escape' */ +#define DUK_STRIDX_ENCODE_URI_COMPONENT 354 /* 'encodeURIComponent' */ +#define DUK_STRIDX_ENCODE_URI 355 /* 'encodeURI' */ +#define DUK_STRIDX_DECODE_URI_COMPONENT 356 /* 'decodeURIComponent' */ +#define DUK_STRIDX_DECODE_URI 357 /* 'decodeURI' */ +#define DUK_STRIDX_IS_FINITE 358 /* 'isFinite' */ +#define DUK_STRIDX_IS_NAN 359 /* 'isNaN' */ +#define DUK_STRIDX_PARSE_FLOAT 360 /* 'parseFloat' */ +#define DUK_STRIDX_PARSE_INT 361 /* 'parseInt' */ +#define DUK_STRIDX_EVAL 362 /* 'eval' */ +#define DUK_STRIDX_URI_ERROR 363 /* 'URIError' */ +#define DUK_STRIDX_TYPE_ERROR 364 /* 'TypeError' */ +#define DUK_STRIDX_SYNTAX_ERROR 365 /* 'SyntaxError' */ +#define DUK_STRIDX_REFERENCE_ERROR 366 /* 'ReferenceError' */ +#define DUK_STRIDX_RANGE_ERROR 367 /* 'RangeError' */ +#define DUK_STRIDX_EVAL_ERROR 368 /* 'EvalError' */ +#define DUK_STRIDX_BREAK 369 /* 'break' */ +#define DUK_STRIDX_CASE 370 /* 'case' */ +#define DUK_STRIDX_CATCH 371 /* 'catch' */ +#define DUK_STRIDX_CONTINUE 372 /* 'continue' */ +#define DUK_STRIDX_DEBUGGER 373 /* 'debugger' */ +#define DUK_STRIDX_DEFAULT 374 /* 'default' */ +#define DUK_STRIDX_DELETE 375 /* 'delete' */ +#define DUK_STRIDX_DO 376 /* 'do' */ +#define DUK_STRIDX_ELSE 377 /* 'else' */ +#define DUK_STRIDX_FINALLY 378 /* 'finally' */ +#define DUK_STRIDX_FOR 379 /* 'for' */ +#define DUK_STRIDX_LC_FUNCTION 380 /* 'function' */ +#define DUK_STRIDX_IF 381 /* 'if' */ +#define DUK_STRIDX_IN 382 /* 'in' */ +#define DUK_STRIDX_INSTANCEOF 383 /* 'instanceof' */ +#define DUK_STRIDX_NEW 384 /* 'new' */ +#define DUK_STRIDX_RETURN 385 /* 'return' */ +#define DUK_STRIDX_SWITCH 386 /* 'switch' */ +#define DUK_STRIDX_THIS 387 /* 'this' */ +#define DUK_STRIDX_THROW 388 /* 'throw' */ +#define DUK_STRIDX_TRY 389 /* 'try' */ +#define DUK_STRIDX_TYPEOF 390 /* 'typeof' */ +#define DUK_STRIDX_VAR 391 /* 'var' */ +#define DUK_STRIDX_VOID 392 /* 'void' */ +#define DUK_STRIDX_WHILE 393 /* 'while' */ +#define DUK_STRIDX_WITH 394 /* 'with' */ +#define DUK_STRIDX_CLASS 395 /* 'class' */ +#define DUK_STRIDX_CONST 396 /* 'const' */ +#define DUK_STRIDX_ENUM 397 /* 'enum' */ +#define DUK_STRIDX_EXPORT 398 /* 'export' */ +#define DUK_STRIDX_EXTENDS 399 /* 'extends' */ +#define DUK_STRIDX_IMPORT 400 /* 'import' */ +#define DUK_STRIDX_SUPER 401 /* 'super' */ +#define DUK_STRIDX_LC_NULL 402 /* 'null' */ +#define DUK_STRIDX_TRUE 403 /* 'true' */ +#define DUK_STRIDX_FALSE 404 /* 'false' */ +#define DUK_STRIDX_IMPLEMENTS 405 /* 'implements' */ +#define DUK_STRIDX_INTERFACE 406 /* 'interface' */ +#define DUK_STRIDX_LET 407 /* 'let' */ +#define DUK_STRIDX_PACKAGE 408 /* 'package' */ +#define DUK_STRIDX_PRIVATE 409 /* 'private' */ +#define DUK_STRIDX_PROTECTED 410 /* 'protected' */ +#define DUK_STRIDX_PUBLIC 411 /* 'public' */ +#define DUK_STRIDX_STATIC 412 /* 'static' */ +#define DUK_STRIDX_YIELD 413 /* 'yield' */ + +#define DUK_HEAP_STRING_UC_LOGGER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER) +#define DUK_HTHREAD_STRING_UC_LOGGER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER) +#define DUK_HEAP_STRING_UC_THREAD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD) +#define DUK_HTHREAD_STRING_UC_THREAD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD) +#define DUK_HEAP_STRING_UC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER) +#define DUK_HTHREAD_STRING_UC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER) +#define DUK_HEAP_STRING_DEC_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV) +#define DUK_HTHREAD_STRING_DEC_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV) +#define DUK_HEAP_STRING_OBJ_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV) +#define DUK_HTHREAD_STRING_OBJ_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV) +#define DUK_HEAP_STRING_FLOAT64_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT64_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HEAP_STRING_FLOAT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HEAP_STRING_UINT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HTHREAD_STRING_UINT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HEAP_STRING_INT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT32_ARRAY) +#define DUK_HTHREAD_STRING_INT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT32_ARRAY) +#define DUK_HEAP_STRING_UINT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HTHREAD_STRING_UINT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HEAP_STRING_INT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT16_ARRAY) +#define DUK_HTHREAD_STRING_INT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT16_ARRAY) +#define DUK_HEAP_STRING_UINT8_CLAMPED_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_CLAMPED_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HEAP_STRING_UINT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HEAP_STRING_INT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT8_ARRAY) +#define DUK_HTHREAD_STRING_INT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT8_ARRAY) +#define DUK_HEAP_STRING_DATA_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA_VIEW) +#define DUK_HTHREAD_STRING_DATA_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA_VIEW) +#define DUK_HEAP_STRING_ARRAY_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HTHREAD_STRING_ARRAY_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HEAP_STRING_UC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER) +#define DUK_HTHREAD_STRING_UC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER) +#define DUK_HEAP_STRING_EMPTY_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING) +#define DUK_HTHREAD_STRING_EMPTY_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING) +#define DUK_HEAP_STRING_GLOBAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL) +#define DUK_HTHREAD_STRING_GLOBAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL) +#define DUK_HEAP_STRING_UC_ARGUMENTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS) +#define DUK_HTHREAD_STRING_UC_ARGUMENTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS) +#define DUK_HEAP_STRING_JSON(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON) +#define DUK_HTHREAD_STRING_JSON(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON) +#define DUK_HEAP_STRING_MATH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH) +#define DUK_HTHREAD_STRING_MATH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH) +#define DUK_HEAP_STRING_UC_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR) +#define DUK_HTHREAD_STRING_UC_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR) +#define DUK_HEAP_STRING_REG_EXP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP) +#define DUK_HTHREAD_STRING_REG_EXP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP) +#define DUK_HEAP_STRING_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATE) +#define DUK_HTHREAD_STRING_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATE) +#define DUK_HEAP_STRING_UC_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER) +#define DUK_HTHREAD_STRING_UC_NUMBER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER) +#define DUK_HEAP_STRING_UC_BOOLEAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN) +#define DUK_HTHREAD_STRING_UC_BOOLEAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN) +#define DUK_HEAP_STRING_UC_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING) +#define DUK_HTHREAD_STRING_UC_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING) +#define DUK_HEAP_STRING_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY) +#define DUK_HTHREAD_STRING_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY) +#define DUK_HEAP_STRING_UC_FUNCTION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION) +#define DUK_HTHREAD_STRING_UC_FUNCTION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION) +#define DUK_HEAP_STRING_UC_OBJECT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT) +#define DUK_HTHREAD_STRING_UC_OBJECT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT) +#define DUK_HEAP_STRING_UC_NULL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL) +#define DUK_HTHREAD_STRING_UC_NULL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL) +#define DUK_HEAP_STRING_UC_UNDEFINED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED) +#define DUK_HTHREAD_STRING_UC_UNDEFINED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED) +#define DUK_HEAP_STRING_JSON_EXT_FUNCTION2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2) +#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2) +#define DUK_HEAP_STRING_JSON_EXT_FUNCTION1(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1) +#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1) +#define DUK_HEAP_STRING_JSON_EXT_NEGINF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF) +#define DUK_HTHREAD_STRING_JSON_EXT_NEGINF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF) +#define DUK_HEAP_STRING_JSON_EXT_POSINF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF) +#define DUK_HTHREAD_STRING_JSON_EXT_POSINF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF) +#define DUK_HEAP_STRING_JSON_EXT_NAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN) +#define DUK_HTHREAD_STRING_JSON_EXT_NAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN) +#define DUK_HEAP_STRING_JSON_EXT_UNDEFINED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED) +#define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED) +#define DUK_HEAP_STRING_TO_LOG_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOG_STRING) +#define DUK_HTHREAD_STRING_TO_LOG_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOG_STRING) +#define DUK_HEAP_STRING_CLOG(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLOG) +#define DUK_HTHREAD_STRING_CLOG(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLOG) +#define DUK_HEAP_STRING_LC_L(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_L) +#define DUK_HTHREAD_STRING_LC_L(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_L) +#define DUK_HEAP_STRING_LC_N(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_N) +#define DUK_HTHREAD_STRING_LC_N(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_N) +#define DUK_HEAP_STRING_LC_FATAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FATAL) +#define DUK_HTHREAD_STRING_LC_FATAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FATAL) +#define DUK_HEAP_STRING_LC_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ERROR) +#define DUK_HTHREAD_STRING_LC_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ERROR) +#define DUK_HEAP_STRING_LC_WARN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_WARN) +#define DUK_HTHREAD_STRING_LC_WARN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_WARN) +#define DUK_HEAP_STRING_LC_DEBUG(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_DEBUG) +#define DUK_HTHREAD_STRING_LC_DEBUG(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_DEBUG) +#define DUK_HEAP_STRING_LC_TRACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_TRACE) +#define DUK_HTHREAD_STRING_LC_TRACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_TRACE) +#define DUK_HEAP_STRING_RAW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RAW) +#define DUK_HTHREAD_STRING_RAW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RAW) +#define DUK_HEAP_STRING_FMT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FMT) +#define DUK_HTHREAD_STRING_FMT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FMT) +#define DUK_HEAP_STRING_CURRENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CURRENT) +#define DUK_HTHREAD_STRING_CURRENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CURRENT) +#define DUK_HEAP_STRING_RESUME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RESUME) +#define DUK_HTHREAD_STRING_RESUME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RESUME) +#define DUK_HEAP_STRING_COMPACT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPACT) +#define DUK_HTHREAD_STRING_COMPACT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPACT) +#define DUK_HEAP_STRING_JC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC) +#define DUK_HTHREAD_STRING_JC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC) +#define DUK_HEAP_STRING_JX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX) +#define DUK_HTHREAD_STRING_JX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX) +#define DUK_HEAP_STRING_BASE64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64) +#define DUK_HTHREAD_STRING_BASE64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64) +#define DUK_HEAP_STRING_HEX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX) +#define DUK_HTHREAD_STRING_HEX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX) +#define DUK_HEAP_STRING_DEC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC) +#define DUK_HTHREAD_STRING_DEC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC) +#define DUK_HEAP_STRING_ENC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENC) +#define DUK_HTHREAD_STRING_ENC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENC) +#define DUK_HEAP_STRING_FIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FIN) +#define DUK_HTHREAD_STRING_FIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FIN) +#define DUK_HEAP_STRING_GC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GC) +#define DUK_HTHREAD_STRING_GC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GC) +#define DUK_HEAP_STRING_ACT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACT) +#define DUK_HTHREAD_STRING_ACT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACT) +#define DUK_HEAP_STRING_LC_INFO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_INFO) +#define DUK_HTHREAD_STRING_LC_INFO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_INFO) +#define DUK_HEAP_STRING_VERSION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VERSION) +#define DUK_HTHREAD_STRING_VERSION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VERSION) +#define DUK_HEAP_STRING_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV) +#define DUK_HTHREAD_STRING_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV) +#define DUK_HEAP_STRING_MOD_LOADED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_LOADED) +#define DUK_HTHREAD_STRING_MOD_LOADED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_LOADED) +#define DUK_HEAP_STRING_MOD_SEARCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_SEARCH) +#define DUK_HTHREAD_STRING_MOD_SEARCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_SEARCH) +#define DUK_HEAP_STRING_ERR_THROW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW) +#define DUK_HTHREAD_STRING_ERR_THROW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW) +#define DUK_HEAP_STRING_ERR_CREATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE) +#define DUK_HTHREAD_STRING_ERR_CREATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE) +#define DUK_HEAP_STRING_COMPILE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE) +#define DUK_HTHREAD_STRING_COMPILE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE) +#define DUK_HEAP_STRING_INT_REGBASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_REGBASE) +#define DUK_HTHREAD_STRING_INT_REGBASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_REGBASE) +#define DUK_HEAP_STRING_INT_THREAD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THREAD) +#define DUK_HTHREAD_STRING_INT_THREAD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THREAD) +#define DUK_HEAP_STRING_INT_HANDLER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_HANDLER) +#define DUK_HTHREAD_STRING_INT_HANDLER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_HANDLER) +#define DUK_HEAP_STRING_INT_FINALIZER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER) +#define DUK_HTHREAD_STRING_INT_FINALIZER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER) +#define DUK_HEAP_STRING_INT_CALLEE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_CALLEE) +#define DUK_HTHREAD_STRING_INT_CALLEE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_CALLEE) +#define DUK_HEAP_STRING_INT_MAP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP) +#define DUK_HTHREAD_STRING_INT_MAP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP) +#define DUK_HEAP_STRING_INT_ARGS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_ARGS) +#define DUK_HTHREAD_STRING_INT_ARGS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_ARGS) +#define DUK_HEAP_STRING_INT_THIS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THIS) +#define DUK_HTHREAD_STRING_INT_THIS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THIS) +#define DUK_HEAP_STRING_INT_PC2LINE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE) +#define DUK_HTHREAD_STRING_INT_PC2LINE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE) +#define DUK_HEAP_STRING_INT_SOURCE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE) +#define DUK_HTHREAD_STRING_INT_SOURCE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE) +#define DUK_HEAP_STRING_INT_VARENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV) +#define DUK_HTHREAD_STRING_INT_VARENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV) +#define DUK_HEAP_STRING_INT_LEXENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_LEXENV) +#define DUK_HTHREAD_STRING_INT_LEXENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_LEXENV) +#define DUK_HEAP_STRING_INT_VARMAP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP) +#define DUK_HTHREAD_STRING_INT_VARMAP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP) +#define DUK_HEAP_STRING_INT_FORMALS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS) +#define DUK_HTHREAD_STRING_INT_FORMALS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS) +#define DUK_HEAP_STRING_INT_BYTECODE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE) +#define DUK_HTHREAD_STRING_INT_BYTECODE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE) +#define DUK_HEAP_STRING_INT_NEXT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT) +#define DUK_HTHREAD_STRING_INT_NEXT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT) +#define DUK_HEAP_STRING_INT_TARGET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET) +#define DUK_HTHREAD_STRING_INT_TARGET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET) +#define DUK_HEAP_STRING_INT_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE) +#define DUK_HTHREAD_STRING_INT_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE) +#define DUK_HEAP_STRING_LC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER) +#define DUK_HTHREAD_STRING_LC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER) +#define DUK_HEAP_STRING_INT_TRACEDATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA) +#define DUK_HTHREAD_STRING_INT_TRACEDATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA) +#define DUK_HEAP_STRING_LINE_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER) +#define DUK_HTHREAD_STRING_LINE_NUMBER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER) +#define DUK_HEAP_STRING_FILE_NAME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME) +#define DUK_HTHREAD_STRING_FILE_NAME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME) +#define DUK_HEAP_STRING_PC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC) +#define DUK_HTHREAD_STRING_PC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC) +#define DUK_HEAP_STRING_STACK(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK) +#define DUK_HTHREAD_STRING_STACK(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK) +#define DUK_HEAP_STRING_THROW_TYPE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW_TYPE_ERROR) +#define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR) +#define DUK_HEAP_STRING_DUKTAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE) +#define DUK_HTHREAD_STRING_DUKTAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE) +#define DUK_HEAP_STRING_SET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT64) +#define DUK_HTHREAD_STRING_SET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT64) +#define DUK_HEAP_STRING_SET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT32) +#define DUK_HTHREAD_STRING_SET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT32) +#define DUK_HEAP_STRING_SET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT32) +#define DUK_HTHREAD_STRING_SET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT32) +#define DUK_HEAP_STRING_SET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT32) +#define DUK_HTHREAD_STRING_SET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT32) +#define DUK_HEAP_STRING_SET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT16) +#define DUK_HTHREAD_STRING_SET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT16) +#define DUK_HEAP_STRING_SET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT16) +#define DUK_HTHREAD_STRING_SET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT16) +#define DUK_HEAP_STRING_SET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT8) +#define DUK_HTHREAD_STRING_SET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT8) +#define DUK_HEAP_STRING_SET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT8) +#define DUK_HTHREAD_STRING_SET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT8) +#define DUK_HEAP_STRING_GET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT64) +#define DUK_HTHREAD_STRING_GET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT64) +#define DUK_HEAP_STRING_GET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT32) +#define DUK_HTHREAD_STRING_GET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT32) +#define DUK_HEAP_STRING_GET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT32) +#define DUK_HTHREAD_STRING_GET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT32) +#define DUK_HEAP_STRING_GET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT32) +#define DUK_HTHREAD_STRING_GET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT32) +#define DUK_HEAP_STRING_GET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT16) +#define DUK_HTHREAD_STRING_GET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT16) +#define DUK_HEAP_STRING_GET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT16) +#define DUK_HTHREAD_STRING_GET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT16) +#define DUK_HEAP_STRING_GET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT8) +#define DUK_HTHREAD_STRING_GET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT8) +#define DUK_HEAP_STRING_GET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT8) +#define DUK_HTHREAD_STRING_GET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT8) +#define DUK_HEAP_STRING_SUBARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBARRAY) +#define DUK_HTHREAD_STRING_SUBARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBARRAY) +#define DUK_HEAP_STRING_BYTES_PER_ELEMENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HEAP_STRING_BYTE_OFFSET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HTHREAD_STRING_BYTE_OFFSET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HEAP_STRING_LC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER) +#define DUK_HTHREAD_STRING_LC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER) +#define DUK_HEAP_STRING_IS_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_VIEW) +#define DUK_HTHREAD_STRING_IS_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_VIEW) +#define DUK_HEAP_STRING_DATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA) +#define DUK_HTHREAD_STRING_DATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA) +#define DUK_HEAP_STRING_TYPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE) +#define DUK_HTHREAD_STRING_TYPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE) +#define DUK_HEAP_STRING_WRITE_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HTHREAD_STRING_WRITE_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HEAP_STRING_WRITE_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HTHREAD_STRING_WRITE_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HEAP_STRING_WRITE_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HEAP_STRING_WRITE_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HEAP_STRING_WRITE_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HEAP_STRING_WRITE_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HEAP_STRING_WRITE_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HTHREAD_STRING_WRITE_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HEAP_STRING_WRITE_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HTHREAD_STRING_WRITE_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HEAP_STRING_WRITE_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HEAP_STRING_WRITE_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HEAP_STRING_WRITE_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HTHREAD_STRING_WRITE_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HEAP_STRING_WRITE_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HTHREAD_STRING_WRITE_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HEAP_STRING_WRITE_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HEAP_STRING_WRITE_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HEAP_STRING_WRITE_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT8) +#define DUK_HTHREAD_STRING_WRITE_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT8) +#define DUK_HEAP_STRING_WRITE_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT8) +#define DUK_HTHREAD_STRING_WRITE_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT8) +#define DUK_HEAP_STRING_READ_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_BE) +#define DUK_HTHREAD_STRING_READ_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_BE) +#define DUK_HEAP_STRING_READ_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_LE) +#define DUK_HTHREAD_STRING_READ_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_LE) +#define DUK_HEAP_STRING_READ_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_BE) +#define DUK_HTHREAD_STRING_READ_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_BE) +#define DUK_HEAP_STRING_READ_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_LE) +#define DUK_HTHREAD_STRING_READ_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_LE) +#define DUK_HEAP_STRING_READ_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HEAP_STRING_READ_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HEAP_STRING_READ_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HTHREAD_STRING_READ_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HEAP_STRING_READ_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HTHREAD_STRING_READ_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HEAP_STRING_READ_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_BE) +#define DUK_HTHREAD_STRING_READ_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_BE) +#define DUK_HEAP_STRING_READ_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_LE) +#define DUK_HTHREAD_STRING_READ_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_LE) +#define DUK_HEAP_STRING_READ_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HTHREAD_STRING_READ_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HEAP_STRING_READ_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HTHREAD_STRING_READ_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HEAP_STRING_READ_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_BE) +#define DUK_HTHREAD_STRING_READ_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_BE) +#define DUK_HEAP_STRING_READ_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_LE) +#define DUK_HTHREAD_STRING_READ_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_LE) +#define DUK_HEAP_STRING_READ_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HTHREAD_STRING_READ_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HEAP_STRING_READ_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HTHREAD_STRING_READ_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HEAP_STRING_READ_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT8) +#define DUK_HTHREAD_STRING_READ_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT8) +#define DUK_HEAP_STRING_READ_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT8) +#define DUK_HTHREAD_STRING_READ_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT8) +#define DUK_HEAP_STRING_COPY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COPY) +#define DUK_HTHREAD_STRING_COPY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COPY) +#define DUK_HEAP_STRING_EQUALS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EQUALS) +#define DUK_HTHREAD_STRING_EQUALS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EQUALS) +#define DUK_HEAP_STRING_FILL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILL) +#define DUK_HTHREAD_STRING_FILL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILL) +#define DUK_HEAP_STRING_WRITE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE) +#define DUK_HTHREAD_STRING_WRITE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE) +#define DUK_HEAP_STRING_COMPARE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPARE) +#define DUK_HTHREAD_STRING_COMPARE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPARE) +#define DUK_HEAP_STRING_BYTE_LENGTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HTHREAD_STRING_BYTE_LENGTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HEAP_STRING_IS_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_BUFFER) +#define DUK_HTHREAD_STRING_IS_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_BUFFER) +#define DUK_HEAP_STRING_IS_ENCODING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ENCODING) +#define DUK_HTHREAD_STRING_IS_ENCODING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ENCODING) +#define DUK_HEAP_STRING_EXPORTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORTS) +#define DUK_HTHREAD_STRING_EXPORTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORTS) +#define DUK_HEAP_STRING_ID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID) +#define DUK_HTHREAD_STRING_ID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID) +#define DUK_HEAP_STRING_REQUIRE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE) +#define DUK_HTHREAD_STRING_REQUIRE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REQUIRE) +#define DUK_HEAP_STRING___PROTO__(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__) +#define DUK_HTHREAD_STRING___PROTO__(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__) +#define DUK_HEAP_STRING_SET_PROTOTYPE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF) +#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF) +#define DUK_HEAP_STRING_OWN_KEYS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS) +#define DUK_HTHREAD_STRING_OWN_KEYS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS) +#define DUK_HEAP_STRING_ENUMERATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERATE) +#define DUK_HTHREAD_STRING_ENUMERATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERATE) +#define DUK_HEAP_STRING_DELETE_PROPERTY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY) +#define DUK_HTHREAD_STRING_DELETE_PROPERTY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY) +#define DUK_HEAP_STRING_HAS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS) +#define DUK_HTHREAD_STRING_HAS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS) +#define DUK_HEAP_STRING_PROXY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROXY) +#define DUK_HTHREAD_STRING_PROXY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROXY) +#define DUK_HEAP_STRING_CALLEE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE) +#define DUK_HTHREAD_STRING_CALLEE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE) +#define DUK_HEAP_STRING_INVALID_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE) +#define DUK_HTHREAD_STRING_INVALID_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE) +#define DUK_HEAP_STRING_BRACKETED_ELLIPSIS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS) +#define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS) +#define DUK_HEAP_STRING_NEWLINE_TAB(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_TAB) +#define DUK_HTHREAD_STRING_NEWLINE_TAB(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_TAB) +#define DUK_HEAP_STRING_SPACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPACE) +#define DUK_HTHREAD_STRING_SPACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPACE) +#define DUK_HEAP_STRING_COMMA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA) +#define DUK_HTHREAD_STRING_COMMA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA) +#define DUK_HEAP_STRING_MINUS_ZERO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO) +#define DUK_HTHREAD_STRING_MINUS_ZERO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO) +#define DUK_HEAP_STRING_PLUS_ZERO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_ZERO) +#define DUK_HTHREAD_STRING_PLUS_ZERO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_ZERO) +#define DUK_HEAP_STRING_ZERO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ZERO) +#define DUK_HTHREAD_STRING_ZERO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ZERO) +#define DUK_HEAP_STRING_MINUS_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY) +#define DUK_HTHREAD_STRING_MINUS_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY) +#define DUK_HEAP_STRING_PLUS_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_INFINITY) +#define DUK_HTHREAD_STRING_PLUS_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_INFINITY) +#define DUK_HEAP_STRING_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY) +#define DUK_HTHREAD_STRING_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY) +#define DUK_HEAP_STRING_LC_OBJECT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT) +#define DUK_HTHREAD_STRING_LC_OBJECT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT) +#define DUK_HEAP_STRING_LC_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING) +#define DUK_HTHREAD_STRING_LC_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING) +#define DUK_HEAP_STRING_LC_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER) +#define DUK_HTHREAD_STRING_LC_NUMBER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER) +#define DUK_HEAP_STRING_LC_BOOLEAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN) +#define DUK_HTHREAD_STRING_LC_BOOLEAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN) +#define DUK_HEAP_STRING_LC_UNDEFINED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED) +#define DUK_HTHREAD_STRING_LC_UNDEFINED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED) +#define DUK_HEAP_STRING_STRINGIFY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STRINGIFY) +#define DUK_HTHREAD_STRING_STRINGIFY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STRINGIFY) +#define DUK_HEAP_STRING_TAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TAN) +#define DUK_HTHREAD_STRING_TAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TAN) +#define DUK_HEAP_STRING_SQRT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT) +#define DUK_HTHREAD_STRING_SQRT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT) +#define DUK_HEAP_STRING_SIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SIN) +#define DUK_HTHREAD_STRING_SIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SIN) +#define DUK_HEAP_STRING_ROUND(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ROUND) +#define DUK_HTHREAD_STRING_ROUND(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ROUND) +#define DUK_HEAP_STRING_RANDOM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANDOM) +#define DUK_HTHREAD_STRING_RANDOM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANDOM) +#define DUK_HEAP_STRING_POW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POW) +#define DUK_HTHREAD_STRING_POW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POW) +#define DUK_HEAP_STRING_MIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN) +#define DUK_HTHREAD_STRING_MIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN) +#define DUK_HEAP_STRING_MAX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX) +#define DUK_HTHREAD_STRING_MAX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX) +#define DUK_HEAP_STRING_LOG(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG) +#define DUK_HTHREAD_STRING_LOG(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG) +#define DUK_HEAP_STRING_FLOOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOOR) +#define DUK_HTHREAD_STRING_FLOOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOOR) +#define DUK_HEAP_STRING_EXP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXP) +#define DUK_HTHREAD_STRING_EXP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXP) +#define DUK_HEAP_STRING_COS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COS) +#define DUK_HTHREAD_STRING_COS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COS) +#define DUK_HEAP_STRING_CEIL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CEIL) +#define DUK_HTHREAD_STRING_CEIL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CEIL) +#define DUK_HEAP_STRING_ATAN2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN2) +#define DUK_HTHREAD_STRING_ATAN2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN2) +#define DUK_HEAP_STRING_ATAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN) +#define DUK_HTHREAD_STRING_ATAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN) +#define DUK_HEAP_STRING_ASIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ASIN) +#define DUK_HTHREAD_STRING_ASIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ASIN) +#define DUK_HEAP_STRING_ACOS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACOS) +#define DUK_HTHREAD_STRING_ACOS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACOS) +#define DUK_HEAP_STRING_ABS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ABS) +#define DUK_HTHREAD_STRING_ABS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ABS) +#define DUK_HEAP_STRING_SQRT2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT2) +#define DUK_HTHREAD_STRING_SQRT2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT2) +#define DUK_HEAP_STRING_SQRT1_2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT1_2) +#define DUK_HTHREAD_STRING_SQRT1_2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT1_2) +#define DUK_HEAP_STRING_PI(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PI) +#define DUK_HTHREAD_STRING_PI(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PI) +#define DUK_HEAP_STRING_LOG10E(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG10E) +#define DUK_HTHREAD_STRING_LOG10E(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG10E) +#define DUK_HEAP_STRING_LOG2E(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG2E) +#define DUK_HTHREAD_STRING_LOG2E(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG2E) +#define DUK_HEAP_STRING_LN2(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN2) +#define DUK_HTHREAD_STRING_LN2(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN2) +#define DUK_HEAP_STRING_LN10(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN10) +#define DUK_HTHREAD_STRING_LN10(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN10) +#define DUK_HEAP_STRING_E(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_E) +#define DUK_HTHREAD_STRING_E(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_E) +#define DUK_HEAP_STRING_MESSAGE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE) +#define DUK_HTHREAD_STRING_MESSAGE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE) +#define DUK_HEAP_STRING_NAME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME) +#define DUK_HTHREAD_STRING_NAME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME) +#define DUK_HEAP_STRING_INPUT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT) +#define DUK_HTHREAD_STRING_INPUT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT) +#define DUK_HEAP_STRING_INDEX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX) +#define DUK_HTHREAD_STRING_INDEX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX) +#define DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPED_EMPTY_REGEXP) +#define DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPED_EMPTY_REGEXP) +#define DUK_HEAP_STRING_LAST_INDEX(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX) +#define DUK_HTHREAD_STRING_LAST_INDEX(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX) +#define DUK_HEAP_STRING_MULTILINE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE) +#define DUK_HTHREAD_STRING_MULTILINE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE) +#define DUK_HEAP_STRING_IGNORE_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE) +#define DUK_HTHREAD_STRING_IGNORE_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE) +#define DUK_HEAP_STRING_SOURCE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE) +#define DUK_HTHREAD_STRING_SOURCE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE) +#define DUK_HEAP_STRING_TEST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TEST) +#define DUK_HTHREAD_STRING_TEST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TEST) +#define DUK_HEAP_STRING_EXEC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXEC) +#define DUK_HTHREAD_STRING_EXEC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXEC) +#define DUK_HEAP_STRING_TO_GMT_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING) +#define DUK_HTHREAD_STRING_TO_GMT_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING) +#define DUK_HEAP_STRING_SET_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_YEAR) +#define DUK_HTHREAD_STRING_SET_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_YEAR) +#define DUK_HEAP_STRING_GET_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_YEAR) +#define DUK_HTHREAD_STRING_GET_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_YEAR) +#define DUK_HEAP_STRING_TO_JSON(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON) +#define DUK_HTHREAD_STRING_TO_JSON(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON) +#define DUK_HEAP_STRING_TO_ISO_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING) +#define DUK_HTHREAD_STRING_TO_ISO_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING) +#define DUK_HEAP_STRING_TO_UTC_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING) +#define DUK_HTHREAD_STRING_TO_UTC_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING) +#define DUK_HEAP_STRING_SET_UTC_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_FULL_YEAR) +#define DUK_HTHREAD_STRING_SET_UTC_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_FULL_YEAR) +#define DUK_HEAP_STRING_SET_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FULL_YEAR) +#define DUK_HTHREAD_STRING_SET_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FULL_YEAR) +#define DUK_HEAP_STRING_SET_UTC_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MONTH) +#define DUK_HTHREAD_STRING_SET_UTC_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MONTH) +#define DUK_HEAP_STRING_SET_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MONTH) +#define DUK_HTHREAD_STRING_SET_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MONTH) +#define DUK_HEAP_STRING_SET_UTC_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_DATE) +#define DUK_HTHREAD_STRING_SET_UTC_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_DATE) +#define DUK_HEAP_STRING_SET_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_DATE) +#define DUK_HTHREAD_STRING_SET_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_DATE) +#define DUK_HEAP_STRING_SET_UTC_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_HOURS) +#define DUK_HTHREAD_STRING_SET_UTC_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_HOURS) +#define DUK_HEAP_STRING_SET_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_HOURS) +#define DUK_HTHREAD_STRING_SET_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_HOURS) +#define DUK_HEAP_STRING_SET_UTC_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MINUTES) +#define DUK_HTHREAD_STRING_SET_UTC_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MINUTES) +#define DUK_HEAP_STRING_SET_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MINUTES) +#define DUK_HTHREAD_STRING_SET_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MINUTES) +#define DUK_HEAP_STRING_SET_UTC_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_SECONDS) +#define DUK_HTHREAD_STRING_SET_UTC_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_SECONDS) +#define DUK_HEAP_STRING_SET_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_SECONDS) +#define DUK_HTHREAD_STRING_SET_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_SECONDS) +#define DUK_HEAP_STRING_SET_UTC_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MILLISECONDS) +#define DUK_HTHREAD_STRING_SET_UTC_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MILLISECONDS) +#define DUK_HEAP_STRING_SET_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MILLISECONDS) +#define DUK_HTHREAD_STRING_SET_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MILLISECONDS) +#define DUK_HEAP_STRING_SET_TIME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_TIME) +#define DUK_HTHREAD_STRING_SET_TIME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_TIME) +#define DUK_HEAP_STRING_GET_TIMEZONE_OFFSET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIMEZONE_OFFSET) +#define DUK_HTHREAD_STRING_GET_TIMEZONE_OFFSET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIMEZONE_OFFSET) +#define DUK_HEAP_STRING_GET_UTC_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MILLISECONDS) +#define DUK_HTHREAD_STRING_GET_UTC_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MILLISECONDS) +#define DUK_HEAP_STRING_GET_MILLISECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MILLISECONDS) +#define DUK_HTHREAD_STRING_GET_MILLISECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MILLISECONDS) +#define DUK_HEAP_STRING_GET_UTC_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_SECONDS) +#define DUK_HTHREAD_STRING_GET_UTC_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_SECONDS) +#define DUK_HEAP_STRING_GET_SECONDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_SECONDS) +#define DUK_HTHREAD_STRING_GET_SECONDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_SECONDS) +#define DUK_HEAP_STRING_GET_UTC_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MINUTES) +#define DUK_HTHREAD_STRING_GET_UTC_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MINUTES) +#define DUK_HEAP_STRING_GET_MINUTES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MINUTES) +#define DUK_HTHREAD_STRING_GET_MINUTES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MINUTES) +#define DUK_HEAP_STRING_GET_UTC_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_HOURS) +#define DUK_HTHREAD_STRING_GET_UTC_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_HOURS) +#define DUK_HEAP_STRING_GET_HOURS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_HOURS) +#define DUK_HTHREAD_STRING_GET_HOURS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_HOURS) +#define DUK_HEAP_STRING_GET_UTC_DAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DAY) +#define DUK_HTHREAD_STRING_GET_UTC_DAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DAY) +#define DUK_HEAP_STRING_GET_DAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DAY) +#define DUK_HTHREAD_STRING_GET_DAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DAY) +#define DUK_HEAP_STRING_GET_UTC_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DATE) +#define DUK_HTHREAD_STRING_GET_UTC_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DATE) +#define DUK_HEAP_STRING_GET_DATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DATE) +#define DUK_HTHREAD_STRING_GET_DATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DATE) +#define DUK_HEAP_STRING_GET_UTC_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MONTH) +#define DUK_HTHREAD_STRING_GET_UTC_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MONTH) +#define DUK_HEAP_STRING_GET_MONTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MONTH) +#define DUK_HTHREAD_STRING_GET_MONTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MONTH) +#define DUK_HEAP_STRING_GET_UTC_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_FULL_YEAR) +#define DUK_HTHREAD_STRING_GET_UTC_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_FULL_YEAR) +#define DUK_HEAP_STRING_GET_FULL_YEAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FULL_YEAR) +#define DUK_HTHREAD_STRING_GET_FULL_YEAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FULL_YEAR) +#define DUK_HEAP_STRING_GET_TIME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIME) +#define DUK_HTHREAD_STRING_GET_TIME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIME) +#define DUK_HEAP_STRING_TO_LOCALE_TIME_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_TIME_STRING) +#define DUK_HTHREAD_STRING_TO_LOCALE_TIME_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_TIME_STRING) +#define DUK_HEAP_STRING_TO_LOCALE_DATE_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_DATE_STRING) +#define DUK_HTHREAD_STRING_TO_LOCALE_DATE_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_DATE_STRING) +#define DUK_HEAP_STRING_TO_TIME_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_TIME_STRING) +#define DUK_HTHREAD_STRING_TO_TIME_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_TIME_STRING) +#define DUK_HEAP_STRING_TO_DATE_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_DATE_STRING) +#define DUK_HTHREAD_STRING_TO_DATE_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_DATE_STRING) +#define DUK_HEAP_STRING_NOW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NOW) +#define DUK_HTHREAD_STRING_NOW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NOW) +#define DUK_HEAP_STRING_UTC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UTC) +#define DUK_HTHREAD_STRING_UTC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UTC) +#define DUK_HEAP_STRING_PARSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE) +#define DUK_HTHREAD_STRING_PARSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE) +#define DUK_HEAP_STRING_TO_PRECISION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_PRECISION) +#define DUK_HTHREAD_STRING_TO_PRECISION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_PRECISION) +#define DUK_HEAP_STRING_TO_EXPONENTIAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_EXPONENTIAL) +#define DUK_HTHREAD_STRING_TO_EXPONENTIAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_EXPONENTIAL) +#define DUK_HEAP_STRING_TO_FIXED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_FIXED) +#define DUK_HTHREAD_STRING_TO_FIXED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_FIXED) +#define DUK_HEAP_STRING_POSITIVE_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POSITIVE_INFINITY) +#define DUK_HTHREAD_STRING_POSITIVE_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POSITIVE_INFINITY) +#define DUK_HEAP_STRING_NEGATIVE_INFINITY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEGATIVE_INFINITY) +#define DUK_HTHREAD_STRING_NEGATIVE_INFINITY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEGATIVE_INFINITY) +#define DUK_HEAP_STRING_NAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN) +#define DUK_HTHREAD_STRING_NAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN) +#define DUK_HEAP_STRING_MIN_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN_VALUE) +#define DUK_HTHREAD_STRING_MIN_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN_VALUE) +#define DUK_HEAP_STRING_MAX_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX_VALUE) +#define DUK_HTHREAD_STRING_MAX_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX_VALUE) +#define DUK_HEAP_STRING_SUBSTR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTR) +#define DUK_HTHREAD_STRING_SUBSTR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTR) +#define DUK_HEAP_STRING_TRIM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRIM) +#define DUK_HTHREAD_STRING_TRIM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRIM) +#define DUK_HEAP_STRING_TO_LOCALE_UPPER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_UPPER_CASE) +#define DUK_HTHREAD_STRING_TO_LOCALE_UPPER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_UPPER_CASE) +#define DUK_HEAP_STRING_TO_UPPER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UPPER_CASE) +#define DUK_HTHREAD_STRING_TO_UPPER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UPPER_CASE) +#define DUK_HEAP_STRING_TO_LOCALE_LOWER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_LOWER_CASE) +#define DUK_HTHREAD_STRING_TO_LOCALE_LOWER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_LOWER_CASE) +#define DUK_HEAP_STRING_TO_LOWER_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOWER_CASE) +#define DUK_HTHREAD_STRING_TO_LOWER_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOWER_CASE) +#define DUK_HEAP_STRING_SUBSTRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTRING) +#define DUK_HTHREAD_STRING_SUBSTRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTRING) +#define DUK_HEAP_STRING_SPLIT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLIT) +#define DUK_HTHREAD_STRING_SPLIT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLIT) +#define DUK_HEAP_STRING_SEARCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEARCH) +#define DUK_HTHREAD_STRING_SEARCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEARCH) +#define DUK_HEAP_STRING_REPLACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REPLACE) +#define DUK_HTHREAD_STRING_REPLACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REPLACE) +#define DUK_HEAP_STRING_MATCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATCH) +#define DUK_HTHREAD_STRING_MATCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATCH) +#define DUK_HEAP_STRING_LOCALE_COMPARE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOCALE_COMPARE) +#define DUK_HTHREAD_STRING_LOCALE_COMPARE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOCALE_COMPARE) +#define DUK_HEAP_STRING_CHAR_CODE_AT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_CODE_AT) +#define DUK_HTHREAD_STRING_CHAR_CODE_AT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_CODE_AT) +#define DUK_HEAP_STRING_CHAR_AT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_AT) +#define DUK_HTHREAD_STRING_CHAR_AT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_AT) +#define DUK_HEAP_STRING_FROM_CHAR_CODE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FROM_CHAR_CODE) +#define DUK_HTHREAD_STRING_FROM_CHAR_CODE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FROM_CHAR_CODE) +#define DUK_HEAP_STRING_REDUCE_RIGHT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE_RIGHT) +#define DUK_HTHREAD_STRING_REDUCE_RIGHT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE_RIGHT) +#define DUK_HEAP_STRING_REDUCE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE) +#define DUK_HTHREAD_STRING_REDUCE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE) +#define DUK_HEAP_STRING_FILTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILTER) +#define DUK_HTHREAD_STRING_FILTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILTER) +#define DUK_HEAP_STRING_MAP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAP) +#define DUK_HTHREAD_STRING_MAP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAP) +#define DUK_HEAP_STRING_FOR_EACH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR_EACH) +#define DUK_HTHREAD_STRING_FOR_EACH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR_EACH) +#define DUK_HEAP_STRING_SOME(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOME) +#define DUK_HTHREAD_STRING_SOME(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOME) +#define DUK_HEAP_STRING_EVERY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVERY) +#define DUK_HTHREAD_STRING_EVERY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVERY) +#define DUK_HEAP_STRING_LAST_INDEX_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX_OF) +#define DUK_HTHREAD_STRING_LAST_INDEX_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX_OF) +#define DUK_HEAP_STRING_INDEX_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX_OF) +#define DUK_HTHREAD_STRING_INDEX_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX_OF) +#define DUK_HEAP_STRING_UNSHIFT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNSHIFT) +#define DUK_HTHREAD_STRING_UNSHIFT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNSHIFT) +#define DUK_HEAP_STRING_SPLICE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLICE) +#define DUK_HTHREAD_STRING_SPLICE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLICE) +#define DUK_HEAP_STRING_SORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SORT) +#define DUK_HTHREAD_STRING_SORT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SORT) +#define DUK_HEAP_STRING_SLICE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SLICE) +#define DUK_HTHREAD_STRING_SLICE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SLICE) +#define DUK_HEAP_STRING_SHIFT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SHIFT) +#define DUK_HTHREAD_STRING_SHIFT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SHIFT) +#define DUK_HEAP_STRING_REVERSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REVERSE) +#define DUK_HTHREAD_STRING_REVERSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REVERSE) +#define DUK_HEAP_STRING_PUSH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUSH) +#define DUK_HTHREAD_STRING_PUSH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUSH) +#define DUK_HEAP_STRING_POP(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POP) +#define DUK_HTHREAD_STRING_POP(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POP) +#define DUK_HEAP_STRING_JOIN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN) +#define DUK_HTHREAD_STRING_JOIN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN) +#define DUK_HEAP_STRING_CONCAT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONCAT) +#define DUK_HTHREAD_STRING_CONCAT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONCAT) +#define DUK_HEAP_STRING_IS_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ARRAY) +#define DUK_HTHREAD_STRING_IS_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ARRAY) +#define DUK_HEAP_STRING_LC_ARGUMENTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS) +#define DUK_HTHREAD_STRING_LC_ARGUMENTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS) +#define DUK_HEAP_STRING_CALLER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER) +#define DUK_HTHREAD_STRING_CALLER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER) +#define DUK_HEAP_STRING_BIND(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BIND) +#define DUK_HTHREAD_STRING_BIND(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BIND) +#define DUK_HEAP_STRING_CALL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALL) +#define DUK_HTHREAD_STRING_CALL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALL) +#define DUK_HEAP_STRING_APPLY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_APPLY) +#define DUK_HTHREAD_STRING_APPLY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_APPLY) +#define DUK_HEAP_STRING_PROPERTY_IS_ENUMERABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROPERTY_IS_ENUMERABLE) +#define DUK_HTHREAD_STRING_PROPERTY_IS_ENUMERABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROPERTY_IS_ENUMERABLE) +#define DUK_HEAP_STRING_IS_PROTOTYPE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_PROTOTYPE_OF) +#define DUK_HTHREAD_STRING_IS_PROTOTYPE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_PROTOTYPE_OF) +#define DUK_HEAP_STRING_HAS_OWN_PROPERTY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS_OWN_PROPERTY) +#define DUK_HTHREAD_STRING_HAS_OWN_PROPERTY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS_OWN_PROPERTY) +#define DUK_HEAP_STRING_VALUE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF) +#define DUK_HTHREAD_STRING_VALUE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF) +#define DUK_HEAP_STRING_TO_LOCALE_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING) +#define DUK_HTHREAD_STRING_TO_LOCALE_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING) +#define DUK_HEAP_STRING_TO_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING) +#define DUK_HTHREAD_STRING_TO_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING) +#define DUK_HEAP_STRING_CONSTRUCTOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR) +#define DUK_HTHREAD_STRING_CONSTRUCTOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR) +#define DUK_HEAP_STRING_SET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET) +#define DUK_HTHREAD_STRING_SET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET) +#define DUK_HEAP_STRING_GET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET) +#define DUK_HTHREAD_STRING_GET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET) +#define DUK_HEAP_STRING_ENUMERABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE) +#define DUK_HTHREAD_STRING_ENUMERABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE) +#define DUK_HEAP_STRING_CONFIGURABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE) +#define DUK_HTHREAD_STRING_CONFIGURABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE) +#define DUK_HEAP_STRING_WRITABLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE) +#define DUK_HTHREAD_STRING_WRITABLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE) +#define DUK_HEAP_STRING_VALUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE) +#define DUK_HTHREAD_STRING_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE) +#define DUK_HEAP_STRING_KEYS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_KEYS) +#define DUK_HTHREAD_STRING_KEYS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_KEYS) +#define DUK_HEAP_STRING_IS_EXTENSIBLE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_EXTENSIBLE) +#define DUK_HTHREAD_STRING_IS_EXTENSIBLE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_EXTENSIBLE) +#define DUK_HEAP_STRING_IS_FROZEN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FROZEN) +#define DUK_HTHREAD_STRING_IS_FROZEN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FROZEN) +#define DUK_HEAP_STRING_IS_SEALED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_SEALED) +#define DUK_HTHREAD_STRING_IS_SEALED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_SEALED) +#define DUK_HEAP_STRING_PREVENT_EXTENSIONS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PREVENT_EXTENSIONS) +#define DUK_HTHREAD_STRING_PREVENT_EXTENSIONS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PREVENT_EXTENSIONS) +#define DUK_HEAP_STRING_FREEZE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FREEZE) +#define DUK_HTHREAD_STRING_FREEZE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FREEZE) +#define DUK_HEAP_STRING_SEAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEAL) +#define DUK_HTHREAD_STRING_SEAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEAL) +#define DUK_HEAP_STRING_DEFINE_PROPERTIES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTIES) +#define DUK_HTHREAD_STRING_DEFINE_PROPERTIES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTIES) +#define DUK_HEAP_STRING_DEFINE_PROPERTY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTY) +#define DUK_HTHREAD_STRING_DEFINE_PROPERTY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTY) +#define DUK_HEAP_STRING_CREATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CREATE) +#define DUK_HTHREAD_STRING_CREATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CREATE) +#define DUK_HEAP_STRING_GET_OWN_PROPERTY_NAMES(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_NAMES) +#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_NAMES(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_NAMES) +#define DUK_HEAP_STRING_GET_OWN_PROPERTY_DESCRIPTOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR) +#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_DESCRIPTOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR) +#define DUK_HEAP_STRING_GET_PROTOTYPE_OF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_PROTOTYPE_OF) +#define DUK_HTHREAD_STRING_GET_PROTOTYPE_OF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_PROTOTYPE_OF) +#define DUK_HEAP_STRING_PROTOTYPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE) +#define DUK_HTHREAD_STRING_PROTOTYPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE) +#define DUK_HEAP_STRING_LENGTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH) +#define DUK_HTHREAD_STRING_LENGTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH) +#define DUK_HEAP_STRING_ALERT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ALERT) +#define DUK_HTHREAD_STRING_ALERT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ALERT) +#define DUK_HEAP_STRING_PRINT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRINT) +#define DUK_HTHREAD_STRING_PRINT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRINT) +#define DUK_HEAP_STRING_UNESCAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNESCAPE) +#define DUK_HTHREAD_STRING_UNESCAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNESCAPE) +#define DUK_HEAP_STRING_ESCAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPE) +#define DUK_HTHREAD_STRING_ESCAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPE) +#define DUK_HEAP_STRING_ENCODE_URI_COMPONENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI_COMPONENT) +#define DUK_HTHREAD_STRING_ENCODE_URI_COMPONENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI_COMPONENT) +#define DUK_HEAP_STRING_ENCODE_URI(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI) +#define DUK_HTHREAD_STRING_ENCODE_URI(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI) +#define DUK_HEAP_STRING_DECODE_URI_COMPONENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI_COMPONENT) +#define DUK_HTHREAD_STRING_DECODE_URI_COMPONENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI_COMPONENT) +#define DUK_HEAP_STRING_DECODE_URI(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI) +#define DUK_HTHREAD_STRING_DECODE_URI(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI) +#define DUK_HEAP_STRING_IS_FINITE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FINITE) +#define DUK_HTHREAD_STRING_IS_FINITE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FINITE) +#define DUK_HEAP_STRING_IS_NAN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_NAN) +#define DUK_HTHREAD_STRING_IS_NAN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_NAN) +#define DUK_HEAP_STRING_PARSE_FLOAT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_FLOAT) +#define DUK_HTHREAD_STRING_PARSE_FLOAT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_FLOAT) +#define DUK_HEAP_STRING_PARSE_INT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_INT) +#define DUK_HTHREAD_STRING_PARSE_INT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_INT) +#define DUK_HEAP_STRING_EVAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL) +#define DUK_HTHREAD_STRING_EVAL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL) +#define DUK_HEAP_STRING_URI_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_URI_ERROR) +#define DUK_HTHREAD_STRING_URI_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_URI_ERROR) +#define DUK_HEAP_STRING_TYPE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE_ERROR) +#define DUK_HTHREAD_STRING_TYPE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE_ERROR) +#define DUK_HEAP_STRING_SYNTAX_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SYNTAX_ERROR) +#define DUK_HTHREAD_STRING_SYNTAX_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SYNTAX_ERROR) +#define DUK_HEAP_STRING_REFERENCE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REFERENCE_ERROR) +#define DUK_HTHREAD_STRING_REFERENCE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REFERENCE_ERROR) +#define DUK_HEAP_STRING_RANGE_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANGE_ERROR) +#define DUK_HTHREAD_STRING_RANGE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANGE_ERROR) +#define DUK_HEAP_STRING_EVAL_ERROR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL_ERROR) +#define DUK_HTHREAD_STRING_EVAL_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL_ERROR) +#define DUK_HEAP_STRING_BREAK(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK) +#define DUK_HTHREAD_STRING_BREAK(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK) +#define DUK_HEAP_STRING_CASE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE) +#define DUK_HTHREAD_STRING_CASE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE) +#define DUK_HEAP_STRING_CATCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH) +#define DUK_HTHREAD_STRING_CATCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH) +#define DUK_HEAP_STRING_CONTINUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE) +#define DUK_HTHREAD_STRING_CONTINUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE) +#define DUK_HEAP_STRING_DEBUGGER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER) +#define DUK_HTHREAD_STRING_DEBUGGER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER) +#define DUK_HEAP_STRING_DEFAULT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT) +#define DUK_HTHREAD_STRING_DEFAULT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT) +#define DUK_HEAP_STRING_DELETE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE) +#define DUK_HTHREAD_STRING_DELETE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE) +#define DUK_HEAP_STRING_DO(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO) +#define DUK_HTHREAD_STRING_DO(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO) +#define DUK_HEAP_STRING_ELSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE) +#define DUK_HTHREAD_STRING_ELSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE) +#define DUK_HEAP_STRING_FINALLY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY) +#define DUK_HTHREAD_STRING_FINALLY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY) +#define DUK_HEAP_STRING_FOR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR) +#define DUK_HTHREAD_STRING_FOR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR) +#define DUK_HEAP_STRING_LC_FUNCTION(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION) +#define DUK_HTHREAD_STRING_LC_FUNCTION(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION) +#define DUK_HEAP_STRING_IF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF) +#define DUK_HTHREAD_STRING_IF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF) +#define DUK_HEAP_STRING_IN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN) +#define DUK_HTHREAD_STRING_IN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN) +#define DUK_HEAP_STRING_INSTANCEOF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF) +#define DUK_HTHREAD_STRING_INSTANCEOF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF) +#define DUK_HEAP_STRING_NEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW) +#define DUK_HTHREAD_STRING_NEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW) +#define DUK_HEAP_STRING_RETURN(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN) +#define DUK_HTHREAD_STRING_RETURN(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN) +#define DUK_HEAP_STRING_SWITCH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH) +#define DUK_HTHREAD_STRING_SWITCH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH) +#define DUK_HEAP_STRING_THIS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS) +#define DUK_HTHREAD_STRING_THIS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS) +#define DUK_HEAP_STRING_THROW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW) +#define DUK_HTHREAD_STRING_THROW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW) +#define DUK_HEAP_STRING_TRY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY) +#define DUK_HTHREAD_STRING_TRY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY) +#define DUK_HEAP_STRING_TYPEOF(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF) +#define DUK_HTHREAD_STRING_TYPEOF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF) +#define DUK_HEAP_STRING_VAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR) +#define DUK_HTHREAD_STRING_VAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR) +#define DUK_HEAP_STRING_VOID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID) +#define DUK_HTHREAD_STRING_VOID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID) +#define DUK_HEAP_STRING_WHILE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE) +#define DUK_HTHREAD_STRING_WHILE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE) +#define DUK_HEAP_STRING_WITH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH) +#define DUK_HTHREAD_STRING_WITH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH) +#define DUK_HEAP_STRING_CLASS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS) +#define DUK_HTHREAD_STRING_CLASS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS) +#define DUK_HEAP_STRING_CONST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST) +#define DUK_HTHREAD_STRING_CONST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST) +#define DUK_HEAP_STRING_ENUM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM) +#define DUK_HTHREAD_STRING_ENUM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM) +#define DUK_HEAP_STRING_EXPORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT) +#define DUK_HTHREAD_STRING_EXPORT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT) +#define DUK_HEAP_STRING_EXTENDS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS) +#define DUK_HTHREAD_STRING_EXTENDS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS) +#define DUK_HEAP_STRING_IMPORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT) +#define DUK_HTHREAD_STRING_IMPORT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT) +#define DUK_HEAP_STRING_SUPER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER) +#define DUK_HTHREAD_STRING_SUPER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER) +#define DUK_HEAP_STRING_LC_NULL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL) +#define DUK_HTHREAD_STRING_LC_NULL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL) +#define DUK_HEAP_STRING_TRUE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE) +#define DUK_HTHREAD_STRING_TRUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE) +#define DUK_HEAP_STRING_FALSE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE) +#define DUK_HTHREAD_STRING_FALSE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE) +#define DUK_HEAP_STRING_IMPLEMENTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS) +#define DUK_HTHREAD_STRING_IMPLEMENTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS) +#define DUK_HEAP_STRING_INTERFACE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE) +#define DUK_HTHREAD_STRING_INTERFACE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE) +#define DUK_HEAP_STRING_LET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET) +#define DUK_HTHREAD_STRING_LET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET) +#define DUK_HEAP_STRING_PACKAGE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE) +#define DUK_HTHREAD_STRING_PACKAGE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE) +#define DUK_HEAP_STRING_PRIVATE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE) +#define DUK_HTHREAD_STRING_PRIVATE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE) +#define DUK_HEAP_STRING_PROTECTED(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED) +#define DUK_HTHREAD_STRING_PROTECTED(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED) +#define DUK_HEAP_STRING_PUBLIC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC) +#define DUK_HTHREAD_STRING_PUBLIC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC) +#define DUK_HEAP_STRING_STATIC(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC) +#define DUK_HTHREAD_STRING_STATIC(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC) +#define DUK_HEAP_STRING_YIELD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD) +#define DUK_HTHREAD_STRING_YIELD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD) + +#define DUK_HEAP_NUM_STRINGS 414 + +#define DUK_STRIDX_START_RESERVED 369 +#define DUK_STRIDX_START_STRICT_RESERVED 405 +#define DUK_STRIDX_END_RESERVED 414 /* exclusive endpoint */ + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[147]; +DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1952]; +#ifdef DUK_USE_BUILTIN_INITJS +DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187]; +#endif /* DUK_USE_BUILTIN_INITJS */ +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_BUILTINS_DATA_LENGTH 1952 +#ifdef DUK_USE_BUILTIN_INITJS +#define DUK_BUILTIN_INITJS_DATA_LENGTH 187 +#endif /* DUK_USE_BUILTIN_INITJS */ + +#define DUK_BIDX_GLOBAL 0 +#define DUK_BIDX_GLOBAL_ENV 1 +#define DUK_BIDX_OBJECT_CONSTRUCTOR 2 +#define DUK_BIDX_OBJECT_PROTOTYPE 3 +#define DUK_BIDX_FUNCTION_CONSTRUCTOR 4 +#define DUK_BIDX_FUNCTION_PROTOTYPE 5 +#define DUK_BIDX_ARRAY_CONSTRUCTOR 6 +#define DUK_BIDX_ARRAY_PROTOTYPE 7 +#define DUK_BIDX_STRING_CONSTRUCTOR 8 +#define DUK_BIDX_STRING_PROTOTYPE 9 +#define DUK_BIDX_BOOLEAN_CONSTRUCTOR 10 +#define DUK_BIDX_BOOLEAN_PROTOTYPE 11 +#define DUK_BIDX_NUMBER_CONSTRUCTOR 12 +#define DUK_BIDX_NUMBER_PROTOTYPE 13 +#define DUK_BIDX_DATE_CONSTRUCTOR 14 +#define DUK_BIDX_DATE_PROTOTYPE 15 +#define DUK_BIDX_REGEXP_CONSTRUCTOR 16 +#define DUK_BIDX_REGEXP_PROTOTYPE 17 +#define DUK_BIDX_ERROR_CONSTRUCTOR 18 +#define DUK_BIDX_ERROR_PROTOTYPE 19 +#define DUK_BIDX_EVAL_ERROR_CONSTRUCTOR 20 +#define DUK_BIDX_EVAL_ERROR_PROTOTYPE 21 +#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR 22 +#define DUK_BIDX_RANGE_ERROR_PROTOTYPE 23 +#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR 24 +#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE 25 +#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR 26 +#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE 27 +#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR 28 +#define DUK_BIDX_TYPE_ERROR_PROTOTYPE 29 +#define DUK_BIDX_URI_ERROR_CONSTRUCTOR 30 +#define DUK_BIDX_URI_ERROR_PROTOTYPE 31 +#define DUK_BIDX_MATH 32 +#define DUK_BIDX_JSON 33 +#define DUK_BIDX_TYPE_ERROR_THROWER 34 +#define DUK_BIDX_PROXY_CONSTRUCTOR 35 +#define DUK_BIDX_DUKTAPE 36 +#define DUK_BIDX_THREAD_CONSTRUCTOR 37 +#define DUK_BIDX_THREAD_PROTOTYPE 38 +#define DUK_BIDX_BUFFER_CONSTRUCTOR 39 +#define DUK_BIDX_BUFFER_PROTOTYPE 40 +#define DUK_BIDX_POINTER_CONSTRUCTOR 41 +#define DUK_BIDX_POINTER_PROTOTYPE 42 +#define DUK_BIDX_LOGGER_CONSTRUCTOR 43 +#define DUK_BIDX_LOGGER_PROTOTYPE 44 +#define DUK_BIDX_DOUBLE_ERROR 45 +#define DUK_BIDX_ARRAYBUFFER_CONSTRUCTOR 46 +#define DUK_BIDX_ARRAYBUFFER_PROTOTYPE 47 +#define DUK_BIDX_DATAVIEW_CONSTRUCTOR 48 +#define DUK_BIDX_DATAVIEW_PROTOTYPE 49 +#define DUK_BIDX_TYPEDARRAY_PROTOTYPE 50 +#define DUK_BIDX_INT8ARRAY_CONSTRUCTOR 51 +#define DUK_BIDX_INT8ARRAY_PROTOTYPE 52 +#define DUK_BIDX_UINT8ARRAY_CONSTRUCTOR 53 +#define DUK_BIDX_UINT8ARRAY_PROTOTYPE 54 +#define DUK_BIDX_UINT8CLAMPEDARRAY_CONSTRUCTOR 55 +#define DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE 56 +#define DUK_BIDX_INT16ARRAY_CONSTRUCTOR 57 +#define DUK_BIDX_INT16ARRAY_PROTOTYPE 58 +#define DUK_BIDX_UINT16ARRAY_CONSTRUCTOR 59 +#define DUK_BIDX_UINT16ARRAY_PROTOTYPE 60 +#define DUK_BIDX_INT32ARRAY_CONSTRUCTOR 61 +#define DUK_BIDX_INT32ARRAY_PROTOTYPE 62 +#define DUK_BIDX_UINT32ARRAY_CONSTRUCTOR 63 +#define DUK_BIDX_UINT32ARRAY_PROTOTYPE 64 +#define DUK_BIDX_FLOAT32ARRAY_CONSTRUCTOR 65 +#define DUK_BIDX_FLOAT32ARRAY_PROTOTYPE 66 +#define DUK_BIDX_FLOAT64ARRAY_CONSTRUCTOR 67 +#define DUK_BIDX_FLOAT64ARRAY_PROTOTYPE 68 +#define DUK_BIDX_NODEJS_BUFFER_CONSTRUCTOR 69 +#define DUK_BIDX_NODEJS_BUFFER_PROTOTYPE 70 + +#define DUK_NUM_BUILTINS 71 + +#else +#error invalid endianness defines +#endif +#endif /* DUK_BUILTINS_H_INCLUDED */ +#line 50 "duk_internal.h" + +#line 1 "duk_util.h" +/* + * Utilities + */ + +#ifndef DUK_UTIL_H_INCLUDED +#define DUK_UTIL_H_INCLUDED + +#define DUK_UTIL_MIN_HASH_PRIME 17 /* must match genhashsizes.py */ + +#define DUK_UTIL_GET_HASH_PROBE_STEP(hash) (duk_util_probe_steps[(hash) & 0x1f]) + +/* + * Endian conversion + */ + +#if defined(DUK_USE_INTEGER_LE) +#define DUK_HTON32(x) DUK_BSWAP32((x)) +#define DUK_NTOH32(x) DUK_BSWAP32((x)) +#define DUK_HTON16(x) DUK_BSWAP16((x)) +#define DUK_NTOH16(x) DUK_BSWAP16((x)) +#elif defined(DUK_USE_INTEGER_BE) +#define DUK_HTON32(x) (x) +#define DUK_NTOH32(x) (x) +#define DUK_HTON16(x) (x) +#define DUK_NTOH16(x) (x) +#else +#error internal error, endianness defines broken +#endif + +/* + * Bitstream decoder + */ + +struct duk_bitdecoder_ctx { + const duk_uint8_t *data; + duk_size_t offset; + duk_size_t length; + duk_uint32_t currval; + duk_small_int_t currbits; +}; + +/* + * Bitstream encoder + */ + +struct duk_bitencoder_ctx { + duk_uint8_t *data; + duk_size_t offset; + duk_size_t length; + duk_uint32_t currval; + duk_small_int_t currbits; + duk_small_int_t truncated; +}; + +/* + * Raw write/read macros for big endian, unaligned basic values. + * Caller ensures there's enough space. The macros update the pointer + * argument automatically on resizes. The idiom seems a bit odd, but + * leads to compact code. + */ + +#define DUK_RAW_WRITE_U8(ptr,val) do { \ + *(ptr)++ = (duk_uint8_t) (val); \ + } while (0) +#define DUK_RAW_WRITE_U16_BE(ptr,val) duk_raw_write_u16_be(&(ptr), (duk_uint16_t) (val)) +#define DUK_RAW_WRITE_U32_BE(ptr,val) duk_raw_write_u32_be(&(ptr), (duk_uint32_t) (val)) +#define DUK_RAW_WRITE_DOUBLE_BE(ptr,val) duk_raw_write_double_be(&(ptr), (duk_double_t) (val)) +#define DUK_RAW_WRITE_XUTF8(ptr,val) do { \ + /* 'ptr' is evaluated both as LHS and RHS. */ \ + duk_uint8_t *duk__ptr; \ + duk_small_int_t duk__len; \ + duk__ptr = (duk_uint8_t *) (ptr); \ + duk__len = duk_unicode_encode_xutf8((duk_ucodepoint_t) (val), duk__ptr); \ + duk__ptr += duk__len; \ + (ptr) = duk__ptr; \ + } while (0) +#define DUK_RAW_WRITE_CESU8(ptr,val) do { \ + /* 'ptr' is evaluated both as LHS and RHS. */ \ + duk_uint8_t *duk__ptr; \ + duk_small_int_t duk__len; \ + duk__ptr = (duk_uint8_t *) (ptr); \ + duk__len = duk_unicode_encode_cesu8((duk_ucodepoint_t) (val), duk__ptr); \ + duk__ptr += duk__len; \ + (ptr) = duk__ptr; \ + } while (0) + +#define DUK_RAW_READ_U8(ptr) ((duk_uint8_t) (*(ptr)++)) +#define DUK_RAW_READ_U16_BE(ptr) duk_raw_read_u16_be(&(ptr)); +#define DUK_RAW_READ_U32_BE(ptr) duk_raw_read_u32_be(&(ptr)); +#define DUK_RAW_READ_DOUBLE_BE(ptr) duk_raw_read_double_be(&(ptr)); + +/* + * Buffer writer (dynamic buffer only) + * + * Helper for writing to a dynamic buffer with a concept of a "spare" area + * to reduce resizes. You can ensure there is enough space beforehand and + * then write for a while without further checks, relying on a stable data + * pointer. Spare handling is automatic so call sites only indicate how + * much data they need right now. + * + * There are several ways to write using bufwriter. The best approach + * depends mainly on how much performance matters over code footprint. + * The key issues are (1) ensuring there is space and (2) keeping the + * pointers consistent. Fast code should ensure space for multiple writes + * with one ensure call. Fastest inner loop code can temporarily borrow + * the 'p' pointer but must write it back eventually. + * + * Be careful to ensure all macro arguments (other than static pointers like + * 'thr' and 'bw_ctx') are evaluated exactly once, using temporaries if + * necessary (if that's not possible, there should be a note near the macro). + * Buffer write arguments often contain arithmetic etc so this is + * particularly important here. + */ + +/* XXX: Migrate bufwriter and other read/write helpers to its own header? */ + +struct duk_bufwriter_ctx { + duk_uint8_t *p; + duk_uint8_t *p_base; + duk_uint8_t *p_limit; + duk_hbuffer_dynamic *buf; +}; + +#define DUK_BW_SPARE_ADD 64 +#define DUK_BW_SPARE_SHIFT 4 /* 2^4 -> 1/16 = 6.25% spare */ + +/* Initialization and finalization (compaction), converting to other types. */ + +#define DUK_BW_INIT_PUSHBUF(thr,bw_ctx,sz) do { \ + duk_bw_init_pushbuf((thr), (bw_ctx), (sz)); \ + } while (0) +#define DUK_BW_INIT_WITHBUF(thr,bw_ctx,buf) do { \ + duk_bw_init((thr), (bw_ctx), (buf)); \ + } while (0) +#define DUK_BW_COMPACT(thr,bw_ctx) do { \ + /* Make underlying buffer compact to match DUK_BW_GET_SIZE(). */ \ + duk_bw_compact((thr), (bw_ctx)); \ + } while (0) +#define DUK_BW_PUSH_AS_STRING(thr,bw_ctx) do { \ + duk_push_lstring((duk_context *) (thr), \ + (const char *) (bw_ctx)->p_base, \ + (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \ + } while (0) +/* Pointers may be NULL for a while when 'buf' size is zero and before any + * ENSURE calls have been made. Once an ENSURE has been made, the pointers + * are required to be non-NULL so that it's always valid to use memcpy() and + * memmove(), even for zero size. + */ +#define DUK_BW_ASSERT_VALID_EXPR(thr,bw_ctx) \ + DUK_ASSERT_EXPR((bw_ctx) != NULL && \ + (bw_ctx)->buf != NULL && \ + ((DUK_HBUFFER_DYNAMIC_GET_SIZE((bw_ctx)->buf) == 0) || \ + ((bw_ctx)->p != NULL && \ + (bw_ctx)->p_base != NULL && \ + (bw_ctx)->p_limit != NULL && \ + (bw_ctx)->p_limit >= (bw_ctx)->p_base && \ + (bw_ctx)->p >= (bw_ctx)->p_base && \ + (bw_ctx)->p <= (bw_ctx)->p_limit))) +#define DUK_BW_ASSERT_VALID(thr,bw_ctx) do { \ + DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)); \ + } while (0) + +/* Working with the pointer and current size. */ + +#define DUK_BW_GET_PTR(thr,bw_ctx) \ + ((bw_ctx)->p) +#define DUK_BW_SET_PTR(thr,bw_ctx,ptr) do { \ + (bw_ctx)->p = (ptr); \ + } while (0) +#define DUK_BW_ADD_PTR(thr,bw_ctx,delta) do { \ + (bw_ctx)->p += (delta); \ + } while (0) +#define DUK_BW_GET_BASEPTR(thr,bw_ctx) \ + ((bw_ctx)->p_base) +#define DUK_BW_GET_LIMITPTR(thr,bw_ctx) \ + ((bw_ctx)->p_limit) +#define DUK_BW_GET_SIZE(thr,bw_ctx) \ + ((duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)) +#define DUK_BW_SET_SIZE(thr,bw_ctx,sz) do { \ + DUK_ASSERT((duk_size_t) (sz) <= (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \ + (bw_ctx)->p = (bw_ctx)->p_base + (sz); \ + } while (0) +#define DUK_BW_RESET_SIZE(thr,bw_ctx) do { \ + /* Reset to zero size, keep current limit. */ \ + (bw_ctx)->p = (bw_ctx)->p_base; \ + } while (0) +#define DUK_BW_GET_BUFFER(thr,bw_ctx) \ + ((bw_ctx)->buf) + +/* Ensuring (reserving) space. */ + +#define DUK_BW_ENSURE(thr,bw_ctx,sz) do { \ + duk_size_t duk__sz, duk__space; \ + DUK_BW_ASSERT_VALID((thr), (bw_ctx)); \ + duk__sz = (sz); \ + duk__space = (duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p); \ + if (duk__space < duk__sz) { \ + (void) duk_bw_resize((thr), (bw_ctx), duk__sz); \ + } \ + } while (0) +/* NOTE: Multiple evaluation of 'ptr' in this macro. */ +/* XXX: Rework to use an always-inline function? */ +#define DUK_BW_ENSURE_RAW(thr,bw_ctx,sz,ptr) \ + (((duk_size_t) ((bw_ctx)->p_limit - (ptr)) >= (sz)) ? \ + (ptr) : \ + ((bw_ctx)->p = (ptr), duk_bw_resize((thr),(bw_ctx),(sz)))) +#define DUK_BW_ENSURE_GETPTR(thr,bw_ctx,sz) \ + DUK_BW_ENSURE_RAW((thr), (bw_ctx), (sz), (bw_ctx)->p) +#define DUK_BW_ASSERT_SPACE_EXPR(thr,bw_ctx,sz) \ + (DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)), \ + DUK_ASSERT_EXPR((duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p) >= (duk_size_t) (sz))) +#define DUK_BW_ASSERT_SPACE(thr,bw_ctx,sz) do { \ + DUK_BW_ASSERT_SPACE_EXPR((thr), (bw_ctx), (sz)); \ + } while (0) + +/* Miscellaneous. */ + +#define DUK_BW_SETPTR_AND_COMPACT(thr,bw_ctx,ptr) do { \ + (bw_ctx)->p = (ptr); \ + duk_bw_compact((thr), (bw_ctx)); \ + } while (0) + +/* Fast write calls which assume you control the spare beforehand. + * Multibyte write variants exist and use a temporary write pointer + * because byte writes alias with anything: with a stored pointer + * explicit pointer load/stores get generated (e.g. gcc -Os). + */ + +#define DUK_BW_WRITE_RAW_U8(thr,bw_ctx,val) do { \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 1); \ + *(bw_ctx)->p++ = (duk_uint8_t) (val); \ + } while (0) +#define DUK_BW_WRITE_RAW_U8_2(thr,bw_ctx,val1,val2) do { \ + duk_uint8_t *duk__p; \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 2); \ + duk__p = (bw_ctx)->p; \ + *duk__p++ = (duk_uint8_t) (val1); \ + *duk__p++ = (duk_uint8_t) (val2); \ + (bw_ctx)->p = duk__p; \ + } while (0) +#define DUK_BW_WRITE_RAW_U8_3(thr,bw_ctx,val1,val2,val3) do { \ + duk_uint8_t *duk__p; \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 3); \ + duk__p = (bw_ctx)->p; \ + *duk__p++ = (duk_uint8_t) (val1); \ + *duk__p++ = (duk_uint8_t) (val2); \ + *duk__p++ = (duk_uint8_t) (val3); \ + (bw_ctx)->p = duk__p; \ + } while (0) +#define DUK_BW_WRITE_RAW_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \ + duk_uint8_t *duk__p; \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 4); \ + duk__p = (bw_ctx)->p; \ + *duk__p++ = (duk_uint8_t) (val1); \ + *duk__p++ = (duk_uint8_t) (val2); \ + *duk__p++ = (duk_uint8_t) (val3); \ + *duk__p++ = (duk_uint8_t) (val4); \ + (bw_ctx)->p = duk__p; \ + } while (0) +#define DUK_BW_WRITE_RAW_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \ + duk_uint8_t *duk__p; \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 5); \ + duk__p = (bw_ctx)->p; \ + *duk__p++ = (duk_uint8_t) (val1); \ + *duk__p++ = (duk_uint8_t) (val2); \ + *duk__p++ = (duk_uint8_t) (val3); \ + *duk__p++ = (duk_uint8_t) (val4); \ + *duk__p++ = (duk_uint8_t) (val5); \ + (bw_ctx)->p = duk__p; \ + } while (0) +#define DUK_BW_WRITE_RAW_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \ + duk_uint8_t *duk__p; \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 6); \ + duk__p = (bw_ctx)->p; \ + *duk__p++ = (duk_uint8_t) (val1); \ + *duk__p++ = (duk_uint8_t) (val2); \ + *duk__p++ = (duk_uint8_t) (val3); \ + *duk__p++ = (duk_uint8_t) (val4); \ + *duk__p++ = (duk_uint8_t) (val5); \ + *duk__p++ = (duk_uint8_t) (val6); \ + (bw_ctx)->p = duk__p; \ + } while (0) +#define DUK_BW_WRITE_RAW_XUTF8(thr,bw_ctx,cp) do { \ + duk_ucodepoint_t duk__cp; \ + duk_small_int_t duk__enc_len; \ + duk__cp = (cp); \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_xutf8_length(duk__cp)); \ + duk__enc_len = duk_unicode_encode_xutf8(duk__cp, (bw_ctx)->p); \ + (bw_ctx)->p += duk__enc_len; \ + } while (0) +#define DUK_BW_WRITE_RAW_CESU8(thr,bw_ctx,cp) do { \ + duk_ucodepoint_t duk__cp; \ + duk_small_int_t duk__enc_len; \ + duk__cp = (duk_ucodepoint_t) (cp); \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_cesu8_length(duk__cp)); \ + duk__enc_len = duk_unicode_encode_cesu8(duk__cp, (bw_ctx)->p); \ + (bw_ctx)->p += duk__enc_len; \ + } while (0) +/* XXX: add temporary duk__p pointer here too; sharing */ +#define DUK_BW_WRITE_RAW_BYTES(thr,bw_ctx,valptr,valsz) do { \ + const void *duk__valptr; \ + duk_size_t duk__valsz; \ + duk__valptr = (const void *) (valptr); \ + duk__valsz = (duk_size_t) (valsz); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \ + (bw_ctx)->p += duk__valsz; \ + } while (0) +#define DUK_BW_WRITE_RAW_CSTRING(thr,bw_ctx,val) do { \ + const duk_uint8_t *duk__val; \ + duk_size_t duk__val_len; \ + duk__val = (const duk_uint8_t *) (val); \ + duk__val_len = DUK_STRLEN((const char *) duk__val); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_RAW_HSTRING(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_RAW_HBUFFER(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_RAW_HBUFFER_FIXED(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) + +/* Append bytes from a slice already in the buffer. */ +#define DUK_BW_WRITE_RAW_SLICE(thr,bw,dst_off,dst_len) \ + duk_bw_write_raw_slice((thr), (bw), (dst_off), (dst_len)) + +/* Insert bytes in the middle of the buffer from an external buffer. */ +#define DUK_BW_INSERT_RAW_BYTES(thr,bw,dst_off,buf,len) \ + duk_bw_insert_raw_bytes((thr), (bw), (dst_off), (buf), (len)) + +/* Insert bytes in the middle of the buffer from a slice already + * in the buffer. Source offset is interpreted "before" the operation. + */ +#define DUK_BW_INSERT_RAW_SLICE(thr,bw,dst_off,src_off,len) \ + duk_bw_insert_raw_slice((thr), (bw), (dst_off), (src_off), (len)) + +/* Insert a reserved area somewhere in the buffer; caller fills it. + * Evaluates to a (duk_uint_t *) pointing to the start of the reserved + * area for convenience. + */ +#define DUK_BW_INSERT_RAW_AREA(thr,bw,off,len) \ + duk_bw_insert_raw_area((thr), (bw), (off), (len)) + +/* Remove a slice from inside buffer. */ +#define DUK_BW_REMOVE_RAW_SLICE(thr,bw,off,len) \ + duk_bw_remove_raw_slice((thr), (bw), (off), (len)) + +/* Safe write calls which will ensure space first. */ + +#define DUK_BW_WRITE_ENSURE_U8(thr,bw_ctx,val) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 1); \ + DUK_BW_WRITE_RAW_U8((thr), (bw_ctx), (val)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_U8_2(thr,bw_ctx,val1,val2) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 2); \ + DUK_BW_WRITE_RAW_U8_2((thr), (bw_ctx), (val1), (val2)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_U8_3(thr,bw_ctx,val1,val2,val3) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 3); \ + DUK_BW_WRITE_RAW_U8_3((thr), (bw_ctx), (val1), (val2), (val3)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 4); \ + DUK_BW_WRITE_RAW_U8_4((thr), (bw_ctx), (val1), (val2), (val3), (val4)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 5); \ + DUK_BW_WRITE_RAW_U8_5((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 6); \ + DUK_BW_WRITE_RAW_U8_6((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5), (val6)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_XUTF8(thr,bw_ctx,cp) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_XUTF8_LENGTH); \ + DUK_BW_WRITE_RAW_XUTF8((thr), (bw_ctx), (cp)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_CESU8(thr,bw_ctx,cp) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_CESU8_LENGTH); \ + DUK_BW_WRITE_RAW_CESU8((thr), (bw_ctx), (cp)); \ + } while (0) +/* XXX: add temporary duk__p pointer here too; sharing */ +#define DUK_BW_WRITE_ENSURE_BYTES(thr,bw_ctx,valptr,valsz) do { \ + const void *duk__valptr; \ + duk_size_t duk__valsz; \ + duk__valptr = (const void *) (valptr); \ + duk__valsz = (duk_size_t) (valsz); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__valsz); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \ + (bw_ctx)->p += duk__valsz; \ + } while (0) +#define DUK_BW_WRITE_ENSURE_CSTRING(thr,bw_ctx,val) do { \ + const duk_uint8_t *duk__val; \ + duk_size_t duk__val_len; \ + duk__val = (const duk_uint8_t *) (val); \ + duk__val_len = DUK_STRLEN((const char *) duk__val); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_ENSURE_HSTRING(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_ENSURE_HBUFFER(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) + +#define DUK_BW_WRITE_ENSURE_SLICE(thr,bw,dst_off,dst_len) \ + duk_bw_write_ensure_slice((thr), (bw), (dst_off), (dst_len)) +#define DUK_BW_INSERT_ENSURE_BYTES(thr,bw,dst_off,buf,len) \ + duk_bw_insert_ensure_bytes((thr), (bw), (dst_off), (buf), (len)) +#define DUK_BW_INSERT_ENSURE_SLICE(thr,bw,dst_off,src_off,len) \ + duk_bw_insert_ensure_slice((thr), (bw), (dst_off), (src_off), (len)) +#define DUK_BW_INSERT_ENSURE_AREA(thr,bw,off,len) \ + /* Evaluates to (duk_uint8_t *) pointing to start of area. */ \ + duk_bw_insert_ensure_area((thr), (bw), (off), (len)) +#define DUK_BW_REMOVE_ENSURE_SLICE(thr,bw,off,len) \ + /* No difference between raw/ensure because the buffer shrinks. */ \ + DUK_BW_REMOVE_RAW_SLICE((thr), (bw), (off), (len)) + +/* + * Externs and prototypes + */ + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL duk_uint8_t duk_lc_digits[36]; +DUK_INTERNAL_DECL duk_uint8_t duk_uc_nybbles[16]; +DUK_INTERNAL_DECL duk_int8_t duk_hex_dectab[256]; +#endif /* !DUK_SINGLE_FILE */ + +/* Note: assumes that duk_util_probe_steps size is 32 */ +#if defined(DUK_USE_HOBJECT_HASH_PART) || defined(DUK_USE_STRTAB_PROBE) +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL duk_uint8_t duk_util_probe_steps[32]; +#endif /* !DUK_SINGLE_FILE */ +#endif + +DUK_INTERNAL_DECL duk_uint32_t duk_util_hashbytes(const duk_uint8_t *data, duk_size_t len, duk_uint32_t seed); + +#if defined(DUK_USE_HOBJECT_HASH_PART) || defined(DUK_USE_STRTAB_PROBE) +DUK_INTERNAL_DECL duk_uint32_t duk_util_get_hash_prime(duk_uint32_t size); +#endif + +DUK_INTERNAL_DECL duk_int32_t duk_bd_decode(duk_bitdecoder_ctx *ctx, duk_small_int_t bits); +DUK_INTERNAL_DECL duk_small_int_t duk_bd_decode_flag(duk_bitdecoder_ctx *ctx); +DUK_INTERNAL_DECL duk_int32_t duk_bd_decode_flagged(duk_bitdecoder_ctx *ctx, duk_small_int_t bits, duk_int32_t def_value); + +DUK_INTERNAL_DECL void duk_be_encode(duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits); +DUK_INTERNAL_DECL void duk_be_finish(duk_bitencoder_ctx *ctx); + +DUK_INTERNAL_DECL duk_uint32_t duk_util_tinyrandom_get_bits(duk_hthread *thr, duk_small_int_t n); +DUK_INTERNAL_DECL duk_double_t duk_util_tinyrandom_get_double(duk_hthread *thr); + +DUK_INTERNAL_DECL void duk_bw_init(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_hbuffer_dynamic *h_buf); +DUK_INTERNAL_DECL void duk_bw_init_pushbuf(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t buf_size); +DUK_INTERNAL_DECL duk_uint8_t *duk_bw_resize(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz); +DUK_INTERNAL_DECL void duk_bw_compact(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx); +DUK_INTERNAL_DECL void duk_bw_write_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_write_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_insert_raw_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_insert_ensure_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_insert_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_insert_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len); +DUK_INTERNAL_DECL duk_uint8_t *duk_bw_insert_raw_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len); +DUK_INTERNAL_DECL duk_uint8_t *duk_bw_insert_ensure_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_remove_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len); +/* No duk_bw_remove_ensure_slice(), functionality would be identical. */ + +DUK_INTERNAL_DECL duk_uint16_t duk_raw_read_u16_be(duk_uint8_t **p); +DUK_INTERNAL_DECL duk_uint32_t duk_raw_read_u32_be(duk_uint8_t **p); +DUK_INTERNAL_DECL duk_double_t duk_raw_read_double_be(duk_uint8_t **p); +DUK_INTERNAL_DECL void duk_raw_write_u16_be(duk_uint8_t **p, duk_uint16_t val); +DUK_INTERNAL_DECL void duk_raw_write_u32_be(duk_uint8_t **p, duk_uint32_t val); +DUK_INTERNAL_DECL void duk_raw_write_double_be(duk_uint8_t **p, duk_double_t val); + +#if defined(DUK_USE_DEBUGGER_SUPPORT) /* For now only needed by the debugger. */ +DUK_INTERNAL void duk_byteswap_bytes(duk_uint8_t *p, duk_small_uint_t len); +#endif + +#endif /* DUK_UTIL_H_INCLUDED */ +#line 1 "duk_strings.h" +/* + * Shared error messages: declarations and macros + * + * Error messages are accessed through macros with fine-grained, explicit + * error message distinctions. Concrete error messages are selected by the + * macros and multiple macros can map to the same concrete string to save + * on code footprint. This allows flexible footprint/verbosity tuning with + * minimal code impact. There are a few limitations to this approach: + * (1) switching between plain messages and format strings doesn't work + * conveniently, and (2) conditional strings are a bit awkward to handle. + * + * Because format strings behave differently in the call site (they need to + * be followed by format arguments), they have a special prefix (DUK_STR_FMT_ + * and duk_str_fmt_). + * + * On some compilers using explicit shared strings is preferable; on others + * it may be better to use straight literals because the compiler will combine + * them anyway, and such strings won't end up unnecessarily in a symbol table. + */ + +#ifndef DUK_ERRMSG_H_INCLUDED +#define DUK_ERRMSG_H_INCLUDED + +#define DUK_STR_INTERNAL_ERROR duk_str_internal_error +#define DUK_STR_INVALID_COUNT duk_str_invalid_count +#define DUK_STR_INVALID_CALL_ARGS duk_str_invalid_call_args +#define DUK_STR_NOT_CONSTRUCTABLE duk_str_not_constructable +#define DUK_STR_NOT_CALLABLE duk_str_not_callable +#define DUK_STR_NOT_EXTENSIBLE duk_str_not_extensible +#define DUK_STR_NOT_WRITABLE duk_str_not_writable +#define DUK_STR_NOT_CONFIGURABLE duk_str_not_configurable + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const char *duk_str_internal_error; +DUK_INTERNAL_DECL const char *duk_str_invalid_count; +DUK_INTERNAL_DECL const char *duk_str_invalid_call_args; +DUK_INTERNAL_DECL const char *duk_str_not_constructable; +DUK_INTERNAL_DECL const char *duk_str_not_callable; +DUK_INTERNAL_DECL const char *duk_str_not_extensible; +DUK_INTERNAL_DECL const char *duk_str_not_writable; +DUK_INTERNAL_DECL const char *duk_str_not_configurable; +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_STR_INVALID_CONTEXT duk_str_invalid_context +#define DUK_STR_INVALID_INDEX duk_str_invalid_index +#define DUK_STR_PUSH_BEYOND_ALLOC_STACK duk_str_push_beyond_alloc_stack +#define DUK_STR_NOT_UNDEFINED duk_str_not_undefined +#define DUK_STR_NOT_NULL duk_str_not_null +#define DUK_STR_NOT_BOOLEAN duk_str_not_boolean +#define DUK_STR_NOT_NUMBER duk_str_not_number +#define DUK_STR_NOT_STRING duk_str_not_string +#define DUK_STR_NOT_POINTER duk_str_not_pointer +#define DUK_STR_NOT_BUFFER duk_str_not_buffer +#define DUK_STR_UNEXPECTED_TYPE duk_str_unexpected_type +#define DUK_STR_NOT_THREAD duk_str_not_thread +#define DUK_STR_NOT_COMPILEDFUNCTION duk_str_not_compiledfunction +#define DUK_STR_NOT_NATIVEFUNCTION duk_str_not_nativefunction +#define DUK_STR_NOT_C_FUNCTION duk_str_not_c_function +#define DUK_STR_DEFAULTVALUE_COERCE_FAILED duk_str_defaultvalue_coerce_failed +#define DUK_STR_NUMBER_OUTSIDE_RANGE duk_str_number_outside_range +#define DUK_STR_NOT_OBJECT_COERCIBLE duk_str_not_object_coercible +#define DUK_STR_STRING_TOO_LONG duk_str_string_too_long +#define DUK_STR_BUFFER_TOO_LONG duk_str_buffer_too_long +#define DUK_STR_SPRINTF_TOO_LONG duk_str_sprintf_too_long +#define DUK_STR_ALLOC_FAILED duk_str_alloc_failed +#define DUK_STR_POP_TOO_MANY duk_str_pop_too_many +#define DUK_STR_WRONG_BUFFER_TYPE duk_str_wrong_buffer_type +#define DUK_STR_FAILED_TO_EXTEND_VALSTACK duk_str_failed_to_extend_valstack +#define DUK_STR_ENCODE_FAILED duk_str_encode_failed +#define DUK_STR_DECODE_FAILED duk_str_decode_failed +#define DUK_STR_NO_SOURCECODE duk_str_no_sourcecode +#define DUK_STR_CONCAT_RESULT_TOO_LONG duk_str_concat_result_too_long +#define DUK_STR_UNIMPLEMENTED duk_str_unimplemented +#define DUK_STR_UNSUPPORTED duk_str_unsupported +#define DUK_STR_ARRAY_LENGTH_OVER_2G duk_str_array_length_over_2g + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const char *duk_str_invalid_context; +DUK_INTERNAL_DECL const char *duk_str_invalid_index; +DUK_INTERNAL_DECL const char *duk_str_push_beyond_alloc_stack; +DUK_INTERNAL_DECL const char *duk_str_not_undefined; +DUK_INTERNAL_DECL const char *duk_str_not_null; +DUK_INTERNAL_DECL const char *duk_str_not_boolean; +DUK_INTERNAL_DECL const char *duk_str_not_number; +DUK_INTERNAL_DECL const char *duk_str_not_string; +DUK_INTERNAL_DECL const char *duk_str_not_pointer; +DUK_INTERNAL_DECL const char *duk_str_not_buffer; +DUK_INTERNAL_DECL const char *duk_str_unexpected_type; +DUK_INTERNAL_DECL const char *duk_str_not_thread; +DUK_INTERNAL_DECL const char *duk_str_not_compiledfunction; +DUK_INTERNAL_DECL const char *duk_str_not_nativefunction; +DUK_INTERNAL_DECL const char *duk_str_not_c_function; +DUK_INTERNAL_DECL const char *duk_str_defaultvalue_coerce_failed; +DUK_INTERNAL_DECL const char *duk_str_number_outside_range; +DUK_INTERNAL_DECL const char *duk_str_not_object_coercible; +DUK_INTERNAL_DECL const char *duk_str_string_too_long; +DUK_INTERNAL_DECL const char *duk_str_buffer_too_long; +DUK_INTERNAL_DECL const char *duk_str_sprintf_too_long; +DUK_INTERNAL_DECL const char *duk_str_alloc_failed; +DUK_INTERNAL_DECL const char *duk_str_pop_too_many; +DUK_INTERNAL_DECL const char *duk_str_wrong_buffer_type; +DUK_INTERNAL_DECL const char *duk_str_failed_to_extend_valstack; +DUK_INTERNAL_DECL const char *duk_str_encode_failed; +DUK_INTERNAL_DECL const char *duk_str_decode_failed; +DUK_INTERNAL_DECL const char *duk_str_no_sourcecode; +DUK_INTERNAL_DECL const char *duk_str_concat_result_too_long; +DUK_INTERNAL_DECL const char *duk_str_unimplemented; +DUK_INTERNAL_DECL const char *duk_str_unsupported; +DUK_INTERNAL_DECL const char *duk_str_array_length_over_2g; +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_STR_FMT_PTR duk_str_fmt_ptr +#define DUK_STR_FMT_INVALID_JSON duk_str_fmt_invalid_json +#define DUK_STR_JSONDEC_RECLIMIT duk_str_jsondec_reclimit +#define DUK_STR_JSONENC_RECLIMIT duk_str_jsonenc_reclimit +#define DUK_STR_CYCLIC_INPUT duk_str_cyclic_input + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const char *duk_str_fmt_ptr; +DUK_INTERNAL_DECL const char *duk_str_fmt_invalid_json; +DUK_INTERNAL_DECL const char *duk_str_jsondec_reclimit; +DUK_INTERNAL_DECL const char *duk_str_jsonenc_reclimit; +DUK_INTERNAL_DECL const char *duk_str_cyclic_input; +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_STR_PROXY_REVOKED duk_str_proxy_revoked +#define DUK_STR_OBJECT_RESIZE_FAILED duk_str_object_resize_failed +#define DUK_STR_INVALID_BASE duk_str_invalid_base +#define DUK_STR_STRICT_CALLER_READ duk_str_strict_caller_read +#define DUK_STR_PROXY_REJECTED duk_str_proxy_rejected +#define DUK_STR_INVALID_ARRAY_LENGTH duk_str_invalid_array_length +#define DUK_STR_ARRAY_LENGTH_WRITE_FAILED duk_str_array_length_write_failed +#define DUK_STR_ARRAY_LENGTH_NOT_WRITABLE duk_str_array_length_not_writable +#define DUK_STR_SETTER_UNDEFINED duk_str_setter_undefined +#define DUK_STR_REDEFINE_VIRT_PROP duk_str_redefine_virt_prop +#define DUK_STR_INVALID_DESCRIPTOR duk_str_invalid_descriptor +#define DUK_STR_PROPERTY_IS_VIRTUAL duk_str_property_is_virtual + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const char *duk_str_proxy_revoked; +DUK_INTERNAL_DECL const char *duk_str_object_resize_failed; +DUK_INTERNAL_DECL const char *duk_str_invalid_base; +DUK_INTERNAL_DECL const char *duk_str_strict_caller_read; +DUK_INTERNAL_DECL const char *duk_str_proxy_rejected; +DUK_INTERNAL_DECL const char *duk_str_invalid_array_length; +DUK_INTERNAL_DECL const char *duk_str_array_length_write_failed; +DUK_INTERNAL_DECL const char *duk_str_array_length_not_writable; +DUK_INTERNAL_DECL const char *duk_str_setter_undefined; +DUK_INTERNAL_DECL const char *duk_str_redefine_virt_prop; +DUK_INTERNAL_DECL const char *duk_str_invalid_descriptor; +DUK_INTERNAL_DECL const char *duk_str_property_is_virtual; +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_STR_PARSE_ERROR duk_str_parse_error +#define DUK_STR_DUPLICATE_LABEL duk_str_duplicate_label +#define DUK_STR_INVALID_LABEL duk_str_invalid_label +#define DUK_STR_INVALID_ARRAY_LITERAL duk_str_invalid_array_literal +#define DUK_STR_INVALID_OBJECT_LITERAL duk_str_invalid_object_literal +#define DUK_STR_INVALID_VAR_DECLARATION duk_str_invalid_var_declaration +#define DUK_STR_CANNOT_DELETE_IDENTIFIER duk_str_cannot_delete_identifier +#define DUK_STR_INVALID_EXPRESSION duk_str_invalid_expression +#define DUK_STR_INVALID_LVALUE duk_str_invalid_lvalue +#define DUK_STR_EXPECTED_IDENTIFIER duk_str_expected_identifier +#define DUK_STR_EMPTY_EXPR_NOT_ALLOWED duk_str_empty_expr_not_allowed +#define DUK_STR_INVALID_FOR duk_str_invalid_for +#define DUK_STR_INVALID_SWITCH duk_str_invalid_switch +#define DUK_STR_INVALID_BREAK_CONT_LABEL duk_str_invalid_break_cont_label +#define DUK_STR_INVALID_RETURN duk_str_invalid_return +#define DUK_STR_INVALID_TRY duk_str_invalid_try +#define DUK_STR_INVALID_THROW duk_str_invalid_throw +#define DUK_STR_WITH_IN_STRICT_MODE duk_str_with_in_strict_mode +#define DUK_STR_FUNC_STMT_NOT_ALLOWED duk_str_func_stmt_not_allowed +#define DUK_STR_UNTERMINATED_STMT duk_str_unterminated_stmt +#define DUK_STR_INVALID_ARG_NAME duk_str_invalid_arg_name +#define DUK_STR_INVALID_FUNC_NAME duk_str_invalid_func_name +#define DUK_STR_INVALID_GETSET_NAME duk_str_invalid_getset_name +#define DUK_STR_FUNC_NAME_REQUIRED duk_str_func_name_required + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const char *duk_str_parse_error; +DUK_INTERNAL_DECL const char *duk_str_duplicate_label; +DUK_INTERNAL_DECL const char *duk_str_invalid_label; +DUK_INTERNAL_DECL const char *duk_str_invalid_array_literal; +DUK_INTERNAL_DECL const char *duk_str_invalid_object_literal; +DUK_INTERNAL_DECL const char *duk_str_invalid_var_declaration; +DUK_INTERNAL_DECL const char *duk_str_cannot_delete_identifier; +DUK_INTERNAL_DECL const char *duk_str_invalid_expression; +DUK_INTERNAL_DECL const char *duk_str_invalid_lvalue; +DUK_INTERNAL_DECL const char *duk_str_expected_identifier; +DUK_INTERNAL_DECL const char *duk_str_empty_expr_not_allowed; +DUK_INTERNAL_DECL const char *duk_str_invalid_for; +DUK_INTERNAL_DECL const char *duk_str_invalid_switch; +DUK_INTERNAL_DECL const char *duk_str_invalid_break_cont_label; +DUK_INTERNAL_DECL const char *duk_str_invalid_return; +DUK_INTERNAL_DECL const char *duk_str_invalid_try; +DUK_INTERNAL_DECL const char *duk_str_invalid_throw; +DUK_INTERNAL_DECL const char *duk_str_with_in_strict_mode; +DUK_INTERNAL_DECL const char *duk_str_func_stmt_not_allowed; +DUK_INTERNAL_DECL const char *duk_str_unterminated_stmt; +DUK_INTERNAL_DECL const char *duk_str_invalid_arg_name; +DUK_INTERNAL_DECL const char *duk_str_invalid_func_name; +DUK_INTERNAL_DECL const char *duk_str_invalid_getset_name; +DUK_INTERNAL_DECL const char *duk_str_func_name_required; +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_STR_INTERNAL_ERROR_EXEC_LONGJMP duk_str_internal_error_exec_longjmp + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const char *duk_str_internal_error_exec_longjmp; +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_STR_INVALID_QUANTIFIER_NO_ATOM duk_str_invalid_quantifier_no_atom +#define DUK_STR_INVALID_QUANTIFIER_VALUES duk_str_invalid_quantifier_values +#define DUK_STR_QUANTIFIER_TOO_MANY_COPIES duk_str_quantifier_too_many_copies +#define DUK_STR_UNEXPECTED_CLOSING_PAREN duk_str_unexpected_closing_paren +#define DUK_STR_UNEXPECTED_END_OF_PATTERN duk_str_unexpected_end_of_pattern +#define DUK_STR_UNEXPECTED_REGEXP_TOKEN duk_str_unexpected_regexp_token +#define DUK_STR_INVALID_REGEXP_FLAGS duk_str_invalid_regexp_flags +#define DUK_STR_INVALID_BACKREFS duk_str_invalid_backrefs +#define DUK_STR_REGEXP_BACKTRACK_FAILED duk_str_regexp_backtrack_failed +#define DUK_STR_REGEXP_ADVANCE_FAILED duk_str_regexp_advance_failed +#define DUK_STR_REGEXP_INTERNAL_ERROR duk_str_regexp_internal_error + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const char *duk_str_invalid_quantifier_no_atom; +DUK_INTERNAL_DECL const char *duk_str_invalid_quantifier_values; +DUK_INTERNAL_DECL const char *duk_str_quantifier_too_many_copies; +DUK_INTERNAL_DECL const char *duk_str_unexpected_closing_paren; +DUK_INTERNAL_DECL const char *duk_str_unexpected_end_of_pattern; +DUK_INTERNAL_DECL const char *duk_str_unexpected_regexp_token; +DUK_INTERNAL_DECL const char *duk_str_invalid_regexp_flags; +DUK_INTERNAL_DECL const char *duk_str_invalid_backrefs; +DUK_INTERNAL_DECL const char *duk_str_regexp_backtrack_failed; +DUK_INTERNAL_DECL const char *duk_str_regexp_advance_failed; +DUK_INTERNAL_DECL const char *duk_str_regexp_internal_error; +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_STR_VALSTACK_LIMIT duk_str_valstack_limit +#define DUK_STR_CALLSTACK_LIMIT duk_str_callstack_limit +#define DUK_STR_CATCHSTACK_LIMIT duk_str_catchstack_limit +#define DUK_STR_OBJECT_PROPERTY_LIMIT duk_str_object_property_limit +#define DUK_STR_PROTOTYPE_CHAIN_LIMIT duk_str_prototype_chain_limit +#define DUK_STR_BOUND_CHAIN_LIMIT duk_str_bound_chain_limit +#define DUK_STR_C_CALLSTACK_LIMIT duk_str_c_callstack_limit +#define DUK_STR_COMPILER_RECURSION_LIMIT duk_str_compiler_recursion_limit +#define DUK_STR_BYTECODE_LIMIT duk_str_bytecode_limit +#define DUK_STR_REG_LIMIT duk_str_reg_limit +#define DUK_STR_TEMP_LIMIT duk_str_temp_limit +#define DUK_STR_CONST_LIMIT duk_str_const_limit +#define DUK_STR_FUNC_LIMIT duk_str_func_limit +#define DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT duk_str_regexp_compiler_recursion_limit +#define DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT duk_str_regexp_executor_recursion_limit +#define DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT duk_str_regexp_executor_step_limit + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const char *duk_str_valstack_limit; +DUK_INTERNAL_DECL const char *duk_str_callstack_limit; +DUK_INTERNAL_DECL const char *duk_str_catchstack_limit; +DUK_INTERNAL_DECL const char *duk_str_object_property_limit; +DUK_INTERNAL_DECL const char *duk_str_prototype_chain_limit; +DUK_INTERNAL_DECL const char *duk_str_bound_chain_limit; +DUK_INTERNAL_DECL const char *duk_str_c_callstack_limit; +DUK_INTERNAL_DECL const char *duk_str_compiler_recursion_limit; +DUK_INTERNAL_DECL const char *duk_str_bytecode_limit; +DUK_INTERNAL_DECL const char *duk_str_reg_limit; +DUK_INTERNAL_DECL const char *duk_str_temp_limit; +DUK_INTERNAL_DECL const char *duk_str_const_limit; +DUK_INTERNAL_DECL const char *duk_str_func_limit; +DUK_INTERNAL_DECL const char *duk_str_regexp_compiler_recursion_limit; +DUK_INTERNAL_DECL const char *duk_str_regexp_executor_recursion_limit; +DUK_INTERNAL_DECL const char *duk_str_regexp_executor_step_limit; +#endif /* !DUK_SINGLE_FILE */ + +#define DUK_STR_ANON duk_str_anon +#define DUK_STR_REALLOC_FAILED duk_str_realloc_failed + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const char *duk_str_anon; +DUK_INTERNAL_DECL const char *duk_str_realloc_failed; +#endif /* !DUK_SINGLE_FILE */ + +#endif /* DUK_ERRMSG_H_INCLUDED */ +#line 1 "duk_js_bytecode.h" +/* + * Ecmascript bytecode + */ + +#ifndef DUK_JS_BYTECODE_H_INCLUDED +#define DUK_JS_BYTECODE_H_INCLUDED + +/* + * Logical instruction layout + * ========================== + * + * !3!3!2!2!2!2!2!2!2!2!2!2!1!1!1!1!1!1!1!1!1!1! ! ! ! ! ! ! ! ! ! ! + * !1!0!9!8!7!6!5!4!3!2!1!0!9!8!7!6!5!4!3!2!1!0!9!8!7!6!5!4!3!2!1!0! + * +---------------------------------------------------+-----------+ + * ! C ! B ! A ! OP ! + * +---------------------------------------------------+-----------+ + * + * OP (6 bits): opcode (DUK_OP_*), access should be fastest + * A (8 bits): typically a target register number + * B (9 bits): typically first source register/constant number + * C (9 bits): typically second source register/constant number + * + * Some instructions combine BC or ABC together for larger parameter values. + * Signed integers (e.g. jump offsets) are encoded as unsigned, with an opcode + * specific bias. B and C may denote a register or a constant, see + * DUK_BC_ISREG() and DUK_BC_ISCONST(). + * + * Note: macro naming is a bit misleading, e.g. "ABC" in macro name but + * the field layout is logically "CBA". + */ + +typedef duk_uint32_t duk_instr_t; + +#define DUK_DEC_OP(x) ((x) & 0x3fUL) +#define DUK_DEC_A(x) (((x) >> 6) & 0xffUL) +#define DUK_DEC_B(x) (((x) >> 14) & 0x1ffUL) +#define DUK_DEC_C(x) (((x) >> 23) & 0x1ffUL) +#define DUK_DEC_BC(x) (((x) >> 14) & 0x3ffffUL) +#define DUK_DEC_ABC(x) (((x) >> 6) & 0x3ffffffUL) + +#define DUK_ENC_OP(op) ((duk_instr_t) (op)) +#define DUK_ENC_OP_ABC(op,abc) ((duk_instr_t) ( \ + (((duk_instr_t) (abc)) << 6) | \ + ((duk_instr_t) (op)) \ + )) +#define DUK_ENC_OP_A_BC(op,a,bc) ((duk_instr_t) ( \ + (((duk_instr_t) (bc)) << 14) | \ + (((duk_instr_t) (a)) << 6) | \ + ((duk_instr_t) (op)) \ + )) +#define DUK_ENC_OP_A_B_C(op,a,b,c) ((duk_instr_t) ( \ + (((duk_instr_t) (c)) << 23) | \ + (((duk_instr_t) (b)) << 14) | \ + (((duk_instr_t) (a)) << 6) | \ + ((duk_instr_t) (op)) \ + )) +#define DUK_ENC_OP_A_B(op,a,b) DUK_ENC_OP_A_B_C(op,a,b,0) +#define DUK_ENC_OP_A(op,a) DUK_ENC_OP_A_B_C(op,a,0,0) + +/* Constants should be signed so that signed arithmetic involving them + * won't cause values to be coerced accidentally to unsigned. + */ +#define DUK_BC_OP_MIN 0 +#define DUK_BC_OP_MAX 0x3fL +#define DUK_BC_A_MIN 0 +#define DUK_BC_A_MAX 0xffL +#define DUK_BC_B_MIN 0 +#define DUK_BC_B_MAX 0x1ffL +#define DUK_BC_C_MIN 0 +#define DUK_BC_C_MAX 0x1ffL +#define DUK_BC_BC_MIN 0 +#define DUK_BC_BC_MAX 0x3ffffL +#define DUK_BC_ABC_MIN 0 +#define DUK_BC_ABC_MAX 0x3ffffffL +#define DUK_BC_EXTRAOP_MIN DUK_BC_A_MIN +#define DUK_BC_EXTRAOP_MAX DUK_BC_A_MAX + +#define DUK_OP_LDREG 0 +#define DUK_OP_STREG 1 +#define DUK_OP_LDCONST 2 +#define DUK_OP_LDINT 3 +#define DUK_OP_LDINTX 4 +#define DUK_OP_MPUTOBJ 5 +#define DUK_OP_MPUTOBJI 6 +#define DUK_OP_MPUTARR 7 +#define DUK_OP_MPUTARRI 8 +#define DUK_OP_NEW 9 +#define DUK_OP_NEWI 10 +#define DUK_OP_REGEXP 11 +#define DUK_OP_CSREG 12 +#define DUK_OP_CSREGI 13 +#define DUK_OP_GETVAR 14 +#define DUK_OP_PUTVAR 15 +#define DUK_OP_DECLVAR 16 +#define DUK_OP_DELVAR 17 +#define DUK_OP_CSVAR 18 +#define DUK_OP_CSVARI 19 +#define DUK_OP_CLOSURE 20 +#define DUK_OP_GETPROP 21 +#define DUK_OP_PUTPROP 22 +#define DUK_OP_DELPROP 23 +#define DUK_OP_CSPROP 24 +#define DUK_OP_CSPROPI 25 +#define DUK_OP_ADD 26 +#define DUK_OP_SUB 27 +#define DUK_OP_MUL 28 +#define DUK_OP_DIV 29 +#define DUK_OP_MOD 30 +#define DUK_OP_BAND 31 +#define DUK_OP_BOR 32 +#define DUK_OP_BXOR 33 +#define DUK_OP_BASL 34 +#define DUK_OP_BLSR 35 +#define DUK_OP_BASR 36 +#define DUK_OP_EQ 37 +#define DUK_OP_NEQ 38 +#define DUK_OP_SEQ 39 +#define DUK_OP_SNEQ 40 +#define DUK_OP_GT 41 +#define DUK_OP_GE 42 +#define DUK_OP_LT 43 +#define DUK_OP_LE 44 +#define DUK_OP_IF 45 +#define DUK_OP_JUMP 46 +#define DUK_OP_RETURN 47 +#define DUK_OP_CALL 48 +#define DUK_OP_CALLI 49 +#define DUK_OP_TRYCATCH 50 +#define DUK_OP_EXTRA 51 +#define DUK_OP_PREINCR 52 /* pre/post opcode values have constraints, */ +#define DUK_OP_PREDECR 53 /* see duk_js_executor.c */ +#define DUK_OP_POSTINCR 54 +#define DUK_OP_POSTDECR 55 +#define DUK_OP_PREINCV 56 +#define DUK_OP_PREDECV 57 +#define DUK_OP_POSTINCV 58 +#define DUK_OP_POSTDECV 59 +#define DUK_OP_PREINCP 60 +#define DUK_OP_PREDECP 61 +#define DUK_OP_POSTINCP 62 +#define DUK_OP_POSTDECP 63 +#define DUK_OP_NONE 64 /* dummy value used as marker */ + +/* DUK_OP_EXTRA, sub-operation in A */ +#define DUK_EXTRAOP_NOP 0 +#define DUK_EXTRAOP_INVALID 1 +#define DUK_EXTRAOP_LDTHIS 2 +#define DUK_EXTRAOP_LDUNDEF 3 +#define DUK_EXTRAOP_LDNULL 4 +#define DUK_EXTRAOP_LDTRUE 5 +#define DUK_EXTRAOP_LDFALSE 6 +#define DUK_EXTRAOP_NEWOBJ 7 +#define DUK_EXTRAOP_NEWARR 8 +#define DUK_EXTRAOP_SETALEN 9 +#define DUK_EXTRAOP_TYPEOF 10 +#define DUK_EXTRAOP_TYPEOFID 11 +#define DUK_EXTRAOP_INITENUM 12 +#define DUK_EXTRAOP_NEXTENUM 13 +#define DUK_EXTRAOP_INITSET 14 +#define DUK_EXTRAOP_INITSETI 15 +#define DUK_EXTRAOP_INITGET 16 +#define DUK_EXTRAOP_INITGETI 17 +#define DUK_EXTRAOP_ENDTRY 18 +#define DUK_EXTRAOP_ENDCATCH 19 +#define DUK_EXTRAOP_ENDFIN 20 +#define DUK_EXTRAOP_THROW 21 +#define DUK_EXTRAOP_INVLHS 22 +#define DUK_EXTRAOP_UNM 23 +#define DUK_EXTRAOP_UNP 24 +#define DUK_EXTRAOP_DEBUGGER 25 +#define DUK_EXTRAOP_BREAK 26 +#define DUK_EXTRAOP_CONTINUE 27 +#define DUK_EXTRAOP_BNOT 28 +#define DUK_EXTRAOP_LNOT 29 +#define DUK_EXTRAOP_INSTOF 30 +#define DUK_EXTRAOP_IN 31 +#define DUK_EXTRAOP_LABEL 32 +#define DUK_EXTRAOP_ENDLABEL 33 + +/* DUK_OP_CALL flags in A */ +#define DUK_BC_CALL_FLAG_TAILCALL (1 << 0) +#define DUK_BC_CALL_FLAG_EVALCALL (1 << 1) + +/* DUK_OP_TRYCATCH flags in A */ +#define DUK_BC_TRYCATCH_FLAG_HAVE_CATCH (1 << 0) +#define DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY (1 << 1) +#define DUK_BC_TRYCATCH_FLAG_CATCH_BINDING (1 << 2) +#define DUK_BC_TRYCATCH_FLAG_WITH_BINDING (1 << 3) + +/* DUK_OP_RETURN flags in A */ +#define DUK_BC_RETURN_FLAG_FAST (1 << 0) +#define DUK_BC_RETURN_FLAG_HAVE_RETVAL (1 << 1) + +/* DUK_OP_DECLVAR flags in A; bottom bits are reserved for propdesc flags (DUK_PROPDESC_FLAG_XXX) */ +#define DUK_BC_DECLVAR_FLAG_UNDEF_VALUE (1 << 4) /* use 'undefined' for value automatically */ +#define DUK_BC_DECLVAR_FLAG_FUNC_DECL (1 << 5) /* function declaration */ + +/* misc constants and helper macros */ +#define DUK_BC_REGLIMIT 256 /* if B/C is >= this value, refers to a const */ +#define DUK_BC_ISREG(x) ((x) < DUK_BC_REGLIMIT) +#define DUK_BC_ISCONST(x) ((x) >= DUK_BC_REGLIMIT) +#define DUK_BC_LDINT_BIAS (1L << 17) +#define DUK_BC_LDINTX_SHIFT 18 +#define DUK_BC_JUMP_BIAS (1L << 25) + +#endif /* DUK_JS_BYTECODE_H_INCLUDED */ +#line 1 "duk_lexer.h" +/* + * Lexer defines. + */ + +#ifndef DUK_LEXER_H_INCLUDED +#define DUK_LEXER_H_INCLUDED + +typedef void (*duk_re_range_callback)(void *user, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct); + +/* + * A token is interpreted as any possible production of InputElementDiv + * and InputElementRegExp, see E5 Section 7 in its entirety. Note that + * the E5 "Token" production does not cover all actual tokens of the + * language (which is explicitly stated in the specification, Section 7.5). + * Null and boolean literals are defined as part of both ReservedWord + * (E5 Section 7.6.1) and Literal (E5 Section 7.8) productions. Here, + * null and boolean values have literal tokens, and are not reserved + * words. + * + * Decimal literal negative/positive sign is -not- part of DUK_TOK_NUMBER. + * The number tokens always have a non-negative value. The unary minus + * operator in "-1.0" is optimized during compilation to yield a single + * negative constant. + * + * Token numbering is free except that reserved words are required to be + * in a continuous range and in a particular order. See genstrings.py. + */ + +#define DUK_LEXER_INITCTX(ctx) duk_lexer_initctx((ctx)) + +#define DUK_LEXER_SETPOINT(ctx,pt) duk_lexer_setpoint((ctx), (pt)) + +#define DUK_LEXER_GETPOINT(ctx,pt) do { (pt)->offset = (ctx)->window[0].offset; \ + (pt)->line = (ctx)->window[0].line; } while (0) + +/* currently 6 characters of lookup are actually needed (duk_lexer.c) */ +#define DUK_LEXER_WINDOW_SIZE 6 +#if defined(DUK_USE_LEXER_SLIDING_WINDOW) +#define DUK_LEXER_BUFFER_SIZE 64 +#endif + +#define DUK_TOK_MINVAL 0 + +/* returned after EOF (infinite amount) */ +#define DUK_TOK_EOF 0 + +/* identifier names (E5 Section 7.6) */ +#define DUK_TOK_IDENTIFIER 1 + +/* reserved words: keywords */ +#define DUK_TOK_START_RESERVED 2 +#define DUK_TOK_BREAK 2 +#define DUK_TOK_CASE 3 +#define DUK_TOK_CATCH 4 +#define DUK_TOK_CONTINUE 5 +#define DUK_TOK_DEBUGGER 6 +#define DUK_TOK_DEFAULT 7 +#define DUK_TOK_DELETE 8 +#define DUK_TOK_DO 9 +#define DUK_TOK_ELSE 10 +#define DUK_TOK_FINALLY 11 +#define DUK_TOK_FOR 12 +#define DUK_TOK_FUNCTION 13 +#define DUK_TOK_IF 14 +#define DUK_TOK_IN 15 +#define DUK_TOK_INSTANCEOF 16 +#define DUK_TOK_NEW 17 +#define DUK_TOK_RETURN 18 +#define DUK_TOK_SWITCH 19 +#define DUK_TOK_THIS 20 +#define DUK_TOK_THROW 21 +#define DUK_TOK_TRY 22 +#define DUK_TOK_TYPEOF 23 +#define DUK_TOK_VAR 24 +#define DUK_TOK_VOID 25 +#define DUK_TOK_WHILE 26 +#define DUK_TOK_WITH 27 + +/* reserved words: future reserved words */ +#define DUK_TOK_CLASS 28 +#define DUK_TOK_CONST 29 +#define DUK_TOK_ENUM 30 +#define DUK_TOK_EXPORT 31 +#define DUK_TOK_EXTENDS 32 +#define DUK_TOK_IMPORT 33 +#define DUK_TOK_SUPER 34 + +/* "null", "true", and "false" are always reserved words. + * Note that "get" and "set" are not! + */ +#define DUK_TOK_NULL 35 +#define DUK_TOK_TRUE 36 +#define DUK_TOK_FALSE 37 + +/* reserved words: additional future reserved words in strict mode */ +#define DUK_TOK_START_STRICT_RESERVED 38 /* inclusive */ +#define DUK_TOK_IMPLEMENTS 38 +#define DUK_TOK_INTERFACE 39 +#define DUK_TOK_LET 40 +#define DUK_TOK_PACKAGE 41 +#define DUK_TOK_PRIVATE 42 +#define DUK_TOK_PROTECTED 43 +#define DUK_TOK_PUBLIC 44 +#define DUK_TOK_STATIC 45 +#define DUK_TOK_YIELD 46 + +#define DUK_TOK_END_RESERVED 47 /* exclusive */ + +/* "get" and "set" are tokens but NOT ReservedWords. They are currently + * parsed and identifiers and these defines are actually now unused. + */ +#define DUK_TOK_GET 47 +#define DUK_TOK_SET 48 + +/* punctuators (unlike the spec, also includes "/" and "/=") */ +#define DUK_TOK_LCURLY 49 +#define DUK_TOK_RCURLY 50 +#define DUK_TOK_LBRACKET 51 +#define DUK_TOK_RBRACKET 52 +#define DUK_TOK_LPAREN 53 +#define DUK_TOK_RPAREN 54 +#define DUK_TOK_PERIOD 55 +#define DUK_TOK_SEMICOLON 56 +#define DUK_TOK_COMMA 57 +#define DUK_TOK_LT 58 +#define DUK_TOK_GT 59 +#define DUK_TOK_LE 60 +#define DUK_TOK_GE 61 +#define DUK_TOK_EQ 62 +#define DUK_TOK_NEQ 63 +#define DUK_TOK_SEQ 64 +#define DUK_TOK_SNEQ 65 +#define DUK_TOK_ADD 66 +#define DUK_TOK_SUB 67 +#define DUK_TOK_MUL 68 +#define DUK_TOK_DIV 69 +#define DUK_TOK_MOD 70 +#define DUK_TOK_INCREMENT 71 +#define DUK_TOK_DECREMENT 72 +#define DUK_TOK_ALSHIFT 73 /* named "arithmetic" because result is signed */ +#define DUK_TOK_ARSHIFT 74 +#define DUK_TOK_RSHIFT 75 +#define DUK_TOK_BAND 76 +#define DUK_TOK_BOR 77 +#define DUK_TOK_BXOR 78 +#define DUK_TOK_LNOT 79 +#define DUK_TOK_BNOT 80 +#define DUK_TOK_LAND 81 +#define DUK_TOK_LOR 82 +#define DUK_TOK_QUESTION 83 +#define DUK_TOK_COLON 84 +#define DUK_TOK_EQUALSIGN 85 +#define DUK_TOK_ADD_EQ 86 +#define DUK_TOK_SUB_EQ 87 +#define DUK_TOK_MUL_EQ 88 +#define DUK_TOK_DIV_EQ 89 +#define DUK_TOK_MOD_EQ 90 +#define DUK_TOK_ALSHIFT_EQ 91 +#define DUK_TOK_ARSHIFT_EQ 92 +#define DUK_TOK_RSHIFT_EQ 93 +#define DUK_TOK_BAND_EQ 94 +#define DUK_TOK_BOR_EQ 95 +#define DUK_TOK_BXOR_EQ 96 + +/* literals (E5 Section 7.8), except null, true, false, which are treated + * like reserved words (above). + */ +#define DUK_TOK_NUMBER 97 +#define DUK_TOK_STRING 98 +#define DUK_TOK_REGEXP 99 + +#define DUK_TOK_MAXVAL 99 /* inclusive */ + +/* Convert heap string index to a token (reserved words) */ +#define DUK_STRIDX_TO_TOK(x) ((x) - DUK_STRIDX_START_RESERVED + DUK_TOK_START_RESERVED) + +/* Sanity check */ +#if (DUK_TOK_MAXVAL > 255) +#error DUK_TOK_MAXVAL too large, code assumes it fits into 8 bits +#endif + +/* Sanity checks for string and token defines */ +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_BREAK) != DUK_TOK_BREAK) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CASE) != DUK_TOK_CASE) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CATCH) != DUK_TOK_CATCH) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CONTINUE) != DUK_TOK_CONTINUE) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DEBUGGER) != DUK_TOK_DEBUGGER) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DEFAULT) != DUK_TOK_DEFAULT) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DELETE) != DUK_TOK_DELETE) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DO) != DUK_TOK_DO) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_ELSE) != DUK_TOK_ELSE) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_FINALLY) != DUK_TOK_FINALLY) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_FOR) != DUK_TOK_FOR) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_LC_FUNCTION) != DUK_TOK_FUNCTION) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IF) != DUK_TOK_IF) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IN) != DUK_TOK_IN) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_INSTANCEOF) != DUK_TOK_INSTANCEOF) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_NEW) != DUK_TOK_NEW) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_RETURN) != DUK_TOK_RETURN) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_SWITCH) != DUK_TOK_SWITCH) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_THIS) != DUK_TOK_THIS) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_THROW) != DUK_TOK_THROW) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_TRY) != DUK_TOK_TRY) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_TYPEOF) != DUK_TOK_TYPEOF) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_VAR) != DUK_TOK_VAR) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_VOID) != DUK_TOK_VOID) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_WHILE) != DUK_TOK_WHILE) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_WITH) != DUK_TOK_WITH) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CLASS) != DUK_TOK_CLASS) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CONST) != DUK_TOK_CONST) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_ENUM) != DUK_TOK_ENUM) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_EXPORT) != DUK_TOK_EXPORT) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_EXTENDS) != DUK_TOK_EXTENDS) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IMPORT) != DUK_TOK_IMPORT) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_SUPER) != DUK_TOK_SUPER) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_LC_NULL) != DUK_TOK_NULL) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_TRUE) != DUK_TOK_TRUE) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_FALSE) != DUK_TOK_FALSE) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IMPLEMENTS) != DUK_TOK_IMPLEMENTS) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_INTERFACE) != DUK_TOK_INTERFACE) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_LET) != DUK_TOK_LET) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PACKAGE) != DUK_TOK_PACKAGE) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PRIVATE) != DUK_TOK_PRIVATE) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PROTECTED) != DUK_TOK_PROTECTED) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PUBLIC) != DUK_TOK_PUBLIC) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_STATIC) != DUK_TOK_STATIC) +#error mismatch in token defines +#endif +#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_YIELD) != DUK_TOK_YIELD) +#error mismatch in token defines +#endif + +/* Regexp tokens */ +#define DUK_RETOK_EOF 0 +#define DUK_RETOK_DISJUNCTION 1 +#define DUK_RETOK_QUANTIFIER 2 +#define DUK_RETOK_ASSERT_START 3 +#define DUK_RETOK_ASSERT_END 4 +#define DUK_RETOK_ASSERT_WORD_BOUNDARY 5 +#define DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY 6 +#define DUK_RETOK_ASSERT_START_POS_LOOKAHEAD 7 +#define DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD 8 +#define DUK_RETOK_ATOM_PERIOD 9 +#define DUK_RETOK_ATOM_CHAR 10 +#define DUK_RETOK_ATOM_DIGIT 11 +#define DUK_RETOK_ATOM_NOT_DIGIT 12 +#define DUK_RETOK_ATOM_WHITE 13 +#define DUK_RETOK_ATOM_NOT_WHITE 14 +#define DUK_RETOK_ATOM_WORD_CHAR 15 +#define DUK_RETOK_ATOM_NOT_WORD_CHAR 16 +#define DUK_RETOK_ATOM_BACKREFERENCE 17 +#define DUK_RETOK_ATOM_START_CAPTURE_GROUP 18 +#define DUK_RETOK_ATOM_START_NONCAPTURE_GROUP 19 +#define DUK_RETOK_ATOM_START_CHARCLASS 20 +#define DUK_RETOK_ATOM_START_CHARCLASS_INVERTED 21 +#define DUK_RETOK_ATOM_END_GROUP 22 + +/* Constants for duk_lexer_ctx.buf. */ +#define DUK_LEXER_TEMP_BUF_LIMIT 256 + +/* A token value. Can be memcpy()'d, but note that slot1/slot2 values are on the valstack. + * Some fields (like num, str1, str2) are only valid for specific token types and may have + * stale values otherwise. + */ +struct duk_token { + duk_small_int_t t; /* token type (with reserved word identification) */ + duk_small_int_t t_nores; /* token type (with reserved words as DUK_TOK_IDENTIFER) */ + duk_double_t num; /* numeric value of token */ + duk_hstring *str1; /* string 1 of token (borrowed, stored to ctx->slot1_idx) */ + duk_hstring *str2; /* string 2 of token (borrowed, stored to ctx->slot2_idx) */ + duk_size_t start_offset; /* start byte offset of token in lexer input */ + duk_int_t start_line; /* start line of token (first char) */ + duk_int_t num_escapes; /* number of escapes and line continuations (for directive prologue) */ + duk_bool_t lineterm; /* token was preceded by a lineterm */ + duk_bool_t allow_auto_semi; /* token allows automatic semicolon insertion (eof or preceded by newline) */ +}; + +#define DUK_RE_QUANTIFIER_INFINITE ((duk_uint32_t) 0xffffffffUL) + +/* A regexp token value. */ +struct duk_re_token { + duk_small_int_t t; /* token type */ + duk_small_int_t greedy; + duk_uint_fast32_t num; /* numeric value (character, count) */ + duk_uint_fast32_t qmin; + duk_uint_fast32_t qmax; +}; + +/* A structure for 'snapshotting' a point for rewinding */ +struct duk_lexer_point { + duk_size_t offset; + duk_int_t line; +}; + +/* Lexer codepoint with additional info like offset/line number */ +struct duk_lexer_codepoint { + duk_codepoint_t codepoint; + duk_size_t offset; + duk_int_t line; +}; + +/* Lexer context. Same context is used for Ecmascript and Regexp parsing. */ +struct duk_lexer_ctx { +#if defined(DUK_USE_LEXER_SLIDING_WINDOW) + duk_lexer_codepoint *window; /* unicode code points, window[0] is always next, points to 'buffer' */ + duk_lexer_codepoint buffer[DUK_LEXER_BUFFER_SIZE]; +#else + duk_lexer_codepoint window[DUK_LEXER_WINDOW_SIZE]; /* unicode code points, window[0] is always next */ +#endif + + duk_hthread *thr; /* thread; minimizes argument passing */ + + const duk_uint8_t *input; /* input string (may be a user pointer) */ + duk_size_t input_length; /* input byte length */ + duk_size_t input_offset; /* input offset for window leading edge (not window[0]) */ + duk_int_t input_line; /* input linenumber at input_offset (not window[0]), init to 1 */ + + duk_idx_t slot1_idx; /* valstack slot for 1st token value */ + duk_idx_t slot2_idx; /* valstack slot for 2nd token value */ + duk_idx_t buf_idx; /* valstack slot for temp buffer */ + duk_hbuffer_dynamic *buf; /* temp accumulation buffer */ + duk_bufwriter_ctx bw; /* bufwriter for temp accumulation */ + + duk_int_t token_count; /* number of tokens parsed */ + duk_int_t token_limit; /* maximum token count before error (sanity backstop) */ +}; + +/* + * Prototypes + */ + +DUK_INTERNAL_DECL void duk_lexer_initctx(duk_lexer_ctx *lex_ctx); + +DUK_INTERNAL_DECL void duk_lexer_setpoint(duk_lexer_ctx *lex_ctx, duk_lexer_point *pt); + +DUK_INTERNAL_DECL +void duk_lexer_parse_js_input_element(duk_lexer_ctx *lex_ctx, + duk_token *out_token, + duk_bool_t strict_mode, + duk_bool_t regexp_mode); +#ifdef DUK_USE_REGEXP_SUPPORT +DUK_INTERNAL_DECL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token *out_token); +DUK_INTERNAL_DECL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range_callback gen_range, void *userdata); +#endif /* DUK_USE_REGEXP_SUPPORT */ + +#endif /* DUK_LEXER_H_INCLUDED */ +#line 1 "duk_js_compiler.h" +/* + * Ecmascript compiler. + */ + +#ifndef DUK_JS_COMPILER_H_INCLUDED +#define DUK_JS_COMPILER_H_INCLUDED + +/* ecmascript compiler limits */ +#define DUK_COMPILER_TOKEN_LIMIT 100000000L /* 1e8: protects against deeply nested inner functions */ + +/* maximum loopcount for peephole optimization */ +#define DUK_COMPILER_PEEPHOLE_MAXITER 3 + +/* maximum bytecode length in instructions */ +#define DUK_COMPILER_MAX_BYTECODE_LENGTH (256L * 1024L * 1024L) /* 1 GB */ + +/* + * Compiler intermediate values + * + * Intermediate values describe either plain values (e.g. strings or + * numbers) or binary operations which have not yet been coerced into + * either a left-hand-side or right-hand-side role (e.g. object property). + */ + +#define DUK_IVAL_NONE 0 /* no value */ +#define DUK_IVAL_PLAIN 1 /* register, constant, or value */ +#define DUK_IVAL_ARITH 2 /* binary arithmetic; DUK_OP_ADD, DUK_OP_EQ, other binary ops */ +#define DUK_IVAL_ARITH_EXTRAOP 3 /* binary arithmetic using extraops; DUK_EXTRAOP_INSTOF etc */ +#define DUK_IVAL_PROP 4 /* property access */ +#define DUK_IVAL_VAR 5 /* variable access */ + +#define DUK_ISPEC_NONE 0 /* no value */ +#define DUK_ISPEC_VALUE 1 /* value resides in 'valstack_idx' */ +#define DUK_ISPEC_REGCONST 2 /* value resides in a register or constant */ + +/* bit mask which indicates that a regconst is a constant instead of a register */ +#define DUK_JS_CONST_MARKER 0x80000000UL + +/* type to represent a reg/const reference during compilation */ +typedef duk_uint32_t duk_regconst_t; + +/* type to represent a straight register reference, with <0 indicating none */ +typedef duk_int32_t duk_reg_t; + +typedef struct { + duk_small_uint_t t; /* DUK_ISPEC_XXX */ + duk_regconst_t regconst; + duk_idx_t valstack_idx; /* always set; points to a reserved valstack slot */ +} duk_ispec; + +typedef struct { + /* + * PLAIN: x1 + * ARITH: x1 <op> x2 + * PROP: x1.x2 + * VAR: x1 (name) + */ + + /* XXX: can be optimized for smaller footprint esp. on 32-bit environments */ + duk_small_uint_t t; /* DUK_IVAL_XXX */ + duk_small_uint_t op; /* bytecode opcode (or extraop) for binary ops */ + duk_ispec x1; + duk_ispec x2; +} duk_ivalue; + +/* + * Bytecode instruction representation during compilation + * + * Contains the actual instruction and (optionally) debug info. + */ + +struct duk_compiler_instr { + duk_instr_t ins; +#if defined(DUK_USE_PC2LINE) + duk_uint32_t line; +#endif +}; + +/* + * Compiler state + */ + +#define DUK_LABEL_FLAG_ALLOW_BREAK (1 << 0) +#define DUK_LABEL_FLAG_ALLOW_CONTINUE (1 << 1) + +#define DUK_DECL_TYPE_VAR 0 +#define DUK_DECL_TYPE_FUNC 1 + +/* XXX: optimize to 16 bytes */ +typedef struct { + duk_small_uint_t flags; + duk_int_t label_id; /* numeric label_id (-1 reserved as marker) */ + duk_hstring *h_label; /* borrowed label name */ + duk_int_t catch_depth; /* catch depth at point of definition */ + duk_int_t pc_label; /* pc of label statement: + * pc+1: break jump site + * pc+2: continue jump site + */ + + /* Fast jumps (which avoid longjmp) jump directly to the jump sites + * which are always known even while the iteration/switch statement + * is still being parsed. A final peephole pass "straightens out" + * the jumps. + */ +} duk_labelinfo; + +/* Compiling state of one function, eventually converted to duk_hcompiledfunction */ +struct duk_compiler_func { + /* These pointers are at the start of the struct so that they pack + * nicely. Mixing pointers and integer values is bad on some + * platforms (e.g. if int is 32 bits and pointers are 64 bits). + */ + + duk_bufwriter_ctx bw_code; /* bufwriter for code */ + + duk_hstring *h_name; /* function name (borrowed reference), ends up in _name */ + /* h_code: held in bw_code */ + duk_hobject *h_consts; /* array */ + duk_hobject *h_funcs; /* array of function templates: [func1, offset1, line1, func2, offset2, line2] + * offset/line points to closing brace to allow skipping on pass 2 + */ + duk_hobject *h_decls; /* array of declarations: [ name1, val1, name2, val2, ... ] + * valN = (typeN) | (fnum << 8), where fnum is inner func number (0 for vars) + * record function and variable declarations in pass 1 + */ + duk_hobject *h_labelnames; /* array of active label names */ + duk_hbuffer_dynamic *h_labelinfos; /* C array of duk_labelinfo */ + duk_hobject *h_argnames; /* array of formal argument names (-> _Formals) */ + duk_hobject *h_varmap; /* variable map for pass 2 (identifier -> register number or null (unmapped)) */ + + /* value stack indices for tracking objects */ + /* code_idx: not needed */ + duk_idx_t consts_idx; + duk_idx_t funcs_idx; + duk_idx_t decls_idx; + duk_idx_t labelnames_idx; + duk_idx_t labelinfos_idx; + duk_idx_t argnames_idx; + duk_idx_t varmap_idx; + + /* temp reg handling */ + duk_reg_t temp_first; /* first register that is a temporary (below: variables) */ + duk_reg_t temp_next; /* next temporary register to allocate */ + duk_reg_t temp_max; /* highest value of temp_reg (temp_max - 1 is highest used reg) */ + + /* shuffle registers if large number of regs/consts */ + duk_reg_t shuffle1; + duk_reg_t shuffle2; + duk_reg_t shuffle3; + + /* stats for current expression being parsed */ + duk_int_t nud_count; + duk_int_t led_count; + duk_int_t paren_level; /* parenthesis count, 0 = top level */ + duk_bool_t expr_lhs; /* expression is left-hand-side compatible */ + duk_bool_t allow_in; /* current paren level allows 'in' token */ + + /* misc */ + duk_int_t stmt_next; /* statement id allocation (running counter) */ + duk_int_t label_next; /* label id allocation (running counter) */ + duk_int_t catch_depth; /* catch stack depth */ + duk_int_t with_depth; /* with stack depth (affects identifier lookups) */ + duk_int_t fnum_next; /* inner function numbering */ + duk_int_t num_formals; /* number of formal arguments */ + duk_reg_t reg_stmt_value; /* register for writing value of 'non-empty' statements (global or eval code), -1 is marker */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) + duk_int_t min_line; /* XXX: typing (duk_hcompiledfunction has duk_uint32_t) */ + duk_int_t max_line; +#endif + + /* status booleans */ + duk_bool_t is_function; /* is an actual function (not global/eval code) */ + duk_bool_t is_eval; /* is eval code */ + duk_bool_t is_global; /* is global code */ + duk_bool_t is_setget; /* is a setter/getter */ + duk_bool_t is_decl; /* is a function declaration (as opposed to function expression) */ + duk_bool_t is_strict; /* function is strict */ + duk_bool_t is_notail; /* function must not be tail called */ + duk_bool_t in_directive_prologue; /* parsing in "directive prologue", recognize directives */ + duk_bool_t in_scanning; /* parsing in "scanning" phase (first pass) */ + duk_bool_t may_direct_eval; /* function may call direct eval */ + duk_bool_t id_access_arguments; /* function refers to 'arguments' identifier */ + duk_bool_t id_access_slow; /* function makes one or more slow path accesses */ + duk_bool_t is_arguments_shadowed; /* argument/function declaration shadows 'arguments' */ + duk_bool_t needs_shuffle; /* function needs shuffle registers */ + duk_bool_t reject_regexp_in_adv; /* reject RegExp literal on next advance() call; needed for handling IdentifierName productions */ +}; + +struct duk_compiler_ctx { + duk_hthread *thr; + + /* filename being compiled (ends up in functions' '_filename' property) */ + duk_hstring *h_filename; /* borrowed reference */ + + /* lexing (tokenization) state (contains two valstack slot indices) */ + duk_lexer_ctx lex; + + /* current and previous token for parsing */ + duk_token prev_token; + duk_token curr_token; + duk_idx_t tok11_idx; /* curr_token slot1 (matches 'lex' slot1_idx) */ + duk_idx_t tok12_idx; /* curr_token slot2 (matches 'lex' slot2_idx) */ + duk_idx_t tok21_idx; /* prev_token slot1 */ + duk_idx_t tok22_idx; /* prev_token slot2 */ + + /* recursion limit */ + duk_int_t recursion_depth; + duk_int_t recursion_limit; + + /* code emission temporary */ + duk_int_t emit_jumpslot_pc; + + /* current function being compiled (embedded instead of pointer for more compact access) */ + duk_compiler_func curr_func; +}; + +/* + * Prototypes + */ + +#define DUK_JS_COMPILE_FLAG_EVAL (1 << 0) /* source is eval code (not global) */ +#define DUK_JS_COMPILE_FLAG_STRICT (1 << 1) /* strict outer context */ +#define DUK_JS_COMPILE_FLAG_FUNCEXPR (1 << 2) /* source is a function expression (used for Function constructor) */ + +DUK_INTERNAL_DECL void duk_js_compile(duk_hthread *thr, const duk_uint8_t *src_buffer, duk_size_t src_length, duk_small_uint_t flags); + +#endif /* DUK_JS_COMPILER_H_INCLUDED */ +#line 1 "duk_regexp.h" +/* + * Regular expression structs, constants, and bytecode defines. + */ + +#ifndef DUK_REGEXP_H_INCLUDED +#define DUK_REGEXP_H_INCLUDED + +/* maximum bytecode copies for {n,m} quantifiers */ +#define DUK_RE_MAX_ATOM_COPIES 1000 + +/* regexp compilation limits */ +#define DUK_RE_COMPILE_TOKEN_LIMIT 100000000L /* 1e8 */ + +/* regexp execution limits */ +#define DUK_RE_EXECUTE_STEPS_LIMIT 1000000000L /* 1e9 */ + +/* regexp opcodes */ +#define DUK_REOP_MATCH 1 +#define DUK_REOP_CHAR 2 +#define DUK_REOP_PERIOD 3 +#define DUK_REOP_RANGES 4 +#define DUK_REOP_INVRANGES 5 +#define DUK_REOP_JUMP 6 +#define DUK_REOP_SPLIT1 7 +#define DUK_REOP_SPLIT2 8 +#define DUK_REOP_SQMINIMAL 9 +#define DUK_REOP_SQGREEDY 10 +#define DUK_REOP_SAVE 11 +#define DUK_REOP_WIPERANGE 12 +#define DUK_REOP_LOOKPOS 13 +#define DUK_REOP_LOOKNEG 14 +#define DUK_REOP_BACKREFERENCE 15 +#define DUK_REOP_ASSERT_START 16 +#define DUK_REOP_ASSERT_END 17 +#define DUK_REOP_ASSERT_WORD_BOUNDARY 18 +#define DUK_REOP_ASSERT_NOT_WORD_BOUNDARY 19 + +/* flags */ +#define DUK_RE_FLAG_GLOBAL (1 << 0) +#define DUK_RE_FLAG_IGNORE_CASE (1 << 1) +#define DUK_RE_FLAG_MULTILINE (1 << 2) + +struct duk_re_matcher_ctx { + duk_hthread *thr; + + duk_uint32_t re_flags; + const duk_uint8_t *input; + const duk_uint8_t *input_end; + const duk_uint8_t *bytecode; + const duk_uint8_t *bytecode_end; + const duk_uint8_t **saved; /* allocated from valstack (fixed buffer) */ + duk_uint32_t nsaved; + duk_uint32_t recursion_depth; + duk_uint32_t recursion_limit; + duk_uint32_t steps_count; + duk_uint32_t steps_limit; +}; + +struct duk_re_compiler_ctx { + duk_hthread *thr; + + duk_uint32_t re_flags; + duk_lexer_ctx lex; + duk_re_token curr_token; + duk_bufwriter_ctx bw; + duk_uint32_t captures; /* highest capture number emitted so far (used as: ++captures) */ + duk_uint32_t highest_backref; + duk_uint32_t recursion_depth; + duk_uint32_t recursion_limit; + duk_uint32_t nranges; /* internal temporary value, used for char classes */ +}; + +/* + * Prototypes + */ + +DUK_INTERNAL_DECL void duk_regexp_compile(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_regexp_create_instance(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_regexp_match(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_regexp_match_force_global(duk_hthread *thr); /* hacky helper for String.prototype.split() */ + +#endif /* DUK_REGEXP_H_INCLUDED */ +#line 1 "duk_tval.h" +/* + * Tagged type definition (duk_tval) and accessor macros. + * + * Access all fields through the accessor macros, as the representation + * is quite tricky. + * + * There are two packed type alternatives: an 8-byte representation + * based on an IEEE double (preferred for compactness), and a 12-byte + * representation (portability). The latter is needed also in e.g. + * 64-bit environments (it usually pads to 16 bytes per value). + * + * Selecting the tagged type format involves many trade-offs (memory + * use, size and performance of generated code, portability, etc), + * see doc/types.rst for a detailed discussion (especially of how the + * IEEE double format is used to pack tagged values). + * + * NB: because macro arguments are often expressions, macros should + * avoid evaluating their argument more than once. + */ + +#ifndef DUK_TVAL_H_INCLUDED +#define DUK_TVAL_H_INCLUDED + +/* sanity */ +#if !defined(DUK_USE_DOUBLE_LE) && !defined(DUK_USE_DOUBLE_ME) && !defined(DUK_USE_DOUBLE_BE) +#error unsupported: cannot determine byte order variant +#endif + +#ifdef DUK_USE_PACKED_TVAL +/* ======================================================================== */ + +/* + * Packed 8-byte representation + */ + +/* sanity */ +#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE) +#error packed representation not supported +#endif + +/* use duk_double_union as duk_tval directly */ +typedef union duk_double_union duk_tval; + +/* tags */ +#define DUK_TAG_NORMALIZED_NAN 0x7ff8UL /* the NaN variant we use */ +/* avoid tag 0xfff0, no risk of confusion with negative infinity */ +#if defined(DUK_USE_FASTINT) +#define DUK_TAG_FASTINT 0xfff1UL /* embed: integer value */ +#endif +#define DUK_TAG_UNDEFINED 0xfff2UL /* embed: 0 or 1 (normal or unused) */ +#define DUK_TAG_NULL 0xfff3UL /* embed: nothing */ +#define DUK_TAG_BOOLEAN 0xfff4UL /* embed: 0 or 1 (false or true) */ +/* DUK_TAG_NUMBER would logically go here, but it has multiple 'tags' */ +#define DUK_TAG_POINTER 0xfff5UL /* embed: void ptr */ +#define DUK_TAG_LIGHTFUNC 0xfff6UL /* embed: func ptr */ +#define DUK_TAG_STRING 0xfff7UL /* embed: duk_hstring ptr */ +#define DUK_TAG_OBJECT 0xfff8UL /* embed: duk_hobject ptr */ +#define DUK_TAG_BUFFER 0xfff9UL /* embed: duk_hbuffer ptr */ + +/* for convenience */ +#define DUK_XTAG_UNDEFINED_ACTUAL 0xfff20000UL +#define DUK_XTAG_UNDEFINED_UNUSED 0xfff20001UL +#define DUK_XTAG_NULL 0xfff30000UL +#define DUK_XTAG_BOOLEAN_FALSE 0xfff40000UL +#define DUK_XTAG_BOOLEAN_TRUE 0xfff40001UL + +/* two casts to avoid gcc warning: "warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]" */ +#ifdef DUK_USE_64BIT_OPS +#ifdef DUK_USE_DOUBLE_ME +#define DUK__TVAL_SET_TAGGEDPOINTER(v,h,tag) do { \ + (v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) (tag)) << 16) | (((duk_uint64_t) (duk_uint32_t) (h)) << 32); \ + } while (0) +#else +#define DUK__TVAL_SET_TAGGEDPOINTER(v,h,tag) do { \ + (v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) (tag)) << 48) | ((duk_uint64_t) (duk_uint32_t) (h)); \ + } while (0) +#endif +#else /* DUK_USE_64BIT_OPS */ +#define DUK__TVAL_SET_TAGGEDPOINTER(v,h,tag) do { \ + (v)->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) (tag)) << 16; \ + (v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (h); \ + } while (0) +#endif /* DUK_USE_64BIT_OPS */ + +#ifdef DUK_USE_64BIT_OPS +/* Double casting for pointer to avoid gcc warning (cast from pointer to integer of different size) */ +#ifdef DUK_USE_DOUBLE_ME +#define DUK__TVAL_SET_LIGHTFUNC(v,fp,flags) do { \ + (v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_LIGHTFUNC) << 16) | \ + ((duk_uint64_t) (flags)) | \ + (((duk_uint64_t) (duk_uint32_t) (fp)) << 32); \ + } while (0) +#else +#define DUK__TVAL_SET_LIGHTFUNC(v,fp,flags) do { \ + (v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_LIGHTFUNC) << 48) | \ + (((duk_uint64_t) (flags)) << 32) | \ + ((duk_uint64_t) (duk_uint32_t) (fp)); \ + } while (0) +#endif +#else /* DUK_USE_64BIT_OPS */ +#define DUK__TVAL_SET_LIGHTFUNC(v,fp,flags) do { \ + (v)->ui[DUK_DBL_IDX_UI0] = (((duk_uint32_t) DUK_TAG_LIGHTFUNC) << 16) | ((duk_uint32_t) (flags)); \ + (v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (fp); \ + } while (0) +#endif /* DUK_USE_64BIT_OPS */ + +#if defined(DUK_USE_FASTINT) +/* Note: masking is done for 'i' to deal with negative numbers correctly */ +#ifdef DUK_USE_DOUBLE_ME +#define DUK__TVAL_SET_FASTINT(v,i) do { \ + (v)->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) DUK_TAG_FASTINT) << 16 | (((duk_uint32_t) ((i) >> 32)) & 0x0000ffffUL); \ + (v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (i); \ + } while (0) +#define DUK__TVAL_SET_FASTINT_U32(v,i) do { \ + (v)->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) DUK_TAG_FASTINT) << 16; \ + (v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (i); \ + } while (0) +#else +#define DUK__TVAL_SET_FASTINT(v,i) do { \ + (v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_FASTINT) << 48) | (((duk_uint64_t) (i)) & 0x0000ffffffffffffULL); \ + } while (0) +#define DUK__TVAL_SET_FASTINT_U32(v,i) do { \ + (v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_FASTINT) << 48) | (duk_uint64_t) (i); \ + } while (0) +#endif + +#define DUK__TVAL_SET_FASTINT_I32(v,i) do { \ + duk_int64_t duk__tmp = (duk_int64_t) (i); \ + DUK_TVAL_SET_FASTINT((v), duk__tmp); \ + } while (0) + +/* XXX: clumsy sign extend and masking of 16 topmost bits */ +#ifdef DUK_USE_DOUBLE_ME +#define DUK__TVAL_GET_FASTINT(v) (((duk_int64_t) ((((duk_uint64_t) (v)->ui[DUK_DBL_IDX_UI0]) << 32) | ((duk_uint64_t) (v)->ui[DUK_DBL_IDX_UI1]))) << 16 >> 16) +#else +#define DUK__TVAL_GET_FASTINT(v) ((((duk_int64_t) (v)->ull[DUK_DBL_IDX_ULL0]) << 16) >> 16) +#endif +#define DUK__TVAL_GET_FASTINT_U32(v) ((v)->ui[DUK_DBL_IDX_UI1]) +#define DUK__TVAL_GET_FASTINT_I32(v) ((duk_int32_t) (v)->ui[DUK_DBL_IDX_UI1]) +#endif /* DUK_USE_FASTINT */ + +#define DUK_TVAL_SET_UNDEFINED_ACTUAL(v) DUK_DBLUNION_SET_HIGH32((v), DUK_XTAG_UNDEFINED_ACTUAL) +#define DUK_TVAL_SET_UNDEFINED_UNUSED(v) DUK_DBLUNION_SET_HIGH32((v), DUK_XTAG_UNDEFINED_UNUSED) + +/* Note: 16-bit initializer suffices (unlike for undefined/boolean) */ +#define DUK_TVAL_SET_NULL(v) do { \ + (v)->us[DUK_DBL_IDX_US0] = (duk_uint16_t) DUK_TAG_NULL; \ + } while (0) + +#define DUK_TVAL_SET_BOOLEAN(v,val) DUK_DBLUNION_SET_HIGH32((v), (((duk_uint32_t) DUK_TAG_BOOLEAN) << 16) | ((duk_uint32_t) (val))) + +#define DUK_TVAL_SET_NAN(v) DUK_DBLUNION_SET_NAN_FULL((v)) + +/* Assumes that caller has normalized NaNs, otherwise trouble ahead. */ +#if defined(DUK_USE_FASTINT) +#define DUK_TVAL_SET_DOUBLE(v,d) do { \ + duk_double_t duk__dblval; \ + duk__dblval = (d); \ + DUK_ASSERT_DOUBLE_IS_NORMALIZED(duk__dblval); \ + DUK_DBLUNION_SET_DOUBLE((v), duk__dblval); \ + } while (0) +#define DUK_TVAL_SET_FASTINT(v,i) DUK__TVAL_SET_FASTINT((v), (i)) +#define DUK_TVAL_SET_FASTINT_I32(v,i) DUK__TVAL_SET_FASTINT_I32((v), (i)) +#define DUK_TVAL_SET_FASTINT_U32(v,i) DUK__TVAL_SET_FASTINT_U32((v), (i)) +#define DUK_TVAL_SET_NUMBER_CHKFAST(v,d) duk_tval_set_number_chkfast((v), (d)) +#define DUK_TVAL_SET_NUMBER(v,d) DUK_TVAL_SET_DOUBLE((v), (d)) +#define DUK_TVAL_CHKFAST_INPLACE(v) do { \ + duk_tval *duk__tv; \ + duk_double_t duk__d; \ + duk__tv = (v); \ + if (DUK_TVAL_IS_DOUBLE(duk__tv)) { \ + duk__d = DUK_TVAL_GET_DOUBLE(duk__tv); \ + DUK_TVAL_SET_NUMBER_CHKFAST(duk__tv, duk__d); \ + } \ + } while (0) +#else +#define DUK_TVAL_SET_DOUBLE(v,d) do { \ + duk_double_t duk__dblval; \ + duk__dblval = (d); \ + DUK_ASSERT_DOUBLE_IS_NORMALIZED(duk__dblval); \ + DUK_DBLUNION_SET_DOUBLE((v), duk__dblval); \ + } while (0) +#define DUK_TVAL_SET_NUMBER_CHKFAST(v,d) DUK_TVAL_SET_DOUBLE((v), (d)) +#define DUK_TVAL_SET_NUMBER(v,d) DUK_TVAL_SET_DOUBLE((v), (d)) +#define DUK_TVAL_CHKFAST_INPLACE(v) do { } while (0) +#endif + +#define DUK_TVAL_SET_LIGHTFUNC(v,fp,flags) DUK__TVAL_SET_LIGHTFUNC((v), (fp), (flags)) +#define DUK_TVAL_SET_STRING(v,h) DUK__TVAL_SET_TAGGEDPOINTER((v), (h), DUK_TAG_STRING) +#define DUK_TVAL_SET_OBJECT(v,h) DUK__TVAL_SET_TAGGEDPOINTER((v), (h), DUK_TAG_OBJECT) +#define DUK_TVAL_SET_BUFFER(v,h) DUK__TVAL_SET_TAGGEDPOINTER((v), (h), DUK_TAG_BUFFER) +#define DUK_TVAL_SET_POINTER(v,p) DUK__TVAL_SET_TAGGEDPOINTER((v), (p), DUK_TAG_POINTER) + +#define DUK_TVAL_SET_TVAL(v,x) do { *(v) = *(x); } while (0) + +/* getters */ +#define DUK_TVAL_GET_BOOLEAN(v) ((int) (v)->us[DUK_DBL_IDX_US1]) +#if defined(DUK_USE_FASTINT) +#define DUK_TVAL_GET_DOUBLE(v) ((v)->d) +#define DUK_TVAL_GET_FASTINT(v) DUK__TVAL_GET_FASTINT((v)) +#define DUK_TVAL_GET_FASTINT_U32(v) DUK__TVAL_GET_FASTINT_U32((v)) +#define DUK_TVAL_GET_FASTINT_I32(v) DUK__TVAL_GET_FASTINT_I32((v)) +#define DUK_TVAL_GET_NUMBER(v) duk_tval_get_number_packed((v)) +#else +#define DUK_TVAL_GET_NUMBER(v) ((v)->d) +#define DUK_TVAL_GET_DOUBLE(v) ((v)->d) +#endif +#define DUK_TVAL_GET_LIGHTFUNC(v,out_fp,out_flags) do { \ + (out_flags) = (v)->ui[DUK_DBL_IDX_UI0] & 0xffffUL; \ + (out_fp) = (duk_c_function) (v)->ui[DUK_DBL_IDX_UI1]; \ + } while (0) +#define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(v) ((duk_c_function) ((v)->ui[DUK_DBL_IDX_UI1])) +#define DUK_TVAL_GET_LIGHTFUNC_FLAGS(v) (((int) (v)->ui[DUK_DBL_IDX_UI0]) & 0xffffUL) +#define DUK_TVAL_GET_STRING(v) ((duk_hstring *) (v)->vp[DUK_DBL_IDX_VP1]) +#define DUK_TVAL_GET_OBJECT(v) ((duk_hobject *) (v)->vp[DUK_DBL_IDX_VP1]) +#define DUK_TVAL_GET_BUFFER(v) ((duk_hbuffer *) (v)->vp[DUK_DBL_IDX_VP1]) +#define DUK_TVAL_GET_POINTER(v) ((void *) (v)->vp[DUK_DBL_IDX_VP1]) +#define DUK_TVAL_GET_HEAPHDR(v) ((duk_heaphdr *) (v)->vp[DUK_DBL_IDX_VP1]) + +/* decoding */ +#define DUK_TVAL_GET_TAG(v) ((duk_small_uint_t) (v)->us[DUK_DBL_IDX_US0]) + +#define DUK_TVAL_IS_UNDEFINED(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_UNDEFINED) +#define DUK_TVAL_IS_UNDEFINED_ACTUAL(v) ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_UNDEFINED_ACTUAL) +#define DUK_TVAL_IS_UNDEFINED_UNUSED(v) ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_UNDEFINED_UNUSED) +#define DUK_TVAL_IS_NULL(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_NULL) +#define DUK_TVAL_IS_BOOLEAN(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_BOOLEAN) +#define DUK_TVAL_IS_BOOLEAN_TRUE(v) ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_TRUE) +#define DUK_TVAL_IS_BOOLEAN_FALSE(v) ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_FALSE) +#define DUK_TVAL_IS_LIGHTFUNC(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_LIGHTFUNC) +#define DUK_TVAL_IS_STRING(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_STRING) +#define DUK_TVAL_IS_OBJECT(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_OBJECT) +#define DUK_TVAL_IS_BUFFER(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_BUFFER) +#define DUK_TVAL_IS_POINTER(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_POINTER) +#if defined(DUK_USE_FASTINT) +/* 0xfff0 is -Infinity */ +#define DUK_TVAL_IS_DOUBLE(v) (DUK_TVAL_GET_TAG((v)) <= 0xfff0UL) +#define DUK_TVAL_IS_FASTINT(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_FASTINT) +#define DUK_TVAL_IS_NUMBER(v) (DUK_TVAL_GET_TAG((v)) <= 0xfff1UL) +#else +#define DUK_TVAL_IS_NUMBER(v) (DUK_TVAL_GET_TAG((v)) <= 0xfff0UL) +#define DUK_TVAL_IS_DOUBLE(v) DUK_TVAL_IS_NUMBER((v)) +#endif + +#define DUK_TVAL_IS_HEAP_ALLOCATED(v) (DUK_TVAL_GET_TAG((v)) >= DUK_TAG_STRING) + +#if defined(DUK_USE_FASTINT) +DUK_INTERNAL_DECL duk_double_t duk_tval_get_number_packed(duk_tval *tv); +#endif + +#else /* DUK_USE_PACKED_TVAL */ +/* ======================================================================== */ + +/* + * Portable 12-byte representation + */ + +/* Note: not initializing all bytes is normally not an issue: Duktape won't + * read or use the uninitialized bytes so valgrind won't issue warnings. + * In some special cases a harmless valgrind warning may be issued though. + * For example, the DumpHeap debugger command writes out a compiled function's + * 'data' area as is, including any uninitialized bytes, which causes a + * valgrind warning. + */ + +typedef struct duk_tval_struct duk_tval; + +struct duk_tval_struct { + duk_small_uint_t t; + duk_small_uint_t v_extra; + union { + duk_double_t d; + duk_small_int_t i; +#if defined(DUK_USE_FASTINT) + duk_int64_t fi; /* if present, forces 16-byte duk_tval */ +#endif + void *voidptr; + duk_hstring *hstring; + duk_hobject *hobject; + duk_hcompiledfunction *hcompiledfunction; + duk_hnativefunction *hnativefunction; + duk_hthread *hthread; + duk_hbuffer *hbuffer; + duk_heaphdr *heaphdr; + duk_c_function lightfunc; + } v; +}; + +#define DUK__TAG_NUMBER 0 /* not exposed */ +#if defined(DUK_USE_FASTINT) +#define DUK_TAG_FASTINT 1 +#endif +#define DUK_TAG_UNDEFINED 2 +#define DUK_TAG_NULL 3 +#define DUK_TAG_BOOLEAN 4 +#define DUK_TAG_POINTER 5 +#define DUK_TAG_LIGHTFUNC 6 +#define DUK_TAG_STRING 7 +#define DUK_TAG_OBJECT 8 +#define DUK_TAG_BUFFER 9 + +/* DUK__TAG_NUMBER is intentionally first, as it is the default clause in code + * to support the 8-byte representation. Further, it is a non-heap-allocated + * type so it should come before DUK_TAG_STRING. Finally, it should not break + * the tag value ranges covered by case-clauses in a switch-case. + */ + +/* setters */ +#define DUK_TVAL_SET_UNDEFINED_ACTUAL(tv) do { \ + (tv)->t = DUK_TAG_UNDEFINED; \ + (tv)->v.i = 0; \ + } while (0) + +#define DUK_TVAL_SET_UNDEFINED_UNUSED(tv) do { \ + (tv)->t = DUK_TAG_UNDEFINED; \ + (tv)->v.i = 1; \ + } while (0) + +#define DUK_TVAL_SET_NULL(tv) do { \ + (tv)->t = DUK_TAG_NULL; \ + } while (0) + +#define DUK_TVAL_SET_BOOLEAN(tv,val) do { \ + (tv)->t = DUK_TAG_BOOLEAN; \ + (tv)->v.i = (val); \ + } while (0) + +#if defined(DUK_USE_FASTINT) +#define DUK_TVAL_SET_DOUBLE(tv,val) do { \ + (tv)->t = DUK__TAG_NUMBER; \ + (tv)->v.d = (val); \ + } while (0) +#define DUK_TVAL_SET_FASTINT(tv,val) do { \ + (tv)->t = DUK_TAG_FASTINT; \ + (tv)->v.fi = (val); \ + } while (0) +#define DUK_TVAL_SET_FASTINT_U32(tv,val) do { \ + (tv)->t = DUK_TAG_FASTINT; \ + (tv)->v.fi = (duk_int64_t) (val); \ + } while (0) +#define DUK_TVAL_SET_FASTINT_I32(tv,val) do { \ + (tv)->t = DUK_TAG_FASTINT; \ + (tv)->v.fi = (duk_int64_t) (val); \ + } while (0) +#define DUK_TVAL_SET_NUMBER_CHKFAST(tv,d) \ + duk_tval_set_number_chkfast((tv), (d)) +#define DUK_TVAL_SET_NUMBER(tv,val) \ + DUK_TVAL_SET_DOUBLE((tv), (val)) +#define DUK_TVAL_CHKFAST_INPLACE(v) do { \ + duk_tval *duk__tv; \ + duk_double_t duk__d; \ + duk__tv = (v); \ + if (DUK_TVAL_IS_DOUBLE(duk__tv)) { \ + duk__d = DUK_TVAL_GET_DOUBLE(duk__tv); \ + DUK_TVAL_SET_NUMBER_CHKFAST(duk__tv, duk__d); \ + } \ + } while (0) +#else +#define DUK_TVAL_SET_NUMBER(tv,val) do { \ + (tv)->t = DUK__TAG_NUMBER; \ + (tv)->v.d = (val); \ + } while (0) +#define DUK_TVAL_SET_NUMBER_CHKFAST(tv,d) \ + DUK_TVAL_SET_NUMBER((tv), (d)) +#define DUK_TVAL_SET_DOUBLE(v,d) \ + DUK_TVAL_SET_NUMBER((tv), (d)) +#define DUK_TVAL_CHKFAST_INPLACE(v) do { } while (0) +#endif /* DUK_USE_FASTINT */ + +#define DUK_TVAL_SET_POINTER(tv,hptr) do { \ + (tv)->t = DUK_TAG_POINTER; \ + (tv)->v.voidptr = (hptr); \ + } while (0) + +#define DUK_TVAL_SET_LIGHTFUNC(tv,fp,flags) do { \ + (tv)->t = DUK_TAG_LIGHTFUNC; \ + (tv)->v_extra = (flags); \ + (tv)->v.lightfunc = (duk_c_function) (fp); \ + } while (0) + +#define DUK_TVAL_SET_STRING(tv,hptr) do { \ + (tv)->t = DUK_TAG_STRING; \ + (tv)->v.hstring = (hptr); \ + } while (0) + +#define DUK_TVAL_SET_OBJECT(tv,hptr) do { \ + (tv)->t = DUK_TAG_OBJECT; \ + (tv)->v.hobject = (hptr); \ + } while (0) + +#define DUK_TVAL_SET_BUFFER(tv,hptr) do { \ + (tv)->t = DUK_TAG_BUFFER; \ + (tv)->v.hbuffer = (hptr); \ + } while (0) + +#define DUK_TVAL_SET_NAN(tv) do { \ + /* in non-packed representation we don't care about which NaN is used */ \ + (tv)->t = DUK__TAG_NUMBER; \ + (tv)->v.d = DUK_DOUBLE_NAN; \ + } while (0) + +#define DUK_TVAL_SET_TVAL(v,x) do { *(v) = *(x); } while (0) + +/* getters */ +#define DUK_TVAL_GET_BOOLEAN(tv) ((tv)->v.i) +#if defined(DUK_USE_FASTINT) +#define DUK_TVAL_GET_DOUBLE(tv) ((tv)->v.d) +#define DUK_TVAL_GET_FASTINT(tv) ((tv)->v.fi) +#define DUK_TVAL_GET_FASTINT_U32(tv) ((duk_uint32_t) ((tv)->v.fi)) +#define DUK_TVAL_GET_FASTINT_I32(tv) ((duk_int32_t) ((tv)->v.fi)) +#if 0 +#define DUK_TVAL_GET_NUMBER(tv) (DUK_TVAL_IS_FASTINT((tv)) ? \ + (duk_double_t) DUK_TVAL_GET_FASTINT((tv)) : \ + DUK_TVAL_GET_DOUBLE((tv))) +#define DUK_TVAL_GET_NUMBER(tv) duk_tval_get_number_unpacked((tv)) +#else +/* This seems reasonable overall. */ +#define DUK_TVAL_GET_NUMBER(tv) (DUK_TVAL_IS_FASTINT((tv)) ? \ + duk_tval_get_number_unpacked_fastint((tv)) : \ + DUK_TVAL_GET_DOUBLE((tv))) +#endif +#else +#define DUK_TVAL_GET_NUMBER(tv) ((tv)->v.d) +#define DUK_TVAL_GET_DOUBLE(tv) ((tv)->v.d) +#endif /* DUK_USE_FASTINT */ +#define DUK_TVAL_GET_POINTER(tv) ((tv)->v.voidptr) +#define DUK_TVAL_GET_LIGHTFUNC(tv,out_fp,out_flags) do { \ + (out_flags) = (duk_uint32_t) (tv)->v_extra; \ + (out_fp) = (tv)->v.lightfunc; \ + } while (0) +#define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv) ((tv)->v.lightfunc) +#define DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv) ((duk_uint32_t) ((tv)->v_extra)) +#define DUK_TVAL_GET_STRING(tv) ((tv)->v.hstring) +#define DUK_TVAL_GET_OBJECT(tv) ((tv)->v.hobject) +#define DUK_TVAL_GET_BUFFER(tv) ((tv)->v.hbuffer) +#define DUK_TVAL_GET_HEAPHDR(tv) ((tv)->v.heaphdr) + +/* decoding */ +#define DUK_TVAL_GET_TAG(tv) ((tv)->t) +#define DUK_TVAL_IS_UNDEFINED(tv) ((tv)->t == DUK_TAG_UNDEFINED) +#define DUK_TVAL_IS_UNDEFINED_ACTUAL(tv) (((tv)->t == DUK_TAG_UNDEFINED) && ((tv)->v.i == 0)) +#define DUK_TVAL_IS_UNDEFINED_UNUSED(tv) (((tv)->t == DUK_TAG_UNDEFINED) && ((tv)->v.i != 0)) +#define DUK_TVAL_IS_NULL(tv) ((tv)->t == DUK_TAG_NULL) +#define DUK_TVAL_IS_BOOLEAN(tv) ((tv)->t == DUK_TAG_BOOLEAN) +#define DUK_TVAL_IS_BOOLEAN_TRUE(tv) (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i != 0)) +#define DUK_TVAL_IS_BOOLEAN_FALSE(tv) (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i == 0)) +#if defined(DUK_USE_FASTINT) +#define DUK_TVAL_IS_DOUBLE(tv) ((tv)->t == DUK__TAG_NUMBER) +#define DUK_TVAL_IS_FASTINT(tv) ((tv)->t == DUK_TAG_FASTINT) +#define DUK_TVAL_IS_NUMBER(tv) ((tv)->t == DUK__TAG_NUMBER || \ + (tv)->t == DUK_TAG_FASTINT) +#else +#define DUK_TVAL_IS_NUMBER(tv) ((tv)->t == DUK__TAG_NUMBER) +#define DUK_TVAL_IS_DOUBLE(v) DUK_TVAL_IS_NUMBER((v)) +#endif /* DUK_USE_FASTINT */ +#define DUK_TVAL_IS_POINTER(tv) ((tv)->t == DUK_TAG_POINTER) +#define DUK_TVAL_IS_LIGHTFUNC(tv) ((tv)->t == DUK_TAG_LIGHTFUNC) +#define DUK_TVAL_IS_STRING(tv) ((tv)->t == DUK_TAG_STRING) +#define DUK_TVAL_IS_OBJECT(tv) ((tv)->t == DUK_TAG_OBJECT) +#define DUK_TVAL_IS_BUFFER(tv) ((tv)->t == DUK_TAG_BUFFER) + +#define DUK_TVAL_IS_HEAP_ALLOCATED(tv) ((tv)->t >= DUK_TAG_STRING) + +#if defined(DUK_USE_FASTINT) +#if 0 +DUK_INTERNAL_DECL duk_double_t duk_tval_get_number_unpacked(duk_tval *tv); +#endif +DUK_INTERNAL_DECL duk_double_t duk_tval_get_number_unpacked_fastint(duk_tval *tv); +#endif + +#endif /* DUK_USE_PACKED_TVAL */ + +/* + * Convenience (independent of representation) + */ + +#define DUK_TVAL_SET_BOOLEAN_TRUE(v) DUK_TVAL_SET_BOOLEAN(v, 1) +#define DUK_TVAL_SET_BOOLEAN_FALSE(v) DUK_TVAL_SET_BOOLEAN(v, 0) + +/* Lightfunc flags packing and unpacking. */ +/* Sign extend: 0x0000##00 -> 0x##000000 -> sign extend to 0xssssss## */ +#define DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags) \ + ((((duk_int32_t) (lf_flags)) << 16) >> 24) +#define DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags) \ + (((lf_flags) >> 4) & 0x0f) +#define DUK_LFUNC_FLAGS_GET_NARGS(lf_flags) \ + ((lf_flags) & 0x0f) +#define DUK_LFUNC_FLAGS_PACK(magic,length,nargs) \ + (((magic) & 0xff) << 8) | ((length) << 4) | (nargs) + +#define DUK_LFUNC_NARGS_VARARGS 0x0f /* varargs marker */ +#define DUK_LFUNC_NARGS_MIN 0x00 +#define DUK_LFUNC_NARGS_MAX 0x0e /* max, excl. varargs marker */ +#define DUK_LFUNC_LENGTH_MIN 0x00 +#define DUK_LFUNC_LENGTH_MAX 0x0f +#define DUK_LFUNC_MAGIC_MIN (-0x80) +#define DUK_LFUNC_MAGIC_MAX 0x7f + +/* fastint constants etc */ +#if defined(DUK_USE_FASTINT) +#define DUK_FASTINT_MIN (-0x800000000000LL) +#define DUK_FASTINT_MAX 0x7fffffffffffLL +#define DUK_FASTINT_BITS 48 + +DUK_INTERNAL_DECL void duk_tval_set_number_chkfast(duk_tval *tv, duk_double_t x); +#endif + +#endif /* DUK_TVAL_H_INCLUDED */ +#line 1 "duk_heaphdr.h" +/* + * Heap header definition and assorted macros, including ref counting. + * Access all fields through the accessor macros. + */ + +#ifndef DUK_HEAPHDR_H_INCLUDED +#define DUK_HEAPHDR_H_INCLUDED + +/* + * Common heap header + * + * All heap objects share the same flags and refcount fields. Objects other + * than strings also need to have a single or double linked list pointers + * for insertion into the "heap allocated" list. Strings are held in the + * heap-wide string table so they don't need link pointers. + * + * Technically, 'h_refcount' must be wide enough to guarantee that it cannot + * wrap (otherwise objects might be freed incorrectly after wrapping). This + * means essentially that the refcount field must be as wide as data pointers. + * On 64-bit platforms this means that the refcount needs to be 64 bits even + * if an 'int' is 32 bits. This is a bit unfortunate, and compromising on + * this might be reasonable in the future. + * + * Heap header size on 32-bit platforms: 8 bytes without reference counting, + * 16 bytes with reference counting. + */ + +struct duk_heaphdr { + duk_uint32_t h_flags; + +#if defined(DUK_USE_REFERENCE_COUNTING) +#if defined(DUK_USE_REFCOUNT16) + duk_uint16_t h_refcount16; +#else + duk_size_t h_refcount; +#endif +#endif + +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t h_next16; +#else + duk_heaphdr *h_next; +#endif + +#if defined(DUK_USE_DOUBLE_LINKED_HEAP) + /* refcounting requires direct heap frees, which in turn requires a dual linked heap */ +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t h_prev16; +#else + duk_heaphdr *h_prev; +#endif +#endif + + /* When DUK_USE_HEAPPTR16 (and DUK_USE_REFCOUNT16) is in use, the + * struct won't align nicely to 4 bytes. This 16-bit extra field + * is added to make the alignment clean; the field can be used by + * heap objects when 16-bit packing is used. This field is now + * conditional to DUK_USE_HEAPPTR16 only, but it is intended to be + * used with DUK_USE_REFCOUNT16 and DUK_USE_DOUBLE_LINKED_HEAP; + * this only matter to low memory environments anyway. + */ +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t h_extra16; +#endif +}; + +struct duk_heaphdr_string { + /* 16 bits would be enough for shared heaphdr flags and duk_hstring + * flags. The initial parts of duk_heaphdr_string and duk_heaphdr + * must match so changing the flags field size here would be quite + * awkward. However, to minimize struct size, we can pack at least + * 16 bits of duk_hstring data into the flags field. + */ + duk_uint32_t h_flags; + +#if defined(DUK_USE_REFERENCE_COUNTING) +#if defined(DUK_USE_REFCOUNT16) + duk_uint16_t h_refcount16; +#else + duk_size_t h_refcount; +#endif +#endif +}; + +#define DUK_HEAPHDR_FLAGS_TYPE_MASK 0x00000003UL +#define DUK_HEAPHDR_FLAGS_FLAG_MASK (~DUK_HEAPHDR_FLAGS_TYPE_MASK) + + /* 2 bits for heap type */ +#define DUK_HEAPHDR_FLAGS_HEAP_START 2 /* 4 heap flags */ +#define DUK_HEAPHDR_FLAGS_USER_START 6 /* 26 user flags */ + +#define DUK_HEAPHDR_HEAP_FLAG_NUMBER(n) (DUK_HEAPHDR_FLAGS_HEAP_START + (n)) +#define DUK_HEAPHDR_USER_FLAG_NUMBER(n) (DUK_HEAPHDR_FLAGS_USER_START + (n)) +#define DUK_HEAPHDR_HEAP_FLAG(n) (1UL << (DUK_HEAPHDR_FLAGS_HEAP_START + (n))) +#define DUK_HEAPHDR_USER_FLAG(n) (1UL << (DUK_HEAPHDR_FLAGS_USER_START + (n))) + +#define DUK_HEAPHDR_FLAG_REACHABLE DUK_HEAPHDR_HEAP_FLAG(0) /* mark-and-sweep: reachable */ +#define DUK_HEAPHDR_FLAG_TEMPROOT DUK_HEAPHDR_HEAP_FLAG(1) /* mark-and-sweep: children not processed */ +#define DUK_HEAPHDR_FLAG_FINALIZABLE DUK_HEAPHDR_HEAP_FLAG(2) /* mark-and-sweep: finalizable (on current pass) */ +#define DUK_HEAPHDR_FLAG_FINALIZED DUK_HEAPHDR_HEAP_FLAG(3) /* mark-and-sweep: finalized (on previous pass) */ + +#define DUK_HTYPE_MIN 1 +#define DUK_HTYPE_STRING 1 +#define DUK_HTYPE_OBJECT 2 +#define DUK_HTYPE_BUFFER 3 +#define DUK_HTYPE_MAX 3 + +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HEAPHDR_GET_NEXT(heap,h) \ + ((duk_heaphdr *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->h_next16)) +#define DUK_HEAPHDR_SET_NEXT(heap,h,val) do { \ + (h)->h_next16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) val); \ + } while (0) +#else +#define DUK_HEAPHDR_GET_NEXT(heap,h) ((h)->h_next) +#define DUK_HEAPHDR_SET_NEXT(heap,h,val) do { \ + (h)->h_next = (val); \ + } while (0) +#endif + +#if defined(DUK_USE_DOUBLE_LINKED_HEAP) +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HEAPHDR_GET_PREV(heap,h) \ + ((duk_heaphdr *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->h_prev16)) +#define DUK_HEAPHDR_SET_PREV(heap,h,val) do { \ + (h)->h_prev16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (val)); \ + } while (0) +#else +#define DUK_HEAPHDR_GET_PREV(heap,h) ((h)->h_prev) +#define DUK_HEAPHDR_SET_PREV(heap,h,val) do { \ + (h)->h_prev = (val); \ + } while (0) +#endif +#endif + +#if defined(DUK_USE_REFERENCE_COUNTING) +#if defined(DUK_USE_REFCOUNT16) +#define DUK_HEAPHDR_GET_REFCOUNT(h) ((h)->h_refcount16) +#define DUK_HEAPHDR_SET_REFCOUNT(h,val) do { \ + (h)->h_refcount16 = (val); \ + } while (0) +#define DUK_HEAPHDR_PREINC_REFCOUNT(h) (++(h)->h_refcount16) /* result: updated refcount */ +#define DUK_HEAPHDR_PREDEC_REFCOUNT(h) (--(h)->h_refcount16) /* result: updated refcount */ +#else +#define DUK_HEAPHDR_GET_REFCOUNT(h) ((h)->h_refcount) +#define DUK_HEAPHDR_SET_REFCOUNT(h,val) do { \ + (h)->h_refcount = (val); \ + } while (0) +#define DUK_HEAPHDR_PREINC_REFCOUNT(h) (++(h)->h_refcount) /* result: updated refcount */ +#define DUK_HEAPHDR_PREDEC_REFCOUNT(h) (--(h)->h_refcount) /* result: updated refcount */ +#endif +#else +/* refcount macros not defined without refcounting, caller must #ifdef now */ +#endif /* DUK_USE_REFERENCE_COUNTING */ + +/* + * Note: type is treated as a field separate from flags, so some masking is + * involved in the macros below. + */ + +#define DUK_HEAPHDR_GET_FLAGS_RAW(h) ((h)->h_flags) + +#define DUK_HEAPHDR_GET_FLAGS(h) ((h)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK) +#define DUK_HEAPHDR_SET_FLAGS(h,val) do { \ + (h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) | (val); \ + } while (0) + +#define DUK_HEAPHDR_GET_TYPE(h) ((h)->h_flags & DUK_HEAPHDR_FLAGS_TYPE_MASK) +#define DUK_HEAPHDR_SET_TYPE(h,val) do { \ + (h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_TYPE_MASK)) | (val); \ + } while (0) + +#define DUK_HEAPHDR_HTYPE_VALID(h) ( \ + DUK_HEAPHDR_GET_TYPE((h)) >= DUK_HTYPE_MIN && \ + DUK_HEAPHDR_GET_TYPE((h)) <= DUK_HTYPE_MAX \ + ) + +#define DUK_HEAPHDR_SET_TYPE_AND_FLAGS(h,tval,fval) do { \ + (h)->h_flags = ((tval) & DUK_HEAPHDR_FLAGS_TYPE_MASK) | \ + ((fval) & DUK_HEAPHDR_FLAGS_FLAG_MASK); \ + } while (0) + +#define DUK_HEAPHDR_SET_FLAG_BITS(h,bits) do { \ + DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \ + (h)->h_flags |= (bits); \ + } while (0) + +#define DUK_HEAPHDR_CLEAR_FLAG_BITS(h,bits) do { \ + DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \ + (h)->h_flags &= ~((bits)); \ + } while (0) + +#define DUK_HEAPHDR_CHECK_FLAG_BITS(h,bits) (((h)->h_flags & (bits)) != 0) + +#define DUK_HEAPHDR_SET_REACHABLE(h) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE) +#define DUK_HEAPHDR_CLEAR_REACHABLE(h) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE) +#define DUK_HEAPHDR_HAS_REACHABLE(h) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE) + +#define DUK_HEAPHDR_SET_TEMPROOT(h) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT) +#define DUK_HEAPHDR_CLEAR_TEMPROOT(h) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT) +#define DUK_HEAPHDR_HAS_TEMPROOT(h) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT) + +#define DUK_HEAPHDR_SET_FINALIZABLE(h) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE) +#define DUK_HEAPHDR_CLEAR_FINALIZABLE(h) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE) +#define DUK_HEAPHDR_HAS_FINALIZABLE(h) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE) + +#define DUK_HEAPHDR_SET_FINALIZED(h) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED) +#define DUK_HEAPHDR_CLEAR_FINALIZED(h) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED) +#define DUK_HEAPHDR_HAS_FINALIZED(h) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED) + +/* get or set a range of flags; m=first bit number, n=number of bits */ +#define DUK_HEAPHDR_GET_FLAG_RANGE(h,m,n) (((h)->h_flags >> (m)) & ((1UL << (n)) - 1UL)) + +#define DUK_HEAPHDR_SET_FLAG_RANGE(h,m,n,v) do { \ + (h)->h_flags = \ + ((h)->h_flags & (~(((1 << (n)) - 1) << (m)))) \ + | ((v) << (m)); \ + } while (0) + +/* init pointer fields to null */ +#if defined(DUK_USE_DOUBLE_LINKED_HEAP) +#define DUK_HEAPHDR_INIT_NULLS(h) do { \ + DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \ + DUK_HEAPHDR_SET_PREV((h), (void *) NULL); \ + } while (0) +#else +#define DUK_HEAPHDR_INIT_NULLS(h) do { \ + DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \ + } while (0) +#endif + +#define DUK_HEAPHDR_STRING_INIT_NULLS(h) /* currently nop */ + +/* + * Reference counting helper macros. The macros take a thread argument + * and must thus always be executed in a specific thread context. The + * thread argument is needed for features like finalization. Currently + * it is not required for INCREF, but it is included just in case. + * + * Note that 'raw' macros such as DUK_HEAPHDR_GET_REFCOUNT() are not + * defined without DUK_USE_REFERENCE_COUNTING, so caller must #ifdef + * around them. + */ + +#if defined(DUK_USE_REFERENCE_COUNTING) + +/* Fast variants, inline refcount operations except for refzero handling. + * Can be used explicitly when speed is always more important than size. + * For a good compiler and a single file build, these are basically the + * same as a forced inline. + */ +#define DUK_TVAL_INCREF_FAST(thr,tv) do { \ + duk_tval *duk__tv = (tv); \ + DUK_ASSERT(duk__tv != NULL); \ + if (DUK_TVAL_IS_HEAP_ALLOCATED(duk__tv)) { \ + duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \ + DUK_ASSERT(duk__h != NULL); \ + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \ + DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \ + } \ + } while (0) +#define DUK_TVAL_DECREF_FAST(thr,tv) do { \ + duk_tval *duk__tv = (tv); \ + DUK_ASSERT(duk__tv != NULL); \ + if (DUK_TVAL_IS_HEAP_ALLOCATED(duk__tv)) { \ + duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \ + DUK_ASSERT(duk__h != NULL); \ + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \ + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \ + if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \ + duk_heaphdr_refzero((thr), duk__h); \ + } \ + } \ + } while (0) +#define DUK_HEAPHDR_INCREF_FAST(thr,h) do { \ + duk_heaphdr *duk__h = (duk_heaphdr *) (h); \ + DUK_ASSERT(duk__h != NULL); \ + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \ + DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \ + } while (0) +#define DUK_HEAPHDR_DECREF_FAST(thr,h) do { \ + duk_heaphdr *duk__h = (duk_heaphdr *) (h); \ + DUK_ASSERT(duk__h != NULL); \ + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \ + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \ + if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \ + duk_heaphdr_refzero((thr), duk__h); \ + } \ + } while (0) + +/* Slow variants, call to a helper to reduce code size. + * Can be used explicitly when size is always more important than speed. + */ +#define DUK_TVAL_INCREF_SLOW(thr,tv) do { \ + duk_tval_incref((tv)); \ + } while (0) +#define DUK_TVAL_DECREF_SLOW(thr,tv) do { \ + duk_tval_decref((thr), (tv)); \ + } while (0) +#define DUK_HEAPHDR_INCREF_SLOW(thr,h) do { \ + duk_heaphdr_incref((duk_heaphdr *) (h)); \ + } while (0) +#define DUK_HEAPHDR_DECREF_SLOW(thr,h) do { \ + duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); \ + } while (0) + +/* Default variants. Selection depends on speed/size preference. + * Concretely: with gcc 4.8.1 -Os x64 the difference in final binary + * is about +1kB for _FAST variants. + */ +#if defined(DUK_USE_FAST_REFCOUNT_DEFAULT) +#define DUK_TVAL_INCREF(thr,tv) DUK_TVAL_INCREF_FAST((thr),(tv)) +#define DUK_TVAL_DECREF(thr,tv) DUK_TVAL_DECREF_FAST((thr),(tv)) +#define DUK_HEAPHDR_INCREF(thr,h) DUK_HEAPHDR_INCREF_FAST((thr),(h)) +#define DUK_HEAPHDR_DECREF(thr,h) DUK_HEAPHDR_DECREF_FAST((thr),(h)) +#else +#define DUK_TVAL_INCREF(thr,tv) DUK_TVAL_INCREF_SLOW((thr),(tv)) +#define DUK_TVAL_DECREF(thr,tv) DUK_TVAL_DECREF_SLOW((thr),(tv)) +#define DUK_HEAPHDR_INCREF(thr,h) DUK_HEAPHDR_INCREF_SLOW((thr),(h)) +#define DUK_HEAPHDR_DECREF(thr,h) DUK_HEAPHDR_DECREF_SLOW((thr),(h)) +#endif + +/* Casting convenience. */ +#define DUK_HSTRING_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h)) +#define DUK_HSTRING_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h)) +#define DUK_HOBJECT_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h)) +#define DUK_HOBJECT_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h)) +#define DUK_HBUFFER_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h)) +#define DUK_HBUFFER_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h)) +#define DUK_HCOMPILEDFUNCTION_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj) +#define DUK_HCOMPILEDFUNCTION_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj) +#define DUK_HNATIVEFUNCTION_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj) +#define DUK_HNATIVEFUNCTION_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj) +#define DUK_HBUFFEROBJECT_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj) +#define DUK_HBUFFEROBJECT_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj) +#define DUK_HTHREAD_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj) +#define DUK_HTHREAD_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj) + +/* Convenience for some situations; the above macros don't allow NULLs + * for performance reasons. + */ +#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h) do { \ + if ((h) != NULL) { \ + DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)); \ + } \ + } while (0) +#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h) do { \ + if ((h) != NULL) { \ + DUK_HEAPHDR_DECREF((thr), (duk_heaphdr *) (h)); \ + } \ + } while (0) + +#else /* DUK_USE_REFERENCE_COUNTING */ + +#define DUK_TVAL_INCREF_FAST(thr,v) do {} while (0) /* nop */ +#define DUK_TVAL_DECREF_FAST(thr,v) do {} while (0) /* nop */ +#define DUK_TVAL_INCREF_SLOW(thr,v) do {} while (0) /* nop */ +#define DUK_TVAL_DECREF_SLOW(thr,v) do {} while (0) /* nop */ +#define DUK_TVAL_INCREF(thr,v) do {} while (0) /* nop */ +#define DUK_TVAL_DECREF(thr,v) do {} while (0) /* nop */ +#define DUK_HEAPHDR_INCREF_FAST(thr,h) do {} while (0) /* nop */ +#define DUK_HEAPHDR_DECREF_FAST(thr,h) do {} while (0) /* nop */ +#define DUK_HEAPHDR_INCREF_SLOW(thr,h) do {} while (0) /* nop */ +#define DUK_HEAPHDR_DECREF_SLOW(thr,h) do {} while (0) /* nop */ +#define DUK_HEAPHDR_INCREF(thr,h) do {} while (0) /* nop */ +#define DUK_HEAPHDR_DECREF(thr,h) do {} while (0) /* nop */ +#define DUK_HSTRING_INCREF(thr,h) do {} while (0) /* nop */ +#define DUK_HSTRING_DECREF(thr,h) do {} while (0) /* nop */ +#define DUK_HOBJECT_INCREF(thr,h) do {} while (0) /* nop */ +#define DUK_HOBJECT_DECREF(thr,h) do {} while (0) /* nop */ +#define DUK_HBUFFER_INCREF(thr,h) do {} while (0) /* nop */ +#define DUK_HBUFFER_DECREF(thr,h) do {} while (0) /* nop */ +#define DUK_HCOMPILEDFUNCTION_INCREF(thr,h) do {} while (0) /* nop */ +#define DUK_HCOMPILEDFUNCTION_DECREF(thr,h) do {} while (0) /* nop */ +#define DUK_HNATIVEFUNCTION_INCREF(thr,h) do {} while (0) /* nop */ +#define DUK_HNATIVEFUNCTION_DECREF(thr,h) do {} while (0) /* nop */ +#define DUK_HBUFFEROBJECT_INCREF(thr,h) do {} while (0) /* nop */ +#define DUK_HBUFFEROBJECT_DECREF(thr,h) do {} while (0) /* nop */ +#define DUK_HTHREAD_INCREF(thr,h) do {} while (0) /* nop */ +#define DUK_HTHREAD_DECREF(thr,h) do {} while (0) /* nop */ +#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h) do {} while (0) /* nop */ +#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h) do {} while (0) /* nop */ + +#endif /* DUK_USE_REFERENCE_COUNTING */ + +#endif /* DUK_HEAPHDR_H_INCLUDED */ +#line 1 "duk_api_internal.h" +/* + * Internal API calls which have (stack and other) semantics similar + * to the public API. + */ + +#ifndef DUK_API_INTERNAL_H_INCLUDED +#define DUK_API_INTERNAL_H_INCLUDED + +/* duk_push_sprintf constants */ +#define DUK_PUSH_SPRINTF_INITIAL_SIZE 256L +#define DUK_PUSH_SPRINTF_SANITY_LIMIT (1L * 1024L * 1024L * 1024L) + +/* Flag ORed to err_code to indicate __FILE__ / __LINE__ is not + * blamed as source of error for error fileName / lineNumber. + */ +#define DUK_ERRCODE_FLAG_NOBLAME_FILELINE (1L << 24) + +/* Valstack resize flags */ +#define DUK_VSRESIZE_FLAG_SHRINK (1 << 0) +#define DUK_VSRESIZE_FLAG_COMPACT (1 << 1) +#define DUK_VSRESIZE_FLAG_THROW (1 << 2) + +/* Current convention is to use duk_size_t for value stack sizes and global indices, + * and duk_idx_t for local frame indices. + */ +DUK_INTERNAL_DECL +duk_bool_t duk_valstack_resize_raw(duk_context *ctx, + duk_size_t min_new_size, + duk_small_uint_t flags); + +DUK_INTERNAL_DECL duk_tval *duk_get_tval(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_tval *duk_require_tval(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL void duk_push_tval(duk_context *ctx, duk_tval *tv); + +/* Push the current 'this' binding; throw TypeError if binding is not object + * coercible (CheckObjectCoercible). + */ +DUK_INTERNAL_DECL void duk_push_this_check_object_coercible(duk_context *ctx); + +/* duk_push_this() + CheckObjectCoercible() + duk_to_object() */ +DUK_INTERNAL_DECL duk_hobject *duk_push_this_coercible_to_object(duk_context *ctx); + +/* duk_push_this() + CheckObjectCoercible() + duk_to_string() */ +DUK_INTERNAL_DECL duk_hstring *duk_push_this_coercible_to_string(duk_context *ctx); + +/* Get a borrowed duk_tval pointer to the current 'this' binding. Caller must + * make sure there's an active callstack entry. Note that the returned pointer + * is unstable with regards to side effects. + */ +DUK_INTERNAL_DECL duk_tval *duk_get_borrowed_this_tval(duk_context *ctx); + +/* XXX: add fastint support? */ +#define duk_push_u64(ctx,val) \ + duk_push_number((ctx), (duk_double_t) (val)) +#define duk_push_i64(ctx,val) \ + duk_push_number((ctx), (duk_double_t) (val)) + +/* duk_push_(u)int() is guaranteed to support at least (un)signed 32-bit range */ +#define duk_push_u32(ctx,val) \ + duk_push_uint((ctx), (duk_uint_t) (val)) +#define duk_push_i32(ctx,val) \ + duk_push_int((ctx), (duk_int_t) (val)) + +/* sometimes stack and array indices need to go on the stack */ +#define duk_push_idx(ctx,val) \ + duk_push_int((ctx), (duk_int_t) (val)) +#define duk_push_uarridx(ctx,val) \ + duk_push_uint((ctx), (duk_uint_t) (val)) +#define duk_push_size_t(ctx,val) \ + duk_push_uint((ctx), (duk_uint_t) (val)) /* XXX: assumed to fit for now */ + +/* internal helper for looking up a tagged type */ +#define DUK_GETTAGGED_FLAG_ALLOW_NULL (1L << 24) +#define DUK_GETTAGGED_FLAG_CHECK_CLASS (1L << 25) +#define DUK_GETTAGGED_CLASS_SHIFT 16 + +DUK_INTERNAL_DECL duk_heaphdr *duk_get_tagged_heaphdr_raw(duk_context *ctx, duk_idx_t index, duk_uint_t flags_and_tag); + +DUK_INTERNAL_DECL duk_hstring *duk_get_hstring(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_hobject *duk_get_hobject(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_hbuffer *duk_get_hbuffer(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_hthread *duk_get_hthread(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_hcompiledfunction *duk_get_hcompiledfunction(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_hnativefunction *duk_get_hnativefunction(duk_context *ctx, duk_idx_t index); + +#define duk_get_hobject_with_class(ctx,index,classnum) \ + ((duk_hobject *) duk_get_tagged_heaphdr_raw((ctx), (index), \ + DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL | \ + DUK_GETTAGGED_FLAG_CHECK_CLASS | ((classnum) << DUK_GETTAGGED_CLASS_SHIFT))) + +#if 0 /* This would be pointless: unexpected type and lightfunc would both return NULL */ +DUK_INTERNAL_DECL duk_hobject *duk_get_hobject_or_lfunc(duk_context *ctx, duk_idx_t index); +#endif +DUK_INTERNAL_DECL duk_hobject *duk_get_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index); + +#if 0 /*unused*/ +DUK_INTERNAL_DECL void *duk_get_voidptr(duk_context *ctx, duk_idx_t index); +#endif + +DUK_INTERNAL_DECL duk_hstring *duk_to_hstring(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_int_t duk_to_int_clamped_raw(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval, duk_bool_t *out_clamped); /* out_clamped=NULL, RangeError if outside range */ +DUK_INTERNAL_DECL duk_int_t duk_to_int_clamped(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval); +DUK_INTERNAL_DECL duk_int_t duk_to_int_check_range(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval); +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL_DECL duk_uint8_t duk_to_uint8clamped(duk_context *ctx, duk_idx_t index); +#endif + +DUK_INTERNAL_DECL duk_hstring *duk_require_hstring(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_hobject *duk_require_hobject(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_hbuffer *duk_require_hbuffer(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_hthread *duk_require_hthread(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_hcompiledfunction *duk_require_hcompiledfunction(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_hnativefunction *duk_require_hnativefunction(duk_context *ctx, duk_idx_t index); + +#define duk_require_hobject_with_class(ctx,index,classnum) \ + ((duk_hobject *) duk_get_tagged_heaphdr_raw((ctx), (index), \ + DUK_TAG_OBJECT | \ + DUK_GETTAGGED_FLAG_CHECK_CLASS | ((classnum) << DUK_GETTAGGED_CLASS_SHIFT))) + +DUK_INTERNAL_DECL duk_hobject *duk_require_hobject_or_lfunc(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL duk_hobject *duk_require_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index); + +#if defined(DUK_USE_DEBUGGER_SUPPORT) +DUK_INTERNAL_DECL void duk_push_unused(duk_context *ctx); +#endif +DUK_INTERNAL_DECL void duk_push_hstring(duk_context *ctx, duk_hstring *h); +DUK_INTERNAL_DECL void duk_push_hstring_stridx(duk_context *ctx, duk_small_int_t stridx); +DUK_INTERNAL_DECL void duk_push_hobject(duk_context *ctx, duk_hobject *h); +DUK_INTERNAL_DECL void duk_push_hbuffer(duk_context *ctx, duk_hbuffer *h); +#define duk_push_hthread(ctx,h) \ + duk_push_hobject((ctx), (duk_hobject *) (h)) +#define duk_push_hcompiledfunction(ctx,h) \ + duk_push_hobject((ctx), (duk_hobject *) (h)) +#define duk_push_hnativefunction(ctx,h) \ + duk_push_hobject((ctx), (duk_hobject *) (h)) +DUK_INTERNAL_DECL void duk_push_hobject_bidx(duk_context *ctx, duk_small_int_t builtin_idx); +DUK_INTERNAL_DECL duk_idx_t duk_push_object_helper(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx); +DUK_INTERNAL_DECL duk_idx_t duk_push_object_helper_proto(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_hobject *proto); +DUK_INTERNAL_DECL duk_idx_t duk_push_object_internal(duk_context *ctx); +DUK_INTERNAL_DECL duk_idx_t duk_push_compiledfunction(duk_context *ctx); +DUK_INTERNAL_DECL void duk_push_c_function_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs); +DUK_INTERNAL_DECL void duk_push_c_function_noconstruct_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs); + +DUK_INTERNAL_DECL void duk_push_string_funcptr(duk_context *ctx, duk_uint8_t *ptr, duk_size_t sz); +DUK_INTERNAL_DECL void duk_push_lightfunc_name(duk_context *ctx, duk_tval *tv); +DUK_INTERNAL_DECL void duk_push_lightfunc_tostring(duk_context *ctx, duk_tval *tv); +DUK_INTERNAL_DECL duk_hbufferobject *duk_push_bufferobject_raw(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx); + +DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx); /* [] -> [val] */ +DUK_INTERNAL_DECL duk_bool_t duk_put_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx); /* [val] -> [] */ +DUK_INTERNAL_DECL duk_bool_t duk_del_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx); /* [] -> [] */ +DUK_INTERNAL_DECL duk_bool_t duk_has_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx); /* [] -> [] */ + +DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx_boolean(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_bool_t *out_has_prop); /* [] -> [] */ + +DUK_INTERNAL_DECL void duk_xdef_prop(duk_context *ctx, duk_idx_t obj_index, duk_small_uint_t desc_flags); /* [key val] -> [] */ +DUK_INTERNAL_DECL void duk_xdef_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index, duk_small_uint_t desc_flags); /* [val] -> [] */ +DUK_INTERNAL_DECL void duk_xdef_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags); /* [val] -> [] */ +DUK_INTERNAL_DECL void duk_xdef_prop_stridx_builtin(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_int_t builtin_idx, duk_small_uint_t desc_flags); /* [] -> [] */ +DUK_INTERNAL_DECL void duk_xdef_prop_stridx_thrower(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags); /* [] -> [] */ + +/* These are macros for now, but could be separate functions to reduce code + * footprint (check call site count before refactoring). + */ +#define duk_xdef_prop_wec(ctx,obj_index) \ + duk_xdef_prop((ctx), (obj_index), DUK_PROPDESC_FLAGS_WEC) +#define duk_xdef_prop_index_wec(ctx,obj_index,arr_index) \ + duk_xdef_prop_index((ctx), (obj_index), (arr_index), DUK_PROPDESC_FLAGS_WEC) +#define duk_xdef_prop_stridx_wec(ctx,obj_index,stridx) \ + duk_xdef_prop_stridx((ctx), (obj_index), (stridx), DUK_PROPDESC_FLAGS_WEC) + +/* Set object 'length'. */ +DUK_INTERNAL_DECL void duk_set_length(duk_context *ctx, duk_idx_t index, duk_size_t length); + +#endif /* DUK_API_INTERNAL_H_INCLUDED */ +#line 1 "duk_hstring.h" +/* + * Heap string representation. + * + * Strings are byte sequences ordinarily stored in extended UTF-8 format, + * allowing values larger than the official UTF-8 range (used internally) + * and also allowing UTF-8 encoding of surrogate pairs (CESU-8 format). + * Strings may also be invalid UTF-8 altogether which is the case e.g. with + * strings used as internal property names and raw buffers converted to + * strings. In such cases the 'clen' field contains an inaccurate value. + * + * Ecmascript requires support for 32-bit long strings. However, since each + * 16-bit codepoint can take 3 bytes in CESU-8, this representation can only + * support about 1.4G codepoint long strings in extreme cases. This is not + * really a practical issue. + */ + +#ifndef DUK_HSTRING_H_INCLUDED +#define DUK_HSTRING_H_INCLUDED + +/* Impose a maximum string length for now. Restricted artificially to + * ensure adding a heap header length won't overflow size_t. The limit + * should be synchronized with DUK_HBUFFER_MAX_BYTELEN. + * + * E5.1 makes provisions to support strings longer than 4G characters. + * This limit should be eliminated on 64-bit platforms (and increased + * closer to maximum support on 32-bit platforms). + */ + +#if defined(DUK_USE_STRLEN16) +#define DUK_HSTRING_MAX_BYTELEN (0x0000ffffUL) +#else +#define DUK_HSTRING_MAX_BYTELEN (0x7fffffffUL) +#endif + +/* XXX: could add flags for "is valid CESU-8" (Ecmascript compatible strings), + * "is valid UTF-8", "is valid extended UTF-8" (internal strings are not, + * regexp bytecode is), and "contains non-BMP characters". These are not + * needed right now. + */ + +#define DUK_HSTRING_FLAG_ARRIDX DUK_HEAPHDR_USER_FLAG(0) /* string is a valid array index */ +#define DUK_HSTRING_FLAG_INTERNAL DUK_HEAPHDR_USER_FLAG(1) /* string is internal */ +#define DUK_HSTRING_FLAG_RESERVED_WORD DUK_HEAPHDR_USER_FLAG(2) /* string is a reserved word (non-strict) */ +#define DUK_HSTRING_FLAG_STRICT_RESERVED_WORD DUK_HEAPHDR_USER_FLAG(3) /* string is a reserved word (strict) */ +#define DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS DUK_HEAPHDR_USER_FLAG(4) /* string is 'eval' or 'arguments' */ +#define DUK_HSTRING_FLAG_EXTDATA DUK_HEAPHDR_USER_FLAG(5) /* string data is external (duk_hstring_external) */ + +#define DUK_HSTRING_HAS_ARRIDX(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX) +#define DUK_HSTRING_HAS_INTERNAL(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL) +#define DUK_HSTRING_HAS_RESERVED_WORD(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD) +#define DUK_HSTRING_HAS_STRICT_RESERVED_WORD(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD) +#define DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS) +#define DUK_HSTRING_HAS_EXTDATA(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA) + +#define DUK_HSTRING_SET_ARRIDX(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX) +#define DUK_HSTRING_SET_INTERNAL(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL) +#define DUK_HSTRING_SET_RESERVED_WORD(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD) +#define DUK_HSTRING_SET_STRICT_RESERVED_WORD(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD) +#define DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS) +#define DUK_HSTRING_SET_EXTDATA(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA) + +#define DUK_HSTRING_CLEAR_ARRIDX(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX) +#define DUK_HSTRING_CLEAR_INTERNAL(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL) +#define DUK_HSTRING_CLEAR_RESERVED_WORD(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD) +#define DUK_HSTRING_CLEAR_STRICT_RESERVED_WORD(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD) +#define DUK_HSTRING_CLEAR_EVAL_OR_ARGUMENTS(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS) +#define DUK_HSTRING_CLEAR_EXTDATA(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA) + +#define DUK_HSTRING_IS_ASCII(x) (DUK_HSTRING_GET_BYTELEN((x)) == DUK_HSTRING_GET_CHARLEN((x))) +#define DUK_HSTRING_IS_EMPTY(x) (DUK_HSTRING_GET_BYTELEN((x)) == 0) + +#if defined(DUK_USE_STRHASH16) +#define DUK_HSTRING_GET_HASH(x) ((x)->hdr.h_flags >> 16) +#define DUK_HSTRING_SET_HASH(x,v) do { \ + (x)->hdr.h_flags = ((x)->hdr.h_flags & 0x0000ffffUL) | ((v) << 16); \ + } while (0) +#else +#define DUK_HSTRING_GET_HASH(x) ((x)->hash) +#define DUK_HSTRING_SET_HASH(x,v) do { \ + (x)->hash = (v); \ + } while (0) +#endif + +#if defined(DUK_USE_STRLEN16) +#define DUK_HSTRING_GET_BYTELEN(x) ((x)->blen16) +#define DUK_HSTRING_SET_BYTELEN(x,v) do { \ + (x)->blen16 = (v); \ + } while (0) +#define DUK_HSTRING_GET_CHARLEN(x) ((x)->clen16) +#define DUK_HSTRING_SET_CHARLEN(x,v) do { \ + (x)->clen16 = (v); \ + } while (0) +#else +#define DUK_HSTRING_GET_BYTELEN(x) ((x)->blen) +#define DUK_HSTRING_SET_BYTELEN(x,v) do { \ + (x)->blen = (v); \ + } while (0) +#define DUK_HSTRING_GET_CHARLEN(x) ((x)->clen) +#define DUK_HSTRING_SET_CHARLEN(x,v) do { \ + (x)->clen = (v); \ + } while (0) +#endif + +#if defined(DUK_USE_HSTRING_EXTDATA) +#define DUK_HSTRING_GET_EXTDATA(x) \ + ((x)->extdata) +#define DUK_HSTRING_GET_DATA(x) \ + (DUK_HSTRING_HAS_EXTDATA((x)) ? \ + DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) (x)) : ((const duk_uint8_t *) ((x) + 1))) +#else +#define DUK_HSTRING_GET_DATA(x) \ + ((const duk_uint8_t *) ((x) + 1)) +#endif + +#define DUK_HSTRING_GET_DATA_END(x) \ + (DUK_HSTRING_GET_DATA((x)) + (x)->blen) + +/* marker value; in E5 2^32-1 is not a valid array index (2^32-2 is highest valid) */ +#define DUK_HSTRING_NO_ARRAY_INDEX (0xffffffffUL) + +/* get array index related to string (or return DUK_HSTRING_NO_ARRAY_INDEX); + * avoids helper call if string has no array index value. + */ +#define DUK_HSTRING_GET_ARRIDX_FAST(h) \ + (DUK_HSTRING_HAS_ARRIDX((h)) ? duk_js_to_arrayindex_string_helper((h)) : DUK_HSTRING_NO_ARRAY_INDEX) + +/* slower but more compact variant */ +#define DUK_HSTRING_GET_ARRIDX_SLOW(h) \ + (duk_js_to_arrayindex_string_helper((h))) + +/* + * Misc + */ + +struct duk_hstring { + /* Smaller heaphdr than for other objects, because strings are held + * in string intern table which requires no link pointers. Much of + * the 32-bit flags field is unused by flags, so we can stuff a 16-bit + * field in there. + */ + duk_heaphdr_string hdr; + + /* Note: we could try to stuff a partial hash (e.g. 16 bits) into the + * shared heap header. Good hashing needs more hash bits though. + */ + + /* string hash */ +#if defined(DUK_USE_STRHASH16) + /* If 16-bit hash is in use, stuff it into duk_heaphdr_string flags. */ +#else + duk_uint32_t hash; +#endif + + /* length in bytes (not counting NUL term) */ +#if defined(DUK_USE_STRLEN16) + duk_uint16_t blen16; +#else + duk_uint32_t blen; +#endif + + /* length in codepoints (must be E5 compatible) */ +#if defined(DUK_USE_STRLEN16) + duk_uint16_t clen16; +#else + duk_uint32_t clen; +#endif + + /* + * String value of 'blen+1' bytes follows (+1 for NUL termination + * convenience for C API). No alignment needs to be guaranteed + * for strings, but fields above should guarantee alignment-by-4 + * (but not alignment-by-8). + */ +}; + +/* The external string struct is defined even when the feature is inactive. */ +struct duk_hstring_external { + duk_hstring str; + + /* + * For an external string, the NUL-terminated string data is stored + * externally. The user must guarantee that data behind this pointer + * doesn't change while it's used. + */ + + const duk_uint8_t *extdata; +}; + +/* + * Prototypes + */ + +DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr, duk_hstring *h, duk_uint_t pos); + +#endif /* DUK_HSTRING_H_INCLUDED */ +#line 1 "duk_hobject.h" +/* + * Heap object representation. + * + * Heap objects are used for Ecmascript objects, arrays, and functions, + * but also for internal control like declarative and object environment + * records. Compiled functions, native functions, and threads are also + * objects but with an extended C struct. + * + * Objects provide the required Ecmascript semantics and exotic behaviors + * especially for property access. + * + * Properties are stored in three conceptual parts: + * + * 1. A linear 'entry part' contains ordered key-value-attributes triples + * and is the main method of string properties. + * + * 2. An optional linear 'array part' is used for array objects to store a + * (dense) range of [0,N[ array indexed entries with default attributes + * (writable, enumerable, configurable). If the array part would become + * sparse or non-default attributes are required, the array part is + * abandoned and moved to the 'entry part'. + * + * 3. An optional 'hash part' is used to optimize lookups of the entry + * part; it is used only for objects with sufficiently many properties + * and can be abandoned without loss of information. + * + * These three conceptual parts are stored in a single memory allocated area. + * This minimizes memory allocation overhead but also means that all three + * parts are resized together, and makes property access a bit complicated. + */ + +#ifndef DUK_HOBJECT_H_INCLUDED +#define DUK_HOBJECT_H_INCLUDED + +/* there are currently 26 flag bits available */ +#define DUK_HOBJECT_FLAG_EXTENSIBLE DUK_HEAPHDR_USER_FLAG(0) /* object is extensible */ +#define DUK_HOBJECT_FLAG_CONSTRUCTABLE DUK_HEAPHDR_USER_FLAG(1) /* object is constructable */ +#define DUK_HOBJECT_FLAG_BOUND DUK_HEAPHDR_USER_FLAG(2) /* object established using Function.prototype.bind() */ +#define DUK_HOBJECT_FLAG_COMPILEDFUNCTION DUK_HEAPHDR_USER_FLAG(4) /* object is a compiled function (duk_hcompiledfunction) */ +#define DUK_HOBJECT_FLAG_NATIVEFUNCTION DUK_HEAPHDR_USER_FLAG(5) /* object is a native function (duk_hnativefunction) */ +#define DUK_HOBJECT_FLAG_BUFFEROBJECT DUK_HEAPHDR_USER_FLAG(6) /* object is a buffer object (duk_hbufferobject) (always exotic) */ +#define DUK_HOBJECT_FLAG_THREAD DUK_HEAPHDR_USER_FLAG(7) /* object is a thread (duk_hthread) */ +#define DUK_HOBJECT_FLAG_ARRAY_PART DUK_HEAPHDR_USER_FLAG(8) /* object has an array part (a_size may still be 0) */ +#define DUK_HOBJECT_FLAG_STRICT DUK_HEAPHDR_USER_FLAG(9) /* function: function object is strict */ +#define DUK_HOBJECT_FLAG_NOTAIL DUK_HEAPHDR_USER_FLAG(10) /* function: function must not be tail called */ +#define DUK_HOBJECT_FLAG_NEWENV DUK_HEAPHDR_USER_FLAG(11) /* function: create new environment when called (see duk_hcompiledfunction) */ +#define DUK_HOBJECT_FLAG_NAMEBINDING DUK_HEAPHDR_USER_FLAG(12) /* function: create binding for func name (function templates only, used for named function expressions) */ +#define DUK_HOBJECT_FLAG_CREATEARGS DUK_HEAPHDR_USER_FLAG(13) /* function: create an arguments object on function call */ +#define DUK_HOBJECT_FLAG_ENVRECCLOSED DUK_HEAPHDR_USER_FLAG(14) /* envrec: (declarative) record is closed */ +#define DUK_HOBJECT_FLAG_EXOTIC_ARRAY DUK_HEAPHDR_USER_FLAG(15) /* 'Array' object, array length and index exotic behavior */ +#define DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ DUK_HEAPHDR_USER_FLAG(16) /* 'String' object, array index exotic behavior */ +#define DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS DUK_HEAPHDR_USER_FLAG(17) /* 'Arguments' object and has arguments exotic behavior (non-strict callee) */ +#define DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC DUK_HEAPHDR_USER_FLAG(18) /* Duktape/C (nativefunction) object, exotic 'length' */ +#define DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ DUK_HEAPHDR_USER_FLAG(19) /* 'Proxy' object */ + +#define DUK_HOBJECT_FLAG_CLASS_BASE DUK_HEAPHDR_USER_FLAG_NUMBER(21) +#define DUK_HOBJECT_FLAG_CLASS_BITS 5 + +#define DUK_HOBJECT_GET_CLASS_NUMBER(h) \ + DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS) +#define DUK_HOBJECT_SET_CLASS_NUMBER(h,v) \ + DUK_HEAPHDR_SET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS, (v)) + +#define DUK_HOBJECT_GET_CLASS_MASK(h) \ + (1UL << DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS)) + +/* Macro for creating flag initializer from a class number. + * Unsigned type cast is needed to avoid warnings about coercing + * a signed integer to an unsigned one; the largest class values + * have the highest bit (bit 31) set which causes this. + */ +#define DUK_HOBJECT_CLASS_AS_FLAGS(v) (((duk_uint_t) (v)) << DUK_HOBJECT_FLAG_CLASS_BASE) + +/* E5 Section 8.6.2 + custom classes */ +#define DUK_HOBJECT_CLASS_UNUSED 0 +#define DUK_HOBJECT_CLASS_ARGUMENTS 1 +#define DUK_HOBJECT_CLASS_ARRAY 2 +#define DUK_HOBJECT_CLASS_BOOLEAN 3 +#define DUK_HOBJECT_CLASS_DATE 4 +#define DUK_HOBJECT_CLASS_ERROR 5 +#define DUK_HOBJECT_CLASS_FUNCTION 6 +#define DUK_HOBJECT_CLASS_JSON 7 +#define DUK_HOBJECT_CLASS_MATH 8 +#define DUK_HOBJECT_CLASS_NUMBER 9 +#define DUK_HOBJECT_CLASS_OBJECT 10 +#define DUK_HOBJECT_CLASS_REGEXP 11 +#define DUK_HOBJECT_CLASS_STRING 12 +#define DUK_HOBJECT_CLASS_GLOBAL 13 +#define DUK_HOBJECT_CLASS_OBJENV 14 /* custom */ +#define DUK_HOBJECT_CLASS_DECENV 15 /* custom */ +#define DUK_HOBJECT_CLASS_BUFFER 16 /* custom; implies DUK_HOBJECT_IS_BUFFEROBJECT */ +#define DUK_HOBJECT_CLASS_POINTER 17 /* custom */ +#define DUK_HOBJECT_CLASS_THREAD 18 /* custom; implies DUK_HOBJECT_IS_THREAD */ +#define DUK_HOBJECT_CLASS_ARRAYBUFFER 19 /* implies DUK_HOBJECT_IS_BUFFEROBJECT */ +#define DUK_HOBJECT_CLASS_DATAVIEW 20 +#define DUK_HOBJECT_CLASS_INT8ARRAY 21 +#define DUK_HOBJECT_CLASS_UINT8ARRAY 22 +#define DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY 23 +#define DUK_HOBJECT_CLASS_INT16ARRAY 24 +#define DUK_HOBJECT_CLASS_UINT16ARRAY 25 +#define DUK_HOBJECT_CLASS_INT32ARRAY 26 +#define DUK_HOBJECT_CLASS_UINT32ARRAY 27 +#define DUK_HOBJECT_CLASS_FLOAT32ARRAY 28 +#define DUK_HOBJECT_CLASS_FLOAT64ARRAY 29 +#define DUK_HOBJECT_CLASS_MAX 29 + +/* class masks */ +#define DUK_HOBJECT_CMASK_ALL ((1UL << (DUK_HOBJECT_CLASS_MAX + 1)) - 1UL) +#define DUK_HOBJECT_CMASK_UNUSED (1UL << DUK_HOBJECT_CLASS_UNUSED) +#define DUK_HOBJECT_CMASK_ARGUMENTS (1UL << DUK_HOBJECT_CLASS_ARGUMENTS) +#define DUK_HOBJECT_CMASK_ARRAY (1UL << DUK_HOBJECT_CLASS_ARRAY) +#define DUK_HOBJECT_CMASK_BOOLEAN (1UL << DUK_HOBJECT_CLASS_BOOLEAN) +#define DUK_HOBJECT_CMASK_DATE (1UL << DUK_HOBJECT_CLASS_DATE) +#define DUK_HOBJECT_CMASK_ERROR (1UL << DUK_HOBJECT_CLASS_ERROR) +#define DUK_HOBJECT_CMASK_FUNCTION (1UL << DUK_HOBJECT_CLASS_FUNCTION) +#define DUK_HOBJECT_CMASK_JSON (1UL << DUK_HOBJECT_CLASS_JSON) +#define DUK_HOBJECT_CMASK_MATH (1UL << DUK_HOBJECT_CLASS_MATH) +#define DUK_HOBJECT_CMASK_NUMBER (1UL << DUK_HOBJECT_CLASS_NUMBER) +#define DUK_HOBJECT_CMASK_OBJECT (1UL << DUK_HOBJECT_CLASS_OBJECT) +#define DUK_HOBJECT_CMASK_REGEXP (1UL << DUK_HOBJECT_CLASS_REGEXP) +#define DUK_HOBJECT_CMASK_STRING (1UL << DUK_HOBJECT_CLASS_STRING) +#define DUK_HOBJECT_CMASK_GLOBAL (1UL << DUK_HOBJECT_CLASS_GLOBAL) +#define DUK_HOBJECT_CMASK_OBJENV (1UL << DUK_HOBJECT_CLASS_OBJENV) +#define DUK_HOBJECT_CMASK_DECENV (1UL << DUK_HOBJECT_CLASS_DECENV) +#define DUK_HOBJECT_CMASK_BUFFER (1UL << DUK_HOBJECT_CLASS_BUFFER) +#define DUK_HOBJECT_CMASK_POINTER (1UL << DUK_HOBJECT_CLASS_POINTER) +#define DUK_HOBJECT_CMASK_THREAD (1UL << DUK_HOBJECT_CLASS_THREAD) +#define DUK_HOBJECT_CMASK_ARRAYBUFFER (1UL << DUK_HOBJECT_CLASS_ARRAYBUFFER) +#define DUK_HOBJECT_CMASK_DATAVIEW (1UL << DUK_HOBJECT_CLASS_DATAVIEW) +#define DUK_HOBJECT_CMASK_INT8ARRAY (1UL << DUK_HOBJECT_CLASS_INT8ARRAY) +#define DUK_HOBJECT_CMASK_UINT8ARRAY (1UL << DUK_HOBJECT_CLASS_UINT8ARRAY) +#define DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY (1UL << DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY) +#define DUK_HOBJECT_CMASK_INT16ARRAY (1UL << DUK_HOBJECT_CLASS_INT16ARRAY) +#define DUK_HOBJECT_CMASK_UINT16ARRAY (1UL << DUK_HOBJECT_CLASS_UINT16ARRAY) +#define DUK_HOBJECT_CMASK_INT32ARRAY (1UL << DUK_HOBJECT_CLASS_INT32ARRAY) +#define DUK_HOBJECT_CMASK_UINT32ARRAY (1UL << DUK_HOBJECT_CLASS_UINT32ARRAY) +#define DUK_HOBJECT_CMASK_FLOAT32ARRAY (1UL << DUK_HOBJECT_CLASS_FLOAT32ARRAY) +#define DUK_HOBJECT_CMASK_FLOAT64ARRAY (1UL << DUK_HOBJECT_CLASS_FLOAT64ARRAY) + +#define DUK_HOBJECT_CMASK_ALL_BUFFEROBJECTS \ + (DUK_HOBJECT_CMASK_BUFFER | \ + DUK_HOBJECT_CMASK_ARRAYBUFFER | \ + DUK_HOBJECT_CMASK_DATAVIEW | \ + DUK_HOBJECT_CMASK_INT8ARRAY | \ + DUK_HOBJECT_CMASK_UINT8ARRAY | \ + DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY | \ + DUK_HOBJECT_CMASK_INT16ARRAY | \ + DUK_HOBJECT_CMASK_UINT16ARRAY | \ + DUK_HOBJECT_CMASK_INT32ARRAY | \ + DUK_HOBJECT_CMASK_UINT32ARRAY | \ + DUK_HOBJECT_CMASK_FLOAT32ARRAY | \ + DUK_HOBJECT_CMASK_FLOAT64ARRAY) + +#define DUK_HOBJECT_IS_OBJENV(h) (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_OBJENV) +#define DUK_HOBJECT_IS_DECENV(h) (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DECENV) +#define DUK_HOBJECT_IS_ENV(h) (DUK_HOBJECT_IS_OBJENV((h)) || DUK_HOBJECT_IS_DECENV((h))) +#define DUK_HOBJECT_IS_ARRAY(h) (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_ARRAY) +#define DUK_HOBJECT_IS_COMPILEDFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION) +#define DUK_HOBJECT_IS_NATIVEFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION) +#define DUK_HOBJECT_IS_BUFFEROBJECT(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT) +#define DUK_HOBJECT_IS_THREAD(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD) + +#define DUK_HOBJECT_IS_NONBOUND_FUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \ + DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \ + DUK_HOBJECT_FLAG_NATIVEFUNCTION) + +#define DUK_HOBJECT_IS_FUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \ + DUK_HOBJECT_FLAG_BOUND | \ + DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \ + DUK_HOBJECT_FLAG_NATIVEFUNCTION) + +#define DUK_HOBJECT_IS_CALLABLE(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \ + DUK_HOBJECT_FLAG_BOUND | \ + DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \ + DUK_HOBJECT_FLAG_NATIVEFUNCTION) + +/* object has any exotic behavior(s) */ +#define DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS (DUK_HOBJECT_FLAG_EXOTIC_ARRAY | \ + DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS | \ + DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | \ + DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC | \ + DUK_HOBJECT_FLAG_BUFFEROBJECT | \ + DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ) + +#define DUK_HOBJECT_HAS_EXOTIC_BEHAVIOR(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS) + +#define DUK_HOBJECT_HAS_EXTENSIBLE(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE) +#define DUK_HOBJECT_HAS_CONSTRUCTABLE(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE) +#define DUK_HOBJECT_HAS_BOUND(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND) +#define DUK_HOBJECT_HAS_COMPILEDFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION) +#define DUK_HOBJECT_HAS_NATIVEFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION) +#define DUK_HOBJECT_HAS_BUFFEROBJECT(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT) +#define DUK_HOBJECT_HAS_THREAD(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD) +#define DUK_HOBJECT_HAS_ARRAY_PART(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART) +#define DUK_HOBJECT_HAS_STRICT(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT) +#define DUK_HOBJECT_HAS_NOTAIL(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL) +#define DUK_HOBJECT_HAS_NEWENV(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV) +#define DUK_HOBJECT_HAS_NAMEBINDING(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING) +#define DUK_HOBJECT_HAS_CREATEARGS(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS) +#define DUK_HOBJECT_HAS_ENVRECCLOSED(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED) +#define DUK_HOBJECT_HAS_EXOTIC_ARRAY(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY) +#define DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ) +#define DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS) +#define DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC) +#define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ) + +#define DUK_HOBJECT_SET_EXTENSIBLE(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE) +#define DUK_HOBJECT_SET_CONSTRUCTABLE(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE) +#define DUK_HOBJECT_SET_BOUND(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND) +#define DUK_HOBJECT_SET_COMPILEDFUNCTION(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION) +#define DUK_HOBJECT_SET_NATIVEFUNCTION(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION) +#define DUK_HOBJECT_SET_BUFFEROBJECT(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT) +#define DUK_HOBJECT_SET_THREAD(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD) +#define DUK_HOBJECT_SET_ARRAY_PART(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART) +#define DUK_HOBJECT_SET_STRICT(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT) +#define DUK_HOBJECT_SET_NOTAIL(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL) +#define DUK_HOBJECT_SET_NEWENV(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV) +#define DUK_HOBJECT_SET_NAMEBINDING(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING) +#define DUK_HOBJECT_SET_CREATEARGS(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS) +#define DUK_HOBJECT_SET_ENVRECCLOSED(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED) +#define DUK_HOBJECT_SET_EXOTIC_ARRAY(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY) +#define DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ) +#define DUK_HOBJECT_SET_EXOTIC_ARGUMENTS(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS) +#define DUK_HOBJECT_SET_EXOTIC_DUKFUNC(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC) +#define DUK_HOBJECT_SET_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ) + +#define DUK_HOBJECT_CLEAR_EXTENSIBLE(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE) +#define DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE) +#define DUK_HOBJECT_CLEAR_BOUND(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND) +#define DUK_HOBJECT_CLEAR_COMPILEDFUNCTION(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION) +#define DUK_HOBJECT_CLEAR_NATIVEFUNCTION(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION) +#define DUK_HOBJECT_CLEAR_BUFFEROBJECT(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT) +#define DUK_HOBJECT_CLEAR_THREAD(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD) +#define DUK_HOBJECT_CLEAR_ARRAY_PART(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART) +#define DUK_HOBJECT_CLEAR_STRICT(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT) +#define DUK_HOBJECT_CLEAR_NOTAIL(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL) +#define DUK_HOBJECT_CLEAR_NEWENV(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV) +#define DUK_HOBJECT_CLEAR_NAMEBINDING(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING) +#define DUK_HOBJECT_CLEAR_CREATEARGS(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS) +#define DUK_HOBJECT_CLEAR_ENVRECCLOSED(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED) +#define DUK_HOBJECT_CLEAR_EXOTIC_ARRAY(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY) +#define DUK_HOBJECT_CLEAR_EXOTIC_STRINGOBJ(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ) +#define DUK_HOBJECT_CLEAR_EXOTIC_ARGUMENTS(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS) +#define DUK_HOBJECT_CLEAR_EXOTIC_DUKFUNC(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC) +#define DUK_HOBJECT_CLEAR_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ) + +/* flags used for property attributes in duk_propdesc and packed flags */ +#define DUK_PROPDESC_FLAG_WRITABLE (1 << 0) /* E5 Section 8.6.1 */ +#define DUK_PROPDESC_FLAG_ENUMERABLE (1 << 1) /* E5 Section 8.6.1 */ +#define DUK_PROPDESC_FLAG_CONFIGURABLE (1 << 2) /* E5 Section 8.6.1 */ +#define DUK_PROPDESC_FLAG_ACCESSOR (1 << 3) /* accessor */ +#define DUK_PROPDESC_FLAG_VIRTUAL (1 << 4) /* property is virtual: used in duk_propdesc, never stored + * (used by e.g. buffer virtual properties) + */ +#define DUK_PROPDESC_FLAGS_MASK (DUK_PROPDESC_FLAG_WRITABLE | \ + DUK_PROPDESC_FLAG_ENUMERABLE | \ + DUK_PROPDESC_FLAG_CONFIGURABLE | \ + DUK_PROPDESC_FLAG_ACCESSOR) + +/* additional flags which are passed in the same flags argument as property + * flags but are not stored in object properties. + */ +#define DUK_PROPDESC_FLAG_NO_OVERWRITE (1 << 4) /* internal define property: skip write silently if exists */ + +/* convenience */ +#define DUK_PROPDESC_FLAGS_NONE 0 +#define DUK_PROPDESC_FLAGS_W (DUK_PROPDESC_FLAG_WRITABLE) +#define DUK_PROPDESC_FLAGS_E (DUK_PROPDESC_FLAG_ENUMERABLE) +#define DUK_PROPDESC_FLAGS_C (DUK_PROPDESC_FLAG_CONFIGURABLE) +#define DUK_PROPDESC_FLAGS_WE (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_ENUMERABLE) +#define DUK_PROPDESC_FLAGS_WC (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_CONFIGURABLE) +#define DUK_PROPDESC_FLAGS_EC (DUK_PROPDESC_FLAG_ENUMERABLE | DUK_PROPDESC_FLAG_CONFIGURABLE) +#define DUK_PROPDESC_FLAGS_WEC (DUK_PROPDESC_FLAG_WRITABLE | \ + DUK_PROPDESC_FLAG_ENUMERABLE | \ + DUK_PROPDESC_FLAG_CONFIGURABLE) + +/* + * Macro for object validity check + * + * Assert for currently guaranteed relations between flags, for instance. + */ + +#define DUK_ASSERT_HOBJECT_VALID(h) do { \ + DUK_ASSERT((h) != NULL); \ + DUK_ASSERT(!DUK_HOBJECT_IS_CALLABLE((h)) || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FUNCTION); \ + DUK_ASSERT(!DUK_HOBJECT_IS_BUFFEROBJECT((h)) || \ + (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_BUFFER || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_ARRAYBUFFER || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DATAVIEW || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT8ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT8ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT16ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT16ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT32ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT32ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FLOAT32ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FLOAT64ARRAY)); \ + } while (0) + +/* + * Macros to access the 'props' allocation. + */ + +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HOBJECT_GET_PROPS(heap,h) \ + ((duk_uint8_t *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, ((duk_heaphdr *) (h))->h_extra16)) +#define DUK_HOBJECT_SET_PROPS(heap,h,x) do { \ + ((duk_heaphdr *) (h))->h_extra16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (x)); \ + } while (0) +#else +#define DUK_HOBJECT_GET_PROPS(heap,h) \ + ((h)->props) +#define DUK_HOBJECT_SET_PROPS(heap,h,x) do { \ + (h)->props = (duk_uint8_t *) (x); \ + } while (0) +#endif + +#if defined(DUK_USE_HOBJECT_LAYOUT_1) +/* LAYOUT 1 */ +#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \ + ((duk_hstring **) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) \ + )) +#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \ + ((duk_propvalue *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + \ + DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_hstring *) \ + )) +#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \ + ((duk_uint8_t *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue)) \ + )) +#define DUK_HOBJECT_A_GET_BASE(heap,h) \ + ((duk_tval *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + \ + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) \ + )) +#define DUK_HOBJECT_H_GET_BASE(heap,h) \ + ((duk_uint32_t *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + \ + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \ + DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \ + )) +#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent,n_arr,n_hash) \ + ( \ + (n_ent) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \ + (n_arr) * sizeof(duk_tval) + \ + (n_hash) * sizeof(duk_uint32_t) \ + ) +#define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash) do { \ + (set_e_k) = (duk_hstring **) (void *) (p_base); \ + (set_e_pv) = (duk_propvalue *) (void *) ((set_e_k) + (n_ent)); \ + (set_e_f) = (duk_uint8_t *) (void *) ((set_e_pv) + (n_ent)); \ + (set_a) = (duk_tval *) (void *) ((set_e_f) + (n_ent)); \ + (set_h) = (duk_uint32_t *) (void *) ((set_a) + (n_arr)); \ + } while (0) +#elif defined(DUK_USE_HOBJECT_LAYOUT_2) +/* LAYOUT 2 */ +#if (DUK_USE_ALIGN_BY == 4) +#define DUK_HOBJECT_E_FLAG_PADDING(e_sz) ((4 - (e_sz)) & 0x03) +#elif (DUK_USE_ALIGN_BY == 8) +#define DUK_HOBJECT_E_FLAG_PADDING(e_sz) ((8 - (e_sz)) & 0x07) +#elif (DUK_USE_ALIGN_BY == 1) +#define DUK_HOBJECT_E_FLAG_PADDING(e_sz) 0 +#else +#error invalid DUK_USE_ALIGN_BY +#endif +#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \ + ((duk_hstring **) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + \ + DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) \ + )) +#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \ + ((duk_propvalue *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) \ + )) +#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \ + ((duk_uint8_t *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue)) \ + )) +#define DUK_HOBJECT_A_GET_BASE(heap,h) \ + ((duk_tval *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + \ + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \ + DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) \ + )) +#define DUK_HOBJECT_H_GET_BASE(heap,h) \ + ((duk_uint32_t *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + \ + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \ + DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) + \ + DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \ + )) +#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent,n_arr,n_hash) \ + ( \ + (n_ent) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \ + DUK_HOBJECT_E_FLAG_PADDING((n_ent)) + \ + (n_arr) * sizeof(duk_tval) + \ + (n_hash) * sizeof(duk_uint32_t) \ + ) +#define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash) do { \ + (set_e_pv) = (duk_propvalue *) (void *) (p_base); \ + (set_e_k) = (duk_hstring **) (void *) ((set_e_pv) + (n_ent)); \ + (set_e_f) = (duk_uint8_t *) (void *) ((set_e_k) + (n_ent)); \ + (set_a) = (duk_tval *) (void *) (((duk_uint8_t *) (set_e_f)) + \ + sizeof(duk_uint8_t) * (n_ent) + \ + DUK_HOBJECT_E_FLAG_PADDING((n_ent))); \ + (set_h) = (duk_uint32_t *) (void *) ((set_a) + (n_arr)); \ + } while (0) +#elif defined(DUK_USE_HOBJECT_LAYOUT_3) +/* LAYOUT 3 */ +#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \ + ((duk_hstring **) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + \ + DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) + \ + DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \ + )) +#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \ + ((duk_propvalue *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) \ + )) +#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \ + ((duk_uint8_t *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + \ + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_propvalue) + sizeof(duk_hstring *)) + \ + DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) + \ + DUK_HOBJECT_GET_HSIZE((h)) * sizeof(duk_uint32_t) \ + )) +#define DUK_HOBJECT_A_GET_BASE(heap,h) \ + ((duk_tval *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + \ + DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) \ + )) +#define DUK_HOBJECT_H_GET_BASE(heap,h) \ + ((duk_uint32_t *) (void *) ( \ + DUK_HOBJECT_GET_PROPS((heap), (h)) + \ + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_propvalue) + sizeof(duk_hstring *)) + \ + DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \ + )) +#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent,n_arr,n_hash) \ + ( \ + (n_ent) * (sizeof(duk_propvalue) + sizeof(duk_hstring *) + sizeof(duk_uint8_t)) + \ + (n_arr) * sizeof(duk_tval) + \ + (n_hash) * sizeof(duk_uint32_t) \ + ) +#define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash) do { \ + (set_e_pv) = (duk_propvalue *) (void *) (p_base); \ + (set_a) = (duk_tval *) (void *) ((set_e_pv) + (n_ent)); \ + (set_e_k) = (duk_hstring **) (void *) ((set_a) + (n_arr)); \ + (set_h) = (duk_uint32_t *) (void *) ((set_e_k) + (n_ent)); \ + (set_e_f) = (duk_uint8_t *) (void *) ((set_h) + (n_hash)); \ + } while (0) +#else +#error invalid hobject layout defines +#endif /* hobject property layout */ + +#define DUK_HOBJECT_E_ALLOC_SIZE(h) \ + DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE((h)), DUK_HOBJECT_GET_ASIZE((h)), DUK_HOBJECT_GET_HSIZE((h))) + +#define DUK_HOBJECT_E_GET_KEY(heap,h,i) (DUK_HOBJECT_E_GET_KEY_BASE((heap), (h))[(i)]) +#define DUK_HOBJECT_E_GET_KEY_PTR(heap,h,i) (&DUK_HOBJECT_E_GET_KEY_BASE((heap), (h))[(i)]) +#define DUK_HOBJECT_E_GET_VALUE(heap,h,i) (DUK_HOBJECT_E_GET_VALUE_BASE((heap), (h))[(i)]) +#define DUK_HOBJECT_E_GET_VALUE_PTR(heap,h,i) (&DUK_HOBJECT_E_GET_VALUE_BASE((heap), (h))[(i)]) +#define DUK_HOBJECT_E_GET_VALUE_TVAL(heap,h,i) (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v) +#define DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap,h,i) (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v) +#define DUK_HOBJECT_E_GET_VALUE_GETTER(heap,h,i) (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get) +#define DUK_HOBJECT_E_GET_VALUE_GETTER_PTR(heap,h,i) (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get) +#define DUK_HOBJECT_E_GET_VALUE_SETTER(heap,h,i) (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set) +#define DUK_HOBJECT_E_GET_VALUE_SETTER_PTR(heap,h,i) (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set) +#define DUK_HOBJECT_E_GET_FLAGS(heap,h,i) (DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)]) +#define DUK_HOBJECT_E_GET_FLAGS_PTR(heap,h,i) (&DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)]) +#define DUK_HOBJECT_A_GET_VALUE(heap,h,i) (DUK_HOBJECT_A_GET_BASE((heap), (h))[(i)]) +#define DUK_HOBJECT_A_GET_VALUE_PTR(heap,h,i) (&DUK_HOBJECT_A_GET_BASE((heap), (h))[(i)]) +#define DUK_HOBJECT_H_GET_INDEX(heap,h,i) (DUK_HOBJECT_H_GET_BASE((heap), (h))[(i)]) +#define DUK_HOBJECT_H_GET_INDEX_PTR(heap,h,i) (&DUK_HOBJECT_H_GET_BASE((heap), (h))[(i)]) + +#define DUK_HOBJECT_E_SET_KEY(heap,h,i,k) do { \ + DUK_HOBJECT_E_GET_KEY((heap), (h), (i)) = (k); \ + } while (0) +#define DUK_HOBJECT_E_SET_VALUE(heap,h,i,v) do { \ + DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)) = (v); \ + } while (0) +#define DUK_HOBJECT_E_SET_VALUE_TVAL(heap,h,i,v) do { \ + DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v = (v); \ + } while (0) +#define DUK_HOBJECT_E_SET_VALUE_GETTER(heap,h,i,v) do { \ + DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get = (v); \ + } while (0) +#define DUK_HOBJECT_E_SET_VALUE_SETTER(heap,h,i,v) do { \ + DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set = (v); \ + } while (0) +#define DUK_HOBJECT_E_SET_FLAGS(heap,h,i,f) do { \ + DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) = (f); \ + } while (0) +#define DUK_HOBJECT_A_SET_VALUE(heap,h,i,v) do { \ + DUK_HOBJECT_A_GET_VALUE((heap), (h), (i)) = (v); \ + } while (0) +#define DUK_HOBJECT_A_SET_VALUE_TVAL(heap,h,i,v) \ + DUK_HOBJECT_A_SET_VALUE((heap), (h), (i), (v)) /* alias for above */ +#define DUK_HOBJECT_H_SET_INDEX(heap,h,i,v) do { \ + DUK_HOBJECT_H_GET_INDEX((heap), (h), (i)) = (v); \ + } while (0) + +#define DUK_HOBJECT_E_SET_FLAG_BITS(heap,h,i,mask) do { \ + DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)] |= (mask); \ + } while (0) + +#define DUK_HOBJECT_E_CLEAR_FLAG_BITS(heap,h,i,mask) do { \ + DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)] &= ~(mask); \ + } while (0) + +#define DUK_HOBJECT_E_SLOT_IS_WRITABLE(heap,h,i) ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_WRITABLE) != 0) +#define DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(heap,h,i) ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ENUMERABLE) != 0) +#define DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(heap,h,i) ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0) +#define DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap,h,i) ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ACCESSOR) != 0) + +#define DUK_HOBJECT_E_SLOT_SET_WRITABLE(heap,h,i) DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_WRITABLE) +#define DUK_HOBJECT_E_SLOT_SET_ENUMERABLE(heap,h,i) DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ENUMERABLE) +#define DUK_HOBJECT_E_SLOT_SET_CONFIGURABLE(heap,h,i) DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_CONFIGURABLE) +#define DUK_HOBJECT_E_SLOT_SET_ACCESSOR(heap,h,i) DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ACCESSOR) + +#define DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(heap,h,i) DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_WRITABLE) +#define DUK_HOBJECT_E_SLOT_CLEAR_ENUMERABLE(heap,h,i) DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ENUMERABLE) +#define DUK_HOBJECT_E_SLOT_CLEAR_CONFIGURABLE(heap,h,i) DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_CONFIGURABLE) +#define DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR(heap,h,i) DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ACCESSOR) + +#define DUK_PROPDESC_IS_WRITABLE(p) (((p)->flags & DUK_PROPDESC_FLAG_WRITABLE) != 0) +#define DUK_PROPDESC_IS_ENUMERABLE(p) (((p)->flags & DUK_PROPDESC_FLAG_ENUMERABLE) != 0) +#define DUK_PROPDESC_IS_CONFIGURABLE(p) (((p)->flags & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0) +#define DUK_PROPDESC_IS_ACCESSOR(p) (((p)->flags & DUK_PROPDESC_FLAG_ACCESSOR) != 0) + +#define DUK_HOBJECT_HASHIDX_UNUSED 0xffffffffUL +#define DUK_HOBJECT_HASHIDX_DELETED 0xfffffffeUL + +/* + * Macros for accessing size fields + */ + +#if defined(DUK_USE_OBJSIZES16) +#define DUK_HOBJECT_GET_ESIZE(h) ((h)->e_size16) +#define DUK_HOBJECT_SET_ESIZE(h,v) do { (h)->e_size16 = (v); } while (0) +#define DUK_HOBJECT_GET_ENEXT(h) ((h)->e_next16) +#define DUK_HOBJECT_SET_ENEXT(h,v) do { (h)->e_next16 = (v); } while (0) +#define DUK_HOBJECT_POSTINC_ENEXT(h) ((h)->e_next16++) +#define DUK_HOBJECT_GET_ASIZE(h) ((h)->a_size16) +#define DUK_HOBJECT_SET_ASIZE(h,v) do { (h)->a_size16 = (v); } while (0) +#if defined(DUK_USE_HOBJECT_HASH_PART) +#define DUK_HOBJECT_GET_HSIZE(h) ((h)->h_size16) +#define DUK_HOBJECT_SET_HSIZE(h,v) do { (h)->h_size16 = (v); } while (0) +#else +#define DUK_HOBJECT_GET_HSIZE(h) 0 +#define DUK_HOBJECT_SET_HSIZE(h,v) do { DUK_ASSERT((v) == 0); } while (0) +#endif +#else +#define DUK_HOBJECT_GET_ESIZE(h) ((h)->e_size) +#define DUK_HOBJECT_SET_ESIZE(h,v) do { (h)->e_size = (v); } while (0) +#define DUK_HOBJECT_GET_ENEXT(h) ((h)->e_next) +#define DUK_HOBJECT_SET_ENEXT(h,v) do { (h)->e_next = (v); } while (0) +#define DUK_HOBJECT_POSTINC_ENEXT(h) ((h)->e_next++) +#define DUK_HOBJECT_GET_ASIZE(h) ((h)->a_size) +#define DUK_HOBJECT_SET_ASIZE(h,v) do { (h)->a_size = (v); } while (0) +#if defined(DUK_USE_HOBJECT_HASH_PART) +#define DUK_HOBJECT_GET_HSIZE(h) ((h)->h_size) +#define DUK_HOBJECT_SET_HSIZE(h,v) do { (h)->h_size = (v); } while (0) +#else +#define DUK_HOBJECT_GET_HSIZE(h) 0 +#define DUK_HOBJECT_SET_HSIZE(h,v) do { DUK_ASSERT((v) == 0); } while (0) +#endif +#endif + +/* + * Misc + */ + +/* Maximum prototype traversal depth. Sanity limit which handles e.g. + * prototype loops (even complex ones like 1->2->3->4->2->3->4->2->3->4). + */ +#define DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY 10000L + +/* Maximum traversal depth for "bound function" chains. */ +#define DUK_HOBJECT_BOUND_CHAIN_SANITY 10000L + +/* + * Ecmascript [[Class]] + */ + +/* range check not necessary because all 4-bit values are mapped */ +#define DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(n) duk_class_number_to_stridx[(n)] + +#define DUK_HOBJECT_GET_CLASS_STRING(heap,h) \ + DUK_HEAP_GET_STRING( \ + (heap), \ + DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(DUK_HOBJECT_GET_CLASS_NUMBER((h))) \ + ) + +/* + * Macros for property handling + */ + +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HOBJECT_GET_PROTOTYPE(heap,h) \ + ((duk_hobject *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->prototype16)) +#define DUK_HOBJECT_SET_PROTOTYPE(heap,h,x) do { \ + (h)->prototype16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (x)); \ + } while (0) +#else +#define DUK_HOBJECT_GET_PROTOTYPE(heap,h) \ + ((h)->prototype) +#define DUK_HOBJECT_SET_PROTOTYPE(heap,h,x) do { \ + (h)->prototype = (x); \ + } while (0) +#endif + +/* note: this updates refcounts */ +#define DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr,h,p) duk_hobject_set_prototype((thr), (h), (p)) + +/* + * Resizing and hash behavior + */ + +/* Sanity limit on max number of properties (allocated, not necessarily used). + * This is somewhat arbitrary, but if we're close to 2**32 properties some + * algorithms will fail (e.g. hash size selection, next prime selection). + * Also, we use negative array/entry table indices to indicate 'not found', + * so anything above 0x80000000 will cause trouble now. + */ +#if defined(DUK_USE_OBJSIZES16) +#define DUK_HOBJECT_MAX_PROPERTIES 0x0000ffffUL +#else +#define DUK_HOBJECT_MAX_PROPERTIES 0x7fffffffUL /* 2**31-1 ~= 2G properties */ +#endif + +/* higher value conserves memory; also note that linear scan is cache friendly */ +#define DUK_HOBJECT_E_USE_HASH_LIMIT 32 + +/* hash size relative to entries size: for value X, approx. hash_prime(e_size + e_size / X) */ +#define DUK_HOBJECT_H_SIZE_DIVISOR 4 /* hash size approx. 1.25 times entries size */ + +/* if new_size < L * old_size, resize without abandon check; L = 3-bit fixed point, e.g. 9 -> 9/8 = 112.5% */ +#define DUK_HOBJECT_A_FAST_RESIZE_LIMIT 9 /* 112.5%, i.e. new size less than 12.5% higher -> fast resize */ + +/* if density < L, abandon array part, L = 3-bit fixed point, e.g. 2 -> 2/8 = 25% */ +/* limit is quite low: one array entry is 8 bytes, one normal entry is 4+1+8+4 = 17 bytes (with hash entry) */ +#define DUK_HOBJECT_A_ABANDON_LIMIT 2 /* 25%, i.e. less than 25% used -> abandon */ + +/* internal align target for props allocation, must be 2*n for some n */ +#if (DUK_USE_ALIGN_BY == 4) +#define DUK_HOBJECT_ALIGN_TARGET 4 +#elif (DUK_USE_ALIGN_BY == 8) +#define DUK_HOBJECT_ALIGN_TARGET 8 +#elif (DUK_USE_ALIGN_BY == 1) +#define DUK_HOBJECT_ALIGN_TARGET 1 +#else +#error invalid DUK_USE_ALIGN_BY +#endif + +/* controls for minimum entry part growth */ +#define DUK_HOBJECT_E_MIN_GROW_ADD 16 +#define DUK_HOBJECT_E_MIN_GROW_DIVISOR 8 /* 2^3 -> 1/8 = 12.5% min growth */ + +/* controls for minimum array part growth */ +#define DUK_HOBJECT_A_MIN_GROW_ADD 16 +#define DUK_HOBJECT_A_MIN_GROW_DIVISOR 8 /* 2^3 -> 1/8 = 12.5% min growth */ + +/* probe sequence */ +#define DUK_HOBJECT_HASH_INITIAL(hash,h_size) ((hash) % (h_size)) +#define DUK_HOBJECT_HASH_PROBE_STEP(hash) DUK_UTIL_GET_HASH_PROBE_STEP((hash)) + +/* + * PC-to-line constants + */ + +#define DUK_PC2LINE_SKIP 64 + +/* maximum length for a SKIP-1 diffstream: 35 bits per entry, rounded up to bytes */ +#define DUK_PC2LINE_MAX_DIFF_LENGTH (((DUK_PC2LINE_SKIP - 1) * 35 + 7) / 8) + +/* + * Struct defs + */ + +struct duk_propaccessor { + duk_hobject *get; + duk_hobject *set; +}; + +union duk_propvalue { + /* The get/set pointers could be 16-bit pointer compressed but it + * would make no difference on 32-bit platforms because duk_tval is + * 8 bytes or more anyway. + */ + duk_tval v; + duk_propaccessor a; +}; + +struct duk_propdesc { + /* read-only values 'lifted' for ease of use */ + duk_small_int_t flags; + duk_hobject *get; + duk_hobject *set; + + /* for updating (all are set to < 0 for virtual properties) */ + duk_int_t e_idx; /* prop index in 'entry part', < 0 if not there */ + duk_int_t h_idx; /* prop index in 'hash part', < 0 if not there */ + duk_int_t a_idx; /* prop index in 'array part', < 0 if not there */ +}; + +struct duk_hobject { + duk_heaphdr hdr; + + /* + * 'props' contains {key,value,flags} entries, optional array entries, and + * an optional hash lookup table for non-array entries in a single 'sliced' + * allocation. There are several layout options, which differ slightly in + * generated code size/speed and alignment/padding; duk_features.h selects + * the layout used. + * + * Layout 1 (DUK_USE_HOBJECT_LAYOUT_1): + * + * e_size * sizeof(duk_hstring *) bytes of entry keys (e_next gc reachable) + * e_size * sizeof(duk_propvalue) bytes of entry values (e_next gc reachable) + * e_size * sizeof(duk_uint8_t) bytes of entry flags (e_next gc reachable) + * a_size * sizeof(duk_tval) bytes of (opt) array values (plain only) (all gc reachable) + * h_size * sizeof(duk_uint32_t) bytes of (opt) hash indexes to entries (e_size), + * 0xffffffffUL = unused, 0xfffffffeUL = deleted + * + * Layout 2 (DUK_USE_HOBJECT_LAYOUT_2): + * + * e_size * sizeof(duk_propvalue) bytes of entry values (e_next gc reachable) + * e_size * sizeof(duk_hstring *) bytes of entry keys (e_next gc reachable) + * e_size * sizeof(duk_uint8_t) + pad bytes of entry flags (e_next gc reachable) + * a_size * sizeof(duk_tval) bytes of (opt) array values (plain only) (all gc reachable) + * h_size * sizeof(duk_uint32_t) bytes of (opt) hash indexes to entries (e_size), + * 0xffffffffUL = unused, 0xfffffffeUL = deleted + * + * Layout 3 (DUK_USE_HOBJECT_LAYOUT_3): + * + * e_size * sizeof(duk_propvalue) bytes of entry values (e_next gc reachable) + * a_size * sizeof(duk_tval) bytes of (opt) array values (plain only) (all gc reachable) + * e_size * sizeof(duk_hstring *) bytes of entry keys (e_next gc reachable) + * h_size * sizeof(duk_uint32_t) bytes of (opt) hash indexes to entries (e_size), + * 0xffffffffUL = unused, 0xfffffffeUL = deleted + * e_size * sizeof(duk_uint8_t) bytes of entry flags (e_next gc reachable) + * + * In layout 1, the 'e_next' count is rounded to 4 or 8 on platforms + * requiring 4 or 8 byte alignment. This ensures proper alignment + * for the entries, at the cost of memory footprint. However, it's + * probably preferable to use another layout on such platforms instead. + * + * In layout 2, the key and value parts are swapped to avoid padding + * the key array on platforms requiring alignment by 8. The flags part + * is padded to get alignment for array entries. The 'e_next' count does + * not need to be rounded as in layout 1. + * + * In layout 3, entry values and array values are always aligned properly, + * and assuming pointers are at most 8 bytes, so are the entry keys. Hash + * indices will be properly aligned (assuming pointers are at least 4 bytes). + * Finally, flags don't need additional alignment. This layout provides + * compact allocations without padding (even on platforms with alignment + * requirements) at the cost of a bit slower lookups. + * + * Objects with few keys don't have a hash index; keys are looked up linearly, + * which is cache efficient because the keys are consecutive. Larger objects + * have a hash index part which contains integer indexes to the entries part. + * + * A single allocation reduces memory allocation overhead but requires more + * work when any part needs to be resized. A sliced allocation for entries + * makes linear key matching faster on most platforms (more locality) and + * skimps on flags size (which would be followed by 3 bytes of padding in + * most architectures if entries were placed in a struct). + * + * 'props' also contains internal properties distinguished with a non-BMP + * prefix. Often used properties should be placed early in 'props' whenever + * possible to make accessing them as fast a possible. + */ + +#if defined(DUK_USE_HEAPPTR16) + /* Located in duk_heaphdr h_extra16. Subclasses of duk_hobject (like + * duk_hcompiledfunction) are not free to use h_extra16 for this reason. + */ +#else + duk_uint8_t *props; +#endif + + /* prototype: the only internal property lifted outside 'e' as it is so central */ +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t prototype16; +#else + duk_hobject *prototype; +#endif + +#if defined(DUK_USE_OBJSIZES16) + duk_uint16_t e_size16; + duk_uint16_t e_next16; + duk_uint16_t a_size16; +#if defined(DUK_USE_HOBJECT_HASH_PART) + duk_uint16_t h_size16; +#endif +#else + duk_uint32_t e_size; /* entry part size */ + duk_uint32_t e_next; /* index for next new key ([0,e_next[ are gc reachable) */ + duk_uint32_t a_size; /* array part size (entirely gc reachable) */ +#if defined(DUK_USE_HOBJECT_HASH_PART) + duk_uint32_t h_size; /* hash part size or 0 if unused */ +#endif +#endif +}; + +/* + * Exposed data + */ + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL duk_uint8_t duk_class_number_to_stridx[32]; +#endif /* !DUK_SINGLE_FILE */ + +/* + * Prototypes + */ + +/* alloc and init */ +DUK_INTERNAL_DECL duk_hobject *duk_hobject_alloc(duk_heap *heap, duk_uint_t hobject_flags); +#if 0 /* unused */ +DUK_INTERNAL_DECL duk_hobject *duk_hobject_alloc_checked(duk_hthread *thr, duk_uint_t hobject_flags); +#endif +DUK_INTERNAL_DECL duk_hcompiledfunction *duk_hcompiledfunction_alloc(duk_heap *heap, duk_uint_t hobject_flags); +DUK_INTERNAL_DECL duk_hnativefunction *duk_hnativefunction_alloc(duk_heap *heap, duk_uint_t hobject_flags); +DUK_INTERNAL duk_hbufferobject *duk_hbufferobject_alloc(duk_heap *heap, duk_uint_t hobject_flags); +DUK_INTERNAL_DECL duk_hthread *duk_hthread_alloc(duk_heap *heap, duk_uint_t hobject_flags); + +/* low-level property functions */ +DUK_INTERNAL_DECL void duk_hobject_find_existing_entry(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_int_t *e_idx, duk_int_t *h_idx); +DUK_INTERNAL_DECL duk_tval *duk_hobject_find_existing_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_hstring *key); +DUK_INTERNAL_DECL duk_tval *duk_hobject_find_existing_entry_tval_ptr_and_attrs(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_int_t *out_attrs); +DUK_INTERNAL_DECL duk_tval *duk_hobject_find_existing_array_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_uarridx_t i); + +/* XXX: when optimizing for guaranteed property slots, use a guaranteed + * slot for internal value; this call can then access it directly. + */ +#define duk_hobject_get_internal_value_tval_ptr(heap,obj) \ + duk_hobject_find_existing_entry_tval_ptr((heap), (obj), DUK_HEAP_STRING_INT_VALUE((heap))) + +/* core property functions */ +DUK_INTERNAL_DECL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key); +DUK_INTERNAL_DECL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key, duk_tval *tv_val, duk_bool_t throw_flag); +DUK_INTERNAL_DECL duk_bool_t duk_hobject_delprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key, duk_bool_t throw_flag); +DUK_INTERNAL_DECL duk_bool_t duk_hobject_hasprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key); + +/* internal property functions */ +#define DUK_DELPROP_FLAG_THROW (1 << 0) +#define DUK_DELPROP_FLAG_FORCE (1 << 1) +DUK_INTERNAL_DECL duk_bool_t duk_hobject_delprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags); +DUK_INTERNAL_DECL duk_bool_t duk_hobject_hasprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key); +DUK_INTERNAL_DECL void duk_hobject_define_property_internal(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags); +DUK_INTERNAL_DECL void duk_hobject_define_property_internal_arridx(duk_hthread *thr, duk_hobject *obj, duk_uarridx_t arr_idx, duk_small_uint_t flags); +DUK_INTERNAL_DECL void duk_hobject_define_accessor_internal(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_hobject *getter, duk_hobject *setter, duk_small_uint_t propflags); +DUK_INTERNAL_DECL void duk_hobject_set_length(duk_hthread *thr, duk_hobject *obj, duk_uint32_t length); /* XXX: duk_uarridx_t? */ +DUK_INTERNAL_DECL void duk_hobject_set_length_zero(duk_hthread *thr, duk_hobject *obj); +DUK_INTERNAL_DECL duk_uint32_t duk_hobject_get_length(duk_hthread *thr, duk_hobject *obj); /* XXX: duk_uarridx_t? */ + +/* helpers for defineProperty() and defineProperties() */ +DUK_INTERNAL_DECL +void duk_hobject_prepare_property_descriptor(duk_context *ctx, + duk_idx_t idx_in, + duk_uint_t *out_defprop_flags, + duk_idx_t *out_idx_value, + duk_hobject **out_getter, + duk_hobject **out_setter); +DUK_INTERNAL_DECL +void duk_hobject_define_property_helper(duk_context *ctx, + duk_uint_t defprop_flags, + duk_hobject *obj, + duk_hstring *key, + duk_idx_t idx_value, + duk_hobject *get, + duk_hobject *set); + +/* Object built-in methods */ +DUK_INTERNAL_DECL duk_ret_t duk_hobject_object_get_own_property_descriptor(duk_context *ctx); +DUK_INTERNAL_DECL void duk_hobject_object_seal_freeze_helper(duk_hthread *thr, duk_hobject *obj, duk_bool_t is_freeze); +DUK_INTERNAL_DECL duk_bool_t duk_hobject_object_is_sealed_frozen_helper(duk_hthread *thr, duk_hobject *obj, duk_bool_t is_frozen); +DUK_INTERNAL_DECL duk_bool_t duk_hobject_object_ownprop_helper(duk_context *ctx, duk_small_uint_t required_desc_flags); + +/* internal properties */ +DUK_INTERNAL_DECL duk_bool_t duk_hobject_get_internal_value(duk_heap *heap, duk_hobject *obj, duk_tval *tv); +DUK_INTERNAL_DECL duk_hstring *duk_hobject_get_internal_value_string(duk_heap *heap, duk_hobject *obj); + +/* hobject management functions */ +DUK_INTERNAL_DECL void duk_hobject_compact_props(duk_hthread *thr, duk_hobject *obj); + +/* ES6 proxy */ +#if defined(DUK_USE_ES6_PROXY) +DUK_INTERNAL_DECL duk_bool_t duk_hobject_proxy_check(duk_hthread *thr, duk_hobject *obj, duk_hobject **out_target, duk_hobject **out_handler); +DUK_INTERNAL_DECL duk_hobject *duk_hobject_resolve_proxy_target(duk_hthread *thr, duk_hobject *obj); +#endif + +/* enumeration */ +DUK_INTERNAL_DECL void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint_t enum_flags); +DUK_INTERNAL_DECL duk_ret_t duk_hobject_get_enumerated_keys(duk_context *ctx, duk_small_uint_t enum_flags); +DUK_INTERNAL_DECL duk_bool_t duk_hobject_enumerator_next(duk_context *ctx, duk_bool_t get_value); + +/* macros */ +DUK_INTERNAL_DECL void duk_hobject_set_prototype(duk_hthread *thr, duk_hobject *h, duk_hobject *p); + +/* finalization */ +DUK_INTERNAL_DECL void duk_hobject_run_finalizer(duk_hthread *thr, duk_hobject *obj); + +/* pc2line */ +#if defined(DUK_USE_PC2LINE) +DUK_INTERNAL_DECL void duk_hobject_pc2line_pack(duk_hthread *thr, duk_compiler_instr *instrs, duk_uint_fast32_t length); +DUK_INTERNAL_DECL duk_uint_fast32_t duk_hobject_pc2line_query(duk_context *ctx, duk_idx_t idx_func, duk_uint_fast32_t pc); +#endif + +/* misc */ +DUK_INTERNAL_DECL duk_bool_t duk_hobject_prototype_chain_contains(duk_hthread *thr, duk_hobject *h, duk_hobject *p, duk_bool_t ignore_loop); + +#endif /* DUK_HOBJECT_H_INCLUDED */ +#line 1 "duk_hcompiledfunction.h" +/* + * Heap compiled function (Ecmascript function) representation. + * + * There is a single data buffer containing the Ecmascript function's + * bytecode, constants, and inner functions. + */ + +#ifndef DUK_HCOMPILEDFUNCTION_H_INCLUDED +#define DUK_HCOMPILEDFUNCTION_H_INCLUDED + +/* + * Field accessor macros + */ + +/* XXX: casts could be improved, especially for GET/SET DATA */ + +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HCOMPILEDFUNCTION_GET_DATA(heap,h) \ + ((duk_hbuffer_fixed *) (void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->data16)) +#define DUK_HCOMPILEDFUNCTION_SET_DATA(heap,h,v) do { \ + (h)->data16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ + } while (0) +#define DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap,h) \ + ((duk_hobject **) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->funcs16))) +#define DUK_HCOMPILEDFUNCTION_SET_FUNCS(heap,h,v) do { \ + (h)->funcs16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ + } while (0) +#define DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap,h) \ + ((duk_instr_t *) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->bytecode16))) +#define DUK_HCOMPILEDFUNCTION_SET_BYTECODE(heap,h,v) do { \ + (h)->bytecode16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ + } while (0) +#else +#define DUK_HCOMPILEDFUNCTION_GET_DATA(heap,h) \ + ((duk_hbuffer_fixed *) (void *) (h)->data) +#define DUK_HCOMPILEDFUNCTION_SET_DATA(heap,h,v) do { \ + (h)->data = (duk_hbuffer *) (v); \ + } while (0) +#define DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap,h) \ + ((h)->funcs) +#define DUK_HCOMPILEDFUNCTION_SET_FUNCS(heap,h,v) do { \ + (h)->funcs = (v); \ + } while (0) +#define DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap,h) \ + ((h)->bytecode) +#define DUK_HCOMPILEDFUNCTION_SET_BYTECODE(heap,h,v) do { \ + (h)->bytecode = (v); \ + } while (0) +#endif + +/* + * Accessor macros for function specific data areas + */ + +/* Note: assumes 'data' is always a fixed buffer */ +#define DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE(heap,h) \ + DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h))) + +#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap,h) \ + ((duk_tval *) (void *) DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE((heap), (h))) + +#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap,h) \ + DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h)) + +#define DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(heap,h) \ + DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h)) + +#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(heap,h) \ + ((duk_tval *) (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h))) + +#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap,h) \ + ((duk_hobject **) (void *) DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h))) + +/* XXX: double evaluation of DUK_HCOMPILEDFUNCTION_GET_DATA() */ +#define DUK_HCOMPILEDFUNCTION_GET_CODE_END(heap,h) \ + ((duk_instr_t *) (void *) (DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h))) + \ + DUK_HBUFFER_GET_SIZE((duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA((heap), h)))) + +#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(heap,h) \ + ( \ + (duk_size_t) \ + ( \ + ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_END((heap), (h))) - \ + ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE((heap), (h))) \ + ) \ + ) + +#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(heap,h) \ + ( \ + (duk_size_t) \ + ( \ + ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END((heap), (h))) - \ + ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE((heap), (h))) \ + ) \ + ) + +#define DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(heap,h) \ + ( \ + (duk_size_t) \ + ( \ + ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_END((heap),(h))) - \ + ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE((heap),(h))) \ + ) \ + ) + +#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(heap,h) \ + ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE((heap), (h)) / sizeof(duk_tval))) + +#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(heap,h) \ + ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE((heap), (h)) / sizeof(duk_hobject *))) + +#define DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(heap,h) \ + ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE((heap), (h)) / sizeof(duk_instr_t))) + + +/* + * Main struct + */ + +struct duk_hcompiledfunction { + /* shared object part */ + duk_hobject obj; + + /* + * Pointers to function data area for faster access. Function + * data is a buffer shared between all closures of the same + * "template" function. The data buffer is always fixed (non- + * dynamic, hence stable), with a layout as follows: + * + * constants (duk_tval) + * inner functions (duk_hobject *) + * bytecode (duk_instr_t) + * + * Note: bytecode end address can be computed from 'data' buffer + * size. It is not strictly necessary functionally, assuming + * bytecode never jumps outside its allocated area. However, + * it's a safety/robustness feature for avoiding the chance of + * executing random data as bytecode due to a compiler error. + * + * Note: values in the data buffer must be incref'd (they will + * be decref'd on release) for every compiledfunction referring + * to the 'data' element. + */ + + /* Data area, fixed allocation, stable data ptrs. */ +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t data16; +#else + duk_hbuffer *data; +#endif + + /* No need for constants pointer (= same as data). + * + * When using 16-bit packing alignment to 4 is nice. 'funcs' will be + * 4-byte aligned because 'constants' are duk_tvals. For now the + * inner function pointers are not compressed, so that 'bytecode' will + * also be 4-byte aligned. + */ +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t funcs16; + duk_uint16_t bytecode16; +#else + duk_hobject **funcs; + duk_instr_t *bytecode; +#endif + + /* + * 'nregs' registers are allocated on function entry, at most 'nargs' + * are initialized to arguments, and the rest to undefined. Arguments + * above 'nregs' are not mapped to registers. All registers in the + * active stack range must be initialized because they are GC reachable. + * 'nargs' is needed so that if the function is given more than 'nargs' + * arguments, the additional arguments do not 'clobber' registers + * beyond 'nregs' which must be consistently initialized to undefined. + * + * Usually there is no need to know which registers are mapped to + * local variables. Registers may be allocated to variable in any + * way (even including gaps). However, a register-variable mapping + * must be the same for the duration of the function execution and + * the register cannot be used for anything else. + * + * When looking up variables by name, the '_Varmap' map is used. + * When an activation closes, registers mapped to arguments are + * copied into the environment record based on the same map. The + * reverse map (from register to variable) is not currently needed + * at run time, except for debugging, so it is not maintained. + */ + + duk_uint16_t nregs; /* regs to allocate */ + duk_uint16_t nargs; /* number of arguments allocated to regs */ + + /* + * Additional control information is placed into the object itself + * as internal properties to avoid unnecessary fields for the + * majority of functions. The compiler tries to omit internal + * control fields when possible. + * + * Function templates: + * + * { + * name: "func", // declaration, named function expressions + * fileName: <debug info for creating nice errors> + * _Varmap: { "arg1": 0, "arg2": 1, "varname": 2 }, + * _Formals: [ "arg1", "arg2" ], + * _Source: "function func(arg1, arg2) { ... }", + * _Pc2line: <debug info for pc-to-line mapping>, + * } + * + * Function instances: + * + * { + * length: 2, + * prototype: { constructor: <func> }, + * caller: <thrower>, + * arguments: <thrower>, + * name: "func", // declaration, named function expressions + * fileName: <debug info for creating nice errors> + * _Varmap: { "arg1": 0, "arg2": 1, "varname": 2 }, + * _Formals: [ "arg1", "arg2" ], + * _Source: "function func(arg1, arg2) { ... }", + * _Pc2line: <debug info for pc-to-line mapping>, + * _Varenv: <variable environment of closure>, + * _Lexenv: <lexical environment of closure (if differs from _Varenv)> + * } + * + * More detailed description of these properties can be found + * in the documentation. + */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) + /* Line number range for function. Needed during debugging to + * determine active breakpoints. + */ + duk_uint32_t start_line; + duk_uint32_t end_line; +#endif +}; + +#endif /* DUK_HCOMPILEDFUNCTION_H_INCLUDED */ +#line 1 "duk_hnativefunction.h" +/* + * Heap native function representation. + */ + +#ifndef DUK_HNATIVEFUNCTION_H_INCLUDED +#define DUK_HNATIVEFUNCTION_H_INCLUDED + +#define DUK_HNATIVEFUNCTION_NARGS_VARARGS ((duk_int16_t) -1) +#define DUK_HNATIVEFUNCTION_NARGS_MAX ((duk_int16_t) 0x7fff) + +struct duk_hnativefunction { + /* shared object part */ + duk_hobject obj; + + duk_c_function func; + duk_int16_t nargs; + duk_int16_t magic; + + /* The 'magic' field allows an opaque 16-bit field to be accessed by the + * Duktape/C function. This allows, for instance, the same native function + * to be used for a set of very similar functions, with the 'magic' field + * providing the necessary non-argument flags / values to guide the behavior + * of the native function. The value is signed on purpose: it is easier to + * convert a signed value to unsigned (simply AND with 0xffff) than vice + * versa. + * + * Note: cannot place nargs/magic into the heaphdr flags, because + * duk_hobject takes almost all flags already (and needs the spare). + */ +}; + +#endif /* DUK_HNATIVEFUNCTION_H_INCLUDED */ +#line 1 "duk_hbufferobject.h" +/* + * Heap Buffer object representation. Used for all Buffer variants. + */ + +#ifndef DUK_HBUFFEROBJECT_H_INCLUDED +#define DUK_HBUFFEROBJECT_H_INCLUDED + +/* All element accessors are host endian now (driven by TypedArray spec). */ +#define DUK_HBUFFEROBJECT_ELEM_UINT8 0 +#define DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED 1 +#define DUK_HBUFFEROBJECT_ELEM_INT8 2 +#define DUK_HBUFFEROBJECT_ELEM_UINT16 3 +#define DUK_HBUFFEROBJECT_ELEM_INT16 4 +#define DUK_HBUFFEROBJECT_ELEM_UINT32 5 +#define DUK_HBUFFEROBJECT_ELEM_INT32 6 +#define DUK_HBUFFEROBJECT_ELEM_FLOAT32 7 +#define DUK_HBUFFEROBJECT_ELEM_FLOAT64 8 +#define DUK_HBUFFEROBJECT_ELEM_MAX 8 + +#define DUK_ASSERT_HBUFFEROBJECT_VALID(h) do { \ + DUK_ASSERT((h) != NULL); \ + DUK_ASSERT((h)->shift <= 3); \ + DUK_ASSERT((h)->elem_type <= DUK_HBUFFEROBJECT_ELEM_MAX); \ + DUK_ASSERT(((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8) || \ + ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) || \ + ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT8) || \ + ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT16) || \ + ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT16) || \ + ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT32) || \ + ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT32) || \ + ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT32) || \ + ((h)->shift == 3 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT64)); \ + DUK_ASSERT((h)->is_view == 0 || (h)->is_view == 1); \ + DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) (h))); \ + if ((h)->buf == NULL) { \ + DUK_ASSERT((h)->offset == 0); \ + DUK_ASSERT((h)->length == 0); \ + } else { \ + /* No assertions for offset or length; in particular, \ + * it's OK for length to be longer than underlying \ + * buffer. Just ensure they don't wrap when added. \ + */ \ + DUK_ASSERT((h)->offset + (h)->length >= (h)->offset); \ + } \ + } while (0) + +/* Get the current data pointer (caller must ensure buf != NULL) as a + * duk_uint8_t ptr. + */ +#define DUK_HBUFFEROBJECT_GET_SLICE_BASE(heap,h) \ + (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ + (((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR((heap), (h)->buf)) + (h)->offset)) + +/* True if slice is full, i.e. offset is zero and length covers the entire + * buffer. This status may change independently of the duk_hbufferobject if + * the underlying buffer is dynamic and changes without the hbufferobject + * being changed. + */ +#define DUK_HBUFFEROBJECT_FULL_SLICE(h) \ + (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ + ((h)->offset == 0 && (h)->length == DUK_HBUFFER_GET_SIZE((h)->buf))) + +/* Validate that the whole slice [0,length[ is contained in the underlying + * buffer. Caller must ensure 'buf' != NULL. + */ +#define DUK_HBUFFEROBJECT_VALID_SLICE(h) \ + (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ + ((h)->offset + (h)->length <= DUK_HBUFFER_GET_SIZE((h)->buf))) + +/* Validate byte read/write for virtual 'offset', i.e. check that the + * offset, taking into account h->offset, is within the underlying + * buffer size. This is a safety check which is needed to ensure + * that even a misconfigured duk_hbufferobject never causes memory + * unsafe behavior (e.g. if an underlying dynamic buffer changes + * after being setup). Caller must ensure 'buf' != NULL. + */ +#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_INCL(h,off) \ + (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ + ((h)->offset + (off) < DUK_HBUFFER_GET_SIZE((h)->buf))) + +#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h,off) \ + (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ + ((h)->offset + (off) <= DUK_HBUFFER_GET_SIZE((h)->buf))) + +/* Clamp an input byte length (already assumed to be within the nominal + * duk_hbufferobject 'length') to the current dynamic buffer limits to + * yield a byte length limit that's safe for memory accesses. This value + * can be invalidated by any side effect because it may trigger a user + * callback that resizes the underlying buffer. + */ +#define DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h,len) \ + (DUK_ASSERT_EXPR((h) != NULL), \ + duk_hbufferobject_clamp_bytelength((h), (len))) + +struct duk_hbufferobject { + /* Shared object part. */ + duk_hobject obj; + + /* Underlying buffer (refcounted), may be NULL. */ + duk_hbuffer *buf; + + /* Slice and accessor information. + * + * Because the underlying buffer may be dynamic, these may be + * invalidated by the buffer being modified so that both offset + * and length should be validated before every access. Behavior + * when the underlying buffer has changed doesn't need to be clean: + * virtual 'length' doesn't need to be affected, reads can return + * zero/NaN, and writes can be ignored. + * + * Note that a data pointer cannot be precomputed because 'buf' may + * be dynamic and its pointer unstable. + */ + + duk_uint_t offset; /* byte offset to buf */ + duk_uint_t length; /* byte index limit for element access, exclusive */ + duk_uint8_t shift; /* element size shift: + * 0 = u8/i8 + * 1 = u16/i16 + * 2 = u32/i32/float + * 3 = double + */ + duk_uint8_t elem_type; /* element type */ + duk_uint8_t is_view; +}; + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL_DECL duk_uint_t duk_hbufferobject_clamp_bytelength(duk_hbufferobject *h_bufobj, duk_uint_t len); +#endif +DUK_INTERNAL_DECL void duk_hbufferobject_push_validated_read(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size); +DUK_INTERNAL_DECL void duk_hbufferobject_validated_write(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size); + +#endif /* DUK_HBUFFEROBJECT_H_INCLUDED */ +#line 1 "duk_hthread.h" +/* + * Heap thread object representation. + * + * duk_hthread is also the 'context' (duk_context) for exposed APIs + * which mostly operate on the topmost frame of the value stack. + */ + +#ifndef DUK_HTHREAD_H_INCLUDED +#define DUK_HTHREAD_H_INCLUDED + +/* + * Stack constants + */ + +#define DUK_VALSTACK_GROW_STEP 128 /* roughly 1 kiB */ +#define DUK_VALSTACK_SHRINK_THRESHOLD 256 /* roughly 2 kiB */ +#define DUK_VALSTACK_SHRINK_SPARE 64 /* roughly 0.5 kiB */ +#define DUK_VALSTACK_INITIAL_SIZE 128 /* roughly 1.0 kiB -> but rounds up to DUK_VALSTACK_GROW_STEP in practice */ +#define DUK_VALSTACK_INTERNAL_EXTRA 64 /* internal extra elements assumed on function entry, + * always added to user-defined 'extra' for e.g. the + * duk_check_stack() call. + */ +#define DUK_VALSTACK_API_ENTRY_MINIMUM DUK_API_ENTRY_STACK + /* number of elements guaranteed to be user accessible + * (in addition to call arguments) on Duktape/C function entry. + */ + +/* Note: DUK_VALSTACK_INITIAL_SIZE must be >= DUK_VALSTACK_API_ENTRY_MINIMUM + * + DUK_VALSTACK_INTERNAL_EXTRA so that the initial stack conforms to spare + * requirements. + */ + +#define DUK_VALSTACK_DEFAULT_MAX 1000000L + +#define DUK_CALLSTACK_GROW_STEP 8 /* roughly 256 bytes */ +#define DUK_CALLSTACK_SHRINK_THRESHOLD 16 /* roughly 512 bytes */ +#define DUK_CALLSTACK_SHRINK_SPARE 8 /* roughly 256 bytes */ +#define DUK_CALLSTACK_INITIAL_SIZE 8 +#define DUK_CALLSTACK_DEFAULT_MAX 10000L + +#define DUK_CATCHSTACK_GROW_STEP 4 /* roughly 64 bytes */ +#define DUK_CATCHSTACK_SHRINK_THRESHOLD 8 /* roughly 128 bytes */ +#define DUK_CATCHSTACK_SHRINK_SPARE 4 /* roughly 64 bytes */ +#define DUK_CATCHSTACK_INITIAL_SIZE 4 +#define DUK_CATCHSTACK_DEFAULT_MAX 10000L + +/* + * Activation defines + */ + +#define DUK_ACT_FLAG_STRICT (1 << 0) /* function executes in strict mode */ +#define DUK_ACT_FLAG_TAILCALLED (1 << 1) /* activation has tail called one or more times */ +#define DUK_ACT_FLAG_CONSTRUCT (1 << 2) /* function executes as a constructor (called via "new") */ +#define DUK_ACT_FLAG_PREVENT_YIELD (1 << 3) /* activation prevents yield (native call or "new") */ +#define DUK_ACT_FLAG_DIRECT_EVAL (1 << 4) /* activation is a direct eval call */ +#define DUK_ACT_FLAG_BREAKPOINT_ACTIVE (1 << 5) /* activation has active breakpoint(s) */ + +#define DUK_ACT_GET_FUNC(act) ((act)->func) + +/* + * Flags for __FILE__ / __LINE__ registered into tracedata + */ + +#define DUK_TB_FLAG_NOBLAME_FILELINE (1 << 0) /* don't report __FILE__ / __LINE__ as fileName/lineNumber */ + +/* + * Catcher defines + */ + +/* flags field: LLLLLLFT, L = label (24 bits), F = flags (4 bits), T = type (4 bits) */ +#define DUK_CAT_TYPE_MASK 0x0000000fUL +#define DUK_CAT_TYPE_BITS 4 +#define DUK_CAT_LABEL_MASK 0xffffff00UL +#define DUK_CAT_LABEL_BITS 24 +#define DUK_CAT_LABEL_SHIFT 8 + +#define DUK_CAT_FLAG_CATCH_ENABLED (1 << 4) /* catch part will catch */ +#define DUK_CAT_FLAG_FINALLY_ENABLED (1 << 5) /* finally part will catch */ +#define DUK_CAT_FLAG_CATCH_BINDING_ENABLED (1 << 6) /* request to create catch binding */ +#define DUK_CAT_FLAG_LEXENV_ACTIVE (1 << 7) /* catch or with binding is currently active */ + +#define DUK_CAT_TYPE_UNKNOWN 0 +#define DUK_CAT_TYPE_TCF 1 +#define DUK_CAT_TYPE_LABEL 2 + +#define DUK_CAT_GET_TYPE(c) ((c)->flags & DUK_CAT_TYPE_MASK) +#define DUK_CAT_GET_LABEL(c) (((c)->flags & DUK_CAT_LABEL_MASK) >> DUK_CAT_LABEL_SHIFT) + +#define DUK_CAT_HAS_CATCH_ENABLED(c) ((c)->flags & DUK_CAT_FLAG_CATCH_ENABLED) +#define DUK_CAT_HAS_FINALLY_ENABLED(c) ((c)->flags & DUK_CAT_FLAG_FINALLY_ENABLED) +#define DUK_CAT_HAS_CATCH_BINDING_ENABLED(c) ((c)->flags & DUK_CAT_FLAG_CATCH_BINDING_ENABLED) +#define DUK_CAT_HAS_LEXENV_ACTIVE(c) ((c)->flags & DUK_CAT_FLAG_LEXENV_ACTIVE) + +#define DUK_CAT_SET_CATCH_ENABLED(c) do { \ + (c)->flags |= DUK_CAT_FLAG_CATCH_ENABLED; \ + } while (0) +#define DUK_CAT_SET_FINALLY_ENABLED(c) do { \ + (c)->flags |= DUK_CAT_FLAG_FINALLY_ENABLED; \ + } while (0) +#define DUK_CAT_SET_CATCH_BINDING_ENABLED(c) do { \ + (c)->flags |= DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \ + } while (0) +#define DUK_CAT_SET_LEXENV_ACTIVE(c) do { \ + (c)->flags |= DUK_CAT_FLAG_LEXENV_ACTIVE; \ + } while (0) + +#define DUK_CAT_CLEAR_CATCH_ENABLED(c) do { \ + (c)->flags &= ~DUK_CAT_FLAG_CATCH_ENABLED; \ + } while (0) +#define DUK_CAT_CLEAR_FINALLY_ENABLED(c) do { \ + (c)->flags &= ~DUK_CAT_FLAG_FINALLY_ENABLED; \ + } while (0) +#define DUK_CAT_CLEAR_CATCH_BINDING_ENABLED(c) do { \ + (c)->flags &= ~DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \ + } while (0) +#define DUK_CAT_CLEAR_LEXENV_ACTIVE(c) do { \ + (c)->flags &= ~DUK_CAT_FLAG_LEXENV_ACTIVE; \ + } while (0) + +/* + * Thread defines + */ + +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HTHREAD_GET_STRING(thr,idx) \ + ((duk_hstring *) DUK_USE_HEAPPTR_DEC16((thr)->heap->heap_udata, (thr)->strs16[(idx)])) +#else +#define DUK_HTHREAD_GET_STRING(thr,idx) \ + ((thr)->strs[(idx)]) +#endif + +#define DUK_HTHREAD_GET_CURRENT_ACTIVATION(thr) (&(thr)->callstack[(thr)->callstack_top - 1]) + +/* values for the state field */ +#define DUK_HTHREAD_STATE_INACTIVE 1 /* thread not currently running */ +#define DUK_HTHREAD_STATE_RUNNING 2 /* thread currently running (only one at a time) */ +#define DUK_HTHREAD_STATE_RESUMED 3 /* thread resumed another thread (active but not running) */ +#define DUK_HTHREAD_STATE_YIELDED 4 /* thread has yielded */ +#define DUK_HTHREAD_STATE_TERMINATED 5 /* thread has terminated */ + +/* Executor interrupt default interval when nothing else requires a + * smaller value. The default interval must be small enough to allow + * for reasonable execution timeout checking but large enough to keep + * impact on execution performance low. + */ +#if defined(DUK_USE_INTERRUPT_COUNTER) +#define DUK_HTHREAD_INTCTR_DEFAULT (256L * 1024L) +#endif + +/* + * Assert context is valid: non-NULL pointer, fields look sane. + * + * This is used by public API call entrypoints to catch invalid 'ctx' pointers + * as early as possible; invalid 'ctx' pointers cause very odd and difficult to + * diagnose behavior so it's worth checking even when the check is not 100%. + */ + +#define DUK_ASSERT_CTX_VALID(ctx) do { \ + DUK_ASSERT((ctx) != NULL); \ + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) (ctx)) == DUK_HTYPE_OBJECT); \ + DUK_ASSERT(DUK_HOBJECT_IS_THREAD((duk_hobject *) (ctx))); \ + DUK_ASSERT(((duk_hthread *) (ctx))->unused1 == 0); \ + DUK_ASSERT(((duk_hthread *) (ctx))->unused2 == 0); \ + DUK_ASSERT(((duk_hthread *) (ctx))->valstack != NULL); \ + DUK_ASSERT(((duk_hthread *) (ctx))->valstack_end >= ((duk_hthread *) (ctx))->valstack); \ + DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack); \ + DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack_bottom); \ + } while (0) + +/* + * Struct defines + */ + +/* XXX: for a memory-code tradeoff, remove 'func' and make it's access either a function + * or a macro. This would make the activation 32 bytes long on 32-bit platforms again. + */ + +/* Note: it's nice if size is 2^N (at least for 32-bit platforms). */ +struct duk_activation { + duk_tval tv_func; /* borrowed: full duk_tval for function being executed; for lightfuncs */ + duk_hobject *func; /* borrowed: function being executed; for bound function calls, this is the final, real function, NULL for lightfuncs */ + duk_hobject *var_env; /* current variable environment (may be NULL if delayed) */ + duk_hobject *lex_env; /* current lexical environment (may be NULL if delayed) */ +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY + /* Previous value of 'func' caller, restored when unwound. Only in use + * when 'func' is non-strict. + */ + duk_hobject *prev_caller; +#endif + + duk_instr_t *curr_pc; /* next instruction to execute (points to 'func' bytecode, stable pointer), NULL for native calls */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) + duk_uint32_t prev_line; /* needed for stepping */ +#endif + duk_small_uint_t flags; + + /* idx_bottom and idx_retval are only used for book-keeping of + * Ecmascript-initiated calls, to allow returning to an Ecmascript + * function properly. They are duk_size_t to match the convention + * that value stack sizes are duk_size_t and local frame indices + * are duk_idx_t. + */ + + /* Bottom of valstack for this activation, used to reset + * valstack_bottom on return; index is absolute. Note: + * idx_top not needed because top is set to 'nregs' always + * when returning to an Ecmascript activation. + */ + duk_size_t idx_bottom; + + /* Return value when returning to this activation (points to caller + * reg, not callee reg); index is absolute (only set if activation is + * not topmost). + * + * Note: idx_bottom is always set, while idx_retval is only applicable + * for activations below the topmost one. Currently idx_retval for + * the topmost activation is considered garbage (and it not initialized + * on entry or cleared on return; may contain previous or garbage + * values). + */ + duk_size_t idx_retval; + + /* Current 'this' binding is the value just below idx_bottom. + * Previously, 'this' binding was handled with an index to the + * (calling) valstack. This works for everything except tail + * calls, which must not "cumulate" valstack temps. + */ +}; + +/* Note: it's nice if size is 2^N (not 4x4 = 16 bytes on 32 bit) */ +struct duk_catcher { + duk_hstring *h_varname; /* borrowed reference to catch variable name (or NULL if none) */ + /* (reference is valid as long activation exists) */ + duk_instr_t *pc_base; /* resume execution from pc_base or pc_base+1 (points to 'func' bytecode, stable pointer) */ + duk_size_t callstack_index; /* callstack index of related activation */ + duk_size_t idx_base; /* idx_base and idx_base+1 get completion value and type */ + duk_uint32_t flags; /* type and control flags, label number */ +}; + +struct duk_hthread { + /* Shared object part */ + duk_hobject obj; + + /* Pointer to bytecode executor's 'curr_pc' variable. Used to copy + * the current PC back into the topmost activation when activation + * state is about to change (or "syncing" is otherwise needed). This + * is rather awkward but important for performance, see execution.rst. + */ + duk_instr_t **ptr_curr_pc; + + /* backpointers */ + duk_heap *heap; + + /* current strictness flag: affects API calls */ + duk_uint8_t strict; + duk_uint8_t state; + duk_uint8_t unused1; + duk_uint8_t unused2; + + /* sanity limits */ + duk_size_t valstack_max; + duk_size_t callstack_max; + duk_size_t catchstack_max; + + /* XXX: valstack, callstack, and catchstack are currently assumed + * to have non-NULL pointers. Relaxing this would not lead to big + * benefits (except perhaps for terminated threads). + */ + + /* value stack: these are expressed as pointers for faster stack manipulation */ + duk_tval *valstack; /* start of valstack allocation */ + duk_tval *valstack_end; /* end of valstack allocation (exclusive) */ + duk_tval *valstack_bottom; /* bottom of current frame */ + duk_tval *valstack_top; /* top of current frame (exclusive) */ + + /* call stack */ + duk_activation *callstack; + duk_size_t callstack_size; /* allocation size */ + duk_size_t callstack_top; /* next to use, highest used is top - 1 */ + duk_size_t callstack_preventcount; /* number of activation records in callstack preventing a yield */ + + /* catch stack */ + duk_catcher *catchstack; + duk_size_t catchstack_size; /* allocation size */ + duk_size_t catchstack_top; /* next to use, highest used is top - 1 */ + + /* yield/resume book-keeping */ + duk_hthread *resumer; /* who resumed us (if any) */ + + /* current compiler state (if any), used for augmenting SyntaxErrors */ + duk_compiler_ctx *compile_ctx; + +#if defined(DUK_USE_INTERRUPT_COUNTER) + /* Interrupt counter for triggering a slow path check for execution + * timeout, debugger interaction such as breakpoints, etc. The value + * is valid for the current running thread, and both the init and + * counter values are copied whenever a thread switch occurs. It's + * important for the counter to be conveniently accessible for the + * bytecode executor inner loop for performance reasons. + */ + duk_int_t interrupt_counter; /* countdown state */ + duk_int_t interrupt_init; /* start value for current countdown */ +#endif + + /* Builtin-objects; may or may not be shared with other threads, + * threads existing in different "compartments" will have different + * built-ins. Must be stored on a per-thread basis because there + * is no intermediate structure for a thread group / compartment. + * This takes quite a lot of space, currently 43x4 = 172 bytes on + * 32-bit platforms. + */ + duk_hobject *builtins[DUK_NUM_BUILTINS]; + + /* convenience copies from heap/vm for faster access */ +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t *strs16; +#else + duk_hstring **strs; +#endif +}; + +/* + * Prototypes + */ + +DUK_INTERNAL_DECL void duk_hthread_copy_builtin_objects(duk_hthread *thr_from, duk_hthread *thr_to); +DUK_INTERNAL_DECL void duk_hthread_create_builtin_objects(duk_hthread *thr); +DUK_INTERNAL_DECL duk_bool_t duk_hthread_init_stacks(duk_heap *heap, duk_hthread *thr); +DUK_INTERNAL_DECL void duk_hthread_terminate(duk_hthread *thr); + +DUK_INTERNAL_DECL void duk_hthread_callstack_grow(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_hthread_callstack_shrink_check(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_hthread_callstack_unwind(duk_hthread *thr, duk_size_t new_top); +DUK_INTERNAL_DECL void duk_hthread_catchstack_grow(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_hthread_catchstack_shrink_check(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_hthread_catchstack_unwind(duk_hthread *thr, duk_size_t new_top); + +DUK_INTERNAL_DECL duk_activation *duk_hthread_get_current_activation(duk_hthread *thr); +DUK_INTERNAL_DECL void *duk_hthread_get_valstack_ptr(duk_heap *heap, void *ud); /* indirect allocs */ +DUK_INTERNAL_DECL void *duk_hthread_get_callstack_ptr(duk_heap *heap, void *ud); /* indirect allocs */ +DUK_INTERNAL_DECL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud); /* indirect allocs */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) +DUK_INTERNAL_DECL duk_uint_fast32_t duk_hthread_get_act_curr_pc(duk_hthread *thr, duk_activation *act); +#endif +DUK_INTERNAL_DECL duk_uint_fast32_t duk_hthread_get_act_prev_pc(duk_hthread *thr, duk_activation *act); +DUK_INTERNAL_DECL void duk_hthread_sync_currpc(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_hthread_sync_and_null_currpc(duk_hthread *thr); + +#endif /* DUK_HTHREAD_H_INCLUDED */ +#line 1 "duk_hbuffer.h" +/* + * Heap buffer representation. + * + * Heap allocated user data buffer which is either: + * + * 1. A fixed size buffer (data follows header statically) + * 2. A dynamic size buffer (data pointer follows header) + * + * The data pointer for a variable size buffer of zero size may be NULL. + */ + +#ifndef DUK_HBUFFER_H_INCLUDED +#define DUK_HBUFFER_H_INCLUDED + +/* + * Flags + * + * Fixed buffer: 0 + * Dynamic buffer: DUK_HBUFFER_FLAG_DYNAMIC + * External buffer: DUK_HBUFFER_FLAG_DYNAMIC | DUK_HBUFFER_FLAG_EXTERNAL + */ + +#define DUK_HBUFFER_FLAG_DYNAMIC DUK_HEAPHDR_USER_FLAG(0) /* buffer is behind a pointer, dynamic or external */ +#define DUK_HBUFFER_FLAG_EXTERNAL DUK_HEAPHDR_USER_FLAG(1) /* buffer pointer is to an externally allocated buffer */ + +#define DUK_HBUFFER_HAS_DYNAMIC(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC) +#define DUK_HBUFFER_HAS_EXTERNAL(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL) + +#define DUK_HBUFFER_SET_DYNAMIC(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC) +#define DUK_HBUFFER_SET_EXTERNAL(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL) + +#define DUK_HBUFFER_CLEAR_DYNAMIC(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC) +#define DUK_HBUFFER_CLEAR_EXTERNAL(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL) + +/* + * Misc defines + */ + +/* Impose a maximum buffer length for now. Restricted artificially to + * ensure resize computations or adding a heap header length won't + * overflow size_t and that a signed duk_int_t can hold a buffer + * length. The limit should be synchronized with DUK_HSTRING_MAX_BYTELEN. + */ + +#if defined(DUK_USE_BUFLEN16) +#define DUK_HBUFFER_MAX_BYTELEN (0x0000ffffUL) +#else +/* Intentionally not 0x7fffffffUL; at least JSON code expects that + * 2*len + 2 fits in 32 bits. + */ +#define DUK_HBUFFER_MAX_BYTELEN (0x7ffffffeUL) +#endif + +/* + * Field access + */ + +/* Get/set the current user visible size, without accounting for a dynamic + * buffer's "spare" (= usable size). + */ +#if defined(DUK_USE_BUFLEN16) +/* size stored in duk_heaphdr unused flag bits */ +#define DUK_HBUFFER_GET_SIZE(x) ((x)->hdr.h_flags >> 16) +#define DUK_HBUFFER_SET_SIZE(x,v) do { \ + (x)->hdr.h_flags = ((x)->hdr.h_flags & 0x0000ffffUL) | ((v) << 16); \ + } while (0) +#define DUK_HBUFFER_ADD_SIZE(x,dv) do { \ + (x)->hdr.h_flags += ((dv) << 16); \ + } while (0) +#define DUK_HBUFFER_SUB_SIZE(x,dv) do { \ + (x)->hdr.h_flags -= ((dv) << 16); \ + } while (0) +#else +#define DUK_HBUFFER_GET_SIZE(x) (((duk_hbuffer *) (x))->size) +#define DUK_HBUFFER_SET_SIZE(x,v) do { \ + ((duk_hbuffer *) (x))->size = (v); \ + } while (0) +#define DUK_HBUFFER_ADD_SIZE(x,dv) do { \ + (x)->size += (dv); \ + } while (0) +#define DUK_HBUFFER_SUB_SIZE(x,dv) do { \ + (x)->size -= (dv); \ + } while (0) +#endif + +#define DUK_HBUFFER_FIXED_GET_SIZE(x) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x)) +#define DUK_HBUFFER_FIXED_SET_SIZE(x,v) DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x)) + +#define DUK_HBUFFER_DYNAMIC_GET_SIZE(x) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x)) +#define DUK_HBUFFER_DYNAMIC_SET_SIZE(x,v) DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v)) +#define DUK_HBUFFER_DYNAMIC_ADD_SIZE(x,dv) DUK_HBUFFER_ADD_SIZE((duk_hbuffer *) (x), (dv)) +#define DUK_HBUFFER_DYNAMIC_SUB_SIZE(x,dv) DUK_HBUFFER_SUB_SIZE((duk_hbuffer *) (x), (dv)) + +#define DUK_HBUFFER_EXTERNAL_GET_SIZE(x) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x)) +#define DUK_HBUFFER_EXTERNAL_SET_SIZE(x,v) DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v)) + +#define DUK_HBUFFER_FIXED_GET_DATA_PTR(heap,x) ((duk_uint8_t *) (((duk_hbuffer_fixed *) (x)) + 1)) + +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap,x) \ + ((void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, ((duk_heaphdr *) (x))->h_extra16)) +#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v) do { \ + ((duk_heaphdr *) (x))->h_extra16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ + } while (0) +#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x) do { \ + ((duk_heaphdr *) (x))->h_extra16 = 0; /* assume 0 <=> NULL */ \ + } while (0) +#else +#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap,x) ((x)->curr_alloc) +#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v) do { \ + (x)->curr_alloc = (void *) (v); \ + } while (0) +#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x) do { \ + (x)->curr_alloc = (void *) NULL; \ + } while (0) +#endif + +/* No pointer compression because pointer is potentially outside of + * Duktape heap. + */ +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap,x) \ + ((void *) (x)->curr_alloc) +#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v) do { \ + (x)->curr_alloc = (void *) (v); \ + } while (0) +#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap,x) do { \ + (x)->curr_alloc = (void *) NULL; \ + } while (0) +#else +#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap,x) \ + ((void *) (x)->curr_alloc) +#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v) do { \ + (x)->curr_alloc = (void *) (v); \ + } while (0) +#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap,x) do { \ + (x)->curr_alloc = (void *) NULL; \ + } while (0) +#endif + +/* Get a pointer to the current buffer contents (matching current allocation + * size). May be NULL for zero size dynamic/external buffer. + */ +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HBUFFER_GET_DATA_PTR(heap,x) ( \ + DUK_HBUFFER_HAS_DYNAMIC((x)) ? \ + ( \ + DUK_HBUFFER_HAS_EXTERNAL((x)) ? \ + DUK_HBUFFER_EXTERNAL_GET_DATA_PTR((heap), (duk_hbuffer_external *) (x)) : \ + DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) \ + ) : \ + DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (x)) \ + ) +#else +/* Without heap pointer compression duk_hbuffer_dynamic and duk_hbuffer_external + * have the same layout so checking for fixed vs. dynamic (or external) is enough. + */ +#define DUK_HBUFFER_GET_DATA_PTR(heap,x) ( \ + DUK_HBUFFER_HAS_DYNAMIC((x)) ? \ + DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) : \ + DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (x)) \ + ) +#endif + +/* + * Structs + */ + +/* Shared prefix for all buffer types. */ +struct duk_hbuffer { + duk_heaphdr hdr; + + /* It's not strictly necessary to track the current size, but + * it is useful for writing robust native code. + */ + + /* Current size (not counting a dynamic buffer's "spare"). */ +#if defined(DUK_USE_BUFLEN16) + /* Stored in duk_heaphdr unused flags. */ +#else + duk_size_t size; +#endif + + /* + * Data following the header depends on the DUK_HBUFFER_FLAG_DYNAMIC + * flag. + * + * If the flag is clear (the buffer is a fixed size one), the buffer + * data follows the header directly, consisting of 'size' bytes. + * + * If the flag is set, the actual buffer is allocated separately, and + * a few control fields follow the header. Specifically: + * + * - a "void *" pointing to the current allocation + * - a duk_size_t indicating the full allocated size (always >= 'size') + * + * If DUK_HBUFFER_FLAG_EXTERNAL is set, the buffer has been allocated + * by user code, so that Duktape won't be able to resize it and won't + * free it. This allows buffers to point to e.g. an externally + * allocated structure such as a frame buffer. + * + * Unlike strings, no terminator byte (NUL) is guaranteed after the + * data. This would be convenient, but would pad aligned user buffers + * unnecessarily upwards in size. For instance, if user code requested + * a 64-byte dynamic buffer, 65 bytes would actually be allocated which + * would then potentially round upwards to perhaps 68 or 72 bytes. + */ +}; + +/* Fixed buffer; data follows struct, with proper alignment guaranteed by + * struct size. + */ +#if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_MSVC_PRAGMA) +#pragma pack(push, 8) +#endif +struct duk_hbuffer_fixed { + /* A union is used here as a portable struct size / alignment trick: + * by adding a 32-bit or a 64-bit (unused) union member, the size of + * the struct is effectively forced to be a multiple of 4 or 8 bytes + * (respectively) without increasing the size of the struct unless + * necessary. + */ + union { + struct { + duk_heaphdr hdr; +#if defined(DUK_USE_BUFLEN16) + /* Stored in duk_heaphdr unused flags. */ +#else + duk_size_t size; +#endif + } s; +#if (DUK_USE_ALIGN_BY == 4) + duk_uint32_t dummy_for_align4; +#elif (DUK_USE_ALIGN_BY == 8) + duk_double_t dummy_for_align8; +#elif (DUK_USE_ALIGN_BY == 1) + /* no extra padding */ +#else +#error invalid DUK_USE_ALIGN_BY +#endif + } u; + + /* + * Data follows the struct header. The struct size is padded by the + * compiler based on the struct members. This guarantees that the + * buffer data will be aligned-by-4 but not necessarily aligned-by-8. + * + * On platforms where alignment does not matter, the struct padding + * could be removed (if there is any). On platforms where alignment + * by 8 is required, the struct size must be forced to be a multiple + * of 8 by some means. Without it, some user code may break, and also + * Duktape itself breaks (e.g. the compiler stores duk_tvals in a + * dynamic buffer). + */ +} +#if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_GCC_ATTR) +__attribute__ ((aligned (8))) +#elif (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_CLANG_ATTR) +__attribute__ ((aligned (8))) +#endif +; +#if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_MSVC_PRAGMA) +#pragma pack(pop) +#endif + +/* Dynamic buffer with 'curr_alloc' pointing to a dynamic area allocated using + * heap allocation primitives. Also used for external buffers when low memory + * options are not used. + */ +struct duk_hbuffer_dynamic { + duk_heaphdr hdr; + +#if defined(DUK_USE_BUFLEN16) + /* Stored in duk_heaphdr unused flags. */ +#else + duk_size_t size; +#endif + +#if defined(DUK_USE_HEAPPTR16) + /* Stored in duk_heaphdr h_extra16. */ +#else + void *curr_alloc; /* may be NULL if alloc_size == 0 */ +#endif + + /* + * Allocation size for 'curr_alloc' is alloc_size. There is no + * automatic NUL terminator for buffers (see above for rationale). + * + * 'curr_alloc' is explicitly allocated with heap allocation + * primitives and will thus always have alignment suitable for + * e.g. duk_tval and an IEEE double. + */ +}; + +/* External buffer with 'curr_alloc' managed by user code and pointing to an + * arbitrary address. When heap pointer compression is not used, this struct + * has the same layout as duk_hbuffer_dynamic. + */ +struct duk_hbuffer_external { + duk_heaphdr hdr; + +#if defined(DUK_USE_BUFLEN16) + /* Stored in duk_heaphdr unused flags. */ +#else + duk_size_t size; +#endif + + /* Cannot be compressed as a heap pointer because may point to + * an arbitrary address. + */ + void *curr_alloc; /* may be NULL if alloc_size == 0 */ +}; + +/* + * Prototypes + */ + +DUK_INTERNAL_DECL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags, void **out_bufdata); +DUK_INTERNAL_DECL void *duk_hbuffer_get_dynalloc_ptr(duk_heap *heap, void *ud); /* indirect allocs */ + +/* dynamic buffer ops */ +DUK_INTERNAL_DECL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size); +DUK_INTERNAL_DECL void duk_hbuffer_reset(duk_hthread *thr, duk_hbuffer_dynamic *buf); + +#endif /* DUK_HBUFFER_H_INCLUDED */ +#line 1 "duk_heap.h" +/* + * Heap structure. + * + * Heap contains allocated heap objects, interned strings, and built-in + * strings for one or more threads. + */ + +#ifndef DUK_HEAP_H_INCLUDED +#define DUK_HEAP_H_INCLUDED + +/* alloc function typedefs in duktape.h */ + +/* + * Heap flags + */ + +#define DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING (1 << 0) /* mark-and-sweep is currently running */ +#define DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED (1 << 1) /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */ +#define DUK_HEAP_FLAG_REFZERO_FREE_RUNNING (1 << 2) /* refcount code is processing refzero list */ +#define DUK_HEAP_FLAG_ERRHANDLER_RUNNING (1 << 3) /* an error handler (user callback to augment/replace error) is running */ +#define DUK_HEAP_FLAG_INTERRUPT_RUNNING (1 << 4) /* executor interrupt running (used to avoid nested interrupts) */ + +#define DUK__HEAP_HAS_FLAGS(heap,bits) ((heap)->flags & (bits)) +#define DUK__HEAP_SET_FLAGS(heap,bits) do { \ + (heap)->flags |= (bits); \ + } while (0) +#define DUK__HEAP_CLEAR_FLAGS(heap,bits) do { \ + (heap)->flags &= ~(bits); \ + } while (0) + +#define DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING) +#define DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED) +#define DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING) +#define DUK_HEAP_HAS_ERRHANDLER_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING) +#define DUK_HEAP_HAS_INTERRUPT_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) + +#define DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING) +#define DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED) +#define DUK_HEAP_SET_REFZERO_FREE_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING) +#define DUK_HEAP_SET_ERRHANDLER_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING) +#define DUK_HEAP_SET_INTERRUPT_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) + +#define DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING) +#define DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED) +#define DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING) +#define DUK_HEAP_CLEAR_ERRHANDLER_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING) +#define DUK_HEAP_CLEAR_INTERRUPT_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) + +/* + * Longjmp types, also double as identifying continuation type for a rethrow (in 'finally') + */ + +#define DUK_LJ_TYPE_UNKNOWN 0 /* unused */ +#define DUK_LJ_TYPE_RETURN 1 /* value1 -> return value */ +#define DUK_LJ_TYPE_THROW 2 /* value1 -> error object */ +#define DUK_LJ_TYPE_BREAK 3 /* value1 -> label number */ +#define DUK_LJ_TYPE_CONTINUE 4 /* value1 -> label number */ +#define DUK_LJ_TYPE_YIELD 5 /* value1 -> yield value, iserror -> error / normal */ +#define DUK_LJ_TYPE_RESUME 6 /* value1 -> resume value, value2 -> resumee thread, iserror -> error/normal */ +#define DUK_LJ_TYPE_NORMAL 7 /* pseudo-type to indicate a normal continuation (for 'finally' rethrowing) */ + +/* + * Mark-and-sweep flags + * + * These are separate from heap level flags now but could be merged. + * The heap structure only contains a 'base mark-and-sweep flags' + * field and the GC caller can impose further flags. + */ + +#define DUK_MS_FLAG_EMERGENCY (1 << 0) /* emergency mode: try extra hard */ +#define DUK_MS_FLAG_NO_STRINGTABLE_RESIZE (1 << 1) /* don't resize stringtable (but may sweep it); needed during stringtable resize */ +#define DUK_MS_FLAG_NO_FINALIZERS (1 << 2) /* don't run finalizers (which may have arbitrary side effects) */ +#define DUK_MS_FLAG_NO_OBJECT_COMPACTION (1 << 3) /* don't compact objects; needed during object property allocation resize */ + +/* + * Thread switching + * + * To switch heap->curr_thread, use the macro below so that interrupt counters + * get updated correctly. The macro allows a NULL target thread because that + * happens e.g. in call handling. + */ + +#if defined(DUK_USE_INTERRUPT_COUNTER) +#define DUK_HEAP_SWITCH_THREAD(heap,newthr) duk_heap_switch_thread((heap), (newthr)) +#else +#define DUK_HEAP_SWITCH_THREAD(heap,newthr) do { \ + (heap)->curr_thread = (newthr); \ + } while (0) +#endif + +/* + * Other heap related defines + */ + +/* Mark-and-sweep interval is relative to combined count of objects and + * strings kept in the heap during the latest mark-and-sweep pass. + * Fixed point .8 multiplier and .0 adder. Trigger count (interval) is + * decreased by each (re)allocation attempt (regardless of size), and each + * refzero processed object. + * + * 'SKIP' indicates how many (re)allocations to wait until a retry if + * GC is skipped because there is no thread do it with yet (happens + * only during init phases). + */ +#if defined(DUK_USE_MARK_AND_SWEEP) +#if defined(DUK_USE_REFERENCE_COUNTING) +#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT 12800L /* 50x heap size */ +#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD 1024L +#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP 256L +#else +#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT 256L /* 1x heap size */ +#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD 1024L +#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP 256L +#endif +#endif + +/* Stringcache is used for speeding up char-offset-to-byte-offset + * translations for non-ASCII strings. + */ +#define DUK_HEAP_STRCACHE_SIZE 4 +#define DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT 16 /* strings up to the this length are not cached */ + +/* helper to insert a (non-string) heap object into heap allocated list */ +#define DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap,hdr) duk_heap_insert_into_heap_allocated((heap),(hdr)) + +/* + * Stringtable + */ + +/* initial stringtable size, must be prime and higher than DUK_UTIL_MIN_HASH_PRIME */ +#define DUK_STRTAB_INITIAL_SIZE 17 + +/* indicates a deleted string; any fixed non-NULL, non-hstring pointer works */ +#define DUK_STRTAB_DELETED_MARKER(heap) ((duk_hstring *) heap) + +/* resizing parameters */ +#define DUK_STRTAB_MIN_FREE_DIVISOR 4 /* load factor max 75% */ +#define DUK_STRTAB_MIN_USED_DIVISOR 4 /* load factor min 25% */ +#define DUK_STRTAB_GROW_ST_SIZE(n) ((n) + (n)) /* used entries + approx 100% -> reset load to 50% */ + +#define DUK_STRTAB_U32_MAX_STRLEN 10 /* 4'294'967'295 */ +#define DUK_STRTAB_HIGHEST_32BIT_PRIME 0xfffffffbUL + +/* probe sequence (open addressing) */ +#define DUK_STRTAB_HASH_INITIAL(hash,h_size) ((hash) % (h_size)) +#define DUK_STRTAB_HASH_PROBE_STEP(hash) DUK_UTIL_GET_HASH_PROBE_STEP((hash)) + +/* fixed top level hashtable size (separate chaining) */ +#define DUK_STRTAB_CHAIN_SIZE DUK_USE_STRTAB_CHAIN_SIZE + +/* + * Built-in strings + */ + +/* heap string indices are autogenerated in duk_strings.h */ +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HEAP_GET_STRING(heap,idx) \ + ((duk_hstring *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (heap)->strs16[(idx)])) +#else +#define DUK_HEAP_GET_STRING(heap,idx) \ + ((heap)->strs[(idx)]) +#endif + +/* + * Raw memory calls: relative to heap, but no GC interaction + */ + +#define DUK_ALLOC_RAW(heap,size) \ + ((heap)->alloc_func((heap)->heap_udata, (size))) + +#define DUK_REALLOC_RAW(heap,ptr,newsize) \ + ((heap)->realloc_func((heap)->heap_udata, (void *) (ptr), (newsize))) + +#define DUK_FREE_RAW(heap,ptr) \ + ((heap)->free_func((heap)->heap_udata, (void *) (ptr))) + +/* + * Memory calls: relative to heap, GC interaction, but no error throwing. + * + * XXX: Currently a mark-and-sweep triggered by memory allocation will run + * using the heap->heap_thread. This thread is also used for running + * mark-and-sweep finalization; this is not ideal because it breaks the + * isolation between multiple global environments. + * + * Notes: + * + * - DUK_FREE() is required to ignore NULL and any other possible return + * value of a zero-sized alloc/realloc (same as ANSI C free()). + * + * - There is no DUK_REALLOC_ZEROED because we don't assume to know the + * old size. Caller must zero the reallocated memory. + * + * - DUK_REALLOC_INDIRECT() must be used when a mark-and-sweep triggered + * by an allocation failure might invalidate the original 'ptr', thus + * causing a realloc retry to use an invalid pointer. Example: we're + * reallocating the value stack and a finalizer resizes the same value + * stack during mark-and-sweep. The indirect variant requests for the + * current location of the pointer being reallocated using a callback + * right before every realloc attempt; this circuitous approach is used + * to avoid strict aliasing issues in a more straightforward indirect + * pointer (void **) approach. Note: the pointer in the storage + * location is read but is NOT updated; the caller must do that. + */ + +/* callback for indirect reallocs, request for current pointer */ +typedef void *(*duk_mem_getptr)(duk_heap *heap, void *ud); + +#define DUK_ALLOC(heap,size) duk_heap_mem_alloc((heap), (size)) +#define DUK_ALLOC_ZEROED(heap,size) duk_heap_mem_alloc_zeroed((heap), (size)) +#define DUK_REALLOC(heap,ptr,newsize) duk_heap_mem_realloc((heap), (ptr), (newsize)) +#define DUK_REALLOC_INDIRECT(heap,cb,ud,newsize) duk_heap_mem_realloc_indirect((heap), (cb), (ud), (newsize)) +#define DUK_FREE(heap,ptr) duk_heap_mem_free((heap), (ptr)) + +/* + * Memory constants + */ + +#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT 5 /* Retry allocation after mark-and-sweep for this + * many times. A single mark-and-sweep round is + * not guaranteed to free all unreferenced memory + * because of finalization (in fact, ANY number of + * rounds is strictly not enough). + */ + +#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT 3 /* Starting from this round, use emergency mode + * for mark-and-sweep. + */ + +/* + * Debugger support + */ + +/* Maximum number of breakpoints. Only breakpoints that are set are + * consulted so increasing this has no performance impact. + */ +#define DUK_HEAP_MAX_BREAKPOINTS 16 + +/* Opcode interval for a Date-based status/peek rate limit check. Only + * relevant when debugger is attached. Requesting a timestamp may be a + * slow operation on some platforms so this shouldn't be too low. On the + * other hand a high value makes Duktape react to a pause request slowly. + */ +#define DUK_HEAP_DBG_RATELIMIT_OPCODES 4000 + +/* Milliseconds between status notify and transport peeks. */ +#define DUK_HEAP_DBG_RATELIMIT_MILLISECS 200 + +/* Step types */ +#define DUK_STEP_TYPE_NONE 0 +#define DUK_STEP_TYPE_INTO 1 +#define DUK_STEP_TYPE_OVER 2 +#define DUK_STEP_TYPE_OUT 3 + +struct duk_breakpoint { + duk_hstring *filename; + duk_uint32_t line; +}; + +#if defined(DUK_USE_DEBUGGER_SUPPORT) +#define DUK_HEAP_IS_DEBUGGER_ATTACHED(heap) ((heap)->dbg_read_cb != NULL) +#define DUK_HEAP_CLEAR_STEP_STATE(heap) do { \ + (heap)->dbg_step_type = DUK_STEP_TYPE_NONE; \ + (heap)->dbg_step_thread = NULL; \ + (heap)->dbg_step_csindex = 0; \ + (heap)->dbg_step_startline = 0; \ + } while (0) +#define DUK_HEAP_SET_PAUSED(heap) do { \ + (heap)->dbg_paused = 1; \ + (heap)->dbg_state_dirty = 1; \ + DUK_HEAP_CLEAR_STEP_STATE((heap)); \ + } while (0) +#define DUK_HEAP_CLEAR_PAUSED(heap) do { \ + (heap)->dbg_paused = 0; \ + (heap)->dbg_state_dirty = 1; \ + DUK_HEAP_CLEAR_STEP_STATE((heap)); \ + } while (0) +#endif /* DUK_USE_DEBUGGER_SUPPORT */ + +/* + * String cache should ideally be at duk_hthread level, but that would + * cause string finalization to slow down relative to the number of + * threads; string finalization must check the string cache for "weak" + * references to the string being finalized to avoid dead pointers. + * + * Thus, string caches are now at the heap level now. + */ + +struct duk_strcache { + duk_hstring *h; + duk_uint32_t bidx; + duk_uint32_t cidx; +}; + +/* + * Longjmp state, contains the information needed to perform a longjmp. + * Longjmp related values are written to value1, value2, and iserror. + */ + +struct duk_ljstate { + duk_jmpbuf *jmpbuf_ptr; /* current setjmp() catchpoint */ + duk_small_uint_t type; /* longjmp type */ + duk_bool_t iserror; /* isError flag for yield */ + duk_tval value1; /* 1st related value (type specific) */ + duk_tval value2; /* 2nd related value (type specific) */ +}; + +/* + * Stringtable entry for fixed size stringtable + */ + +struct duk_strtab_entry { +#if defined(DUK_USE_HEAPPTR16) + /* A 16-bit listlen makes sense with 16-bit heap pointers: there + * won't be space for 64k strings anyway. + */ + duk_uint16_t listlen; /* if 0, 'str16' used, if > 0, 'strlist16' used */ + union { + duk_uint16_t strlist16; + duk_uint16_t str16; + } u; +#else + duk_size_t listlen; /* if 0, 'str' used, if > 0, 'strlist' used */ + union { + duk_hstring **strlist; + duk_hstring *str; + } u; +#endif +}; + +/* + * Main heap structure + */ + +struct duk_heap { + duk_small_uint_t flags; + + /* Allocator functions. */ + duk_alloc_function alloc_func; + duk_realloc_function realloc_func; + duk_free_function free_func; + + /* Heap udata, used for allocator functions but also for other heap + * level callbacks like pointer compression, etc. + */ + void *heap_udata; + + /* Precomputed pointers when using 16-bit heap pointer packing. */ +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t heapptr_null16; + duk_uint16_t heapptr_deleted16; +#endif + + /* Fatal error handling, called e.g. when a longjmp() is needed but + * lj.jmpbuf_ptr is NULL. fatal_func must never return; it's not + * declared as "noreturn" because doing that for typedefs is a bit + * challenging portability-wise. + */ + duk_fatal_function fatal_func; + + /* allocated heap objects */ + duk_heaphdr *heap_allocated; + + /* work list for objects whose refcounts are zero but which have not been + * "finalized"; avoids recursive C calls when refcounts go to zero in a + * chain of objects. + */ +#if defined(DUK_USE_REFERENCE_COUNTING) + duk_heaphdr *refzero_list; + duk_heaphdr *refzero_list_tail; +#endif + +#if defined(DUK_USE_MARK_AND_SWEEP) + /* mark-and-sweep control */ +#if defined(DUK_USE_VOLUNTARY_GC) + duk_int_t mark_and_sweep_trigger_counter; +#endif + duk_int_t mark_and_sweep_recursion_depth; + + /* mark-and-sweep flags automatically active (used for critical sections) */ + duk_small_uint_t mark_and_sweep_base_flags; + + /* work list for objects to be finalized (by mark-and-sweep) */ + duk_heaphdr *finalize_list; +#endif + + /* longjmp state */ + duk_ljstate lj; + + /* marker for detecting internal "double faults", see duk_error_throw.c */ + duk_bool_t handling_error; + + /* heap thread, used internally and for finalization */ + duk_hthread *heap_thread; + + /* current thread */ + duk_hthread *curr_thread; /* currently running thread */ + + /* heap level "stash" object (e.g., various reachability roots) */ + duk_hobject *heap_object; + + /* duk_handle_call / duk_handle_safe_call recursion depth limiting */ + duk_int_t call_recursion_depth; + duk_int_t call_recursion_limit; + + /* mix-in value for computing string hashes; should be reasonably unpredictable */ + duk_uint32_t hash_seed; + + /* rnd_state for duk_util_tinyrandom.c */ + duk_uint32_t rnd_state; + + /* For manual debugging: instruction count based on executor and + * interrupt counter book-keeping. Inspect debug logs to see how + * they match up. + */ +#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) + duk_int_t inst_count_exec; + duk_int_t inst_count_interrupt; +#endif + + /* debugger */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) + /* callbacks and udata; dbg_read_cb != NULL is used to indicate attached state */ + duk_debug_read_function dbg_read_cb; /* required, NULL implies detached */ + duk_debug_write_function dbg_write_cb; /* required */ + duk_debug_peek_function dbg_peek_cb; + duk_debug_read_flush_function dbg_read_flush_cb; + duk_debug_write_flush_function dbg_write_flush_cb; + duk_debug_detached_function dbg_detached_cb; + void *dbg_udata; + + /* debugger state, only relevant when attached */ + duk_bool_t dbg_processing; /* currently processing messages or breakpoints: don't enter message processing recursively (e.g. no breakpoints when processing debugger eval) */ + duk_bool_t dbg_paused; /* currently paused: talk with debug client until step/resume */ + duk_bool_t dbg_state_dirty; /* resend state next time executor is about to run */ + duk_bool_t dbg_force_restart; /* force executor restart to recheck breakpoints; used to handle function returns (see GH-303) */ + duk_small_uint_t dbg_step_type; /* step type: none, step into, step over, step out */ + duk_hthread *dbg_step_thread; /* borrowed; NULL if no step state (NULLed in unwind) */ + duk_size_t dbg_step_csindex; /* callstack index */ + duk_uint32_t dbg_step_startline; /* starting line number */ + duk_breakpoint dbg_breakpoints[DUK_HEAP_MAX_BREAKPOINTS]; /* breakpoints: [0,breakpoint_count[ gc reachable */ + duk_small_uint_t dbg_breakpoint_count; + duk_breakpoint *dbg_breakpoints_active[DUK_HEAP_MAX_BREAKPOINTS + 1]; /* currently active breakpoints: NULL term, borrowed pointers */ + /* XXX: make active breakpoints actual copies instead of pointers? */ + + /* These are for rate limiting Status notifications and transport peeking. */ + duk_uint32_t dbg_exec_counter; /* cumulative opcode execution count (overflows are OK) */ + duk_uint32_t dbg_last_counter; /* value of dbg_exec_counter when we last did a Date-based check */ + duk_double_t dbg_last_time; /* time when status/peek was last done (Date-based rate limit) */ +#endif + + /* string intern table (weak refs) */ +#if defined(DUK_USE_STRTAB_PROBE) +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t *strtable16; +#else + duk_hstring **strtable; +#endif + duk_uint32_t st_size; /* alloc size in elements */ + duk_uint32_t st_used; /* used elements (includes DELETED) */ +#endif + + /* XXX: static alloc is OK until separate chaining stringtable + * resizing is implemented. + */ +#if defined(DUK_USE_STRTAB_CHAIN) + duk_strtab_entry strtable[DUK_STRTAB_CHAIN_SIZE]; +#endif + + /* string access cache (codepoint offset -> byte offset) for fast string + * character looping; 'weak' reference which needs special handling in GC. + */ + duk_strcache strcache[DUK_HEAP_STRCACHE_SIZE]; + + /* built-in strings */ +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t strs16[DUK_HEAP_NUM_STRINGS]; +#else + duk_hstring *strs[DUK_HEAP_NUM_STRINGS]; +#endif +}; + +/* + * Prototypes + */ + +DUK_INTERNAL_DECL +duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, + duk_realloc_function realloc_func, + duk_free_function free_func, + void *heap_udata, + duk_fatal_function fatal_func); +DUK_INTERNAL_DECL void duk_heap_free(duk_heap *heap); +DUK_INTERNAL_DECL void duk_free_hobject_inner(duk_heap *heap, duk_hobject *h); +DUK_INTERNAL_DECL void duk_free_hbuffer_inner(duk_heap *heap, duk_hbuffer *h); +DUK_INTERNAL_DECL void duk_free_hstring_inner(duk_heap *heap, duk_hstring *h); +DUK_INTERNAL_DECL void duk_heap_free_heaphdr_raw(duk_heap *heap, duk_heaphdr *hdr); + +DUK_INTERNAL_DECL void duk_heap_insert_into_heap_allocated(duk_heap *heap, duk_heaphdr *hdr); +#if defined(DUK_USE_DOUBLE_LINKED_HEAP) && defined(DUK_USE_REFERENCE_COUNTING) +DUK_INTERNAL_DECL void duk_heap_remove_any_from_heap_allocated(duk_heap *heap, duk_heaphdr *hdr); +#endif +#if defined(DUK_USE_INTERRUPT_COUNTER) +DUK_INTERNAL_DECL void duk_heap_switch_thread(duk_heap *heap, duk_hthread *new_thr); +#endif + +#if 0 /*unused*/ +DUK_INTERNAL_DECL duk_hstring *duk_heap_string_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen); +#endif +DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen); +DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_checked(duk_hthread *thr, const duk_uint8_t *str, duk_uint32_t len); +#if 0 /*unused*/ +DUK_INTERNAL_DECL duk_hstring *duk_heap_string_lookup_u32(duk_heap *heap, duk_uint32_t val); +#endif +DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_u32(duk_heap *heap, duk_uint32_t val); +DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_u32_checked(duk_hthread *thr, duk_uint32_t val); +DUK_INTERNAL_DECL void duk_heap_string_remove(duk_heap *heap, duk_hstring *h); +#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_MS_STRINGTABLE_RESIZE) +DUK_INTERNAL_DECL void duk_heap_force_strtab_resize(duk_heap *heap); +#endif +DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap); +#if defined(DUK_USE_DEBUG) +DUK_INTERNAL void duk_heap_dump_strtab(duk_heap *heap); +#endif + + +DUK_INTERNAL_DECL void duk_heap_strcache_string_remove(duk_heap *heap, duk_hstring *h); +DUK_INTERNAL_DECL duk_uint_fast32_t duk_heap_strcache_offset_char2byte(duk_hthread *thr, duk_hstring *h, duk_uint_fast32_t char_offset); + +#if defined(DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS) +DUK_INTERNAL_DECL void *duk_default_alloc_function(void *udata, duk_size_t size); +DUK_INTERNAL_DECL void *duk_default_realloc_function(void *udata, void *ptr, duk_size_t newsize); +DUK_INTERNAL_DECL void duk_default_free_function(void *udata, void *ptr); +#endif + +DUK_INTERNAL_DECL void *duk_heap_mem_alloc(duk_heap *heap, duk_size_t size); +DUK_INTERNAL_DECL void *duk_heap_mem_alloc_zeroed(duk_heap *heap, duk_size_t size); +DUK_INTERNAL_DECL void *duk_heap_mem_realloc(duk_heap *heap, void *ptr, duk_size_t newsize); +DUK_INTERNAL_DECL void *duk_heap_mem_realloc_indirect(duk_heap *heap, duk_mem_getptr cb, void *ud, duk_size_t newsize); +DUK_INTERNAL_DECL void duk_heap_mem_free(duk_heap *heap, void *ptr); + +#ifdef DUK_USE_REFERENCE_COUNTING +#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT) +DUK_INTERNAL_DECL void duk_tval_incref(duk_tval *tv); +#endif +#if 0 /* unused */ +DUK_INTERNAL_DECL void duk_tval_incref_allownull(duk_tval *tv); +#endif +DUK_INTERNAL_DECL void duk_tval_decref(duk_hthread *thr, duk_tval *tv); +#if 0 /* unused */ +DUK_INTERNAL_DECL void duk_tval_decref_allownull(duk_hthread *thr, duk_tval *tv); +#endif +#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT) +DUK_INTERNAL_DECL void duk_heaphdr_incref(duk_heaphdr *h); +#endif +#if 0 /* unused */ +DUK_INTERNAL_DECL void duk_heaphdr_incref_allownull(duk_heaphdr *h); +#endif +DUK_INTERNAL_DECL void duk_heaphdr_decref(duk_hthread *thr, duk_heaphdr *h); +DUK_INTERNAL_DECL void duk_heaphdr_decref_allownull(duk_hthread *thr, duk_heaphdr *h); +DUK_INTERNAL_DECL void duk_heaphdr_refzero(duk_hthread *thr, duk_heaphdr *h); +DUK_INTERNAL_DECL void duk_heaphdr_refcount_finalize(duk_hthread *thr, duk_heaphdr *hdr); +#else +/* no refcounting */ +#endif + +#if defined(DUK_USE_MARK_AND_SWEEP) +DUK_INTERNAL_DECL duk_bool_t duk_heap_mark_and_sweep(duk_heap *heap, duk_small_uint_t flags); +#endif + +DUK_INTERNAL_DECL duk_uint32_t duk_heap_hashstring(duk_heap *heap, const duk_uint8_t *str, duk_size_t len); + +#endif /* DUK_HEAP_H_INCLUDED */ +#line 1 "duk_debugger.h" +#ifndef DUK_DEBUGGER_H_INCLUDED +#define DUK_DEBUGGER_H_INCLUDED + +/* Debugger protocol version is defined in the public API header. */ + +#define DUK_DBG_MARKER_EOM 0x00 +#define DUK_DBG_MARKER_REQUEST 0x01 +#define DUK_DBG_MARKER_REPLY 0x02 +#define DUK_DBG_MARKER_ERROR 0x03 +#define DUK_DBG_MARKER_NOTIFY 0x04 + +#define DUK_DBG_ERR_UNKNOWN 0x00 +#define DUK_DBG_ERR_UNSUPPORTED 0x01 +#define DUK_DBG_ERR_TOOMANY 0x02 +#define DUK_DBG_ERR_NOTFOUND 0x03 + +/* Initiated by Duktape */ +#define DUK_DBG_CMD_STATUS 0x01 +#define DUK_DBG_CMD_PRINT 0x02 +#define DUK_DBG_CMD_ALERT 0x03 +#define DUK_DBG_CMD_LOG 0x04 + +/* Initiated by debug client */ +#define DUK_DBG_CMD_BASICINFO 0x10 +#define DUK_DBG_CMD_TRIGGERSTATUS 0x11 +#define DUK_DBG_CMD_PAUSE 0x12 +#define DUK_DBG_CMD_RESUME 0x13 +#define DUK_DBG_CMD_STEPINTO 0x14 +#define DUK_DBG_CMD_STEPOVER 0x15 +#define DUK_DBG_CMD_STEPOUT 0x16 +#define DUK_DBG_CMD_LISTBREAK 0x17 +#define DUK_DBG_CMD_ADDBREAK 0x18 +#define DUK_DBG_CMD_DELBREAK 0x19 +#define DUK_DBG_CMD_GETVAR 0x1a +#define DUK_DBG_CMD_PUTVAR 0x1b +#define DUK_DBG_CMD_GETCALLSTACK 0x1c +#define DUK_DBG_CMD_GETLOCALS 0x1d +#define DUK_DBG_CMD_EVAL 0x1e +#define DUK_DBG_CMD_DETACH 0x1f +#define DUK_DBG_CMD_DUMPHEAP 0x20 +#define DUK_DBG_CMD_GETBYTECODE 0x21 + +#if defined(DUK_USE_DEBUGGER_SUPPORT) +DUK_INTERNAL_DECL void duk_debug_do_detach(duk_heap *heap); + +DUK_INTERNAL_DECL duk_bool_t duk_debug_read_peek(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_debug_write_flush(duk_hthread *thr); + +DUK_INTERNAL_DECL void duk_debug_skip_bytes(duk_hthread *thr, duk_size_t length); +DUK_INTERNAL_DECL void duk_debug_skip_byte(duk_hthread *thr); + +DUK_INTERNAL_DECL void duk_debug_read_bytes(duk_hthread *thr, duk_uint8_t *data, duk_size_t length); +DUK_INTERNAL_DECL duk_uint8_t duk_debug_read_byte(duk_hthread *thr); +DUK_INTERNAL_DECL duk_int32_t duk_debug_read_int(duk_hthread *thr); +DUK_INTERNAL_DECL duk_hstring *duk_debug_read_hstring(duk_hthread *thr); +/* XXX: exposed duk_debug_read_pointer */ +/* XXX: exposed duk_debug_read_buffer */ +/* XXX: exposed duk_debug_read_hbuffer */ +DUK_INTERNAL_DECL void duk_debug_read_tval(duk_hthread *thr); + +DUK_INTERNAL_DECL void duk_debug_write_bytes(duk_hthread *thr, const duk_uint8_t *data, duk_size_t length); +DUK_INTERNAL_DECL void duk_debug_write_byte(duk_hthread *thr, duk_uint8_t x); +DUK_INTERNAL_DECL void duk_debug_write_unused(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_debug_write_undefined(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_debug_write_int(duk_hthread *thr, duk_int32_t x); +DUK_INTERNAL_DECL void duk_debug_write_uint(duk_hthread *thr, duk_uint32_t x); +DUK_INTERNAL_DECL void duk_debug_write_string(duk_hthread *thr, const char *data, duk_size_t length); +DUK_INTERNAL_DECL void duk_debug_write_cstring(duk_hthread *thr, const char *data); +DUK_INTERNAL_DECL void duk_debug_write_hstring(duk_hthread *thr, duk_hstring *h); +DUK_INTERNAL_DECL void duk_debug_write_buffer(duk_hthread *thr, const char *data, duk_size_t length); +DUK_INTERNAL_DECL void duk_debug_write_hbuffer(duk_hthread *thr, duk_hbuffer *h); +DUK_INTERNAL_DECL void duk_debug_write_pointer(duk_hthread *thr, const void *ptr); +#if defined(DUK_USE_DEBUGGER_DUMPHEAP) +DUK_INTERNAL_DECL void duk_debug_write_heapptr(duk_hthread *thr, duk_heaphdr *h); +#endif +DUK_INTERNAL_DECL void duk_debug_write_hobject(duk_hthread *thr, duk_hobject *obj); +DUK_INTERNAL_DECL void duk_debug_write_tval(duk_hthread *thr, duk_tval *tv); + +#if 0 /* unused */ +DUK_INTERNAL_DECL void duk_debug_write_request(duk_hthread *thr, duk_small_uint_t command); +#endif +DUK_INTERNAL_DECL void duk_debug_write_reply(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_debug_write_error_eom(duk_hthread *thr, duk_small_uint_t err_code, const char *msg); +DUK_INTERNAL_DECL void duk_debug_write_notify(duk_hthread *thr, duk_small_uint_t command); +DUK_INTERNAL_DECL void duk_debug_write_eom(duk_hthread *thr); + +DUK_INTERNAL duk_uint_fast32_t duk_debug_curr_line(duk_hthread *thr); +DUK_INTERNAL void duk_debug_send_status(duk_hthread *thr); + +DUK_INTERNAL_DECL duk_bool_t duk_debug_process_messages(duk_hthread *thr, duk_bool_t no_block); + +DUK_INTERNAL_DECL duk_small_int_t duk_debug_add_breakpoint(duk_hthread *thr, duk_hstring *filename, duk_uint32_t line); +DUK_INTERNAL_DECL duk_bool_t duk_debug_remove_breakpoint(duk_hthread *thr, duk_small_uint_t breakpoint_index); +#endif + +#endif /* DUK_DEBUGGER_H_INCLUDED */ +#line 1 "duk_debug.h" +/* + * Debugging macros, DUK_DPRINT() and its variants in particular. + * + * DUK_DPRINT() allows formatted debug prints, and supports standard + * and Duktape specific formatters. See duk_debug_vsnprintf.c for details. + * + * DUK_D(x), DUK_DD(x), and DUK_DDD(x) are used together with log macros + * for technical reasons. They are concretely used to hide 'x' from the + * compiler when the corresponding log level is disabled. This allows + * clean builds on non-C99 compilers, at the cost of more verbose code. + * Examples: + * + * DUK_D(DUK_DPRINT("foo")); + * DUK_DD(DUK_DDPRINT("foo")); + * DUK_DDD(DUK_DDDPRINT("foo")); + * + * This approach is preferable to the old "double parentheses" hack because + * double parentheses make the C99 solution worse: __FILE__ and __LINE__ can + * no longer be added transparently without going through globals, which + * works poorly with threading. + */ + +#ifndef DUK_DEBUG_H_INCLUDED +#define DUK_DEBUG_H_INCLUDED + +#ifdef DUK_USE_DEBUG + +#if defined(DUK_USE_DPRINT) +#define DUK_D(x) x +#else +#define DUK_D(x) do { } while (0) /* omit */ +#endif + +#if defined(DUK_USE_DDPRINT) +#define DUK_DD(x) x +#else +#define DUK_DD(x) do { } while (0) /* omit */ +#endif + +#if defined(DUK_USE_DDDPRINT) +#define DUK_DDD(x) x +#else +#define DUK_DDD(x) do { } while (0) /* omit */ +#endif + +/* + * Exposed debug macros: debugging enabled + */ + +#define DUK_LEVEL_DEBUG 1 +#define DUK_LEVEL_DDEBUG 2 +#define DUK_LEVEL_DDDEBUG 3 + +#ifdef DUK_USE_VARIADIC_MACROS + +/* Note: combining __FILE__, __LINE__, and __func__ into fmt would be + * possible compile time, but waste some space with shared function names. + */ +#define DUK__DEBUG_LOG(lev,...) duk_debug_log((duk_small_int_t) (lev), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, DUK_FUNC_MACRO, __VA_ARGS__); + +#define DUK_DPRINT(...) DUK__DEBUG_LOG(DUK_LEVEL_DEBUG, __VA_ARGS__) + +#ifdef DUK_USE_DDPRINT +#define DUK_DDPRINT(...) DUK__DEBUG_LOG(DUK_LEVEL_DDEBUG, __VA_ARGS__) +#else +#define DUK_DDPRINT(...) +#endif + +#ifdef DUK_USE_DDDPRINT +#define DUK_DDDPRINT(...) DUK__DEBUG_LOG(DUK_LEVEL_DDDEBUG, __VA_ARGS__) +#else +#define DUK_DDDPRINT(...) +#endif + +#else /* DUK_USE_VARIADIC_MACROS */ + +#define DUK__DEBUG_STASH(lev) \ + (void) DUK_SNPRINTF(duk_debug_file_stash, DUK_DEBUG_STASH_SIZE, "%s", (const char *) DUK_FILE_MACRO), \ + duk_debug_file_stash[DUK_DEBUG_STASH_SIZE - 1] = (char) 0; \ + (void) DUK_SNPRINTF(duk_debug_line_stash, DUK_DEBUG_STASH_SIZE, "%ld", (long) DUK_LINE_MACRO), \ + duk_debug_line_stash[DUK_DEBUG_STASH_SIZE - 1] = (char) 0; \ + (void) DUK_SNPRINTF(duk_debug_func_stash, DUK_DEBUG_STASH_SIZE, "%s", (const char *) DUK_FUNC_MACRO), \ + duk_debug_func_stash[DUK_DEBUG_STASH_SIZE - 1] = (char) 0; \ + (void) (duk_debug_level_stash = (lev)) + +/* Without variadic macros resort to comma expression trickery to handle debug + * prints. This generates a lot of harmless warnings. These hacks are not + * needed normally because DUK_D() and friends will hide the entire debug log + * statement from the compiler. + */ + +#ifdef DUK_USE_DPRINT +#define DUK_DPRINT DUK__DEBUG_STASH(DUK_LEVEL_DEBUG), (void) duk_debug_log /* args go here in parens */ +#else +#define DUK_DPRINT 0 && /* args go here as a comma expression in parens */ +#endif + +#ifdef DUK_USE_DDPRINT +#define DUK_DDPRINT DUK__DEBUG_STASH(DUK_LEVEL_DDEBUG), (void) duk_debug_log /* args go here in parens */ +#else +#define DUK_DDPRINT 0 && /* args */ +#endif + +#ifdef DUK_USE_DDDPRINT +#define DUK_DDDPRINT DUK__DEBUG_STASH(DUK_LEVEL_DDDEBUG), (void) duk_debug_log /* args go here in parens */ +#else +#define DUK_DDDPRINT 0 && /* args */ +#endif + +#endif /* DUK_USE_VARIADIC_MACROS */ + +#else /* DUK_USE_DEBUG */ + +/* + * Exposed debug macros: debugging disabled + */ + +#define DUK_D(x) do { } while (0) /* omit */ +#define DUK_DD(x) do { } while (0) /* omit */ +#define DUK_DDD(x) do { } while (0) /* omit */ + +#ifdef DUK_USE_VARIADIC_MACROS + +#define DUK_DPRINT(...) +#define DUK_DDPRINT(...) +#define DUK_DDDPRINT(...) + +#else /* DUK_USE_VARIADIC_MACROS */ + +#define DUK_DPRINT 0 && /* args go here as a comma expression in parens */ +#define DUK_DDPRINT 0 && /* args */ +#define DUK_DDDPRINT 0 && /* args */ + +#endif /* DUK_USE_VARIADIC_MACROS */ + +#endif /* DUK_USE_DEBUG */ + +/* + * Structs + */ + +#ifdef DUK_USE_DEBUG +struct duk_fixedbuffer { + duk_uint8_t *buffer; + duk_size_t length; + duk_size_t offset; + duk_bool_t truncated; +}; +#endif + +/* + * Prototypes + */ + +#ifdef DUK_USE_DEBUG +DUK_INTERNAL_DECL duk_int_t duk_debug_vsnprintf(char *str, duk_size_t size, const char *format, va_list ap); +#if 0 /*unused*/ +DUK_INTERNAL_DECL duk_int_t duk_debug_snprintf(char *str, duk_size_t size, const char *format, ...); +#endif +DUK_INTERNAL_DECL void duk_debug_format_funcptr(char *buf, duk_size_t buf_size, duk_uint8_t *fptr, duk_size_t fptr_size); + +#ifdef DUK_USE_VARIADIC_MACROS +DUK_INTERNAL_DECL void duk_debug_log(duk_small_int_t level, const char *file, duk_int_t line, const char *func, const char *fmt, ...); +#else /* DUK_USE_VARIADIC_MACROS */ +/* parameter passing, not thread safe */ +#define DUK_DEBUG_STASH_SIZE 128 +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL char duk_debug_file_stash[DUK_DEBUG_STASH_SIZE]; +DUK_INTERNAL_DECL char duk_debug_line_stash[DUK_DEBUG_STASH_SIZE]; +DUK_INTERNAL_DECL char duk_debug_func_stash[DUK_DEBUG_STASH_SIZE]; +DUK_INTERNAL_DECL duk_small_int_t duk_debug_level_stash; +#endif +DUK_INTERNAL_DECL void duk_debug_log(const char *fmt, ...); +#endif /* DUK_USE_VARIADIC_MACROS */ + +DUK_INTERNAL_DECL void duk_fb_put_bytes(duk_fixedbuffer *fb, duk_uint8_t *buffer, duk_size_t length); +DUK_INTERNAL_DECL void duk_fb_put_byte(duk_fixedbuffer *fb, duk_uint8_t x); +DUK_INTERNAL_DECL void duk_fb_put_cstring(duk_fixedbuffer *fb, const char *x); +DUK_INTERNAL_DECL void duk_fb_sprintf(duk_fixedbuffer *fb, const char *fmt, ...); +DUK_INTERNAL_DECL void duk_fb_put_funcptr(duk_fixedbuffer *fb, duk_uint8_t *fptr, duk_size_t fptr_size); +DUK_INTERNAL_DECL duk_bool_t duk_fb_is_full(duk_fixedbuffer *fb); + +#endif /* DUK_USE_DEBUG */ + +#endif /* DUK_DEBUG_H_INCLUDED */ +#line 1 "duk_error.h" +/* + * Error handling macros, assertion macro, error codes. + * + * There are three level of 'errors': + * + * 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. Panic errors, unrelated to a heap and cause a process exit. + * + * Panics are used by the default fatal error handler and by debug code + * such as assertions. By providing a proper fatal error handler, user + * code can avoid panics in non-debug builds. + */ + +#ifndef DUK_ERROR_H_INCLUDED +#define DUK_ERROR_H_INCLUDED + +/* + * Error codes: defined in duktape.h + * + * Error codes are used as a shorthand to throw exceptions from inside + * the implementation. The appropriate Ecmascript object is constructed + * 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. + */ + +/* + * Normal error + * + * 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. + * + * Error formatting is not always necessary but there are no separate calls + * (to minimize code size). Error object creation will consume a considerable + * amount of time, compared to which formatting is probably trivial. Note + * that special formatting (provided by DUK_DEBUG macros) is NOT available. + * + * 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. + * + * We prefer the standard variadic macros; if they are not available, we + * fall back to awkward hacks. + */ + +#ifdef DUK_USE_VERBOSE_ERRORS + +#ifdef DUK_USE_VARIADIC_MACROS + +/* __VA_ARGS__ has comma issues for empty lists, so we mandate at least 1 argument for '...' (format string) */ +#define DUK_ERROR(thr,err,...) duk_err_handle_error(DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (thr), (err), __VA_ARGS__) +#define DUK_ERROR_RAW(file,line,thr,err,...) duk_err_handle_error((file), (line), (thr), (err), __VA_ARGS__) + +#else /* DUK_USE_VARIADIC_MACROS */ + +/* Parameter passing here is not thread safe. We rely on the __FILE__ + * pointer being a constant which can be passed through a global. + */ + +#define DUK_ERROR \ + (void) (duk_err_file_stash = (const char *) DUK_FILE_MACRO, \ + duk_err_line_stash = (duk_int_t) DUK_LINE_MACRO, \ + duk_err_handle_error_stash) /* arguments follow */ +#define DUK_ERROR_RAW duk_err_handle_error + +#endif /* DUK_USE_VARIADIC_MACROS */ + +#else /* DUK_USE_VERBOSE_ERRORS */ + +#ifdef DUK_USE_VARIADIC_MACROS + +#define DUK_ERROR(thr,err,...) duk_err_handle_error((thr), (err)) +#define DUK_ERROR_RAW(file,line,thr,err,...) duk_err_handle_error((thr), (err)) + +#else /* DUK_USE_VARIADIC_MACROS */ + +/* This is sub-optimal because arguments will be passed but ignored, and the strings + * will go into the object file. Can't think of how to do this portably and still + * relatively conveniently. + */ +#define DUK_ERROR duk_err_handle_error_nonverbose1 +#define DUK_ERROR_RAW duk_err_handle_error_nonverbose2 + +#endif /* DUK_USE_VARIADIC_MACROS */ + +#endif /* DUK_USE_VERBOSE_ERRORS */ + +/* + * Fatal error + * + * There are no fatal error macros at the moment. There are so few call + * sites that the fatal error handler is called directly. + */ + +/* + * Panic error + * + * Panic errors are not relative to either a heap or a thread, and cause + * DUK_PANIC() macro to be invoked. Unless a user provides DUK_USE_PANIC_HANDLER, + * DUK_PANIC() calls a helper which prints out the error and causes a process + * exit. + * + * The user can override the macro to provide custom handling. A macro is + * used to allow the user to have inline panic handling if desired (without + * causing a potentially risky function call). + * + * Panics are only used in debug code such as assertions, and by the default + * fatal error handler. + */ + +#if defined(DUK_USE_PANIC_HANDLER) +/* already defined, good */ +#define DUK_PANIC(code,msg) DUK_USE_PANIC_HANDLER((code),(msg)) +#else +#define DUK_PANIC(code,msg) duk_default_panic_handler((code),(msg)) +#endif /* DUK_USE_PANIC_HANDLER */ + +/* + * Assert macro: failure causes panic. + */ + +#ifdef DUK_USE_ASSERTIONS + +/* the message should be a compile time constant without formatting (less risk); + * we don't care about assertion text size because they're not used in production + * builds. + */ +#define DUK_ASSERT(x) do { \ + if (!(x)) { \ + DUK_PANIC(DUK_ERR_ASSERTION_ERROR, \ + "assertion failed: " #x \ + " (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"); \ + } \ + } while (0) + +/* Assertion compatible inside a comma expression, evaluates to void. + * Currently not compatible with DUK_USE_PANIC_HANDLER() which may have + * a statement block. + */ +#if defined(DUK_USE_PANIC_HANDLER) +/* XXX: resolve macro definition issue or call through a helper function? */ +#define DUK_ASSERT_EXPR(x) ((void) 0) +#else +#define DUK_ASSERT_EXPR(x) \ + ((void) ((x) ? 0 : (DUK_PANIC(DUK_ERR_ASSERTION_ERROR, \ + "assertion failed: " #x \ + " (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"), 0))) +#endif + +#else /* DUK_USE_ASSERTIONS */ + +#define DUK_ASSERT(x) do { /* assertion omitted */ } while (0) + +#define DUK_ASSERT_EXPR(x) ((void) 0) + +#endif /* DUK_USE_ASSERTIONS */ + +/* this variant is used when an assert would generate a compile warning by + * being always true (e.g. >= 0 comparison for an unsigned value + */ +#define DUK_ASSERT_DISABLE(x) do { /* assertion disabled */ } while (0) + +/* + * Assertion helpers + */ + +#if defined(DUK_USE_ASSERTIONS) && defined(DUK_USE_REFERENCE_COUNTING) +#define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h) do { \ + DUK_ASSERT((h) == NULL || DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) (h)) > 0); \ + } while (0) +#define DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv) do { \ + if ((tv) != NULL && DUK_TVAL_IS_HEAP_ALLOCATED((tv))) { \ + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(DUK_TVAL_GET_HEAPHDR((tv))) > 0); \ + } \ + } while (0) +#else +#define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h) /* no refcount check */ +#define DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv) /* no refcount check */ +#endif + +#define DUK_ASSERT_TOP(ctx,n) DUK_ASSERT((duk_idx_t) duk_get_top((ctx)) == (duk_idx_t) (n)) + +#if defined(DUK_USE_ASSERTIONS) && defined(DUK_USE_PACKED_TVAL) +#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval) do { \ + duk_double_union duk__assert_tmp_du; \ + duk__assert_tmp_du.d = (dval); \ + DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&duk__assert_tmp_du)); \ + } while (0) +#else +#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval) /* nop */ +#endif + +/* + * Helper for valstack space + * + * Caller of DUK_ASSERT_VALSTACK_SPACE() estimates the number of free stack entries + * 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). + */ + +#define DUK_VALSTACK_ASSERT_EXTRA 5 /* this is added to checks to allow for Duktape + * API calls in addition to function's own use + */ +#if defined(DUK_USE_ASSERTIONS) +#define DUK_ASSERT_VALSTACK_SPACE(thr,n) do { \ + DUK_ASSERT((thr) != NULL); \ + DUK_ASSERT((thr)->valstack_end - (thr)->valstack_top >= (n) + DUK_VALSTACK_ASSERT_EXTRA); \ + } while (0) +#else +#define DUK_ASSERT_VALSTACK_SPACE(thr,n) /* no valstack space check */ +#endif + +/* + * Prototypes + */ + +#ifdef DUK_USE_VERBOSE_ERRORS +#ifdef DUK_USE_VARIADIC_MACROS +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...)); +#else /* DUK_USE_VARIADIC_MACROS */ +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const char *duk_err_file_stash; +DUK_INTERNAL_DECL duk_int_t duk_err_line_stash; +#endif /* !DUK_SINGLE_FILE */ +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...)); +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_stash(duk_hthread *thr, duk_errcode_t code, const char *fmt, ...)); +#endif /* DUK_USE_VARIADIC_MACROS */ +#else /* DUK_USE_VERBOSE_ERRORS */ +#ifdef DUK_USE_VARIADIC_MACROS +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code)); +#else /* DUK_USE_VARIADIC_MACROS */ +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_nonverbose1(duk_hthread *thr, duk_errcode_t code, const char *fmt, ...)); +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_nonverbose2(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...)); +#endif /* DUK_USE_VARIADIC_MACROS */ +#endif /* DUK_USE_VERBOSE_ERRORS */ + +#ifdef DUK_USE_VERBOSE_ERRORS +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)); +#else +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code)); +#endif + +DUK_NORETURN(DUK_INTERNAL_DECL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc)); + +#if defined(DUK_USE_AUGMENT_ERROR_CREATE) +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); +#endif +#if defined(DUK_USE_AUGMENT_ERROR_THROW) +DUK_INTERNAL_DECL void duk_err_augment_error_throw(duk_hthread *thr); +#endif + +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_longjmp(duk_hthread *thr)); + +DUK_NORETURN(DUK_INTERNAL_DECL void duk_default_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg)); + +#if !defined(DUK_USE_PANIC_HANDLER) +DUK_NORETURN(DUK_INTERNAL_DECL void duk_default_panic_handler(duk_errcode_t code, const char *msg)); +#endif + +DUK_INTERNAL_DECL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_int_t lj_type); + +DUK_INTERNAL_DECL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t err_code); + +#endif /* DUK_ERROR_H_INCLUDED */ +#line 1 "duk_unicode.h" +/* + * Unicode helpers + */ + +#ifndef DUK_UNICODE_H_INCLUDED +#define DUK_UNICODE_H_INCLUDED + +/* + * UTF-8 / XUTF-8 / CESU-8 constants + */ + +#define DUK_UNICODE_MAX_XUTF8_LENGTH 7 /* up to 36 bit codepoints */ +#define DUK_UNICODE_MAX_XUTF8_BMP_LENGTH 3 /* all codepoints up to U+FFFF */ +#define DUK_UNICODE_MAX_CESU8_LENGTH 6 /* all codepoints up to U+10FFFF */ +#define DUK_UNICODE_MAX_CESU8_BMP_LENGTH 3 /* all codepoints up to U+FFFF */ + +/* + * Useful Unicode codepoints + * + * Integer constants must be signed to avoid unexpected coercions + * in comparisons. + */ + +#define DUK_UNICODE_CP_ZWNJ 0x200cL /* zero-width non-joiner */ +#define DUK_UNICODE_CP_ZWJ 0x200dL /* zero-width joiner */ +#define DUK_UNICODE_CP_REPLACEMENT_CHARACTER 0xfffdL /* http://en.wikipedia.org/wiki/Replacement_character#Replacement_character */ + +/* + * ASCII character constants + * + * C character literals like 'x' have a platform specific value and do + * not match ASCII (UTF-8) values on e.g. EBCDIC platforms. So, use + * these (admittedly awkward) constants instead. These constants must + * also have signed values to avoid unexpected coercions in comparisons. + * + * http://en.wikipedia.org/wiki/ASCII + */ + +#define DUK_ASC_NUL 0x00 +#define DUK_ASC_SOH 0x01 +#define DUK_ASC_STX 0x02 +#define DUK_ASC_ETX 0x03 +#define DUK_ASC_EOT 0x04 +#define DUK_ASC_ENQ 0x05 +#define DUK_ASC_ACK 0x06 +#define DUK_ASC_BEL 0x07 +#define DUK_ASC_BS 0x08 +#define DUK_ASC_HT 0x09 +#define DUK_ASC_LF 0x0a +#define DUK_ASC_VT 0x0b +#define DUK_ASC_FF 0x0c +#define DUK_ASC_CR 0x0d +#define DUK_ASC_SO 0x0e +#define DUK_ASC_SI 0x0f +#define DUK_ASC_DLE 0x10 +#define DUK_ASC_DC1 0x11 +#define DUK_ASC_DC2 0x12 +#define DUK_ASC_DC3 0x13 +#define DUK_ASC_DC4 0x14 +#define DUK_ASC_NAK 0x15 +#define DUK_ASC_SYN 0x16 +#define DUK_ASC_ETB 0x17 +#define DUK_ASC_CAN 0x18 +#define DUK_ASC_EM 0x19 +#define DUK_ASC_SUB 0x1a +#define DUK_ASC_ESC 0x1b +#define DUK_ASC_FS 0x1c +#define DUK_ASC_GS 0x1d +#define DUK_ASC_RS 0x1e +#define DUK_ASC_US 0x1f +#define DUK_ASC_SPACE 0x20 +#define DUK_ASC_EXCLAMATION 0x21 +#define DUK_ASC_DOUBLEQUOTE 0x22 +#define DUK_ASC_HASH 0x23 +#define DUK_ASC_DOLLAR 0x24 +#define DUK_ASC_PERCENT 0x25 +#define DUK_ASC_AMP 0x26 +#define DUK_ASC_SINGLEQUOTE 0x27 +#define DUK_ASC_LPAREN 0x28 +#define DUK_ASC_RPAREN 0x29 +#define DUK_ASC_STAR 0x2a +#define DUK_ASC_PLUS 0x2b +#define DUK_ASC_COMMA 0x2c +#define DUK_ASC_MINUS 0x2d +#define DUK_ASC_PERIOD 0x2e +#define DUK_ASC_SLASH 0x2f +#define DUK_ASC_0 0x30 +#define DUK_ASC_1 0x31 +#define DUK_ASC_2 0x32 +#define DUK_ASC_3 0x33 +#define DUK_ASC_4 0x34 +#define DUK_ASC_5 0x35 +#define DUK_ASC_6 0x36 +#define DUK_ASC_7 0x37 +#define DUK_ASC_8 0x38 +#define DUK_ASC_9 0x39 +#define DUK_ASC_COLON 0x3a +#define DUK_ASC_SEMICOLON 0x3b +#define DUK_ASC_LANGLE 0x3c +#define DUK_ASC_EQUALS 0x3d +#define DUK_ASC_RANGLE 0x3e +#define DUK_ASC_QUESTION 0x3f +#define DUK_ASC_ATSIGN 0x40 +#define DUK_ASC_UC_A 0x41 +#define DUK_ASC_UC_B 0x42 +#define DUK_ASC_UC_C 0x43 +#define DUK_ASC_UC_D 0x44 +#define DUK_ASC_UC_E 0x45 +#define DUK_ASC_UC_F 0x46 +#define DUK_ASC_UC_G 0x47 +#define DUK_ASC_UC_H 0x48 +#define DUK_ASC_UC_I 0x49 +#define DUK_ASC_UC_J 0x4a +#define DUK_ASC_UC_K 0x4b +#define DUK_ASC_UC_L 0x4c +#define DUK_ASC_UC_M 0x4d +#define DUK_ASC_UC_N 0x4e +#define DUK_ASC_UC_O 0x4f +#define DUK_ASC_UC_P 0x50 +#define DUK_ASC_UC_Q 0x51 +#define DUK_ASC_UC_R 0x52 +#define DUK_ASC_UC_S 0x53 +#define DUK_ASC_UC_T 0x54 +#define DUK_ASC_UC_U 0x55 +#define DUK_ASC_UC_V 0x56 +#define DUK_ASC_UC_W 0x57 +#define DUK_ASC_UC_X 0x58 +#define DUK_ASC_UC_Y 0x59 +#define DUK_ASC_UC_Z 0x5a +#define DUK_ASC_LBRACKET 0x5b +#define DUK_ASC_BACKSLASH 0x5c +#define DUK_ASC_RBRACKET 0x5d +#define DUK_ASC_CARET 0x5e +#define DUK_ASC_UNDERSCORE 0x5f +#define DUK_ASC_GRAVE 0x60 +#define DUK_ASC_LC_A 0x61 +#define DUK_ASC_LC_B 0x62 +#define DUK_ASC_LC_C 0x63 +#define DUK_ASC_LC_D 0x64 +#define DUK_ASC_LC_E 0x65 +#define DUK_ASC_LC_F 0x66 +#define DUK_ASC_LC_G 0x67 +#define DUK_ASC_LC_H 0x68 +#define DUK_ASC_LC_I 0x69 +#define DUK_ASC_LC_J 0x6a +#define DUK_ASC_LC_K 0x6b +#define DUK_ASC_LC_L 0x6c +#define DUK_ASC_LC_M 0x6d +#define DUK_ASC_LC_N 0x6e +#define DUK_ASC_LC_O 0x6f +#define DUK_ASC_LC_P 0x70 +#define DUK_ASC_LC_Q 0x71 +#define DUK_ASC_LC_R 0x72 +#define DUK_ASC_LC_S 0x73 +#define DUK_ASC_LC_T 0x74 +#define DUK_ASC_LC_U 0x75 +#define DUK_ASC_LC_V 0x76 +#define DUK_ASC_LC_W 0x77 +#define DUK_ASC_LC_X 0x78 +#define DUK_ASC_LC_Y 0x79 +#define DUK_ASC_LC_Z 0x7a +#define DUK_ASC_LCURLY 0x7b +#define DUK_ASC_PIPE 0x7c +#define DUK_ASC_RCURLY 0x7d +#define DUK_ASC_TILDE 0x7e +#define DUK_ASC_DEL 0x7f + +/* + * Unicode tables + */ + +#ifdef DUK_USE_SOURCE_NONBMP +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +extern const duk_uint8_t duk_unicode_ids_noa[791]; +#else +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +extern const duk_uint8_t duk_unicode_ids_noabmp[611]; +#endif + +#ifdef DUK_USE_SOURCE_NONBMP +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +extern const duk_uint8_t duk_unicode_ids_m_let_noa[42]; +#else +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +extern const duk_uint8_t duk_unicode_ids_m_let_noabmp[24]; +#endif + +#ifdef DUK_USE_SOURCE_NONBMP +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +extern const duk_uint8_t duk_unicode_idp_m_ids_noa[397]; +#else +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +extern const duk_uint8_t duk_unicode_idp_m_ids_noabmp[348]; +#endif + +/* + * Automatically generated by extract_caseconv.py, do not edit! + */ + +extern const duk_uint8_t duk_unicode_caseconv_uc[1288]; +extern const duk_uint8_t duk_unicode_caseconv_lc[616]; + +/* + * Extern + */ + +/* duk_unicode_support.c */ +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL duk_uint8_t duk_unicode_xutf8_markers[7]; +DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_digit[2]; +DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_white[22]; +DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_wordchar[8]; +DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_not_digit[4]; +DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_not_white[24]; +DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_not_wordchar[10]; +#endif /* !DUK_SINGLE_FILE */ + +/* + * Prototypes + */ + +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_get_xutf8_length(duk_ucodepoint_t cp); +#if defined(DUK_USE_ASSERTIONS) +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_get_cesu8_length(duk_ucodepoint_t cp); +#endif +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_xutf8(duk_ucodepoint_t cp, duk_uint8_t *out); +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_cesu8(duk_ucodepoint_t cp, duk_uint8_t *out); +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_decode_xutf8(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_ucodepoint_t *out_cp); +DUK_INTERNAL_DECL duk_ucodepoint_t duk_unicode_decode_xutf8_checked(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end); +DUK_INTERNAL_DECL duk_size_t duk_unicode_unvalidated_utf8_length(const duk_uint8_t *data, duk_size_t blen); +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_whitespace(duk_codepoint_t cp); +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_line_terminator(duk_codepoint_t cp); +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_start(duk_codepoint_t cp); +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_part(duk_codepoint_t cp); +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_letter(duk_codepoint_t cp); +DUK_INTERNAL_DECL void duk_unicode_case_convert_string(duk_hthread *thr, duk_bool_t uppercase); +DUK_INTERNAL_DECL duk_codepoint_t duk_unicode_re_canonicalize_char(duk_hthread *thr, duk_codepoint_t cp); +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_re_is_wordchar(duk_codepoint_t cp); + +#endif /* DUK_UNICODE_H_INCLUDED */ +#line 1 "duk_json.h" +/* + * Defines for JSON, especially duk_bi_json.c. + */ + +#ifndef DUK_JSON_H_INCLUDED +#define DUK_JSON_H_INCLUDED + +/* Encoding/decoding flags */ +#define DUK_JSON_FLAG_ASCII_ONLY (1 << 0) /* escape any non-ASCII characters */ +#define DUK_JSON_FLAG_AVOID_KEY_QUOTES (1 << 1) /* avoid key quotes when key is an ASCII Identifier */ +#define DUK_JSON_FLAG_EXT_CUSTOM (1 << 2) /* extended types: custom encoding */ +#define DUK_JSON_FLAG_EXT_COMPATIBLE (1 << 3) /* extended types: compatible encoding */ + +/* How much stack to require on entry to object/array encode */ +#define DUK_JSON_ENC_REQSTACK 32 + +/* How much stack to require on entry to object/array decode */ +#define DUK_JSON_DEC_REQSTACK 32 + +/* How large a loop detection stack to use for fast path */ +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) +#define DUK_JSON_ENC_LOOPARRAY 64 +#endif + +/* Encoding state. Heap object references are all borrowed. */ +typedef struct { + duk_hthread *thr; + duk_bufwriter_ctx bw; /* output bufwriter */ + duk_hobject *h_replacer; /* replacer function */ + duk_hstring *h_gap; /* gap (if empty string, NULL) */ + duk_hstring *h_indent; /* current indent (if gap is NULL, this is NULL) */ + duk_idx_t idx_proplist; /* explicit PropertyList */ + duk_idx_t idx_loop; /* valstack index of loop detection object */ + duk_small_uint_t flags; + duk_small_uint_t flag_ascii_only; + duk_small_uint_t flag_avoid_key_quotes; +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + duk_small_uint_t flag_ext_custom; + duk_small_uint_t flag_ext_compatible; +#endif + duk_int_t recursion_depth; + duk_int_t recursion_limit; + duk_uint_t mask_for_undefined; /* type bit mask: types which certainly produce 'undefined' */ +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + duk_small_uint_t stridx_custom_undefined; + duk_small_uint_t stridx_custom_nan; + duk_small_uint_t stridx_custom_neginf; + duk_small_uint_t stridx_custom_posinf; + duk_small_uint_t stridx_custom_function; +#endif +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) + duk_hobject *visiting[DUK_JSON_ENC_LOOPARRAY]; /* indexed by recursion_depth */ +#endif +} duk_json_enc_ctx; + +typedef struct { + duk_hthread *thr; + const duk_uint8_t *p; + const duk_uint8_t *p_start; + const duk_uint8_t *p_end; + duk_idx_t idx_reviver; + duk_small_uint_t flags; +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + duk_small_uint_t flag_ext_custom; + duk_small_uint_t flag_ext_compatible; +#endif + duk_int_t recursion_depth; + duk_int_t recursion_limit; +} duk_json_dec_ctx; + +#endif /* DUK_JSON_H_INCLUDED */ +#line 1 "duk_js.h" +/* + * Ecmascript execution, support primitives. + */ + +#ifndef DUK_JS_H_INCLUDED +#define DUK_JS_H_INCLUDED + +/* Flags for call handling. */ +#define DUK_CALL_FLAG_PROTECTED (1 << 0) /* duk_handle_call: call is protected */ +#define DUK_CALL_FLAG_IGNORE_RECLIMIT (1 << 1) /* duk_handle_call: call ignores C recursion limit (for errhandler calls) */ +#define DUK_CALL_FLAG_CONSTRUCTOR_CALL (1 << 2) /* duk_handle_call: constructor call (i.e. called as 'new Foo()') */ +#define DUK_CALL_FLAG_IS_RESUME (1 << 3) /* duk_handle_ecma_call_setup: setup for a resume() */ +#define DUK_CALL_FLAG_IS_TAILCALL (1 << 4) /* duk_handle_ecma_call_setup: setup for a tail call */ +#define DUK_CALL_FLAG_DIRECT_EVAL (1 << 5) /* call is a direct eval call */ + +/* Flags for duk_js_equals_helper(). */ +#define DUK_EQUALS_FLAG_SAMEVALUE (1 << 0) /* use SameValue instead of non-strict equality */ +#define DUK_EQUALS_FLAG_STRICT (1 << 1) /* use strict equality instead of non-strict equality */ + +/* Flags for duk_js_compare_helper(). */ +#define DUK_COMPARE_FLAG_EVAL_LEFT_FIRST (1 << 0) /* eval left argument first */ +#define DUK_COMPARE_FLAG_NEGATE (1 << 1) /* negate result */ + +/* conversions, coercions, comparison, etc */ +DUK_INTERNAL_DECL duk_bool_t duk_js_toboolean(duk_tval *tv); +DUK_INTERNAL_DECL duk_double_t duk_js_tonumber(duk_hthread *thr, duk_tval *tv); +DUK_INTERNAL_DECL duk_double_t duk_js_tointeger_number(duk_double_t x); +DUK_INTERNAL_DECL duk_double_t duk_js_tointeger(duk_hthread *thr, duk_tval *tv); +DUK_INTERNAL_DECL duk_uint32_t duk_js_touint32(duk_hthread *thr, duk_tval *tv); +DUK_INTERNAL_DECL duk_int32_t duk_js_toint32(duk_hthread *thr, duk_tval *tv); +DUK_INTERNAL_DECL duk_uint16_t duk_js_touint16(duk_hthread *thr, duk_tval *tv); +DUK_INTERNAL_DECL duk_small_int_t duk_js_to_arrayindex_raw_string(const duk_uint8_t *str, duk_uint32_t blen, duk_uarridx_t *out_idx); +DUK_INTERNAL_DECL duk_uarridx_t duk_js_to_arrayindex_string_helper(duk_hstring *h); +DUK_INTERNAL_DECL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags); +DUK_INTERNAL_DECL duk_small_int_t duk_js_data_compare(const duk_uint8_t *buf1, const duk_uint8_t *buf2, duk_size_t len1, duk_size_t len2); +DUK_INTERNAL_DECL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring *h2); +#if 0 /* unused */ +DUK_INTERNAL_DECL duk_small_int_t duk_js_buffer_compare(duk_heap *heap, duk_hbuffer *h1, duk_hbuffer *h2); +#endif +DUK_INTERNAL_DECL duk_bool_t duk_js_compare_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags); +DUK_INTERNAL_DECL duk_bool_t duk_js_instanceof(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y); +DUK_INTERNAL_DECL duk_bool_t duk_js_in(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y); +DUK_INTERNAL_DECL duk_hstring *duk_js_typeof(duk_hthread *thr, duk_tval *tv_x); + +#define duk_js_equals(thr,tv_x,tv_y) \ + duk_js_equals_helper((thr), (tv_x), (tv_y), 0) +#define duk_js_strict_equals(tv_x,tv_y) \ + duk_js_equals_helper(NULL, (tv_x), (tv_y), DUK_EQUALS_FLAG_STRICT) +#define duk_js_samevalue(tv_x,tv_y) \ + duk_js_equals_helper(NULL, (tv_x), (tv_y), DUK_EQUALS_FLAG_SAMEVALUE) + +/* E5 Sections 11.8.1, 11.8.5; x < y */ +#define duk_js_lessthan(thr,tv_x,tv_y) \ + duk_js_compare_helper((thr), (tv_x), (tv_Y), DUK_COMPARE_FLAG_EVAL_LEFT_FIRST) + +/* E5 Sections 11.8.2, 11.8.5; x > y --> y < x */ +#define duk_js_greaterthan(thr,tv_x,tv_y) \ + duk_js_compare_helper((thr), (tv_y), (tv_x), 0) + +/* E5 Sections 11.8.3, 11.8.5; x <= y --> not (x > y) --> not (y < x) */ +#define duk_js_lessthanorequal(thr,tv_x,tv_y) \ + duk_js_compare_helper((thr), (tv_y), (tv_x), DUK_COMPARE_FLAG_NEGATE) + +/* E5 Sections 11.8.4, 11.8.5; x >= y --> not (x < y) */ +#define duk_js_greaterthanorequal(thr,tv_x,tv_y) \ + duk_js_compare_helper((thr), (tv_x), (tv_y), DUK_COMPARE_FLAG_EVAL_LEFT_FIRST | DUK_COMPARE_FLAG_NEGATE) + +/* identifiers and environment handling */ +#if 0 /*unused*/ +DUK_INTERNAL duk_bool_t duk_js_hasvar_envrec(duk_hthread *thr, duk_hobject *env, duk_hstring *name); +#endif +DUK_INTERNAL_DECL duk_bool_t duk_js_getvar_envrec(duk_hthread *thr, duk_hobject *env, duk_hstring *name, duk_bool_t throw_flag); +DUK_INTERNAL_DECL duk_bool_t duk_js_getvar_activation(duk_hthread *thr, duk_activation *act, duk_hstring *name, duk_bool_t throw_flag); +DUK_INTERNAL_DECL void duk_js_putvar_envrec(duk_hthread *thr, duk_hobject *env, duk_hstring *name, duk_tval *val, duk_bool_t strict); +DUK_INTERNAL_DECL void duk_js_putvar_activation(duk_hthread *thr, duk_activation *act, duk_hstring *name, duk_tval *val, duk_bool_t strict); +#if 0 /*unused*/ +DUK_INTERNAL_DECL duk_bool_t duk_js_delvar_envrec(duk_hthread *thr, duk_hobject *env, duk_hstring *name); +#endif +DUK_INTERNAL_DECL duk_bool_t duk_js_delvar_activation(duk_hthread *thr, duk_activation *act, duk_hstring *name); +DUK_INTERNAL_DECL duk_bool_t duk_js_declvar_activation(duk_hthread *thr, duk_activation *act, duk_hstring *name, duk_tval *val, duk_small_int_t prop_flags, duk_bool_t is_func_decl); +DUK_INTERNAL_DECL void duk_js_init_activation_environment_records_delayed(duk_hthread *thr, duk_activation *act); +DUK_INTERNAL_DECL void duk_js_close_environment_record(duk_hthread *thr, duk_hobject *env, duk_hobject *func, duk_size_t regbase); +DUK_INTERNAL_DECL duk_hobject *duk_create_activation_environment_record(duk_hthread *thr, duk_hobject *func, duk_size_t idx_bottom); +DUK_INTERNAL_DECL +void duk_js_push_closure(duk_hthread *thr, + duk_hcompiledfunction *fun_temp, + duk_hobject *outer_var_env, + duk_hobject *outer_lex_env); + +/* call handling */ +DUK_INTERNAL_DECL duk_int_t duk_handle_call(duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags); +DUK_INTERNAL_DECL duk_int_t duk_handle_safe_call(duk_hthread *thr, duk_safe_call_function func, duk_idx_t num_stack_args, duk_idx_t num_stack_res); +DUK_INTERNAL_DECL duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags); + +/* bytecode execution */ +DUK_INTERNAL_DECL void duk_js_execute_bytecode(duk_hthread *exec_thr); + +#endif /* DUK_JS_H_INCLUDED */ +#line 1 "duk_numconv.h" +#ifndef DUK_NUMCONV_H_INCLUDED +#define DUK_NUMCONV_H_INCLUDED + +/* + * Number-to-string conversion. The semantics of these is very tightly + * bound with the Ecmascript semantics required for call sites. + */ + +/* Output a specified number of digits instead of using the shortest + * form. Used for toPrecision() and toFixed(). + */ +#define DUK_N2S_FLAG_FIXED_FORMAT (1 << 0) + +/* Force exponential format. Used for toExponential(). */ +#define DUK_N2S_FLAG_FORCE_EXP (1 << 1) + +/* If number would need zero padding (for whole number part), use + * exponential format instead. E.g. if input number is 12300, 3 + * digits are generated ("123"), output "1.23e+4" instead of "12300". + * Used for toPrecision(). + */ +#define DUK_N2S_FLAG_NO_ZERO_PAD (1 << 2) + +/* Digit count indicates number of fractions (i.e. an absolute + * digit index instead of a relative one). Used together with + * DUK_N2S_FLAG_FIXED_FORMAT for toFixed(). + */ +#define DUK_N2S_FLAG_FRACTION_DIGITS (1 << 3) + +/* + * String-to-number conversion + */ + +/* Maximum exponent value when parsing numbers. This is not strictly + * compliant as there should be no upper limit, but as we parse the + * exponent without a bigint, impose some limit. + */ +#define DUK_S2N_MAX_EXPONENT 1000000000 + +/* Trim white space (= allow leading and trailing whitespace) */ +#define DUK_S2N_FLAG_TRIM_WHITE (1 << 0) + +/* Allow exponent */ +#define DUK_S2N_FLAG_ALLOW_EXP (1 << 1) + +/* Allow trailing garbage (e.g. treat "123foo" as "123) */ +#define DUK_S2N_FLAG_ALLOW_GARBAGE (1 << 2) + +/* Allow leading plus sign */ +#define DUK_S2N_FLAG_ALLOW_PLUS (1 << 3) + +/* Allow leading minus sign */ +#define DUK_S2N_FLAG_ALLOW_MINUS (1 << 4) + +/* Allow 'Infinity' */ +#define DUK_S2N_FLAG_ALLOW_INF (1 << 5) + +/* Allow fraction part */ +#define DUK_S2N_FLAG_ALLOW_FRAC (1 << 6) + +/* Allow naked fraction (e.g. ".123") */ +#define DUK_S2N_FLAG_ALLOW_NAKED_FRAC (1 << 7) + +/* Allow empty fraction (e.g. "123.") */ +#define DUK_S2N_FLAG_ALLOW_EMPTY_FRAC (1 << 8) + +/* Allow empty string to be interpreted as 0 */ +#define DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO (1 << 9) + +/* Allow leading zeroes (e.g. "0123" -> "123") */ +#define DUK_S2N_FLAG_ALLOW_LEADING_ZERO (1 << 10) + +/* Allow automatic detection of hex base ("0x" or "0X" prefix), + * overrides radix argument and forces integer mode. + */ +#define DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT (1 << 11) + +/* Allow automatic detection of octal base, overrides radix + * argument and forces integer mode. + */ +#define DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT (1 << 12) + +/* + * Prototypes + */ + +DUK_INTERNAL_DECL void duk_numconv_stringify(duk_context *ctx, duk_small_int_t radix, duk_small_int_t digits, duk_small_uint_t flags); +DUK_INTERNAL_DECL void duk_numconv_parse(duk_context *ctx, duk_small_int_t radix, duk_small_uint_t flags); + +#endif /* DUK_NUMCONV_H_INCLUDED */ +#line 1 "duk_bi_protos.h" +/* + * Prototypes for all built-in functions. + */ + +#ifndef DUK_BUILTIN_PROTOS_H_INCLUDED +#define DUK_BUILTIN_PROTOS_H_INCLUDED + +/* Buffer size needed for duk_bi_date_format_timeval(). + * Accurate value is 32 + 1 for NUL termination: + * >>> len('+123456-01-23T12:34:56.123+12:34') + * 32 + * Include additional space to be safe. + */ +#define DUK_BI_DATE_ISO8601_BUFSIZE 48 + +/* Maximum length of CommonJS module identifier to resolve. Length includes + * both current module ID, requested (possibly relative) module ID, and a + * slash in between. + */ +#define DUK_BI_COMMONJS_MODULE_ID_LIMIT 256 + +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_constructor_is_array(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_to_string(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_concat(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_join_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_pop(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_push(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_reverse(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_shift(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_slice(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_sort(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_splice(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_unshift(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_indexof_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_iter_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_reduce_shared(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_boolean_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_boolean_prototype_tostring_shared(duk_context *ctx); + +/* XXX: naming is inconsistent with other builtins, "prototype" not used as + * part of function name. + */ +DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_readfield(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_writefield(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_compare_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_slice_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_arraybuffer_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_arraybuffer_isview(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_dataview_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_typedarray_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_typedarray_set(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_concat(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_is_encoding(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_is_buffer(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_byte_length(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_tostring(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_tojson(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_fill(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_copy(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_write(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor_parse(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor_utc(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor_now(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_tostring_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_value_of(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_to_json(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_get_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_get_timezone_offset(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_set_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_set_time(duk_context *ctx); +/* Helpers exposed for internal use */ +DUK_INTERNAL_DECL void duk_bi_date_timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags); +DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_timeval_from_dparts(duk_double_t *dparts, duk_small_uint_t flags); +DUK_INTERNAL_DECL void duk_bi_date_format_timeval(duk_double_t timeval, duk_uint8_t *out_buf); +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_is_leap_year(duk_int_t year); +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_valid_range(duk_double_t x); +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_year_in_valid_range(duk_double_t year); +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_leeway_range(duk_double_t x); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_info(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_act(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_gc(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_fin(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_enc(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_dec(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_compact(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_error_constructor_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_to_string(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_stack_getter(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_filename_getter(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_linenumber_getter(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_nop_setter(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_function_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_to_string(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_apply(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_call(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_bind(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_eval(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_parse_int(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_parse_float(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_is_nan(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_is_finite(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_decode_uri(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_decode_uri_component(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_encode_uri(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_encode_uri_component(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_escape(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_unescape(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_require(duk_context *ctx); + +DUK_INTERNAL_DECL +void duk_bi_json_parse_helper(duk_context *ctx, + duk_idx_t idx_value, + duk_idx_t idx_reviver, + duk_small_uint_t flags); +DUK_INTERNAL_DECL +void duk_bi_json_stringify_helper(duk_context *ctx, + duk_idx_t idx_value, + duk_idx_t idx_replacer, + duk_idx_t idx_space, + duk_small_uint_t flags); +DUK_INTERNAL_DECL duk_ret_t duk_bi_json_object_parse(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_json_object_stringify(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_onearg_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_twoarg_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_max(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_min(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_random(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_number_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_string(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_locale_string(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_value_of(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_fixed(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_exponential(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_precision(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_setprototype_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_get_own_property_descriptor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_create(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_define_property(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_define_properties(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_seal_freeze_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_prevent_extensions(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_is_sealed_frozen_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_is_extensible(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_keys_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_to_string(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_to_locale_string(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_value_of(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_has_own_property(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_is_prototype_of(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_property_is_enumerable(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_pointer_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_pointer_prototype_tostring_shared(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_prototype_exec(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_prototype_test(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_prototype_to_string(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_constructor_from_char_code(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_to_string(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_char_at(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_char_code_at(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_concat(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_indexof_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_locale_compare(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_match(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_slice(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_split(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_substring(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_caseconv_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_trim(duk_context *ctx); +/* Note: present even if DUK_USE_SECTION_B undefined given because genbuiltins.py + * will point to it. + */ +DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx); +#if 0 /* unimplemented now */ +DUK_INTERNAL_DECL duk_ret_t duk_bi_proxy_constructor_revocable(duk_context *ctx); +#endif + +DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_resume(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_yield(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_current(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_prototype_fmt(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_prototype_raw(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_prototype_log_shared(duk_context *ctx); + +DUK_INTERNAL_DECL duk_ret_t duk_bi_type_error_thrower(duk_context *ctx); + +#endif /* DUK_BUILTIN_PROTOS_H_INCLUDED */ +#line 1 "duk_selftest.h" +/* + * Selftest code + */ + +#ifndef DUK_SELFTEST_H_INCLUDED +#define DUK_SELFTEST_H_INCLUDED + +#if defined(DUK_USE_SELF_TESTS) +DUK_INTERNAL_DECL void duk_selftest_run_tests(void); +#endif + +#endif /* DUK_SELFTEST_H_INCLUDED */ +#line 77 "duk_internal.h" + +#endif /* DUK_INTERNAL_H_INCLUDED */ +#line 1 "duk_strings.c" +/* + * Shared error message strings + * + * To minimize code footprint, try to share error messages inside Duktape + * code. Modern compilers will do this automatically anyway, this is mostly + * for older compilers. + */ + +/* include removed: duk_internal.h */ + +/* Mostly API and built-in method related */ +DUK_INTERNAL const char *duk_str_internal_error = "internal error"; +DUK_INTERNAL const char *duk_str_invalid_count = "invalid count"; +DUK_INTERNAL const char *duk_str_invalid_call_args = "invalid call args"; +DUK_INTERNAL const char *duk_str_not_constructable = "not constructable"; +DUK_INTERNAL const char *duk_str_not_callable = "not callable"; +DUK_INTERNAL const char *duk_str_not_extensible = "not extensible"; +DUK_INTERNAL const char *duk_str_not_writable = "not writable"; +DUK_INTERNAL const char *duk_str_not_configurable = "not configurable"; + +DUK_INTERNAL const char *duk_str_invalid_context = "invalid context"; +DUK_INTERNAL const char *duk_str_invalid_index = "invalid index"; +DUK_INTERNAL const char *duk_str_push_beyond_alloc_stack = "attempt to push beyond currently allocated stack"; +DUK_INTERNAL const char *duk_str_not_undefined = "not undefined"; +DUK_INTERNAL const char *duk_str_not_null = "not null"; +DUK_INTERNAL const char *duk_str_not_boolean = "not boolean"; +DUK_INTERNAL const char *duk_str_not_number = "not number"; +DUK_INTERNAL const char *duk_str_not_string = "not string"; +DUK_INTERNAL const char *duk_str_not_pointer = "not pointer"; +DUK_INTERNAL const char *duk_str_not_buffer = "not buffer"; +DUK_INTERNAL const char *duk_str_unexpected_type = "unexpected type"; +DUK_INTERNAL const char *duk_str_not_thread = "not thread"; +DUK_INTERNAL const char *duk_str_not_compiledfunction = "not compiledfunction"; +DUK_INTERNAL const char *duk_str_not_nativefunction = "not nativefunction"; +DUK_INTERNAL const char *duk_str_not_c_function = "not c function"; +DUK_INTERNAL const char *duk_str_defaultvalue_coerce_failed = "[[DefaultValue]] coerce failed"; +DUK_INTERNAL const char *duk_str_number_outside_range = "number outside range"; +DUK_INTERNAL const char *duk_str_not_object_coercible = "not object coercible"; +DUK_INTERNAL const char *duk_str_string_too_long = "string too long"; +DUK_INTERNAL const char *duk_str_buffer_too_long = "buffer too long"; +DUK_INTERNAL const char *duk_str_sprintf_too_long = "sprintf message too long"; +DUK_INTERNAL const char *duk_str_alloc_failed = "alloc failed"; +DUK_INTERNAL const char *duk_str_pop_too_many = "attempt to pop too many entries"; +DUK_INTERNAL const char *duk_str_wrong_buffer_type = "wrong buffer type"; +DUK_INTERNAL const char *duk_str_failed_to_extend_valstack = "failed to extend valstack"; +DUK_INTERNAL const char *duk_str_encode_failed = "encode failed"; +DUK_INTERNAL const char *duk_str_decode_failed = "decode failed"; +DUK_INTERNAL const char *duk_str_no_sourcecode = "no sourcecode"; +DUK_INTERNAL const char *duk_str_concat_result_too_long = "concat result too long"; +DUK_INTERNAL const char *duk_str_unimplemented = "unimplemented"; +DUK_INTERNAL const char *duk_str_unsupported = "unsupported"; +DUK_INTERNAL const char *duk_str_array_length_over_2g = "array length over 2G"; + +/* JSON */ +DUK_INTERNAL const char *duk_str_fmt_ptr = "%p"; +DUK_INTERNAL const char *duk_str_fmt_invalid_json = "invalid json (at offset %ld)"; +DUK_INTERNAL const char *duk_str_jsondec_reclimit = "json decode recursion limit"; +DUK_INTERNAL const char *duk_str_jsonenc_reclimit = "json encode recursion limit"; +DUK_INTERNAL const char *duk_str_cyclic_input = "cyclic input"; + +/* Object property access */ +DUK_INTERNAL const char *duk_str_proxy_revoked = "proxy revoked"; +DUK_INTERNAL const char *duk_str_object_resize_failed = "object resize failed"; +DUK_INTERNAL const char *duk_str_invalid_base = "invalid base value"; +DUK_INTERNAL const char *duk_str_strict_caller_read = "attempt to read strict 'caller'"; +DUK_INTERNAL const char *duk_str_proxy_rejected = "proxy rejected"; +DUK_INTERNAL const char *duk_str_invalid_array_length = "invalid array length"; +DUK_INTERNAL const char *duk_str_array_length_write_failed = "array length write failed"; +DUK_INTERNAL const char *duk_str_array_length_not_writable = "array length non-writable"; +DUK_INTERNAL const char *duk_str_setter_undefined = "setter undefined"; +DUK_INTERNAL const char *duk_str_redefine_virt_prop = "attempt to redefine virtual property"; +DUK_INTERNAL const char *duk_str_invalid_descriptor = "invalid descriptor"; +DUK_INTERNAL const char *duk_str_property_is_virtual = "property is virtual"; + +/* Compiler */ +DUK_INTERNAL const char *duk_str_parse_error = "parse error"; +DUK_INTERNAL const char *duk_str_duplicate_label = "duplicate label"; +DUK_INTERNAL const char *duk_str_invalid_label = "invalid label"; +DUK_INTERNAL const char *duk_str_invalid_array_literal = "invalid array literal"; +DUK_INTERNAL const char *duk_str_invalid_object_literal = "invalid object literal"; +DUK_INTERNAL const char *duk_str_invalid_var_declaration = "invalid variable declaration"; +DUK_INTERNAL const char *duk_str_cannot_delete_identifier = "cannot delete identifier"; +DUK_INTERNAL const char *duk_str_invalid_expression = "invalid expression"; +DUK_INTERNAL const char *duk_str_invalid_lvalue = "invalid lvalue"; +DUK_INTERNAL const char *duk_str_expected_identifier = "expected identifier"; +DUK_INTERNAL const char *duk_str_empty_expr_not_allowed = "empty expression not allowed"; +DUK_INTERNAL const char *duk_str_invalid_for = "invalid for statement"; +DUK_INTERNAL const char *duk_str_invalid_switch = "invalid switch statement"; +DUK_INTERNAL const char *duk_str_invalid_break_cont_label = "invalid break/continue label"; +DUK_INTERNAL const char *duk_str_invalid_return = "invalid return"; +DUK_INTERNAL const char *duk_str_invalid_try = "invalid try"; +DUK_INTERNAL const char *duk_str_invalid_throw = "invalid throw"; +DUK_INTERNAL const char *duk_str_with_in_strict_mode = "with in strict mode"; +DUK_INTERNAL const char *duk_str_func_stmt_not_allowed = "function statement not allowed"; +DUK_INTERNAL const char *duk_str_unterminated_stmt = "unterminated statement"; +DUK_INTERNAL const char *duk_str_invalid_arg_name = "invalid argument name"; +DUK_INTERNAL const char *duk_str_invalid_func_name = "invalid function name"; +DUK_INTERNAL const char *duk_str_invalid_getset_name = "invalid getter/setter name"; +DUK_INTERNAL const char *duk_str_func_name_required = "function name required"; + +/* Executor */ +DUK_INTERNAL const char *duk_str_internal_error_exec_longjmp = "internal error in bytecode executor longjmp handler"; + +/* Regexp */ +DUK_INTERNAL const char *duk_str_invalid_quantifier_no_atom = "quantifier without preceding atom"; +DUK_INTERNAL const char *duk_str_invalid_quantifier_values = "quantifier values invalid (qmin > qmax)"; +DUK_INTERNAL const char *duk_str_quantifier_too_many_copies = "quantifier expansion requires too many atom copies"; +DUK_INTERNAL const char *duk_str_unexpected_closing_paren = "unexpected closing parenthesis"; +DUK_INTERNAL const char *duk_str_unexpected_end_of_pattern = "unexpected end of pattern"; +DUK_INTERNAL const char *duk_str_unexpected_regexp_token = "unexpected token in regexp"; +DUK_INTERNAL const char *duk_str_invalid_regexp_flags = "invalid regexp flags"; +DUK_INTERNAL const char *duk_str_invalid_backrefs = "invalid backreference(s)"; +DUK_INTERNAL const char *duk_str_regexp_backtrack_failed = "regexp backtrack failed"; +DUK_INTERNAL const char *duk_str_regexp_advance_failed = "regexp advance failed"; +DUK_INTERNAL const char *duk_str_regexp_internal_error = "regexp internal error"; + +/* Limits */ +DUK_INTERNAL const char *duk_str_valstack_limit = "valstack limit"; +DUK_INTERNAL const char *duk_str_callstack_limit = "callstack limit"; +DUK_INTERNAL const char *duk_str_catchstack_limit = "catchstack limit"; +DUK_INTERNAL const char *duk_str_object_property_limit = "object property limit"; +DUK_INTERNAL const char *duk_str_prototype_chain_limit = "prototype chain limit"; +DUK_INTERNAL const char *duk_str_bound_chain_limit = "function call bound chain limit"; +DUK_INTERNAL const char *duk_str_c_callstack_limit = "C call stack depth limit"; +DUK_INTERNAL const char *duk_str_compiler_recursion_limit = "compiler recursion limit"; +DUK_INTERNAL const char *duk_str_bytecode_limit = "bytecode limit"; +DUK_INTERNAL const char *duk_str_reg_limit = "register limit"; +DUK_INTERNAL const char *duk_str_temp_limit = "temp limit"; +DUK_INTERNAL const char *duk_str_const_limit = "const limit"; +DUK_INTERNAL const char *duk_str_func_limit = "function limit"; +DUK_INTERNAL const char *duk_str_regexp_compiler_recursion_limit = "regexp compiler recursion limit"; +DUK_INTERNAL const char *duk_str_regexp_executor_recursion_limit = "regexp executor recursion limit"; +DUK_INTERNAL const char *duk_str_regexp_executor_step_limit = "regexp step limit"; + +/* Misc */ +DUK_INTERNAL const char *duk_str_anon = "anon"; +DUK_INTERNAL const char *duk_str_realloc_failed = "realloc failed"; +#line 1 "duk_debug_macros.c" +/* + * Debugging macro calls. + */ + +/* include removed: duk_internal.h */ + +#ifdef DUK_USE_DEBUG + +/* + * Debugging enabled + */ + +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> + +#define DUK__DEBUG_BUFSIZE DUK_USE_DEBUG_BUFSIZE +DUK_LOCAL char duk__debug_buf[DUK__DEBUG_BUFSIZE]; + +DUK_LOCAL const char *duk__get_level_string(duk_small_int_t level) { + switch ((int) level) { + case DUK_LEVEL_DEBUG: + return "D"; + case DUK_LEVEL_DDEBUG: + return "DD"; + case DUK_LEVEL_DDDEBUG: + return "DDD"; + } + return "???"; +} + +#ifdef DUK_USE_DPRINT_COLORS + +/* http://en.wikipedia.org/wiki/ANSI_escape_code */ +#define DUK__TERM_REVERSE "\x1b[7m" +#define DUK__TERM_BRIGHT "\x1b[1m" +#define DUK__TERM_RESET "\x1b[0m" +#define DUK__TERM_BLUE "\x1b[34m" +#define DUK__TERM_RED "\x1b[31m" + +DUK_LOCAL const char *duk__get_term_1(duk_small_int_t level) { + DUK_UNREF(level); + return (const char *) DUK__TERM_RED; +} + +DUK_LOCAL const char *duk__get_term_2(duk_small_int_t level) { + switch ((int) level) { + case DUK_LEVEL_DEBUG: + return (const char *) (DUK__TERM_RESET DUK__TERM_BRIGHT); + case DUK_LEVEL_DDEBUG: + return (const char *) (DUK__TERM_RESET); + case DUK_LEVEL_DDDEBUG: + return (const char *) (DUK__TERM_RESET DUK__TERM_BLUE); + } + return (const char *) DUK__TERM_RESET; +} + +DUK_LOCAL const char *duk__get_term_3(duk_small_int_t level) { + DUK_UNREF(level); + return (const char *) DUK__TERM_RESET; +} + +#else + +DUK_LOCAL const char *duk__get_term_1(duk_small_int_t level) { + DUK_UNREF(level); + return (const char *) ""; +} + +DUK_LOCAL const char *duk__get_term_2(duk_small_int_t level) { + DUK_UNREF(level); + return (const char *) ""; +} + +DUK_LOCAL const char *duk__get_term_3(duk_small_int_t level) { + DUK_UNREF(level); + return (const char *) ""; +} + +#endif /* DUK_USE_DPRINT_COLORS */ + +#ifdef DUK_USE_VARIADIC_MACROS + +DUK_INTERNAL void duk_debug_log(duk_small_int_t level, const char *file, duk_int_t line, const char *func, const char *fmt, ...) { + va_list ap; + + va_start(ap, fmt); + + DUK_MEMZERO((void *) duk__debug_buf, (size_t) DUK__DEBUG_BUFSIZE); + duk_debug_vsnprintf(duk__debug_buf, DUK__DEBUG_BUFSIZE - 1, fmt, ap); + +#ifdef DUK_USE_DPRINT_RDTSC + DUK_FPRINTF(DUK_STDERR, "%s[%s] <%llu> %s:%ld (%s):%s %s%s\n", + (const char *) duk__get_term_1(level), + (const char *) duk__get_level_string(level), + (unsigned long long) DUK_USE_RDTSC(), /* match the inline asm in duk_features.h */ + (const char *) file, + (long) line, + (const char *) func, + (const char *) duk__get_term_2(level), + (const char *) duk__debug_buf, + (const char *) duk__get_term_3(level)); +#else + DUK_FPRINTF(DUK_STDERR, "%s[%s] %s:%ld (%s):%s %s%s\n", + (const char *) duk__get_term_1(level), + (const char *) duk__get_level_string(level), + (const char *) file, + (long) line, + (const char *) func, + (const char *) duk__get_term_2(level), + (const char *) duk__debug_buf, + (const char *) duk__get_term_3(level)); +#endif + DUK_FFLUSH(DUK_STDERR); + + va_end(ap); +} + +#else /* DUK_USE_VARIADIC_MACROS */ + +DUK_INTERNAL char duk_debug_file_stash[DUK_DEBUG_STASH_SIZE]; +DUK_INTERNAL char duk_debug_line_stash[DUK_DEBUG_STASH_SIZE]; +DUK_INTERNAL char duk_debug_func_stash[DUK_DEBUG_STASH_SIZE]; +DUK_INTERNAL duk_small_int_t duk_debug_level_stash; + +DUK_INTERNAL void duk_debug_log(const char *fmt, ...) { + va_list ap; + duk_small_int_t level = duk_debug_level_stash; + + va_start(ap, fmt); + + DUK_MEMZERO((void *) duk__debug_buf, (size_t) DUK__DEBUG_BUFSIZE); + duk_debug_vsnprintf(duk__debug_buf, DUK__DEBUG_BUFSIZE - 1, fmt, ap); + +#ifdef DUK_USE_DPRINT_RDTSC + DUK_FPRINTF(DUK_STDERR, "%s[%s] <%llu> %s:%s (%s):%s %s%s\n", + (const char *) duk__get_term_1(level), + (const char *) duk__get_level_string(duk_debug_level_stash), + (unsigned long long) DUK_USE_RDTSC(), /* match duk_features.h */ + (const char *) duk_debug_file_stash, + (const char *) duk_debug_line_stash, + (const char *) duk_debug_func_stash, + (const char *) duk__get_term_2(level), + (const char *) duk__debug_buf, + (const char *) duk__get_term_3(level)); +#else + DUK_FPRINTF(DUK_STDERR, "%s[%s] %s:%s (%s):%s %s%s\n", + (const char *) duk__get_term_1(level), + (const char *) duk__get_level_string(duk_debug_level_stash), + (const char *) duk_debug_file_stash, + (const char *) duk_debug_line_stash, + (const char *) duk_debug_func_stash, + (const char *) duk__get_term_2(level), + (const char *) duk__debug_buf, + (const char *) duk__get_term_3(level)); +#endif + DUK_FFLUSH(DUK_STDERR); + + va_end(ap); +} + +#endif /* DUK_USE_VARIADIC_MACROS */ + +#else /* DUK_USE_DEBUG */ + +/* + * Debugging disabled + */ + +#endif /* DUK_USE_DEBUG */ +#line 1 "duk_builtins.c" +/* + * Automatically generated by genbuiltins.py, do not edit! + */ + +/* include removed: duk_internal.h */ + +#if defined(DUK_USE_DOUBLE_LE) +DUK_INTERNAL const duk_uint8_t duk_strings_data[2624] = { +55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,50,11,164,109, +77,215,5,61,35,106,206,149,110,4,254,219,237,58,8,196,24,103,74,183,2,127, +103,246,93,4,98,12,47,180,67,103,246,127,101,208,70,32,194,186,134,207,236, +254,203,160,140,65,133,246,136,108,254,199,237,186,8,196,24,87,80,217,253, +143,219,116,17,136,49,30,209,13,159,220,116,75,3,30,65,244,17,136,48,174, +209,13,159,220,116,17,136,48,158,161,179,251,142,130,49,6,17,209,130,96, +237,80,75,47,160,140,65,142,134,133,41,34,110,134,133,41,34,3,25,110,8,22, +158,130,38,163,8,217,200,158,76,156,210,117,128,153,203,210,70,46,137,187, +18,27,164,187,201,209,130,100,55,91,70,4,145,63,66,231,44,128,105,187,41, +197,13,49,122,8,196,24,71,75,70,138,104,115,77,215,5,36,20,201,214,209,107, +79,104,209,144,168,105,6,207,251,209,104,209,125,212,227,66,127,235,191, +239,232,180,90,52,95,69,247,83,141,9,255,174,255,191,162,211,80,210,253,23, +221,78,52,39,254,183,254,254,139,72,105,126,139,238,167,26,19,255,91,255, +127,69,166,129,191,69,247,83,141,9,255,175,255,191,162,213,26,50,23,232, +190,234,113,161,63,245,115,119,86,227,118,83,138,26,98,9,110,48,86,22,148, +160,152,22,82,70,46,137,44,8,180,163,32,104,98,206,32,17,7,16,88,101,100, +206,42,70,36,108,205,18,74,140,33,196,230,60,2,152,146,33,38,230,8,36,79, +182,251,65,156,151,24,200,33,145,162,25,80,209,24,67,0,166,68,52,174,61,73, +25,33,205,25,27,84,177,195,234,220,1,144,105,99,135,217,16,17,17,208,72, +199,179,60,93,100,146,49,232,162,64,76,135,19,152,244,44,136,223,98,67,4, +18,33,247,217,158,36,0,209,190,156,13,26,201,21,111,165,67,64,180,100,145, +62,250,32,45,100,33,55,214,1,229,223,65,19,72,187,236,206,137,35,125,120, +190,201,104,105,15,190,201,212,136,136,125,246,160,137,27,83,239,171,37, +200,218,159,125,168,34,192,61,27,233,93,22,1,114,78,250,28,76,130,112,200, +93,245,164,188,207,190,204,17,49,38,109,246,160,93,8,119,185,13,153,34,173, +246,113,0,136,48,76,10,90,26,78,182,140,9,34,130,161,100,235,64,194,9,226, +44,166,1,41,221,153,226,235,118,120,121,58,72,197,209,63,71,69,76,15,34, +164,73,244,171,112,39,246,223,104,169,18,125,42,220,9,253,159,217,38,68, +159,104,134,207,236,254,201,18,36,250,134,207,236,254,201,50,36,251,68,54, +127,99,246,200,145,39,212,54,127,99,246,200,145,39,218,33,179,251,131,200, +147,234,27,63,184,81,137,62,149,110,4,254,219,237,20,98,79,165,91,129,63, +179,251,36,152,147,237,16,217,253,159,217,32,196,159,80,217,253,159,217,36, +196,159,104,134,207,236,126,217,6,36,250,134,207,236,126,217,6,36,251,68, +54,127,112,115,18,125,67,103,247,8,149,2,8,196,24,143,131,137,146,90,121, +35,162,44,140,35,102,160,226,100,235,138,89,18,102,13,10,82,68,200,151,106, +130,88,131,4,192,73,225,228,85,162,137,147,168,108,252,18,42,209,68,201, +212,54,126,89,23,104,162,100,245,17,230,207,193,34,237,20,76,158,162,60, +217,249,100,109,162,137,147,163,117,2,178,120,36,109,162,137,147,163,117,2, +178,121,100,101,162,137,147,165,91,129,63,4,140,180,81,50,116,171,112,39, +229,145,150,138,38,78,161,179,251,63,178,240,72,203,69,19,39,80,217,253, +159,217,121,100,109,162,137,147,212,71,155,63,179,251,47,4,141,180,81,50, +122,136,243,103,246,127,101,229,145,150,138,38,78,161,179,251,31,182,240, +72,203,69,19,39,80,217,253,143,219,121,100,109,162,137,147,212,71,155,63, +177,251,111,4,141,180,81,50,122,136,243,103,246,63,109,229,145,54,138,38, +78,161,179,251,133,90,40,153,61,68,121,179,251,132,196,128,31,80,217,248, +36,76,72,1,245,13,159,150,69,68,128,31,168,143,54,126,9,21,18,0,126,162,60, +217,249,100,100,72,1,244,110,160,86,79,4,140,137,0,62,141,212,10,201,229, +145,113,32,7,210,173,192,159,130,69,196,128,31,74,183,2,126,89,23,18,0,125, +67,103,246,127,101,224,145,113,32,7,212,54,127,103,246,94,89,25,18,0,126, +162,60,217,253,159,217,120,36,100,72,1,250,136,243,103,246,127,101,229,145, +113,32,7,212,54,127,99,246,222,9,23,18,0,125,67,103,246,63,109,229,145,145, +32,7,234,35,205,159,216,253,183,130,70,68,128,31,168,143,54,127,99,246,222, +89,17,18,0,125,67,103,247,9,137,0,63,81,30,108,254,224,130,115,240,98,66, +128,92,136,84,45,101,180,81,50,28,78,99,193,18,40,56,153,58,178,52,211,58, +17,46,134,133,41,34,164,75,164,104,156,52,52,199,37,222,232,206,66,64,207, +18,66,136,137,19,173,62,46,155,181,167,72,147,235,226,233,186,120,121,58, +226,157,214,111,84,76,73,36,109,24,72,130,100,112,200,178,76,157,124,92, +242,70,120,25,193,34,245,241,117,240,97,1,107,33,25,212,54,160,90,7,244,29, +24,38,66,254,223,215,125,119,215,126,232,190,43,226,67,244,1,250,193,125, +111,216,11,234,254,192,63,96,159,173,234,26,84,53,19,194,126,175,168,105, +80,212,79,8,234,26,84,53,19,193,156,20,144,83,52,167,20,52,198,109,24,18, +68,225,115,150,64,53,52,104,200,84,52,131,76,167,20,52,200,46,7,48,52,146, +132,102,57,33,165,139,168,209,154,32,104,220,193,189,214,27,16,209,176,23, +26,220,98,149,110,116,70,75,188,98,116,136,34,33,101,4,192,223,178,32,38,6, +144,18,67,72,1,58,67,0,100,95,74,17,159,217,31,210,132,103,246,58,251,33, +121,232,55,150,227,125,143,216,16,190,91,141,246,68,31,150,223,178,39,150, +223,177,251,0,244,135,97,37,32,24,132,104,24,66,161,175,164,202,134,140, +151,39,212,125,255,221,125,74,86,9,79,168,104,201,116,178,139,154,22,134, +145,72,51,93,18,116,64,145,13,39,82,34,33,38,73,76,132,185,4,185,187,198, +100,229,233,197,13,49,228,73,247,4,4,78,98,79,184,32,34,105,187,201,147, +154,185,187,200,147,165,233,197,13,50,230,239,82,98,151,167,20,52,206,145, +39,234,76,69,245,22,190,224,128,138,228,73,244,180,90,251,130,2,43,145,39, +234,76,76,243,155,51,162,68,159,88,230,204,234,145,39,234,76,67,240,38,67, +200,147,232,193,50,46,68,159,169,49,31,206,164,100,137,18,125,59,169,25,54, +68,159,169,49,51,200,109,38,73,42,68,159,88,134,210,100,147,100,73,250,147, +20,188,65,57,163,146,164,73,246,68,19,154,57,74,68,159,169,49,51,200,90, +209,34,9,205,28,159,34,79,172,66,214,137,16,78,104,228,121,18,125,154,24, +72,152,147,236,208,194,101,205,39,92,82,200,147,145,137,63,82,98,103,144, +181,162,68,19,154,57,60,196,159,88,133,173,18,32,156,209,201,166,36,253,73, +138,94,32,156,209,201,70,36,251,34,9,205,28,154,98,79,212,152,153,228,54, +147,36,148,98,79,172,67,105,50,73,102,36,253,73,136,254,117,35,36,24,147, +233,221,72,201,38,36,253,73,136,126,6,12,98,79,163,6,20,98,79,212,152,135, +224,76,135,49,39,209,130,100,89,137,63,82,98,103,156,217,157,6,36,250,199, +54,103,113,137,63,82,98,47,168,181,247,4,4,86,98,79,165,162,215,220,16,17, +57,137,62,205,12,36,166,238,173,194,2,201,217,161,132,236,167,20,52,210, +155,186,183,8,11,39,70,9,147,178,156,80,211,50,110,236,208,194,118,83,138, +26,102,77,221,24,38,78,202,113,67,76,54,186,195,245,38,34,188,17,145,23,55, +117,241,32,145,36,57,173,155,186,75,189,205,35,102,128,44,243,119,74,139, +144,113,243,221,36,77,21,38,144,210,161,168,158,35,230,144,192,154,42,77, +33,165,67,81,60,15,173,7,90,159,49,13,213,64,186,17,62,96,47,170,129,116, +33,165,64,202,113,36,226,134,70,110,234,220,32,44,157,163,222,72,244,64, +145,23,55,118,143,121,35,209,2,68,140,221,213,184,64,89,58,183,88,145,232, +129,34,46,110,234,221,98,71,162,4,136,153,80,50,156,80,211,22,79,90,38,105, +16,17,17,207,18,61,96,17,10,192,76,71,106,220,32,44,157,19,152,240,68,138, +17,193,30,137,195,39,65,51,8,224,143,65,54,22,46,103,68,112,71,162,112,200, +184,144,116,17,59,20,24,243,52,72,58,8,134,42,23,50,68,108,3,206,87,71,164, +0,142,73,57,132,41,42,72,225,107,4,167,212,52,100,191,92,83,161,163,37,250, +226,158,141,145,208,89,154,79,90,4,66,73,209,153,100,180,8,133,145,208,89, +158,36,169,35,34,17,244,145,198,247,60,137,114,26,97,57,162,4,206,137,116, +17,136,48,144,68,212,97,27,57,24,64,90,201,18,5,13,25,4,5,172,160,123,215, +138,62,46,121,35,60,117,18,233,27,70,18,32,10,200,212,75,175,139,166,233, +225,228,235,138,227,130,93,117,155,215,197,207,36,103,131,212,11,161,58, +226,186,110,234,220,32,44,157,148,226,134,153,19,119,101,56,161,166,88,156, +217,78,52,20,221,17,200,147,25,137,53,17,180,97,34,0,172,140,19,154,84,26, +145,0,86,68,90,40,152,2,178,22,160,93,8,69,19,18,98,37,210,94,100,108,144, +21,145,8,151,75,23,100,141,66,37,217,16,11,32,226,248,146,164,108,250,75, +204,141,146,28,217,24,177,33,50,66,72,128,92,6,66,161,164,235,226,231,146, +51,65,36,225,144,168,105,58,248,185,228,140,240,97,68,128,153,38,98,79,174, +179,122,248,185,228,140,241,214,129,132,150,12,73,245,214,111,95,23,60,145, +158,58,50,72,81,67,230,232,184,196,159,95,23,77,211,195,201,215,21,47,139, +166,233,225,228,50,200,211,76,229,2,201,25,149,241,67,102,138,52,146,16,30, +67,18,66,3,201,34,52,78,25,61,72,160,94,115,30,230,145,179,73,26,39,12,158, +164,81,33,144,78,25,61,72,160,94,115,30,230,145,179,72,200,39,12,158,164, +80,132,75,165,67,81,50,21,18,235,65,214,169,224,140,137,210,173,192,154,30, +8,200,157,67,102,66,84,11,71,169,20,19,209,139,162,158,207,15,39,73,24,186, +43,236,176,217,130,253,36,98,232,187,177,33,73,18,52,68,233,35,23,69,93, +136,26,98,116,145,139,162,158,146,160,95,73,24,186,37,12,72,5,16,64,145,10, +32,76,71,64,156,217,161,180,34,6,64,208,198,36,78,50,20,20,92,204,50,44, +147,32,134,226,17,114,33,202,134,129,107,192,202,232,160,180,104,166,135, +52,72,40,144,213,33,178,152,26,34,56,163,105,44,104,146,116,139,77,43,34, +98,57,38,116,72,179,60,93,97,206,56,52,240,242,56,163,168,34,74,185,3,45, +142,133,144,150,68,206,81,44,18,145,68,230,202,100,35,104,195,18,239,116, +102,114,94,100,104,228,100,49,238,140,203,42,60,145,35,104,181,146,113,161, +10,80,46,68,82,24,245,145,132,108,228,148,54,100,137,64,34,13,100,153,222, +1,40,6,33,223,20,84,19,34,95,23,76,130,153,6,103,208,43,64,141,41,130,104, +17,112,130,44,96, +}; + +/* to convert a heap stridx to a token number, subtract + * DUK_STRIDX_START_RESERVED and add DUK_TOK_START_RESERVED. + */ + +/* native functions: 147 */ +DUK_INTERNAL const duk_c_function duk_bi_native_functions[147] = { + duk_bi_array_constructor, + duk_bi_array_constructor_is_array, + duk_bi_array_prototype_concat, + duk_bi_array_prototype_indexof_shared, + duk_bi_array_prototype_iter_shared, + duk_bi_array_prototype_join_shared, + duk_bi_array_prototype_pop, + duk_bi_array_prototype_push, + duk_bi_array_prototype_reduce_shared, + duk_bi_array_prototype_reverse, + duk_bi_array_prototype_shift, + duk_bi_array_prototype_slice, + duk_bi_array_prototype_sort, + duk_bi_array_prototype_splice, + duk_bi_array_prototype_to_string, + duk_bi_array_prototype_unshift, + duk_bi_arraybuffer_constructor, + duk_bi_arraybuffer_isview, + duk_bi_boolean_constructor, + duk_bi_boolean_prototype_tostring_shared, + duk_bi_buffer_compare_shared, + duk_bi_buffer_constructor, + duk_bi_buffer_prototype_tostring_shared, + duk_bi_buffer_readfield, + duk_bi_buffer_slice_shared, + duk_bi_buffer_writefield, + duk_bi_dataview_constructor, + duk_bi_date_constructor, + duk_bi_date_constructor_now, + duk_bi_date_constructor_parse, + duk_bi_date_constructor_utc, + duk_bi_date_prototype_get_shared, + duk_bi_date_prototype_get_timezone_offset, + duk_bi_date_prototype_set_shared, + duk_bi_date_prototype_set_time, + duk_bi_date_prototype_to_json, + duk_bi_date_prototype_tostring_shared, + duk_bi_date_prototype_value_of, + duk_bi_duktape_object_act, + duk_bi_duktape_object_compact, + duk_bi_duktape_object_dec, + duk_bi_duktape_object_enc, + duk_bi_duktape_object_fin, + duk_bi_duktape_object_gc, + duk_bi_duktape_object_info, + duk_bi_error_constructor_shared, + duk_bi_error_prototype_filename_getter, + duk_bi_error_prototype_linenumber_getter, + duk_bi_error_prototype_nop_setter, + duk_bi_error_prototype_stack_getter, + duk_bi_error_prototype_to_string, + duk_bi_function_constructor, + duk_bi_function_prototype, + duk_bi_function_prototype_apply, + duk_bi_function_prototype_bind, + duk_bi_function_prototype_call, + duk_bi_function_prototype_to_string, + duk_bi_global_object_decode_uri, + duk_bi_global_object_decode_uri_component, + duk_bi_global_object_encode_uri, + duk_bi_global_object_encode_uri_component, + duk_bi_global_object_escape, + duk_bi_global_object_eval, + duk_bi_global_object_is_finite, + duk_bi_global_object_is_nan, + duk_bi_global_object_parse_float, + duk_bi_global_object_parse_int, + duk_bi_global_object_print_helper, + duk_bi_global_object_require, + duk_bi_global_object_unescape, + duk_bi_json_object_parse, + duk_bi_json_object_stringify, + duk_bi_logger_constructor, + duk_bi_logger_prototype_fmt, + duk_bi_logger_prototype_log_shared, + duk_bi_logger_prototype_raw, + duk_bi_math_object_max, + duk_bi_math_object_min, + duk_bi_math_object_onearg_shared, + duk_bi_math_object_random, + duk_bi_math_object_twoarg_shared, + duk_bi_nodejs_buffer_byte_length, + duk_bi_nodejs_buffer_concat, + duk_bi_nodejs_buffer_constructor, + duk_bi_nodejs_buffer_copy, + duk_bi_nodejs_buffer_fill, + duk_bi_nodejs_buffer_is_buffer, + duk_bi_nodejs_buffer_is_encoding, + duk_bi_nodejs_buffer_tojson, + duk_bi_nodejs_buffer_tostring, + duk_bi_nodejs_buffer_write, + duk_bi_number_constructor, + duk_bi_number_prototype_to_exponential, + duk_bi_number_prototype_to_fixed, + duk_bi_number_prototype_to_locale_string, + duk_bi_number_prototype_to_precision, + duk_bi_number_prototype_to_string, + duk_bi_number_prototype_value_of, + duk_bi_object_constructor, + duk_bi_object_constructor_create, + duk_bi_object_constructor_define_properties, + duk_bi_object_constructor_define_property, + duk_bi_object_constructor_get_own_property_descriptor, + duk_bi_object_constructor_is_extensible, + duk_bi_object_constructor_is_sealed_frozen_shared, + duk_bi_object_constructor_keys_shared, + duk_bi_object_constructor_prevent_extensions, + duk_bi_object_constructor_seal_freeze_shared, + duk_bi_object_getprototype_shared, + duk_bi_object_prototype_has_own_property, + duk_bi_object_prototype_is_prototype_of, + duk_bi_object_prototype_property_is_enumerable, + duk_bi_object_prototype_to_locale_string, + duk_bi_object_prototype_to_string, + duk_bi_object_prototype_value_of, + duk_bi_object_setprototype_shared, + duk_bi_pointer_constructor, + duk_bi_pointer_prototype_tostring_shared, + duk_bi_proxy_constructor, + duk_bi_regexp_constructor, + duk_bi_regexp_prototype_exec, + duk_bi_regexp_prototype_test, + duk_bi_regexp_prototype_to_string, + duk_bi_string_constructor, + duk_bi_string_constructor_from_char_code, + duk_bi_string_prototype_caseconv_shared, + duk_bi_string_prototype_char_at, + duk_bi_string_prototype_char_code_at, + duk_bi_string_prototype_concat, + duk_bi_string_prototype_indexof_shared, + duk_bi_string_prototype_locale_compare, + duk_bi_string_prototype_match, + duk_bi_string_prototype_replace, + duk_bi_string_prototype_search, + duk_bi_string_prototype_slice, + duk_bi_string_prototype_split, + duk_bi_string_prototype_substr, + duk_bi_string_prototype_substring, + duk_bi_string_prototype_to_string, + duk_bi_string_prototype_trim, + duk_bi_thread_constructor, + duk_bi_thread_current, + duk_bi_thread_resume, + duk_bi_thread_yield, + duk_bi_type_error_thrower, + duk_bi_typedarray_constructor, + duk_bi_typedarray_set, +}; + +DUK_INTERNAL const duk_uint8_t duk_builtins_data[1952] = { +105,195,75,16,121,40,105,51,14,252,104,52,8,131,72,0,115,225,65,165,236,55, +243,6,145,32,210,24,210,182,25,249,35,120,216,99,226,13,78,225,116,177,164, +180,44,192,4,202,52,150,220,24,0,169,70,146,219,123,0,23,40,210,91,110,96, +3,37,26,75,109,172,0,108,163,73,109,177,128,14,148,105,45,181,176,1,242, +144,56,209,32,94,6,167,101,98,80,211,24,1,250,67,72,168,67,232,13,46,128, +47,162,52,164,0,62,80,163,72,128,61,40,107,26,7,37,20,53,200,131,88,0,66, +134,185,16,98,80,215,34,11,96,0,138,26,228,65,76,0,69,67,92,136,37,128,6, +168,107,145,4,48,1,165,13,114,32,118,0,44,161,174,68,12,192,7,148,53,200, +129,88,1,26,134,165,48,130,80,31,255,241,69,224,0,0,0,0,0,0,124,63,174,32, +0,0,0,0,0,0,120,63,175,98,7,140,16,116,194,7,12,48,108,196,6,140,80,100, +198,6,12,112,92,200,5,140,149,192,202,91,204,181,184,204,91,76,213,176,206, +90,204,240,84,208,5,13,9,124,210,43,13,24,64,226,131,205,112,56,216,3,77, +152,48,218,130,205,184,40,220,130,77,216,32,222,129,205,248,24,224,129,78, +25,214,163,226,90,80,145,104,65,37,157,0,150,99,242,89,78,73,100,58,37,140, +236,150,35,194,88,79,73,96,69,37,125,12,122,188,134,62,0,2,165,68,39,255, +255,193,43,67,0,0,80,127,192,58,182,216,80,0,21,59,154,64,0,107,76,200,172, +180,146,176,198,138,187,43,42,204,136,170,181,146,168,214,80,0,26,155,81, +42,77,4,168,180,20,0,6,160,206,74,123,73,64,0,127,255,4,10,153,219,28,198, +163,184,130,140,224,10,43,144,40,141,164,161,183,18,132,222,64,161,127,128, +0,63,225,1,109,74,8,137,71,56,5,4,213,20,3,115,233,249,177,240,80,255,192, +6,120,2,64,127,195,0,173,28,56,20,96,80,128,0,206,192,143,167,64,164,156, +131,2,112,14,125,55,9,4,216,40,19,80,180,77,3,9,51,13,94,153,7,159,76,64, +207,192,0,102,0,103,255,255,242,240,67,73,112,33,168,0,12,180,16,212,0,10, +88,8,106,0,7,43,4,53,0,4,149,4,31,128,0,202,66,15,255,255,194,137,254,0,50, +135,195,224,127,196,2,87,132,17,82,143,20,10,44,80,36,239,196,147,63,146, +119,0,125,49,129,52,152,64,154,128,0,201,96,137,36,131,36,142,17,18,40,82, +77,97,145,33,135,68,130,37,17,247,208,71,159,65,29,125,8,0,12,113,244,32,0, +49,184,176,70,162,16,20,95,240,0,7,252,80,37,120,193,81,196,194,0,3,69,19, +0,81,191,197,140,192,255,255,255,255,255,255,239,127,140,64,1,0,0,0,0,0,0, +0,139,192,0,0,0,0,0,0,248,127,138,192,0,0,0,0,0,0,240,127,139,64,0,0,0,0,0, +0,240,255,0,31,241,128,149,224,0,0,0,0,0,0,0,0,13,71,96,37,25,120,148,86, +16,69,23,73,19,92,36,73,124,129,71,255,0,56,136,233,34,3,223,208,241,192,3, +254,56,18,188,128,0,0,0,0,0,15,135,251,104,228,128,135,18,4,0,6,26,72,16,0, +42,49,32,64,0,225,132,129,0,4,133,146,4,0,21,210,72,16,0,103,65,32,64,1, +220,228,100,162,146,130,20,74,8,72,248,64,2,33,3,225,0,9,131,143,132,0,42, +12,62,16,0,184,40,248,64,3,32,131,225,0,13,129,143,132,0,58,4,62,16,0,248, +8,248,64,4,32,3,225,0,17,127,143,132,0,73,252,62,16,1,55,232,248,64,5,31, +131,225,0,21,125,143,132,0,89,244,62,16,1,119,201,0,31,4,68,123,144,148,0, +97,236,66,80,1,151,169,10,248,0,211,208,133,124,0,109,230,66,254,0,56,242, +33,127,0,29,120,144,207,128,15,60,8,103,192,7,221,228,37,0,32,119,16,148,0, +133,218,66,190,0,68,236,33,95,0,35,117,144,191,128,18,58,136,95,192,9,92, +195,225,0,38,114,144,148,0,156,41,31,224,0,15,249,1,138,144,64,192,2,2,225, +132,221,9,70,112,70,111,198,111,72,0,0,0,0,0,0,0,0,13,198,240,71,19,201,40, +239,64,10,79,248,0,3,254,72,86,209,5,155,36,17,46,185,137,129,109,203,140, +11,78,94,96,13,28,200,1,74,255,0,2,127,202,4,218,43,131,100,130,32,5,47, +252,0,9,255,44,19,104,173,237,146,8,128,20,207,240,0,39,252,192,77,162,183, +54,72,34,0,83,127,192,0,159,243,65,54,138,218,217,32,136,1,78,255,0,2,127, +206,4,218,43,99,100,130,32,5,63,252,0,9,255,60,19,104,173,109,146,8,128,15, +255,242,27,16,26,85,197,34,194,175,193,80,26,240,5,149,109,110,236,90,192, +144,26,208,59,206,126,191,144,139,185,143,218,176,63,160,138,217,81,197, +125,207,218,144,3,185,73,133,94,242,246,207,218,112,6,11,81,21,62,200,66, +80,26,80,51,78,223,217,167,168,57,143,218,48,51,78,223,217,167,168,61,143, +210,104,39,17,158,156,80,0,22,114,113,64,0,153,169,197,0,3,102,40,33,150, +156,80,0,70,82,113,64,1,89,41,197,0,6,100,39,20,0,29,142,156,80,0,134,50, +98,243,21,53,121,136,160,144,0,22,26,120,24,73,197,0,9,96,167,20,0,41,128, +156,80,0,181,250,113,64,3,1,255,254,0,81,20,100,47,145,216,23,255,240,0,11, +255,248,0,3,255,252,81,252,0,0,0,0,0,1,236,68,0,129,167,1,26,144,9,165,0, +26,177,199,197,132,30,147,16,120,86,65,217,80,240,232,164,120,114,80,60,52, +39,32,84,223,192,15,59,30,129,156,115,6,81,160,7,253,40,0,5,81,252,0,1,255, +78,0,84,113,96,128,0,209,69,128,21,87,240,0,7,253,72,1,81,221,66,0,3,69, +117,0,85,159,192,0,31,245,97,10,100,0,0,0,0,0,0,0,32,10,164,130,97,221,191, +113,3,20,146,12,18,200,47,74,30,23,37,15,128,0,143,146,135,192,0,133,169, +67,224,0,98,196,161,240,0,65,90,80,248,0,41,63,255,194,109,65,11,137,191, +174,45,153,98,242,229,191,147,102,8,190,94,92,183,242,65,167,114,12,188, +185,111,228,131,70,29,217,54,105,221,156,0,171,255,128,9,208,68,128,255, +174,0,25,168,194,64,0,130,177,254,0,0,255,176,1,3,120,186,64,12,13,194,233, +0,32,54,139,164,0,196,216,46,144,2,19,88,186,64,12,141,66,233,0,34,52,139, +164,0,140,208,46,144,2,67,56,203,64,12,12,195,45,0,32,50,140,180,0,196,200, +50,208,2,19,24,203,64,12,140,67,45,0,34,48,140,180,0,140,192,50,208,2,64, +127,255,128,21,38,73,7,1,132,128,0,133,105,252,19,140,0,0,0,0,0,0,15,3,240, +25,127,102,0,1,91,127,4,227,0,0,0,0,0,0,3,192,252,6,95,218,128,0,87,31,193, +56,192,0,0,0,0,0,0,240,63,1,151,246,224,0,21,215,240,78,48,0,0,0,0,0,0,0, +16,0,101,253,200,0,5,121,252,19,140,0,0,0,0,0,0,0,4,0,25,127,118,0,1,95, +127,4,227,0,0,0,0,0,0,0,65,0,6,95,222,128,0,88,31,193,56,192,0,0,0,0,0,0, +16,64,1,151,247,224,0,22,23,240,78,48,0,0,0,0,0,0,4,16,0,101,254,8,0,5,137, +252,19,140,0,0,0,0,0,0,2,4,0,25,127,134,0,1,99,127,0,89,218,146,20,74,228, +80,171,17,64,162,132,248,162,64,0,193,255,138,5,137,161,116,38,69,210,0,32, +152,23,72,0,10,92,93,32,1,41,97,116,128,8,165,69,210,0,50,148,23,72,0,18, +76,93,32,1,73,33,116,128,9,36,69,210,0,52,144,23,72,0,26,60,93,32,1,104, +225,116,128,2,35,69,210,0,24,140,23,104,0,42,44,93,160,1,168,161,118,128, +10,162,69,218,0,58,136,25,98,28,101,160,2,8,97,150,128,0,161,70,90,0,18, +132,25,104,0,138,12,101,160,3,40,33,150,128,1,32,70,90,0,20,128,25,104,0, +145,252,101,160,3,71,225,150,128,1,159,70,90,0,22,124,25,104,0,33,236,101, +160,1,135,161,152,128,2,158,70,98,0,26,120,25,136,0,169,220,102,32,3,180, +117,150,57,214,0,157,85,98,112,80,137,241,66,128,0,166,213,33,53,24,66,121, +106,0, +}; +#ifdef DUK_USE_BUILTIN_INITJS +DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = { +40,102,117,110,99,116,105,111,110,40,100,44,97,41,123,102,117,110,99,116, +105,111,110,32,98,40,97,44,98,44,99,41,123,79,98,106,101,99,116,46,100,101, +102,105,110,101,80,114,111,112,101,114,116,121,40,97,44,98,44,123,118,97, +108,117,101,58,99,44,119,114,105,116,97,98,108,101,58,33,48,44,101,110,117, +109,101,114,97,98,108,101,58,33,49,44,99,111,110,102,105,103,117,114,97,98, +108,101,58,33,48,125,41,125,98,40,97,46,76,111,103,103,101,114,44,34,99, +108,111,103,34,44,110,101,119,32,97,46,76,111,103,103,101,114,40,34,67,34, +41,41,59,98,40,97,44,34,109,111,100,76,111,97,100,101,100,34,44,123,125,41, +125,41,40,116,104,105,115,44,68,117,107,116,97,112,101,41,59,10,0, +}; +#endif /* DUK_USE_BUILTIN_INITJS */ +#elif defined(DUK_USE_DOUBLE_BE) +DUK_INTERNAL const duk_uint8_t duk_strings_data[2624] = { +55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,50,11,164,109, +77,215,5,61,35,106,206,149,110,4,254,219,237,58,8,196,24,103,74,183,2,127, +103,246,93,4,98,12,47,180,67,103,246,127,101,208,70,32,194,186,134,207,236, +254,203,160,140,65,133,246,136,108,254,199,237,186,8,196,24,87,80,217,253, +143,219,116,17,136,49,30,209,13,159,220,116,75,3,30,65,244,17,136,48,174, +209,13,159,220,116,17,136,48,158,161,179,251,142,130,49,6,17,209,130,96, +237,80,75,47,160,140,65,142,134,133,41,34,110,134,133,41,34,3,25,110,8,22, +158,130,38,163,8,217,200,158,76,156,210,117,128,153,203,210,70,46,137,187, +18,27,164,187,201,209,130,100,55,91,70,4,145,63,66,231,44,128,105,187,41, +197,13,49,122,8,196,24,71,75,70,138,104,115,77,215,5,36,20,201,214,209,107, +79,104,209,144,168,105,6,207,251,209,104,209,125,212,227,66,127,235,191, +239,232,180,90,52,95,69,247,83,141,9,255,174,255,191,162,211,80,210,253,23, +221,78,52,39,254,183,254,254,139,72,105,126,139,238,167,26,19,255,91,255, +127,69,166,129,191,69,247,83,141,9,255,175,255,191,162,213,26,50,23,232, +190,234,113,161,63,245,115,119,86,227,118,83,138,26,98,9,110,48,86,22,148, +160,152,22,82,70,46,137,44,8,180,163,32,104,98,206,32,17,7,16,88,101,100, +206,42,70,36,108,205,18,74,140,33,196,230,60,2,152,146,33,38,230,8,36,79, +182,251,65,156,151,24,200,33,145,162,25,80,209,24,67,0,166,68,52,174,61,73, +25,33,205,25,27,84,177,195,234,220,1,144,105,99,135,217,16,17,17,208,72, +199,179,60,93,100,146,49,232,162,64,76,135,19,152,244,44,136,223,98,67,4, +18,33,247,217,158,36,0,209,190,156,13,26,201,21,111,165,67,64,180,100,145, +62,250,32,45,100,33,55,214,1,229,223,65,19,72,187,236,206,137,35,125,120, +190,201,104,105,15,190,201,212,136,136,125,246,160,137,27,83,239,171,37, +200,218,159,125,168,34,192,61,27,233,93,22,1,114,78,250,28,76,130,112,200, +93,245,164,188,207,190,204,17,49,38,109,246,160,93,8,119,185,13,153,34,173, +246,113,0,136,48,76,10,90,26,78,182,140,9,34,130,161,100,235,64,194,9,226, +44,166,1,41,221,153,226,235,118,120,121,58,72,197,209,63,71,69,76,15,34, +164,73,244,171,112,39,246,223,104,169,18,125,42,220,9,253,159,217,38,68, +159,104,134,207,236,254,201,18,36,250,134,207,236,254,201,50,36,251,68,54, +127,99,246,200,145,39,212,54,127,99,246,200,145,39,218,33,179,251,131,200, +147,234,27,63,184,81,137,62,149,110,4,254,219,237,20,98,79,165,91,129,63, +179,251,36,152,147,237,16,217,253,159,217,32,196,159,80,217,253,159,217,36, +196,159,104,134,207,236,126,217,6,36,250,134,207,236,126,217,6,36,251,68, +54,127,112,115,18,125,67,103,247,8,149,2,8,196,24,143,131,137,146,90,121, +35,162,44,140,35,102,160,226,100,235,138,89,18,102,13,10,82,68,200,151,106, +130,88,131,4,192,73,225,228,85,162,137,147,168,108,252,18,42,209,68,201, +212,54,126,89,23,104,162,100,245,17,230,207,193,34,237,20,76,158,162,60, +217,249,100,109,162,137,147,163,117,2,178,120,36,109,162,137,147,163,117,2, +178,121,100,101,162,137,147,165,91,129,63,4,140,180,81,50,116,171,112,39, +229,145,150,138,38,78,161,179,251,63,178,240,72,203,69,19,39,80,217,253, +159,217,121,100,109,162,137,147,212,71,155,63,179,251,47,4,141,180,81,50, +122,136,243,103,246,127,101,229,145,150,138,38,78,161,179,251,31,182,240, +72,203,69,19,39,80,217,253,143,219,121,100,109,162,137,147,212,71,155,63, +177,251,111,4,141,180,81,50,122,136,243,103,246,63,109,229,145,54,138,38, +78,161,179,251,133,90,40,153,61,68,121,179,251,132,196,128,31,80,217,248, +36,76,72,1,245,13,159,150,69,68,128,31,168,143,54,126,9,21,18,0,126,162,60, +217,249,100,100,72,1,244,110,160,86,79,4,140,137,0,62,141,212,10,201,229, +145,113,32,7,210,173,192,159,130,69,196,128,31,74,183,2,126,89,23,18,0,125, +67,103,246,127,101,224,145,113,32,7,212,54,127,103,246,94,89,25,18,0,126, +162,60,217,253,159,217,120,36,100,72,1,250,136,243,103,246,127,101,229,145, +113,32,7,212,54,127,99,246,222,9,23,18,0,125,67,103,246,63,109,229,145,145, +32,7,234,35,205,159,216,253,183,130,70,68,128,31,168,143,54,127,99,246,222, +89,17,18,0,125,67,103,247,9,137,0,63,81,30,108,254,224,130,115,240,98,66, +128,92,136,84,45,101,180,81,50,28,78,99,193,18,40,56,153,58,178,52,211,58, +17,46,134,133,41,34,164,75,164,104,156,52,52,199,37,222,232,206,66,64,207, +18,66,136,137,19,173,62,46,155,181,167,72,147,235,226,233,186,120,121,58, +226,157,214,111,84,76,73,36,109,24,72,130,100,112,200,178,76,157,124,92, +242,70,120,25,193,34,245,241,117,240,97,1,107,33,25,212,54,160,90,7,244,29, +24,38,66,254,223,215,125,119,215,126,232,190,43,226,67,244,1,250,193,125, +111,216,11,234,254,192,63,96,159,173,234,26,84,53,19,194,126,175,168,105, +80,212,79,8,234,26,84,53,19,193,156,20,144,83,52,167,20,52,198,109,24,18, +68,225,115,150,64,53,52,104,200,84,52,131,76,167,20,52,200,46,7,48,52,146, +132,102,57,33,165,139,168,209,154,32,104,220,193,189,214,27,16,209,176,23, +26,220,98,149,110,116,70,75,188,98,116,136,34,33,101,4,192,223,178,32,38,6, +144,18,67,72,1,58,67,0,100,95,74,17,159,217,31,210,132,103,246,58,251,33, +121,232,55,150,227,125,143,216,16,190,91,141,246,68,31,150,223,178,39,150, +223,177,251,0,244,135,97,37,32,24,132,104,24,66,161,175,164,202,134,140, +151,39,212,125,255,221,125,74,86,9,79,168,104,201,116,178,139,154,22,134, +145,72,51,93,18,116,64,145,13,39,82,34,33,38,73,76,132,185,4,185,187,198, +100,229,233,197,13,49,228,73,247,4,4,78,98,79,184,32,34,105,187,201,147, +154,185,187,200,147,165,233,197,13,50,230,239,82,98,151,167,20,52,206,145, +39,234,76,69,245,22,190,224,128,138,228,73,244,180,90,251,130,2,43,145,39, +234,76,76,243,155,51,162,68,159,88,230,204,234,145,39,234,76,67,240,38,67, +200,147,232,193,50,46,68,159,169,49,31,206,164,100,137,18,125,59,169,25,54, +68,159,169,49,51,200,109,38,73,42,68,159,88,134,210,100,147,100,73,250,147, +20,188,65,57,163,146,164,73,246,68,19,154,57,74,68,159,169,49,51,200,90, +209,34,9,205,28,159,34,79,172,66,214,137,16,78,104,228,121,18,125,154,24, +72,152,147,236,208,194,101,205,39,92,82,200,147,145,137,63,82,98,103,144, +181,162,68,19,154,57,60,196,159,88,133,173,18,32,156,209,201,166,36,253,73, +138,94,32,156,209,201,70,36,251,34,9,205,28,154,98,79,212,152,153,228,54, +147,36,148,98,79,172,67,105,50,73,102,36,253,73,136,254,117,35,36,24,147, +233,221,72,201,38,36,253,73,136,126,6,12,98,79,163,6,20,98,79,212,152,135, +224,76,135,49,39,209,130,100,89,137,63,82,98,103,156,217,157,6,36,250,199, +54,103,113,137,63,82,98,47,168,181,247,4,4,86,98,79,165,162,215,220,16,17, +57,137,62,205,12,36,166,238,173,194,2,201,217,161,132,236,167,20,52,210, +155,186,183,8,11,39,70,9,147,178,156,80,211,50,110,236,208,194,118,83,138, +26,102,77,221,24,38,78,202,113,67,76,54,186,195,245,38,34,188,17,145,23,55, +117,241,32,145,36,57,173,155,186,75,189,205,35,102,128,44,243,119,74,139, +144,113,243,221,36,77,21,38,144,210,161,168,158,35,230,144,192,154,42,77, +33,165,67,81,60,15,173,7,90,159,49,13,213,64,186,17,62,96,47,170,129,116, +33,165,64,202,113,36,226,134,70,110,234,220,32,44,157,163,222,72,244,64, +145,23,55,118,143,121,35,209,2,68,140,221,213,184,64,89,58,183,88,145,232, +129,34,46,110,234,221,98,71,162,4,136,153,80,50,156,80,211,22,79,90,38,105, +16,17,17,207,18,61,96,17,10,192,76,71,106,220,32,44,157,19,152,240,68,138, +17,193,30,137,195,39,65,51,8,224,143,65,54,22,46,103,68,112,71,162,112,200, +184,144,116,17,59,20,24,243,52,72,58,8,134,42,23,50,68,108,3,206,87,71,164, +0,142,73,57,132,41,42,72,225,107,4,167,212,52,100,191,92,83,161,163,37,250, +226,158,141,145,208,89,154,79,90,4,66,73,209,153,100,180,8,133,145,208,89, +158,36,169,35,34,17,244,145,198,247,60,137,114,26,97,57,162,4,206,137,116, +17,136,48,144,68,212,97,27,57,24,64,90,201,18,5,13,25,4,5,172,160,123,215, +138,62,46,121,35,60,117,18,233,27,70,18,32,10,200,212,75,175,139,166,233, +225,228,235,138,227,130,93,117,155,215,197,207,36,103,131,212,11,161,58, +226,186,110,234,220,32,44,157,148,226,134,153,19,119,101,56,161,166,88,156, +217,78,52,20,221,17,200,147,25,137,53,17,180,97,34,0,172,140,19,154,84,26, +145,0,86,68,90,40,152,2,178,22,160,93,8,69,19,18,98,37,210,94,100,108,144, +21,145,8,151,75,23,100,141,66,37,217,16,11,32,226,248,146,164,108,250,75, +204,141,146,28,217,24,177,33,50,66,72,128,92,6,66,161,164,235,226,231,146, +51,65,36,225,144,168,105,58,248,185,228,140,240,97,68,128,153,38,98,79,174, +179,122,248,185,228,140,241,214,129,132,150,12,73,245,214,111,95,23,60,145, +158,58,50,72,81,67,230,232,184,196,159,95,23,77,211,195,201,215,21,47,139, +166,233,225,228,50,200,211,76,229,2,201,25,149,241,67,102,138,52,146,16,30, +67,18,66,3,201,34,52,78,25,61,72,160,94,115,30,230,145,179,73,26,39,12,158, +164,81,33,144,78,25,61,72,160,94,115,30,230,145,179,72,200,39,12,158,164, +80,132,75,165,67,81,50,21,18,235,65,214,169,224,140,137,210,173,192,154,30, +8,200,157,67,102,66,84,11,71,169,20,19,209,139,162,158,207,15,39,73,24,186, +43,236,176,217,130,253,36,98,232,187,177,33,73,18,52,68,233,35,23,69,93, +136,26,98,116,145,139,162,158,146,160,95,73,24,186,37,12,72,5,16,64,145,10, +32,76,71,64,156,217,161,180,34,6,64,208,198,36,78,50,20,20,92,204,50,44, +147,32,134,226,17,114,33,202,134,129,107,192,202,232,160,180,104,166,135, +52,72,40,144,213,33,178,152,26,34,56,163,105,44,104,146,116,139,77,43,34, +98,57,38,116,72,179,60,93,97,206,56,52,240,242,56,163,168,34,74,185,3,45, +142,133,144,150,68,206,81,44,18,145,68,230,202,100,35,104,195,18,239,116, +102,114,94,100,104,228,100,49,238,140,203,42,60,145,35,104,181,146,113,161, +10,80,46,68,82,24,245,145,132,108,228,148,54,100,137,64,34,13,100,153,222, +1,40,6,33,223,20,84,19,34,95,23,76,130,153,6,103,208,43,64,141,41,130,104, +17,112,130,44,96, +}; + +/* to convert a heap stridx to a token number, subtract + * DUK_STRIDX_START_RESERVED and add DUK_TOK_START_RESERVED. + */ + +/* native functions: 147 */ +DUK_INTERNAL const duk_c_function duk_bi_native_functions[147] = { + duk_bi_array_constructor, + duk_bi_array_constructor_is_array, + duk_bi_array_prototype_concat, + duk_bi_array_prototype_indexof_shared, + duk_bi_array_prototype_iter_shared, + duk_bi_array_prototype_join_shared, + duk_bi_array_prototype_pop, + duk_bi_array_prototype_push, + duk_bi_array_prototype_reduce_shared, + duk_bi_array_prototype_reverse, + duk_bi_array_prototype_shift, + duk_bi_array_prototype_slice, + duk_bi_array_prototype_sort, + duk_bi_array_prototype_splice, + duk_bi_array_prototype_to_string, + duk_bi_array_prototype_unshift, + duk_bi_arraybuffer_constructor, + duk_bi_arraybuffer_isview, + duk_bi_boolean_constructor, + duk_bi_boolean_prototype_tostring_shared, + duk_bi_buffer_compare_shared, + duk_bi_buffer_constructor, + duk_bi_buffer_prototype_tostring_shared, + duk_bi_buffer_readfield, + duk_bi_buffer_slice_shared, + duk_bi_buffer_writefield, + duk_bi_dataview_constructor, + duk_bi_date_constructor, + duk_bi_date_constructor_now, + duk_bi_date_constructor_parse, + duk_bi_date_constructor_utc, + duk_bi_date_prototype_get_shared, + duk_bi_date_prototype_get_timezone_offset, + duk_bi_date_prototype_set_shared, + duk_bi_date_prototype_set_time, + duk_bi_date_prototype_to_json, + duk_bi_date_prototype_tostring_shared, + duk_bi_date_prototype_value_of, + duk_bi_duktape_object_act, + duk_bi_duktape_object_compact, + duk_bi_duktape_object_dec, + duk_bi_duktape_object_enc, + duk_bi_duktape_object_fin, + duk_bi_duktape_object_gc, + duk_bi_duktape_object_info, + duk_bi_error_constructor_shared, + duk_bi_error_prototype_filename_getter, + duk_bi_error_prototype_linenumber_getter, + duk_bi_error_prototype_nop_setter, + duk_bi_error_prototype_stack_getter, + duk_bi_error_prototype_to_string, + duk_bi_function_constructor, + duk_bi_function_prototype, + duk_bi_function_prototype_apply, + duk_bi_function_prototype_bind, + duk_bi_function_prototype_call, + duk_bi_function_prototype_to_string, + duk_bi_global_object_decode_uri, + duk_bi_global_object_decode_uri_component, + duk_bi_global_object_encode_uri, + duk_bi_global_object_encode_uri_component, + duk_bi_global_object_escape, + duk_bi_global_object_eval, + duk_bi_global_object_is_finite, + duk_bi_global_object_is_nan, + duk_bi_global_object_parse_float, + duk_bi_global_object_parse_int, + duk_bi_global_object_print_helper, + duk_bi_global_object_require, + duk_bi_global_object_unescape, + duk_bi_json_object_parse, + duk_bi_json_object_stringify, + duk_bi_logger_constructor, + duk_bi_logger_prototype_fmt, + duk_bi_logger_prototype_log_shared, + duk_bi_logger_prototype_raw, + duk_bi_math_object_max, + duk_bi_math_object_min, + duk_bi_math_object_onearg_shared, + duk_bi_math_object_random, + duk_bi_math_object_twoarg_shared, + duk_bi_nodejs_buffer_byte_length, + duk_bi_nodejs_buffer_concat, + duk_bi_nodejs_buffer_constructor, + duk_bi_nodejs_buffer_copy, + duk_bi_nodejs_buffer_fill, + duk_bi_nodejs_buffer_is_buffer, + duk_bi_nodejs_buffer_is_encoding, + duk_bi_nodejs_buffer_tojson, + duk_bi_nodejs_buffer_tostring, + duk_bi_nodejs_buffer_write, + duk_bi_number_constructor, + duk_bi_number_prototype_to_exponential, + duk_bi_number_prototype_to_fixed, + duk_bi_number_prototype_to_locale_string, + duk_bi_number_prototype_to_precision, + duk_bi_number_prototype_to_string, + duk_bi_number_prototype_value_of, + duk_bi_object_constructor, + duk_bi_object_constructor_create, + duk_bi_object_constructor_define_properties, + duk_bi_object_constructor_define_property, + duk_bi_object_constructor_get_own_property_descriptor, + duk_bi_object_constructor_is_extensible, + duk_bi_object_constructor_is_sealed_frozen_shared, + duk_bi_object_constructor_keys_shared, + duk_bi_object_constructor_prevent_extensions, + duk_bi_object_constructor_seal_freeze_shared, + duk_bi_object_getprototype_shared, + duk_bi_object_prototype_has_own_property, + duk_bi_object_prototype_is_prototype_of, + duk_bi_object_prototype_property_is_enumerable, + duk_bi_object_prototype_to_locale_string, + duk_bi_object_prototype_to_string, + duk_bi_object_prototype_value_of, + duk_bi_object_setprototype_shared, + duk_bi_pointer_constructor, + duk_bi_pointer_prototype_tostring_shared, + duk_bi_proxy_constructor, + duk_bi_regexp_constructor, + duk_bi_regexp_prototype_exec, + duk_bi_regexp_prototype_test, + duk_bi_regexp_prototype_to_string, + duk_bi_string_constructor, + duk_bi_string_constructor_from_char_code, + duk_bi_string_prototype_caseconv_shared, + duk_bi_string_prototype_char_at, + duk_bi_string_prototype_char_code_at, + duk_bi_string_prototype_concat, + duk_bi_string_prototype_indexof_shared, + duk_bi_string_prototype_locale_compare, + duk_bi_string_prototype_match, + duk_bi_string_prototype_replace, + duk_bi_string_prototype_search, + duk_bi_string_prototype_slice, + duk_bi_string_prototype_split, + duk_bi_string_prototype_substr, + duk_bi_string_prototype_substring, + duk_bi_string_prototype_to_string, + duk_bi_string_prototype_trim, + duk_bi_thread_constructor, + duk_bi_thread_current, + duk_bi_thread_resume, + duk_bi_thread_yield, + duk_bi_type_error_thrower, + duk_bi_typedarray_constructor, + duk_bi_typedarray_set, +}; + +DUK_INTERNAL const duk_uint8_t duk_builtins_data[1952] = { +105,195,75,16,121,40,105,51,14,252,104,52,8,131,72,0,115,225,65,165,236,55, +243,6,145,32,210,24,210,182,25,249,35,120,216,99,226,13,78,225,116,177,164, +180,44,192,4,202,52,150,220,24,0,169,70,146,219,123,0,23,40,210,91,110,96, +3,37,26,75,109,172,0,108,163,73,109,177,128,14,148,105,45,181,176,1,242, +144,56,209,32,94,6,167,101,98,80,211,24,1,250,67,72,168,67,232,13,46,128, +47,162,52,164,0,62,80,163,72,128,61,40,107,26,7,37,20,53,200,131,88,0,66, +134,185,16,98,80,215,34,11,96,0,138,26,228,65,76,0,69,67,92,136,37,128,6, +168,107,145,4,48,1,165,13,114,32,118,0,44,161,174,68,12,192,7,148,53,200, +129,88,1,26,134,165,48,130,80,31,255,241,69,224,63,252,0,0,0,0,0,0,46,32, +63,248,0,0,0,0,0,0,47,98,7,140,16,116,194,7,12,48,108,196,6,140,80,100,198, +6,12,112,92,200,5,140,149,192,202,91,204,181,184,204,91,76,213,176,206,90, +204,240,84,208,5,13,9,124,210,43,13,24,64,226,131,205,112,56,216,3,77,152, +48,218,130,205,184,40,220,130,77,216,32,222,129,205,248,24,224,129,78,25, +214,163,226,90,80,145,104,65,37,157,0,150,99,242,89,78,73,100,58,37,140, +236,150,35,194,88,79,73,96,69,37,125,12,122,188,134,62,0,2,165,68,39,255, +255,193,43,67,0,0,80,127,192,58,182,216,80,0,21,59,154,64,0,107,76,200,172, +180,146,176,198,138,187,43,42,204,136,170,181,146,168,214,80,0,26,155,81, +42,77,4,168,180,20,0,6,160,206,74,123,73,64,0,127,255,4,10,153,219,28,198, +163,184,130,140,224,10,43,144,40,141,164,161,183,18,132,222,64,161,127,128, +0,63,225,1,109,74,8,137,71,56,5,4,213,20,3,115,233,249,177,240,80,255,192, +6,120,2,64,127,195,0,173,28,56,20,96,80,128,0,206,192,143,167,64,164,156, +131,2,112,14,125,55,9,4,216,40,19,80,180,77,3,9,51,13,94,153,7,159,76,64, +207,192,0,102,0,103,255,255,242,240,67,73,112,33,168,0,12,180,16,212,0,10, +88,8,106,0,7,43,4,53,0,4,149,4,31,128,0,202,66,15,255,255,194,137,254,0,50, +135,195,224,127,196,2,87,132,17,82,143,20,10,44,80,36,239,196,147,63,146, +119,0,125,49,129,52,152,64,154,128,0,201,96,137,36,131,36,142,17,18,40,82, +77,97,145,33,135,68,130,37,17,247,208,71,159,65,29,125,8,0,12,113,244,32,0, +49,184,176,70,162,16,20,95,240,0,7,252,80,37,120,193,81,196,194,0,3,69,19, +0,81,191,197,140,192,127,239,255,255,255,255,255,255,140,64,0,0,0,0,0,0,0, +1,139,192,127,248,0,0,0,0,0,0,138,192,127,240,0,0,0,0,0,0,139,64,255,240,0, +0,0,0,0,0,0,31,241,128,149,224,0,0,0,0,0,0,0,0,13,71,96,37,25,120,148,86, +16,69,23,73,19,92,36,73,124,129,71,255,0,56,136,233,34,3,223,208,241,192,3, +254,56,18,188,135,255,128,0,0,0,0,0,11,104,228,128,135,18,4,0,6,26,72,16,0, +42,49,32,64,0,225,132,129,0,4,133,146,4,0,21,210,72,16,0,103,65,32,64,1, +220,228,100,162,146,130,20,74,8,72,248,64,2,33,3,225,0,9,131,143,132,0,42, +12,62,16,0,184,40,248,64,3,32,131,225,0,13,129,143,132,0,58,4,62,16,0,248, +8,248,64,4,32,3,225,0,17,127,143,132,0,73,252,62,16,1,55,232,248,64,5,31, +131,225,0,21,125,143,132,0,89,244,62,16,1,119,201,0,31,4,68,123,144,148,0, +97,236,66,80,1,151,169,10,248,0,211,208,133,124,0,109,230,66,254,0,56,242, +33,127,0,29,120,144,207,128,15,60,8,103,192,7,221,228,37,0,32,119,16,148,0, +133,218,66,190,0,68,236,33,95,0,35,117,144,191,128,18,58,136,95,192,9,92, +195,225,0,38,114,144,148,0,156,41,31,224,0,15,249,1,138,144,64,192,2,2,225, +132,221,9,70,112,70,111,198,111,72,0,0,0,0,0,0,0,0,13,198,240,71,19,201,40, +239,64,10,79,248,0,3,254,72,86,209,5,155,36,17,46,185,137,129,109,203,140, +11,78,94,96,13,28,200,1,74,255,0,2,127,202,4,218,43,131,100,130,32,5,47, +252,0,9,255,44,19,104,173,237,146,8,128,20,207,240,0,39,252,192,77,162,183, +54,72,34,0,83,127,192,0,159,243,65,54,138,218,217,32,136,1,78,255,0,2,127, +206,4,218,43,99,100,130,32,5,63,252,0,9,255,60,19,104,173,109,146,8,128,15, +255,242,27,16,16,1,111,194,162,197,21,218,90,240,16,0,154,236,110,237,85, +69,154,208,15,249,139,144,191,190,142,123,218,176,15,253,197,81,217,74,224, +191,154,144,15,246,242,222,197,73,185,67,154,112,16,2,72,126,213,17,11,70, +26,80,15,249,168,39,153,159,206,243,90,48,15,253,168,39,153,159,206,243,82, +104,39,17,158,156,80,0,22,114,113,64,0,153,169,197,0,3,102,40,33,150,156, +80,0,70,82,113,64,1,89,41,197,0,6,100,39,20,0,29,142,156,80,0,134,50,98, +243,21,53,121,136,160,144,0,22,26,120,24,73,197,0,9,96,167,20,0,41,128,156, +80,0,181,250,113,64,3,1,255,254,0,81,20,100,47,145,216,23,255,240,0,11,255, +248,0,3,255,252,81,252,4,12,65,224,0,0,0,0,0,129,167,1,26,144,9,165,0,26, +177,199,197,132,30,147,16,120,86,65,217,80,240,232,164,120,114,80,60,52,39, +32,84,223,192,15,59,30,129,156,115,6,81,160,7,253,40,0,5,81,252,0,1,255,78, +0,84,113,96,128,0,209,69,128,21,87,240,0,7,253,72,1,81,221,66,0,3,69,117,0, +85,159,192,0,31,245,97,10,100,32,0,0,0,0,0,0,0,10,164,130,97,221,191,113,3, +20,146,12,18,200,47,74,30,23,37,15,128,0,143,146,135,192,0,133,169,67,224, +0,98,196,161,240,0,65,90,80,248,0,41,63,255,194,109,65,11,137,191,174,45, +153,98,242,229,191,147,102,8,190,94,92,183,242,65,167,114,12,188,185,111, +228,131,70,29,217,54,105,221,156,0,171,255,128,9,208,68,128,255,174,0,25, +168,194,64,0,130,177,254,0,0,255,176,1,3,120,186,64,12,13,194,233,0,32,54, +139,164,0,196,216,46,144,2,19,88,186,64,12,141,66,233,0,34,52,139,164,0, +140,208,46,144,2,67,56,203,64,12,12,195,45,0,32,50,140,180,0,196,200,50, +208,2,19,24,203,64,12,140,67,45,0,34,48,140,180,0,140,192,50,208,2,64,127, +255,128,21,38,73,7,1,132,128,0,133,105,252,19,140,3,255,0,0,0,0,0,0,0,25, +127,102,0,1,91,127,4,227,0,255,192,0,0,0,0,0,0,6,95,218,128,0,87,31,193,56, +192,63,240,0,0,0,0,0,0,1,151,246,224,0,21,215,240,78,48,16,0,0,0,0,0,0,0,0, +101,253,200,0,5,121,252,19,140,4,0,0,0,0,0,0,0,0,25,127,118,0,1,95,127,4, +227,1,0,64,0,0,0,0,0,0,6,95,222,128,0,88,31,193,56,192,64,16,0,0,0,0,0,0,1, +151,247,224,0,22,23,240,78,48,16,4,0,0,0,0,0,0,0,101,254,8,0,5,137,252,19, +140,4,2,0,0,0,0,0,0,0,25,127,134,0,1,99,127,0,89,218,146,20,74,228,80,171, +17,64,162,132,248,162,64,0,193,255,138,5,137,161,116,38,69,210,0,32,152,23, +72,0,10,92,93,32,1,41,97,116,128,8,165,69,210,0,50,148,23,72,0,18,76,93,32, +1,73,33,116,128,9,36,69,210,0,52,144,23,72,0,26,60,93,32,1,104,225,116,128, +2,35,69,210,0,24,140,23,104,0,42,44,93,160,1,168,161,118,128,10,162,69,218, +0,58,136,25,98,28,101,160,2,8,97,150,128,0,161,70,90,0,18,132,25,104,0,138, +12,101,160,3,40,33,150,128,1,32,70,90,0,20,128,25,104,0,145,252,101,160,3, +71,225,150,128,1,159,70,90,0,22,124,25,104,0,33,236,101,160,1,135,161,152, +128,2,158,70,98,0,26,120,25,136,0,169,220,102,32,3,180,117,150,57,214,0, +157,85,98,112,80,137,241,66,128,0,166,213,33,53,24,66,121,106,0, +}; +#ifdef DUK_USE_BUILTIN_INITJS +DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = { +40,102,117,110,99,116,105,111,110,40,100,44,97,41,123,102,117,110,99,116, +105,111,110,32,98,40,97,44,98,44,99,41,123,79,98,106,101,99,116,46,100,101, +102,105,110,101,80,114,111,112,101,114,116,121,40,97,44,98,44,123,118,97, +108,117,101,58,99,44,119,114,105,116,97,98,108,101,58,33,48,44,101,110,117, +109,101,114,97,98,108,101,58,33,49,44,99,111,110,102,105,103,117,114,97,98, +108,101,58,33,48,125,41,125,98,40,97,46,76,111,103,103,101,114,44,34,99, +108,111,103,34,44,110,101,119,32,97,46,76,111,103,103,101,114,40,34,67,34, +41,41,59,98,40,97,44,34,109,111,100,76,111,97,100,101,100,34,44,123,125,41, +125,41,40,116,104,105,115,44,68,117,107,116,97,112,101,41,59,10,0, +}; +#endif /* DUK_USE_BUILTIN_INITJS */ +#elif defined(DUK_USE_DOUBLE_ME) +DUK_INTERNAL const duk_uint8_t duk_strings_data[2624] = { +55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,50,11,164,109, +77,215,5,61,35,106,206,149,110,4,254,219,237,58,8,196,24,103,74,183,2,127, +103,246,93,4,98,12,47,180,67,103,246,127,101,208,70,32,194,186,134,207,236, +254,203,160,140,65,133,246,136,108,254,199,237,186,8,196,24,87,80,217,253, +143,219,116,17,136,49,30,209,13,159,220,116,75,3,30,65,244,17,136,48,174, +209,13,159,220,116,17,136,48,158,161,179,251,142,130,49,6,17,209,130,96, +237,80,75,47,160,140,65,142,134,133,41,34,110,134,133,41,34,3,25,110,8,22, +158,130,38,163,8,217,200,158,76,156,210,117,128,153,203,210,70,46,137,187, +18,27,164,187,201,209,130,100,55,91,70,4,145,63,66,231,44,128,105,187,41, +197,13,49,122,8,196,24,71,75,70,138,104,115,77,215,5,36,20,201,214,209,107, +79,104,209,144,168,105,6,207,251,209,104,209,125,212,227,66,127,235,191, +239,232,180,90,52,95,69,247,83,141,9,255,174,255,191,162,211,80,210,253,23, +221,78,52,39,254,183,254,254,139,72,105,126,139,238,167,26,19,255,91,255, +127,69,166,129,191,69,247,83,141,9,255,175,255,191,162,213,26,50,23,232, +190,234,113,161,63,245,115,119,86,227,118,83,138,26,98,9,110,48,86,22,148, +160,152,22,82,70,46,137,44,8,180,163,32,104,98,206,32,17,7,16,88,101,100, +206,42,70,36,108,205,18,74,140,33,196,230,60,2,152,146,33,38,230,8,36,79, +182,251,65,156,151,24,200,33,145,162,25,80,209,24,67,0,166,68,52,174,61,73, +25,33,205,25,27,84,177,195,234,220,1,144,105,99,135,217,16,17,17,208,72, +199,179,60,93,100,146,49,232,162,64,76,135,19,152,244,44,136,223,98,67,4, +18,33,247,217,158,36,0,209,190,156,13,26,201,21,111,165,67,64,180,100,145, +62,250,32,45,100,33,55,214,1,229,223,65,19,72,187,236,206,137,35,125,120, +190,201,104,105,15,190,201,212,136,136,125,246,160,137,27,83,239,171,37, +200,218,159,125,168,34,192,61,27,233,93,22,1,114,78,250,28,76,130,112,200, +93,245,164,188,207,190,204,17,49,38,109,246,160,93,8,119,185,13,153,34,173, +246,113,0,136,48,76,10,90,26,78,182,140,9,34,130,161,100,235,64,194,9,226, +44,166,1,41,221,153,226,235,118,120,121,58,72,197,209,63,71,69,76,15,34, +164,73,244,171,112,39,246,223,104,169,18,125,42,220,9,253,159,217,38,68, +159,104,134,207,236,254,201,18,36,250,134,207,236,254,201,50,36,251,68,54, +127,99,246,200,145,39,212,54,127,99,246,200,145,39,218,33,179,251,131,200, +147,234,27,63,184,81,137,62,149,110,4,254,219,237,20,98,79,165,91,129,63, +179,251,36,152,147,237,16,217,253,159,217,32,196,159,80,217,253,159,217,36, +196,159,104,134,207,236,126,217,6,36,250,134,207,236,126,217,6,36,251,68, +54,127,112,115,18,125,67,103,247,8,149,2,8,196,24,143,131,137,146,90,121, +35,162,44,140,35,102,160,226,100,235,138,89,18,102,13,10,82,68,200,151,106, +130,88,131,4,192,73,225,228,85,162,137,147,168,108,252,18,42,209,68,201, +212,54,126,89,23,104,162,100,245,17,230,207,193,34,237,20,76,158,162,60, +217,249,100,109,162,137,147,163,117,2,178,120,36,109,162,137,147,163,117,2, +178,121,100,101,162,137,147,165,91,129,63,4,140,180,81,50,116,171,112,39, +229,145,150,138,38,78,161,179,251,63,178,240,72,203,69,19,39,80,217,253, +159,217,121,100,109,162,137,147,212,71,155,63,179,251,47,4,141,180,81,50, +122,136,243,103,246,127,101,229,145,150,138,38,78,161,179,251,31,182,240, +72,203,69,19,39,80,217,253,143,219,121,100,109,162,137,147,212,71,155,63, +177,251,111,4,141,180,81,50,122,136,243,103,246,63,109,229,145,54,138,38, +78,161,179,251,133,90,40,153,61,68,121,179,251,132,196,128,31,80,217,248, +36,76,72,1,245,13,159,150,69,68,128,31,168,143,54,126,9,21,18,0,126,162,60, +217,249,100,100,72,1,244,110,160,86,79,4,140,137,0,62,141,212,10,201,229, +145,113,32,7,210,173,192,159,130,69,196,128,31,74,183,2,126,89,23,18,0,125, +67,103,246,127,101,224,145,113,32,7,212,54,127,103,246,94,89,25,18,0,126, +162,60,217,253,159,217,120,36,100,72,1,250,136,243,103,246,127,101,229,145, +113,32,7,212,54,127,99,246,222,9,23,18,0,125,67,103,246,63,109,229,145,145, +32,7,234,35,205,159,216,253,183,130,70,68,128,31,168,143,54,127,99,246,222, +89,17,18,0,125,67,103,247,9,137,0,63,81,30,108,254,224,130,115,240,98,66, +128,92,136,84,45,101,180,81,50,28,78,99,193,18,40,56,153,58,178,52,211,58, +17,46,134,133,41,34,164,75,164,104,156,52,52,199,37,222,232,206,66,64,207, +18,66,136,137,19,173,62,46,155,181,167,72,147,235,226,233,186,120,121,58, +226,157,214,111,84,76,73,36,109,24,72,130,100,112,200,178,76,157,124,92, +242,70,120,25,193,34,245,241,117,240,97,1,107,33,25,212,54,160,90,7,244,29, +24,38,66,254,223,215,125,119,215,126,232,190,43,226,67,244,1,250,193,125, +111,216,11,234,254,192,63,96,159,173,234,26,84,53,19,194,126,175,168,105, +80,212,79,8,234,26,84,53,19,193,156,20,144,83,52,167,20,52,198,109,24,18, +68,225,115,150,64,53,52,104,200,84,52,131,76,167,20,52,200,46,7,48,52,146, +132,102,57,33,165,139,168,209,154,32,104,220,193,189,214,27,16,209,176,23, +26,220,98,149,110,116,70,75,188,98,116,136,34,33,101,4,192,223,178,32,38,6, +144,18,67,72,1,58,67,0,100,95,74,17,159,217,31,210,132,103,246,58,251,33, +121,232,55,150,227,125,143,216,16,190,91,141,246,68,31,150,223,178,39,150, +223,177,251,0,244,135,97,37,32,24,132,104,24,66,161,175,164,202,134,140, +151,39,212,125,255,221,125,74,86,9,79,168,104,201,116,178,139,154,22,134, +145,72,51,93,18,116,64,145,13,39,82,34,33,38,73,76,132,185,4,185,187,198, +100,229,233,197,13,49,228,73,247,4,4,78,98,79,184,32,34,105,187,201,147, +154,185,187,200,147,165,233,197,13,50,230,239,82,98,151,167,20,52,206,145, +39,234,76,69,245,22,190,224,128,138,228,73,244,180,90,251,130,2,43,145,39, +234,76,76,243,155,51,162,68,159,88,230,204,234,145,39,234,76,67,240,38,67, +200,147,232,193,50,46,68,159,169,49,31,206,164,100,137,18,125,59,169,25,54, +68,159,169,49,51,200,109,38,73,42,68,159,88,134,210,100,147,100,73,250,147, +20,188,65,57,163,146,164,73,246,68,19,154,57,74,68,159,169,49,51,200,90, +209,34,9,205,28,159,34,79,172,66,214,137,16,78,104,228,121,18,125,154,24, +72,152,147,236,208,194,101,205,39,92,82,200,147,145,137,63,82,98,103,144, +181,162,68,19,154,57,60,196,159,88,133,173,18,32,156,209,201,166,36,253,73, +138,94,32,156,209,201,70,36,251,34,9,205,28,154,98,79,212,152,153,228,54, +147,36,148,98,79,172,67,105,50,73,102,36,253,73,136,254,117,35,36,24,147, +233,221,72,201,38,36,253,73,136,126,6,12,98,79,163,6,20,98,79,212,152,135, +224,76,135,49,39,209,130,100,89,137,63,82,98,103,156,217,157,6,36,250,199, +54,103,113,137,63,82,98,47,168,181,247,4,4,86,98,79,165,162,215,220,16,17, +57,137,62,205,12,36,166,238,173,194,2,201,217,161,132,236,167,20,52,210, +155,186,183,8,11,39,70,9,147,178,156,80,211,50,110,236,208,194,118,83,138, +26,102,77,221,24,38,78,202,113,67,76,54,186,195,245,38,34,188,17,145,23,55, +117,241,32,145,36,57,173,155,186,75,189,205,35,102,128,44,243,119,74,139, +144,113,243,221,36,77,21,38,144,210,161,168,158,35,230,144,192,154,42,77, +33,165,67,81,60,15,173,7,90,159,49,13,213,64,186,17,62,96,47,170,129,116, +33,165,64,202,113,36,226,134,70,110,234,220,32,44,157,163,222,72,244,64, +145,23,55,118,143,121,35,209,2,68,140,221,213,184,64,89,58,183,88,145,232, +129,34,46,110,234,221,98,71,162,4,136,153,80,50,156,80,211,22,79,90,38,105, +16,17,17,207,18,61,96,17,10,192,76,71,106,220,32,44,157,19,152,240,68,138, +17,193,30,137,195,39,65,51,8,224,143,65,54,22,46,103,68,112,71,162,112,200, +184,144,116,17,59,20,24,243,52,72,58,8,134,42,23,50,68,108,3,206,87,71,164, +0,142,73,57,132,41,42,72,225,107,4,167,212,52,100,191,92,83,161,163,37,250, +226,158,141,145,208,89,154,79,90,4,66,73,209,153,100,180,8,133,145,208,89, +158,36,169,35,34,17,244,145,198,247,60,137,114,26,97,57,162,4,206,137,116, +17,136,48,144,68,212,97,27,57,24,64,90,201,18,5,13,25,4,5,172,160,123,215, +138,62,46,121,35,60,117,18,233,27,70,18,32,10,200,212,75,175,139,166,233, +225,228,235,138,227,130,93,117,155,215,197,207,36,103,131,212,11,161,58, +226,186,110,234,220,32,44,157,148,226,134,153,19,119,101,56,161,166,88,156, +217,78,52,20,221,17,200,147,25,137,53,17,180,97,34,0,172,140,19,154,84,26, +145,0,86,68,90,40,152,2,178,22,160,93,8,69,19,18,98,37,210,94,100,108,144, +21,145,8,151,75,23,100,141,66,37,217,16,11,32,226,248,146,164,108,250,75, +204,141,146,28,217,24,177,33,50,66,72,128,92,6,66,161,164,235,226,231,146, +51,65,36,225,144,168,105,58,248,185,228,140,240,97,68,128,153,38,98,79,174, +179,122,248,185,228,140,241,214,129,132,150,12,73,245,214,111,95,23,60,145, +158,58,50,72,81,67,230,232,184,196,159,95,23,77,211,195,201,215,21,47,139, +166,233,225,228,50,200,211,76,229,2,201,25,149,241,67,102,138,52,146,16,30, +67,18,66,3,201,34,52,78,25,61,72,160,94,115,30,230,145,179,73,26,39,12,158, +164,81,33,144,78,25,61,72,160,94,115,30,230,145,179,72,200,39,12,158,164, +80,132,75,165,67,81,50,21,18,235,65,214,169,224,140,137,210,173,192,154,30, +8,200,157,67,102,66,84,11,71,169,20,19,209,139,162,158,207,15,39,73,24,186, +43,236,176,217,130,253,36,98,232,187,177,33,73,18,52,68,233,35,23,69,93, +136,26,98,116,145,139,162,158,146,160,95,73,24,186,37,12,72,5,16,64,145,10, +32,76,71,64,156,217,161,180,34,6,64,208,198,36,78,50,20,20,92,204,50,44, +147,32,134,226,17,114,33,202,134,129,107,192,202,232,160,180,104,166,135, +52,72,40,144,213,33,178,152,26,34,56,163,105,44,104,146,116,139,77,43,34, +98,57,38,116,72,179,60,93,97,206,56,52,240,242,56,163,168,34,74,185,3,45, +142,133,144,150,68,206,81,44,18,145,68,230,202,100,35,104,195,18,239,116, +102,114,94,100,104,228,100,49,238,140,203,42,60,145,35,104,181,146,113,161, +10,80,46,68,82,24,245,145,132,108,228,148,54,100,137,64,34,13,100,153,222, +1,40,6,33,223,20,84,19,34,95,23,76,130,153,6,103,208,43,64,141,41,130,104, +17,112,130,44,96, +}; + +/* to convert a heap stridx to a token number, subtract + * DUK_STRIDX_START_RESERVED and add DUK_TOK_START_RESERVED. + */ + +/* native functions: 147 */ +DUK_INTERNAL const duk_c_function duk_bi_native_functions[147] = { + duk_bi_array_constructor, + duk_bi_array_constructor_is_array, + duk_bi_array_prototype_concat, + duk_bi_array_prototype_indexof_shared, + duk_bi_array_prototype_iter_shared, + duk_bi_array_prototype_join_shared, + duk_bi_array_prototype_pop, + duk_bi_array_prototype_push, + duk_bi_array_prototype_reduce_shared, + duk_bi_array_prototype_reverse, + duk_bi_array_prototype_shift, + duk_bi_array_prototype_slice, + duk_bi_array_prototype_sort, + duk_bi_array_prototype_splice, + duk_bi_array_prototype_to_string, + duk_bi_array_prototype_unshift, + duk_bi_arraybuffer_constructor, + duk_bi_arraybuffer_isview, + duk_bi_boolean_constructor, + duk_bi_boolean_prototype_tostring_shared, + duk_bi_buffer_compare_shared, + duk_bi_buffer_constructor, + duk_bi_buffer_prototype_tostring_shared, + duk_bi_buffer_readfield, + duk_bi_buffer_slice_shared, + duk_bi_buffer_writefield, + duk_bi_dataview_constructor, + duk_bi_date_constructor, + duk_bi_date_constructor_now, + duk_bi_date_constructor_parse, + duk_bi_date_constructor_utc, + duk_bi_date_prototype_get_shared, + duk_bi_date_prototype_get_timezone_offset, + duk_bi_date_prototype_set_shared, + duk_bi_date_prototype_set_time, + duk_bi_date_prototype_to_json, + duk_bi_date_prototype_tostring_shared, + duk_bi_date_prototype_value_of, + duk_bi_duktape_object_act, + duk_bi_duktape_object_compact, + duk_bi_duktape_object_dec, + duk_bi_duktape_object_enc, + duk_bi_duktape_object_fin, + duk_bi_duktape_object_gc, + duk_bi_duktape_object_info, + duk_bi_error_constructor_shared, + duk_bi_error_prototype_filename_getter, + duk_bi_error_prototype_linenumber_getter, + duk_bi_error_prototype_nop_setter, + duk_bi_error_prototype_stack_getter, + duk_bi_error_prototype_to_string, + duk_bi_function_constructor, + duk_bi_function_prototype, + duk_bi_function_prototype_apply, + duk_bi_function_prototype_bind, + duk_bi_function_prototype_call, + duk_bi_function_prototype_to_string, + duk_bi_global_object_decode_uri, + duk_bi_global_object_decode_uri_component, + duk_bi_global_object_encode_uri, + duk_bi_global_object_encode_uri_component, + duk_bi_global_object_escape, + duk_bi_global_object_eval, + duk_bi_global_object_is_finite, + duk_bi_global_object_is_nan, + duk_bi_global_object_parse_float, + duk_bi_global_object_parse_int, + duk_bi_global_object_print_helper, + duk_bi_global_object_require, + duk_bi_global_object_unescape, + duk_bi_json_object_parse, + duk_bi_json_object_stringify, + duk_bi_logger_constructor, + duk_bi_logger_prototype_fmt, + duk_bi_logger_prototype_log_shared, + duk_bi_logger_prototype_raw, + duk_bi_math_object_max, + duk_bi_math_object_min, + duk_bi_math_object_onearg_shared, + duk_bi_math_object_random, + duk_bi_math_object_twoarg_shared, + duk_bi_nodejs_buffer_byte_length, + duk_bi_nodejs_buffer_concat, + duk_bi_nodejs_buffer_constructor, + duk_bi_nodejs_buffer_copy, + duk_bi_nodejs_buffer_fill, + duk_bi_nodejs_buffer_is_buffer, + duk_bi_nodejs_buffer_is_encoding, + duk_bi_nodejs_buffer_tojson, + duk_bi_nodejs_buffer_tostring, + duk_bi_nodejs_buffer_write, + duk_bi_number_constructor, + duk_bi_number_prototype_to_exponential, + duk_bi_number_prototype_to_fixed, + duk_bi_number_prototype_to_locale_string, + duk_bi_number_prototype_to_precision, + duk_bi_number_prototype_to_string, + duk_bi_number_prototype_value_of, + duk_bi_object_constructor, + duk_bi_object_constructor_create, + duk_bi_object_constructor_define_properties, + duk_bi_object_constructor_define_property, + duk_bi_object_constructor_get_own_property_descriptor, + duk_bi_object_constructor_is_extensible, + duk_bi_object_constructor_is_sealed_frozen_shared, + duk_bi_object_constructor_keys_shared, + duk_bi_object_constructor_prevent_extensions, + duk_bi_object_constructor_seal_freeze_shared, + duk_bi_object_getprototype_shared, + duk_bi_object_prototype_has_own_property, + duk_bi_object_prototype_is_prototype_of, + duk_bi_object_prototype_property_is_enumerable, + duk_bi_object_prototype_to_locale_string, + duk_bi_object_prototype_to_string, + duk_bi_object_prototype_value_of, + duk_bi_object_setprototype_shared, + duk_bi_pointer_constructor, + duk_bi_pointer_prototype_tostring_shared, + duk_bi_proxy_constructor, + duk_bi_regexp_constructor, + duk_bi_regexp_prototype_exec, + duk_bi_regexp_prototype_test, + duk_bi_regexp_prototype_to_string, + duk_bi_string_constructor, + duk_bi_string_constructor_from_char_code, + duk_bi_string_prototype_caseconv_shared, + duk_bi_string_prototype_char_at, + duk_bi_string_prototype_char_code_at, + duk_bi_string_prototype_concat, + duk_bi_string_prototype_indexof_shared, + duk_bi_string_prototype_locale_compare, + duk_bi_string_prototype_match, + duk_bi_string_prototype_replace, + duk_bi_string_prototype_search, + duk_bi_string_prototype_slice, + duk_bi_string_prototype_split, + duk_bi_string_prototype_substr, + duk_bi_string_prototype_substring, + duk_bi_string_prototype_to_string, + duk_bi_string_prototype_trim, + duk_bi_thread_constructor, + duk_bi_thread_current, + duk_bi_thread_resume, + duk_bi_thread_yield, + duk_bi_type_error_thrower, + duk_bi_typedarray_constructor, + duk_bi_typedarray_set, +}; + +DUK_INTERNAL const duk_uint8_t duk_builtins_data[1952] = { +105,195,75,16,121,40,105,51,14,252,104,52,8,131,72,0,115,225,65,165,236,55, +243,6,145,32,210,24,210,182,25,249,35,120,216,99,226,13,78,225,116,177,164, +180,44,192,4,202,52,150,220,24,0,169,70,146,219,123,0,23,40,210,91,110,96, +3,37,26,75,109,172,0,108,163,73,109,177,128,14,148,105,45,181,176,1,242, +144,56,209,32,94,6,167,101,98,80,211,24,1,250,67,72,168,67,232,13,46,128, +47,162,52,164,0,62,80,163,72,128,61,40,107,26,7,37,20,53,200,131,88,0,66, +134,185,16,98,80,215,34,11,96,0,138,26,228,65,76,0,69,67,92,136,37,128,6, +168,107,145,4,48,1,165,13,114,32,118,0,44,161,174,68,12,192,7,148,53,200, +129,88,1,26,134,165,48,130,80,31,255,241,69,224,0,0,124,63,128,0,0,0,46,32, +0,0,120,63,128,0,0,0,47,98,7,140,16,116,194,7,12,48,108,196,6,140,80,100, +198,6,12,112,92,200,5,140,149,192,202,91,204,181,184,204,91,76,213,176,206, +90,204,240,84,208,5,13,9,124,210,43,13,24,64,226,131,205,112,56,216,3,77, +152,48,218,130,205,184,40,220,130,77,216,32,222,129,205,248,24,224,129,78, +25,214,163,226,90,80,145,104,65,37,157,0,150,99,242,89,78,73,100,58,37,140, +236,150,35,194,88,79,73,96,69,37,125,12,122,188,134,62,0,2,165,68,39,255, +255,193,43,67,0,0,80,127,192,58,182,216,80,0,21,59,154,64,0,107,76,200,172, +180,146,176,198,138,187,43,42,204,136,170,181,146,168,214,80,0,26,155,81, +42,77,4,168,180,20,0,6,160,206,74,123,73,64,0,127,255,4,10,153,219,28,198, +163,184,130,140,224,10,43,144,40,141,164,161,183,18,132,222,64,161,127,128, +0,63,225,1,109,74,8,137,71,56,5,4,213,20,3,115,233,249,177,240,80,255,192, +6,120,2,64,127,195,0,173,28,56,20,96,80,128,0,206,192,143,167,64,164,156, +131,2,112,14,125,55,9,4,216,40,19,80,180,77,3,9,51,13,94,153,7,159,76,64, +207,192,0,102,0,103,255,255,242,240,67,73,112,33,168,0,12,180,16,212,0,10, +88,8,106,0,7,43,4,53,0,4,149,4,31,128,0,202,66,15,255,255,194,137,254,0,50, +135,195,224,127,196,2,87,132,17,82,143,20,10,44,80,36,239,196,147,63,146, +119,0,125,49,129,52,152,64,154,128,0,201,96,137,36,131,36,142,17,18,40,82, +77,97,145,33,135,68,130,37,17,247,208,71,159,65,29,125,8,0,12,113,244,32,0, +49,184,176,70,162,16,20,95,240,0,7,252,80,37,120,193,81,196,194,0,3,69,19, +0,81,191,197,140,192,255,255,239,127,255,255,255,255,140,64,0,0,0,0,1,0,0, +0,139,192,0,0,248,127,0,0,0,0,138,192,0,0,240,127,0,0,0,0,139,64,0,0,240, +255,0,0,0,0,0,31,241,128,149,224,0,0,0,0,0,0,0,0,13,71,96,37,25,120,148,86, +16,69,23,73,19,92,36,73,124,129,71,255,0,56,136,233,34,3,223,208,241,192,3, +254,56,18,188,128,0,15,135,240,0,0,0,11,104,228,128,135,18,4,0,6,26,72,16, +0,42,49,32,64,0,225,132,129,0,4,133,146,4,0,21,210,72,16,0,103,65,32,64,1, +220,228,100,162,146,130,20,74,8,72,248,64,2,33,3,225,0,9,131,143,132,0,42, +12,62,16,0,184,40,248,64,3,32,131,225,0,13,129,143,132,0,58,4,62,16,0,248, +8,248,64,4,32,3,225,0,17,127,143,132,0,73,252,62,16,1,55,232,248,64,5,31, +131,225,0,21,125,143,132,0,89,244,62,16,1,119,201,0,31,4,68,123,144,148,0, +97,236,66,80,1,151,169,10,248,0,211,208,133,124,0,109,230,66,254,0,56,242, +33,127,0,29,120,144,207,128,15,60,8,103,192,7,221,228,37,0,32,119,16,148,0, +133,218,66,190,0,68,236,33,95,0,35,117,144,191,128,18,58,136,95,192,9,92, +195,225,0,38,114,144,148,0,156,41,31,224,0,15,249,1,138,144,64,192,2,2,225, +132,221,9,70,112,70,111,198,111,72,0,0,0,0,0,0,0,0,13,198,240,71,19,201,40, +239,64,10,79,248,0,3,254,72,86,209,5,155,36,17,46,185,137,129,109,203,140, +11,78,94,96,13,28,200,1,74,255,0,2,127,202,4,218,43,131,100,130,32,5,47, +252,0,9,255,44,19,104,173,237,146,8,128,20,207,240,0,39,252,192,77,162,183, +54,72,34,0,83,127,192,0,159,243,65,54,138,218,217,32,136,1,78,255,0,2,127, +206,4,218,43,99,100,130,32,5,63,252,0,9,255,60,19,104,173,109,146,8,128,15, +255,242,27,16,2,175,193,80,26,85,197,34,218,240,44,90,192,144,5,149,109, +110,218,208,16,139,185,143,251,206,126,191,154,176,17,197,125,207,255,160, +138,217,90,144,30,242,246,207,195,185,73,133,90,112,62,200,66,80,6,11,81, +21,26,80,39,168,57,143,243,78,223,217,154,48,39,168,61,143,243,78,223,217, +146,104,39,17,158,156,80,0,22,114,113,64,0,153,169,197,0,3,102,40,33,150, +156,80,0,70,82,113,64,1,89,41,197,0,6,100,39,20,0,29,142,156,80,0,134,50, +98,243,21,53,121,136,160,144,0,22,26,120,24,73,197,0,9,96,167,20,0,41,128, +156,80,0,181,250,113,64,3,1,255,254,0,81,20,100,47,145,216,23,255,240,0,11, +255,248,0,3,255,252,81,252,0,1,236,68,0,0,0,0,0,129,167,1,26,144,9,165,0, +26,177,199,197,132,30,147,16,120,86,65,217,80,240,232,164,120,114,80,60,52, +39,32,84,223,192,15,59,30,129,156,115,6,81,160,7,253,40,0,5,81,252,0,1,255, +78,0,84,113,96,128,0,209,69,128,21,87,240,0,7,253,72,1,81,221,66,0,3,69, +117,0,85,159,192,0,31,245,97,10,100,0,0,0,32,0,0,0,0,10,164,130,97,221,191, +113,3,20,146,12,18,200,47,74,30,23,37,15,128,0,143,146,135,192,0,133,169, +67,224,0,98,196,161,240,0,65,90,80,248,0,41,63,255,194,109,65,11,137,191, +174,45,153,98,242,229,191,147,102,8,190,94,92,183,242,65,167,114,12,188, +185,111,228,131,70,29,217,54,105,221,156,0,171,255,128,9,208,68,128,255, +174,0,25,168,194,64,0,130,177,254,0,0,255,176,1,3,120,186,64,12,13,194,233, +0,32,54,139,164,0,196,216,46,144,2,19,88,186,64,12,141,66,233,0,34,52,139, +164,0,140,208,46,144,2,67,56,203,64,12,12,195,45,0,32,50,140,180,0,196,200, +50,208,2,19,24,203,64,12,140,67,45,0,34,48,140,180,0,140,192,50,208,2,64, +127,255,128,21,38,73,7,1,132,128,0,133,105,252,19,140,0,0,15,3,240,0,0,0,0, +25,127,102,0,1,91,127,4,227,0,0,3,192,252,0,0,0,0,6,95,218,128,0,87,31,193, +56,192,0,0,240,63,0,0,0,0,1,151,246,224,0,21,215,240,78,48,0,0,0,16,0,0,0, +0,0,101,253,200,0,5,121,252,19,140,0,0,0,4,0,0,0,0,0,25,127,118,0,1,95,127, +4,227,0,0,0,65,0,0,0,0,0,6,95,222,128,0,88,31,193,56,192,0,0,16,64,0,0,0,0, +1,151,247,224,0,22,23,240,78,48,0,0,4,16,0,0,0,0,0,101,254,8,0,5,137,252, +19,140,0,0,2,4,0,0,0,0,0,25,127,134,0,1,99,127,0,89,218,146,20,74,228,80, +171,17,64,162,132,248,162,64,0,193,255,138,5,137,161,116,38,69,210,0,32, +152,23,72,0,10,92,93,32,1,41,97,116,128,8,165,69,210,0,50,148,23,72,0,18, +76,93,32,1,73,33,116,128,9,36,69,210,0,52,144,23,72,0,26,60,93,32,1,104, +225,116,128,2,35,69,210,0,24,140,23,104,0,42,44,93,160,1,168,161,118,128, +10,162,69,218,0,58,136,25,98,28,101,160,2,8,97,150,128,0,161,70,90,0,18, +132,25,104,0,138,12,101,160,3,40,33,150,128,1,32,70,90,0,20,128,25,104,0, +145,252,101,160,3,71,225,150,128,1,159,70,90,0,22,124,25,104,0,33,236,101, +160,1,135,161,152,128,2,158,70,98,0,26,120,25,136,0,169,220,102,32,3,180, +117,150,57,214,0,157,85,98,112,80,137,241,66,128,0,166,213,33,53,24,66,121, +106,0, +}; +#ifdef DUK_USE_BUILTIN_INITJS +DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = { +40,102,117,110,99,116,105,111,110,40,100,44,97,41,123,102,117,110,99,116, +105,111,110,32,98,40,97,44,98,44,99,41,123,79,98,106,101,99,116,46,100,101, +102,105,110,101,80,114,111,112,101,114,116,121,40,97,44,98,44,123,118,97, +108,117,101,58,99,44,119,114,105,116,97,98,108,101,58,33,48,44,101,110,117, +109,101,114,97,98,108,101,58,33,49,44,99,111,110,102,105,103,117,114,97,98, +108,101,58,33,48,125,41,125,98,40,97,46,76,111,103,103,101,114,44,34,99, +108,111,103,34,44,110,101,119,32,97,46,76,111,103,103,101,114,40,34,67,34, +41,41,59,98,40,97,44,34,109,111,100,76,111,97,100,101,100,34,44,123,125,41, +125,41,40,116,104,105,115,44,68,117,107,116,97,112,101,41,59,10,0, +}; +#endif /* DUK_USE_BUILTIN_INITJS */ +#else +#error invalid endianness defines +#endif +#line 1 "duk_error_macros.c" +/* + * Error, fatal, and panic handling. + */ + +/* include removed: duk_internal.h */ + +#define DUK__ERRFMT_BUFSIZE 256 /* size for formatting buffers */ + +#ifdef DUK_USE_VERBOSE_ERRORS + +#ifdef DUK_USE_VARIADIC_MACROS +DUK_INTERNAL void duk_err_handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...) { + va_list ap; + char msg[DUK__ERRFMT_BUFSIZE]; + va_start(ap, fmt); + (void) DUK_VSNPRINTF(msg, sizeof(msg), fmt, ap); + msg[sizeof(msg) - 1] = (char) 0; + duk_err_create_and_throw(thr, code, msg, filename, line); + va_end(ap); /* dead code, but ensures portability (see Linux man page notes) */ +} +#else /* DUK_USE_VARIADIC_MACROS */ +DUK_INTERNAL const char *duk_err_file_stash = NULL; +DUK_INTERNAL duk_int_t duk_err_line_stash = 0; + +DUK_NORETURN(DUK_LOCAL_DECL void duk__handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, va_list ap)); + +DUK_LOCAL void duk__handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, va_list ap) { + char msg[DUK__ERRFMT_BUFSIZE]; + (void) DUK_VSNPRINTF(msg, sizeof(msg), fmt, ap); + msg[sizeof(msg) - 1] = (char) 0; + duk_err_create_and_throw(thr, code, msg, filename, line); +} + +DUK_INTERNAL void duk_err_handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...) { + va_list ap; + va_start(ap, fmt); + duk__handle_error(filename, line, thr, code, fmt, ap); + va_end(ap); /* dead code */ +} + +DUK_INTERNAL void duk_err_handle_error_stash(duk_hthread *thr, duk_errcode_t code, const char *fmt, ...) { + va_list ap; + va_start(ap, fmt); + duk__handle_error(duk_err_file_stash, duk_err_line_stash, thr, code, fmt, ap); + va_end(ap); /* dead code */ +} +#endif /* DUK_USE_VARIADIC_MACROS */ + +#else /* DUK_USE_VERBOSE_ERRORS */ + +#ifdef DUK_USE_VARIADIC_MACROS +DUK_INTERNAL void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code) { + duk_err_create_and_throw(thr, code); +} + +#else /* DUK_USE_VARIADIC_MACROS */ +DUK_INTERNAL void duk_err_handle_error_nonverbose1(duk_hthread *thr, duk_errcode_t code, const char *fmt, ...) { + DUK_UNREF(fmt); + duk_err_create_and_throw(thr, code); +} + +DUK_INTERNAL void duk_err_handle_error_nonverbose2(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...) { + DUK_UNREF(filename); + DUK_UNREF(line); + DUK_UNREF(fmt); + duk_err_create_and_throw(thr, code); +} +#endif /* DUK_USE_VARIADIC_MACROS */ + +#endif /* DUK_USE_VERBOSE_ERRORS */ + +/* + * Default fatal error handler + */ + +DUK_INTERNAL void duk_default_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg) { + DUK_UNREF(ctx); +#ifdef DUK_USE_FILE_IO + DUK_FPRINTF(DUK_STDERR, "FATAL %ld: %s\n", (long) code, (const char *) (msg ? msg : "null")); + DUK_FFLUSH(DUK_STDERR); +#else + /* omit print */ +#endif + DUK_D(DUK_DPRINT("default fatal handler called, code %ld -> calling DUK_PANIC()", (long) code)); + DUK_PANIC(code, msg); + DUK_UNREACHABLE(); +} + +/* + * Default panic handler + */ + +#if !defined(DUK_USE_PANIC_HANDLER) +DUK_INTERNAL void duk_default_panic_handler(duk_errcode_t code, const char *msg) { +#ifdef DUK_USE_FILE_IO + DUK_FPRINTF(DUK_STDERR, "PANIC %ld: %s (" +#if defined(DUK_USE_PANIC_ABORT) + "calling abort" +#elif defined(DUK_USE_PANIC_EXIT) + "calling exit" +#elif defined(DUK_USE_PANIC_SEGFAULT) + "segfaulting on purpose" +#else +#error no DUK_USE_PANIC_xxx macro defined +#endif + ")\n", (long) code, (const char *) (msg ? msg : "null")); + DUK_FFLUSH(DUK_STDERR); +#else + /* omit print */ + DUK_UNREF(code); + DUK_UNREF(msg); +#endif + +#if defined(DUK_USE_PANIC_ABORT) + DUK_ABORT(); +#elif defined(DUK_USE_PANIC_EXIT) + DUK_EXIT(-1); +#elif defined(DUK_USE_PANIC_SEGFAULT) + /* exit() afterwards to satisfy "noreturn" */ + DUK_CAUSE_SEGFAULT(); /* SCANBUILD: "Dereference of null pointer", normal */ + DUK_EXIT(-1); +#else +#error no DUK_USE_PANIC_xxx macro defined +#endif + + DUK_UNREACHABLE(); +} +#endif /* !DUK_USE_PANIC_HANDLER */ + +#undef DUK__ERRFMT_BUFSIZE +#line 1 "duk_unicode_support.c" +/* + * Various Unicode help functions for character classification predicates, + * case conversion, decoding, etc. + */ + +/* include removed: duk_internal.h */ + +/* + * XUTF-8 and CESU-8 encoding/decoding + */ + +DUK_INTERNAL duk_small_int_t duk_unicode_get_xutf8_length(duk_ucodepoint_t cp) { + duk_uint_fast32_t x = (duk_uint_fast32_t) cp; + if (x < 0x80UL) { + /* 7 bits */ + return 1; + } else if (x < 0x800UL) { + /* 11 bits */ + return 2; + } else if (x < 0x10000UL) { + /* 16 bits */ + return 3; + } else if (x < 0x200000UL) { + /* 21 bits */ + return 4; + } else if (x < 0x4000000UL) { + /* 26 bits */ + return 5; + } else if (x < (duk_ucodepoint_t) 0x80000000UL) { + /* 31 bits */ + return 6; + } else { + /* 36 bits */ + return 7; + } +} + +#if defined(DUK_USE_ASSERTIONS) +DUK_INTERNAL duk_small_int_t duk_unicode_get_cesu8_length(duk_ucodepoint_t cp) { + duk_uint_fast32_t x = (duk_uint_fast32_t) cp; + if (x < 0x80UL) { + /* 7 bits */ + return 1; + } else if (x < 0x800UL) { + /* 11 bits */ + return 2; + } else if (x < 0x10000UL) { + /* 16 bits */ + return 3; + } else { + /* Encoded as surrogate pair, each encoding to 3 bytes for + * 6 bytes total. Codepoints above U+10FFFF encode as 6 bytes + * too, see duk_unicode_encode_cesu8(). + */ + return 3 + 3; + } +} +#endif /* DUK_USE_ASSERTIONS */ + +DUK_INTERNAL duk_uint8_t duk_unicode_xutf8_markers[7] = { + 0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe +}; + +/* Encode to extended UTF-8; 'out' must have space for at least + * DUK_UNICODE_MAX_XUTF8_LENGTH bytes. Allows encoding of any + * 32-bit (unsigned) codepoint. + */ +DUK_INTERNAL duk_small_int_t duk_unicode_encode_xutf8(duk_ucodepoint_t cp, duk_uint8_t *out) { + duk_uint_fast32_t x = (duk_uint_fast32_t) cp; + duk_small_int_t len; + duk_uint8_t marker; + duk_small_int_t i; + + len = duk_unicode_get_xutf8_length(cp); + DUK_ASSERT(len > 0); + + marker = duk_unicode_xutf8_markers[len - 1]; /* 64-bit OK because always >= 0 */ + + i = len; + DUK_ASSERT(i > 0); + do { + i--; + if (i > 0) { + out[i] = (duk_uint8_t) (0x80 + (x & 0x3f)); + x >>= 6; + } else { + /* Note: masking of 'x' is not necessary because of + * range check and shifting -> no bits overlapping + * the marker should be set. + */ + out[0] = (duk_uint8_t) (marker + x); + } + } while (i > 0); + + return len; +} + +/* Encode to CESU-8; 'out' must have space for at least + * DUK_UNICODE_MAX_CESU8_LENGTH bytes; codepoints above U+10FFFF + * will encode to garbage but won't overwrite the output buffer. + */ +DUK_INTERNAL duk_small_int_t duk_unicode_encode_cesu8(duk_ucodepoint_t cp, duk_uint8_t *out) { + duk_uint_fast32_t x = (duk_uint_fast32_t) cp; + duk_small_int_t len; + + if (x < 0x80UL) { + out[0] = (duk_uint8_t) x; + len = 1; + } else if (x < 0x800UL) { + out[0] = (duk_uint8_t) (0xc0 + ((x >> 6) & 0x1f)); + out[1] = (duk_uint8_t) (0x80 + (x & 0x3f)); + len = 2; + } else if (x < 0x10000UL) { + /* surrogate pairs get encoded here */ + out[0] = (duk_uint8_t) (0xe0 + ((x >> 12) & 0x0f)); + out[1] = (duk_uint8_t) (0x80 + ((x >> 6) & 0x3f)); + out[2] = (duk_uint8_t) (0x80 + (x & 0x3f)); + len = 3; + } else { + /* + * Unicode codepoints above U+FFFF are encoded as surrogate + * pairs here. This ensures that all CESU-8 codepoints are + * 16-bit values as expected in Ecmascript. The surrogate + * pairs always get a 3-byte encoding (each) in CESU-8. + * See: http://en.wikipedia.org/wiki/Surrogate_pair + * + * 20-bit codepoint, 10 bits (A and B) per surrogate pair: + * + * x = 0b00000000 0000AAAA AAAAAABB BBBBBBBB + * sp1 = 0b110110AA AAAAAAAA (0xd800 + ((x >> 10) & 0x3ff)) + * sp2 = 0b110111BB BBBBBBBB (0xdc00 + (x & 0x3ff)) + * + * Encoded into CESU-8: + * + * sp1 -> 0b11101101 (0xe0 + ((sp1 >> 12) & 0x0f)) + * -> 0b1010AAAA (0x80 + ((sp1 >> 6) & 0x3f)) + * -> 0b10AAAAAA (0x80 + (sp1 & 0x3f)) + * sp2 -> 0b11101101 (0xe0 + ((sp2 >> 12) & 0x0f)) + * -> 0b1011BBBB (0x80 + ((sp2 >> 6) & 0x3f)) + * -> 0b10BBBBBB (0x80 + (sp2 & 0x3f)) + * + * Note that 0x10000 must be subtracted first. The code below + * avoids the sp1, sp2 temporaries which saves around 20 bytes + * of code. + */ + + x -= 0x10000UL; + + out[0] = (duk_uint8_t) (0xed); + out[1] = (duk_uint8_t) (0xa0 + ((x >> 16) & 0x0f)); + out[2] = (duk_uint8_t) (0x80 + ((x >> 10) & 0x3f)); + out[3] = (duk_uint8_t) (0xed); + out[4] = (duk_uint8_t) (0xb0 + ((x >> 6) & 0x0f)); + out[5] = (duk_uint8_t) (0x80 + (x & 0x3f)); + len = 6; + } + + return len; +} + +/* Decode helper. Return zero on error. */ +DUK_INTERNAL duk_small_int_t duk_unicode_decode_xutf8(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_ucodepoint_t *out_cp) { + const duk_uint8_t *p; + duk_uint32_t res; + duk_uint_fast8_t ch; + duk_small_int_t n; + + DUK_UNREF(thr); + + p = *ptr; + if (p < ptr_start || p >= ptr_end) { + goto fail; + } + + /* + * UTF-8 decoder which accepts longer than standard byte sequences. + * This allows full 32-bit code points to be used. + */ + + ch = (duk_uint_fast8_t) (*p++); + if (ch < 0x80) { + /* 0xxx xxxx [7 bits] */ + res = (duk_uint32_t) (ch & 0x7f); + n = 0; + } else if (ch < 0xc0) { + /* 10xx xxxx -> invalid */ + goto fail; + } else if (ch < 0xe0) { + /* 110x xxxx 10xx xxxx [11 bits] */ + res = (duk_uint32_t) (ch & 0x1f); + n = 1; + } else if (ch < 0xf0) { + /* 1110 xxxx 10xx xxxx 10xx xxxx [16 bits] */ + res = (duk_uint32_t) (ch & 0x0f); + n = 2; + } else if (ch < 0xf8) { + /* 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx [21 bits] */ + res = (duk_uint32_t) (ch & 0x07); + n = 3; + } else if (ch < 0xfc) { + /* 1111 10xx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [26 bits] */ + res = (duk_uint32_t) (ch & 0x03); + n = 4; + } else if (ch < 0xfe) { + /* 1111 110x 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [31 bits] */ + res = (duk_uint32_t) (ch & 0x01); + n = 5; + } else if (ch < 0xff) { + /* 1111 1110 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [36 bits] */ + res = (duk_uint32_t) (0); + n = 6; + } else { + /* 8-byte format could be: + * 1111 1111 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [41 bits] + * + * However, this format would not have a zero bit following the + * leading one bits and would not allow 0xFF to be used as an + * "invalid xutf-8" marker for internal keys. Further, 8-byte + * encodings (up to 41 bit code points) are not currently needed. + */ + goto fail; + } + + DUK_ASSERT(p >= ptr_start); /* verified at beginning */ + if (p + n > ptr_end) { + /* check pointer at end */ + goto fail; + } + + while (n > 0) { + DUK_ASSERT(p >= ptr_start && p < ptr_end); + res = res << 6; + res += (duk_uint32_t) ((*p++) & 0x3f); + n--; + } + + *ptr = p; + *out_cp = res; + return 1; + + fail: + return 0; +} + +/* used by e.g. duk_regexp_executor.c, string built-ins */ +DUK_INTERNAL duk_ucodepoint_t duk_unicode_decode_xutf8_checked(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end) { + duk_ucodepoint_t cp; + + if (duk_unicode_decode_xutf8(thr, ptr, ptr_start, ptr_end, &cp)) { + return cp; + } + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "utf-8 decode failed"); + DUK_UNREACHABLE(); + return 0; +} + +/* (extended) utf-8 length without codepoint encoding validation, used + * for string interning (should probably be inlined). + */ +DUK_INTERNAL duk_size_t duk_unicode_unvalidated_utf8_length(const duk_uint8_t *data, duk_size_t blen) { + const duk_uint8_t *p = data; + const duk_uint8_t *p_end = data + blen; + duk_size_t clen = 0; + + while (p < p_end) { + duk_uint8_t x = *p++; + if (x < 0x80 || x >= 0xc0) { + /* 10xxxxxx = continuation chars (0x80...0xbf), above + * and below that initial bytes. + */ + clen++; + } + } + + return clen; +} + +/* + * Unicode range matcher + * + * Matches a codepoint against a packed bitstream of character ranges. + * Used for slow path Unicode matching. + */ + +/* Must match src/extract_chars.py, generate_match_table3(). */ +DUK_LOCAL duk_uint32_t duk__uni_decode_value(duk_bitdecoder_ctx *bd_ctx) { + duk_uint32_t t; + + t = (duk_uint32_t) duk_bd_decode(bd_ctx, 4); + if (t <= 0x0eU) { + return t; + } + t = (duk_uint32_t) duk_bd_decode(bd_ctx, 8); + if (t <= 0xfdU) { + return t + 0x0f; + } + if (t == 0xfeU) { + t = (duk_uint32_t) duk_bd_decode(bd_ctx, 12); + return t + 0x0fU + 0xfeU; + } else { + t = (duk_uint32_t) duk_bd_decode(bd_ctx, 24); + return t + 0x0fU + 0xfeU + 0x1000UL; + } +} + +DUK_LOCAL duk_small_int_t duk__uni_range_match(const duk_uint8_t *unitab, duk_size_t unilen, duk_codepoint_t cp) { + duk_bitdecoder_ctx bd_ctx; + duk_codepoint_t prev_re; + + DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx)); + bd_ctx.data = (duk_uint8_t *) unitab; + bd_ctx.length = (duk_size_t) unilen; + + prev_re = 0; + for (;;) { + duk_codepoint_t r1, r2; + r1 = (duk_codepoint_t) duk__uni_decode_value(&bd_ctx); + if (r1 == 0) { + break; + } + r2 = (duk_codepoint_t) duk__uni_decode_value(&bd_ctx); + + r1 = prev_re + r1; + r2 = r1 + r2; + prev_re = r2; + + /* [r1,r2] is the range */ + + DUK_DDD(DUK_DDDPRINT("duk__uni_range_match: cp=%06lx range=[0x%06lx,0x%06lx]", + (unsigned long) cp, (unsigned long) r1, (unsigned long) r2)); + if (cp >= r1 && cp <= r2) { + return 1; + } + } + + return 0; +} + +/* + * "WhiteSpace" production check. + */ + +DUK_INTERNAL duk_small_int_t duk_unicode_is_whitespace(duk_codepoint_t cp) { + /* + * E5 Section 7.2 specifies six characters specifically as + * white space: + * + * 0009;<control>;Cc;0;S;;;;;N;CHARACTER TABULATION;;;; + * 000B;<control>;Cc;0;S;;;;;N;LINE TABULATION;;;; + * 000C;<control>;Cc;0;WS;;;;;N;FORM FEED (FF);;;; + * 0020;SPACE;Zs;0;WS;;;;;N;;;;; + * 00A0;NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;NON-BREAKING SPACE;;;; + * FEFF;ZERO WIDTH NO-BREAK SPACE;Cf;0;BN;;;;;N;BYTE ORDER MARK;;;; + * + * It also specifies any Unicode category 'Zs' characters as white + * space. These can be extracted with the "src/extract_chars.py" script. + * Current result: + * + * RAW OUTPUT: + * =========== + * 0020;SPACE;Zs;0;WS;;;;;N;;;;; + * 00A0;NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;NON-BREAKING SPACE;;;; + * 1680;OGHAM SPACE MARK;Zs;0;WS;;;;;N;;;;; + * 180E;MONGOLIAN VOWEL SEPARATOR;Zs;0;WS;;;;;N;;;;; + * 2000;EN QUAD;Zs;0;WS;2002;;;;N;;;;; + * 2001;EM QUAD;Zs;0;WS;2003;;;;N;;;;; + * 2002;EN SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;; + * 2003;EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;; + * 2004;THREE-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;; + * 2005;FOUR-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;; + * 2006;SIX-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;; + * 2007;FIGURE SPACE;Zs;0;WS;<noBreak> 0020;;;;N;;;;; + * 2008;PUNCTUATION SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;; + * 2009;THIN SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;; + * 200A;HAIR SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;; + * 202F;NARROW NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;;;;; + * 205F;MEDIUM MATHEMATICAL SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;; + * 3000;IDEOGRAPHIC SPACE;Zs;0;WS;<wide> 0020;;;;N;;;;; + * + * RANGES: + * ======= + * 0x0020 + * 0x00a0 + * 0x1680 + * 0x180e + * 0x2000 ... 0x200a + * 0x202f + * 0x205f + * 0x3000 + * + * A manual decoder (below) is probably most compact for this. + */ + + duk_uint_fast8_t lo; + duk_uint_fast32_t hi; + + /* cp == -1 (EOF) never matches and causes return value 0 */ + + lo = (duk_uint_fast8_t) (cp & 0xff); + hi = (duk_uint_fast32_t) (cp >> 8); /* does not fit into an uchar */ + + if (hi == 0x0000UL) { + if (lo == 0x09U || lo == 0x0bU || lo == 0x0cU || + lo == 0x20U || lo == 0xa0U) { + return 1; + } + } else if (hi == 0x0020UL) { + if (lo <= 0x0aU || lo == 0x2fU || lo == 0x5fU) { + return 1; + } + } else if (cp == 0x1680L || cp == 0x180eL || cp == 0x3000L || + cp == 0xfeffL) { + return 1; + } + + return 0; +} + +/* + * "LineTerminator" production check. + */ + +DUK_INTERNAL duk_small_int_t duk_unicode_is_line_terminator(duk_codepoint_t cp) { + /* + * E5 Section 7.3 + * + * A LineTerminatorSequence essentially merges <CR> <LF> sequences + * into a single line terminator. This must be handled by the caller. + */ + + if (cp == 0x000aL || cp == 0x000dL || cp == 0x2028L || + cp == 0x2029L) { + return 1; + } + + return 0; +} + +/* + * "IdentifierStart" production check. + */ + +DUK_INTERNAL duk_small_int_t duk_unicode_is_identifier_start(duk_codepoint_t cp) { + /* + * E5 Section 7.6: + * + * IdentifierStart: + * UnicodeLetter + * $ + * _ + * \ UnicodeEscapeSequence + * + * IdentifierStart production has one multi-character production: + * + * \ UnicodeEscapeSequence + * + * The '\' character is -not- matched by this function. Rather, the caller + * should decode the escape and then call this function to check whether the + * decoded character is acceptable (see discussion in E5 Section 7.6). + * + * The "UnicodeLetter" alternative of the production allows letters + * from various Unicode categories. These can be extracted with the + * "src/extract_chars.py" script. + * + * Because the result has hundreds of Unicode codepoint ranges, matching + * for any values >= 0x80 are done using a very slow range-by-range scan + * and a packed range format. + * + * The ASCII portion (codepoints 0x00 ... 0x7f) is fast-pathed below because + * it matters the most. The ASCII related ranges of IdentifierStart are: + * + * 0x0041 ... 0x005a ['A' ... 'Z'] + * 0x0061 ... 0x007a ['a' ... 'z'] + * 0x0024 ['$'] + * 0x005f ['_'] + */ + + /* ASCII (and EOF) fast path -- quick accept and reject */ + if (cp <= 0x7fL) { + if ((cp >= 'a' && cp <= 'z') || + (cp >= 'A' && cp <= 'Z') || + cp == '_' || cp == '$') { + return 1; + } + return 0; + } + + /* Non-ASCII slow path (range-by-range linear comparison), very slow */ + +#ifdef DUK_USE_SOURCE_NONBMP + if (duk__uni_range_match(duk_unicode_ids_noa, + (duk_size_t) sizeof(duk_unicode_ids_noa), + (duk_codepoint_t) cp)) { + return 1; + } + return 0; +#else + if (cp < 0x10000L) { + if (duk__uni_range_match(duk_unicode_ids_noabmp, + sizeof(duk_unicode_ids_noabmp), + (duk_codepoint_t) cp)) { + return 1; + } + return 0; + } else { + /* without explicit non-BMP support, assume non-BMP characters + * are always accepted as identifier characters. + */ + return 1; + } +#endif +} + +/* + * "IdentifierPart" production check. + */ + +DUK_INTERNAL duk_small_int_t duk_unicode_is_identifier_part(duk_codepoint_t cp) { + /* + * E5 Section 7.6: + * + * IdentifierPart: + * IdentifierStart + * UnicodeCombiningMark + * UnicodeDigit + * UnicodeConnectorPunctuation + * <ZWNJ> [U+200C] + * <ZWJ> [U+200D] + * + * IdentifierPart production has one multi-character production + * as part of its IdentifierStart alternative. The '\' character + * of an escape sequence is not matched here, see discussion in + * duk_unicode_is_identifier_start(). + * + * To match non-ASCII characters (codepoints >= 0x80), a very slow + * linear range-by-range scan is used. The codepoint is first compared + * to the IdentifierStart ranges, and if it doesn't match, then to a + * set consisting of code points in IdentifierPart but not in + * IdentifierStart. This is done to keep the unicode range data small, + * at the expense of speed. + * + * The ASCII fast path consists of: + * + * 0x0030 ... 0x0039 ['0' ... '9', UnicodeDigit] + * 0x0041 ... 0x005a ['A' ... 'Z', IdentifierStart] + * 0x0061 ... 0x007a ['a' ... 'z', IdentifierStart] + * 0x0024 ['$', IdentifierStart] + * 0x005f ['_', IdentifierStart and + * UnicodeConnectorPunctuation] + * + * UnicodeCombiningMark has no code points <= 0x7f. + * + * The matching code reuses the "identifier start" tables, and then + * consults a separate range set for characters in "identifier part" + * but not in "identifier start". These can be extracted with the + * "src/extract_chars.py" script. + * + * UnicodeCombiningMark -> categories Mn, Mc + * UnicodeDigit -> categories Nd + * UnicodeConnectorPunctuation -> categories Pc + */ + + /* ASCII (and EOF) fast path -- quick accept and reject */ + if (cp <= 0x7fL) { + if ((cp >= 'a' && cp <= 'z') || + (cp >= 'A' && cp <= 'Z') || + (cp >= '0' && cp <= '9') || + cp == '_' || cp == '$') { + return 1; + } + return 0; + } + + /* Non-ASCII slow path (range-by-range linear comparison), very slow */ + +#ifdef DUK_USE_SOURCE_NONBMP + if (duk__uni_range_match(duk_unicode_ids_noa, + sizeof(duk_unicode_ids_noa), + (duk_codepoint_t) cp) || + duk__uni_range_match(duk_unicode_idp_m_ids_noa, + sizeof(duk_unicode_idp_m_ids_noa), + (duk_codepoint_t) cp)) { + return 1; + } + return 0; +#else + if (cp < 0x10000L) { + if (duk__uni_range_match(duk_unicode_ids_noabmp, + sizeof(duk_unicode_ids_noabmp), + (duk_codepoint_t) cp) || + duk__uni_range_match(duk_unicode_idp_m_ids_noabmp, + sizeof(duk_unicode_idp_m_ids_noabmp), + (duk_codepoint_t) cp)) { + return 1; + } + return 0; + } else { + /* without explicit non-BMP support, assume non-BMP characters + * are always accepted as identifier characters. + */ + return 1; + } +#endif +} + +/* + * Unicode letter check. + */ + +DUK_INTERNAL duk_small_int_t duk_unicode_is_letter(duk_codepoint_t cp) { + /* + * Unicode letter is now taken to be the categories: + * + * Lu, Ll, Lt, Lm, Lo + * + * (Not sure if this is exactly correct.) + * + * The ASCII fast path consists of: + * + * 0x0041 ... 0x005a ['A' ... 'Z'] + * 0x0061 ... 0x007a ['a' ... 'z'] + */ + + /* ASCII (and EOF) fast path -- quick accept and reject */ + if (cp <= 0x7fL) { + if ((cp >= 'a' && cp <= 'z') || + (cp >= 'A' && cp <= 'Z')) { + return 1; + } + return 0; + } + + /* Non-ASCII slow path (range-by-range linear comparison), very slow */ + +#ifdef DUK_USE_SOURCE_NONBMP + if (duk__uni_range_match(duk_unicode_ids_noa, + sizeof(duk_unicode_ids_noa), + (duk_codepoint_t) cp) && + !duk__uni_range_match(duk_unicode_ids_m_let_noa, + sizeof(duk_unicode_ids_m_let_noa), + (duk_codepoint_t) cp)) { + return 1; + } + return 0; +#else + if (cp < 0x10000L) { + if (duk__uni_range_match(duk_unicode_ids_noabmp, + sizeof(duk_unicode_ids_noabmp), + (duk_codepoint_t) cp) && + !duk__uni_range_match(duk_unicode_ids_m_let_noabmp, + sizeof(duk_unicode_ids_m_let_noabmp), + (duk_codepoint_t) cp)) { + return 1; + } + return 0; + } else { + /* without explicit non-BMP support, assume non-BMP characters + * are always accepted as letters. + */ + return 1; + } +#endif +} + +/* + * Complex case conversion helper which decodes a bit-packed conversion + * control stream generated by unicode/extract_caseconv.py. The conversion + * is very slow because it runs through the conversion data in a linear + * fashion to save space (which is why ASCII characters have a special + * fast path before arriving here). + * + * The particular bit counts etc have been determined experimentally to + * be small but still sufficient, and must match the Python script + * (src/extract_caseconv.py). + * + * The return value is the case converted codepoint or -1 if the conversion + * results in multiple characters (this is useful for regexp Canonicalization + * operation). If 'buf' is not NULL, the result codepoint(s) are also + * appended to the hbuffer. + * + * Context and locale specific rules must be checked before consulting + * this function. + */ + +DUK_LOCAL +duk_codepoint_t duk__slow_case_conversion(duk_hthread *thr, + duk_bufwriter_ctx *bw, + duk_codepoint_t cp, + duk_bitdecoder_ctx *bd_ctx) { + duk_small_int_t skip = 0; + duk_small_int_t n; + duk_small_int_t t; + duk_small_int_t count; + duk_codepoint_t tmp_cp; + duk_codepoint_t start_i; + duk_codepoint_t start_o; + + DUK_UNREF(thr); + DUK_ASSERT(bd_ctx != NULL); + + DUK_DDD(DUK_DDDPRINT("slow case conversion for codepoint: %ld", (long) cp)); + + /* range conversion with a "skip" */ + DUK_DDD(DUK_DDDPRINT("checking ranges")); + for (;;) { + skip++; + n = (duk_small_int_t) duk_bd_decode(bd_ctx, 6); + if (n == 0x3f) { + /* end marker */ + break; + } + DUK_DDD(DUK_DDDPRINT("skip=%ld, n=%ld", (long) skip, (long) n)); + + while (n--) { + start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16); + start_o = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16); + count = (duk_small_int_t) duk_bd_decode(bd_ctx, 7); + DUK_DDD(DUK_DDDPRINT("range: start_i=%ld, start_o=%ld, count=%ld, skip=%ld", + (long) start_i, (long) start_o, (long) count, (long) skip)); + + if (cp >= start_i) { + tmp_cp = cp - start_i; /* always >= 0 */ + if (tmp_cp < (duk_codepoint_t) count * (duk_codepoint_t) skip && + (tmp_cp % (duk_codepoint_t) skip) == 0) { + DUK_DDD(DUK_DDDPRINT("range matches input codepoint")); + cp = start_o + tmp_cp; + goto single; + } + } + } + } + + /* 1:1 conversion */ + n = (duk_small_int_t) duk_bd_decode(bd_ctx, 6); + DUK_DDD(DUK_DDDPRINT("checking 1:1 conversions (count %ld)", (long) n)); + while (n--) { + start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16); + start_o = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16); + DUK_DDD(DUK_DDDPRINT("1:1 conversion %ld -> %ld", (long) start_i, (long) start_o)); + if (cp == start_i) { + DUK_DDD(DUK_DDDPRINT("1:1 matches input codepoint")); + cp = start_o; + goto single; + } + } + + /* complex, multicharacter conversion */ + n = (duk_small_int_t) duk_bd_decode(bd_ctx, 7); + DUK_DDD(DUK_DDDPRINT("checking 1:n conversions (count %ld)", (long) n)); + while (n--) { + start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16); + t = (duk_small_int_t) duk_bd_decode(bd_ctx, 2); + DUK_DDD(DUK_DDDPRINT("1:n conversion %ld -> %ld chars", (long) start_i, (long) t)); + if (cp == start_i) { + DUK_DDD(DUK_DDDPRINT("1:n matches input codepoint")); + if (bw != NULL) { + while (t--) { + tmp_cp = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16); + DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) tmp_cp); + } + } + return -1; + } else { + while (t--) { + (void) duk_bd_decode(bd_ctx, 16); + } + } + } + + /* default: no change */ + DUK_DDD(DUK_DDDPRINT("no rule matches, output is same as input")); + /* fall through */ + + single: + if (bw != NULL) { + DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) cp); + } + return cp; +} + +/* + * Case conversion helper, with context/local sensitivity. + * For proper case conversion, one needs to know the character + * and the preceding and following characters, as well as + * locale/language. + */ + +/* XXX: add 'language' argument when locale/language sensitive rule + * support added. + */ +DUK_LOCAL +duk_codepoint_t duk__case_transform_helper(duk_hthread *thr, + duk_bufwriter_ctx *bw, + duk_codepoint_t cp, + duk_codepoint_t prev, + duk_codepoint_t next, + duk_bool_t uppercase) { + duk_bitdecoder_ctx bd_ctx; + + /* fast path for ASCII */ + if (cp < 0x80L) { + /* XXX: there are language sensitive rules for the ASCII range. + * If/when language/locale support is implemented, they need to + * be implemented here for the fast path. There are no context + * sensitive rules for ASCII range. + */ + + if (uppercase) { + if (cp >= 'a' && cp <= 'z') { + cp = cp - 'a' + 'A'; + } + } else { + if (cp >= 'A' && cp <= 'Z') { + cp = cp - 'A' + 'a'; + } + } + + if (bw != NULL) { + DUK_BW_WRITE_RAW_U8(thr, bw, (duk_uint8_t) cp); + } + return cp; + } + + /* context and locale specific rules which cannot currently be represented + * in the caseconv bitstream: hardcoded rules in C + */ + if (uppercase) { + /* XXX: turkish / azeri */ + } else { + /* + * Final sigma context specific rule. This is a rather tricky + * rule and this handling is probably not 100% correct now. + * The rule is not locale/language specific so it is supported. + */ + + if (cp == 0x03a3L && /* U+03A3 = GREEK CAPITAL LETTER SIGMA */ + duk_unicode_is_letter(prev) && /* prev exists and is not a letter */ + !duk_unicode_is_letter(next)) { /* next does not exist or next is not a letter */ + /* Capital sigma occurred at "end of word", lowercase to + * U+03C2 = GREEK SMALL LETTER FINAL SIGMA. Otherwise + * fall through and let the normal rules lowercase it to + * U+03C3 = GREEK SMALL LETTER SIGMA. + */ + cp = 0x03c2L; + goto singlechar; + } + + /* XXX: lithuanian not implemented */ + /* XXX: lithuanian, explicit dot rules */ + /* XXX: turkish / azeri, lowercase rules */ + } + + /* 1:1 or special conversions, but not locale/context specific: script generated rules */ + DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx)); + if (uppercase) { + bd_ctx.data = (duk_uint8_t *) duk_unicode_caseconv_uc; + bd_ctx.length = (duk_size_t) sizeof(duk_unicode_caseconv_uc); + } else { + bd_ctx.data = (duk_uint8_t *) duk_unicode_caseconv_lc; + bd_ctx.length = (duk_size_t) sizeof(duk_unicode_caseconv_lc); + } + return duk__slow_case_conversion(thr, bw, cp, &bd_ctx); + + singlechar: + if (bw != NULL) { + DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) cp); + } + return cp; + + /* unused now, not needed until Turkish/Azeri */ +#if 0 + nochar: + return -1; +#endif +} + +/* + * Replace valstack top with case converted version. + */ + +DUK_INTERNAL void duk_unicode_case_convert_string(duk_hthread *thr, duk_small_int_t uppercase) { + duk_context *ctx = (duk_context *) thr; + duk_hstring *h_input; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; + const duk_uint8_t *p, *p_start, *p_end; + duk_codepoint_t prev, curr, next; + + h_input = duk_require_hstring(ctx, -1); + DUK_ASSERT(h_input != NULL); + + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input)); + + /* [ ... input buffer ] */ + + p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); + p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input); + p = p_start; + + prev = -1; DUK_UNREF(prev); + curr = -1; + next = -1; + for (;;) { + prev = curr; + curr = next; + next = -1; + if (p < p_end) { + next = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end); + } else { + /* end of input and last char has been processed */ + if (curr < 0) { + break; + } + } + + /* on first round, skip */ + if (curr >= 0) { + /* XXX: could add a fast path to process chunks of input codepoints, + * but relative benefit would be quite small. + */ + + /* Ensure space for maximum multi-character result; estimate is overkill. */ + DUK_BW_ENSURE(thr, bw, 8 * DUK_UNICODE_MAX_XUTF8_LENGTH); + + duk__case_transform_helper(thr, + bw, + (duk_codepoint_t) curr, + prev, + next, + uppercase); + } + } + + DUK_BW_COMPACT(thr, bw); + duk_to_string(ctx, -1); /* invalidates h_buf pointer */ + duk_remove(ctx, -2); +} + +#ifdef DUK_USE_REGEXP_SUPPORT + +/* + * Canonicalize() abstract operation needed for canonicalization of individual + * codepoints during regexp compilation and execution, see E5 Section 15.10.2.8. + * Note that codepoints are canonicalized one character at a time, so no context + * specific rules can apply. Locale specific rules can apply, though. + */ + +DUK_INTERNAL duk_codepoint_t duk_unicode_re_canonicalize_char(duk_hthread *thr, duk_codepoint_t cp) { + duk_codepoint_t y; + + y = duk__case_transform_helper(thr, + NULL, /* NULL is allowed, no output */ + cp, /* curr char */ + -1, /* prev char */ + -1, /* next char */ + 1); /* uppercase */ + + if ((y < 0) || (cp >= 0x80 && y < 0x80)) { + /* multiple codepoint conversion or non-ASCII mapped to ASCII + * --> leave as is. + */ + return cp; + } + + return y; +} + +/* + * E5 Section 15.10.2.6 "IsWordChar" abstract operation. Assume + * x < 0 for characters read outside the string. + */ + +DUK_INTERNAL duk_small_int_t duk_unicode_re_is_wordchar(duk_codepoint_t x) { + /* + * Note: the description in E5 Section 15.10.2.6 has a typo, it + * contains 'A' twice and lacks 'a'; the intent is [0-9a-zA-Z_]. + */ + if ((x >= '0' && x <= '9') || + (x >= 'a' && x <= 'z') || + (x >= 'A' && x <= 'Z') || + (x == '_')) { + return 1; + } + return 0; +} + +/* + * Regexp range tables + */ + +/* exposed because lexer needs these too */ +DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_digit[2] = { + (duk_uint16_t) 0x0030UL, (duk_uint16_t) 0x0039UL, +}; +DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_white[22] = { + (duk_uint16_t) 0x0009UL, (duk_uint16_t) 0x000DUL, + (duk_uint16_t) 0x0020UL, (duk_uint16_t) 0x0020UL, + (duk_uint16_t) 0x00A0UL, (duk_uint16_t) 0x00A0UL, + (duk_uint16_t) 0x1680UL, (duk_uint16_t) 0x1680UL, + (duk_uint16_t) 0x180EUL, (duk_uint16_t) 0x180EUL, + (duk_uint16_t) 0x2000UL, (duk_uint16_t) 0x200AUL, + (duk_uint16_t) 0x2028UL, (duk_uint16_t) 0x2029UL, + (duk_uint16_t) 0x202FUL, (duk_uint16_t) 0x202FUL, + (duk_uint16_t) 0x205FUL, (duk_uint16_t) 0x205FUL, + (duk_uint16_t) 0x3000UL, (duk_uint16_t) 0x3000UL, + (duk_uint16_t) 0xFEFFUL, (duk_uint16_t) 0xFEFFUL, +}; +DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_wordchar[8] = { + (duk_uint16_t) 0x0030UL, (duk_uint16_t) 0x0039UL, + (duk_uint16_t) 0x0041UL, (duk_uint16_t) 0x005AUL, + (duk_uint16_t) 0x005FUL, (duk_uint16_t) 0x005FUL, + (duk_uint16_t) 0x0061UL, (duk_uint16_t) 0x007AUL, +}; +DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_not_digit[4] = { + (duk_uint16_t) 0x0000UL, (duk_uint16_t) 0x002FUL, + (duk_uint16_t) 0x003AUL, (duk_uint16_t) 0xFFFFUL, +}; +DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_not_white[24] = { + (duk_uint16_t) 0x0000UL, (duk_uint16_t) 0x0008UL, + (duk_uint16_t) 0x000EUL, (duk_uint16_t) 0x001FUL, + (duk_uint16_t) 0x0021UL, (duk_uint16_t) 0x009FUL, + (duk_uint16_t) 0x00A1UL, (duk_uint16_t) 0x167FUL, + (duk_uint16_t) 0x1681UL, (duk_uint16_t) 0x180DUL, + (duk_uint16_t) 0x180FUL, (duk_uint16_t) 0x1FFFUL, + (duk_uint16_t) 0x200BUL, (duk_uint16_t) 0x2027UL, + (duk_uint16_t) 0x202AUL, (duk_uint16_t) 0x202EUL, + (duk_uint16_t) 0x2030UL, (duk_uint16_t) 0x205EUL, + (duk_uint16_t) 0x2060UL, (duk_uint16_t) 0x2FFFUL, + (duk_uint16_t) 0x3001UL, (duk_uint16_t) 0xFEFEUL, + (duk_uint16_t) 0xFF00UL, (duk_uint16_t) 0xFFFFUL, +}; +DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_not_wordchar[10] = { + (duk_uint16_t) 0x0000UL, (duk_uint16_t) 0x002FUL, + (duk_uint16_t) 0x003AUL, (duk_uint16_t) 0x0040UL, + (duk_uint16_t) 0x005BUL, (duk_uint16_t) 0x005EUL, + (duk_uint16_t) 0x0060UL, (duk_uint16_t) 0x0060UL, + (duk_uint16_t) 0x007BUL, (duk_uint16_t) 0xFFFFUL, +}; + +#endif /* DUK_USE_REGEXP_SUPPORT */ +#line 1 "duk_util_misc.c" +/* + * Misc util stuff + */ + +/* include removed: duk_internal.h */ + +/* + * Lowercase digits for radix values 2 to 36. Also doubles as lowercase + * hex nybble table. + */ + +DUK_INTERNAL duk_uint8_t duk_lc_digits[36] = { + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', + 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', + 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', + 'w', 'x', 'y', 'z' +}; + +DUK_INTERNAL duk_uint8_t duk_uc_nybbles[16] = { + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' +}; + +/* + * Table for decoding ASCII hex digits, -1 if invalid. + */ + +DUK_INTERNAL duk_int8_t duk_hex_dectab[256] = { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x00-0x0f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x10-0x1f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x20-0x2f */ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, /* 0x30-0x3f */ + -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x40-0x4f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x50-0x5f */ + -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x60-0x6f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x70-0x7f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x80-0x8f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x90-0x9f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xa0-0xaf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xb0-0xbf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xc0-0xcf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xd0-0xdf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xe0-0xef */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 0xf0-0xff */ +}; + +/* + * Arbitrary byteswap for potentially unaligned values + * + * Used to byteswap pointers e.g. in debugger code. + */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) /* For now only needed by the debugger. */ +DUK_INTERNAL void duk_byteswap_bytes(duk_uint8_t *p, duk_small_uint_t len) { + duk_uint8_t tmp; + duk_uint8_t *q = p + len - 1; + + while (p - q < 0) { + tmp = *p; + *p = *q; + *q = tmp; + p++; + q--; + } +} +#endif +#line 1 "duk_util_hashprime.c" +/* + * Round a number upwards to a prime (not usually the nearest one). + * + * Uses a table of successive 32-bit primes whose ratio is roughly + * constant. This keeps the relative upwards 'rounding error' bounded + * and the data size small. A simple 'predict-correct' compression is + * used to compress primes to one byte per prime. See genhashsizes.py + * for details. + * + * The minimum prime returned here must be coordinated with the possible + * probe sequence steps in duk_hobject and duk_heap stringtable. + */ + +/* include removed: duk_internal.h */ + +/* Awkward inclusion condition: drop out of compilation if not needed by any + * call site: object hash part or probing stringtable. + */ +#if defined(DUK_USE_HOBJECT_HASH_PART) || defined(DUK_USE_STRTAB_PROBE) + +/* hash size ratio goal, must match genhashsizes.py */ +#define DUK__HASH_SIZE_RATIO 1177 /* floor(1.15 * (1 << 10)) */ + +/* prediction corrections for prime list (see genhashsizes.py) */ +DUK_LOCAL const duk_int8_t duk__hash_size_corrections[] = { + 17, /* minimum prime */ + 4, 3, 4, 1, 4, 1, 1, 2, 2, 2, 2, 1, 6, 6, 9, 5, 1, 2, 2, 5, 1, 3, 3, 3, + 5, 4, 4, 2, 4, 8, 3, 4, 23, 2, 4, 7, 8, 11, 2, 12, 15, 10, 1, 1, 5, 1, 5, + 8, 9, 17, 14, 10, 7, 5, 2, 46, 21, 1, 9, 9, 4, 4, 10, 23, 36, 6, 20, 29, + 18, 6, 19, 21, 16, 11, 5, 5, 48, 9, 1, 39, 14, 8, 4, 29, 9, 1, 15, 48, 12, + 22, 6, 15, 27, 4, 2, 17, 28, 8, 9, 4, 5, 8, 3, 3, 8, 37, 11, 15, 8, 30, + 43, 6, 33, 41, 5, 20, 32, 41, 38, 24, 77, 14, 19, 11, 4, 35, 18, 19, 41, + 10, 23, 16, 9, 2, + -1 +}; + +/* probe steps (see genhashsizes.py), currently assumed to be 32 entries long + * (DUK_UTIL_GET_HASH_PROBE_STEP macro). + */ +DUK_INTERNAL duk_uint8_t duk_util_probe_steps[32] = { + 2, 3, 5, 7, 11, 13, 19, 31, 41, 47, 59, 67, 73, 79, 89, 101, 103, 107, + 109, 127, 137, 139, 149, 157, 163, 167, 173, 181, 191, 193, 197, 199 +}; + +DUK_INTERNAL duk_uint32_t duk_util_get_hash_prime(duk_uint32_t size) { + const duk_int8_t *p = duk__hash_size_corrections; + duk_uint32_t curr; + + curr = (duk_uint32_t) *p++; + for (;;) { + duk_small_int_t t = (duk_small_int_t) *p++; + if (t < 0) { + /* may happen if size is very close to 2^32-1 */ + break; + } + + /* prediction: portable variant using doubles if 64-bit values not available */ +#ifdef DUK_USE_64BIT_OPS + curr = (duk_uint32_t) ((((duk_uint64_t) curr) * ((duk_uint64_t) DUK__HASH_SIZE_RATIO)) >> 10); +#else + /* 32-bit x 11-bit = 43-bit, fits accurately into a double */ + curr = (duk_uint32_t) DUK_FLOOR(((double) curr) * ((double) DUK__HASH_SIZE_RATIO) / 1024.0); +#endif + + /* correction */ + curr += t; + + DUK_DDD(DUK_DDDPRINT("size=%ld, curr=%ld", (long) size, (long) curr)); + + if (curr >= size) { + return curr; + } + } + return 0; +} + +#endif /* DUK_USE_HOBJECT_HASH_PART || DUK_USE_STRTAB_PROBE */ +#line 1 "duk_hobject_class.c" +/* + * Hobject Ecmascript [[Class]]. + */ + +/* include removed: duk_internal.h */ + +#if (DUK_STRIDX_UC_ARGUMENTS > 255) +#error constant too large +#endif +#if (DUK_STRIDX_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_BOOLEAN > 255) +#error constant too large +#endif +#if (DUK_STRIDX_DATE > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_ERROR > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_FUNCTION > 255) +#error constant too large +#endif +#if (DUK_STRIDX_JSON > 255) +#error constant too large +#endif +#if (DUK_STRIDX_MATH > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_NUMBER > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_OBJECT > 255) +#error constant too large +#endif +#if (DUK_STRIDX_REG_EXP > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_STRING > 255) +#error constant too large +#endif +#if (DUK_STRIDX_GLOBAL > 255) +#error constant too large +#endif +#if (DUK_STRIDX_OBJ_ENV > 255) +#error constant too large +#endif +#if (DUK_STRIDX_DEC_ENV > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_BUFFER > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_POINTER > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_THREAD > 255) +#error constant too large +#endif +#if (DUK_STRIDX_ARRAY_BUFFER > 255) +#error constant too large +#endif +#if (DUK_STRIDX_DATA_VIEW > 255) +#error constant too large +#endif +#if (DUK_STRIDX_INT8_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UINT8_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UINT8_CLAMPED_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_INT16_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UINT16_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_INT32_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UINT32_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_FLOAT32_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_FLOAT64_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_EMPTY_STRING > 255) +#error constant too large +#endif + +/* Note: assumes that these string indexes are 8-bit, genstrings.py must ensure that */ +DUK_INTERNAL duk_uint8_t duk_class_number_to_stridx[32] = { + DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ + DUK_STRIDX_UC_ARGUMENTS, + DUK_STRIDX_ARRAY, + DUK_STRIDX_UC_BOOLEAN, + DUK_STRIDX_DATE, + DUK_STRIDX_UC_ERROR, + DUK_STRIDX_UC_FUNCTION, + DUK_STRIDX_JSON, + DUK_STRIDX_MATH, + DUK_STRIDX_UC_NUMBER, + DUK_STRIDX_UC_OBJECT, + DUK_STRIDX_REG_EXP, + DUK_STRIDX_UC_STRING, + DUK_STRIDX_GLOBAL, + DUK_STRIDX_OBJ_ENV, + DUK_STRIDX_DEC_ENV, + DUK_STRIDX_UC_BUFFER, + DUK_STRIDX_UC_POINTER, + DUK_STRIDX_UC_THREAD, + DUK_STRIDX_ARRAY_BUFFER, + DUK_STRIDX_DATA_VIEW, + DUK_STRIDX_INT8_ARRAY, + DUK_STRIDX_UINT8_ARRAY, + DUK_STRIDX_UINT8_CLAMPED_ARRAY, + DUK_STRIDX_INT16_ARRAY, + DUK_STRIDX_UINT16_ARRAY, + DUK_STRIDX_INT32_ARRAY, + DUK_STRIDX_UINT32_ARRAY, + DUK_STRIDX_FLOAT32_ARRAY, + DUK_STRIDX_FLOAT64_ARRAY, + DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ + DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ +}; +#line 1 "duk_alloc_default.c" +/* + * Default allocation functions. + * + * Assumes behavior such as malloc allowing zero size, yielding + * a NULL or a unique pointer which is a no-op for free. + */ + +/* include removed: duk_internal.h */ + +DUK_INTERNAL void *duk_default_alloc_function(void *udata, duk_size_t size) { + void *res; + DUK_UNREF(udata); + res = DUK_ANSI_MALLOC(size); + DUK_DDD(DUK_DDDPRINT("default alloc function: %lu -> %p", + (unsigned long) size, (void *) res)); + return res; +} + +DUK_INTERNAL void *duk_default_realloc_function(void *udata, void *ptr, duk_size_t newsize) { + void *res; + DUK_UNREF(udata); + res = DUK_ANSI_REALLOC(ptr, newsize); + DUK_DDD(DUK_DDDPRINT("default realloc function: %p %lu -> %p", + (void *) ptr, (unsigned long) newsize, (void *) res)); + return res; +} + +DUK_INTERNAL void duk_default_free_function(void *udata, void *ptr) { + DUK_DDD(DUK_DDDPRINT("default free function: %p", (void *) ptr)); + DUK_UNREF(udata); + DUK_ANSI_FREE(ptr); +} +#line 1 "duk_api_buffer.c" +/* + * Buffer + */ + +/* include removed: duk_internal.h */ + +DUK_EXTERNAL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hbuffer_dynamic *h; + + DUK_ASSERT_CTX_VALID(ctx); + + h = (duk_hbuffer_dynamic *) duk_require_hbuffer(ctx, index); + DUK_ASSERT(h != NULL); + + if (!(DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h))) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_WRONG_BUFFER_TYPE); + } + + /* maximum size check is handled by callee */ + duk_hbuffer_resize(thr, h, new_size); + + return DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h); +} + +DUK_EXTERNAL void *duk_steal_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hbuffer_dynamic *h; + void *ptr; + duk_size_t sz; + + DUK_ASSERT(ctx != NULL); + + h = (duk_hbuffer_dynamic *) duk_require_hbuffer(ctx, index); + DUK_ASSERT(h != NULL); + + if (!(DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h))) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_WRONG_BUFFER_TYPE); + } + + /* Forget the previous allocation, setting size to 0 and alloc to + * NULL. Caller is responsible for freeing the previous allocation. + * Getting the allocation and clearing it is done in the same API + * call to avoid any chance of a realloc. + */ + ptr = DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h); + sz = DUK_HBUFFER_DYNAMIC_GET_SIZE(h); + if (out_size) { + *out_size = sz; + } + DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(thr->heap, h); + DUK_HBUFFER_DYNAMIC_SET_SIZE(h, 0); + + return ptr; +} + +DUK_EXTERNAL void duk_config_buffer(duk_context *ctx, duk_idx_t index, void *ptr, duk_size_t len) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hbuffer_external *h; + + DUK_ASSERT(ctx != NULL); + + h = (duk_hbuffer_external *) duk_require_hbuffer(ctx, index); + DUK_ASSERT(h != NULL); + + if (!DUK_HBUFFER_HAS_EXTERNAL(h)) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_WRONG_BUFFER_TYPE); + } + DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h)); + + DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(thr->heap, h, ptr); + DUK_HBUFFER_EXTERNAL_SET_SIZE(h, len); +} +#line 1 "duk_api_bytecode.c" +/* + * Bytecode dump/load + * + * The bytecode load primitive is more important performance-wise than the + * dump primitive. + * + * Unlike most Duktape API calls, bytecode dump/load is not guaranteed to be + * memory safe for invalid arguments - caller beware! There's little point + * in trying to achieve memory safety unless bytecode instructions are also + * validated which is not easy to do with indirect register references etc. + */ + +/* include removed: duk_internal.h */ + +#if defined(DUK_USE_BYTECODE_DUMP_SUPPORT) + +#define DUK__SER_MARKER 0xff +#define DUK__SER_VERSION 0x00 +#define DUK__SER_STRING 0x00 +#define DUK__SER_NUMBER 0x01 +#define DUK__BYTECODE_INITIAL_ALLOC 256 + +/* + * Dump/load helpers, xxx_raw() helpers do no buffer checks + */ + +DUK_LOCAL duk_uint8_t *duk__load_string_raw(duk_context *ctx, duk_uint8_t *p) { + duk_uint32_t len; + + len = DUK_RAW_READ_U32_BE(p); + duk_push_lstring(ctx, (const char *) p, len); + p += len; + return p; +} + +DUK_LOCAL duk_uint8_t *duk__load_buffer_raw(duk_context *ctx, duk_uint8_t *p) { + duk_uint32_t len; + duk_uint8_t *buf; + + len = DUK_RAW_READ_U32_BE(p); + buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len); + DUK_ASSERT(buf != NULL); + DUK_MEMCPY((void *) buf, (const void *) p, (size_t) len); + p += len; + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_hstring_raw(duk_uint8_t *p, duk_hstring *h) { + duk_size_t len; + duk_uint32_t tmp32; + + DUK_ASSERT(h != NULL); + + len = DUK_HSTRING_GET_BYTELEN(h); + DUK_ASSERT(len <= 0xffffffffUL); /* string limits */ + tmp32 = (duk_uint32_t) len; + DUK_RAW_WRITE_U32_BE(p, tmp32); + DUK_MEMCPY((void *) p, + (const void *) DUK_HSTRING_GET_DATA(h), + len); + p += len; + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_hbuffer_raw(duk_hthread *thr, duk_uint8_t *p, duk_hbuffer *h) { + duk_size_t len; + duk_uint32_t tmp32; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(h != NULL); + DUK_UNREF(thr); + + len = DUK_HBUFFER_GET_SIZE(h); + DUK_ASSERT(len <= 0xffffffffUL); /* buffer limits */ + tmp32 = (duk_uint32_t) len; + DUK_RAW_WRITE_U32_BE(p, tmp32); + DUK_MEMCPY((void *) p, + (const void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h), + len); + p += len; + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_string_prop(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func, duk_small_uint_t stridx) { + duk_hstring *h_str; + duk_tval *tv; + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_GET_STRING(thr, stridx)); + if (tv != NULL && DUK_TVAL_IS_STRING(tv)) { + h_str = DUK_TVAL_GET_STRING(tv); + DUK_ASSERT(h_str != NULL); + } else { + h_str = DUK_HTHREAD_STRING_EMPTY_STRING(thr); + DUK_ASSERT(h_str != NULL); + } + DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */ + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HSTRING_GET_BYTELEN(h_str), p); + p = duk__dump_hstring_raw(p, h_str); + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_buffer_prop(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func, duk_small_uint_t stridx) { + duk_tval *tv; + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_GET_STRING(thr, stridx)); + if (tv != NULL && DUK_TVAL_IS_BUFFER(tv)) { + duk_hbuffer *h_buf; + h_buf = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h_buf != NULL); + DUK_ASSERT(DUK_HBUFFER_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */ + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HBUFFER_GET_SIZE(h_buf), p); + p = duk__dump_hbuffer_raw(thr, p, h_buf); + } else { + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p); + DUK_RAW_WRITE_U32_BE(p, 0); + } + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_uint32_prop(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func, duk_small_uint_t stridx, duk_uint32_t def_value) { + duk_tval *tv; + duk_uint32_t val; + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_GET_STRING(thr, stridx)); + if (tv != NULL && DUK_TVAL_IS_NUMBER(tv)) { + val = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv); + } else { + val = def_value; + } + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p); + DUK_RAW_WRITE_U32_BE(p, val); + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_varmap(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func) { + duk_tval *tv; + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_STRING_INT_VARMAP(thr)); + if (tv != NULL && DUK_TVAL_IS_OBJECT(tv)) { + duk_hobject *h; + duk_uint_fast32_t i; + + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + + /* We know _Varmap only has own properties so walk property + * table directly. We also know _Varmap is dense and all + * values are numbers; assert for these. GC and finalizers + * shouldn't affect _Varmap so side effects should be fine. + */ + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) { + duk_hstring *key; + duk_tval *tv_val; + duk_uint32_t val; + + key = DUK_HOBJECT_E_GET_KEY(thr->heap, h, i); + DUK_ASSERT(key != NULL); /* _Varmap is dense */ + DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h, i)); + tv_val = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h, i); + DUK_ASSERT(tv_val != NULL); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_val)); /* known to be number; in fact an integer */ +#if defined(DUK_USE_FASTINT) + DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv_val)); + DUK_ASSERT(DUK_TVAL_GET_FASTINT(tv_val) == (duk_int64_t) DUK_TVAL_GET_FASTINT_U32(tv_val)); /* known to be 32-bit */ + val = DUK_TVAL_GET_FASTINT_U32(tv_val); +#else + val = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv_val); +#endif + + DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */ + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HSTRING_GET_BYTELEN(key) + 4, p); + p = duk__dump_hstring_raw(p, key); + DUK_RAW_WRITE_U32_BE(p, val); + } + } + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p); + DUK_RAW_WRITE_U32_BE(p, 0); /* end of _Varmap */ + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_formals(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func) { + duk_tval *tv; + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_STRING_INT_FORMALS(thr)); + if (tv != NULL && DUK_TVAL_IS_OBJECT(tv)) { + duk_hobject *h; + duk_uint_fast32_t i; + + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + + /* We know _Formals is dense and all entries will be in the + * array part. GC and finalizers shouldn't affect _Formals + * so side effects should be fine. + */ + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) { + duk_tval *tv_val; + duk_hstring *varname; + + tv_val = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, h, i); + DUK_ASSERT(tv_val != NULL); + if (DUK_TVAL_IS_STRING(tv_val)) { + /* Array is dense and contains only strings, but ASIZE may + * be larger than used part and there are UNUSED entries. + */ + varname = DUK_TVAL_GET_STRING(tv_val); + DUK_ASSERT(varname != NULL); + + DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */ + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HSTRING_GET_BYTELEN(varname), p); + p = duk__dump_hstring_raw(p, varname); + } + } + } + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p); + DUK_RAW_WRITE_U32_BE(p, 0); /* end of _Formals */ + return p; +} + +static duk_uint8_t *duk__dump_func(duk_context *ctx, duk_hcompiledfunction *func, duk_bufwriter_ctx *bw_ctx, duk_uint8_t *p) { + duk_hthread *thr; + duk_tval *tv, *tv_end; + duk_instr_t *ins, *ins_end; + duk_hobject **fn, **fn_end; + duk_hstring *h_str; + duk_uint32_t count_instr; + duk_uint32_t tmp32; + duk_uint16_t tmp16; + duk_double_t d; + + thr = (duk_hthread *) ctx; + DUK_UNREF(ctx); + DUK_UNREF(thr); + + DUK_DD(DUK_DDPRINT("dumping function %p to %p: " + "consts=[%p,%p[ (%ld bytes, %ld items), " + "funcs=[%p,%p[ (%ld bytes, %ld items), " + "code=[%p,%p[ (%ld bytes, %ld items)", + (void *) func, + (void *) p, + (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, func), + (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(thr->heap, func), + (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, func), + (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, func), + (void *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, func), + (void *) DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(thr->heap, func))); + + DUK_ASSERT(DUK_USE_ESBC_MAX_BYTES <= 0x7fffffffUL); /* ensures no overflow */ + count_instr = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(thr->heap, func); + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 3 * 4 + 2 * 2 + 3 * 4 + count_instr * 4, p); + + /* Fixed header info. */ + tmp32 = count_instr; + DUK_RAW_WRITE_U32_BE(p, tmp32); + tmp32 = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(thr->heap, func); + DUK_RAW_WRITE_U32_BE(p, tmp32); + tmp32 = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, func); + DUK_RAW_WRITE_U32_BE(p, tmp32); + tmp16 = func->nregs; + DUK_RAW_WRITE_U16_BE(p, tmp16); + tmp16 = func->nargs; + DUK_RAW_WRITE_U16_BE(p, tmp16); +#if defined(DUK_USE_DEBUGGER_SUPPORT) + tmp32 = func->start_line; + DUK_RAW_WRITE_U32_BE(p, tmp32); + tmp32 = func->end_line; + DUK_RAW_WRITE_U32_BE(p, tmp32); +#else + DUK_RAW_WRITE_U32_BE(p, 0); + DUK_RAW_WRITE_U32_BE(p, 0); +#endif + tmp32 = ((duk_heaphdr *) func)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK; + DUK_RAW_WRITE_U32_BE(p, tmp32); + + /* Bytecode instructions: endian conversion needed unless + * platform is big endian. + */ + ins = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, func); + ins_end = DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, func); + DUK_ASSERT((duk_size_t) (ins_end - ins) == (duk_size_t) count_instr); +#if defined(DUK_USE_INTEGER_BE) + DUK_MEMCPY((void *) p, (const void *) ins, (size_t) (ins_end - ins)); + p += (size_t) (ins_end - ins); +#else + while (ins != ins_end) { + tmp32 = (duk_uint32_t) (*ins); + DUK_RAW_WRITE_U32_BE(p, tmp32); + ins++; + } +#endif + + /* Constants: variable size encoding. */ + tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, func); + tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, func); + while (tv != tv_end) { + /* constants are strings or numbers now */ + DUK_ASSERT(DUK_TVAL_IS_STRING(tv) || + DUK_TVAL_IS_NUMBER(tv)); + + if (DUK_TVAL_IS_STRING(tv)) { + h_str = DUK_TVAL_GET_STRING(tv); + DUK_ASSERT(h_str != NULL); + DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */ + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 1 + 4 + DUK_HSTRING_GET_BYTELEN(h_str), p), + *p++ = DUK__SER_STRING; + p = duk__dump_hstring_raw(p, h_str); + } else { + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 1 + 8, p); + *p++ = DUK__SER_NUMBER; + d = DUK_TVAL_GET_NUMBER(tv); + DUK_RAW_WRITE_DOUBLE_BE(p, d); + } + tv++; + } + + /* Inner functions recursively. */ + fn = (duk_hobject **) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, func); + fn_end = (duk_hobject **) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, func); + while (fn != fn_end) { + /* XXX: This causes recursion up to inner function depth + * which is normally not an issue, e.g. mark-and-sweep uses + * a recursion limiter to avoid C stack issues. Avoiding + * this would mean some sort of a work list or just refusing + * to serialize deep functions. + */ + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(*fn)); + p = duk__dump_func(ctx, (duk_hcompiledfunction *) *fn, bw_ctx, p); + fn++; + } + + /* Object extra properties. + * + * There are some difference between function templates and functions. + * For example, function templates don't have .length and nargs is + * normally used to instantiate the functions. + */ + + p = duk__dump_uint32_prop(thr, p, bw_ctx, (duk_hobject *) func, DUK_STRIDX_LENGTH, (duk_uint32_t) func->nargs); + p = duk__dump_string_prop(thr, p, bw_ctx, (duk_hobject *) func, DUK_STRIDX_NAME); + p = duk__dump_string_prop(thr, p, bw_ctx, (duk_hobject *) func, DUK_STRIDX_FILE_NAME); + p = duk__dump_buffer_prop(thr, p, bw_ctx, (duk_hobject *) func, DUK_STRIDX_INT_PC2LINE); + p = duk__dump_varmap(thr, p, bw_ctx, (duk_hobject *) func); + p = duk__dump_formals(thr, p, bw_ctx, (duk_hobject *) func); + + DUK_DD(DUK_DDPRINT("serialized function %p -> final pointer %p", (void *) func, (void *) p)); + + return p; +} + +/* Load a function from bytecode. The function object returned here must + * match what is created by duk_js_push_closure() with respect to its flags, + * properties, etc. + * + * NOTE: there are intentionally no input buffer length / bound checks. + * Adding them would be easy but wouldn't ensure memory safety as untrusted + * or broken bytecode is unsafe during execution unless the opcodes themselves + * are validated (which is quite complex, especially for indirect opcodes). + */ + +#define DUK__ASSERT_LEFT(n) do { \ + DUK_ASSERT((duk_size_t) (p_end - p) >= (duk_size_t) (n)); \ + } while (0) + +static duk_uint8_t *duk__load_func(duk_context *ctx, duk_uint8_t *p, duk_uint8_t *p_end) { + duk_hthread *thr; + duk_hcompiledfunction *h_fun; + duk_hbuffer *h_data; + duk_size_t data_size; + duk_uint32_t count_instr, count_const, count_funcs; + duk_uint32_t n; + duk_uint32_t tmp32; + duk_small_uint_t const_type; + duk_uint8_t *fun_data; + duk_uint8_t *q; + duk_idx_t idx_base; + duk_tval *tv1; + duk_uarridx_t arr_idx; + + /* XXX: There's some overlap with duk_js_closure() here, but + * seems difficult to share code. Ensure that the final function + * looks the same as created by duk_js_closure(). + */ + + DUK_ASSERT(ctx != NULL); + thr = (duk_hthread *) ctx; + + DUK_DD(DUK_DDPRINT("loading function, p=%p, p_end=%p", (void *) p, (void *) p_end)); + + DUK__ASSERT_LEFT(3 * 4); + count_instr = DUK_RAW_READ_U32_BE(p); + count_const = DUK_RAW_READ_U32_BE(p); + count_funcs = DUK_RAW_READ_U32_BE(p); + + data_size = sizeof(duk_tval) * count_const + + sizeof(duk_hobject *) * count_funcs + + sizeof(duk_instr_t) * count_instr; + + DUK_DD(DUK_DDPRINT("instr=%ld, const=%ld, funcs=%ld, data_size=%ld", + (long) count_instr, (long) count_const, + (long) count_const, (long) data_size)); + + /* Value stack is used to ensure reachability of constants and + * inner functions being loaded. Require enough space to handle + * large functions correctly. + */ + duk_require_stack(ctx, 2 + count_const + count_funcs); + idx_base = duk_get_top(ctx); + + /* Push function object, init flags etc. This must match + * duk_js_push_closure() quite carefully. + */ + duk_push_compiledfunction(ctx); + h_fun = duk_get_hcompiledfunction(ctx, -1); + DUK_ASSERT(h_fun != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) h_fun)); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, h_fun) == NULL); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, h_fun) == NULL); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, h_fun) == NULL); + + h_fun->nregs = DUK_RAW_READ_U16_BE(p); + h_fun->nargs = DUK_RAW_READ_U16_BE(p); +#if defined(DUK_USE_DEBUGGER_SUPPORT) + h_fun->start_line = DUK_RAW_READ_U32_BE(p); + h_fun->end_line = DUK_RAW_READ_U32_BE(p); +#else + p += 8; /* skip line info */ +#endif + + /* duk_hcompiledfunction flags; quite version specific */ + tmp32 = DUK_RAW_READ_U32_BE(p); + DUK_HEAPHDR_SET_FLAGS((duk_heaphdr *) h_fun, tmp32); + + /* standard prototype */ + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, &h_fun->obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]); + + /* assert just a few critical flags */ + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h_fun) == DUK_HTYPE_OBJECT); + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(&h_fun->obj)); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(&h_fun->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(&h_fun->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(&h_fun->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(&h_fun->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(&h_fun->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(&h_fun->obj)); + + /* Create function 'data' buffer but don't attach it yet. */ + fun_data = (duk_uint8_t *) duk_push_fixed_buffer(ctx, data_size); + DUK_ASSERT(fun_data != NULL); + + /* Load bytecode instructions. */ + DUK_ASSERT(sizeof(duk_instr_t) == 4); + DUK__ASSERT_LEFT(count_instr * sizeof(duk_instr_t)); +#if defined(DUK_USE_INTEGER_BE) + q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs; + DUK_MEMCPY((void *) q, + (const void *) p, + sizeof(duk_instr_t) * count_instr); + p += sizeof(duk_instr_t) * count_instr; +#else + q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs; + for (n = count_instr; n > 0; n--) { + *((duk_instr_t *) (void *) q) = DUK_RAW_READ_U32_BE(p); + q += sizeof(duk_instr_t); + } +#endif + + /* Load constants onto value stack but don't yet copy to buffer. */ + for (n = count_const; n > 0; n--) { + DUK__ASSERT_LEFT(1); + const_type = DUK_RAW_READ_U8(p); + switch (const_type) { + case DUK__SER_STRING: { + p = duk__load_string_raw(ctx, p); + break; + } + case DUK__SER_NUMBER: { + /* Important to do a fastint check so that constants are + * properly read back as fastints. + */ + duk_tval tv_tmp; + duk_double_t val; + DUK__ASSERT_LEFT(8); + val = DUK_RAW_READ_DOUBLE_BE(p); + DUK_TVAL_SET_NUMBER_CHKFAST(&tv_tmp, val); + duk_push_tval(ctx, &tv_tmp); + break; + } + default: { + goto format_error; + } + } + } + + /* Load inner functions to value stack, but don't yet copy to buffer. */ + for (n = count_funcs; n > 0; n--) { + p = duk__load_func(ctx, p, p_end); + if (p == NULL) { + goto format_error; + } + } + + /* With constants and inner functions on value stack, we can now + * atomically finish the function 'data' buffer, bump refcounts, + * etc. + * + * Here we take advantage of the value stack being just a duk_tval + * array: we can just memcpy() the constants as long as we incref + * them afterwards. + */ + + h_data = (duk_hbuffer *) duk_get_hbuffer(ctx, idx_base + 1); + DUK_ASSERT(h_data != NULL); + DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC(h_data)); + DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, h_fun, h_data); + DUK_HBUFFER_INCREF(thr, h_data); + + tv1 = duk_get_tval(ctx, idx_base + 2); /* may be NULL if no constants or inner funcs */ + DUK_ASSERT((count_const == 0 && count_funcs == 0) || tv1 != NULL); + + q = fun_data; + if (count_const > 0) { + /* Explicit zero size check to avoid NULL 'tv1'. */ + DUK_MEMCPY((void *) q, (const void *) tv1, sizeof(duk_tval) * count_const); + for (n = count_const; n > 0; n--) { + DUK_TVAL_INCREF_FAST(thr, (duk_tval *) (void *) q); /* no side effects */ + q += sizeof(duk_tval); + } + tv1 += count_const; + } + + DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, h_fun, (duk_hobject **) (void *) q); + for (n = count_funcs; n > 0; n--) { + duk_hobject *h_obj; + + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1)); + h_obj = DUK_TVAL_GET_OBJECT(tv1); + DUK_ASSERT(h_obj != NULL); + tv1++; + DUK_HOBJECT_INCREF(thr, h_obj); + + *((duk_hobject **) (void *) q) = h_obj; + q += sizeof(duk_hobject *); + } + + DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, h_fun, (duk_instr_t *) (void *) q); + + /* The function object is now reachable and refcounts are fine, + * so we can pop off all the temporaries. + */ + DUK_DDD(DUK_DDDPRINT("function is reachable, reset top; func: %!iT", duk_get_tval(ctx, idx_base))); + duk_set_top(ctx, idx_base + 1); + + /* Setup function properties. */ + tmp32 = DUK_RAW_READ_U32_BE(p); + duk_push_u32(ctx, tmp32); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE); + + p = duk__load_string_raw(ctx, p); + if (DUK_HOBJECT_HAS_NAMEBINDING((duk_hobject *) h_fun)) { + /* Original function instance/template had NAMEBINDING. + * Must create a lexical environment on loading to allow + * recursive functions like 'function foo() { foo(); }'. + */ + duk_hobject *proto; + + proto = thr->builtins[DUK_BIDX_GLOBAL_ENV]; + (void) duk_push_object_helper_proto(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV), + proto); + duk_dup(ctx, -2); /* -> [ func funcname env funcname ] */ + duk_dup(ctx, idx_base); /* -> [ func funcname env funcname func ] */ + duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_NONE); /* -> [ func funcname env ] */ + duk_xdef_prop_stridx(ctx, idx_base, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC); + /* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it + * will be ignored anyway + */ + } + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE); + + p = duk__load_string_raw(ctx, p); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC); + + duk_push_object(ctx); + duk_dup(ctx, -2); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_CONSTRUCTOR, DUK_PROPDESC_FLAGS_WC); /* func.prototype.constructor = func */ + duk_compact(ctx, -1); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE, DUK_PROPDESC_FLAGS_W); + + p = duk__load_buffer_raw(ctx, p); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_PC2LINE, DUK_PROPDESC_FLAGS_WC); + + duk_push_object(ctx); /* _Varmap */ + for (;;) { + /* XXX: awkward */ + p = duk__load_string_raw(ctx, p); + if (duk_get_length(ctx, -1) == 0) { + duk_pop(ctx); + break; + } + tmp32 = DUK_RAW_READ_U32_BE(p); + duk_push_u32(ctx, tmp32); + duk_put_prop(ctx, -3); + } + duk_compact(ctx, -1); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VARMAP, DUK_PROPDESC_FLAGS_NONE); + + duk_push_array(ctx); /* _Formals */ + for (arr_idx = 0; ; arr_idx++) { + /* XXX: awkward */ + p = duk__load_string_raw(ctx, p); + if (duk_get_length(ctx, -1) == 0) { + duk_pop(ctx); + break; + } + duk_put_prop_index(ctx, -2, arr_idx); + } + duk_compact(ctx, -1); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_FORMALS, DUK_PROPDESC_FLAGS_NONE); + + /* Return with final function pushed on stack top. */ + DUK_DD(DUK_DDPRINT("final loaded function: %!iT", duk_get_tval(ctx, -1))); + DUK_ASSERT_TOP(ctx, idx_base + 1); + return p; + + format_error: + return NULL; +} + +DUK_EXTERNAL void duk_dump_function(duk_context *ctx) { + duk_hthread *thr; + duk_hcompiledfunction *func; + duk_bufwriter_ctx bw_ctx_alloc; + duk_bufwriter_ctx *bw_ctx = &bw_ctx_alloc; + duk_uint8_t *p; + + DUK_ASSERT(ctx != NULL); + thr = (duk_hthread *) ctx; + + /* Bound functions don't have all properties so we'd either need to + * lookup the non-bound target function or reject bound functions. + * For now, bound functions are rejected. + */ + func = duk_require_hcompiledfunction(ctx, -1); + DUK_ASSERT(func != NULL); + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(&func->obj)); + + /* Estimating the result size beforehand would be costly, so + * start with a reasonable size and extend as needed. + */ + DUK_BW_INIT_PUSHBUF(thr, bw_ctx, DUK__BYTECODE_INITIAL_ALLOC); + p = DUK_BW_GET_PTR(thr, bw_ctx); + *p++ = DUK__SER_MARKER; + *p++ = DUK__SER_VERSION; + p = duk__dump_func(ctx, func, bw_ctx, p); + DUK_BW_SET_PTR(thr, bw_ctx, p); + DUK_BW_COMPACT(thr, bw_ctx); + + DUK_DD(DUK_DDPRINT("serialized result: %!T", duk_get_tval(ctx, -1))); + + duk_remove(ctx, -2); /* [ ... func buf ] -> [ ... buf ] */ +} + +DUK_EXTERNAL void duk_load_function(duk_context *ctx) { + duk_hthread *thr; + duk_uint8_t *p_buf, *p, *p_end; + duk_size_t sz; + + DUK_ASSERT(ctx != NULL); + thr = (duk_hthread *) ctx; + DUK_UNREF(ctx); + + p_buf = (duk_uint8_t *) duk_require_buffer(ctx, -1, &sz); + DUK_ASSERT(p_buf != NULL); + + /* The caller is responsible for being sure that bytecode being loaded + * is valid and trusted. Invalid bytecode can cause memory unsafe + * behavior directly during loading or later during bytecode execution + * (instruction validation would be quite complex to implement). + * + * This signature check is the only sanity check for detecting + * accidental invalid inputs. The initial 0xFF byte ensures no + * ordinary string will be accepted by accident. + */ + p = p_buf; + p_end = p_buf + sz; + if (sz < 2 || p[0] != DUK__SER_MARKER || p[1] != DUK__SER_VERSION) { + goto format_error; + } + p += 2; + + p = duk__load_func(ctx, p, p_end); + if (p == NULL) { + goto format_error; + } + + duk_remove(ctx, -2); /* [ ... buf func ] -> [ ... func ] */ + return; + + format_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_DECODE_FAILED); +} + +#undef DUK__SER_MARKER +#undef DUK__SER_VERSION +#undef DUK__SER_STRING +#undef DUK__SER_NUMBER +#undef DUK__BYTECODE_INITIAL_ALLOC + +#else /* DUK_USE_BYTECODE_DUMP_SUPPORT */ + +DUK_EXTERNAL void duk_dump_function(duk_context *ctx) { + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_ERROR, DUK_STR_UNSUPPORTED); +} + +DUK_EXTERNAL void duk_load_function(duk_context *ctx) { + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_ERROR, DUK_STR_UNSUPPORTED); +} + +#endif /* DUK_USE_BYTECODE_DUMP_SUPPORT */ +#line 1 "duk_api_call.c" +/* + * Calls. + * + * Protected variants should avoid ever throwing an error. + */ + +/* include removed: duk_internal.h */ + +/* Prepare value stack for a method call through an object property. + * May currently throw an error e.g. when getting the property. + */ +DUK_LOCAL void duk__call_prop_prep_stack(duk_context *ctx, duk_idx_t normalized_obj_index, duk_idx_t nargs) { + DUK_ASSERT_CTX_VALID(ctx); + + DUK_DDD(DUK_DDDPRINT("duk__call_prop_prep_stack, normalized_obj_index=%ld, nargs=%ld, stacktop=%ld", + (long) normalized_obj_index, (long) nargs, (long) duk_get_top(ctx))); + + /* [... key arg1 ... argN] */ + + /* duplicate key */ + duk_dup(ctx, -nargs - 1); /* Note: -nargs alone would fail for nargs == 0, this is OK */ + duk_get_prop(ctx, normalized_obj_index); + + DUK_DDD(DUK_DDDPRINT("func: %!T", (duk_tval *) duk_get_tval(ctx, -1))); + + /* [... key arg1 ... argN func] */ + + duk_replace(ctx, -nargs - 2); + + /* [... func arg1 ... argN] */ + + duk_dup(ctx, normalized_obj_index); + duk_insert(ctx, -nargs - 1); + + /* [... func this arg1 ... argN] */ +} + +DUK_EXTERNAL void duk_call(duk_context *ctx, duk_idx_t nargs) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_small_uint_t call_flags; + duk_idx_t idx_func; + duk_int_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + + idx_func = duk_get_top(ctx) - nargs - 1; + if (idx_func < 0 || nargs < 0) { + /* note that we can't reliably pop anything here */ + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + } + + /* XXX: awkward; we assume there is space for this, overwrite + * directly instead? + */ + duk_push_undefined(ctx); + duk_insert(ctx, idx_func + 1); + + call_flags = 0; /* not protected, respect reclimit, not constructor */ + + rc = duk_handle_call(thr, /* thread */ + nargs, /* num_stack_args */ + call_flags); /* call_flags */ + DUK_UNREF(rc); +} + +DUK_EXTERNAL void duk_call_method(duk_context *ctx, duk_idx_t nargs) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_small_uint_t call_flags; + duk_idx_t idx_func; + duk_int_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + + idx_func = duk_get_top(ctx) - nargs - 2; /* must work for nargs <= 0 */ + if (idx_func < 0 || nargs < 0) { + /* note that we can't reliably pop anything here */ + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + } + + call_flags = 0; /* not protected, respect reclimit, not constructor */ + + rc = duk_handle_call(thr, /* thread */ + nargs, /* num_stack_args */ + call_flags); /* call_flags */ + DUK_UNREF(rc); +} + +DUK_EXTERNAL void duk_call_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs) { + /* + * XXX: if duk_handle_call() took values through indices, this could be + * made much more sensible. However, duk_handle_call() needs to fudge + * the 'this' and 'func' values to handle bound function chains, which + * is now done "in-place", so this is not a trivial change. + */ + + DUK_ASSERT_CTX_VALID(ctx); + + obj_index = duk_require_normalize_index(ctx, obj_index); /* make absolute */ + + duk__call_prop_prep_stack(ctx, obj_index, nargs); + + duk_call_method(ctx, nargs); +} + +DUK_EXTERNAL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_small_uint_t call_flags; + duk_idx_t idx_func; + duk_int_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + + idx_func = duk_get_top(ctx) - nargs - 1; /* must work for nargs <= 0 */ + if (idx_func < 0 || nargs < 0) { + /* We can't reliably pop anything here because the stack input + * shape is incorrect. So we throw an error; if the caller has + * no catch point for this, a fatal error will occur. Another + * alternative would be to just return an error. But then the + * stack would be in an unknown state which might cause some + * very hard to diagnose problems later on. Also note that even + * if we did not throw an error here, the underlying call handler + * might STILL throw an out-of-memory error or some other internal + * fatal error. + */ + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + return DUK_EXEC_ERROR; /* unreachable */ + } + + /* awkward; we assume there is space for this */ + duk_push_undefined(ctx); + duk_insert(ctx, idx_func + 1); + + call_flags = DUK_CALL_FLAG_PROTECTED; /* protected, respect reclimit, not constructor */ + + rc = duk_handle_call(thr, /* thread */ + nargs, /* num_stack_args */ + call_flags); /* call_flags */ + + return rc; +} + +DUK_EXTERNAL duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_small_uint_t call_flags; + duk_idx_t idx_func; + duk_int_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + + idx_func = duk_get_top(ctx) - nargs - 2; /* must work for nargs <= 0 */ + if (idx_func < 0 || nargs < 0) { + /* See comments in duk_pcall(). */ + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + return DUK_EXEC_ERROR; /* unreachable */ + } + + call_flags = DUK_CALL_FLAG_PROTECTED; /* protected, respect reclimit, not constructor */ + + rc = duk_handle_call(thr, /* thread */ + nargs, /* num_stack_args */ + call_flags); /* call_flags */ + + return rc; +} + +DUK_LOCAL duk_ret_t duk__pcall_prop_raw(duk_context *ctx) { + duk_idx_t obj_index; + duk_idx_t nargs; + + /* Get the original arguments. Note that obj_index may be a relative + * index so the stack must have the same top when we use it. + */ + + DUK_ASSERT_CTX_VALID(ctx); + + obj_index = (duk_idx_t) duk_get_int(ctx, -2); + nargs = (duk_idx_t) duk_get_int(ctx, -1); + duk_pop_2(ctx); + + obj_index = duk_require_normalize_index(ctx, obj_index); /* make absolute */ + duk__call_prop_prep_stack(ctx, obj_index, nargs); + duk_call_method(ctx, nargs); + return 1; +} + +DUK_EXTERNAL duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs) { + /* + * Must be careful to catch errors related to value stack manipulation + * and property lookup, not just the call itself. + */ + + DUK_ASSERT_CTX_VALID(ctx); + + duk_push_idx(ctx, obj_index); + duk_push_idx(ctx, nargs); + + /* Inputs: explicit arguments (nargs), +1 for key, +2 for obj_index/nargs passing. + * If the value stack does not contain enough args, an error is thrown; this matches + * behavior of the other protected call API functions. + */ + return duk_safe_call(ctx, duk__pcall_prop_raw, nargs + 1 + 2 /*nargs*/, 1 /*nrets*/); +} + +DUK_EXTERNAL duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function func, duk_idx_t nargs, duk_idx_t nrets) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_int_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + + if (duk_get_top(ctx) < nargs || nrets < 0) { + /* See comments in duk_pcall(). */ + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + return DUK_EXEC_ERROR; /* unreachable */ + } + + rc = duk_handle_safe_call(thr, /* thread */ + func, /* func */ + nargs, /* num_stack_args */ + nrets); /* num_stack_res */ + + return rc; +} + +DUK_EXTERNAL void duk_new(duk_context *ctx, duk_idx_t nargs) { + /* + * There are two [[Construct]] operations in the specification: + * + * - E5 Section 13.2.2: for Function objects + * - E5 Section 15.3.4.5.2: for "bound" Function objects + * + * The chain of bound functions is resolved in Section 15.3.4.5.2, + * with arguments "piling up" until the [[Construct]] internal + * method is called on the final, actual Function object. Note + * that the "prototype" property is looked up *only* from the + * final object, *before* calling the constructor. + * + * Currently we follow the bound function chain here to get the + * "prototype" property value from the final, non-bound function. + * However, we let duk_handle_call() handle the argument "piling" + * when the constructor is called. The bound function chain is + * thus now processed twice. + * + * When constructing new Array instances, an unnecessary object is + * created and discarded now: the standard [[Construct]] creates an + * object, and calls the Array constructor. The Array constructor + * returns an Array instance, which is used as the result value for + * the "new" operation; the object created before the Array constructor + * call is discarded. + * + * This would be easy to fix, e.g. by knowing that the Array constructor + * will always create a replacement object and skip creating the fallback + * object in that case. + * + * Note: functions called via "new" need to know they are called as a + * constructor. For instance, built-in constructors behave differently + * depending on how they are called. + */ + + /* XXX: merge this with duk_js_call.c, as this function implements + * core semantics (or perhaps merge the two files altogether). + */ + + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *proto; + duk_hobject *cons; + duk_hobject *fallback; + duk_idx_t idx_cons; + duk_small_uint_t call_flags; + duk_int_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + + /* [... constructor arg1 ... argN] */ + + idx_cons = duk_require_normalize_index(ctx, -nargs - 1); + + DUK_DDD(DUK_DDDPRINT("top=%ld, nargs=%ld, idx_cons=%ld", + (long) duk_get_top(ctx), (long) nargs, (long) idx_cons)); + + /* XXX: code duplication */ + + /* + * Figure out the final, non-bound constructor, to get "prototype" + * property. + */ + + duk_dup(ctx, idx_cons); + for (;;) { + cons = duk_get_hobject(ctx, -1); + if (cons == NULL || !DUK_HOBJECT_HAS_CONSTRUCTABLE(cons)) { + /* Checking constructability from anything else than the + * initial constructor is not strictly necessary, but a + * nice sanity check. + */ + goto not_constructable; + } + if (!DUK_HOBJECT_HAS_BOUND(cons)) { + break; + } + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET); /* -> [... cons target] */ + duk_remove(ctx, -2); /* -> [... target] */ + } + DUK_ASSERT(cons != NULL && !DUK_HOBJECT_HAS_BOUND(cons)); + + /* [... constructor arg1 ... argN final_cons] */ + + /* + * Create "fallback" object to be used as the object instance, + * unless the constructor returns a replacement value. + * Its internal prototype needs to be set based on "prototype" + * property of the constructor. + */ + + duk_push_object(ctx); /* class Object, extensible */ + + /* [... constructor arg1 ... argN final_cons fallback] */ + + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE); + proto = duk_get_hobject(ctx, -1); + if (!proto) { + DUK_DDD(DUK_DDDPRINT("constructor has no 'prototype' property, or value not an object " + "-> leave standard Object prototype as fallback prototype")); + } else { + DUK_DDD(DUK_DDDPRINT("constructor has 'prototype' property with object value " + "-> set fallback prototype to that value: %!iO", (duk_heaphdr *) proto)); + fallback = duk_get_hobject(ctx, -2); + DUK_ASSERT(fallback != NULL); + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, fallback, proto); + } + duk_pop(ctx); + + /* [... constructor arg1 ... argN final_cons fallback] */ + + /* + * Manipulate callstack for the call. + */ + + duk_dup_top(ctx); + duk_insert(ctx, idx_cons + 1); /* use fallback as 'this' value */ + duk_insert(ctx, idx_cons); /* also stash it before constructor, + * in case we need it (as the fallback value) + */ + duk_pop(ctx); /* pop final_cons */ + + + /* [... fallback constructor fallback(this) arg1 ... argN]; + * Note: idx_cons points to first 'fallback', not 'constructor'. + */ + + DUK_DDD(DUK_DDDPRINT("before call, idx_cons+1 (constructor) -> %!T, idx_cons+2 (fallback/this) -> %!T, " + "nargs=%ld, top=%ld", + (duk_tval *) duk_get_tval(ctx, idx_cons + 1), + (duk_tval *) duk_get_tval(ctx, idx_cons + 2), + (long) nargs, + (long) duk_get_top(ctx))); + + /* + * Call the constructor function (called in "constructor mode"). + */ + + call_flags = DUK_CALL_FLAG_CONSTRUCTOR_CALL; /* not protected, respect reclimit, is a constructor call */ + + rc = duk_handle_call(thr, /* thread */ + nargs, /* num_stack_args */ + call_flags); /* call_flags */ + DUK_UNREF(rc); + + /* [... fallback retval] */ + + DUK_DDD(DUK_DDDPRINT("constructor call finished, rc=%ld, fallback=%!iT, retval=%!iT", + (long) rc, + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + + /* + * Determine whether to use the constructor return value as the created + * object instance or not. + */ + + if (duk_is_object(ctx, -1)) { + duk_remove(ctx, -2); + } else { + duk_pop(ctx); + } + + /* + * Augment created errors upon creation (not when they are thrown or + * rethrown). __FILE__ and __LINE__ are not desirable here; the call + * stack reflects the caller which is correct. + */ + +#ifdef DUK_USE_AUGMENT_ERROR_CREATE + duk_hthread_sync_currpc(thr); + duk_err_augment_error_create(thr, thr, NULL, 0, 1 /*noblame_fileline*/); +#endif + + /* [... retval] */ + + return; + + not_constructable: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CONSTRUCTABLE); +} + +DUK_LOCAL duk_ret_t duk__pnew_helper(duk_context *ctx) { + duk_uint_t nargs; + + nargs = duk_to_uint(ctx, -1); + duk_pop(ctx); + + duk_new(ctx, nargs); + return 1; +} + +DUK_EXTERNAL duk_int_t duk_pnew(duk_context *ctx, duk_idx_t nargs) { + duk_int_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + + /* For now, just use duk_safe_call() to wrap duk_new(). We can't + * simply use a protected duk_handle_call() because there's post + * processing which might throw. It should be possible to ensure + * the post processing never throws (except in internal errors and + * out of memory etc which are always allowed) and then remove this + * wrapper. + */ + + duk_push_uint(ctx, nargs); + rc = duk_safe_call(ctx, duk__pnew_helper, nargs + 2 /*nargs*/, 1 /*nrets*/); + return rc; +} + +DUK_EXTERNAL duk_bool_t duk_is_constructor_call(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_activation *act; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + DUK_ASSERT_DISABLE(thr->callstack_top >= 0); + + act = duk_hthread_get_current_activation(thr); + DUK_ASSERT(act != NULL); /* because callstack_top > 0 */ + return ((act->flags & DUK_ACT_FLAG_CONSTRUCT) != 0 ? 1 : 0); +} + +DUK_EXTERNAL duk_bool_t duk_is_strict_call(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_activation *act; + + /* For user code this could just return 1 (strict) always + * because all Duktape/C functions are considered strict, + * and strict is also the default when nothing is running. + * However, Duktape may call this function internally when + * the current activation is an Ecmascript function, so + * this cannot be replaced by a 'return 1' without fixing + * the internal call sites. + */ + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + DUK_ASSERT_DISABLE(thr->callstack_top >= 0); + + act = duk_hthread_get_current_activation(thr); + if (act == NULL) { + /* Strict by default. */ + return 1; + } + return ((act->flags & DUK_ACT_FLAG_STRICT) != 0 ? 1 : 0); +} + +/* + * Duktape/C function magic + */ + +DUK_EXTERNAL duk_int_t duk_get_current_magic(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_activation *act; + duk_hobject *func; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + DUK_ASSERT_DISABLE(thr->callstack_top >= 0); + + act = duk_hthread_get_current_activation(thr); + if (act) { + func = DUK_ACT_GET_FUNC(act); + if (!func) { + duk_tval *tv = &act->tv_func; + duk_small_uint_t lf_flags; + lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv); + return (duk_int_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags); + } + DUK_ASSERT(func != NULL); + + if (DUK_HOBJECT_IS_NATIVEFUNCTION(func)) { + duk_hnativefunction *nf = (duk_hnativefunction *) func; + return (duk_int_t) nf->magic; + } + } + return 0; +} + +DUK_EXTERNAL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_hobject *h; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_require_tval(ctx, index); + if (DUK_TVAL_IS_OBJECT(tv)) { + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + if (!DUK_HOBJECT_HAS_NATIVEFUNCTION(h)) { + goto type_error; + } + return (duk_int_t) ((duk_hnativefunction *) h)->magic; + } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) { + duk_small_uint_t lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv); + return (duk_int_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags); + } + + /* fall through */ + type_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE); + return 0; +} + +DUK_EXTERNAL void duk_set_magic(duk_context *ctx, duk_idx_t index, duk_int_t magic) { + duk_hnativefunction *nf; + + DUK_ASSERT_CTX_VALID(ctx); + + nf = duk_require_hnativefunction(ctx, index); + DUK_ASSERT(nf != NULL); + nf->magic = (duk_int16_t) magic; +} +#line 1 "duk_api_codec.c" +/* + * Encoding and decoding basic formats: hex, base64. + * + * These are in-place operations which may allow an optimized implementation. + */ + +/* include removed: duk_internal.h */ + +/* dst length must be exactly ceil(len/3)*4 */ +DUK_LOCAL void duk__base64_encode_helper(const duk_uint8_t *src, const duk_uint8_t *src_end, + duk_uint8_t *dst, duk_uint8_t *dst_end) { + duk_small_uint_t i, snip; + duk_uint_fast32_t t; + duk_uint_fast8_t x, y; + + DUK_UNREF(dst_end); + + while (src < src_end) { + /* read 3 bytes into 't', padded by zero */ + snip = 4; + t = 0; + for (i = 0; i < 3; i++) { + t = t << 8; + if (src >= src_end) { + snip--; + } else { + t += (duk_uint_fast32_t) (*src++); + } + } + + /* + * Missing bytes snip base64 example + * 0 4 XXXX + * 1 3 XXX= + * 2 2 XX== + */ + + DUK_ASSERT(snip >= 2 && snip <= 4); + + for (i = 0; i < 4; i++) { + x = (duk_uint_fast8_t) ((t >> 18) & 0x3f); + t = t << 6; + + /* A straightforward 64-byte lookup would be faster + * and cleaner, but this is shorter. + */ + if (i >= snip) { + y = '='; + } else if (x <= 25) { + y = x + 'A'; + } else if (x <= 51) { + y = x - 26 + 'a'; + } else if (x <= 61) { + y = x - 52 + '0'; + } else if (x == 62) { + y = '+'; + } else { + y = '/'; + } + + DUK_ASSERT(dst < dst_end); + *dst++ = (duk_uint8_t) y; + } + } +} + +DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src, const duk_uint8_t *src_end, + duk_uint8_t *dst, duk_uint8_t *dst_end, duk_uint8_t **out_dst_final) { + duk_uint_fast32_t t; + duk_uint_fast8_t x, y; + duk_small_uint_t group_idx; + + DUK_UNREF(dst_end); + + t = 0; + group_idx = 0; + + while (src < src_end) { + x = *src++; + + if (x >= 'A' && x <= 'Z') { + y = x - 'A' + 0; + } else if (x >= 'a' && x <= 'z') { + y = x - 'a' + 26; + } else if (x >= '0' && x <= '9') { + y = x - '0' + 52; + } else if (x == '+') { + y = 62; + } else if (x == '/') { + y = 63; + } else if (x == '=') { + /* We don't check the zero padding bytes here right now. + * This seems to be common behavior for base-64 decoders. + */ + + if (group_idx == 2) { + /* xx== -> 1 byte, t contains 12 bits, 4 on right are zero */ + t = t >> 4; + DUK_ASSERT(dst < dst_end); + *dst++ = (duk_uint8_t) t; + + if (src >= src_end) { + goto error; + } + x = *src++; + if (x != '=') { + goto error; + } + } else if (group_idx == 3) { + /* xxx= -> 2 bytes, t contains 18 bits, 2 on right are zero */ + t = t >> 2; + DUK_ASSERT(dst < dst_end); + *dst++ = (duk_uint8_t) ((t >> 8) & 0xff); + DUK_ASSERT(dst < dst_end); + *dst++ = (duk_uint8_t) (t & 0xff); + } else { + goto error; + } + + /* Here we can choose either to end parsing and ignore + * whatever follows, or to continue parsing in case + * multiple (possibly padded) base64 strings have been + * concatenated. Currently, keep on parsing. + */ + t = 0; + group_idx = 0; + continue; + } else if (x == 0x09 || x == 0x0a || x == 0x0d || x == 0x20) { + /* allow basic ASCII whitespace */ + continue; + } else { + goto error; + } + + t = (t << 6) + y; + + if (group_idx == 3) { + /* output 3 bytes from 't' */ + DUK_ASSERT(dst < dst_end); + *dst++ = (duk_uint8_t) ((t >> 16) & 0xff); + DUK_ASSERT(dst < dst_end); + *dst++ = (duk_uint8_t) ((t >> 8) & 0xff); + DUK_ASSERT(dst < dst_end); + *dst++ = (duk_uint8_t) (t & 0xff); + t = 0; + group_idx = 0; + } else { + group_idx++; + } + } + + if (group_idx != 0) { + /* Here we'd have the option of decoding unpadded base64 + * (e.g. "xxxxyy" instead of "xxxxyy==". Currently not + * accepted. + */ + goto error; + } + + *out_dst_final = dst; + return 1; + + error: + return 0; +} + +/* Shared handling for encode/decode argument. Fast path handling for + * buffer and string values because they're the most common. In particular, + * avoid creating a temporary string or buffer when possible. + */ +DUK_LOCAL const duk_uint8_t *duk__prep_codec_arg(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) { + DUK_ASSERT(duk_is_valid_index(ctx, index)); /* checked by caller */ + if (duk_is_buffer(ctx, index)) { + return (const duk_uint8_t *) duk_get_buffer(ctx, index, out_len); + } else { + return (const duk_uint8_t *) duk_to_lstring(ctx, index, out_len); + } +} + +DUK_EXTERNAL const char *duk_base64_encode(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_uint8_t *src; + duk_size_t srclen; + duk_size_t dstlen; + duk_uint8_t *dst; + const char *ret; + + DUK_ASSERT_CTX_VALID(ctx); + + /* XXX: optimize for string inputs: no need to coerce to a buffer + * which makes a copy of the input. + */ + + index = duk_require_normalize_index(ctx, index); + src = (duk_uint8_t *) duk_to_buffer(ctx, index, &srclen); + /* Note: for srclen=0, src may be NULL */ + + /* Computation must not wrap; this limit works for 32-bit size_t: + * >>> srclen = 3221225469 + * >>> '%x' % ((srclen + 2) / 3 * 4) + * 'fffffffc' + */ + if (srclen > 3221225469UL) { + goto type_error; + } + dstlen = (srclen + 2) / 3 * 4; + dst = (duk_uint8_t *) duk_push_fixed_buffer(ctx, dstlen); + + duk__base64_encode_helper((const duk_uint8_t *) src, (const duk_uint8_t *) (src + srclen), + dst, (dst + dstlen)); + + ret = duk_to_string(ctx, -1); + duk_replace(ctx, index); + return ret; + + type_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_ENCODE_FAILED); + return NULL; /* never here */ +} + +DUK_EXTERNAL void duk_base64_decode(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + const duk_uint8_t *src; + duk_size_t srclen; + duk_size_t dstlen; + duk_uint8_t *dst; + duk_uint8_t *dst_final; + duk_bool_t retval; + + DUK_ASSERT_CTX_VALID(ctx); + + /* XXX: optimize for buffer inputs: no need to coerce to a string + * which causes an unnecessary interning. + */ + + index = duk_require_normalize_index(ctx, index); + src = (const duk_uint8_t *) duk_to_lstring(ctx, index, &srclen); + + /* Computation must not wrap, only srclen + 3 is at risk of + * wrapping because after that the number gets smaller. + * This limit works for 32-bit size_t: + * 0x100000000 - 3 - 1 = 4294967292 + */ + if (srclen > 4294967292UL) { + goto type_error; + } + dstlen = (srclen + 3) / 4 * 3; /* upper limit */ + dst = (duk_uint8_t *) duk_push_dynamic_buffer(ctx, dstlen); + /* Note: for dstlen=0, dst may be NULL */ + + retval = duk__base64_decode_helper((const duk_uint8_t *) src, (const duk_uint8_t *) (src + srclen), + dst, dst + dstlen, &dst_final); + if (!retval) { + goto type_error; + } + + /* XXX: convert to fixed buffer? */ + (void) duk_resize_buffer(ctx, -1, (duk_size_t) (dst_final - dst)); + duk_replace(ctx, index); + return; + + type_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_DECODE_FAILED); +} + +DUK_EXTERNAL const char *duk_hex_encode(duk_context *ctx, duk_idx_t index) { + const duk_uint8_t *inp; + duk_size_t len; + duk_size_t i; + duk_small_uint_t t; + duk_uint8_t *buf; + const char *ret; + + DUK_ASSERT_CTX_VALID(ctx); + + index = duk_require_normalize_index(ctx, index); + inp = duk__prep_codec_arg(ctx, index, &len); + DUK_ASSERT(inp != NULL || len == 0); + + /* Fixed buffer, no zeroing because we'll fill all the data. */ + buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len * 2, DUK_BUF_FLAG_NOZERO /*flags*/); + DUK_ASSERT(buf != NULL); + + for (i = 0; i < len; i++) { + /* XXX: by using two 256-entry tables could avoid shifting and masking. */ + t = (duk_small_uint_t) inp[i]; + buf[i*2 + 0] = duk_lc_digits[t >> 4]; + buf[i*2 + 1] = duk_lc_digits[t & 0x0f]; + } + + /* XXX: Using a string return value forces a string intern which is + * not always necessary. As a rough performance measure, hex encode + * time for tests/perf/test-hex-encode.js dropped from ~35s to ~15s + * without string coercion. Change to returning a buffer and let the + * caller coerce to string if necessary? + */ + + ret = duk_to_string(ctx, -1); + duk_replace(ctx, index); + return ret; +} + +DUK_EXTERNAL void duk_hex_decode(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + const duk_uint8_t *inp; + duk_size_t len; + duk_size_t i; + duk_small_int_t t; + duk_uint8_t *buf; + + DUK_ASSERT_CTX_VALID(ctx); + + index = duk_require_normalize_index(ctx, index); + inp = duk__prep_codec_arg(ctx, index, &len); + DUK_ASSERT(inp != NULL || len == 0); + + if (len & 0x01) { + goto type_error; + } + + /* Fixed buffer, no zeroing because we'll fill all the data. */ + buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len / 2, DUK_BUF_FLAG_NOZERO /*flags*/); + DUK_ASSERT(buf != NULL); + + for (i = 0; i < len; i += 2) { + /* For invalid characters the value -1 gets extended to + * at least 16 bits. If either nybble is invalid, the + * resulting 't' will be < 0. + */ + t = (((duk_small_int_t) duk_hex_dectab[inp[i]]) << 4) | + ((duk_small_int_t) duk_hex_dectab[inp[i + 1]]); + if (DUK_UNLIKELY(t < 0)) { + goto type_error; + } + buf[i >> 1] = (duk_uint8_t) t; + } + + duk_replace(ctx, index); + return; + + type_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_DECODE_FAILED); +} + +DUK_EXTERNAL const char *duk_json_encode(duk_context *ctx, duk_idx_t index) { +#ifdef DUK_USE_ASSERTIONS + duk_idx_t top_at_entry; +#endif + const char *ret; + + DUK_ASSERT_CTX_VALID(ctx); +#ifdef DUK_USE_ASSERTIONS + top_at_entry = duk_get_top(ctx); +#endif + + index = duk_require_normalize_index(ctx, index); + duk_bi_json_stringify_helper(ctx, + index /*idx_value*/, + DUK_INVALID_INDEX /*idx_replacer*/, + DUK_INVALID_INDEX /*idx_space*/, + 0 /*flags*/); + DUK_ASSERT(duk_is_string(ctx, -1)); + duk_replace(ctx, index); + ret = duk_get_string(ctx, index); + + DUK_ASSERT(duk_get_top(ctx) == top_at_entry); + + return ret; +} + +DUK_EXTERNAL void duk_json_decode(duk_context *ctx, duk_idx_t index) { +#ifdef DUK_USE_ASSERTIONS + duk_idx_t top_at_entry; +#endif + + DUK_ASSERT_CTX_VALID(ctx); +#ifdef DUK_USE_ASSERTIONS + top_at_entry = duk_get_top(ctx); +#endif + + index = duk_require_normalize_index(ctx, index); + duk_bi_json_parse_helper(ctx, + index /*idx_value*/, + DUK_INVALID_INDEX /*idx_reviver*/, + 0 /*flags*/); + duk_replace(ctx, index); + + DUK_ASSERT(duk_get_top(ctx) == top_at_entry); +} +#line 1 "duk_api_compile.c" +/* + * Compilation and evaluation + */ + +/* include removed: duk_internal.h */ + +typedef struct duk__compile_raw_args duk__compile_raw_args; +struct duk__compile_raw_args { + duk_size_t src_length; /* should be first on 64-bit platforms */ + const duk_uint8_t *src_buffer; + duk_uint_t flags; +}; + +/* Eval is just a wrapper now. */ +DUK_EXTERNAL duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags) { + duk_uint_t comp_flags; + duk_int_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + + /* Note: strictness is *not* inherited from the current Duktape/C. + * This would be confusing because the current strictness state + * depends on whether we're running inside a Duktape/C activation + * (= strict mode) or outside of any activation (= non-strict mode). + * See tests/api/test-eval-strictness.c for more discussion. + */ + + /* [ ... source? filename ] (depends on flags) */ + + comp_flags = flags; + comp_flags |= DUK_COMPILE_EVAL; + rc = duk_compile_raw(ctx, src_buffer, src_length, comp_flags); /* may be safe, or non-safe depending on flags */ + + /* [ ... closure/error ] */ + + if (rc != DUK_EXEC_SUCCESS) { + rc = DUK_EXEC_ERROR; + goto got_rc; + } + + duk_push_global_object(ctx); /* explicit 'this' binding, see GH-164 */ + + if (flags & DUK_COMPILE_SAFE) { + rc = duk_pcall_method(ctx, 0); + } else { + duk_call_method(ctx, 0); + rc = DUK_EXEC_SUCCESS; + } + + /* [ ... result/error ] */ + + got_rc: + if (flags & DUK_COMPILE_NORESULT) { + duk_pop(ctx); + } + + return rc; +} + +/* Helper which can be called both directly and with duk_safe_call(). */ +DUK_LOCAL duk_ret_t duk__do_compile(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk__compile_raw_args *comp_args; + duk_uint_t flags; + duk_small_uint_t comp_flags; + duk_hcompiledfunction *h_templ; + + DUK_ASSERT_CTX_VALID(ctx); + + /* Note: strictness is not inherited from the current Duktape/C + * context. Otherwise it would not be possible to compile + * non-strict code inside a Duktape/C activation (which is + * always strict now). See tests/api/test-eval-strictness.c + * for discussion. + */ + + /* [ ... source? filename &comp_args ] (depends on flags) */ + + comp_args = (duk__compile_raw_args *) duk_require_pointer(ctx, -1); + flags = comp_args->flags; + duk_pop(ctx); + + /* [ ... source? filename ] */ + + if (!comp_args->src_buffer) { + duk_hstring *h_sourcecode; + + h_sourcecode = duk_get_hstring(ctx, -2); + if ((flags & DUK_COMPILE_NOSOURCE) || /* args incorrect */ + (h_sourcecode == NULL)) { /* e.g. duk_push_string_file_raw() pushed undefined */ + /* XXX: when this error is caused by a nonexistent + * file given to duk_peval_file() or similar, the + * error message is not the best possible. + */ + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_NO_SOURCECODE); + } + DUK_ASSERT(h_sourcecode != NULL); + comp_args->src_buffer = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_sourcecode); + comp_args->src_length = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sourcecode); + } + DUK_ASSERT(comp_args->src_buffer != NULL); + + /* XXX: unnecessary translation of flags */ + comp_flags = 0; + if (flags & DUK_COMPILE_EVAL) { + comp_flags |= DUK_JS_COMPILE_FLAG_EVAL; + } + if (flags & DUK_COMPILE_FUNCTION) { + comp_flags |= DUK_JS_COMPILE_FLAG_EVAL | + DUK_JS_COMPILE_FLAG_FUNCEXPR; + } + if (flags & DUK_COMPILE_STRICT) { + comp_flags |= DUK_JS_COMPILE_FLAG_STRICT; + } + + /* [ ... source? filename ] */ + + duk_js_compile(thr, comp_args->src_buffer, comp_args->src_length, comp_flags); + + /* [ ... source? func_template ] */ + + if (flags & DUK_COMPILE_NOSOURCE) { + ; + } else { + duk_remove(ctx, -2); + } + + /* [ ... func_template ] */ + + h_templ = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1); + DUK_ASSERT(h_templ != NULL); + duk_js_push_closure(thr, + h_templ, + thr->builtins[DUK_BIDX_GLOBAL_ENV], + thr->builtins[DUK_BIDX_GLOBAL_ENV]); + duk_remove(ctx, -2); /* -> [ ... closure ] */ + + /* [ ... closure ] */ + + return 1; +} + +DUK_EXTERNAL duk_int_t duk_compile_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags) { + duk__compile_raw_args comp_args_alloc; + duk__compile_raw_args *comp_args = &comp_args_alloc; + + DUK_ASSERT_CTX_VALID(ctx); + + if ((flags & DUK_COMPILE_STRLEN) && (src_buffer != NULL)) { + /* String length is computed here to avoid multiple evaluation + * of a macro argument in the calling side. + */ + src_length = DUK_STRLEN(src_buffer); + } + + comp_args->src_buffer = (const duk_uint8_t *) src_buffer; + comp_args->src_length = src_length; + comp_args->flags = flags; + duk_push_pointer(ctx, (void *) comp_args); + + /* [ ... source? filename &comp_args ] (depends on flags) */ + + if (flags & DUK_COMPILE_SAFE) { + duk_int_t rc; + duk_int_t nargs; + duk_int_t nrets = 1; + + /* Arguments are either: [ filename &comp_args ] or [ source filename &comp_args ] */ + nargs = (flags & DUK_COMPILE_NOSOURCE) ? 2 : 3; + rc = duk_safe_call(ctx, duk__do_compile, nargs, nrets); + + /* [ ... closure ] */ + return rc; + } + + (void) duk__do_compile(ctx); + + /* [ ... closure ] */ + return DUK_EXEC_SUCCESS; +} +#line 1 "duk_api_debug.c" +/* + * Debugging related API calls + */ + +/* include removed: duk_internal.h */ + +DUK_EXTERNAL void duk_push_context_dump(duk_context *ctx) { + duk_idx_t idx; + duk_idx_t top; + + DUK_ASSERT_CTX_VALID(ctx); + + /* We don't duk_require_stack() here now, but rely on the caller having + * enough space. + */ + + top = duk_get_top(ctx); + duk_push_array(ctx); + for (idx = 0; idx < top; idx++) { + duk_dup(ctx, idx); + duk_put_prop_index(ctx, -2, idx); + } + + /* XXX: conversion errors should not propagate outwards. + * Perhaps values need to be coerced individually? + */ + duk_bi_json_stringify_helper(ctx, + duk_get_top_index(ctx), /*idx_value*/ + DUK_INVALID_INDEX, /*idx_replacer*/ + DUK_INVALID_INDEX, /*idx_space*/ + DUK_JSON_FLAG_EXT_CUSTOM | + DUK_JSON_FLAG_ASCII_ONLY | + DUK_JSON_FLAG_AVOID_KEY_QUOTES /*flags*/); + + duk_push_sprintf(ctx, "ctx: top=%ld, stack=%s", (long) top, (const char *) duk_safe_to_string(ctx, -1)); + duk_replace(ctx, -3); /* [ ... arr jsonx(arr) res ] -> [ ... res jsonx(arr) ] */ + duk_pop(ctx); + DUK_ASSERT(duk_is_string(ctx, -1)); +} + +#if defined(DUK_USE_DEBUGGER_SUPPORT) + +DUK_EXTERNAL void duk_debugger_attach(duk_context *ctx, + duk_debug_read_function read_cb, + duk_debug_write_function write_cb, + duk_debug_peek_function peek_cb, + duk_debug_read_flush_function read_flush_cb, + duk_debug_write_flush_function write_flush_cb, + duk_debug_detached_function detached_cb, + void *udata) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_heap *heap; + const char *str; + duk_size_t len; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(read_cb != NULL); + DUK_ASSERT(write_cb != NULL); + /* Other callbacks are optional. */ + + heap = thr->heap; + heap->dbg_read_cb = read_cb; + heap->dbg_write_cb = write_cb; + heap->dbg_peek_cb = peek_cb; + heap->dbg_read_flush_cb = read_flush_cb; + heap->dbg_write_flush_cb = write_flush_cb; + heap->dbg_detached_cb = detached_cb; + heap->dbg_udata = udata; + + /* Start in paused state. */ + heap->dbg_processing = 0; + heap->dbg_paused = 1; + heap->dbg_state_dirty = 1; + heap->dbg_force_restart = 0; + heap->dbg_step_type = 0; + heap->dbg_step_thread = NULL; + heap->dbg_step_csindex = 0; + heap->dbg_step_startline = 0; + heap->dbg_exec_counter = 0; + heap->dbg_last_counter = 0; + heap->dbg_last_time = 0.0; + + /* Send version identification and flush right afterwards. Note that + * we must write raw, unframed bytes here. + */ + duk_push_sprintf(ctx, "%ld %ld %s %s\n", + (long) DUK_DEBUG_PROTOCOL_VERSION, + (long) DUK_VERSION, + (const char *) DUK_GIT_DESCRIBE, + (const char *) DUK_USE_TARGET_INFO); + str = duk_get_lstring(ctx, -1, &len); + DUK_ASSERT(str != NULL); + duk_debug_write_bytes(thr, (const duk_uint8_t *) str, len); + duk_debug_write_flush(thr); + duk_pop(ctx); +} + +DUK_EXTERNAL void duk_debugger_detach(duk_context *ctx) { + duk_hthread *thr; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + + /* Can be called muliple times with no harm. */ + duk_debug_do_detach(thr->heap); +} + +DUK_EXTERNAL void duk_debugger_cooperate(duk_context *ctx) { + duk_hthread *thr; + duk_bool_t processed_messages; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + + if (!DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) { + return; + } + if (thr->callstack_top > 0 || thr->heap->dbg_processing) { + /* Calling duk_debugger_cooperate() while Duktape is being + * called into is not supported. This is not a 100% check + * but prevents any damage in most cases. + */ + return; + } + + thr->heap->dbg_processing = 1; + processed_messages = duk_debug_process_messages(thr, 1 /*no_block*/); + thr->heap->dbg_processing = 0; + DUK_UNREF(processed_messages); +} + +#else /* DUK_USE_DEBUGGER_SUPPORT */ + +DUK_EXTERNAL void duk_debugger_attach(duk_context *ctx, + duk_debug_read_function read_cb, + duk_debug_write_function write_cb, + duk_debug_peek_function peek_cb, + duk_debug_read_flush_function read_flush_cb, + duk_debug_write_flush_function write_flush_cb, + duk_debug_detached_function detached_cb, + void *udata) { + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(read_cb); + DUK_UNREF(write_cb); + DUK_UNREF(peek_cb); + DUK_UNREF(read_flush_cb); + DUK_UNREF(write_flush_cb); + DUK_UNREF(detached_cb); + DUK_UNREF(udata); + duk_error(ctx, DUK_ERR_API_ERROR, "no debugger support"); +} + +DUK_EXTERNAL void duk_debugger_detach(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + duk_error(ctx, DUK_ERR_API_ERROR, "no debugger support"); +} + +DUK_EXTERNAL void duk_debugger_cooperate(duk_context *ctx) { + /* nop */ + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(ctx); +} + +#endif /* DUK_USE_DEBUGGER_SUPPORT */ +#line 1 "duk_api_heap.c" +/* + * Heap creation and destruction + */ + +/* include removed: duk_internal.h */ + +DUK_EXTERNAL +duk_context *duk_create_heap(duk_alloc_function alloc_func, + duk_realloc_function realloc_func, + duk_free_function free_func, + void *heap_udata, + duk_fatal_function fatal_handler) { + duk_heap *heap = NULL; + duk_context *ctx; + + /* Assume that either all memory funcs are NULL or non-NULL, mixed + * cases will now be unsafe. + */ + + /* XXX: just assert non-NULL values here and make caller arguments + * do the defaulting to the default implementations (smaller code)? + */ + + if (!alloc_func) { + DUK_ASSERT(realloc_func == NULL); + DUK_ASSERT(free_func == NULL); + alloc_func = duk_default_alloc_function; + realloc_func = duk_default_realloc_function; + free_func = duk_default_free_function; + } else { + DUK_ASSERT(realloc_func != NULL); + DUK_ASSERT(free_func != NULL); + } + + if (!fatal_handler) { + fatal_handler = duk_default_fatal_handler; + } + + DUK_ASSERT(alloc_func != NULL); + DUK_ASSERT(realloc_func != NULL); + DUK_ASSERT(free_func != NULL); + DUK_ASSERT(fatal_handler != NULL); + + heap = duk_heap_alloc(alloc_func, realloc_func, free_func, heap_udata, fatal_handler); + if (!heap) { + return NULL; + } + ctx = (duk_context *) heap->heap_thread; + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(((duk_hthread *) ctx)->heap != NULL); + return ctx; +} + +DUK_EXTERNAL void duk_destroy_heap(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_heap *heap; + + if (!ctx) { + return; + } + heap = thr->heap; + DUK_ASSERT(heap != NULL); + + duk_heap_free(heap); +} + +/* XXX: better place for this */ +DUK_EXTERNAL void duk_set_global_object(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h_glob; + duk_hobject *h_prev_glob; + duk_hobject *h_env; + duk_hobject *h_prev_env; + + DUK_D(DUK_DPRINT("replace global object with: %!T", duk_get_tval(ctx, -1))); + + h_glob = duk_require_hobject(ctx, -1); + DUK_ASSERT(h_glob != NULL); + + /* + * Replace global object. + */ + + h_prev_glob = thr->builtins[DUK_BIDX_GLOBAL]; + thr->builtins[DUK_BIDX_GLOBAL] = h_glob; + DUK_HOBJECT_INCREF(thr, h_glob); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_prev_glob); /* side effects, in theory (referenced by global env) */ + + /* + * Replace lexical environment for global scope + * + * Create a new object environment for the global lexical scope. + * We can't just reset the _Target property of the current one, + * because the lexical scope is shared by other threads with the + * same (initial) built-ins. + */ + + (void) duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJENV), + -1); /* no prototype, updated below */ + + duk_dup(ctx, -2); + duk_dup(ctx, -3); + + /* [ ... new_glob new_env new_glob new_glob ] */ + + duk_xdef_prop_stridx(thr, -3, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE); + duk_xdef_prop_stridx(thr, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE); + + /* [ ... new_glob new_env ] */ + + h_env = duk_get_hobject(ctx, -1); + DUK_ASSERT(h_env != NULL); + + h_prev_env = thr->builtins[DUK_BIDX_GLOBAL_ENV]; + thr->builtins[DUK_BIDX_GLOBAL_ENV] = h_env; + DUK_HOBJECT_INCREF(thr, h_env); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_prev_env); /* side effects */ + DUK_UNREF(h_env); /* without refcounts */ + DUK_UNREF(h_prev_env); + + /* [ ... new_glob new_env ] */ + + duk_pop_2(ctx); + + /* [ ... ] */ +} +#line 1 "duk_api_logging.c" +/* + * Logging + * + * Current logging primitive is a sprintf-style log which is convenient + * for most C code. Another useful primitive would be to log N arguments + * from value stack (like the Ecmascript binding does). + */ + +/* include removed: duk_internal.h */ + +DUK_EXTERNAL void duk_log_va(duk_context *ctx, duk_int_t level, const char *fmt, va_list ap) { + /* stridx_logfunc[] must be static to allow initializer with old compilers like BCC */ + static const duk_uint16_t stridx_logfunc[6] = { + DUK_STRIDX_LC_TRACE, DUK_STRIDX_LC_DEBUG, DUK_STRIDX_LC_INFO, + DUK_STRIDX_LC_WARN, DUK_STRIDX_LC_ERROR, DUK_STRIDX_LC_FATAL + }; + + DUK_ASSERT_CTX_VALID(ctx); + + if (level < 0) { + level = 0; + } else if (level > (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1) { + level = (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1; + } + + duk_push_hobject_bidx(ctx, DUK_BIDX_LOGGER_CONSTRUCTOR); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_CLOG); + duk_get_prop_stridx(ctx, -1, stridx_logfunc[level]); + duk_dup(ctx, -2); + + /* [ ... Logger clog logfunc clog ] */ + + duk_push_vsprintf(ctx, fmt, ap); + + /* [ ... Logger clog logfunc clog(=this) msg ] */ + + duk_call_method(ctx, 1 /*nargs*/); + + /* [ ... Logger clog res ] */ + + duk_pop_3(ctx); +} + +DUK_EXTERNAL void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, ...) { + va_list ap; + + DUK_ASSERT_CTX_VALID(ctx); + + va_start(ap, fmt); + duk_log_va(ctx, level, fmt, ap); + va_end(ap); +} +#line 1 "duk_api_memory.c" +/* + * Memory calls. + */ + +/* include removed: duk_internal.h */ + +DUK_EXTERNAL void *duk_alloc_raw(duk_context *ctx, duk_size_t size) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + + return DUK_ALLOC_RAW(thr->heap, size); +} + +DUK_EXTERNAL void duk_free_raw(duk_context *ctx, void *ptr) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + + DUK_FREE_RAW(thr->heap, ptr); +} + +DUK_EXTERNAL void *duk_realloc_raw(duk_context *ctx, void *ptr, duk_size_t size) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + + return DUK_REALLOC_RAW(thr->heap, ptr, size); +} + +DUK_EXTERNAL void *duk_alloc(duk_context *ctx, duk_size_t size) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + + return DUK_ALLOC(thr->heap, size); +} + +DUK_EXTERNAL void duk_free(duk_context *ctx, void *ptr) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + + DUK_FREE(thr->heap, ptr); +} + +DUK_EXTERNAL void *duk_realloc(duk_context *ctx, void *ptr, duk_size_t size) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + + /* + * Note: since this is an exposed API call, there should be + * no way a mark-and-sweep could have a side effect on the + * memory allocation behind 'ptr'; the pointer should never + * be something that Duktape wants to change. + * + * Thus, no need to use DUK_REALLOC_INDIRECT (and we don't + * have the storage location here anyway). + */ + + return DUK_REALLOC(thr->heap, ptr, size); +} + +DUK_EXTERNAL void duk_get_memory_functions(duk_context *ctx, duk_memory_functions *out_funcs) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_heap *heap; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(out_funcs != NULL); + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + + heap = thr->heap; + out_funcs->alloc_func = heap->alloc_func; + out_funcs->realloc_func = heap->realloc_func; + out_funcs->free_func = heap->free_func; + out_funcs->udata = heap->heap_udata; +} + +DUK_EXTERNAL void duk_gc(duk_context *ctx, duk_uint_t flags) { +#ifdef DUK_USE_MARK_AND_SWEEP + duk_hthread *thr = (duk_hthread *) ctx; + duk_heap *heap; + + DUK_UNREF(flags); + + /* NULL accepted */ + if (!ctx) { + return; + } + DUK_ASSERT_CTX_VALID(ctx); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + + DUK_D(DUK_DPRINT("mark-and-sweep requested by application")); + duk_heap_mark_and_sweep(heap, 0); +#else + DUK_D(DUK_DPRINT("mark-and-sweep requested by application but mark-and-sweep not enabled, ignoring")); + DUK_UNREF(ctx); + DUK_UNREF(flags); +#endif +} +#line 1 "duk_api_object.c" +/* + * Object handling: property access and other support functions. + */ + +/* include removed: duk_internal.h */ + +/* + * Property handling + * + * The API exposes only the most common property handling functions. + * The caller can invoke Ecmascript built-ins for full control (e.g. + * defineProperty, getOwnPropertyDescriptor). + */ + +DUK_EXTERNAL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv_obj; + duk_tval *tv_key; + duk_bool_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + + /* Note: copying tv_obj and tv_key to locals to shield against a valstack + * resize is not necessary for a property get right now. + */ + + tv_obj = duk_require_tval(ctx, obj_index); + tv_key = duk_require_tval(ctx, -1); + + rc = duk_hobject_getprop(thr, tv_obj, tv_key); + DUK_ASSERT(rc == 0 || rc == 1); + /* a value is left on stack regardless of rc */ + + duk_remove(ctx, -2); /* remove key */ + return rc; /* 1 if property found, 0 otherwise */ +} + +DUK_EXTERNAL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) { + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(key != NULL); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_string(ctx, key); + return duk_get_prop(ctx, obj_index); +} + +DUK_EXTERNAL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) { + DUK_ASSERT_CTX_VALID(ctx); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_uarridx(ctx, arr_index); + return duk_get_prop(ctx, obj_index); +} + +DUK_INTERNAL duk_bool_t duk_get_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT_DISABLE(stridx >= 0); + DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx)); + return duk_get_prop(ctx, obj_index); +} + +DUK_INTERNAL duk_bool_t duk_get_prop_stridx_boolean(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_bool_t *out_has_prop) { + duk_bool_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT_DISABLE(stridx >= 0); + DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); + + rc = duk_get_prop_stridx(ctx, obj_index, stridx); + if (out_has_prop) { + *out_has_prop = rc; + } + rc = duk_to_boolean(ctx, -1); + DUK_ASSERT(rc == 0 || rc == 1); + duk_pop(ctx); + return rc; +} + +DUK_EXTERNAL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv_obj; + duk_tval *tv_key; + duk_tval *tv_val; + duk_small_int_t throw_flag; + duk_bool_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + + /* Note: copying tv_obj and tv_key to locals to shield against a valstack + * resize is not necessary for a property put right now (putprop protects + * against it internally). + */ + + tv_obj = duk_require_tval(ctx, obj_index); + tv_key = duk_require_tval(ctx, -2); + tv_val = duk_require_tval(ctx, -1); + throw_flag = duk_is_strict_call(ctx); + + rc = duk_hobject_putprop(thr, tv_obj, tv_key, tv_val, throw_flag); + DUK_ASSERT(rc == 0 || rc == 1); + + duk_pop_2(ctx); /* remove key and value */ + return rc; /* 1 if property found, 0 otherwise */ +} + +DUK_EXTERNAL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) { + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(key != NULL); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_string(ctx, key); + duk_swap_top(ctx, -2); /* [val key] -> [key val] */ + return duk_put_prop(ctx, obj_index); +} + +DUK_EXTERNAL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) { + DUK_ASSERT_CTX_VALID(ctx); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_uarridx(ctx, arr_index); + duk_swap_top(ctx, -2); /* [val key] -> [key val] */ + return duk_put_prop(ctx, obj_index); +} + +DUK_INTERNAL duk_bool_t duk_put_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT_DISABLE(stridx >= 0); + DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx)); + duk_swap_top(ctx, -2); /* [val key] -> [key val] */ + return duk_put_prop(ctx, obj_index); +} + +DUK_EXTERNAL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv_obj; + duk_tval *tv_key; + duk_small_int_t throw_flag; + duk_bool_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + + /* Note: copying tv_obj and tv_key to locals to shield against a valstack + * resize is not necessary for a property delete right now. + */ + + tv_obj = duk_require_tval(ctx, obj_index); + tv_key = duk_require_tval(ctx, -1); + throw_flag = duk_is_strict_call(ctx); + + rc = duk_hobject_delprop(thr, tv_obj, tv_key, throw_flag); + DUK_ASSERT(rc == 0 || rc == 1); + + duk_pop(ctx); /* remove key */ + return rc; +} + +DUK_EXTERNAL duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) { + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(key != NULL); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_string(ctx, key); + return duk_del_prop(ctx, obj_index); +} + +DUK_EXTERNAL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) { + DUK_ASSERT_CTX_VALID(ctx); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_uarridx(ctx, arr_index); + return duk_del_prop(ctx, obj_index); +} + +DUK_INTERNAL duk_bool_t duk_del_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT_DISABLE(stridx >= 0); + DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx)); + return duk_del_prop(ctx, obj_index); +} + +DUK_EXTERNAL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv_obj; + duk_tval *tv_key; + duk_bool_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + + /* Note: copying tv_obj and tv_key to locals to shield against a valstack + * resize is not necessary for a property existence check right now. + */ + + tv_obj = duk_require_tval(ctx, obj_index); + tv_key = duk_require_tval(ctx, -1); + + rc = duk_hobject_hasprop(thr, tv_obj, tv_key); + DUK_ASSERT(rc == 0 || rc == 1); + + duk_pop(ctx); /* remove key */ + return rc; /* 1 if property found, 0 otherwise */ +} + +DUK_EXTERNAL duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) { + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(key != NULL); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_string(ctx, key); + return duk_has_prop(ctx, obj_index); +} + +DUK_EXTERNAL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) { + DUK_ASSERT_CTX_VALID(ctx); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_uarridx(ctx, arr_index); + return duk_has_prop(ctx, obj_index); +} + +DUK_INTERNAL duk_bool_t duk_has_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT_DISABLE(stridx >= 0); + DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); + + obj_index = duk_require_normalize_index(ctx, obj_index); + duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx)); + return duk_has_prop(ctx, obj_index); +} + +/* Define own property without inheritance looks and such. This differs from + * [[DefineOwnProperty]] because special behaviors (like Array 'length') are + * not invoked by this method. The caller must be careful to invoke any such + * behaviors if necessary. + */ +DUK_INTERNAL void duk_xdef_prop(duk_context *ctx, duk_idx_t obj_index, duk_small_uint_t desc_flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj; + duk_hstring *key; + + DUK_ASSERT_CTX_VALID(ctx); + + obj = duk_require_hobject(ctx, obj_index); + DUK_ASSERT(obj != NULL); + key = duk_to_hstring(ctx, -2); + DUK_ASSERT(key != NULL); + DUK_ASSERT(duk_require_tval(ctx, -1) != NULL); + + duk_hobject_define_property_internal(thr, obj, key, desc_flags); + + duk_pop(ctx); /* pop key */ +} + +DUK_INTERNAL void duk_xdef_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index, duk_small_uint_t desc_flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj; + + DUK_ASSERT_CTX_VALID(ctx); + + obj = duk_require_hobject(ctx, obj_index); + DUK_ASSERT(obj != NULL); + + duk_hobject_define_property_internal_arridx(thr, obj, arr_index, desc_flags); + /* value popped by call */ +} + +DUK_INTERNAL void duk_xdef_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj; + duk_hstring *key; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT_DISABLE(stridx >= 0); + DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); + + obj = duk_require_hobject(ctx, obj_index); + DUK_ASSERT(obj != NULL); + key = DUK_HTHREAD_GET_STRING(thr, stridx); + DUK_ASSERT(key != NULL); + DUK_ASSERT(duk_require_tval(ctx, -1) != NULL); + + duk_hobject_define_property_internal(thr, obj, key, desc_flags); + /* value popped by call */ +} + +DUK_INTERNAL void duk_xdef_prop_stridx_builtin(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_int_t builtin_idx, duk_small_uint_t desc_flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj; + duk_hstring *key; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT_DISABLE(stridx >= 0); + DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); + DUK_ASSERT_DISABLE(builtin_idx >= 0); + DUK_ASSERT(builtin_idx < DUK_NUM_BUILTINS); + + obj = duk_require_hobject(ctx, obj_index); + DUK_ASSERT(obj != NULL); + key = DUK_HTHREAD_GET_STRING(thr, stridx); + DUK_ASSERT(key != NULL); + + duk_push_hobject(ctx, thr->builtins[builtin_idx]); + duk_hobject_define_property_internal(thr, obj, key, desc_flags); + /* value popped by call */ +} + +/* This is a rare property helper; it sets the global thrower (E5 Section 13.2.3) + * setter/getter into an object property. This is needed by the 'arguments' + * object creation code, function instance creation code, and Function.prototype.bind(). + */ + +DUK_INTERNAL void duk_xdef_prop_stridx_thrower(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj = duk_require_hobject(ctx, obj_index); + duk_hobject *thrower = thr->builtins[DUK_BIDX_TYPE_ERROR_THROWER]; + duk_hobject_define_accessor_internal(thr, obj, DUK_HTHREAD_GET_STRING(thr, stridx), thrower, thrower, desc_flags); +} + +/* Object.defineProperty() equivalent C binding. */ +DUK_EXTERNAL void duk_def_prop(duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t idx_base; + duk_hobject *obj; + duk_hstring *key; + duk_idx_t idx_value; + duk_hobject *get; + duk_hobject *set; + duk_uint_t is_data_desc; + duk_uint_t is_acc_desc; + + DUK_ASSERT_CTX_VALID(ctx); + + obj = duk_require_hobject(ctx, obj_index); + + is_data_desc = flags & (DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_HAVE_WRITABLE); + is_acc_desc = flags & (DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER); + if (is_data_desc && is_acc_desc) { + /* "Have" flags must not be conflicting so that they would + * apply to both a plain property and an accessor at the same + * time. + */ + goto fail_invalid_desc; + } + + idx_base = duk_get_top_index(ctx); + if (flags & DUK_DEFPROP_HAVE_SETTER) { + duk_require_type_mask(ctx, idx_base, DUK_TYPE_MASK_UNDEFINED | + DUK_TYPE_MASK_OBJECT | + DUK_TYPE_MASK_LIGHTFUNC); + set = duk_get_hobject_or_lfunc_coerce(ctx, idx_base); + if (set != NULL && !DUK_HOBJECT_IS_CALLABLE(set)) { + goto fail_not_callable; + } + idx_base--; + } else { + set = NULL; + } + if (flags & DUK_DEFPROP_HAVE_GETTER) { + duk_require_type_mask(ctx, idx_base, DUK_TYPE_MASK_UNDEFINED | + DUK_TYPE_MASK_OBJECT | + DUK_TYPE_MASK_LIGHTFUNC); + get = duk_get_hobject_or_lfunc_coerce(ctx, idx_base); + if (get != NULL && !DUK_HOBJECT_IS_CALLABLE(get)) { + goto fail_not_callable; + } + idx_base--; + } else { + get = NULL; + } + if (flags & DUK_DEFPROP_HAVE_VALUE) { + idx_value = idx_base; + idx_base--; + } else { + idx_value = (duk_idx_t) -1; + } + key = duk_require_hstring(ctx, idx_base); + + duk_require_valid_index(ctx, idx_base); + + duk_hobject_define_property_helper(ctx, + flags /*defprop_flags*/, + obj, + key, + idx_value, + get, + set); + + /* Clean up stack */ + + duk_set_top(ctx, idx_base); + + /* [ ... obj ... ] */ + + return; + + fail_invalid_desc: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_DESCRIPTOR); + return; + + fail_not_callable: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CALLABLE); + return; +} + +/* + * Object related + * + * Note: seal() and freeze() are accessible through Ecmascript bindings, + * and are not exposed through the API. + */ + +DUK_EXTERNAL void duk_compact(duk_context *ctx, duk_idx_t obj_index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj; + + DUK_ASSERT_CTX_VALID(ctx); + + obj = duk_get_hobject(ctx, obj_index); + if (obj) { + /* Note: this may fail, caller should protect the call if necessary */ + duk_hobject_compact_props(thr, obj); + } +} + +/* XXX: the duk_hobject_enum.c stack APIs should be reworked */ + +DUK_EXTERNAL void duk_enum(duk_context *ctx, duk_idx_t obj_index, duk_uint_t enum_flags) { + DUK_ASSERT_CTX_VALID(ctx); + + duk_dup(ctx, obj_index); + duk_require_hobject_or_lfunc_coerce(ctx, -1); + duk_hobject_enumerator_create(ctx, enum_flags); /* [target] -> [enum] */ +} + +DUK_EXTERNAL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_index, duk_bool_t get_value) { + DUK_ASSERT_CTX_VALID(ctx); + + duk_require_hobject(ctx, enum_index); + duk_dup(ctx, enum_index); + return duk_hobject_enumerator_next(ctx, get_value); +} + +/* + * Helpers for writing multiple properties + */ + +DUK_EXTERNAL void duk_put_function_list(duk_context *ctx, duk_idx_t obj_index, const duk_function_list_entry *funcs) { + const duk_function_list_entry *ent = funcs; + + DUK_ASSERT_CTX_VALID(ctx); + + obj_index = duk_require_normalize_index(ctx, obj_index); + if (ent != NULL) { + while (ent->key != NULL) { + duk_push_c_function(ctx, ent->value, ent->nargs); + duk_put_prop_string(ctx, obj_index, ent->key); + ent++; + } + } +} + +DUK_EXTERNAL void duk_put_number_list(duk_context *ctx, duk_idx_t obj_index, const duk_number_list_entry *numbers) { + const duk_number_list_entry *ent = numbers; + + DUK_ASSERT_CTX_VALID(ctx); + + obj_index = duk_require_normalize_index(ctx, obj_index); + if (ent != NULL) { + while (ent->key != NULL) { + duk_push_number(ctx, ent->value); + duk_put_prop_string(ctx, obj_index, ent->key); + ent++; + } + } +} + +/* + * Shortcut for accessing global object properties + */ + +DUK_EXTERNAL duk_bool_t duk_get_global_string(duk_context *ctx, const char *key) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_bool_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL); + + /* XXX: direct implementation */ + + duk_push_hobject(ctx, thr->builtins[DUK_BIDX_GLOBAL]); + ret = duk_get_prop_string(ctx, -1, key); + duk_remove(ctx, -2); + return ret; +} + +DUK_EXTERNAL duk_bool_t duk_put_global_string(duk_context *ctx, const char *key) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_bool_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL); + + /* XXX: direct implementation */ + + duk_push_hobject(ctx, thr->builtins[DUK_BIDX_GLOBAL]); + duk_insert(ctx, -2); + ret = duk_put_prop_string(ctx, -2, key); /* [ ... global val ] -> [ ... global ] */ + duk_pop(ctx); + return ret; +} + +/* + * Object prototype + */ + +DUK_EXTERNAL void duk_get_prototype(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj; + duk_hobject *proto; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(thr); + + obj = duk_require_hobject(ctx, index); + DUK_ASSERT(obj != NULL); + + /* XXX: shared helper for duk_push_hobject_or_undefined()? */ + proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, obj); + if (proto) { + duk_push_hobject(ctx, proto); + } else { + duk_push_undefined(ctx); + } +} + +DUK_EXTERNAL void duk_set_prototype(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj; + duk_hobject *proto; + + DUK_ASSERT_CTX_VALID(ctx); + + obj = duk_require_hobject(ctx, index); + DUK_ASSERT(obj != NULL); + duk_require_type_mask(ctx, -1, DUK_TYPE_MASK_UNDEFINED | + DUK_TYPE_MASK_OBJECT); + proto = duk_get_hobject(ctx, -1); + /* proto can also be NULL here (allowed explicitly) */ + + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, obj, proto); + + duk_pop(ctx); +} + +/* + * Object finalizer + */ + +/* XXX: these could be implemented as macros calling an internal function + * directly. + * XXX: same issue as with Duktape.fin: there's no way to delete the property + * now (just set it to undefined). + */ +DUK_EXTERNAL void duk_get_finalizer(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + + duk_get_prop_stridx(ctx, index, DUK_STRIDX_INT_FINALIZER); +} + +DUK_EXTERNAL void duk_set_finalizer(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + + duk_put_prop_stridx(ctx, index, DUK_STRIDX_INT_FINALIZER); +} +#line 1 "duk_api_stack.c" +/* + * API calls related to general value stack manipulation: resizing the value + * stack, pushing and popping values, type checking and reading values, + * coercing values, etc. + * + * Also contains internal functions (such as duk_get_tval()), defined + * in duk_api_internal.h, with semantics similar to the public API. + */ + +/* XXX: repetition of stack pre-checks -> helper or macro or inline */ +/* XXX: shared api error strings, and perhaps even throw code for rare cases? */ + +/* include removed: duk_internal.h */ + +/* + * Forward declarations + */ + +DUK_LOCAL_DECL duk_idx_t duk__push_c_function_raw(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_uint_t flags); + +/* + * Global state for working around missing variadic macros + */ + +#ifndef DUK_USE_VARIADIC_MACROS +DUK_EXTERNAL const char *duk_api_global_filename = NULL; +DUK_EXTERNAL duk_int_t duk_api_global_line = 0; +#endif + +/* + * Helpers + */ + +#if defined(DUK_USE_VALSTACK_UNSAFE) +/* Faster but value stack overruns are memory unsafe. */ +#define DUK__CHECK_SPACE() do { \ + DUK_ASSERT(!(thr->valstack_top >= thr->valstack_end)); \ + } while (0) +#else +#define DUK__CHECK_SPACE() do { \ + if (thr->valstack_top >= thr->valstack_end) { \ + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); \ + } \ + } while (0) +#endif + +DUK_LOCAL duk_int_t duk__api_coerce_d2i(duk_context *ctx, duk_idx_t index, duk_bool_t require) { + duk_hthread *thr; + duk_tval *tv; + duk_small_int_t c; + duk_double_t d; + + thr = (duk_hthread *) ctx; + + tv = duk_get_tval(ctx, index); + if (tv == NULL) { + goto error_notnumber; + } + + /* + * Special cases like NaN and +/- Infinity are handled explicitly + * because a plain C coercion from double to int handles these cases + * in undesirable ways. For instance, NaN may coerce to INT_MIN + * (not zero), and INT_MAX + 1 may coerce to INT_MIN (not INT_MAX). + * + * This double-to-int coercion differs from ToInteger() because it + * has a finite range (ToInteger() allows e.g. +/- Infinity). It + * also differs from ToInt32() because the INT_MIN/INT_MAX clamping + * depends on the size of the int type on the platform. In particular, + * on platforms with a 64-bit int type, the full range is allowed. + */ + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv)) { + duk_int64_t t = DUK_TVAL_GET_FASTINT(tv); +#if (DUK_INT_MAX <= 0x7fffffffL) + /* Clamping only necessary for 32-bit ints. */ + if (t < DUK_INT_MIN) { + t = DUK_INT_MIN; + } else if (t > DUK_INT_MAX) { + t = DUK_INT_MAX; + } +#endif + return (duk_int_t) t; + } +#endif + + if (DUK_TVAL_IS_NUMBER(tv)) { + d = DUK_TVAL_GET_NUMBER(tv); + c = (duk_small_int_t) DUK_FPCLASSIFY(d); + if (c == DUK_FP_NAN) { + return 0; + } else if (d < (duk_double_t) DUK_INT_MIN) { + /* covers -Infinity */ + return DUK_INT_MIN; + } else if (d > (duk_double_t) DUK_INT_MAX) { + /* covers +Infinity */ + return DUK_INT_MAX; + } else { + /* coerce towards zero */ + return (duk_int_t) d; + } + } + + error_notnumber: + + if (require) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NUMBER); + /* not reachable */ + } + return 0; +} + +DUK_LOCAL duk_uint_t duk__api_coerce_d2ui(duk_context *ctx, duk_idx_t index, duk_bool_t require) { + duk_hthread *thr; + duk_tval *tv; + duk_small_int_t c; + duk_double_t d; + + /* Same as above but for unsigned int range. */ + + thr = (duk_hthread *) ctx; + + tv = duk_get_tval(ctx, index); + if (tv == NULL) { + goto error_notnumber; + } + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv)) { + duk_int64_t t = DUK_TVAL_GET_FASTINT(tv); + if (t < 0) { + t = 0; + } +#if (DUK_UINT_MAX <= 0xffffffffUL) + /* Clamping only necessary for 32-bit ints. */ + else if (t > DUK_UINT_MAX) { + t = DUK_UINT_MAX; + } +#endif + return (duk_uint_t) t; + } +#endif + + if (DUK_TVAL_IS_NUMBER(tv)) { + d = DUK_TVAL_GET_NUMBER(tv); + c = (duk_small_int_t) DUK_FPCLASSIFY(d); + if (c == DUK_FP_NAN) { + return 0; + } else if (d < 0.0) { + /* covers -Infinity */ + return (duk_uint_t) 0; + } else if (d > (duk_double_t) DUK_UINT_MAX) { + /* covers +Infinity */ + return (duk_uint_t) DUK_UINT_MAX; + } else { + /* coerce towards zero */ + return (duk_uint_t) d; + } + } + + error_notnumber: + + if (require) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NUMBER); + /* not reachable */ + } + return 0; +} + +/* + * Stack index validation/normalization and getting a stack duk_tval ptr. + * + * These are called by many API entrypoints so the implementations must be + * fast and "inlined". + * + * There's some repetition because of this; keep the functions in sync. + */ + +DUK_EXTERNAL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t vs_size; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(DUK_INVALID_INDEX < 0); + + /* Care must be taken to avoid pointer wrapping in the index + * validation. For instance, on a 32-bit platform with 8-byte + * duk_tval the index 0x20000000UL would wrap the memory space + * once. + */ + + /* Assume value stack sizes (in elements) fits into duk_idx_t. */ + vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); + DUK_ASSERT(vs_size >= 0); + + if (index < 0) { + index = vs_size + index; + if (DUK_UNLIKELY(index < 0)) { + /* Also catches index == DUK_INVALID_INDEX: vs_size >= 0 + * so that vs_size + DUK_INVALID_INDEX cannot underflow + * and will always be negative. + */ + return DUK_INVALID_INDEX; + } + } else { + /* since index non-negative */ + DUK_ASSERT(index != DUK_INVALID_INDEX); + + if (DUK_UNLIKELY(index >= vs_size)) { + return DUK_INVALID_INDEX; + } + } + + DUK_ASSERT(index >= 0); + DUK_ASSERT(index < vs_size); + return index; +} + +DUK_EXTERNAL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t vs_size; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(DUK_INVALID_INDEX < 0); + + vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); + DUK_ASSERT(vs_size >= 0); + + if (index < 0) { + index = vs_size + index; + if (DUK_UNLIKELY(index < 0)) { + goto invalid_index; + } + } else { + DUK_ASSERT(index != DUK_INVALID_INDEX); + if (DUK_UNLIKELY(index >= vs_size)) { + goto invalid_index; + } + } + + DUK_ASSERT(index >= 0); + DUK_ASSERT(index < vs_size); + return index; + + invalid_index: + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); + return 0; /* unreachable */ +} + +DUK_INTERNAL duk_tval *duk_get_tval(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t vs_size; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(DUK_INVALID_INDEX < 0); + + vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); + DUK_ASSERT(vs_size >= 0); + + if (index < 0) { + index = vs_size + index; + if (DUK_UNLIKELY(index < 0)) { + return NULL; + } + } else { + DUK_ASSERT(index != DUK_INVALID_INDEX); + if (DUK_UNLIKELY(index >= vs_size)) { + return NULL; + } + } + + DUK_ASSERT(index >= 0); + DUK_ASSERT(index < vs_size); + return thr->valstack_bottom + index; +} + +DUK_INTERNAL duk_tval *duk_require_tval(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t vs_size; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(DUK_INVALID_INDEX < 0); + + vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); + DUK_ASSERT(vs_size >= 0); + + if (index < 0) { + index = vs_size + index; + if (DUK_UNLIKELY(index < 0)) { + goto invalid_index; + } + } else { + DUK_ASSERT(index != DUK_INVALID_INDEX); + if (DUK_UNLIKELY(index >= vs_size)) { + goto invalid_index; + } + } + + DUK_ASSERT(index >= 0); + DUK_ASSERT(index < vs_size); + return thr->valstack_bottom + index; + + invalid_index: + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); + return NULL; +} + +/* Non-critical. */ +DUK_EXTERNAL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(DUK_INVALID_INDEX < 0); + + return (duk_normalize_index(ctx, index) >= 0); +} + +/* Non-critical. */ +DUK_EXTERNAL void duk_require_valid_index(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(DUK_INVALID_INDEX < 0); + + if (duk_normalize_index(ctx, index) < 0) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); + } +} + +/* + * Value stack top handling + */ + +DUK_EXTERNAL duk_idx_t duk_get_top(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + + return (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); +} + +/* set stack top within currently allocated range, but don't reallocate */ +DUK_EXTERNAL void duk_set_top(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t vs_size; + duk_idx_t vs_limit; + duk_idx_t count; + duk_tval tv_tmp; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(DUK_INVALID_INDEX < 0); + + vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); + vs_limit = (duk_idx_t) (thr->valstack_end - thr->valstack_bottom); + + if (index < 0) { + /* Negative indices are always within allocated stack but + * must not go below zero index. + */ + index = vs_size + index; + if (index < 0) { + /* Also catches index == DUK_INVALID_INDEX. */ + goto invalid_index; + } + } else { + /* Positive index can be higher than valstack top but must + * not go above allocated stack (equality is OK). + */ + if (index > vs_limit) { + goto invalid_index; + } + } + DUK_ASSERT(index >= 0); + DUK_ASSERT(index <= vs_limit); + + if (index >= vs_size) { + /* Stack size increases or stays the same. Fill the new + * entries (if any) with undefined. No pointer stability + * issues here so we can use a running pointer. + */ + + tv = thr->valstack_top; + count = index - vs_size; + DUK_ASSERT(count >= 0); + while (count > 0) { + /* no need to decref previous or new value */ + count--; + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv)); + DUK_TVAL_SET_UNDEFINED_ACTUAL(tv); + tv++; + } + thr->valstack_top = tv; + } else { + /* Stack size decreases, DECREF entries which are above the + * new top. Each DECREF potentially invalidates valstack + * pointers, so don't hold on to pointers. The valstack top + * must also be updated on every loop in case a GC is triggered. + */ + + /* XXX: Here it would be useful to have a DECREF macro which + * doesn't need a NULL check, and does refzero queueing without + * running the refzero algorithm. There would be no pointer + * instability in this case, and code could be inlined. After + * the loop, one call to refzero would be needed. + */ + + count = vs_size - index; + DUK_ASSERT(count > 0); + + while (count > 0) { + count--; + tv = --thr->valstack_top; /* tv -> value just before prev top value */ + DUK_ASSERT(tv >= thr->valstack_bottom); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_UNDEFINED_UNUSED(tv); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + /* XXX: fast primitive to set a bunch of values to UNDEFINED_UNUSED */ + + } + } + return; + + invalid_index: + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); +} + +DUK_EXTERNAL duk_idx_t duk_get_top_index(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + + ret = ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1; + if (DUK_UNLIKELY(ret < 0)) { + /* Return invalid index; if caller uses this without checking + * in another API call, the index won't map to a valid stack + * entry. + */ + return DUK_INVALID_INDEX; + } + return ret; +} + +DUK_EXTERNAL duk_idx_t duk_require_top_index(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + + ret = ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1; + if (DUK_UNLIKELY(ret < 0)) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); + } + return ret; +} + +/* + * Value stack resizing. + * + * This resizing happens above the current "top": the value stack can be + * grown or shrunk, but the "top" is not affected. The value stack cannot + * be resized to a size below the current "top". + * + * The low level reallocation primitive must carefully recompute all value + * stack pointers, and must also work if ALL pointers are NULL. The resize + * is quite tricky because the valstack realloc may cause a mark-and-sweep, + * which may run finalizers. Running finalizers may resize the valstack + * recursively (the same value stack we're working on). So, after realloc + * returns, we know that the valstack "top" should still be the same (there + * should not be live values above the "top"), but its underlying size and + * pointer may have changed. + */ + +/* XXX: perhaps refactor this to allow caller to specify some parameters, or + * at least a 'compact' flag which skips any spare or round-up .. useful for + * emergency gc. + */ + +DUK_LOCAL duk_bool_t duk__resize_valstack(duk_context *ctx, duk_size_t new_size) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_ptrdiff_t old_bottom_offset; + duk_ptrdiff_t old_top_offset; + duk_ptrdiff_t old_end_offset_post; +#ifdef DUK_USE_DEBUG + duk_ptrdiff_t old_end_offset_pre; + duk_tval *old_valstack_pre; + duk_tval *old_valstack_post; +#endif + duk_tval *new_valstack; + duk_tval *p; + duk_size_t new_alloc_size; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack) <= new_size); /* can't resize below 'top' */ + DUK_ASSERT(new_size <= thr->valstack_max); /* valstack limit caller has check, prevents wrapping */ + DUK_ASSERT(new_size <= DUK_SIZE_MAX / sizeof(duk_tval)); /* specific assert for wrapping */ + + /* get pointer offsets for tweaking below */ + old_bottom_offset = (((duk_uint8_t *) thr->valstack_bottom) - ((duk_uint8_t *) thr->valstack)); + old_top_offset = (((duk_uint8_t *) thr->valstack_top) - ((duk_uint8_t *) thr->valstack)); +#ifdef DUK_USE_DEBUG + old_end_offset_pre = (((duk_uint8_t *) thr->valstack_end) - ((duk_uint8_t *) thr->valstack)); /* not very useful, used for debugging */ + old_valstack_pre = thr->valstack; +#endif + + /* Allocate a new valstack. + * + * Note: cannot use a plain DUK_REALLOC() because a mark-and-sweep may + * invalidate the original thr->valstack base pointer inside the realloc + * process. See doc/memory-management.rst. + */ + + new_alloc_size = sizeof(duk_tval) * new_size; + new_valstack = (duk_tval *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_valstack_ptr, (void *) thr, new_alloc_size); + if (!new_valstack) { + /* Because new_size != 0, if condition doesn't need to be + * (new_valstack != NULL || new_size == 0). + */ + DUK_ASSERT(new_size != 0); + DUK_D(DUK_DPRINT("failed to resize valstack to %lu entries (%lu bytes)", + (unsigned long) new_size, (unsigned long) new_alloc_size)); + return 0; + } + + /* Note: the realloc may have triggered a mark-and-sweep which may + * have resized our valstack internally. However, the mark-and-sweep + * MUST NOT leave the stack bottom/top in a different state. Particular + * assumptions and facts: + * + * - The thr->valstack pointer may be different after realloc, + * and the offset between thr->valstack_end <-> thr->valstack + * may have changed. + * - The offset between thr->valstack_bottom <-> thr->valstack + * and thr->valstack_top <-> thr->valstack MUST NOT have changed, + * because mark-and-sweep must adhere to a strict stack policy. + * In other words, logical bottom and top MUST NOT have changed. + * - All values above the top are unreachable but are initialized + * to UNDEFINED_UNUSED, up to the post-realloc valstack_end. + * - 'old_end_offset' must be computed after realloc to be correct. + */ + + DUK_ASSERT((((duk_uint8_t *) thr->valstack_bottom) - ((duk_uint8_t *) thr->valstack)) == old_bottom_offset); + DUK_ASSERT((((duk_uint8_t *) thr->valstack_top) - ((duk_uint8_t *) thr->valstack)) == old_top_offset); + + /* success, fixup pointers */ + old_end_offset_post = (((duk_uint8_t *) thr->valstack_end) - ((duk_uint8_t *) thr->valstack)); /* must be computed after realloc */ +#ifdef DUK_USE_DEBUG + old_valstack_post = thr->valstack; +#endif + thr->valstack = new_valstack; + thr->valstack_end = new_valstack + new_size; + thr->valstack_bottom = (duk_tval *) (void *) ((duk_uint8_t *) new_valstack + old_bottom_offset); + thr->valstack_top = (duk_tval *) (void *) ((duk_uint8_t *) new_valstack + old_top_offset); + + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + + /* useful for debugging */ +#ifdef DUK_USE_DEBUG + if (old_end_offset_pre != old_end_offset_post) { + DUK_D(DUK_DPRINT("valstack was resized during valstack_resize(), probably by mark-and-sweep; " + "end offset changed: %lu -> %lu", + (unsigned long) old_end_offset_pre, + (unsigned long) old_end_offset_post)); + } + if (old_valstack_pre != old_valstack_post) { + DUK_D(DUK_DPRINT("valstack pointer changed during valstack_resize(), probably by mark-and-sweep: %p -> %p", + (void *) old_valstack_pre, + (void *) old_valstack_post)); + } +#endif + + DUK_DD(DUK_DDPRINT("resized valstack to %lu elements (%lu bytes), bottom=%ld, top=%ld, " + "new pointers: start=%p end=%p bottom=%p top=%p", + (unsigned long) new_size, (unsigned long) new_alloc_size, + (long) (thr->valstack_bottom - thr->valstack), + (long) (thr->valstack_top - thr->valstack), + (void *) thr->valstack, (void *) thr->valstack_end, + (void *) thr->valstack_bottom, (void *) thr->valstack_top)); + + /* init newly allocated slots (only) */ + p = (duk_tval *) (void *) ((duk_uint8_t *) thr->valstack + old_end_offset_post); + while (p < thr->valstack_end) { + /* never executed if new size is smaller */ + DUK_TVAL_SET_UNDEFINED_UNUSED(p); + p++; + } + + /* assertion check: we maintain elements above top in known state */ +#ifdef DUK_USE_ASSERTIONS + p = thr->valstack_top; + while (p < thr->valstack_end) { + /* everything above old valstack top should be preinitialized now */ + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(p)); + p++; + } +#endif + return 1; +} + +DUK_INTERNAL +duk_bool_t duk_valstack_resize_raw(duk_context *ctx, + duk_size_t min_new_size, + duk_small_uint_t flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_size_t old_size; + duk_size_t new_size; + duk_bool_t is_shrink = 0; + duk_small_uint_t shrink_flag = (flags & DUK_VSRESIZE_FLAG_SHRINK); + duk_small_uint_t compact_flag = (flags & DUK_VSRESIZE_FLAG_COMPACT); + duk_small_uint_t throw_flag = (flags & DUK_VSRESIZE_FLAG_THROW); + + DUK_DDD(DUK_DDDPRINT("check valstack resize: min_new_size=%lu, curr_size=%ld, curr_top=%ld, " + "curr_bottom=%ld, shrink=%d, compact=%d, throw=%d", + (unsigned long) min_new_size, + (long) (thr->valstack_end - thr->valstack), + (long) (thr->valstack_top - thr->valstack), + (long) (thr->valstack_bottom - thr->valstack), + (int) shrink_flag, (int) compact_flag, (int) throw_flag)); + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + + old_size = (duk_size_t) (thr->valstack_end - thr->valstack); + + if (min_new_size <= old_size) { + is_shrink = 1; + if (!shrink_flag || + old_size - min_new_size < DUK_VALSTACK_SHRINK_THRESHOLD) { + DUK_DDD(DUK_DDDPRINT("no need to grow or shrink valstack")); + return 1; + } + } + + new_size = min_new_size; + if (!compact_flag) { + if (is_shrink) { + /* shrink case; leave some spare */ + new_size += DUK_VALSTACK_SHRINK_SPARE; + } + + /* round up roughly to next 'grow step' */ + new_size = (new_size / DUK_VALSTACK_GROW_STEP + 1) * DUK_VALSTACK_GROW_STEP; + } + + DUK_DD(DUK_DDPRINT("want to %s valstack: %lu -> %lu elements (min_new_size %lu)", + (const char *) (new_size > old_size ? "grow" : "shrink"), + (unsigned long) old_size, (unsigned long) new_size, + (unsigned long) min_new_size)); + + if (new_size > thr->valstack_max) { + /* Note: may be triggered even if minimal new_size would not reach the limit, + * plan limit accordingly (taking DUK_VALSTACK_GROW_STEP into account). + */ + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_VALSTACK_LIMIT); + } else { + return 0; + } + } + + /* + * When resizing the valstack, a mark-and-sweep may be triggered for + * the allocation of the new valstack. If the mark-and-sweep needs + * to use our thread for something, it may cause *the same valstack* + * to be resized recursively. This happens e.g. when mark-and-sweep + * finalizers are called. This is taken into account carefully in + * duk__resize_valstack(). + * + * 'new_size' is known to be <= valstack_max, which ensures that + * size_t and pointer arithmetic won't wrap in duk__resize_valstack(). + */ + + if (!duk__resize_valstack(ctx, new_size)) { + if (is_shrink) { + DUK_DD(DUK_DDPRINT("valstack resize failed, but is a shrink, ignore")); + return 1; + } + + DUK_DD(DUK_DDPRINT("valstack resize failed")); + + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_FAILED_TO_EXTEND_VALSTACK); + } else { + return 0; + } + } + + DUK_DDD(DUK_DDDPRINT("valstack resize successful")); + return 1; +} + +DUK_EXTERNAL duk_bool_t duk_check_stack(duk_context *ctx, duk_idx_t extra) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_size_t min_new_size; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + + if (DUK_UNLIKELY(extra < 0)) { + /* Clamping to zero makes the API more robust to calling code + * calculation errors. + */ + extra = 0; + } + + min_new_size = (thr->valstack_top - thr->valstack) + extra + DUK_VALSTACK_INTERNAL_EXTRA; + return duk_valstack_resize_raw(ctx, + min_new_size, /* min_new_size */ + 0 /* no shrink */ | /* flags */ + 0 /* no compact */ | + 0 /* no throw */); +} + +DUK_EXTERNAL void duk_require_stack(duk_context *ctx, duk_idx_t extra) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_size_t min_new_size; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + + if (DUK_UNLIKELY(extra < 0)) { + /* Clamping to zero makes the API more robust to calling code + * calculation errors. + */ + extra = 0; + } + + min_new_size = (thr->valstack_top - thr->valstack) + extra + DUK_VALSTACK_INTERNAL_EXTRA; + (void) duk_valstack_resize_raw(ctx, + min_new_size, /* min_new_size */ + 0 /* no shrink */ | /* flags */ + 0 /* no compact */ | + DUK_VSRESIZE_FLAG_THROW); +} + +DUK_EXTERNAL duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top) { + duk_size_t min_new_size; + + DUK_ASSERT_CTX_VALID(ctx); + + if (DUK_UNLIKELY(top < 0)) { + /* Clamping to zero makes the API more robust to calling code + * calculation errors. + */ + top = 0; + } + + min_new_size = top + DUK_VALSTACK_INTERNAL_EXTRA; + return duk_valstack_resize_raw(ctx, + min_new_size, /* min_new_size */ + 0 /* no shrink */ | /* flags */ + 0 /* no compact */ | + 0 /* no throw */); +} + +DUK_EXTERNAL void duk_require_stack_top(duk_context *ctx, duk_idx_t top) { + duk_size_t min_new_size; + + DUK_ASSERT_CTX_VALID(ctx); + + if (DUK_UNLIKELY(top < 0)) { + /* Clamping to zero makes the API more robust to calling code + * calculation errors. + */ + top = 0; + } + + min_new_size = top + DUK_VALSTACK_INTERNAL_EXTRA; + (void) duk_valstack_resize_raw(ctx, + min_new_size, /* min_new_size */ + 0 /* no shrink */ | /* flags */ + 0 /* no compact */ | + DUK_VSRESIZE_FLAG_THROW); +} + +/* + * Basic stack manipulation: swap, dup, insert, replace, etc + */ + +DUK_EXTERNAL void duk_swap(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) { + duk_tval *tv1; + duk_tval *tv2; + duk_tval tv_tmp; + + DUK_ASSERT_CTX_VALID(ctx); + + tv1 = duk_require_tval(ctx, index1); + DUK_ASSERT(tv1 != NULL); + tv2 = duk_require_tval(ctx, index2); + DUK_ASSERT(tv2 != NULL); + + /* If tv1==tv2 this is a NOP, no check is needed */ + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, tv2); + DUK_TVAL_SET_TVAL(tv2, &tv_tmp); +} + +DUK_EXTERNAL void duk_swap_top(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + + duk_swap(ctx, index, -1); +} + +DUK_EXTERNAL void duk_dup(duk_context *ctx, duk_idx_t from_index) { + duk_hthread *thr; + duk_tval *tv_from; + duk_tval *tv_to; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + + tv_from = duk_require_tval(ctx, from_index); + tv_to = thr->valstack_top++; + DUK_ASSERT(tv_from != NULL); + DUK_ASSERT(tv_to != NULL); + DUK_TVAL_SET_TVAL(tv_to, tv_from); + DUK_TVAL_INCREF(thr, tv_to); /* no side effects */ +} + +DUK_EXTERNAL void duk_dup_top(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv_from; + duk_tval *tv_to; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + + if (thr->valstack_top - thr->valstack_bottom <= 0) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); + } + tv_from = thr->valstack_top - 1; + tv_to = thr->valstack_top++; + DUK_ASSERT(tv_from != NULL); + DUK_ASSERT(tv_to != NULL); + DUK_TVAL_SET_TVAL(tv_to, tv_from); + DUK_TVAL_INCREF(thr, tv_to); /* no side effects */ +} + +DUK_EXTERNAL void duk_insert(duk_context *ctx, duk_idx_t to_index) { + duk_tval *p; + duk_tval *q; + duk_tval tv_tmp; + duk_size_t nbytes; + + DUK_ASSERT_CTX_VALID(ctx); + + p = duk_require_tval(ctx, to_index); + DUK_ASSERT(p != NULL); + q = duk_require_tval(ctx, -1); + DUK_ASSERT(q != NULL); + + DUK_ASSERT(q >= p); + + /* nbytes + * <---------> + * [ ... | p | x | x | q ] + * => [ ... | q | p | x | x ] + */ + + nbytes = (duk_size_t) (((duk_uint8_t *) q) - ((duk_uint8_t *) p)); /* Note: 'q' is top-1 */ + + DUK_DDD(DUK_DDDPRINT("duk_insert: to_index=%ld, p=%p, q=%p, nbytes=%lu", + (long) to_index, (void *) p, (void *) q, (unsigned long) nbytes)); + + /* No net refcount changes. */ + + if (nbytes > 0) { + DUK_TVAL_SET_TVAL(&tv_tmp, q); + DUK_ASSERT(nbytes > 0); + DUK_MEMMOVE((void *) (p + 1), (void *) p, nbytes); + DUK_TVAL_SET_TVAL(p, &tv_tmp); + } else { + /* nop: insert top to top */ + DUK_ASSERT(nbytes == 0); + DUK_ASSERT(p == q); + } +} + +DUK_EXTERNAL void duk_replace(duk_context *ctx, duk_idx_t to_index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv1; + duk_tval *tv2; + duk_tval tv_tmp; + + DUK_ASSERT_CTX_VALID(ctx); + + tv1 = duk_require_tval(ctx, -1); + DUK_ASSERT(tv1 != NULL); + tv2 = duk_require_tval(ctx, to_index); + DUK_ASSERT(tv2 != NULL); + + /* For tv1 == tv2, both pointing to stack top, the end result + * is same as duk_pop(ctx). + */ + + DUK_TVAL_SET_TVAL(&tv_tmp, tv2); + DUK_TVAL_SET_TVAL(tv2, tv1); + DUK_TVAL_SET_UNDEFINED_UNUSED(tv1); + thr->valstack_top--; + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +} + +DUK_EXTERNAL void duk_copy(duk_context *ctx, duk_idx_t from_index, duk_idx_t to_index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv1; + duk_tval *tv2; + duk_tval tv_tmp; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(thr); /* w/o refcounting */ + + tv1 = duk_require_tval(ctx, from_index); + DUK_ASSERT(tv1 != NULL); + tv2 = duk_require_tval(ctx, to_index); + DUK_ASSERT(tv2 != NULL); + + /* For tv1 == tv2, this is a no-op (no explicit check needed). */ + + DUK_TVAL_SET_TVAL(&tv_tmp, tv2); + DUK_TVAL_SET_TVAL(tv2, tv1); + DUK_TVAL_INCREF(thr, tv2); /* no side effects */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +} + +DUK_EXTERNAL void duk_remove(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *p; + duk_tval *q; +#ifdef DUK_USE_REFERENCE_COUNTING + duk_tval tv_tmp; +#endif + duk_size_t nbytes; + + DUK_ASSERT_CTX_VALID(ctx); + + p = duk_require_tval(ctx, index); + DUK_ASSERT(p != NULL); + q = duk_require_tval(ctx, -1); + DUK_ASSERT(q != NULL); + + DUK_ASSERT(q >= p); + + /* nbytes zero size case + * <---------> + * [ ... | p | x | x | q ] [ ... | p==q ] + * => [ ... | x | x | q ] [ ... ] + */ + +#ifdef DUK_USE_REFERENCE_COUNTING + /* use a temp: decref only when valstack reachable values are correct */ + DUK_TVAL_SET_TVAL(&tv_tmp, p); +#endif + + nbytes = (duk_size_t) (((duk_uint8_t *) q) - ((duk_uint8_t *) p)); /* Note: 'q' is top-1 */ + DUK_MEMMOVE(p, p + 1, nbytes); /* zero size not an issue: pointers are valid */ + + DUK_TVAL_SET_UNDEFINED_UNUSED(q); + thr->valstack_top--; + +#ifdef DUK_USE_REFERENCE_COUNTING + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +#endif +} + +/* + * Stack slice primitives + */ + +DUK_EXTERNAL void duk_xcopymove_raw(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count, duk_bool_t is_copy) { + duk_hthread *to_thr = (duk_hthread *) to_ctx; + duk_hthread *from_thr = (duk_hthread *) from_ctx; + void *src; + duk_size_t nbytes; + duk_tval *p; + duk_tval *q; + + /* XXX: several pointer comparison issues here */ + + DUK_ASSERT_CTX_VALID(to_ctx); + DUK_ASSERT_CTX_VALID(from_ctx); + DUK_ASSERT(to_ctx != NULL); + DUK_ASSERT(from_ctx != NULL); + + if (to_ctx == from_ctx) { + DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CONTEXT); + return; + } + if ((count < 0) || + (count > (duk_idx_t) to_thr->valstack_max)) { + /* Maximum value check ensures 'nbytes' won't wrap below. */ + DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT); + return; + } + + nbytes = sizeof(duk_tval) * count; + if (nbytes == 0) { + return; + } + DUK_ASSERT(to_thr->valstack_top <= to_thr->valstack_end); + if ((duk_size_t) ((duk_uint8_t *) to_thr->valstack_end - (duk_uint8_t *) to_thr->valstack_top) < nbytes) { + DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + } + src = (void *) ((duk_uint8_t *) from_thr->valstack_top - nbytes); + if (src < (void *) from_thr->valstack_bottom) { + DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT); + } + + /* copy values (no overlap even if to_ctx == from_ctx; that's not + * allowed now anyway) + */ + DUK_ASSERT(nbytes > 0); + DUK_MEMCPY((void *) to_thr->valstack_top, src, nbytes); + + p = to_thr->valstack_top; + to_thr->valstack_top = (duk_tval *) (void *) (((duk_uint8_t *) p) + nbytes); + + if (is_copy) { + /* incref copies, keep originals */ + q = to_thr->valstack_top; + while (p < q) { + DUK_TVAL_INCREF(to_thr, p); /* no side effects */ + p++; + } + } else { + /* no net refcount change */ + p = from_thr->valstack_top; + q = (duk_tval *) (void *) (((duk_uint8_t *) p) - nbytes); + from_thr->valstack_top = q; + + /* elements above stack top are kept UNUSED */ + while (p > q) { + p--; + DUK_TVAL_SET_UNDEFINED_UNUSED(p); + + /* XXX: fast primitive to set a bunch of values to UNDEFINED_UNUSED */ + } + } +} + +/* + * Get/require + */ + +DUK_EXTERNAL void duk_require_undefined(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_UNDEFINED(tv)) { + /* Note: accept both 'actual' and 'unused' undefined */ + return; + } + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_UNDEFINED); +} + +DUK_EXTERNAL void duk_require_null(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_NULL(tv)) { + return; + } + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NULL); + return; /* not reachable */ +} + +DUK_EXTERNAL duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t index) { + duk_bool_t ret = 0; /* default: false */ + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_BOOLEAN(tv)) { + ret = DUK_TVAL_GET_BOOLEAN(tv); + } + + DUK_ASSERT(ret == 0 || ret == 1); + return ret; +} + +DUK_EXTERNAL duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_BOOLEAN(tv)) { + duk_bool_t ret = DUK_TVAL_GET_BOOLEAN(tv); + DUK_ASSERT(ret == 0 || ret == 1); + return ret; + } + + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_BOOLEAN); + return 0; /* not reachable */ +} + +DUK_EXTERNAL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t index) { + duk_double_union ret; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + ret.d = DUK_DOUBLE_NAN; /* default: NaN */ + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_NUMBER(tv)) { + ret.d = DUK_TVAL_GET_NUMBER(tv); + } + + /* + * Number should already be in NaN-normalized form, but let's + * normalize anyway. + */ + + DUK_DBLUNION_NORMALIZE_NAN_CHECK(&ret); + return ret.d; +} + +DUK_EXTERNAL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_NUMBER(tv)) { + duk_double_union ret; + ret.d = DUK_TVAL_GET_NUMBER(tv); + + /* + * Number should already be in NaN-normalized form, + * but let's normalize anyway. + */ + + DUK_DBLUNION_NORMALIZE_NAN_CHECK(&ret); + return ret.d; + } + + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NUMBER); + return DUK_DOUBLE_NAN; /* not reachable */ +} + +DUK_EXTERNAL duk_int_t duk_get_int(duk_context *ctx, duk_idx_t index) { + /* Custom coercion for API */ + DUK_ASSERT_CTX_VALID(ctx); + return (duk_int_t) duk__api_coerce_d2i(ctx, index, 0 /*require*/); +} + +DUK_EXTERNAL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t index) { + /* Custom coercion for API */ + DUK_ASSERT_CTX_VALID(ctx); + return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 0 /*require*/); +} + +DUK_EXTERNAL duk_int_t duk_require_int(duk_context *ctx, duk_idx_t index) { + /* Custom coercion for API */ + DUK_ASSERT_CTX_VALID(ctx); + return (duk_int_t) duk__api_coerce_d2i(ctx, index, 1 /*require*/); +} + +DUK_EXTERNAL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index) { + /* Custom coercion for API */ + DUK_ASSERT_CTX_VALID(ctx); + return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 1 /*require*/); +} + +DUK_EXTERNAL const char *duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) { + const char *ret; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + /* default: NULL, length 0 */ + ret = NULL; + if (out_len) { + *out_len = 0; + } + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_STRING(tv)) { + /* Here we rely on duk_hstring instances always being zero + * terminated even if the actual string is not. + */ + duk_hstring *h = DUK_TVAL_GET_STRING(tv); + DUK_ASSERT(h != NULL); + ret = (const char *) DUK_HSTRING_GET_DATA(h); + if (out_len) { + *out_len = DUK_HSTRING_GET_BYTELEN(h); + } + } + + return ret; +} + +DUK_EXTERNAL const char *duk_require_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) { + duk_hthread *thr = (duk_hthread *) ctx; + const char *ret; + + DUK_ASSERT_CTX_VALID(ctx); + + /* Note: this check relies on the fact that even a zero-size string + * has a non-NULL pointer. + */ + ret = duk_get_lstring(ctx, index, out_len); + if (ret) { + return ret; + } + + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_STRING); + return NULL; /* not reachable */ +} + +DUK_EXTERNAL const char *duk_get_string(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + + return duk_get_lstring(ctx, index, NULL); +} + +DUK_EXTERNAL const char *duk_require_string(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + + return duk_require_lstring(ctx, index, NULL); +} + +DUK_EXTERNAL void *duk_get_pointer(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_POINTER(tv)) { + void *p = DUK_TVAL_GET_POINTER(tv); /* may be NULL */ + return (void *) p; + } + + return NULL; +} + +DUK_EXTERNAL void *duk_require_pointer(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + /* Note: here we must be wary of the fact that a pointer may be + * valid and be a NULL. + */ + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_POINTER(tv)) { + void *p = DUK_TVAL_GET_POINTER(tv); /* may be NULL */ + return (void *) p; + } + + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_POINTER); + return NULL; /* not reachable */ +} + +#if 0 /*unused*/ +DUK_INTERNAL void *duk_get_voidptr(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { + duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv); + DUK_ASSERT(h != NULL); + return (void *) h; + } + + return NULL; +} +#endif + +DUK_LOCAL void *duk__get_buffer_helper(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_bool_t throw_flag) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(thr); + + if (out_size != NULL) { + *out_size = 0; + } + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_BUFFER(tv)) { + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h != NULL); + if (out_size) { + *out_size = DUK_HBUFFER_GET_SIZE(h); + } + return (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h); /* may be NULL (but only if size is 0) */ + } + + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_BUFFER); + } + return NULL; +} + +DUK_EXTERNAL void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + return duk__get_buffer_helper(ctx, index, out_size, 0 /*throw_flag*/); +} + +DUK_EXTERNAL void *duk_require_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + return duk__get_buffer_helper(ctx, index, out_size, 1 /*throw_flag*/); +} + +DUK_LOCAL void *duk__get_buffer_data_helper(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_bool_t throw_flag) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(thr); + + if (out_size != NULL) { + *out_size = 0; + } + + tv = duk_get_tval(ctx, index); + if (tv == NULL) { + goto fail; + } + + if (DUK_TVAL_IS_BUFFER(tv)) { + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h != NULL); + if (out_size) { + *out_size = DUK_HBUFFER_GET_SIZE(h); + } + return (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h); /* may be NULL (but only if size is 0) */ + } else if (DUK_TVAL_IS_OBJECT(tv)) { + duk_hobject *h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + /* XXX: this is probably a useful shared helper: for a + * duk_hbufferobject, get a validated buffer pointer/length. + */ + duk_hbufferobject *h_bufobj = (duk_hbufferobject *) h; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + if (h_bufobj->buf != NULL && + DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)) { + duk_uint8_t *p; + + p = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf); + if (out_size != NULL) { + *out_size = (duk_size_t) h_bufobj->length; + } + return (void *) (p + h_bufobj->offset); + } + /* if slice not fully valid, treat as error */ + } + } + + fail: + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_BUFFER); + } + return NULL; +} + +DUK_EXTERNAL void *duk_get_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + return duk__get_buffer_data_helper(ctx, index, out_size, 0 /*throw_flag*/); +} + +DUK_EXTERNAL void *duk_require_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + return duk__get_buffer_data_helper(ctx, index, out_size, 1 /*throw_flag*/); +} + +/* Raw helper for getting a value from the stack, checking its tag, and possible its object class. + * The tag cannot be a number because numbers don't have an internal tag in the packed representation. + */ +DUK_INTERNAL duk_heaphdr *duk_get_tagged_heaphdr_raw(duk_context *ctx, duk_idx_t index, duk_uint_t flags_and_tag) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_small_uint_t tag = flags_and_tag & 0xffffU; /* tags can be up to 16 bits */ + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && (DUK_TVAL_GET_TAG(tv) == tag)) { + duk_heaphdr *ret; + + /* Note: tag comparison in general doesn't work for numbers, + * but it does work for everything else (heap objects here). + */ + ret = DUK_TVAL_GET_HEAPHDR(tv); + DUK_ASSERT(ret != NULL); /* tagged null pointers should never occur */ + + /* If class check has been requested, tag must also be DUK_TAG_OBJECT. + * This allows us to just check the class check flag without checking + * the tag also. + */ + DUK_ASSERT((flags_and_tag & DUK_GETTAGGED_FLAG_CHECK_CLASS) == 0 || + tag == DUK_TAG_OBJECT); + + if ((flags_and_tag & DUK_GETTAGGED_FLAG_CHECK_CLASS) == 0 || /* no class check */ + (duk_int_t) DUK_HOBJECT_GET_CLASS_NUMBER((duk_hobject *) ret) == /* or class check matches */ + (duk_int_t) ((flags_and_tag >> DUK_GETTAGGED_CLASS_SHIFT) & 0xff)) { + return ret; + } + } + + if (flags_and_tag & DUK_GETTAGGED_FLAG_ALLOW_NULL) { + return (duk_heaphdr *) NULL; + } + + /* Formatting the tag number here is not very useful: the tag value + * is Duktape internal (not the same as DUK_TYPE_xxx) and even depends + * on the duk_tval layout. If anything, add a human readable type here. + */ + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE); + return NULL; /* not reachable */ +} + +DUK_INTERNAL duk_hstring *duk_get_hstring(duk_context *ctx, duk_idx_t index) { + return (duk_hstring *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING | DUK_GETTAGGED_FLAG_ALLOW_NULL); +} + +DUK_INTERNAL duk_hstring *duk_require_hstring(duk_context *ctx, duk_idx_t index) { + return (duk_hstring *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING); +} + +DUK_INTERNAL duk_hobject *duk_get_hobject(duk_context *ctx, duk_idx_t index) { + return (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL); +} + +DUK_INTERNAL duk_hobject *duk_require_hobject(duk_context *ctx, duk_idx_t index) { + return (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); +} + +DUK_INTERNAL duk_hbuffer *duk_get_hbuffer(duk_context *ctx, duk_idx_t index) { + return (duk_hbuffer *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER | DUK_GETTAGGED_FLAG_ALLOW_NULL); +} + +DUK_INTERNAL duk_hbuffer *duk_require_hbuffer(duk_context *ctx, duk_idx_t index) { + return (duk_hbuffer *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER); +} + +DUK_INTERNAL duk_hthread *duk_get_hthread(duk_context *ctx, duk_idx_t index) { + duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL); + if (h != NULL && !DUK_HOBJECT_IS_THREAD(h)) { + h = NULL; + } + return (duk_hthread *) h; +} + +DUK_INTERNAL duk_hthread *duk_require_hthread(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); + DUK_ASSERT(h != NULL); + if (!DUK_HOBJECT_IS_THREAD(h)) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_THREAD); + } + return (duk_hthread *) h; +} + +DUK_INTERNAL duk_hcompiledfunction *duk_get_hcompiledfunction(duk_context *ctx, duk_idx_t index) { + duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL); + if (h != NULL && !DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) { + h = NULL; + } + return (duk_hcompiledfunction *) h; +} + +DUK_INTERNAL duk_hcompiledfunction *duk_require_hcompiledfunction(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); + DUK_ASSERT(h != NULL); + if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_COMPILEDFUNCTION); + } + return (duk_hcompiledfunction *) h; +} + +DUK_INTERNAL duk_hnativefunction *duk_get_hnativefunction(duk_context *ctx, duk_idx_t index) { + duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL); + if (h != NULL && !DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { + h = NULL; + } + return (duk_hnativefunction *) h; +} + +DUK_INTERNAL duk_hnativefunction *duk_require_hnativefunction(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); + DUK_ASSERT(h != NULL); + if (!DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NATIVEFUNCTION); + } + return (duk_hnativefunction *) h; +} + +DUK_EXTERNAL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + duk_hobject *h; + duk_hnativefunction *f; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (!tv) { + return NULL; + } + if (!DUK_TVAL_IS_OBJECT(tv)) { + return NULL; + } + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + + if (!DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { + return NULL; + } + DUK_ASSERT(DUK_HOBJECT_HAS_NATIVEFUNCTION(h)); + f = (duk_hnativefunction *) h; + + return f->func; +} + +DUK_EXTERNAL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_c_function ret; + + DUK_ASSERT_CTX_VALID(ctx); + + ret = duk_get_c_function(ctx, index); + if (!ret) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_C_FUNCTION); + } + return ret; +} + +DUK_EXTERNAL duk_context *duk_get_context(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + + return (duk_context *) duk_get_hthread(ctx, index); +} + +DUK_EXTERNAL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + + return (duk_context *) duk_require_hthread(ctx, index); +} + +DUK_EXTERNAL void *duk_get_heapptr(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + void *ret; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { + ret = (void *) DUK_TVAL_GET_HEAPHDR(tv); + DUK_ASSERT(ret != NULL); + return ret; + } + + return (void *) NULL; +} + +DUK_EXTERNAL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + void *ret; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { + ret = (void *) DUK_TVAL_GET_HEAPHDR(tv); + DUK_ASSERT(ret != NULL); + return ret; + } + + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE); + return (void *) NULL; /* not reachable */ +} + +#if 0 +/* This would be pointless: we'd return NULL for both lightfuncs and + * unexpected types. + */ +duk_hobject *duk_get_hobject_or_lfunc(duk_context *ctx, duk_idx_t index) { +} +#endif + +/* Useful for internal call sites where we either expect an object (function) + * or a lightfunc. Accepts an object (returned as is) or a lightfunc (coerced + * to an object). Return value is NULL if value is neither an object nor a + * lightfunc. + */ +duk_hobject *duk_get_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + if (DUK_TVAL_IS_OBJECT(tv)) { + return DUK_TVAL_GET_OBJECT(tv); + } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) { + duk_to_object(ctx, index); + return duk_require_hobject(ctx, index); + } + + return NULL; +} + +/* Useful for internal call sites where we either expect an object (function) + * or a lightfunc. Returns NULL for a lightfunc. + */ +DUK_INTERNAL duk_hobject *duk_require_hobject_or_lfunc(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + if (DUK_TVAL_IS_OBJECT(tv)) { + return DUK_TVAL_GET_OBJECT(tv); + } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) { + return NULL; + } + + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE); + return NULL; /* not reachable */ +} + +/* Useful for internal call sites where we either expect an object (function) + * or a lightfunc. Accepts an object (returned as is) or a lightfunc (coerced + * to an object). Return value is never NULL. + */ +DUK_INTERNAL duk_hobject *duk_require_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_require_tval(ctx, index); + if (DUK_TVAL_IS_OBJECT(tv)) { + return DUK_TVAL_GET_OBJECT(tv); + } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) { + duk_to_object(ctx, index); + return duk_require_hobject(ctx, index); + } + + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE); + return NULL; /* not reachable */ +} + +DUK_EXTERNAL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (!tv) { + return 0; + } + + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: + case DUK_TAG_NULL: + case DUK_TAG_BOOLEAN: + case DUK_TAG_POINTER: + return 0; + case DUK_TAG_STRING: { + duk_hstring *h = DUK_TVAL_GET_STRING(tv); + DUK_ASSERT(h != NULL); + return (duk_size_t) DUK_HSTRING_GET_CHARLEN(h); + } + case DUK_TAG_OBJECT: { + duk_hobject *h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + return (duk_size_t) duk_hobject_get_length((duk_hthread *) ctx, h); + } + case DUK_TAG_BUFFER: { + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h != NULL); + return (duk_size_t) DUK_HBUFFER_GET_SIZE(h); + } + case DUK_TAG_LIGHTFUNC: { + duk_small_uint_t lf_flags; + lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv); + return (duk_size_t) DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags); + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: + /* number */ + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + return 0; + } + + DUK_UNREACHABLE(); +} + +DUK_INTERNAL void duk_set_length(duk_context *ctx, duk_idx_t index, duk_size_t length) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h; + + DUK_ASSERT_CTX_VALID(ctx); + + h = duk_get_hobject(ctx, index); + if (!h) { + return; + } + + duk_hobject_set_length(thr, h, (duk_uint32_t) length); /* XXX: typing */ +} + +/* + * Conversions and coercions + * + * The conversion/coercions are in-place operations on the value stack. + * Some operations are implemented here directly, while others call a + * helper in duk_js_ops.c after validating arguments. + */ + +/* E5 Section 8.12.8 */ + +DUK_LOCAL duk_bool_t duk__defaultvalue_coerce_attempt(duk_context *ctx, duk_idx_t index, duk_small_int_t func_stridx) { + if (duk_get_prop_stridx(ctx, index, func_stridx)) { + /* [ ... func ] */ + if (duk_is_callable(ctx, -1)) { + duk_dup(ctx, index); /* -> [ ... func this ] */ + duk_call_method(ctx, 0); /* -> [ ... retval ] */ + if (duk_is_primitive(ctx, -1)) { + duk_replace(ctx, index); + return 1; + } + /* [ ... retval ]; popped below */ + } + } + duk_pop(ctx); /* [ ... func/retval ] -> [ ... ] */ + return 0; +} + +DUK_EXTERNAL void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int_t hint) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj; + /* inline initializer for coercers[] is not allowed by old compilers like BCC */ + duk_small_int_t coercers[2]; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + + coercers[0] = DUK_STRIDX_VALUE_OF; + coercers[1] = DUK_STRIDX_TO_STRING; + + index = duk_require_normalize_index(ctx, index); + obj = duk_require_hobject_or_lfunc(ctx, index); + + if (hint == DUK_HINT_NONE) { + if (obj != NULL && DUK_HOBJECT_GET_CLASS_NUMBER(obj) == DUK_HOBJECT_CLASS_DATE) { + hint = DUK_HINT_STRING; + } else { + hint = DUK_HINT_NUMBER; + } + } + + if (hint == DUK_HINT_STRING) { + coercers[0] = DUK_STRIDX_TO_STRING; + coercers[1] = DUK_STRIDX_VALUE_OF; + } + + if (duk__defaultvalue_coerce_attempt(ctx, index, coercers[0])) { + return; + } + + if (duk__defaultvalue_coerce_attempt(ctx, index, coercers[1])) { + return; + } + + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_DEFAULTVALUE_COERCE_FAILED); +} + +DUK_EXTERNAL void duk_to_undefined(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_tval tv_tmp; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(thr); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_UNDEFINED_ACTUAL(tv); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +} + +DUK_EXTERNAL void duk_to_null(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_tval tv_tmp; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(thr); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_NULL(tv); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +} + +/* E5 Section 9.1 */ +DUK_EXTERNAL void duk_to_primitive(duk_context *ctx, duk_idx_t index, duk_int_t hint) { + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(hint == DUK_HINT_NONE || hint == DUK_HINT_NUMBER || hint == DUK_HINT_STRING); + + index = duk_require_normalize_index(ctx, index); + + if (!duk_check_type_mask(ctx, index, DUK_TYPE_MASK_OBJECT | + DUK_TYPE_MASK_LIGHTFUNC)) { + /* everything except object stay as is */ + return; + } + duk_to_defaultvalue(ctx, index, hint); +} + +/* E5 Section 9.2 */ +DUK_EXTERNAL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_tval tv_tmp; + duk_bool_t val; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(thr); + + index = duk_require_normalize_index(ctx, index); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + + val = duk_js_toboolean(tv); + DUK_ASSERT(val == 0 || val == 1); + + /* Note: no need to re-lookup tv, conversion is side effect free */ + DUK_ASSERT(tv != NULL); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_BOOLEAN(tv, val); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + return val; +} + +DUK_EXTERNAL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_tval tv_tmp; + duk_double_t d; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + /* XXX: fastint? */ + d = duk_js_tonumber(thr, tv); + + /* Note: need to re-lookup because ToNumber() may have side effects */ + tv = duk_require_tval(ctx, index); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_NUMBER(tv, d); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + return d; +} + +/* XXX: combine all the integer conversions: they share everything + * but the helper function for coercion. + */ + +typedef duk_double_t (*duk__toint_coercer)(duk_hthread *thr, duk_tval *tv); + +DUK_LOCAL duk_double_t duk__to_int_uint_helper(duk_context *ctx, duk_idx_t index, duk__toint_coercer coerce_func) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_tval tv_tmp; + duk_double_t d; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + d = coerce_func(thr, tv); + + /* XXX: fastint? */ + + /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */ + tv = duk_require_tval(ctx, index); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_NUMBER(tv, d); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + return d; +} + +DUK_EXTERNAL duk_int_t duk_to_int(duk_context *ctx, duk_idx_t index) { + /* Value coercion (in stack): ToInteger(), E5 Section 9.4 + * API return value coercion: custom + */ + DUK_ASSERT_CTX_VALID(ctx); + (void) duk__to_int_uint_helper(ctx, index, duk_js_tointeger); + return (duk_int_t) duk__api_coerce_d2i(ctx, index, 0 /*require*/); +} + +DUK_EXTERNAL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t index) { + /* Value coercion (in stack): ToInteger(), E5 Section 9.4 + * API return value coercion: custom + */ + DUK_ASSERT_CTX_VALID(ctx); + (void) duk__to_int_uint_helper(ctx, index, duk_js_tointeger); + return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 0 /*require*/); +} + +DUK_EXTERNAL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_tval tv_tmp; + duk_int32_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + ret = duk_js_toint32(thr, tv); + + /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */ + tv = duk_require_tval(ctx, index); +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_FASTINT_I32(tv, ret); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + return ret; +#else + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_NUMBER(tv, (duk_double_t) ret); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + return ret; +#endif +} + +DUK_EXTERNAL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_tval tv_tmp; + duk_uint32_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + ret = duk_js_touint32(thr, tv); + + /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */ + tv = duk_require_tval(ctx, index); +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_FASTINT_U32(tv, ret); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + return ret; +#else + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_NUMBER(tv, (duk_double_t) ret); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +#endif + return ret; +} + +DUK_EXTERNAL duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_tval tv_tmp; + duk_uint16_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + ret = duk_js_touint16(thr, tv); + + /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */ + tv = duk_require_tval(ctx, index); +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_FASTINT_U32(tv, ret); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + return ret; +#else + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_NUMBER(tv, (duk_double_t) ret); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +#endif + return ret; +} + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Special coercion for Uint8ClampedArray. */ +DUK_INTERNAL duk_uint8_t duk_to_uint8clamped(duk_context *ctx, duk_idx_t index) { + duk_double_t d; + duk_double_t t; + duk_uint8_t ret; + + /* XXX: Simplify this algorithm, should be possible to come up with + * a shorter and faster algorithm by inspecting IEEE representation + * directly. + */ + + d = duk_to_number(ctx, index); + if (d <= 0.0) { + return 0; + } else if (d >= 255) { + return 255; + } else if (DUK_ISNAN(d)) { + /* Avoid NaN-to-integer coercion as it is compiler specific. */ + return 0; + } + + t = d - DUK_FLOOR(d); + if (t == 0.5) { + /* Exact halfway, round to even. */ + ret = (duk_uint8_t) d; + ret = (ret + 1) & 0xfe; /* Example: d=3.5, t=0.5 -> ret = (3 + 1) & 0xfe = 4 & 0xfe = 4 + * Example: d=4.5, t=0.5 -> ret = (4 + 1) & 0xfe = 5 & 0xfe = 4 + */ + } else { + /* Not halfway, round to nearest. */ + ret = (duk_uint8_t) (d + 0.5); + } + return ret; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +DUK_EXTERNAL const char *duk_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) { + DUK_ASSERT_CTX_VALID(ctx); + + (void) duk_to_string(ctx, index); + return duk_require_lstring(ctx, index, out_len); +} + +DUK_LOCAL duk_ret_t duk__safe_to_string_raw(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + + duk_to_string(ctx, -1); + return 1; +} + +DUK_EXTERNAL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) { + DUK_ASSERT_CTX_VALID(ctx); + + index = duk_require_normalize_index(ctx, index); + + /* We intentionally ignore the duk_safe_call() return value and only + * check the output type. This way we don't also need to check that + * the returned value is indeed a string in the success case. + */ + + duk_dup(ctx, index); + (void) duk_safe_call(ctx, duk__safe_to_string_raw, 1 /*nargs*/, 1 /*nrets*/); + if (!duk_is_string(ctx, -1)) { + /* Error: try coercing error to string once. */ + (void) duk_safe_call(ctx, duk__safe_to_string_raw, 1 /*nargs*/, 1 /*nrets*/); + if (!duk_is_string(ctx, -1)) { + /* Double error */ + duk_pop(ctx); + duk_push_hstring_stridx(ctx, DUK_STRIDX_UC_ERROR); + } else { + ; + } + } else { + ; + } + DUK_ASSERT(duk_is_string(ctx, -1)); + + duk_replace(ctx, index); + return duk_require_lstring(ctx, index, out_len); +} + +/* XXX: other variants like uint, u32 etc */ +DUK_INTERNAL duk_int_t duk_to_int_clamped_raw(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval, duk_bool_t *out_clamped) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_tval tv_tmp; + duk_double_t d, dmin, dmax; + duk_int_t res; + duk_bool_t clamped = 0; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + d = duk_js_tointeger(thr, tv); /* E5 Section 9.4, ToInteger() */ + + dmin = (duk_double_t) minval; + dmax = (duk_double_t) maxval; + + if (d < dmin) { + clamped = 1; + res = minval; + d = dmin; + } else if (d > dmax) { + clamped = 1; + res = maxval; + d = dmax; + } else { + res = (duk_int_t) d; + } + /* 'd' and 'res' agree here */ + + /* Relookup in case duk_js_tointeger() ends up e.g. coercing an object. */ + tv = duk_require_tval(ctx, index); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); +#if defined(DUK_USE_FASTINT) +#if (DUK_INT_MAX <= 0x7fffffffL) + DUK_TVAL_SET_FASTINT_I32(tv, res); +#else + /* Clamping needed if duk_int_t is 64 bits. */ + if (res >= DUK_FASTINT_MIN && res <= DUK_FASTINT_MAX) { + DUK_TVAL_SET_FASTINT(tv, res); + } else { + DUK_TVAL_SET_NUMBER(tv, d); + } +#endif +#else + DUK_TVAL_SET_NUMBER(tv, d); /* no need to incref */ +#endif + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + if (out_clamped) { + *out_clamped = clamped; + } else { + /* coerced value is updated to value stack even when RangeError thrown */ + if (clamped) { + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_NUMBER_OUTSIDE_RANGE); + } + } + + return res; +} + +DUK_INTERNAL duk_int_t duk_to_int_clamped(duk_context *ctx, duk_idx_t index, duk_idx_t minval, duk_idx_t maxval) { + duk_bool_t dummy; + return duk_to_int_clamped_raw(ctx, index, minval, maxval, &dummy); +} + +DUK_INTERNAL duk_int_t duk_to_int_check_range(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval) { + return duk_to_int_clamped_raw(ctx, index, minval, maxval, NULL); /* out_clamped==NULL -> RangeError if outside range */ +} + +DUK_EXTERNAL const char *duk_to_string(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(thr); + + index = duk_require_normalize_index(ctx, index); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: { + duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_UNDEFINED); + break; + } + case DUK_TAG_NULL: { + duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_NULL); + break; + } + case DUK_TAG_BOOLEAN: { + if (DUK_TVAL_GET_BOOLEAN(tv)) { + duk_push_hstring_stridx(ctx, DUK_STRIDX_TRUE); + } else { + duk_push_hstring_stridx(ctx, DUK_STRIDX_FALSE); + } + break; + } + case DUK_TAG_STRING: { + /* nop */ + goto skip_replace; + } + case DUK_TAG_OBJECT: { + duk_to_primitive(ctx, index, DUK_HINT_STRING); + return duk_to_string(ctx, index); /* Note: recursive call */ + } + case DUK_TAG_BUFFER: { + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + + /* Note: this allows creation of internal strings. */ + + DUK_ASSERT(h != NULL); + duk_push_lstring(ctx, + (const char *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h), + (duk_size_t) DUK_HBUFFER_GET_SIZE(h)); + break; + } + case DUK_TAG_POINTER: { + void *ptr = DUK_TVAL_GET_POINTER(tv); + if (ptr != NULL) { + duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) ptr); + } else { + /* Represent a null pointer as 'null' to be consistent with + * the JX format variant. Native '%p' format for a NULL + * pointer may be e.g. '(nil)'. + */ + duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_NULL); + } + break; + } + case DUK_TAG_LIGHTFUNC: { + /* Should match Function.prototype.toString() */ + duk_push_lightfunc_tostring(ctx, tv); + break; + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: { + /* number */ + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + duk_push_tval(ctx, tv); + duk_numconv_stringify(ctx, + 10 /*radix*/, + 0 /*precision:shortest*/, + 0 /*force_exponential*/); + break; + } + } + + duk_replace(ctx, index); + + skip_replace: + return duk_require_string(ctx, index); +} + +DUK_INTERNAL duk_hstring *duk_to_hstring(duk_context *ctx, duk_idx_t index) { + duk_hstring *ret; + DUK_ASSERT_CTX_VALID(ctx); + duk_to_string(ctx, index); + ret = duk_get_hstring(ctx, index); + DUK_ASSERT(ret != NULL); + return ret; +} + +DUK_EXTERNAL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_uint_t mode) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hbuffer *h_buf; + const duk_uint8_t *src_data; + duk_size_t src_size; + duk_uint8_t *dst_data; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(thr); + + index = duk_require_normalize_index(ctx, index); + + h_buf = duk_get_hbuffer(ctx, index); + if (h_buf != NULL) { + /* Buffer is kept as is, with the fixed/dynamic nature of the + * buffer only changed if requested. An external buffer + * is converted into a non-external dynamic buffer in a + * duk_to_dynamic_buffer() call. + */ + duk_uint_t tmp; + + src_data = (const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_buf); + src_size = DUK_HBUFFER_GET_SIZE(h_buf); + + tmp = (DUK_HBUFFER_HAS_DYNAMIC(h_buf) ? DUK_BUF_MODE_DYNAMIC : DUK_BUF_MODE_FIXED); + if ((tmp == mode && !DUK_HBUFFER_HAS_EXTERNAL(h_buf)) || + mode == DUK_BUF_MODE_DONTCARE) { + /* Note: src_data may be NULL if input is a zero-size + * dynamic buffer. + */ + dst_data = (duk_uint8_t *) src_data; + goto skip_copy; + } + } else { + /* Non-buffer value is first ToString() coerced, then converted + * to a buffer (fixed buffer is used unless a dynamic buffer is + * explicitly requested). + */ + + src_data = (const duk_uint8_t *) duk_to_lstring(ctx, index, &src_size); + } + + dst_data = (duk_uint8_t *) duk_push_buffer(ctx, src_size, (mode == DUK_BUF_MODE_DYNAMIC) /*dynamic*/); + if (DUK_LIKELY(src_size > 0)) { + /* When src_size == 0, src_data may be NULL (if source + * buffer is dynamic), and dst_data may be NULL (if + * target buffer is dynamic). Avoid zero-size memcpy() + * with an invalid pointer. + */ + DUK_MEMCPY(dst_data, src_data, src_size); + } + duk_replace(ctx, index); + skip_copy: + + if (out_size) { + *out_size = src_size; + } + return dst_data; +} + +DUK_EXTERNAL void *duk_to_pointer(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + void *res; + + DUK_ASSERT_CTX_VALID(ctx); + + index = duk_require_normalize_index(ctx, index); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: + case DUK_TAG_NULL: + case DUK_TAG_BOOLEAN: + res = NULL; + break; + case DUK_TAG_POINTER: + res = DUK_TVAL_GET_POINTER(tv); + break; + case DUK_TAG_STRING: + case DUK_TAG_OBJECT: + case DUK_TAG_BUFFER: + /* Heap allocated: return heap pointer which is NOT useful + * for the caller, except for debugging. + */ + res = (void *) DUK_TVAL_GET_HEAPHDR(tv); + break; + case DUK_TAG_LIGHTFUNC: + /* Function pointers do not always cast correctly to void * + * (depends on memory and segmentation model for instance), + * so they coerce to NULL. + */ + res = NULL; + break; +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: + /* number */ + res = NULL; + break; + } + + duk_push_pointer(ctx, res); + duk_replace(ctx, index); + return res; +} + +DUK_EXTERNAL void duk_to_object(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_uint_t flags = 0; /* shared flags for a subset of types */ + duk_small_int_t proto = 0; + + DUK_ASSERT_CTX_VALID(ctx); + + index = duk_require_normalize_index(ctx, index); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: + case DUK_TAG_NULL: { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_OBJECT_COERCIBLE); + break; + } + case DUK_TAG_BOOLEAN: { + flags = DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BOOLEAN); + proto = DUK_BIDX_BOOLEAN_PROTOTYPE; + goto create_object; + } + case DUK_TAG_STRING: { + flags = DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_STRING); + proto = DUK_BIDX_STRING_PROTOTYPE; + goto create_object; + } + case DUK_TAG_OBJECT: { + /* nop */ + break; + } + case DUK_TAG_BUFFER: { + /* A plain buffer coerces to a Duktape.Buffer because it's the + * object counterpart of the plain buffer value. But it might + * still make more sense to produce an ArrayBuffer here? + */ + + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; + + h_val = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h_val != NULL); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER), + DUK_BIDX_BUFFER_PROTOTYPE); + DUK_ASSERT(h_bufobj != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE((duk_hobject *) h_bufobj)); + DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_bufobj)); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + DUK_ASSERT(h_bufobj->offset == 0); + h_bufobj->length = (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_val); + DUK_ASSERT(h_bufobj->shift == 0); + DUK_ASSERT(h_bufobj->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8); + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + goto replace_value; + } + case DUK_TAG_POINTER: { + flags = DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_POINTER); + proto = DUK_BIDX_POINTER_PROTOTYPE; + goto create_object; + } + case DUK_TAG_LIGHTFUNC: { + /* Lightfunc coerces to a Function instance with concrete + * properties. Since 'length' is virtual for Duktape/C + * functions, don't need to define that. + * + * The result is made extensible to mimic what happens to + * strings: + * > Object.isExtensible(Object('foo')) + * true + */ + duk_small_uint_t lf_flags; + duk_small_uint_t nargs; + duk_small_uint_t lf_len; + duk_c_function func; + duk_hnativefunction *nf; + + DUK_TVAL_GET_LIGHTFUNC(tv, func, lf_flags); + + nargs = DUK_LFUNC_FLAGS_GET_NARGS(lf_flags); + if (nargs == DUK_LFUNC_NARGS_VARARGS) { + nargs = DUK_VARARGS; + } + flags = DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_CONSTRUCTABLE | + DUK_HOBJECT_FLAG_NATIVEFUNCTION | + DUK_HOBJECT_FLAG_NEWENV | + DUK_HOBJECT_FLAG_STRICT | + DUK_HOBJECT_FLAG_NOTAIL | + /* DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC: omitted here intentionally */ + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION); + (void) duk__push_c_function_raw(ctx, func, (duk_idx_t) nargs, flags); + + lf_len = DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags); + if (lf_len != nargs) { + /* Explicit length is only needed if it differs from 'nargs'. */ + duk_push_int(ctx, (duk_int_t) lf_len); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE); + } + duk_push_lightfunc_name(ctx, tv); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE); + + nf = duk_get_hnativefunction(ctx, -1); + DUK_ASSERT(nf != NULL); + nf->magic = (duk_int16_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags); + + /* Enable DUKFUNC exotic behavior once properties are set up. */ + DUK_HOBJECT_SET_EXOTIC_DUKFUNC((duk_hobject *) nf); + goto replace_value; + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: { + flags = DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_NUMBER); + proto = DUK_BIDX_NUMBER_PROTOTYPE; + goto create_object; + } + } + return; + + create_object: + (void) duk_push_object_helper(ctx, flags, proto); + + /* Note: Boolean prototype's internal value property is not writable, + * but duk_xdef_prop_stridx() disregards the write protection. Boolean + * instances are immutable. + * + * String and buffer special behaviors are already enabled which is not + * ideal, but a write to the internal value is not affected by them. + */ + duk_dup(ctx, index); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE); + + replace_value: + duk_replace(ctx, index); +} + +/* + * Type checking + */ + +DUK_LOCAL duk_bool_t duk__tag_check(duk_context *ctx, duk_idx_t index, duk_small_uint_t tag) { + duk_tval *tv; + + tv = duk_get_tval(ctx, index); + if (!tv) { + return 0; + } + return (DUK_TVAL_GET_TAG(tv) == tag); +} + +DUK_LOCAL duk_bool_t duk__obj_flag_any_default_false(duk_context *ctx, duk_idx_t index, duk_uint_t flag_mask) { + duk_hobject *obj; + + DUK_ASSERT_CTX_VALID(ctx); + + obj = duk_get_hobject(ctx, index); + if (obj) { + return (DUK_HEAPHDR_CHECK_FLAG_BITS((duk_heaphdr *) obj, flag_mask) ? 1 : 0); + } + return 0; +} + +DUK_EXTERNAL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (!tv) { + return DUK_TYPE_NONE; + } + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: + return DUK_TYPE_UNDEFINED; + case DUK_TAG_NULL: + return DUK_TYPE_NULL; + case DUK_TAG_BOOLEAN: + return DUK_TYPE_BOOLEAN; + case DUK_TAG_STRING: + return DUK_TYPE_STRING; + case DUK_TAG_OBJECT: + return DUK_TYPE_OBJECT; + case DUK_TAG_BUFFER: + return DUK_TYPE_BUFFER; + case DUK_TAG_POINTER: + return DUK_TYPE_POINTER; + case DUK_TAG_LIGHTFUNC: + return DUK_TYPE_LIGHTFUNC; +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: + /* Note: number has no explicit tag (in 8-byte representation) */ + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + return DUK_TYPE_NUMBER; + } + DUK_UNREACHABLE(); +} + +DUK_EXTERNAL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t index, duk_int_t type) { + DUK_ASSERT_CTX_VALID(ctx); + + return (duk_get_type(ctx, index) == type) ? 1 : 0; +} + +DUK_EXTERNAL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (!tv) { + return DUK_TYPE_MASK_NONE; + } + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: + return DUK_TYPE_MASK_UNDEFINED; + case DUK_TAG_NULL: + return DUK_TYPE_MASK_NULL; + case DUK_TAG_BOOLEAN: + return DUK_TYPE_MASK_BOOLEAN; + case DUK_TAG_STRING: + return DUK_TYPE_MASK_STRING; + case DUK_TAG_OBJECT: + return DUK_TYPE_MASK_OBJECT; + case DUK_TAG_BUFFER: + return DUK_TYPE_MASK_BUFFER; + case DUK_TAG_POINTER: + return DUK_TYPE_MASK_POINTER; + case DUK_TAG_LIGHTFUNC: + return DUK_TYPE_MASK_LIGHTFUNC; +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: + /* Note: number has no explicit tag (in 8-byte representation) */ + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + return DUK_TYPE_MASK_NUMBER; + } + DUK_UNREACHABLE(); +} + +DUK_EXTERNAL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t index, duk_uint_t mask) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + + if (duk_get_type_mask(ctx, index) & mask) { + return 1; + } + if (mask & DUK_TYPE_MASK_THROW) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE); + DUK_UNREACHABLE(); + } + return 0; +} + +DUK_EXTERNAL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__tag_check(ctx, index, DUK_TAG_UNDEFINED); +} + +DUK_EXTERNAL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__tag_check(ctx, index, DUK_TAG_NULL); +} + +DUK_EXTERNAL duk_bool_t duk_is_null_or_undefined(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + duk_small_uint_t tag; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (!tv) { + return 0; + } + tag = DUK_TVAL_GET_TAG(tv); + return (tag == DUK_TAG_UNDEFINED) || (tag == DUK_TAG_NULL); +} + +DUK_EXTERNAL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__tag_check(ctx, index, DUK_TAG_BOOLEAN); +} + +DUK_EXTERNAL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + /* + * Number is special because it doesn't have a specific + * tag in the 8-byte representation. + */ + + /* XXX: shorter version for 12-byte representation? */ + + tv = duk_get_tval(ctx, index); + if (!tv) { + return 0; + } + return DUK_TVAL_IS_NUMBER(tv); +} + +DUK_EXTERNAL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t index) { + /* XXX: This will now return false for non-numbers, even though they would + * coerce to NaN (as a general rule). In particular, duk_get_number() + * returns a NaN for non-numbers, so should this function also return + * true for non-numbers? + */ + + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (!tv || !DUK_TVAL_IS_NUMBER(tv)) { + return 0; + } + return DUK_ISNAN(DUK_TVAL_GET_NUMBER(tv)); +} + +DUK_EXTERNAL duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__tag_check(ctx, index, DUK_TAG_STRING); +} + +DUK_EXTERNAL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__tag_check(ctx, index, DUK_TAG_OBJECT); +} + +DUK_EXTERNAL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__tag_check(ctx, index, DUK_TAG_BUFFER); +} + +DUK_EXTERNAL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__tag_check(ctx, index, DUK_TAG_POINTER); +} + +DUK_EXTERNAL duk_bool_t duk_is_lightfunc(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__tag_check(ctx, index, DUK_TAG_LIGHTFUNC); +} + +DUK_EXTERNAL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index) { + duk_hobject *obj; + + DUK_ASSERT_CTX_VALID(ctx); + + obj = duk_get_hobject(ctx, index); + if (obj) { + return (DUK_HOBJECT_GET_CLASS_NUMBER(obj) == DUK_HOBJECT_CLASS_ARRAY ? 1 : 0); + } + return 0; +} + +DUK_EXTERNAL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_LIGHTFUNC(tv)) { + return 1; + } + return duk__obj_flag_any_default_false(ctx, + index, + DUK_HOBJECT_FLAG_COMPILEDFUNCTION | + DUK_HOBJECT_FLAG_NATIVEFUNCTION | + DUK_HOBJECT_FLAG_BOUND); +} + +DUK_EXTERNAL duk_bool_t duk_is_c_function(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__obj_flag_any_default_false(ctx, + index, + DUK_HOBJECT_FLAG_NATIVEFUNCTION); +} + +DUK_EXTERNAL duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__obj_flag_any_default_false(ctx, + index, + DUK_HOBJECT_FLAG_COMPILEDFUNCTION); +} + +DUK_EXTERNAL duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__obj_flag_any_default_false(ctx, + index, + DUK_HOBJECT_FLAG_BOUND); +} + +DUK_EXTERNAL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk__obj_flag_any_default_false(ctx, + index, + DUK_HOBJECT_FLAG_THREAD); +} + +DUK_EXTERNAL duk_bool_t duk_is_callable(duk_context *ctx, duk_idx_t index) { + /* XXX: currently same as duk_is_function() */ + DUK_ASSERT_CTX_VALID(ctx); + return duk_is_function(ctx, index); +} + +DUK_EXTERNAL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_BUFFER(tv)) { + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h != NULL); + return (DUK_HBUFFER_HAS_DYNAMIC(h) ? 0 : 1); + } + return 0; +} + +DUK_EXTERNAL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_BUFFER(tv)) { + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h != NULL); + return (DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h) ? 1 : 0); + } + return 0; +} + +DUK_EXTERNAL duk_bool_t duk_is_external_buffer(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_BUFFER(tv)) { + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h != NULL); + return (DUK_HBUFFER_HAS_DYNAMIC(h) && DUK_HBUFFER_HAS_EXTERNAL(h) ? 1 : 0); + } + return 0; +} + +DUK_EXTERNAL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h; + duk_uint_t sanity; + + DUK_ASSERT_CTX_VALID(ctx); + + h = duk_get_hobject(ctx, index); + + sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY; + do { + if (!h) { + return DUK_ERR_NONE; + } + if (h == thr->builtins[DUK_BIDX_EVAL_ERROR_PROTOTYPE]) { + return DUK_ERR_EVAL_ERROR; + } + if (h == thr->builtins[DUK_BIDX_RANGE_ERROR_PROTOTYPE]) { + return DUK_ERR_RANGE_ERROR; + } + if (h == thr->builtins[DUK_BIDX_REFERENCE_ERROR_PROTOTYPE]) { + return DUK_ERR_REFERENCE_ERROR; + } + if (h == thr->builtins[DUK_BIDX_SYNTAX_ERROR_PROTOTYPE]) { + return DUK_ERR_SYNTAX_ERROR; + } + if (h == thr->builtins[DUK_BIDX_TYPE_ERROR_PROTOTYPE]) { + return DUK_ERR_TYPE_ERROR; + } + if (h == thr->builtins[DUK_BIDX_URI_ERROR_PROTOTYPE]) { + return DUK_ERR_URI_ERROR; + } + if (h == thr->builtins[DUK_BIDX_ERROR_PROTOTYPE]) { + return DUK_ERR_ERROR; + } + + h = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h); + } while (--sanity > 0); + + return DUK_ERR_NONE; +} + +/* + * Pushers + */ + +DUK_INTERNAL void duk_push_tval(duk_context *ctx, duk_tval *tv) { + duk_hthread *thr; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(tv != NULL); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_TVAL(tv_slot, tv); + DUK_TVAL_INCREF(thr, tv); /* no side effects */ +} + +#if defined(DUK_USE_DEBUGGER_SUPPORT) +/* Right now only needed by the debugger. */ +DUK_INTERNAL void duk_push_unused(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_UNDEFINED_UNUSED(tv_slot); +} +#endif + +DUK_EXTERNAL void duk_push_undefined(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_UNDEFINED_ACTUAL(tv_slot); +} + +DUK_EXTERNAL void duk_push_null(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_NULL(tv_slot); +} + +DUK_EXTERNAL void duk_push_boolean(duk_context *ctx, duk_bool_t val) { + duk_hthread *thr; + duk_tval *tv_slot; + duk_small_int_t b; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + b = (val ? 1 : 0); /* ensure value is 1 or 0 (not other non-zero) */ + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_BOOLEAN(tv_slot, b); +} + +DUK_EXTERNAL void duk_push_true(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_BOOLEAN_TRUE(tv_slot); +} + +DUK_EXTERNAL void duk_push_false(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_BOOLEAN_FALSE(tv_slot); +} + +/* normalize NaN which may not match our canonical internal NaN */ +DUK_EXTERNAL void duk_push_number(duk_context *ctx, duk_double_t val) { + duk_hthread *thr; + duk_tval *tv_slot; + duk_double_union du; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + du.d = val; + DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du); + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_NUMBER(tv_slot, du.d); +} + +DUK_EXTERNAL void duk_push_int(duk_context *ctx, duk_int_t val) { +#if defined(DUK_USE_FASTINT) + duk_hthread *thr; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + tv_slot = thr->valstack_top++; +#if DUK_INT_MAX <= 0x7fffffffL + DUK_TVAL_SET_FASTINT_I32(tv_slot, (duk_int32_t) val); +#else + if (val >= DUK_FASTINT_MIN && val <= DUK_FASTINT_MAX) { + DUK_TVAL_SET_FASTINT(tv_slot, (duk_int64_t) val); + } else { + duk_double_t = (duk_double_t) val; + DUK_TVAL_SET_NUMBER(tv_slot, d); + } +#endif +#else /* DUK_USE_FASTINT */ + duk_hthread *thr; + duk_tval *tv_slot; + duk_double_t d; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + d = (duk_double_t) val; + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_NUMBER(tv_slot, d); +#endif /* DUK_USE_FASTINT */ +} + +DUK_EXTERNAL void duk_push_uint(duk_context *ctx, duk_uint_t val) { +#if defined(DUK_USE_FASTINT) + duk_hthread *thr; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + tv_slot = thr->valstack_top++; +#if DUK_UINT_MAX <= 0xffffffffUL + DUK_TVAL_SET_FASTINT_U32(tv_slot, (duk_uint32_t) val); +#else + if (val <= DUK_FASTINT_MAX) { /* val is unsigned so >= 0 */ + /* XXX: take advantage of val being unsigned, no need to mask */ + DUK_TVAL_SET_FASTINT(tv_slot, (duk_int64_t) val); + } else { + duk_double_t = (duk_double_t) val; + DUK_TVAL_SET_NUMBER(tv_slot, d); + } +#endif +#else /* DUK_USE_FASTINT */ + duk_hthread *thr; + duk_tval *tv_slot; + duk_double_t d; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + d = (duk_double_t) val; + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_NUMBER(tv_slot, d); +#endif /* DUK_USE_FASTINT */ +} + +DUK_EXTERNAL void duk_push_nan(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv_slot; + duk_double_union du; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + DUK_DBLUNION_SET_NAN(&du); + DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du)); + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_NUMBER(tv_slot, du.d); +} + +DUK_EXTERNAL const char *duk_push_lstring(duk_context *ctx, const char *str, duk_size_t len) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + + /* check stack before interning (avoid hanging temp) */ + if (thr->valstack_top >= thr->valstack_end) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + } + + /* NULL with zero length represents an empty string; NULL with higher + * length is also now trated like an empty string although it is + * a bit dubious. This is unlike duk_push_string() which pushes a + * 'null' if the input string is a NULL. + */ + if (!str) { + len = 0; + } + + /* Check for maximum string length */ + if (len > DUK_HSTRING_MAX_BYTELEN) { + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_STRING_TOO_LONG); + } + + h = duk_heap_string_intern_checked(thr, (duk_uint8_t *) str, (duk_uint32_t) len); + DUK_ASSERT(h != NULL); + + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_STRING(tv_slot, h); + DUK_HSTRING_INCREF(thr, h); /* no side effects */ + + return (const char *) DUK_HSTRING_GET_DATA(h); +} + +DUK_EXTERNAL const char *duk_push_string(duk_context *ctx, const char *str) { + DUK_ASSERT_CTX_VALID(ctx); + + if (str) { + return duk_push_lstring(ctx, str, DUK_STRLEN(str)); + } else { + duk_push_null(ctx); + return NULL; + } +} + +#ifdef DUK_USE_FILE_IO +/* This is a bit clunky because it is ANSI C portable. Should perhaps + * relocate to another file because this is potentially platform + * dependent. + */ +DUK_EXTERNAL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_file *f = NULL; + char *buf; + long sz; /* ANSI C typing */ + + DUK_ASSERT_CTX_VALID(ctx); + + if (!path) { + goto fail; + } + f = DUK_FOPEN(path, "rb"); + if (!f) { + goto fail; + } + if (DUK_FSEEK(f, 0, SEEK_END) < 0) { + goto fail; + } + sz = DUK_FTELL(f); + if (sz < 0) { + goto fail; + } + if (DUK_FSEEK(f, 0, SEEK_SET) < 0) { + goto fail; + } + buf = (char *) duk_push_fixed_buffer(ctx, (duk_size_t) sz); + DUK_ASSERT(buf != NULL); + if ((duk_size_t) DUK_FREAD(buf, 1, (size_t) sz, f) != (duk_size_t) sz) { + goto fail; + } + (void) DUK_FCLOSE(f); /* ignore fclose() error */ + f = NULL; + return duk_to_string(ctx, -1); + + fail: + if (f) { + DUK_FCLOSE(f); + } + + if (flags != 0) { + DUK_ASSERT(flags == DUK_STRING_PUSH_SAFE); /* only flag now */ + duk_push_undefined(ctx); + } else { + /* XXX: string not shared because it is conditional */ + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "read file error"); + } + return NULL; +} +#else +DUK_EXTERNAL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags) { + duk_hthread *thr = (duk_hthread *) ctx; + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(path); + + if (flags != 0) { + DUK_ASSERT(flags == DUK_STRING_PUSH_SAFE); /* only flag now */ + duk_push_undefined(ctx); + } else { + /* XXX: string not shared because it is conditional */ + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "file I/O disabled"); + } + return NULL; +} +#endif /* DUK_USE_FILE_IO */ + +DUK_EXTERNAL void duk_push_pointer(duk_context *ctx, void *val) { + duk_hthread *thr; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK__CHECK_SPACE(); + tv_slot = thr->valstack_top++; + DUK_TVAL_SET_POINTER(tv_slot, val); +} + +#define DUK__PUSH_THIS_FLAG_CHECK_COERC (1 << 0) +#define DUK__PUSH_THIS_FLAG_TO_OBJECT (1 << 1) +#define DUK__PUSH_THIS_FLAG_TO_STRING (1 << 2) + +DUK_LOCAL void duk__push_this_helper(duk_context *ctx, duk_small_uint_t flags) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT_DISABLE(thr->callstack_top >= 0); /* avoid warning (unsigned) */ + DUK_ASSERT(thr->callstack_top <= thr->callstack_size); + + if (thr->callstack_top == 0) { + if (flags & DUK__PUSH_THIS_FLAG_CHECK_COERC) { + goto type_error; + } + duk_push_undefined(ctx); + } else { + duk_tval tv_tmp; + duk_tval *tv; + + /* 'this' binding is just before current activation's bottom */ + DUK_ASSERT(thr->valstack_bottom > thr->valstack); + tv = thr->valstack_bottom - 1; + if (flags & DUK__PUSH_THIS_FLAG_CHECK_COERC) { + if (DUK_TVAL_IS_UNDEFINED(tv) || DUK_TVAL_IS_NULL(tv)) { + goto type_error; + } + } + + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + duk_push_tval(ctx, &tv_tmp); + } + + if (flags & DUK__PUSH_THIS_FLAG_TO_OBJECT) { + duk_to_object(ctx, -1); + } else if (flags & DUK__PUSH_THIS_FLAG_TO_STRING) { + duk_to_string(ctx, -1); + } + + return; + + type_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_OBJECT_COERCIBLE); +} + +DUK_EXTERNAL void duk_push_this(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + + duk__push_this_helper(ctx, 0 /*flags*/); +} + +DUK_INTERNAL void duk_push_this_check_object_coercible(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + + duk__push_this_helper(ctx, DUK__PUSH_THIS_FLAG_CHECK_COERC /*flags*/); +} + +DUK_INTERNAL duk_hobject *duk_push_this_coercible_to_object(duk_context *ctx) { + duk_hobject *h; + + DUK_ASSERT_CTX_VALID(ctx); + + duk__push_this_helper(ctx, DUK__PUSH_THIS_FLAG_CHECK_COERC | + DUK__PUSH_THIS_FLAG_TO_OBJECT /*flags*/); + h = duk_get_hobject(ctx, -1); + DUK_ASSERT(h != NULL); + return h; +} + +DUK_INTERNAL duk_hstring *duk_push_this_coercible_to_string(duk_context *ctx) { + duk_hstring *h; + + DUK_ASSERT_CTX_VALID(ctx); + + duk__push_this_helper(ctx, DUK__PUSH_THIS_FLAG_CHECK_COERC | + DUK__PUSH_THIS_FLAG_TO_STRING /*flags*/); + h = duk_get_hstring(ctx, -1); + DUK_ASSERT(h != NULL); + return h; +} + +DUK_INTERNAL duk_tval *duk_get_borrowed_this_tval(duk_context *ctx) { + duk_hthread *thr; + + DUK_ASSERT(ctx != NULL); + thr = (duk_hthread *) ctx; + + DUK_ASSERT(thr->callstack_top > 0); /* caller required to know */ + DUK_ASSERT(thr->valstack_bottom > thr->valstack); /* consequence of above */ + DUK_ASSERT(thr->valstack_bottom - 1 >= thr->valstack); /* 'this' binding exists */ + + return thr->valstack_bottom - 1; +} + +DUK_EXTERNAL void duk_push_current_function(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_activation *act; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + DUK_ASSERT_DISABLE(thr->callstack_top >= 0); + DUK_ASSERT(thr->callstack_top <= thr->callstack_size); + + act = duk_hthread_get_current_activation(thr); + if (act) { + duk_push_tval(ctx, &act->tv_func); + } else { + duk_push_undefined(ctx); + } +} + +DUK_EXTERNAL void duk_push_current_thread(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + + if (thr->heap->curr_thread) { + duk_push_hobject(ctx, (duk_hobject *) thr->heap->curr_thread); + } else { + duk_push_undefined(ctx); + } +} + +DUK_EXTERNAL void duk_push_global_object(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + + duk_push_hobject_bidx(ctx, DUK_BIDX_GLOBAL); +} + +/* XXX: size optimize */ +DUK_LOCAL void duk__push_stash(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE)) { + DUK_DDD(DUK_DDDPRINT("creating heap/global/thread stash on first use")); + duk_pop(ctx); + duk_push_object_internal(ctx); + duk_dup_top(ctx); + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_C); /* [ ... parent stash stash ] -> [ ... parent stash ] */ + } + duk_remove(ctx, -2); +} + +DUK_EXTERNAL void duk_push_heap_stash(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_heap *heap; + DUK_ASSERT_CTX_VALID(ctx); + heap = thr->heap; + DUK_ASSERT(heap->heap_object != NULL); + duk_push_hobject(ctx, heap->heap_object); + duk__push_stash(ctx); +} + +DUK_EXTERNAL void duk_push_global_stash(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + duk_push_global_object(ctx); + duk__push_stash(ctx); +} + +DUK_EXTERNAL void duk_push_thread_stash(duk_context *ctx, duk_context *target_ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + DUK_ASSERT_CTX_VALID(ctx); + if (!target_ctx) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + return; /* not reached */ + } + duk_push_hobject(ctx, (duk_hobject *) target_ctx); + duk__push_stash(ctx); +} + +/* XXX: duk_ssize_t would be useful here */ +DUK_LOCAL duk_int_t duk__try_push_vsprintf(duk_context *ctx, void *buf, duk_size_t sz, const char *fmt, va_list ap) { + duk_int_t len; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(ctx); + + /* NUL terminator handling doesn't matter here */ + len = DUK_VSNPRINTF((char *) buf, sz, fmt, ap); + if (len < (duk_int_t) sz) { + /* Return value of 'sz' or more indicates output was (potentially) + * truncated. + */ + return (duk_int_t) len; + } + return -1; +} + +DUK_EXTERNAL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_uint8_t stack_buf[DUK_PUSH_SPRINTF_INITIAL_SIZE]; + duk_size_t sz = DUK_PUSH_SPRINTF_INITIAL_SIZE; + duk_bool_t pushed_buf = 0; + void *buf; + duk_int_t len; /* XXX: duk_ssize_t */ + const char *res; + + DUK_ASSERT_CTX_VALID(ctx); + + /* special handling of fmt==NULL */ + if (!fmt) { + duk_hstring *h_str; + duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING); + h_str = DUK_HTHREAD_STRING_EMPTY_STRING(thr); /* rely on interning, must be this string */ + return (const char *) DUK_HSTRING_GET_DATA(h_str); + } + + /* initial estimate based on format string */ + sz = DUK_STRLEN(fmt) + 16; /* format plus something to avoid just missing */ + if (sz < DUK_PUSH_SPRINTF_INITIAL_SIZE) { + sz = DUK_PUSH_SPRINTF_INITIAL_SIZE; + } + DUK_ASSERT(sz > 0); + + /* Try to make do with a stack buffer to avoid allocating a temporary buffer. + * This works 99% of the time which is quite nice. + */ + for (;;) { + va_list ap_copy; /* copied so that 'ap' can be reused */ + + if (sz <= sizeof(stack_buf)) { + buf = stack_buf; + } else if (!pushed_buf) { + pushed_buf = 1; + buf = duk_push_dynamic_buffer(ctx, sz); + } else { + buf = duk_resize_buffer(ctx, -1, sz); + } + DUK_ASSERT(buf != NULL); + + DUK_VA_COPY(ap_copy, ap); + len = duk__try_push_vsprintf(ctx, buf, sz, fmt, ap_copy); + va_end(ap_copy); + if (len >= 0) { + break; + } + + /* failed, resize and try again */ + sz = sz * 2; + if (sz >= DUK_PUSH_SPRINTF_SANITY_LIMIT) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_SPRINTF_TOO_LONG); + } + } + + /* Cannot use duk_to_string() on the buffer because it is usually + * larger than 'len'. Also, 'buf' is usually a stack buffer. + */ + res = duk_push_lstring(ctx, (const char *) buf, (duk_size_t) len); /* [ buf? res ] */ + if (pushed_buf) { + duk_remove(ctx, -2); + } + return res; +} + +DUK_EXTERNAL const char *duk_push_sprintf(duk_context *ctx, const char *fmt, ...) { + va_list ap; + const char *ret; + + DUK_ASSERT_CTX_VALID(ctx); + + /* allow fmt==NULL */ + va_start(ap, fmt); + ret = duk_push_vsprintf(ctx, fmt, ap); + va_end(ap); + + return ret; +} + +DUK_INTERNAL duk_idx_t duk_push_object_helper(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv_slot; + duk_hobject *h; + duk_idx_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(prototype_bidx == -1 || + (prototype_bidx >= 0 && prototype_bidx < DUK_NUM_BUILTINS)); + + /* check stack first */ + if (thr->valstack_top >= thr->valstack_end) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + } + + h = duk_hobject_alloc(thr->heap, hobject_flags_and_class); + if (!h) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); + } + + DUK_DDD(DUK_DDDPRINT("created object with flags: 0x%08lx", (unsigned long) h->hdr.h_flags)); + + tv_slot = thr->valstack_top; + DUK_TVAL_SET_OBJECT(tv_slot, h); + DUK_HOBJECT_INCREF(thr, h); /* no side effects */ + ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); + thr->valstack_top++; + + /* object is now reachable */ + + if (prototype_bidx >= 0) { + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[prototype_bidx]); + } else { + DUK_ASSERT(prototype_bidx == -1); + DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h) == NULL); + } + + return ret; +} + +DUK_INTERNAL duk_idx_t duk_push_object_helper_proto(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_hobject *proto) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t ret; + duk_hobject *h; + + DUK_ASSERT_CTX_VALID(ctx); + + ret = duk_push_object_helper(ctx, hobject_flags_and_class, -1); + h = duk_get_hobject(ctx, -1); + DUK_ASSERT(h != NULL); + DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h) == NULL); + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, proto); + return ret; +} + +DUK_EXTERNAL duk_idx_t duk_push_object(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + + return duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT), + DUK_BIDX_OBJECT_PROTOTYPE); +} + +DUK_EXTERNAL duk_idx_t duk_push_array(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj; + duk_idx_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + + ret = duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_ARRAY_PART | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAY), + DUK_BIDX_ARRAY_PROTOTYPE); + + obj = duk_require_hobject(ctx, ret); + + /* + * An array must have a 'length' property (E5 Section 15.4.5.2). + * The special array behavior flag must only be enabled once the + * length property has been added. + * + * The internal property must be a number (and preferably a + * fastint if fastint support is enabled). + */ + + duk_push_int(ctx, 0); +#if defined(DUK_USE_FASTINT) + DUK_ASSERT(DUK_TVAL_IS_FASTINT(duk_require_tval(ctx, -1))); +#endif + + duk_hobject_define_property_internal(thr, + obj, + DUK_HTHREAD_STRING_LENGTH(thr), + DUK_PROPDESC_FLAGS_W); + DUK_HOBJECT_SET_EXOTIC_ARRAY(obj); + + return ret; +} + +DUK_EXTERNAL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hthread *obj; + duk_idx_t ret; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + + /* check stack first */ + if (thr->valstack_top >= thr->valstack_end) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + } + + obj = duk_hthread_alloc(thr->heap, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_THREAD | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_THREAD)); + if (!obj) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); + } + obj->state = DUK_HTHREAD_STATE_INACTIVE; +#if defined(DUK_USE_HEAPPTR16) + obj->strs16 = thr->strs16; +#else + obj->strs = thr->strs; +#endif + DUK_DDD(DUK_DDDPRINT("created thread object with flags: 0x%08lx", (unsigned long) obj->obj.hdr.h_flags)); + + /* make the new thread reachable */ + tv_slot = thr->valstack_top; + DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj); + DUK_HTHREAD_INCREF(thr, obj); + ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); + thr->valstack_top++; + + /* important to do this *after* pushing, to make the thread reachable for gc */ + if (!duk_hthread_init_stacks(thr->heap, obj)) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); + } + + /* initialize built-ins - either by copying or creating new ones */ + if (flags & DUK_THREAD_NEW_GLOBAL_ENV) { + duk_hthread_create_builtin_objects(obj); + } else { + duk_hthread_copy_builtin_objects(thr, obj); + } + + /* default prototype (Note: 'obj' must be reachable) */ + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, obj->builtins[DUK_BIDX_THREAD_PROTOTYPE]); + + /* Initial stack size satisfies the stack spare constraints so there + * is no need to require stack here. + */ + DUK_ASSERT(DUK_VALSTACK_INITIAL_SIZE >= + DUK_VALSTACK_API_ENTRY_MINIMUM + DUK_VALSTACK_INTERNAL_EXTRA); + + return ret; +} + +DUK_INTERNAL duk_idx_t duk_push_compiledfunction(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hcompiledfunction *obj; + duk_idx_t ret; + duk_tval *tv_slot; + + DUK_ASSERT_CTX_VALID(ctx); + + /* check stack first */ + if (thr->valstack_top >= thr->valstack_end) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + } + + /* Template functions are not strictly constructable (they don't + * have a "prototype" property for instance), so leave the + * DUK_HOBJECT_FLAG_CONSRUCTABLE flag cleared here. + */ + + obj = duk_hcompiledfunction_alloc(thr->heap, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_COMPILEDFUNCTION | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION)); + if (!obj) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); + } + + DUK_DDD(DUK_DDDPRINT("created compiled function object with flags: 0x%08lx", (unsigned long) obj->obj.hdr.h_flags)); + + tv_slot = thr->valstack_top; + DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj); + DUK_HOBJECT_INCREF(thr, obj); + ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); + thr->valstack_top++; + + /* default prototype (Note: 'obj' must be reachable) */ + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]); + + return ret; +} + +DUK_LOCAL duk_idx_t duk__push_c_function_raw(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_uint_t flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hnativefunction *obj; + duk_idx_t ret; + duk_tval *tv_slot; + duk_uint16_t func_nargs; + + DUK_ASSERT_CTX_VALID(ctx); + + /* check stack first */ + if (thr->valstack_top >= thr->valstack_end) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + } + if (func == NULL) { + goto api_error; + } + if (nargs >= 0 && nargs < DUK_HNATIVEFUNCTION_NARGS_MAX) { + func_nargs = (duk_uint16_t) nargs; + } else if (nargs == DUK_VARARGS) { + func_nargs = DUK_HNATIVEFUNCTION_NARGS_VARARGS; + } else { + goto api_error; + } + + obj = duk_hnativefunction_alloc(thr->heap, flags); + if (!obj) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); + } + + obj->func = func; + obj->nargs = func_nargs; + + DUK_DDD(DUK_DDDPRINT("created native function object with flags: 0x%08lx, nargs=%ld", + (unsigned long) obj->obj.hdr.h_flags, (long) obj->nargs)); + + tv_slot = thr->valstack_top; + DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj); + DUK_HOBJECT_INCREF(thr, obj); + ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); + thr->valstack_top++; + + /* default prototype (Note: 'obj' must be reachable) */ + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]); + + return ret; + + api_error: + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + return 0; /* not reached */ +} + +DUK_EXTERNAL duk_idx_t duk_push_c_function(duk_context *ctx, duk_c_function func, duk_int_t nargs) { + duk_uint_t flags; + + DUK_ASSERT_CTX_VALID(ctx); + + flags = DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_CONSTRUCTABLE | + DUK_HOBJECT_FLAG_NATIVEFUNCTION | + DUK_HOBJECT_FLAG_NEWENV | + DUK_HOBJECT_FLAG_STRICT | + DUK_HOBJECT_FLAG_NOTAIL | + DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION); + + return duk__push_c_function_raw(ctx, func, nargs, flags); +} + +DUK_INTERNAL void duk_push_c_function_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs) { + duk_uint_t flags; + + DUK_ASSERT_CTX_VALID(ctx); + + flags = DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_CONSTRUCTABLE | + DUK_HOBJECT_FLAG_NATIVEFUNCTION | + DUK_HOBJECT_FLAG_NEWENV | + DUK_HOBJECT_FLAG_STRICT | + DUK_HOBJECT_FLAG_NOTAIL | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION); + + (void) duk__push_c_function_raw(ctx, func, nargs, flags); +} + +DUK_INTERNAL void duk_push_c_function_noconstruct_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs) { + duk_uint_t flags; + + DUK_ASSERT_CTX_VALID(ctx); + + flags = DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_NATIVEFUNCTION | + DUK_HOBJECT_FLAG_NEWENV | + DUK_HOBJECT_FLAG_STRICT | + DUK_HOBJECT_FLAG_NOTAIL | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION); + + (void) duk__push_c_function_raw(ctx, func, nargs, flags); +} + +DUK_EXTERNAL duk_idx_t duk_push_c_lightfunc(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_idx_t length, duk_int_t magic) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval tv_tmp; + duk_small_uint_t lf_flags; + + DUK_ASSERT_CTX_VALID(ctx); + + /* check stack first */ + if (thr->valstack_top >= thr->valstack_end) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + } + + if (nargs >= DUK_LFUNC_NARGS_MIN && nargs <= DUK_LFUNC_NARGS_MAX) { + /* as is */ + } else if (nargs == DUK_VARARGS) { + nargs = DUK_LFUNC_NARGS_VARARGS; + } else { + goto api_error; + } + if (!(length >= DUK_LFUNC_LENGTH_MIN && length <= DUK_LFUNC_LENGTH_MAX)) { + goto api_error; + } + if (!(magic >= DUK_LFUNC_MAGIC_MIN && magic <= DUK_LFUNC_MAGIC_MAX)) { + goto api_error; + } + + lf_flags = DUK_LFUNC_FLAGS_PACK(magic, length, nargs); + DUK_TVAL_SET_LIGHTFUNC(&tv_tmp, func, lf_flags); + duk_push_tval(ctx, &tv_tmp); /* XXX: direct valstack write */ + DUK_ASSERT(thr->valstack_top != thr->valstack_bottom); + return ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1; + + api_error: + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + return 0; /* not reached */ +} + +DUK_INTERNAL duk_hbufferobject *duk_push_bufferobject_raw(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hbufferobject *obj; + duk_tval *tv_slot; + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(prototype_bidx >= 0); + + /* check stack first */ + if (thr->valstack_top >= thr->valstack_end) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + } + + obj = duk_hbufferobject_alloc(thr->heap, hobject_flags_and_class); + if (!obj) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); + } + + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, thr->builtins[prototype_bidx]); + DUK_ASSERT_HBUFFEROBJECT_VALID(obj); + + tv_slot = thr->valstack_top; + DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj); + DUK_HOBJECT_INCREF(thr, obj); + thr->valstack_top++; + + return obj; +} + +/* XXX: There's quite a bit of overlap with buffer creation handling in + * duk_bi_buffer.c. Look for overlap and refactor. + */ +#define DUK__PACK_ARGS(classnum,protobidx,elemtype,elemshift,isview) \ + (((classnum) << 24) | ((protobidx) << 16) | ((elemtype) << 8) | ((elemshift) << 4) | (isview)) + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +static const duk_uint32_t duk__bufobj_flags_lookup[] = { + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER, DUK_BIDX_BUFFER_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 0), /* DUK_BUFOBJ_DUKTAPE_BUFFER */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER, DUK_BIDX_NODEJS_BUFFER_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 0), /* DUK_BUFOBJ_NODEJS_BUFFER */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_ARRAYBUFFER, DUK_BIDX_ARRAYBUFFER_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 0), /* DUK_BUFOBJ_ARRAYBUFFER */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_DATAVIEW, DUK_BIDX_DATAVIEW_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 1), /* DUK_BUFOBJ_DATAVIEW */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT8ARRAY, DUK_BIDX_INT8ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_INT8, 0, 1), /* DUK_BUFOBJ_INT8ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT8ARRAY, DUK_BIDX_UINT8ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 1), /* DUK_BUFOBJ_UINT8ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY, DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED, 0, 1), /* DUK_BUFOBJ_UINT8CLAMPEDARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT16ARRAY, DUK_BIDX_INT16ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_INT16, 1, 1), /* DUK_BUFOBJ_INT16ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT16ARRAY, DUK_BIDX_UINT16ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT16, 1, 1), /* DUK_BUFOBJ_UINT16ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT32ARRAY, DUK_BIDX_INT32ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_INT32, 2, 1), /* DUK_BUFOBJ_INT32ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT32ARRAY, DUK_BIDX_UINT32ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT32, 2, 1), /* DUK_BUFOBJ_UINT32ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_FLOAT32ARRAY, DUK_BIDX_FLOAT32ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_FLOAT32, 2, 1), /* DUK_BUFOBJ_FLOAT32ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_FLOAT64ARRAY, DUK_BIDX_FLOAT64ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_FLOAT64, 3, 1) /* DUK_BUFOBJ_FLOAT64ARRAY */ +}; +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +/* Only allow Duktape.Buffer when support disabled. */ +static const duk_uint32_t duk__bufobj_flags_lookup[] = { + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER, DUK_BIDX_BUFFER_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 0) /* DUK_BUFOBJ_DUKTAPE_BUFFER */ +}; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ +#undef DUK__PACK_ARGS + +DUK_EXTERNAL void duk_push_buffer_object(duk_context *ctx, duk_idx_t idx_buffer, duk_size_t byte_offset, duk_size_t byte_length, duk_uint_t flags) { + duk_hthread *thr; + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; + duk_uint32_t tmp; + duk_uint_t classnum; + duk_uint_t protobidx; + duk_uint_t lookupidx; + duk_uint_t uint_offset, uint_length, uint_added; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + /* The underlying types for offset/length in duk_hbufferobject is + * duk_uint_t; make sure argument values fit and that offset + length + * does not wrap. + */ + uint_offset = (duk_uint_t) byte_offset; + uint_length = (duk_uint_t) byte_length; + if (sizeof(duk_size_t) != sizeof(duk_uint_t)) { + if ((duk_size_t) uint_offset != byte_offset || (duk_size_t) uint_length != byte_length) { + goto range_error; + } + } + uint_added = uint_offset + uint_length; + if (uint_added < uint_offset) { + goto range_error; + } + DUK_ASSERT(uint_added >= uint_offset && uint_added >= uint_length); + + DUK_ASSERT_DISABLE(flags >= 0); /* flags is unsigned */ + lookupidx = flags & 0x0f; /* 4 low bits */ + if (lookupidx >= sizeof(duk__bufobj_flags_lookup) / sizeof(duk_uint32_t)) { + goto arg_error; + } + tmp = duk__bufobj_flags_lookup[lookupidx]; + classnum = tmp >> 24; + protobidx = (tmp >> 16) & 0xff; + + h_val = duk_require_hbuffer(ctx, idx_buffer); + DUK_ASSERT(h_val != NULL); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(classnum), + protobidx); + DUK_ASSERT(h_bufobj != NULL); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->offset = uint_offset; + h_bufobj->length = uint_length; + h_bufobj->shift = (tmp >> 4) & 0x0f; + h_bufobj->elem_type = (tmp >> 8) & 0xff; + h_bufobj->is_view = tmp & 0x0f; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) + /* TypedArray views need an automatic ArrayBuffer which must be + * provided as .buffer property of the view. Just create a new + * ArrayBuffer sharing the same underlying buffer. + */ + if (flags & DUK_BUFOBJ_CREATE_ARRBUF) { + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAYBUFFER), + DUK_BIDX_ARRAYBUFFER_PROTOTYPE); + + DUK_ASSERT(h_bufobj != NULL); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->offset = uint_offset; + h_bufobj->length = uint_length; + DUK_ASSERT(h_bufobj->shift == 0); + h_bufobj->elem_type = DUK_HBUFFEROBJECT_ELEM_UINT8; + DUK_ASSERT(h_bufobj->is_view == 0); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE); + duk_compact(ctx, -1); + } +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + + return; + + range_error: + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_INVALID_CALL_ARGS); + return; /* not reached */ + + arg_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_CALL_ARGS); + return; /* not reached */ +} + +DUK_EXTERNAL duk_idx_t duk_push_error_object_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t ret; + duk_hobject *proto; +#ifdef DUK_USE_AUGMENT_ERROR_CREATE + duk_bool_t noblame_fileline; +#endif + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + DUK_UNREF(filename); + DUK_UNREF(line); + + /* Error code also packs a tracedata related flag. */ +#ifdef DUK_USE_AUGMENT_ERROR_CREATE + noblame_fileline = err_code & DUK_ERRCODE_FLAG_NOBLAME_FILELINE; +#endif + err_code = err_code & (~DUK_ERRCODE_FLAG_NOBLAME_FILELINE); + + /* error gets its 'name' from the prototype */ + proto = duk_error_prototype_from_code(thr, err_code); + ret = duk_push_object_helper_proto(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ERROR), + proto); + + /* ... and its 'message' from an instance property */ + if (fmt) { + duk_push_vsprintf(ctx, fmt, ap); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE, DUK_PROPDESC_FLAGS_WC); + } else { + /* If no explicit message given, put error code into message field + * (as a number). This is not fully in keeping with the Ecmascript + * error model because messages are supposed to be strings (Error + * constructors use ToString() on their argument). However, it's + * probably more useful than having a separate 'code' property. + */ + duk_push_int(ctx, err_code); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE, DUK_PROPDESC_FLAGS_WC); + } + +#if 0 + /* Disabled for now, not sure this is a useful property */ + duk_push_int(ctx, err_code); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_CODE, DUK_PROPDESC_FLAGS_WC); +#endif + + /* Creation time error augmentation */ +#ifdef DUK_USE_AUGMENT_ERROR_CREATE + /* filename may be NULL in which case file/line is not recorded */ + duk_err_augment_error_create(thr, thr, filename, line, noblame_fileline); /* may throw an error */ +#endif + + return ret; +} + +DUK_EXTERNAL duk_idx_t duk_push_error_object_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...) { + va_list ap; + duk_idx_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + + va_start(ap, fmt); + ret = duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap); + va_end(ap); + return ret; +} + +#if !defined(DUK_USE_VARIADIC_MACROS) +DUK_EXTERNAL duk_idx_t duk_push_error_object_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...) { + const char *filename = duk_api_global_filename; + duk_int_t line = duk_api_global_line; + va_list ap; + duk_idx_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + + duk_api_global_filename = NULL; + duk_api_global_line = 0; + va_start(ap, fmt); + ret = duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap); + va_end(ap); + return ret; +} +#endif /* DUK_USE_VARIADIC_MACROS */ + +DUK_EXTERNAL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_small_uint_t flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv_slot; + duk_hbuffer *h; + void *buf_data; + + DUK_ASSERT_CTX_VALID(ctx); + + /* check stack first */ + if (thr->valstack_top >= thr->valstack_end) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + } + + /* Check for maximum buffer length. */ + if (size > DUK_HBUFFER_MAX_BYTELEN) { + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_BUFFER_TOO_LONG); + } + + h = duk_hbuffer_alloc(thr->heap, size, flags, &buf_data); + if (!h) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); + } + + tv_slot = thr->valstack_top; + DUK_TVAL_SET_BUFFER(tv_slot, h); + DUK_HBUFFER_INCREF(thr, h); + thr->valstack_top++; + + return (void *) buf_data; +} + +DUK_EXTERNAL duk_idx_t duk_push_heapptr(duk_context *ctx, void *ptr) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t ret; + + DUK_ASSERT_CTX_VALID(ctx); + + ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); + + if (ptr == NULL) { + goto push_undefined; + } + + switch (DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) ptr)) { + case DUK_HTYPE_STRING: + duk_push_hstring(ctx, (duk_hstring *) ptr); + break; + case DUK_HTYPE_OBJECT: + duk_push_hobject(ctx, (duk_hobject *) ptr); + break; + case DUK_HTYPE_BUFFER: + duk_push_hbuffer(ctx, (duk_hbuffer *) ptr); + break; + default: + goto push_undefined; + } + return ret; + + push_undefined: + duk_push_undefined(ctx); + return ret; +} + +DUK_INTERNAL duk_idx_t duk_push_object_internal(duk_context *ctx) { + return duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT), + -1); /* no prototype */ +} + +DUK_INTERNAL void duk_push_hstring(duk_context *ctx, duk_hstring *h) { + duk_tval tv; + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(h != NULL); + DUK_TVAL_SET_STRING(&tv, h); + duk_push_tval(ctx, &tv); +} + +DUK_INTERNAL void duk_push_hstring_stridx(duk_context *ctx, duk_small_int_t stridx) { + duk_hthread *thr = (duk_hthread *) ctx; + DUK_ASSERT(stridx >= 0 && stridx < DUK_HEAP_NUM_STRINGS); + duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx)); +} + +DUK_INTERNAL void duk_push_hobject(duk_context *ctx, duk_hobject *h) { + duk_tval tv; + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(h != NULL); + DUK_TVAL_SET_OBJECT(&tv, h); + duk_push_tval(ctx, &tv); +} + +DUK_INTERNAL void duk_push_hbuffer(duk_context *ctx, duk_hbuffer *h) { + duk_tval tv; + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(h != NULL); + DUK_TVAL_SET_BUFFER(&tv, h); + duk_push_tval(ctx, &tv); +} + +DUK_INTERNAL void duk_push_hobject_bidx(duk_context *ctx, duk_small_int_t builtin_idx) { + duk_hthread *thr = (duk_hthread *) ctx; + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + DUK_ASSERT(builtin_idx >= 0 && builtin_idx < DUK_NUM_BUILTINS); + DUK_ASSERT(thr->builtins[builtin_idx] != NULL); + duk_push_hobject(ctx, thr->builtins[builtin_idx]); +} + +/* + * Poppers + */ + +DUK_EXTERNAL void duk_pop_n(duk_context *ctx, duk_idx_t count) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + + if (count < 0) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT); + return; + } + + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + if ((duk_size_t) (thr->valstack_top - thr->valstack_bottom) < (duk_size_t) count) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_POP_TOO_MANY); + } + + /* + * Must be very careful here, every DECREF may cause reallocation + * of our valstack. + */ + + /* XXX: inlined DECREF macro would be nice here: no NULL check, + * refzero queueing but no refzero algorithm run (= no pointer + * instability), inline code. + */ + +#ifdef DUK_USE_REFERENCE_COUNTING + while (count > 0) { + duk_tval tv_tmp; + duk_tval *tv; + + tv = --thr->valstack_top; /* tv points to element just below prev top */ + DUK_ASSERT(tv >= thr->valstack_bottom); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_UNDEFINED_UNUSED(tv); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + count--; + } +#else + while (count > 0) { + duk_tval *tv; + + tv = --thr->valstack_top; + DUK_ASSERT(tv >= thr->valstack_bottom); + DUK_TVAL_SET_UNDEFINED_UNUSED(tv); + count--; + } +#endif + + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); +} + +DUK_EXTERNAL void duk_pop(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + duk_pop_n(ctx, 1); +} + +DUK_EXTERNAL void duk_pop_2(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + duk_pop_n(ctx, 2); +} + +DUK_EXTERNAL void duk_pop_3(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + duk_pop_n(ctx, 3); +} + +/* + * Error throwing + */ + +DUK_EXTERNAL void duk_throw(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + + if (thr->valstack_top == thr->valstack_bottom) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + } + + /* Errors are augmented when they are created, not when they are + * thrown or re-thrown. The current error handler, however, runs + * just before an error is thrown. + */ + + /* Sync so that augmentation sees up-to-date activations, NULL + * thr->ptr_curr_pc so that it's not used if side effects occur + * in augmentation or longjmp handling. + */ + duk_hthread_sync_and_null_currpc(thr); + +#if defined(DUK_USE_AUGMENT_ERROR_THROW) + DUK_DDD(DUK_DDDPRINT("THROW ERROR (API): %!dT (before throw augment)", (duk_tval *) duk_get_tval(ctx, -1))); + duk_err_augment_error_throw(thr); +#endif + DUK_DDD(DUK_DDDPRINT("THROW ERROR (API): %!dT (after throw augment)", (duk_tval *) duk_get_tval(ctx, -1))); + + duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW); + + /* thr->heap->lj.jmpbuf_ptr is checked by duk_err_longjmp() so we don't + * need to check that here. If the value is NULL, a panic occurs because + * we can't return. + */ + + duk_err_longjmp(thr); + DUK_UNREACHABLE(); +} + +DUK_EXTERNAL void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char *err_msg) { + duk_hthread *thr = (duk_hthread *) ctx; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(thr->heap->fatal_func != NULL); + + DUK_D(DUK_DPRINT("fatal error occurred, code %ld, message %s", + (long) err_code, (const char *) err_msg)); + + /* fatal_func should be noreturn, but noreturn declarations on function + * pointers has a very spotty support apparently so it's not currently + * done. + */ + thr->heap->fatal_func(ctx, err_code, err_msg); + + DUK_PANIC(DUK_ERR_API_ERROR, "fatal handler returned"); +} + +DUK_EXTERNAL void duk_error_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap) { + DUK_ASSERT_CTX_VALID(ctx); + + duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap); + duk_throw(ctx); +} + +DUK_EXTERNAL void duk_error_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...) { + va_list ap; + + DUK_ASSERT_CTX_VALID(ctx); + + va_start(ap, fmt); + duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap); + va_end(ap); + duk_throw(ctx); +} + +#if !defined(DUK_USE_VARIADIC_MACROS) +DUK_EXTERNAL void duk_error_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...) { + const char *filename; + duk_int_t line; + va_list ap; + + DUK_ASSERT_CTX_VALID(ctx); + + filename = duk_api_global_filename; + line = duk_api_global_line; + duk_api_global_filename = NULL; + duk_api_global_line = 0; + + va_start(ap, fmt); + duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap); + va_end(ap); + duk_throw(ctx); +} +#endif /* DUK_USE_VARIADIC_MACROS */ + +/* + * Comparison + */ + +DUK_EXTERNAL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv1, *tv2; + + DUK_ASSERT_CTX_VALID(ctx); + + tv1 = duk_get_tval(ctx, index1); + tv2 = duk_get_tval(ctx, index2); + if ((tv1 == NULL) || (tv2 == NULL)) { + return 0; + } + + /* Coercion may be needed, the helper handles that by pushing the + * tagged values to the stack. + */ + return duk_js_equals(thr, tv1, tv2); +} + +DUK_EXTERNAL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) { + duk_tval *tv1, *tv2; + + DUK_ASSERT_CTX_VALID(ctx); + + tv1 = duk_get_tval(ctx, index1); + tv2 = duk_get_tval(ctx, index2); + if ((tv1 == NULL) || (tv2 == NULL)) { + return 0; + } + + /* No coercions or other side effects, so safe */ + return duk_js_strict_equals(tv1, tv2); +} + +/* + * instanceof + */ + +DUK_EXTERNAL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) { + duk_tval *tv1, *tv2; + + DUK_ASSERT_CTX_VALID(ctx); + + /* Index validation is strict, which differs from duk_equals(). + * The strict behavior mimics how instanceof itself works, e.g. + * it is a TypeError if rval is not a -callable- object. It would + * be somewhat inconsistent if rval would be allowed to be + * non-existent without a TypeError. + */ + tv1 = duk_require_tval(ctx, index1); + DUK_ASSERT(tv1 != NULL); + tv2 = duk_require_tval(ctx, index2); + DUK_ASSERT(tv2 != NULL); + + return duk_js_instanceof((duk_hthread *) ctx, tv1, tv2); +} + +/* + * Lightfunc + */ + +DUK_INTERNAL void duk_push_lightfunc_name(duk_context *ctx, duk_tval *tv) { + duk_c_function func; + + DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv)); + + /* Lightfunc name, includes Duktape/C native function pointer, which + * can often be used to locate the function from a symbol table. + * The name also includes the 16-bit duk_tval flags field because it + * includes the magic value. Because a single native function often + * provides different functionality depending on the magic value, it + * seems reasonably to include it in the name. + * + * On the other hand, a complicated name increases string table + * pressure in low memory environments (but only when function name + * is accessed). + */ + + func = DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv); + duk_push_sprintf(ctx, "light_"); + duk_push_string_funcptr(ctx, (duk_uint8_t *) &func, sizeof(func)); + duk_push_sprintf(ctx, "_%04x", (unsigned int) DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv)); + duk_concat(ctx, 3); +} + +DUK_INTERNAL void duk_push_lightfunc_tostring(duk_context *ctx, duk_tval *tv) { + DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv)); + + duk_push_string(ctx, "function "); + duk_push_lightfunc_name(ctx, tv); + duk_push_string(ctx, "() {/* light */}"); + duk_concat(ctx, 3); +} + +/* + * Function pointers + * + * Printing function pointers is non-portable, so we do that by hex printing + * bytes from memory. + */ + +DUK_INTERNAL void duk_push_string_funcptr(duk_context *ctx, duk_uint8_t *ptr, duk_size_t sz) { + duk_uint8_t buf[32 * 2]; + duk_uint8_t *p, *q; + duk_small_uint_t i; + duk_small_uint_t t; + + DUK_ASSERT(sz <= 32); /* sanity limit for function pointer size */ + + p = buf; +#if defined(DUK_USE_INTEGER_LE) + q = ptr + sz; +#else + q = ptr; +#endif + for (i = 0; i < sz; i++) { +#if defined(DUK_USE_INTEGER_LE) + t = *(--q); +#else + t = *(q++); +#endif + *p++ = duk_lc_digits[t >> 4]; + *p++ = duk_lc_digits[t & 0x0f]; + } + + duk_push_lstring(ctx, (const char *) buf, sz * 2); +} + +#undef DUK__CHECK_SPACE +#line 1 "duk_api_string.c" +/* + * String manipulation + */ + +/* include removed: duk_internal.h */ + +DUK_LOCAL void duk__concat_and_join_helper(duk_context *ctx, duk_idx_t count_in, duk_bool_t is_join) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_uint_t count; + duk_uint_t i; + duk_size_t idx; + duk_size_t len; + duk_hstring *h; + duk_uint8_t *buf; + + DUK_ASSERT_CTX_VALID(ctx); + + if (DUK_UNLIKELY(count_in <= 0)) { + if (count_in < 0) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT); + return; + } + DUK_ASSERT(count_in == 0); + duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING); + return; + } + count = (duk_uint_t) count_in; + + if (is_join) { + duk_size_t t1, t2, limit; + h = duk_to_hstring(ctx, -((duk_idx_t) count) - 1); + DUK_ASSERT(h != NULL); + + /* A bit tricky overflow test, see doc/code-issues.rst. */ + t1 = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h); + t2 = (duk_size_t) (count - 1); + limit = (duk_size_t) DUK_HSTRING_MAX_BYTELEN; + if (DUK_UNLIKELY(t2 != 0 && t1 > limit / t2)) { + /* Combined size of separators already overflows */ + goto error_overflow; + } + len = (duk_size_t) (t1 * t2); + } else { + len = (duk_size_t) 0; + } + + for (i = count; i >= 1; i--) { + duk_size_t new_len; + duk_to_string(ctx, -((duk_idx_t) i)); + h = duk_require_hstring(ctx, -((duk_idx_t) i)); + new_len = len + (duk_size_t) DUK_HSTRING_GET_BYTELEN(h); + + /* Impose a string maximum length, need to handle overflow + * correctly. + */ + if (new_len < len || /* wrapped */ + new_len > (duk_size_t) DUK_HSTRING_MAX_BYTELEN) { + goto error_overflow; + } + len = new_len; + } + + DUK_DDD(DUK_DDDPRINT("join/concat %lu strings, total length %lu bytes", + (unsigned long) count, (unsigned long) len)); + + /* use stack allocated buffer to ensure reachability in errors (e.g. intern error) */ + buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, len); + DUK_ASSERT(buf != NULL); + + /* [... (sep) str1 str2 ... strN buf] */ + + idx = 0; + for (i = count; i >= 1; i--) { + if (is_join && i != count) { + h = duk_require_hstring(ctx, -((duk_idx_t) count) - 2); /* extra -1 for buffer */ + DUK_MEMCPY(buf + idx, DUK_HSTRING_GET_DATA(h), DUK_HSTRING_GET_BYTELEN(h)); + idx += DUK_HSTRING_GET_BYTELEN(h); + } + h = duk_require_hstring(ctx, -((duk_idx_t) i) - 1); /* extra -1 for buffer */ + DUK_MEMCPY(buf + idx, DUK_HSTRING_GET_DATA(h), DUK_HSTRING_GET_BYTELEN(h)); + idx += DUK_HSTRING_GET_BYTELEN(h); + } + + DUK_ASSERT(idx == len); + + /* [... (sep) str1 str2 ... strN buf] */ + + /* get rid of the strings early to minimize memory use before intern */ + + if (is_join) { + duk_replace(ctx, -((duk_idx_t) count) - 2); /* overwrite sep */ + duk_pop_n(ctx, count); + } else { + duk_replace(ctx, -((duk_idx_t) count) - 1); /* overwrite str1 */ + duk_pop_n(ctx, count-1); + } + + /* [... buf] */ + + (void) duk_to_string(ctx, -1); + + /* [... res] */ + return; + + error_overflow: + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_CONCAT_RESULT_TOO_LONG); +} + +DUK_EXTERNAL void duk_concat(duk_context *ctx, duk_idx_t count) { + DUK_ASSERT_CTX_VALID(ctx); + + duk__concat_and_join_helper(ctx, count, 0 /*is_join*/); +} + +DUK_EXTERNAL void duk_join(duk_context *ctx, duk_idx_t count) { + DUK_ASSERT_CTX_VALID(ctx); + + duk__concat_and_join_helper(ctx, count, 1 /*is_join*/); +} + +/* XXX: could map/decode be unified with duk_unicode_support.c code? + * Case conversion needs also the character surroundings though. + */ + +DUK_EXTERNAL void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decode_char_function callback, void *udata) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h_input; + const duk_uint8_t *p, *p_start, *p_end; + duk_codepoint_t cp; + + DUK_ASSERT_CTX_VALID(ctx); + + h_input = duk_require_hstring(ctx, index); + DUK_ASSERT(h_input != NULL); + + p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); + p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input); + p = p_start; + + for (;;) { + if (p >= p_end) { + break; + } + cp = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end); + callback(udata, cp); + } +} + +DUK_EXTERNAL void duk_map_string(duk_context *ctx, duk_idx_t index, duk_map_char_function callback, void *udata) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h_input; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; + const duk_uint8_t *p, *p_start, *p_end; + duk_codepoint_t cp; + + DUK_ASSERT_CTX_VALID(ctx); + + index = duk_normalize_index(ctx, index); + + h_input = duk_require_hstring(ctx, index); + DUK_ASSERT(h_input != NULL); + + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input)); /* reasonable output estimate */ + + p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); + p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input); + p = p_start; + + for (;;) { + /* XXX: could write output in chunks with fewer ensure calls, + * but relative benefit would be small here. + */ + + if (p >= p_end) { + break; + } + cp = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end); + cp = callback(udata, cp); + + DUK_BW_WRITE_ENSURE_XUTF8(thr, bw, cp); + } + + DUK_BW_COMPACT(thr, bw); + duk_to_string(ctx, -1); + duk_replace(ctx, index); +} + +DUK_EXTERNAL void duk_substring(duk_context *ctx, duk_idx_t index, duk_size_t start_offset, duk_size_t end_offset) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h; + duk_hstring *res; + duk_size_t start_byte_offset; + duk_size_t end_byte_offset; + + DUK_ASSERT_CTX_VALID(ctx); + + index = duk_require_normalize_index(ctx, index); + h = duk_require_hstring(ctx, index); + DUK_ASSERT(h != NULL); + + if (end_offset >= DUK_HSTRING_GET_CHARLEN(h)) { + end_offset = DUK_HSTRING_GET_CHARLEN(h); + } + if (start_offset > end_offset) { + start_offset = end_offset; + } + + DUK_ASSERT_DISABLE(start_offset >= 0); + DUK_ASSERT(start_offset <= end_offset && start_offset <= DUK_HSTRING_GET_CHARLEN(h)); + DUK_ASSERT_DISABLE(end_offset >= 0); + DUK_ASSERT(end_offset >= start_offset && end_offset <= DUK_HSTRING_GET_CHARLEN(h)); + + /* guaranteed by string limits */ + DUK_ASSERT(start_offset <= DUK_UINT32_MAX); + DUK_ASSERT(end_offset <= DUK_UINT32_MAX); + + start_byte_offset = (duk_size_t) duk_heap_strcache_offset_char2byte(thr, h, (duk_uint_fast32_t) start_offset); + end_byte_offset = (duk_size_t) duk_heap_strcache_offset_char2byte(thr, h, (duk_uint_fast32_t) end_offset); + + DUK_ASSERT(end_byte_offset >= start_byte_offset); + DUK_ASSERT(end_byte_offset - start_byte_offset <= DUK_UINT32_MAX); /* guaranteed by string limits */ + + /* no size check is necessary */ + res = duk_heap_string_intern_checked(thr, + DUK_HSTRING_GET_DATA(h) + start_byte_offset, + (duk_uint32_t) (end_byte_offset - start_byte_offset)); + + duk_push_hstring(ctx, res); + duk_replace(ctx, index); +} + +/* XXX: this is quite clunky. Add Unicode helpers to scan backwards and + * forwards with a callback to process codepoints? + */ +DUK_EXTERNAL void duk_trim(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h; + const duk_uint8_t *p, *p_start, *p_end, *p_tmp1, *p_tmp2; /* pointers for scanning */ + const duk_uint8_t *q_start, *q_end; /* start (incl) and end (excl) of trimmed part */ + duk_codepoint_t cp; + + DUK_ASSERT_CTX_VALID(ctx); + + index = duk_require_normalize_index(ctx, index); + h = duk_require_hstring(ctx, index); + DUK_ASSERT(h != NULL); + + p_start = DUK_HSTRING_GET_DATA(h); + p_end = p_start + DUK_HSTRING_GET_BYTELEN(h); + + p = p_start; + while (p < p_end) { + p_tmp1 = p; + cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &p_tmp1, p_start, p_end); + if (!(duk_unicode_is_whitespace(cp) || duk_unicode_is_line_terminator(cp))) { + break; + } + p = p_tmp1; + } + q_start = p; + if (p == p_end) { + /* entire string is whitespace */ + q_end = p; + goto scan_done; + } + + p = p_end; + while (p > p_start) { + p_tmp1 = p; + while (p > p_start) { + p--; + if (((*p) & 0xc0) != 0x80) { + break; + } + } + p_tmp2 = p; + + cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &p_tmp2, p_start, p_end); + if (!(duk_unicode_is_whitespace(cp) || duk_unicode_is_line_terminator(cp))) { + p = p_tmp1; + break; + } + } + q_end = p; + + scan_done: + /* This may happen when forward and backward scanning disagree + * (possible for non-extended-UTF-8 strings). + */ + if (q_end < q_start) { + q_end = q_start; + } + + DUK_ASSERT(q_start >= p_start && q_start <= p_end); + DUK_ASSERT(q_end >= p_start && q_end <= p_end); + DUK_ASSERT(q_end >= q_start); + + DUK_DDD(DUK_DDDPRINT("trim: p_start=%p, p_end=%p, q_start=%p, q_end=%p", + (void *) p_start, (void *) p_end, (void *) q_start, (void *) q_end)); + + if (q_start == p_start && q_end == p_end) { + DUK_DDD(DUK_DDDPRINT("nothing was trimmed: avoid interning (hashing etc)")); + return; + } + + duk_push_lstring(ctx, (const char *) q_start, (duk_size_t) (q_end - q_start)); + duk_replace(ctx, index); +} + +DUK_EXTERNAL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t index, duk_size_t char_offset) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h; + duk_ucodepoint_t cp; + + DUK_ASSERT_CTX_VALID(ctx); + + h = duk_require_hstring(ctx, index); + DUK_ASSERT(h != NULL); + + DUK_ASSERT_DISABLE(char_offset >= 0); /* always true, arg is unsigned */ + if (char_offset >= DUK_HSTRING_GET_CHARLEN(h)) { + return 0; + } + + DUK_ASSERT(char_offset <= DUK_UINT_MAX); /* guaranteed by string limits */ + cp = duk_hstring_char_code_at_raw(thr, h, (duk_uint_t) char_offset); + return (duk_codepoint_t) cp; +} +#line 1 "duk_api_var.c" +/* + * Variable access + */ + +/* include removed: duk_internal.h */ + +DUK_EXTERNAL void duk_get_var(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_activation *act; + duk_hstring *h_varname; + duk_small_int_t throw_flag = 1; /* always throw ReferenceError for unresolvable */ + + DUK_ASSERT_CTX_VALID(ctx); + + h_varname = duk_require_hstring(ctx, -1); /* XXX: tostring? */ + DUK_ASSERT(h_varname != NULL); + + act = duk_hthread_get_current_activation(thr); + if (act) { + (void) duk_js_getvar_activation(thr, act, h_varname, throw_flag); /* -> [ ... varname val this ] */ + } else { + /* Outside any activation -> look up from global. */ + DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL_ENV] != NULL); + (void) duk_js_getvar_envrec(thr, thr->builtins[DUK_BIDX_GLOBAL_ENV], h_varname, throw_flag); + } + + /* [ ... varname val this ] (because throw_flag == 1, always resolved) */ + + duk_pop(ctx); + duk_remove(ctx, -2); + + /* [ ... val ] */ + + /* Return value would be pointless: because throw_flag==1, we always + * throw if the identifier doesn't resolve. + */ + return; +} + +DUK_EXTERNAL void duk_put_var(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_activation *act; + duk_hstring *h_varname; + duk_tval *tv_val; + duk_small_int_t throw_flag; + + DUK_ASSERT_CTX_VALID(ctx); + + h_varname = duk_require_hstring(ctx, -2); /* XXX: tostring? */ + DUK_ASSERT(h_varname != NULL); + + tv_val = duk_require_tval(ctx, -1); + + throw_flag = duk_is_strict_call(ctx); + + act = duk_hthread_get_current_activation(thr); + if (act) { + duk_js_putvar_activation(thr, act, h_varname, tv_val, throw_flag); /* -> [ ... varname val this ] */ + } else { + /* Outside any activation -> put to global. */ + DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL_ENV] != NULL); + duk_js_putvar_envrec(thr, thr->builtins[DUK_BIDX_GLOBAL_ENV], h_varname, tv_val, throw_flag); + } + + /* [ ... varname val ] */ + + duk_pop_2(ctx); + + /* [ ... ] */ + + return; +} + +DUK_EXTERNAL duk_bool_t duk_del_var(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_UNIMPLEMENTED_ERROR, DUK_STR_UNIMPLEMENTED); + return 0; +} + +DUK_EXTERNAL duk_bool_t duk_has_var(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_UNIMPLEMENTED_ERROR, DUK_STR_UNIMPLEMENTED); + return 0; +} +#line 1 "duk_bi_array.c" +/* + * Array built-ins + * + * Note that most Array built-ins are intentionally generic and work even + * when the 'this' binding is not an Array instance. To ensure this, + * Array algorithms do not assume "magical" Array behavior for the "length" + * property, for instance. + * + * XXX: the "Throw" flag should be set for (almost?) all [[Put]] and + * [[Delete]] operations, but it's currently false throughout. Go through + * all put/delete cases and check throw flag use. Need a new API primitive + * which allows throws flag to be specified. + * + * XXX: array lengths above 2G won't work reliably. There are many places + * where one needs a full signed 32-bit range ([-0xffffffff, 0xffffffff], + * i.e. -33- bits). Although array 'length' cannot be written to be outside + * the unsigned 32-bit range (E5.1 Section 15.4.5.1 throws a RangeError if so) + * some intermediate values may be above 0xffffffff and this may not be always + * correctly handled now (duk_uint32_t is not enough for all algorithms). + * + * For instance, push() can legitimately write entries beyond length 0xffffffff + * and cause a RangeError only at the end. To do this properly, the current + * push() implementation tracks the array index using a 'double' instead of a + * duk_uint32_t (which is somewhat awkward). See test-bi-array-push-maxlen.js. + * + * On using "put" vs. "def" prop + * ============================= + * + * Code below must be careful to use the appropriate primitive as it matters + * for compliance. When using "put" there may be inherited properties in + * Array.prototype which cause side effects when values are written. When + * using "define" there are no such side effects, and many test262 test cases + * check for this (for real world code, such side effects are very rare). + * Both "put" and "define" are used in the E5.1 specification; as a rule, + * "put" is used when modifying an existing array (or a non-array 'this' + * binding) and "define" for setting values into a fresh result array. + * + * Also note that Array instance 'length' should be writable, but not + * enumerable and definitely not configurable: even Duktape code internally + * assumes that an Array instance will always have a 'length' property. + * Preventing deletion of the property is critical. + */ + +/* include removed: duk_internal.h */ + +/* Perform an intermediate join when this many elements have been pushed + * on the value stack. + */ +#define DUK__ARRAY_MID_JOIN_LIMIT 4096 + +/* Shared entry code for many Array built-ins. Note that length is left + * on stack (it could be popped, but that's not necessary). + */ +DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32(duk_context *ctx) { + duk_uint32_t len; + + (void) duk_push_this_coercible_to_object(ctx); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH); + len = duk_to_uint32(ctx, -1); + + /* -> [ ... ToObject(this) ToUint32(length) ] */ + return len; +} + +DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32_limited(duk_context *ctx) { + /* Range limited to [0, 0x7fffffff] range, i.e. range that can be + * represented with duk_int32_t. Use this when the method doesn't + * handle the full 32-bit unsigned range correctly. + */ + duk_uint32_t ret = duk__push_this_obj_len_u32(ctx); + if (DUK_UNLIKELY(ret >= 0x80000000UL)) { + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_INTERNAL_ERROR, DUK_STR_ARRAY_LENGTH_OVER_2G); + } + return ret; +} + +/* + * Constructor + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_constructor(duk_context *ctx) { + duk_idx_t nargs; + duk_double_t d; + duk_uint32_t len; + duk_idx_t i; + + nargs = duk_get_top(ctx); + duk_push_array(ctx); + + if (nargs == 1 && duk_is_number(ctx, 0)) { + /* XXX: expensive check (also shared elsewhere - so add a shared internal API call?) */ + d = duk_get_number(ctx, 0); + len = duk_to_uint32(ctx, 0); + if (((duk_double_t) len) != d) { + return DUK_RET_RANGE_ERROR; + } + + /* XXX: if 'len' is low, may want to ensure array part is kept: + * the caller is likely to want a dense array. + */ + duk_push_u32(ctx, len); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W); /* [ ToUint32(len) array ToUint32(len) ] -> [ ToUint32(len) array ] */ + return 1; + } + + /* XXX: optimize by creating array into correct size directly, and + * operating on the array part directly; values can be memcpy()'d from + * value stack directly as long as refcounts are increased. + */ + for (i = 0; i < nargs; i++) { + duk_dup(ctx, i); + duk_xdef_prop_index_wec(ctx, -2, (duk_uarridx_t) i); + } + + duk_push_u32(ctx, (duk_uint32_t) nargs); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W); + return 1; +} + +/* + * isArray() + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_constructor_is_array(duk_context *ctx) { + duk_hobject *h; + + h = duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_ARRAY); + duk_push_boolean(ctx, (h != NULL)); + return 1; +} + +/* + * toString() + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_to_string(duk_context *ctx) { + (void) duk_push_this_coercible_to_object(ctx); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_JOIN); + + /* [ ... this func ] */ + if (!duk_is_callable(ctx, -1)) { + /* Fall back to the initial (original) Object.toString(). We don't + * currently have pointers to the built-in functions, only the top + * level global objects (like "Array") so this is now done in a bit + * of a hacky manner. It would be cleaner to push the (original) + * function and use duk_call_method(). + */ + + /* XXX: 'this' will be ToObject() coerced twice, which is incorrect + * but should have no visible side effects. + */ + DUK_DDD(DUK_DDDPRINT("this.join is not callable, fall back to (original) Object.toString")); + duk_set_top(ctx, 0); + return duk_bi_object_prototype_to_string(ctx); /* has access to 'this' binding */ + } + + /* [ ... this func ] */ + + duk_insert(ctx, -2); + + /* [ ... func this ] */ + + DUK_DDD(DUK_DDDPRINT("calling: func=%!iT, this=%!iT", + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + duk_call_method(ctx, 0); + + return 1; +} + +/* + * concat() + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_concat(duk_context *ctx) { + duk_idx_t i, n; + duk_uarridx_t idx, idx_last; + duk_uarridx_t j, len; + duk_hobject *h; + + /* XXX: the insert here is a bit expensive if there are a lot of items. + * It could also be special cased in the outermost for loop quite easily + * (as the element is dup()'d anyway). + */ + + (void) duk_push_this_coercible_to_object(ctx); + duk_insert(ctx, 0); + n = duk_get_top(ctx); + duk_push_array(ctx); /* -> [ ToObject(this) item1 ... itemN arr ] */ + + /* NOTE: The Array special behaviors are NOT invoked by duk_xdef_prop_index() + * (which differs from the official algorithm). If no error is thrown, this + * doesn't matter as the length is updated at the end. However, if an error + * is thrown, the length will be unset. That shouldn't matter because the + * caller won't get a reference to the intermediate value. + */ + + idx = 0; + idx_last = 0; + for (i = 0; i < n; i++) { + DUK_ASSERT_TOP(ctx, n + 1); + + /* [ ToObject(this) item1 ... itemN arr ] */ + + duk_dup(ctx, i); + h = duk_get_hobject_with_class(ctx, -1, DUK_HOBJECT_CLASS_ARRAY); + if (!h) { + duk_xdef_prop_index_wec(ctx, -2, idx++); + idx_last = idx; + continue; + } + + /* [ ToObject(this) item1 ... itemN arr item(i) ] */ + + /* XXX: an array can have length higher than 32 bits; this is not handled + * correctly now. + */ + len = (duk_uarridx_t) duk_get_length(ctx, -1); + for (j = 0; j < len; j++) { + if (duk_get_prop_index(ctx, -1, j)) { + /* [ ToObject(this) item1 ... itemN arr item(i) item(i)[j] ] */ + duk_xdef_prop_index_wec(ctx, -3, idx++); + idx_last = idx; + } else { + idx++; + duk_pop(ctx); +#if defined(DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER) + /* According to E5.1 Section 15.4.4.4 nonexistent trailing + * elements do not affect 'length' of the result. Test262 + * and other engines disagree, so update idx_last here too. + */ + idx_last = idx; +#else + /* Strict standard behavior, ignore trailing elements for + * result 'length'. + */ +#endif + } + } + duk_pop(ctx); + } + + /* The E5.1 Section 15.4.4.4 algorithm doesn't set the length explicitly + * in the end, but because we're operating with an internal value which + * is known to be an array, this should be equivalent. + */ + duk_push_uarridx(ctx, idx_last); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W); + + DUK_ASSERT_TOP(ctx, n + 1); + return 1; +} + +/* + * join(), toLocaleString() + * + * Note: checking valstack is necessary, but only in the per-element loop. + * + * Note: the trivial approach of pushing all the elements on the value stack + * and then calling duk_join() fails when the array contains a large number + * of elements. This problem can't be offloaded to duk_join() because the + * elements to join must be handled here and have special handling. Current + * approach is to do intermediate joins with very large number of elements. + * There is no fancy handling; the prefix gets re-joined multiple times. + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_join_shared(duk_context *ctx) { + duk_uint32_t len, count; + duk_uint32_t idx; + duk_small_int_t to_locale_string = duk_get_current_magic(ctx); + duk_idx_t valstack_required; + + /* For join(), nargs is 1. For toLocaleString(), nargs is 0 and + * setting the top essentially pushes an undefined to the stack, + * thus defaulting to a comma separator. + */ + duk_set_top(ctx, 1); + if (duk_is_undefined(ctx, 0)) { + duk_pop(ctx); + duk_push_hstring_stridx(ctx, DUK_STRIDX_COMMA); + } else { + duk_to_string(ctx, 0); + } + + len = duk__push_this_obj_len_u32(ctx); + + /* [ sep ToObject(this) len ] */ + + DUK_DDD(DUK_DDDPRINT("sep=%!T, this=%!T, len=%lu", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 1), + (unsigned long) len)); + + /* The extra (+4) is tight. */ + valstack_required = (len >= DUK__ARRAY_MID_JOIN_LIMIT ? + DUK__ARRAY_MID_JOIN_LIMIT : len) + 4; + duk_require_stack(ctx, valstack_required); + + duk_dup(ctx, 0); + + /* [ sep ToObject(this) len sep ] */ + + count = 0; + idx = 0; + for (;;) { + if (count >= DUK__ARRAY_MID_JOIN_LIMIT || /* intermediate join to avoid valstack overflow */ + idx >= len) { /* end of loop (careful with len==0) */ + /* [ sep ToObject(this) len sep str0 ... str(count-1) ] */ + DUK_DDD(DUK_DDDPRINT("mid/final join, count=%ld, idx=%ld, len=%ld", + (long) count, (long) idx, (long) len)); + duk_join(ctx, (duk_idx_t) count); /* -> [ sep ToObject(this) len str ] */ + duk_dup(ctx, 0); /* -> [ sep ToObject(this) len str sep ] */ + duk_insert(ctx, -2); /* -> [ sep ToObject(this) len sep str ] */ + count = 1; + } + if (idx >= len) { + /* if true, the stack already contains the final result */ + break; + } + + duk_get_prop_index(ctx, 1, (duk_uarridx_t) idx); + if (duk_is_null_or_undefined(ctx, -1)) { + duk_pop(ctx); + duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING); + } else { + if (to_locale_string) { + duk_to_object(ctx, -1); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_TO_LOCALE_STRING); + duk_insert(ctx, -2); /* -> [ ... toLocaleString ToObject(val) ] */ + duk_call_method(ctx, 0); + duk_to_string(ctx, -1); + } else { + duk_to_string(ctx, -1); + } + } + + count++; + idx++; + } + + /* [ sep ToObject(this) len sep result ] */ + + return 1; +} + +/* + * pop(), push() + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_pop(duk_context *ctx) { + duk_uint32_t len; + duk_uint32_t idx; + + DUK_ASSERT_TOP(ctx, 0); + len = duk__push_this_obj_len_u32(ctx); + if (len == 0) { + duk_push_int(ctx, 0); + duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH); + return 0; + } + idx = len - 1; + + duk_get_prop_index(ctx, 0, (duk_uarridx_t) idx); + duk_del_prop_index(ctx, 0, (duk_uarridx_t) idx); + duk_push_u32(ctx, idx); + duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_push(duk_context *ctx) { + /* Note: 'this' is not necessarily an Array object. The push() + * algorithm is supposed to work for other kinds of objects too, + * so the algorithm has e.g. an explicit update for the 'length' + * property which is normally "magical" in arrays. + */ + + duk_uint32_t len; + duk_idx_t i, n; + + n = duk_get_top(ctx); + len = duk__push_this_obj_len_u32(ctx); + + /* [ arg1 ... argN obj length ] */ + + /* Technically Array.prototype.push() can create an Array with length + * longer than 2^32-1, i.e. outside the 32-bit range. The final length + * is *not* wrapped to 32 bits in the specification. + * + * This implementation tracks length with a uint32 because it's much + * more practical. + * + * See: test-bi-array-push-maxlen.js. + */ + + if (len + (duk_uint32_t) n < len) { + DUK_D(DUK_DPRINT("Array.prototype.push() would go beyond 32-bit length, throw")); + return DUK_RET_RANGE_ERROR; + } + + for (i = 0; i < n; i++) { + duk_dup(ctx, i); + duk_put_prop_index(ctx, -3, len + i); + } + len += n; + + duk_push_u32(ctx, len); + duk_dup_top(ctx); + duk_put_prop_stridx(ctx, -4, DUK_STRIDX_LENGTH); + + /* [ arg1 ... argN obj length new_length ] */ + return 1; +} + +/* + * sort() + * + * Currently qsort with random pivot. This is now really, really slow, + * because there is no fast path for array parts. + * + * Signed indices are used because qsort() leaves and degenerate cases + * may use a negative offset. + */ + +DUK_LOCAL duk_small_int_t duk__array_sort_compare(duk_context *ctx, duk_int_t idx1, duk_int_t idx2) { + duk_bool_t have1, have2; + duk_bool_t undef1, undef2; + duk_small_int_t ret; + duk_idx_t idx_obj = 1; /* fixed offsets in valstack */ + duk_idx_t idx_fn = 0; + duk_hstring *h1, *h2; + + /* Fast exit if indices are identical. This is valid for a non-existent property, + * for an undefined value, and almost always for ToString() coerced comparison of + * arbitrary values (corner cases where this is not the case include e.g. a an + * object with varying ToString() coercion). + * + * The specification does not prohibit "caching" of values read from the array, so + * assuming equality for comparing an index with itself falls into the category of + * "caching". + * + * Also, compareFn may be inconsistent, so skipping a call to compareFn here may + * have an effect on the final result. The specification does not require any + * specific behavior for inconsistent compare functions, so again, this fast path + * is OK. + */ + + if (idx1 == idx2) { + DUK_DDD(DUK_DDDPRINT("duk__array_sort_compare: idx1=%ld, idx2=%ld -> indices identical, quick exit", + (long) idx1, (long) idx2)); + return 0; + } + + have1 = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) idx1); + have2 = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) idx2); + + DUK_DDD(DUK_DDDPRINT("duk__array_sort_compare: idx1=%ld, idx2=%ld, have1=%ld, have2=%ld, val1=%!T, val2=%!T", + (long) idx1, (long) idx2, (long) have1, (long) have2, + (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1))); + + if (have1) { + if (have2) { + ; + } else { + ret = -1; + goto pop_ret; + } + } else { + if (have2) { + ret = 1; + goto pop_ret; + } else { + ret = 0; + goto pop_ret; + } + } + + undef1 = duk_is_undefined(ctx, -2); + undef2 = duk_is_undefined(ctx, -1); + if (undef1) { + if (undef2) { + ret = 0; + goto pop_ret; + } else { + ret = 1; + goto pop_ret; + } + } else { + if (undef2) { + ret = -1; + goto pop_ret; + } else { + ; + } + } + + if (!duk_is_undefined(ctx, idx_fn)) { + duk_double_t d; + + /* no need to check callable; duk_call() will do that */ + duk_dup(ctx, idx_fn); /* -> [ ... x y fn ] */ + duk_insert(ctx, -3); /* -> [ ... fn x y ] */ + duk_call(ctx, 2); /* -> [ ... res ] */ + + /* The specification is a bit vague what to do if the return + * value is not a number. Other implementations seem to + * tolerate non-numbers but e.g. V8 won't apparently do a + * ToNumber(). + */ + + /* XXX: best behavior for real world compatibility? */ + + d = duk_to_number(ctx, -1); + if (d < 0.0) { + ret = -1; + } else if (d > 0.0) { + ret = 1; + } else { + ret = 0; + } + + duk_pop(ctx); + DUK_DDD(DUK_DDDPRINT("-> result %ld (from comparefn, after coercion)", (long) ret)); + return ret; + } + + /* string compare is the default (a bit oddly) */ + + h1 = duk_to_hstring(ctx, -2); + h2 = duk_to_hstring(ctx, -1); + DUK_ASSERT(h1 != NULL); + DUK_ASSERT(h2 != NULL); + + ret = duk_js_string_compare(h1, h2); /* retval is directly usable */ + goto pop_ret; + + pop_ret: + duk_pop_2(ctx); + DUK_DDD(DUK_DDDPRINT("-> result %ld", (long) ret)); + return ret; +} + +DUK_LOCAL void duk__array_sort_swap(duk_context *ctx, duk_int_t l, duk_int_t r) { + duk_bool_t have_l, have_r; + duk_idx_t idx_obj = 1; /* fixed offset in valstack */ + + if (l == r) { + return; + } + + /* swap elements; deal with non-existent elements correctly */ + have_l = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) l); + have_r = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) r); + + if (have_r) { + /* right exists, [[Put]] regardless whether or not left exists */ + duk_put_prop_index(ctx, idx_obj, (duk_uarridx_t) l); + } else { + duk_del_prop_index(ctx, idx_obj, (duk_uarridx_t) l); + duk_pop(ctx); + } + + if (have_l) { + duk_put_prop_index(ctx, idx_obj, (duk_uarridx_t) r); + } else { + duk_del_prop_index(ctx, idx_obj, (duk_uarridx_t) r); + duk_pop(ctx); + } +} + +#if defined(DUK_USE_DDDPRINT) +/* Debug print which visualizes the qsort partitioning process. */ +DUK_LOCAL void duk__debuglog_qsort_state(duk_context *ctx, duk_int_t lo, duk_int_t hi, duk_int_t pivot) { + char buf[4096]; + char *ptr = buf; + duk_int_t i, n; + n = (duk_int_t) duk_get_length(ctx, 1); + if (n > 4000) { + n = 4000; + } + *ptr++ = '['; + for (i = 0; i < n; i++) { + if (i == pivot) { + *ptr++ = '|'; + } else if (i == lo) { + *ptr++ = '<'; + } else if (i == hi) { + *ptr++ = '>'; + } else if (i >= lo && i <= hi) { + *ptr++ = '-'; + } else { + *ptr++ = ' '; + } + } + *ptr++ = ']'; + *ptr++ = '\0'; + + DUK_DDD(DUK_DDDPRINT("%s (lo=%ld, hi=%ld, pivot=%ld)", + (const char *) buf, (long) lo, (long) hi, (long) pivot)); +} +#endif + +DUK_LOCAL void duk__array_qsort(duk_context *ctx, duk_int_t lo, duk_int_t hi) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_int_t p, l, r; + + /* The lo/hi indices may be crossed and hi < 0 is possible at entry. */ + + DUK_DDD(DUK_DDDPRINT("duk__array_qsort: lo=%ld, hi=%ld, obj=%!T", + (long) lo, (long) hi, (duk_tval *) duk_get_tval(ctx, 1))); + + DUK_ASSERT_TOP(ctx, 3); + + /* In some cases it may be that lo > hi, or hi < 0; these + * degenerate cases happen e.g. for empty arrays, and in + * recursion leaves. + */ + + /* trivial cases */ + if (hi - lo < 1) { + DUK_DDD(DUK_DDDPRINT("degenerate case, return immediately")); + return; + } + DUK_ASSERT(hi > lo); + DUK_ASSERT(hi - lo + 1 >= 2); + + /* randomized pivot selection */ + p = lo + (duk_util_tinyrandom_get_bits(thr, 30) % (hi - lo + 1)); /* rnd in [lo,hi] */ + DUK_ASSERT(p >= lo && p <= hi); + DUK_DDD(DUK_DDDPRINT("lo=%ld, hi=%ld, chose pivot p=%ld", + (long) lo, (long) hi, (long) p)); + + /* move pivot out of the way */ + duk__array_sort_swap(ctx, p, lo); + p = lo; + DUK_DDD(DUK_DDDPRINT("pivot moved out of the way: %!T", (duk_tval *) duk_get_tval(ctx, 1))); + + l = lo + 1; + r = hi; + for (;;) { + /* find elements to swap */ + for (;;) { + DUK_DDD(DUK_DDDPRINT("left scan: l=%ld, r=%ld, p=%ld", + (long) l, (long) r, (long) p)); + if (l >= hi) { + break; + } + if (duk__array_sort_compare(ctx, l, p) >= 0) { /* !(l < p) */ + break; + } + l++; + } + for (;;) { + DUK_DDD(DUK_DDDPRINT("right scan: l=%ld, r=%ld, p=%ld", + (long) l, (long) r, (long) p)); + if (r <= lo) { + break; + } + if (duk__array_sort_compare(ctx, p, r) >= 0) { /* !(p < r) */ + break; + } + r--; + } + if (l >= r) { + goto done; + } + DUK_ASSERT(l < r); + + DUK_DDD(DUK_DDDPRINT("swap %ld and %ld", (long) l, (long) r)); + + duk__array_sort_swap(ctx, l, r); + + DUK_DDD(DUK_DDDPRINT("after swap: %!T", (duk_tval *) duk_get_tval(ctx, 1))); + l++; + r--; + } + done: + /* Note that 'l' and 'r' may cross, i.e. r < l */ + DUK_ASSERT(l >= lo && l <= hi); + DUK_ASSERT(r >= lo && r <= hi); + + /* XXX: there's no explicit recursion bound here now. For the average + * qsort recursion depth O(log n) that's not really necessary: e.g. for + * 2**32 recursion depth would be about 32 which is OK. However, qsort + * worst case recursion depth is O(n) which may be a problem. + */ + + /* move pivot to its final place */ + DUK_DDD(DUK_DDDPRINT("before final pivot swap: %!T", (duk_tval *) duk_get_tval(ctx, 1))); + duk__array_sort_swap(ctx, lo, r); + +#if defined(DUK_USE_DDDPRINT) + duk__debuglog_qsort_state(ctx, lo, hi, r); +#endif + + DUK_DDD(DUK_DDDPRINT("recurse: pivot=%ld, obj=%!T", (long) r, (duk_tval *) duk_get_tval(ctx, 1))); + duk__array_qsort(ctx, lo, r - 1); + duk__array_qsort(ctx, r + 1, hi); +} + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_sort(duk_context *ctx) { + duk_uint32_t len; + + /* XXX: len >= 0x80000000 won't work below because a signed type + * is needed by qsort. + */ + len = duk__push_this_obj_len_u32_limited(ctx); + + /* stack[0] = compareFn + * stack[1] = ToObject(this) + * stack[2] = ToUint32(length) + */ + + if (len > 0) { + /* avoid degenerate cases, so that (len - 1) won't underflow */ + duk__array_qsort(ctx, (duk_int_t) 0, (duk_int_t) (len - 1)); + } + + DUK_ASSERT_TOP(ctx, 3); + duk_pop(ctx); + return 1; /* return ToObject(this) */ +} + +/* + * splice() + */ + +/* XXX: this compiles to over 500 bytes now, even without special handling + * for an array part. Uses signed ints so does not handle full array range correctly. + */ + +/* XXX: can shift() / unshift() use the same helper? + * shift() is (close to?) <--> splice(0, 1) + * unshift is (close to?) <--> splice(0, 0, [items])? + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_splice(duk_context *ctx) { + duk_idx_t nargs; + duk_uint32_t len; + duk_bool_t have_delcount; + duk_int_t item_count; + duk_int_t act_start; + duk_int_t del_count; + duk_int_t i, n; + + DUK_UNREF(have_delcount); + + nargs = duk_get_top(ctx); + if (nargs < 2) { + duk_set_top(ctx, 2); + nargs = 2; + have_delcount = 0; + } else { + have_delcount = 1; + } + + /* XXX: len >= 0x80000000 won't work below because we need to be + * able to represent -len. + */ + len = duk__push_this_obj_len_u32_limited(ctx); + + act_start = duk_to_int_clamped(ctx, 0, -((duk_int_t) len), (duk_int_t) len); + if (act_start < 0) { + act_start = len + act_start; + } + DUK_ASSERT(act_start >= 0 && act_start <= (duk_int_t) len); + +#ifdef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT + if (have_delcount) { +#endif + del_count = duk_to_int_clamped(ctx, 1, 0, len - act_start); +#ifdef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT + } else { + /* E5.1 standard behavior when deleteCount is not given would be + * to treat it just like if 'undefined' was given, which coerces + * ultimately to 0. Real world behavior is to splice to the end + * of array, see test-bi-array-proto-splice-no-delcount.js. + */ + del_count = len - act_start; + } +#endif + + DUK_ASSERT(nargs >= 2); + item_count = (duk_int_t) (nargs - 2); + + DUK_ASSERT(del_count >= 0 && del_count <= (duk_int_t) len - act_start); + DUK_ASSERT(del_count + act_start <= (duk_int_t) len); + + /* For now, restrict result array into 32-bit length range. */ + if (((duk_double_t) len) - ((duk_double_t) del_count) + ((duk_double_t) item_count) > (duk_double_t) DUK_UINT32_MAX) { + DUK_D(DUK_DPRINT("Array.prototype.splice() would go beyond 32-bit length, throw")); + return DUK_RET_RANGE_ERROR; + } + + duk_push_array(ctx); + + /* stack[0] = start + * stack[1] = deleteCount + * stack[2...nargs-1] = items + * stack[nargs] = ToObject(this) -3 + * stack[nargs+1] = ToUint32(length) -2 + * stack[nargs+2] = result array -1 + */ + + DUK_ASSERT_TOP(ctx, nargs + 3); + + /* Step 9: copy elements-to-be-deleted into the result array */ + + for (i = 0; i < del_count; i++) { + if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (act_start + i))) { + duk_xdef_prop_index_wec(ctx, -2, i); /* throw flag irrelevant (false in std alg) */ + } else { + duk_pop(ctx); + } + } + duk_push_u32(ctx, (duk_uint32_t) del_count); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W); + + /* Steps 12 and 13: reorganize elements to make room for itemCount elements */ + + if (item_count < del_count) { + /* [ A B C D E F G H ] rel_index = 2, del_count 3, item count 1 + * -> [ A B F G H ] (conceptual intermediate step) + * -> [ A B . F G H ] (placeholder marked) + * [ A B C F G H ] (actual result at this point, C will be replaced) + */ + + DUK_ASSERT_TOP(ctx, nargs + 3); + + n = len - del_count; + for (i = act_start; i < n; i++) { + if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (i + del_count))) { + duk_put_prop_index(ctx, -4, (duk_uarridx_t) (i + item_count)); + } else { + duk_pop(ctx); + duk_del_prop_index(ctx, -3, (duk_uarridx_t) (i + item_count)); + } + } + + DUK_ASSERT_TOP(ctx, nargs + 3); + + /* loop iterator init and limit changed from standard algorithm */ + n = len - del_count + item_count; + for (i = len - 1; i >= n; i--) { + duk_del_prop_index(ctx, -3, (duk_uarridx_t) i); + } + + DUK_ASSERT_TOP(ctx, nargs + 3); + } else if (item_count > del_count) { + /* [ A B C D E F G H ] rel_index = 2, del_count 3, item count 4 + * -> [ A B F G H ] (conceptual intermediate step) + * -> [ A B . . . . F G H ] (placeholder marked) + * [ A B C D E F F G H ] (actual result at this point) + */ + + DUK_ASSERT_TOP(ctx, nargs + 3); + + /* loop iterator init and limit changed from standard algorithm */ + for (i = len - del_count - 1; i >= act_start; i--) { + if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (i + del_count))) { + duk_put_prop_index(ctx, -4, (duk_uarridx_t) (i + item_count)); + } else { + duk_pop(ctx); + duk_del_prop_index(ctx, -3, (duk_uarridx_t) (i + item_count)); + } + } + + DUK_ASSERT_TOP(ctx, nargs + 3); + } else { + /* [ A B C D E F G H ] rel_index = 2, del_count 3, item count 3 + * -> [ A B F G H ] (conceptual intermediate step) + * -> [ A B . . . F G H ] (placeholder marked) + * [ A B C D E F G H ] (actual result at this point) + */ + } + DUK_ASSERT_TOP(ctx, nargs + 3); + + /* Step 15: insert itemCount elements into the hole made above */ + + for (i = 0; i < item_count; i++) { + duk_dup(ctx, i + 2); /* args start at index 2 */ + duk_put_prop_index(ctx, -4, (duk_uarridx_t) (act_start + i)); + } + + /* Step 16: update length; note that the final length may be above 32 bit range + * (but we checked above that this isn't the case here) + */ + + duk_push_u32(ctx, len - del_count + item_count); + duk_put_prop_stridx(ctx, -4, DUK_STRIDX_LENGTH); + + /* result array is already at the top of stack */ + DUK_ASSERT_TOP(ctx, nargs + 3); + return 1; +} + +/* + * reverse() + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_reverse(duk_context *ctx) { + duk_uint32_t len; + duk_uint32_t middle; + duk_uint32_t lower, upper; + duk_bool_t have_lower, have_upper; + + len = duk__push_this_obj_len_u32(ctx); + middle = len / 2; + + /* If len <= 1, middle will be 0 and for-loop bails out + * immediately (0 < 0 -> false). + */ + + for (lower = 0; lower < middle; lower++) { + DUK_ASSERT(len >= 2); + DUK_ASSERT_TOP(ctx, 2); + + DUK_ASSERT(len >= lower + 1); + upper = len - lower - 1; + + have_lower = duk_get_prop_index(ctx, -2, (duk_uarridx_t) lower); + have_upper = duk_get_prop_index(ctx, -3, (duk_uarridx_t) upper); + + /* [ ToObject(this) ToUint32(length) lowerValue upperValue ] */ + + if (have_upper) { + duk_put_prop_index(ctx, -4, (duk_uarridx_t) lower); + } else { + duk_del_prop_index(ctx, -4, (duk_uarridx_t) lower); + duk_pop(ctx); + } + + if (have_lower) { + duk_put_prop_index(ctx, -3, (duk_uarridx_t) upper); + } else { + duk_del_prop_index(ctx, -3, (duk_uarridx_t) upper); + duk_pop(ctx); + } + + DUK_ASSERT_TOP(ctx, 2); + } + + DUK_ASSERT_TOP(ctx, 2); + duk_pop(ctx); /* -> [ ToObject(this) ] */ + return 1; +} + +/* + * slice() + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_slice(duk_context *ctx) { + duk_uint32_t len; + duk_int_t start, end; + duk_int_t i; + duk_uarridx_t idx; + duk_uint32_t res_length = 0; + + /* XXX: len >= 0x80000000 won't work below because we need to be + * able to represent -len. + */ + len = duk__push_this_obj_len_u32_limited(ctx); + duk_push_array(ctx); + + /* stack[0] = start + * stack[1] = end + * stack[2] = ToObject(this) + * stack[3] = ToUint32(length) + * stack[4] = result array + */ + + start = duk_to_int_clamped(ctx, 0, -((duk_int_t) len), (duk_int_t) len); + if (start < 0) { + start = len + start; + } + /* XXX: could duk_is_undefined() provide defaulting undefined to 'len' + * (the upper limit)? + */ + if (duk_is_undefined(ctx, 1)) { + end = len; + } else { + end = duk_to_int_clamped(ctx, 1, -((duk_int_t) len), (duk_int_t) len); + if (end < 0) { + end = len + end; + } + } + DUK_ASSERT(start >= 0 && (duk_uint32_t) start <= len); + DUK_ASSERT(end >= 0 && (duk_uint32_t) end <= len); + + idx = 0; + for (i = start; i < end; i++) { + DUK_ASSERT_TOP(ctx, 5); + if (duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) { + duk_xdef_prop_index_wec(ctx, 4, idx); + res_length = idx + 1; + } else { + duk_pop(ctx); + } + idx++; + DUK_ASSERT_TOP(ctx, 5); + } + + duk_push_u32(ctx, res_length); + duk_xdef_prop_stridx(ctx, 4, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W); + + DUK_ASSERT_TOP(ctx, 5); + return 1; +} + +/* + * shift() + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_shift(duk_context *ctx) { + duk_uint32_t len; + duk_uint32_t i; + + len = duk__push_this_obj_len_u32(ctx); + if (len == 0) { + duk_push_int(ctx, 0); + duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH); + return 0; + } + + duk_get_prop_index(ctx, 0, 0); + + /* stack[0] = object (this) + * stack[1] = ToUint32(length) + * stack[2] = elem at index 0 (retval) + */ + + for (i = 1; i < len; i++) { + DUK_ASSERT_TOP(ctx, 3); + if (duk_get_prop_index(ctx, 0, (duk_uarridx_t) i)) { + /* fromPresent = true */ + duk_put_prop_index(ctx, 0, (duk_uarridx_t) (i - 1)); + } else { + /* fromPresent = false */ + duk_del_prop_index(ctx, 0, (duk_uarridx_t) (i - 1)); + duk_pop(ctx); + } + } + duk_del_prop_index(ctx, 0, (duk_uarridx_t) (len - 1)); + + duk_push_u32(ctx, (duk_uint32_t) (len - 1)); + duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH); + + DUK_ASSERT_TOP(ctx, 3); + return 1; +} + +/* + * unshift() + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_unshift(duk_context *ctx) { + duk_idx_t nargs; + duk_uint32_t len; + duk_uint32_t i; + + nargs = duk_get_top(ctx); + len = duk__push_this_obj_len_u32(ctx); + + /* stack[0...nargs-1] = unshift args (vararg) + * stack[nargs] = ToObject(this) + * stack[nargs+1] = ToUint32(length) + */ + + DUK_ASSERT_TOP(ctx, nargs + 2); + + /* Note: unshift() may operate on indices above unsigned 32-bit range + * and the final length may be >= 2**32. However, we restrict the + * final result to 32-bit range for practicality. + */ + + if (len + (duk_uint32_t) nargs < len) { + DUK_D(DUK_DPRINT("Array.prototype.unshift() would go beyond 32-bit length, throw")); + return DUK_RET_RANGE_ERROR; + } + + i = len; + while (i > 0) { + DUK_ASSERT_TOP(ctx, nargs + 2); + i--; + /* k+argCount-1; note that may be above 32-bit range */ + + if (duk_get_prop_index(ctx, -2, (duk_uarridx_t) i)) { + /* fromPresent = true */ + /* [ ... ToObject(this) ToUint32(length) val ] */ + duk_put_prop_index(ctx, -3, (duk_uarridx_t) (i + nargs)); /* -> [ ... ToObject(this) ToUint32(length) ] */ + } else { + /* fromPresent = false */ + /* [ ... ToObject(this) ToUint32(length) val ] */ + duk_pop(ctx); + duk_del_prop_index(ctx, -2, (duk_uarridx_t) (i + nargs)); /* -> [ ... ToObject(this) ToUint32(length) ] */ + } + DUK_ASSERT_TOP(ctx, nargs + 2); + } + + for (i = 0; i < (duk_uint32_t) nargs; i++) { + DUK_ASSERT_TOP(ctx, nargs + 2); + duk_dup(ctx, i); /* -> [ ... ToObject(this) ToUint32(length) arg[i] ] */ + duk_put_prop_index(ctx, -3, (duk_uarridx_t) i); + DUK_ASSERT_TOP(ctx, nargs + 2); + } + + DUK_ASSERT_TOP(ctx, nargs + 2); + duk_push_u32(ctx, len + nargs); + duk_dup_top(ctx); /* -> [ ... ToObject(this) ToUint32(length) final_len final_len ] */ + duk_put_prop_stridx(ctx, -4, DUK_STRIDX_LENGTH); + return 1; +} + +/* + * indexOf(), lastIndexOf() + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_indexof_shared(duk_context *ctx) { + duk_idx_t nargs; + duk_int_t i, len; + duk_int_t from_index; + duk_small_int_t idx_step = duk_get_current_magic(ctx); /* idx_step is +1 for indexOf, -1 for lastIndexOf */ + + /* lastIndexOf() needs to be a vararg function because we must distinguish + * between an undefined fromIndex and a "not given" fromIndex; indexOf() is + * made vararg for symmetry although it doesn't strictly need to be. + */ + + nargs = duk_get_top(ctx); + duk_set_top(ctx, 2); + + /* XXX: must be able to represent -len */ + len = (duk_int_t) duk__push_this_obj_len_u32_limited(ctx); + if (len == 0) { + goto not_found; + } + + /* Index clamping is a bit tricky, we must ensure that we'll only iterate + * through elements that exist and that the specific requirements from E5.1 + * Sections 15.4.4.14 and 15.4.4.15 are fulfilled; especially: + * + * - indexOf: clamp to [-len,len], negative handling -> [0,len], + * if clamped result is len, for-loop bails out immediately + * + * - lastIndexOf: clamp to [-len-1, len-1], negative handling -> [-1, len-1], + * if clamped result is -1, for-loop bails out immediately + * + * If fromIndex is not given, ToInteger(undefined) = 0, which is correct + * for indexOf() but incorrect for lastIndexOf(). Hence special handling, + * and why lastIndexOf() needs to be a vararg function. + */ + + if (nargs >= 2) { + /* indexOf: clamp fromIndex to [-len, len] + * (if fromIndex == len, for-loop terminates directly) + * + * lastIndexOf: clamp fromIndex to [-len - 1, len - 1] + * (if clamped to -len-1 -> fromIndex becomes -1, terminates for-loop directly) + */ + from_index = duk_to_int_clamped(ctx, + 1, + (idx_step > 0 ? -len : -len - 1), + (idx_step > 0 ? len : len - 1)); + if (from_index < 0) { + /* for lastIndexOf, result may be -1 (mark immediate termination) */ + from_index = len + from_index; + } + } else { + /* for indexOf, ToInteger(undefined) would be 0, i.e. correct, but + * handle both indexOf and lastIndexOf specially here. + */ + if (idx_step > 0) { + from_index = 0; + } else { + from_index = len - 1; + } + } + + /* stack[0] = searchElement + * stack[1] = fromIndex + * stack[2] = object + * stack[3] = length (not needed, but not popped above) + */ + + for (i = from_index; i >= 0 && i < len; i += idx_step) { + DUK_ASSERT_TOP(ctx, 4); + + if (duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) { + DUK_ASSERT_TOP(ctx, 5); + if (duk_strict_equals(ctx, 0, 4)) { + duk_push_int(ctx, i); + return 1; + } + } + + duk_pop(ctx); + } + + not_found: + duk_push_int(ctx, -1); + return 1; +} + +/* + * every(), some(), forEach(), map(), filter() + */ + +#define DUK__ITER_EVERY 0 +#define DUK__ITER_SOME 1 +#define DUK__ITER_FOREACH 2 +#define DUK__ITER_MAP 3 +#define DUK__ITER_FILTER 4 + +/* XXX: This helper is a bit awkward because the handling for the different iteration + * callers is quite different. This now compiles to a bit less than 500 bytes, so with + * 5 callers the net result is about 100 bytes / caller. + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_iter_shared(duk_context *ctx) { + duk_uint32_t len; + duk_uint32_t i; + duk_uarridx_t k; + duk_bool_t bval; + duk_small_int_t iter_type = duk_get_current_magic(ctx); + duk_uint32_t res_length = 0; + + /* each call this helper serves has nargs==2 */ + DUK_ASSERT_TOP(ctx, 2); + + len = duk__push_this_obj_len_u32(ctx); + if (!duk_is_callable(ctx, 0)) { + goto type_error; + } + /* if thisArg not supplied, behave as if undefined was supplied */ + + if (iter_type == DUK__ITER_MAP || iter_type == DUK__ITER_FILTER) { + duk_push_array(ctx); + } else { + duk_push_undefined(ctx); + } + + /* stack[0] = callback + * stack[1] = thisArg + * stack[2] = object + * stack[3] = ToUint32(length) (unused, but avoid unnecessary pop) + * stack[4] = result array (or undefined) + */ + + k = 0; /* result index for filter() */ + for (i = 0; i < len; i++) { + DUK_ASSERT_TOP(ctx, 5); + + if (!duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) { +#if defined(DUK_USE_NONSTD_ARRAY_MAP_TRAILER) + /* Real world behavior for map(): trailing non-existent + * elements don't invoke the user callback, but are still + * counted towards result 'length'. + */ + if (iter_type == DUK__ITER_MAP) { + res_length = i + 1; + } +#else + /* Standard behavior for map(): trailing non-existent + * elements don't invoke the user callback and are not + * counted towards result 'length'. + */ +#endif + duk_pop(ctx); + continue; + } + + /* The original value needs to be preserved for filter(), hence + * this funny order. We can't re-get the value because of side + * effects. + */ + + duk_dup(ctx, 0); + duk_dup(ctx, 1); + duk_dup(ctx, -3); + duk_push_u32(ctx, i); + duk_dup(ctx, 2); /* [ ... val callback thisArg val i obj ] */ + duk_call_method(ctx, 3); /* -> [ ... val retval ] */ + + switch (iter_type) { + case DUK__ITER_EVERY: + bval = duk_to_boolean(ctx, -1); + if (!bval) { + /* stack top contains 'false' */ + return 1; + } + break; + case DUK__ITER_SOME: + bval = duk_to_boolean(ctx, -1); + if (bval) { + /* stack top contains 'true' */ + return 1; + } + break; + case DUK__ITER_FOREACH: + /* nop */ + break; + case DUK__ITER_MAP: + duk_dup(ctx, -1); + duk_xdef_prop_index_wec(ctx, 4, (duk_uarridx_t) i); /* retval to result[i] */ + res_length = i + 1; + break; + case DUK__ITER_FILTER: + bval = duk_to_boolean(ctx, -1); + if (bval) { + duk_dup(ctx, -2); /* orig value */ + duk_xdef_prop_index_wec(ctx, 4, (duk_uarridx_t) k); + k++; + res_length = k; + } + break; + default: + DUK_UNREACHABLE(); + break; + } + duk_pop_2(ctx); + + DUK_ASSERT_TOP(ctx, 5); + } + + switch (iter_type) { + case DUK__ITER_EVERY: + duk_push_true(ctx); + break; + case DUK__ITER_SOME: + duk_push_false(ctx); + break; + case DUK__ITER_FOREACH: + duk_push_undefined(ctx); + break; + case DUK__ITER_MAP: + case DUK__ITER_FILTER: + DUK_ASSERT_TOP(ctx, 5); + DUK_ASSERT(duk_is_array(ctx, -1)); /* topmost element is the result array already */ + duk_push_u32(ctx, res_length); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W); + break; + default: + DUK_UNREACHABLE(); + break; + } + + return 1; + + type_error: + return DUK_RET_TYPE_ERROR; +} + +/* + * reduce(), reduceRight() + */ + +DUK_INTERNAL duk_ret_t duk_bi_array_prototype_reduce_shared(duk_context *ctx) { + duk_idx_t nargs; + duk_bool_t have_acc; + duk_uint32_t i, len; + duk_small_int_t idx_step = duk_get_current_magic(ctx); /* idx_step is +1 for reduce, -1 for reduceRight */ + + /* We're a varargs function because we need to detect whether + * initialValue was given or not. + */ + nargs = duk_get_top(ctx); + DUK_DDD(DUK_DDDPRINT("nargs=%ld", (long) nargs)); + + duk_set_top(ctx, 2); + len = duk__push_this_obj_len_u32(ctx); + if (!duk_is_callable(ctx, 0)) { + goto type_error; + } + + /* stack[0] = callback fn + * stack[1] = initialValue + * stack[2] = object (coerced this) + * stack[3] = length (not needed, but not popped above) + * stack[4] = accumulator + */ + + have_acc = 0; + if (nargs >= 2) { + duk_dup(ctx, 1); + have_acc = 1; + } + DUK_DDD(DUK_DDDPRINT("have_acc=%ld, acc=%!T", + (long) have_acc, (duk_tval *) duk_get_tval(ctx, 3))); + + /* For len == 0, i is initialized to len - 1 which underflows. + * The condition (i < len) will then exit the for-loop on the + * first round which is correct. Similarly, loop termination + * happens by i underflowing. + */ + + for (i = (idx_step >= 0 ? 0 : len - 1); + i < len; /* i >= 0 would always be true */ + i += idx_step) { + DUK_DDD(DUK_DDDPRINT("i=%ld, len=%ld, have_acc=%ld, top=%ld, acc=%!T", + (long) i, (long) len, (long) have_acc, + (long) duk_get_top(ctx), + (duk_tval *) duk_get_tval(ctx, 4))); + + DUK_ASSERT((have_acc && duk_get_top(ctx) == 5) || + (!have_acc && duk_get_top(ctx) == 4)); + + if (!duk_has_prop_index(ctx, 2, (duk_uarridx_t) i)) { + continue; + } + + if (!have_acc) { + DUK_ASSERT_TOP(ctx, 4); + duk_get_prop_index(ctx, 2, (duk_uarridx_t) i); + have_acc = 1; + DUK_ASSERT_TOP(ctx, 5); + } else { + DUK_ASSERT_TOP(ctx, 5); + duk_dup(ctx, 0); + duk_dup(ctx, 4); + duk_get_prop_index(ctx, 2, (duk_uarridx_t) i); + duk_push_u32(ctx, i); + duk_dup(ctx, 2); + DUK_DDD(DUK_DDDPRINT("calling reduce function: func=%!T, prev=%!T, curr=%!T, idx=%!T, obj=%!T", + (duk_tval *) duk_get_tval(ctx, -5), (duk_tval *) duk_get_tval(ctx, -4), + (duk_tval *) duk_get_tval(ctx, -3), (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + duk_call(ctx, 4); + DUK_DDD(DUK_DDDPRINT("-> result: %!T", (duk_tval *) duk_get_tval(ctx, -1))); + duk_replace(ctx, 4); + DUK_ASSERT_TOP(ctx, 5); + } + } + + if (!have_acc) { + goto type_error; + } + + DUK_ASSERT_TOP(ctx, 5); + return 1; + + type_error: + return DUK_RET_TYPE_ERROR; +} + +#undef DUK__ARRAY_MID_JOIN_LIMIT + +#undef DUK__ITER_EVERY +#undef DUK__ITER_SOME +#undef DUK__ITER_FOREACH +#undef DUK__ITER_MAP +#undef DUK__ITER_FILTER +#line 1 "duk_bi_boolean.c" +/* + * Boolean built-ins + */ + +/* include removed: duk_internal.h */ + +/* Shared helper to provide toString() and valueOf(). Checks 'this', gets + * the primitive value to stack top, and optionally coerces with ToString(). + */ +DUK_INTERNAL duk_ret_t duk_bi_boolean_prototype_tostring_shared(duk_context *ctx) { + duk_tval *tv; + duk_hobject *h; + duk_small_int_t coerce_tostring = duk_get_current_magic(ctx); + + /* XXX: there is room to use a shared helper here, many built-ins + * check the 'this' type, and if it's an object, check its class, + * then get its internal value, etc. + */ + + duk_push_this(ctx); + tv = duk_get_tval(ctx, -1); + DUK_ASSERT(tv != NULL); + + if (DUK_TVAL_IS_BOOLEAN(tv)) { + goto type_ok; + } else if (DUK_TVAL_IS_OBJECT(tv)) { + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + + if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_BOOLEAN) { + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE); + DUK_ASSERT(duk_is_boolean(ctx, -1)); + goto type_ok; + } + } + + return DUK_RET_TYPE_ERROR; + + type_ok: + if (coerce_tostring) { + duk_to_string(ctx, -1); + } + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_boolean_constructor(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h_this; + + DUK_UNREF(thr); + + duk_to_boolean(ctx, 0); + + if (duk_is_constructor_call(ctx)) { + /* XXX: helper; rely on Boolean.prototype as being non-writable, non-configurable */ + duk_push_this(ctx); + h_this = duk_get_hobject(ctx, -1); + DUK_ASSERT(h_this != NULL); + DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_this) == thr->builtins[DUK_BIDX_BOOLEAN_PROTOTYPE]); + + DUK_HOBJECT_SET_CLASS_NUMBER(h_this, DUK_HOBJECT_CLASS_BOOLEAN); + + duk_dup(ctx, 0); /* -> [ val obj val ] */ + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE); /* XXX: proper flags? */ + } /* unbalanced stack */ + + return 1; +} +#line 1 "duk_bi_buffer.c" +/* + * Duktape.Buffer, Node.js Buffer, and Khronos/ES6 TypedArray built-ins + */ + +/* include removed: duk_internal.h */ + +/* + * Misc helpers + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Map DUK_HBUFFEROBJECT_ELEM_xxx to duk_hobject class number. + * Sync with duk_hbufferobject.h and duk_hobject.h. + */ +static const duk_uint8_t duk__buffer_class_from_elemtype[9] = { + DUK_HOBJECT_CLASS_UINT8ARRAY, + DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY, + DUK_HOBJECT_CLASS_INT8ARRAY, + DUK_HOBJECT_CLASS_UINT16ARRAY, + DUK_HOBJECT_CLASS_INT16ARRAY, + DUK_HOBJECT_CLASS_UINT32ARRAY, + DUK_HOBJECT_CLASS_INT32ARRAY, + DUK_HOBJECT_CLASS_FLOAT32ARRAY, + DUK_HOBJECT_CLASS_FLOAT64ARRAY +}; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Map DUK_HBUFFEROBJECT_ELEM_xxx to prototype object built-in index. + * Sync with duk_hbufferobject.h. + */ +static const duk_uint8_t duk__buffer_proto_from_elemtype[9] = { + DUK_BIDX_UINT8ARRAY_PROTOTYPE, + DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE, + DUK_BIDX_INT8ARRAY_PROTOTYPE, + DUK_BIDX_UINT16ARRAY_PROTOTYPE, + DUK_BIDX_INT16ARRAY_PROTOTYPE, + DUK_BIDX_UINT32ARRAY_PROTOTYPE, + DUK_BIDX_INT32ARRAY_PROTOTYPE, + DUK_BIDX_FLOAT32ARRAY_PROTOTYPE, + DUK_BIDX_FLOAT64ARRAY_PROTOTYPE +}; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Map DUK__FLX_xxx to byte size. + */ +static const duk_uint8_t duk__buffer_nbytes_from_fldtype[6] = { + 1, /* DUK__FLD_8BIT */ + 2, /* DUK__FLD_16BIT */ + 4, /* DUK__FLD_32BIT */ + 4, /* DUK__FLD_FLOAT */ + 8, /* DUK__FLD_DOUBLE */ + 0 /* DUK__FLD_VARINT; not relevant here */ +}; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Bitfield for each DUK_HBUFFEROBJECT_ELEM_xxx indicating which element types + * are compatible with a blind byte copy for the TypedArray set() method (also + * used for TypedArray constructor). Array index is target buffer elem type, + * bitfield indicates compatible source types. The types must have same byte + * size and they must be coercion compatible. + */ +static duk_uint16_t duk__buffer_elemtype_copy_compatible[9] = { + /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT8 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8) | + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT8), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED + * Note: INT8 is -not- copy compatible, e.g. -1 would coerce to 0x00. + */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8) | + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_INT8 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8) | + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT8), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT16 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT16) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT16), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_INT16 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT16) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT16), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT32 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT32) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT32), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_INT32 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT32) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT32), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_FLOAT32 */ + (1U << DUK_HBUFFEROBJECT_ELEM_FLOAT32), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_FLOAT64 */ + (1U << DUK_HBUFFEROBJECT_ELEM_FLOAT64) +}; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Shared helper. */ +DUK_LOCAL duk_hbufferobject *duk__getrequire_bufobj_this(duk_context *ctx, duk_bool_t throw_flag) { + duk_hthread *thr; + duk_tval *tv; + duk_hbufferobject *h_this; + + DUK_ASSERT(ctx != NULL); + thr = (duk_hthread *) ctx; + + tv = duk_get_borrowed_this_tval(ctx); + DUK_ASSERT(tv != NULL); + if (DUK_TVAL_IS_OBJECT(tv)) { + h_this = (duk_hbufferobject *) DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h_this != NULL); + if (DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_this)) { + DUK_ASSERT_HBUFFEROBJECT_VALID(h_this); + return h_this; + } + } + + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_BUFFER); + } + return NULL; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Check that 'this' is a duk_hbufferobject and return a pointer to it. */ +DUK_LOCAL duk_hbufferobject *duk__get_bufobj_this(duk_context *ctx) { + return duk__getrequire_bufobj_this(ctx, 0); +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Check that 'this' is a duk_hbufferobject and return a pointer to it + * (NULL if not). + */ +DUK_LOCAL duk_hbufferobject *duk__require_bufobj_this(duk_context *ctx) { + return duk__getrequire_bufobj_this(ctx, 1); +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Check that value is a duk_hbufferobject and return a pointer to it. */ +DUK_LOCAL duk_hbufferobject *duk__require_bufobj_value(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr; + duk_tval *tv; + duk_hbufferobject *h_obj; + + thr = (duk_hthread *) ctx; + + /* Don't accept relative indices now. */ + DUK_ASSERT(index >= 0); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + if (DUK_TVAL_IS_OBJECT(tv)) { + h_obj = (duk_hbufferobject *) DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h_obj != NULL); + if (DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_obj)) { + DUK_ASSERT_HBUFFEROBJECT_VALID(h_obj); + return h_obj; + } + } + + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_BUFFER); + return NULL; /* not reachable */ +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +DUK_LOCAL void duk__set_bufobj_buffer(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_hbuffer *h_val) { + duk_hthread *thr; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(h_bufobj != NULL); + DUK_ASSERT(h_bufobj->buf == NULL); /* no need to decref */ + DUK_ASSERT(h_val != NULL); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->length = (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_val); + DUK_ASSERT(h_bufobj->shift == 0); + DUK_ASSERT(h_bufobj->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8); + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); +} + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_LOCAL duk_hbufferobject *duk__push_arraybuffer_with_length(duk_context *ctx, duk_uint_t len) { + duk_hbuffer *h_val; + duk_hbufferobject *h_bufobj; + + (void) duk_push_fixed_buffer(ctx, (duk_size_t) len); + h_val = (duk_hbuffer *) duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_val != NULL); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAYBUFFER), + DUK_BIDX_ARRAYBUFFER_PROTOTYPE); + DUK_ASSERT(h_bufobj != NULL); + + duk__set_bufobj_buffer(ctx, h_bufobj, h_val); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + return h_bufobj; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Shared offset/length coercion helper. */ +DUK_LOCAL void duk__resolve_offset_opt_length(duk_context *ctx, + duk_hbufferobject *h_bufarg, + duk_idx_t idx_offset, + duk_idx_t idx_length, + duk_uint_t *out_offset, + duk_uint_t *out_length, + duk_bool_t throw_flag) { + duk_hthread *thr; + duk_int_t offset_signed; + duk_int_t length_signed; + duk_uint_t offset; + duk_uint_t length; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + offset_signed = duk_to_int(ctx, idx_offset); + if (offset_signed < 0) { + goto fail_range; + } + offset = (duk_uint_t) offset_signed; + if (offset > h_bufarg->length) { + goto fail_range; + } + DUK_ASSERT_DISABLE(offset >= 0); /* unsigned */ + DUK_ASSERT(offset <= h_bufarg->length); + + if (duk_is_undefined(ctx, idx_length)) { + DUK_ASSERT(h_bufarg->length >= offset); + length = h_bufarg->length - offset; /* >= 0 */ + } else { + length_signed = duk_to_int(ctx, idx_length); + if (length_signed < 0) { + goto fail_range; + } + length = (duk_uint_t) length_signed; + DUK_ASSERT(h_bufarg->length >= offset); + if (length > h_bufarg->length - offset) { + /* Unlike for negative arguments, some call sites + * want length to be clamped if it's positive. + */ + if (throw_flag) { + goto fail_range; + } else { + length = h_bufarg->length - offset; + } + } + } + DUK_ASSERT_DISABLE(length >= 0); /* unsigned */ + DUK_ASSERT(offset + length <= h_bufarg->length); + + *out_offset = offset; + *out_length = length; + return; + + fail_range: + duk_error(thr, DUK_ERR_RANGE_ERROR, DUK_STR_INVALID_CALL_ARGS); +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Shared lenient buffer length clamping helper. No negative indices, no + * element/byte shifting. + */ +DUK_LOCAL void duk__clamp_startend_nonegidx_noshift(duk_context *ctx, + duk_hbufferobject *h_bufobj, + duk_idx_t idx_start, + duk_idx_t idx_end, + duk_int_t *out_start_offset, + duk_int_t *out_end_offset) { + duk_int_t buffer_length; + duk_int_t start_offset; + duk_int_t end_offset; + + DUK_ASSERT(out_start_offset != NULL); + DUK_ASSERT(out_end_offset != NULL); + + buffer_length = (duk_int_t) h_bufobj->length; + + /* undefined coerces to zero which is correct */ + start_offset = duk_to_int_clamped(ctx, idx_start, 0, buffer_length); + if (duk_is_undefined(ctx, idx_end)) { + end_offset = buffer_length; + } else { + end_offset = duk_to_int_clamped(ctx, idx_end, start_offset, buffer_length); + } + + DUK_ASSERT(start_offset >= 0); + DUK_ASSERT(start_offset <= buffer_length); + DUK_ASSERT(end_offset >= 0); + DUK_ASSERT(end_offset <= buffer_length); + DUK_ASSERT(start_offset <= end_offset); + + *out_start_offset = start_offset; + *out_end_offset = end_offset; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Shared lenient buffer length clamping helper. Indices are treated as + * element indices (though output values are byte offsets) which only + * really matters for TypedArray views as other buffer object have a zero + * shift. Negative indices are counted from end of input slice; crossed + * indices are clamped to zero length; and final indices are clamped + * against input slice. Used for e.g. ArrayBuffer slice(). + */ +DUK_LOCAL void duk__clamp_startend_negidx_shifted(duk_context *ctx, + duk_hbufferobject *h_bufobj, + duk_idx_t idx_start, + duk_idx_t idx_end, + duk_int_t *out_start_offset, + duk_int_t *out_end_offset) { + duk_int_t buffer_length; + duk_int_t start_offset; + duk_int_t end_offset; + + DUK_ASSERT(out_start_offset != NULL); + DUK_ASSERT(out_end_offset != NULL); + + buffer_length = (duk_int_t) h_bufobj->length; + buffer_length >>= h_bufobj->shift; /* as elements */ + + /* Resolve start/end offset as element indices first; arguments + * at idx_start/idx_end are element offsets. Working with element + * indices first also avoids potential for wrapping. + */ + + start_offset = duk_to_int(ctx, idx_start); + if (start_offset < 0) { + start_offset = buffer_length + start_offset; + } + if (duk_is_undefined(ctx, idx_end)) { + end_offset = buffer_length; + } else { + end_offset = duk_to_int(ctx, idx_end); + if (end_offset < 0) { + end_offset = buffer_length + end_offset; + } + } + /* Note: start_offset/end_offset can still be < 0 here. */ + + if (start_offset < 0) { + start_offset = 0; + } else if (start_offset > buffer_length) { + start_offset = buffer_length; + } + if (end_offset < start_offset) { + end_offset = start_offset; + } else if (end_offset > buffer_length) { + end_offset = buffer_length; + } + DUK_ASSERT(start_offset >= 0); + DUK_ASSERT(start_offset <= buffer_length); + DUK_ASSERT(end_offset >= 0); + DUK_ASSERT(end_offset <= buffer_length); + DUK_ASSERT(start_offset <= end_offset); + + /* Convert indices to byte offsets. */ + start_offset <<= h_bufobj->shift; + end_offset <<= h_bufobj->shift; + + *out_start_offset = start_offset; + *out_end_offset = end_offset; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Indexed read/write helpers (also used from outside this file) + */ + +DUK_INTERNAL void duk_hbufferobject_push_validated_read(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size) { + duk_double_union du; + + DUK_MEMCPY((void *) du.uc, (const void *) p, elem_size); + + switch (h_bufobj->elem_type) { + case DUK_HBUFFEROBJECT_ELEM_UINT8: +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) + case DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED: +#endif + duk_push_uint(ctx, (duk_uint_t) du.uc[0]); + break; +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) + /* These are not needed when only Duktape.Buffer is supported. */ + case DUK_HBUFFEROBJECT_ELEM_INT8: + duk_push_int(ctx, (duk_int_t) (duk_int8_t) du.uc[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_UINT16: + duk_push_uint(ctx, (duk_uint_t) du.us[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_INT16: + duk_push_int(ctx, (duk_int_t) (duk_int16_t) du.us[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_UINT32: + duk_push_uint(ctx, (duk_uint_t) du.ui[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_INT32: + duk_push_int(ctx, (duk_int_t) (duk_int32_t) du.ui[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_FLOAT32: + duk_push_number(ctx, (duk_double_t) du.f[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_FLOAT64: + duk_push_number(ctx, (duk_double_t) du.d); + break; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + default: + DUK_UNREACHABLE(); + } +} + +DUK_INTERNAL void duk_hbufferobject_validated_write(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size) { + duk_double_union du; + + /* NOTE! Caller must ensure that any side effects from the + * coercions below are safe. If that cannot be guaranteed + * (which is normally the case), caller must coerce the + * argument using duk_to_number() before any pointer + * validations; the result of duk_to_number() always coerces + * without side effects here. + */ + + switch (h_bufobj->elem_type) { + case DUK_HBUFFEROBJECT_ELEM_UINT8: + du.uc[0] = (duk_uint8_t) duk_to_uint32(ctx, -1); + break; +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) + /* These are not needed when only Duktape.Buffer is supported. */ + case DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED: + du.uc[0] = (duk_uint8_t) duk_to_uint8clamped(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_INT8: + du.uc[0] = (duk_uint8_t) duk_to_int32(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_UINT16: + du.us[0] = (duk_uint16_t) duk_to_uint32(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_INT16: + du.us[0] = (duk_uint16_t) duk_to_int32(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_UINT32: + du.ui[0] = (duk_uint32_t) duk_to_uint32(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_INT32: + du.ui[0] = (duk_uint32_t) duk_to_int32(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_FLOAT32: + du.f[0] = (duk_float_t) duk_to_number(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_FLOAT64: + du.d = (duk_double_t) duk_to_number(ctx, -1); + break; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + default: + DUK_UNREACHABLE(); + } + + DUK_MEMCPY((void *) p, (const void *) du.uc, elem_size); +} + +/* + * Duktape.Buffer: constructor + */ + +DUK_INTERNAL duk_ret_t duk_bi_buffer_constructor(duk_context *ctx) { + duk_hthread *thr; + duk_size_t buf_size; + duk_small_int_t buf_dynamic; + duk_uint8_t *buf_data; + const duk_uint8_t *src_data; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + /* + * Constructor arguments are currently somewhat compatible with + * (keep it that way if possible): + * + * http://nodejs.org/api/buffer.html + * + * Note that the ToBuffer() coercion (duk_to_buffer()) does NOT match + * the constructor behavior. + */ + + buf_dynamic = duk_get_boolean(ctx, 1); /* default to false */ + + switch (duk_get_type(ctx, 0)) { + case DUK_TYPE_NUMBER: { + /* new buffer of specified size */ + buf_size = (duk_size_t) duk_to_int(ctx, 0); + (void) duk_push_buffer(ctx, buf_size, buf_dynamic); + break; + } + case DUK_TYPE_BUFFER: { + /* return input buffer, converted to a Duktape.Buffer object + * if called as a constructor (no change if called as a + * function). + */ + duk_set_top(ctx, 1); + break; + } + case DUK_TYPE_STRING: { + /* new buffer with string contents */ + src_data = (const duk_uint8_t *) duk_get_lstring(ctx, 0, &buf_size); + DUK_ASSERT(src_data != NULL); /* even for zero-length string */ + buf_data = (duk_uint8_t *) duk_push_buffer(ctx, buf_size, buf_dynamic); + DUK_MEMCPY((void *) buf_data, (const void *) src_data, (size_t) buf_size); + break; + } + case DUK_TYPE_OBJECT: { + /* For all duk_hbufferobjects, get the plain buffer inside + * without making a copy. This is compatible with Duktape 1.2 + * but means that a slice/view information is ignored and the + * full underlying buffer is returned. + * + * If called as a constructor, a new Duktape.Buffer object + * pointing to the same plain buffer is created below. + */ + duk_hbufferobject *h_bufobj; + h_bufobj = (duk_hbufferobject *) duk_get_hobject(ctx, 0); + DUK_ASSERT(h_bufobj != NULL); + if (!DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_bufobj)) { + return DUK_RET_TYPE_ERROR; + } + if (h_bufobj->buf == NULL) { + return DUK_RET_TYPE_ERROR; + } + duk_push_hbuffer(ctx, h_bufobj->buf); + break; + } + case DUK_TYPE_NONE: + default: { + return DUK_RET_TYPE_ERROR; + } + } + DUK_ASSERT(duk_is_buffer(ctx, -1)); + + /* stack is unbalanced, but: [ <something> buf ] */ + + if (duk_is_constructor_call(ctx)) { + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; + + h_val = duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_val != NULL); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER), + DUK_BIDX_BUFFER_PROTOTYPE); + DUK_ASSERT(h_bufobj != NULL); + + duk__set_bufobj_buffer(ctx, h_bufobj, h_val); + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + } + /* Note: unbalanced stack on purpose */ + + return 1; +} + +/* + * Node.js Buffer: constructor + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_constructor(duk_context *ctx) { + /* Internal class is Object: Object.prototype.toString.call(new Buffer(0)) + * prints "[object Object]". + */ + duk_int_t len; + duk_int_t i; + duk_uint8_t *buf; + duk_hbuffer *h_buf; + duk_hbufferobject *h_bufobj; + duk_size_t buf_size; + + switch (duk_get_type(ctx, 0)) { + case DUK_TYPE_BUFFER: { + /* Custom behavior: plain buffer is used as internal buffer + * without making a copy (matches Duktape.Buffer). + */ + duk_set_top(ctx, 1); /* -> [ buffer ] */ + break; + } + case DUK_TYPE_NUMBER: { + len = duk_to_int_clamped(ctx, 0, 0, DUK_INT_MAX); + buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len); + break; + } + case DUK_TYPE_OBJECT: { + (void) duk_get_prop_string(ctx, 0, "length"); + len = duk_to_int_clamped(ctx, -1, 0, DUK_INT_MAX); + duk_pop(ctx); + buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len); + for (i = 0; i < len; i++) { + /* XXX: fast path for array arguments? */ + duk_get_prop_index(ctx, 0, (duk_uarridx_t) i); + buf[i] = (duk_uint8_t) (duk_to_uint32(ctx, -1) & 0xffU); + duk_pop(ctx); + } + break; + } + case DUK_TYPE_STRING: { + /* ignore encoding for now */ + duk_dup(ctx, 0); + buf = (duk_uint8_t *) duk_to_buffer(ctx, -1, &buf_size); + break; + } + default: + return DUK_RET_TYPE_ERROR; + } + + DUK_ASSERT(duk_is_buffer(ctx, -1)); + h_buf = duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_buf != NULL); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER), + DUK_BIDX_NODEJS_BUFFER_PROTOTYPE); + DUK_ASSERT(h_bufobj != NULL); + + h_bufobj->buf = h_buf; + DUK_HBUFFER_INCREF(thr, h_buf); + DUK_ASSERT(h_bufobj->offset == 0); + h_bufobj->length = (duk_int_t) DUK_HBUFFER_GET_SIZE(h_buf); + DUK_ASSERT(h_bufobj->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8); + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_constructor(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * ArrayBuffer, DataView, and TypedArray constructors + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_constructor(duk_context *ctx) { + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; + + /* XXX: function flag to make this automatic? */ + if (!duk_is_constructor_call(ctx)) { + return DUK_RET_TYPE_ERROR; + } + + if (duk_is_buffer(ctx, 0)) { + /* Custom behavior: plain buffer is used as internal buffer + * without making a copy (matches Duktape.Buffer). + */ + + h_val = duk_get_hbuffer(ctx, 0); + DUK_ASSERT(h_val != NULL); + + /* XXX: accept any duk_hbufferobject type as an input also? */ + } else { + duk_int_t len; + len = duk_to_int(ctx, 0); + if (len < 0) { + goto fail_length; + } + (void) duk_push_fixed_buffer(ctx, (duk_size_t) len); + h_val = (duk_hbuffer *) duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_val != NULL); + } + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAYBUFFER), + DUK_BIDX_ARRAYBUFFER_PROTOTYPE); + DUK_ASSERT(h_bufobj != NULL); + + duk__set_bufobj_buffer(ctx, h_bufobj, h_val); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + return 1; + + fail_length: + return DUK_RET_RANGE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_constructor(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + + +/* Format of magic, bits: + * 0...1: elem size shift (0-3) + * 2...5: elem type (DUK_HBUFFEROBJECT_ELEM_xxx) + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_typedarray_constructor(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv; + duk_hobject *h_obj; + duk_hbufferobject *h_bufobj = NULL; + duk_hbufferobject *h_bufarr = NULL; + duk_hbufferobject *h_bufarg = NULL; + duk_hbuffer *h_val; + duk_small_uint_t magic; + duk_small_uint_t shift; + duk_small_uint_t elem_type; + duk_small_uint_t elem_size; + duk_small_uint_t class_num; + duk_small_uint_t proto_bidx; + duk_uint_t align_mask; + duk_uint_t elem_length; + duk_int_t elem_length_signed; + duk_uint_t byte_length; + duk_small_uint_t copy_mode; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + /* XXX: function flag to make this automatic? */ + if (!duk_is_constructor_call(ctx)) { + return DUK_RET_TYPE_ERROR; + } + + /* We could fit built-in index into magic but that'd make the magic + * number dependent on built-in numbering (genbuiltins.py doesn't + * handle that yet). So map both class and prototype from the + * element type. + */ + magic = duk_get_current_magic(ctx); + shift = magic & 0x03; /* bits 0...1: shift */ + elem_type = (magic >> 2) & 0x0f; /* bits 2...5: type */ + elem_size = 1 << shift; + align_mask = elem_size - 1; + DUK_ASSERT(elem_type < sizeof(duk__buffer_proto_from_elemtype) / sizeof(duk_uint8_t)); + proto_bidx = duk__buffer_proto_from_elemtype[elem_type]; + DUK_ASSERT(proto_bidx < DUK_NUM_BUILTINS); + DUK_ASSERT(elem_type < sizeof(duk__buffer_class_from_elemtype) / sizeof(duk_uint8_t)); + class_num = duk__buffer_class_from_elemtype[elem_type]; + + DUK_DD(DUK_DDPRINT("typedarray constructor, magic=%d, shift=%d, elem_type=%d, " + "elem_size=%d, proto_bidx=%d, class_num=%d", + (int) magic, (int) shift, (int) elem_type, (int) elem_size, + (int) proto_bidx, (int) class_num)); + + /* Argument variants. When the argument is an ArrayBuffer a view to + * the same buffer is created; otherwise a new ArrayBuffer is always + * created. + */ + + tv = duk_get_tval(ctx, 0); + DUK_ASSERT(tv != NULL); /* arg count */ + if (DUK_TVAL_IS_OBJECT(tv)) { + h_obj = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h_obj != NULL); + + if (DUK_HOBJECT_GET_CLASS_NUMBER(h_obj) == DUK_HOBJECT_CLASS_ARRAYBUFFER) { + /* ArrayBuffer: unlike any other argument variant, create + * a view into the existing buffer. + */ + + duk_int_t byte_offset_signed; + duk_uint_t byte_offset; + + h_bufarg = (duk_hbufferobject *) h_obj; + + byte_offset_signed = duk_to_int(ctx, 1); + if (byte_offset_signed < 0) { + goto fail_arguments; + } + byte_offset = (duk_uint_t) byte_offset_signed; + if (byte_offset > h_bufarg->length || + (byte_offset & align_mask) != 0) { + /* Must be >= 0 and multiple of element size. */ + goto fail_arguments; + } + if (duk_is_undefined(ctx, 2)) { + DUK_ASSERT(h_bufarg->length >= byte_offset); + byte_length = h_bufarg->length - byte_offset; + if ((byte_length & align_mask) != 0) { + /* Must be element size multiple from + * start offset to end of buffer. + */ + goto fail_arguments; + } + elem_length = (byte_length >> shift); + } else { + elem_length_signed = duk_to_int(ctx, 2); + if (elem_length_signed < 0) { + goto fail_arguments; + } + elem_length = (duk_uint_t) elem_length_signed; + byte_length = elem_length << shift; + if ((byte_length >> shift) != elem_length) { + /* Byte length would overflow. */ + /* XXX: easier check with less code? */ + goto fail_arguments; + } + DUK_ASSERT(h_bufarg->length >= byte_offset); + if (byte_length > h_bufarg->length - byte_offset) { + /* Not enough data. */ + goto fail_arguments; + } + } + DUK_ASSERT_DISABLE(byte_offset >= 0); + DUK_ASSERT(byte_offset <= h_bufarg->length); + DUK_ASSERT_DISABLE(byte_length >= 0); + DUK_ASSERT(byte_offset + byte_length <= h_bufarg->length); + DUK_ASSERT((elem_length << shift) == byte_length); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(class_num), + proto_bidx); + h_val = h_bufarg->buf; + if (h_val == NULL) { + return DUK_RET_TYPE_ERROR; + } + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->offset = h_bufarg->offset + byte_offset; + h_bufobj->length = byte_length; + h_bufobj->shift = shift; + h_bufobj->elem_type = elem_type; + h_bufobj->is_view = 1; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + /* Set .buffer to the argument ArrayBuffer. */ + duk_dup(ctx, 0); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE); + duk_compact(ctx, -1); + return 1; + } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) { + /* TypedArray (or other non-ArrayBuffer duk_hbufferobject). + * Conceptually same behavior as for an Array-like argument, + * with a few fast paths. + */ + + h_bufarg = (duk_hbufferobject *) h_obj; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufarg); + elem_length_signed = (duk_int_t) (h_bufarg->length >> h_bufarg->shift); + if (h_bufarg->buf == NULL) { + return DUK_RET_TYPE_ERROR; + } + + /* Select copy mode. Must take into account element + * compatibility and validity of the underlying source + * buffer. + */ + + DUK_DDD(DUK_DDDPRINT("selecting copy mode for bufobj arg, " + "src byte_length=%ld, src shift=%d, " + "src/dst elem_length=%ld; " + "dst shift=%d -> dst byte_length=%ld", + (long) h_bufarg->length, (int) h_bufarg->shift, + (long) elem_length_signed, (int) shift, + (long) (elem_length_signed << shift))); + + copy_mode = 2; /* default is explicit index read/write copy */ + DUK_ASSERT(elem_type < sizeof(duk__buffer_elemtype_copy_compatible) / sizeof(duk_uint16_t)); + if (DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)) { + if ((duk__buffer_elemtype_copy_compatible[elem_type] & (1 << h_bufarg->elem_type)) != 0) { + DUK_DDD(DUK_DDDPRINT("source/target are copy compatible, memcpy")); + DUK_ASSERT(shift == h_bufarg->shift); /* byte sizes will match */ + copy_mode = 0; + } else { + DUK_DDD(DUK_DDDPRINT("source/target not copy compatible but valid, fast copy")); + copy_mode = 1; + } + } + } else { + /* Array or Array-like */ + elem_length_signed = (duk_int_t) duk_get_length(ctx, 0); + copy_mode = 2; + } + } else { + /* Non-object argument is simply int coerced, matches + * V8 behavior (except for "null", which we coerce to + * 0 but V8 TypeErrors). + */ + elem_length_signed = duk_to_int(ctx, 0); + copy_mode = 3; + } + if (elem_length_signed < 0) { + goto fail_arguments; + } + elem_length = (duk_uint_t) elem_length_signed; + byte_length = (duk_uint_t) (elem_length << shift); + if ((byte_length >> shift) != elem_length) { + /* Byte length would overflow. */ + /* XXX: easier check with less code? */ + goto fail_arguments; + } + + DUK_DDD(DUK_DDDPRINT("elem_length=%ld, byte_length=%ld", + (long) elem_length, (long) byte_length)); + + /* ArrayBuffer argument is handled specially above; the rest of the + * argument variants are handled by shared code below. + */ + + /* Push a new ArrayBuffer (becomes view .buffer) */ + h_bufarr = duk__push_arraybuffer_with_length(ctx, byte_length); + DUK_ASSERT(h_bufarr != NULL); + h_val = h_bufarr->buf; + DUK_ASSERT(h_val != NULL); + + /* Push the resulting view object and attach the ArrayBuffer. */ + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(class_num), + proto_bidx); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + DUK_ASSERT(h_bufobj->offset == 0); + h_bufobj->length = byte_length; + h_bufobj->shift = shift; + h_bufobj->elem_type = elem_type; + h_bufobj->is_view = 1; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + /* Set .buffer */ + duk_dup(ctx, -2); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE); + duk_compact(ctx, -1); + + /* Copy values, the copy method depends on the arguments. + * + * Copy mode decision may depend on the validity of the underlying + * buffer of the source argument; there must be no harmful side effects + * from there to here for copy_mode to still be valid. + */ + DUK_DDD(DUK_DDDPRINT("copy mode: %d", (int) copy_mode)); + switch (copy_mode) { + case 0: { + /* Use byte copy. */ + + duk_uint8_t *p_src; + duk_uint8_t *p_dst; + + DUK_ASSERT(h_bufobj != NULL); + DUK_ASSERT(h_bufobj->buf != NULL); + DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)); + DUK_ASSERT(h_bufarg != NULL); + DUK_ASSERT(h_bufarg->buf != NULL); + DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)); + + p_dst = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj); + p_src = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg); + + DUK_DDD(DUK_DDDPRINT("using memcpy: p_src=%p, p_dst=%p, byte_length=%ld", + (void *) p_src, (void *) p_dst, (long) byte_length)); + + DUK_MEMCPY((void *) p_dst, (const void *) p_src, (size_t) byte_length); + break; + } + case 1: { + /* Copy values through direct validated reads and writes. */ + + duk_small_uint_t src_elem_size; + duk_small_uint_t dst_elem_size; + duk_uint8_t *p_src; + duk_uint8_t *p_src_end; + duk_uint8_t *p_dst; + + DUK_ASSERT(h_bufobj != NULL); + DUK_ASSERT(h_bufobj->buf != NULL); + DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)); + DUK_ASSERT(h_bufarg != NULL); + DUK_ASSERT(h_bufarg->buf != NULL); + DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)); + + src_elem_size = 1 << h_bufarg->shift; + dst_elem_size = elem_size; + + p_src = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg); + p_dst = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj); + p_src_end = p_src + h_bufarg->length; + + DUK_DDD(DUK_DDDPRINT("using fast copy: p_src=%p, p_src_end=%p, p_dst=%p, " + "src_elem_size=%d, dst_elem_size=%d", + (void *) p_src, (void *) p_src_end, (void *) p_dst, + (int) src_elem_size, (int) dst_elem_size)); + + while (p_src != p_src_end) { + DUK_DDD(DUK_DDDPRINT("fast path per element copy loop: " + "p_src=%p, p_src_end=%p, p_dst=%p", + (void *) p_src, (void *) p_src_end, (void *) p_dst)); + /* A validated read() is always a number, so it's write coercion + * is always side effect free an won't invalidate pointers etc. + */ + duk_hbufferobject_push_validated_read(ctx, h_bufarg, p_src, src_elem_size); + duk_hbufferobject_validated_write(ctx, h_bufobj, p_dst, dst_elem_size); + duk_pop(ctx); + p_src += src_elem_size; + p_dst += dst_elem_size; + } + break; + } + case 2: { + /* Copy values by index reads and writes. Let virtual + * property handling take care of coercion. + */ + duk_uint_t i; + + DUK_DDD(DUK_DDDPRINT("using slow copy")); + + for (i = 0; i < elem_length; i++) { + duk_get_prop_index(ctx, 0, (duk_uarridx_t) i); + duk_put_prop_index(ctx, -2, (duk_uarridx_t) i); + } + break; + } + default: + case 3: { + /* No copy, leave zero bytes in the buffer. There's no + * ambiguity with Float32/Float64 because zero bytes also + * represent 0.0. + */ + + DUK_DDD(DUK_DDDPRINT("using no copy")); + break; + } + } + + return 1; + + fail_arguments: + return DUK_RET_RANGE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_typedarray_constructor(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_dataview_constructor(duk_context *ctx) { + duk_hbufferobject *h_bufarg; + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; + duk_uint_t offset; + duk_uint_t length; + + /* XXX: function flag to make this automatic? */ + if (!duk_is_constructor_call(ctx)) { + return DUK_RET_TYPE_ERROR; + } + + h_bufarg = duk__require_bufobj_value(ctx, 0); + DUK_ASSERT(h_bufarg != NULL); + + duk__resolve_offset_opt_length(ctx, h_bufarg, 1, 2, &offset, &length, 1 /*throw_flag*/); + DUK_ASSERT(offset <= h_bufarg->length); + DUK_ASSERT(offset + length <= h_bufarg->length); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DATAVIEW), + DUK_BIDX_DATAVIEW_PROTOTYPE); + + h_val = h_bufarg->buf; + if (h_val == NULL) { + return DUK_RET_TYPE_ERROR; + } + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->offset = h_bufarg->offset + offset; + h_bufobj->length = length; + DUK_ASSERT(h_bufobj->shift == 0); + DUK_ASSERT(h_bufobj->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8); + h_bufobj->is_view = 1; + + /* The DataView .buffer property is ordinarily set to the argument + * which is an ArrayBuffer. We accept any duk_hbufferobject as + * an argument and .buffer will be set to the argument regardless + * of what it is. This may be a bit confusing if the argument + * is e.g. a DataView or another TypedArray view. + * + * XXX: Copy .buffer property from a DataView/TypedArray argument? + * Create a fresh ArrayBuffer for Duktape.Buffer and Node.js Buffer + * arguments? See: test-bug-dataview-buffer-prop.js. + */ + + duk_dup(ctx, 0); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE); + duk_compact(ctx, -1); + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_dataview_constructor(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * ArrayBuffer.isView() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_isview(duk_context *ctx) { + duk_hobject *h_obj; + duk_bool_t ret = 0; + + h_obj = duk_get_hobject(ctx, 0); + if (h_obj != NULL && DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) { + ret = ((duk_hbufferobject *) h_obj)->is_view; + } + duk_push_boolean(ctx, ret); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_isview(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer: toString([encoding], [start], [end]) + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tostring(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + duk_int_t start_offset, end_offset; + duk_uint8_t *buf_slice; + duk_size_t slice_length; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + h_this = duk__get_bufobj_this(ctx); + if (h_this == NULL) { + /* XXX: happens e.g. when evaluating: String(Buffer.prototype). */ + duk_push_string(ctx, "[object Object]"); + return 1; + } + DUK_ASSERT_HBUFFEROBJECT_VALID(h_this); + + /* ignore encoding for now */ + + duk__clamp_startend_nonegidx_noshift(ctx, h_this, 1 /*idx_start*/, 2 /*idx_end*/, &start_offset, &end_offset); + + slice_length = (duk_size_t) (end_offset - start_offset); + buf_slice = (duk_uint8_t *) duk_push_fixed_buffer(ctx, slice_length); + DUK_ASSERT(buf_slice != NULL); + + if (h_this->buf == NULL) { + goto type_error; + } + + if (DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_this, start_offset + slice_length)) { + DUK_MEMCPY((void *) buf_slice, + (const void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + start_offset), + slice_length); + } else { + /* not covered, return all zeroes */ + ; + } + + duk_to_string(ctx, -1); + return 1; + + type_error: + return DUK_RET_TYPE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tostring(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Duktape.Buffer: toString(), valueOf() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv; + duk_small_int_t to_string = duk_get_current_magic(ctx); + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + tv = duk_get_borrowed_this_tval(ctx); + DUK_ASSERT(tv != NULL); + + if (DUK_TVAL_IS_BUFFER(tv)) { + duk_hbuffer *h_buf; + h_buf = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h_buf != NULL); + duk_push_hbuffer(ctx, h_buf); + } else if (DUK_TVAL_IS_OBJECT(tv)) { + duk_hobject *h; + duk_hbufferobject *h_bufobj; + + /* Accept any duk_hbufferobject, though we're only normally + * called for Duktape.Buffer values. + */ + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + if (!DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + DUK_DD(DUK_DDPRINT("toString/valueOf() called for a non-bufferobject object")); + goto type_error; + } + h_bufobj = (duk_hbufferobject *) h; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + if (h_bufobj->buf == NULL) { + DUK_DD(DUK_DDPRINT("toString/valueOf() called for a bufferobject with NULL buf")); + goto type_error; + } + duk_push_hbuffer(ctx, h_bufobj->buf); + } else { + goto type_error; + } + + if (to_string) { + duk_to_string(ctx, -1); + } + return 1; + + type_error: + return DUK_RET_TYPE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype: toJSON() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tojson(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + duk_uint8_t *buf; + duk_uint_t i; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + + if (h_this->buf == NULL || !DUK_HBUFFEROBJECT_VALID_SLICE(h_this)) { + /* Serialize uncovered backing buffer as a null; doesn't + * really matter as long we're memory safe. + */ + duk_push_null(ctx); + return 1; + } + + duk_push_object(ctx); + duk_push_hstring_stridx(ctx, DUK_STRIDX_UC_BUFFER); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_TYPE); + + duk_push_array(ctx); + for (i = 0; i < h_this->length; i++) { + /* XXX: regetting the pointer may be overkill - we're writing + * to a side-effect free array here. + */ + DUK_ASSERT(h_this->buf != NULL); + buf = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this); + duk_push_uint(ctx, (duk_uint_t) buf[i]); + duk_put_prop_index(ctx, -2, (duk_idx_t) i); + } + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_DATA); + + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tojson(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype.equals() + * Node.js Buffer.prototype.compare() + * Node.js Buffer.compare() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_buffer_compare_shared(duk_context *ctx) { + duk_hthread *thr; + duk_small_uint_t magic; + duk_hbufferobject *h_bufarg1; + duk_hbufferobject *h_bufarg2; + duk_small_int_t comp_res; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + magic = duk_get_current_magic(ctx); + if (magic & 0x02) { + /* Static call style. */ + h_bufarg1 = duk__require_bufobj_value(ctx, 0); + h_bufarg2 = duk__require_bufobj_value(ctx, 1); + } else { + h_bufarg1 = duk__require_bufobj_this(ctx); + h_bufarg2 = duk__require_bufobj_value(ctx, 0); + } + DUK_ASSERT(h_bufarg1 != NULL); + DUK_ASSERT(h_bufarg2 != NULL); + + /* We want to compare the slice/view areas of the arguments. + * If either slice/view is invalid (underlying buffer is shorter) + * ensure equals() is false, but otherwise the only thing that + * matters is to be memory safe. + */ + + if (DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg1) && + DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg2)) { + comp_res = duk_js_data_compare((const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufarg1->buf) + h_bufarg1->offset, + (const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufarg2->buf) + h_bufarg2->offset, + (duk_size_t) h_bufarg1->length, + (duk_size_t) h_bufarg2->length); + } else { + comp_res = -1; /* either nonzero value is ok */ + } + + if (magic & 0x01) { + /* compare: similar to string comparison but for buffer data. */ + duk_push_int(ctx, comp_res); + } else { + /* equals */ + duk_push_boolean(ctx, (comp_res == 0)); + } + + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_compare_shared(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype.fill() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_fill(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + const duk_uint8_t *fill_str_ptr; + duk_size_t fill_str_len; + duk_uint8_t fill_value; + duk_int_t fill_offset; + duk_int_t fill_end; + duk_size_t fill_length; + duk_uint8_t *p; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + if (h_this->buf == NULL) { + return DUK_RET_TYPE_ERROR; + } + + /* [ value offset end ] */ + + if (duk_is_string(ctx, 0)) { + fill_str_ptr = (const duk_uint8_t *) duk_get_lstring(ctx, 0, &fill_str_len); + DUK_ASSERT(fill_str_ptr != NULL); + } else { + fill_value = (duk_uint8_t) duk_to_uint32(ctx, 0); + fill_str_ptr = (const duk_uint8_t *) &fill_value; + fill_str_len = 1; + } + + /* Fill offset handling is more lenient than in Node.js. */ + + duk__clamp_startend_nonegidx_noshift(ctx, h_this, 1 /*idx_start*/, 2 /*idx_end*/, &fill_offset, &fill_end); + + DUK_DDD(DUK_DDDPRINT("fill: fill_value=%02x, fill_offset=%ld, fill_end=%ld, view length=%ld", + (unsigned int) fill_value, (long) fill_offset, (long) fill_end, (long) h_this->length)); + + DUK_ASSERT(fill_end - fill_offset >= 0); + DUK_ASSERT(h_this->buf != NULL); + + p = (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + fill_offset); + fill_length = (duk_size_t) (fill_end - fill_offset); + if (fill_str_len == 1) { + /* Handle single character fills as memset() even when + * the fill data comes from a one-char argument. + */ + DUK_MEMSET((void *) p, (int) fill_str_ptr[0], (size_t) fill_length); + } else if (fill_str_len > 1) { + duk_size_t i, n, t; + + for (i = 0, n = (fill_end - fill_offset), t = 0; i < n; i++) { + p[i] = fill_str_ptr[t++]; + if (t >= fill_str_len) { + t = 0; + } + } + } else { + DUK_DDD(DUK_DDDPRINT("zero size fill pattern, ignore silently")); + } + + /* Return the Buffer to allow chaining: b.fill(0x11).fill(0x22, 3, 5).toString() */ + duk_push_this(ctx); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_fill(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype.write(string, [offset], [length], [encoding]) + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_write(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + duk_uint_t offset; + duk_uint_t length; + const duk_uint8_t *str_data; + duk_size_t str_len; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + + /* Argument must be a string, e.g. a buffer is not allowed. */ + str_data = (const duk_uint8_t *) duk_require_lstring(ctx, 0, &str_len); + + duk__resolve_offset_opt_length(ctx, h_this, 1, 2, &offset, &length, 0 /*throw_flag*/); + DUK_ASSERT(offset <= h_this->length); + DUK_ASSERT(offset + length <= h_this->length); + + /* XXX: encoding is ignored now. */ + + if (length > str_len) { + length = (duk_uint_t) str_len; + } + + if (DUK_HBUFFEROBJECT_VALID_SLICE(h_this)) { + /* Cannot overlap. */ + DUK_MEMCPY((void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + offset), + (const void *) str_data, + (size_t) length); + } else { + DUK_DDD(DUK_DDDPRINT("write() target buffer is not covered, silent ignore")); + } + + duk_push_uint(ctx, length); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_write(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype.copy() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_copy(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + duk_hbufferobject *h_bufarg; + duk_int_t source_length; + duk_int_t target_length; + duk_int_t target_start, source_start, source_end; + duk_uint_t target_ustart, source_ustart, source_uend; + duk_uint_t copy_size = 0; + + /* [ targetBuffer targetStart sourceStart sourceEnd ] */ + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + h_this = duk__require_bufobj_this(ctx); + h_bufarg = duk__require_bufobj_value(ctx, 0); + DUK_ASSERT(h_this != NULL); + DUK_ASSERT(h_bufarg != NULL); + source_length = (duk_int_t) h_this->length; + target_length = (duk_int_t) h_bufarg->length; + + target_start = duk_to_int(ctx, 1); + source_start = duk_to_int(ctx, 2); + if (duk_is_undefined(ctx, 3)) { + source_end = source_length; + } else { + source_end = duk_to_int(ctx, 3); + } + + DUK_DDD(DUK_DDDPRINT("checking copy args: target_start=%ld, target_length=%ld, " + "source_start=%ld, source_end=%ld, source_length=%ld", + (long) target_start, (long) h_bufarg->length, + (long) source_start, (long) source_end, (long) source_length)); + + /* This behavior mostly mimics Node.js now. */ + + if (source_start < 0 || source_end < 0 || target_start < 0) { + /* Negative offsets cause a RangeError. */ + goto fail_bounds; + } + source_ustart = (duk_uint_t) source_start; + source_uend = (duk_uint_t) source_end; + target_ustart = (duk_uint_t) target_start; + if (source_ustart >= source_uend || /* crossed offsets or zero size */ + source_ustart >= (duk_uint_t) source_length || /* source out-of-bounds (but positive) */ + target_ustart >= (duk_uint_t) target_length) { /* target out-of-bounds (but positive) */ + goto silent_ignore; + } + if (source_uend >= (duk_uint_t) source_length) { + /* Source end clamped silently to available length. */ + source_uend = source_length; + } + copy_size = source_uend - source_ustart; + if (target_ustart + copy_size > (duk_uint_t) target_length) { + /* Clamp to target's end if too long. + * + * NOTE: there's no overflow possibility in the comparison; + * both target_ustart and copy_size are >= 0 and based on + * values in duk_int_t range. Adding them as duk_uint_t + * values is then guaranteed not to overflow. + */ + DUK_ASSERT(target_ustart + copy_size >= target_ustart); /* no overflow */ + DUK_ASSERT(target_ustart + copy_size >= copy_size); /* no overflow */ + copy_size = (duk_uint_t) target_length - target_ustart; + } + + DUK_DDD(DUK_DDDPRINT("making copy: target_ustart=%lu source_ustart=%lu copy_size=%lu", + (unsigned long) target_ustart, (unsigned long) source_ustart, + (unsigned long) copy_size)); + + DUK_ASSERT(copy_size >= 1); + DUK_ASSERT(source_ustart <= (duk_uint_t) source_length); + DUK_ASSERT(source_ustart + copy_size <= (duk_uint_t) source_length); + DUK_ASSERT(target_ustart <= (duk_uint_t) target_length); + DUK_ASSERT(target_ustart + copy_size <= (duk_uint_t) target_length); + + /* Ensure copy is covered by underlying buffers. */ + DUK_ASSERT(h_bufarg->buf != NULL); /* length check */ + DUK_ASSERT(h_this->buf != NULL); /* length check */ + if (DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufarg, target_ustart + copy_size) && + DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_this, source_ustart + copy_size)) { + /* Must use memmove() because copy area may overlap (source and target + * buffer may be the same, or from different slices. + */ + DUK_MEMMOVE((void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg) + target_ustart), + (const void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + source_ustart), + (size_t) copy_size); + } else { + DUK_DDD(DUK_DDDPRINT("buffer copy not covered by underlying buffer(s), ignoring")); + } + + silent_ignore: + /* Return value is like write(), number of bytes written. + * The return value matters because of code like: + * "off += buf.copy(...)". + */ + duk_push_uint(ctx, copy_size); + return 1; + + fail_bounds: + return DUK_RET_RANGE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_copy(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * TypedArray.prototype.set() + * + * TypedArray set() is pretty interesting to implement because: + * + * - The source argument may be a plain array or a typedarray. If the + * source is a TypedArray, values are decoded and re-encoded into the + * target (not as a plain byte copy). This may happen even when the + * element byte size is the same, e.g. integer values may be re-encoded + * into floats. + * + * - Source and target may refer to the same underlying buffer, so that + * the set() operation may overlap. The specification requires that this + * must work as if a copy was made before the operation. Note that this + * is NOT a simple memmove() situation because the source and target + * byte sizes may be different -- e.g. a 4-byte source (Int8Array) may + * expand to a 16-byte target (Uint32Array) so that the target overlaps + * the source both from beginning and the end (unlike in typical memmove). + * + * - Even if 'buf' pointers of the source and target differ, there's no + * guarantee that their memory areas don't overlap. This may be the + * case with external buffers. + * + * Even so, it is nice to optimize for the common case: + * + * - Source and target separate buffers or non-overlapping. + * + * - Source and target have a compatible type so that a plain byte copy + * is possible. Note that while e.g. uint8 and int8 are compatible + * (coercion one way or another doesn't change the byte representation), + * e.g. int8 and uint8clamped are NOT compatible when writing int8 + * values into uint8clamped typedarray (-1 would clamp to 0 for instance). + * + * See test-bi-typedarray-proto-set.js. + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_typedarray_set(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + duk_hobject *h_obj; + duk_uarridx_t i, n; + duk_int_t offset_signed; + duk_uint_t offset_elems; + duk_uint_t offset_bytes; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_this); + + if (h_this->buf == NULL) { + DUK_DDD(DUK_DDDPRINT("source neutered, skip copy")); + return 0; + } + + h_obj = duk_require_hobject(ctx, 0); + DUK_ASSERT(h_obj != NULL); + + /* XXX: V8 throws a TypeError for negative values. Would it + * be more useful to interpret negative offsets here from the + * end of the buffer too? + */ + offset_signed = duk_to_int(ctx, 1); + if (offset_signed < 0) { + return DUK_RET_TYPE_ERROR; + } + offset_elems = (duk_uint_t) offset_signed; + offset_bytes = offset_elems << h_this->shift; + if ((offset_bytes >> h_this->shift) != offset_elems) { + /* Byte length would overflow. */ + /* XXX: easier check with less code? */ + return DUK_RET_RANGE_ERROR; + } + if (offset_bytes > h_this->length) { + /* Equality may be OK but >length not. Checking + * this explicitly avoids some overflow cases + * below. + */ + return DUK_RET_RANGE_ERROR; + } + DUK_ASSERT(offset_bytes <= h_this->length); + + /* Fast path: source is a TypedArray (or any bufferobject). */ + + if (DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) { + duk_hbufferobject *h_bufarg; + duk_uint16_t comp_mask; + duk_small_int_t no_overlap = 0; + duk_uint_t src_length; + duk_uint_t dst_length; + duk_uint_t dst_length_elems; + duk_uint8_t *p_src_base; + duk_uint8_t *p_src_end; + duk_uint8_t *p_src; + duk_uint8_t *p_dst_base; + duk_uint8_t *p_dst; + duk_small_uint_t src_elem_size; + duk_small_uint_t dst_elem_size; + + h_bufarg = (duk_hbufferobject *) h_obj; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufarg); + + if (h_bufarg->buf == NULL) { + DUK_DDD(DUK_DDDPRINT("target neutered, skip copy")); + return 0; + } + + /* Nominal size check. */ + src_length = h_bufarg->length; /* bytes in source */ + dst_length_elems = (src_length >> h_bufarg->shift); /* elems in source and dest */ + dst_length = dst_length_elems << h_this->shift; /* bytes in dest */ + if ((dst_length >> h_this->shift) != dst_length_elems) { + /* Byte length would overflow. */ + /* XXX: easier check with less code? */ + return DUK_RET_RANGE_ERROR; + } + DUK_DDD(DUK_DDDPRINT("nominal size check: src_length=%ld, dst_length=%ld", + (long) src_length, (long) dst_length)); + DUK_ASSERT(offset_bytes <= h_this->length); + if (dst_length > h_this->length - offset_bytes) { + /* Overflow not an issue because subtraction is used on the right + * side and guaranteed to be >= 0. + */ + DUK_DDD(DUK_DDDPRINT("copy exceeds target buffer nominal length")); + return DUK_RET_RANGE_ERROR; + } + if (!DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_this, offset_bytes + dst_length)) { + DUK_DDD(DUK_DDDPRINT("copy not covered by underlying target buffer, ignore")); + return 0; + } + + p_src_base = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg); + p_dst_base = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + offset_bytes; + + /* Check actual underlying buffers for validity and that they + * cover the copy. No side effects are allowed after the check + * so that the validity status doesn't change. + */ + if (!DUK_HBUFFEROBJECT_VALID_SLICE(h_this) || + !DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)) { + /* The condition could be more narrow and check for the + * copy area only, but there's no need for fine grained + * behavior when the underlying buffer is misconfigured. + */ + DUK_DDD(DUK_DDDPRINT("source and/or target not covered by underlying buffer, skip copy")); + return 0; + } + + /* We want to do a straight memory copy if possible: this is + * an important operation because .set() is the TypedArray + * way to copy chunks of memory. However, because set() + * conceptually works in terms of elements, not all views are + * compatible with direct byte copying. + * + * If we do manage a direct copy, the "overlap issue" handled + * below can just be solved using memmove() because the source + * and destination element sizes are necessarily equal. + */ + + DUK_ASSERT(h_this->elem_type < sizeof(duk__buffer_elemtype_copy_compatible) / sizeof(duk_uint16_t)); + comp_mask = duk__buffer_elemtype_copy_compatible[h_this->elem_type]; + if (comp_mask & (1 << h_bufarg->elem_type)) { + DUK_ASSERT(src_length == dst_length); + + DUK_DDD(DUK_DDDPRINT("fast path: able to use memmove() because views are compatible")); + DUK_MEMMOVE((void *) p_dst_base, (const void *) p_src_base, (size_t) dst_length); + return 0; + } + DUK_DDD(DUK_DDDPRINT("fast path: views are not compatible with a byte copy, copy by item")); + + /* We want to avoid making a copy to process set() but that's + * not always possible: the source and the target may overlap + * and because element sizes are different, the overlap cannot + * always be handled with a memmove() or choosing the copy + * direction in a certain way. For example, if source type is + * uint8 and target type is uint32, the target area may exceed + * the source area from both ends! + * + * Note that because external buffers may point to the same + * memory areas, we must ultimately make this check using + * pointers. + * + * NOTE: careful with side effects: any side effect may cause + * a buffer resize (or external buffer pointer/length update)! + */ + + DUK_DDD(DUK_DDDPRINT("overlap check: p_src_base=%p, src_length=%ld, " + "p_dst_base=%p, dst_length=%ld", + (void *) p_src_base, (long) src_length, + (void *) p_dst_base, (long) dst_length)); + + if (p_src_base >= p_dst_base + dst_length || /* source starts after dest ends */ + p_src_base + src_length <= p_dst_base) { /* source ends before dest starts */ + no_overlap = 1; + } + + if (!no_overlap) { + /* There's overlap: the desired end result is that + * conceptually a copy is made to avoid "trampling" + * of source data by destination writes. We make + * an actual temporary copy to handle this case. + */ + duk_uint8_t *p_src_copy; + + DUK_DDD(DUK_DDDPRINT("there is overlap, make a copy of the source")); + p_src_copy = (duk_uint8_t *) duk_push_fixed_buffer(ctx, src_length); + DUK_ASSERT(p_src_copy != NULL); + DUK_MEMCPY((void *) p_src_copy, (const void *) p_src_base, (size_t) src_length); + + p_src_base = p_src_copy; /* use p_src_base from now on */ + } + /* Value stack intentionally mixed size here. */ + + DUK_DDD(DUK_DDDPRINT("after overlap check: p_src_base=%p, src_length=%ld, " + "p_dst_base=%p, dst_length=%ld, valstack top=%ld", + (void *) p_src_base, (long) src_length, + (void *) p_dst_base, (long) dst_length, + (long) duk_get_top(ctx))); + + /* Ready to make the copy. We must proceed element by element + * and must avoid any side effects that might cause the buffer + * validity check above to become invalid. + * + * Although we work through the value stack here, only plain + * numbers are handled which should be side effect safe. + */ + + src_elem_size = 1 << h_bufarg->shift; + dst_elem_size = 1 << h_this->shift; + p_src = p_src_base; + p_dst = p_dst_base; + p_src_end = p_src_base + src_length; + + while (p_src != p_src_end) { + DUK_DDD(DUK_DDDPRINT("fast path per element copy loop: " + "p_src=%p, p_src_end=%p, p_dst=%p", + (void *) p_src, (void *) p_src_end, (void *) p_dst)); + /* A validated read() is always a number, so it's write coercion + * is always side effect free an won't invalidate pointers etc. + */ + duk_hbufferobject_push_validated_read(ctx, h_bufarg, p_src, src_elem_size); + duk_hbufferobject_validated_write(ctx, h_this, p_dst, dst_elem_size); + duk_pop(ctx); + p_src += src_elem_size; + p_dst += dst_elem_size; + } + + return 0; + } else { + /* Slow path: quite slow, but we save space by using the property code + * to write coerce target values. We don't need to worry about overlap + * here because the source is not a TypedArray. + * + * We could use the bufferobject write coercion helper but since the + * property read may have arbitrary side effects, full validity checks + * would be needed for every element anyway. + */ + + n = (duk_uarridx_t) duk_get_length(ctx, 0); + DUK_ASSERT(offset_bytes <= h_this->length); + if ((n << h_this->shift) > h_this->length - offset_bytes) { + /* Overflow not an issue because subtraction is used on the right + * side and guaranteed to be >= 0. + */ + DUK_DDD(DUK_DDDPRINT("copy exceeds target buffer nominal length")); + return DUK_RET_RANGE_ERROR; + } + + /* There's no need to check for buffer validity status for the + * target here: the property access code will do that for each + * element. Moreover, if we did check the validity here, side + * effects from reading the source argument might invalidate + * the results anyway. + */ + + DUK_ASSERT_TOP(ctx, 2); + duk_push_this(ctx); + + for (i = 0; i < n; i++) { + duk_get_prop_index(ctx, 0, i); + duk_put_prop_index(ctx, 2, offset_elems + i); + } + } + + return 0; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_typedarray_set(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype.slice([start], [end]) + * ArrayBuffer.prototype.slice(begin, [end]) + * TypedArray.prototype.slice(begin, [end]) + * + * The API calls are almost identical; negative indices are counted from end + * of buffer, and final indices are clamped (allowing crossed indices). Main + * differences: + * + * - Copy/view behavior; Node.js .slice() and TypedArray .subarray() create + * views, ArrayBuffer .slice() creates a copy + * + * - Resulting object has a different class and prototype depending on the + * call (or 'this' argument) + * + * - TypedArray .subarray() arguments are element indices, not byte offsets + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_buffer_slice_shared(duk_context *ctx) { + duk_hthread *thr; + duk_small_int_t magic; + duk_small_uint_t res_class_num; + duk_hobject *res_proto; + duk_hbufferobject *h_this; + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; + duk_int_t start_offset, end_offset; + duk_uint_t slice_length; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + /* [ start end ] */ + + magic = duk_get_current_magic(ctx); + h_this = duk__require_bufobj_this(ctx); + + /* Slice offsets are element (not byte) offsets, which only matters + * for TypedArray views, Node.js Buffer and ArrayBuffer have shift + * zero so byte and element offsets are the same. Negative indices + * are counted from end of slice, crossed indices are allowed (and + * result in zero length result), and final values are clamped + * against the current slice. There's intentionally no check + * against the underlying buffer here. + */ + + duk__clamp_startend_negidx_shifted(ctx, h_this, 0 /*idx_start*/, 1 /*idx_end*/, &start_offset, &end_offset); + DUK_ASSERT(end_offset >= start_offset); + slice_length = (duk_uint_t) (end_offset - start_offset); + + /* The resulting buffer object gets the same class and prototype as + * the buffer in 'this', e.g. if the input is a Node.js Buffer the + * result is a Node.js Buffer; if the input is a Float32Array, the + * result is a Float32Array. + * + * For the class number this seems correct. The internal prototype + * is not so clear: if 'this' is a bufferobject with a non-standard + * prototype object, that value gets copied over into the result + * (instead of using the standard prototype for that object type). + */ + + res_class_num = DUK_HOBJECT_GET_CLASS_NUMBER((duk_hobject *) h_this); + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(res_class_num), + DUK_BIDX_OBJECT_PROTOTYPE); /* replaced */ + DUK_ASSERT(h_bufobj != NULL); + res_proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, (duk_hobject *) h_this); /* may be NULL */ + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) h_bufobj, res_proto); + + h_bufobj->length = slice_length; + h_bufobj->shift = h_this->shift; /* inherit */ + h_bufobj->elem_type = h_this->elem_type; /* inherit */ + h_bufobj->is_view = magic & 0x01; + DUK_ASSERT(h_bufobj->is_view == 0 || h_bufobj->is_view == 1); + + h_val = h_this->buf; + if (h_val == NULL) { + return DUK_RET_TYPE_ERROR; + } + + if (magic & 0x02) { + /* non-zero: make copy */ + duk_uint8_t *p_copy; + duk_size_t copy_length; + + p_copy = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) slice_length); + DUK_ASSERT(p_copy != NULL); + + /* Copy slice, respecting underlying buffer limits; remainder + * is left as zero. + */ + copy_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, slice_length); + DUK_MEMCPY((void *) p_copy, + (const void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + start_offset), + copy_length); + + h_val = duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_val != NULL); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + DUK_ASSERT(h_bufobj->offset == 0); + + duk_pop(ctx); /* reachable so pop OK */ + } else { + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->offset = (duk_uint_t) (h_this->offset + start_offset); + + /* Copy the .buffer property, needed for TypedArray.prototype.subarray(). + * + * XXX: limit copy only for TypedArray classes specifically? + */ + + duk_push_this(ctx); + if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LC_BUFFER)) { + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE); + duk_pop(ctx); + } else { + duk_pop_2(ctx); + } + } + /* unbalanced stack on purpose */ + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_slice_shared(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.isEncoding() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_is_encoding(duk_context *ctx) { + const char *encoding; + + /* only accept lowercase 'utf8' now. */ + + encoding = duk_to_string(ctx, 0); + DUK_ASSERT(duk_is_string(ctx, 0)); /* guaranteed by duk_to_string() */ + duk_push_boolean(ctx, DUK_STRCMP(encoding, "utf8") == 0); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_is_encoding(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.isBuffer() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_is_buffer(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv; + duk_hobject *h; + duk_hobject *h_proto; + duk_bool_t ret = 0; + + thr = (duk_hthread *) ctx; + + DUK_ASSERT(duk_get_top(ctx) >= 1); /* nargs */ + tv = duk_get_tval(ctx, 0); + DUK_ASSERT(tv != NULL); + + if (DUK_TVAL_IS_OBJECT(tv)) { + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + + h_proto = thr->builtins[DUK_BIDX_NODEJS_BUFFER_PROTOTYPE]; + DUK_ASSERT(h_proto != NULL); + + h = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h); + if (h) { + ret = duk_hobject_prototype_chain_contains(thr, h, h_proto, 0 /*ignore_loop*/); + } + } + + duk_push_boolean(ctx, ret); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_is_buffer(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.byteLength() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_byte_length(duk_context *ctx) { + const char *str; + duk_size_t len; + + /* At the moment Buffer(<str>) will just use the string bytes as + * is (ignoring encoding), so we return the string length here + * unconditionally. + */ + + str = duk_to_lstring(ctx, 0, &len); + DUK_UNREF(str); + duk_push_size_t(ctx, len); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_byte_length(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.concat() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_concat(duk_context *ctx) { + duk_hthread *thr; + duk_hobject *h_arg; + duk_int_t total_length = 0; + duk_hbufferobject *h_bufobj; + duk_hbufferobject *h_bufres; + duk_hbuffer *h_val; + duk_uint_t i, n; + duk_uint8_t *p; + duk_size_t space_left; + duk_size_t copy_size; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + /* Node.js accepts only actual Arrays. */ + h_arg = duk_require_hobject(ctx, 0); + if (DUK_HOBJECT_GET_CLASS_NUMBER(h_arg) != DUK_HOBJECT_CLASS_ARRAY) { + return DUK_RET_TYPE_ERROR; + } + + /* Compute result length and validate argument buffers. */ + n = (duk_uint_t) duk_get_length(ctx, 0); + for (i = 0; i < n; i++) { + /* Neutered checks not necessary here: neutered buffers have + * zero 'length' so we'll effectively skip them. + */ + DUK_ASSERT_TOP(ctx, 2); /* [ array totalLength ] */ + duk_get_prop_index(ctx, 0, (duk_uarridx_t) i); /* -> [ array totalLength buf ] */ + h_bufobj = duk__require_bufobj_value(ctx, 2); + DUK_ASSERT(h_bufobj != NULL); + total_length += h_bufobj->length; + duk_pop(ctx); + } + if (n == 1) { + /* For the case n==1 Node.js doesn't seem to type check + * the sole member but we do it before returning it. + * For this case only the original buffer object is + * returned (not a copy). + */ + duk_get_prop_index(ctx, 0, 0); + return 1; + } + + /* User totalLength overrides a computed length, but we'll check + * every copy in the copy loop. Note that duk_to_uint() can + * technically have arbitrary side effects so we need to recheck + * the buffers in the copy loop. + */ + if (!duk_is_undefined(ctx, 1) && n > 0) { + /* For n == 0, Node.js ignores totalLength argument and + * returns a zero length buffer. + */ + total_length = duk_to_int(ctx, 1); + } + if (total_length < 0) { + return DUK_RET_RANGE_ERROR; + } + + h_bufres = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER), + DUK_BIDX_NODEJS_BUFFER_PROTOTYPE); + DUK_ASSERT(h_bufres != NULL); + + p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, total_length); + DUK_ASSERT(p != NULL); + space_left = total_length; + + for (i = 0; i < n; i++) { + DUK_ASSERT_TOP(ctx, 4); /* [ array totalLength bufres buf ] */ + + duk_get_prop_index(ctx, 0, (duk_uarridx_t) i); + h_bufobj = duk__require_bufobj_value(ctx, 4); + DUK_ASSERT(h_bufobj != NULL); + + copy_size = h_bufobj->length; + if (copy_size > space_left) { + copy_size = space_left; + } + + if (h_bufobj->buf != NULL && + DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)) { + DUK_MEMCPY((void *) p, + (const void *) DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj), + copy_size); + } else { + /* Just skip, leaving zeroes in the result. */ + ; + } + p += copy_size; + space_left -= copy_size; + + duk_pop(ctx); + } + + h_val = duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_val != NULL); + + duk__set_bufobj_buffer(ctx, h_bufres, h_val); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufres); + + duk_pop(ctx); /* pop plain buffer, now reachable through h_bufres */ + + return 1; /* return h_bufres */ +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_concat(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Shared readfield and writefield methods + * + * The readfield/writefield methods need support for endianness and field + * types. All offsets are byte based so no offset shifting is needed. + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Format of magic, bits: + * 0...1: field type; 0=uint8, 1=uint16, 2=uint32, 3=float, 4=double, 5=unused, 6=unused, 7=unused + * 3: endianness: 0=little, 1=big + * 4: signed: 1=yes, 0=no + * 5: typedarray: 1=yes, 0=no + */ +#define DUK__FLD_8BIT 0 +#define DUK__FLD_16BIT 1 +#define DUK__FLD_32BIT 2 +#define DUK__FLD_FLOAT 3 +#define DUK__FLD_DOUBLE 4 +#define DUK__FLD_VARINT 5 +#define DUK__FLD_BIGENDIAN (1 << 3) +#define DUK__FLD_SIGNED (1 << 4) +#define DUK__FLD_TYPEDARRAY (1 << 5) + +/* XXX: split into separate functions for each field type? */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_readfield(duk_context *ctx) { + duk_hthread *thr; + duk_small_int_t magic = (duk_small_int_t) duk_get_current_magic(ctx); + duk_small_int_t magic_ftype; + duk_small_int_t magic_bigendian; + duk_small_int_t magic_signed; + duk_small_int_t magic_typedarray; + duk_small_int_t endswap; + duk_hbufferobject *h_this; + duk_bool_t no_assert; + duk_int_t offset_signed; + duk_uint_t offset; + duk_uint_t buffer_length; + duk_uint_t check_length; + duk_uint8_t *buf; + duk_double_union du; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + magic_ftype = magic & 0x0007; + magic_bigendian = magic & 0x0008; + magic_signed = magic & 0x0010; + magic_typedarray = magic & 0x0020; + + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + buffer_length = h_this->length; + + /* [ offset noAssert ], when ftype != DUK__FLD_VARINT */ + /* [ offset fieldByteLength noAssert ], when ftype == DUK__FLD_VARINT */ + /* [ offset littleEndian ], when DUK__FLD_TYPEDARRAY (regardless of ftype) */ + + /* Handle TypedArray vs. Node.js Buffer arg differences */ + if (magic_typedarray) { + no_assert = 0; +#if defined(DUK_USE_INTEGER_LE) + endswap = !duk_to_boolean(ctx, 1); /* 1=little endian */ +#else + endswap = duk_to_boolean(ctx, 1); /* 1=little endian */ +#endif + } else { + no_assert = duk_to_boolean(ctx, (magic_ftype == DUK__FLD_VARINT) ? 2 : 1); +#if defined(DUK_USE_INTEGER_LE) + endswap = magic_bigendian; +#else + endswap = !magic_bigendian; +#endif + } + + /* Offset is coerced first to signed integer range and then to unsigned. + * This ensures we can add a small byte length (1-8) to the offset in + * bound checks and not wrap. + */ + offset_signed = duk_to_int(ctx, 0); + offset = (duk_uint_t) offset_signed; + if (offset_signed < 0) { + goto fail_bounds; + } + + DUK_DDD(DUK_DDDPRINT("readfield, buffer_length=%ld, offset=%ld, no_assert=%d, " + "magic=%04x, magic_fieldtype=%d, magic_bigendian=%d, magic_signed=%d, " + "endswap=%d", + (long) buffer_length, (long) offset, (int) no_assert, + (unsigned int) magic, (int) magic_ftype, (int) (magic_bigendian >> 3), + (int) (magic_signed >> 4), (int) endswap)); + + /* Update 'buffer_length' to be the effective, safe limit which + * takes into account the underlying buffer. This value will be + * potentially invalidated by any side effect. + */ + check_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, buffer_length); + DUK_DDD(DUK_DDDPRINT("buffer_length=%ld, check_length=%ld", + (long) buffer_length, (long) check_length)); + + if (h_this->buf) { + buf = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this); + } else { + /* neutered, value doesn't matter because check_length is 0. */ + DUK_ASSERT(check_length == 0); + buf = NULL; + } + + switch (magic_ftype) { + case DUK__FLD_8BIT: { + duk_uint8_t tmp; + if (offset + 1U > check_length) { + goto fail_bounds; + } + tmp = buf[offset]; + if (magic_signed) { + duk_push_int(ctx, (duk_int_t) ((duk_int8_t) tmp)); + } else { + duk_push_uint(ctx, (duk_uint_t) tmp); + } + break; + } + case DUK__FLD_16BIT: { + duk_uint16_t tmp; + if (offset + 2U > check_length) { + goto fail_bounds; + } + DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 2); + tmp = du.us[0]; + if (endswap) { + tmp = DUK_BSWAP16(tmp); + } + if (magic_signed) { + duk_push_int(ctx, (duk_int_t) ((duk_int16_t) tmp)); + } else { + duk_push_uint(ctx, (duk_uint_t) tmp); + } + break; + } + case DUK__FLD_32BIT: { + duk_uint32_t tmp; + if (offset + 4U > check_length) { + goto fail_bounds; + } + DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 4); + tmp = du.ui[0]; + if (endswap) { + tmp = DUK_BSWAP32(tmp); + } + if (magic_signed) { + duk_push_int(ctx, (duk_int_t) ((duk_int32_t) tmp)); + } else { + duk_push_uint(ctx, (duk_uint_t) tmp); + } + break; + } + case DUK__FLD_FLOAT: { + duk_uint32_t tmp; + if (offset + 4U > check_length) { + goto fail_bounds; + } + DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 4); + if (endswap) { + tmp = du.ui[0]; + tmp = DUK_BSWAP32(tmp); + du.ui[0] = tmp; + } + duk_push_number(ctx, (duk_double_t) du.f[0]); + break; + } + case DUK__FLD_DOUBLE: { + if (offset + 8U > check_length) { + goto fail_bounds; + } + DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 8); + if (endswap) { + DUK_DBLUNION_BSWAP64(&du); + } + duk_push_number(ctx, (duk_double_t) du.d); + break; + } + case DUK__FLD_VARINT: { + /* Node.js Buffer variable width integer field. We don't really + * care about speed here, so aim for shortest algorithm. + */ + duk_int_t field_bytelen; + duk_int_t i, i_step, i_end; +#if defined(DUK_USE_64BIT_OPS) + duk_int64_t tmp; + duk_small_uint_t shift_tmp; +#else + duk_double_t tmp; + duk_small_int_t highbyte; +#endif + const duk_uint8_t *p; + + field_bytelen = duk_get_int(ctx, 1); /* avoid side effects! */ + if (field_bytelen < 1 || field_bytelen > 6) { + goto fail_field_length; + } + if (offset + (duk_uint_t) field_bytelen > check_length) { + goto fail_bounds; + } + p = (const duk_uint8_t *) (buf + offset); + + /* Slow gathering of value using either 64-bit arithmetic + * or IEEE doubles if 64-bit types not available. Handling + * of negative numbers is a bit non-obvious in both cases. + */ + + if (magic_bigendian) { + /* Gather in big endian */ + i = 0; + i_step = 1; + i_end = field_bytelen; /* one i_step over */ + } else { + /* Gather in little endian */ + i = field_bytelen - 1; + i_step = -1; + i_end = -1; /* one i_step over */ + } + +#if defined(DUK_USE_64BIT_OPS) + tmp = 0; + do { + DUK_ASSERT(i >= 0 && i < field_bytelen); + tmp = (tmp << 8) + (duk_int64_t) p[i]; + i += i_step; + } while (i != i_end); + + if (magic_signed) { + /* Shift to sign extend. */ + shift_tmp = 64 - (field_bytelen * 8); + tmp = (tmp << shift_tmp) >> shift_tmp; + } + + duk_push_i64(ctx, tmp); +#else + highbyte = p[i]; + if (magic_signed && (highbyte & 0x80) != 0) { + /* 0xff => 255 - 256 = -1; 0x80 => 128 - 256 = -128 */ + tmp = (duk_double_t) (highbyte - 256); + } else { + tmp = (duk_double_t) highbyte; + } + for (;;) { + i += i_step; + if (i == i_end) { + break; + } + DUK_ASSERT(i >= 0 && i < field_bytelen); + tmp = (tmp * 256.0) + (duk_double_t) p[i]; + } + + duk_push_number(ctx, tmp); +#endif + break; + } + default: { /* should never happen but default here */ + goto fail_bounds; + } + } + + return 1; + + fail_field_length: + fail_bounds: + if (no_assert) { + /* Node.js return value for noAssert out-of-bounds reads is + * usually (but not always) NaN. Return NaN consistently. + */ + duk_push_nan(ctx); + return 1; + } + + return DUK_RET_RANGE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_readfield(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* XXX: split into separate functions for each field type? */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_writefield(duk_context *ctx) { + duk_hthread *thr; + duk_small_int_t magic = (duk_small_int_t) duk_get_current_magic(ctx); + duk_small_int_t magic_ftype; + duk_small_int_t magic_bigendian; + duk_small_int_t magic_signed; + duk_small_int_t magic_typedarray; + duk_small_int_t endswap; + duk_hbufferobject *h_this; + duk_bool_t no_assert; + duk_int_t offset_signed; + duk_uint_t offset; + duk_uint_t buffer_length; + duk_uint_t check_length; + duk_uint8_t *buf; + duk_double_union du; + duk_int_t nbytes = 0; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + magic_ftype = magic & 0x0007; + magic_bigendian = magic & 0x0008; + magic_signed = magic & 0x0010; + magic_typedarray = magic & 0x0020; + DUK_UNREF(magic_signed); + + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + buffer_length = h_this->length; + + /* [ value offset noAssert ], when ftype != DUK__FLD_VARINT */ + /* [ value offset fieldByteLength noAssert ], when ftype == DUK__FLD_VARINT */ + /* [ offset value littleEndian ], when DUK__FLD_TYPEDARRAY (regardless of ftype) */ + + /* Handle TypedArray vs. Node.js Buffer arg differences */ + if (magic_typedarray) { + no_assert = 0; +#if defined(DUK_USE_INTEGER_LE) + endswap = !duk_to_boolean(ctx, 2); /* 1=little endian */ +#else + endswap = duk_to_boolean(ctx, 2); /* 1=little endian */ +#endif + duk_swap(ctx, 0, 1); /* offset/value order different from Node.js */ + } else { + no_assert = duk_to_boolean(ctx, (magic_ftype == DUK__FLD_VARINT) ? 3 : 2); +#if defined(DUK_USE_INTEGER_LE) + endswap = magic_bigendian; +#else + endswap = !magic_bigendian; +#endif + } + + /* Offset is coerced first to signed integer range and then to unsigned. + * This ensures we can add a small byte length (1-8) to the offset in + * bound checks and not wrap. + */ + offset_signed = duk_to_int(ctx, 1); + offset = (duk_uint_t) offset_signed; + + /* We need 'nbytes' even for a failed offset; return value must be + * (offset + nbytes) even when write fails due to invalid offset. + */ + if (magic_ftype != DUK__FLD_VARINT) { + DUK_ASSERT(magic_ftype >= 0 && magic_ftype < (duk_small_int_t) (sizeof(duk__buffer_nbytes_from_fldtype) / sizeof(duk_uint8_t))); + nbytes = duk__buffer_nbytes_from_fldtype[magic_ftype]; + } else { + nbytes = duk_get_int(ctx, 2); + if (nbytes < 1 || nbytes > 6) { + goto fail_field_length; + } + } + DUK_ASSERT(nbytes >= 1 && nbytes <= 8); + + /* Now we can check offset validity. */ + if (offset_signed < 0) { + goto fail_bounds; + } + + DUK_DDD(DUK_DDDPRINT("writefield, value=%!T, buffer_length=%ld, offset=%ld, no_assert=%d, " + "magic=%04x, magic_fieldtype=%d, magic_bigendian=%d, magic_signed=%d, " + "endswap=%d", + duk_get_tval(ctx, 0), (long) buffer_length, (long) offset, (int) no_assert, + (unsigned int) magic, (int) magic_ftype, (int) (magic_bigendian >> 3), + (int) (magic_signed >> 4), (int) endswap)); + + /* Coerce value to a number before computing check_length, so that + * the field type specific coercion below can't have side effects + * that would invalidate check_length. + */ + duk_to_number(ctx, 0); + + /* Update 'buffer_length' to be the effective, safe limit which + * takes into account the underlying buffer. This value will be + * potentially invalidated by any side effect. + */ + check_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, buffer_length); + DUK_DDD(DUK_DDDPRINT("buffer_length=%ld, check_length=%ld", + (long) buffer_length, (long) check_length)); + + if (h_this->buf) { + buf = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this); + } else { + /* neutered, value doesn't matter because check_length is 0. */ + DUK_ASSERT(check_length == 0); + buf = NULL; + } + + switch (magic_ftype) { + case DUK__FLD_8BIT: { + if (offset + 1U > check_length) { + goto fail_bounds; + } + /* sign doesn't matter when writing */ + buf[offset] = (duk_uint8_t) duk_to_uint32(ctx, 0); + break; + } + case DUK__FLD_16BIT: { + duk_uint16_t tmp; + if (offset + 2U > check_length) { + goto fail_bounds; + } + tmp = (duk_uint16_t) duk_to_uint32(ctx, 0); + if (endswap) { + tmp = DUK_BSWAP16(tmp); + } + du.us[0] = tmp; + /* sign doesn't matter when writing */ + DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 2); + break; + } + case DUK__FLD_32BIT: { + duk_uint32_t tmp; + if (offset + 4U > check_length) { + goto fail_bounds; + } + tmp = (duk_uint32_t) duk_to_uint32(ctx, 0); + if (endswap) { + tmp = DUK_BSWAP32(tmp); + } + du.ui[0] = tmp; + /* sign doesn't matter when writing */ + DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 4); + break; + } + case DUK__FLD_FLOAT: { + duk_uint32_t tmp; + if (offset + 4U > check_length) { + goto fail_bounds; + } + du.f[0] = (duk_float_t) duk_to_number(ctx, 0); + if (endswap) { + tmp = du.ui[0]; + tmp = DUK_BSWAP32(tmp); + du.ui[0] = tmp; + } + /* sign doesn't matter when writing */ + DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 4); + break; + } + case DUK__FLD_DOUBLE: { + if (offset + 8U > check_length) { + goto fail_bounds; + } + du.d = (duk_double_t) duk_to_number(ctx, 0); + if (endswap) { + DUK_DBLUNION_BSWAP64(&du); + } + /* sign doesn't matter when writing */ + DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 8); + break; + } + case DUK__FLD_VARINT: { + /* Node.js Buffer variable width integer field. We don't really + * care about speed here, so aim for shortest algorithm. + */ + duk_int_t field_bytelen; + duk_int_t i, i_step, i_end; +#if defined(DUK_USE_64BIT_OPS) + duk_int64_t tmp; +#else + duk_double_t tmp; +#endif + duk_uint8_t *p; + + field_bytelen = (duk_int_t) nbytes; + if (offset + (duk_uint_t) field_bytelen > check_length) { + goto fail_bounds; + } + + /* Slow writing of value using either 64-bit arithmetic + * or IEEE doubles if 64-bit types not available. There's + * no special sign handling when writing varints. + */ + + if (magic_bigendian) { + /* Write in big endian */ + i = field_bytelen; /* one i_step added at top of loop */ + i_step = -1; + i_end = 0; + } else { + /* Write in little endian */ + i = -1; /* one i_step added at top of loop */ + i_step = 1; + i_end = field_bytelen - 1; + } + + /* XXX: The duk_to_number() cast followed by integer coercion + * is platform specific so NaN, +/- Infinity, and out-of-bounds + * values result in platform specific output now. + * See: test-bi-nodejs-buffer-proto-varint-special.js + */ + +#if defined(DUK_USE_64BIT_OPS) + tmp = (duk_int64_t) duk_to_number(ctx, 0); + p = (duk_uint8_t *) (buf + offset); + do { + i += i_step; + DUK_ASSERT(i >= 0 && i < field_bytelen); + p[i] = (duk_uint8_t) (tmp & 0xff); + tmp = tmp >> 8; /* unnecessary shift for last byte */ + } while (i != i_end); +#else + tmp = duk_to_number(ctx, 0); + p = (duk_uint8_t *) (buf + offset); + do { + i += i_step; + tmp = DUK_FLOOR(tmp); + DUK_ASSERT(i >= 0 && i < field_bytelen); + p[i] = (duk_uint8_t) (DUK_FMOD(tmp, 256.0)); + tmp = tmp / 256.0; /* unnecessary div for last byte */ + } while (i != i_end); +#endif + break; + } + default: { /* should never happen but default here */ + goto fail_bounds; + } + } + + /* Node.js Buffer: return offset + #bytes written (i.e. next + * write offset). + */ + if (magic_typedarray) { + /* For TypedArrays 'undefined' return value is specified + * by ES6 (matches V8). + */ + return 0; + } + duk_push_uint(ctx, offset + nbytes); + return 1; + + fail_field_length: + fail_bounds: + if (no_assert) { + /* Node.js return value for failed writes is offset + #bytes + * that would have been written. + */ + /* XXX: for negative input offsets, 'offset' will be a large + * positive value so the result here is confusing. + */ + if (magic_typedarray) { + return 0; + } + duk_push_uint(ctx, offset + nbytes); + return 1; + } + return DUK_RET_RANGE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_writefield(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#undef DUK__FLD_8BIT +#undef DUK__FLD_16BIT +#undef DUK__FLD_32BIT +#undef DUK__FLD_FLOAT +#undef DUK__FLD_DOUBLE +#undef DUK__FLD_VARINT +#undef DUK__FLD_BIGENDIAN +#undef DUK__FLD_SIGNED +#undef DUK__FLD_TYPEDARRAY +#line 1 "duk_bi_date.c" +/* + * Date built-ins + * + * Unlike most built-ins, Date has some platform dependencies for getting + * UTC time, converting between UTC and local time, and parsing and + * formatting time values. These are all abstracted behind DUK_USE_xxx + * config options. There are built-in platform specific providers for + * POSIX and Windows, but external providers can also be used. + * + * See doc/datetime.rst. + * + */ + +/* include removed: duk_internal.h */ + +/* + * Forward declarations + */ + +DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval_tzoffset(duk_context *ctx, duk_small_uint_t flags, duk_int_t *out_tzoffset); +DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval(duk_context *ctx, duk_small_uint_t flags); +DUK_LOCAL_DECL void duk__twodigit_year_fixup(duk_context *ctx, duk_idx_t idx_val); +DUK_LOCAL_DECL duk_ret_t duk__set_this_timeval_from_dparts(duk_context *ctx, duk_double_t *dparts, duk_small_uint_t flags); + +/* + * Other file level defines + */ + +/* Debug macro to print all parts and dparts (used manually because of debug level). */ +#define DUK__DPRINT_PARTS_AND_DPARTS(parts,dparts) do { \ + DUK_D(DUK_DPRINT("parts: %ld %ld %ld %ld %ld %ld %ld %ld, dparts: %lf %lf %lf %lf %lf %lf %lf %lf", \ + (long) (parts)[0], (long) (parts)[1], \ + (long) (parts)[2], (long) (parts)[3], \ + (long) (parts)[4], (long) (parts)[5], \ + (long) (parts)[6], (long) (parts)[7], \ + (double) (dparts)[0], (double) (dparts)[1], \ + (double) (dparts)[2], (double) (dparts)[3], \ + (double) (dparts)[4], (double) (dparts)[5], \ + (double) (dparts)[6], (double) (dparts)[7])); \ + } while (0) +#define DUK__DPRINT_PARTS(parts) do { \ + DUK_D(DUK_DPRINT("parts: %ld %ld %ld %ld %ld %ld %ld %ld", \ + (long) (parts)[0], (long) (parts)[1], \ + (long) (parts)[2], (long) (parts)[3], \ + (long) (parts)[4], (long) (parts)[5], \ + (long) (parts)[6], (long) (parts)[7])); \ + } while (0) +#define DUK__DPRINT_DPARTS(dparts) do { \ + DUK_D(DUK_DPRINT("dparts: %lf %lf %lf %lf %lf %lf %lf %lf", \ + (double) (dparts)[0], (double) (dparts)[1], \ + (double) (dparts)[2], (double) (dparts)[3], \ + (double) (dparts)[4], (double) (dparts)[5], \ + (double) (dparts)[6], (double) (dparts)[7])); \ + } while (0) + +/* Equivalent year for DST calculations outside [1970,2038[ range, see + * E5 Section 15.9.1.8. Equivalent year has the same leap-year-ness and + * starts with the same weekday on Jan 1. + * https://bugzilla.mozilla.org/show_bug.cgi?id=351066 + */ +#define DUK__YEAR(x) ((duk_uint8_t) ((x) - 1970)) +DUK_LOCAL duk_uint8_t duk__date_equivyear[14] = { +#if 1 + /* This is based on V8 EquivalentYear() algorithm (see src/genequivyear.py): + * http://code.google.com/p/v8/source/browse/trunk/src/date.h#146 + */ + + /* non-leap year: sunday, monday, ... */ + DUK__YEAR(2023), DUK__YEAR(2035), DUK__YEAR(2019), DUK__YEAR(2031), + DUK__YEAR(2015), DUK__YEAR(2027), DUK__YEAR(2011), + + /* leap year: sunday, monday, ... */ + DUK__YEAR(2012), DUK__YEAR(2024), DUK__YEAR(2008), DUK__YEAR(2020), + DUK__YEAR(2032), DUK__YEAR(2016), DUK__YEAR(2028) +#endif + +#if 0 + /* This is based on Rhino EquivalentYear() algorithm: + * https://github.com/mozilla/rhino/blob/f99cc11d616f0cdda2c42bde72b3484df6182947/src/org/mozilla/javascript/NativeDate.java + */ + + /* non-leap year: sunday, monday, ... */ + DUK__YEAR(1978), DUK__YEAR(1973), DUK__YEAR(1985), DUK__YEAR(1986), + DUK__YEAR(1981), DUK__YEAR(1971), DUK__YEAR(1977), + + /* leap year: sunday, monday, ... */ + DUK__YEAR(1984), DUK__YEAR(1996), DUK__YEAR(1980), DUK__YEAR(1992), + DUK__YEAR(1976), DUK__YEAR(1988), DUK__YEAR(1972) +#endif +}; +#undef DUK__YEAR + +/* + * ISO 8601 subset parser. + */ + +/* Parser part count. */ +#define DUK__NUM_ISO8601_PARSER_PARTS 9 + +/* Parser part indices. */ +#define DUK__PI_YEAR 0 +#define DUK__PI_MONTH 1 +#define DUK__PI_DAY 2 +#define DUK__PI_HOUR 3 +#define DUK__PI_MINUTE 4 +#define DUK__PI_SECOND 5 +#define DUK__PI_MILLISECOND 6 +#define DUK__PI_TZHOUR 7 +#define DUK__PI_TZMINUTE 8 + +/* Parser part masks. */ +#define DUK__PM_YEAR (1 << DUK__PI_YEAR) +#define DUK__PM_MONTH (1 << DUK__PI_MONTH) +#define DUK__PM_DAY (1 << DUK__PI_DAY) +#define DUK__PM_HOUR (1 << DUK__PI_HOUR) +#define DUK__PM_MINUTE (1 << DUK__PI_MINUTE) +#define DUK__PM_SECOND (1 << DUK__PI_SECOND) +#define DUK__PM_MILLISECOND (1 << DUK__PI_MILLISECOND) +#define DUK__PM_TZHOUR (1 << DUK__PI_TZHOUR) +#define DUK__PM_TZMINUTE (1 << DUK__PI_TZMINUTE) + +/* Parser separator indices. */ +#define DUK__SI_PLUS 0 +#define DUK__SI_MINUS 1 +#define DUK__SI_T 2 +#define DUK__SI_SPACE 3 +#define DUK__SI_COLON 4 +#define DUK__SI_PERIOD 5 +#define DUK__SI_Z 6 +#define DUK__SI_NUL 7 + +/* Parser separator masks. */ +#define DUK__SM_PLUS (1 << DUK__SI_PLUS) +#define DUK__SM_MINUS (1 << DUK__SI_MINUS) +#define DUK__SM_T (1 << DUK__SI_T) +#define DUK__SM_SPACE (1 << DUK__SI_SPACE) +#define DUK__SM_COLON (1 << DUK__SI_COLON) +#define DUK__SM_PERIOD (1 << DUK__SI_PERIOD) +#define DUK__SM_Z (1 << DUK__SI_Z) +#define DUK__SM_NUL (1 << DUK__SI_NUL) + +/* Rule control flags. */ +#define DUK__CF_NEG (1 << 0) /* continue matching, set neg_tzoffset flag */ +#define DUK__CF_ACCEPT (1 << 1) /* accept string */ +#define DUK__CF_ACCEPT_NUL (1 << 2) /* accept string if next char is NUL (otherwise reject) */ + +#define DUK__PACK_RULE(partmask,sepmask,nextpart,flags) \ + ((duk_uint32_t) (partmask) + \ + (((duk_uint32_t) (sepmask)) << 9) + \ + (((duk_uint32_t) (nextpart)) << 17) + \ + (((duk_uint32_t) (flags)) << 21)) + +#define DUK__UNPACK_RULE(rule,var_nextidx,var_flags) do { \ + (var_nextidx) = (duk_small_uint_t) (((rule) >> 17) & 0x0f); \ + (var_flags) = (duk_small_uint_t) ((rule) >> 21); \ + } while (0) + +#define DUK__RULE_MASK_PART_SEP 0x1ffffUL + +/* Matching separator index is used in the control table */ +DUK_LOCAL const duk_uint8_t duk__parse_iso8601_seps[] = { + DUK_ASC_PLUS /*0*/, DUK_ASC_MINUS /*1*/, DUK_ASC_UC_T /*2*/, DUK_ASC_SPACE /*3*/, + DUK_ASC_COLON /*4*/, DUK_ASC_PERIOD /*5*/, DUK_ASC_UC_Z /*6*/, DUK_ASC_NUL /*7*/ +}; + +/* Rule table: first matching rule is used to determine what to do next. */ +DUK_LOCAL const duk_uint32_t duk__parse_iso8601_control[] = { + DUK__PACK_RULE(DUK__PM_YEAR, DUK__SM_MINUS, DUK__PI_MONTH, 0), + DUK__PACK_RULE(DUK__PM_MONTH, DUK__SM_MINUS, DUK__PI_DAY, 0), + DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY, DUK__SM_T | DUK__SM_SPACE, DUK__PI_HOUR, 0), + DUK__PACK_RULE(DUK__PM_HOUR, DUK__SM_COLON, DUK__PI_MINUTE, 0), + DUK__PACK_RULE(DUK__PM_MINUTE, DUK__SM_COLON, DUK__PI_SECOND, 0), + DUK__PACK_RULE(DUK__PM_SECOND, DUK__SM_PERIOD, DUK__PI_MILLISECOND, 0), + DUK__PACK_RULE(DUK__PM_TZHOUR, DUK__SM_COLON, DUK__PI_TZMINUTE, 0), + DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY | DUK__PM_HOUR /*Note1*/ | DUK__PM_MINUTE | DUK__PM_SECOND | DUK__PM_MILLISECOND, DUK__SM_PLUS, DUK__PI_TZHOUR, 0), + DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY | DUK__PM_HOUR /*Note1*/ | DUK__PM_MINUTE | DUK__PM_SECOND | DUK__PM_MILLISECOND, DUK__SM_MINUS, DUK__PI_TZHOUR, DUK__CF_NEG), + DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY | DUK__PM_HOUR /*Note1*/ | DUK__PM_MINUTE | DUK__PM_SECOND | DUK__PM_MILLISECOND, DUK__SM_Z, 0, DUK__CF_ACCEPT_NUL), + DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY | DUK__PM_HOUR /*Note1*/ | DUK__PM_MINUTE | DUK__PM_SECOND | DUK__PM_MILLISECOND | DUK__PM_TZHOUR /*Note2*/ | DUK__PM_TZMINUTE, DUK__SM_NUL, 0, DUK__CF_ACCEPT) + + /* Note1: the specification doesn't require matching a time form with + * just hours ("HH"), but we accept it here, e.g. "2012-01-02T12Z". + * + * Note2: the specification doesn't require matching a timezone offset + * with just hours ("HH"), but accept it here, e.g. "2012-01-02T03:04:05+02" + */ +}; + +DUK_LOCAL duk_bool_t duk__parse_string_iso8601_subset(duk_context *ctx, const char *str) { + duk_int_t parts[DUK__NUM_ISO8601_PARSER_PARTS]; + duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS]; + duk_double_t d; + const duk_uint8_t *p; + duk_small_uint_t part_idx = 0; + duk_int_t accum = 0; + duk_small_uint_t ndigits = 0; + duk_bool_t neg_year = 0; + duk_bool_t neg_tzoffset = 0; + duk_uint_fast8_t ch; + duk_small_uint_t i; + + /* During parsing, month and day are one-based; set defaults here. */ + DUK_MEMZERO(parts, sizeof(parts)); + DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] == 0); /* don't care value, year is mandatory */ + parts[DUK_DATE_IDX_MONTH] = 1; + parts[DUK_DATE_IDX_DAY] = 1; + + /* Special handling for year sign. */ + p = (const duk_uint8_t *) str; + ch = p[0]; + if (ch == DUK_ASC_PLUS) { + p++; + } else if (ch == DUK_ASC_MINUS) { + neg_year = 1; + p++; + } + + for (;;) { + ch = *p++; + DUK_DDD(DUK_DDDPRINT("parsing, part_idx=%ld, char=%ld ('%c')", + (long) part_idx, (long) ch, + (int) ((ch >= 0x20 && ch <= 0x7e) ? ch : DUK_ASC_QUESTION))); + + if (ch >= DUK_ASC_0 && ch <= DUK_ASC_9) { + if (ndigits >= 9) { + DUK_DDD(DUK_DDDPRINT("too many digits -> reject")); + goto reject; + } + if (part_idx == DUK__PI_MILLISECOND /*msec*/ && ndigits >= 3) { + /* ignore millisecond fractions after 3 */ + } else { + accum = accum * 10 + ((duk_int_t) ch) - ((duk_int_t) DUK_ASC_0) + 0x00; + ndigits++; + } + } else { + duk_uint_fast32_t match_val; + duk_small_int_t sep_idx; + + if (ndigits <= 0) { + goto reject; + } + if (part_idx == DUK__PI_MILLISECOND) { + /* complete the millisecond field */ + while (ndigits < 3) { + accum *= 10; + ndigits++; + } + } + parts[part_idx] = accum; + DUK_DDD(DUK_DDDPRINT("wrote part %ld -> value %ld", (long) part_idx, (long) accum)); + + accum = 0; + ndigits = 0; + + for (i = 0; i < (duk_small_uint_t) (sizeof(duk__parse_iso8601_seps) / sizeof(duk_uint8_t)); i++) { + if (duk__parse_iso8601_seps[i] == ch) { + break; + } + } + if (i == (duk_small_uint_t) (sizeof(duk__parse_iso8601_seps) / sizeof(duk_uint8_t))) { + DUK_DDD(DUK_DDDPRINT("separator character doesn't match -> reject")); + goto reject; + } + + sep_idx = i; + match_val = (1UL << part_idx) + (1UL << (sep_idx + 9)); /* match against rule part/sep bits */ + + for (i = 0; i < (duk_small_uint_t) (sizeof(duk__parse_iso8601_control) / sizeof(duk_uint32_t)); i++) { + duk_uint_fast32_t rule = duk__parse_iso8601_control[i]; + duk_small_uint_t nextpart; + duk_small_uint_t cflags; + + DUK_DDD(DUK_DDDPRINT("part_idx=%ld, sep_idx=%ld, match_val=0x%08lx, considering rule=0x%08lx", + (long) part_idx, (long) sep_idx, + (unsigned long) match_val, (unsigned long) rule)); + + if ((rule & match_val) != match_val) { + continue; + } + + DUK__UNPACK_RULE(rule, nextpart, cflags); + + DUK_DDD(DUK_DDDPRINT("rule match -> part_idx=%ld, sep_idx=%ld, match_val=0x%08lx, " + "rule=0x%08lx -> nextpart=%ld, cflags=0x%02lx", + (long) part_idx, (long) sep_idx, + (unsigned long) match_val, (unsigned long) rule, + (long) nextpart, (unsigned long) cflags)); + + if (cflags & DUK__CF_NEG) { + neg_tzoffset = 1; + } + + if (cflags & DUK__CF_ACCEPT) { + goto accept; + } + + if (cflags & DUK__CF_ACCEPT_NUL) { + DUK_ASSERT(*(p - 1) != (char) 0); + if (*p == DUK_ASC_NUL) { + goto accept; + } + goto reject; + } + + part_idx = nextpart; + break; + } /* rule match */ + + if (i == (duk_small_uint_t) (sizeof(duk__parse_iso8601_control) / sizeof(duk_uint32_t))) { + DUK_DDD(DUK_DDDPRINT("no rule matches -> reject")); + goto reject; + } + + if (ch == 0) { + /* This shouldn't be necessary, but check just in case + * to avoid any chance of overruns. + */ + DUK_DDD(DUK_DDDPRINT("NUL after rule matching (should not happen) -> reject")); + goto reject; + } + } /* if-digit-else-ctrl */ + } /* char loop */ + + /* We should never exit the loop above, but if we do, reject + * by falling through. + */ + DUK_DDD(DUK_DDDPRINT("fell out of char loop without explicit accept/reject -> reject")); + + reject: + DUK_DDD(DUK_DDDPRINT("reject")); + return 0; + + accept: + DUK_DDD(DUK_DDDPRINT("accept")); + + /* Apply timezone offset to get the main parts in UTC */ + if (neg_year) { + parts[DUK__PI_YEAR] = -parts[DUK__PI_YEAR]; + } + if (neg_tzoffset) { + parts[DUK__PI_HOUR] += parts[DUK__PI_TZHOUR]; + parts[DUK__PI_MINUTE] += parts[DUK__PI_TZMINUTE]; + } else { + parts[DUK__PI_HOUR] -= parts[DUK__PI_TZHOUR]; + parts[DUK__PI_MINUTE] -= parts[DUK__PI_TZMINUTE]; + } + parts[DUK__PI_MONTH] -= 1; /* zero-based month */ + parts[DUK__PI_DAY] -= 1; /* zero-based day */ + + /* Use double parts, they tolerate unnormalized time. + * + * Note: DUK_DATE_IDX_WEEKDAY is initialized with a bogus value (DUK__PI_TZHOUR) + * on purpose. It won't be actually used by duk_bi_date_get_timeval_from_dparts(), + * but will make the value initialized just in case, and avoid any + * potential for Valgrind issues. + */ + for (i = 0; i < DUK_DATE_IDX_NUM_PARTS; i++) { + DUK_DDD(DUK_DDDPRINT("part[%ld] = %ld", (long) i, (long) parts[i])); + dparts[i] = parts[i]; + } + + d = duk_bi_date_get_timeval_from_dparts(dparts, 0 /*flags*/); + duk_push_number(ctx, d); + return 1; +} + +/* + * Date/time parsing helper. + * + * Parse a datetime string into a time value. We must first try to parse + * the input according to the standard format in E5.1 Section 15.9.1.15. + * If that fails, we can try to parse using custom parsing, which can + * either be platform neutral (custom code) or platform specific (using + * existing platform API calls). + * + * Note in particular that we must parse whatever toString(), toUTCString(), + * and toISOString() can produce; see E5.1 Section 15.9.4.2. + * + * Returns 1 to allow tail calling. + * + * There is much room for improvement here with respect to supporting + * alternative datetime formats. For instance, V8 parses '2012-01-01' as + * UTC and '2012/01/01' as local time. + */ + +DUK_LOCAL duk_ret_t duk__parse_string(duk_context *ctx, const char *str) { + /* XXX: there is a small risk here: because the ISO 8601 parser is + * very loose, it may end up parsing some datetime values which + * would be better parsed with a platform specific parser. + */ + + DUK_ASSERT(str != NULL); + DUK_DDD(DUK_DDDPRINT("parse datetime from string '%s'", (const char *) str)); + + if (duk__parse_string_iso8601_subset(ctx, str) != 0) { + return 1; + } + +#if defined(DUK_USE_DATE_PARSE_STRING) + /* Contract, either: + * - Push value on stack and return 1 + * - Don't push anything on stack and return 0 + */ + + if (DUK_USE_DATE_PARSE_STRING(ctx, str) != 0) { + return 1; + } +#else + /* No platform-specific parsing, this is not an error. */ +#endif + + duk_push_nan(ctx); + return 1; +} + +/* + * Calendar helpers + * + * Some helpers are used for getters and can operate on normalized values + * which can be represented with 32-bit signed integers. Other helpers are + * needed by setters and operate on un-normalized double values, must watch + * out for non-finite numbers etc. + */ + +DUK_LOCAL duk_uint8_t duk__days_in_month[12] = { + (duk_uint8_t) 31, (duk_uint8_t) 28, (duk_uint8_t) 31, (duk_uint8_t) 30, + (duk_uint8_t) 31, (duk_uint8_t) 30, (duk_uint8_t) 31, (duk_uint8_t) 31, + (duk_uint8_t) 30, (duk_uint8_t) 31, (duk_uint8_t) 30, (duk_uint8_t) 31 +}; + +/* Maximum iteration count for computing UTC-to-local time offset when + * creating an Ecmascript time value from local parts. + */ +#define DUK__LOCAL_TZOFFSET_MAXITER 4 + +/* Because 'day since epoch' can be negative and is used to compute weekday + * using a modulo operation, add this multiple of 7 to avoid negative values + * when year is below 1970 epoch. Ecmascript time values are restricted to + * +/- 100 million days from epoch, so this adder fits nicely into 32 bits. + * Round to a multiple of 7 (= floor(100000000 / 7) * 7) and add margin. + */ +#define DUK__WEEKDAY_MOD_ADDER (20000000 * 7) /* 0x08583b00 */ + +DUK_INTERNAL duk_bool_t duk_bi_date_is_leap_year(duk_int_t year) { + if ((year % 4) != 0) { + return 0; + } + if ((year % 100) != 0) { + return 1; + } + if ((year % 400) != 0) { + return 0; + } + return 1; +} + +DUK_INTERNAL duk_bool_t duk_bi_date_timeval_in_valid_range(duk_double_t x) { + return (x >= -DUK_DATE_MSEC_100M_DAYS && x <= DUK_DATE_MSEC_100M_DAYS); +} + +DUK_INTERNAL duk_bool_t duk_bi_date_timeval_in_leeway_range(duk_double_t x) { + return (x >= -DUK_DATE_MSEC_100M_DAYS_LEEWAY && x <= DUK_DATE_MSEC_100M_DAYS_LEEWAY); +} + +DUK_INTERNAL duk_bool_t duk_bi_date_year_in_valid_range(duk_double_t x) { + return (x >= DUK_DATE_MIN_ECMA_YEAR && x <= DUK_DATE_MAX_ECMA_YEAR); +} + +DUK_LOCAL duk_double_t duk__timeclip(duk_double_t x) { + if (!DUK_ISFINITE(x)) { + return DUK_DOUBLE_NAN; + } + + if (!duk_bi_date_timeval_in_valid_range(x)) { + return DUK_DOUBLE_NAN; + } + + x = duk_js_tointeger_number(x); + + /* Here we'd have the option to normalize -0 to +0. */ + return x; +} + +/* Integer division which floors also negative values correctly. */ +DUK_LOCAL duk_int_t duk__div_floor(duk_int_t a, duk_int_t b) { + DUK_ASSERT(b > 0); + if (a >= 0) { + return a / b; + } else { + /* e.g. a = -4, b = 5 --> -4 - 5 + 1 / 5 --> -8 / 5 --> -1 + * a = -5, b = 5 --> -5 - 5 + 1 / 5 --> -9 / 5 --> -1 + * a = -6, b = 5 --> -6 - 5 + 1 / 5 --> -10 / 5 --> -2 + */ + return (a - b + 1) / b; + } +} + +/* Compute day number of the first day of a given year. */ +DUK_LOCAL duk_int_t duk__day_from_year(duk_int_t year) { + /* Note: in integer arithmetic, (x / 4) is same as floor(x / 4) for non-negative + * values, but is incorrect for negative ones. + */ + return 365 * (year - 1970) + + duk__div_floor(year - 1969, 4) + - duk__div_floor(year - 1901, 100) + + duk__div_floor(year - 1601, 400); +} + +/* Given a day number, determine year and day-within-year. */ +DUK_LOCAL duk_int_t duk__year_from_day(duk_int_t day, duk_small_int_t *out_day_within_year) { + duk_int_t year; + duk_int_t diff_days; + + /* estimate year upwards (towards positive infinity), then back down; + * two iterations should be enough + */ + + if (day >= 0) { + year = 1970 + day / 365; + } else { + year = 1970 + day / 366; + } + + for (;;) { + diff_days = duk__day_from_year(year) - day; + DUK_DDD(DUK_DDDPRINT("year=%ld day=%ld, diff_days=%ld", (long) year, (long) day, (long) diff_days)); + if (diff_days <= 0) { + DUK_ASSERT(-diff_days < 366); /* fits into duk_small_int_t */ + *out_day_within_year = -diff_days; + DUK_DDD(DUK_DDDPRINT("--> year=%ld, day-within-year=%ld", + (long) year, (long) *out_day_within_year)); + DUK_ASSERT(*out_day_within_year >= 0); + DUK_ASSERT(*out_day_within_year < (duk_bi_date_is_leap_year(year) ? 366 : 365)); + return year; + } + + /* Note: this is very tricky; we must never 'overshoot' the + * correction downwards. + */ + year -= 1 + (diff_days - 1) / 366; /* conservative */ + } +} + +/* Given a (year, month, day-within-month) triple, compute day number. + * The input triple is un-normalized and may contain non-finite values. + */ +DUK_LOCAL duk_double_t duk__make_day(duk_double_t year, duk_double_t month, duk_double_t day) { + duk_int_t day_num; + duk_bool_t is_leap; + duk_small_int_t i, n; + + /* Assume that year, month, day are all coerced to whole numbers. + * They may also be NaN or infinity, in which case this function + * must return NaN or infinity to ensure time value becomes NaN. + * If 'day' is NaN, the final return will end up returning a NaN, + * so it doesn't need to be checked here. + */ + + if (!DUK_ISFINITE(year) || !DUK_ISFINITE(month)) { + return DUK_DOUBLE_NAN; + } + + year += DUK_FLOOR(month / 12.0); + + month = DUK_FMOD(month, 12.0); + if (month < 0.0) { + /* handle negative values */ + month += 12.0; + } + + /* The algorithm in E5.1 Section 15.9.1.12 normalizes month, but + * does not normalize the day-of-month (nor check whether or not + * it is finite) because it's not necessary for finding the day + * number which matches the (year,month) pair. + * + * We assume that duk__day_from_year() is exact here. + * + * Without an explicit infinity / NaN check in the beginning, + * day_num would be a bogus integer here. + * + * It's possible for 'year' to be out of integer range here. + * If so, we need to return NaN without integer overflow. + * This fixes test-bug-setyear-overflow.js. + */ + + if (!duk_bi_date_year_in_valid_range(year)) { + DUK_DD(DUK_DDPRINT("year not in ecmascript valid range, avoid integer overflow: %lf", (double) year)); + return DUK_DOUBLE_NAN; + } + day_num = duk__day_from_year((duk_int_t) year); + is_leap = duk_bi_date_is_leap_year((duk_int_t) year); + + n = (duk_small_int_t) month; + for (i = 0; i < n; i++) { + day_num += duk__days_in_month[i]; + if (i == 1 && is_leap) { + day_num++; + } + } + + /* If 'day' is NaN, returns NaN. */ + return (duk_double_t) day_num + day; +} + +/* Split time value into parts. The time value is assumed to be an internal + * one, i.e. finite, no fractions. Possible local time adjustment has already + * been applied when reading the time value. + */ +DUK_INTERNAL void duk_bi_date_timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags) { + duk_double_t d1, d2; + duk_int_t t1, t2; + duk_int_t day_since_epoch; + duk_int_t year; /* does not fit into 16 bits */ + duk_small_int_t day_in_year; + duk_small_int_t month; + duk_small_int_t day; + duk_small_int_t dim; + duk_int_t jan1_since_epoch; + duk_small_int_t jan1_weekday; + duk_int_t equiv_year; + duk_small_uint_t i; + duk_bool_t is_leap; + duk_small_int_t arridx; + + DUK_ASSERT(DUK_ISFINITE(d)); /* caller checks */ + DUK_ASSERT(DUK_FLOOR(d) == d); /* no fractions in internal time */ + + /* The timevalue must be in valid Ecmascript range, but since a local + * time offset can be applied, we need to allow a +/- 24h leeway to + * the value. In other words, although the UTC time is within the + * Ecmascript range, the local part values can be just outside of it. + */ + DUK_UNREF(duk_bi_date_timeval_in_leeway_range); + DUK_ASSERT(duk_bi_date_timeval_in_leeway_range(d)); + + /* these computations are guaranteed to be exact for the valid + * E5 time value range, assuming milliseconds without fractions. + */ + d1 = (duk_double_t) DUK_FMOD(d, (double) DUK_DATE_MSEC_DAY); + if (d1 < 0.0) { + /* deal with negative values */ + d1 += (duk_double_t) DUK_DATE_MSEC_DAY; + } + d2 = DUK_FLOOR((double) (d / (duk_double_t) DUK_DATE_MSEC_DAY)); + DUK_ASSERT(d2 * ((duk_double_t) DUK_DATE_MSEC_DAY) + d1 == d); + /* now expected to fit into a 32-bit integer */ + t1 = (duk_int_t) d1; + t2 = (duk_int_t) d2; + day_since_epoch = t2; + DUK_ASSERT((duk_double_t) t1 == d1); + DUK_ASSERT((duk_double_t) t2 == d2); + + /* t1 = milliseconds within day (fits 32 bit) + * t2 = day number from epoch (fits 32 bit, may be negative) + */ + + parts[DUK_DATE_IDX_MILLISECOND] = t1 % 1000; t1 /= 1000; + parts[DUK_DATE_IDX_SECOND] = t1 % 60; t1 /= 60; + parts[DUK_DATE_IDX_MINUTE] = t1 % 60; t1 /= 60; + parts[DUK_DATE_IDX_HOUR] = t1; + DUK_ASSERT(parts[DUK_DATE_IDX_MILLISECOND] >= 0 && parts[DUK_DATE_IDX_MILLISECOND] <= 999); + DUK_ASSERT(parts[DUK_DATE_IDX_SECOND] >= 0 && parts[DUK_DATE_IDX_SECOND] <= 59); + DUK_ASSERT(parts[DUK_DATE_IDX_MINUTE] >= 0 && parts[DUK_DATE_IDX_MINUTE] <= 59); + DUK_ASSERT(parts[DUK_DATE_IDX_HOUR] >= 0 && parts[DUK_DATE_IDX_HOUR] <= 23); + + DUK_DDD(DUK_DDDPRINT("d=%lf, d1=%lf, d2=%lf, t1=%ld, t2=%ld, parts: hour=%ld min=%ld sec=%ld msec=%ld", + (double) d, (double) d1, (double) d2, (long) t1, (long) t2, + (long) parts[DUK_DATE_IDX_HOUR], + (long) parts[DUK_DATE_IDX_MINUTE], + (long) parts[DUK_DATE_IDX_SECOND], + (long) parts[DUK_DATE_IDX_MILLISECOND])); + + /* This assert depends on the input parts representing time inside + * the Ecmascript range. + */ + DUK_ASSERT(t2 + DUK__WEEKDAY_MOD_ADDER >= 0); + parts[DUK_DATE_IDX_WEEKDAY] = (t2 + 4 + DUK__WEEKDAY_MOD_ADDER) % 7; /* E5.1 Section 15.9.1.6 */ + DUK_ASSERT(parts[DUK_DATE_IDX_WEEKDAY] >= 0 && parts[DUK_DATE_IDX_WEEKDAY] <= 6); + + year = duk__year_from_day(t2, &day_in_year); + day = day_in_year; + is_leap = duk_bi_date_is_leap_year(year); + for (month = 0; month < 12; month++) { + dim = duk__days_in_month[month]; + if (month == 1 && is_leap) { + dim++; + } + DUK_DDD(DUK_DDDPRINT("month=%ld, dim=%ld, day=%ld", + (long) month, (long) dim, (long) day)); + if (day < dim) { + break; + } + day -= dim; + } + DUK_DDD(DUK_DDDPRINT("final month=%ld", (long) month)); + DUK_ASSERT(month >= 0 && month <= 11); + DUK_ASSERT(day >= 0 && day <= 31); + + /* Equivalent year mapping, used to avoid DST trouble when platform + * may fail to provide reasonable DST answers for dates outside the + * ordinary range (e.g. 1970-2038). An equivalent year has the same + * leap-year-ness as the original year and begins on the same weekday + * (Jan 1). + * + * The year 2038 is avoided because there seem to be problems with it + * on some platforms. The year 1970 is also avoided as there were + * practical problems with it; an equivalent year is used for it too, + * which breaks some DST computations for 1970 right now, see e.g. + * test-bi-date-tzoffset-brute-fi.js. + */ + if ((flags & DUK_DATE_FLAG_EQUIVYEAR) && (year < 1971 || year > 2037)) { + DUK_ASSERT(is_leap == 0 || is_leap == 1); + + jan1_since_epoch = day_since_epoch - day_in_year; /* day number for Jan 1 since epoch */ + DUK_ASSERT(jan1_since_epoch + DUK__WEEKDAY_MOD_ADDER >= 0); + jan1_weekday = (jan1_since_epoch + 4 + DUK__WEEKDAY_MOD_ADDER) % 7; /* E5.1 Section 15.9.1.6 */ + DUK_ASSERT(jan1_weekday >= 0 && jan1_weekday <= 6); + arridx = jan1_weekday; + if (is_leap) { + arridx += 7; + } + DUK_ASSERT(arridx >= 0 && arridx < (duk_small_int_t) (sizeof(duk__date_equivyear) / sizeof(duk_uint8_t))); + + equiv_year = (duk_int_t) duk__date_equivyear[arridx] + 1970; + year = equiv_year; + DUK_DDD(DUK_DDDPRINT("equiv year mapping, year=%ld, day_in_year=%ld, day_since_epoch=%ld, " + "jan1_since_epoch=%ld, jan1_weekday=%ld -> equiv year %ld", + (long) year, (long) day_in_year, (long) day_since_epoch, + (long) jan1_since_epoch, (long) jan1_weekday, (long) equiv_year)); + } + + parts[DUK_DATE_IDX_YEAR] = year; + parts[DUK_DATE_IDX_MONTH] = month; + parts[DUK_DATE_IDX_DAY] = day; + + if (flags & DUK_DATE_FLAG_ONEBASED) { + parts[DUK_DATE_IDX_MONTH]++; /* zero-based -> one-based */ + parts[DUK_DATE_IDX_DAY]++; /* -""- */ + } + + if (dparts != NULL) { + for (i = 0; i < DUK_DATE_IDX_NUM_PARTS; i++) { + dparts[i] = (duk_double_t) parts[i]; + } + } +} + +/* Compute time value from (double) parts. The parts can be either UTC + * or local time; if local, they need to be (conceptually) converted into + * UTC time. The parts may represent valid or invalid time, and may be + * wildly out of range (but may cancel each other and still come out in + * the valid Date range). + */ +DUK_INTERNAL duk_double_t duk_bi_date_get_timeval_from_dparts(duk_double_t *dparts, duk_small_uint_t flags) { +#if defined(DUK_USE_PARANOID_DATE_COMPUTATION) + /* See comments below on MakeTime why these are volatile. */ + volatile duk_double_t tmp_time; + volatile duk_double_t tmp_day; + volatile duk_double_t d; +#else + duk_double_t tmp_time; + duk_double_t tmp_day; + duk_double_t d; +#endif + duk_small_uint_t i; + duk_int_t tzoff, tzoffprev1, tzoffprev2; + + /* Expects 'this' at top of stack on entry. */ + + /* Coerce all finite parts with ToInteger(). ToInteger() must not + * be called for NaN/Infinity because it will convert e.g. NaN to + * zero. If ToInteger() has already been called, this has no side + * effects and is idempotent. + * + * Don't read dparts[DUK_DATE_IDX_WEEKDAY]; it will cause Valgrind + * issues if the value is uninitialized. + */ + for (i = 0; i <= DUK_DATE_IDX_MILLISECOND; i++) { + /* SCANBUILD: scan-build complains here about assigned value + * being garbage or undefined. This is correct but operating + * on undefined values has no ill effect and is ignored by the + * caller in the case where this happens. + */ + d = dparts[i]; + if (DUK_ISFINITE(d)) { + dparts[i] = duk_js_tointeger_number(d); + } + } + + /* Use explicit steps in computation to try to ensure that + * computation happens with intermediate results coerced to + * double values (instead of using something more accurate). + * E.g. E5.1 Section 15.9.1.11 requires use of IEEE 754 + * rules (= Ecmascript '+' and '*' operators). + * + * Without 'volatile' even this approach fails on some platform + * and compiler combinations. For instance, gcc 4.8.1 on Ubuntu + * 64-bit, with -m32 and without -std=c99, test-bi-date-canceling.js + * would fail because of some optimizations when computing tmp_time + * (MakeTime below). Adding 'volatile' to tmp_time solved this + * particular problem (annoyingly, also adding debug prints or + * running the executable under valgrind hides it). + */ + + /* MakeTime */ + tmp_time = 0.0; + tmp_time += dparts[DUK_DATE_IDX_HOUR] * ((duk_double_t) DUK_DATE_MSEC_HOUR); + tmp_time += dparts[DUK_DATE_IDX_MINUTE] * ((duk_double_t) DUK_DATE_MSEC_MINUTE); + tmp_time += dparts[DUK_DATE_IDX_SECOND] * ((duk_double_t) DUK_DATE_MSEC_SECOND); + tmp_time += dparts[DUK_DATE_IDX_MILLISECOND]; + + /* MakeDay */ + tmp_day = duk__make_day(dparts[DUK_DATE_IDX_YEAR], dparts[DUK_DATE_IDX_MONTH], dparts[DUK_DATE_IDX_DAY]); + + /* MakeDate */ + d = tmp_day * ((duk_double_t) DUK_DATE_MSEC_DAY) + tmp_time; + + DUK_DDD(DUK_DDDPRINT("time=%lf day=%lf --> timeval=%lf", + (double) tmp_time, (double) tmp_day, (double) d)); + + /* Optional UTC conversion. */ + if (flags & DUK_DATE_FLAG_LOCALTIME) { + /* DUK_USE_DATE_GET_LOCAL_TZOFFSET() needs to be called with a + * time value computed from UTC parts. At this point we only + * have 'd' which is a time value computed from local parts, so + * it is off by the UTC-to-local time offset which we don't know + * yet. The current solution for computing the UTC-to-local + * time offset is to iterate a few times and detect a fixed + * point or a two-cycle loop (or a sanity iteration limit), + * see test-bi-date-local-parts.js and test-bi-date-tzoffset-basic-fi.js. + * + * E5.1 Section 15.9.1.9: + * UTC(t) = t - LocalTZA - DaylightSavingTA(t - LocalTZA) + * + * For NaN/inf, DUK_USE_DATE_GET_LOCAL_TZOFFSET() returns 0. + */ + +#if 0 + /* Old solution: don't iterate, incorrect */ + tzoff = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d); + DUK_DDD(DUK_DDDPRINT("tzoffset w/o iteration, tzoff=%ld", (long) tzoff)); + d -= tzoff * 1000L; + DUK_UNREF(tzoffprev1); + DUK_UNREF(tzoffprev2); +#endif + + /* Iteration solution */ + tzoff = 0; + tzoffprev1 = 999999999L; /* invalid value which never matches */ + for (i = 0; i < DUK__LOCAL_TZOFFSET_MAXITER; i++) { + tzoffprev2 = tzoffprev1; + tzoffprev1 = tzoff; + tzoff = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d - tzoff * 1000L); + DUK_DDD(DUK_DDDPRINT("tzoffset iteration, i=%d, tzoff=%ld, tzoffprev1=%ld tzoffprev2=%ld", + (int) i, (long) tzoff, (long) tzoffprev1, (long) tzoffprev2)); + if (tzoff == tzoffprev1) { + DUK_DDD(DUK_DDDPRINT("tzoffset iteration finished, i=%d, tzoff=%ld, tzoffprev1=%ld, tzoffprev2=%ld", + (int) i, (long) tzoff, (long) tzoffprev1, (long) tzoffprev2)); + break; + } else if (tzoff == tzoffprev2) { + /* Two value cycle, see e.g. test-bi-date-tzoffset-basic-fi.js. + * In these cases, favor a higher tzoffset to get a consistent + * result which is independent of iteration count. Not sure if + * this is a generically correct solution. + */ + DUK_DDD(DUK_DDDPRINT("tzoffset iteration two-value cycle, i=%d, tzoff=%ld, tzoffprev1=%ld, tzoffprev2=%ld", + (int) i, (long) tzoff, (long) tzoffprev1, (long) tzoffprev2)); + if (tzoffprev1 > tzoff) { + tzoff = tzoffprev1; + } + break; + } + } + DUK_DDD(DUK_DDDPRINT("tzoffset iteration, tzoff=%ld", (long) tzoff)); + d -= tzoff * 1000L; + } + + /* TimeClip(), which also handles Infinity -> NaN conversion */ + d = duk__timeclip(d); + + return d; +} + +/* + * API oriented helpers + */ + +/* Push 'this' binding, check that it is a Date object; then push the + * internal time value. At the end, stack is: [ ... this timeval ]. + * Returns the time value. Local time adjustment is done if requested. + */ +DUK_LOCAL duk_double_t duk__push_this_get_timeval_tzoffset(duk_context *ctx, duk_small_uint_t flags, duk_int_t *out_tzoffset) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h; + duk_double_t d; + duk_int_t tzoffset = 0; + + duk_push_this(ctx); + h = duk_get_hobject(ctx, -1); /* XXX: getter with class check, useful in built-ins */ + if (h == NULL || DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_DATE) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "expected Date"); + } + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE); + d = duk_to_number(ctx, -1); + duk_pop(ctx); + + if (DUK_ISNAN(d)) { + if (flags & DUK_DATE_FLAG_NAN_TO_ZERO) { + d = 0.0; + } + if (flags & DUK_DATE_FLAG_NAN_TO_RANGE_ERROR) { + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, "Invalid Date"); + } + } + /* if no NaN handling flag, may still be NaN here, but not Inf */ + DUK_ASSERT(!DUK_ISINF(d)); + + if (flags & DUK_DATE_FLAG_LOCALTIME) { + /* Note: DST adjustment is determined using UTC time. + * If 'd' is NaN, tzoffset will be 0. + */ + tzoffset = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d); /* seconds */ + d += tzoffset * 1000L; + } + if (out_tzoffset) { + *out_tzoffset = tzoffset; + } + + /* [ ... this ] */ + return d; +} + +DUK_LOCAL duk_double_t duk__push_this_get_timeval(duk_context *ctx, duk_small_uint_t flags) { + return duk__push_this_get_timeval_tzoffset(ctx, flags, NULL); +} + +/* Set timeval to 'this' from dparts, push the new time value onto the + * value stack and return 1 (caller can then tail call us). Expects + * the value stack to contain 'this' on the stack top. + */ +DUK_LOCAL duk_ret_t duk__set_this_timeval_from_dparts(duk_context *ctx, duk_double_t *dparts, duk_small_uint_t flags) { + duk_double_t d; + + /* [ ... this ] */ + + d = duk_bi_date_get_timeval_from_dparts(dparts, flags); + duk_push_number(ctx, d); /* -> [ ... this timeval_new ] */ + duk_dup_top(ctx); /* -> [ ... this timeval_new timeval_new ] */ + duk_put_prop_stridx(ctx, -3, DUK_STRIDX_INT_VALUE); + + /* stack top: new time value, return 1 to allow tail calls */ + return 1; +} + +/* 'out_buf' must be at least DUK_BI_DATE_ISO8601_BUFSIZE long. */ +DUK_LOCAL void duk__format_parts_iso8601(duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags, duk_uint8_t *out_buf) { + char yearstr[8]; /* "-123456\0" */ + char tzstr[8]; /* "+11:22\0" */ + char sep = (flags & DUK_DATE_FLAG_SEP_T) ? DUK_ASC_UC_T : DUK_ASC_SPACE; + + DUK_ASSERT(parts[DUK_DATE_IDX_MONTH] >= 1 && parts[DUK_DATE_IDX_MONTH] <= 12); + DUK_ASSERT(parts[DUK_DATE_IDX_DAY] >= 1 && parts[DUK_DATE_IDX_DAY] <= 31); + DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] >= -999999 && parts[DUK_DATE_IDX_YEAR] <= 999999); + + /* Note: %06d for positive value, %07d for negative value to include + * sign and 6 digits. + */ + DUK_SNPRINTF(yearstr, + sizeof(yearstr), + (parts[DUK_DATE_IDX_YEAR] >= 0 && parts[DUK_DATE_IDX_YEAR] <= 9999) ? "%04ld" : + ((parts[DUK_DATE_IDX_YEAR] >= 0) ? "+%06ld" : "%07ld"), + (long) parts[DUK_DATE_IDX_YEAR]); + yearstr[sizeof(yearstr) - 1] = (char) 0; + + if (flags & DUK_DATE_FLAG_LOCALTIME) { + /* tzoffset seconds are dropped; 16 bits suffice for + * time offset in minutes + */ + if (tzoffset >= 0) { + duk_small_int_t tmp = tzoffset / 60; + DUK_SNPRINTF(tzstr, sizeof(tzstr), "+%02d:%02d", (int) (tmp / 60), (int) (tmp % 60)); + } else { + duk_small_int_t tmp = -tzoffset / 60; + DUK_SNPRINTF(tzstr, sizeof(tzstr), "-%02d:%02d", (int) (tmp / 60), (int) (tmp % 60)); + } + tzstr[sizeof(tzstr) - 1] = (char) 0; + } else { + tzstr[0] = DUK_ASC_UC_Z; + tzstr[1] = (char) 0; + } + + /* Unlike year, the other parts fit into 16 bits so %d format + * is portable. + */ + if ((flags & DUK_DATE_FLAG_TOSTRING_DATE) && (flags & DUK_DATE_FLAG_TOSTRING_TIME)) { + DUK_SPRINTF((char *) out_buf, "%s-%02d-%02d%c%02d:%02d:%02d.%03d%s", + (const char *) yearstr, (int) parts[DUK_DATE_IDX_MONTH], (int) parts[DUK_DATE_IDX_DAY], (int) sep, + (int) parts[DUK_DATE_IDX_HOUR], (int) parts[DUK_DATE_IDX_MINUTE], + (int) parts[DUK_DATE_IDX_SECOND], (int) parts[DUK_DATE_IDX_MILLISECOND], (const char *) tzstr); + } else if (flags & DUK_DATE_FLAG_TOSTRING_DATE) { + DUK_SPRINTF((char *) out_buf, "%s-%02d-%02d", + (const char *) yearstr, (int) parts[DUK_DATE_IDX_MONTH], (int) parts[DUK_DATE_IDX_DAY]); + } else { + DUK_ASSERT(flags & DUK_DATE_FLAG_TOSTRING_TIME); + DUK_SPRINTF((char *) out_buf, "%02d:%02d:%02d.%03d%s", + (int) parts[DUK_DATE_IDX_HOUR], (int) parts[DUK_DATE_IDX_MINUTE], + (int) parts[DUK_DATE_IDX_SECOND], (int) parts[DUK_DATE_IDX_MILLISECOND], + (const char *) tzstr); + } +} + +/* Helper for string conversion calls: check 'this' binding, get the + * internal time value, and format date and/or time in a few formats. + * Return value allows tail calls. + */ +DUK_LOCAL duk_ret_t duk__to_string_helper(duk_context *ctx, duk_small_uint_t flags) { + duk_double_t d; + duk_int_t parts[DUK_DATE_IDX_NUM_PARTS]; + duk_int_t tzoffset; /* seconds, doesn't fit into 16 bits */ + duk_bool_t rc; + duk_uint8_t buf[DUK_BI_DATE_ISO8601_BUFSIZE]; + + DUK_UNREF(rc); /* unreferenced with some options */ + + d = duk__push_this_get_timeval_tzoffset(ctx, flags, &tzoffset); + if (DUK_ISNAN(d)) { + duk_push_hstring_stridx(ctx, DUK_STRIDX_INVALID_DATE); + return 1; + } + DUK_ASSERT(DUK_ISFINITE(d)); + + /* formatters always get one-based month/day-of-month */ + duk_bi_date_timeval_to_parts(d, parts, NULL, DUK_DATE_FLAG_ONEBASED); + DUK_ASSERT(parts[DUK_DATE_IDX_MONTH] >= 1 && parts[DUK_DATE_IDX_MONTH] <= 12); + DUK_ASSERT(parts[DUK_DATE_IDX_DAY] >= 1 && parts[DUK_DATE_IDX_DAY] <= 31); + + if (flags & DUK_DATE_FLAG_TOSTRING_LOCALE) { + /* try locale specific formatter; if it refuses to format the + * string, fall back to an ISO 8601 formatted value in local + * time. + */ +#if defined(DUK_USE_DATE_FORMAT_STRING) + /* Contract, either: + * - Push string to value stack and return 1 + * - Don't push anything and return 0 + */ + + rc = DUK_USE_DATE_FORMAT_STRING(ctx, parts, tzoffset, flags); + if (rc != 0) { + return 1; + } +#else + /* No locale specific formatter; this is OK, we fall back + * to ISO 8601. + */ +#endif + } + + /* Different calling convention than above used because the helper + * is shared. + */ + duk__format_parts_iso8601(parts, tzoffset, flags, buf); + duk_push_string(ctx, (const char *) buf); + return 1; +} + +/* Helper for component getter calls: check 'this' binding, get the + * internal time value, split it into parts (either as UTC time or + * local time), push a specified component as a return value to the + * value stack and return 1 (caller can then tail call us). + */ +DUK_LOCAL duk_ret_t duk__get_part_helper(duk_context *ctx, duk_small_uint_t flags_and_idx) { + duk_double_t d; + duk_int_t parts[DUK_DATE_IDX_NUM_PARTS]; + duk_small_uint_t idx_part = (duk_small_uint_t) (flags_and_idx >> DUK_DATE_FLAG_VALUE_SHIFT); /* unpack args */ + + DUK_ASSERT_DISABLE(idx_part >= 0); /* unsigned */ + DUK_ASSERT(idx_part < DUK_DATE_IDX_NUM_PARTS); + + d = duk__push_this_get_timeval(ctx, flags_and_idx); + if (DUK_ISNAN(d)) { + duk_push_nan(ctx); + return 1; + } + DUK_ASSERT(DUK_ISFINITE(d)); + + duk_bi_date_timeval_to_parts(d, parts, NULL, flags_and_idx); /* no need to mask idx portion */ + + /* Setter APIs detect special year numbers (0...99) and apply a +1900 + * only in certain cases. The legacy getYear() getter applies -1900 + * unconditionally. + */ + duk_push_int(ctx, (flags_and_idx & DUK_DATE_FLAG_SUB1900) ? parts[idx_part] - 1900 : parts[idx_part]); + return 1; +} + +/* Helper for component setter calls: check 'this' binding, get the + * internal time value, split it into parts (either as UTC time or + * local time), modify one or more components as specified, recompute + * the time value, set it as the internal value. Finally, push the + * new time value as a return value to the value stack and return 1 + * (caller can then tail call us). + */ +DUK_LOCAL duk_ret_t duk__set_part_helper(duk_context *ctx, duk_small_uint_t flags_and_maxnargs) { + duk_double_t d; + duk_int_t parts[DUK_DATE_IDX_NUM_PARTS]; + duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS]; + duk_idx_t nargs; + duk_small_uint_t maxnargs = (duk_small_uint_t) (flags_and_maxnargs >> DUK_DATE_FLAG_VALUE_SHIFT); /* unpack args */ + duk_small_uint_t idx_first, idx; + duk_small_uint_t i; + + nargs = duk_get_top(ctx); + d = duk__push_this_get_timeval(ctx, flags_and_maxnargs); + DUK_ASSERT(DUK_ISFINITE(d) || DUK_ISNAN(d)); + + if (DUK_ISFINITE(d)) { + duk_bi_date_timeval_to_parts(d, parts, dparts, flags_and_maxnargs); + } else { + /* NaN timevalue: we need to coerce the arguments, but + * the resulting internal timestamp needs to remain NaN. + * This works but is not pretty: parts and dparts will + * be partially uninitialized, but we only write to them. + */ + } + + /* + * Determining which datetime components to overwrite based on + * stack arguments is a bit complicated, but important to factor + * out from setters themselves for compactness. + * + * If DUK_DATE_FLAG_TIMESETTER, maxnargs indicates setter type: + * + * 1 -> millisecond + * 2 -> second, [millisecond] + * 3 -> minute, [second], [millisecond] + * 4 -> hour, [minute], [second], [millisecond] + * + * Else: + * + * 1 -> date + * 2 -> month, [date] + * 3 -> year, [month], [date] + * + * By comparing nargs and maxnargs (and flags) we know which + * components to override. We rely on part index ordering. + */ + + if (flags_and_maxnargs & DUK_DATE_FLAG_TIMESETTER) { + DUK_ASSERT(maxnargs >= 1 && maxnargs <= 4); + idx_first = DUK_DATE_IDX_MILLISECOND - (maxnargs - 1); + } else { + DUK_ASSERT(maxnargs >= 1 && maxnargs <= 3); + idx_first = DUK_DATE_IDX_DAY - (maxnargs - 1); + } + DUK_ASSERT_DISABLE(idx_first >= 0); /* unsigned */ + DUK_ASSERT(idx_first < DUK_DATE_IDX_NUM_PARTS); + + for (i = 0; i < maxnargs; i++) { + if ((duk_idx_t) i >= nargs) { + /* no argument given -> leave components untouched */ + break; + } + idx = idx_first + i; + DUK_ASSERT_DISABLE(idx >= 0); /* unsigned */ + DUK_ASSERT(idx < DUK_DATE_IDX_NUM_PARTS); + + if (idx == DUK_DATE_IDX_YEAR && (flags_and_maxnargs & DUK_DATE_FLAG_YEAR_FIXUP)) { + duk__twodigit_year_fixup(ctx, (duk_idx_t) i); + } + + dparts[idx] = duk_to_number(ctx, i); + + if (idx == DUK_DATE_IDX_DAY) { + /* Day-of-month is one-based in the API, but zero-based + * internally, so fix here. Note that month is zero-based + * both in the API and internally. + */ + /* SCANBUILD: complains about use of uninitialized values. + * The complaint is correct, but operating in undefined + * values here is intentional in some cases and the caller + * ignores the results. + */ + dparts[idx] -= 1.0; + } + } + + /* Leaves new timevalue on stack top and returns 1, which is correct + * for part setters. + */ + if (DUK_ISFINITE(d)) { + return duk__set_this_timeval_from_dparts(ctx, dparts, flags_and_maxnargs); + } else { + /* Internal timevalue is already NaN, so don't touch it. */ + duk_push_nan(ctx); + return 1; + } +} + +/* Apply ToNumber() to specified index; if ToInteger(val) in [0,99], add + * 1900 and replace value at idx_val. + */ +DUK_LOCAL void duk__twodigit_year_fixup(duk_context *ctx, duk_idx_t idx_val) { + duk_double_t d; + + /* XXX: idx_val would fit into 16 bits, but using duk_small_uint_t + * might not generate better code due to casting. + */ + + /* E5 Sections 15.9.3.1, B.2.4, B.2.5 */ + duk_to_number(ctx, idx_val); + if (duk_is_nan(ctx, idx_val)) { + return; + } + duk_dup(ctx, idx_val); + duk_to_int(ctx, -1); + d = duk_get_number(ctx, -1); /* get as double to handle huge numbers correctly */ + if (d >= 0.0 && d <= 99.0) { + d += 1900.0; + duk_push_number(ctx, d); + duk_replace(ctx, idx_val); + } + duk_pop(ctx); +} + +/* Set datetime parts from stack arguments, defaulting any missing values. + * Day-of-week is not set; it is not required when setting the time value. + */ +DUK_LOCAL void duk__set_parts_from_args(duk_context *ctx, duk_double_t *dparts, duk_idx_t nargs) { + duk_double_t d; + duk_small_uint_t i; + duk_small_uint_t idx; + + /* Causes a ToNumber() coercion, but doesn't break coercion order since + * year is coerced first anyway. + */ + duk__twodigit_year_fixup(ctx, 0); + + /* There are at most 7 args, but we use 8 here so that also + * DUK_DATE_IDX_WEEKDAY gets initialized (to zero) to avoid the potential + * for any Valgrind gripes later. + */ + for (i = 0; i < 8; i++) { + /* Note: rely on index ordering */ + idx = DUK_DATE_IDX_YEAR + i; + if ((duk_idx_t) i < nargs) { + d = duk_to_number(ctx, (duk_idx_t) i); + if (idx == DUK_DATE_IDX_DAY) { + /* Convert day from one-based to zero-based (internal). This may + * cause the day part to be negative, which is OK. + */ + d -= 1.0; + } + } else { + /* All components default to 0 except day-of-month which defaults + * to 1. However, because our internal day-of-month is zero-based, + * it also defaults to zero here. + */ + d = 0.0; + } + dparts[idx] = d; + } + + DUK_DDD(DUK_DDDPRINT("parts from args -> %lf %lf %lf %lf %lf %lf %lf %lf", + (double) dparts[0], (double) dparts[1], + (double) dparts[2], (double) dparts[3], + (double) dparts[4], (double) dparts[5], + (double) dparts[6], (double) dparts[7])); +} + +/* + * Helper to format a time value into caller buffer, used by logging. + * 'out_buf' must be at least DUK_BI_DATE_ISO8601_BUFSIZE long. + */ + +DUK_INTERNAL void duk_bi_date_format_timeval(duk_double_t timeval, duk_uint8_t *out_buf) { + duk_int_t parts[DUK_DATE_IDX_NUM_PARTS]; + + duk_bi_date_timeval_to_parts(timeval, + parts, + NULL, + DUK_DATE_FLAG_ONEBASED); + + duk__format_parts_iso8601(parts, + 0 /*tzoffset*/, + DUK_DATE_FLAG_TOSTRING_DATE | + DUK_DATE_FLAG_TOSTRING_TIME | + DUK_DATE_FLAG_SEP_T /*flags*/, + out_buf); +} + +/* + * Indirect magic value lookup for Date methods. + * + * Date methods don't put their control flags into the function magic value + * because they wouldn't fit into a LIGHTFUNC's magic field. Instead, the + * magic value is set to an index pointing to the array of control flags + * below. + * + * This must be kept in strict sync with genbuiltins.py! + */ + +static duk_uint16_t duk__date_magics[] = { + /* 0: toString */ + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_LOCALTIME, + + /* 1: toDateString */ + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_LOCALTIME, + + /* 2: toTimeString */ + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_LOCALTIME, + + /* 3: toLocaleString */ + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_TOSTRING_LOCALE + DUK_DATE_FLAG_LOCALTIME, + + /* 4: toLocaleDateString */ + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_LOCALE + DUK_DATE_FLAG_LOCALTIME, + + /* 5: toLocaleTimeString */ + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_TOSTRING_LOCALE + DUK_DATE_FLAG_LOCALTIME, + + /* 6: toUTCString */ + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME, + + /* 7: toISOString */ + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_NAN_TO_RANGE_ERROR + DUK_DATE_FLAG_SEP_T, + + /* 8: getFullYear */ + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_YEAR << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 9: getUTCFullYear */ + 0 + (DUK_DATE_IDX_YEAR << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 10: getMonth */ + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_MONTH << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 11: getUTCMonth */ + 0 + (DUK_DATE_IDX_MONTH << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 12: getDate */ + DUK_DATE_FLAG_ONEBASED + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_DAY << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 13: getUTCDate */ + DUK_DATE_FLAG_ONEBASED + (DUK_DATE_IDX_DAY << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 14: getDay */ + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_WEEKDAY << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 15: getUTCDay */ + 0 + (DUK_DATE_IDX_WEEKDAY << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 16: getHours */ + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_HOUR << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 17: getUTCHours */ + 0 + (DUK_DATE_IDX_HOUR << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 18: getMinutes */ + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_MINUTE << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 19: getUTCMinutes */ + 0 + (DUK_DATE_IDX_MINUTE << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 20: getSeconds */ + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_SECOND << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 21: getUTCSeconds */ + 0 + (DUK_DATE_IDX_SECOND << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 22: getMilliseconds */ + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_MILLISECOND << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 23: getUTCMilliseconds */ + 0 + (DUK_DATE_IDX_MILLISECOND << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 24: setMilliseconds */ + DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (1 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 25: setUTCMilliseconds */ + DUK_DATE_FLAG_TIMESETTER + (1 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 26: setSeconds */ + DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (2 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 27: setUTCSeconds */ + DUK_DATE_FLAG_TIMESETTER + (2 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 28: setMinutes */ + DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (3 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 29: setUTCMinutes */ + DUK_DATE_FLAG_TIMESETTER + (3 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 30: setHours */ + DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (4 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 31: setUTCHours */ + DUK_DATE_FLAG_TIMESETTER + (4 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 32: setDate */ + DUK_DATE_FLAG_LOCALTIME + (1 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 33: setUTCDate */ + 0 + (1 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 34: setMonth */ + DUK_DATE_FLAG_LOCALTIME + (2 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 35: setUTCMonth */ + 0 + (2 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 36: setFullYear */ + DUK_DATE_FLAG_NAN_TO_ZERO + DUK_DATE_FLAG_LOCALTIME + (3 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 37: setUTCFullYear */ + DUK_DATE_FLAG_NAN_TO_ZERO + (3 << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 38: getYear */ + DUK_DATE_FLAG_LOCALTIME + DUK_DATE_FLAG_SUB1900 + (DUK_DATE_IDX_YEAR << DUK_DATE_FLAG_VALUE_SHIFT), + + /* 39: setYear */ + DUK_DATE_FLAG_NAN_TO_ZERO + DUK_DATE_FLAG_YEAR_FIXUP + (3 << DUK_DATE_FLAG_VALUE_SHIFT), +}; + +DUK_LOCAL duk_small_uint_t duk__date_get_indirect_magic(duk_context *ctx) { + duk_small_int_t magicidx = (duk_small_uint_t) duk_get_current_magic(ctx); + DUK_ASSERT(magicidx >= 0 && magicidx < (duk_small_int_t) (sizeof(duk__date_magics) / sizeof(duk_uint16_t))); + return (duk_small_uint_t) duk__date_magics[magicidx]; +} + +/* + * Constructor calls + */ + +DUK_INTERNAL duk_ret_t duk_bi_date_constructor(duk_context *ctx) { + duk_idx_t nargs = duk_get_top(ctx); + duk_bool_t is_cons = duk_is_constructor_call(ctx); + duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS]; + duk_double_t d; + + DUK_DDD(DUK_DDDPRINT("Date constructor, nargs=%ld, is_cons=%ld", (long) nargs, (long) is_cons)); + + duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DATE), + DUK_BIDX_DATE_PROTOTYPE); + + /* Unlike most built-ins, the internal [[PrimitiveValue]] of a Date + * is mutable. + */ + + if (nargs == 0 || !is_cons) { + d = duk__timeclip(DUK_USE_DATE_GET_NOW(ctx)); + duk_push_number(ctx, d); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_W); + if (!is_cons) { + /* called as a normal function: return new Date().toString() */ + duk_to_string(ctx, -1); + } + return 1; + } else if (nargs == 1) { + duk_to_primitive(ctx, 0, DUK_HINT_NONE); + if (duk_is_string(ctx, 0)) { + duk__parse_string(ctx, duk_to_string(ctx, 0)); + duk_replace(ctx, 0); /* may be NaN */ + } + d = duk__timeclip(duk_to_number(ctx, 0)); + duk_push_number(ctx, d); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_W); + return 1; + } + + duk__set_parts_from_args(ctx, dparts, nargs); + + /* Parts are in local time, convert when setting. */ + + (void) duk__set_this_timeval_from_dparts(ctx, dparts, DUK_DATE_FLAG_LOCALTIME /*flags*/); /* -> [ ... this timeval ] */ + duk_pop(ctx); /* -> [ ... this ] */ + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_date_constructor_parse(duk_context *ctx) { + return duk__parse_string(ctx, duk_to_string(ctx, 0)); +} + +DUK_INTERNAL duk_ret_t duk_bi_date_constructor_utc(duk_context *ctx) { + duk_idx_t nargs = duk_get_top(ctx); + duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS]; + duk_double_t d; + + /* Behavior for nargs < 2 is implementation dependent: currently we'll + * set a NaN time value (matching V8 behavior) in this case. + */ + + if (nargs < 2) { + duk_push_nan(ctx); + } else { + duk__set_parts_from_args(ctx, dparts, nargs); + d = duk_bi_date_get_timeval_from_dparts(dparts, 0 /*flags*/); + duk_push_number(ctx, d); + } + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_date_constructor_now(duk_context *ctx) { + duk_double_t d; + + d = DUK_USE_DATE_GET_NOW(ctx); + DUK_ASSERT(duk__timeclip(d) == d); /* TimeClip() should never be necessary */ + duk_push_number(ctx, d); + return 1; +} + +/* + * String/JSON conversions + * + * Human readable conversions are now basically ISO 8601 with a space + * (instead of 'T') as the date/time separator. This is a good baseline + * and is platform independent. + * + * A shared native helper to provide many conversions. Magic value contains + * a set of flags. The helper provides: + * + * toString() + * toDateString() + * toTimeString() + * toLocaleString() + * toLocaleDateString() + * toLocaleTimeString() + * toUTCString() + * toISOString() + * + * Notes: + * + * - Date.prototype.toGMTString() and Date.prototype.toUTCString() are + * required to be the same Ecmascript function object (!), so it is + * omitted from here. + * + * - Date.prototype.toUTCString(): E5.1 specification does not require a + * specific format, but result should be human readable. The + * specification suggests using ISO 8601 format with a space (instead + * of 'T') separator if a more human readable format is not available. + * + * - Date.prototype.toISOString(): unlike other conversion functions, + * toISOString() requires a RangeError for invalid date values. + */ + +DUK_INTERNAL duk_ret_t duk_bi_date_prototype_tostring_shared(duk_context *ctx) { + duk_small_uint_t flags = duk__date_get_indirect_magic(ctx); + return duk__to_string_helper(ctx, flags); +} + +DUK_INTERNAL duk_ret_t duk_bi_date_prototype_value_of(duk_context *ctx) { + /* This native function is also used for Date.prototype.getTime() + * as their behavior is identical. + */ + + duk_double_t d = duk__push_this_get_timeval(ctx, 0 /*flags*/); /* -> [ this ] */ + DUK_ASSERT(DUK_ISFINITE(d) || DUK_ISNAN(d)); + duk_push_number(ctx, d); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_date_prototype_to_json(duk_context *ctx) { + /* Note: toJSON() is a generic function which works even if 'this' + * is not a Date. The sole argument is ignored. + */ + + duk_push_this(ctx); + duk_to_object(ctx, -1); + + duk_dup_top(ctx); + duk_to_primitive(ctx, -1, DUK_HINT_NUMBER); + if (duk_is_number(ctx, -1)) { + duk_double_t d = duk_get_number(ctx, -1); + if (!DUK_ISFINITE(d)) { + duk_push_null(ctx); + return 1; + } + } + duk_pop(ctx); + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_TO_ISO_STRING); + duk_dup(ctx, -2); /* -> [ O toIsoString O ] */ + duk_call_method(ctx, 0); + return 1; +} + +/* + * Getters. + * + * Implementing getters is quite easy. The internal time value is either + * NaN, or represents milliseconds (without fractions) from Jan 1, 1970. + * The internal time value can be converted to integer parts, and each + * part will be normalized and will fit into a 32-bit signed integer. + * + * A shared native helper to provide all getters. Magic value contains + * a set of flags and also packs the date component index argument. The + * helper provides: + * + * getFullYear() + * getUTCFullYear() + * getMonth() + * getUTCMonth() + * getDate() + * getUTCDate() + * getDay() + * getUTCDay() + * getHours() + * getUTCHours() + * getMinutes() + * getUTCMinutes() + * getSeconds() + * getUTCSeconds() + * getMilliseconds() + * getUTCMilliseconds() + * getYear() + * + * Notes: + * + * - Date.prototype.getDate(): 'date' means day-of-month, and is + * zero-based in internal calculations but public API expects it to + * be one-based. + * + * - Date.prototype.getTime() and Date.prototype.valueOf() have identical + * behavior. They have separate function objects, but share the same C + * function (duk_bi_date_prototype_value_of). + */ + +DUK_INTERNAL duk_ret_t duk_bi_date_prototype_get_shared(duk_context *ctx) { + duk_small_uint_t flags_and_idx = duk__date_get_indirect_magic(ctx); + return duk__get_part_helper(ctx, flags_and_idx); +} + +DUK_INTERNAL duk_ret_t duk_bi_date_prototype_get_timezone_offset(duk_context *ctx) { + /* + * Return (t - LocalTime(t)) in minutes: + * + * t - LocalTime(t) = t - (t + LocalTZA + DaylightSavingTA(t)) + * = -(LocalTZA + DaylightSavingTA(t)) + * + * where DaylightSavingTA() is checked for time 't'. + * + * Note that the sign of the result is opposite to common usage, + * e.g. for EE(S)T which normally is +2h or +3h from UTC, this + * function returns -120 or -180. + * + */ + + duk_double_t d; + duk_int_t tzoffset; + + /* Note: DST adjustment is determined using UTC time. */ + d = duk__push_this_get_timeval(ctx, 0 /*flags*/); + DUK_ASSERT(DUK_ISFINITE(d) || DUK_ISNAN(d)); + if (DUK_ISNAN(d)) { + duk_push_nan(ctx); + } else { + DUK_ASSERT(DUK_ISFINITE(d)); + tzoffset = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d); + duk_push_int(ctx, -tzoffset / 60); + } + return 1; +} + +/* + * Setters. + * + * Setters are a bit more complicated than getters. Component setters + * break down the current time value into its (normalized) component + * parts, replace one or more components with -unnormalized- new values, + * and the components are then converted back into a time value. As an + * example of using unnormalized values: + * + * var d = new Date(1234567890); + * + * is equivalent to: + * + * var d = new Date(0); + * d.setUTCMilliseconds(1234567890); + * + * A shared native helper to provide almost all setters. Magic value + * contains a set of flags and also packs the "maxnargs" argument. The + * helper provides: + * + * setMilliseconds() + * setUTCMilliseconds() + * setSeconds() + * setUTCSeconds() + * setMinutes() + * setUTCMinutes() + * setHours() + * setUTCHours() + * setDate() + * setUTCDate() + * setMonth() + * setUTCMonth() + * setFullYear() + * setUTCFullYear() + * setYear() + * + * Notes: + * + * - Date.prototype.setYear() (Section B addition): special year check + * is omitted. NaN / Infinity will just flow through and ultimately + * result in a NaN internal time value. + * + * - Date.prototype.setYear() does not have optional arguments for + * setting month and day-in-month (like setFullYear()), but we indicate + * 'maxnargs' to be 3 to get the year written to the correct component + * index in duk__set_part_helper(). The function has nargs == 1, so only + * the year will be set regardless of actual argument count. + */ + +DUK_INTERNAL duk_ret_t duk_bi_date_prototype_set_shared(duk_context *ctx) { + duk_small_uint_t flags_and_maxnargs = duk__date_get_indirect_magic(ctx); + return duk__set_part_helper(ctx, flags_and_maxnargs); +} + +DUK_INTERNAL duk_ret_t duk_bi_date_prototype_set_time(duk_context *ctx) { + duk_double_t d; + + (void) duk__push_this_get_timeval(ctx, 0 /*flags*/); /* -> [ timeval this ] */ + d = duk__timeclip(duk_to_number(ctx, 0)); + duk_push_number(ctx, d); + duk_dup_top(ctx); + duk_put_prop_stridx(ctx, -3, DUK_STRIDX_INT_VALUE); /* -> [ timeval this timeval ] */ + + return 1; +} +#line 1 "duk_bi_date_unix.c" +/* + * Unix-like Date providers + * + * Generally useful Unix / POSIX / ANSI Date providers. + */ + +/* include removed: duk_internal.h */ + +/* The necessary #includes are in place in duk_config.h. */ + +/* Buffer sizes for some UNIX calls. Larger than strictly necessary + * to avoid Valgrind errors. + */ +#define DUK__STRPTIME_BUF_SIZE 64 +#define DUK__STRFTIME_BUF_SIZE 64 + +#if defined(DUK_USE_DATE_NOW_GETTIMEOFDAY) +/* Get current Ecmascript time (= UNIX/Posix time, but in milliseconds). */ +DUK_INTERNAL duk_double_t duk_bi_date_get_now_gettimeofday(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + struct timeval tv; + duk_double_t d; + + if (gettimeofday(&tv, NULL) != 0) { + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "gettimeofday failed"); + } + + d = ((duk_double_t) tv.tv_sec) * 1000.0 + + ((duk_double_t) (tv.tv_usec / 1000)); + DUK_ASSERT(DUK_FLOOR(d) == d); /* no fractions */ + + return d; +} +#endif /* DUK_USE_DATE_NOW_GETTIMEOFDAY */ + +#if defined(DUK_USE_DATE_NOW_TIME) +/* Not a very good provider: only full seconds are available. */ +DUK_INTERNAL duk_double_t duk_bi_date_get_now_time(duk_context *ctx) { + time_t t = time(NULL); + return ((duk_double_t) t) * 1000.0; +} +#endif /* DUK_USE_DATE_NOW_TIME */ + +#if defined(DUK_USE_DATE_TZO_GMTIME) || defined(DUK_USE_DATE_TZO_GMTIME_R) +/* Get local time offset (in seconds) for a certain (UTC) instant 'd'. */ +DUK_INTERNAL duk_int_t duk_bi_date_get_local_tzoffset_gmtime(duk_double_t d) { + time_t t, t1, t2; + duk_int_t parts[DUK_DATE_IDX_NUM_PARTS]; + duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS]; + struct tm tms[2]; +#ifdef DUK_USE_DATE_TZO_GMTIME + struct tm *tm_ptr; +#endif + + /* For NaN/inf, the return value doesn't matter. */ + if (!DUK_ISFINITE(d)) { + return 0; + } + + /* If not within Ecmascript range, some integer time calculations + * won't work correctly (and some asserts will fail), so bail out + * if so. This fixes test-bug-date-insane-setyear.js. There is + * a +/- 24h leeway in this range check to avoid a test262 corner + * case documented in test-bug-date-timeval-edges.js. + */ + if (!duk_bi_date_timeval_in_leeway_range(d)) { + DUK_DD(DUK_DDPRINT("timeval not within valid range, skip tzoffset computation to avoid integer overflows")); + return 0; + } + + /* + * This is a bit tricky to implement portably. The result depends + * on the timestamp (specifically, DST depends on the timestamp). + * If e.g. UNIX APIs are used, they'll have portability issues with + * very small and very large years. + * + * Current approach: + * + * - Stay within portable UNIX limits by using equivalent year mapping. + * Avoid year 1970 and 2038 as some conversions start to fail, at + * least on some platforms. Avoiding 1970 means that there are + * currently DST discrepancies for 1970. + * + * - Create a UTC and local time breakdowns from 't'. Then create + * a time_t using gmtime() and localtime() and compute the time + * difference between the two. + * + * Equivalent year mapping (E5 Section 15.9.1.8): + * + * If the host environment provides functionality for determining + * daylight saving time, the implementation of ECMAScript is free + * to map the year in question to an equivalent year (same + * leap-year-ness and same starting week day for the year) for which + * the host environment provides daylight saving time information. + * The only restriction is that all equivalent years should produce + * the same result. + * + * This approach is quite reasonable but not entirely correct, e.g. + * the specification also states (E5 Section 15.9.1.8): + * + * The implementation of ECMAScript should not try to determine + * whether the exact time was subject to daylight saving time, but + * just whether daylight saving time would have been in effect if + * the _current daylight saving time algorithm_ had been used at the + * time. This avoids complications such as taking into account the + * years that the locale observed daylight saving time year round. + * + * Since we rely on the platform APIs for conversions between local + * time and UTC, we can't guarantee the above. Rather, if the platform + * has historical DST rules they will be applied. This seems to be the + * general preferred direction in Ecmascript standardization (or at least + * implementations) anyway, and even the equivalent year mapping should + * be disabled if the platform is known to handle DST properly for the + * full Ecmascript range. + * + * The following has useful discussion and links: + * + * https://bugzilla.mozilla.org/show_bug.cgi?id=351066 + */ + + duk_bi_date_timeval_to_parts(d, parts, dparts, DUK_DATE_FLAG_EQUIVYEAR /*flags*/); + DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] >= 1970 && parts[DUK_DATE_IDX_YEAR] <= 2038); + + d = duk_bi_date_get_timeval_from_dparts(dparts, 0 /*flags*/); + DUK_ASSERT(d >= 0 && d < 2147483648.0 * 1000.0); /* unsigned 31-bit range */ + t = (time_t) (d / 1000.0); + DUK_DDD(DUK_DDDPRINT("timeval: %lf -> time_t %ld", (double) d, (long) t)); + + t1 = t; + + DUK_MEMZERO((void *) tms, sizeof(struct tm) * 2); + +#if defined(DUK_USE_DATE_TZO_GMTIME_R) + (void) gmtime_r(&t, &tms[0]); + (void) localtime_r(&t, &tms[1]); +#elif defined(DUK_USE_DATE_TZO_GMTIME) + tm_ptr = gmtime(&t); + DUK_MEMCPY((void *) &tms[0], tm_ptr, sizeof(struct tm)); + tm_ptr = localtime(&t); + DUK_MEMCPY((void *) &tms[1], tm_ptr, sizeof(struct tm)); +#else +#error internal error +#endif + DUK_DDD(DUK_DDDPRINT("gmtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld," + "wday:%ld,yday:%ld,isdst:%ld}", + (long) tms[0].tm_sec, (long) tms[0].tm_min, (long) tms[0].tm_hour, + (long) tms[0].tm_mday, (long) tms[0].tm_mon, (long) tms[0].tm_year, + (long) tms[0].tm_wday, (long) tms[0].tm_yday, (long) tms[0].tm_isdst)); + DUK_DDD(DUK_DDDPRINT("localtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld," + "wday:%ld,yday:%ld,isdst:%ld}", + (long) tms[1].tm_sec, (long) tms[1].tm_min, (long) tms[1].tm_hour, + (long) tms[1].tm_mday, (long) tms[1].tm_mon, (long) tms[1].tm_year, + (long) tms[1].tm_wday, (long) tms[1].tm_yday, (long) tms[1].tm_isdst)); + + t1 = mktime(&tms[0]); /* UTC */ + t2 = mktime(&tms[1]); /* local */ + if (t1 == (time_t) -1 || t2 == (time_t) -1) { + /* This check used to be for (t < 0) but on some platforms + * time_t is unsigned and apparently the proper way to detect + * an mktime() error return is the cast above. See e.g.: + * http://pubs.opengroup.org/onlinepubs/009695299/functions/mktime.html + */ + goto error; + } + if (tms[1].tm_isdst > 0) { + t2 += 3600; + } else if (tms[1].tm_isdst < 0) { + DUK_D(DUK_DPRINT("tm_isdst is negative: %d", (int) tms[1].tm_isdst)); + } + DUK_DDD(DUK_DDDPRINT("t1=%ld (utc), t2=%ld (local)", (long) t1, (long) t2)); + + /* Compute final offset in seconds, positive if local time ahead of + * UTC (returned value is UTC-to-local offset). + * + * difftime() returns a double, so coercion to int generates quite + * a lot of code. Direct subtraction is not portable, however. + * XXX: allow direct subtraction on known platforms. + */ +#if 0 + return (duk_int_t) (t2 - t1); +#endif + return (duk_int_t) difftime(t2, t1); + + error: + /* XXX: return something more useful, so that caller can throw? */ + DUK_D(DUK_DPRINT("mktime() failed, d=%lf", (double) d)); + return 0; +} +#endif /* DUK_USE_DATE_TZO_GMTIME */ + +#if defined(DUK_USE_DATE_PRS_STRPTIME) +DUK_INTERNAL duk_bool_t duk_bi_date_parse_string_strptime(duk_context *ctx, const char *str) { + struct tm tm; + time_t t; + char buf[DUK__STRPTIME_BUF_SIZE]; + + /* copy to buffer with spare to avoid Valgrind gripes from strptime */ + DUK_ASSERT(str != NULL); + DUK_MEMZERO(buf, sizeof(buf)); /* valgrind whine without this */ + DUK_SNPRINTF(buf, sizeof(buf), "%s", (const char *) str); + buf[sizeof(buf) - 1] = (char) 0; + + DUK_DDD(DUK_DDDPRINT("parsing: '%s'", (const char *) buf)); + + DUK_MEMZERO(&tm, sizeof(tm)); + if (strptime((const char *) buf, "%c", &tm) != NULL) { + DUK_DDD(DUK_DDDPRINT("before mktime: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld," + "wday:%ld,yday:%ld,isdst:%ld}", + (long) tm.tm_sec, (long) tm.tm_min, (long) tm.tm_hour, + (long) tm.tm_mday, (long) tm.tm_mon, (long) tm.tm_year, + (long) tm.tm_wday, (long) tm.tm_yday, (long) tm.tm_isdst)); + tm.tm_isdst = -1; /* negative: dst info not available */ + + t = mktime(&tm); + DUK_DDD(DUK_DDDPRINT("mktime() -> %ld", (long) t)); + if (t >= 0) { + duk_push_number(ctx, ((duk_double_t) t) * 1000.0); + return 1; + } + } + + return 0; +} +#endif /* DUK_USE_DATE_PRS_STRPTIME */ + +#if defined(DUK_USE_DATE_PRS_GETDATE) +DUK_INTERNAL duk_bool_t duk_bi_date_parse_string_getdate(duk_context *ctx, const char *str) { + struct tm tm; + duk_small_int_t rc; + time_t t; + + /* For this to work, DATEMSK must be set, so this is not very + * convenient for an embeddable interpreter. + */ + + DUK_MEMZERO(&tm, sizeof(struct tm)); + rc = (duk_small_int_t) getdate_r(str, &tm); + DUK_DDD(DUK_DDDPRINT("getdate_r() -> %ld", (long) rc)); + + if (rc == 0) { + t = mktime(&tm); + DUK_DDD(DUK_DDDPRINT("mktime() -> %ld", (long) t)); + if (t >= 0) { + duk_push_number(ctx, (duk_double_t) t); + return 1; + } + } + + return 0; +} +#endif /* DUK_USE_DATE_PRS_GETDATE */ + +#if defined(DUK_USE_DATE_FMT_STRFTIME) +DUK_INTERNAL duk_bool_t duk_bi_date_format_parts_strftime(duk_context *ctx, duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags) { + char buf[DUK__STRFTIME_BUF_SIZE]; + struct tm tm; + const char *fmt; + + DUK_UNREF(tzoffset); + + /* If the platform doesn't support the entire Ecmascript range, we need + * to return 0 so that the caller can fall back to the default formatter. + * + * For now, assume that if time_t is 8 bytes or more, the whole Ecmascript + * range is supported. For smaller time_t values (4 bytes in practice), + * assumes that the signed 32-bit range is supported. + * + * XXX: detect this more correctly per platform. The size of time_t is + * probably not an accurate guarantee of strftime() supporting or not + * supporting a large time range (the full Ecmascript range). + */ + if (sizeof(time_t) < 8 && + (parts[DUK_DATE_IDX_YEAR] < 1970 || parts[DUK_DATE_IDX_YEAR] > 2037)) { + /* be paranoid for 32-bit time values (even avoiding negative ones) */ + return 0; + } + + DUK_MEMZERO(&tm, sizeof(tm)); + tm.tm_sec = parts[DUK_DATE_IDX_SECOND]; + tm.tm_min = parts[DUK_DATE_IDX_MINUTE]; + tm.tm_hour = parts[DUK_DATE_IDX_HOUR]; + tm.tm_mday = parts[DUK_DATE_IDX_DAY]; /* already one-based */ + tm.tm_mon = parts[DUK_DATE_IDX_MONTH] - 1; /* one-based -> zero-based */ + tm.tm_year = parts[DUK_DATE_IDX_YEAR] - 1900; + tm.tm_wday = parts[DUK_DATE_IDX_WEEKDAY]; + tm.tm_isdst = 0; + + DUK_MEMZERO(buf, sizeof(buf)); + if ((flags & DUK_DATE_FLAG_TOSTRING_DATE) && (flags & DUK_DATE_FLAG_TOSTRING_TIME)) { + fmt = "%c"; + } else if (flags & DUK_DATE_FLAG_TOSTRING_DATE) { + fmt = "%x"; + } else { + DUK_ASSERT(flags & DUK_DATE_FLAG_TOSTRING_TIME); + fmt = "%X"; + } + (void) strftime(buf, sizeof(buf) - 1, fmt, &tm); + DUK_ASSERT(buf[sizeof(buf) - 1] == 0); + + duk_push_string(ctx, buf); + return 1; +} +#endif /* DUK_USE_DATE_FMT_STRFTIME */ + +#undef DUK__STRPTIME_BUF_SIZE +#undef DUK__STRFTIME_BUF_SIZE +#line 1 "duk_bi_date_windows.c" +/* + * Windows Date providers + * + * Platform specific links: + * + * - http://msdn.microsoft.com/en-us/library/windows/desktop/ms725473(v=vs.85).aspx + */ + +/* include removed: duk_internal.h */ + +/* The necessary #includes are in place in duk_config.h. */ + +#if defined(DUK_USE_DATE_NOW_WINDOWS) || defined(DUK_USE_DATE_TZO_WINDOWS) +/* Shared Windows helpers. */ +DUK_LOCAL void duk__convert_systime_to_ularge(const SYSTEMTIME *st, ULARGE_INTEGER *res) { + FILETIME ft; + if (SystemTimeToFileTime(st, &ft) == 0) { + DUK_D(DUK_DPRINT("SystemTimeToFileTime() failed, returning 0")); + res->QuadPart = 0; + } else { + res->LowPart = ft.dwLowDateTime; + res->HighPart = ft.dwHighDateTime; + } +} +DUK_LOCAL void duk__set_systime_jan1970(SYSTEMTIME *st) { + DUK_MEMZERO((void *) st, sizeof(*st)); + st->wYear = 1970; + st->wMonth = 1; + st->wDayOfWeek = 4; /* not sure whether or not needed; Thursday */ + st->wDay = 1; + DUK_ASSERT(st->wHour == 0); + DUK_ASSERT(st->wMinute == 0); + DUK_ASSERT(st->wSecond == 0); + DUK_ASSERT(st->wMilliseconds == 0); +} +#endif /* defined(DUK_USE_DATE_NOW_WINDOWS) || defined(DUK_USE_DATE_TZO_WINDOWS) */ + +#ifdef DUK_USE_DATE_NOW_WINDOWS +DUK_INTERNAL duk_double_t duk_bi_date_get_now_windows(duk_context *ctx) { + /* Suggested step-by-step method from documentation of RtlTimeToSecondsSince1970: + * http://msdn.microsoft.com/en-us/library/windows/desktop/ms724928(v=vs.85).aspx + */ + SYSTEMTIME st1, st2; + ULARGE_INTEGER tmp1, tmp2; + + DUK_UNREF(ctx); + + GetSystemTime(&st1); + duk__convert_systime_to_ularge((const SYSTEMTIME *) &st1, &tmp1); + + duk__set_systime_jan1970(&st2); + duk__convert_systime_to_ularge((const SYSTEMTIME *) &st2, &tmp2); + + /* Difference is in 100ns units, convert to milliseconds w/o fractions */ + return (duk_double_t) ((tmp1.QuadPart - tmp2.QuadPart) / 10000LL); +} +#endif /* DUK_USE_DATE_NOW_WINDOWS */ + + +#if defined(DUK_USE_DATE_TZO_WINDOWS) +DUK_INTERNAL_DECL duk_int_t duk_bi_date_get_local_tzoffset_windows(duk_double_t d) { + SYSTEMTIME st1; + SYSTEMTIME st2; + SYSTEMTIME st3; + ULARGE_INTEGER tmp1; + ULARGE_INTEGER tmp2; + ULARGE_INTEGER tmp3; + FILETIME ft1; + + /* XXX: handling of timestamps outside Windows supported range. + * How does Windows deal with dates before 1600? Does windows + * support all Ecmascript years (like -200000 and +200000)? + * Should equivalent year mapping be used here too? If so, use + * a shared helper (currently integrated into timeval-to-parts). + */ + + /* Use the approach described in "Remarks" of FileTimeToLocalFileTime: + * http://msdn.microsoft.com/en-us/library/windows/desktop/ms724277(v=vs.85).aspx + */ + + duk__set_systime_jan1970(&st1); + duk__convert_systime_to_ularge((const SYSTEMTIME *) &st1, &tmp1); + tmp2.QuadPart = (ULONGLONG) (d * 10000.0); /* millisec -> 100ns units since jan 1, 1970 */ + tmp2.QuadPart += tmp1.QuadPart; /* input 'd' in Windows UTC, 100ns units */ + + ft1.dwLowDateTime = tmp2.LowPart; + ft1.dwHighDateTime = tmp2.HighPart; + FileTimeToSystemTime((const FILETIME *) &ft1, &st2); + if (SystemTimeToTzSpecificLocalTime((LPTIME_ZONE_INFORMATION) NULL, &st2, &st3) == 0) { + DUK_D(DUK_DPRINT("SystemTimeToTzSpecificLocalTime() failed, return tzoffset 0")); + return 0; + } + duk__convert_systime_to_ularge((const SYSTEMTIME *) &st3, &tmp3); + + /* Positive if local time ahead of UTC. */ + return (duk_int_t) (((LONGLONG) tmp3.QuadPart - (LONGLONG) tmp2.QuadPart) / 10000000LL); /* seconds */ +} +#endif /* DUK_USE_DATE_TZO_WINDOWS */ +#line 1 "duk_bi_duktape.c" +/* + * Duktape built-ins + * + * Size optimization note: it might seem that vararg multipurpose functions + * like fin(), enc(), and dec() are not very size optimal, but using a single + * user-visible Ecmascript function saves a lot of run-time footprint; each + * Function instance takes >100 bytes. Using a shared native helper and a + * 'magic' value won't save much if there are multiple Function instances + * anyway. + */ + +/* include removed: duk_internal.h */ + +/* Raw helper to extract internal information / statistics about a value. + * The return values are version specific and must not expose anything + * that would lead to security issues (e.g. exposing compiled function + * 'data' buffer might be an issue). Currently only counts and sizes and + * such are given so there should not be a security impact. + */ +DUK_INTERNAL duk_ret_t duk_bi_duktape_object_info(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + duk_heaphdr *h; + duk_int_t i, n; + + DUK_UNREF(thr); + + /* result array */ + duk_push_array(ctx); /* -> [ val arr ] */ + + /* type tag (public) */ + duk_push_int(ctx, duk_get_type(ctx, 0)); + + /* address */ + tv = duk_get_tval(ctx, 0); + DUK_ASSERT(tv != NULL); /* because arg count is 1 */ + if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { + h = DUK_TVAL_GET_HEAPHDR(tv); + duk_push_pointer(ctx, (void *) h); + } else { + /* internal type tag */ + duk_push_int(ctx, (duk_int_t) DUK_TVAL_GET_TAG(tv)); + goto done; + } + DUK_ASSERT(h != NULL); + + /* refcount */ +#ifdef DUK_USE_REFERENCE_COUNTING + duk_push_size_t(ctx, DUK_HEAPHDR_GET_REFCOUNT(h)); +#else + duk_push_undefined(ctx); +#endif + + /* heaphdr size and additional allocation size, followed by + * type specific stuff (with varying value count) + */ + switch ((duk_small_int_t) DUK_HEAPHDR_GET_TYPE(h)) { + case DUK_HTYPE_STRING: { + duk_hstring *h_str = (duk_hstring *) h; + duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hstring) + DUK_HSTRING_GET_BYTELEN(h_str) + 1)); + break; + } + case DUK_HTYPE_OBJECT: { + duk_hobject *h_obj = (duk_hobject *) h; + duk_small_uint_t hdr_size; + if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h_obj)) { + hdr_size = (duk_small_uint_t) sizeof(duk_hcompiledfunction); + } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h_obj)) { + hdr_size = (duk_small_uint_t) sizeof(duk_hnativefunction); + } else if (DUK_HOBJECT_IS_THREAD(h_obj)) { + hdr_size = (duk_small_uint_t) sizeof(duk_hthread); + } else { + hdr_size = (duk_small_uint_t) sizeof(duk_hobject); + } + duk_push_uint(ctx, (duk_uint_t) hdr_size); + duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_E_ALLOC_SIZE(h_obj)); + duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ESIZE(h_obj)); + /* Note: e_next indicates the number of gc-reachable entries + * in the entry part, and also indicates the index where the + * next new property would be inserted. It does *not* indicate + * the number of non-NULL keys present in the object. That + * value could be counted separately but requires a pass through + * the key list. + */ + duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ENEXT(h_obj)); + duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ASIZE(h_obj)); + duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_HSIZE(h_obj)); + if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h_obj)) { + duk_hbuffer *h_data = (duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, (duk_hcompiledfunction *) h_obj); + if (h_data) { + duk_push_uint(ctx, (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_data)); + } else { + duk_push_uint(ctx, 0); + } + } + break; + } + case DUK_HTYPE_BUFFER: { + duk_hbuffer *h_buf = (duk_hbuffer *) h; + if (DUK_HBUFFER_HAS_DYNAMIC(h_buf)) { + if (DUK_HBUFFER_HAS_EXTERNAL(h_buf)) { + duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_external))); + } else { + /* When alloc_size == 0 the second allocation may not + * actually exist. + */ + duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_dynamic))); + } + duk_push_uint(ctx, (duk_uint_t) (DUK_HBUFFER_GET_SIZE(h_buf))); + } else { + duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_fixed) + DUK_HBUFFER_GET_SIZE(h_buf) + 1)); + } + break; + + } + } + + done: + /* set values into ret array */ + /* XXX: primitive to make array from valstack slice */ + n = duk_get_top(ctx); + for (i = 2; i < n; i++) { + duk_dup(ctx, i); + duk_put_prop_index(ctx, 1, i - 2); + } + duk_dup(ctx, 1); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_duktape_object_act(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_activation *act; + duk_uint_fast32_t pc; + duk_uint_fast32_t line; + duk_int_t level; + + /* -1 = top callstack entry, callstack[callstack_top - 1] + * -callstack_top = bottom callstack entry, callstack[0] + */ + level = duk_to_int(ctx, 0); + if (level >= 0 || -level > (duk_int_t) thr->callstack_top) { + return 0; + } + DUK_ASSERT(level >= -((duk_int_t) thr->callstack_top) && level <= -1); + act = thr->callstack + thr->callstack_top + level; + + duk_push_object(ctx); + + duk_push_tval(ctx, &act->tv_func); + + /* Relevant PC is just before current one because PC is + * post-incremented. This should match what error augment + * code does. + */ + pc = duk_hthread_get_act_prev_pc(thr, act); + duk_push_uint(ctx, (duk_uint_t) pc); + +#if defined(DUK_USE_PC2LINE) + line = duk_hobject_pc2line_query(ctx, -2, pc); +#else + line = 0; +#endif + duk_push_uint(ctx, (duk_uint_t) line); + + /* Providing access to e.g. act->lex_env would be dangerous: these + * internal structures must never be accessible to the application. + * Duktape relies on them having consistent data, and this consistency + * is only asserted for, not checked for. + */ + + /* [ level obj func pc line ] */ + + /* XXX: version specific array format instead? */ + duk_xdef_prop_stridx_wec(ctx, -4, DUK_STRIDX_LINE_NUMBER); + duk_xdef_prop_stridx_wec(ctx, -3, DUK_STRIDX_PC); + duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_LC_FUNCTION); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_duktape_object_gc(duk_context *ctx) { +#ifdef DUK_USE_MARK_AND_SWEEP + duk_hthread *thr = (duk_hthread *) ctx; + duk_small_uint_t flags; + duk_bool_t rc; + + flags = (duk_small_uint_t) duk_get_uint(ctx, 0); + rc = duk_heap_mark_and_sweep(thr->heap, flags); + + /* XXX: Not sure what the best return value would be in the API. + * Return a boolean for now. Note that rc == 0 is success (true). + */ + duk_push_boolean(ctx, !rc); + return 1; +#else + DUK_UNREF(ctx); + return 0; +#endif +} + +DUK_INTERNAL duk_ret_t duk_bi_duktape_object_fin(duk_context *ctx) { + (void) duk_require_hobject(ctx, 0); + if (duk_get_top(ctx) >= 2) { + /* Set: currently a finalizer is disabled by setting it to + * undefined; this does not remove the property at the moment. + * The value could be type checked to be either a function + * or something else; if something else, the property could + * be deleted. + */ + duk_set_top(ctx, 2); + (void) duk_put_prop_stridx(ctx, 0, DUK_STRIDX_INT_FINALIZER); + return 0; + } else { + /* Get. */ + DUK_ASSERT(duk_get_top(ctx) == 1); + duk_get_prop_stridx(ctx, 0, DUK_STRIDX_INT_FINALIZER); + return 1; + } +} + +DUK_INTERNAL duk_ret_t duk_bi_duktape_object_enc(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h_str; + + /* Vararg function: must be careful to check/require arguments. + * The JSON helpers accept invalid indices and treat them like + * non-existent optional parameters. + */ + + h_str = duk_require_hstring(ctx, 0); + duk_require_valid_index(ctx, 1); + + if (h_str == DUK_HTHREAD_STRING_HEX(thr)) { + duk_set_top(ctx, 2); + duk_hex_encode(ctx, 1); + DUK_ASSERT_TOP(ctx, 2); + } else if (h_str == DUK_HTHREAD_STRING_BASE64(thr)) { + duk_set_top(ctx, 2); + duk_base64_encode(ctx, 1); + DUK_ASSERT_TOP(ctx, 2); +#ifdef DUK_USE_JX + } else if (h_str == DUK_HTHREAD_STRING_JX(thr)) { + duk_bi_json_stringify_helper(ctx, + 1 /*idx_value*/, + 2 /*idx_replacer*/, + 3 /*idx_space*/, + DUK_JSON_FLAG_EXT_CUSTOM | + DUK_JSON_FLAG_ASCII_ONLY | + DUK_JSON_FLAG_AVOID_KEY_QUOTES /*flags*/); +#endif +#ifdef DUK_USE_JC + } else if (h_str == DUK_HTHREAD_STRING_JC(thr)) { + duk_bi_json_stringify_helper(ctx, + 1 /*idx_value*/, + 2 /*idx_replacer*/, + 3 /*idx_space*/, + DUK_JSON_FLAG_EXT_COMPATIBLE | + DUK_JSON_FLAG_ASCII_ONLY /*flags*/); +#endif + } else { + return DUK_RET_TYPE_ERROR; + } + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_duktape_object_dec(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h_str; + + /* Vararg function: must be careful to check/require arguments. + * The JSON helpers accept invalid indices and treat them like + * non-existent optional parameters. + */ + + h_str = duk_require_hstring(ctx, 0); + duk_require_valid_index(ctx, 1); + + if (h_str == DUK_HTHREAD_STRING_HEX(thr)) { + duk_set_top(ctx, 2); + duk_hex_decode(ctx, 1); + DUK_ASSERT_TOP(ctx, 2); + } else if (h_str == DUK_HTHREAD_STRING_BASE64(thr)) { + duk_set_top(ctx, 2); + duk_base64_decode(ctx, 1); + DUK_ASSERT_TOP(ctx, 2); +#ifdef DUK_USE_JX + } else if (h_str == DUK_HTHREAD_STRING_JX(thr)) { + duk_bi_json_parse_helper(ctx, + 1 /*idx_value*/, + 2 /*idx_replacer*/, + DUK_JSON_FLAG_EXT_CUSTOM /*flags*/); +#endif +#ifdef DUK_USE_JC + } else if (h_str == DUK_HTHREAD_STRING_JC(thr)) { + duk_bi_json_parse_helper(ctx, + 1 /*idx_value*/, + 2 /*idx_replacer*/, + DUK_JSON_FLAG_EXT_COMPATIBLE /*flags*/); +#endif + } else { + return DUK_RET_TYPE_ERROR; + } + return 1; +} + +/* + * Compact an object + */ + +DUK_INTERNAL duk_ret_t duk_bi_duktape_object_compact(duk_context *ctx) { + DUK_ASSERT_TOP(ctx, 1); + duk_compact(ctx, 0); + return 1; /* return the argument object */ +} +#line 1 "duk_bi_error.c" +/* + * Error built-ins + */ + +/* include removed: duk_internal.h */ + +DUK_INTERNAL duk_ret_t duk_bi_error_constructor_shared(duk_context *ctx) { + /* Behavior for constructor and non-constructor call is + * the same except for augmenting the created error. When + * called as a constructor, the caller (duk_new()) will handle + * augmentation; when called as normal function, we need to do + * it here. + */ + + duk_hthread *thr = (duk_hthread *) ctx; + duk_small_int_t bidx_prototype = duk_get_current_magic(ctx); + + /* same for both error and each subclass like TypeError */ + duk_uint_t flags_and_class = DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ERROR); + + DUK_UNREF(thr); + + duk_push_object_helper(ctx, flags_and_class, bidx_prototype); + + /* If message is undefined, the own property 'message' is not set at + * all to save property space. An empty message is inherited anyway. + */ + if (!duk_is_undefined(ctx, 0)) { + duk_to_string(ctx, 0); + duk_dup(ctx, 0); /* [ message error message ] */ + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE, DUK_PROPDESC_FLAGS_WC); + } + + /* Augment the error if called as a normal function. __FILE__ and __LINE__ + * are not desirable in this case. + */ + +#ifdef DUK_USE_AUGMENT_ERROR_CREATE + if (!duk_is_constructor_call(ctx)) { + duk_err_augment_error_create(thr, thr, NULL, 0, 1 /*noblame_fileline*/); + } +#endif + + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_error_prototype_to_string(duk_context *ctx) { + /* XXX: optimize with more direct internal access */ + + duk_push_this(ctx); + (void) duk_require_hobject_or_lfunc_coerce(ctx, -1); + + /* [ ... this ] */ + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME); + if (duk_is_undefined(ctx, -1)) { + duk_pop(ctx); + duk_push_string(ctx, "Error"); + } else { + duk_to_string(ctx, -1); + } + + /* [ ... this name ] */ + + /* XXX: Are steps 6 and 7 in E5 Section 15.11.4.4 duplicated by + * accident or are they actually needed? The first ToString() + * could conceivably return 'undefined'. + */ + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE); + if (duk_is_undefined(ctx, -1)) { + duk_pop(ctx); + duk_push_string(ctx, ""); + } else { + duk_to_string(ctx, -1); + } + + /* [ ... this name message ] */ + + if (duk_get_length(ctx, -2) == 0) { + /* name is empty -> return message */ + return 1; + } + if (duk_get_length(ctx, -1) == 0) { + /* message is empty -> return name */ + duk_pop(ctx); + return 1; + } + duk_push_string(ctx, ": "); + duk_insert(ctx, -2); /* ... name ': ' message */ + duk_concat(ctx, 3); + + return 1; +} + +#ifdef DUK_USE_TRACEBACKS + +/* + * Traceback handling + * + * The unified helper decodes the traceback and produces various requested + * outputs. It should be optimized for size, and may leave garbage on stack, + * only the topmost return value matters. For instance, traceback separator + * and decoded strings are pushed even when looking for filename only. + * + * NOTE: although _Tracedata is an internal property, user code can currently + * write to the array (or replace it with something other than an array). + * The code below must tolerate arbitrary _Tracedata. It can throw errors + * etc, but cannot cause a segfault or memory unsafe behavior. + */ + +/* constants arbitrary, chosen for small loads */ +#define DUK__OUTPUT_TYPE_TRACEBACK (-1) +#define DUK__OUTPUT_TYPE_FILENAME 0 +#define DUK__OUTPUT_TYPE_LINENUMBER 1 + +DUK_LOCAL duk_ret_t duk__traceback_getter_helper(duk_context *ctx, duk_small_int_t output_type) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t idx_td; + duk_small_int_t i; /* traceback depth fits into 16 bits */ + duk_small_int_t t; /* stack type fits into 16 bits */ + const char *str_tailcalled = " tailcalled"; + const char *str_strict = " strict"; + const char *str_construct = " construct"; + const char *str_prevyield = " preventsyield"; + const char *str_directeval = " directeval"; + const char *str_empty = ""; + + DUK_ASSERT_TOP(ctx, 0); /* fixed arg count */ + + duk_push_this(ctx); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TRACEDATA); + idx_td = duk_get_top_index(ctx); + + duk_push_hstring_stridx(ctx, DUK_STRIDX_NEWLINE_TAB); + duk_push_this(ctx); + + /* [ ... this tracedata sep this ] */ + + /* XXX: skip null filename? */ + + if (duk_check_type(ctx, idx_td, DUK_TYPE_OBJECT)) { + /* Current tracedata contains 2 entries per callstack entry. */ + for (i = 0; ; i += 2) { + duk_int_t pc; + duk_int_t line; + duk_int_t flags; + duk_double_t d; + const char *funcname; + const char *filename; + duk_hobject *h_func; + duk_hstring *h_name; + + duk_require_stack(ctx, 5); + duk_get_prop_index(ctx, idx_td, i); + duk_get_prop_index(ctx, idx_td, i + 1); + d = duk_to_number(ctx, -1); + pc = (duk_int_t) DUK_FMOD(d, DUK_DOUBLE_2TO32); + flags = (duk_int_t) DUK_FLOOR(d / DUK_DOUBLE_2TO32); + t = (duk_small_int_t) duk_get_type(ctx, -2); + + if (t == DUK_TYPE_OBJECT || t == DUK_TYPE_LIGHTFUNC) { + /* + * Ecmascript/native function call or lightfunc call + */ + + /* [ ... v1(func) v2(pc+flags) ] */ + + h_func = duk_get_hobject(ctx, -2); /* NULL for lightfunc */ + + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME); + duk_get_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME); + +#if defined(DUK_USE_PC2LINE) + line = duk_hobject_pc2line_query(ctx, -4, (duk_uint_fast32_t) pc); +#else + line = 0; +#endif + + /* [ ... v1 v2 name filename ] */ + + if (output_type == DUK__OUTPUT_TYPE_FILENAME) { + return 1; + } else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) { + duk_push_int(ctx, line); + return 1; + } + + h_name = duk_get_hstring(ctx, -2); /* may be NULL */ + funcname = (h_name == NULL || h_name == DUK_HTHREAD_STRING_EMPTY_STRING(thr)) ? + "anon" : (const char *) DUK_HSTRING_GET_DATA(h_name); + filename = duk_get_string(ctx, -1); + filename = filename ? filename : ""; + DUK_ASSERT(funcname != NULL); + DUK_ASSERT(filename != NULL); + + if (h_func == NULL) { + duk_push_sprintf(ctx, "%s light%s%s%s%s%s", + (const char *) funcname, + (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcalled : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty)); + } else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(h_func)) { + duk_push_sprintf(ctx, "%s %s native%s%s%s%s%s", + (const char *) funcname, + (const char *) filename, + (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcalled : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty)); + } else { + duk_push_sprintf(ctx, "%s %s:%ld%s%s%s%s%s", + (const char *) funcname, + (const char *) filename, + (long) line, + (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcalled : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty), + (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty)); + } + duk_replace(ctx, -5); /* [ ... v1 v2 name filename str ] -> [ ... str v2 name filename ] */ + duk_pop_n(ctx, 3); /* -> [ ... str ] */ + } else if (t == DUK_TYPE_STRING) { + /* + * __FILE__ / __LINE__ entry, here 'pc' is line number directly. + * Sometimes __FILE__ / __LINE__ is reported as the source for + * the error (fileName, lineNumber), sometimes not. + */ + + /* [ ... v1(filename) v2(line+flags) ] */ + + if (!(flags & DUK_TB_FLAG_NOBLAME_FILELINE)) { + if (output_type == DUK__OUTPUT_TYPE_FILENAME) { + duk_pop(ctx); + return 1; + } else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) { + duk_push_int(ctx, pc); + return 1; + } + } + + duk_push_sprintf(ctx, "%s:%ld", + (const char *) duk_get_string(ctx, -2), (long) pc); + duk_replace(ctx, -3); /* [ ... v1 v2 str ] -> [ ... str v2 ] */ + duk_pop(ctx); /* -> [ ... str ] */ + } else { + /* unknown, ignore */ + duk_pop_2(ctx); + break; + } + } + + if (i >= DUK_USE_TRACEBACK_DEPTH * 2) { + /* Possibly truncated; there is no explicit truncation + * marker so this is the best we can do. + */ + + duk_push_hstring_stridx(ctx, DUK_STRIDX_BRACKETED_ELLIPSIS); + } + } + + /* [ ... this tracedata sep this str1 ... strN ] */ + + if (output_type != DUK__OUTPUT_TYPE_TRACEBACK) { + return 0; + } else { + /* The 'this' after 'sep' will get ToString() coerced by + * duk_join() automatically. We don't want to do that + * coercion when providing .fileName or .lineNumber (GH-254). + */ + duk_join(ctx, duk_get_top(ctx) - (idx_td + 2) /*count, not including sep*/); + return 1; + } +} + +/* XXX: output type could be encoded into native function 'magic' value to + * save space. + */ + +DUK_INTERNAL duk_ret_t duk_bi_error_prototype_stack_getter(duk_context *ctx) { + return duk__traceback_getter_helper(ctx, DUK__OUTPUT_TYPE_TRACEBACK); +} + +DUK_INTERNAL duk_ret_t duk_bi_error_prototype_filename_getter(duk_context *ctx) { + return duk__traceback_getter_helper(ctx, DUK__OUTPUT_TYPE_FILENAME); +} + +DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_getter(duk_context *ctx) { + return duk__traceback_getter_helper(ctx, DUK__OUTPUT_TYPE_LINENUMBER); +} + +#undef DUK__OUTPUT_TYPE_TRACEBACK +#undef DUK__OUTPUT_TYPE_FILENAME +#undef DUK__OUTPUT_TYPE_LINENUMBER + +#else /* DUK_USE_TRACEBACKS */ + +/* + * Traceback handling when tracebacks disabled. + * + * The fileName / lineNumber stubs are now necessary because built-in + * data will include the accessor properties in Error.prototype. If those + * are removed for builds without tracebacks, these can also be removed. + * 'stack' should still be present and produce a ToString() equivalent: + * this is useful for user code which prints a stacktrace and expects to + * see something useful. A normal stacktrace also begins with a ToString() + * of the error so this makes sense. + */ + +DUK_INTERNAL duk_ret_t duk_bi_error_prototype_stack_getter(duk_context *ctx) { + /* XXX: remove this native function and map 'stack' accessor + * to the toString() implementation directly. + */ + return duk_bi_error_prototype_to_string(ctx); +} + +DUK_INTERNAL duk_ret_t duk_bi_error_prototype_filename_getter(duk_context *ctx) { + DUK_UNREF(ctx); + return 0; +} + +DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_getter(duk_context *ctx) { + DUK_UNREF(ctx); + return 0; +} + +#endif /* DUK_USE_TRACEBACKS */ + +DUK_INTERNAL duk_ret_t duk_bi_error_prototype_nop_setter(duk_context *ctx) { + /* Attempt to write 'stack', 'fileName', 'lineNumber' is a silent no-op. + * User can use Object.defineProperty() to override this behavior. + */ + DUK_ASSERT_TOP(ctx, 1); /* fixed arg count */ + DUK_UNREF(ctx); + return 0; +} +#line 1 "duk_bi_function.c" +/* + * Function built-ins + */ + +/* include removed: duk_internal.h */ + +DUK_INTERNAL duk_ret_t duk_bi_function_constructor(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h_sourcecode; + duk_idx_t nargs; + duk_idx_t i; + duk_small_uint_t comp_flags; + duk_hcompiledfunction *func; + duk_hobject *outer_lex_env; + duk_hobject *outer_var_env; + + /* normal and constructor calls have identical semantics */ + + nargs = duk_get_top(ctx); + for (i = 0; i < nargs; i++) { + duk_to_string(ctx, i); + } + + if (nargs == 0) { + duk_push_string(ctx, ""); + duk_push_string(ctx, ""); + } else if (nargs == 1) { + /* XXX: cover this with the generic >1 case? */ + duk_push_string(ctx, ""); + } else { + duk_insert(ctx, 0); /* [ arg1 ... argN-1 body] -> [body arg1 ... argN-1] */ + duk_push_string(ctx, ","); + duk_insert(ctx, 1); + duk_join(ctx, nargs - 1); + } + + /* [ body formals ], formals is comma separated list that needs to be parsed */ + + DUK_ASSERT_TOP(ctx, 2); + + /* XXX: this placeholder is not always correct, but use for now. + * It will fail in corner cases; see test-dev-func-cons-args.js. + */ + duk_push_string(ctx, "function("); + duk_dup(ctx, 1); + duk_push_string(ctx, "){"); + duk_dup(ctx, 0); + duk_push_string(ctx, "}"); + duk_concat(ctx, 5); + + /* [ body formals source ] */ + + DUK_ASSERT_TOP(ctx, 3); + + /* strictness is not inherited, intentional */ + comp_flags = DUK_JS_COMPILE_FLAG_FUNCEXPR; + + duk_push_hstring_stridx(ctx, DUK_STRIDX_COMPILE); /* XXX: copy from caller? */ /* XXX: ignored now */ + h_sourcecode = duk_require_hstring(ctx, -2); + duk_js_compile(thr, + (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_sourcecode), + (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sourcecode), + comp_flags); + func = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1); + DUK_ASSERT(func != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) func)); + + /* [ body formals source template ] */ + + /* only outer_lex_env matters, as functions always get a new + * variable declaration environment. + */ + + outer_lex_env = thr->builtins[DUK_BIDX_GLOBAL_ENV]; + outer_var_env = thr->builtins[DUK_BIDX_GLOBAL_ENV]; + + duk_js_push_closure(thr, func, outer_var_env, outer_lex_env); + + /* [ body formals source template closure ] */ + + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_function_prototype(duk_context *ctx) { + /* ignore arguments, return undefined (E5 Section 15.3.4) */ + DUK_UNREF(ctx); + return 0; +} + +DUK_INTERNAL duk_ret_t duk_bi_function_prototype_to_string(duk_context *ctx) { + duk_tval *tv; + + /* + * E5 Section 15.3.4.2 places few requirements on the output of + * this function: + * + * - The result is an implementation dependent representation + * of the function; in particular + * + * - The result must follow the syntax of a FunctionDeclaration. + * In particular, the function must have a name (even in the + * case of an anonymous function or a function with an empty + * name). + * + * - Note in particular that the output does NOT need to compile + * into anything useful. + */ + + + /* XXX: faster internal way to get this */ + duk_push_this(ctx); + tv = duk_get_tval(ctx, -1); + DUK_ASSERT(tv != NULL); + + if (DUK_TVAL_IS_OBJECT(tv)) { + duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv); + const char *func_name = DUK_STR_ANON; + + /* XXX: rework, it would be nice to avoid C formatting functions to + * ensure there are no Unicode issues. + */ + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME); + if (!duk_is_undefined(ctx, -1)) { + func_name = duk_to_string(ctx, -1); + DUK_ASSERT(func_name != NULL); + + if (func_name[0] == (char) 0) { + func_name = DUK_STR_ANON; + } + } + + if (DUK_HOBJECT_HAS_COMPILEDFUNCTION(obj)) { + /* XXX: actual source, if available */ + duk_push_sprintf(ctx, "function %s() {/* ecmascript */}", (const char *) func_name); + } else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(obj)) { + duk_push_sprintf(ctx, "function %s() {/* native */}", (const char *) func_name); + } else if (DUK_HOBJECT_HAS_BOUND(obj)) { + duk_push_sprintf(ctx, "function %s() {/* bound */}", (const char *) func_name); + } else { + goto type_error; + } + } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) { + duk_push_lightfunc_tostring(ctx, tv); + } else { + goto type_error; + } + + return 1; + + type_error: + return DUK_RET_TYPE_ERROR; +} + +DUK_INTERNAL duk_ret_t duk_bi_function_prototype_apply(duk_context *ctx) { + duk_idx_t len; + duk_idx_t i; + + DUK_ASSERT_TOP(ctx, 2); /* not a vararg function */ + + duk_push_this(ctx); + if (!duk_is_callable(ctx, -1)) { + DUK_DDD(DUK_DDDPRINT("func is not callable")); + goto type_error; + } + duk_insert(ctx, 0); + DUK_ASSERT_TOP(ctx, 3); + + DUK_DDD(DUK_DDDPRINT("func=%!iT, thisArg=%!iT, argArray=%!iT", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 1), + (duk_tval *) duk_get_tval(ctx, 2))); + + /* [ func thisArg argArray ] */ + + if (duk_is_null_or_undefined(ctx, 2)) { + DUK_DDD(DUK_DDDPRINT("argArray is null/undefined, no args")); + len = 0; + } else if (!duk_is_object(ctx, 2)) { + goto type_error; + } else { + DUK_DDD(DUK_DDDPRINT("argArray is an object")); + + /* XXX: make this an internal helper */ + duk_get_prop_stridx(ctx, 2, DUK_STRIDX_LENGTH); + len = (duk_idx_t) duk_to_uint32(ctx, -1); /* ToUint32() coercion required */ + duk_pop(ctx); + + duk_require_stack(ctx, len); + + DUK_DDD(DUK_DDDPRINT("argArray length is %ld", (long) len)); + for (i = 0; i < len; i++) { + duk_get_prop_index(ctx, 2, i); + } + } + duk_remove(ctx, 2); + DUK_ASSERT_TOP(ctx, 2 + len); + + /* [ func thisArg arg1 ... argN ] */ + + DUK_DDD(DUK_DDDPRINT("apply, func=%!iT, thisArg=%!iT, len=%ld", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 1), + (long) len)); + duk_call_method(ctx, len); + return 1; + + type_error: + return DUK_RET_TYPE_ERROR; +} + +DUK_INTERNAL duk_ret_t duk_bi_function_prototype_call(duk_context *ctx) { + duk_idx_t nargs; + + /* Step 1 is not necessary because duk_call_method() will take + * care of it. + */ + + /* vararg function, thisArg needs special handling */ + nargs = duk_get_top(ctx); /* = 1 + arg count */ + if (nargs == 0) { + duk_push_undefined(ctx); + nargs++; + } + DUK_ASSERT(nargs >= 1); + + /* [ thisArg arg1 ... argN ] */ + + duk_push_this(ctx); /* 'func' in the algorithm */ + duk_insert(ctx, 0); + + /* [ func thisArg arg1 ... argN ] */ + + DUK_DDD(DUK_DDDPRINT("func=%!iT, thisArg=%!iT, argcount=%ld, top=%ld", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 1), + (long) (nargs - 1), + (long) duk_get_top(ctx))); + duk_call_method(ctx, nargs - 1); + return 1; +} + +/* XXX: the implementation now assumes "chained" bound functions, + * whereas "collapsed" bound functions (where there is ever only + * one bound function which directly points to a non-bound, final + * function) would require a "collapsing" implementation which + * merges argument lists etc here. + */ +DUK_INTERNAL duk_ret_t duk_bi_function_prototype_bind(duk_context *ctx) { + duk_hobject *h_bound; + duk_hobject *h_target; + duk_idx_t nargs; + duk_idx_t i; + + /* vararg function, careful arg handling (e.g. thisArg may not be present) */ + nargs = duk_get_top(ctx); /* = 1 + arg count */ + if (nargs == 0) { + duk_push_undefined(ctx); + nargs++; + } + DUK_ASSERT(nargs >= 1); + + duk_push_this(ctx); + if (!duk_is_callable(ctx, -1)) { + DUK_DDD(DUK_DDDPRINT("func is not callable")); + goto type_error; + } + + /* [ thisArg arg1 ... argN func ] (thisArg+args == nargs total) */ + DUK_ASSERT_TOP(ctx, nargs + 1); + + /* create bound function object */ + duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BOUND | + DUK_HOBJECT_FLAG_CONSTRUCTABLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION), + DUK_BIDX_FUNCTION_PROTOTYPE); + h_bound = duk_get_hobject(ctx, -1); + DUK_ASSERT(h_bound != NULL); + + /* [ thisArg arg1 ... argN func boundFunc ] */ + duk_dup(ctx, -2); /* func */ + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE); + + duk_dup(ctx, 0); /* thisArg */ + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE); + + duk_push_array(ctx); + + /* [ thisArg arg1 ... argN func boundFunc argArray ] */ + + for (i = 0; i < nargs - 1; i++) { + duk_dup(ctx, 1 + i); + duk_put_prop_index(ctx, -2, i); + } + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_ARGS, DUK_PROPDESC_FLAGS_NONE); + + /* [ thisArg arg1 ... argN func boundFunc ] */ + + /* bound function 'length' property is interesting */ + h_target = duk_get_hobject(ctx, -2); + if (h_target == NULL || /* lightfunc */ + DUK_HOBJECT_GET_CLASS_NUMBER(h_target) == DUK_HOBJECT_CLASS_FUNCTION) { + /* For lightfuncs, simply read the virtual property. */ + duk_int_t tmp; + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH); + tmp = duk_to_int(ctx, -1) - (nargs - 1); /* step 15.a */ + duk_pop(ctx); + duk_push_int(ctx, (tmp < 0 ? 0 : tmp)); + } else { + duk_push_int(ctx, 0); + } + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE); /* attrs in E5 Section 15.3.5.1 */ + + /* caller and arguments must use the same thrower, [[ThrowTypeError]] */ + duk_xdef_prop_stridx_thrower(ctx, -1, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE); + duk_xdef_prop_stridx_thrower(ctx, -1, DUK_STRIDX_LC_ARGUMENTS, DUK_PROPDESC_FLAGS_NONE); + + /* these non-standard properties are copied for convenience */ + /* XXX: 'copy properties' API call? */ + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_WC); + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC); + + /* The 'strict' flag is copied to get the special [[Get]] of E5.1 + * Section 15.3.5.4 to apply when a 'caller' value is a strict bound + * function. Not sure if this is correct, because the specification + * is a bit ambiguous on this point but it would make sense. + */ + if (h_target == NULL) { + /* Lightfuncs are always strict. */ + DUK_HOBJECT_SET_STRICT(h_bound); + } else if (DUK_HOBJECT_HAS_STRICT(h_target)) { + DUK_HOBJECT_SET_STRICT(h_bound); + } + DUK_DDD(DUK_DDDPRINT("created bound function: %!iT", (duk_tval *) duk_get_tval(ctx, -1))); + + return 1; + + type_error: + return DUK_RET_TYPE_ERROR; +} +#line 1 "duk_bi_global.c" +/* + * Global object built-ins + */ + +/* include removed: duk_internal.h */ + +/* + * Encoding/decoding helpers + */ + +/* XXX: Could add fast path (for each transform callback) with direct byte + * lookups (no shifting) and no explicit check for x < 0x80 before table + * lookup. + */ + +/* Macros for creating and checking bitmasks for character encoding. + * Bit number is a bit counterintuitive, but minimizes code size. + */ +#define DUK__MKBITS(a,b,c,d,e,f,g,h) ((duk_uint8_t) ( \ + ((a) << 0) | ((b) << 1) | ((c) << 2) | ((d) << 3) | \ + ((e) << 4) | ((f) << 5) | ((g) << 6) | ((h) << 7) \ + )) +#define DUK__CHECK_BITMASK(table,cp) ((table)[(cp) >> 3] & (1 << ((cp) & 0x07))) + +/* E5.1 Section 15.1.3.3: uriReserved + uriUnescaped + '#' */ +DUK_LOCAL const duk_uint8_t duk__encode_uriunescaped_table[16] = { + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x00-0x0f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x10-0x1f */ + DUK__MKBITS(0, 1, 0, 1, 1, 0, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), /* 0x20-0x2f */ + DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 0, 1, 0, 1), /* 0x30-0x3f */ + DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), /* 0x40-0x4f */ + DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 1), /* 0x50-0x5f */ + DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), /* 0x60-0x6f */ + DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 1, 0), /* 0x70-0x7f */ +}; + +/* E5.1 Section 15.1.3.4: uriUnescaped */ +DUK_LOCAL const duk_uint8_t duk__encode_uricomponent_unescaped_table[16] = { + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x00-0x0f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x10-0x1f */ + DUK__MKBITS(0, 1, 0, 0, 0, 0, 0, 1), DUK__MKBITS(1, 1, 1, 0, 0, 1, 1, 0), /* 0x20-0x2f */ + DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 0, 0, 0, 0, 0, 0), /* 0x30-0x3f */ + DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), /* 0x40-0x4f */ + DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 1), /* 0x50-0x5f */ + DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), /* 0x60-0x6f */ + DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 1, 0), /* 0x70-0x7f */ +}; + +/* E5.1 Section 15.1.3.1: uriReserved + '#' */ +DUK_LOCAL const duk_uint8_t duk__decode_uri_reserved_table[16] = { + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x00-0x0f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x10-0x1f */ + DUK__MKBITS(0, 0, 0, 1, 1, 0, 1, 0), DUK__MKBITS(0, 0, 0, 1, 1, 0, 0, 1), /* 0x20-0x2f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 1, 1, 0, 1, 0, 1), /* 0x30-0x3f */ + DUK__MKBITS(1, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x40-0x4f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x50-0x5f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x60-0x6f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x70-0x7f */ +}; + +/* E5.1 Section 15.1.3.2: empty */ +DUK_LOCAL const duk_uint8_t duk__decode_uri_component_reserved_table[16] = { + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x00-0x0f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x10-0x1f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x20-0x2f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x30-0x3f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x40-0x4f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x50-0x5f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x60-0x6f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x70-0x7f */ +}; + +#ifdef DUK_USE_SECTION_B +/* E5.1 Section B.2.2, step 7. */ +DUK_LOCAL const duk_uint8_t duk__escape_unescaped_table[16] = { + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x00-0x0f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), /* 0x10-0x1f */ + DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 1, 1, 0, 1, 1, 1), /* 0x20-0x2f */ + DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 0, 0, 0, 0, 0, 0), /* 0x30-0x3f */ + DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), /* 0x40-0x4f */ + DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 1), /* 0x50-0x5f */ + DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), /* 0x60-0x6f */ + DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 0) /* 0x70-0x7f */ +}; +#endif /* DUK_USE_SECTION_B */ + +#undef DUK__MKBITS + +typedef struct { + duk_hthread *thr; + duk_hstring *h_str; + duk_bufwriter_ctx bw; + const duk_uint8_t *p; + const duk_uint8_t *p_start; + const duk_uint8_t *p_end; +} duk__transform_context; + +typedef void (*duk__transform_callback)(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp); + +/* XXX: refactor and share with other code */ +DUK_LOCAL duk_small_int_t duk__decode_hex_escape(const duk_uint8_t *p, duk_small_int_t n) { + duk_small_int_t ch; + duk_small_int_t t = 0; + + while (n > 0) { + t = t * 16; + ch = (duk_small_int_t) duk_hex_dectab[*p++]; + if (DUK_LIKELY(ch >= 0)) { + t += ch; + } else { + return -1; + } + n--; + } + return t; +} + +DUK_LOCAL int duk__transform_helper(duk_context *ctx, duk__transform_callback callback, void *udata) { + duk_hthread *thr = (duk_hthread *) ctx; + duk__transform_context tfm_ctx_alloc; + duk__transform_context *tfm_ctx = &tfm_ctx_alloc; + duk_codepoint_t cp; + + tfm_ctx->thr = thr; + + tfm_ctx->h_str = duk_to_hstring(ctx, 0); + DUK_ASSERT(tfm_ctx->h_str != NULL); + + DUK_BW_INIT_PUSHBUF(thr, &tfm_ctx->bw, DUK_HSTRING_GET_BYTELEN(tfm_ctx->h_str)); /* initial size guess */ + + tfm_ctx->p_start = DUK_HSTRING_GET_DATA(tfm_ctx->h_str); + tfm_ctx->p_end = tfm_ctx->p_start + DUK_HSTRING_GET_BYTELEN(tfm_ctx->h_str); + tfm_ctx->p = tfm_ctx->p_start; + + while (tfm_ctx->p < tfm_ctx->p_end) { + cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &tfm_ctx->p, tfm_ctx->p_start, tfm_ctx->p_end); + callback(tfm_ctx, udata, cp); + } + + DUK_BW_COMPACT(thr, &tfm_ctx->bw); + + duk_to_string(ctx, -1); + return 1; +} + +DUK_LOCAL void duk__transform_callback_encode_uri(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) { + duk_uint8_t xutf8_buf[DUK_UNICODE_MAX_XUTF8_LENGTH]; + duk_small_int_t len; + duk_codepoint_t cp1, cp2; + duk_small_int_t i, t; + const duk_uint8_t *unescaped_table = (duk_uint8_t *) udata; + + /* UTF-8 encoded bytes escaped as %xx%xx%xx... -> 3 * nbytes. + * Codepoint range is restricted so this is a slightly too large + * but doesn't matter. + */ + DUK_BW_ENSURE(tfm_ctx->thr, &tfm_ctx->bw, 3 * DUK_UNICODE_MAX_XUTF8_LENGTH); + + if (cp < 0) { + goto uri_error; + } else if ((cp < 0x80L) && DUK__CHECK_BITMASK(unescaped_table, cp)) { + DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) cp); + return; + } else if (cp >= 0xdc00L && cp <= 0xdfffL) { + goto uri_error; + } else if (cp >= 0xd800L && cp <= 0xdbffL) { + /* Needs lookahead */ + if (duk_unicode_decode_xutf8(tfm_ctx->thr, &tfm_ctx->p, tfm_ctx->p_start, tfm_ctx->p_end, (duk_ucodepoint_t *) &cp2) == 0) { + goto uri_error; + } + if (!(cp2 >= 0xdc00L && cp2 <= 0xdfffL)) { + goto uri_error; + } + cp1 = cp; + cp = ((cp1 - 0xd800L) << 10) + (cp2 - 0xdc00L) + 0x10000L; + } else if (cp > 0x10ffffL) { + /* Although we can allow non-BMP characters (they'll decode + * back into surrogate pairs), we don't allow extended UTF-8 + * characters; they would encode to URIs which won't decode + * back because of strict UTF-8 checks in URI decoding. + * (However, we could just as well allow them here.) + */ + goto uri_error; + } else { + /* Non-BMP characters within valid UTF-8 range: encode as is. + * They'll decode back into surrogate pairs if the escaped + * output is decoded. + */ + ; + } + + len = duk_unicode_encode_xutf8((duk_ucodepoint_t) cp, xutf8_buf); + for (i = 0; i < len; i++) { + t = (int) xutf8_buf[i]; + DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr, + &tfm_ctx->bw, + DUK_ASC_PERCENT, + (duk_uint8_t) duk_uc_nybbles[t >> 4], + (duk_uint8_t) duk_uc_nybbles[t & 0x0f]); + } + + return; + + uri_error: + DUK_ERROR(tfm_ctx->thr, DUK_ERR_URI_ERROR, "invalid input"); +} + +DUK_LOCAL void duk__transform_callback_decode_uri(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) { + const duk_uint8_t *reserved_table = (duk_uint8_t *) udata; + duk_small_uint_t utf8_blen; + duk_codepoint_t min_cp; + duk_small_int_t t; /* must be signed */ + duk_small_uint_t i; + + /* Maximum write size: XUTF8 path writes max DUK_UNICODE_MAX_XUTF8_LENGTH, + * percent escape path writes max two times CESU-8 encoded BMP length. + */ + DUK_BW_ENSURE(tfm_ctx->thr, + &tfm_ctx->bw, + (DUK_UNICODE_MAX_XUTF8_LENGTH >= 2 * DUK_UNICODE_MAX_CESU8_BMP_LENGTH ? + DUK_UNICODE_MAX_XUTF8_LENGTH : DUK_UNICODE_MAX_CESU8_BMP_LENGTH)); + + if (cp == (duk_codepoint_t) '%') { + const duk_uint8_t *p = tfm_ctx->p; + duk_size_t left = (duk_size_t) (tfm_ctx->p_end - p); /* bytes left */ + + DUK_DDD(DUK_DDDPRINT("percent encoding, left=%ld", (long) left)); + + if (left < 2) { + goto uri_error; + } + + t = duk__decode_hex_escape(p, 2); + DUK_DDD(DUK_DDDPRINT("first byte: %ld", (long) t)); + if (t < 0) { + goto uri_error; + } + + if (t < 0x80) { + if (DUK__CHECK_BITMASK(reserved_table, t)) { + /* decode '%xx' to '%xx' if decoded char in reserved set */ + DUK_ASSERT(tfm_ctx->p - 1 >= tfm_ctx->p_start); + DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr, + &tfm_ctx->bw, + DUK_ASC_PERCENT, + p[0], + p[1]); + } else { + DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) t); + } + tfm_ctx->p += 2; + return; + } + + /* Decode UTF-8 codepoint from a sequence of hex escapes. The + * first byte of the sequence has been decoded to 't'. + * + * Note that UTF-8 validation must be strict according to the + * specification: E5.1 Section 15.1.3, decode algorithm step + * 4.d.vii.8. URIError from non-shortest encodings is also + * specifically noted in the spec. + */ + + DUK_ASSERT(t >= 0x80); + if (t < 0xc0) { + /* continuation byte */ + goto uri_error; + } else if (t < 0xe0) { + /* 110x xxxx; 2 bytes */ + utf8_blen = 2; + min_cp = 0x80L; + cp = t & 0x1f; + } else if (t < 0xf0) { + /* 1110 xxxx; 3 bytes */ + utf8_blen = 3; + min_cp = 0x800L; + cp = t & 0x0f; + } else if (t < 0xf8) { + /* 1111 0xxx; 4 bytes */ + utf8_blen = 4; + min_cp = 0x10000L; + cp = t & 0x07; + } else { + /* extended utf-8 not allowed for URIs */ + goto uri_error; + } + + if (left < utf8_blen * 3 - 1) { + /* '%xx%xx...%xx', p points to char after first '%' */ + goto uri_error; + } + + p += 3; + for (i = 1; i < utf8_blen; i++) { + /* p points to digit part ('%xy', p points to 'x') */ + t = duk__decode_hex_escape(p, 2); + DUK_DDD(DUK_DDDPRINT("i=%ld utf8_blen=%ld cp=%ld t=0x%02lx", + (long) i, (long) utf8_blen, (long) cp, (unsigned long) t)); + if (t < 0) { + goto uri_error; + } + if ((t & 0xc0) != 0x80) { + goto uri_error; + } + cp = (cp << 6) + (t & 0x3f); + p += 3; + } + p--; /* p overshoots */ + tfm_ctx->p = p; + + DUK_DDD(DUK_DDDPRINT("final cp=%ld, min_cp=%ld", (long) cp, (long) min_cp)); + + if (cp < min_cp || cp > 0x10ffffL || (cp >= 0xd800L && cp <= 0xdfffL)) { + goto uri_error; + } + + /* The E5.1 algorithm checks whether or not a decoded codepoint + * is below 0x80 and perhaps may be in the "reserved" set. + * This seems pointless because the single byte UTF-8 case is + * handled separately, and non-shortest encodings are rejected. + * So, 'cp' cannot be below 0x80 here, and thus cannot be in + * the reserved set. + */ + + /* utf-8 validation ensures these */ + DUK_ASSERT(cp >= 0x80L && cp <= 0x10ffffL); + + if (cp >= 0x10000L) { + cp -= 0x10000L; + DUK_ASSERT(cp < 0x100000L); + + DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, ((cp >> 10) + 0xd800L)); + DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, ((cp & 0x03ffUL) + 0xdc00L)); + } else { + DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, cp); + } + } else { + DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, cp); + } + return; + + uri_error: + DUK_ERROR(tfm_ctx->thr, DUK_ERR_URI_ERROR, "invalid input"); +} + +#ifdef DUK_USE_SECTION_B +DUK_LOCAL void duk__transform_callback_escape(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) { + DUK_UNREF(udata); + + DUK_BW_ENSURE(tfm_ctx->thr, &tfm_ctx->bw, 6); + + if (cp < 0) { + goto esc_error; + } else if ((cp < 0x80L) && DUK__CHECK_BITMASK(duk__escape_unescaped_table, cp)) { + DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) cp); + } else if (cp < 0x100L) { + DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr, + &tfm_ctx->bw, + (duk_uint8_t) DUK_ASC_PERCENT, + (duk_uint8_t) duk_uc_nybbles[cp >> 4], + (duk_uint8_t) duk_uc_nybbles[cp & 0x0f]); + } else if (cp < 0x10000L) { + DUK_BW_WRITE_RAW_U8_6(tfm_ctx->thr, + &tfm_ctx->bw, + (duk_uint8_t) DUK_ASC_PERCENT, + (duk_uint8_t) DUK_ASC_LC_U, + (duk_uint8_t) duk_uc_nybbles[cp >> 12], + (duk_uint8_t) duk_uc_nybbles[(cp >> 8) & 0x0f], + (duk_uint8_t) duk_uc_nybbles[(cp >> 4) & 0x0f], + (duk_uint8_t) duk_uc_nybbles[cp & 0x0f]); + } else { + /* Characters outside BMP cannot be escape()'d. We could + * encode them as surrogate pairs (for codepoints inside + * valid UTF-8 range, but not extended UTF-8). Because + * escape() and unescape() are legacy functions, we don't. + */ + goto esc_error; + } + + return; + + esc_error: + DUK_ERROR(tfm_ctx->thr, DUK_ERR_TYPE_ERROR, "invalid input"); +} + +DUK_LOCAL void duk__transform_callback_unescape(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) { + duk_small_int_t t; + + DUK_UNREF(udata); + + if (cp == (duk_codepoint_t) '%') { + const duk_uint8_t *p = tfm_ctx->p; + duk_size_t left = (duk_size_t) (tfm_ctx->p_end - p); /* bytes left */ + + if (left >= 5 && p[0] == 'u' && + ((t = duk__decode_hex_escape(p + 1, 4)) >= 0)) { + cp = (duk_codepoint_t) t; + tfm_ctx->p += 5; + } else if (left >= 2 && + ((t = duk__decode_hex_escape(p, 2)) >= 0)) { + cp = (duk_codepoint_t) t; + tfm_ctx->p += 2; + } + } + + DUK_BW_WRITE_ENSURE_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, cp); +} +#endif /* DUK_USE_SECTION_B */ + +/* + * Eval + * + * Eval needs to handle both a "direct eval" and an "indirect eval". + * Direct eval handling needs access to the caller's activation so that its + * lexical environment can be accessed. A direct eval is only possible from + * Ecmascript code; an indirect eval call is possible also from C code. + * When an indirect eval call is made from C code, there may not be a + * calling activation at all which needs careful handling. + */ + +DUK_INTERNAL duk_ret_t duk_bi_global_object_eval(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h; + duk_activation *act_caller; + duk_activation *act_eval; + duk_activation *act; + duk_hcompiledfunction *func; + duk_hobject *outer_lex_env; + duk_hobject *outer_var_env; + duk_bool_t this_to_global = 1; + duk_small_uint_t comp_flags; + + DUK_ASSERT_TOP(ctx, 1); + DUK_ASSERT(thr->callstack_top >= 1); /* at least this function exists */ + DUK_ASSERT(((thr->callstack + thr->callstack_top - 1)->flags & DUK_ACT_FLAG_DIRECT_EVAL) == 0 || /* indirect eval */ + (thr->callstack_top >= 2)); /* if direct eval, calling activation must exist */ + + /* + * callstack_top - 1 --> this function + * callstack_top - 2 --> caller (may not exist) + * + * If called directly from C, callstack_top might be 1. If calling + * activation doesn't exist, call must be indirect. + */ + + h = duk_get_hstring(ctx, 0); + if (!h) { + return 1; /* return arg as-is */ + } + + /* [ source ] */ + + comp_flags = DUK_JS_COMPILE_FLAG_EVAL; + act_eval = thr->callstack + thr->callstack_top - 1; /* this function */ + if (thr->callstack_top >= 2) { + /* Have a calling activation, check for direct eval (otherwise + * assume indirect eval. + */ + act_caller = thr->callstack + thr->callstack_top - 2; /* caller */ + if ((act_caller->flags & DUK_ACT_FLAG_STRICT) && + (act_eval->flags & DUK_ACT_FLAG_DIRECT_EVAL)) { + /* Only direct eval inherits strictness from calling code + * (E5.1 Section 10.1.1). + */ + comp_flags |= DUK_JS_COMPILE_FLAG_STRICT; + } + } else { + DUK_ASSERT((act_eval->flags & DUK_ACT_FLAG_DIRECT_EVAL) == 0); + } + act_caller = NULL; /* avoid dereference after potential callstack realloc */ + act_eval = NULL; + + duk_push_hstring_stridx(ctx, DUK_STRIDX_INPUT); /* XXX: copy from caller? */ + duk_js_compile(thr, + (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h), + (duk_size_t) DUK_HSTRING_GET_BYTELEN(h), + comp_flags); + func = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1); + DUK_ASSERT(func != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) func)); + + /* [ source template ] */ + + /* E5 Section 10.4.2 */ + DUK_ASSERT(thr->callstack_top >= 1); + act = thr->callstack + thr->callstack_top - 1; /* this function */ + if (act->flags & DUK_ACT_FLAG_DIRECT_EVAL) { + DUK_ASSERT(thr->callstack_top >= 2); + act = thr->callstack + thr->callstack_top - 2; /* caller */ + if (act->lex_env == NULL) { + DUK_ASSERT(act->var_env == NULL); + DUK_DDD(DUK_DDDPRINT("delayed environment initialization")); + + /* this may have side effects, so re-lookup act */ + duk_js_init_activation_environment_records_delayed(thr, act); + act = thr->callstack + thr->callstack_top - 2; + } + DUK_ASSERT(act->lex_env != NULL); + DUK_ASSERT(act->var_env != NULL); + + this_to_global = 0; + + if (DUK_HOBJECT_HAS_STRICT((duk_hobject *) func)) { + duk_hobject *new_env; + duk_hobject *act_lex_env; + + DUK_DDD(DUK_DDDPRINT("direct eval call to a strict function -> " + "var_env and lex_env to a fresh env, " + "this_binding to caller's this_binding")); + + act = thr->callstack + thr->callstack_top - 2; /* caller */ + act_lex_env = act->lex_env; + act = NULL; /* invalidated */ + + (void) duk_push_object_helper_proto(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV), + act_lex_env); + new_env = duk_require_hobject(ctx, -1); + DUK_ASSERT(new_env != NULL); + DUK_DDD(DUK_DDDPRINT("new_env allocated: %!iO", + (duk_heaphdr *) new_env)); + + outer_lex_env = new_env; + outer_var_env = new_env; + + duk_insert(ctx, 0); /* stash to bottom of value stack to keep new_env reachable */ + + /* compiler's responsibility */ + DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV((duk_hobject *) func)); + } else { + DUK_DDD(DUK_DDDPRINT("direct eval call to a non-strict function -> " + "var_env and lex_env to caller's envs, " + "this_binding to caller's this_binding")); + + outer_lex_env = act->lex_env; + outer_var_env = act->var_env; + + /* compiler's responsibility */ + DUK_ASSERT(!DUK_HOBJECT_HAS_NEWENV((duk_hobject *) func)); + } + } else { + DUK_DDD(DUK_DDDPRINT("indirect eval call -> var_env and lex_env to " + "global object, this_binding to global object")); + + this_to_global = 1; + outer_lex_env = thr->builtins[DUK_BIDX_GLOBAL_ENV]; + outer_var_env = thr->builtins[DUK_BIDX_GLOBAL_ENV]; + } + act = NULL; + + duk_js_push_closure(thr, func, outer_var_env, outer_lex_env); + + /* [ source template closure ] */ + + if (this_to_global) { + DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL); + duk_push_hobject_bidx(ctx, DUK_BIDX_GLOBAL); + } else { + duk_tval *tv; + DUK_ASSERT(thr->callstack_top >= 2); + act = thr->callstack + thr->callstack_top - 2; /* caller */ + tv = thr->valstack + act->idx_bottom - 1; /* this is just beneath bottom */ + DUK_ASSERT(tv >= thr->valstack); + duk_push_tval(ctx, tv); + } + + DUK_DDD(DUK_DDDPRINT("eval -> lex_env=%!iO, var_env=%!iO, this_binding=%!T", + (duk_heaphdr *) outer_lex_env, + (duk_heaphdr *) outer_var_env, + (duk_tval *) duk_get_tval(ctx, -1))); + + /* [ source template closure this ] */ + + duk_call_method(ctx, 0); + + /* [ source template result ] */ + + return 1; +} + +/* + * Parsing of ints and floats + */ + +DUK_INTERNAL duk_ret_t duk_bi_global_object_parse_int(duk_context *ctx) { + duk_bool_t strip_prefix; + duk_int32_t radix; + duk_small_uint_t s2n_flags; + + DUK_ASSERT_TOP(ctx, 2); + duk_to_string(ctx, 0); + + strip_prefix = 1; + radix = duk_to_int32(ctx, 1); + if (radix != 0) { + if (radix < 2 || radix > 36) { + goto ret_nan; + } + /* For octal, setting strip_prefix=0 is not necessary, as zero + * is tolerated anyway: + * + * parseInt('123', 8) === parseInt('0123', 8) with or without strip_prefix + * parseInt('123', 16) === parseInt('0x123', 16) requires strip_prefix = 1 + */ + if (radix != 16) { + strip_prefix = 0; + } + } else { + radix = 10; + } + + s2n_flags = DUK_S2N_FLAG_TRIM_WHITE | + DUK_S2N_FLAG_ALLOW_GARBAGE | + DUK_S2N_FLAG_ALLOW_PLUS | + DUK_S2N_FLAG_ALLOW_MINUS | + DUK_S2N_FLAG_ALLOW_LEADING_ZERO | +#ifdef DUK_USE_OCTAL_SUPPORT + (strip_prefix ? (DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT | DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT) : 0) +#else + (strip_prefix ? DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT : 0) +#endif + ; + + duk_dup(ctx, 0); + duk_numconv_parse(ctx, radix, s2n_flags); + return 1; + + ret_nan: + duk_push_nan(ctx); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_global_object_parse_float(duk_context *ctx) { + duk_small_uint_t s2n_flags; + duk_int32_t radix; + + DUK_ASSERT_TOP(ctx, 1); + duk_to_string(ctx, 0); + + radix = 10; + + /* XXX: check flags */ + s2n_flags = DUK_S2N_FLAG_TRIM_WHITE | + DUK_S2N_FLAG_ALLOW_EXP | + DUK_S2N_FLAG_ALLOW_GARBAGE | + DUK_S2N_FLAG_ALLOW_PLUS | + DUK_S2N_FLAG_ALLOW_MINUS | + DUK_S2N_FLAG_ALLOW_INF | + DUK_S2N_FLAG_ALLOW_FRAC | + DUK_S2N_FLAG_ALLOW_NAKED_FRAC | + DUK_S2N_FLAG_ALLOW_EMPTY_FRAC | + DUK_S2N_FLAG_ALLOW_LEADING_ZERO; + + duk_numconv_parse(ctx, radix, s2n_flags); + return 1; +} + +/* + * Number checkers + */ + +DUK_INTERNAL duk_ret_t duk_bi_global_object_is_nan(duk_context *ctx) { + duk_double_t d = duk_to_number(ctx, 0); + duk_push_boolean(ctx, DUK_ISNAN(d)); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_global_object_is_finite(duk_context *ctx) { + duk_double_t d = duk_to_number(ctx, 0); + duk_push_boolean(ctx, DUK_ISFINITE(d)); + return 1; +} + +/* + * URI handling + */ + +DUK_INTERNAL duk_ret_t duk_bi_global_object_decode_uri(duk_context *ctx) { + return duk__transform_helper(ctx, duk__transform_callback_decode_uri, (void *) duk__decode_uri_reserved_table); +} + +DUK_INTERNAL duk_ret_t duk_bi_global_object_decode_uri_component(duk_context *ctx) { + return duk__transform_helper(ctx, duk__transform_callback_decode_uri, (void *) duk__decode_uri_component_reserved_table); +} + +DUK_INTERNAL duk_ret_t duk_bi_global_object_encode_uri(duk_context *ctx) { + return duk__transform_helper(ctx, duk__transform_callback_encode_uri, (void *) duk__encode_uriunescaped_table); +} + +DUK_INTERNAL duk_ret_t duk_bi_global_object_encode_uri_component(duk_context *ctx) { + return duk__transform_helper(ctx, duk__transform_callback_encode_uri, (void *) duk__encode_uricomponent_unescaped_table); +} + +#ifdef DUK_USE_SECTION_B +DUK_INTERNAL duk_ret_t duk_bi_global_object_escape(duk_context *ctx) { + return duk__transform_helper(ctx, duk__transform_callback_escape, (void *) NULL); +} + +DUK_INTERNAL duk_ret_t duk_bi_global_object_unescape(duk_context *ctx) { + return duk__transform_helper(ctx, duk__transform_callback_unescape, (void *) NULL); +} +#else /* DUK_USE_SECTION_B */ +DUK_INTERNAL duk_ret_t duk_bi_global_object_escape(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} + +DUK_INTERNAL duk_ret_t duk_bi_global_object_unescape(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_SECTION_B */ + +#if defined(DUK_USE_BROWSER_LIKE) && (defined(DUK_USE_FILE_IO) || defined(DUK_USE_DEBUGGER_SUPPORT)) +DUK_INTERNAL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_int_t magic; + duk_idx_t nargs; + const duk_uint8_t *buf; + duk_size_t sz_buf; + const char nl = (const char) DUK_ASC_LF; +#ifndef DUK_USE_PREFER_SIZE + duk_uint8_t buf_stack[256]; +#endif +#ifdef DUK_USE_FILE_IO + duk_file *f_out; +#endif + + magic = duk_get_current_magic(ctx); + DUK_UNREF(magic); + + nargs = duk_get_top(ctx); + + /* If argument count is 1 and first argument is a buffer, write the buffer + * as raw data into the file without a newline; this allows exact control + * over stdout/stderr without an additional entrypoint (useful for now). + * + * Otherwise current print/alert semantics are to ToString() coerce + * arguments, join them with a single space, and append a newline. + */ + + if (nargs == 1 && duk_is_buffer(ctx, 0)) { + buf = (const duk_uint8_t *) duk_get_buffer(ctx, 0, &sz_buf); + DUK_ASSERT(buf != NULL); + } else if (nargs > 0) { +#ifdef DUK_USE_PREFER_SIZE + /* Compact but lots of churn. */ + duk_push_hstring_stridx(thr, DUK_STRIDX_SPACE); + duk_insert(ctx, 0); + duk_join(ctx, nargs); + duk_push_string(thr, "\n"); + duk_concat(ctx, 2); + buf = (const duk_uint8_t *) duk_get_lstring(ctx, -1, &sz_buf); + DUK_ASSERT(buf != NULL); +#else /* DUK_USE_PREFER_SIZE */ + /* Higher footprint, less churn. */ + duk_idx_t i; + duk_size_t sz_str; + const duk_uint8_t *p_str; + duk_uint8_t *p; + + sz_buf = (duk_size_t) nargs; /* spaces (nargs - 1) + newline */ + for (i = 0; i < nargs; i++) { + (void) duk_to_lstring(ctx, i, &sz_str); + sz_buf += sz_str; + } + + if (sz_buf <= sizeof(buf_stack)) { + buf = (const duk_uint8_t *) buf_stack; + } else { + buf = (const duk_uint8_t *) duk_push_fixed_buffer(ctx, sz_buf); + DUK_ASSERT(buf != NULL); + } + + p = (duk_uint8_t *) buf; + for (i = 0; i < nargs; i++) { + p_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &sz_str); + DUK_ASSERT(p_str != NULL); + DUK_MEMCPY((void *) p, (const void *) p_str, sz_str); + p += sz_str; + *p++ = (duk_uint8_t) (i == nargs - 1 ? DUK_ASC_LF : DUK_ASC_SPACE); + } + DUK_ASSERT((const duk_uint8_t *) p == buf + sz_total); +#endif /* DUK_USE_PREFER_SIZE */ + } else { + buf = (const duk_uint8_t *) &nl; + sz_buf = 1; + } + + /* 'buf' contains the string to write, 'sz_buf' contains the length + * (which may be zero). + */ + DUK_ASSERT(buf != NULL); + + if (sz_buf == 0) { + return 0; + } + +#ifdef DUK_USE_FILE_IO + f_out = (magic ? DUK_STDERR : DUK_STDOUT); + DUK_FWRITE((const void *) buf, 1, (size_t) sz_buf, f_out); + DUK_FFLUSH(f_out); +#endif + +#if defined(DUK_USE_DEBUGGER_SUPPORT) && defined(DUK_USE_DEBUGGER_FWD_PRINTALERT) + if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) { + duk_debug_write_notify(thr, magic ? DUK_DBG_CMD_ALERT : DUK_DBG_CMD_PRINT); + duk_debug_write_string(thr, (const char *) buf, sz_buf); + duk_debug_write_eom(thr); + } +#endif + return 0; +} +#elif defined(DUK_USE_BROWSER_LIKE) /* print provider */ +DUK_INTERNAL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx) { + DUK_UNREF(ctx); + return 0; +} +#else /* print provider */ +DUK_INTERNAL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* print provider */ + +/* + * CommonJS require() and modules support + */ + +#if defined(DUK_USE_COMMONJS_MODULES) +DUK_LOCAL void duk__bi_global_resolve_module_id(duk_context *ctx, const char *req_id, const char *mod_id) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_size_t mod_id_len; + duk_size_t req_id_len; + duk_uint8_t buf_in[DUK_BI_COMMONJS_MODULE_ID_LIMIT]; + duk_uint8_t buf_out[DUK_BI_COMMONJS_MODULE_ID_LIMIT]; + duk_uint8_t *p; + duk_uint8_t *q; + + DUK_ASSERT(req_id != NULL); + /* mod_id may be NULL */ + DUK_ASSERT(sizeof(buf_out) >= sizeof(buf_in)); /* bound checking requires this */ + + /* + * A few notes on the algorithm: + * + * - Terms are not allowed to begin with a period unless the term + * is either '.' or '..'. This simplifies implementation (and + * is within CommonJS modules specification). + * + * - There are few output bound checks here. This is on purpose: + * we check the input length and rely on the output never being + * longer than the input, so we cannot run out of output space. + * + * - Non-ASCII characters are processed as individual bytes and + * need no special treatment. However, U+0000 terminates the + * algorithm; this is not an issue because U+0000 is not a + * desirable term character anyway. + */ + + /* + * Set up the resolution input which is the requested ID directly + * (if absolute or no current module path) or with current module + * ID prepended (if relative and current module path exists). + * + * Suppose current module is 'foo/bar' and relative path is './quux'. + * The 'bar' component must be replaced so the initial input here is + * 'foo/bar/.././quux'. + */ + + req_id_len = DUK_STRLEN(req_id); + if (mod_id != NULL && req_id[0] == '.') { + mod_id_len = DUK_STRLEN(mod_id); + if (mod_id_len + 4 + req_id_len + 1 >= sizeof(buf_in)) { + DUK_DD(DUK_DDPRINT("resolve error: current and requested module ID don't fit into resolve input buffer")); + goto resolve_error; + } + (void) DUK_SNPRINTF((char *) buf_in, sizeof(buf_in), "%s/../%s", (const char *) mod_id, (const char *) req_id); + } else { + if (req_id_len + 1 >= sizeof(buf_in)) { + DUK_DD(DUK_DDPRINT("resolve error: requested module ID doesn't fit into resolve input buffer")); + goto resolve_error; + } + (void) DUK_SNPRINTF((char *) buf_in, sizeof(buf_in), "%s", (const char *) req_id); + } + buf_in[sizeof(buf_in) - 1] = (duk_uint8_t) 0; + + DUK_DDD(DUK_DDDPRINT("input module id: '%s'", (const char *) buf_in)); + + /* + * Resolution loop. At the top of the loop we're expecting a valid + * term: '.', '..', or a non-empty identifier not starting with a period. + */ + + p = buf_in; + q = buf_out; + for (;;) { + duk_uint_fast8_t c; + + /* Here 'p' always points to the start of a term. */ + DUK_DDD(DUK_DDDPRINT("resolve loop top: p -> '%s', q=%p, buf_out=%p", + (const char *) p, (void *) q, (void *) buf_out)); + + c = *p++; + if (DUK_UNLIKELY(c == 0)) { + DUK_DD(DUK_DDPRINT("resolve error: requested ID must end with a non-empty term")); + goto resolve_error; + } else if (DUK_UNLIKELY(c == '.')) { + c = *p++; + if (c == '/') { + /* Term was '.' and is eaten entirely (including dup slashes). */ + goto eat_dup_slashes; + } + if (c == '.' && *p == '/') { + /* Term was '..', backtrack resolved name by one component. + * q[-1] = previous slash (or beyond start of buffer) + * q[-2] = last char of previous component (or beyond start of buffer) + */ + p++; /* eat (first) input slash */ + DUK_ASSERT(q >= buf_out); + if (q == buf_out) { + DUK_DD(DUK_DDPRINT("resolve error: term was '..' but nothing to backtrack")); + goto resolve_error; + } + DUK_ASSERT(*(q - 1) == '/'); + q--; /* backtrack to last output slash */ + for (;;) { + /* Backtrack to previous slash or start of buffer. */ + DUK_ASSERT(q >= buf_out); + if (q == buf_out) { + break; + } + if (*(q - 1) == '/') { + break; + } + q--; + } + goto eat_dup_slashes; + } + DUK_DD(DUK_DDPRINT("resolve error: term begins with '.' but is not '.' or '..' (not allowed now)")); + goto resolve_error; + } else if (DUK_UNLIKELY(c == '/')) { + /* e.g. require('/foo'), empty terms not allowed */ + DUK_DD(DUK_DDPRINT("resolve error: empty term (not allowed now)")); + goto resolve_error; + } else { + for (;;) { + /* Copy term name until end or '/'. */ + *q++ = c; + c = *p++; + if (DUK_UNLIKELY(c == 0)) { + goto loop_done; + } else if (DUK_UNLIKELY(c == '/')) { + *q++ = '/'; + break; + } else { + /* write on next loop */ + } + } + } + + eat_dup_slashes: + for (;;) { + /* eat dup slashes */ + c = *p; + if (DUK_LIKELY(c != '/')) { + break; + } + p++; + } + } + loop_done: + + duk_push_lstring(ctx, (const char *) buf_out, (size_t) (q - buf_out)); + return; + + resolve_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "cannot resolve module id: %s", (const char *) req_id); +} +#endif /* DUK_USE_COMMONJS_MODULES */ + +#if defined(DUK_USE_COMMONJS_MODULES) +DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { + const char *str_req_id; /* requested identifier */ + const char *str_mod_id; /* require.id of current module */ + duk_int_t pcall_rc; + + /* NOTE: we try to minimize code size by avoiding unnecessary pops, + * so the stack looks a bit cluttered in this function. DUK_ASSERT_TOP() + * assertions are used to ensure stack configuration is correct at each + * step. + */ + + /* + * Resolve module identifier into canonical absolute form. + */ + + str_req_id = duk_require_string(ctx, 0); + duk_push_current_function(ctx); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_ID); + str_mod_id = duk_get_string(ctx, 2); /* ignore non-strings */ + DUK_DDD(DUK_DDDPRINT("resolve module id: requested=%!T, currentmodule=%!T", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 2))); + duk__bi_global_resolve_module_id(ctx, str_req_id, str_mod_id); + str_req_id = NULL; + str_mod_id = NULL; + DUK_DDD(DUK_DDDPRINT("resolved module id: requested=%!T, currentmodule=%!T, result=%!T", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 2), + (duk_tval *) duk_get_tval(ctx, 3))); + + /* [ requested_id require require.id resolved_id ] */ + DUK_ASSERT_TOP(ctx, 4); + + /* + * Cached module check. + * + * If module has been loaded or its loading has already begun without + * finishing, return the same cached value ('exports'). The value is + * registered when module load starts so that circular references can + * be supported to some extent. + */ + + /* [ requested_id require require.id resolved_id ] */ + DUK_ASSERT_TOP(ctx, 4); + + duk_push_hobject_bidx(ctx, DUK_BIDX_DUKTAPE); + duk_get_prop_stridx(ctx, 4, DUK_STRIDX_MOD_LOADED); /* Duktape.modLoaded */ + (void) duk_require_hobject(ctx, 5); + + /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded ] */ + DUK_ASSERT_TOP(ctx, 6); + + duk_dup(ctx, 3); + if (duk_get_prop(ctx, 5)) { + /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded Duktape.modLoaded[id] ] */ + DUK_DD(DUK_DDPRINT("module already loaded: %!T", + (duk_tval *) duk_get_tval(ctx, 3))); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_EXPORTS); /* return module.exports */ + return 1; + } + + /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined ] */ + DUK_ASSERT_TOP(ctx, 7); + + /* + * Module not loaded (and loading not started previously). + * + * Create a new require() function with 'id' set to resolved ID + * of module being loaded. Also create 'exports' and 'module' + * tables but don't register exports to the loaded table yet. + * We don't want to do that unless the user module search callbacks + * succeeds in finding the module. + */ + + DUK_DD(DUK_DDPRINT("module not yet loaded: %!T", + (duk_tval *) duk_get_tval(ctx, 3))); + + /* Fresh require: require.id is left configurable (but not writable) + * so that is not easy to accidentally tweak it, but it can still be + * done with Object.defineProperty(). + * + * XXX: require.id could also be just made non-configurable, as there + * is no practical reason to touch it. + */ + duk_push_c_function(ctx, duk_bi_global_object_require, 1 /*nargs*/); + duk_dup(ctx, 3); + duk_xdef_prop_stridx(ctx, 7, DUK_STRIDX_ID, DUK_PROPDESC_FLAGS_C); /* a fresh require() with require.id = resolved target module id */ + + /* Module table: + * - module.exports: initial exports table (may be replaced by user) + * - module.id is non-writable and non-configurable, as the CommonJS + * spec suggests this if possible. + */ + duk_push_object(ctx); /* exports */ + duk_push_object(ctx); /* module */ + duk_dup(ctx, -2); + duk_xdef_prop_stridx(ctx, 9, DUK_STRIDX_EXPORTS, DUK_PROPDESC_FLAGS_WC); /* module.exports = exports */ + duk_dup(ctx, 3); /* resolved id: require(id) must return this same module */ + duk_xdef_prop_stridx(ctx, 9, DUK_STRIDX_ID, DUK_PROPDESC_FLAGS_NONE); /* module.id = resolved_id */ + duk_compact(ctx, 9); /* module table remains registered to modLoaded, minimize its size */ + + /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module ] */ + DUK_ASSERT_TOP(ctx, 10); + + /* Register the module table early to modLoaded[] so that we can + * support circular references even in modSearch(). If an error + * is thrown, we'll delete the reference. + */ + duk_dup(ctx, 3); + duk_dup(ctx, 9); + duk_put_prop(ctx, 5); /* Duktape.modLoaded[resolved_id] = module */ + + /* + * Call user provided module search function and build the wrapped + * module source code (if necessary). The module search function + * can be used to implement pure Ecmacsript, pure C, and mixed + * Ecmascript/C modules. + * + * The module search function can operate on the exports table directly + * (e.g. DLL code can register values to it). It can also return a + * string which is interpreted as module source code (if a non-string + * is returned the module is assumed to be a pure C one). If a module + * cannot be found, an error must be thrown by the user callback. + * + * Because Duktape.modLoaded[] already contains the module being + * loaded, circular references for C modules should also work + * (although expected to be quite rare). + */ + + duk_push_string(ctx, "(function(require,exports,module){"); + + /* Duktape.modSearch(resolved_id, fresh_require, exports, module). */ + duk_get_prop_stridx(ctx, 4, DUK_STRIDX_MOD_SEARCH); /* Duktape.modSearch */ + duk_dup(ctx, 3); + duk_dup(ctx, 7); + duk_dup(ctx, 8); + duk_dup(ctx, 9); /* [ ... Duktape.modSearch resolved_id fresh_require exports module ] */ + pcall_rc = duk_pcall(ctx, 4 /*nargs*/); /* -> [ ... source ] */ + DUK_ASSERT_TOP(ctx, 12); + + if (pcall_rc != DUK_EXEC_SUCCESS) { + /* Delete entry in Duktape.modLoaded[] and rethrow. */ + goto delete_rethrow; + } + + /* If user callback did not return source code, module loading + * is finished (user callback initialized exports table directly). + */ + if (!duk_is_string(ctx, 11)) { + /* User callback did not return source code, so module loading + * is finished: just update modLoaded with final module.exports + * and we're done. + */ + goto return_exports; + } + + /* Finish the wrapped module source. Force resolved module ID as the + * fileName so it gets set for functions defined within a module. This + * also ensures loggers created within the module get the module ID as + * their default logger name. + */ + duk_push_string(ctx, "})"); + duk_concat(ctx, 3); + duk_dup(ctx, 3); /* resolved module ID for fileName */ + duk_eval_raw(ctx, NULL, 0, DUK_COMPILE_EVAL); + + /* XXX: The module wrapper function is currently anonymous and is shown + * in stack traces. It would be nice to force it to match the module + * name (perhaps just the cleaned up last term). At the moment 'name' + * is write protected so we can't change it directly. Note that we must + * not introduce an actual name binding into the function scope (which + * is usually the case with a named function) because it would affect + * the scope seen by the module and shadow accesses to globals of the + * same name. + */ + + /* + * Call the wrapped module function. + * + * Use a protected call so that we can update Duktape.modLoaded[resolved_id] + * even if the module throws an error. + */ + + /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module mod_func ] */ + DUK_ASSERT_TOP(ctx, 11); + + duk_dup(ctx, 8); /* exports (this binding) */ + duk_dup(ctx, 7); /* fresh require (argument) */ + duk_get_prop_stridx(ctx, 9, DUK_STRIDX_EXPORTS); /* relookup exports from module.exports in case it was changed by modSearch */ + duk_dup(ctx, 9); /* module (argument) */ + + /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module mod_func exports fresh_require exports module ] */ + DUK_ASSERT_TOP(ctx, 15); + + pcall_rc = duk_pcall_method(ctx, 3 /*nargs*/); + if (pcall_rc != DUK_EXEC_SUCCESS) { + /* Module loading failed. Node.js will forget the module + * registration so that another require() will try to load + * the module again. Mimic that behavior. + */ + goto delete_rethrow; + } + + /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module result(ignored) ] */ + DUK_ASSERT_TOP(ctx, 11); + + /* fall through */ + + return_exports: + duk_get_prop_stridx(ctx, 9, DUK_STRIDX_EXPORTS); + return 1; /* return module.exports */ + + delete_rethrow: + duk_dup(ctx, 3); + duk_del_prop(ctx, 5); /* delete Duktape.modLoaded[resolved_id] */ + duk_throw(ctx); /* rethrow original error */ + return 0; /* not reachable */ +} +#else +DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_COMMONJS_MODULES */ +#line 1 "duk_bi_json.c" +/* + * JSON built-ins. + * + * See doc/json.rst. + * + * Codepoints are handled as duk_uint_fast32_t to ensure that the full + * unsigned 32-bit range is supported. This matters to e.g. JX. + * + * Input parsing doesn't do an explicit end-of-input check at all. This is + * safe: input string data is always NUL-terminated (0x00) and valid JSON + * inputs never contain plain NUL characters, so that as long as syntax checks + * are correct, we'll never read past the NUL. This approach reduces code size + * and improves parsing performance, but it's critical that syntax checks are + * indeed correct! + */ + +/* include removed: duk_internal.h */ + +/* + * Local defines and forward declarations. + */ + +#define DUK__JSON_DECSTR_BUFSIZE 128 +#define DUK__JSON_DECSTR_CHUNKSIZE 64 +#define DUK__JSON_ENCSTR_CHUNKSIZE 64 +#define DUK__JSON_STRINGIFY_BUFSIZE 128 +#define DUK__JSON_MAX_ESC_LEN 10 /* '\Udeadbeef' */ + +DUK_LOCAL_DECL void duk__dec_syntax_error(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL void duk__dec_eat_white(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL duk_uint8_t duk__dec_peek(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL duk_uint8_t duk__dec_get(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL duk_uint8_t duk__dec_get_nonwhite(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL duk_uint_fast32_t duk__dec_decode_hex_escape(duk_json_dec_ctx *js_ctx, duk_small_uint_t n); +DUK_LOCAL_DECL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx); +DUK_LOCAL_DECL void duk__dec_string(duk_json_dec_ctx *js_ctx); +#ifdef DUK_USE_JX +DUK_LOCAL_DECL void duk__dec_plain_string(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL void duk__dec_pointer(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL void duk__dec_buffer(duk_json_dec_ctx *js_ctx); +#endif +DUK_LOCAL_DECL void duk__dec_number(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL void duk__dec_objarr_entry(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL void duk__dec_objarr_exit(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL void duk__dec_object(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL void duk__dec_array(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL void duk__dec_value(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL void duk__dec_reviver_walk(duk_json_dec_ctx *js_ctx); + +DUK_LOCAL_DECL void duk__emit_1(duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch); +DUK_LOCAL_DECL void duk__emit_2(duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch1, duk_uint_fast8_t ch2); +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) +DUK_LOCAL_DECL void duk__unemit_1(duk_json_enc_ctx *js_ctx); +#endif +DUK_LOCAL_DECL void duk__emit_hstring(duk_json_enc_ctx *js_ctx, duk_hstring *h); +#if defined(DUK_USE_FASTINT) +DUK_LOCAL_DECL void duk__emit_cstring(duk_json_enc_ctx *js_ctx, const char *p); +#endif +DUK_LOCAL_DECL void duk__emit_stridx(duk_json_enc_ctx *js_ctx, duk_small_uint_t stridx); +DUK_LOCAL_DECL duk_uint8_t *duk__emit_esc_auto_fast(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp, duk_uint8_t *q); +DUK_LOCAL_DECL duk_bool_t duk__enc_key_quotes_needed(duk_hstring *h_key); +DUK_LOCAL_DECL void duk__enc_quote_string(duk_json_enc_ctx *js_ctx, duk_hstring *h_str); +DUK_LOCAL_DECL void duk__enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top); +DUK_LOCAL_DECL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top); +DUK_LOCAL_DECL void duk__enc_object(duk_json_enc_ctx *js_ctx); +DUK_LOCAL_DECL void duk__enc_array(duk_json_enc_ctx *js_ctx); +DUK_LOCAL_DECL duk_bool_t duk__enc_value1(duk_json_enc_ctx *js_ctx, duk_idx_t idx_holder); +DUK_LOCAL_DECL void duk__enc_value2(duk_json_enc_ctx *js_ctx); +DUK_LOCAL_DECL duk_bool_t duk__enc_allow_into_proplist(duk_tval *tv); +DUK_LOCAL_DECL void duk__enc_double(duk_json_enc_ctx *js_ctx); +#if defined(DUK_USE_FASTINT) +DUK_LOCAL_DECL void duk__enc_fastint_tval(duk_json_enc_ctx *js_ctx, duk_tval *tv); +#endif + +/* + * Helper tables + */ + +#if defined(DUK_USE_JSON_QUOTESTRING_FASTPATH) +DUK_LOCAL const duk_uint8_t duk__json_quotestr_lookup[256] = { + /* 0x00 ... 0x7f: as is + * 0x80: escape generically + * 0x81: slow path + * 0xa0 ... 0xff: backslash + one char + */ + + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xe2, 0xf4, 0xee, 0x80, 0xe6, 0xf2, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x20, 0x21, 0xa2, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0xdc, 0x5d, 0x5e, 0x5f, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81 +}; +#else /* DUK_USE_JSON_QUOTESTRING_FASTPATH */ +DUK_LOCAL const duk_uint8_t duk__json_quotestr_esc[14] = { + DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, + DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, + DUK_ASC_LC_B, DUK_ASC_LC_T, DUK_ASC_LC_N, DUK_ASC_NUL, + DUK_ASC_LC_F, DUK_ASC_LC_R +}; +#endif /* DUK_USE_JSON_QUOTESTRING_FASTPATH */ + +#if defined(DUK_USE_JSON_DECSTRING_FASTPATH) +DUK_LOCAL const duk_uint8_t duk__json_decstr_lookup[256] = { + /* 0x00: slow path + * other: as is + */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x20, 0x21, 0x00, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x00, 0x5d, 0x5e, 0x5f, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, + 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, + 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, + 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, + 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, + 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, + 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff +}; +#endif /* DUK_USE_JSON_DECSTRING_FASTPATH */ + +#if defined(DUK_USE_JSON_EATWHITE_FASTPATH) +DUK_LOCAL const duk_uint8_t duk__json_eatwhite_lookup[256] = { + /* 0x00: finish (non-white) + * 0x01: continue + */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; +#endif /* DUK_USE_JSON_EATWHITE_FASTPATH */ + +#if defined(DUK_USE_JSON_DECNUMBER_FASTPATH) +DUK_LOCAL const duk_uint8_t duk__json_decnumber_lookup[256] = { + /* 0x00: finish (not part of number) + * 0x01: continue + */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; +#endif /* DUK_USE_JSON_DECNUMBER_FASTPATH */ + +/* + * Parsing implementation. + * + * JSON lexer is now separate from duk_lexer.c because there are numerous + * small differences making it difficult to share the lexer. + * + * The parser here works with raw bytes directly; this works because all + * JSON delimiters are ASCII characters. Invalid xUTF-8 encoded values + * inside strings will be passed on without normalization; this is not a + * compliance concern because compliant inputs will always be valid + * CESU-8 encodings. + */ + +DUK_LOCAL void duk__dec_syntax_error(duk_json_dec_ctx *js_ctx) { + /* Shared handler to minimize parser size. Cause will be + * hidden, unfortunately, but we'll have an offset which + * is often quite enough. + */ + DUK_ERROR(js_ctx->thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_FMT_INVALID_JSON, + (long) (js_ctx->p - js_ctx->p_start)); +} + +DUK_LOCAL void duk__dec_eat_white(duk_json_dec_ctx *js_ctx) { + const duk_uint8_t *p; + duk_uint8_t t; + + p = js_ctx->p; + for (;;) { + DUK_ASSERT(p <= js_ctx->p_end); + t = *p; + +#if defined(DUK_USE_JSON_EATWHITE_FASTPATH) + /* This fast path is pretty marginal in practice. + * XXX: candidate for removal. + */ + DUK_ASSERT(duk__json_eatwhite_lookup[0x00] == 0x00); /* end-of-input breaks */ + if (duk__json_eatwhite_lookup[t] == 0) { + break; + } +#else /* DUK_USE_JSON_EATWHITE_FASTPATH */ + if (!(t == 0x20 || t == 0x0a || t == 0x0d || t == 0x09)) { + /* NUL also comes here. Comparison order matters, 0x20 + * is most common whitespace. + */ + break; + } +#endif /* DUK_USE_JSON_EATWHITE_FASTPATH */ + p++; + } + js_ctx->p = p; +} + +DUK_LOCAL duk_uint8_t duk__dec_peek(duk_json_dec_ctx *js_ctx) { + DUK_ASSERT(js_ctx->p <= js_ctx->p_end); + return *js_ctx->p; +} + +DUK_LOCAL duk_uint8_t duk__dec_get(duk_json_dec_ctx *js_ctx) { + DUK_ASSERT(js_ctx->p <= js_ctx->p_end); + return *js_ctx->p++; +} + +DUK_LOCAL duk_uint8_t duk__dec_get_nonwhite(duk_json_dec_ctx *js_ctx) { + duk__dec_eat_white(js_ctx); + return duk__dec_get(js_ctx); +} + +/* For JX, expressing the whole unsigned 32-bit range matters. */ +DUK_LOCAL duk_uint_fast32_t duk__dec_decode_hex_escape(duk_json_dec_ctx *js_ctx, duk_small_uint_t n) { + duk_small_uint_t i; + duk_uint_fast32_t res = 0; + duk_uint8_t x; + duk_small_int_t t; + + for (i = 0; i < n; i++) { + /* XXX: share helper from lexer; duk_lexer.c / hexval(). */ + + x = duk__dec_get(js_ctx); + DUK_DDD(DUK_DDDPRINT("decode_hex_escape: i=%ld, n=%ld, res=%ld, x=%ld", + (long) i, (long) n, (long) res, (long) x)); + + /* x == 0x00 (EOF) causes syntax_error */ + DUK_ASSERT(duk_hex_dectab[0] == -1); + t = duk_hex_dectab[x & 0xff]; + if (DUK_LIKELY(t >= 0)) { + res = (res * 16) + t; + } else { + /* catches EOF and invalid digits */ + goto syntax_error; + } + } + + DUK_DDD(DUK_DDDPRINT("final hex decoded value: %ld", (long) res)); + return res; + + syntax_error: + duk__dec_syntax_error(js_ctx); + DUK_UNREACHABLE(); + return 0; +} + +DUK_LOCAL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx) { + duk_hstring *h; + duk_uint8_t *p; + duk_uint8_t x, y; + + /* First character has already been eaten and checked by the caller. + * We can scan until a NUL in stridx string because no built-in strings + * have internal NULs. + */ + + DUK_ASSERT_DISABLE(stridx >= 0); /* unsigned */ + DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); + h = DUK_HTHREAD_GET_STRING(js_ctx->thr, stridx); + DUK_ASSERT(h != NULL); + + p = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h) + 1; + DUK_ASSERT(*(js_ctx->p - 1) == *(p - 1)); /* first character has been matched */ + + for (;;) { + x = *p; + if (x == 0) { + break; + } + y = duk__dec_get(js_ctx); + if (x != y) { + /* Catches EOF of JSON input. */ + goto syntax_error; + } + p++; + } + + return; + + syntax_error: + duk__dec_syntax_error(js_ctx); + DUK_UNREACHABLE(); +} + +DUK_LOCAL duk_small_int_t duk__dec_string_escape(duk_json_dec_ctx *js_ctx, duk_uint8_t **ext_p) { + duk_uint_fast32_t cp; + + /* EOF (-1) will be cast to an unsigned value first + * and then re-cast for the switch. In any case, it + * will match the default case (syntax error). + */ + cp = (duk_uint_fast32_t) duk__dec_get(js_ctx); + switch ((int) cp) { + case DUK_ASC_BACKSLASH: break; + case DUK_ASC_DOUBLEQUOTE: break; + case DUK_ASC_SLASH: break; + case DUK_ASC_LC_T: cp = 0x09; break; + case DUK_ASC_LC_N: cp = 0x0a; break; + case DUK_ASC_LC_R: cp = 0x0d; break; + case DUK_ASC_LC_F: cp = 0x0c; break; + case DUK_ASC_LC_B: cp = 0x08; break; + case DUK_ASC_LC_U: { + cp = duk__dec_decode_hex_escape(js_ctx, 4); + break; + } +#ifdef DUK_USE_JX + case DUK_ASC_UC_U: { + if (js_ctx->flag_ext_custom) { + cp = duk__dec_decode_hex_escape(js_ctx, 8); + } else { + return 1; /* syntax error */ + } + break; + } + case DUK_ASC_LC_X: { + if (js_ctx->flag_ext_custom) { + cp = duk__dec_decode_hex_escape(js_ctx, 2); + } else { + return 1; /* syntax error */ + } + break; + } +#endif /* DUK_USE_JX */ + default: + /* catches EOF (0x00) */ + return 1; /* syntax error */ + } + + DUK_RAW_WRITE_XUTF8(*ext_p, cp); + + return 0; +} + +DUK_LOCAL void duk__dec_string(duk_json_dec_ctx *js_ctx) { + duk_hthread *thr = js_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; + duk_uint8_t *q; + + /* '"' was eaten by caller */ + + /* Note that we currently parse -bytes-, not codepoints. + * All non-ASCII extended UTF-8 will encode to bytes >= 0x80, + * so they'll simply pass through (valid UTF-8 or not). + */ + + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(js_ctx->thr, bw, DUK__JSON_DECSTR_BUFSIZE); + q = DUK_BW_GET_PTR(js_ctx->thr, bw); + +#if defined(DUK_USE_JSON_DECSTRING_FASTPATH) + for (;;) { + duk_small_uint_t safe; + duk_uint8_t b, x; + const duk_uint8_t *p; + + /* Select a safe loop count where no output checks are + * needed assuming we won't encounter escapes. Input + * bound checks are not necessary as a NUL (guaranteed) + * will cause a SyntaxError before we read out of bounds. + */ + + safe = DUK__JSON_DECSTR_CHUNKSIZE; + + /* Ensure space for 1:1 output plus one escape. */ + q = DUK_BW_ENSURE_RAW(js_ctx->thr, bw, safe + DUK_UNICODE_MAX_XUTF8_LENGTH, q); + + p = js_ctx->p; /* temp copy, write back for next loop */ + for (;;) { + if (safe == 0) { + js_ctx->p = p; + break; + } + safe--; + + /* End of input (NUL) goes through slow path and causes SyntaxError. */ + DUK_ASSERT(duk__json_decstr_lookup[0] == 0x00); + + b = *p++; + x = (duk_small_int_t) duk__json_decstr_lookup[b]; + if (DUK_LIKELY(x != 0)) { + /* Fast path, decode as is. */ + *q++ = b; + } else if (b == DUK_ASC_DOUBLEQUOTE) { + js_ctx->p = p; + goto found_quote; + } else if (b == DUK_ASC_BACKSLASH) { + /* We've ensured space for one escaped input; then + * bail out and recheck (this makes escape handling + * quite slow but it's uncommon). + */ + js_ctx->p = p; + if (duk__dec_string_escape(js_ctx, &q) != 0) { + goto syntax_error; + } + break; + } else { + js_ctx->p = p; + goto syntax_error; + } + } + } + found_quote: +#else /* DUK_USE_JSON_DECSTRING_FASTPATH */ + for (;;) { + duk_uint8_t x; + + q = DUK_BW_ENSURE_RAW(js_ctx->thr, bw, DUK_UNICODE_MAX_XUTF8_LENGTH, q); + + x = duk__dec_get(js_ctx); + + if (x == DUK_ASC_DOUBLEQUOTE) { + break; + } else if (x == DUK_ASC_BACKSLASH) { + if (duk__dec_string_escape(js_ctx, &q) != 0) { + goto syntax_error; + } + } else if (x < 0x20) { + /* catches EOF (NUL) */ + goto syntax_error; + } else { + *q++ = (duk_uint8_t) x; + } + } +#endif /* DUK_USE_JSON_DECSTRING_FASTPATH */ + + DUK_BW_SETPTR_AND_COMPACT(js_ctx->thr, bw, q); + duk_to_string(ctx, -1); + + /* [ ... str ] */ + + return; + + syntax_error: + duk__dec_syntax_error(js_ctx); + DUK_UNREACHABLE(); +} + +#ifdef DUK_USE_JX +/* Decode a plain string consisting entirely of identifier characters. + * Used to parse plain keys (e.g. "foo: 123"). + */ +DUK_LOCAL void duk__dec_plain_string(duk_json_dec_ctx *js_ctx) { + duk_hthread *thr = js_ctx->thr; + duk_context *ctx = (duk_context *) thr; + const duk_uint8_t *p; + duk_small_int_t x; + + /* Caller has already eaten the first char so backtrack one byte. */ + + js_ctx->p--; /* safe */ + p = js_ctx->p; + + /* Here again we parse bytes, and non-ASCII UTF-8 will cause end of + * parsing (which is correct except if there are non-shortest encodings). + * There is also no need to check explicitly for end of input buffer as + * the input is NUL padded and NUL will exit the parsing loop. + * + * Because no unescaping takes place, we can just scan to the end of the + * plain string and intern from the input buffer. + */ + + for (;;) { + x = *p; + + /* There is no need to check the first character specially here + * (i.e. reject digits): the caller only accepts valid initial + * characters and won't call us if the first character is a digit. + * This also ensures that the plain string won't be empty. + */ + + if (!duk_unicode_is_identifier_part((duk_codepoint_t) x)) { + break; + } + p++; + } + + duk_push_lstring(ctx, (const char *) js_ctx->p, (duk_size_t) (p - js_ctx->p)); + js_ctx->p = p; + + /* [ ... str ] */ +} +#endif /* DUK_USE_JX */ + +#ifdef DUK_USE_JX +DUK_LOCAL void duk__dec_pointer(duk_json_dec_ctx *js_ctx) { + duk_hthread *thr = js_ctx->thr; + duk_context *ctx = (duk_context *) thr; + const duk_uint8_t *p; + duk_small_int_t x; + void *voidptr; + + /* Caller has already eaten the first character ('(') which we don't need. */ + + p = js_ctx->p; + + for (;;) { + x = *p; + + /* Assume that the native representation never contains a closing + * parenthesis. + */ + + if (x == DUK_ASC_RPAREN) { + break; + } else if (x <= 0) { + /* NUL term or -1 (EOF), NUL check would suffice */ + goto syntax_error; + } + p++; + } + + /* There is no need to NUL delimit the sscanf() call: trailing garbage is + * ignored and there is always a NUL terminator which will force an error + * if no error is encountered before it. It's possible that the scan + * would scan further than between [js_ctx->p,p[ though and we'd advance + * by less than the scanned value. + * + * Because pointers are platform specific, a failure to scan a pointer + * results in a null pointer which is a better placeholder than a missing + * value or an error. + */ + + voidptr = NULL; + (void) DUK_SSCANF((const char *) js_ctx->p, DUK_STR_FMT_PTR, &voidptr); + duk_push_pointer(ctx, voidptr); + js_ctx->p = p + 1; /* skip ')' */ + + /* [ ... ptr ] */ + + return; + + syntax_error: + duk__dec_syntax_error(js_ctx); + DUK_UNREACHABLE(); +} +#endif /* DUK_USE_JX */ + +#ifdef DUK_USE_JX +DUK_LOCAL void duk__dec_buffer(duk_json_dec_ctx *js_ctx) { + duk_hthread *thr = js_ctx->thr; + duk_context *ctx = (duk_context *) thr; + const duk_uint8_t *p; + duk_small_int_t x; + + /* Caller has already eaten the first character ('|') which we don't need. */ + + p = js_ctx->p; + + for (;;) { + x = *p; + + /* This loop intentionally does not ensure characters are valid + * ([0-9a-fA-F]) because the hex decode call below will do that. + */ + if (x == DUK_ASC_PIPE) { + break; + } else if (x <= 0) { + /* NUL term or -1 (EOF), NUL check would suffice */ + goto syntax_error; + } + p++; + } + + duk_push_lstring(ctx, (const char *) js_ctx->p, (duk_size_t) (p - js_ctx->p)); + duk_hex_decode(ctx, -1); + js_ctx->p = p + 1; /* skip '|' */ + + /* [ ... buf ] */ + + return; + + syntax_error: + duk__dec_syntax_error(js_ctx); + DUK_UNREACHABLE(); +} +#endif /* DUK_USE_JX */ + +/* Parse a number, other than NaN or +/- Infinity */ +DUK_LOCAL void duk__dec_number(duk_json_dec_ctx *js_ctx) { + duk_context *ctx = (duk_context *) js_ctx->thr; + const duk_uint8_t *p_start; + const duk_uint8_t *p; + duk_uint8_t x; + duk_small_uint_t s2n_flags; + + DUK_DDD(DUK_DDDPRINT("parse_number")); + + p_start = js_ctx->p; + + /* First pass parse is very lenient (e.g. allows '1.2.3') and extracts a + * string for strict number parsing. + */ + + p = js_ctx->p; + for (;;) { + x = *p; + + DUK_DDD(DUK_DDDPRINT("parse_number: p_start=%p, p=%p, p_end=%p, x=%ld", + (void *) p_start, (void *) p, + (void *) js_ctx->p_end, (long) x)); + +#if defined(DUK_USE_JSON_DECNUMBER_FASTPATH) + /* This fast path is pretty marginal in practice. + * XXX: candidate for removal. + */ + DUK_ASSERT(duk__json_decnumber_lookup[0x00] == 0x00); /* end-of-input breaks */ + if (duk__json_decnumber_lookup[x] == 0) { + break; + } +#else /* DUK_USE_JSON_DECNUMBER_FASTPATH */ + if (!((x >= DUK_ASC_0 && x <= DUK_ASC_9) || + (x == DUK_ASC_PERIOD || x == DUK_ASC_LC_E || + x == DUK_ASC_UC_E || x == DUK_ASC_MINUS || x == DUK_ASC_PLUS))) { + /* Plus sign must be accepted for positive exponents + * (e.g. '1.5e+2'). This clause catches NULs. + */ + break; + } +#endif /* DUK_USE_JSON_DECNUMBER_FASTPATH */ + p++; /* safe, because matched (NUL causes a break) */ + } + js_ctx->p = p; + + DUK_ASSERT(js_ctx->p > p_start); + duk_push_lstring(ctx, (const char *) p_start, (duk_size_t) (p - p_start)); + + s2n_flags = DUK_S2N_FLAG_ALLOW_EXP | + DUK_S2N_FLAG_ALLOW_MINUS | /* but don't allow leading plus */ + DUK_S2N_FLAG_ALLOW_FRAC; + + DUK_DDD(DUK_DDDPRINT("parse_number: string before parsing: %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + duk_numconv_parse(ctx, 10 /*radix*/, s2n_flags); + if (duk_is_nan(ctx, -1)) { + duk__dec_syntax_error(js_ctx); + } + DUK_ASSERT(duk_is_number(ctx, -1)); + DUK_DDD(DUK_DDDPRINT("parse_number: final number: %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + + /* [ ... num ] */ +} + +DUK_LOCAL void duk__dec_objarr_entry(duk_json_dec_ctx *js_ctx) { + duk_context *ctx = (duk_context *) js_ctx->thr; + duk_require_stack(ctx, DUK_JSON_DEC_REQSTACK); + + /* c recursion check */ + + DUK_ASSERT(js_ctx->recursion_depth >= 0); + DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); + if (js_ctx->recursion_depth >= js_ctx->recursion_limit) { + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_RANGE_ERROR, DUK_STR_JSONDEC_RECLIMIT); + } + js_ctx->recursion_depth++; +} + +DUK_LOCAL void duk__dec_objarr_exit(duk_json_dec_ctx *js_ctx) { + /* c recursion check */ + + DUK_ASSERT(js_ctx->recursion_depth > 0); + DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); + js_ctx->recursion_depth--; +} + +DUK_LOCAL void duk__dec_object(duk_json_dec_ctx *js_ctx) { + duk_context *ctx = (duk_context *) js_ctx->thr; + duk_int_t key_count; /* XXX: a "first" flag would suffice */ + duk_uint8_t x; + + DUK_DDD(DUK_DDDPRINT("parse_object")); + + duk__dec_objarr_entry(js_ctx); + + duk_push_object(ctx); + + /* Initial '{' has been checked and eaten by caller. */ + + key_count = 0; + for (;;) { + x = duk__dec_get_nonwhite(js_ctx); + + DUK_DDD(DUK_DDDPRINT("parse_object: obj=%!T, x=%ld, key_count=%ld", + (duk_tval *) duk_get_tval(ctx, -1), + (long) x, (long) key_count)); + + /* handle comma and closing brace */ + + if (x == DUK_ASC_COMMA && key_count > 0) { + /* accept comma, expect new value */ + x = duk__dec_get_nonwhite(js_ctx); + } else if (x == DUK_ASC_RCURLY) { + /* eat closing brace */ + break; + } else if (key_count == 0) { + /* accept anything, expect first value (EOF will be + * caught by key parsing below. + */ + ; + } else { + /* catches EOF (NUL) and initial comma */ + goto syntax_error; + } + + /* parse key and value */ + + if (x == DUK_ASC_DOUBLEQUOTE) { + duk__dec_string(js_ctx); +#ifdef DUK_USE_JX + } else if (js_ctx->flag_ext_custom && + duk_unicode_is_identifier_start((duk_codepoint_t) x)) { + duk__dec_plain_string(js_ctx); +#endif + } else { + goto syntax_error; + } + + /* [ ... obj key ] */ + + x = duk__dec_get_nonwhite(js_ctx); + if (x != DUK_ASC_COLON) { + goto syntax_error; + } + + duk__dec_value(js_ctx); + + /* [ ... obj key val ] */ + + duk_xdef_prop_wec(ctx, -3); + + /* [ ... obj ] */ + + key_count++; + } + + /* [ ... obj ] */ + + DUK_DDD(DUK_DDDPRINT("parse_object: final object is %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + + duk__dec_objarr_exit(js_ctx); + return; + + syntax_error: + duk__dec_syntax_error(js_ctx); + DUK_UNREACHABLE(); +} + +DUK_LOCAL void duk__dec_array(duk_json_dec_ctx *js_ctx) { + duk_context *ctx = (duk_context *) js_ctx->thr; + duk_uarridx_t arr_idx; + duk_uint8_t x; + + DUK_DDD(DUK_DDDPRINT("parse_array")); + + duk__dec_objarr_entry(js_ctx); + + duk_push_array(ctx); + + /* Initial '[' has been checked and eaten by caller. */ + + arr_idx = 0; + for (;;) { + x = duk__dec_get_nonwhite(js_ctx); + + DUK_DDD(DUK_DDDPRINT("parse_array: arr=%!T, x=%ld, arr_idx=%ld", + (duk_tval *) duk_get_tval(ctx, -1), + (long) x, (long) arr_idx)); + + /* handle comma and closing bracket */ + + if ((x == DUK_ASC_COMMA) && (arr_idx != 0)) { + /* accept comma, expect new value */ + ; + } else if (x == DUK_ASC_RBRACKET) { + /* eat closing bracket */ + break; + } else if (arr_idx == 0) { + /* accept anything, expect first value (EOF will be + * caught by duk__dec_value() below. + */ + js_ctx->p--; /* backtrack (safe) */ + } else { + /* catches EOF (NUL) and initial comma */ + goto syntax_error; + } + + /* parse value */ + + duk__dec_value(js_ctx); + + /* [ ... arr val ] */ + + duk_xdef_prop_index_wec(ctx, -2, arr_idx); + arr_idx++; + } + + /* Must set 'length' explicitly when using duk_xdef_prop_xxx() to + * set the values. + */ + + duk_set_length(ctx, -1, arr_idx); + + /* [ ... arr ] */ + + DUK_DDD(DUK_DDDPRINT("parse_array: final array is %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + + duk__dec_objarr_exit(js_ctx); + return; + + syntax_error: + duk__dec_syntax_error(js_ctx); + DUK_UNREACHABLE(); +} + +DUK_LOCAL void duk__dec_value(duk_json_dec_ctx *js_ctx) { + duk_context *ctx = (duk_context *) js_ctx->thr; + duk_uint8_t x; + + x = duk__dec_get_nonwhite(js_ctx); + + DUK_DDD(DUK_DDDPRINT("parse_value: initial x=%ld", (long) x)); + + /* Note: duk__dec_req_stridx() backtracks one char */ + + if (x == DUK_ASC_DOUBLEQUOTE) { + duk__dec_string(js_ctx); + } else if ((x >= DUK_ASC_0 && x <= DUK_ASC_9) || (x == DUK_ASC_MINUS)) { +#ifdef DUK_USE_JX + if (js_ctx->flag_ext_custom && x == DUK_ASC_MINUS && duk__dec_peek(js_ctx) == DUK_ASC_UC_I) { + duk__dec_req_stridx(js_ctx, DUK_STRIDX_MINUS_INFINITY); /* "-Infinity", '-' has been eaten */ + duk_push_number(ctx, -DUK_DOUBLE_INFINITY); + } else { +#else + { /* unconditional block */ +#endif + /* We already ate 'x', so backup one byte. */ + js_ctx->p--; /* safe */ + duk__dec_number(js_ctx); + } + } else if (x == DUK_ASC_LC_T) { + duk__dec_req_stridx(js_ctx, DUK_STRIDX_TRUE); + duk_push_true(ctx); + } else if (x == DUK_ASC_LC_F) { + duk__dec_req_stridx(js_ctx, DUK_STRIDX_FALSE); + duk_push_false(ctx); + } else if (x == DUK_ASC_LC_N) { + duk__dec_req_stridx(js_ctx, DUK_STRIDX_LC_NULL); + duk_push_null(ctx); +#ifdef DUK_USE_JX + } else if (js_ctx->flag_ext_custom && x == DUK_ASC_LC_U) { + duk__dec_req_stridx(js_ctx, DUK_STRIDX_LC_UNDEFINED); + duk_push_undefined(ctx); + } else if (js_ctx->flag_ext_custom && x == DUK_ASC_UC_N) { + duk__dec_req_stridx(js_ctx, DUK_STRIDX_NAN); + duk_push_nan(ctx); + } else if (js_ctx->flag_ext_custom && x == DUK_ASC_UC_I) { + duk__dec_req_stridx(js_ctx, DUK_STRIDX_INFINITY); + duk_push_number(ctx, DUK_DOUBLE_INFINITY); + } else if (js_ctx->flag_ext_custom && x == DUK_ASC_LPAREN) { + duk__dec_pointer(js_ctx); + } else if (js_ctx->flag_ext_custom && x == DUK_ASC_PIPE) { + duk__dec_buffer(js_ctx); +#endif + } else if (x == DUK_ASC_LCURLY) { + duk__dec_object(js_ctx); + } else if (x == DUK_ASC_LBRACKET) { + duk__dec_array(js_ctx); + } else { + /* catches EOF (NUL) */ + goto syntax_error; + } + + duk__dec_eat_white(js_ctx); + + /* [ ... val ] */ + return; + + syntax_error: + duk__dec_syntax_error(js_ctx); + DUK_UNREACHABLE(); +} + +/* Recursive value reviver, implements the Walk() algorithm. No C recursion + * check is done here because the initial parsing step will already ensure + * there is a reasonable limit on C recursion depth and hence object depth. + */ +DUK_LOCAL void duk__dec_reviver_walk(duk_json_dec_ctx *js_ctx) { + duk_context *ctx = (duk_context *) js_ctx->thr; + duk_hobject *h; + duk_uarridx_t i, arr_len; + + DUK_DDD(DUK_DDDPRINT("walk: top=%ld, holder=%!T, name=%!T", + (long) duk_get_top(ctx), + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + + duk_dup_top(ctx); + duk_get_prop(ctx, -3); /* -> [ ... holder name val ] */ + + h = duk_get_hobject(ctx, -1); + if (h != NULL) { + if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_ARRAY) { + arr_len = (duk_uarridx_t) duk_get_length(ctx, -1); + for (i = 0; i < arr_len; i++) { + /* [ ... holder name val ] */ + + DUK_DDD(DUK_DDDPRINT("walk: array, top=%ld, i=%ld, arr_len=%ld, holder=%!T, name=%!T, val=%!T", + (long) duk_get_top(ctx), (long) i, (long) arr_len, + (duk_tval *) duk_get_tval(ctx, -3), (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + + /* XXX: push_uint_string / push_u32_string */ + duk_dup_top(ctx); + duk_push_uint(ctx, (duk_uint_t) i); + duk_to_string(ctx, -1); /* -> [ ... holder name val val ToString(i) ] */ + duk__dec_reviver_walk(js_ctx); /* -> [ ... holder name val new_elem ] */ + + if (duk_is_undefined(ctx, -1)) { + duk_pop(ctx); + duk_del_prop_index(ctx, -1, i); + } else { + /* XXX: duk_xdef_prop_index_wec() would be more appropriate + * here but it currently makes some assumptions that might + * not hold (e.g. that previous property is not an accessor). + */ + duk_put_prop_index(ctx, -2, i); + } + } + } else { + /* [ ... holder name val ] */ + duk_enum(ctx, -1, DUK_ENUM_OWN_PROPERTIES_ONLY /*flags*/); + while (duk_next(ctx, -1 /*enum_index*/, 0 /*get_value*/)) { + DUK_DDD(DUK_DDDPRINT("walk: object, top=%ld, holder=%!T, name=%!T, val=%!T, enum=%!iT, obj_key=%!T", + (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, -5), + (duk_tval *) duk_get_tval(ctx, -4), (duk_tval *) duk_get_tval(ctx, -3), + (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1))); + + /* [ ... holder name val enum obj_key ] */ + duk_dup(ctx, -3); + duk_dup(ctx, -2); + + /* [ ... holder name val enum obj_key val obj_key ] */ + duk__dec_reviver_walk(js_ctx); + + /* [ ... holder name val enum obj_key new_elem ] */ + if (duk_is_undefined(ctx, -1)) { + duk_pop(ctx); + duk_del_prop(ctx, -3); + } else { + /* XXX: duk_xdef_prop_index_wec() would be more appropriate + * here but it currently makes some assumptions that might + * not hold (e.g. that previous property is not an accessor). + * + * Using duk_put_prop() works incorrectly with '__proto__' + * if the own property with that name has been deleted. This + * does not happen normally, but a clever reviver can trigger + * that, see complex reviver case in: test-bug-json-parse-__proto__.js. + */ + duk_put_prop(ctx, -4); + } + } + duk_pop(ctx); /* pop enum */ + } + } + + /* [ ... holder name val ] */ + + duk_dup(ctx, js_ctx->idx_reviver); + duk_insert(ctx, -4); /* -> [ ... reviver holder name val ] */ + duk_call_method(ctx, 2); /* -> [ ... res ] */ + + DUK_DDD(DUK_DDDPRINT("walk: top=%ld, result=%!T", + (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, -1))); +} + +/* + * Stringify implementation. + */ + +#define DUK__EMIT_1(js_ctx,ch) duk__emit_1((js_ctx), (duk_uint_fast8_t) (ch)) +#define DUK__EMIT_2(js_ctx,ch1,ch2) duk__emit_2((js_ctx), (duk_uint_fast8_t) (ch1), (duk_uint_fast8_t) (ch2)) +#define DUK__EMIT_HSTR(js_ctx,h) duk__emit_hstring((js_ctx), (h)) +#if defined(DUK_USE_FASTINT) || defined(DUK_USE_JX) || defined(DUK_USE_JC) +#define DUK__EMIT_CSTR(js_ctx,p) duk__emit_cstring((js_ctx), (p)) +#endif +#define DUK__EMIT_STRIDX(js_ctx,i) duk__emit_stridx((js_ctx), (i)) +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) +#define DUK__UNEMIT_1(js_ctx) duk__unemit_1((js_ctx)) +#endif + +DUK_LOCAL void duk__emit_1(duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch) { + DUK_BW_WRITE_ENSURE_U8(js_ctx->thr, &js_ctx->bw, ch); +} + +DUK_LOCAL void duk__emit_2(duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch1, duk_uint_fast8_t ch2) { + DUK_BW_WRITE_ENSURE_U8_2(js_ctx->thr, &js_ctx->bw, ch1, ch2); +} + +DUK_LOCAL void duk__emit_hstring(duk_json_enc_ctx *js_ctx, duk_hstring *h) { + DUK_BW_WRITE_ENSURE_HSTRING(js_ctx->thr, &js_ctx->bw, h); +} + +#if defined(DUK_USE_FASTINT) || defined(DUK_USE_JX) || defined(DUK_USE_JC) +DUK_LOCAL void duk__emit_cstring(duk_json_enc_ctx *js_ctx, const char *str) { + DUK_BW_WRITE_ENSURE_CSTRING(js_ctx->thr, &js_ctx->bw, str); +} +#endif + +DUK_LOCAL void duk__emit_stridx(duk_json_enc_ctx *js_ctx, duk_small_uint_t stridx) { + duk_hstring *h; + + DUK_ASSERT_DISABLE(stridx >= 0); /* unsigned */ + DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); + h = DUK_HTHREAD_GET_STRING(js_ctx->thr, stridx); + DUK_ASSERT(h != NULL); + + DUK_BW_WRITE_ENSURE_HSTRING(js_ctx->thr, &js_ctx->bw, h); +} + +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) +DUK_LOCAL void duk__unemit_1(duk_json_enc_ctx *js_ctx) { + DUK_ASSERT(DUK_BW_GET_SIZE(js_ctx->thr, &js_ctx->bw) >= 1); + DUK_BW_ADD_PTR(js_ctx->thr, &js_ctx->bw, -1); +} +#endif /* DUK_USE_JSON_STRINGIFY_FASTPATH */ + +#define DUK__MKESC(nybbles,esc1,esc2) \ + (((duk_uint_fast32_t) (nybbles)) << 16) | \ + (((duk_uint_fast32_t) (esc1)) << 8) | \ + ((duk_uint_fast32_t) (esc2)) + +DUK_LOCAL duk_uint8_t *duk__emit_esc_auto_fast(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp, duk_uint8_t *q) { + duk_uint_fast32_t tmp; + duk_small_uint_t dig; + + DUK_UNREF(js_ctx); + + /* Caller ensures space for at least DUK__JSON_MAX_ESC_LEN. */ + + /* Select appropriate escape format automatically, and set 'tmp' to a + * value encoding both the escape format character and the nybble count: + * + * (nybble_count << 16) | (escape_char1) | (escape_char2) + */ + +#ifdef DUK_USE_JX + if (DUK_LIKELY(cp < 0x100UL)) { + if (DUK_UNLIKELY(js_ctx->flag_ext_custom)) { + tmp = DUK__MKESC(2, DUK_ASC_BACKSLASH, DUK_ASC_LC_X); + } else { + tmp = DUK__MKESC(4, DUK_ASC_BACKSLASH, DUK_ASC_LC_U); + } + } else +#endif + if (DUK_LIKELY(cp < 0x10000UL)) { + tmp = DUK__MKESC(4, DUK_ASC_BACKSLASH, DUK_ASC_LC_U); + } else { +#ifdef DUK_USE_JX + if (DUK_LIKELY(js_ctx->flag_ext_custom)) { + tmp = DUK__MKESC(8, DUK_ASC_BACKSLASH, DUK_ASC_UC_U); + } else +#endif + { + /* In compatible mode and standard JSON mode, output + * something useful for non-BMP characters. This won't + * roundtrip but will still be more or less readable and + * more useful than an error. + */ + tmp = DUK__MKESC(8, DUK_ASC_UC_U, DUK_ASC_PLUS); + } + } + + *q++ = (duk_uint8_t) ((tmp >> 8) & 0xff); + *q++ = (duk_uint8_t) (tmp & 0xff); + + tmp = tmp >> 16; + while (tmp > 0) { + tmp--; + dig = (duk_small_uint_t) ((cp >> (4 * tmp)) & 0x0f); + *q++ = duk_lc_digits[dig]; + } + + return q; +} + +/* Check whether key quotes would be needed (custom encoding). */ +DUK_LOCAL duk_bool_t duk__enc_key_quotes_needed(duk_hstring *h_key) { + const duk_uint8_t *p, *p_start, *p_end; + duk_small_uint_t ch; + + DUK_ASSERT(h_key != NULL); + p_start = DUK_HSTRING_GET_DATA(h_key); + p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_key); + p = p_start; + + DUK_DDD(DUK_DDDPRINT("duk__enc_key_quotes_needed: h_key=%!O, p_start=%p, p_end=%p, p=%p", + (duk_heaphdr *) h_key, (void *) p_start, (void *) p_end, (void *) p)); + + /* Since we only accept ASCII characters, there is no need for + * actual decoding. A non-ASCII character will be >= 0x80 which + * causes a false return value immediately. + */ + + if (p == p_end) { + /* Zero length string is not accepted without quotes */ + return 1; + } + + while (p < p_end) { + ch = (duk_small_uint_t) (*p); + + /* Accept ASCII IdentifierStart and IdentifierPart if not first char. + * Function selection is a bit uncommon. + */ + if ((p > p_start ? duk_unicode_is_identifier_part : + duk_unicode_is_identifier_start) ((duk_codepoint_t) ch)) { + p++; + continue; + } + + /* all non-ASCII characters also come here (first byte >= 0x80) */ + return 1; + } + + return 0; +} + +/* The Quote(value) operation: quote a string. + * + * Stack policy: [ ] -> [ ]. + */ + +DUK_LOCAL void duk__enc_quote_string(duk_json_enc_ctx *js_ctx, duk_hstring *h_str) { + duk_hthread *thr = js_ctx->thr; + const duk_uint8_t *p, *p_start, *p_end, *p_now, *p_tmp; + duk_uint8_t *q; + duk_ucodepoint_t cp; /* typed for duk_unicode_decode_xutf8() */ + + DUK_DDD(DUK_DDDPRINT("duk__enc_quote_string: h_str=%!O", (duk_heaphdr *) h_str)); + + DUK_ASSERT(h_str != NULL); + p_start = DUK_HSTRING_GET_DATA(h_str); + p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_str); + p = p_start; + + DUK__EMIT_1(js_ctx, DUK_ASC_DOUBLEQUOTE); + + /* Encode string in small chunks, estimating the maximum expansion so that + * there's no need to ensure space while processing the chunk. + */ + + while (p < p_end) { + duk_size_t left, now, space; + + left = (duk_size_t) (p_end - p); + now = (left > DUK__JSON_ENCSTR_CHUNKSIZE ? + DUK__JSON_ENCSTR_CHUNKSIZE : left); + + /* Maximum expansion per input byte is 6: + * - invalid UTF-8 byte causes "\uXXXX" to be emitted (6/1 = 6). + * - 2-byte UTF-8 encodes as "\uXXXX" (6/2 = 3). + * - 4-byte UTF-8 encodes as "\Uxxxxxxxx" (10/4 = 2.5). + */ + space = now * 6; + q = DUK_BW_ENSURE_GETPTR(thr, &js_ctx->bw, space); + + p_now = p + now; + + while (p < p_now) { +#if defined(DUK_USE_JSON_QUOTESTRING_FASTPATH) + duk_uint8_t b; + + b = duk__json_quotestr_lookup[*p++]; + if (DUK_LIKELY(b < 0x80)) { + /* Most input bytes go through here. */ + *q++ = b; + } else if (b >= 0xa0) { + *q++ = DUK_ASC_BACKSLASH; + *q++ = (duk_uint8_t) (b - 0x80); + } else if (b == 0x80) { + cp = (duk_ucodepoint_t) (*(p - 1)); + q = duk__emit_esc_auto_fast(js_ctx, cp, q); + } else if (b == 0x7f && js_ctx->flag_ascii_only) { + /* 0x7F is special */ + DUK_ASSERT(b == 0x81); + cp = (duk_ucodepoint_t) 0x7f; + q = duk__emit_esc_auto_fast(js_ctx, cp, q); + } else { + DUK_ASSERT(b == 0x81); + p--; + + /* slow path is shared */ +#else /* DUK_USE_JSON_QUOTESTRING_FASTPATH */ + cp = *p; + + if (DUK_LIKELY(cp <= 0x7f)) { + /* ascii fast path: avoid decoding utf-8 */ + p++; + if (cp == 0x22 || cp == 0x5c) { + /* double quote or backslash */ + *q++ = DUK_ASC_BACKSLASH; + *q++ = (duk_uint8_t) cp; + } else if (cp < 0x20) { + duk_uint_fast8_t esc_char; + + /* This approach is a bit shorter than a straight + * if-else-ladder and also a bit faster. + */ + if (cp < (sizeof(duk__json_quotestr_esc) / sizeof(duk_uint8_t)) && + (esc_char = duk__json_quotestr_esc[cp]) != 0) { + *q++ = DUK_ASC_BACKSLASH; + *q++ = (duk_uint8_t) esc_char; + } else { + q = duk__emit_esc_auto_fast(js_ctx, cp, q); + } + } else if (cp == 0x7f && js_ctx->flag_ascii_only) { + q = duk__emit_esc_auto_fast(js_ctx, cp, q); + } else { + /* any other printable -> as is */ + *q++ = (duk_uint8_t) cp; + } + } else { + /* slow path is shared */ +#endif /* DUK_USE_JSON_QUOTESTRING_FASTPATH */ + + /* slow path decode */ + + /* If XUTF-8 decoding fails, treat the offending byte as a codepoint directly + * and go forward one byte. This is of course very lossy, but allows some kind + * of output to be produced even for internal strings which don't conform to + * XUTF-8. All standard Ecmascript strings are always CESU-8, so this behavior + * does not violate the Ecmascript specification. The behavior is applied to + * all modes, including Ecmascript standard JSON. Because the current XUTF-8 + * decoding is not very strict, this behavior only really affects initial bytes + * and truncated codepoints. + * + * Another alternative would be to scan forwards to start of next codepoint + * (or end of input) and emit just one replacement codepoint. + */ + + p_tmp = p; + if (!duk_unicode_decode_xutf8(thr, &p, p_start, p_end, &cp)) { + /* Decode failed. */ + cp = *p_tmp; + p = p_tmp + 1; + } + +#ifdef DUK_USE_NONSTD_JSON_ESC_U2028_U2029 + if (js_ctx->flag_ascii_only || cp == 0x2028 || cp == 0x2029) { +#else + if (js_ctx->flag_ascii_only) { +#endif + q = duk__emit_esc_auto_fast(js_ctx, cp, q); + } else { + /* as is */ + DUK_RAW_WRITE_XUTF8(q, cp); + } + } + } + + DUK_BW_SET_PTR(thr, &js_ctx->bw, q); + } + + DUK__EMIT_1(js_ctx, DUK_ASC_DOUBLEQUOTE); +} + +/* Encode a double (checked by caller) from stack top. Stack top may be + * replaced by serialized string but is not popped (caller does that). + */ +DUK_LOCAL void duk__enc_double(duk_json_enc_ctx *js_ctx) { + duk_context *ctx; + duk_tval *tv; + duk_double_t d; + duk_small_int_t c; + duk_small_int_t s; + duk_small_uint_t stridx; + duk_small_uint_t n2s_flags; + duk_hstring *h_str; + + DUK_ASSERT(js_ctx != NULL); + ctx = (duk_context *) js_ctx->thr; + DUK_ASSERT(ctx != NULL); + + /* Caller must ensure 'tv' is indeed a double and not a fastint! */ + tv = duk_get_tval(ctx, -1); + DUK_ASSERT(tv != NULL); + DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv)); + d = DUK_TVAL_GET_DOUBLE(tv); + + c = (duk_small_int_t) DUK_FPCLASSIFY(d); + s = (duk_small_int_t) DUK_SIGNBIT(d); + DUK_UNREF(s); + + if (DUK_LIKELY(!(c == DUK_FP_INFINITE || c == DUK_FP_NAN))) { + DUK_ASSERT(DUK_ISFINITE(d)); + +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + /* Negative zero needs special handling in JX/JC because + * it would otherwise serialize to '0', not '-0'. + */ + if (DUK_UNLIKELY(c == DUK_FP_ZERO && s != 0 && + (js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible))) { + duk_push_hstring_stridx(ctx, DUK_STRIDX_MINUS_ZERO); /* '-0' */ + } else +#endif /* DUK_USE_JX || DUK_USE_JC */ + { + n2s_flags = 0; + /* [ ... number ] -> [ ... string ] */ + duk_numconv_stringify(ctx, 10 /*radix*/, 0 /*digits*/, n2s_flags); + } + h_str = duk_to_hstring(ctx, -1); + DUK_ASSERT(h_str != NULL); + DUK__EMIT_HSTR(js_ctx, h_str); + return; + } + +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + if (!(js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM | + DUK_JSON_FLAG_EXT_COMPATIBLE))) { + stridx = DUK_STRIDX_LC_NULL; + } else if (c == DUK_FP_NAN) { + stridx = js_ctx->stridx_custom_nan; + } else if (s == 0) { + stridx = js_ctx->stridx_custom_posinf; + } else { + stridx = js_ctx->stridx_custom_neginf; + } +#else + stridx = DUK_STRIDX_LC_NULL; +#endif + DUK__EMIT_STRIDX(js_ctx, stridx); +} + +#if defined(DUK_USE_FASTINT) +/* Encode a fastint from duk_tval ptr, no value stack effects. */ +DUK_LOCAL void duk__enc_fastint_tval(duk_json_enc_ctx *js_ctx, duk_tval *tv) { + duk_int64_t v; + + /* Fastint range is signed 48-bit so longest value is -2^47 = -140737488355328 + * (16 chars long), longest signed 64-bit value is -2^63 = -9223372036854775808 + * (20 chars long). Alloc space for 64-bit range to be safe. + */ + duk_uint8_t buf[20 + 1]; + + /* Caller must ensure 'tv' is indeed a fastint! */ + DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv)); + v = DUK_TVAL_GET_FASTINT(tv); + + /* XXX: There are no format strings in duk_config.h yet, could add + * one for formatting duk_int64_t. For now, assumes "%lld" and that + * "long long" type exists. Could also rely on C99 directly but that + * won't work for older MSVC. + */ + DUK_SPRINTF((char *) buf, "%lld", (long long) v); + DUK__EMIT_CSTR(js_ctx, (const char *) buf); +} +#endif + +/* Shared entry handling for object/array serialization: indent/stepback, + * loop detection. + */ +DUK_LOCAL void duk__enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top) { + duk_context *ctx = (duk_context *) js_ctx->thr; + duk_hobject *h_target; + + *entry_top = duk_get_top(ctx); + + duk_require_stack(ctx, DUK_JSON_ENC_REQSTACK); + + /* loop check */ + + h_target = duk_get_hobject(ctx, -1); /* object or array */ + DUK_ASSERT(h_target != NULL); + + /* XXX: this check is very expensive, perhaps use a small + * array to make it faster for at least reasonably shallow + * objects? + */ + duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target); + duk_dup_top(ctx); /* -> [ ... voidp voidp ] */ + if (duk_has_prop(ctx, js_ctx->idx_loop)) { + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_TYPE_ERROR, DUK_STR_CYCLIC_INPUT); + } + duk_push_true(ctx); /* -> [ ... voidp true ] */ + duk_put_prop(ctx, js_ctx->idx_loop); /* -> [ ... ] */ + + /* c recursion check */ + + DUK_ASSERT(js_ctx->recursion_depth >= 0); + DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); + if (js_ctx->recursion_depth >= js_ctx->recursion_limit) { + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_RANGE_ERROR, DUK_STR_JSONENC_RECLIMIT); + } + js_ctx->recursion_depth++; + + /* figure out indent and stepback */ + + *h_indent = NULL; + *h_stepback = NULL; + if (js_ctx->h_gap != NULL) { + DUK_ASSERT(js_ctx->h_indent != NULL); + + *h_stepback = js_ctx->h_indent; + duk_push_hstring(ctx, js_ctx->h_indent); + duk_push_hstring(ctx, js_ctx->h_gap); + duk_concat(ctx, 2); + js_ctx->h_indent = duk_get_hstring(ctx, -1); + *h_indent = js_ctx->h_indent; + DUK_ASSERT(js_ctx->h_indent != NULL); + + /* The new indent string is left at value stack top, and will + * be popped by the shared exit handler. + */ + } else { + DUK_ASSERT(js_ctx->h_indent == NULL); + } + + DUK_DDD(DUK_DDDPRINT("shared entry finished: top=%ld, loop=%!T", + (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop))); +} + +/* Shared exit handling for object/array serialization. */ +DUK_LOCAL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top) { + duk_context *ctx = (duk_context *) js_ctx->thr; + duk_hobject *h_target; + + DUK_UNREF(h_indent); + + if (js_ctx->h_gap != NULL) { + DUK_ASSERT(js_ctx->h_indent != NULL); + DUK_ASSERT(*h_stepback != NULL); + DUK_ASSERT(*h_indent != NULL); + + js_ctx->h_indent = *h_stepback; /* previous js_ctx->h_indent */ + + /* Note: we don't need to pop anything because the duk_set_top() + * at the end will take care of it. + */ + } else { + DUK_ASSERT(js_ctx->h_indent == NULL); + DUK_ASSERT(*h_stepback == NULL); + DUK_ASSERT(*h_indent == NULL); + } + + /* c recursion check */ + + DUK_ASSERT(js_ctx->recursion_depth > 0); + DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); + js_ctx->recursion_depth--; + + /* loop check */ + + h_target = duk_get_hobject(ctx, *entry_top - 1); /* original target at entry_top - 1 */ + DUK_ASSERT(h_target != NULL); + + /* XXX: this check is very expensive */ + duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target); + duk_del_prop(ctx, js_ctx->idx_loop); /* -> [ ... ] */ + + /* restore stack top after unbalanced code paths */ + duk_set_top(ctx, *entry_top); + + DUK_DDD(DUK_DDDPRINT("shared entry finished: top=%ld, loop=%!T", + (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop))); +} + +/* The JO(value) operation: encode object. + * + * Stack policy: [ object ] -> [ object ]. + */ +DUK_LOCAL void duk__enc_object(duk_json_enc_ctx *js_ctx) { + duk_context *ctx = (duk_context *) js_ctx->thr; + duk_hstring *h_stepback; + duk_hstring *h_indent; + duk_hstring *h_key; + duk_idx_t entry_top; + duk_idx_t idx_obj; + duk_idx_t idx_keys; + duk_bool_t first; + duk_bool_t undef; + duk_uarridx_t arr_len, i; + + DUK_DDD(DUK_DDDPRINT("duk__enc_object: obj=%!T", (duk_tval *) duk_get_tval(ctx, -1))); + + duk__enc_objarr_entry(js_ctx, &h_stepback, &h_indent, &entry_top); + + idx_obj = entry_top - 1; + + if (js_ctx->idx_proplist >= 0) { + idx_keys = js_ctx->idx_proplist; + } else { + /* XXX: would be nice to enumerate an object at specified index */ + duk_dup(ctx, idx_obj); + (void) duk_hobject_get_enumerated_keys(ctx, DUK_ENUM_OWN_PROPERTIES_ONLY /*flags*/); /* [ ... target ] -> [ ... target keys ] */ + idx_keys = duk_require_normalize_index(ctx, -1); + /* leave stack unbalanced on purpose */ + } + + DUK_DDD(DUK_DDDPRINT("idx_keys=%ld, h_keys=%!T", + (long) idx_keys, (duk_tval *) duk_get_tval(ctx, idx_keys))); + + /* Steps 8-10 have been merged to avoid a "partial" variable. */ + + DUK__EMIT_1(js_ctx, DUK_ASC_LCURLY); + + /* XXX: keys is an internal object with all keys to be processed + * in its (gapless) array part. Because nobody can touch the keys + * object, we could iterate its array part directly (keeping in mind + * that it can be reallocated). + */ + + arr_len = (duk_uarridx_t) duk_get_length(ctx, idx_keys); + first = 1; + for (i = 0; i < arr_len; i++) { + duk_get_prop_index(ctx, idx_keys, i); /* -> [ ... key ] */ + + DUK_DDD(DUK_DDDPRINT("object property loop: holder=%!T, key=%!T", + (duk_tval *) duk_get_tval(ctx, idx_obj), + (duk_tval *) duk_get_tval(ctx, -1))); + + undef = duk__enc_value1(js_ctx, idx_obj); + if (undef) { + /* Value would yield 'undefined', so skip key altogether. + * Side effects have already happened. + */ + continue; + } + + /* [ ... key val ] */ + + if (first) { + first = 0; + } else { + DUK__EMIT_1(js_ctx, DUK_ASC_COMMA); + } + if (h_indent != NULL) { + DUK__EMIT_1(js_ctx, 0x0a); + DUK__EMIT_HSTR(js_ctx, h_indent); + } + + h_key = duk_get_hstring(ctx, -2); + DUK_ASSERT(h_key != NULL); + if (js_ctx->flag_avoid_key_quotes && !duk__enc_key_quotes_needed(h_key)) { + /* emit key as is */ + DUK__EMIT_HSTR(js_ctx, h_key); + } else { + duk__enc_quote_string(js_ctx, h_key); + } + + if (h_indent != NULL) { + DUK__EMIT_2(js_ctx, DUK_ASC_COLON, DUK_ASC_SPACE); + } else { + DUK__EMIT_1(js_ctx, DUK_ASC_COLON); + } + + /* [ ... key val ] */ + + duk__enc_value2(js_ctx); /* -> [ ... ] */ + } + + if (!first) { + if (h_stepback != NULL) { + DUK_ASSERT(h_indent != NULL); + DUK__EMIT_1(js_ctx, 0x0a); + DUK__EMIT_HSTR(js_ctx, h_stepback); + } + } + DUK__EMIT_1(js_ctx, DUK_ASC_RCURLY); + + duk__enc_objarr_exit(js_ctx, &h_stepback, &h_indent, &entry_top); + + DUK_ASSERT_TOP(ctx, entry_top); +} + +/* The JA(value) operation: encode array. + * + * Stack policy: [ array ] -> [ array ]. + */ +DUK_LOCAL void duk__enc_array(duk_json_enc_ctx *js_ctx) { + duk_context *ctx = (duk_context *) js_ctx->thr; + duk_hstring *h_stepback; + duk_hstring *h_indent; + duk_idx_t entry_top; + duk_idx_t idx_arr; + duk_bool_t undef; + duk_uarridx_t i, arr_len; + + DUK_DDD(DUK_DDDPRINT("duk__enc_array: array=%!T", + (duk_tval *) duk_get_tval(ctx, -1))); + + duk__enc_objarr_entry(js_ctx, &h_stepback, &h_indent, &entry_top); + + idx_arr = entry_top - 1; + + /* Steps 8-10 have been merged to avoid a "partial" variable. */ + + DUK__EMIT_1(js_ctx, DUK_ASC_LBRACKET); + + arr_len = (duk_uarridx_t) duk_get_length(ctx, idx_arr); + for (i = 0; i < arr_len; i++) { + DUK_DDD(DUK_DDDPRINT("array entry loop: array=%!T, h_indent=%!O, h_stepback=%!O, index=%ld, arr_len=%ld", + (duk_tval *) duk_get_tval(ctx, idx_arr), (duk_heaphdr *) h_indent, + (duk_heaphdr *) h_stepback, (long) i, (long) arr_len)); + + if (i > 0) { + DUK__EMIT_1(js_ctx, DUK_ASC_COMMA); + } + if (h_indent != NULL) { + DUK__EMIT_1(js_ctx, 0x0a); + DUK__EMIT_HSTR(js_ctx, h_indent); + } + + /* XXX: duk_push_uint_string() */ + duk_push_uint(ctx, (duk_uint_t) i); + duk_to_string(ctx, -1); /* -> [ ... key ] */ + undef = duk__enc_value1(js_ctx, idx_arr); + + if (undef) { + DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL); + } else { + /* [ ... key val ] */ + duk__enc_value2(js_ctx); + } + } + + if (arr_len > 0) { + if (h_stepback != NULL) { + DUK_ASSERT(h_indent != NULL); + DUK__EMIT_1(js_ctx, 0x0a); + DUK__EMIT_HSTR(js_ctx, h_stepback); + } + } + DUK__EMIT_1(js_ctx, DUK_ASC_RBRACKET); + + duk__enc_objarr_exit(js_ctx, &h_stepback, &h_indent, &entry_top); + + DUK_ASSERT_TOP(ctx, entry_top); +} + +/* The Str(key, holder) operation: encode value, steps 1-4. + * + * Returns non-zero if the value between steps 4 and 5 would yield an + * 'undefined' final result. This is useful in JO() because we need to + * get the side effects out, but need to know whether or not a key will + * be omitted from the serialization. + * + * Stack policy: [ ... key ] -> [ ... key val ] if retval == 0. + * -> [ ... ] if retval != 0. + */ +DUK_LOCAL duk_bool_t duk__enc_value1(duk_json_enc_ctx *js_ctx, duk_idx_t idx_holder) { + duk_context *ctx = (duk_context *) js_ctx->thr; + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h; + duk_tval *tv; + duk_small_int_t c; + + DUK_DDD(DUK_DDDPRINT("duk__enc_value1: idx_holder=%ld, holder=%!T, key=%!T", + (long) idx_holder, (duk_tval *) duk_get_tval(ctx, idx_holder), + (duk_tval *) duk_get_tval(ctx, -1))); + + DUK_UNREF(thr); + + duk_dup_top(ctx); /* -> [ ... key key ] */ + duk_get_prop(ctx, idx_holder); /* -> [ ... key val ] */ + + DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1))); + + h = duk_get_hobject_or_lfunc_coerce(ctx, -1); + if (h != NULL) { + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_TO_JSON); + h = duk_get_hobject_or_lfunc_coerce(ctx, -1); /* toJSON() can also be a lightfunc */ + + if (h != NULL && DUK_HOBJECT_IS_CALLABLE(h)) { + DUK_DDD(DUK_DDDPRINT("value is object, has callable toJSON() -> call it")); + duk_dup(ctx, -2); /* -> [ ... key val toJSON val ] */ + duk_dup(ctx, -4); /* -> [ ... key val toJSON val key ] */ + duk_call_method(ctx, 1); /* -> [ ... key val val' ] */ + duk_remove(ctx, -2); /* -> [ ... key val' ] */ + } else { + duk_pop(ctx); + } + } + + /* [ ... key val ] */ + + DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1))); + + if (js_ctx->h_replacer) { + /* XXX: here a "slice copy" would be useful */ + DUK_DDD(DUK_DDDPRINT("replacer is set, call replacer")); + duk_push_hobject(ctx, js_ctx->h_replacer); /* -> [ ... key val replacer ] */ + duk_dup(ctx, idx_holder); /* -> [ ... key val replacer holder ] */ + duk_dup(ctx, -4); /* -> [ ... key val replacer holder key ] */ + duk_dup(ctx, -4); /* -> [ ... key val replacer holder key val ] */ + duk_call_method(ctx, 2); /* -> [ ... key val val' ] */ + duk_remove(ctx, -2); /* -> [ ... key val' ] */ + } + + /* [ ... key val ] */ + + DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1))); + + tv = duk_get_tval(ctx, -1); + DUK_ASSERT(tv != NULL); + if (DUK_TVAL_IS_OBJECT(tv)) { + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + + if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + duk_hbufferobject *h_bufobj; + h_bufobj = (duk_hbufferobject *) h; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + if (h_bufobj->buf == NULL || !DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)) { + duk_push_null(ctx); + } else if (DUK_HBUFFEROBJECT_FULL_SLICE(h_bufobj)) { + duk_push_hbuffer(ctx, h_bufobj->buf); + } else { + /* This is not very good because we're making a copy + * for serialization, but only for proper views. + * Better support would be to serialize slices + * directly but since we only push a raw buffer + * here we can't convey the slice offset/length. + */ + duk_uint8_t *p_buf; + + p_buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, h_bufobj->length); + DUK_MEMCPY((void *) p_buf, + (const void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj)), + h_bufobj->length); + } + duk_remove(ctx, -2); + } else { + c = (duk_small_int_t) DUK_HOBJECT_GET_CLASS_NUMBER(h); + switch ((int) c) { + case DUK_HOBJECT_CLASS_NUMBER: { + DUK_DDD(DUK_DDDPRINT("value is a Number object -> coerce with ToNumber()")); + duk_to_number(ctx, -1); + break; + } + case DUK_HOBJECT_CLASS_STRING: { + DUK_DDD(DUK_DDDPRINT("value is a String object -> coerce with ToString()")); + duk_to_string(ctx, -1); + break; + } +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + case DUK_HOBJECT_CLASS_POINTER: +#endif + case DUK_HOBJECT_CLASS_BOOLEAN: { + DUK_DDD(DUK_DDDPRINT("value is a Boolean/Buffer/Pointer object -> get internal value")); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE); + duk_remove(ctx, -2); + break; + } + } /* end switch */ + } + } + + /* [ ... key val ] */ + + DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1))); + + if (duk_check_type_mask(ctx, -1, js_ctx->mask_for_undefined)) { + /* will result in undefined */ + DUK_DDD(DUK_DDDPRINT("-> will result in undefined (type mask check)")); + goto undef; + } + + /* functions are detected specially */ + h = duk_get_hobject(ctx, -1); + if (h != NULL && DUK_HOBJECT_IS_CALLABLE(h)) { + if (js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM | + DUK_JSON_FLAG_EXT_COMPATIBLE)) { + /* function will be serialized to custom format */ + } else { + /* functions are not serialized, results in undefined */ + DUK_DDD(DUK_DDDPRINT("-> will result in undefined (function)")); + goto undef; + } + } + + DUK_DDD(DUK_DDDPRINT("-> will not result in undefined")); + return 0; + + undef: + duk_pop_2(ctx); + return 1; +} + +/* The Str(key, holder) operation: encode value, steps 5-10. + * + * This must not be called unless duk__enc_value1() returns non-zero. + * If so, this is guaranteed to produce a non-undefined result. + * Non-standard encodings (e.g. for undefined) are only used if + * duk__enc_value1() indicates they are accepted; they're not + * checked or asserted here again. + * + * Stack policy: [ ... key val ] -> [ ... ]. + */ +DUK_LOCAL void duk__enc_value2(duk_json_enc_ctx *js_ctx) { + duk_context *ctx = (duk_context *) js_ctx->thr; + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + + DUK_UNREF(thr); + + DUK_DDD(DUK_DDDPRINT("duk__enc_value2: key=%!T, val=%!T", + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + + /* [ ... key val ] */ + + tv = duk_get_tval(ctx, -1); + DUK_ASSERT(tv != NULL); + + switch (DUK_TVAL_GET_TAG(tv)) { +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + /* When JX/JC not in use, duk__enc_value1 will block undefined values. */ + case DUK_TAG_UNDEFINED: { + DUK__EMIT_STRIDX(js_ctx, js_ctx->stridx_custom_undefined); + break; + } +#endif + case DUK_TAG_NULL: { + DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL); + break; + } + case DUK_TAG_BOOLEAN: { + DUK__EMIT_STRIDX(js_ctx, DUK_TVAL_GET_BOOLEAN(tv) ? + DUK_STRIDX_TRUE : DUK_STRIDX_FALSE); + break; + } +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + /* When JX/JC not in use, duk__enc_value1 will block pointer values. */ + case DUK_TAG_POINTER: { + char buf[64]; /* XXX: how to figure correct size? */ + const char *fmt; + void *ptr = DUK_TVAL_GET_POINTER(tv); + + DUK_MEMZERO(buf, sizeof(buf)); + + /* The #ifdef clutter here needs to handle the three cases: + * (1) JX+JC, (2) JX only, (3) JC only. + */ +#if defined(DUK_USE_JX) && defined(DUK_USE_JC) + if (js_ctx->flag_ext_custom) +#endif +#if defined(DUK_USE_JX) + { + fmt = ptr ? "(%p)" : "(null)"; + } +#endif +#if defined(DUK_USE_JX) && defined(DUK_USE_JC) + else +#endif +#if defined(DUK_USE_JC) + { + fmt = ptr ? "{\"_ptr\":\"%p\"}" : "{\"_ptr\":\"null\"}"; + } +#endif + + /* When ptr == NULL, the format argument is unused. */ + DUK_SNPRINTF(buf, sizeof(buf) - 1, fmt, ptr); /* must not truncate */ + DUK__EMIT_CSTR(js_ctx, buf); + break; + } +#endif /* DUK_USE_JX || DUK_USE_JC */ + case DUK_TAG_STRING: { + duk_hstring *h = DUK_TVAL_GET_STRING(tv); + DUK_ASSERT(h != NULL); + + duk__enc_quote_string(js_ctx, h); + break; + } + case DUK_TAG_OBJECT: { + duk_hobject *h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + if (DUK_HOBJECT_IS_CALLABLE(h)) { + /* We only get here when doing non-standard JSON encoding */ + DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible); + DUK__EMIT_STRIDX(js_ctx, js_ctx->stridx_custom_function); + } else /* continues below */ +#endif + if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_ARRAY) { + duk__enc_array(js_ctx); + } else { + duk__enc_object(js_ctx); + } + break; + } +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + /* When JX/JC not in use, duk__enc_value1 will block buffer values. */ + case DUK_TAG_BUFFER: { + /* Buffer values are encoded in (lowercase) hex to make the + * binary data readable. Base64 or similar would be more + * compact but less readable, and the point of JX/JC + * variants is to be as useful to a programmer as possible. + */ + + /* The #ifdef clutter here needs to handle the three cases: + * (1) JX+JC, (2) JX only, (3) JC only. + */ +#if defined(DUK_USE_JX) && defined(DUK_USE_JC) + if (js_ctx->flag_ext_custom) +#endif +#if defined(DUK_USE_JX) + { + duk_uint8_t *p, *p_end; + duk_small_uint_t x; + duk_hbuffer *h; + duk_uint8_t *q; + duk_size_t space; + + h = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h != NULL); + p = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h); + p_end = p + DUK_HBUFFER_GET_SIZE(h); + + space = 1 + DUK_HBUFFER_GET_SIZE(h) * 2 + 1; + DUK_ASSERT(DUK_HBUFFER_MAX_BYTELEN <= 0x7ffffffeUL); + DUK_ASSERT((space - 2) / 2 == DUK_HBUFFER_GET_SIZE(h)); /* overflow not possible, buffer limits */ + q = DUK_BW_ENSURE_GETPTR(thr, &js_ctx->bw, space); + + *q++ = DUK_ASC_PIPE; + while (p < p_end) { + x = *p++; + *q++ = duk_lc_digits[(x >> 4) & 0x0f]; + *q++ = duk_lc_digits[x & 0x0f]; + } + *q++ = DUK_ASC_PIPE; + + DUK_BW_SET_PTR(thr, &js_ctx->bw, q); + } +#endif +#if defined(DUK_USE_JX) && defined(DUK_USE_JC) + else +#endif +#if defined(DUK_USE_JC) + { + DUK_ASSERT(js_ctx->flag_ext_compatible); + duk_hex_encode(ctx, -1); + DUK__EMIT_CSTR(js_ctx, "{\"_buf\":"); + duk__enc_quote_string(js_ctx, duk_require_hstring(ctx, -1)); + DUK__EMIT_1(js_ctx, DUK_ASC_RCURLY); + } +#endif + break; + } +#endif /* DUK_USE_JX || DUK_USE_JC */ + case DUK_TAG_LIGHTFUNC: { +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + /* We only get here when doing non-standard JSON encoding */ + DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible); + DUK__EMIT_STRIDX(js_ctx, js_ctx->stridx_custom_function); +#else + /* Standard JSON omits functions */ + DUK_UNREACHABLE(); +#endif + break; + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: + /* Number serialization has a significant impact relative to + * other fast path code, so careful fast path for fastints. + */ + duk__enc_fastint_tval(js_ctx, tv); + break; +#endif + default: { + /* number */ + /* XXX: A fast path for usual integers would be useful when + * fastint support is not enabled. + */ + duk__enc_double(js_ctx); + break; + } + } + + /* [ ... key val ] -> [ ... ] */ + + duk_pop_2(ctx); +} + +/* E5 Section 15.12.3, main algorithm, step 4.b.ii steps 1-4. */ +DUK_LOCAL duk_bool_t duk__enc_allow_into_proplist(duk_tval *tv) { + duk_hobject *h; + duk_small_int_t c; + + DUK_ASSERT(tv != NULL); + if (DUK_TVAL_IS_STRING(tv) || DUK_TVAL_IS_NUMBER(tv)) { + return 1; + } else if (DUK_TVAL_IS_OBJECT(tv)) { + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + c = (duk_small_int_t) DUK_HOBJECT_GET_CLASS_NUMBER(h); + if (c == DUK_HOBJECT_CLASS_STRING || c == DUK_HOBJECT_CLASS_NUMBER) { + return 1; + } + } + + return 0; +} + +/* + * JSON.stringify() fast path + */ + +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) +DUK_LOCAL duk_bool_t duk__json_stringify_fast_value(duk_json_enc_ctx *js_ctx, duk_tval *tv) { + duk_uint_fast32_t i, n; + + DUK_DDD(DUK_DDDPRINT("stringify fast: %!T", tv)); + + DUK_ASSERT(js_ctx != NULL); + DUK_ASSERT(js_ctx->thr != NULL); +#if defined(DUK_USE_JX) + DUK_ASSERT(js_ctx->flag_ext_custom == 0); +#endif +#if defined(DUK_USE_JC) + DUK_ASSERT(js_ctx->flag_ext_compatible == 0); +#endif + + restart_match: + DUK_ASSERT(tv != NULL); + + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: { + goto emit_undefined; + } + case DUK_TAG_NULL: { + DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL); + break; + } + case DUK_TAG_BOOLEAN: { + DUK__EMIT_STRIDX(js_ctx, DUK_TVAL_GET_BOOLEAN(tv) ? + DUK_STRIDX_TRUE : DUK_STRIDX_FALSE); + break; + } + case DUK_TAG_STRING: { + duk_hstring *h; + + h = DUK_TVAL_GET_STRING(tv); + DUK_ASSERT(h != NULL); + duk__enc_quote_string(js_ctx, h); + break; + } + case DUK_TAG_OBJECT: { + duk_hobject *obj; + duk_tval *tv_val; + duk_bool_t emitted = 0; + duk_uint32_t c_bit, c_all, c_array, c_unbox, c_undef, c_object; + + /* For objects JSON.stringify() only looks for own, enumerable + * properties which is nice for the fast path here. + * + * For arrays JSON.stringify() uses [[Get]] so it will actually + * inherit properties during serialization! This fast path + * supports gappy arrays as long as there's no actual inherited + * property (which might be a getter etc). + * + * Since recursion only happens for objects, we can have both + * recursion and loop checks here. We use a simple, depth-limited + * loop check in the fast path because the object-based tracking + * is very slow (when tested, it accounted for 50% of fast path + * execution time for input data with a lot of small objects!). + */ + + obj = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(obj != NULL); + + /* We rely on a few object flag / class number relationships here, + * assert for them. + */ + DUK_ASSERT_HOBJECT_VALID(obj); + + /* Once recursion depth is increased, exit path must decrease + * it (though it's OK to abort the fast path). + */ + + DUK_ASSERT(js_ctx->recursion_depth >= 0); + DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); + if (js_ctx->recursion_depth >= js_ctx->recursion_limit) { + DUK_DD(DUK_DDPRINT("fast path recursion limit")); + DUK_ERROR(js_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_JSONDEC_RECLIMIT); + } + + for (i = 0, n = (duk_uint_fast32_t) js_ctx->recursion_depth; i < n; i++) { + if (js_ctx->visiting[i] == obj) { + DUK_DD(DUK_DDPRINT("fast path loop detect")); + DUK_ERROR(js_ctx->thr, DUK_ERR_TYPE_ERROR, DUK_STR_CYCLIC_INPUT); + } + } + + /* Guaranteed by recursion_limit setup so we don't have to + * check twice. + */ + DUK_ASSERT(js_ctx->recursion_depth < DUK_JSON_ENC_LOOPARRAY); + js_ctx->visiting[js_ctx->recursion_depth] = obj; + js_ctx->recursion_depth++; + + /* If object has a .toJSON() property, we can't be certain + * that it wouldn't mutate any value arbitrarily, so bail + * out of the fast path. + * + * If an object is a Proxy we also can't avoid side effects + * so abandon. + */ + if (duk_hobject_hasprop_raw(js_ctx->thr, obj, DUK_HTHREAD_STRING_TO_JSON(js_ctx->thr)) || + DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj)) { + DUK_DD(DUK_DDPRINT("object has a .toJSON property or object is a Proxy, abort fast path")); + goto abort_fastpath; + } + + /* We could use a switch-case for the class number but it turns out + * a small if-else ladder on class masks is better. The if-ladder + * should be in order of relevancy. + */ + + DUK_ASSERT(DUK_HOBJECT_CLASS_MAX <= 31); + c_all = DUK_HOBJECT_CMASK_ALL; + c_array = DUK_HOBJECT_CMASK_ARRAY; + c_unbox = DUK_HOBJECT_CMASK_NUMBER | + DUK_HOBJECT_CMASK_STRING | + DUK_HOBJECT_CMASK_BOOLEAN; + c_undef = DUK_HOBJECT_CMASK_FUNCTION | + DUK_HOBJECT_CMASK_ALL_BUFFEROBJECTS; + c_object = c_all & ~(c_array | c_unbox | c_undef); + + c_bit = DUK_HOBJECT_GET_CLASS_MASK(obj); + if (c_bit & c_object) { + /* All other object types. */ + DUK__EMIT_1(js_ctx, DUK_ASC_LCURLY); + + /* A non-Array object should not have an array part in practice. + * But since it is supported internally (and perhaps used at some + * point), check and abandon if that's the case. + */ + if (DUK_HOBJECT_HAS_ARRAY_PART(obj)) { + DUK_DD(DUK_DDPRINT("non-Array object has array part, abort fast path")); + goto abort_fastpath; + } + + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(obj); i++) { + duk_hstring *k; + duk_size_t prev_size; + + k = DUK_HOBJECT_E_GET_KEY(js_ctx->thr->heap, obj, i); + if (!k) { + continue; + } + if (!DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(js_ctx->thr->heap, obj, i)) { + continue; + } + if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(js_ctx->thr->heap, obj, i)) { + /* Getter might have arbitrary side effects, + * so bail out. + */ + DUK_DD(DUK_DDPRINT("property is an accessor, abort fast path")); + goto abort_fastpath; + } + if (DUK_HSTRING_HAS_INTERNAL(k)) { + continue; + } + + tv_val = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(js_ctx->thr->heap, obj, i); + + prev_size = DUK_BW_GET_SIZE(js_ctx->thr, &js_ctx->bw); + duk__enc_quote_string(js_ctx, k); + DUK__EMIT_1(js_ctx, DUK_ASC_COLON); + if (duk__json_stringify_fast_value(js_ctx, tv_val) == 0) { + DUK_DD(DUK_DDPRINT("prop value not supported, rewind key and colon")); + DUK_BW_SET_SIZE(js_ctx->thr, &js_ctx->bw, prev_size); + } else { + DUK__EMIT_1(js_ctx, DUK_ASC_COMMA); + emitted = 1; + } + } + + /* If any non-Array value had enumerable virtual own + * properties, they should be serialized here. Standard + * types don't. + */ + + if (emitted) { + DUK__UNEMIT_1(js_ctx); /* eat trailing comma */ + } + DUK__EMIT_1(js_ctx, DUK_ASC_RCURLY); + } else if (c_bit & c_array) { + duk_uint_fast32_t arr_len; + duk_uint_fast32_t asize; + + DUK__EMIT_1(js_ctx, DUK_ASC_LBRACKET); + + /* Assume arrays are dense in the fast path. */ + if (!DUK_HOBJECT_HAS_ARRAY_PART(obj)) { + DUK_DD(DUK_DDPRINT("Array object is sparse, abort fast path")); + goto abort_fastpath; + } + + arr_len = (duk_uint_fast32_t) duk_hobject_get_length(js_ctx->thr, obj); + asize = (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(obj); + if (arr_len > asize) { + /* Array length is larger than 'asize'. This shouldn't + * happen in practice. Bail out just in case. + */ + DUK_DD(DUK_DDPRINT("arr_len > asize, abort fast path")); + goto abort_fastpath; + } + /* Array part may be larger than 'length'; if so, iterate + * only up to array 'length'. + */ + for (i = 0; i < arr_len; i++) { + DUK_ASSERT(i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(obj)); + + tv_val = DUK_HOBJECT_A_GET_VALUE_PTR(js_ctx->thr->heap, obj, i); + + if (DUK_UNLIKELY(DUK_TVAL_IS_UNDEFINED_UNUSED(tv_val))) { + /* Gap in array; check for inherited property, + * bail out if one exists. This should be enough + * to support gappy arrays for all practical code. + */ + duk_hstring *h_tmp; + duk_bool_t has_inherited; + + /* XXX: refactor into an internal helper, pretty awkward */ + duk_push_uint((duk_context *) js_ctx->thr, (duk_uint_t) i); + h_tmp = duk_to_hstring((duk_context *) js_ctx->thr, -1); + DUK_ASSERT(h_tmp != NULL); + has_inherited = duk_hobject_hasprop_raw(js_ctx->thr, obj, h_tmp); + duk_pop((duk_context *) js_ctx->thr); + + if (has_inherited) { + DUK_D(DUK_DPRINT("gap in array, conflicting inherited property, abort fast path")); + goto abort_fastpath; + } + + /* Ordinary gap, undefined encodes to 'null' in + * standard JSON (and no JX/JC support here now). + */ + DUK_D(DUK_DPRINT("gap in array, no conflicting inherited property, remain on fast path")); + DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL); + } else { + if (duk__json_stringify_fast_value(js_ctx, tv_val) == 0) { + DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL); + } + } + DUK__EMIT_1(js_ctx, DUK_ASC_COMMA); + emitted = 1; + } + + if (emitted) { + DUK__UNEMIT_1(js_ctx); /* eat trailing comma */ + } + DUK__EMIT_1(js_ctx, DUK_ASC_RBRACKET); + } else if (c_bit & c_unbox) { + /* These three boxed types are required to go through + * automatic unboxing. Rely on internal value being + * sane (to avoid infinite recursion). + */ + duk_tval *tv_internal; + + DUK_DD(DUK_DDPRINT("auto unboxing in fast path")); + + tv_internal = duk_hobject_get_internal_value_tval_ptr(js_ctx->thr->heap, obj); + DUK_ASSERT(tv_internal != NULL); + DUK_ASSERT(DUK_TVAL_IS_STRING(tv_internal) || + DUK_TVAL_IS_NUMBER(tv_internal) || + DUK_TVAL_IS_BOOLEAN(tv_internal)); + + /* XXX: for JX/JC, special handling for Pointer, and Buffer? */ + tv = tv_internal; + goto restart_match; + } else { + DUK_ASSERT((c_bit & c_undef) != 0); + + /* Function objects are treated as "undefined" by JSON. + * + * The slow path replaces a buffer object automatically with + * the binary data which then gets treated like "undefined". + * Since we don't support buffers here now, treat as "undefined". + */ + + /* Must decrease recursion depth before returning. */ + DUK_ASSERT(js_ctx->recursion_depth > 0); + DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); + js_ctx->recursion_depth--; + goto emit_undefined; + } + + DUK_ASSERT(js_ctx->recursion_depth > 0); + DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); + js_ctx->recursion_depth--; + break; + } + case DUK_TAG_BUFFER: { + goto emit_undefined; + } + case DUK_TAG_POINTER: { + goto emit_undefined; + } + case DUK_TAG_LIGHTFUNC: { + /* A lightfunc might also inherit a .toJSON() so just bail out. */ + DUK_DD(DUK_DDPRINT("value is a lightfunc, abort fast path")); + goto abort_fastpath; + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: { + /* Number serialization has a significant impact relative to + * other fast path code, so careful fast path for fastints. + */ + duk__enc_fastint_tval(js_ctx, tv); + break; + } +#endif + default: { + /* XXX: A fast path for usual integers would be useful when + * fastint support is not enabled. + */ + /* XXX: Stack discipline is annoying, could be changed in numconv. */ + duk_push_tval((duk_context *) js_ctx->thr, tv); + duk__enc_double(js_ctx); + duk_pop((duk_context *) js_ctx->thr); + +#if 0 + /* Could also rely on native sprintf(), but it will handle + * values like NaN, Infinity, -0, exponent notation etc in + * a JSON-incompatible way. + */ + duk_double_t d; + char buf[64]; + + DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv)); + d = DUK_TVAL_GET_DOUBLE(tv); + DUK_SPRINTF(buf, "%lg", d); + DUK__EMIT_CSTR(js_ctx, buf); +#endif + } + } + return 1; /* not undefined */ + + emit_undefined: + return 0; /* value was undefined/unsupported */ + + abort_fastpath: + /* Error message doesn't matter: the error is ignored anyway. */ + DUK_DD(DUK_DDPRINT("aborting fast path")); + DUK_ERROR(js_ctx->thr, DUK_ERR_ERROR, DUK_STR_INTERNAL_ERROR); + return 0; /* unreachable */ +} + +DUK_LOCAL duk_ret_t duk__json_stringify_fast(duk_context *ctx) { + duk_json_enc_ctx *js_ctx; + + DUK_ASSERT(ctx != NULL); + js_ctx = (duk_json_enc_ctx *) duk_get_pointer(ctx, -2); + DUK_ASSERT(js_ctx != NULL); + + if (duk__json_stringify_fast_value(js_ctx, duk_get_tval((duk_context *) (js_ctx->thr), -1)) == 0) { + DUK_DD(DUK_DDPRINT("top level value not supported, fail fast path")); + return DUK_RET_ERROR; /* error message doesn't matter, ignored anyway */ + } + + return 0; +} +#endif /* DUK_USE_JSON_STRINGIFY_FASTPATH */ + +/* + * Top level wrappers + */ + +DUK_INTERNAL +void duk_bi_json_parse_helper(duk_context *ctx, + duk_idx_t idx_value, + duk_idx_t idx_reviver, + duk_small_uint_t flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_json_dec_ctx js_ctx_alloc; + duk_json_dec_ctx *js_ctx = &js_ctx_alloc; + duk_hstring *h_text; +#ifdef DUK_USE_ASSERTIONS + duk_idx_t entry_top = duk_get_top(ctx); +#endif + + /* negative top-relative indices not allowed now */ + DUK_ASSERT(idx_value == DUK_INVALID_INDEX || idx_value >= 0); + DUK_ASSERT(idx_reviver == DUK_INVALID_INDEX || idx_reviver >= 0); + + DUK_DDD(DUK_DDDPRINT("JSON parse start: text=%!T, reviver=%!T, flags=0x%08lx, stack_top=%ld", + (duk_tval *) duk_get_tval(ctx, idx_value), + (duk_tval *) duk_get_tval(ctx, idx_reviver), + (unsigned long) flags, + (long) duk_get_top(ctx))); + + DUK_MEMZERO(&js_ctx_alloc, sizeof(js_ctx_alloc)); + js_ctx->thr = thr; +#ifdef DUK_USE_EXPLICIT_NULL_INIT + /* nothing now */ +#endif + js_ctx->recursion_limit = DUK_USE_JSON_DEC_RECLIMIT; + DUK_ASSERT(js_ctx->recursion_depth == 0); + + /* Flag handling currently assumes that flags are consistent. This is OK + * because the call sites are now strictly controlled. + */ + + js_ctx->flags = flags; +#ifdef DUK_USE_JX + js_ctx->flag_ext_custom = flags & DUK_JSON_FLAG_EXT_CUSTOM; +#endif +#ifdef DUK_USE_JC + js_ctx->flag_ext_compatible = flags & DUK_JSON_FLAG_EXT_COMPATIBLE; +#endif + + h_text = duk_to_hstring(ctx, idx_value); /* coerce in-place */ + DUK_ASSERT(h_text != NULL); + + /* JSON parsing code is allowed to read [p_start,p_end]: p_end is + * valid and points to the string NUL terminator (which is always + * guaranteed for duk_hstrings. + */ + js_ctx->p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text); + js_ctx->p = js_ctx->p_start; + js_ctx->p_end = ((duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text)) + + DUK_HSTRING_GET_BYTELEN(h_text); + DUK_ASSERT(*(js_ctx->p_end) == 0x00); + + duk__dec_value(js_ctx); /* -> [ ... value ] */ + + /* Trailing whitespace has been eaten by duk__dec_value(), so if + * we're not at end of input here, it's a SyntaxError. + */ + + if (js_ctx->p != js_ctx->p_end) { + duk__dec_syntax_error(js_ctx); + } + + if (duk_is_callable(ctx, idx_reviver)) { + DUK_DDD(DUK_DDDPRINT("applying reviver: %!T", + (duk_tval *) duk_get_tval(ctx, idx_reviver))); + + js_ctx->idx_reviver = idx_reviver; + + duk_push_object(ctx); + duk_dup(ctx, -2); /* -> [ ... val root val ] */ + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_EMPTY_STRING); /* default attrs ok */ + duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING); /* -> [ ... val root "" ] */ + + DUK_DDD(DUK_DDDPRINT("start reviver walk, root=%!T, name=%!T", + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + + duk__dec_reviver_walk(js_ctx); /* [ ... val root "" ] -> [ ... val val' ] */ + duk_remove(ctx, -2); /* -> [ ... val' ] */ + } else { + DUK_DDD(DUK_DDDPRINT("reviver does not exist or is not callable: %!T", + (duk_tval *) duk_get_tval(ctx, idx_reviver))); + } + + /* Final result is at stack top. */ + + DUK_DDD(DUK_DDDPRINT("JSON parse end: text=%!T, reviver=%!T, flags=0x%08lx, result=%!T, stack_top=%ld", + (duk_tval *) duk_get_tval(ctx, idx_value), + (duk_tval *) duk_get_tval(ctx, idx_reviver), + (unsigned long) flags, + (duk_tval *) duk_get_tval(ctx, -1), + (long) duk_get_top(ctx))); + + DUK_ASSERT(duk_get_top(ctx) == entry_top + 1); +} + +DUK_INTERNAL +void duk_bi_json_stringify_helper(duk_context *ctx, + duk_idx_t idx_value, + duk_idx_t idx_replacer, + duk_idx_t idx_space, + duk_small_uint_t flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_json_enc_ctx js_ctx_alloc; + duk_json_enc_ctx *js_ctx = &js_ctx_alloc; + duk_hobject *h; + duk_bool_t undef; + duk_idx_t idx_holder; + duk_idx_t entry_top; + + /* negative top-relative indices not allowed now */ + DUK_ASSERT(idx_value == DUK_INVALID_INDEX || idx_value >= 0); + DUK_ASSERT(idx_replacer == DUK_INVALID_INDEX || idx_replacer >= 0); + DUK_ASSERT(idx_space == DUK_INVALID_INDEX || idx_space >= 0); + + DUK_DDD(DUK_DDDPRINT("JSON stringify start: value=%!T, replacer=%!T, space=%!T, flags=0x%08lx, stack_top=%ld", + (duk_tval *) duk_get_tval(ctx, idx_value), + (duk_tval *) duk_get_tval(ctx, idx_replacer), + (duk_tval *) duk_get_tval(ctx, idx_space), + (unsigned long) flags, + (long) duk_get_top(ctx))); + + entry_top = duk_get_top(ctx); + + /* + * Context init + */ + + DUK_MEMZERO(&js_ctx_alloc, sizeof(js_ctx_alloc)); + js_ctx->thr = thr; +#ifdef DUK_USE_EXPLICIT_NULL_INIT + js_ctx->h_replacer = NULL; + js_ctx->h_gap = NULL; + js_ctx->h_indent = NULL; +#endif + js_ctx->idx_proplist = -1; + + /* Flag handling currently assumes that flags are consistent. This is OK + * because the call sites are now strictly controlled. + */ + + js_ctx->flags = flags; + js_ctx->flag_ascii_only = flags & DUK_JSON_FLAG_ASCII_ONLY; + js_ctx->flag_avoid_key_quotes = flags & DUK_JSON_FLAG_AVOID_KEY_QUOTES; +#ifdef DUK_USE_JX + js_ctx->flag_ext_custom = flags & DUK_JSON_FLAG_EXT_CUSTOM; +#endif +#ifdef DUK_USE_JC + js_ctx->flag_ext_compatible = flags & DUK_JSON_FLAG_EXT_COMPATIBLE; +#endif + + /* The #ifdef clutter here handles the JX/JC enable/disable + * combinations properly. + */ +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) +#if defined(DUK_USE_JX) + if (flags & DUK_JSON_FLAG_EXT_CUSTOM) { + js_ctx->stridx_custom_undefined = DUK_STRIDX_LC_UNDEFINED; + js_ctx->stridx_custom_nan = DUK_STRIDX_NAN; + js_ctx->stridx_custom_neginf = DUK_STRIDX_MINUS_INFINITY; + js_ctx->stridx_custom_posinf = DUK_STRIDX_INFINITY; + js_ctx->stridx_custom_function = + (flags & DUK_JSON_FLAG_AVOID_KEY_QUOTES) ? + DUK_STRIDX_JSON_EXT_FUNCTION2 : + DUK_STRIDX_JSON_EXT_FUNCTION1; + } +#endif /* DUK_USE_JX */ +#if defined(DUK_USE_JX) && defined(DUK_USE_JC) + else +#endif /* DUK_USE_JX && DUK_USE_JC */ +#if defined(DUK_USE_JC) + if (js_ctx->flags & DUK_JSON_FLAG_EXT_COMPATIBLE) { + js_ctx->stridx_custom_undefined = DUK_STRIDX_JSON_EXT_UNDEFINED; + js_ctx->stridx_custom_nan = DUK_STRIDX_JSON_EXT_NAN; + js_ctx->stridx_custom_neginf = DUK_STRIDX_JSON_EXT_NEGINF; + js_ctx->stridx_custom_posinf = DUK_STRIDX_JSON_EXT_POSINF; + js_ctx->stridx_custom_function = DUK_STRIDX_JSON_EXT_FUNCTION1; + } +#endif /* DUK_USE_JC */ +#endif /* DUK_USE_JX || DUK_USE_JC */ + +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + if (js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM | + DUK_JSON_FLAG_EXT_COMPATIBLE)) { + DUK_ASSERT(js_ctx->mask_for_undefined == 0); /* already zero */ + } + else +#endif /* DUK_USE_JX || DUK_USE_JC */ + { + js_ctx->mask_for_undefined = DUK_TYPE_MASK_UNDEFINED | + DUK_TYPE_MASK_POINTER | + DUK_TYPE_MASK_BUFFER | + DUK_TYPE_MASK_LIGHTFUNC; + } + + DUK_BW_INIT_PUSHBUF(thr, &js_ctx->bw, DUK__JSON_STRINGIFY_BUFSIZE); + + js_ctx->idx_loop = duk_push_object_internal(ctx); + DUK_ASSERT(js_ctx->idx_loop >= 0); + + /* [ ... buf loop ] */ + + /* + * Process replacer/proplist (2nd argument to JSON.stringify) + */ + + h = duk_get_hobject(ctx, idx_replacer); + if (h != NULL) { + if (DUK_HOBJECT_IS_CALLABLE(h)) { + js_ctx->h_replacer = h; + } else if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_ARRAY) { + /* Here the specification requires correct array index enumeration + * which is a bit tricky for sparse arrays (it is handled by the + * enum setup code). We now enumerate ancestors too, although the + * specification is not very clear on whether that is required. + */ + + duk_uarridx_t plist_idx = 0; + duk_small_uint_t enum_flags; + + js_ctx->idx_proplist = duk_push_array(ctx); /* XXX: array internal? */ + + enum_flags = DUK_ENUM_ARRAY_INDICES_ONLY | + DUK_ENUM_SORT_ARRAY_INDICES; /* expensive flag */ + duk_enum(ctx, idx_replacer, enum_flags); + while (duk_next(ctx, -1 /*enum_index*/, 1 /*get_value*/)) { + /* [ ... proplist enum_obj key val ] */ + if (duk__enc_allow_into_proplist(duk_get_tval(ctx, -1))) { + /* XXX: duplicates should be eliminated here */ + DUK_DDD(DUK_DDDPRINT("proplist enum: key=%!T, val=%!T --> accept", + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + duk_to_string(ctx, -1); /* extra coercion of strings is OK */ + duk_put_prop_index(ctx, -4, plist_idx); /* -> [ ... proplist enum_obj key ] */ + plist_idx++; + duk_pop(ctx); + } else { + DUK_DDD(DUK_DDDPRINT("proplist enum: key=%!T, val=%!T --> reject", + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + duk_pop_2(ctx); + } + } + duk_pop(ctx); /* pop enum */ + + /* [ ... proplist ] */ + } + } + + /* [ ... buf loop (proplist) ] */ + + /* + * Process space (3rd argument to JSON.stringify) + */ + + h = duk_get_hobject(ctx, idx_space); + if (h != NULL) { + int c = DUK_HOBJECT_GET_CLASS_NUMBER(h); + if (c == DUK_HOBJECT_CLASS_NUMBER) { + duk_to_number(ctx, idx_space); + } else if (c == DUK_HOBJECT_CLASS_STRING) { + duk_to_string(ctx, idx_space); + } + } + + if (duk_is_number(ctx, idx_space)) { + duk_small_int_t nspace; + /* spaces[] must be static to allow initializer with old compilers like BCC */ + static const char spaces[10] = { + DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE, + DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE, + DUK_ASC_SPACE, DUK_ASC_SPACE + }; /* XXX: helper */ + + /* ToInteger() coercion; NaN -> 0, infinities are clamped to 0 and 10 */ + nspace = (duk_small_int_t) duk_to_int_clamped(ctx, idx_space, 0 /*minval*/, 10 /*maxval*/); + DUK_ASSERT(nspace >= 0 && nspace <= 10); + + duk_push_lstring(ctx, spaces, (duk_size_t) nspace); + js_ctx->h_gap = duk_get_hstring(ctx, -1); + DUK_ASSERT(js_ctx->h_gap != NULL); + } else if (duk_is_string(ctx, idx_space)) { + /* XXX: substring in-place at idx_place? */ + duk_dup(ctx, idx_space); + duk_substring(ctx, -1, 0, 10); /* clamp to 10 chars */ + js_ctx->h_gap = duk_get_hstring(ctx, -1); + DUK_ASSERT(js_ctx->h_gap != NULL); + } else { + /* nop */ + } + + if (js_ctx->h_gap != NULL) { + /* if gap is empty, behave as if not given at all */ + if (DUK_HSTRING_GET_CHARLEN(js_ctx->h_gap) == 0) { + js_ctx->h_gap = NULL; + } else { + /* set 'indent' only if it will actually increase */ + js_ctx->h_indent = DUK_HTHREAD_STRING_EMPTY_STRING(thr); + } + } + + DUK_ASSERT((js_ctx->h_gap == NULL && js_ctx->h_indent == NULL) || + (js_ctx->h_gap != NULL && js_ctx->h_indent != NULL)); + + /* [ ... buf loop (proplist) (gap) ] */ + + /* + * Fast path: assume no mutation, iterate object property tables + * directly; bail out if that assumption doesn't hold. + */ + +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) + /* For now fast path is limited to plain JSON (no JX/JC). This would + * be easy to fix but must go through value type handling in the fast + * path. + */ + if (flags == 0 && + js_ctx->h_replacer == NULL && + js_ctx->idx_proplist == -1 && + js_ctx->h_gap == NULL && + js_ctx->h_indent == NULL) { + duk_int_t pcall_rc; +#ifdef DUK_USE_MARK_AND_SWEEP + duk_small_uint_t prev_mark_and_sweep_base_flags; +#endif + + DUK_DD(DUK_DDPRINT("try JSON.stringify() fast path")); + + /* Use recursion_limit to ensure we don't overwrite js_ctx->visiting[] + * array so we don't need two counter checks in the fast path. The + * slow path has a much larger recursion limit which we'll use if + * necessary. + */ + DUK_ASSERT(DUK_USE_JSON_ENC_RECLIMIT >= DUK_JSON_ENC_LOOPARRAY); + js_ctx->recursion_limit = DUK_JSON_ENC_LOOPARRAY; + DUK_ASSERT(js_ctx->recursion_depth == 0); + + /* Execute the fast path in a protected call. If any error is thrown, + * fall back to the slow path. This includes e.g. recursion limit + * because the fast path has a smaller recursion limit (and simpler, + * limited loop detection). + */ + + duk_push_pointer(ctx, (void *) js_ctx); + duk_dup(ctx, idx_value); + +#if defined(DUK_USE_MARK_AND_SWEEP) + /* Must prevent finalizers which may have arbitrary side effects. */ + prev_mark_and_sweep_base_flags = thr->heap->mark_and_sweep_base_flags; + thr->heap->mark_and_sweep_base_flags |= + DUK_MS_FLAG_NO_FINALIZERS | /* avoid attempts to add/remove object keys */ + DUK_MS_FLAG_NO_OBJECT_COMPACTION; /* avoid attempt to compact any objects */ +#endif + + pcall_rc = duk_safe_call(ctx, duk__json_stringify_fast, 2 /*nargs*/, 0 /*nret*/); + +#if defined(DUK_USE_MARK_AND_SWEEP) + thr->heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags; +#endif + if (pcall_rc == DUK_EXEC_SUCCESS) { + DUK_DD(DUK_DDPRINT("fast path successful")); + DUK_BW_PUSH_AS_STRING(thr, &js_ctx->bw); + goto replace_finished; + } + + /* We come here for actual aborts (like encountering .toJSON()) + * but also for recursion/loop errors. Bufwriter size can be + * kept because we'll probably need at least as much as we've + * allocated so far. + */ + DUK_DD(DUK_DDPRINT("fast path failed, serialize using slow path instead")); + DUK_BW_RESET_SIZE(thr, &js_ctx->bw); + js_ctx->recursion_depth = 0; + } +#endif + + /* + * Create wrapper object and serialize + */ + + idx_holder = duk_push_object(ctx); + duk_dup(ctx, idx_value); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_EMPTY_STRING); + + DUK_DDD(DUK_DDDPRINT("before: flags=0x%08lx, loop=%!T, replacer=%!O, " + "proplist=%!T, gap=%!O, indent=%!O, holder=%!T", + (unsigned long) js_ctx->flags, + (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop), + (duk_heaphdr *) js_ctx->h_replacer, + (duk_tval *) (js_ctx->idx_proplist >= 0 ? duk_get_tval(ctx, js_ctx->idx_proplist) : NULL), + (duk_heaphdr *) js_ctx->h_gap, + (duk_heaphdr *) js_ctx->h_indent, + (duk_tval *) duk_get_tval(ctx, -1))); + + /* serialize the wrapper with empty string key */ + + duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING); + + /* [ ... buf loop (proplist) (gap) holder "" ] */ + + js_ctx->recursion_limit = DUK_USE_JSON_ENC_RECLIMIT; + DUK_ASSERT(js_ctx->recursion_depth == 0); + undef = duk__enc_value1(js_ctx, idx_holder); /* [ ... holder key ] -> [ ... holder key val ] */ + + DUK_DDD(DUK_DDDPRINT("after: flags=0x%08lx, loop=%!T, replacer=%!O, " + "proplist=%!T, gap=%!O, indent=%!O, holder=%!T", + (unsigned long) js_ctx->flags, + (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop), + (duk_heaphdr *) js_ctx->h_replacer, + (duk_tval *) (js_ctx->idx_proplist >= 0 ? duk_get_tval(ctx, js_ctx->idx_proplist) : NULL), + (duk_heaphdr *) js_ctx->h_gap, + (duk_heaphdr *) js_ctx->h_indent, + (duk_tval *) duk_get_tval(ctx, -3))); + + if (undef) { + /* + * Result is undefined + */ + + duk_push_undefined(ctx); + } else { + /* + * Finish and convert buffer to result string + */ + + duk__enc_value2(js_ctx); /* [ ... key val ] -> [ ... ] */ + + DUK_BW_PUSH_AS_STRING(thr, &js_ctx->bw); + } + + /* The stack has a variable shape here, so force it to the + * desired one explicitly. + */ + +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) + replace_finished: +#endif + duk_replace(ctx, entry_top); + duk_set_top(ctx, entry_top + 1); + + DUK_DDD(DUK_DDDPRINT("JSON stringify end: value=%!T, replacer=%!T, space=%!T, " + "flags=0x%08lx, result=%!T, stack_top=%ld", + (duk_tval *) duk_get_tval(ctx, idx_value), + (duk_tval *) duk_get_tval(ctx, idx_replacer), + (duk_tval *) duk_get_tval(ctx, idx_space), + (unsigned long) flags, + (duk_tval *) duk_get_tval(ctx, -1), + (long) duk_get_top(ctx))); + + DUK_ASSERT(duk_get_top(ctx) == entry_top + 1); +} + +/* + * Entry points + */ + +DUK_INTERNAL duk_ret_t duk_bi_json_object_parse(duk_context *ctx) { + duk_bi_json_parse_helper(ctx, + 0 /*idx_value*/, + 1 /*idx_replacer*/, + 0 /*flags*/); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_json_object_stringify(duk_context *ctx) { + duk_bi_json_stringify_helper(ctx, + 0 /*idx_value*/, + 1 /*idx_replacer*/, + 2 /*idx_space*/, + 0 /*flags*/); + return 1; +} + +#undef DUK__JSON_DECSTR_BUFSIZE +#undef DUK__JSON_DECSTR_CHUNKSIZE +#undef DUK__JSON_ENCSTR_CHUNKSIZE +#undef DUK__JSON_STRINGIFY_BUFSIZE +#undef DUK__JSON_MAX_ESC_LEN +#line 1 "duk_bi_logger.c" +/* + * Logging support + */ + +/* include removed: duk_internal.h */ + +/* 3-letter log level strings */ +DUK_LOCAL const duk_uint8_t duk__log_level_strings[] = { + (duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_C, + (duk_uint8_t) DUK_ASC_UC_D, (duk_uint8_t) DUK_ASC_UC_B, (duk_uint8_t) DUK_ASC_UC_G, + (duk_uint8_t) DUK_ASC_UC_I, (duk_uint8_t) DUK_ASC_UC_N, (duk_uint8_t) DUK_ASC_UC_F, + (duk_uint8_t) DUK_ASC_UC_W, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_N, + (duk_uint8_t) DUK_ASC_UC_E, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_R, + (duk_uint8_t) DUK_ASC_UC_F, (duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_L +}; + +/* Constructor */ +DUK_INTERNAL duk_ret_t duk_bi_logger_constructor(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t nargs; + + /* Calling as a non-constructor is not meaningful. */ + if (!duk_is_constructor_call(ctx)) { + return DUK_RET_TYPE_ERROR; + } + + nargs = duk_get_top(ctx); + duk_set_top(ctx, 1); + + duk_push_this(ctx); + + /* [ name this ] */ + + if (nargs == 0) { + /* Automatic defaulting of logger name from caller. This would + * work poorly with tail calls, but constructor calls are currently + * never tail calls, so tail calls are not an issue now. + */ + + if (thr->callstack_top >= 2) { + duk_activation *act_caller = thr->callstack + thr->callstack_top - 2; + duk_hobject *func_caller; + + func_caller = DUK_ACT_GET_FUNC(act_caller); + if (func_caller) { + /* Stripping the filename might be a good idea + * ("/foo/bar/quux.js" -> logger name "quux"), + * but now used verbatim. + */ + duk_push_hobject(ctx, func_caller); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME); + duk_replace(ctx, 0); + } + } + } + /* the stack is unbalanced here on purpose; we only rely on the + * initial two values: [ name this ]. + */ + + if (duk_is_string(ctx, 0)) { + duk_dup(ctx, 0); + duk_put_prop_stridx(ctx, 1, DUK_STRIDX_LC_N); + } else { + /* don't set 'n' at all, inherited value is used as name */ + } + + duk_compact(ctx, 1); + + return 0; /* keep default instance */ +} + +/* Default function to format objects. Tries to use toLogString() but falls + * back to toString(). Any errors are propagated out without catching. + */ +DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_fmt(duk_context *ctx) { + if (duk_get_prop_stridx(ctx, 0, DUK_STRIDX_TO_LOG_STRING)) { + /* [ arg toLogString ] */ + + duk_dup(ctx, 0); + duk_call_method(ctx, 0); + + /* [ arg result ] */ + return 1; + } + + /* [ arg undefined ] */ + duk_pop(ctx); + duk_to_string(ctx, 0); + return 1; +} + +/* Default function to write a formatted log line. Writes to stderr, + * appending a newline to the log line. + * + * The argument is a buffer whose visible size contains the log message. + * This function should avoid coercing the buffer to a string to avoid + * string table traffic. + */ +DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_raw(duk_context *ctx) { + const char *data; + duk_size_t data_len; + + DUK_UNREF(ctx); + DUK_UNREF(data); + DUK_UNREF(data_len); + +#ifdef DUK_USE_FILE_IO + data = (const char *) duk_require_buffer(ctx, 0, &data_len); + DUK_FWRITE((const void *) data, 1, data_len, DUK_STDERR); + DUK_FPUTC((int) '\n', DUK_STDERR); + DUK_FFLUSH(DUK_STDERR); +#else + /* nop */ +#endif + return 0; +} + +/* Log frontend shared helper, magic value indicates log level. Provides + * frontend functions: trace(), debug(), info(), warn(), error(), fatal(). + * This needs to have small footprint, reasonable performance, minimal + * memory churn, etc. + */ +DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_log_shared(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_double_t now; + duk_small_int_t entry_lev = duk_get_current_magic(ctx); + duk_small_int_t logger_lev; + duk_int_t nargs; + duk_int_t i; + duk_size_t tot_len; + const duk_uint8_t *arg_str; + duk_size_t arg_len; + duk_uint8_t *buf, *p; + const duk_uint8_t *q; + duk_uint8_t date_buf[DUK_BI_DATE_ISO8601_BUFSIZE]; + duk_size_t date_len; + duk_small_int_t rc; + + DUK_ASSERT(entry_lev >= 0 && entry_lev <= 5); + DUK_UNREF(thr); + + /* XXX: sanitize to printable (and maybe ASCII) */ + /* XXX: better multiline */ + + /* + * Logger arguments are: + * + * magic: log level (0-5) + * this: logger + * stack: plain log args + * + * We want to minimize memory churn so a two-pass approach + * is used: first pass formats arguments and computes final + * string length, second pass copies strings either into a + * pre-allocated and reused buffer (short messages) or into a + * newly allocated fixed buffer. If the backend function plays + * nice, it won't coerce the buffer to a string (and thus + * intern it). + */ + + nargs = duk_get_top(ctx); + + /* [ arg1 ... argN this ] */ + + /* + * Log level check + */ + + duk_push_this(ctx); + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LC_L); + logger_lev = (duk_small_int_t) duk_get_int(ctx, -1); + if (entry_lev < logger_lev) { + return 0; + } + /* log level could be popped but that's not necessary */ + + now = DUK_USE_DATE_GET_NOW(ctx); + duk_bi_date_format_timeval(now, date_buf); + date_len = DUK_STRLEN((const char *) date_buf); + + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_LC_N); + duk_to_string(ctx, -1); + DUK_ASSERT(duk_is_string(ctx, -1)); + + /* [ arg1 ... argN this loggerLevel loggerName ] */ + + /* + * Pass 1 + */ + + /* Line format: <time> <entryLev> <loggerName>: <msg> */ + + tot_len = 0; + tot_len += 3 + /* separators: space, space, colon */ + 3 + /* level string */ + date_len + /* time */ + duk_get_length(ctx, -1); /* loggerName */ + + for (i = 0; i < nargs; i++) { + /* When formatting an argument to a string, errors may happen from multiple + * causes. In general we want to catch obvious errors like a toLogString() + * throwing an error, but we don't currently try to catch every possible + * error. In particular, internal errors (like out of memory or stack) are + * not caught. Also, we expect Error toString() to not throw an error. + */ + if (duk_is_object(ctx, i)) { + /* duk_pcall_prop() may itself throw an error, but we're content + * in catching the obvious errors (like toLogString() throwing an + * error). + */ + duk_push_hstring_stridx(ctx, DUK_STRIDX_FMT); + duk_dup(ctx, i); + /* [ arg1 ... argN this loggerLevel loggerName 'fmt' arg ] */ + /* call: this.fmt(arg) */ + rc = duk_pcall_prop(ctx, -5 /*obj_index*/, 1 /*nargs*/); + if (rc) { + /* Keep the error as the result (coercing it might fail below, + * but we don't catch that now). + */ + ; + } + duk_replace(ctx, i); + } + (void) duk_to_lstring(ctx, i, &arg_len); + tot_len++; /* sep (even before first one) */ + tot_len += arg_len; + } + + /* + * Pass 2 + */ + + /* XXX: There used to be a shared log buffer here, but it was removed + * when dynamic buffer spare was removed. The problem with using + * bufwriter is that, without the spare, the buffer gets passed on + * as an argument to the raw() call so it'd need to be resized + * (reallocated) anyway. If raw() call convention is changed, this + * could be made more efficient. + */ + + buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, tot_len); + DUK_ASSERT(buf != NULL); + p = buf; + + DUK_MEMCPY((void *) p, (void *) date_buf, date_len); + p += date_len; + *p++ = (duk_uint8_t) DUK_ASC_SPACE; + + q = duk__log_level_strings + (entry_lev * 3); + DUK_MEMCPY((void *) p, (void *) q, (duk_size_t) 3); + p += 3; + + *p++ = (duk_uint8_t) DUK_ASC_SPACE; + + arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, -2, &arg_len); + DUK_MEMCPY((void *) p, (const void *) arg_str, arg_len); + p += arg_len; + + *p++ = (duk_uint8_t) DUK_ASC_COLON; + + for (i = 0; i < nargs; i++) { + *p++ = (duk_uint8_t) DUK_ASC_SPACE; + + arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &arg_len); + DUK_ASSERT(arg_str != NULL); + DUK_MEMCPY((void *) p, (const void *) arg_str, arg_len); + p += arg_len; + } + DUK_ASSERT(buf + tot_len == p); + + /* [ arg1 ... argN this loggerLevel loggerName buffer ] */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) && defined(DUK_USE_DEBUGGER_FWD_LOGGING) + /* Do debugger forwarding before raw() because the raw() function + * doesn't get the log level right now. + */ + if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) { + const char *log_buf; + duk_size_t sz_buf; + log_buf = (const char *) duk_get_buffer(ctx, -1, &sz_buf); + DUK_ASSERT(log_buf != NULL); + duk_debug_write_notify(thr, DUK_DBG_CMD_LOG); + duk_debug_write_int(thr, (duk_int32_t) entry_lev); + duk_debug_write_string(thr, (const char *) log_buf, sz_buf); + duk_debug_write_eom(thr); + } +#endif + + /* Call this.raw(msg); look up through the instance allows user to override + * the raw() function in the instance or in the prototype for maximum + * flexibility. + */ + duk_push_hstring_stridx(ctx, DUK_STRIDX_RAW); + duk_dup(ctx, -2); + /* [ arg1 ... argN this loggerLevel loggerName buffer 'raw' buffer ] */ + duk_call_prop(ctx, -6, 1); /* this.raw(buffer) */ + + return 0; +} +#line 1 "duk_bi_math.c" +/* + * Math built-ins + */ + +/* include removed: duk_internal.h */ + +#if defined(DUK_USE_MATH_BUILTIN) + +/* + * Use static helpers which can work with math.h functions matching + * the following signatures. This is not portable if any of these math + * functions is actually a macro. + * + * Typing here is intentionally 'double' wherever values interact with + * the standard library APIs. + */ + +typedef double (*duk__one_arg_func)(double); +typedef double (*duk__two_arg_func)(double, double); + +DUK_LOCAL duk_ret_t duk__math_minmax(duk_context *ctx, duk_double_t initial, duk__two_arg_func min_max) { + duk_idx_t n = duk_get_top(ctx); + duk_idx_t i; + duk_double_t res = initial; + duk_double_t t; + + /* + * Note: fmax() does not match the E5 semantics. E5 requires + * that if -any- input to Math.max() is a NaN, the result is a + * NaN. fmax() will return a NaN only if -both- inputs are NaN. + * Same applies to fmin(). + * + * Note: every input value must be coerced with ToNumber(), even + * if we know the result will be a NaN anyway: ToNumber() may have + * side effects for which even order of evaluation matters. + */ + + for (i = 0; i < n; i++) { + t = duk_to_number(ctx, i); + if (DUK_FPCLASSIFY(t) == DUK_FP_NAN || DUK_FPCLASSIFY(res) == DUK_FP_NAN) { + /* Note: not normalized, but duk_push_number() will normalize */ + res = (duk_double_t) DUK_DOUBLE_NAN; + } else { + res = (duk_double_t) min_max(res, (double) t); + } + } + + duk_push_number(ctx, res); + return 1; +} + +DUK_LOCAL double duk__fmin_fixed(double x, double y) { + /* fmin() with args -0 and +0 is not guaranteed to return + * -0 as Ecmascript requires. + */ + if (x == 0 && y == 0) { + /* XXX: what's the safest way of creating a negative zero? */ + if (DUK_SIGNBIT(x) != 0 || DUK_SIGNBIT(y) != 0) { + return -0.0; + } else { + return +0.0; + } + } +#ifdef DUK_USE_MATH_FMIN + return DUK_FMIN(x, y); +#else + return (x < y ? x : y); +#endif +} + +DUK_LOCAL double duk__fmax_fixed(double x, double y) { + /* fmax() with args -0 and +0 is not guaranteed to return + * +0 as Ecmascript requires. + */ + if (x == 0 && y == 0) { + if (DUK_SIGNBIT(x) == 0 || DUK_SIGNBIT(y) == 0) { + return +0.0; + } else { + return -0.0; + } + } +#ifdef DUK_USE_MATH_FMAX + return DUK_FMAX(x, y); +#else + return (x > y ? x : y); +#endif +} + +DUK_LOCAL double duk__round_fixed(double x) { + /* Numbers half-way between integers must be rounded towards +Infinity, + * e.g. -3.5 must be rounded to -3 (not -4). When rounded to zero, zero + * sign must be set appropriately. E5.1 Section 15.8.2.15. + * + * Note that ANSI C round() is "round to nearest integer, away from zero", + * which is incorrect for negative values. Here we make do with floor(). + */ + + duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x); + if (c == DUK_FP_NAN || c == DUK_FP_INFINITE || c == DUK_FP_ZERO) { + return x; + } + + /* + * x is finite and non-zero + * + * -1.6 -> floor(-1.1) -> -2 + * -1.5 -> floor(-1.0) -> -1 (towards +Inf) + * -1.4 -> floor(-0.9) -> -1 + * -0.5 -> -0.0 (special case) + * -0.1 -> -0.0 (special case) + * +0.1 -> +0.0 (special case) + * +0.5 -> floor(+1.0) -> 1 (towards +Inf) + * +1.4 -> floor(+1.9) -> 1 + * +1.5 -> floor(+2.0) -> 2 (towards +Inf) + * +1.6 -> floor(+2.1) -> 2 + */ + + if (x >= -0.5 && x < 0.5) { + /* +0.5 is handled by floor, this is on purpose */ + if (x < 0.0) { + return -0.0; + } else { + return +0.0; + } + } + + return DUK_FLOOR(x + 0.5); +} + +DUK_LOCAL double duk__pow_fixed(double x, double y) { + /* The ANSI C pow() semantics differ from Ecmascript. + * + * E.g. when x==1 and y is +/- infinite, the Ecmascript required + * result is NaN, while at least Linux pow() returns 1. + */ + + duk_small_int_t cx, cy, sx; + + DUK_UNREF(cx); + DUK_UNREF(sx); + cy = (duk_small_int_t) DUK_FPCLASSIFY(y); + + if (cy == DUK_FP_NAN) { + goto ret_nan; + } + if (DUK_FABS(x) == 1.0 && cy == DUK_FP_INFINITE) { + goto ret_nan; + } +#if defined(DUK_USE_POW_NETBSD_WORKAROUND) + /* See test-bug-netbsd-math-pow.js: NetBSD 6.0 on x86 (at least) does not + * correctly handle some cases where x=+/-0. Specific fixes to these + * here. + */ + cx = (duk_small_int_t) DUK_FPCLASSIFY(x); + if (cx == DUK_FP_ZERO && y < 0.0) { + sx = (duk_small_int_t) DUK_SIGNBIT(x); + if (sx == 0) { + /* Math.pow(+0,y) should be Infinity when y<0. NetBSD pow() + * returns -Infinity instead when y is <0 and finite. The + * if-clause also catches y == -Infinity (which works even + * without the fix). + */ + return DUK_DOUBLE_INFINITY; + } else { + /* Math.pow(-0,y) where y<0 should be: + * - -Infinity if y<0 and an odd integer + * - Infinity otherwise + * NetBSD pow() returns -Infinity for all finite y<0. The + * if-clause also catches y == -Infinity (which works even + * without the fix). + */ + + /* fmod() return value has same sign as input (negative) so + * the result here will be in the range ]-2,0], 1 indicates + * odd. If x is -Infinity, NaN is returned and the odd check + * always concludes "not odd" which results in desired outcome. + */ + double tmp = DUK_FMOD(y, 2); + if (tmp == -1.0) { + return -DUK_DOUBLE_INFINITY; + } else { + /* Not odd, or y == -Infinity */ + return DUK_DOUBLE_INFINITY; + } + } + } +#endif + return DUK_POW(x, y); + + ret_nan: + return DUK_DOUBLE_NAN; +} + +/* Wrappers for calling standard math library methods. These may be required + * on platforms where one or more of the math built-ins are defined as macros + * or inline functions and are thus not suitable to be used as function pointers. + */ +#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS) +DUK_LOCAL double duk__fabs(double x) { + return DUK_FABS(x); +} +DUK_LOCAL double duk__acos(double x) { + return DUK_ACOS(x); +} +DUK_LOCAL double duk__asin(double x) { + return DUK_ASIN(x); +} +DUK_LOCAL double duk__atan(double x) { + return DUK_ATAN(x); +} +DUK_LOCAL double duk__ceil(double x) { + return DUK_CEIL(x); +} +DUK_LOCAL double duk__cos(double x) { + return DUK_COS(x); +} +DUK_LOCAL double duk__exp(double x) { + return DUK_EXP(x); +} +DUK_LOCAL double duk__floor(double x) { + return DUK_FLOOR(x); +} +DUK_LOCAL double duk__log(double x) { + return DUK_LOG(x); +} +DUK_LOCAL double duk__sin(double x) { + return DUK_SIN(x); +} +DUK_LOCAL double duk__sqrt(double x) { + return DUK_SQRT(x); +} +DUK_LOCAL double duk__tan(double x) { + return DUK_TAN(x); +} +DUK_LOCAL double duk__atan2(double x, double y) { + return DUK_ATAN2(x, y); +} +#endif /* DUK_USE_AVOID_PLATFORM_FUNCPTRS */ + +/* order must match constants in genbuiltins.py */ +DUK_LOCAL const duk__one_arg_func duk__one_arg_funcs[] = { +#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS) + duk__fabs, + duk__acos, + duk__asin, + duk__atan, + duk__ceil, + duk__cos, + duk__exp, + duk__floor, + duk__log, + duk__round_fixed, + duk__sin, + duk__sqrt, + duk__tan +#else + DUK_FABS, + DUK_ACOS, + DUK_ASIN, + DUK_ATAN, + DUK_CEIL, + DUK_COS, + DUK_EXP, + DUK_FLOOR, + DUK_LOG, + duk__round_fixed, + DUK_SIN, + DUK_SQRT, + DUK_TAN +#endif +}; + +/* order must match constants in genbuiltins.py */ +DUK_LOCAL const duk__two_arg_func duk__two_arg_funcs[] = { +#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS) + duk__atan2, + duk__pow_fixed +#else + DUK_ATAN2, + duk__pow_fixed +#endif +}; + +DUK_INTERNAL duk_ret_t duk_bi_math_object_onearg_shared(duk_context *ctx) { + duk_small_int_t fun_idx = duk_get_current_magic(ctx); + duk__one_arg_func fun; + + DUK_ASSERT(fun_idx >= 0); + DUK_ASSERT(fun_idx < (duk_small_int_t) (sizeof(duk__one_arg_funcs) / sizeof(duk__one_arg_func))); + fun = duk__one_arg_funcs[fun_idx]; + duk_push_number(ctx, (duk_double_t) fun((double) duk_to_number(ctx, 0))); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_math_object_twoarg_shared(duk_context *ctx) { + duk_small_int_t fun_idx = duk_get_current_magic(ctx); + duk__two_arg_func fun; + + DUK_ASSERT(fun_idx >= 0); + DUK_ASSERT(fun_idx < (duk_small_int_t) (sizeof(duk__two_arg_funcs) / sizeof(duk__two_arg_func))); + fun = duk__two_arg_funcs[fun_idx]; + duk_push_number(ctx, (duk_double_t) fun((double) duk_to_number(ctx, 0), (double) duk_to_number(ctx, 1))); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_math_object_max(duk_context *ctx) { + return duk__math_minmax(ctx, -DUK_DOUBLE_INFINITY, duk__fmax_fixed); +} + +DUK_INTERNAL duk_ret_t duk_bi_math_object_min(duk_context *ctx) { + return duk__math_minmax(ctx, DUK_DOUBLE_INFINITY, duk__fmin_fixed); +} + +DUK_INTERNAL duk_ret_t duk_bi_math_object_random(duk_context *ctx) { + duk_push_number(ctx, (duk_double_t) duk_util_tinyrandom_get_double((duk_hthread *) ctx)); + return 1; +} + +#else /* DUK_USE_MATH_BUILTIN */ + +/* A stubbed built-in is useful for e.g. compilation torture testing with BCC. */ + +DUK_INTERNAL duk_ret_t duk_bi_math_object_onearg_shared(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNIMPLEMENTED_ERROR; +} + +DUK_INTERNAL duk_ret_t duk_bi_math_object_twoarg_shared(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNIMPLEMENTED_ERROR; +} + +DUK_INTERNAL duk_ret_t duk_bi_math_object_max(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNIMPLEMENTED_ERROR; +} + +DUK_INTERNAL duk_ret_t duk_bi_math_object_min(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNIMPLEMENTED_ERROR; +} + +DUK_INTERNAL duk_ret_t duk_bi_math_object_random(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNIMPLEMENTED_ERROR; +} + +#endif /* DUK_USE_MATH_BUILTIN */ +#line 1 "duk_bi_number.c" +/* + * Number built-ins + */ + +/* include removed: duk_internal.h */ + +DUK_LOCAL duk_double_t duk__push_this_number_plain(duk_context *ctx) { + duk_hobject *h; + + /* Number built-in accepts a plain number or a Number object (whose + * internal value is operated on). Other types cause TypeError. + */ + + duk_push_this(ctx); + if (duk_is_number(ctx, -1)) { + DUK_DDD(DUK_DDDPRINT("plain number value: %!T", (duk_tval *) duk_get_tval(ctx, -1))); + goto done; + } + h = duk_get_hobject(ctx, -1); + if (!h || + (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_NUMBER)) { + DUK_DDD(DUK_DDDPRINT("unacceptable this value: %!T", (duk_tval *) duk_get_tval(ctx, -1))); + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_TYPE_ERROR, "expected a number"); + } + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE); + DUK_ASSERT(duk_is_number(ctx, -1)); + DUK_DDD(DUK_DDDPRINT("number object: %!T, internal value: %!T", + (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1))); + duk_remove(ctx, -2); + + done: + return duk_get_number(ctx, -1); +} + +DUK_INTERNAL duk_ret_t duk_bi_number_constructor(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t nargs; + duk_hobject *h_this; + + DUK_UNREF(thr); + + /* + * The Number constructor uses ToNumber(arg) for number coercion + * (coercing an undefined argument to NaN). However, if the + * argument is not given at all, +0 must be used instead. To do + * this, a vararg function is used. + */ + + nargs = duk_get_top(ctx); + if (nargs == 0) { + duk_push_int(ctx, 0); + } + duk_to_number(ctx, 0); + duk_set_top(ctx, 1); + DUK_ASSERT_TOP(ctx, 1); + + if (!duk_is_constructor_call(ctx)) { + return 1; + } + + /* + * E5 Section 15.7.2.1 requires that the constructed object + * must have the original Number.prototype as its internal + * prototype. However, since Number.prototype is non-writable + * and non-configurable, this doesn't have to be enforced here: + * The default object (bound to 'this') is OK, though we have + * to change its class. + * + * Internal value set to ToNumber(arg) or +0; if no arg given, + * ToNumber(undefined) = NaN, so special treatment is needed + * (above). String internal value is immutable. + */ + + /* XXX: helper */ + duk_push_this(ctx); + h_this = duk_get_hobject(ctx, -1); + DUK_ASSERT(h_this != NULL); + DUK_HOBJECT_SET_CLASS_NUMBER(h_this, DUK_HOBJECT_CLASS_NUMBER); + + DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_this) == thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE]); + DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(h_this) == DUK_HOBJECT_CLASS_NUMBER); + DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h_this)); + + duk_dup(ctx, 0); /* -> [ val obj val ] */ + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE); + return 0; /* no return value -> don't replace created value */ +} + +DUK_INTERNAL duk_ret_t duk_bi_number_prototype_value_of(duk_context *ctx) { + (void) duk__push_this_number_plain(ctx); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_string(duk_context *ctx) { + duk_small_int_t radix; + duk_small_uint_t n2s_flags; + + (void) duk__push_this_number_plain(ctx); + if (duk_is_undefined(ctx, 0)) { + radix = 10; + } else { + radix = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 2, 36); + } + DUK_DDD(DUK_DDDPRINT("radix=%ld", (long) radix)); + + n2s_flags = 0; + + duk_numconv_stringify(ctx, + radix /*radix*/, + 0 /*digits*/, + n2s_flags /*flags*/); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_locale_string(duk_context *ctx) { + /* XXX: just use toString() for now; permitted although not recommended. + * nargs==1, so radix is passed to toString(). + */ + return duk_bi_number_prototype_to_string(ctx); +} + +/* + * toFixed(), toExponential(), toPrecision() + */ + +/* XXX: shared helper for toFixed(), toExponential(), toPrecision()? */ + +DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_fixed(duk_context *ctx) { + duk_small_int_t frac_digits; + duk_double_t d; + duk_small_int_t c; + duk_small_uint_t n2s_flags; + + frac_digits = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 0, 20); + d = duk__push_this_number_plain(ctx); + + c = (duk_small_int_t) DUK_FPCLASSIFY(d); + if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) { + goto use_to_string; + } + + if (d >= 1.0e21 || d <= -1.0e21) { + goto use_to_string; + } + + n2s_flags = DUK_N2S_FLAG_FIXED_FORMAT | + DUK_N2S_FLAG_FRACTION_DIGITS; + + duk_numconv_stringify(ctx, + 10 /*radix*/, + frac_digits /*digits*/, + n2s_flags /*flags*/); + return 1; + + use_to_string: + DUK_ASSERT_TOP(ctx, 2); + duk_to_string(ctx, -1); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_exponential(duk_context *ctx) { + duk_bool_t frac_undefined; + duk_small_int_t frac_digits; + duk_double_t d; + duk_small_int_t c; + duk_small_uint_t n2s_flags; + + d = duk__push_this_number_plain(ctx); + + frac_undefined = duk_is_undefined(ctx, 0); + duk_to_int(ctx, 0); /* for side effects */ + + c = (duk_small_int_t) DUK_FPCLASSIFY(d); + if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) { + goto use_to_string; + } + + frac_digits = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 0, 20); + + n2s_flags = DUK_N2S_FLAG_FORCE_EXP | + (frac_undefined ? 0 : DUK_N2S_FLAG_FIXED_FORMAT); + + duk_numconv_stringify(ctx, + 10 /*radix*/, + frac_digits + 1 /*leading digit + fractions*/, + n2s_flags /*flags*/); + return 1; + + use_to_string: + DUK_ASSERT_TOP(ctx, 2); + duk_to_string(ctx, -1); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_precision(duk_context *ctx) { + /* The specification has quite awkward order of coercion and + * checks for toPrecision(). The operations below are a bit + * reordered, within constraints of observable side effects. + */ + + duk_double_t d; + duk_small_int_t prec; + duk_small_int_t c; + duk_small_uint_t n2s_flags; + + DUK_ASSERT_TOP(ctx, 1); + + d = duk__push_this_number_plain(ctx); + if (duk_is_undefined(ctx, 0)) { + goto use_to_string; + } + DUK_ASSERT_TOP(ctx, 2); + + duk_to_int(ctx, 0); /* for side effects */ + + c = (duk_small_int_t) DUK_FPCLASSIFY(d); + if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) { + goto use_to_string; + } + + prec = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 1, 21); + + n2s_flags = DUK_N2S_FLAG_FIXED_FORMAT | + DUK_N2S_FLAG_NO_ZERO_PAD; + + duk_numconv_stringify(ctx, + 10 /*radix*/, + prec /*digits*/, + n2s_flags /*flags*/); + return 1; + + use_to_string: + /* Used when precision is undefined; also used for NaN (-> "NaN"), + * and +/- infinity (-> "Infinity", "-Infinity"). + */ + + DUK_ASSERT_TOP(ctx, 2); + duk_to_string(ctx, -1); + return 1; +} +#line 1 "duk_bi_object.c" +/* + * Object built-ins + */ + +/* include removed: duk_internal.h */ + +DUK_INTERNAL duk_ret_t duk_bi_object_constructor(duk_context *ctx) { + if (!duk_is_constructor_call(ctx) && + !duk_is_null_or_undefined(ctx, 0)) { + duk_to_object(ctx, 0); + return 1; + } + + if (duk_is_object(ctx, 0)) { + return 1; + } + + /* Pointer and buffer primitive values are treated like other + * primitives values which have a fully fledged object counterpart: + * promote to an object value. Lightfuncs are coerced with + * ToObject() even they could also be returned as is. + */ + if (duk_check_type_mask(ctx, 0, DUK_TYPE_MASK_STRING | + DUK_TYPE_MASK_BOOLEAN | + DUK_TYPE_MASK_NUMBER | + DUK_TYPE_MASK_POINTER | + DUK_TYPE_MASK_BUFFER | + DUK_TYPE_MASK_LIGHTFUNC)) { + duk_to_object(ctx, 0); + return 1; + } + + duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT), + DUK_BIDX_OBJECT_PROTOTYPE); + return 1; +} + +/* Shared helper to implement Object.getPrototypeOf and the ES6 + * Object.prototype.__proto__ getter. + * + * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__ + */ +DUK_INTERNAL duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h; + duk_hobject *proto; + + DUK_UNREF(thr); + + /* magic: 0=getter call, 1=Object.getPrototypeOf */ + if (duk_get_current_magic(ctx) == 0) { + duk_push_this_coercible_to_object(ctx); + duk_insert(ctx, 0); + } + + h = duk_require_hobject_or_lfunc(ctx, 0); + /* h is NULL for lightfunc */ + + /* XXX: should the API call handle this directly, i.e. attempt + * to duk_push_hobject(ctx, null) would push a null instead? + * (On the other hand 'undefined' would be just as logical, but + * not wanted here.) + */ + + if (h == NULL) { + duk_push_hobject_bidx(ctx, DUK_BIDX_FUNCTION_PROTOTYPE); + } else { + proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h); + if (proto) { + duk_push_hobject(ctx, proto); + } else { + duk_push_null(ctx); + } + } + return 1; +} + +/* Shared helper to implement ES6 Object.setPrototypeOf and + * Object.prototype.__proto__ setter. + * + * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__ + * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-object.setprototypeof + */ +DUK_INTERNAL duk_ret_t duk_bi_object_setprototype_shared(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h_obj; + duk_hobject *h_new_proto; + duk_hobject *h_curr; + duk_ret_t ret_success = 1; /* retval for success path */ + + /* Preliminaries for __proto__ and setPrototypeOf (E6 19.1.2.18 steps 1-4); + * magic: 0=setter call, 1=Object.setPrototypeOf + */ + if (duk_get_current_magic(ctx) == 0) { + duk_push_this_check_object_coercible(ctx); + duk_insert(ctx, 0); + if (!duk_check_type_mask(ctx, 1, DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_OBJECT)) { + return 0; + } + + /* __proto__ setter returns 'undefined' on success unlike the + * setPrototypeOf() call which returns the target object. + */ + ret_success = 0; + } else { + duk_require_object_coercible(ctx, 0); + duk_require_type_mask(ctx, 1, DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_OBJECT); + } + + h_new_proto = duk_get_hobject(ctx, 1); + /* h_new_proto may be NULL */ + if (duk_is_lightfunc(ctx, 0)) { + if (h_new_proto == thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]) { + goto skip; + } + goto fail_nonextensible; + } + h_obj = duk_get_hobject(ctx, 0); + if (!h_obj) { + goto skip; + } + DUK_ASSERT(h_obj != NULL); + + /* [[SetPrototypeOf]] standard behavior, E6 9.1.2 */ + /* TODO: implement Proxy object support here */ + + if (h_new_proto == DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_obj)) { + goto skip; + } + if (!DUK_HOBJECT_HAS_EXTENSIBLE(h_obj)) { + goto fail_nonextensible; + } + for (h_curr = h_new_proto; h_curr != NULL; h_curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_curr)) { + /* Loop prevention */ + if (h_curr == h_obj) { + goto fail_loop; + } + } + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h_obj, h_new_proto); + /* fall thru */ + + skip: + duk_set_top(ctx, 1); + return ret_success; + + fail_nonextensible: + fail_loop: + return DUK_RET_TYPE_ERROR; +} + +DUK_INTERNAL duk_ret_t duk_bi_object_constructor_get_own_property_descriptor(duk_context *ctx) { + /* XXX: no need for indirect call */ + return duk_hobject_object_get_own_property_descriptor(ctx); +} + +DUK_INTERNAL duk_ret_t duk_bi_object_constructor_create(duk_context *ctx) { + duk_tval *tv; + duk_hobject *proto = NULL; + + DUK_ASSERT_TOP(ctx, 2); + + tv = duk_get_tval(ctx, 0); + DUK_ASSERT(tv != NULL); + if (DUK_TVAL_IS_NULL(tv)) { + ; + } else if (DUK_TVAL_IS_OBJECT(tv)) { + proto = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(proto != NULL); + } else { + return DUK_RET_TYPE_ERROR; + } + + (void) duk_push_object_helper_proto(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT), + proto); + + if (!duk_is_undefined(ctx, 1)) { + /* [ O Properties obj ] */ + + duk_replace(ctx, 0); + + /* [ obj Properties ] */ + + /* Just call the "original" Object.defineProperties() to + * finish up. + */ + + return duk_bi_object_constructor_define_properties(ctx); + } + + /* [ O Properties obj ] */ + + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_object_constructor_define_property(duk_context *ctx) { + duk_hobject *obj; + duk_hstring *key; + duk_hobject *get; + duk_hobject *set; + duk_idx_t idx_value; + duk_uint_t defprop_flags; + + DUK_ASSERT(ctx != NULL); + + DUK_DDD(DUK_DDDPRINT("Object.defineProperty(): ctx=%p obj=%!T key=%!T desc=%!T", + (void *) ctx, + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 1), + (duk_tval *) duk_get_tval(ctx, 2))); + + /* [ obj key desc ] */ + + /* Lightfuncs are currently supported by coercing to a temporary + * Function object; changes will be allowed (the coerced value is + * extensible) but will be lost. + */ + obj = duk_require_hobject_or_lfunc_coerce(ctx, 0); + (void) duk_to_string(ctx, 1); + key = duk_require_hstring(ctx, 1); + (void) duk_require_hobject(ctx, 2); + + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + DUK_ASSERT(duk_get_hobject(ctx, 2) != NULL); + + /* + * Validate and convert argument property descriptor (an Ecmascript + * object) into a set of defprop_flags and possibly property value, + * getter, and/or setter values on the value stack. + * + * Lightfunc set/get values are coerced to full Functions. + */ + + duk_hobject_prepare_property_descriptor(ctx, + 2 /*idx_desc*/, + &defprop_flags, + &idx_value, + &get, + &set); + + /* + * Use Object.defineProperty() helper for the actual operation. + */ + + duk_hobject_define_property_helper(ctx, + defprop_flags, + obj, + key, + idx_value, + get, + set); + + /* Ignore the normalize/validate helper outputs on the value stack, + * they're popped automatically. + */ + + /* + * Return target object. + */ + + duk_push_hobject(ctx, obj); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_object_constructor_define_properties(duk_context *ctx) { + duk_small_uint_t pass; + duk_uint_t defprop_flags; + duk_hobject *obj; + duk_idx_t idx_value; + duk_hobject *get; + duk_hobject *set; + + /* Lightfunc handling by ToObject() coercion. */ + obj = duk_require_hobject_or_lfunc_coerce(ctx, 0); /* target */ + DUK_ASSERT(obj != NULL); + + duk_to_object(ctx, 1); /* properties object */ + + DUK_DDD(DUK_DDDPRINT("target=%!iT, properties=%!iT", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 1))); + + /* + * Two pass approach to processing the property descriptors. + * On first pass validate and normalize all descriptors before + * any changes are made to the target object. On second pass + * make the actual modifications to the target object. + * + * Right now we'll just use the same normalize/validate helper + * on both passes, ignoring its outputs on the first pass. + */ + + for (pass = 0; pass < 2; pass++) { + duk_set_top(ctx, 2); /* -> [ hobject props ] */ + duk_enum(ctx, 1, DUK_ENUM_OWN_PROPERTIES_ONLY /*enum_flags*/); + + for (;;) { + duk_hstring *key; + + /* [ hobject props enum(props) ] */ + + duk_set_top(ctx, 3); + + if (!duk_next(ctx, 2, 1 /*get_value*/)) { + break; + } + + DUK_DDD(DUK_DDDPRINT("-> key=%!iT, desc=%!iT", + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + + /* [ hobject props enum(props) key desc ] */ + + duk_hobject_prepare_property_descriptor(ctx, + 4 /*idx_desc*/, + &defprop_flags, + &idx_value, + &get, + &set); + + /* [ hobject props enum(props) key desc value? getter? setter? ] */ + + if (pass == 0) { + continue; + } + + key = duk_get_hstring(ctx, 3); + DUK_ASSERT(key != NULL); + + duk_hobject_define_property_helper(ctx, + defprop_flags, + obj, + key, + idx_value, + get, + set); + } + } + + /* + * Return target object + */ + + duk_dup(ctx, 0); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_object_constructor_seal_freeze_shared(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h; + duk_bool_t is_freeze; + + h = duk_require_hobject_or_lfunc(ctx, 0); + if (!h) { + /* Lightfunc, always success. */ + return 1; + } + + is_freeze = (duk_bool_t) duk_get_current_magic(ctx); + duk_hobject_object_seal_freeze_helper(thr, h, is_freeze); + + /* Sealed and frozen objects cannot gain any more properties, + * so this is a good time to compact them. + */ + duk_hobject_compact_props(thr, h); + + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_object_constructor_prevent_extensions(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h; + + h = duk_require_hobject_or_lfunc(ctx, 0); + if (!h) { + /* Lightfunc, always success. */ + return 1; + } + DUK_ASSERT(h != NULL); + + DUK_HOBJECT_CLEAR_EXTENSIBLE(h); + + /* A non-extensible object cannot gain any more properties, + * so this is a good time to compact. + */ + duk_hobject_compact_props(thr, h); + + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_sealed_frozen_shared(duk_context *ctx) { + duk_hobject *h; + duk_bool_t is_frozen; + duk_bool_t rc; + + h = duk_require_hobject_or_lfunc(ctx, 0); + if (!h) { + duk_push_true(ctx); /* frozen and sealed */ + } else { + is_frozen = duk_get_current_magic(ctx); + rc = duk_hobject_object_is_sealed_frozen_helper((duk_hthread *) ctx, h, is_frozen /*is_frozen*/); + duk_push_boolean(ctx, rc); + } + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_extensible(duk_context *ctx) { + duk_hobject *h; + + h = duk_require_hobject_or_lfunc(ctx, 0); + if (!h) { + duk_push_false(ctx); + } else { + duk_push_boolean(ctx, DUK_HOBJECT_HAS_EXTENSIBLE(h)); + } + return 1; +} + +/* Shared helper for Object.getOwnPropertyNames() and Object.keys(). + * Magic: 0=getOwnPropertyNames, 1=Object.keys. + */ +DUK_INTERNAL duk_ret_t duk_bi_object_constructor_keys_shared(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj; +#if defined(DUK_USE_ES6_PROXY) + duk_hobject *h_proxy_target; + duk_hobject *h_proxy_handler; + duk_hobject *h_trap_result; + duk_uarridx_t i, len, idx; +#endif + duk_small_uint_t enum_flags; + + DUK_ASSERT_TOP(ctx, 1); + DUK_UNREF(thr); + + obj = duk_require_hobject_or_lfunc_coerce(ctx, 0); + DUK_ASSERT(obj != NULL); + DUK_UNREF(obj); + +#if defined(DUK_USE_ES6_PROXY) + if (DUK_LIKELY(!duk_hobject_proxy_check(thr, + obj, + &h_proxy_target, + &h_proxy_handler))) { + goto skip_proxy; + } + + duk_push_hobject(ctx, h_proxy_handler); + if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_OWN_KEYS)) { + /* Careful with reachability here: don't pop 'obj' before pushing + * proxy target. + */ + DUK_DDD(DUK_DDDPRINT("no ownKeys trap, get keys of target instead")); + duk_pop_2(ctx); + duk_push_hobject(ctx, h_proxy_target); + duk_replace(ctx, 0); + DUK_ASSERT_TOP(ctx, 1); + goto skip_proxy; + } + + /* [ obj handler trap ] */ + duk_insert(ctx, -2); + duk_push_hobject(ctx, h_proxy_target); /* -> [ obj trap handler target ] */ + duk_call_method(ctx, 1 /*nargs*/); /* -> [ obj trap_result ] */ + h_trap_result = duk_require_hobject(ctx, -1); + DUK_UNREF(h_trap_result); + + len = (duk_uarridx_t) duk_get_length(ctx, -1); + idx = 0; + duk_push_array(ctx); + for (i = 0; i < len; i++) { + /* [ obj trap_result res_arr ] */ + if (duk_get_prop_index(ctx, -2, i) && duk_is_string(ctx, -1)) { + /* XXX: for Object.keys() we should check enumerability of key */ + /* [ obj trap_result res_arr propname ] */ + duk_put_prop_index(ctx, -2, idx); + idx++; + } else { + duk_pop(ctx); + } + } + + /* XXX: for Object.keys() the [[OwnPropertyKeys]] result (trap result) + * should be filtered so that only enumerable keys remain. Enumerability + * should be checked with [[GetOwnProperty]] on the original object + * (i.e., the proxy in this case). If the proxy has a getOwnPropertyDescriptor + * trap, it should be triggered for every property. If the proxy doesn't have + * the trap, enumerability should be checked against the target object instead. + * We don't do any of this now, so Object.keys() and Object.getOwnPropertyNames() + * return the same result now for proxy traps. We still do clean up the trap + * result, so that Object.keys() and Object.getOwnPropertyNames() will return a + * clean array of strings without gaps. + */ + return 1; + + skip_proxy: +#endif /* DUK_USE_ES6_PROXY */ + + DUK_ASSERT_TOP(ctx, 1); + + if (duk_get_current_magic(ctx)) { + /* Object.keys */ + enum_flags = DUK_ENUM_OWN_PROPERTIES_ONLY | + DUK_ENUM_NO_PROXY_BEHAVIOR; + } else { + /* Object.getOwnPropertyNames */ + enum_flags = DUK_ENUM_INCLUDE_NONENUMERABLE | + DUK_ENUM_OWN_PROPERTIES_ONLY | + DUK_ENUM_NO_PROXY_BEHAVIOR; + } + + return duk_hobject_get_enumerated_keys(ctx, enum_flags); +} + +DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_string(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + + duk_push_this(ctx); + duk_push_string(ctx, "[object "); + + if (duk_is_undefined(ctx, -2)) { + duk_push_hstring_stridx(ctx, DUK_STRIDX_UC_UNDEFINED); + } else if (duk_is_null(ctx, -2)) { + duk_push_hstring_stridx(ctx, DUK_STRIDX_UC_NULL); + } else { + duk_hobject *h_this; + duk_hstring *h_classname; + + duk_to_object(ctx, -2); + h_this = duk_get_hobject(ctx, -2); + DUK_ASSERT(h_this != NULL); + + h_classname = DUK_HOBJECT_GET_CLASS_STRING(thr->heap, h_this); + DUK_ASSERT(h_classname != NULL); + + duk_push_hstring(ctx, h_classname); + } + + duk_push_string(ctx, "]"); + duk_concat(ctx, 3); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_locale_string(duk_context *ctx) { + DUK_ASSERT_TOP(ctx, 0); + (void) duk_push_this_coercible_to_object(ctx); + duk_get_prop_stridx(ctx, 0, DUK_STRIDX_TO_STRING); + if (!duk_is_callable(ctx, 1)) { + return DUK_RET_TYPE_ERROR; + } + duk_dup(ctx, 0); /* -> [ O toString O ] */ + duk_call_method(ctx, 0); /* XXX: call method tail call? */ + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_object_prototype_value_of(duk_context *ctx) { + (void) duk_push_this_coercible_to_object(ctx); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_object_prototype_is_prototype_of(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h_v; + duk_hobject *h_obj; + + DUK_ASSERT_TOP(ctx, 1); + + h_v = duk_get_hobject(ctx, 0); + if (!h_v) { + duk_push_false(ctx); /* XXX: tail call: return duk_push_false(ctx) */ + return 1; + } + + h_obj = duk_push_this_coercible_to_object(ctx); + DUK_ASSERT(h_obj != NULL); + + /* E5.1 Section 15.2.4.6, step 3.a, lookup proto once before compare. + * Prototype loops should cause an error to be thrown. + */ + duk_push_boolean(ctx, duk_hobject_prototype_chain_contains(thr, DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_v), h_obj, 0 /*ignore_loop*/)); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_object_prototype_has_own_property(duk_context *ctx) { + return duk_hobject_object_ownprop_helper(ctx, 0 /*required_desc_flags*/); +} + +DUK_INTERNAL duk_ret_t duk_bi_object_prototype_property_is_enumerable(duk_context *ctx) { + return duk_hobject_object_ownprop_helper(ctx, DUK_PROPDESC_FLAG_ENUMERABLE /*required_desc_flags*/); +} +#line 1 "duk_bi_pointer.c" +/* + * Pointer built-ins + */ + +/* include removed: duk_internal.h */ + +/* + * Constructor + */ + +DUK_INTERNAL duk_ret_t duk_bi_pointer_constructor(duk_context *ctx) { + /* XXX: this behavior is quite useless now; it would be nice to be able + * to create pointer values from e.g. numbers or strings. Numbers are + * problematic on 64-bit platforms though. Hex encoded strings? + */ + if (duk_get_top(ctx) == 0) { + duk_push_pointer(ctx, NULL); + } else { + duk_to_pointer(ctx, 0); + } + DUK_ASSERT(duk_is_pointer(ctx, 0)); + duk_set_top(ctx, 1); + + if (duk_is_constructor_call(ctx)) { + duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_POINTER), + DUK_BIDX_POINTER_PROTOTYPE); + + /* Pointer object internal value is immutable */ + duk_dup(ctx, 0); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE); + } + /* Note: unbalanced stack on purpose */ + + return 1; +} + +/* + * toString(), valueOf() + */ + +DUK_INTERNAL duk_ret_t duk_bi_pointer_prototype_tostring_shared(duk_context *ctx) { + duk_tval *tv; + duk_small_int_t to_string = duk_get_current_magic(ctx); + + duk_push_this(ctx); + tv = duk_require_tval(ctx, -1); + DUK_ASSERT(tv != NULL); + + if (DUK_TVAL_IS_POINTER(tv)) { + /* nop */ + } else if (DUK_TVAL_IS_OBJECT(tv)) { + duk_hobject *h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + + /* Must be a "pointer object", i.e. class "Pointer" */ + if (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_POINTER) { + goto type_error; + } + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE); + } else { + goto type_error; + } + + if (to_string) { + duk_to_string(ctx, -1); + } + return 1; + + type_error: + return DUK_RET_TYPE_ERROR; +} +#line 1 "duk_bi_proxy.c" +/* + * Proxy built-in (ES6) + */ + +/* include removed: duk_internal.h */ + +#if defined(DUK_USE_ES6_PROXY) +DUK_INTERNAL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx) { + duk_hobject *h_target; + duk_hobject *h_handler; + + if (!duk_is_constructor_call(ctx)) { + return DUK_RET_TYPE_ERROR; + } + + /* Reject a proxy object as the target because it would need + * special handler in property lookups. (ES6 has no such restriction) + */ + h_target = duk_require_hobject_or_lfunc_coerce(ctx, 0); + DUK_ASSERT(h_target != NULL); + if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_target)) { + return DUK_RET_TYPE_ERROR; + } + + /* Reject a proxy object as the handler because it would cause + * potentially unbounded recursion. (ES6 has no such restriction) + */ + h_handler = duk_require_hobject_or_lfunc_coerce(ctx, 1); + DUK_ASSERT(h_handler != NULL); + if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_handler)) { + return DUK_RET_TYPE_ERROR; + } + + /* XXX: the returned value is exotic in ES6, but we use a + * simple object here with no prototype. Without a prototype, + * [[DefaultValue]] coercion fails which is abit confusing. + * No callable check/handling in the current Proxy subset. + */ + (void) duk_push_object_helper_proto(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT), + NULL); + DUK_ASSERT_TOP(ctx, 3); + + /* Make _Target and _Handler non-configurable and non-writable. + * They can still be forcibly changed by C code (both user and + * Duktape internal), but not by Ecmascript code. + */ + + /* Proxy target */ + duk_dup(ctx, 0); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE); + + /* Proxy handler */ + duk_dup(ctx, 1); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_HANDLER, DUK_PROPDESC_FLAGS_NONE); + + return 1; /* replacement handler */ +} +#else /* DUK_USE_ES6_PROXY */ +DUK_INTERNAL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_ES6_PROXY */ +#line 1 "duk_bi_regexp.c" +/* + * RegExp built-ins + */ + +/* include removed: duk_internal.h */ + +#ifdef DUK_USE_REGEXP_SUPPORT + +DUK_LOCAL void duk__get_this_regexp(duk_context *ctx) { + duk_hobject *h; + + duk_push_this(ctx); + h = duk_require_hobject_with_class(ctx, -1, DUK_HOBJECT_CLASS_REGEXP); + DUK_ASSERT(h != NULL); + DUK_UNREF(h); + duk_insert(ctx, 0); /* prepend regexp to valstack 0 index */ +} + +/* XXX: much to improve (code size) */ +DUK_INTERNAL duk_ret_t duk_bi_regexp_constructor(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *h_pattern; + + DUK_ASSERT_TOP(ctx, 2); + h_pattern = duk_get_hobject(ctx, 0); + + if (!duk_is_constructor_call(ctx) && + h_pattern != NULL && + DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP && + duk_is_undefined(ctx, 1)) { + /* Called as a function, pattern has [[Class]] "RegExp" and + * flags is undefined -> return object as is. + */ + duk_dup(ctx, 0); + return 1; + } + + /* Else functionality is identical for function call and constructor + * call. + */ + + if (h_pattern != NULL && + DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP) { + if (duk_is_undefined(ctx, 1)) { + duk_bool_t flag_g, flag_i, flag_m; + duk_get_prop_stridx(ctx, 0, DUK_STRIDX_SOURCE); + flag_g = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL); + flag_i = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_IGNORE_CASE, NULL); + flag_m = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_MULTILINE, NULL); + + duk_push_sprintf(ctx, "%s%s%s", + (const char *) (flag_g ? "g" : ""), + (const char *) (flag_i ? "i" : ""), + (const char *) (flag_m ? "m" : "")); + + /* [ ... pattern flags ] */ + } else { + return DUK_RET_TYPE_ERROR; + } + } else { + if (duk_is_undefined(ctx, 0)) { + duk_push_string(ctx, ""); + } else { + duk_dup(ctx, 0); + duk_to_string(ctx, -1); + } + if (duk_is_undefined(ctx, 1)) { + duk_push_string(ctx, ""); + } else { + duk_dup(ctx, 1); + duk_to_string(ctx, -1); + } + + /* [ ... pattern flags ] */ + } + + DUK_DDD(DUK_DDDPRINT("RegExp constructor/function call, pattern=%!T, flags=%!T", + (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1))); + + /* [ ... pattern flags ] */ + + duk_regexp_compile(thr); + + /* [ ... bytecode escaped_source ] */ + + duk_regexp_create_instance(thr); + + /* [ ... RegExp ] */ + + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_exec(duk_context *ctx) { + duk__get_this_regexp(ctx); + + /* [ regexp input ] */ + + duk_regexp_match((duk_hthread *) ctx); + + /* [ result ] */ + + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_test(duk_context *ctx) { + duk__get_this_regexp(ctx); + + /* [ regexp input ] */ + + /* result object is created and discarded; wasteful but saves code space */ + duk_regexp_match((duk_hthread *) ctx); + + /* [ result ] */ + + duk_push_boolean(ctx, (duk_is_null(ctx, -1) ? 0 : 1)); + + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_to_string(duk_context *ctx) { + duk_hstring *h_bc; + duk_small_int_t re_flags; + +#if 0 + /* A little tricky string approach to provide the flags string. + * This depends on the specific flag values in duk_regexp.h, + * which needs to be asserted for. In practice this doesn't + * produce more compact code than the easier approach in use. + */ + + const char *flag_strings = "gim\0gi\0gm\0g\0"; + duk_uint8_t flag_offsets[8] = { + (duk_uint8_t) 3, /* flags: "" */ + (duk_uint8_t) 10, /* flags: "g" */ + (duk_uint8_t) 5, /* flags: "i" */ + (duk_uint8_t) 4, /* flags: "gi" */ + (duk_uint8_t) 2, /* flags: "m" */ + (duk_uint8_t) 7, /* flags: "gm" */ + (duk_uint8_t) 1, /* flags: "im" */ + (duk_uint8_t) 0, /* flags: "gim" */ + }; + DUK_ASSERT(DUK_RE_FLAG_GLOBAL == 1); + DUK_ASSERT(DUK_RE_FLAG_IGNORE_CASE == 2); + DUK_ASSERT(DUK_RE_FLAG_MULTILINE == 4); +#endif + + duk__get_this_regexp(ctx); + + /* [ regexp ] */ + + duk_get_prop_stridx(ctx, 0, DUK_STRIDX_SOURCE); + duk_get_prop_stridx(ctx, 0, DUK_STRIDX_INT_BYTECODE); + h_bc = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_bc != NULL); + DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(h_bc) >= 1); + DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h_bc) >= 1); + DUK_ASSERT(DUK_HSTRING_GET_DATA(h_bc)[0] < 0x80); + re_flags = (duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0]; + + /* [ regexp source bytecode ] */ + +#if 1 + /* This is a cleaner approach and also produces smaller code than + * the other alternative. Use duk_require_string() for format + * safety (although the source property should always exist). + */ + duk_push_sprintf(ctx, "/%s/%s%s%s", + (const char *) duk_require_string(ctx, -2), /* require to be safe */ + (re_flags & DUK_RE_FLAG_GLOBAL) ? "g" : "", + (re_flags & DUK_RE_FLAG_IGNORE_CASE) ? "i" : "", + (re_flags & DUK_RE_FLAG_MULTILINE) ? "m" : ""); +#else + /* This should not be necessary because no-one should tamper with the + * regexp bytecode, but is prudent to avoid potential segfaults if that + * were to happen for some reason. + */ + re_flags &= 0x07; + DUK_ASSERT(re_flags >= 0 && re_flags <= 7); /* three flags */ + duk_push_sprintf(ctx, "/%s/%s", + (const char *) duk_require_string(ctx, -2), + (const char *) (flag_strings + flag_offsets[re_flags])); +#endif + + return 1; +} + +#else /* DUK_USE_REGEXP_SUPPORT */ + +DUK_INTERNAL duk_ret_t duk_bi_regexp_constructor(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} + +DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_exec(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} + +DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_test(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} + +DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_to_string(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} + +#endif /* DUK_USE_REGEXP_SUPPORT */ +#line 1 "duk_bi_string.c" +/* + * String built-ins + */ + +/* XXX: There are several limitations in the current implementation for + * strings with >= 0x80000000UL characters. In some cases one would need + * to be able to represent the range [-0xffffffff,0xffffffff] and so on. + * Generally character and byte length are assumed to fit into signed 32 + * bits (< 0x80000000UL). Places with issues are not marked explicitly + * below in all cases, look for signed type usage (duk_int_t etc) for + * offsets/lengths. + */ + +/* include removed: duk_internal.h */ + +/* + * Constructor + */ + +DUK_INTERNAL duk_ret_t duk_bi_string_constructor(duk_context *ctx) { + /* String constructor needs to distinguish between an argument not given at all + * vs. given as 'undefined'. We're a vararg function to handle this properly. + */ + + if (duk_get_top(ctx) == 0) { + duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING); + } else { + duk_to_string(ctx, 0); + } + DUK_ASSERT(duk_is_string(ctx, 0)); + duk_set_top(ctx, 1); + + if (duk_is_constructor_call(ctx)) { + duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_STRING), + DUK_BIDX_STRING_PROTOTYPE); + + /* String object internal value is immutable */ + duk_dup(ctx, 0); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE); + } + /* Note: unbalanced stack on purpose */ + + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_string_constructor_from_char_code(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; + duk_idx_t i, n; + duk_ucodepoint_t cp; + + /* XXX: It would be nice to build the string directly but ToUint16() + * coercion is needed so a generic helper would not be very + * helpful (perhaps coerce the value stack first here and then + * build a string from a duk_tval number sequence in one go?). + */ + + n = duk_get_top(ctx); + + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(thr, bw, n); /* initial estimate for ASCII only codepoints */ + + for (i = 0; i < n; i++) { + /* XXX: could improve bufwriter handling to write multiple codepoints + * with one ensure call but the relative benefit would be quite small. + */ + +#if defined(DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT) + /* ToUint16() coercion is mandatory in the E5.1 specification, but + * this non-compliant behavior makes more sense because we support + * non-BMP codepoints. Don't use CESU-8 because that'd create + * surrogate pairs. + */ + + cp = (duk_ucodepoint_t) duk_to_uint32(ctx, i); + DUK_BW_WRITE_ENSURE_XUTF8(thr, bw, cp); +#else + cp = (duk_ucodepoint_t) duk_to_uint32(ctx, i); + DUK_BW_WRITE_ENSURE_CESU8(thr, bw, cp); +#endif + } + + DUK_BW_COMPACT(thr, bw); + duk_to_string(ctx, -1); + return 1; +} + +/* + * toString(), valueOf() + */ + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_to_string(duk_context *ctx) { + duk_tval *tv; + + duk_push_this(ctx); + tv = duk_require_tval(ctx, -1); + DUK_ASSERT(tv != NULL); + + if (DUK_TVAL_IS_STRING(tv)) { + /* return as is */ + return 1; + } else if (DUK_TVAL_IS_OBJECT(tv)) { + duk_hobject *h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + + /* Must be a "string object", i.e. class "String" */ + if (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_STRING) { + goto type_error; + } + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE); + DUK_ASSERT(duk_is_string(ctx, -1)); + + return 1; + } else { + goto type_error; + } + + /* never here, but fall through */ + + type_error: + return DUK_RET_TYPE_ERROR; +} + +/* + * Character and charcode access + */ + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_char_at(duk_context *ctx) { + duk_int_t pos; + + /* XXX: faster implementation */ + + (void) duk_push_this_coercible_to_string(ctx); + pos = duk_to_int(ctx, 0); + duk_substring(ctx, -1, pos, pos + 1); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_char_code_at(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_int_t pos; + duk_hstring *h; + duk_bool_t clamped; + + /* XXX: faster implementation */ + + DUK_DDD(DUK_DDDPRINT("arg=%!T", (duk_tval *) duk_get_tval(ctx, 0))); + + h = duk_push_this_coercible_to_string(ctx); + DUK_ASSERT(h != NULL); + + pos = duk_to_int_clamped_raw(ctx, + 0 /*index*/, + 0 /*min(incl)*/, + DUK_HSTRING_GET_CHARLEN(h) - 1 /*max(incl)*/, + &clamped /*out_clamped*/); + if (clamped) { + duk_push_number(ctx, DUK_DOUBLE_NAN); + return 1; + } + + duk_push_u32(ctx, (duk_uint32_t) duk_hstring_char_code_at_raw(thr, h, pos)); + return 1; +} + +/* + * substring(), substr(), slice() + */ + +/* XXX: any chance of merging these three similar but still slightly + * different algorithms so that footprint would be reduced? + */ + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substring(duk_context *ctx) { + duk_hstring *h; + duk_int_t start_pos, end_pos; + duk_int_t len; + + h = duk_push_this_coercible_to_string(ctx); + DUK_ASSERT(h != NULL); + len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h); + + /* [ start end str ] */ + + start_pos = duk_to_int_clamped(ctx, 0, 0, len); + if (duk_is_undefined(ctx, 1)) { + end_pos = len; + } else { + end_pos = duk_to_int_clamped(ctx, 1, 0, len); + } + DUK_ASSERT(start_pos >= 0 && start_pos <= len); + DUK_ASSERT(end_pos >= 0 && end_pos <= len); + + if (start_pos > end_pos) { + duk_int_t tmp = start_pos; + start_pos = end_pos; + end_pos = tmp; + } + + DUK_ASSERT(end_pos >= start_pos); + + duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos); + return 1; +} + +#ifdef DUK_USE_SECTION_B +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx) { + duk_hstring *h; + duk_int_t start_pos, end_pos; + duk_int_t len; + + /* Unlike non-obsolete String calls, substr() algorithm in E5.1 + * specification will happily coerce undefined and null to strings + * ("undefined" and "null"). + */ + duk_push_this(ctx); + h = duk_to_hstring(ctx, -1); + DUK_ASSERT(h != NULL); + len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h); + + /* [ start length str ] */ + + /* The implementation for computing of start_pos and end_pos differs + * from the standard algorithm, but is intended to result in the exactly + * same behavior. This is not always obvious. + */ + + /* combines steps 2 and 5; -len ensures max() not needed for step 5 */ + start_pos = duk_to_int_clamped(ctx, 0, -len, len); + if (start_pos < 0) { + start_pos = len + start_pos; + } + DUK_ASSERT(start_pos >= 0 && start_pos <= len); + + /* combines steps 3, 6; step 7 is not needed */ + if (duk_is_undefined(ctx, 1)) { + end_pos = len; + } else { + DUK_ASSERT(start_pos <= len); + end_pos = start_pos + duk_to_int_clamped(ctx, 1, 0, len - start_pos); + } + DUK_ASSERT(start_pos >= 0 && start_pos <= len); + DUK_ASSERT(end_pos >= 0 && end_pos <= len); + DUK_ASSERT(end_pos >= start_pos); + + duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos); + return 1; +} +#else /* DUK_USE_SECTION_B */ +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_SECTION_B */ + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_slice(duk_context *ctx) { + duk_hstring *h; + duk_int_t start_pos, end_pos; + duk_int_t len; + + h = duk_push_this_coercible_to_string(ctx); + DUK_ASSERT(h != NULL); + len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h); + + /* [ start end str ] */ + + start_pos = duk_to_int_clamped(ctx, 0, -len, len); + if (start_pos < 0) { + start_pos = len + start_pos; + } + if (duk_is_undefined(ctx, 1)) { + end_pos = len; + } else { + end_pos = duk_to_int_clamped(ctx, 1, -len, len); + if (end_pos < 0) { + end_pos = len + end_pos; + } + } + DUK_ASSERT(start_pos >= 0 && start_pos <= len); + DUK_ASSERT(end_pos >= 0 && end_pos <= len); + + if (end_pos < start_pos) { + end_pos = start_pos; + } + + DUK_ASSERT(end_pos >= start_pos); + + duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos); + return 1; +} + +/* + * Case conversion + */ + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_caseconv_shared(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_small_int_t uppercase = duk_get_current_magic(ctx); + + (void) duk_push_this_coercible_to_string(ctx); + duk_unicode_case_convert_string(thr, (duk_bool_t) uppercase); + return 1; +} + +/* + * indexOf() and lastIndexOf() + */ + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_indexof_shared(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h_this; + duk_hstring *h_search; + duk_int_t clen_this; + duk_int_t cpos; + duk_int_t bpos; + const duk_uint8_t *p_start, *p_end, *p; + const duk_uint8_t *q_start; + duk_int_t q_blen; + duk_uint8_t firstbyte; + duk_uint8_t t; + duk_small_int_t is_lastindexof = duk_get_current_magic(ctx); /* 0=indexOf, 1=lastIndexOf */ + + h_this = duk_push_this_coercible_to_string(ctx); + DUK_ASSERT(h_this != NULL); + clen_this = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h_this); + + h_search = duk_to_hstring(ctx, 0); + DUK_ASSERT(h_search != NULL); + q_start = DUK_HSTRING_GET_DATA(h_search); + q_blen = (duk_int_t) DUK_HSTRING_GET_BYTELEN(h_search); + + duk_to_number(ctx, 1); + if (duk_is_nan(ctx, 1) && is_lastindexof) { + /* indexOf: NaN should cause pos to be zero. + * lastIndexOf: NaN should cause pos to be +Infinity + * (and later be clamped to len). + */ + cpos = clen_this; + } else { + cpos = duk_to_int_clamped(ctx, 1, 0, clen_this); + } + + /* Empty searchstring always matches; cpos must be clamped here. + * (If q_blen were < 0 due to clamped coercion, it would also be + * caught here.) + */ + if (q_blen <= 0) { + duk_push_int(ctx, cpos); + return 1; + } + DUK_ASSERT(q_blen > 0); + + bpos = (duk_int_t) duk_heap_strcache_offset_char2byte(thr, h_this, (duk_uint32_t) cpos); + + p_start = DUK_HSTRING_GET_DATA(h_this); + p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_this); + p = p_start + bpos; + + /* This loop is optimized for size. For speed, there should be + * two separate loops, and we should ensure that memcmp() can be + * used without an extra "will searchstring fit" check. Doing + * the preconditioning for 'p' and 'p_end' is easy but cpos + * must be updated if 'p' is wound back (backward scanning). + */ + + firstbyte = q_start[0]; /* leading byte of match string */ + while (p <= p_end && p >= p_start) { + t = *p; + + /* For Ecmascript strings, this check can only match for + * initial UTF-8 bytes (not continuation bytes). For other + * strings all bets are off. + */ + + if ((t == firstbyte) && ((duk_size_t) (p_end - p) >= (duk_size_t) q_blen)) { + DUK_ASSERT(q_blen > 0); /* no issues with memcmp() zero size, even if broken */ + if (DUK_MEMCMP(p, q_start, (duk_size_t) q_blen) == 0) { + duk_push_int(ctx, cpos); + return 1; + } + } + + /* track cpos while scanning */ + if (is_lastindexof) { + /* when going backwards, we decrement cpos 'early'; + * 'p' may point to a continuation byte of the char + * at offset 'cpos', but that's OK because we'll + * backtrack all the way to the initial byte. + */ + if ((t & 0xc0) != 0x80) { + cpos--; + } + p--; + } else { + if ((t & 0xc0) != 0x80) { + cpos++; + } + p++; + } + } + + /* Not found. Empty string case is handled specially above. */ + duk_push_int(ctx, -1); + return 1; +} + +/* + * replace() + */ + +/* XXX: the current implementation works but is quite clunky; it compiles + * to almost 1,4kB of x86 code so it needs to be simplified (better approach, + * shared helpers, etc). Some ideas for refactoring: + * + * - a primitive to convert a string into a regexp matcher (reduces matching + * code at the cost of making matching much slower) + * - use replace() as a basic helper for match() and split(), which are both + * much simpler + * - API call to get_prop and to_boolean + */ + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h_input; + duk_hstring *h_match; + duk_hstring *h_search; + duk_hobject *h_re; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; +#ifdef DUK_USE_REGEXP_SUPPORT + duk_bool_t is_regexp; + duk_bool_t is_global; +#endif + duk_bool_t is_repl_func; + duk_uint32_t match_start_coff, match_start_boff; +#ifdef DUK_USE_REGEXP_SUPPORT + duk_int_t match_caps; +#endif + duk_uint32_t prev_match_end_boff; + const duk_uint8_t *r_start, *r_end, *r; /* repl string scan */ + duk_size_t tmp_sz; + + DUK_ASSERT_TOP(ctx, 2); + h_input = duk_push_this_coercible_to_string(ctx); + DUK_ASSERT(h_input != NULL); + + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input)); /* input size is good output starting point */ + + DUK_ASSERT_TOP(ctx, 4); + + /* stack[0] = search value + * stack[1] = replace value + * stack[2] = input string + * stack[3] = result buffer + */ + + h_re = duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_REGEXP); + if (h_re) { +#ifdef DUK_USE_REGEXP_SUPPORT + is_regexp = 1; + is_global = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL); + + if (is_global) { + /* start match from beginning */ + duk_push_int(ctx, 0); + duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX); + } +#else /* DUK_USE_REGEXP_SUPPORT */ + return DUK_RET_UNSUPPORTED_ERROR; +#endif /* DUK_USE_REGEXP_SUPPORT */ + } else { + duk_to_string(ctx, 0); +#ifdef DUK_USE_REGEXP_SUPPORT + is_regexp = 0; + is_global = 0; +#endif + } + + if (duk_is_function(ctx, 1)) { + is_repl_func = 1; + r_start = NULL; + r_end = NULL; + } else { + duk_hstring *h_repl; + + is_repl_func = 0; + h_repl = duk_to_hstring(ctx, 1); + DUK_ASSERT(h_repl != NULL); + r_start = DUK_HSTRING_GET_DATA(h_repl); + r_end = r_start + DUK_HSTRING_GET_BYTELEN(h_repl); + } + + prev_match_end_boff = 0; + + for (;;) { + /* + * If matching with a regexp: + * - non-global RegExp: lastIndex not touched on a match, zeroed + * on a non-match + * - global RegExp: on match, lastIndex will be updated by regexp + * executor to point to next char after the matching part (so that + * characters in the matching part are not matched again) + * + * If matching with a string: + * - always non-global match, find first occurrence + * + * We need: + * - The character offset of start-of-match for the replacer function + * - The byte offsets for start-of-match and end-of-match to implement + * the replacement values $&, $`, and $', and to copy non-matching + * input string portions (including header and trailer) verbatim. + * + * NOTE: the E5.1 specification is a bit vague how the RegExp should + * behave in the replacement process; e.g. is matching done first for + * all matches (in the global RegExp case) before any replacer calls + * are made? See: test-bi-string-proto-replace.js for discussion. + */ + + DUK_ASSERT_TOP(ctx, 4); + +#ifdef DUK_USE_REGEXP_SUPPORT + if (is_regexp) { + duk_dup(ctx, 0); + duk_dup(ctx, 2); + duk_regexp_match(thr); /* [ ... regexp input ] -> [ res_obj ] */ + if (!duk_is_object(ctx, -1)) { + duk_pop(ctx); + break; + } + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX); + DUK_ASSERT(duk_is_number(ctx, -1)); + match_start_coff = duk_get_int(ctx, -1); + duk_pop(ctx); + + duk_get_prop_index(ctx, -1, 0); + DUK_ASSERT(duk_is_string(ctx, -1)); + h_match = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_match != NULL); + duk_pop(ctx); /* h_match is borrowed, remains reachable through match_obj */ + + if (DUK_HSTRING_GET_BYTELEN(h_match) == 0) { + /* This should be equivalent to match() algorithm step 8.f.iii.2: + * detect an empty match and allow it, but don't allow it twice. + */ + duk_uint32_t last_index; + + duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX); + last_index = (duk_uint32_t) duk_get_uint(ctx, -1); + DUK_DDD(DUK_DDDPRINT("empty match, bump lastIndex: %ld -> %ld", + (long) last_index, (long) (last_index + 1))); + duk_pop(ctx); + duk_push_int(ctx, last_index + 1); + duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX); + } + + DUK_ASSERT(duk_get_length(ctx, -1) <= DUK_INT_MAX); /* string limits */ + match_caps = (duk_int_t) duk_get_length(ctx, -1); + } else { +#else /* DUK_USE_REGEXP_SUPPORT */ + { /* unconditionally */ +#endif /* DUK_USE_REGEXP_SUPPORT */ + const duk_uint8_t *p_start, *p_end, *p; /* input string scan */ + const duk_uint8_t *q_start; /* match string */ + duk_size_t q_blen; + +#ifdef DUK_USE_REGEXP_SUPPORT + DUK_ASSERT(!is_global); /* single match always */ +#endif + + p_start = DUK_HSTRING_GET_DATA(h_input); + p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input); + p = p_start; + + h_search = duk_get_hstring(ctx, 0); + DUK_ASSERT(h_search != NULL); + q_start = DUK_HSTRING_GET_DATA(h_search); + q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_search); + + p_end -= q_blen; /* ensure full memcmp() fits in while */ + + match_start_coff = 0; + + while (p <= p_end) { + DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input)); + if (DUK_MEMCMP((void *) p, (void *) q_start, (size_t) q_blen) == 0) { + duk_dup(ctx, 0); + h_match = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_match != NULL); +#ifdef DUK_USE_REGEXP_SUPPORT + match_caps = 0; +#endif + goto found; + } + + /* track utf-8 non-continuation bytes */ + if ((p[0] & 0xc0) != 0x80) { + match_start_coff++; + } + p++; + } + + /* not found */ + break; + } + found: + + /* stack[0] = search value + * stack[1] = replace value + * stack[2] = input string + * stack[3] = result buffer + * stack[4] = regexp match OR match string + */ + + match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff); + + tmp_sz = (duk_size_t) (match_start_boff - prev_match_end_boff); + DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, tmp_sz); + + prev_match_end_boff = match_start_boff + DUK_HSTRING_GET_BYTELEN(h_match); + + if (is_repl_func) { + duk_idx_t idx_args; + duk_hstring *h_repl; + + /* regexp res_obj is at index 4 */ + + duk_dup(ctx, 1); + idx_args = duk_get_top(ctx); + +#ifdef DUK_USE_REGEXP_SUPPORT + if (is_regexp) { + duk_int_t idx; + duk_require_stack(ctx, match_caps + 2); + for (idx = 0; idx < match_caps; idx++) { + /* match followed by capture(s) */ + duk_get_prop_index(ctx, 4, idx); + } + } else { +#else /* DUK_USE_REGEXP_SUPPORT */ + { /* unconditionally */ +#endif /* DUK_USE_REGEXP_SUPPORT */ + /* match == search string, by definition */ + duk_dup(ctx, 0); + } + duk_push_int(ctx, match_start_coff); + duk_dup(ctx, 2); + + /* [ ... replacer match [captures] match_char_offset input ] */ + + duk_call(ctx, duk_get_top(ctx) - idx_args); + h_repl = duk_to_hstring(ctx, -1); /* -> [ ... repl_value ] */ + DUK_ASSERT(h_repl != NULL); + + DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_repl); + + duk_pop(ctx); /* repl_value */ + } else { + r = r_start; + + while (r < r_end) { + duk_int_t ch1; + duk_int_t ch2; +#ifdef DUK_USE_REGEXP_SUPPORT + duk_int_t ch3; +#endif + duk_size_t left; + + ch1 = *r++; + if (ch1 != DUK_ASC_DOLLAR) { + goto repl_write; + } + left = r_end - r; + + if (left <= 0) { + goto repl_write; + } + + ch2 = r[0]; + switch ((int) ch2) { + case DUK_ASC_DOLLAR: { + ch1 = (1 << 8) + DUK_ASC_DOLLAR; + goto repl_write; + } + case DUK_ASC_AMP: { + DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_match); + r++; + continue; + } + case DUK_ASC_GRAVE: { + tmp_sz = (duk_size_t) match_start_boff; + DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input), tmp_sz); + r++; + continue; + } + case DUK_ASC_SINGLEQUOTE: { + duk_uint32_t match_end_boff; + + /* Use match charlen instead of bytelen, just in case the input and + * match codepoint encodings would have different lengths. + */ + match_end_boff = duk_heap_strcache_offset_char2byte(thr, + h_input, + match_start_coff + DUK_HSTRING_GET_CHARLEN(h_match)); + + tmp_sz = (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - match_end_boff); + DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + match_end_boff, tmp_sz); + r++; + continue; + } + default: { +#ifdef DUK_USE_REGEXP_SUPPORT + duk_int_t capnum, captmp, capadv; + /* XXX: optional check, match_caps is zero if no regexp, + * so dollar will be interpreted literally anyway. + */ + + if (!is_regexp) { + goto repl_write; + } + + if (!(ch2 >= DUK_ASC_0 && ch2 <= DUK_ASC_9)) { + goto repl_write; + } + capnum = ch2 - DUK_ASC_0; + capadv = 1; + + if (left >= 2) { + ch3 = r[1]; + if (ch3 >= DUK_ASC_0 && ch3 <= DUK_ASC_9) { + captmp = capnum * 10 + (ch3 - DUK_ASC_0); + if (captmp < match_caps) { + capnum = captmp; + capadv = 2; + } + } + } + + if (capnum > 0 && capnum < match_caps) { + DUK_ASSERT(is_regexp != 0); /* match_caps == 0 without regexps */ + + /* regexp res_obj is at offset 4 */ + duk_get_prop_index(ctx, 4, (duk_uarridx_t) capnum); + if (duk_is_string(ctx, -1)) { + duk_hstring *h_tmp_str; + + h_tmp_str = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_tmp_str != NULL); + + DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_tmp_str); + } else { + /* undefined -> skip (replaced with empty) */ + } + duk_pop(ctx); + r += capadv; + continue; + } else { + goto repl_write; + } +#else /* DUK_USE_REGEXP_SUPPORT */ + goto repl_write; /* unconditionally */ +#endif /* DUK_USE_REGEXP_SUPPORT */ + } /* default case */ + } /* switch (ch2) */ + + repl_write: + /* ch1 = (r_increment << 8) + byte */ + + DUK_BW_WRITE_ENSURE_U8(thr, bw, (duk_uint8_t) (ch1 & 0xff)); + r += ch1 >> 8; + } /* while repl */ + } /* if (is_repl_func) */ + + duk_pop(ctx); /* pop regexp res_obj or match string */ + +#ifdef DUK_USE_REGEXP_SUPPORT + if (!is_global) { +#else + { /* unconditionally; is_global==0 */ +#endif + break; + } + } + + /* trailer */ + tmp_sz = (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - prev_match_end_boff); + DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, tmp_sz); + + DUK_ASSERT_TOP(ctx, 4); + DUK_BW_COMPACT(thr, bw); + duk_to_string(ctx, -1); + return 1; +} + +/* + * split() + */ + +/* XXX: very messy now, but works; clean up, remove unused variables (nomimally + * used so compiler doesn't complain). + */ + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_split(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h_input; + duk_hstring *h_sep; + duk_uint32_t limit; + duk_uint32_t arr_idx; +#ifdef DUK_USE_REGEXP_SUPPORT + duk_bool_t is_regexp; +#endif + duk_bool_t matched; /* set to 1 if any match exists (needed for empty input special case) */ + duk_uint32_t prev_match_end_coff, prev_match_end_boff; + duk_uint32_t match_start_boff, match_start_coff; + duk_uint32_t match_end_boff, match_end_coff; + + DUK_UNREF(thr); + + h_input = duk_push_this_coercible_to_string(ctx); + DUK_ASSERT(h_input != NULL); + + duk_push_array(ctx); + + if (duk_is_undefined(ctx, 1)) { + limit = 0xffffffffUL; + } else { + limit = duk_to_uint32(ctx, 1); + } + + if (limit == 0) { + return 1; + } + + /* If the separator is a RegExp, make a "clone" of it. The specification + * algorithm calls [[Match]] directly for specific indices; we emulate this + * by tweaking lastIndex and using a "force global" variant of duk_regexp_match() + * which will use global-style matching even when the RegExp itself is non-global. + */ + + if (duk_is_undefined(ctx, 0)) { + /* The spec algorithm first does "R = ToString(separator)" before checking + * whether separator is undefined. Since this is side effect free, we can + * skip the ToString() here. + */ + duk_dup(ctx, 2); + duk_put_prop_index(ctx, 3, 0); + return 1; + } else if (duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_REGEXP) != NULL) { +#ifdef DUK_USE_REGEXP_SUPPORT + duk_push_hobject_bidx(ctx, DUK_BIDX_REGEXP_CONSTRUCTOR); + duk_dup(ctx, 0); + duk_new(ctx, 1); /* [ ... RegExp val ] -> [ ... res ] */ + duk_replace(ctx, 0); + /* lastIndex is initialized to zero by new RegExp() */ + is_regexp = 1; +#else + return DUK_RET_UNSUPPORTED_ERROR; +#endif + } else { + duk_to_string(ctx, 0); +#ifdef DUK_USE_REGEXP_SUPPORT + is_regexp = 0; +#endif + } + + /* stack[0] = separator (string or regexp) + * stack[1] = limit + * stack[2] = input string + * stack[3] = result array + */ + + prev_match_end_boff = 0; + prev_match_end_coff = 0; + arr_idx = 0; + matched = 0; + + for (;;) { + /* + * The specification uses RegExp [[Match]] to attempt match at specific + * offsets. We don't have such a primitive, so we use an actual RegExp + * and tweak lastIndex. Since the RegExp may be non-global, we use a + * special variant which forces global-like behavior for matching. + */ + + DUK_ASSERT_TOP(ctx, 4); + +#ifdef DUK_USE_REGEXP_SUPPORT + if (is_regexp) { + duk_dup(ctx, 0); + duk_dup(ctx, 2); + duk_regexp_match_force_global(thr); /* [ ... regexp input ] -> [ res_obj ] */ + if (!duk_is_object(ctx, -1)) { + duk_pop(ctx); + break; + } + matched = 1; + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX); + DUK_ASSERT(duk_is_number(ctx, -1)); + match_start_coff = duk_get_int(ctx, -1); + match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff); + duk_pop(ctx); + + if (match_start_coff == DUK_HSTRING_GET_CHARLEN(h_input)) { + /* don't allow an empty match at the end of the string */ + duk_pop(ctx); + break; + } + + duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX); + DUK_ASSERT(duk_is_number(ctx, -1)); + match_end_coff = duk_get_int(ctx, -1); + match_end_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_end_coff); + duk_pop(ctx); + + /* empty match -> bump and continue */ + if (prev_match_end_boff == match_end_boff) { + duk_push_int(ctx, match_end_coff + 1); + duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX); + duk_pop(ctx); + continue; + } + } else { +#else /* DUK_USE_REGEXP_SUPPORT */ + { /* unconditionally */ +#endif /* DUK_USE_REGEXP_SUPPORT */ + const duk_uint8_t *p_start, *p_end, *p; /* input string scan */ + const duk_uint8_t *q_start; /* match string */ + duk_size_t q_blen, q_clen; + + p_start = DUK_HSTRING_GET_DATA(h_input); + p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input); + p = p_start + prev_match_end_boff; + + h_sep = duk_get_hstring(ctx, 0); + DUK_ASSERT(h_sep != NULL); + q_start = DUK_HSTRING_GET_DATA(h_sep); + q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sep); + q_clen = (duk_size_t) DUK_HSTRING_GET_CHARLEN(h_sep); + + p_end -= q_blen; /* ensure full memcmp() fits in while */ + + match_start_coff = prev_match_end_coff; + + if (q_blen == 0) { + /* Handle empty separator case: it will always match, and always + * triggers the check in step 13.c.iii initially. Note that we + * must skip to either end of string or start of first codepoint, + * skipping over any continuation bytes! + * + * Don't allow an empty string to match at the end of the input. + */ + + matched = 1; /* empty separator can always match */ + + match_start_coff++; + p++; + while (p < p_end) { + if ((p[0] & 0xc0) != 0x80) { + goto found; + } + p++; + } + goto not_found; + } + + DUK_ASSERT(q_blen > 0 && q_clen > 0); + while (p <= p_end) { + DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input)); + DUK_ASSERT(q_blen > 0); /* no issues with empty memcmp() */ + if (DUK_MEMCMP((void *) p, (void *) q_start, (duk_size_t) q_blen) == 0) { + /* never an empty match, so step 13.c.iii can't be triggered */ + goto found; + } + + /* track utf-8 non-continuation bytes */ + if ((p[0] & 0xc0) != 0x80) { + match_start_coff++; + } + p++; + } + + not_found: + /* not found */ + break; + + found: + matched = 1; + match_start_boff = (duk_uint32_t) (p - p_start); + match_end_coff = (duk_uint32_t) (match_start_coff + q_clen); /* constrained by string length */ + match_end_boff = (duk_uint32_t) (match_start_boff + q_blen); /* ditto */ + + /* empty match (may happen with empty separator) -> bump and continue */ + if (prev_match_end_boff == match_end_boff) { + prev_match_end_boff++; + prev_match_end_coff++; + continue; + } + } /* if (is_regexp) */ + + /* stack[0] = separator (string or regexp) + * stack[1] = limit + * stack[2] = input string + * stack[3] = result array + * stack[4] = regexp res_obj (if is_regexp) + */ + + DUK_DDD(DUK_DDDPRINT("split; match_start b=%ld,c=%ld, match_end b=%ld,c=%ld, prev_end b=%ld,c=%ld", + (long) match_start_boff, (long) match_start_coff, + (long) match_end_boff, (long) match_end_coff, + (long) prev_match_end_boff, (long) prev_match_end_coff)); + + duk_push_lstring(ctx, + (const char *) (DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff), + (duk_size_t) (match_start_boff - prev_match_end_boff)); + duk_put_prop_index(ctx, 3, arr_idx); + arr_idx++; + if (arr_idx >= limit) { + goto hit_limit; + } + +#ifdef DUK_USE_REGEXP_SUPPORT + if (is_regexp) { + duk_size_t i, len; + + len = duk_get_length(ctx, 4); + for (i = 1; i < len; i++) { + DUK_ASSERT(i <= DUK_UARRIDX_MAX); /* cannot have >4G captures */ + duk_get_prop_index(ctx, 4, (duk_uarridx_t) i); + duk_put_prop_index(ctx, 3, arr_idx); + arr_idx++; + if (arr_idx >= limit) { + goto hit_limit; + } + } + + duk_pop(ctx); + /* lastIndex already set up for next match */ + } else { +#else /* DUK_USE_REGEXP_SUPPORT */ + { /* unconditionally */ +#endif /* DUK_USE_REGEXP_SUPPORT */ + /* no action */ + } + + prev_match_end_boff = match_end_boff; + prev_match_end_coff = match_end_coff; + continue; + } /* for */ + + /* Combined step 11 (empty string special case) and 14-15. */ + + DUK_DDD(DUK_DDDPRINT("split trailer; prev_end b=%ld,c=%ld", + (long) prev_match_end_boff, (long) prev_match_end_coff)); + + if (DUK_HSTRING_GET_CHARLEN(h_input) > 0 || !matched) { + /* Add trailer if: + * a) non-empty input + * b) empty input and no (zero size) match found (step 11) + */ + + duk_push_lstring(ctx, + (const char *) DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, + (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - prev_match_end_boff)); + duk_put_prop_index(ctx, 3, arr_idx); + /* No arr_idx update or limit check */ + } + + return 1; + + hit_limit: +#ifdef DUK_USE_REGEXP_SUPPORT + if (is_regexp) { + duk_pop(ctx); + } +#endif + + return 1; +} + +/* + * Various + */ + +#ifdef DUK_USE_REGEXP_SUPPORT +DUK_LOCAL void duk__to_regexp_helper(duk_context *ctx, duk_idx_t index, duk_bool_t force_new) { + duk_hobject *h; + + /* Shared helper for match() steps 3-4, search() steps 3-4. */ + + DUK_ASSERT(index >= 0); + + if (force_new) { + goto do_new; + } + + h = duk_get_hobject_with_class(ctx, index, DUK_HOBJECT_CLASS_REGEXP); + if (!h) { + goto do_new; + } + return; + + do_new: + duk_push_hobject_bidx(ctx, DUK_BIDX_REGEXP_CONSTRUCTOR); + duk_dup(ctx, index); + duk_new(ctx, 1); /* [ ... RegExp val ] -> [ ... res ] */ + duk_replace(ctx, index); +} +#endif /* DUK_USE_REGEXP_SUPPORT */ + +#ifdef DUK_USE_REGEXP_SUPPORT +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + + /* Easiest way to implement the search required by the specification + * is to do a RegExp test() with lastIndex forced to zero. To avoid + * side effects on the argument, "clone" the RegExp if a RegExp was + * given as input. + * + * The global flag of the RegExp should be ignored; setting lastIndex + * to zero (which happens when "cloning" the RegExp) should have an + * equivalent effect. + */ + + DUK_ASSERT_TOP(ctx, 1); + (void) duk_push_this_coercible_to_string(ctx); /* at index 1 */ + duk__to_regexp_helper(ctx, 0 /*index*/, 1 /*force_new*/); + + /* stack[0] = regexp + * stack[1] = string + */ + + /* Avoid using RegExp.prototype methods, as they're writable and + * configurable and may have been changed. + */ + + duk_dup(ctx, 0); + duk_dup(ctx, 1); /* [ ... re_obj input ] */ + duk_regexp_match(thr); /* -> [ ... res_obj ] */ + + if (!duk_is_object(ctx, -1)) { + duk_push_int(ctx, -1); + return 1; + } + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX); + DUK_ASSERT(duk_is_number(ctx, -1)); + return 1; +} +#else /* DUK_USE_REGEXP_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_REGEXP_SUPPORT */ + +#ifdef DUK_USE_REGEXP_SUPPORT +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_match(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_bool_t global; + duk_int_t prev_last_index; + duk_int_t this_index; + duk_int_t arr_idx; + + DUK_ASSERT_TOP(ctx, 1); + (void) duk_push_this_coercible_to_string(ctx); + duk__to_regexp_helper(ctx, 0 /*index*/, 0 /*force_new*/); + global = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL); + DUK_ASSERT_TOP(ctx, 2); + + /* stack[0] = regexp + * stack[1] = string + */ + + if (!global) { + duk_regexp_match(thr); /* -> [ res_obj ] */ + return 1; /* return 'res_obj' */ + } + + /* Global case is more complex. */ + + /* [ regexp string ] */ + + duk_push_int(ctx, 0); + duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX); + duk_push_array(ctx); + + /* [ regexp string res_arr ] */ + + prev_last_index = 0; + arr_idx = 0; + + for (;;) { + DUK_ASSERT_TOP(ctx, 3); + + duk_dup(ctx, 0); + duk_dup(ctx, 1); + duk_regexp_match(thr); /* -> [ ... regexp string ] -> [ ... res_obj ] */ + + if (!duk_is_object(ctx, -1)) { + duk_pop(ctx); + break; + } + + duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX); + DUK_ASSERT(duk_is_number(ctx, -1)); + this_index = duk_get_int(ctx, -1); + duk_pop(ctx); + + if (this_index == prev_last_index) { + this_index++; + duk_push_int(ctx, this_index); + duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX); + } + prev_last_index = this_index; + + duk_get_prop_index(ctx, -1, 0); /* match string */ + duk_put_prop_index(ctx, 2, arr_idx); + arr_idx++; + duk_pop(ctx); /* res_obj */ + } + + if (arr_idx == 0) { + duk_push_null(ctx); + } + + return 1; /* return 'res_arr' or 'null' */ +} +#else /* DUK_USE_REGEXP_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_match(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_REGEXP_SUPPORT */ + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_concat(duk_context *ctx) { + /* duk_concat() coerces arguments with ToString() in correct order */ + (void) duk_push_this_coercible_to_string(ctx); + duk_insert(ctx, 0); /* this is relatively expensive */ + duk_concat(ctx, duk_get_top(ctx)); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_trim(duk_context *ctx) { + DUK_ASSERT_TOP(ctx, 0); + (void) duk_push_this_coercible_to_string(ctx); + duk_trim(ctx, 0); + DUK_ASSERT_TOP(ctx, 1); + return 1; +} + +DUK_INTERNAL duk_ret_t duk_bi_string_prototype_locale_compare(duk_context *ctx) { + duk_hstring *h1; + duk_hstring *h2; + duk_size_t h1_len, h2_len, prefix_len; + duk_small_int_t ret = 0; + duk_small_int_t rc; + + /* The current implementation of localeCompare() is simply a codepoint + * by codepoint comparison, implemented with a simple string compare + * because UTF-8 should preserve codepoint ordering (assuming valid + * shortest UTF-8 encoding). + * + * The specification requires that the return value must be related + * to the sort order: e.g. negative means that 'this' comes before + * 'that' in sort order. We assume an ascending sort order. + */ + + /* XXX: could share code with duk_js_ops.c, duk_js_compare_helper */ + + h1 = duk_push_this_coercible_to_string(ctx); + DUK_ASSERT(h1 != NULL); + + h2 = duk_to_hstring(ctx, 0); + DUK_ASSERT(h2 != NULL); + + h1_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h1); + h2_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h2); + prefix_len = (h1_len <= h2_len ? h1_len : h2_len); + + /* Zero size compare not an issue with DUK_MEMCMP. */ + rc = (duk_small_int_t) DUK_MEMCMP((const char *) DUK_HSTRING_GET_DATA(h1), + (const char *) DUK_HSTRING_GET_DATA(h2), + prefix_len); + + if (rc < 0) { + ret = -1; + goto done; + } else if (rc > 0) { + ret = 1; + goto done; + } + + /* prefix matches, lengths matter now */ + if (h1_len > h2_len) { + ret = 1; + goto done; + } else if (h1_len == h2_len) { + DUK_ASSERT(ret == 0); + goto done; + } + ret = -1; + goto done; + + done: + duk_push_int(ctx, (duk_int_t) ret); + return 1; +} +#line 1 "duk_bi_thread.c" +/* + * Thread builtins + */ + +/* include removed: duk_internal.h */ + +/* + * Constructor + */ + +DUK_INTERNAL duk_ret_t duk_bi_thread_constructor(duk_context *ctx) { + duk_hthread *new_thr; + duk_hobject *func; + + /* XXX: need a duk_require_func_or_lfunc_coerce() */ + if (!duk_is_callable(ctx, 0)) { + return DUK_RET_TYPE_ERROR; + } + func = duk_require_hobject_or_lfunc_coerce(ctx, 0); + DUK_ASSERT(func != NULL); + + duk_push_thread(ctx); + new_thr = (duk_hthread *) duk_get_hobject(ctx, -1); + DUK_ASSERT(new_thr != NULL); + new_thr->state = DUK_HTHREAD_STATE_INACTIVE; + + /* push initial function call to new thread stack; this is + * picked up by resume(). + */ + duk_push_hobject((duk_context *) new_thr, func); + + return 1; /* return thread */ +} + +/* + * Resume a thread. + * + * The thread must be in resumable state, either (a) new thread which hasn't + * yet started, or (b) a thread which has previously yielded. This method + * must be called from an Ecmascript function. + * + * Args: + * - thread + * - value + * - isError (defaults to false) + * + * Note: yield and resume handling is currently asymmetric. + */ + +DUK_INTERNAL duk_ret_t duk_bi_thread_resume(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hthread *thr_resume; + duk_tval tv_tmp; + duk_tval *tv; + duk_hobject *func; + duk_hobject *caller_func; + duk_small_int_t is_error; + + DUK_DDD(DUK_DDDPRINT("Duktape.Thread.resume(): thread=%!T, value=%!T, is_error=%!T", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 1), + (duk_tval *) duk_get_tval(ctx, 2))); + + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); + DUK_ASSERT(thr->heap->curr_thread == thr); + + thr_resume = duk_require_hthread(ctx, 0); + is_error = (duk_small_int_t) duk_to_boolean(ctx, 2); + duk_set_top(ctx, 2); + + /* [ thread value ] */ + + /* + * Thread state and calling context checks + */ + + if (thr->callstack_top < 2) { + DUK_DD(DUK_DDPRINT("resume state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.resume)")); + goto state_error; + } + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL); /* us */ + DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))); + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL); /* caller */ + + caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2); + if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) { + DUK_DD(DUK_DDPRINT("resume state invalid: caller must be Ecmascript code")); + goto state_error; + } + + /* Note: there is no requirement that: 'thr->callstack_preventcount == 1' + * like for yield. + */ + + if (thr_resume->state != DUK_HTHREAD_STATE_INACTIVE && + thr_resume->state != DUK_HTHREAD_STATE_YIELDED) { + DUK_DD(DUK_DDPRINT("resume state invalid: target thread must be INACTIVE or YIELDED")); + goto state_error; + } + + DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE || + thr_resume->state == DUK_HTHREAD_STATE_YIELDED); + + /* Further state-dependent pre-checks */ + + if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) { + /* no pre-checks now, assume a previous yield() has left things in + * tip-top shape (longjmp handler will assert for these). + */ + } else { + DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE); + + if ((thr_resume->callstack_top != 0) || + (thr_resume->valstack_top - thr_resume->valstack != 1)) { + goto state_invalid_initial; + } + tv = &thr_resume->valstack_top[-1]; + DUK_ASSERT(tv >= thr_resume->valstack && tv < thr_resume->valstack_top); + if (!DUK_TVAL_IS_OBJECT(tv)) { + goto state_invalid_initial; + } + func = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(func != NULL); + if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { + /* Note: cannot be a bound function either right now, + * this would be easy to relax though. + */ + goto state_invalid_initial; + } + + } + + /* + * The error object has been augmented with a traceback and other + * info from its creation point -- usually another thread. The + * error handler is called here right before throwing, but it also + * runs in the resumer's thread. It might be nice to get a traceback + * from the resumee but this is not the case now. + */ + +#if defined(DUK_USE_AUGMENT_ERROR_THROW) + if (is_error) { + DUK_ASSERT_TOP(ctx, 2); /* value (error) is at stack top */ + duk_err_augment_error_throw(thr); /* in resumer's context */ + } +#endif + +#ifdef DUK_USE_DEBUG + if (is_error) { + DUK_DDD(DUK_DDDPRINT("RESUME ERROR: thread=%!T, value=%!T", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 1))); + } else if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) { + DUK_DDD(DUK_DDDPRINT("RESUME NORMAL: thread=%!T, value=%!T", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 1))); + } else { + DUK_DDD(DUK_DDDPRINT("RESUME INITIAL: thread=%!T, value=%!T", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 1))); + } +#endif + + thr->heap->lj.type = DUK_LJ_TYPE_RESUME; + + /* lj value2: thread */ + DUK_ASSERT(thr->valstack_bottom < thr->valstack_top); + DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2); + DUK_TVAL_SET_TVAL(&thr->heap->lj.value2, &thr->valstack_bottom[0]); + DUK_TVAL_INCREF(thr, &thr->heap->lj.value2); + DUK_TVAL_DECREF(thr, &tv_tmp); + + /* lj value1: value */ + DUK_ASSERT(thr->valstack_bottom + 1 < thr->valstack_top); + DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); + DUK_TVAL_SET_TVAL(&thr->heap->lj.value1, &thr->valstack_bottom[1]); + DUK_TVAL_INCREF(thr, &thr->heap->lj.value1); + DUK_TVAL_DECREF(thr, &tv_tmp); + + thr->heap->lj.iserror = is_error; + + DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* call is from executor, so we know we have a jmpbuf */ + duk_err_longjmp(thr); /* execution resumes in bytecode executor */ + return 0; /* never here */ + + state_invalid_initial: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid initial thread state/stack"); + return 0; /* never here */ + + state_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid state for resume"); + return 0; /* never here */ +} + +/* + * Yield the current thread. + * + * The thread must be in yieldable state: it must have a resumer, and there + * must not be any yield-preventing calls (native calls and constructor calls, + * currently) in the thread's call stack (otherwise a resume would not be + * possible later). This method must be called from an Ecmascript function. + * + * Args: + * - value + * - isError (defaults to false) + * + * Note: yield and resume handling is currently asymmetric. + */ + +DUK_INTERNAL duk_ret_t duk_bi_thread_yield(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval tv_tmp; + duk_hobject *caller_func; + duk_small_int_t is_error; + + DUK_DDD(DUK_DDDPRINT("Duktape.Thread.yield(): value=%!T, is_error=%!T", + (duk_tval *) duk_get_tval(ctx, 0), + (duk_tval *) duk_get_tval(ctx, 1))); + + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); + DUK_ASSERT(thr->heap->curr_thread == thr); + + is_error = (duk_small_int_t) duk_to_boolean(ctx, 1); + duk_set_top(ctx, 1); + + /* [ value ] */ + + /* + * Thread state and calling context checks + */ + + if (!thr->resumer) { + DUK_DD(DUK_DDPRINT("yield state invalid: current thread must have a resumer")); + goto state_error; + } + DUK_ASSERT(thr->resumer->state == DUK_HTHREAD_STATE_RESUMED); + + if (thr->callstack_top < 2) { + DUK_DD(DUK_DDPRINT("yield state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.yield)")); + goto state_error; + } + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL); /* us */ + DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))); + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL); /* caller */ + + caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2); + if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) { + DUK_DD(DUK_DDPRINT("yield state invalid: caller must be Ecmascript code")); + goto state_error; + } + + DUK_ASSERT(thr->callstack_preventcount >= 1); /* should never be zero, because we (Duktape.Thread.yield) are on the stack */ + if (thr->callstack_preventcount != 1) { + /* Note: the only yield-preventing call is Duktape.Thread.yield(), hence check for 1, not 0 */ + DUK_DD(DUK_DDPRINT("yield state invalid: there must be no yield-preventing calls in current thread callstack (preventcount is %ld)", + (long) thr->callstack_preventcount)); + goto state_error; + } + + /* + * The error object has been augmented with a traceback and other + * info from its creation point -- usually the current thread. + * The error handler, however, is called right before throwing + * and runs in the yielder's thread. + */ + +#if defined(DUK_USE_AUGMENT_ERROR_THROW) + if (is_error) { + DUK_ASSERT_TOP(ctx, 1); /* value (error) is at stack top */ + duk_err_augment_error_throw(thr); /* in yielder's context */ + } +#endif + +#ifdef DUK_USE_DEBUG + if (is_error) { + DUK_DDD(DUK_DDDPRINT("YIELD ERROR: value=%!T", + (duk_tval *) duk_get_tval(ctx, 0))); + } else { + DUK_DDD(DUK_DDDPRINT("YIELD NORMAL: value=%!T", + (duk_tval *) duk_get_tval(ctx, 0))); + } +#endif + + /* + * Process yield + * + * After longjmp(), processing continues in bytecode executor longjmp + * handler, which will e.g. update thr->resumer to NULL. + */ + + thr->heap->lj.type = DUK_LJ_TYPE_YIELD; + + /* lj value1: value */ + DUK_ASSERT(thr->valstack_bottom < thr->valstack_top); + DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); + DUK_TVAL_SET_TVAL(&thr->heap->lj.value1, &thr->valstack_bottom[0]); + DUK_TVAL_INCREF(thr, &thr->heap->lj.value1); + DUK_TVAL_DECREF(thr, &tv_tmp); + + thr->heap->lj.iserror = is_error; + + DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* call is from executor, so we know we have a jmpbuf */ + duk_err_longjmp(thr); /* execution resumes in bytecode executor */ + return 0; /* never here */ + + state_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid state for yield"); + return 0; /* never here */ +} + +DUK_INTERNAL duk_ret_t duk_bi_thread_current(duk_context *ctx) { + duk_push_current_thread(ctx); + return 1; +} +#line 1 "duk_bi_thrower.c" +/* + * Type error thrower, E5 Section 13.2.3. + */ + +/* include removed: duk_internal.h */ + +DUK_INTERNAL duk_ret_t duk_bi_type_error_thrower(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_TYPE_ERROR; +} +#line 1 "duk_debug_fixedbuffer.c" +/* + * Fixed buffer helper useful for debugging, requires no allocation + * which is critical for debugging. + */ + +/* include removed: duk_internal.h */ + +#ifdef DUK_USE_DEBUG + +DUK_INTERNAL void duk_fb_put_bytes(duk_fixedbuffer *fb, duk_uint8_t *buffer, duk_size_t length) { + duk_size_t avail; + duk_size_t copylen; + + avail = (fb->offset >= fb->length ? (duk_size_t) 0 : (duk_size_t) (fb->length - fb->offset)); + if (length > avail) { + copylen = avail; + fb->truncated = 1; + } else { + copylen = length; + } + DUK_MEMCPY(fb->buffer + fb->offset, buffer, copylen); + fb->offset += copylen; +} + +DUK_INTERNAL void duk_fb_put_byte(duk_fixedbuffer *fb, duk_uint8_t x) { + duk_fb_put_bytes(fb, &x, 1); +} + +DUK_INTERNAL void duk_fb_put_cstring(duk_fixedbuffer *fb, const char *x) { + duk_fb_put_bytes(fb, (duk_uint8_t *) x, (duk_size_t) DUK_STRLEN(x)); +} + +DUK_INTERNAL void duk_fb_sprintf(duk_fixedbuffer *fb, const char *fmt, ...) { + duk_size_t avail; + va_list ap; + + va_start(ap, fmt); + avail = (fb->offset >= fb->length ? (duk_size_t) 0 : (duk_size_t) (fb->length - fb->offset)); + if (avail > 0) { + duk_int_t res = (duk_int_t) DUK_VSNPRINTF((char *) (fb->buffer + fb->offset), avail, fmt, ap); + if (res < 0) { + /* error */ + } else if ((duk_size_t) res >= avail) { + /* (maybe) truncated */ + fb->offset += avail; + if ((duk_size_t) res > avail) { + /* actual chars dropped (not just NUL term) */ + fb->truncated = 1; + } + } else { + /* normal */ + fb->offset += res; + } + } + va_end(ap); +} + +DUK_INTERNAL void duk_fb_put_funcptr(duk_fixedbuffer *fb, duk_uint8_t *fptr, duk_size_t fptr_size) { + char buf[64+1]; + duk_debug_format_funcptr(buf, sizeof(buf), fptr, fptr_size); + buf[sizeof(buf) - 1] = (char) 0; + duk_fb_put_cstring(fb, buf); +} + +DUK_INTERNAL duk_bool_t duk_fb_is_full(duk_fixedbuffer *fb) { + return (fb->offset >= fb->length); +} + +#endif /* DUK_USE_DEBUG */ +#line 1 "duk_debug_heap.c" +/* + * Debug dumping of duk_heap. + */ + +/* include removed: duk_internal.h */ + +#ifdef DUK_USE_DEBUG + +#if 0 /*unused*/ +DUK_LOCAL void duk__sanitize_snippet(char *buf, duk_size_t buf_size, duk_hstring *str) { + duk_size_t i; + duk_size_t nchars; + duk_size_t maxchars; + duk_uint8_t *data; + + DUK_MEMZERO(buf, buf_size); + + maxchars = (duk_size_t) (buf_size - 1); + data = DUK_HSTRING_GET_DATA(str); + nchars = ((duk_size_t) str->blen < maxchars ? (duk_size_t) str->blen : maxchars); + for (i = 0; i < nchars; i++) { + duk_small_int_t c = (duk_small_int_t) data[i]; + if (c < 0x20 || c > 0x7e) { + c = '.'; + } + buf[i] = (char) c; + } +} +#endif + +#if 0 +DUK_LOCAL const char *duk__get_heap_type_string(duk_heaphdr *hdr) { + switch (DUK_HEAPHDR_GET_TYPE(hdr)) { + case DUK_HTYPE_STRING: + return "string"; + case DUK_HTYPE_OBJECT: + return "object"; + case DUK_HTYPE_BUFFER: + return "buffer"; + default: + return "???"; + } +} +#endif + +#if 0 +DUK_LOCAL void duk__dump_indented(duk_heaphdr *obj, int index) { + DUK_UNREF(obj); + DUK_UNREF(index); + DUK_UNREF(duk__get_heap_type_string); + +#ifdef DUK_USE_REFERENCE_COUNTING + DUK_D(DUK_DPRINT(" [%ld]: %p %s (flags: 0x%08lx, ref: %ld) -> %!O", + (long) index, + (void *) obj, + (const char *) duk__get_heap_type_string(obj), + (unsigned long) DUK_HEAPHDR_GET_FLAGS(obj), + (long) DUK_HEAPHDR_GET_REFCOUNT(obj), + (duk_heaphdr *) obj)); +#else + DUK_D(DUK_DPRINT(" [%ld]: %p %s (flags: 0x%08lx) -> %!O", + (long) index, + (void *) obj, + (const char *) duk__get_heap_type_string(obj), + (unsigned long) DUK_HEAPHDR_GET_FLAGS(obj), + (duk_heaphdr *) obj)); +#endif +} +#endif + +#if 0 /*unused*/ +DUK_LOCAL void duk__dump_heaphdr_list(duk_heap *heap, duk_heaphdr *root, const char *name) { + duk_int_t count; + duk_heaphdr *curr; + + DUK_UNREF(heap); + DUK_UNREF(name); + + count = 0; + curr = root; + while (curr) { + count++; + curr = DUK_HEAPHDR_GET_NEXT(curr); + } + + DUK_D(DUK_DPRINT("%s, %ld objects", (const char *) name, (long) count)); + + count = 0; + curr = root; + while (curr) { + count++; + duk__dump_indented(curr, count); + curr = DUK_HEAPHDR_GET_NEXT(curr); + } +} +#endif + +#if 0 /*unused*/ +DUK_LOCAL void duk__dump_stringtable(duk_heap *heap) { + duk_uint_fast32_t i; + char buf[64+1]; + + DUK_D(DUK_DPRINT("stringtable %p, used %ld, size %ld, load %ld%%", + (void *) heap->strtable, + (long) heap->st_used, + (long) heap->st_size, + (long) (((double) heap->st_used) / ((double) heap->st_size) * 100.0))); + + for (i = 0; i < (duk_uint_fast32_t) heap->st_size; i++) { + duk_hstring *e = heap->strtable[i]; + + if (!e) { + DUK_D(DUK_DPRINT(" [%ld]: NULL", (long) i)); + } else if (e == DUK_STRTAB_DELETED_MARKER(heap)) { + DUK_D(DUK_DPRINT(" [%ld]: DELETED", (long) i)); + } else { + duk__sanitize_snippet(buf, sizeof(buf), e); + +#ifdef DUK_USE_REFERENCE_COUNTING + DUK_D(DUK_DPRINT(" [%ld]: %p (flags: 0x%08lx, ref: %ld) '%s', strhash=0x%08lx, blen=%ld, clen=%ld, " + "arridx=%ld, internal=%ld, reserved_word=%ld, strict_reserved_word=%ld, eval_or_arguments=%ld", + (long) i, + (void *) e, + (unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e), + (long) DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) e), + (const char *) buf, + (unsigned long) e->hash, + (long) e->blen, + (long) e->clen, + (long) (DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0), + (long) (DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0), + (long) (DUK_HSTRING_HAS_RESERVED_WORD(e) ? 1 : 0), + (long) (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(e) ? 1 : 0), + (long) (DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(e) ? 1 : 0))); +#else + DUK_D(DUK_DPRINT(" [%ld]: %p (flags: 0x%08lx) '%s', strhash=0x%08lx, blen=%ld, clen=%ld, " + "arridx=%ld, internal=%ld, reserved_word=%ld, strict_reserved_word=%ld, eval_or_arguments=%ld", + (long) i, + (void *) e, + (unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e), + (const char *) buf, + (long) e->hash, + (long) e->blen, + (long) e->clen, + (long) (DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0), + (long) (DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0), + (long) (DUK_HSTRING_HAS_RESERVED_WORD(e) ? 1 : 0), + (long) (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(e) ? 1 : 0), + (long) (DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(e) ? 1 : 0))); +#endif + } + } +} +#endif + +#if 0 /*unused*/ +DUK_LOCAL void duk__dump_strcache(duk_heap *heap) { + duk_uint_fast32_t i; + char buf[64+1]; + + DUK_D(DUK_DPRINT("stringcache")); + + for (i = 0; i < (duk_uint_fast32_t) DUK_HEAP_STRCACHE_SIZE; i++) { + duk_strcache *c = &heap->strcache[i]; + if (!c->h) { + DUK_D(DUK_DPRINT(" [%ld]: bidx=%ld, cidx=%ld, str=NULL", + (long) i, (long) c->bidx, (long) c->cidx)); + } else { + duk__sanitize_snippet(buf, sizeof(buf), c->h); + DUK_D(DUK_DPRINT(" [%ld]: bidx=%ld cidx=%ld str=%s", + (long) i, (long) c->bidx, (long) c->cidx, (const char *) buf)); + } + } +} +#endif + +#if 0 /*unused*/ +DUK_INTERNAL void duk_debug_dump_heap(duk_heap *heap) { + char buf[64+1]; + + DUK_D(DUK_DPRINT("=== heap %p ===", (void *) heap)); + DUK_D(DUK_DPRINT(" flags: 0x%08lx", (unsigned long) heap->flags)); + + /* Note: there is no standard formatter for function pointers */ +#ifdef DUK_USE_GCC_PRAGMAS +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-pedantic" +#endif + duk_debug_format_funcptr(buf, sizeof(buf), (duk_uint8_t *) &heap->alloc_func, sizeof(heap->alloc_func)); + DUK_D(DUK_DPRINT(" alloc_func: %s", (const char *) buf)); + duk_debug_format_funcptr(buf, sizeof(buf), (duk_uint8_t *) &heap->realloc_func, sizeof(heap->realloc_func)); + DUK_D(DUK_DPRINT(" realloc_func: %s", (const char *) buf)); + duk_debug_format_funcptr(buf, sizeof(buf), (duk_uint8_t *) &heap->free_func, sizeof(heap->free_func)); + DUK_D(DUK_DPRINT(" free_func: %s", (const char *) buf)); + duk_debug_format_funcptr(buf, sizeof(buf), (duk_uint8_t *) &heap->fatal_func, sizeof(heap->fatal_func)); + DUK_D(DUK_DPRINT(" fatal_func: %s", (const char *) buf)); +#ifdef DUK_USE_GCC_PRAGMAS +#pragma GCC diagnostic pop +#endif + + DUK_D(DUK_DPRINT(" heap_udata: %p", (void *) heap->heap_udata)); + +#ifdef DUK_USE_MARK_AND_SWEEP +#ifdef DUK_USE_VOLUNTARY_GC + DUK_D(DUK_DPRINT(" mark-and-sweep trig counter: %ld", (long) heap->mark_and_sweep_trigger_counter)); +#endif + DUK_D(DUK_DPRINT(" mark-and-sweep rec depth: %ld", (long) heap->mark_and_sweep_recursion_depth)); + DUK_D(DUK_DPRINT(" mark-and-sweep base flags: 0x%08lx", (unsigned long) heap->mark_and_sweep_base_flags)); +#endif + + DUK_D(DUK_DPRINT(" lj.jmpbuf_ptr: %p", (void *) heap->lj.jmpbuf_ptr)); + DUK_D(DUK_DPRINT(" lj.type: %ld", (long) heap->lj.type)); + DUK_D(DUK_DPRINT(" lj.value1: %!T", (duk_tval *) &heap->lj.value1)); + DUK_D(DUK_DPRINT(" lj.value2: %!T", (duk_tval *) &heap->lj.value2)); + DUK_D(DUK_DPRINT(" lj.iserror: %ld", (long) heap->lj.iserror)); + + DUK_D(DUK_DPRINT(" handling_error: %ld", (long) heap->handling_error)); + + DUK_D(DUK_DPRINT(" heap_thread: %!@O", (duk_heaphdr *) heap->heap_thread)); + DUK_D(DUK_DPRINT(" curr_thread: %!@O", (duk_heaphdr *) heap->curr_thread)); + DUK_D(DUK_DPRINT(" heap_object: %!@O", (duk_heaphdr *) heap->heap_object)); + + DUK_D(DUK_DPRINT(" call_recursion_depth: %ld", (long) heap->call_recursion_depth)); + DUK_D(DUK_DPRINT(" call_recursion_limit: %ld", (long) heap->call_recursion_limit)); + + DUK_D(DUK_DPRINT(" hash_seed: 0x%08lx", (unsigned long) heap->hash_seed)); + DUK_D(DUK_DPRINT(" rnd_state: 0x%08lx", (unsigned long) heap->rnd_state)); + + duk__dump_strcache(heap); + + duk__dump_heaphdr_list(heap, heap->heap_allocated, "heap allocated"); + +#ifdef DUK_USE_REFERENCE_COUNTING + duk__dump_heaphdr_list(heap, heap->refzero_list, "refcounting refzero list"); +#endif + +#ifdef DUK_USE_MARK_AND_SWEEP + duk__dump_heaphdr_list(heap, heap->finalize_list, "mark-and-sweep finalize list"); +#endif + + duk__dump_stringtable(heap); + + /* heap->strs: not worth dumping */ +} +#endif + +#endif /* DUK_USE_DEBUG */ +#line 1 "duk_debug_vsnprintf.c" +/* + * Custom formatter for debug printing, allowing Duktape specific data + * structures (such as tagged values and heap objects) to be printed with + * a nice format string. Because debug printing should not affect execution + * state, formatting here must be independent of execution (see implications + * below) and must not allocate memory. + * + * Custom format tags begin with a '%!' to safely distinguish them from + * standard format tags. The following conversions are supported: + * + * %!T tagged value (duk_tval *) + * %!O heap object (duk_heaphdr *) + * %!I decoded bytecode instruction + * %!C bytecode instruction opcode name (arg is long) + * + * Everything is serialized in a JSON-like manner. The default depth is one + * level, internal prototype is not followed, and internal properties are not + * serialized. The following modifiers change this behavior: + * + * @ print pointers + * # print binary representations (where applicable) + * d deep traversal of own properties (not prototype) + * p follow prototype chain (useless without 'd') + * i include internal properties (other than prototype) + * x hexdump buffers + * h heavy formatting + * + * For instance, the following serializes objects recursively, but does not + * follow the prototype chain nor print internal properties: "%!dO". + * + * Notes: + * + * * Standard snprintf return value semantics seem to vary. This + * implementation returns the number of bytes it actually wrote + * (excluding the null terminator). If retval == buffer size, + * output was truncated (except for corner cases). + * + * * Output format is intentionally different from Ecmascript + * formatting requirements, as formatting here serves debugging + * of internals. + * + * * Depth checking (and updating) is done in each type printer + * separately, to allow them to call each other freely. + * + * * Some pathological structures might take ages to print (e.g. + * self recursion with 100 properties pointing to the object + * itself). To guard against these, each printer also checks + * whether the output buffer is full; if so, early exit. + * + * * Reference loops are detected using a loop stack. + */ + +/* include removed: duk_internal.h */ + +#ifdef DUK_USE_DEBUG + +#include <stdio.h> +#include <stdarg.h> +#include <string.h> + +/* list of conversion specifiers that terminate a format tag; + * this is unfortunately guesswork. + */ +#define DUK__ALLOWED_STANDARD_SPECIFIERS "diouxXeEfFgGaAcsCSpnm" + +/* maximum length of standard format tag that we support */ +#define DUK__MAX_FORMAT_TAG_LENGTH 32 + +/* heapobj recursion depth when deep printing is selected */ +#define DUK__DEEP_DEPTH_LIMIT 8 + +/* maximum recursion depth for loop detection stacks */ +#define DUK__LOOP_STACK_DEPTH 256 + +/* must match bytecode defines now; build autogenerate? */ +DUK_LOCAL const char *duk__bc_optab[64] = { + "LDREG", "STREG", "LDCONST", "LDINT", "LDINTX", "MPUTOBJ", "MPUTOBJI", "MPUTARR", "MPUTARRI", "NEW", + "NEWI", "REGEXP", "CSREG", "CSREGI", "GETVAR", "PUTVAR", "DECLVAR", "DELVAR", "CSVAR", "CSVARI", + "CLOSURE", "GETPROP", "PUTPROP", "DELPROP", "CSPROP", "CSPROPI", "ADD", "SUB", "MUL", "DIV", + "MOD", "BAND", "BOR", "BXOR", "BASL", "BLSR", "BASR", "EQ", "NEQ", "SEQ", + "SNEQ", "GT", "GE", "LT", "LE", "IF", "JUMP", "RETURN", "CALL", "CALLI", + "TRYCATCH", "EXTRA", "PREINCR", "PREDECR", "POSTINCR", "POSTDECR", "PREINCV", "PREDECV", "POSTINCV", "POSTDECV", + "PREINCP", "PREDECP", "POSTINCP", "POSTDECP" +}; + +DUK_LOCAL const char *duk__bc_extraoptab[256] = { + "NOP", "INVALID", "LDTHIS", "LDUNDEF", "LDNULL", "LDTRUE", "LDFALSE", "NEWOBJ", "NEWARR", "SETALEN", + "TYPEOF", "TYPEOFID", "INITENUM", "NEXTENUM", "INITSET", "INITSETI", "INITGET", "INITGETI", "ENDTRY", "ENDCATCH", + "ENDFIN", "THROW", "INVLHS", "UNM", "UNP", "DEBUGGER", "BREAK", "CONTINUE", "BNOT", "LNOT", + "INSTOF", "IN", "LABEL", "ENDLABEL", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", + + "XXX", "XXX", "XXX", "XXX", "XXX", "XXX" +}; + +typedef struct duk__dprint_state duk__dprint_state; +struct duk__dprint_state { + duk_fixedbuffer *fb; + + /* loop_stack_index could be perhaps be replaced by 'depth', but it's nice + * to not couple these two mechanisms unnecessarily. + */ + duk_hobject *loop_stack[DUK__LOOP_STACK_DEPTH]; + duk_int_t loop_stack_index; + duk_int_t loop_stack_limit; + + duk_int_t depth; + duk_int_t depth_limit; + + duk_bool_t pointer; + duk_bool_t heavy; + duk_bool_t binary; + duk_bool_t follow_proto; + duk_bool_t internal; + duk_bool_t hexdump; +}; + +/* helpers */ +DUK_LOCAL_DECL void duk__print_hstring(duk__dprint_state *st, duk_hstring *k, duk_bool_t quotes); +DUK_LOCAL_DECL void duk__print_hobject(duk__dprint_state *st, duk_hobject *h); +DUK_LOCAL_DECL void duk__print_hbuffer(duk__dprint_state *st, duk_hbuffer *h); +DUK_LOCAL_DECL void duk__print_tval(duk__dprint_state *st, duk_tval *tv); +DUK_LOCAL_DECL void duk__print_instr(duk__dprint_state *st, duk_instr_t ins); +DUK_LOCAL_DECL void duk__print_heaphdr(duk__dprint_state *st, duk_heaphdr *h); +DUK_LOCAL_DECL void duk__print_shared_heaphdr(duk__dprint_state *st, duk_heaphdr *h); +DUK_LOCAL_DECL void duk__print_shared_heaphdr_string(duk__dprint_state *st, duk_heaphdr_string *h); + +DUK_LOCAL void duk__print_shared_heaphdr(duk__dprint_state *st, duk_heaphdr *h) { + duk_fixedbuffer *fb = st->fb; + + if (st->heavy) { + duk_fb_sprintf(fb, "(%p)", (void *) h); + } + + if (!h) { + return; + } + + if (st->binary) { + duk_size_t i; + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LBRACKET); + for (i = 0; i < (duk_size_t) sizeof(*h); i++) { + duk_fb_sprintf(fb, "%02lx", (unsigned long) ((duk_uint8_t *)h)[i]); + } + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RBRACKET); + } + +#ifdef DUK_USE_REFERENCE_COUNTING /* currently implicitly also DUK_USE_DOUBLE_LINKED_HEAP */ + if (st->heavy) { + duk_fb_sprintf(fb, "[h_next=%p,h_prev=%p,h_refcount=%lu,h_flags=%08lx,type=%ld," + "reachable=%ld,temproot=%ld,finalizable=%ld,finalized=%ld]", + (void *) DUK_HEAPHDR_GET_NEXT(NULL, h), + (void *) DUK_HEAPHDR_GET_PREV(NULL, h), + (unsigned long) DUK_HEAPHDR_GET_REFCOUNT(h), + (unsigned long) DUK_HEAPHDR_GET_FLAGS(h), + (long) DUK_HEAPHDR_GET_TYPE(h), + (long) (DUK_HEAPHDR_HAS_REACHABLE(h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_TEMPROOT(h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_FINALIZABLE(h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_FINALIZED(h) ? 1 : 0)); + } +#else + if (st->heavy) { + duk_fb_sprintf(fb, "[h_next=%p,h_flags=%08lx,type=%ld,reachable=%ld,temproot=%ld,finalizable=%ld,finalized=%ld]", + (void *) DUK_HEAPHDR_GET_NEXT(NULL, h), + (unsigned long) DUK_HEAPHDR_GET_FLAGS(h), + (long) DUK_HEAPHDR_GET_TYPE(h), + (long) (DUK_HEAPHDR_HAS_REACHABLE(h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_TEMPROOT(h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_FINALIZABLE(h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_FINALIZED(h) ? 1 : 0)); + } +#endif +} + +DUK_LOCAL void duk__print_shared_heaphdr_string(duk__dprint_state *st, duk_heaphdr_string *h) { + duk_fixedbuffer *fb = st->fb; + + if (st->heavy) { + duk_fb_sprintf(fb, "(%p)", (void *) h); + } + + if (!h) { + return; + } + + if (st->binary) { + duk_size_t i; + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LBRACKET); + for (i = 0; i < (duk_size_t) sizeof(*h); i++) { + duk_fb_sprintf(fb, "%02lx", (unsigned long) ((duk_uint8_t *)h)[i]); + } + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RBRACKET); + } + +#ifdef DUK_USE_REFERENCE_COUNTING + if (st->heavy) { + duk_fb_sprintf(fb, "[h_refcount=%lu,h_flags=%08lx,type=%ld,reachable=%ld,temproot=%ld,finalizable=%ld,finalized=%ld]", + (unsigned long) DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h), + (unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) h), + (long) DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h), + (long) (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_TEMPROOT((duk_heaphdr *) h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_FINALIZABLE((duk_heaphdr *) h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_FINALIZED((duk_heaphdr *) h) ? 1 : 0)); + } +#else + if (st->heavy) { + duk_fb_sprintf(fb, "[h_flags=%08lx,type=%ld,reachable=%ld,temproot=%ld,finalizable=%ld,finalized=%ld]", + (unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) h), + (long) DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h), + (long) (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_TEMPROOT((duk_heaphdr *) h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_FINALIZABLE((duk_heaphdr *) h) ? 1 : 0), + (long) (DUK_HEAPHDR_HAS_FINALIZED((duk_heaphdr *) h) ? 1 : 0)); + } +#endif +} + +DUK_LOCAL void duk__print_hstring(duk__dprint_state *st, duk_hstring *h, duk_bool_t quotes) { + duk_fixedbuffer *fb = st->fb; + const duk_uint8_t *p; + const duk_uint8_t *p_end; + + /* terminal type: no depth check */ + + if (duk_fb_is_full(fb)) { + return; + } + + duk__print_shared_heaphdr_string(st, &h->hdr); + + if (!h) { + duk_fb_put_cstring(fb, "NULL"); + return; + } + + p = DUK_HSTRING_GET_DATA(h); + p_end = p + DUK_HSTRING_GET_BYTELEN(h); + + if (p_end > p && p[0] == DUK_ASC_UNDERSCORE) { + /* if property key begins with underscore, encode it with + * forced quotes (e.g. "_Foo") to distinguish it from encoded + * internal properties (e.g. \xffBar -> _Bar). + */ + quotes = 1; + } + + if (quotes) { + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_DOUBLEQUOTE); + } + while (p < p_end) { + duk_uint8_t ch = *p++; + + /* two special escapes: '\' and '"', other printables as is */ + if (ch == '\\') { + duk_fb_sprintf(fb, "\\\\"); + } else if (ch == '"') { + duk_fb_sprintf(fb, "\\\""); + } else if (ch >= 0x20 && ch <= 0x7e) { + duk_fb_put_byte(fb, ch); + } else if (ch == 0xff && !quotes) { + /* encode \xffBar as _Bar if no quotes are applied, this is for + * readable internal keys. + */ + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_UNDERSCORE); + } else { + duk_fb_sprintf(fb, "\\x%02lx", (unsigned long) ch); + } + } + if (quotes) { + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_DOUBLEQUOTE); + } +#ifdef DUK_USE_REFERENCE_COUNTING + /* XXX: limit to quoted strings only, to save keys from being cluttered? */ + duk_fb_sprintf(fb, "/%lu", (unsigned long) DUK_HEAPHDR_GET_REFCOUNT(&h->hdr)); +#endif +} + +#ifdef DUK__COMMA +#undef DUK__COMMA +#endif +#define DUK__COMMA() do { \ + if (first) { \ + first = 0; \ + } else { \ + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_COMMA); \ + } \ + } while (0) + +DUK_LOCAL void duk__print_hobject(duk__dprint_state *st, duk_hobject *h) { + duk_fixedbuffer *fb = st->fb; + duk_uint_fast32_t i; + duk_tval *tv; + duk_hstring *key; + duk_bool_t first = 1; + const char *brace1 = "{"; + const char *brace2 = "}"; + duk_bool_t pushed_loopstack = 0; + + if (duk_fb_is_full(fb)) { + return; + } + + duk__print_shared_heaphdr(st, &h->hdr); + + if (h && DUK_HOBJECT_HAS_ARRAY_PART(h)) { + brace1 = "["; + brace2 = "]"; + } + + if (!h) { + duk_fb_put_cstring(fb, "NULL"); + goto finished; + } + + if (st->depth >= st->depth_limit) { + if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) { + duk_fb_sprintf(fb, "%sobject/compiledfunction %p%s", (const char *) brace1, (void *) h, (const char *) brace2); + } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { + duk_fb_sprintf(fb, "%sobject/nativefunction %p%s", (const char *) brace1, (void *) h, (const char *) brace2); + } else if (DUK_HOBJECT_IS_THREAD(h)) { + duk_fb_sprintf(fb, "%sobject/thread %p%s", (const char *) brace1, (void *) h, (const char *) brace2); + } else { + duk_fb_sprintf(fb, "%sobject %p%s", (const char *) brace1, (void *) h, (const char *) brace2); /* may be NULL */ + } + return; + } + + for (i = 0; i < (duk_uint_fast32_t) st->loop_stack_index; i++) { + if (st->loop_stack[i] == h) { + duk_fb_sprintf(fb, "%sLOOP:%p%s", (const char *) brace1, (void *) h, (const char *) brace2); + return; + } + } + + /* after this, return paths should 'goto finished' for decrement */ + st->depth++; + + if (st->loop_stack_index >= st->loop_stack_limit) { + duk_fb_sprintf(fb, "%sOUT-OF-LOOP-STACK%s", (const char *) brace1, (const char *) brace2); + goto finished; + } + st->loop_stack[st->loop_stack_index++] = h; + pushed_loopstack = 1; + + /* + * Notation: double underscore used for internal properties which are not + * stored in the property allocation (e.g. '__valstack'). + */ + + duk_fb_put_cstring(fb, brace1); + + if (DUK_HOBJECT_GET_PROPS(NULL, h)) { + duk_uint32_t a_limit; + + a_limit = DUK_HOBJECT_GET_ASIZE(h); + if (st->internal) { + /* dump all allocated entries, unused entries print as 'unused', + * note that these may extend beyond current 'length' and look + * a bit funny. + */ + } else { + /* leave out trailing 'unused' elements */ + while (a_limit > 0) { + tv = DUK_HOBJECT_A_GET_VALUE_PTR(NULL, h, a_limit - 1); + if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + break; + } + a_limit--; + } + } + + for (i = 0; i < a_limit; i++) { + tv = DUK_HOBJECT_A_GET_VALUE_PTR(NULL, h, i); + DUK__COMMA(); + duk__print_tval(st, tv); + } + for (i = 0; i < DUK_HOBJECT_GET_ENEXT(h); i++) { + key = DUK_HOBJECT_E_GET_KEY(NULL, h, i); + if (!key) { + continue; + } + if (!st->internal && + DUK_HSTRING_GET_BYTELEN(key) > 0 && + DUK_HSTRING_GET_DATA(key)[0] == 0xff) { + /* XXX: use DUK_HSTRING_FLAG_INTERNAL? */ + continue; + } + DUK__COMMA(); + duk__print_hstring(st, key, 0); + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_COLON); + if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(NULL, h, i)) { + duk_fb_sprintf(fb, "[get:%p,set:%p]", + (void *) DUK_HOBJECT_E_GET_VALUE(NULL, h, i).a.get, + (void *) DUK_HOBJECT_E_GET_VALUE(NULL, h, i).a.set); + } else { + tv = &DUK_HOBJECT_E_GET_VALUE(NULL, h, i).v; + duk__print_tval(st, tv); + } + if (st->heavy) { + duk_fb_sprintf(fb, "<%02lx>", (unsigned long) DUK_HOBJECT_E_GET_FLAGS(NULL, h, i)); + } + } + } + if (st->internal) { + if (DUK_HOBJECT_HAS_EXTENSIBLE(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__extensible:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_CONSTRUCTABLE(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__constructable:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_BOUND(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__bound:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_COMPILEDFUNCTION(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__compiledfunction:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_NATIVEFUNCTION(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__nativefunction:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_THREAD(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__thread:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_ARRAY_PART(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__array_part:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_STRICT(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__strict:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_NEWENV(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__newenv:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_NAMEBINDING(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__namebinding:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_CREATEARGS(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__createargs:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_ENVRECCLOSED(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__envrecclosed:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__special_array:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__special_stringobj:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__special_arguments:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__special_dukfunc:true"); + } else { + ; + } + if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__special_bufferobj:true"); + } else { + ; + } + if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h)) { + DUK__COMMA(); duk_fb_sprintf(fb, "__special_proxyobj:true"); + } else { + ; + } + } + if (st->internal && DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) { + duk_hcompiledfunction *f = (duk_hcompiledfunction *) h; + DUK__COMMA(); duk_fb_put_cstring(fb, "__data:"); + duk__print_hbuffer(st, (duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA(NULL, f)); + DUK__COMMA(); duk_fb_sprintf(fb, "__nregs:%ld", (long) f->nregs); + DUK__COMMA(); duk_fb_sprintf(fb, "__nargs:%ld", (long) f->nargs); +#if defined(DUK_USE_DEBUGGER_SUPPORT) + DUK__COMMA(); duk_fb_sprintf(fb, "__start_line:%ld", (long) f->start_line); + DUK__COMMA(); duk_fb_sprintf(fb, "__end_line:%ld", (long) f->end_line); +#endif + DUK__COMMA(); duk_fb_put_cstring(fb, "__data:"); + duk__print_hbuffer(st, (duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA(NULL, f)); + } else if (st->internal && DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { + duk_hnativefunction *f = (duk_hnativefunction *) h; + DUK__COMMA(); duk_fb_sprintf(fb, "__func:"); + duk_fb_put_funcptr(fb, (duk_uint8_t *) &f->func, sizeof(f->func)); + DUK__COMMA(); duk_fb_sprintf(fb, "__nargs:%ld", (long) f->nargs); + } else if (st->internal && DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + duk_hbufferobject *b = (duk_hbufferobject *) h; + DUK__COMMA(); duk_fb_sprintf(fb, "__buf:"); + duk__print_hbuffer(st, (duk_hbuffer *) b->buf); + DUK__COMMA(); duk_fb_sprintf(fb, "__offset:%ld", (long) b->offset); + DUK__COMMA(); duk_fb_sprintf(fb, "__length:%ld", (long) b->length); + DUK__COMMA(); duk_fb_sprintf(fb, "__shift:%ld", (long) b->shift); + DUK__COMMA(); duk_fb_sprintf(fb, "__elemtype:%ld", (long) b->elem_type); + } else if (st->internal && DUK_HOBJECT_IS_THREAD(h)) { + duk_hthread *t = (duk_hthread *) h; + DUK__COMMA(); duk_fb_sprintf(fb, "__strict:%ld", (long) t->strict); + DUK__COMMA(); duk_fb_sprintf(fb, "__state:%ld", (long) t->state); + DUK__COMMA(); duk_fb_sprintf(fb, "__unused1:%ld", (long) t->unused1); + DUK__COMMA(); duk_fb_sprintf(fb, "__unused2:%ld", (long) t->unused2); + DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_max:%ld", (long) t->valstack_max); + DUK__COMMA(); duk_fb_sprintf(fb, "__callstack_max:%ld", (long) t->callstack_max); + DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack_max:%ld", (long) t->catchstack_max); + DUK__COMMA(); duk_fb_sprintf(fb, "__valstack:%p", (void *) t->valstack); + DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_end:%p/%ld", (void *) t->valstack_end, (long) (t->valstack_end - t->valstack)); + DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_bottom:%p/%ld", (void *) t->valstack_bottom, (long) (t->valstack_bottom - t->valstack)); + DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_top:%p/%ld", (void *) t->valstack_top, (long) (t->valstack_top - t->valstack)); + DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack:%p", (void *) t->catchstack); + DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack_size:%ld", (long) t->catchstack_size); + DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack_top:%ld", (long) t->catchstack_top); + DUK__COMMA(); duk_fb_sprintf(fb, "__resumer:"); duk__print_hobject(st, (duk_hobject *) t->resumer); + /* XXX: print built-ins array? */ + + } +#ifdef DUK_USE_REFERENCE_COUNTING + if (st->internal) { + DUK__COMMA(); duk_fb_sprintf(fb, "__refcount:%lu", (unsigned long) DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h)); + } +#endif + if (st->internal) { + DUK__COMMA(); duk_fb_sprintf(fb, "__class:%ld", (long) DUK_HOBJECT_GET_CLASS_NUMBER(h)); + } + + /* prototype should be last, for readability */ + if (st->follow_proto && DUK_HOBJECT_GET_PROTOTYPE(NULL, h)) { + DUK__COMMA(); duk_fb_put_cstring(fb, "__prototype:"); duk__print_hobject(st, DUK_HOBJECT_GET_PROTOTYPE(NULL, h)); + } + + duk_fb_put_cstring(fb, brace2); + +#if defined(DUK_USE_HOBJECT_HASH_PART) + if (st->heavy && DUK_HOBJECT_GET_HSIZE(h) > 0) { + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LANGLE); + for (i = 0; i < DUK_HOBJECT_GET_HSIZE(h); i++) { + duk_uint_t h_idx = DUK_HOBJECT_H_GET_INDEX(NULL, h, i); + if (i > 0) { + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_COMMA); + } + if (h_idx == DUK_HOBJECT_HASHIDX_UNUSED) { + duk_fb_sprintf(fb, "u"); + } else if (h_idx == DUK_HOBJECT_HASHIDX_DELETED) { + duk_fb_sprintf(fb, "d"); + } else { + duk_fb_sprintf(fb, "%ld", (long) h_idx); + } + } + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RANGLE); + } +#endif + + finished: + st->depth--; + if (pushed_loopstack) { + st->loop_stack_index--; + st->loop_stack[st->loop_stack_index] = NULL; + } +} + +#undef DUK__COMMA + +DUK_LOCAL void duk__print_hbuffer(duk__dprint_state *st, duk_hbuffer *h) { + duk_fixedbuffer *fb = st->fb; + duk_size_t i, n; + duk_uint8_t *p; + + if (duk_fb_is_full(fb)) { + return; + } + + /* terminal type: no depth check */ + + if (!h) { + duk_fb_put_cstring(fb, "NULL"); + return; + } + + if (DUK_HBUFFER_HAS_DYNAMIC(h)) { + if (DUK_HBUFFER_HAS_EXTERNAL(h)) { + duk_hbuffer_external *g = (duk_hbuffer_external *) h; + duk_fb_sprintf(fb, "buffer:external:%p:%ld", + (void *) DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(NULL, g), + (long) DUK_HBUFFER_EXTERNAL_GET_SIZE(g)); + } else { + duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h; + duk_fb_sprintf(fb, "buffer:dynamic:%p:%ld", + (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(NULL, g), + (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(g)); + } + } else { + duk_fb_sprintf(fb, "buffer:fixed:%ld", (long) DUK_HBUFFER_GET_SIZE(h)); + } + +#ifdef DUK_USE_REFERENCE_COUNTING + duk_fb_sprintf(fb, "/%lu", (unsigned long) DUK_HEAPHDR_GET_REFCOUNT(&h->hdr)); +#endif + + if (st->hexdump) { + duk_fb_sprintf(fb, "=["); + n = DUK_HBUFFER_GET_SIZE(h); + p = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(NULL, h); + for (i = 0; i < n; i++) { + duk_fb_sprintf(fb, "%02lx", (unsigned long) p[i]); + } + duk_fb_sprintf(fb, "]"); + } +} + +DUK_LOCAL void duk__print_heaphdr(duk__dprint_state *st, duk_heaphdr *h) { + duk_fixedbuffer *fb = st->fb; + + if (duk_fb_is_full(fb)) { + return; + } + + if (!h) { + duk_fb_put_cstring(fb, "NULL"); + return; + } + + switch (DUK_HEAPHDR_GET_TYPE(h)) { + case DUK_HTYPE_STRING: + duk__print_hstring(st, (duk_hstring *) h, 1); + break; + case DUK_HTYPE_OBJECT: + duk__print_hobject(st, (duk_hobject *) h); + break; + case DUK_HTYPE_BUFFER: + duk__print_hbuffer(st, (duk_hbuffer *) h); + break; + default: + duk_fb_sprintf(fb, "[unknown htype %ld]", (long) DUK_HEAPHDR_GET_TYPE(h)); + break; + } +} + +DUK_LOCAL void duk__print_tval(duk__dprint_state *st, duk_tval *tv) { + duk_fixedbuffer *fb = st->fb; + + if (duk_fb_is_full(fb)) { + return; + } + + /* depth check is done when printing an actual type */ + + if (st->heavy) { + duk_fb_sprintf(fb, "(%p)", (void *) tv); + } + + if (!tv) { + duk_fb_put_cstring(fb, "NULL"); + return; + } + + if (st->binary) { + duk_size_t i; + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LBRACKET); + for (i = 0; i < (duk_size_t) sizeof(*tv); i++) { + duk_fb_sprintf(fb, "%02lx", (unsigned long) ((duk_uint8_t *)tv)[i]); + } + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RBRACKET); + } + + if (st->heavy) { + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LANGLE); + } + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: { + if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + duk_fb_put_cstring(fb, "unused"); + } else { + duk_fb_put_cstring(fb, "undefined"); + } + break; + } + case DUK_TAG_NULL: { + duk_fb_put_cstring(fb, "null"); + break; + } + case DUK_TAG_BOOLEAN: { + duk_fb_put_cstring(fb, DUK_TVAL_GET_BOOLEAN(tv) ? "true" : "false"); + break; + } + case DUK_TAG_STRING: { + /* Note: string is a terminal heap object, so no depth check here */ + duk__print_hstring(st, DUK_TVAL_GET_STRING(tv), 1); + break; + } + case DUK_TAG_OBJECT: { + duk__print_hobject(st, DUK_TVAL_GET_OBJECT(tv)); + break; + } + case DUK_TAG_BUFFER: { + duk__print_hbuffer(st, DUK_TVAL_GET_BUFFER(tv)); + break; + } + case DUK_TAG_POINTER: { + duk_fb_sprintf(fb, "pointer:%p", (void *) DUK_TVAL_GET_POINTER(tv)); + break; + } + case DUK_TAG_LIGHTFUNC: { + duk_c_function func; + duk_small_uint_t lf_flags; + + DUK_TVAL_GET_LIGHTFUNC(tv, func, lf_flags); + duk_fb_sprintf(fb, "lightfunc:"); + duk_fb_put_funcptr(fb, (duk_uint8_t *) &func, sizeof(func)); + duk_fb_sprintf(fb, ":%04lx", (long) lf_flags); + break; + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: { + /* IEEE double is approximately 16 decimal digits; print a couple extra */ + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + duk_fb_sprintf(fb, "%.18g", (double) DUK_TVAL_GET_NUMBER(tv)); + break; + } + } + if (st->heavy) { + duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RANGLE); + } +} + +DUK_LOCAL void duk__print_instr(duk__dprint_state *st, duk_instr_t ins) { + duk_fixedbuffer *fb = st->fb; + duk_small_int_t op; + const char *op_name; + const char *extraop_name; + + op = (duk_small_int_t) DUK_DEC_OP(ins); + op_name = duk__bc_optab[op]; + + /* XXX: option to fix opcode length so it lines up nicely */ + + if (op == DUK_OP_EXTRA) { + extraop_name = duk__bc_extraoptab[DUK_DEC_A(ins)]; + + duk_fb_sprintf(fb, "%s %ld, %ld", + (const char *) extraop_name, (long) DUK_DEC_B(ins), (long) DUK_DEC_C(ins)); + } else if (op == DUK_OP_JUMP) { + duk_int_t diff1 = DUK_DEC_ABC(ins) - DUK_BC_JUMP_BIAS; /* from next pc */ + duk_int_t diff2 = diff1 + 1; /* from curr pc */ + + duk_fb_sprintf(fb, "%s %ld (to pc%c%ld)", + (const char *) op_name, (long) diff1, + (int) (diff2 >= 0 ? '+' : '-'), /* char format: use int */ + (long) (diff2 >= 0 ? diff2 : -diff2)); + } else { + duk_fb_sprintf(fb, "%s %ld, %ld, %ld", + (const char *) op_name, (long) DUK_DEC_A(ins), + (long) DUK_DEC_B(ins), (long) DUK_DEC_C(ins)); + } +} + +DUK_LOCAL void duk__print_opcode(duk__dprint_state *st, duk_small_int_t opcode) { + duk_fixedbuffer *fb = st->fb; + + if (opcode < DUK_BC_OP_MIN || opcode > DUK_BC_OP_MAX) { + duk_fb_sprintf(fb, "?(%ld)", (long) opcode); + } else { + duk_fb_sprintf(fb, "%s", (const char *) duk__bc_optab[opcode]); + } +} + +DUK_INTERNAL duk_int_t duk_debug_vsnprintf(char *str, duk_size_t size, const char *format, va_list ap) { + duk_fixedbuffer fb; + const char *p = format; + const char *p_end = p + DUK_STRLEN(format); + duk_int_t retval; + + DUK_MEMZERO(&fb, sizeof(fb)); + fb.buffer = (duk_uint8_t *) str; + fb.length = size; + fb.offset = 0; + fb.truncated = 0; + + while (p < p_end) { + char ch = *p++; + const char *p_begfmt = NULL; + duk_bool_t got_exclamation = 0; + duk_bool_t got_long = 0; /* %lf, %ld etc */ + duk__dprint_state st; + + if (ch != DUK_ASC_PERCENT) { + duk_fb_put_byte(&fb, (duk_uint8_t) ch); + continue; + } + + /* + * Format tag parsing. Since we don't understand all the + * possible format tags allowed, we just scan for a terminating + * specifier and keep track of relevant modifiers that we do + * understand. See man 3 printf. + */ + + DUK_MEMZERO(&st, sizeof(st)); + st.fb = &fb; + st.depth = 0; + st.depth_limit = 1; + st.loop_stack_index = 0; + st.loop_stack_limit = DUK__LOOP_STACK_DEPTH; + + p_begfmt = p - 1; + while (p < p_end) { + ch = *p++; + + if (ch == DUK_ASC_STAR) { + /* unsupported: would consume multiple args */ + goto error; + } else if (ch == DUK_ASC_PERCENT) { + duk_fb_put_byte(&fb, (duk_uint8_t) DUK_ASC_PERCENT); + break; + } else if (ch == DUK_ASC_EXCLAMATION) { + got_exclamation = 1; + } else if (!got_exclamation && ch == DUK_ASC_LC_L) { + got_long = 1; + } else if (got_exclamation && ch == DUK_ASC_LC_D) { + st.depth_limit = DUK__DEEP_DEPTH_LIMIT; + } else if (got_exclamation && ch == DUK_ASC_LC_P) { + st.follow_proto = 1; + } else if (got_exclamation && ch == DUK_ASC_LC_I) { + st.internal = 1; + } else if (got_exclamation && ch == DUK_ASC_LC_X) { + st.hexdump = 1; + } else if (got_exclamation && ch == DUK_ASC_LC_H) { + st.heavy = 1; + } else if (got_exclamation && ch == DUK_ASC_ATSIGN) { + st.pointer = 1; + } else if (got_exclamation && ch == DUK_ASC_HASH) { + st.binary = 1; + } else if (got_exclamation && ch == DUK_ASC_UC_T) { + duk_tval *t = va_arg(ap, duk_tval *); + if (st.pointer && !st.heavy) { + duk_fb_sprintf(&fb, "(%p)", (void *) t); + } + duk__print_tval(&st, t); + break; + } else if (got_exclamation && ch == DUK_ASC_UC_O) { + duk_heaphdr *t = va_arg(ap, duk_heaphdr *); + if (st.pointer && !st.heavy) { + duk_fb_sprintf(&fb, "(%p)", (void *) t); + } + duk__print_heaphdr(&st, t); + break; + } else if (got_exclamation && ch == DUK_ASC_UC_I) { + duk_instr_t t = va_arg(ap, duk_instr_t); + duk__print_instr(&st, t); + break; + } else if (got_exclamation && ch == DUK_ASC_UC_C) { + long t = va_arg(ap, long); + duk__print_opcode(&st, (duk_small_int_t) t); + break; + } else if (!got_exclamation && strchr(DUK__ALLOWED_STANDARD_SPECIFIERS, (int) ch)) { + char fmtbuf[DUK__MAX_FORMAT_TAG_LENGTH]; + duk_size_t fmtlen; + + DUK_ASSERT(p >= p_begfmt); + fmtlen = (duk_size_t) (p - p_begfmt); + if (fmtlen >= sizeof(fmtbuf)) { + /* format is too large, abort */ + goto error; + } + DUK_MEMZERO(fmtbuf, sizeof(fmtbuf)); + DUK_MEMCPY(fmtbuf, p_begfmt, fmtlen); + + /* assume exactly 1 arg, which is why '*' is forbidden; arg size still + * depends on type though. + */ + + if (ch == DUK_ASC_LC_F || ch == DUK_ASC_LC_G || ch == DUK_ASC_LC_E) { + /* %f and %lf both consume a 'long' */ + double arg = va_arg(ap, double); + duk_fb_sprintf(&fb, fmtbuf, arg); + } else if (ch == DUK_ASC_LC_D && got_long) { + /* %ld */ + long arg = va_arg(ap, long); + duk_fb_sprintf(&fb, fmtbuf, arg); + } else if (ch == DUK_ASC_LC_D) { + /* %d; only 16 bits are guaranteed */ + int arg = va_arg(ap, int); + duk_fb_sprintf(&fb, fmtbuf, arg); + } else if (ch == DUK_ASC_LC_U && got_long) { + /* %lu */ + unsigned long arg = va_arg(ap, unsigned long); + duk_fb_sprintf(&fb, fmtbuf, arg); + } else if (ch == DUK_ASC_LC_U) { + /* %u; only 16 bits are guaranteed */ + unsigned int arg = va_arg(ap, unsigned int); + duk_fb_sprintf(&fb, fmtbuf, arg); + } else if (ch == DUK_ASC_LC_X && got_long) { + /* %lx */ + unsigned long arg = va_arg(ap, unsigned long); + duk_fb_sprintf(&fb, fmtbuf, arg); + } else if (ch == DUK_ASC_LC_X) { + /* %x; only 16 bits are guaranteed */ + unsigned int arg = va_arg(ap, unsigned int); + duk_fb_sprintf(&fb, fmtbuf, arg); + } else if (ch == DUK_ASC_LC_S) { + /* %s */ + const char *arg = va_arg(ap, const char *); + if (arg == NULL) { + /* '%s' and NULL is not portable, so special case + * it for debug printing. + */ + duk_fb_sprintf(&fb, "NULL"); + } else { + duk_fb_sprintf(&fb, fmtbuf, arg); + } + } else if (ch == DUK_ASC_LC_P) { + /* %p */ + void *arg = va_arg(ap, void *); + if (arg == NULL) { + /* '%p' and NULL is portable, but special case it + * anyway to get a standard NULL marker in logs. + */ + duk_fb_sprintf(&fb, "NULL"); + } else { + duk_fb_sprintf(&fb, fmtbuf, arg); + } + } else if (ch == DUK_ASC_LC_C) { + /* '%c', passed concretely as int */ + int arg = va_arg(ap, int); + duk_fb_sprintf(&fb, fmtbuf, arg); + } else { + /* Should not happen. */ + duk_fb_sprintf(&fb, "INVALID-FORMAT(%s)", (const char *) fmtbuf); + } + break; + } else { + /* ignore */ + } + } + } + goto done; + + error: + duk_fb_put_cstring(&fb, "FMTERR"); + /* fall through */ + + done: + retval = (duk_int_t) fb.offset; + duk_fb_put_byte(&fb, (duk_uint8_t) 0); + + /* return total chars written excluding terminator */ + return retval; +} + +#if 0 /*unused*/ +DUK_INTERNAL duk_int_t duk_debug_snprintf(char *str, duk_size_t size, const char *format, ...) { + duk_int_t retval; + va_list ap; + va_start(ap, format); + retval = duk_debug_vsnprintf(str, size, format, ap); + va_end(ap); + return retval; +} +#endif + +/* Formatting function pointers is tricky: there is no standard pointer for + * function pointers and the size of a function pointer may depend on the + * specific pointer type. This helper formats a function pointer based on + * its memory layout to get something useful on most platforms. + */ +DUK_INTERNAL void duk_debug_format_funcptr(char *buf, duk_size_t buf_size, duk_uint8_t *fptr, duk_size_t fptr_size) { + duk_size_t i; + duk_uint8_t *p = (duk_uint8_t *) buf; + duk_uint8_t *p_end = (duk_uint8_t *) (buf + buf_size - 1); + + DUK_MEMZERO(buf, buf_size); + + for (i = 0; i < fptr_size; i++) { + duk_int_t left = (duk_int_t) (p_end - p); + duk_uint8_t ch; + if (left <= 0) { + break; + } + + /* Quite approximate but should be useful for little and big endian. */ +#ifdef DUK_USE_INTEGER_BE + ch = fptr[i]; +#else + ch = fptr[fptr_size - 1 - i]; +#endif + p += DUK_SNPRINTF((char *) p, left, "%02lx", (unsigned long) ch); + } +} + +#endif /* DUK_USE_DEBUG */ +#line 1 "duk_debugger.c" +/* + * Duktape debugger + */ + +/* include removed: duk_internal.h */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) + +/* + * Helper structs + */ + +typedef union { + void *p; + duk_uint_t b[1]; + /* Use b[] to access the size of the union, which is strictly not + * correct. Can't use fixed size unless there's feature detection + * for pointer byte size. + */ +} duk__ptr_union; + +/* + * Detach handling + */ + +#define DUK__SET_CONN_BROKEN(thr) do { \ + /* For now shared handler is fine. */ \ + duk_debug_do_detach((thr)->heap); \ + } while (0) + +DUK_INTERNAL void duk_debug_do_detach(duk_heap *heap) { + /* Can be called muliple times with no harm. */ + + heap->dbg_read_cb = NULL; + heap->dbg_write_cb = NULL; + heap->dbg_peek_cb = NULL; + heap->dbg_read_flush_cb = NULL; + heap->dbg_write_flush_cb = NULL; + if (heap->dbg_detached_cb) { + heap->dbg_detached_cb(heap->dbg_udata); + } + heap->dbg_detached_cb = NULL; + heap->dbg_udata = NULL; + heap->dbg_processing = 0; + heap->dbg_paused = 0; + heap->dbg_state_dirty = 0; + heap->dbg_force_restart = 0; + heap->dbg_step_type = 0; + heap->dbg_step_thread = NULL; + heap->dbg_step_csindex = 0; + heap->dbg_step_startline = 0; + + /* Ensure there are no stale active breakpoint pointers. + * Breakpoint list is currently kept - we could empty it + * here but we'd need to handle refcounts correctly, and + * we'd need a 'thr' reference for that. + * + * XXX: clear breakpoint on either attach or detach? + */ + heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL; +} + +/* + * Debug connection peek and flush primitives + */ + +DUK_INTERNAL duk_bool_t duk_debug_read_peek(duk_hthread *thr) { + duk_heap *heap; + + DUK_ASSERT(thr != NULL); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + + if (heap->dbg_read_cb == NULL) { + DUK_D(DUK_DPRINT("attempt to peek in detached state, return zero (= no data)")); + return 0; + } + if (heap->dbg_peek_cb == NULL) { + DUK_DD(DUK_DDPRINT("no peek callback, return zero (= no data)")); + return 0; + } + + return (duk_bool_t) (heap->dbg_peek_cb(heap->dbg_udata) > 0); +} + +DUK_INTERNAL void duk_debug_read_flush(duk_hthread *thr) { + duk_heap *heap; + + DUK_ASSERT(thr != NULL); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + + if (heap->dbg_read_cb == NULL) { + DUK_D(DUK_DPRINT("attempt to read flush in detached state, ignore")); + return; + } + if (heap->dbg_read_flush_cb == NULL) { + DUK_DD(DUK_DDPRINT("no read flush callback, ignore")); + return; + } + + heap->dbg_read_flush_cb(heap->dbg_udata); +} + +DUK_INTERNAL void duk_debug_write_flush(duk_hthread *thr) { + duk_heap *heap; + + DUK_ASSERT(thr != NULL); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + + if (heap->dbg_read_cb == NULL) { + DUK_D(DUK_DPRINT("attempt to write flush in detached state, ignore")); + return; + } + if (heap->dbg_write_flush_cb == NULL) { + DUK_DD(DUK_DDPRINT("no write flush callback, ignore")); + return; + } + + heap->dbg_write_flush_cb(heap->dbg_udata); +} + +/* + * Debug connection skip primitives + */ + +/* Skip fully. */ +DUK_INTERNAL void duk_debug_skip_bytes(duk_hthread *thr, duk_size_t length) { + duk_uint8_t dummy[64]; + duk_size_t now; + + DUK_ASSERT(thr != NULL); + + while (length > 0) { + now = (length > sizeof(dummy) ? sizeof(dummy) : length); + duk_debug_read_bytes(thr, dummy, now); + length -= now; + } +} + +DUK_INTERNAL void duk_debug_skip_byte(duk_hthread *thr) { + DUK_ASSERT(thr != NULL); + + (void) duk_debug_read_byte(thr); +} + +/* + * Debug connection read primitives + */ + +/* Read fully. */ +DUK_INTERNAL void duk_debug_read_bytes(duk_hthread *thr, duk_uint8_t *data, duk_size_t length) { + duk_heap *heap; + duk_uint8_t *p; + duk_size_t left; + duk_size_t got; + + DUK_ASSERT(thr != NULL); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + + if (heap->dbg_read_cb == NULL) { + DUK_D(DUK_DPRINT("attempt to read %ld bytes in detached state, return zero data", (long) length)); + goto fail; + } + + p = data; + for (;;) { + left = (duk_size_t) ((data + length) - p); + if (left == 0) { + break; + } + DUK_ASSERT(heap->dbg_read_cb != NULL); + DUK_ASSERT(left >= 1); +#if defined(DUK_USE_DEBUGGER_TRANSPORT_TORTURE) + left = 1; +#endif + got = heap->dbg_read_cb(heap->dbg_udata, (char *) p, left); + if (got == 0 || got > left) { + DUK_D(DUK_DPRINT("connection error during read, return zero data")); + DUK__SET_CONN_BROKEN(thr); + goto fail; + } + p += got; + } + return; + + fail: + DUK_MEMZERO((void *) data, (size_t) length); +} + +DUK_INTERNAL duk_uint8_t duk_debug_read_byte(duk_hthread *thr) { + duk_heap *heap; + duk_size_t got; + duk_uint8_t x; + + DUK_ASSERT(thr != NULL); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + + if (heap->dbg_read_cb == NULL) { + DUK_D(DUK_DPRINT("attempt to read 1 bytes in detached state, return zero data")); + return 0; + } + + x = 0; /* just in case callback is broken and won't write 'x' */ + DUK_ASSERT(heap->dbg_read_cb != NULL); + got = heap->dbg_read_cb(heap->dbg_udata, (char *) (&x), 1); + if (got != 1) { + DUK_D(DUK_DPRINT("connection error during read, return zero data")); + DUK__SET_CONN_BROKEN(thr); + return 0; + } + + return x; +} + +DUK_LOCAL duk_uint32_t duk__debug_read_uint32_raw(duk_hthread *thr) { + duk_uint8_t buf[4]; + + DUK_ASSERT(thr != NULL); + + duk_debug_read_bytes(thr, buf, 4); + return ((duk_uint32_t) buf[0] << 24) | + ((duk_uint32_t) buf[1] << 16) | + ((duk_uint32_t) buf[2] << 8) | + (duk_uint32_t) buf[3]; +} + +DUK_LOCAL duk_uint32_t duk__debug_read_int32_raw(duk_hthread *thr) { + return (duk_int32_t) duk__debug_read_uint32_raw(thr); +} + +DUK_LOCAL duk_uint16_t duk__debug_read_uint16_raw(duk_hthread *thr) { + duk_uint8_t buf[2]; + + DUK_ASSERT(thr != NULL); + + duk_debug_read_bytes(thr, buf, 2); + return ((duk_uint16_t) buf[0] << 8) | + (duk_uint16_t) buf[1]; +} + +DUK_INTERNAL duk_int32_t duk_debug_read_int(duk_hthread *thr) { + duk_small_uint_t x; + duk_small_uint_t t; + + DUK_ASSERT(thr != NULL); + + x = duk_debug_read_byte(thr); + if (x >= 0xc0) { + t = duk_debug_read_byte(thr); + return (duk_int32_t) (((x - 0xc0) << 8) + t); + } else if (x >= 0x80) { + return (duk_int32_t) (x - 0x80); + } else if (x == 0x10) { + return (duk_int32_t) duk__debug_read_uint32_raw(thr); + } + + DUK_D(DUK_DPRINT("debug connection error: failed to decode int")); + DUK__SET_CONN_BROKEN(thr); + return 0; +} + +DUK_LOCAL duk_hstring *duk__debug_read_hstring_raw(duk_hthread *thr, duk_uint32_t len) { + duk_context *ctx = (duk_context *) thr; + duk_uint8_t buf[31]; + duk_uint8_t *p; + + if (len <= sizeof(buf)) { + duk_debug_read_bytes(thr, buf, (duk_size_t) len); + duk_push_lstring(ctx, (const char *) buf, (duk_size_t) len); + } else { + p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len); + DUK_ASSERT(p != NULL); + duk_debug_read_bytes(thr, p, (duk_size_t) len); + duk_to_string(ctx, -1); + } + + return duk_require_hstring(ctx, -1); +} + +DUK_INTERNAL duk_hstring *duk_debug_read_hstring(duk_hthread *thr) { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_t x; + duk_uint32_t len; + + DUK_ASSERT(thr != NULL); + + x = duk_debug_read_byte(thr); + if (x >= 0x60 && x <= 0x7f) { + /* For short strings, use a fixed temp buffer. */ + len = (duk_uint32_t) (x - 0x60); + } else if (x == 0x12) { + len = (duk_uint32_t) duk__debug_read_uint16_raw(thr); + } else if (x == 0x11) { + len = (duk_uint32_t) duk__debug_read_uint32_raw(thr); + } else { + goto fail; + } + + return duk__debug_read_hstring_raw(thr, len); + + fail: + DUK_D(DUK_DPRINT("debug connection error: failed to decode int")); + DUK__SET_CONN_BROKEN(thr); + duk_push_hstring_stridx(thr, DUK_STRIDX_EMPTY_STRING); /* always push some string */ + return duk_require_hstring(ctx, -1); +} + +DUK_LOCAL duk_hbuffer *duk__debug_read_hbuffer_raw(duk_hthread *thr, duk_uint32_t len) { + duk_context *ctx = (duk_context *) thr; + duk_uint8_t *p; + + p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len); + DUK_ASSERT(p != NULL); + duk_debug_read_bytes(thr, p, (duk_size_t) len); + + return duk_require_hbuffer(ctx, -1); +} + +DUK_LOCAL const void *duk__debug_read_pointer_raw(duk_hthread *thr) { + duk_small_uint_t x; + volatile duk__ptr_union pu; + + DUK_ASSERT(thr != NULL); + + x = duk_debug_read_byte(thr); + if (x != sizeof(pu)) { + goto fail; + } + duk_debug_read_bytes(thr, (duk_uint8_t *) &pu.p, sizeof(pu)); +#if defined(DUK_USE_INTEGER_LE) + duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu)); +#endif + return (const void *) pu.p; + + fail: + DUK_D(DUK_DPRINT("debug connection error: failed to decode pointer")); + DUK__SET_CONN_BROKEN(thr); + return (const void *) NULL; +} + +DUK_LOCAL duk_double_t duk__debug_read_double_raw(duk_hthread *thr) { + duk_double_union du; + + DUK_ASSERT(sizeof(du.uc) == 8); + duk_debug_read_bytes(thr, (duk_uint8_t *) du.uc, sizeof(du.uc)); + DUK_DBLUNION_DOUBLE_NTOH(&du); + return du.d; +} + +DUK_INTERNAL void duk_debug_read_tval(duk_hthread *thr) { + duk_context *ctx = (duk_context *) thr; + duk_uint8_t x; + duk_uint_t t; + duk_uint32_t len; + + DUK_ASSERT(thr != NULL); + + x = duk_debug_read_byte(thr); + + if (x >= 0xc0) { + t = (duk_uint_t) (x - 0xc0); + t = (t << 8) + duk_debug_read_byte(thr); + duk_push_uint(ctx, (duk_uint_t) t); + return; + } + if (x >= 0x80) { + duk_push_uint(ctx, (duk_uint_t) (x - 0x80)); + return; + } + if (x >= 0x60) { + len = (duk_uint32_t) (x - 0x60); + duk__debug_read_hstring_raw(thr, len); + return; + } + + switch (x) { + case 0x10: { + duk_int32_t i = duk__debug_read_int32_raw(thr); + duk_push_i32(ctx, i); + break; + } + case 0x11: + len = duk__debug_read_uint32_raw(thr); + duk__debug_read_hstring_raw(thr, len); + break; + case 0x12: + len = duk__debug_read_uint16_raw(thr); + duk__debug_read_hstring_raw(thr, len); + break; + case 0x13: + len = duk__debug_read_uint32_raw(thr); + duk__debug_read_hbuffer_raw(thr, len); + break; + case 0x14: + len = duk__debug_read_uint16_raw(thr); + duk__debug_read_hbuffer_raw(thr, len); + break; + case 0x15: + duk_push_unused(ctx); + break; + case 0x16: + duk_push_undefined(ctx); + break; + case 0x17: + duk_push_null(ctx); + break; + case 0x18: + duk_push_true(ctx); + break; + case 0x19: + duk_push_false(ctx); + break; + case 0x1a: { + duk_double_t d; + d = duk__debug_read_double_raw(thr); + duk_push_number(ctx, d); + break; + } + case 0x1b: + /* XXX: not needed for now, so not implemented */ + DUK_D(DUK_DPRINT("reading object values unimplemented")); + goto fail; + case 0x1c: { + const void *ptr; + ptr = duk__debug_read_pointer_raw(thr); + duk_push_pointer(thr, (void *) ptr); + break; + } + case 0x1d: + /* XXX: not needed for now, so not implemented */ + DUK_D(DUK_DPRINT("reading lightfunc values unimplemented")); + goto fail; + case 0x1e: { + duk_heaphdr *h; + h = (duk_heaphdr *) duk__debug_read_pointer_raw(thr); + duk_push_heapptr(thr, (void *) h); + break; + } + default: + goto fail; + } + + return; + + fail: + DUK_D(DUK_DPRINT("debug connection error: failed to decode tval")); + DUK__SET_CONN_BROKEN(thr); +} + +/* + * Debug connection write primitives + */ + +/* Write fully. */ +DUK_INTERNAL void duk_debug_write_bytes(duk_hthread *thr, const duk_uint8_t *data, duk_size_t length) { + duk_heap *heap; + const duk_uint8_t *p; + duk_size_t left; + duk_size_t got; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(length == 0 || data != NULL); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + + if (heap->dbg_write_cb == NULL) { + DUK_D(DUK_DPRINT("attempt to write %ld bytes in detached state, ignore", (long) length)); + return; + } + if (length == 0) { + /* Avoid doing an actual write callback with length == 0, + * because that's reserved for a write flush. + */ + return; + } + DUK_ASSERT(data != NULL); + + p = data; + for (;;) { + left = (duk_size_t) ((data + length) - p); + if (left == 0) { + break; + } + DUK_ASSERT(heap->dbg_write_cb != NULL); + DUK_ASSERT(left >= 1); +#if defined(DUK_USE_DEBUGGER_TRANSPORT_TORTURE) + left = 1; +#endif + got = heap->dbg_write_cb(heap->dbg_udata, (const char *) p, left); + if (got == 0 || got > left) { + DUK_D(DUK_DPRINT("connection error during write")); + DUK__SET_CONN_BROKEN(thr); + return; + } + p += got; + } +} + +DUK_INTERNAL void duk_debug_write_byte(duk_hthread *thr, duk_uint8_t x) { + duk_heap *heap; + duk_size_t got; + + DUK_ASSERT(thr != NULL); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + + if (heap->dbg_write_cb == NULL) { + DUK_D(DUK_DPRINT("attempt to write 1 bytes in detached state, ignore")); + return; + } + + DUK_ASSERT(heap->dbg_write_cb != NULL); + got = heap->dbg_write_cb(heap->dbg_udata, (const char *) (&x), 1); + if (got != 1) { + DUK_D(DUK_DPRINT("connection error during write")); + DUK__SET_CONN_BROKEN(thr); + } +} + +DUK_INTERNAL void duk_debug_write_unused(duk_hthread *thr) { + duk_debug_write_byte(thr, 0x15); +} + +DUK_INTERNAL void duk_debug_write_undefined(duk_hthread *thr) { + duk_debug_write_byte(thr, 0x16); +} + +/* Write signed 32-bit integer. */ +DUK_INTERNAL void duk_debug_write_int(duk_hthread *thr, duk_int32_t x) { + duk_uint8_t buf[5]; + duk_size_t len; + + DUK_ASSERT(thr != NULL); + + if (x >= 0 && x <= 0x3fL) { + buf[0] = (duk_uint8_t) (0x80 + x); + len = 1; + } else if (x >= 0 && x <= 0x3fffL) { + buf[0] = (duk_uint8_t) (0xc0 + (x >> 8)); + buf[1] = (duk_uint8_t) (x & 0xff); + len = 2; + } else { + /* Signed integers always map to 4 bytes now. */ + buf[0] = (duk_uint8_t) 0x10; + buf[1] = (duk_uint8_t) ((x >> 24) & 0xff); + buf[2] = (duk_uint8_t) ((x >> 16) & 0xff); + buf[3] = (duk_uint8_t) ((x >> 8) & 0xff); + buf[4] = (duk_uint8_t) (x & 0xff); + len = 5; + } + duk_debug_write_bytes(thr, buf, len); +} + +/* Write unsigned 32-bit integer. */ +DUK_INTERNAL void duk_debug_write_uint(duk_hthread *thr, duk_uint32_t x) { + /* XXX: there's currently no need to support full 32-bit unsigned + * integer range in practice. If that becomes necessary, add a new + * dvalue type or encode as an IEEE double. + */ + duk_debug_write_int(thr, (duk_int32_t) x); +} + +DUK_INTERNAL void duk_debug_write_strbuf(duk_hthread *thr, const char *data, duk_size_t length, duk_uint8_t marker_base) { + duk_uint8_t buf[5]; + duk_size_t buflen; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(length == 0 || data != NULL); + + if (length <= 0x1fUL && marker_base == 0x11) { + /* For strings, special form for short lengths. */ + buf[0] = (duk_uint8_t) (0x60 + length); + buflen = 1; + } else if (length <= 0xffffUL) { + buf[0] = (duk_uint8_t) (marker_base + 1); + buf[1] = (duk_uint8_t) (length >> 8); + buf[2] = (duk_uint8_t) (length & 0xff); + buflen = 3; + } else { + buf[0] = (duk_uint8_t) marker_base; + buf[1] = (duk_uint8_t) (length >> 24); + buf[2] = (duk_uint8_t) ((length >> 16) & 0xff); + buf[3] = (duk_uint8_t) ((length >> 8) & 0xff); + buf[4] = (duk_uint8_t) (length & 0xff); + buflen = 5; + } + + duk_debug_write_bytes(thr, (const duk_uint8_t *) buf, buflen); + duk_debug_write_bytes(thr, (const duk_uint8_t *) data, length); +} + +DUK_INTERNAL void duk_debug_write_string(duk_hthread *thr, const char *data, duk_size_t length) { + duk_debug_write_strbuf(thr, data, length, 0x11); +} + +DUK_INTERNAL void duk_debug_write_cstring(duk_hthread *thr, const char *data) { + DUK_ASSERT(thr != NULL); + + duk_debug_write_string(thr, + data, + data ? DUK_STRLEN(data) : 0); +} + +DUK_INTERNAL void duk_debug_write_hstring(duk_hthread *thr, duk_hstring *h) { + DUK_ASSERT(thr != NULL); + + /* XXX: differentiate null pointer from empty string? */ + duk_debug_write_string(thr, + (h != NULL ? (const char *) DUK_HSTRING_GET_DATA(h) : NULL), + (h != NULL ? (duk_size_t) DUK_HSTRING_GET_BYTELEN(h) : 0)); +} + +DUK_INTERNAL void duk_debug_write_buffer(duk_hthread *thr, const char *data, duk_size_t length) { + duk_debug_write_strbuf(thr, data, length, 0x13); +} + +DUK_INTERNAL void duk_debug_write_hbuffer(duk_hthread *thr, duk_hbuffer *h) { + DUK_ASSERT(thr != NULL); + + duk_debug_write_buffer(thr, + (h != NULL ? (const char *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h) : NULL), + (h != NULL ? (duk_size_t) DUK_HBUFFER_GET_SIZE(h) : 0)); +} + +DUK_LOCAL void duk__debug_write_pointer_raw(duk_hthread *thr, const void *ptr, duk_uint8_t ibyte) { + duk_uint8_t buf[2]; + volatile duk__ptr_union pu; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(sizeof(ptr) >= 1 && sizeof(ptr) <= 16); + /* ptr may be NULL */ + + buf[0] = ibyte; + buf[1] = sizeof(pu); + duk_debug_write_bytes(thr, buf, 2); + pu.p = (void *) ptr; +#if defined(DUK_USE_INTEGER_LE) + duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu)); +#endif + duk_debug_write_bytes(thr, (const duk_uint8_t *) &pu.p, (duk_size_t) sizeof(pu)); +} + +DUK_INTERNAL void duk_debug_write_pointer(duk_hthread *thr, const void *ptr) { + duk__debug_write_pointer_raw(thr, ptr, 0x1c); +} + +#if defined(DUK_USE_DEBUGGER_DUMPHEAP) +DUK_INTERNAL void duk_debug_write_heapptr(duk_hthread *thr, duk_heaphdr *h) { + duk__debug_write_pointer_raw(thr, (const void *) h, 0x1e); +} +#endif /* DUK_USE_DEBUGGER_DUMPHEAP */ + +DUK_INTERNAL void duk_debug_write_hobject(duk_hthread *thr, duk_hobject *obj) { + duk_uint8_t buf[3]; + volatile duk__ptr_union pu; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(sizeof(obj) >= 1 && sizeof(obj) <= 16); + DUK_ASSERT(obj != NULL); + + buf[0] = 0x1b; + buf[1] = (duk_uint8_t) DUK_HOBJECT_GET_CLASS_NUMBER(obj); + buf[2] = sizeof(pu); + duk_debug_write_bytes(thr, buf, 3); + pu.p = (void *) obj; +#if defined(DUK_USE_INTEGER_LE) + duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu)); +#endif + duk_debug_write_bytes(thr, (const duk_uint8_t *) &pu.p, (duk_size_t) sizeof(pu)); +} + +DUK_INTERNAL void duk_debug_write_tval(duk_hthread *thr, duk_tval *tv) { + duk_c_function lf_func; + duk_small_uint_t lf_flags; + duk_uint8_t buf[4]; + duk_double_union du; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(tv != NULL); + + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: + duk_debug_write_byte(thr, + DUK_TVAL_IS_UNDEFINED_UNUSED(tv) ? 0x15 : 0x16); + break; + case DUK_TAG_NULL: + duk_debug_write_byte(thr, 0x17); + break; + case DUK_TAG_BOOLEAN: + DUK_ASSERT(DUK_TVAL_GET_BOOLEAN(tv) == 0 || + DUK_TVAL_GET_BOOLEAN(tv) == 1); + duk_debug_write_byte(thr, DUK_TVAL_GET_BOOLEAN(tv) ? 0x18 : 0x19); + break; + case DUK_TAG_POINTER: + duk_debug_write_pointer(thr, (const void *) DUK_TVAL_GET_POINTER(tv)); + break; + case DUK_TAG_LIGHTFUNC: + DUK_TVAL_GET_LIGHTFUNC(tv, lf_func, lf_flags); + buf[0] = 0x1d; + buf[1] = (duk_uint8_t) (lf_flags >> 8); + buf[2] = (duk_uint8_t) (lf_flags & 0xff); + buf[3] = sizeof(lf_func); + duk_debug_write_bytes(thr, buf, 4); + duk_debug_write_bytes(thr, (const duk_uint8_t *) &lf_func, sizeof(lf_func)); + break; + case DUK_TAG_STRING: + duk_debug_write_hstring(thr, DUK_TVAL_GET_STRING(tv)); + break; + case DUK_TAG_OBJECT: + duk_debug_write_hobject(thr, DUK_TVAL_GET_OBJECT(tv)); + break; + case DUK_TAG_BUFFER: + duk_debug_write_hbuffer(thr, DUK_TVAL_GET_BUFFER(tv)); + break; +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: + /* Numbers are normalized to big (network) endian. */ + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + du.d = DUK_TVAL_GET_NUMBER(tv); + DUK_DBLUNION_DOUBLE_HTON(&du); + + duk_debug_write_byte(thr, 0x1a); + duk_debug_write_bytes(thr, (const duk_uint8_t *) du.uc, sizeof(du.uc)); + } +} + +#if defined(DUK_USE_DEBUGGER_DUMPHEAP) +/* Variant for writing duk_tvals so that any heap allocated values are + * written out as tagged heap pointers. + */ +DUK_LOCAL void duk__debug_write_tval_heapptr(duk_hthread *thr, duk_tval *tv) { + if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { + duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv); + duk_debug_write_heapptr(thr, h); + } else { + duk_debug_write_tval(thr, tv); + } +} +#endif /* DUK_USE_DEBUGGER_DUMPHEAP */ + +/* + * Debug connection message write helpers + */ + +#if 0 /* unused */ +DUK_INTERNAL void duk_debug_write_request(duk_hthread *thr, duk_small_uint_t command) { + duk_debug_write_byte(thr, DUK_DBG_MARKER_REQUEST); + duk_debug_write_int(thr, command); +} +#endif + +DUK_INTERNAL void duk_debug_write_reply(duk_hthread *thr) { + duk_debug_write_byte(thr, DUK_DBG_MARKER_REPLY); +} + +DUK_INTERNAL void duk_debug_write_error_eom(duk_hthread *thr, duk_small_uint_t err_code, const char *msg) { + /* Allow NULL 'msg' */ + duk_debug_write_byte(thr, DUK_DBG_MARKER_ERROR); + duk_debug_write_int(thr, (duk_int32_t) err_code); + duk_debug_write_cstring(thr, msg); + duk_debug_write_eom(thr); +} + +DUK_INTERNAL void duk_debug_write_notify(duk_hthread *thr, duk_small_uint_t command) { + duk_debug_write_byte(thr, DUK_DBG_MARKER_NOTIFY); + duk_debug_write_int(thr, command); +} + +DUK_INTERNAL void duk_debug_write_eom(duk_hthread *thr) { + duk_debug_write_byte(thr, DUK_DBG_MARKER_EOM); + + /* As an initial implementation, write flush after every EOM (and the + * version identifier). A better implementation would flush only when + * Duktape is finished processing messages so that a flush only happens + * after all outbound messages are finished on that occasion. + */ + duk_debug_write_flush(thr); +} + +/* + * Status message and helpers + */ + +DUK_INTERNAL duk_uint_fast32_t duk_debug_curr_line(duk_hthread *thr) { + duk_context *ctx = (duk_context *) thr; + duk_activation *act; + duk_uint_fast32_t line; + duk_uint_fast32_t pc; + + if (thr->callstack_top == 0) { + return 0; + } + act = thr->callstack + thr->callstack_top - 1; + + /* We're conceptually between two opcodes; act->pc indicates the next + * instruction to be executed. This is usually the correct pc/line to + * indicate in Status. (For the 'debugger' statement this now reports + * the pc/line after the debugger statement because the debugger opcode + * has already been executed.) + */ + + pc = duk_hthread_get_act_curr_pc(thr, act); + + /* XXX: this should be optimized to be a raw query and avoid valstack + * operations if possible. + */ + duk_push_hobject(ctx, act->func); + line = duk_hobject_pc2line_query(ctx, -1, pc); + duk_pop(ctx); + return line; +} + +DUK_INTERNAL void duk_debug_send_status(duk_hthread *thr) { + duk_context *ctx = (duk_context *) thr; + duk_activation *act; + + duk_debug_write_notify(thr, DUK_DBG_CMD_STATUS); + duk_debug_write_int(thr, thr->heap->dbg_paused); + + DUK_ASSERT_DISABLE(thr->callstack_top >= 0); /* unsigned */ + if (thr->callstack_top == 0) { + duk_debug_write_undefined(thr); + duk_debug_write_undefined(thr); + duk_debug_write_int(thr, 0); + duk_debug_write_int(thr, 0); + } else { + act = thr->callstack + thr->callstack_top - 1; + duk_push_hobject(ctx, act->func); + duk_get_prop_string(ctx, -1, "fileName"); + duk_safe_to_string(ctx, -1); + duk_debug_write_hstring(thr, duk_require_hstring(ctx, -1)); + duk_get_prop_string(ctx, -2, "name"); + duk_safe_to_string(ctx, -1); + duk_debug_write_hstring(thr, duk_require_hstring(ctx, -1)); + duk_pop_3(ctx); + /* Report next pc/line to be executed. */ + duk_debug_write_uint(thr, (duk_uint32_t) duk_debug_curr_line(thr)); + duk_debug_write_uint(thr, (duk_uint32_t) duk_hthread_get_act_curr_pc(thr, act)); + } + + duk_debug_write_eom(thr); +} + +/* + * Debug message processing + */ + +/* Skip dvalue. */ +DUK_LOCAL duk_bool_t duk__debug_skip_dvalue(duk_hthread *thr) { + duk_uint8_t x; + duk_uint32_t len; + + x = duk_debug_read_byte(thr); + + if (x >= 0xc0) { + duk_debug_skip_byte(thr); + return 0; + } + if (x >= 0x80) { + return 0; + } + if (x >= 0x60) { + duk_debug_skip_bytes(thr, x - 0x60); + return 0; + } + switch(x) { + case 0x00: + return 1; /* Return 1: got EOM */ + case 0x01: + case 0x02: + case 0x03: + case 0x04: + break; + case 0x10: + (void) duk__debug_read_uint32_raw(thr); + break; + case 0x11: + case 0x13: + len = duk__debug_read_uint32_raw(thr); + duk_debug_skip_bytes(thr, len); + break; + case 0x12: + case 0x14: + len = duk__debug_read_uint16_raw(thr); + duk_debug_skip_bytes(thr, len); + break; + case 0x15: + case 0x16: + case 0x17: + case 0x18: + case 0x19: + break; + case 0x1a: + duk_debug_skip_bytes(thr, 8); + break; + case 0x1b: + duk_debug_skip_byte(thr); + len = duk_debug_read_byte(thr); + duk_debug_skip_bytes(thr, len); + break; + case 0x1c: + len = duk_debug_read_byte(thr); + duk_debug_skip_bytes(thr, len); + break; + case 0x1d: + duk_debug_skip_bytes(thr, 2); + len = duk_debug_read_byte(thr); + duk_debug_skip_bytes(thr, len); + break; + default: + goto fail; + } + + return 0; + + fail: + DUK__SET_CONN_BROKEN(thr); + return 1; /* Pretend like we got EOM */ +} + +/* Skip dvalues to EOM. */ +DUK_LOCAL void duk__debug_skip_to_eom(duk_hthread *thr) { + for (;;) { + if (duk__debug_skip_dvalue(thr)) { + break; + } + } +} + +/* + * Process incoming debug requests + */ + +DUK_LOCAL void duk__debug_handle_basic_info(duk_hthread *thr, duk_heap *heap) { + DUK_UNREF(heap); + DUK_D(DUK_DPRINT("debug command version")); + + duk_debug_write_reply(thr); + duk_debug_write_int(thr, DUK_VERSION); + duk_debug_write_cstring(thr, DUK_GIT_DESCRIBE); + duk_debug_write_cstring(thr, DUK_USE_TARGET_INFO); +#if defined(DUK_USE_DOUBLE_LE) + duk_debug_write_int(thr, 1); +#elif defined(DUK_USE_DOUBLE_ME) + duk_debug_write_int(thr, 2); +#elif defined(DUK_USE_DOUBLE_BE) + duk_debug_write_int(thr, 3); +#else + duk_debug_write_int(thr, 0); +#endif + duk_debug_write_eom(thr); +} + +DUK_LOCAL void duk__debug_handle_trigger_status(duk_hthread *thr, duk_heap *heap) { + DUK_UNREF(heap); + DUK_D(DUK_DPRINT("debug command triggerstatus")); + + duk_debug_write_reply(thr); + duk_debug_write_eom(thr); + heap->dbg_state_dirty = 1; +} + +DUK_LOCAL void duk__debug_handle_pause(duk_hthread *thr, duk_heap *heap) { + DUK_D(DUK_DPRINT("debug command pause")); + + DUK_HEAP_SET_PAUSED(heap); + duk_debug_write_reply(thr); + duk_debug_write_eom(thr); +} + +DUK_LOCAL void duk__debug_handle_resume(duk_hthread *thr, duk_heap *heap) { + DUK_D(DUK_DPRINT("debug command resume")); + + DUK_HEAP_CLEAR_PAUSED(heap); + duk_debug_write_reply(thr); + duk_debug_write_eom(thr); +} + +DUK_LOCAL void duk__debug_handle_step(duk_hthread *thr, duk_heap *heap, duk_int32_t cmd) { + duk_small_uint_t step_type; + duk_uint_fast32_t line; + + if (cmd == DUK_DBG_CMD_STEPINTO) { + step_type = DUK_STEP_TYPE_INTO; + } else if (cmd == DUK_DBG_CMD_STEPOVER) { + step_type = DUK_STEP_TYPE_OVER; + } else { + DUK_ASSERT(cmd == DUK_DBG_CMD_STEPOUT); + step_type = DUK_STEP_TYPE_OUT; + } + + DUK_D(DUK_DPRINT("debug command stepinto/stepover/stepout: %d", (int) cmd)); + line = duk_debug_curr_line(thr); + if (line > 0) { + heap->dbg_paused = 0; + heap->dbg_step_type = step_type; + heap->dbg_step_thread = thr; + heap->dbg_step_csindex = thr->callstack_top - 1; + heap->dbg_step_startline = line; + heap->dbg_state_dirty = 1; + } else { + DUK_D(DUK_DPRINT("cannot determine current line, stepinto/stepover/stepout ignored")); + } + duk_debug_write_reply(thr); + duk_debug_write_eom(thr); +} + +DUK_LOCAL void duk__debug_handle_list_break(duk_hthread *thr, duk_heap *heap) { + duk_small_int_t i; + + DUK_D(DUK_DPRINT("debug command listbreak")); + duk_debug_write_reply(thr); + for (i = 0; i < (duk_small_int_t) heap->dbg_breakpoint_count; i++) { + duk_debug_write_hstring(thr, heap->dbg_breakpoints[i].filename); + duk_debug_write_uint(thr, (duk_uint32_t) heap->dbg_breakpoints[i].line); + } + duk_debug_write_eom(thr); +} + +DUK_LOCAL void duk__debug_handle_add_break(duk_hthread *thr, duk_heap *heap) { + duk_context *ctx = (duk_context *) thr; + duk_hstring *filename; + duk_uint32_t linenumber; + duk_small_int_t idx; + + DUK_UNREF(heap); + + filename = duk_debug_read_hstring(thr); + linenumber = (duk_uint32_t) duk_debug_read_int(thr); + DUK_D(DUK_DPRINT("debug command addbreak: %!O:%ld", (duk_hobject *) filename, (long) linenumber)); + idx = duk_debug_add_breakpoint(thr, filename, linenumber); + if (idx >= 0) { + duk_debug_write_reply(thr); + duk_debug_write_int(thr, (duk_int32_t) idx); + duk_debug_write_eom(thr); + } else { + duk_debug_write_error_eom(thr, DUK_DBG_ERR_TOOMANY, "no space for breakpoint"); + } + duk_pop(ctx); +} + +DUK_LOCAL void duk__debug_handle_del_break(duk_hthread *thr, duk_heap *heap) { + duk_small_uint_t idx; + + DUK_UNREF(heap); + + DUK_D(DUK_DPRINT("debug command delbreak")); + idx = (duk_small_uint_t) duk_debug_read_int(thr); + if (duk_debug_remove_breakpoint(thr, idx)) { + duk_debug_write_reply(thr); + duk_debug_write_eom(thr); + } else { + duk_debug_write_error_eom(thr, DUK_DBG_ERR_NOTFOUND, "invalid breakpoint index"); + } +} + +DUK_LOCAL void duk__debug_handle_get_var(duk_hthread *thr, duk_heap *heap) { + duk_context *ctx = (duk_context *) thr; + duk_hstring *str; + duk_bool_t rc; + + DUK_UNREF(heap); + DUK_D(DUK_DPRINT("debug command getvar")); + + str = duk_debug_read_hstring(thr); /* push to stack */ + DUK_ASSERT(str != NULL); + + if (thr->callstack_top > 0) { + rc = duk_js_getvar_activation(thr, + thr->callstack + thr->callstack_top - 1, + str, + 0); + } else { + /* No activation, no variable access. Could also pretend + * we're in the global program context and read stuff off + * the global object. + */ + DUK_D(DUK_DPRINT("callstack empty, no activation -> ignore getvar")); + rc = 0; + } + + duk_debug_write_reply(thr); + if (rc) { + duk_debug_write_int(thr, 1); + duk_debug_write_tval(thr, duk_require_tval(ctx, -2)); + duk_pop_2(ctx); + } else { + duk_debug_write_int(thr, 0); + duk_debug_write_unused(thr); + } + duk_pop(ctx); + duk_debug_write_eom(thr); +} + +DUK_LOCAL void duk__debug_handle_put_var(duk_hthread *thr, duk_heap *heap) { + duk_context *ctx = (duk_context *) thr; + duk_hstring *str; + duk_tval *tv; + + DUK_UNREF(heap); + DUK_D(DUK_DPRINT("debug command putvar")); + + str = duk_debug_read_hstring(thr); /* push to stack */ + DUK_ASSERT(str != NULL); + duk_debug_read_tval(thr); /* push to stack */ + tv = duk_require_tval(ctx, -1); + + if (thr->callstack_top > 0) { + duk_js_putvar_activation(thr, + thr->callstack + thr->callstack_top - 1, + str, + tv, + 0); + } else { + DUK_D(DUK_DPRINT("callstack empty, no activation -> ignore putvar")); + } + duk_pop_2(ctx); + + /* XXX: Current putvar implementation doesn't have a success flag, + * add one and send to debug client? + */ + duk_debug_write_reply(thr); + duk_debug_write_eom(thr); +} + +DUK_LOCAL void duk__debug_handle_get_call_stack(duk_hthread *thr, duk_heap *heap) { + duk_context *ctx = (duk_context *) thr; + duk_hthread *curr_thr = thr; + duk_activation *curr_act; + duk_uint_fast32_t pc; + duk_uint_fast32_t line; + duk_size_t i; + + DUK_UNREF(heap); + + duk_debug_write_reply(thr); + while (curr_thr != NULL) { + i = curr_thr->callstack_top; + while (i > 0) { + i--; + curr_act = curr_thr->callstack + i; + + /* PC/line semantics here are: + * - For callstack top we're conceptually between two + * opcodes and current PC indicates next line to + * execute, so report that (matches Status). + * - For other activations we're conceptually still + * executing the instruction at PC-1, so report that + * (matches error stacktrace behavior). + * - See: https://github.com/svaarala/duktape/issues/281 + */ + + /* XXX: optimize to use direct reads, i.e. avoid + * value stack operations. + */ + duk_push_tval(ctx, &curr_act->tv_func); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME); + duk_safe_to_string(ctx, -1); + duk_debug_write_hstring(thr, duk_get_hstring(ctx, -1)); + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME); + duk_safe_to_string(ctx, -1); + duk_debug_write_hstring(thr, duk_get_hstring(ctx, -1)); + pc = duk_hthread_get_act_curr_pc(thr, curr_act); + if (i != curr_thr->callstack_top - 1 && pc > 0) { + pc--; + } + line = duk_hobject_pc2line_query(ctx, -3, pc); + duk_debug_write_uint(thr, (duk_uint32_t) line); + duk_debug_write_uint(thr, (duk_uint32_t) pc); + duk_pop_3(ctx); + } + curr_thr = curr_thr->resumer; + } + duk_debug_write_eom(thr); +} + +DUK_LOCAL void duk__debug_handle_get_locals(duk_hthread *thr, duk_heap *heap) { + duk_context *ctx = (duk_context *) thr; + duk_activation *curr_act; + duk_hstring *varname; + + DUK_UNREF(heap); + + duk_debug_write_reply(thr); + if (thr->callstack_top == 0) { + goto callstack_empty; + } + curr_act = thr->callstack + thr->callstack_top - 1; + + /* XXX: several nice-to-have improvements here: + * - Use direct reads avoiding value stack operations + * - Avoid triggering getters, indicate getter values to debug client + * - If side effects are possible, add error catching + */ + + duk_push_tval(ctx, &curr_act->tv_func); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VARMAP); + if (duk_is_object(ctx, -1)) { + duk_enum(ctx, -1, 0 /*enum_flags*/); + while (duk_next(ctx, -1 /*enum_index*/, 0 /*get_value*/)) { + varname = duk_get_hstring(ctx, -1); + DUK_ASSERT(varname != NULL); + + duk_js_getvar_activation(thr, curr_act, varname, 0 /*throw_flag*/); + /* [ ... func varmap enum key value this ] */ + duk_debug_write_hstring(thr, duk_get_hstring(ctx, -3)); + duk_debug_write_tval(thr, duk_get_tval(ctx, -2)); + duk_pop_3(ctx); /* -> [ ... func varmap enum ] */ + } + duk_pop(ctx); + } else { + DUK_D(DUK_DPRINT("varmap is not an object in GetLocals, ignore")); + } + duk_pop_2(ctx); + + callstack_empty: + duk_debug_write_eom(thr); +} + +DUK_LOCAL void duk__debug_handle_eval(duk_hthread *thr, duk_heap *heap) { + duk_context *ctx = (duk_context *) thr; + + duk_small_uint_t call_flags; + duk_int_t call_ret; + duk_small_int_t eval_err; +#if defined(DUK_USE_ASSERTIONS) + duk_idx_t entry_top; +#endif + + DUK_UNREF(heap); + + DUK_D(DUK_DPRINT("debug command eval")); + + /* The eval code must be executed within the current (topmost) + * activation. For now, use global object eval() function, with + * the eval considered a 'direct call to eval'. + */ + +#if defined(DUK_USE_ASSERTIONS) + entry_top = duk_get_top(ctx); +#endif + + duk_push_c_function(ctx, duk_bi_global_object_eval, 1 /*nargs*/); + duk_push_undefined(ctx); /* 'this' binding shouldn't matter here */ + (void) duk_debug_read_hstring(thr); + + /* [ ... eval "eval" eval_input ] */ + + call_flags = DUK_CALL_FLAG_PROTECTED; + if (thr->callstack_top >= 1) { + duk_activation *act; + duk_hobject *fun; + + act = thr->callstack + thr->callstack_top - 1; + fun = DUK_ACT_GET_FUNC(act); + if (fun && DUK_HOBJECT_IS_COMPILEDFUNCTION(fun)) { + /* Direct eval requires that there's a current + * activation and it is an Ecmascript function. + * When Eval is executed from e.g. cooperate API + * call we'll need to an indirect eval instead. + */ + call_flags |= DUK_CALL_FLAG_DIRECT_EVAL; + } + } + + call_ret = duk_handle_call(thr, 1 /*num_stack_args*/, call_flags); + + if (call_ret == DUK_EXEC_SUCCESS) { + eval_err = 0; + /* Use result value as is. */ + } else { + /* For errors a string coerced result is most informative + * right now, as the debug client doesn't have the capability + * to traverse the error object. + */ + eval_err = 1; + duk_safe_to_string(ctx, -1); + } + + /* [ ... result ] */ + + duk_debug_write_reply(thr); + duk_debug_write_int(thr, (duk_int32_t) eval_err); + duk_debug_write_tval(thr, duk_require_tval(ctx, -1)); + duk_debug_write_eom(thr); + duk_pop(ctx); + + DUK_ASSERT(duk_get_top(ctx) == entry_top); +} + +DUK_LOCAL void duk__debug_handle_detach(duk_hthread *thr, duk_heap *heap) { + DUK_UNREF(heap); + DUK_D(DUK_DPRINT("debug command detach")); + + duk_debug_write_reply(thr); + duk_debug_write_eom(thr); + + DUK_D(DUK_DPRINT("debug connection detached, mark broken")); + DUK__SET_CONN_BROKEN(thr); +} + +#if defined(DUK_USE_DEBUGGER_DUMPHEAP) +DUK_LOCAL void duk__debug_dump_heaphdr(duk_hthread *thr, duk_heap *heap, duk_heaphdr *hdr) { + DUK_UNREF(heap); + + duk_debug_write_heapptr(thr, hdr); + duk_debug_write_uint(thr, (duk_uint32_t) DUK_HEAPHDR_GET_TYPE(hdr)); + duk_debug_write_uint(thr, (duk_uint32_t) DUK_HEAPHDR_GET_FLAGS_RAW(hdr)); +#if defined(DUK_USE_REFERENCE_COUNTING) + duk_debug_write_uint(thr, (duk_uint32_t) DUK_HEAPHDR_GET_REFCOUNT(hdr)); +#else + duk_debug_write_int(thr, (duk_int32_t) -1); +#endif + + switch (DUK_HEAPHDR_GET_TYPE(hdr)) { + case DUK_HTYPE_STRING: { + duk_hstring *h = (duk_hstring *) hdr; + + duk_debug_write_uint(thr, (duk_int32_t) DUK_HSTRING_GET_BYTELEN(h)); + duk_debug_write_uint(thr, (duk_int32_t) DUK_HSTRING_GET_CHARLEN(h)); + duk_debug_write_uint(thr, (duk_int32_t) DUK_HSTRING_GET_HASH(h)); + duk_debug_write_hstring(thr, h); + break; + } + case DUK_HTYPE_OBJECT: { + duk_hobject *h = (duk_hobject *) hdr; + duk_hstring *k; + duk_uint_fast32_t i; + + duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_CLASS_NUMBER(h)); + duk_debug_write_heapptr(thr, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(heap, h)); + duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_ESIZE(h)); + duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_ENEXT(h)); + duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_ASIZE(h)); + duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_HSIZE(h)); + + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) { + duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_E_GET_FLAGS(heap, h, i)); + k = DUK_HOBJECT_E_GET_KEY(heap, h, i); + duk_debug_write_heapptr(thr, (duk_heaphdr *) k); + if (k == NULL) { + duk_debug_write_int(thr, 0); /* isAccessor */ + duk_debug_write_unused(thr); + continue; + } + if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, h, i)) { + duk_debug_write_int(thr, 1); /* isAccessor */ + duk_debug_write_heapptr(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.get); + duk_debug_write_heapptr(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.set); + } else { + duk_debug_write_int(thr, 0); /* isAccessor */ + + duk__debug_write_tval_heapptr(thr, &DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->v); + } + } + + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) { + /* Note: array dump will include elements beyond + * 'length'. + */ + duk__debug_write_tval_heapptr(thr, DUK_HOBJECT_A_GET_VALUE_PTR(heap, h, i)); + } + break; + } + case DUK_HTYPE_BUFFER: { + duk_hbuffer *h = (duk_hbuffer *) hdr; + + duk_debug_write_uint(thr, (duk_uint32_t) DUK_HBUFFER_GET_SIZE(h)); + duk_debug_write_buffer(thr, (const char *) DUK_HBUFFER_GET_DATA_PTR(heap, h), (duk_size_t) DUK_HBUFFER_GET_SIZE(h)); + break; + } + default: { + DUK_D(DUK_DPRINT("invalid htype: %d", (int) DUK_HEAPHDR_GET_TYPE(hdr))); + } + } +} + +DUK_LOCAL void duk__debug_dump_heap_allocated(duk_hthread *thr, duk_heap *heap) { + duk_heaphdr *hdr; + + hdr = heap->heap_allocated; + while (hdr != NULL) { + duk__debug_dump_heaphdr(thr, heap, hdr); + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } +} + +#if defined(DUK_USE_STRTAB_CHAIN) +DUK_LOCAL void duk__debug_dump_strtab_chain(duk_hthread *thr, duk_heap *heap) { + duk_uint_fast32_t i, j; + duk_strtab_entry *e; +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t *lst; +#else + duk_hstring **lst; +#endif + duk_hstring *h; + + for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) { + e = heap->strtable + i; + if (e->listlen > 0) { +#if defined(DUK_USE_HEAPPTR16) + lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16); +#else + lst = e->u.strlist; +#endif + DUK_ASSERT(lst != NULL); + + for (j = 0; j < e->listlen; j++) { +#if defined(DUK_USE_HEAPPTR16) + h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, lst[j]); +#else + h = lst[j]; +#endif + if (h != NULL) { + duk__debug_dump_heaphdr(thr, heap, (duk_heaphdr *) h); + } + } + } else { +#if defined(DUK_USE_HEAPPTR16) + h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.str16); +#else + h = e->u.str; +#endif + if (h != NULL) { + duk__debug_dump_heaphdr(thr, heap, (duk_heaphdr *) h); + } + } + } +} +#endif /* DUK_USE_STRTAB_CHAIN */ + +#if defined(DUK_USE_STRTAB_PROBE) +DUK_LOCAL void duk__debug_dump_strtab_probe(duk_hthread *thr, duk_heap *heap) { + duk_uint32_t i; + duk_hstring *h; + + for (i = 0; i < heap->st_size; i++) { +#if defined(DUK_USE_HEAPPTR16) + h = DUK_USE_HEAPPTR_DEC16(heap->strtable16[i]); +#else + h = heap->strtable[i]; +#endif + if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) { + continue; + } + + duk__debug_dump_heaphdr(thr, heap, (duk_heaphdr *) h); + } +} +#endif /* DUK_USE_STRTAB_PROBE */ + +DUK_LOCAL void duk__debug_handle_dump_heap(duk_hthread *thr, duk_heap *heap) { + DUK_D(DUK_DPRINT("debug command dumpheap")); + + duk_debug_write_reply(thr); + duk__debug_dump_heap_allocated(thr, heap); +#if defined(DUK_USE_STRTAB_CHAIN) + duk__debug_dump_strtab_chain(thr, heap); +#endif +#if defined(DUK_USE_STRTAB_PROBE) + duk__debug_dump_strtab_probe(thr, heap); +#endif + duk_debug_write_eom(thr); +} +#endif /* DUK_USE_DEBUGGER_DUMPHEAP */ + +DUK_LOCAL void duk__debug_handle_get_bytecode(duk_hthread *thr, duk_heap *heap) { + duk_activation *act; + duk_hcompiledfunction *fun; + duk_size_t i, n; + duk_tval *tv; + duk_hobject **fn; + + DUK_UNREF(heap); + + DUK_D(DUK_DPRINT("debug command getbytecode")); + + duk_debug_write_reply(thr); + if (thr->callstack_top == 0) { + fun = NULL; + } else { + act = thr->callstack + thr->callstack_top - 1; + fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act); + if (!DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) fun)) { + fun = NULL; + } + } + DUK_ASSERT(fun == NULL || DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) fun)); + + if (fun) { + n = DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(heap, fun); + duk_debug_write_int(thr, (int) n); + tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap, fun); + for (i = 0; i < n; i++) { + duk_debug_write_tval(thr, tv); + tv++; + } + + n = DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(heap, fun); + duk_debug_write_int(thr, (int) n); + fn = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap, fun); + for (i = 0; i < n; i++) { + duk_debug_write_hobject(thr, *fn); + fn++; + } + + duk_debug_write_string(thr, + (const char *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(heap, fun), + (duk_size_t) DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(heap, fun)); + } else { + duk_debug_write_int(thr, 0); + duk_debug_write_int(thr, 0); + duk_debug_write_cstring(thr, ""); + } + duk_debug_write_eom(thr); +} + +DUK_LOCAL void duk__debug_process_message(duk_hthread *thr) { + duk_context *ctx = (duk_context *) thr; + duk_heap *heap; + duk_uint8_t x; + duk_int32_t cmd; + + DUK_ASSERT(thr != NULL); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + DUK_UNREF(ctx); + + x = duk_debug_read_byte(thr); + switch (x) { + case DUK_DBG_MARKER_REQUEST: { + cmd = duk_debug_read_int(thr); + switch (cmd) { + case DUK_DBG_CMD_BASICINFO: { + duk__debug_handle_basic_info(thr, heap); + break; + } + case DUK_DBG_CMD_TRIGGERSTATUS: { + duk__debug_handle_trigger_status(thr, heap); + break; + } + case DUK_DBG_CMD_PAUSE: { + duk__debug_handle_pause(thr, heap); + break; + } + case DUK_DBG_CMD_RESUME: { + duk__debug_handle_resume(thr, heap); + break; + } + case DUK_DBG_CMD_STEPINTO: + case DUK_DBG_CMD_STEPOVER: + case DUK_DBG_CMD_STEPOUT: { + duk__debug_handle_step(thr, heap, cmd); + break; + } + case DUK_DBG_CMD_LISTBREAK: { + duk__debug_handle_list_break(thr, heap); + break; + } + case DUK_DBG_CMD_ADDBREAK: { + duk__debug_handle_add_break(thr, heap); + break; + } + case DUK_DBG_CMD_DELBREAK: { + duk__debug_handle_del_break(thr, heap); + break; + } + case DUK_DBG_CMD_GETVAR: { + duk__debug_handle_get_var(thr, heap); + break; + } + case DUK_DBG_CMD_PUTVAR: { + duk__debug_handle_put_var(thr, heap); + break; + } + case DUK_DBG_CMD_GETCALLSTACK: { + duk__debug_handle_get_call_stack(thr, heap); + break; + } + case DUK_DBG_CMD_GETLOCALS: { + duk__debug_handle_get_locals(thr, heap); + break; + } + case DUK_DBG_CMD_EVAL: { + duk__debug_handle_eval(thr, heap); + break; + } + case DUK_DBG_CMD_DETACH: { + duk__debug_handle_detach(thr, heap); + break; + } +#if defined(DUK_USE_DEBUGGER_DUMPHEAP) + case DUK_DBG_CMD_DUMPHEAP: { + duk__debug_handle_dump_heap(thr, heap); + break; + } +#endif /* DUK_USE_DEBUGGER_DUMPHEAP */ + case DUK_DBG_CMD_GETBYTECODE: { + duk__debug_handle_get_bytecode(thr, heap); + break; + } + default: { + DUK_D(DUK_DPRINT("debug command unsupported: %d", (int) cmd)); + duk_debug_write_error_eom(thr, DUK_DBG_ERR_UNSUPPORTED, "unsupported command"); + } + } /* switch cmd */ + break; + } + case DUK_DBG_MARKER_REPLY: { + DUK_D(DUK_DPRINT("debug reply, skipping")); + break; + } + case DUK_DBG_MARKER_ERROR: { + DUK_D(DUK_DPRINT("debug error, skipping")); + break; + } + case DUK_DBG_MARKER_NOTIFY: { + DUK_D(DUK_DPRINT("debug notify, skipping")); + break; + } + default: { + DUK_D(DUK_DPRINT("invalid initial byte, drop connection: %d", (int) x)); + goto fail; + } + } /* switch initial byte */ + + duk__debug_skip_to_eom(thr); + return; + + fail: + DUK__SET_CONN_BROKEN(thr); + return; +} + +DUK_INTERNAL duk_bool_t duk_debug_process_messages(duk_hthread *thr, duk_bool_t no_block) { + duk_context *ctx = (duk_context *) thr; +#if defined(DUK_USE_ASSERTIONS) + duk_idx_t entry_top; +#endif + duk_bool_t retval = 0; + + DUK_ASSERT(thr != NULL); + DUK_UNREF(ctx); +#if defined(DUK_USE_ASSERTIONS) + entry_top = duk_get_top(ctx); +#endif + + DUK_DD(DUK_DDPRINT("top at entry: %ld", (long) duk_get_top(ctx))); + + for (;;) { + /* Process messages until we're no longer paused or we peek + * and see there's nothing to read right now. + */ + DUK_DD(DUK_DDPRINT("top at loop top: %ld", (long) duk_get_top(ctx))); + + if (thr->heap->dbg_read_cb == NULL) { + DUK_D(DUK_DPRINT("debug connection broken, stop processing messages")); + break; + } else if (!thr->heap->dbg_paused || no_block) { + if (!duk_debug_read_peek(thr)) { + DUK_D(DUK_DPRINT("processing debug message, peek indicated no data, stop processing")); + break; + } + DUK_D(DUK_DPRINT("processing debug message, peek indicated there is data, handle it")); + } else { + DUK_D(DUK_DPRINT("paused, process debug message, blocking if necessary")); + } + + duk__debug_process_message(thr); + if (thr->heap->dbg_state_dirty) { + /* Executed something that may have affected status, + * resend. + */ + duk_debug_send_status(thr); + thr->heap->dbg_state_dirty = 0; + } + retval = 1; /* processed one or more messages */ + } + + /* As an initial implementation, read flush after exiting the message + * loop. + */ + duk_debug_read_flush(thr); + + DUK_DD(DUK_DDPRINT("top at exit: %ld", (long) duk_get_top(ctx))); + +#if defined(DUK_USE_ASSERTIONS) + /* Easy to get wrong, so assert for it. */ + DUK_ASSERT(entry_top == duk_get_top(ctx)); +#endif + + return retval; +} + +/* + * Breakpoint management + */ + +DUK_INTERNAL duk_small_int_t duk_debug_add_breakpoint(duk_hthread *thr, duk_hstring *filename, duk_uint32_t line) { + duk_heap *heap; + duk_breakpoint *b; + + /* Caller must trigger recomputation of active breakpoint list. To + * ensure stale values are not used if that doesn't happen, clear the + * active breakpoint list here. + */ + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(filename != NULL); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + + if (heap->dbg_breakpoint_count >= DUK_HEAP_MAX_BREAKPOINTS) { + DUK_D(DUK_DPRINT("failed to add breakpoint for %O:%ld, all breakpoint slots used", + (duk_heaphdr *) filename, (long) line)); + return -1; + } + heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL; + b = heap->dbg_breakpoints + (heap->dbg_breakpoint_count++); + b->filename = filename; + b->line = line; + DUK_HSTRING_INCREF(thr, filename); + + return heap->dbg_breakpoint_count - 1; /* index */ +} + +DUK_INTERNAL duk_bool_t duk_debug_remove_breakpoint(duk_hthread *thr, duk_small_uint_t breakpoint_index) { + duk_heap *heap; + duk_hstring *h; + duk_breakpoint *b; + duk_size_t move_size; + + /* Caller must trigger recomputation of active breakpoint list. To + * ensure stale values are not used if that doesn't happen, clear the + * active breakpoint list here. + */ + + DUK_ASSERT(thr != NULL); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + DUK_ASSERT_DISABLE(breakpoint_index >= 0); /* unsigned */ + + if (breakpoint_index >= heap->dbg_breakpoint_count) { + DUK_D(DUK_DPRINT("invalid breakpoint index: %ld", (long) breakpoint_index)); + return 0; + } + b = heap->dbg_breakpoints + breakpoint_index; + + h = b->filename; + DUK_ASSERT(h != NULL); + + move_size = sizeof(duk_breakpoint) * (heap->dbg_breakpoint_count - breakpoint_index - 1); + if (move_size > 0) { + DUK_MEMMOVE((void *) b, + (void *) (b + 1), + move_size); + } + heap->dbg_breakpoint_count--; + heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL; + + DUK_HSTRING_DECREF(thr, h); /* side effects */ + + /* Breakpoint entries above the used area are left as garbage. */ + + return 1; +} + +#undef DUK__SET_CONN_BROKEN + +#else /* DUK_USE_DEBUGGER_SUPPORT */ + +/* No debugger support. */ + +#endif /* DUK_USE_DEBUGGER_SUPPORT */ +#line 1 "duk_error_augment.c" +/* + * Augmenting errors at their creation site and their throw site. + * + * When errors are created, traceback data is added by built-in code + * and a user error handler (if defined) can process or replace the + * error. Similarly, when errors are thrown, a user error handler + * (if defined) can process or replace the error. + * + * Augmentation and other processing at error creation time is nice + * because an error is only created once, but it may be thrown and + * rethrown multiple times. User error handler registered for processing + * an error at its throw site must be careful to handle rethrowing in + * a useful manner. + * + * Error augmentation may throw an internal error (e.g. alloc error). + * + * Ecmascript allows throwing any values, so all values cannot be + * augmented. Currently, the built-in augmentation at error creation + * only augments error values which are Error instances (= have the + * built-in Error.prototype in their prototype chain) and are also + * extensible. User error handlers have no limitations in this respect. + */ + +/* include removed: duk_internal.h */ + +/* + * Helper for calling a user error handler. + * + * 'thr' must be the currently active thread; the error handler is called + * in its context. The valstack of 'thr' must have the error value on + * top, and will be replaced by another error value based on the return + * value of the error handler. + * + * The helper calls duk_handle_call() recursively in protected mode. + * Before that call happens, no longjmps should happen; as a consequence, + * we must assume that the valstack contains enough temporary space for + * arguments and such. + * + * While the error handler runs, any errors thrown will not trigger a + * recursive error handler call (this is implemented using a heap level + * flag which will "follow" through any coroutines resumed inside the + * error handler). If the error handler is not callable or throws an + * error, the resulting error replaces the original error (for Duktape + * internal errors, duk_error_throw.c further substitutes this error with + * a DoubleError which is not ideal). This would be easy to change and + * even signal to the caller. + * + * The user error handler is stored in 'Duktape.errCreate' or + * 'Duktape.errThrow' depending on whether we're augmenting the error at + * creation or throw time. There are several alternatives to this approach, + * see doc/error-objects.rst for discussion. + * + * Note: since further longjmp()s may occur while calling the error handler + * (for many reasons, e.g. a labeled 'break' inside the handler), the + * caller can make no assumptions on the thr->heap->lj state after the + * call (this affects especially duk_error_throw.c). This is not an issue + * as long as the caller writes to the lj state only after the error handler + * finishes. + */ + +#if defined(DUK_USE_ERRTHROW) || defined(DUK_USE_ERRCREATE) +DUK_LOCAL void duk__err_augment_user(duk_hthread *thr, duk_small_uint_t stridx_cb) { + duk_context *ctx = (duk_context *) thr; + duk_tval *tv_hnd; + duk_small_uint_t call_flags; + duk_int_t rc; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT_DISABLE(stridx_cb >= 0); /* unsigned */ + DUK_ASSERT(stridx_cb < DUK_HEAP_NUM_STRINGS); + + if (DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap)) { + DUK_DD(DUK_DDPRINT("recursive call to error handler, ignore")); + return; + } + + /* + * Check whether or not we have an error handler. + * + * We must be careful of not triggering an error when looking up the + * property. For instance, if the property is a getter, we don't want + * to call it, only plain values are allowed. The value, if it exists, + * is not checked. If the value is not a function, a TypeError happens + * when it is called and that error replaces the original one. + */ + + DUK_ASSERT_VALSTACK_SPACE(thr, 4); /* 3 entries actually needed below */ + + /* [ ... errval ] */ + + if (thr->builtins[DUK_BIDX_DUKTAPE] == NULL) { + /* When creating built-ins, some of the built-ins may not be set + * and we want to tolerate that when throwing errors. + */ + DUK_DD(DUK_DDPRINT("error occurred when DUK_BIDX_DUKTAPE is NULL, ignoring")); + return; + } + tv_hnd = duk_hobject_find_existing_entry_tval_ptr(thr->heap, + thr->builtins[DUK_BIDX_DUKTAPE], + DUK_HTHREAD_GET_STRING(thr, stridx_cb)); + if (tv_hnd == NULL) { + DUK_DD(DUK_DDPRINT("error handler does not exist or is not a plain value: %!T", + (duk_tval *) tv_hnd)); + return; + } + DUK_DDD(DUK_DDDPRINT("error handler dump (callability not checked): %!T", + (duk_tval *) tv_hnd)); + duk_push_tval(ctx, tv_hnd); + + /* [ ... errval errhandler ] */ + + duk_insert(ctx, -2); /* -> [ ... errhandler errval ] */ + duk_push_undefined(ctx); + duk_insert(ctx, -2); /* -> [ ... errhandler undefined(= this) errval ] */ + + /* [ ... errhandler undefined errval ] */ + + /* + * DUK_CALL_FLAG_IGNORE_RECLIMIT causes duk_handle_call() to ignore C + * recursion depth limit (and won't increase it either). This is + * dangerous, but useful because it allows the error handler to run + * even if the original error is caused by C recursion depth limit. + * + * The heap level DUK_HEAP_FLAG_ERRHANDLER_RUNNING is set for the + * duration of the error handler and cleared afterwards. This flag + * prevents the error handler from running recursively. The flag is + * heap level so that the flag properly controls even coroutines + * launched by an error handler. Since the flag is heap level, it is + * critical to restore it correctly. + * + * We ignore errors now: a success return and an error value both + * replace the original error value. (This would be easy to change.) + */ + + DUK_ASSERT(!DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap)); /* since no recursive error handler calls */ + DUK_HEAP_SET_ERRHANDLER_RUNNING(thr->heap); + + call_flags = DUK_CALL_FLAG_PROTECTED | + DUK_CALL_FLAG_IGNORE_RECLIMIT; /* protected, ignore reclimit, not constructor */ + + rc = duk_handle_call(thr, + 1, /* num args */ + call_flags); /* call_flags */ + DUK_UNREF(rc); /* no need to check now: both success and error are OK */ + + DUK_ASSERT(DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap)); + DUK_HEAP_CLEAR_ERRHANDLER_RUNNING(thr->heap); + + /* [ ... errval ] */ +} +#endif /* DUK_USE_ERRTHROW || DUK_USE_ERRCREATE */ + +/* + * Add tracedata to an error on the stack top. + */ + +#ifdef DUK_USE_TRACEBACKS +DUK_LOCAL void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_t depth; + duk_int_t i, i_min; + duk_uarridx_t arr_idx; + duk_double_t d; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr_callstack != NULL); + DUK_ASSERT(ctx != NULL); + + /* [ ... error ] */ + + /* + * The traceback format is pretty arcane in an attempt to keep it compact + * and cheap to create. It may change arbitrarily from version to version. + * It should be decoded/accessed through version specific accessors only. + * + * See doc/error-objects.rst. + */ + + DUK_DDD(DUK_DDDPRINT("adding traceback to object: %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + + duk_push_array(ctx); /* XXX: specify array size, as we know it */ + arr_idx = 0; + + /* compiler SyntaxErrors (and other errors) come first; blame the source + * code file/line primarily. + */ + if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) { + duk_push_hstring(ctx, thr->compile_ctx->h_filename); + duk_xdef_prop_index_wec(ctx, -2, arr_idx); + arr_idx++; + + duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line); /* (flags<<32) + (line), flags = 0 */ + duk_xdef_prop_index_wec(ctx, -2, arr_idx); + arr_idx++; + } + + /* filename/line from C macros (__FILE__, __LINE__) are added as an + * entry with a special format: (string, number). The number contains + * the line and flags. + */ + + /* XXX: optimize: allocate an array part to the necessary size (upwards + * estimate) and fill in the values directly into the array part; finally + * update 'length'. + */ + + /* XXX: using duk_put_prop_index() would cause obscure error cases when Array.prototype + * has write-protected array index named properties. This was seen as DoubleErrors + * in e.g. some test262 test cases. Using duk_xdef_prop_index() is better but heavier. + * The best fix is to fill in the tracedata directly into the array part. + */ + + /* [ ... error arr ] */ + + if (c_filename) { + duk_push_string(ctx, c_filename); + duk_xdef_prop_index_wec(ctx, -2, arr_idx); + arr_idx++; + + d = (noblame_fileline ? ((duk_double_t) DUK_TB_FLAG_NOBLAME_FILELINE) * DUK_DOUBLE_2TO32 : 0.0) + + (duk_double_t) c_line; + duk_push_number(ctx, d); + duk_xdef_prop_index_wec(ctx, -2, arr_idx); + arr_idx++; + } + + /* traceback depth doesn't take into account the filename/line + * special handling above (intentional) + */ + depth = DUK_USE_TRACEBACK_DEPTH; + i_min = (thr_callstack->callstack_top > (duk_size_t) depth ? (duk_int_t) (thr_callstack->callstack_top - depth) : 0); + DUK_ASSERT(i_min >= 0); + + /* [ ... error arr ] */ + + DUK_ASSERT(thr_callstack->callstack_top <= DUK_INT_MAX); /* callstack limits */ + for (i = (duk_int_t) (thr_callstack->callstack_top - 1); i >= i_min; i--) { + duk_uint32_t pc; + + /* + * Note: each API operation potentially resizes the callstack, + * so be careful to re-lookup after every operation. Currently + * these is no issue because we don't store a temporary 'act' + * pointer at all. (This would be a non-issue if we operated + * directly on the array part.) + */ + + /* [... arr] */ + + DUK_ASSERT_DISABLE(thr_callstack->callstack[i].pc >= 0); /* unsigned */ + + /* Add function object. */ + duk_push_tval(ctx, &(thr_callstack->callstack + i)->tv_func); + duk_xdef_prop_index_wec(ctx, -2, arr_idx); + arr_idx++; + + /* Add a number containing: pc, activation flags. + * + * PC points to next instruction, find offending PC. Note that + * PC == 0 for native code. + */ + pc = duk_hthread_get_act_prev_pc(thr_callstack, thr_callstack->callstack + i); + DUK_ASSERT_DISABLE(pc >= 0); /* unsigned */ + DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32); /* assume PC is at most 32 bits and non-negative */ + d = ((duk_double_t) thr_callstack->callstack[i].flags) * DUK_DOUBLE_2TO32 + (duk_double_t) pc; + duk_push_number(ctx, d); /* -> [... arr num] */ + duk_xdef_prop_index_wec(ctx, -2, arr_idx); + arr_idx++; + } + + /* XXX: set with duk_hobject_set_length() when tracedata is filled directly */ + duk_push_uint(ctx, (duk_uint_t) arr_idx); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_WC); + + /* [ ... error arr ] */ + + duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_TRACEDATA); /* -> [ ... error ] */ +} +#endif /* DUK_USE_TRACEBACKS */ + +#if defined(DUK_USE_AUGMENT_ERROR_CREATE) +DUK_LOCAL void duk__err_augment_builtin_throw(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_small_int_t noblame_fileline, duk_hobject *obj) { + duk_context *ctx = (duk_context *) thr; +#ifdef DUK_USE_ASSERTIONS + duk_int_t entry_top; +#endif + +#ifdef DUK_USE_ASSERTIONS + entry_top = duk_get_top(ctx); +#endif + DUK_ASSERT(obj != NULL); + + DUK_UNREF(obj); /* unreferenced w/o tracebacks */ + DUK_UNREF(ctx); /* unreferenced w/ tracebacks */ + +#ifdef DUK_USE_TRACEBACKS + /* + * If tracebacks are enabled, the '_Tracedata' property is the only + * thing we need: 'fileName' and 'lineNumber' are virtual properties + * which use '_Tracedata'. + */ + + if (duk_hobject_hasprop_raw(thr, obj, DUK_HTHREAD_STRING_INT_TRACEDATA(thr))) { + DUK_DDD(DUK_DDDPRINT("error value already has a '_Tracedata' property, not modifying it")); + } else { + duk__add_traceback(thr, thr_callstack, c_filename, c_line, noblame_fileline); + } +#else + /* + * If tracebacks are disabled, 'fileName' and 'lineNumber' are added + * as plain own properties. Since Error.prototype has accessors of + * the same name, we need to define own properties directly (cannot + * just use e.g. duk_put_prop_stridx). Existing properties are not + * overwritten in case they already exist. + */ + + if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) { + /* Compiler SyntaxError (or other error) gets the primary blame. */ + duk_push_hstring(ctx, thr->compile_ctx->h_filename); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); + duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); + } else if (c_filename && !noblame_fileline) { + /* XXX: file/line is disabled in minimal builds, so disable this too + * when appropriate. + */ + duk_push_string(ctx, c_filename); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); + duk_push_int(ctx, c_line); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); + } else if (thr_callstack->callstack_top > 0) { + duk_activation *act; + duk_hobject *func; + + act = thr_callstack->callstack + thr_callstack->callstack_top - 1; + DUK_ASSERT(act >= thr_callstack->callstack && act < thr_callstack->callstack + thr_callstack->callstack_size); + func = DUK_ACT_GET_FUNC(act); + if (func) { + duk_uint32_t pc; + + /* PC points to next instruction, find offending PC. Note that + * PC == 0 for native code. + */ + pc = duk_hthread_get_act_prev_pc(thr, act); + DUK_ASSERT_DISABLE(pc >= 0); /* unsigned */ + DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32); /* assume PC is at most 32 bits and non-negative */ + act = NULL; /* invalidated by pushes, so get out of the way */ + + duk_push_hobject(ctx, func); + + /* [ ... error func ] */ + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME); + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); + +#if defined(DUK_USE_PC2LINE) + if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { + duk_uint32_t ecma_line; +#if 0 + duk_push_u32(ctx, pc); + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_PC, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAGS_NO_OVERWRITE); +#endif + ecma_line = duk_hobject_pc2line_query(ctx, -1, (duk_uint_fast32_t) pc); + if (ecma_line > 0) { + duk_push_u32(ctx, (duk_uint32_t) ecma_line); /* -> [ ... error func line ] */ + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); + } + } else { + /* Native function, no relevant lineNumber. */ + } +#endif /* DUK_USE_PC2LINE */ + + duk_pop(ctx); + } + } +#endif /* DUK_USE_TRACEBACKS */ + +#ifdef DUK_USE_ASSERTIONS + DUK_ASSERT(duk_get_top(ctx) == entry_top); +#endif +} +#endif /* DUK_USE_AUGMENT_ERROR_CREATE */ + +/* + * Augment an error at creation time with _Tracedata/fileName/lineNumber + * and allow a user error handler (if defined) to process/replace the error. + * The error to be augmented is at the stack top. + * + * thr: thread containing the error value + * thr_callstack: thread which should be used for generating callstack etc. + * c_filename: C __FILE__ related to the error + * c_line: C __LINE__ related to the error + * noblame_fileline: if true, don't fileName/line as error source, otherwise use traceback + * (needed because user code filename/line are reported but internal ones + * are not) + * + * XXX: rename noblame_fileline to flags field; combine it to some existing + * field (there are only a few call sites so this may not be worth it). + */ + +#if defined(DUK_USE_AUGMENT_ERROR_CREATE) +DUK_INTERNAL void duk_err_augment_error_create(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) { + duk_context *ctx = (duk_context *) thr; + duk_hobject *obj; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr_callstack != NULL); + DUK_ASSERT(ctx != NULL); + + /* [ ... error ] */ + + /* + * Criteria for augmenting: + * + * - augmentation enabled in build (naturally) + * - error value internal prototype chain contains the built-in + * Error prototype object (i.e. 'val instanceof Error') + * + * Additional criteria for built-in augmenting: + * + * - error value is an extensible object + */ + + obj = duk_get_hobject(ctx, -1); + if (!obj) { + DUK_DDD(DUK_DDDPRINT("value is not an object, skip both built-in and user augment")); + return; + } + if (!duk_hobject_prototype_chain_contains(thr, obj, thr->builtins[DUK_BIDX_ERROR_PROTOTYPE], 1 /*ignore_loop*/)) { + /* If the value has a prototype loop, it's critical not to + * throw here. Instead, assume the value is not to be + * augmented. + */ + DUK_DDD(DUK_DDDPRINT("value is not an error instance, skip both built-in and user augment")); + return; + } + if (DUK_HOBJECT_HAS_EXTENSIBLE(obj)) { + DUK_DDD(DUK_DDDPRINT("error meets criteria, built-in augment")); + duk__err_augment_builtin_throw(thr, thr_callstack, c_filename, c_line, noblame_fileline, obj); + } else { + DUK_DDD(DUK_DDDPRINT("error does not meet criteria, no built-in augment")); + } + + /* [ ... error ] */ + +#if defined(DUK_USE_ERRCREATE) + duk__err_augment_user(thr, DUK_STRIDX_ERR_CREATE); +#endif +} +#endif /* DUK_USE_AUGMENT_ERROR_CREATE */ + +/* + * Augment an error at throw time; allow a user error handler (if defined) + * to process/replace the error. The error to be augmented is at the + * stack top. + */ + +#if defined(DUK_USE_AUGMENT_ERROR_THROW) +DUK_INTERNAL void duk_err_augment_error_throw(duk_hthread *thr) { +#if defined(DUK_USE_ERRTHROW) + duk__err_augment_user(thr, DUK_STRIDX_ERR_THROW); +#endif /* DUK_USE_ERRTHROW */ +} +#endif /* DUK_USE_AUGMENT_ERROR_THROW */ +#line 1 "duk_error_longjmp.c" +/* + * Do a longjmp call, calling the fatal error handler if no + * catchpoint exists. + */ + +/* include removed: duk_internal.h */ + +DUK_INTERNAL void duk_err_longjmp(duk_hthread *thr) { + DUK_ASSERT(thr != NULL); + + if (!thr->heap->lj.jmpbuf_ptr) { + /* + * If we don't have a jmpbuf_ptr, there is little we can do + * except panic. The caller's expectation is that we never + * return. + */ + + DUK_D(DUK_DPRINT("uncaught error: type=%d iserror=%d value1=%!T value2=%!T", + (int) thr->heap->lj.type, (int) thr->heap->lj.iserror, + &thr->heap->lj.value1, &thr->heap->lj.value2)); + + duk_fatal((duk_context *) thr, DUK_ERR_UNCAUGHT_ERROR, "uncaught error"); + DUK_UNREACHABLE(); + } + + DUK_LONGJMP(thr->heap->lj.jmpbuf_ptr->jb); + DUK_UNREACHABLE(); +} +#line 1 "duk_error_misc.c" +/* + * Error helpers + */ + +/* include removed: duk_internal.h */ + +/* + * Get prototype object for an integer error code. + */ + +DUK_INTERNAL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t code) { + switch (code) { + case DUK_ERR_EVAL_ERROR: + return thr->builtins[DUK_BIDX_EVAL_ERROR_PROTOTYPE]; + case DUK_ERR_RANGE_ERROR: + return thr->builtins[DUK_BIDX_RANGE_ERROR_PROTOTYPE]; + case DUK_ERR_REFERENCE_ERROR: + return thr->builtins[DUK_BIDX_REFERENCE_ERROR_PROTOTYPE]; + case DUK_ERR_SYNTAX_ERROR: + return thr->builtins[DUK_BIDX_SYNTAX_ERROR_PROTOTYPE]; + case DUK_ERR_TYPE_ERROR: + return thr->builtins[DUK_BIDX_TYPE_ERROR_PROTOTYPE]; + case DUK_ERR_URI_ERROR: + return thr->builtins[DUK_BIDX_URI_ERROR_PROTOTYPE]; + + /* XXX: more specific error classes? */ + case DUK_ERR_UNIMPLEMENTED_ERROR: + case DUK_ERR_INTERNAL_ERROR: + case DUK_ERR_ALLOC_ERROR: + case DUK_ERR_ASSERTION_ERROR: + case DUK_ERR_API_ERROR: + case DUK_ERR_ERROR: + default: + return thr->builtins[DUK_BIDX_ERROR_PROTOTYPE]; + } +} + +/* + * Exposed helper for setting up heap longjmp state. + */ + +DUK_INTERNAL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_int_t lj_type) { + duk_tval tv_tmp; + + thr->heap->lj.type = lj_type; + + DUK_ASSERT(thr->valstack_top > thr->valstack); + DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); + DUK_TVAL_SET_TVAL(&thr->heap->lj.value1, thr->valstack_top - 1); + DUK_TVAL_INCREF(thr, &thr->heap->lj.value1); + DUK_TVAL_DECREF(thr, &tv_tmp); + + duk_pop((duk_context *) thr); +} +#line 1 "duk_error_throw.c" +/* + * Create and throw an Ecmascript error object based on a code and a message. + * + * Used when we throw errors internally. Ecmascript generated error objects + * are created by Ecmascript code, and the throwing is handled by the bytecode + * executor. + */ + +/* include removed: duk_internal.h */ + +/* + * Create and throw an error (originating from Duktape internally) + * + * Push an error object on top of the stack, possibly throw augmenting + * the error, and finally longjmp. + * + * If an error occurs while we're dealing with the current error, we might + * enter an infinite recursion loop. This is prevented by detecting a + * "double fault" through the heap->handling_error flag; the recursion + * then stops at the second level. + */ + +#ifdef DUK_USE_VERBOSE_ERRORS +DUK_INTERNAL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code, const char *msg, const char *filename, duk_int_t line) { +#else +DUK_INTERNAL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code) { +#endif + duk_context *ctx = (duk_context *) thr; + duk_bool_t double_error = thr->heap->handling_error; + +#ifdef DUK_USE_VERBOSE_ERRORS + DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld, msg=%s, filename=%s, line=%ld", + (long) code, (const char *) msg, + (const char *) filename, (long) line)); +#else + DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld", (long) code)); +#endif + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + + thr->heap->handling_error = 1; + + if (!double_error) { + /* Allow headroom for calls during error handling (see GH-191). + * We allow space for 10 additional recursions, with one extra + * for, e.g. a print() call at the deepest level. + */ + DUK_ASSERT(thr->callstack_max == DUK_CALLSTACK_DEFAULT_MAX); + thr->callstack_max = DUK_CALLSTACK_DEFAULT_MAX + DUK_CALLSTACK_GROW_STEP + 11; + } + + DUK_ASSERT(thr->callstack_max == DUK_CALLSTACK_DEFAULT_MAX + DUK_CALLSTACK_GROW_STEP + 11); /* just making sure */ + + /* Sync so that augmentation sees up-to-date activations, NULL + * thr->ptr_curr_pc so that it's not used if side effects occur + * in augmentation or longjmp handling. + */ + duk_hthread_sync_and_null_currpc(thr); + + /* + * Create and push an error object onto the top of stack. + * If a "double error" occurs, use a fixed error instance + * to avoid further trouble. + */ + + /* XXX: if attempt to push beyond allocated valstack, this double fault + * handling fails miserably. We should really write the double error + * directly to thr->heap->lj.value1 and avoid valstack use entirely. + */ + + if (double_error) { + if (thr->builtins[DUK_BIDX_DOUBLE_ERROR]) { + DUK_D(DUK_DPRINT("double fault detected -> push built-in fixed 'double error' instance")); + duk_push_hobject_bidx(ctx, DUK_BIDX_DOUBLE_ERROR); + } else { + DUK_D(DUK_DPRINT("double fault detected; there is no built-in fixed 'double error' instance " + "-> push the error code as a number")); + duk_push_int(ctx, (duk_int_t) code); + } + } else { + /* Error object is augmented at its creation here. */ + duk_require_stack(ctx, 1); + /* XXX: unnecessary '%s' formatting here, but cannot use + * 'msg' as a format string directly. + */ +#ifdef DUK_USE_VERBOSE_ERRORS + duk_push_error_object_raw(ctx, + code | DUK_ERRCODE_FLAG_NOBLAME_FILELINE, + filename, + line, + "%s", + (const char *) msg); +#else + duk_push_error_object_raw(ctx, + code | DUK_ERRCODE_FLAG_NOBLAME_FILELINE, + NULL, + 0, + NULL); +#endif + } + + /* + * Augment error (throw time), unless alloc/double error + */ + + if (double_error || code == DUK_ERR_ALLOC_ERROR) { + DUK_D(DUK_DPRINT("alloc or double error: skip throw augmenting to avoid further trouble")); + } else { +#if defined(DUK_USE_AUGMENT_ERROR_THROW) + DUK_DDD(DUK_DDDPRINT("THROW ERROR (INTERNAL): %!iT (before throw augment)", + (duk_tval *) duk_get_tval(ctx, -1))); + duk_err_augment_error_throw(thr); +#endif + } + + /* + * Finally, longjmp + */ + + duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW); + + thr->callstack_max = DUK_CALLSTACK_DEFAULT_MAX; /* reset callstack limit */ + thr->heap->handling_error = 0; + + DUK_DDD(DUK_DDDPRINT("THROW ERROR (INTERNAL): %!iT, %!iT (after throw augment)", + (duk_tval *) &thr->heap->lj.value1, (duk_tval *) &thr->heap->lj.value2)); + + duk_err_longjmp(thr); + DUK_UNREACHABLE(); +} + +/* + * Helper for C function call negative return values. + */ + +DUK_INTERNAL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc) { + duk_context *ctx = (duk_context *) thr; + const char *msg; + duk_errcode_t code; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(rc < 0); + + /* XXX: this generates quite large code - perhaps select the error + * class based on the code and then just use the error 'name'? + */ + /* XXX: shared strings */ + + code = -rc; + + switch (rc) { + case DUK_RET_UNIMPLEMENTED_ERROR: msg = "unimplemented"; break; + case DUK_RET_UNSUPPORTED_ERROR: msg = "unsupported"; break; + case DUK_RET_INTERNAL_ERROR: msg = "internal"; break; + case DUK_RET_ALLOC_ERROR: msg = "alloc"; break; + case DUK_RET_ASSERTION_ERROR: msg = "assertion"; break; + case DUK_RET_API_ERROR: msg = "api"; break; + case DUK_RET_UNCAUGHT_ERROR: msg = "uncaught"; break; + case DUK_RET_ERROR: msg = "error"; break; + case DUK_RET_EVAL_ERROR: msg = "eval"; break; + case DUK_RET_RANGE_ERROR: msg = "range"; break; + case DUK_RET_REFERENCE_ERROR: msg = "reference"; break; + case DUK_RET_SYNTAX_ERROR: msg = "syntax"; break; + case DUK_RET_TYPE_ERROR: msg = "type"; break; + case DUK_RET_URI_ERROR: msg = "uri"; break; + default: msg = "unknown"; break; + } + + DUK_ASSERT(msg != NULL); + + /* + * The __FILE__ and __LINE__ information is intentionally not used in the + * creation of the error object, as it isn't useful in the tracedata. The + * tracedata still contains the function which returned the negative return + * code, and having the file/line of this function isn't very useful. + */ + + duk_error_raw(ctx, code, NULL, 0, "%s error (rc %ld)", (const char *) msg, (long) rc); + DUK_UNREACHABLE(); +} +#line 1 "duk_hbuffer_alloc.c" +/* + * duk_hbuffer allocation and freeing. + */ + +/* include removed: duk_internal.h */ + +/* Allocate a new duk_hbuffer of a certain type and return a pointer to it + * (NULL on error). Write buffer data pointer to 'out_bufdata' (only if + * allocation successful). + */ +DUK_INTERNAL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags, void **out_bufdata) { + duk_hbuffer *res = NULL; + duk_size_t header_size; + duk_size_t alloc_size; + + DUK_ASSERT(heap != NULL); + DUK_ASSERT(out_bufdata != NULL); + + DUK_DDD(DUK_DDDPRINT("allocate hbuffer")); + + /* Size sanity check. Should not be necessary because caller is + * required to check this, but we don't want to cause a segfault + * if the size wraps either in duk_size_t computation or when + * storing the size in a 16-bit field. + */ + if (size > DUK_HBUFFER_MAX_BYTELEN) { + DUK_D(DUK_DPRINT("hbuffer alloc failed: size too large: %ld", (long) size)); + return NULL; /* no need to write 'out_bufdata' */ + } + + if (flags & DUK_BUF_FLAG_EXTERNAL) { + header_size = sizeof(duk_hbuffer_external); + alloc_size = sizeof(duk_hbuffer_external); + } if (flags & DUK_BUF_FLAG_DYNAMIC) { + header_size = sizeof(duk_hbuffer_dynamic); + alloc_size = sizeof(duk_hbuffer_dynamic); + } else { + header_size = sizeof(duk_hbuffer_fixed); + alloc_size = sizeof(duk_hbuffer_fixed) + size; + DUK_ASSERT(alloc_size >= sizeof(duk_hbuffer_fixed)); /* no wrapping */ + } + + res = (duk_hbuffer *) DUK_ALLOC(heap, alloc_size); + if (!res) { + goto error; + } + + /* zero everything unless requested not to do so */ +#if defined(DUK_USE_ZERO_BUFFER_DATA) + DUK_MEMZERO((void *) res, + (flags & DUK_BUF_FLAG_NOZERO) ? header_size : alloc_size); +#else + DUK_MEMZERO((void *) res, header_size); +#endif + + if (flags & DUK_BUF_FLAG_EXTERNAL) { + duk_hbuffer_external *h; + h = (duk_hbuffer_external *) res; + DUK_UNREF(h); + *out_bufdata = NULL; +#if defined(DUK_USE_EXPLICIT_NULL_INIT) +#if defined(DUK_USE_HEAPPTR16) +/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */ +#else + DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap, h, NULL); +#endif +#endif + DUK_ASSERT(DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap, h) == NULL); + } else if (flags & DUK_BUF_FLAG_DYNAMIC) { + duk_hbuffer_dynamic *h = (duk_hbuffer_dynamic *) res; + void *ptr; + + if (size > 0) { + DUK_ASSERT(!(flags & DUK_BUF_FLAG_EXTERNAL)); /* alloc external with size zero */ + DUK_DDD(DUK_DDDPRINT("dynamic buffer with nonzero size, alloc actual buffer")); +#ifdef DUK_USE_ZERO_BUFFER_DATA + ptr = DUK_ALLOC_ZEROED(heap, size); +#else + ptr = DUK_ALLOC(heap, size); +#endif + if (!ptr) { + /* Because size > 0, NULL check is correct */ + goto error; + } + *out_bufdata = ptr; + + DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, ptr); + } else { + *out_bufdata = NULL; +#if defined(DUK_USE_EXPLICIT_NULL_INIT) +#if defined(DUK_USE_HEAPPTR16) +/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */ +#else + DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, NULL); +#endif +#endif + DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, h) == NULL); + } + } else { + *out_bufdata = (void *) ((duk_hbuffer_fixed *) res + 1); + } + + DUK_HBUFFER_SET_SIZE(res, size); + + DUK_HEAPHDR_SET_TYPE(&res->hdr, DUK_HTYPE_BUFFER); + if (flags & DUK_BUF_FLAG_DYNAMIC) { + DUK_HBUFFER_SET_DYNAMIC(res); + if (flags & DUK_BUF_FLAG_EXTERNAL) { + DUK_HBUFFER_SET_EXTERNAL(res); + } + } else { + DUK_ASSERT(!(flags & DUK_BUF_FLAG_EXTERNAL)); + } + DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, &res->hdr); + + DUK_DDD(DUK_DDDPRINT("allocated hbuffer: %p", (void *) res)); + return res; + + error: + DUK_DD(DUK_DDPRINT("hbuffer allocation failed")); + + DUK_FREE(heap, res); + return NULL; /* no need to write 'out_bufdata' */ +} + +/* For indirect allocs. */ + +DUK_INTERNAL void *duk_hbuffer_get_dynalloc_ptr(duk_heap *heap, void *ud) { + duk_hbuffer_dynamic *buf = (duk_hbuffer_dynamic *) ud; + DUK_UNREF(heap); + return (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, buf); +} +#line 1 "duk_hbuffer_ops.c" +/* + * duk_hbuffer operations such as resizing and inserting/appending data to + * a dynamic buffer. + * + * Append operations append to the end of the buffer and they are relatively + * efficient: the buffer is grown with a "spare" part relative to the buffer + * size to minimize reallocations. Insert operations need to move existing + * data forward in the buffer with memmove() and are not very efficient. + * They are used e.g. by the regexp compiler to "backpatch" regexp bytecode. + */ + +/* include removed: duk_internal.h */ + +/* + * Resizing + */ + +DUK_INTERNAL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size) { + void *res; + duk_size_t prev_size; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(buf != NULL); + DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); + DUK_ASSERT(!DUK_HBUFFER_HAS_EXTERNAL(buf)); + + /* + * Maximum size check + */ + + if (new_size > DUK_HBUFFER_MAX_BYTELEN) { + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, "buffer too long"); + } + + /* + * Note: use indirect realloc variant just in case mark-and-sweep + * (finalizers) might resize this same buffer during garbage + * collection. + */ + + res = DUK_REALLOC_INDIRECT(thr->heap, duk_hbuffer_get_dynalloc_ptr, (void *) buf, new_size); + if (res != NULL || new_size == 0) { + /* 'res' may be NULL if new allocation size is 0. */ + + DUK_DDD(DUK_DDDPRINT("resized dynamic buffer %p:%ld -> %p:%ld", + (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf), + (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(buf), + (void *) res, + (long) new_size)); + + /* + * The entire allocated buffer area, regardless of actual used + * size, is kept zeroed in resizes for simplicity. If the buffer + * is grown, zero the new part. + */ + + prev_size = DUK_HBUFFER_DYNAMIC_GET_SIZE(buf); + if (new_size > prev_size) { + DUK_ASSERT(new_size - prev_size > 0); +#ifdef DUK_USE_ZERO_BUFFER_DATA + DUK_MEMZERO((void *) ((char *) res + prev_size), + (duk_size_t) (new_size - prev_size)); +#endif + } + + DUK_HBUFFER_DYNAMIC_SET_SIZE(buf, new_size); + DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(thr->heap, buf, res); + } else { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "buffer resize failed: %ld to %ld", + (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(buf), + (long) new_size); + } + + DUK_ASSERT(res != NULL || new_size == 0); +} + +DUK_INTERNAL void duk_hbuffer_reset(duk_hthread *thr, duk_hbuffer_dynamic *buf) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(buf != NULL); + DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); + DUK_ASSERT(!DUK_HBUFFER_HAS_EXTERNAL(buf)); + + duk_hbuffer_resize(thr, buf, 0); +} +/* include removed: duk_internal.h */ +#line 2 "duk_hbufferobject_misc.c" + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_uint_t duk_hbufferobject_clamp_bytelength(duk_hbufferobject *h_bufobj, duk_uint_t len) { + duk_uint_t buf_size; + duk_uint_t buf_avail; + + DUK_ASSERT(h_bufobj != NULL); + DUK_ASSERT(h_bufobj->buf != NULL); + + buf_size = (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_bufobj->buf); + if (h_bufobj->offset > buf_size) { + /* Slice starting point is beyond current length. */ + return 0; + } + buf_avail = buf_size - h_bufobj->offset; + + return buf_avail >= len ? len : buf_avail; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ +#line 1 "duk_heap_alloc.c" +/* + * duk_heap allocation and freeing. + */ + +/* include removed: duk_internal.h */ + +/* constants for built-in string data depacking */ +#define DUK__BITPACK_LETTER_LIMIT 26 +#define DUK__BITPACK_UNDERSCORE 26 +#define DUK__BITPACK_FF 27 +#define DUK__BITPACK_SWITCH1 29 +#define DUK__BITPACK_SWITCH 30 +#define DUK__BITPACK_SEVENBIT 31 + +/* + * Free a heap object. + * + * Free heap object and its internal (non-heap) pointers. Assumes that + * caller has removed the object from heap allocated list or the string + * intern table, and any weak references (which strings may have) have + * been already dealt with. + */ + +DUK_INTERNAL void duk_free_hobject_inner(duk_heap *heap, duk_hobject *h) { + DUK_ASSERT(heap != NULL); + DUK_ASSERT(h != NULL); + + DUK_FREE(heap, DUK_HOBJECT_GET_PROPS(heap, h)); + + if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) { + duk_hcompiledfunction *f = (duk_hcompiledfunction *) h; + DUK_UNREF(f); + /* Currently nothing to free; 'data' is a heap object */ + } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { + duk_hnativefunction *f = (duk_hnativefunction *) h; + DUK_UNREF(f); + /* Currently nothing to free */ + } else if (DUK_HOBJECT_IS_THREAD(h)) { + duk_hthread *t = (duk_hthread *) h; + DUK_FREE(heap, t->valstack); + DUK_FREE(heap, t->callstack); + DUK_FREE(heap, t->catchstack); + /* Don't free h->resumer because it exists in the heap. + * Callstack entries also contain function pointers which + * are not freed for the same reason. + */ + + /* XXX: with 'caller' property the callstack would need + * to be unwound to update the 'caller' properties of + * functions in the callstack. + */ + } +} + +DUK_INTERNAL void duk_free_hbuffer_inner(duk_heap *heap, duk_hbuffer *h) { + DUK_ASSERT(heap != NULL); + DUK_ASSERT(h != NULL); + + if (DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h)) { + duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h; + DUK_DDD(DUK_DDDPRINT("free dynamic buffer %p", (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, g))); + DUK_FREE(heap, DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, g)); + } +} + +DUK_INTERNAL void duk_free_hstring_inner(duk_heap *heap, duk_hstring *h) { + DUK_ASSERT(heap != NULL); + DUK_ASSERT(h != NULL); + + DUK_UNREF(heap); + DUK_UNREF(h); + +#if defined(DUK_USE_HSTRING_EXTDATA) && defined(DUK_USE_EXTSTR_FREE) + if (DUK_HSTRING_HAS_EXTDATA(h)) { + DUK_DDD(DUK_DDDPRINT("free extstr: hstring %!O, extdata: %p", + h, DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h))); + DUK_USE_EXTSTR_FREE(heap->heap_udata, (const void *) DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h)); + } +#endif +} + +DUK_INTERNAL void duk_heap_free_heaphdr_raw(duk_heap *heap, duk_heaphdr *hdr) { + DUK_ASSERT(heap); + DUK_ASSERT(hdr); + + DUK_DDD(DUK_DDDPRINT("free heaphdr %p, htype %ld", (void *) hdr, (long) DUK_HEAPHDR_GET_TYPE(hdr))); + + switch ((int) DUK_HEAPHDR_GET_TYPE(hdr)) { + case DUK_HTYPE_STRING: + duk_free_hstring_inner(heap, (duk_hstring *) hdr); + break; + case DUK_HTYPE_OBJECT: + duk_free_hobject_inner(heap, (duk_hobject *) hdr); + break; + case DUK_HTYPE_BUFFER: + duk_free_hbuffer_inner(heap, (duk_hbuffer *) hdr); + break; + default: + DUK_UNREACHABLE(); + } + + DUK_FREE(heap, hdr); +} + +/* + * Free the heap. + * + * Frees heap-related non-heap-tracked allocations such as the + * string intern table; then frees the heap allocated objects; + * and finally frees the heap structure itself. Reference counts + * and GC markers are ignored (and not updated) in this process, + * and finalizers won't be called. + * + * The heap pointer and heap object pointers must not be used + * after this call. + */ + +DUK_LOCAL void duk__free_allocated(duk_heap *heap) { + duk_heaphdr *curr; + duk_heaphdr *next; + + curr = heap->heap_allocated; + while (curr) { + /* We don't log or warn about freeing zero refcount objects + * because they may happen with finalizer processing. + */ + + DUK_DDD(DUK_DDDPRINT("FINALFREE (allocated): %!iO", + (duk_heaphdr *) curr)); + next = DUK_HEAPHDR_GET_NEXT(heap, curr); + duk_heap_free_heaphdr_raw(heap, curr); + curr = next; + } +} + +#ifdef DUK_USE_REFERENCE_COUNTING +DUK_LOCAL void duk__free_refzero_list(duk_heap *heap) { + duk_heaphdr *curr; + duk_heaphdr *next; + + curr = heap->refzero_list; + while (curr) { + DUK_DDD(DUK_DDDPRINT("FINALFREE (refzero_list): %!iO", + (duk_heaphdr *) curr)); + next = DUK_HEAPHDR_GET_NEXT(heap, curr); + duk_heap_free_heaphdr_raw(heap, curr); + curr = next; + } +} +#endif + +#ifdef DUK_USE_MARK_AND_SWEEP +DUK_LOCAL void duk__free_markandsweep_finalize_list(duk_heap *heap) { + duk_heaphdr *curr; + duk_heaphdr *next; + + curr = heap->finalize_list; + while (curr) { + DUK_DDD(DUK_DDDPRINT("FINALFREE (finalize_list): %!iO", + (duk_heaphdr *) curr)); + next = DUK_HEAPHDR_GET_NEXT(heap, curr); + duk_heap_free_heaphdr_raw(heap, curr); + curr = next; + } +} +#endif + +DUK_LOCAL void duk__free_stringtable(duk_heap *heap) { + /* strings are only tracked by stringtable */ + duk_heap_free_strtab(heap); +} + +DUK_LOCAL void duk__free_run_finalizers(duk_heap *heap) { + duk_hthread *thr; + duk_heaphdr *curr; +#ifdef DUK_USE_DEBUG + duk_size_t count_obj = 0; +#endif + + DUK_ASSERT(heap != NULL); + DUK_ASSERT(heap->heap_thread != NULL); +#ifdef DUK_USE_REFERENCE_COUNTING + DUK_ASSERT(heap->refzero_list == NULL); /* refzero not running -> must be empty */ +#endif +#ifdef DUK_USE_MARK_AND_SWEEP + DUK_ASSERT(heap->finalize_list == NULL); /* mark-and-sweep not running -> must be empty */ +#endif + + /* XXX: here again finalizer thread is the heap_thread which needs + * to be coordinated with finalizer thread fixes. + */ + thr = heap->heap_thread; + DUK_ASSERT(thr != NULL); + + curr = heap->heap_allocated; + while (curr) { + if (DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT) { + /* Only objects in heap_allocated may have finalizers. Check that + * the object itself has a _Finalizer property so that we don't + * execute finalizers for e.g. Proxy objects. + */ + DUK_ASSERT(thr != NULL); + DUK_ASSERT(curr != NULL); + + if (duk_hobject_hasprop_raw(thr, (duk_hobject *) curr, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) { + duk_hobject_run_finalizer(thr, (duk_hobject *) curr); + } +#ifdef DUK_USE_DEBUG + count_obj++; +#endif + } + curr = DUK_HEAPHDR_GET_NEXT(heap, curr); + } + + /* Note: count includes all objects, not only those with an actual finalizer. */ +#ifdef DUK_USE_DEBUG + DUK_D(DUK_DPRINT("checked %ld objects for finalizers before freeing heap", (long) count_obj)); +#endif +} + +DUK_INTERNAL void duk_heap_free(duk_heap *heap) { + DUK_D(DUK_DPRINT("free heap: %p", (void *) heap)); + +#if defined(DUK_USE_DEBUG) + duk_heap_dump_strtab(heap); +#endif + +#if defined(DUK_USE_DEBUGGER_SUPPORT) + /* Detach a debugger if attached (can be called multiple times) + * safely. + */ + duk_debug_do_detach(heap); +#endif + + /* Execute finalizers before freeing the heap, even for reachable + * objects, and regardless of whether or not mark-and-sweep is + * enabled. This gives finalizers the chance to free any native + * resources like file handles, allocations made outside Duktape, + * etc. + * + * XXX: this perhaps requires an execution time limit. + */ + DUK_D(DUK_DPRINT("execute finalizers before freeing heap")); +#ifdef DUK_USE_MARK_AND_SWEEP + /* run mark-and-sweep a few times just in case (unreachable + * object finalizers run already here) + */ + duk_heap_mark_and_sweep(heap, 0); + duk_heap_mark_and_sweep(heap, 0); +#endif + duk__free_run_finalizers(heap); + + /* Note: heap->heap_thread, heap->curr_thread, and heap->heap_object + * are on the heap allocated list. + */ + + DUK_D(DUK_DPRINT("freeing heap objects of heap: %p", (void *) heap)); + duk__free_allocated(heap); + +#ifdef DUK_USE_REFERENCE_COUNTING + DUK_D(DUK_DPRINT("freeing refzero list of heap: %p", (void *) heap)); + duk__free_refzero_list(heap); +#endif + +#ifdef DUK_USE_MARK_AND_SWEEP + DUK_D(DUK_DPRINT("freeing mark-and-sweep finalize list of heap: %p", (void *) heap)); + duk__free_markandsweep_finalize_list(heap); +#endif + + DUK_D(DUK_DPRINT("freeing string table of heap: %p", (void *) heap)); + duk__free_stringtable(heap); + + DUK_D(DUK_DPRINT("freeing heap structure: %p", (void *) heap)); + heap->free_func(heap->heap_udata, heap); +} + +/* + * Allocate a heap. + * + * String table is initialized with built-in strings from genstrings.py. + */ + +/* intern built-in strings from precooked data (genstrings.py) */ +DUK_LOCAL duk_bool_t duk__init_heap_strings(duk_heap *heap) { + duk_bitdecoder_ctx bd_ctx; + duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */ + duk_small_uint_t i, j; + + DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx)); + bd->data = (const duk_uint8_t *) duk_strings_data; + bd->length = (duk_size_t) DUK_STRDATA_DATA_LENGTH; + + for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) { + duk_uint8_t tmp[DUK_STRDATA_MAX_STRLEN]; + duk_hstring *h; + duk_small_uint_t len; + duk_small_uint_t mode; + duk_small_uint_t t; + + len = duk_bd_decode(bd, 5); + mode = 32; /* 0 = uppercase, 32 = lowercase (= 'a' - 'A') */ + for (j = 0; j < len; j++) { + t = duk_bd_decode(bd, 5); + if (t < DUK__BITPACK_LETTER_LIMIT) { + t = t + DUK_ASC_UC_A + mode; + } else if (t == DUK__BITPACK_UNDERSCORE) { + t = DUK_ASC_UNDERSCORE; + } else if (t == DUK__BITPACK_FF) { + /* Internal keys are prefixed with 0xFF in the stringtable + * (which makes them invalid UTF-8 on purpose). + */ + t = 0xff; + } else if (t == DUK__BITPACK_SWITCH1) { + t = duk_bd_decode(bd, 5); + DUK_ASSERT_DISABLE(t >= 0); /* unsigned */ + DUK_ASSERT(t <= 25); + t = t + DUK_ASC_UC_A + (mode ^ 32); + } else if (t == DUK__BITPACK_SWITCH) { + mode = mode ^ 32; + t = duk_bd_decode(bd, 5); + DUK_ASSERT_DISABLE(t >= 0); + DUK_ASSERT(t <= 25); + t = t + DUK_ASC_UC_A + mode; + } else if (t == DUK__BITPACK_SEVENBIT) { + t = duk_bd_decode(bd, 7); + } + tmp[j] = (duk_uint8_t) t; + } + + /* No need to length check string: it will never exceed even + * the 16-bit length maximum. + */ + DUK_ASSERT(len <= 0xffffUL); + DUK_DDD(DUK_DDDPRINT("intern built-in string %ld", (long) i)); + h = duk_heap_string_intern(heap, tmp, len); + if (!h) { + goto error; + } + + /* Special flags checks. Since these strings are always + * reachable and a string cannot appear twice in the string + * table, there's no need to check/set these flags elsewhere. + * The 'internal' flag is set by string intern code. + */ + if (i == DUK_STRIDX_EVAL || i == DUK_STRIDX_LC_ARGUMENTS) { + DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(h); + } + if (i >= DUK_STRIDX_START_RESERVED && i < DUK_STRIDX_END_RESERVED) { + DUK_HSTRING_SET_RESERVED_WORD(h); + if (i >= DUK_STRIDX_START_STRICT_RESERVED) { + DUK_HSTRING_SET_STRICT_RESERVED_WORD(h); + } + } + + DUK_DDD(DUK_DDDPRINT("interned: %!O", (duk_heaphdr *) h)); + + /* XXX: The incref macro takes a thread pointer but doesn't + * use it right now. + */ + DUK_HSTRING_INCREF(_never_referenced_, h); + +#if defined(DUK_USE_HEAPPTR16) + heap->strs16[i] = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h); +#else + heap->strs[i] = h; +#endif + } + + return 1; + + error: + return 0; +} + +DUK_LOCAL duk_bool_t duk__init_heap_thread(duk_heap *heap) { + duk_hthread *thr; + + DUK_DD(DUK_DDPRINT("heap init: alloc heap thread")); + thr = duk_hthread_alloc(heap, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_THREAD | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_THREAD)); + if (!thr) { + DUK_D(DUK_DPRINT("failed to alloc heap_thread")); + return 0; + } + thr->state = DUK_HTHREAD_STATE_INACTIVE; +#if defined(DUK_USE_HEAPPTR16) + thr->strs16 = heap->strs16; +#else + thr->strs = heap->strs; +#endif + + heap->heap_thread = thr; + DUK_HTHREAD_INCREF(thr, thr); /* Note: first argument not really used */ + + /* 'thr' is now reachable */ + + if (!duk_hthread_init_stacks(heap, thr)) { + return 0; + } + + /* XXX: this may now fail, and is not handled correctly */ + duk_hthread_create_builtin_objects(thr); + + /* default prototype (Note: 'thr' must be reachable) */ + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) thr, thr->builtins[DUK_BIDX_THREAD_PROTOTYPE]); + + return 1; +} + +#ifdef DUK_USE_DEBUG +#define DUK__DUMPSZ(t) do { \ + DUK_D(DUK_DPRINT("" #t "=%ld", (long) sizeof(t))); \ + } while (0) + +/* These is not 100% because format would need to be non-portable "long long". + * Also print out as doubles to catch cases where the "long" type is not wide + * enough; the limits will then not be printed accurately but the magnitude + * will be correct. + */ +#define DUK__DUMPLM_SIGNED_RAW(t,a,b) do { \ + DUK_D(DUK_DPRINT(t "=[%ld,%ld]=[%lf,%lf]", \ + (long) (a), (long) (b), \ + (double) (a), (double) (b))); \ + } while(0) +#define DUK__DUMPLM_UNSIGNED_RAW(t,a,b) do { \ + DUK_D(DUK_DPRINT(t "=[%lu,%lu]=[%lf,%lf]", \ + (unsigned long) (a), (unsigned long) (b), \ + (double) (a), (double) (b))); \ + } while(0) +#define DUK__DUMPLM_SIGNED(t) do { \ + DUK__DUMPLM_SIGNED_RAW("DUK_" #t "_{MIN,MAX}", DUK_##t##_MIN, DUK_##t##_MAX); \ + } while(0) +#define DUK__DUMPLM_UNSIGNED(t) do { \ + DUK__DUMPLM_UNSIGNED_RAW("DUK_" #t "_{MIN,MAX}", DUK_##t##_MIN, DUK_##t##_MAX); \ + } while(0) + +DUK_LOCAL void duk__dump_type_sizes(void) { + DUK_D(DUK_DPRINT("sizeof()")); + + /* basic platform types */ + DUK__DUMPSZ(char); + DUK__DUMPSZ(short); + DUK__DUMPSZ(int); + DUK__DUMPSZ(long); + DUK__DUMPSZ(double); + DUK__DUMPSZ(void *); + DUK__DUMPSZ(size_t); + + /* basic types from duk_features.h */ + DUK__DUMPSZ(duk_uint8_t); + DUK__DUMPSZ(duk_int8_t); + DUK__DUMPSZ(duk_uint16_t); + DUK__DUMPSZ(duk_int16_t); + DUK__DUMPSZ(duk_uint32_t); + DUK__DUMPSZ(duk_int32_t); + DUK__DUMPSZ(duk_uint64_t); + DUK__DUMPSZ(duk_int64_t); + DUK__DUMPSZ(duk_uint_least8_t); + DUK__DUMPSZ(duk_int_least8_t); + DUK__DUMPSZ(duk_uint_least16_t); + DUK__DUMPSZ(duk_int_least16_t); + DUK__DUMPSZ(duk_uint_least32_t); + DUK__DUMPSZ(duk_int_least32_t); +#if defined(DUK_USE_64BIT_OPS) + DUK__DUMPSZ(duk_uint_least64_t); + DUK__DUMPSZ(duk_int_least64_t); +#endif + DUK__DUMPSZ(duk_uint_fast8_t); + DUK__DUMPSZ(duk_int_fast8_t); + DUK__DUMPSZ(duk_uint_fast16_t); + DUK__DUMPSZ(duk_int_fast16_t); + DUK__DUMPSZ(duk_uint_fast32_t); + DUK__DUMPSZ(duk_int_fast32_t); +#if defined(DUK_USE_64BIT_OPS) + DUK__DUMPSZ(duk_uint_fast64_t); + DUK__DUMPSZ(duk_int_fast64_t); +#endif + DUK__DUMPSZ(duk_uintptr_t); + DUK__DUMPSZ(duk_intptr_t); + DUK__DUMPSZ(duk_uintmax_t); + DUK__DUMPSZ(duk_intmax_t); + DUK__DUMPSZ(duk_double_t); + + /* important chosen base types */ + DUK__DUMPSZ(duk_int_t); + DUK__DUMPSZ(duk_uint_t); + DUK__DUMPSZ(duk_int_fast_t); + DUK__DUMPSZ(duk_uint_fast_t); + DUK__DUMPSZ(duk_small_int_t); + DUK__DUMPSZ(duk_small_uint_t); + DUK__DUMPSZ(duk_small_int_fast_t); + DUK__DUMPSZ(duk_small_uint_fast_t); + + /* some derived types */ + DUK__DUMPSZ(duk_codepoint_t); + DUK__DUMPSZ(duk_ucodepoint_t); + DUK__DUMPSZ(duk_idx_t); + DUK__DUMPSZ(duk_errcode_t); + DUK__DUMPSZ(duk_uarridx_t); + + /* tval */ + DUK__DUMPSZ(duk_double_union); + DUK__DUMPSZ(duk_tval); + + /* structs from duk_forwdecl.h */ + DUK__DUMPSZ(duk_jmpbuf); + DUK__DUMPSZ(duk_heaphdr); + DUK__DUMPSZ(duk_heaphdr_string); + DUK__DUMPSZ(duk_hstring); + DUK__DUMPSZ(duk_hstring_external); + DUK__DUMPSZ(duk_hobject); + DUK__DUMPSZ(duk_hcompiledfunction); + DUK__DUMPSZ(duk_hnativefunction); + DUK__DUMPSZ(duk_hthread); + DUK__DUMPSZ(duk_hbuffer); + DUK__DUMPSZ(duk_hbuffer_fixed); + DUK__DUMPSZ(duk_hbuffer_dynamic); + DUK__DUMPSZ(duk_hbuffer_external); + DUK__DUMPSZ(duk_propaccessor); + DUK__DUMPSZ(duk_propvalue); + DUK__DUMPSZ(duk_propdesc); + DUK__DUMPSZ(duk_heap); +#if defined(DUK_USE_STRTAB_CHAIN) + DUK__DUMPSZ(duk_strtab_entry); +#endif + DUK__DUMPSZ(duk_activation); + DUK__DUMPSZ(duk_catcher); + DUK__DUMPSZ(duk_strcache); + DUK__DUMPSZ(duk_ljstate); + DUK__DUMPSZ(duk_fixedbuffer); + DUK__DUMPSZ(duk_bitdecoder_ctx); + DUK__DUMPSZ(duk_bitencoder_ctx); + DUK__DUMPSZ(duk_token); + DUK__DUMPSZ(duk_re_token); + DUK__DUMPSZ(duk_lexer_point); + DUK__DUMPSZ(duk_lexer_ctx); + DUK__DUMPSZ(duk_compiler_instr); + DUK__DUMPSZ(duk_compiler_func); + DUK__DUMPSZ(duk_compiler_ctx); + DUK__DUMPSZ(duk_re_matcher_ctx); + DUK__DUMPSZ(duk_re_compiler_ctx); +} +DUK_LOCAL void duk__dump_type_limits(void) { + DUK_D(DUK_DPRINT("limits")); + + /* basic types */ + DUK__DUMPLM_SIGNED(INT8); + DUK__DUMPLM_UNSIGNED(UINT8); + DUK__DUMPLM_SIGNED(INT_FAST8); + DUK__DUMPLM_UNSIGNED(UINT_FAST8); + DUK__DUMPLM_SIGNED(INT_LEAST8); + DUK__DUMPLM_UNSIGNED(UINT_LEAST8); + DUK__DUMPLM_SIGNED(INT16); + DUK__DUMPLM_UNSIGNED(UINT16); + DUK__DUMPLM_SIGNED(INT_FAST16); + DUK__DUMPLM_UNSIGNED(UINT_FAST16); + DUK__DUMPLM_SIGNED(INT_LEAST16); + DUK__DUMPLM_UNSIGNED(UINT_LEAST16); + DUK__DUMPLM_SIGNED(INT32); + DUK__DUMPLM_UNSIGNED(UINT32); + DUK__DUMPLM_SIGNED(INT_FAST32); + DUK__DUMPLM_UNSIGNED(UINT_FAST32); + DUK__DUMPLM_SIGNED(INT_LEAST32); + DUK__DUMPLM_UNSIGNED(UINT_LEAST32); +#if defined(DUK_USE_64BIT_OPS) + DUK__DUMPLM_SIGNED(INT64); + DUK__DUMPLM_UNSIGNED(UINT64); + DUK__DUMPLM_SIGNED(INT_FAST64); + DUK__DUMPLM_UNSIGNED(UINT_FAST64); + DUK__DUMPLM_SIGNED(INT_LEAST64); + DUK__DUMPLM_UNSIGNED(UINT_LEAST64); +#endif + DUK__DUMPLM_SIGNED(INTPTR); + DUK__DUMPLM_UNSIGNED(UINTPTR); + DUK__DUMPLM_SIGNED(INTMAX); + DUK__DUMPLM_UNSIGNED(UINTMAX); + + /* derived types */ + DUK__DUMPLM_SIGNED(INT); + DUK__DUMPLM_UNSIGNED(UINT); + DUK__DUMPLM_SIGNED(INT_FAST); + DUK__DUMPLM_UNSIGNED(UINT_FAST); + DUK__DUMPLM_SIGNED(SMALL_INT); + DUK__DUMPLM_UNSIGNED(SMALL_UINT); + DUK__DUMPLM_SIGNED(SMALL_INT_FAST); + DUK__DUMPLM_UNSIGNED(SMALL_UINT_FAST); +} +#undef DUK__DUMPSZ +#undef DUK__DUMPLM_SIGNED_RAW +#undef DUK__DUMPLM_UNSIGNED_RAW +#undef DUK__DUMPLM_SIGNED +#undef DUK__DUMPLM_UNSIGNED + +DUK_LOCAL void duk__dump_misc_options(void) { + DUK_D(DUK_DPRINT("DUK_VERSION: %ld", (long) DUK_VERSION)); + DUK_D(DUK_DPRINT("DUK_GIT_DESCRIBE: %s", DUK_GIT_DESCRIBE)); +#if defined(DUK_USE_PACKED_TVAL) + DUK_D(DUK_DPRINT("DUK_USE_PACKED_TVAL: yes")); +#else + DUK_D(DUK_DPRINT("DUK_USE_PACKED_TVAL: no")); +#endif +#if defined(DUK_USE_INTEGER_LE) + DUK_D(DUK_DPRINT("Integer endianness: little")); +#elif defined(DUK_USE_INTEGER_ME) + DUK_D(DUK_DPRINT("Integer endianness: mixed")); +#elif defined(DUK_USE_INTEGER_BE) + DUK_D(DUK_DPRINT("Integer endianness: big")); +#else + DUK_D(DUK_DPRINT("Integer endianness: ???")); +#endif +#if defined(DUK_USE_DOUBLE_LE) + DUK_D(DUK_DPRINT("IEEE double endianness: little")); +#elif defined(DUK_USE_DOUBLE_ME) + DUK_D(DUK_DPRINT("IEEE double endianness: mixed")); +#elif defined(DUK_USE_DOUBLE_BE) + DUK_D(DUK_DPRINT("IEEE double endianness: big")); +#else + DUK_D(DUK_DPRINT("IEEE double endianness: ???")); +#endif +} +#endif /* DUK_USE_DEBUG */ + +DUK_INTERNAL +duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, + duk_realloc_function realloc_func, + duk_free_function free_func, + void *heap_udata, + duk_fatal_function fatal_func) { + duk_heap *res = NULL; + + /* Silence a few global unused warnings here. */ + DUK_UNREF(duk_str_unsupported); + + DUK_D(DUK_DPRINT("allocate heap")); + + /* + * Debug dump type sizes + */ + +#ifdef DUK_USE_DEBUG + duk__dump_misc_options(); + duk__dump_type_sizes(); + duk__dump_type_limits(); +#endif + + /* + * If selftests enabled, run them as early as possible + */ +#ifdef DUK_USE_SELF_TESTS + DUK_D(DUK_DPRINT("running self tests")); + duk_selftest_run_tests(); + DUK_D(DUK_DPRINT("self tests passed")); +#endif + + /* + * Computed values (e.g. INFINITY) + */ + +#ifdef DUK_USE_COMPUTED_NAN + do { + /* Workaround for some exotic platforms where NAN is missing + * and the expression (0.0 / 0.0) does NOT result in a NaN. + * Such platforms use the global 'duk_computed_nan' which must + * be initialized at runtime. Use 'volatile' to ensure that + * the compiler will actually do the computation and not try + * to do constant folding which might result in the original + * problem. + */ + volatile double dbl1 = 0.0; + volatile double dbl2 = 0.0; + duk_computed_nan = dbl1 / dbl2; + } while (0); +#endif + +#ifdef DUK_USE_COMPUTED_INFINITY + do { + /* Similar workaround for INFINITY. */ + volatile double dbl1 = 1.0; + volatile double dbl2 = 0.0; + duk_computed_infinity = dbl1 / dbl2; + } while (0); +#endif + + /* + * Allocate heap struct + * + * Use a raw call, all macros expect the heap to be initialized + */ + + res = (duk_heap *) alloc_func(heap_udata, sizeof(duk_heap)); + if (!res) { + goto error; + } + + /* + * Zero the struct, and start initializing roughly in order + */ + + DUK_MEMZERO(res, sizeof(*res)); + + /* explicit NULL inits */ +#ifdef DUK_USE_EXPLICIT_NULL_INIT + res->heap_udata = NULL; + res->heap_allocated = NULL; +#ifdef DUK_USE_REFERENCE_COUNTING + res->refzero_list = NULL; + res->refzero_list_tail = NULL; +#endif +#ifdef DUK_USE_MARK_AND_SWEEP + res->finalize_list = NULL; +#endif + res->heap_thread = NULL; + res->curr_thread = NULL; + res->heap_object = NULL; +#if defined(DUK_USE_STRTAB_CHAIN) + /* nothing to NULL */ +#elif defined(DUK_USE_STRTAB_PROBE) +#if defined(DUK_USE_HEAPPTR16) + res->strtable16 = (duk_uint16_t *) NULL; +#else + res->strtable = (duk_hstring **) NULL; +#endif +#endif +#if defined(DUK_USE_HEAPPTR16) +/* res->strs16[] is zeroed and zero decodes to NULL, so no NULL inits. */ +#else + { + duk_small_uint_t i; + for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) { + res->strs[i] = NULL; + } + } +#endif +#if defined(DUK_USE_DEBUGGER_SUPPORT) + res->dbg_read_cb = NULL; + res->dbg_write_cb = NULL; + res->dbg_peek_cb = NULL; + res->dbg_read_flush_cb = NULL; + res->dbg_write_flush_cb = NULL; + res->dbg_udata = NULL; + res->dbg_step_thread = NULL; +#endif +#endif /* DUK_USE_EXPLICIT_NULL_INIT */ + + res->alloc_func = alloc_func; + res->realloc_func = realloc_func; + res->free_func = free_func; + res->heap_udata = heap_udata; + res->fatal_func = fatal_func; + +#if defined(DUK_USE_HEAPPTR16) + /* XXX: zero assumption */ + res->heapptr_null16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) NULL); + res->heapptr_deleted16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) DUK_STRTAB_DELETED_MARKER(res)); +#endif + + /* res->mark_and_sweep_trigger_counter == 0 -> now causes immediate GC; which is OK */ + + res->call_recursion_depth = 0; + res->call_recursion_limit = DUK_USE_NATIVE_CALL_RECLIMIT; + + /* XXX: use the pointer as a seed for now: mix in time at least */ + + /* The casts through duk_intr_pt is to avoid the following GCC warning: + * + * warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] + * + * This still generates a /Wp64 warning on VS2010 when compiling for x86. + */ + res->hash_seed = (duk_uint32_t) (duk_intptr_t) res; + res->rnd_state = (duk_uint32_t) (duk_intptr_t) res; + +#ifdef DUK_USE_EXPLICIT_NULL_INIT + res->lj.jmpbuf_ptr = NULL; +#endif + DUK_ASSERT(res->lj.type == DUK_LJ_TYPE_UNKNOWN); /* zero */ + + DUK_TVAL_SET_UNDEFINED_UNUSED(&res->lj.value1); + DUK_TVAL_SET_UNDEFINED_UNUSED(&res->lj.value2); + +#if (DUK_STRTAB_INITIAL_SIZE < DUK_UTIL_MIN_HASH_PRIME) +#error initial heap stringtable size is defined incorrectly +#endif + + /* + * Init stringtable: fixed variant + */ + +#if defined(DUK_USE_STRTAB_CHAIN) + DUK_MEMZERO(res->strtable, sizeof(duk_strtab_entry) * DUK_STRTAB_CHAIN_SIZE); +#ifdef DUK_USE_EXPLICIT_NULL_INIT + { + duk_small_uint_t i; + for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) { +#if defined(DUK_USE_HEAPPTR16) + res->strtable[i].u.str16 = res->heapptr_null16; +#else + res->strtable[i].u.str = NULL; +#endif + } + } +#endif /* DUK_USE_EXPLICIT_NULL_INIT */ +#endif /* DUK_USE_STRTAB_CHAIN */ + + /* + * Init stringtable: probe variant + */ + +#if defined(DUK_USE_STRTAB_PROBE) +#if defined(DUK_USE_HEAPPTR16) + res->strtable16 = (duk_uint16_t *) alloc_func(heap_udata, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE); + if (!res->strtable16) { + goto error; + } +#else /* DUK_USE_HEAPPTR16 */ + res->strtable = (duk_hstring **) alloc_func(heap_udata, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE); + if (!res->strtable) { + goto error; + } +#endif /* DUK_USE_HEAPPTR16 */ + res->st_size = DUK_STRTAB_INITIAL_SIZE; +#ifdef DUK_USE_EXPLICIT_NULL_INIT + { + duk_small_uint_t i; + DUK_ASSERT(res->st_size == DUK_STRTAB_INITIAL_SIZE); + for (i = 0; i < DUK_STRTAB_INITIAL_SIZE; i++) { +#if defined(DUK_USE_HEAPPTR16) + res->strtable16[i] = res->heapptr_null16; +#else + res->strtable[i] = NULL; +#endif + } + } +#else /* DUK_USE_EXPLICIT_NULL_INIT */ +#if defined(DUK_USE_HEAPPTR16) + DUK_MEMZERO(res->strtable16, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE); +#else + DUK_MEMZERO(res->strtable, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE); +#endif +#endif /* DUK_USE_EXPLICIT_NULL_INIT */ +#endif /* DUK_USE_STRTAB_PROBE */ + + /* + * Init stringcache + */ + +#ifdef DUK_USE_EXPLICIT_NULL_INIT + { + duk_small_uint_t i; + for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) { + res->strcache[i].h = NULL; + } + } +#endif + + /* XXX: error handling is incomplete. It would be cleanest if + * there was a setjmp catchpoint, so that all init code could + * freely throw errors. If that were the case, the return code + * passing here could be removed. + */ + + /* + * Init built-in strings + */ + + DUK_DD(DUK_DDPRINT("HEAP: INIT STRINGS")); + if (!duk__init_heap_strings(res)) { + goto error; + } + + /* + * Init the heap thread + */ + + DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP THREAD")); + if (!duk__init_heap_thread(res)) { + goto error; + } + + /* + * Init the heap object + */ + + DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP OBJECT")); + DUK_ASSERT(res->heap_thread != NULL); + res->heap_object = duk_hobject_alloc(res, DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT)); + if (!res->heap_object) { + goto error; + } + DUK_HOBJECT_INCREF(res->heap_thread, res->heap_object); + + /* + * All done + */ + + DUK_D(DUK_DPRINT("allocated heap: %p", (void *) res)); + return res; + + error: + DUK_D(DUK_DPRINT("heap allocation failed")); + + if (res) { + /* assumes that allocated pointers and alloc funcs are valid + * if res exists + */ + DUK_ASSERT(res->alloc_func != NULL); + DUK_ASSERT(res->realloc_func != NULL); + DUK_ASSERT(res->free_func != NULL); + duk_heap_free(res); + } + return NULL; +} +#line 1 "duk_heap_hashstring.c" +/* + * String hash computation (interning). + */ + +/* include removed: duk_internal.h */ + +/* constants for duk_hashstring() */ +#define DUK__STRHASH_SHORTSTRING 4096L +#define DUK__STRHASH_MEDIUMSTRING (256L * 1024L) +#define DUK__STRHASH_BLOCKSIZE 256L + +DUK_INTERNAL duk_uint32_t duk_heap_hashstring(duk_heap *heap, const duk_uint8_t *str, duk_size_t len) { + duk_uint32_t hash; + + /* + * Sampling long strings by byte skipping (like Lua does) is potentially + * a cache problem. Here we do 'block skipping' instead for long strings: + * hash an initial part, and then sample the rest of the string with + * reasonably sized chunks. + * + * Skip should depend on length and bound the total time to roughly + * logarithmic. + * + * With current values: + * + * 1M string => 256 * 241 = 61696 bytes (0.06M) of hashing + * 1G string => 256 * 16321 = 4178176 bytes (3.98M) of hashing + * + * After an initial part has been hashed, an offset is applied before + * starting the sampling. The initial offset is computed from the + * hash of the initial part of the string. The idea is to avoid the + * case that all long strings have certain offset ranges that are never + * sampled. + */ + + /* note: mixing len into seed improves hashing when skipping */ + duk_uint32_t str_seed = heap->hash_seed ^ ((duk_uint32_t) len); + + if (len <= DUK__STRHASH_SHORTSTRING) { + hash = duk_util_hashbytes(str, len, str_seed); + } else { + duk_size_t off; + duk_size_t skip; + + if (len <= DUK__STRHASH_MEDIUMSTRING) { + skip = (duk_size_t) (16 * DUK__STRHASH_BLOCKSIZE + DUK__STRHASH_BLOCKSIZE); + } else { + skip = (duk_size_t) (256 * DUK__STRHASH_BLOCKSIZE + DUK__STRHASH_BLOCKSIZE); + } + + hash = duk_util_hashbytes(str, (duk_size_t) DUK__STRHASH_SHORTSTRING, str_seed); + off = DUK__STRHASH_SHORTSTRING + (skip * (hash % 256)) / 256; + + /* XXX: inefficient loop */ + while (off < len) { + duk_size_t left = len - off; + duk_size_t now = (duk_size_t) (left > DUK__STRHASH_BLOCKSIZE ? DUK__STRHASH_BLOCKSIZE : left); + hash ^= duk_util_hashbytes(str + off, now, str_seed); + off += skip; + } + } + +#if defined(DUK_USE_STRHASH16) + /* Truncate to 16 bits here, so that a computed hash can be compared + * against a hash stored in a 16-bit field. + */ + hash &= 0x0000ffffUL; +#endif + return hash; +} +#line 1 "duk_heap_markandsweep.c" +/* + * Mark-and-sweep garbage collection. + */ + +/* include removed: duk_internal.h */ + +#ifdef DUK_USE_MARK_AND_SWEEP + +DUK_LOCAL_DECL void duk__mark_heaphdr(duk_heap *heap, duk_heaphdr *h); +DUK_LOCAL_DECL void duk__mark_tval(duk_heap *heap, duk_tval *tv); + +/* + * Misc + */ + +/* Select a thread for mark-and-sweep use. + * + * XXX: This needs to change later. + */ +DUK_LOCAL duk_hthread *duk__get_temp_hthread(duk_heap *heap) { + if (heap->curr_thread) { + return heap->curr_thread; + } + return heap->heap_thread; /* may be NULL, too */ +} + +/* + * Marking functions for heap types: mark children recursively + */ + +DUK_LOCAL void duk__mark_hstring(duk_heap *heap, duk_hstring *h) { + DUK_UNREF(heap); + DUK_UNREF(h); + + DUK_DDD(DUK_DDDPRINT("duk__mark_hstring: %p", (void *) h)); + DUK_ASSERT(h); + + /* nothing to process */ +} + +DUK_LOCAL void duk__mark_hobject(duk_heap *heap, duk_hobject *h) { + duk_uint_fast32_t i; + + DUK_DDD(DUK_DDDPRINT("duk__mark_hobject: %p", (void *) h)); + + DUK_ASSERT(h); + + /* XXX: use advancing pointers instead of index macros -> faster and smaller? */ + + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) { + duk_hstring *key = DUK_HOBJECT_E_GET_KEY(heap, h, i); + if (!key) { + continue; + } + duk__mark_heaphdr(heap, (duk_heaphdr *) key); + if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, h, i)) { + duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.get); + duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.set); + } else { + duk__mark_tval(heap, &DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->v); + } + } + + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) { + duk__mark_tval(heap, DUK_HOBJECT_A_GET_VALUE_PTR(heap, h, i)); + } + + /* hash part is a 'weak reference' and does not contribute */ + + duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(heap, h)); + + if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) { + duk_hcompiledfunction *f = (duk_hcompiledfunction *) h; + duk_tval *tv, *tv_end; + duk_hobject **fn, **fn_end; + + /* 'data' is reachable through every compiled function which + * contains a reference. + */ + + duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HCOMPILEDFUNCTION_GET_DATA(heap, f)); + + tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap, f); + tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(heap, f); + while (tv < tv_end) { + duk__mark_tval(heap, tv); + tv++; + } + + fn = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap, f); + fn_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap, f); + while (fn < fn_end) { + duk__mark_heaphdr(heap, (duk_heaphdr *) *fn); + fn++; + } + } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { + duk_hnativefunction *f = (duk_hnativefunction *) h; + DUK_UNREF(f); + /* nothing to mark */ + } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + duk_hbufferobject *b = (duk_hbufferobject *) h; + duk__mark_heaphdr(heap, (duk_heaphdr *) b->buf); + } else if (DUK_HOBJECT_IS_THREAD(h)) { + duk_hthread *t = (duk_hthread *) h; + duk_tval *tv; + + tv = t->valstack; + while (tv < t->valstack_end) { + duk__mark_tval(heap, tv); + tv++; + } + + for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) { + duk_activation *act = t->callstack + i; + duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_ACT_GET_FUNC(act)); + duk__mark_heaphdr(heap, (duk_heaphdr *) act->var_env); + duk__mark_heaphdr(heap, (duk_heaphdr *) act->lex_env); +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY + duk__mark_heaphdr(heap, (duk_heaphdr *) act->prev_caller); +#endif + } + +#if 0 /* nothing now */ + for (i = 0; i < (duk_uint_fast32_t) t->catchstack_top; i++) { + duk_catcher *cat = t->catchstack + i; + } +#endif + + duk__mark_heaphdr(heap, (duk_heaphdr *) t->resumer); + + /* XXX: duk_small_uint_t would be enough for this loop */ + for (i = 0; i < DUK_NUM_BUILTINS; i++) { + duk__mark_heaphdr(heap, (duk_heaphdr *) t->builtins[i]); + } + } +} + +/* recursion tracking happens here only */ +DUK_LOCAL void duk__mark_heaphdr(duk_heap *heap, duk_heaphdr *h) { + DUK_DDD(DUK_DDDPRINT("duk__mark_heaphdr %p, type %ld", + (void *) h, + (h != NULL ? (long) DUK_HEAPHDR_GET_TYPE(h) : (long) -1))); + if (!h) { + return; + } + + if (DUK_HEAPHDR_HAS_REACHABLE(h)) { + DUK_DDD(DUK_DDDPRINT("already marked reachable, skip")); + return; + } + DUK_HEAPHDR_SET_REACHABLE(h); + + if (heap->mark_and_sweep_recursion_depth >= DUK_USE_MARK_AND_SWEEP_RECLIMIT) { + /* log this with a normal debug level because this should be relatively rare */ + DUK_D(DUK_DPRINT("mark-and-sweep recursion limit reached, marking as temproot: %p", (void *) h)); + DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap); + DUK_HEAPHDR_SET_TEMPROOT(h); + return; + } + + heap->mark_and_sweep_recursion_depth++; + + switch ((int) DUK_HEAPHDR_GET_TYPE(h)) { + case DUK_HTYPE_STRING: + duk__mark_hstring(heap, (duk_hstring *) h); + break; + case DUK_HTYPE_OBJECT: + duk__mark_hobject(heap, (duk_hobject *) h); + break; + case DUK_HTYPE_BUFFER: + /* nothing to mark */ + break; + default: + DUK_D(DUK_DPRINT("attempt to mark heaphdr %p with invalid htype %ld", (void *) h, (long) DUK_HEAPHDR_GET_TYPE(h))); + DUK_UNREACHABLE(); + } + + heap->mark_and_sweep_recursion_depth--; +} + +DUK_LOCAL void duk__mark_tval(duk_heap *heap, duk_tval *tv) { + DUK_DDD(DUK_DDDPRINT("duk__mark_tval %p", (void *) tv)); + if (!tv) { + return; + } + if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { + duk__mark_heaphdr(heap, DUK_TVAL_GET_HEAPHDR(tv)); + } +} + +/* + * Mark the heap. + */ + +DUK_LOCAL void duk__mark_roots_heap(duk_heap *heap) { + duk_small_uint_t i; + + DUK_DD(DUK_DDPRINT("duk__mark_roots_heap: %p", (void *) heap)); + + duk__mark_heaphdr(heap, (duk_heaphdr *) heap->heap_thread); + duk__mark_heaphdr(heap, (duk_heaphdr *) heap->heap_object); + + for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) { + duk_hstring *h = DUK_HEAP_GET_STRING(heap, i); + duk__mark_heaphdr(heap, (duk_heaphdr *) h); + } + + duk__mark_tval(heap, &heap->lj.value1); + duk__mark_tval(heap, &heap->lj.value2); + +#if defined(DUK_USE_DEBUGGER_SUPPORT) + for (i = 0; i < heap->dbg_breakpoint_count; i++) { + duk__mark_heaphdr(heap, (duk_heaphdr *) heap->dbg_breakpoints[i].filename); + } +#endif +} + +/* + * Mark refzero_list objects. + * + * Objects on the refzero_list have no inbound references. They might have + * outbound references to objects that we might free, which would invalidate + * any references held by the refzero objects. A refzero object might also + * be rescued by refcount finalization. Refzero objects are treated as + * reachability roots to ensure they (or anything they point to) are not + * freed in mark-and-sweep. + */ + +#ifdef DUK_USE_REFERENCE_COUNTING +DUK_LOCAL void duk__mark_refzero_list(duk_heap *heap) { + duk_heaphdr *hdr; + + DUK_DD(DUK_DDPRINT("duk__mark_refzero_list: %p", (void *) heap)); + + hdr = heap->refzero_list; + while (hdr) { + duk__mark_heaphdr(heap, hdr); + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } +} +#endif + +/* + * Mark unreachable, finalizable objects. + * + * Such objects will be moved aside and their finalizers run later. They have + * to be treated as reachability roots for their properties etc to remain + * allocated. This marking is only done for unreachable values which would + * be swept later (refzero_list is thus excluded). + * + * Objects are first marked FINALIZABLE and only then marked as reachability + * roots; otherwise circular references might be handled inconsistently. + */ + +DUK_LOCAL void duk__mark_finalizable(duk_heap *heap) { + duk_hthread *thr; + duk_heaphdr *hdr; + duk_size_t count_finalizable = 0; + + DUK_DD(DUK_DDPRINT("duk__mark_finalizable: %p", (void *) heap)); + + thr = duk__get_temp_hthread(heap); + DUK_ASSERT(thr != NULL); + + hdr = heap->heap_allocated; + while (hdr) { + /* A finalizer is looked up from the object and up its prototype chain + * (which allows inherited finalizers). A prototype loop must not cause + * an error to be thrown here; duk_hobject_hasprop_raw() will ignore a + * prototype loop silently and indicate that the property doesn't exist. + */ + + if (!DUK_HEAPHDR_HAS_REACHABLE(hdr) && + DUK_HEAPHDR_GET_TYPE(hdr) == DUK_HTYPE_OBJECT && + !DUK_HEAPHDR_HAS_FINALIZED(hdr) && + duk_hobject_hasprop_raw(thr, (duk_hobject *) hdr, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) { + + /* heaphdr: + * - is not reachable + * - is an object + * - is not a finalized object + * - has a finalizer + */ + + DUK_DD(DUK_DDPRINT("unreachable heap object will be " + "finalized -> mark as finalizable " + "and treat as a reachability root: %p", + (void *) hdr)); + DUK_HEAPHDR_SET_FINALIZABLE(hdr); + count_finalizable ++; + } + + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } + + if (count_finalizable == 0) { + return; + } + + DUK_DD(DUK_DDPRINT("marked %ld heap objects as finalizable, now mark them reachable", + (long) count_finalizable)); + + hdr = heap->heap_allocated; + while (hdr) { + if (DUK_HEAPHDR_HAS_FINALIZABLE(hdr)) { + duk__mark_heaphdr(heap, hdr); + } + + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } + + /* Caller will finish the marking process if we hit a recursion limit. */ +} + +/* + * Mark objects on finalize_list. + * + */ + +DUK_LOCAL void duk__mark_finalize_list(duk_heap *heap) { + duk_heaphdr *hdr; +#ifdef DUK_USE_DEBUG + duk_size_t count_finalize_list = 0; +#endif + + DUK_DD(DUK_DDPRINT("duk__mark_finalize_list: %p", (void *) heap)); + + hdr = heap->finalize_list; + while (hdr) { + duk__mark_heaphdr(heap, hdr); + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); +#ifdef DUK_USE_DEBUG + count_finalize_list++; +#endif + } + +#ifdef DUK_USE_DEBUG + if (count_finalize_list > 0) { + DUK_D(DUK_DPRINT("marked %ld objects on the finalize_list as reachable (previous finalizer run skipped)", + (long) count_finalize_list)); + } +#endif +} + +/* + * Fallback marking handler if recursion limit is reached. + * + * Iterates 'temproots' until recursion limit is no longer hit. Note + * that temproots may reside either in heap allocated list or the + * refzero work list. This is a slow scan, but guarantees that we + * finish with a bounded C stack. + * + * Note that nodes may have been marked as temproots before this + * scan begun, OR they may have been marked during the scan (as + * we process nodes recursively also during the scan). This is + * intended behavior. + */ + +#ifdef DUK_USE_DEBUG +DUK_LOCAL void duk__handle_temproot(duk_heap *heap, duk_heaphdr *hdr, duk_size_t *count) { +#else +DUK_LOCAL void duk__handle_temproot(duk_heap *heap, duk_heaphdr *hdr) { +#endif + if (!DUK_HEAPHDR_HAS_TEMPROOT(hdr)) { + DUK_DDD(DUK_DDDPRINT("not a temp root: %p", (void *) hdr)); + return; + } + + DUK_DDD(DUK_DDDPRINT("found a temp root: %p", (void *) hdr)); + DUK_HEAPHDR_CLEAR_TEMPROOT(hdr); + DUK_HEAPHDR_CLEAR_REACHABLE(hdr); /* done so that duk__mark_heaphdr() works correctly */ + duk__mark_heaphdr(heap, hdr); + +#ifdef DUK_USE_DEBUG + (*count)++; +#endif +} + +DUK_LOCAL void duk__mark_temproots_by_heap_scan(duk_heap *heap) { + duk_heaphdr *hdr; +#ifdef DUK_USE_DEBUG + duk_size_t count; +#endif + + DUK_DD(DUK_DDPRINT("duk__mark_temproots_by_heap_scan: %p", (void *) heap)); + + while (DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap)) { + DUK_DD(DUK_DDPRINT("recursion limit reached, doing heap scan to continue from temproots")); + +#ifdef DUK_USE_DEBUG + count = 0; +#endif + DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap); + + hdr = heap->heap_allocated; + while (hdr) { +#ifdef DUK_USE_DEBUG + duk__handle_temproot(heap, hdr, &count); +#else + duk__handle_temproot(heap, hdr); +#endif + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } + + /* must also check refzero_list */ +#ifdef DUK_USE_REFERENCE_COUNTING + hdr = heap->refzero_list; + while (hdr) { +#ifdef DUK_USE_DEBUG + duk__handle_temproot(heap, hdr, &count); +#else + duk__handle_temproot(heap, hdr); +#endif + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } +#endif /* DUK_USE_REFERENCE_COUNTING */ + +#ifdef DUK_USE_DEBUG + DUK_DD(DUK_DDPRINT("temproot mark heap scan processed %ld temp roots", (long) count)); +#endif + } +} + +/* + * Finalize refcounts for heap elements just about to be freed. + * This must be done for all objects before freeing to avoid any + * stale pointer dereferences. + * + * Note that this must deduce the set of objects to be freed + * identically to duk__sweep_heap(). + */ + +#ifdef DUK_USE_REFERENCE_COUNTING +DUK_LOCAL void duk__finalize_refcounts(duk_heap *heap) { + duk_hthread *thr; + duk_heaphdr *hdr; + + thr = duk__get_temp_hthread(heap); + DUK_ASSERT(thr != NULL); + + DUK_DD(DUK_DDPRINT("duk__finalize_refcounts: heap=%p, hthread=%p", + (void *) heap, (void *) thr)); + + hdr = heap->heap_allocated; + while (hdr) { + if (!DUK_HEAPHDR_HAS_REACHABLE(hdr)) { + /* + * Unreachable object about to be swept. Finalize target refcounts + * (objects which the unreachable object points to) without doing + * refzero processing. Recursive decrefs are also prevented when + * refzero processing is disabled. + * + * Value cannot be a finalizable object, as they have been made + * temporarily reachable for this round. + */ + + DUK_DDD(DUK_DDDPRINT("unreachable object, refcount finalize before sweeping: %p", (void *) hdr)); + duk_heaphdr_refcount_finalize(thr, hdr); + } + + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } +} +#endif /* DUK_USE_REFERENCE_COUNTING */ + +/* + * Clear (reachable) flags of refzero work list. + */ + +#ifdef DUK_USE_REFERENCE_COUNTING +DUK_LOCAL void duk__clear_refzero_list_flags(duk_heap *heap) { + duk_heaphdr *hdr; + + DUK_DD(DUK_DDPRINT("duk__clear_refzero_list_flags: %p", (void *) heap)); + + hdr = heap->refzero_list; + while (hdr) { + DUK_HEAPHDR_CLEAR_REACHABLE(hdr); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(hdr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(hdr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(hdr)); + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } +} +#endif /* DUK_USE_REFERENCE_COUNTING */ + +/* + * Clear (reachable) flags of finalize_list + * + * We could mostly do in the sweep phase when we move objects from the + * heap into the finalize_list. However, if a finalizer run is skipped + * during a mark-and-sweep, the objects on the finalize_list will be marked + * reachable during the next mark-and-sweep. Since they're already on the + * finalize_list, no-one will be clearing their REACHABLE flag so we do it + * here. (This now overlaps with the sweep handling in a harmless way.) + */ + +DUK_LOCAL void duk__clear_finalize_list_flags(duk_heap *heap) { + duk_heaphdr *hdr; + + DUK_DD(DUK_DDPRINT("duk__clear_finalize_list_flags: %p", (void *) heap)); + + hdr = heap->finalize_list; + while (hdr) { + DUK_HEAPHDR_CLEAR_REACHABLE(hdr); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(hdr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(hdr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(hdr)); + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } +} + +/* + * Sweep stringtable + */ + +#if defined(DUK_USE_STRTAB_CHAIN) + +/* XXX: skip count_free w/o debug? */ +#if defined(DUK_USE_HEAPPTR16) +DUK_LOCAL void duk__sweep_string_chain16(duk_heap *heap, duk_uint16_t *slot, duk_size_t *count_keep, duk_size_t *count_free) { + duk_uint16_t h16 = *slot; + duk_hstring *h; + duk_uint16_t null16 = heap->heapptr_null16; + + if (h16 == null16) { + /* nop */ + return; + } + h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, h16); + DUK_ASSERT(h != NULL); + + if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) { + DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h); + (*count_keep)++; + } else { +#if defined(DUK_USE_REFERENCE_COUNTING) + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h) == 0); +#endif + /* deal with weak references first */ + duk_heap_strcache_string_remove(heap, (duk_hstring *) h); + *slot = null16; + + /* free inner references (these exist e.g. when external + * strings are enabled) + */ + duk_free_hstring_inner(heap, h); + DUK_FREE(heap, h); + (*count_free)++; + } +} +#else /* DUK_USE_HEAPPTR16 */ +DUK_LOCAL void duk__sweep_string_chain(duk_heap *heap, duk_hstring **slot, duk_size_t *count_keep, duk_size_t *count_free) { + duk_hstring *h = *slot; + + if (h == NULL) { + /* nop */ + return; + } + + if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) { + DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h); + (*count_keep)++; + } else { +#if defined(DUK_USE_REFERENCE_COUNTING) + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h) == 0); +#endif + /* deal with weak references first */ + duk_heap_strcache_string_remove(heap, (duk_hstring *) h); + *slot = NULL; + + /* free inner references (these exist e.g. when external + * strings are enabled) + */ + duk_free_hstring_inner(heap, h); + DUK_FREE(heap, h); + (*count_free)++; + } +} +#endif /* DUK_USE_HEAPPTR16 */ + +DUK_LOCAL void duk__sweep_stringtable_chain(duk_heap *heap, duk_size_t *out_count_keep) { + duk_strtab_entry *e; + duk_uint_fast32_t i; + duk_size_t count_free = 0; + duk_size_t count_keep = 0; + duk_size_t j, n; +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t *lst; +#else + duk_hstring **lst; +#endif + + DUK_DD(DUK_DDPRINT("duk__sweep_stringtable: %p", (void *) heap)); + + /* Non-zero refcounts should not happen for unreachable strings, + * because we refcount finalize all unreachable objects which + * should have decreased unreachable string refcounts to zero + * (even for cycles). + */ + + for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) { + e = heap->strtable + i; + if (e->listlen == 0) { +#if defined(DUK_USE_HEAPPTR16) + duk__sweep_string_chain16(heap, &e->u.str16, &count_keep, &count_free); +#else + duk__sweep_string_chain(heap, &e->u.str, &count_keep, &count_free); +#endif + } else { +#if defined(DUK_USE_HEAPPTR16) + lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16); +#else + lst = e->u.strlist; +#endif + for (j = 0, n = e->listlen; j < n; j++) { +#if defined(DUK_USE_HEAPPTR16) + duk__sweep_string_chain16(heap, lst + j, &count_keep, &count_free); +#else + duk__sweep_string_chain(heap, lst + j, &count_keep, &count_free); +#endif + } + } + } + + DUK_D(DUK_DPRINT("mark-and-sweep sweep stringtable: %ld freed, %ld kept", + (long) count_free, (long) count_keep)); + *out_count_keep = count_keep; +} +#endif /* DUK_USE_STRTAB_CHAIN */ + +#if defined(DUK_USE_STRTAB_PROBE) +DUK_LOCAL void duk__sweep_stringtable_probe(duk_heap *heap, duk_size_t *out_count_keep) { + duk_hstring *h; + duk_uint_fast32_t i; +#ifdef DUK_USE_DEBUG + duk_size_t count_free = 0; +#endif + duk_size_t count_keep = 0; + + DUK_DD(DUK_DDPRINT("duk__sweep_stringtable: %p", (void *) heap)); + + for (i = 0; i < heap->st_size; i++) { +#if defined(DUK_USE_HEAPPTR16) + h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->strtable16[i]); +#else + h = heap->strtable[i]; +#endif + if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) { + continue; + } else if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) { + DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h); + count_keep++; + continue; + } + +#ifdef DUK_USE_DEBUG + count_free++; +#endif + +#if defined(DUK_USE_REFERENCE_COUNTING) + /* Non-zero refcounts should not happen for unreachable strings, + * because we refcount finalize all unreachable objects which + * should have decreased unreachable string refcounts to zero + * (even for cycles). + */ + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h) == 0); +#endif + + DUK_DDD(DUK_DDDPRINT("sweep string, not reachable: %p", (void *) h)); + + /* deal with weak references first */ + duk_heap_strcache_string_remove(heap, (duk_hstring *) h); + + /* remove the string (mark DELETED), could also call + * duk_heap_string_remove() but that would be slow and + * pointless because we already know the slot. + */ +#if defined(DUK_USE_HEAPPTR16) + heap->strtable16[i] = heap->heapptr_deleted16; +#else + heap->strtable[i] = DUK_STRTAB_DELETED_MARKER(heap); +#endif + + /* free inner references (these exist e.g. when external + * strings are enabled) + */ + duk_free_hstring_inner(heap, (duk_hstring *) h); + + /* finally free the struct itself */ + DUK_FREE(heap, h); + } + +#ifdef DUK_USE_DEBUG + DUK_D(DUK_DPRINT("mark-and-sweep sweep stringtable: %ld freed, %ld kept", + (long) count_free, (long) count_keep)); +#endif + *out_count_keep = count_keep; +} +#endif /* DUK_USE_STRTAB_PROBE */ + +/* + * Sweep heap + */ + +DUK_LOCAL void duk__sweep_heap(duk_heap *heap, duk_int_t flags, duk_size_t *out_count_keep) { + duk_heaphdr *prev; /* last element that was left in the heap */ + duk_heaphdr *curr; + duk_heaphdr *next; +#ifdef DUK_USE_DEBUG + duk_size_t count_free = 0; + duk_size_t count_finalize = 0; + duk_size_t count_rescue = 0; +#endif + duk_size_t count_keep = 0; + + DUK_UNREF(flags); + DUK_DD(DUK_DDPRINT("duk__sweep_heap: %p", (void *) heap)); + + prev = NULL; + curr = heap->heap_allocated; + heap->heap_allocated = NULL; + while (curr) { + /* strings are never placed on the heap allocated list */ + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) != DUK_HTYPE_STRING); + + next = DUK_HEAPHDR_GET_NEXT(heap, curr); + + if (DUK_HEAPHDR_HAS_REACHABLE(curr)) { + /* + * Reachable object, keep + */ + + DUK_DDD(DUK_DDDPRINT("sweep, reachable: %p", (void *) curr)); + + if (DUK_HEAPHDR_HAS_FINALIZABLE(curr)) { + /* + * If object has been marked finalizable, move it to the + * "to be finalized" work list. It will be collected on + * the next mark-and-sweep if it is still unreachable + * after running the finalizer. + */ + + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr)); + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT); + DUK_DDD(DUK_DDDPRINT("object has finalizer, move to finalization work list: %p", (void *) curr)); + +#ifdef DUK_USE_DOUBLE_LINKED_HEAP + if (heap->finalize_list) { + DUK_HEAPHDR_SET_PREV(heap, heap->finalize_list, curr); + } + DUK_HEAPHDR_SET_PREV(heap, curr, NULL); +#endif + DUK_HEAPHDR_SET_NEXT(heap, curr, heap->finalize_list); + heap->finalize_list = curr; +#ifdef DUK_USE_DEBUG + count_finalize++; +#endif + } else { + /* + * Object will be kept; queue object back to heap_allocated (to tail) + */ + + if (DUK_HEAPHDR_HAS_FINALIZED(curr)) { + /* + * Object's finalizer was executed on last round, and + * object has been happily rescued. + */ + + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr)); + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT); + DUK_DD(DUK_DDPRINT("object rescued during mark-and-sweep finalization: %p", (void *) curr)); +#ifdef DUK_USE_DEBUG + count_rescue++; +#endif + } else { + /* + * Plain, boring reachable object. + */ + count_keep++; + } + + if (!heap->heap_allocated) { + heap->heap_allocated = curr; + } + if (prev) { + DUK_HEAPHDR_SET_NEXT(heap, prev, curr); + } +#ifdef DUK_USE_DOUBLE_LINKED_HEAP + DUK_HEAPHDR_SET_PREV(heap, curr, prev); +#endif + prev = curr; + } + + DUK_HEAPHDR_CLEAR_REACHABLE(curr); + DUK_HEAPHDR_CLEAR_FINALIZED(curr); + DUK_HEAPHDR_CLEAR_FINALIZABLE(curr); + + DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(curr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr)); + + curr = next; + } else { + /* + * Unreachable object, free + */ + + DUK_DDD(DUK_DDDPRINT("sweep, not reachable: %p", (void *) curr)); + +#if defined(DUK_USE_REFERENCE_COUNTING) + /* Non-zero refcounts should not happen because we refcount + * finalize all unreachable objects which should cancel out + * refcounts (even for cycles). + */ + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(curr) == 0); +#endif + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr)); + + if (DUK_HEAPHDR_HAS_FINALIZED(curr)) { + DUK_DDD(DUK_DDDPRINT("finalized object not rescued: %p", (void *) curr)); + } + + /* Note: object cannot be a finalizable unreachable object, as + * they have been marked temporarily reachable for this round, + * and are handled above. + */ + +#ifdef DUK_USE_DEBUG + count_free++; +#endif + + /* weak refs should be handled here, but no weak refs for + * any non-string objects exist right now. + */ + + /* free object and all auxiliary (non-heap) allocs */ + duk_heap_free_heaphdr_raw(heap, curr); + + curr = next; + } + } + if (prev) { + DUK_HEAPHDR_SET_NEXT(heap, prev, NULL); + } + +#ifdef DUK_USE_DEBUG + DUK_D(DUK_DPRINT("mark-and-sweep sweep objects (non-string): %ld freed, %ld kept, %ld rescued, %ld queued for finalization", + (long) count_free, (long) count_keep, (long) count_rescue, (long) count_finalize)); +#endif + *out_count_keep = count_keep; +} + +/* + * Run (object) finalizers in the "to be finalized" work list. + */ + +DUK_LOCAL void duk__run_object_finalizers(duk_heap *heap) { + duk_heaphdr *curr; + duk_heaphdr *next; +#ifdef DUK_USE_DEBUG + duk_size_t count = 0; +#endif + duk_hthread *thr; + + DUK_DD(DUK_DDPRINT("duk__run_object_finalizers: %p", (void *) heap)); + + thr = duk__get_temp_hthread(heap); + DUK_ASSERT(thr != NULL); + + curr = heap->finalize_list; + while (curr) { + DUK_DDD(DUK_DDDPRINT("mark-and-sweep finalize: %p", (void *) curr)); + + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT); /* only objects have finalizers */ + DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(curr)); /* flags have been already cleared */ + DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(curr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr)); + + /* run the finalizer */ + duk_hobject_run_finalizer(thr, (duk_hobject *) curr); /* must never longjmp */ + + /* mark FINALIZED, for next mark-and-sweep (will collect unless has become reachable; + * prevent running finalizer again if reachable) + */ + DUK_HEAPHDR_SET_FINALIZED(curr); + + /* queue back to heap_allocated */ + next = DUK_HEAPHDR_GET_NEXT(heap, curr); + DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, curr); + + curr = next; +#ifdef DUK_USE_DEBUG + count++; +#endif + } + + /* finalize_list will always be processed completely */ + heap->finalize_list = NULL; + +#ifdef DUK_USE_DEBUG + DUK_D(DUK_DPRINT("mark-and-sweep finalize objects: %ld finalizers called", (long) count)); +#endif +} + +/* + * Object compaction. + * + * Compaction is assumed to never throw an error. + */ + +DUK_LOCAL int duk__protected_compact_object(duk_context *ctx) { + /* XXX: for threads, compact value stack, call stack, catch stack? */ + + duk_hobject *obj = duk_get_hobject(ctx, -1); + DUK_ASSERT(obj != NULL); + duk_hobject_compact_props((duk_hthread *) ctx, obj); + return 0; +} + +#ifdef DUK_USE_DEBUG +DUK_LOCAL void duk__compact_object_list(duk_heap *heap, duk_hthread *thr, duk_heaphdr *start, duk_size_t *p_count_check, duk_size_t *p_count_compact, duk_size_t *p_count_bytes_saved) { +#else +DUK_LOCAL void duk__compact_object_list(duk_heap *heap, duk_hthread *thr, duk_heaphdr *start) { +#endif + duk_heaphdr *curr; +#ifdef DUK_USE_DEBUG + duk_size_t old_size, new_size; +#endif + duk_hobject *obj; + + DUK_UNREF(heap); + + curr = start; + while (curr) { + DUK_DDD(DUK_DDDPRINT("mark-and-sweep compact: %p", (void *) curr)); + + if (DUK_HEAPHDR_GET_TYPE(curr) != DUK_HTYPE_OBJECT) { + goto next; + } + obj = (duk_hobject *) curr; + +#ifdef DUK_USE_DEBUG + old_size = DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj), + DUK_HOBJECT_GET_ASIZE(obj), + DUK_HOBJECT_GET_HSIZE(obj)); +#endif + + DUK_DD(DUK_DDPRINT("compact object: %p", (void *) obj)); + duk_push_hobject((duk_context *) thr, obj); + /* XXX: disable error handlers for duration of compaction? */ + duk_safe_call((duk_context *) thr, duk__protected_compact_object, 1, 0); + +#ifdef DUK_USE_DEBUG + new_size = DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj), + DUK_HOBJECT_GET_ASIZE(obj), + DUK_HOBJECT_GET_HSIZE(obj)); +#endif + +#ifdef DUK_USE_DEBUG + (*p_count_compact)++; + (*p_count_bytes_saved) += (duk_size_t) (old_size - new_size); +#endif + + next: + curr = DUK_HEAPHDR_GET_NEXT(heap, curr); +#ifdef DUK_USE_DEBUG + (*p_count_check)++; +#endif + } +} + +DUK_LOCAL void duk__compact_objects(duk_heap *heap) { + /* XXX: which lists should participate? to be finalized? */ +#ifdef DUK_USE_DEBUG + duk_size_t count_check = 0; + duk_size_t count_compact = 0; + duk_size_t count_bytes_saved = 0; +#endif + duk_hthread *thr; + + DUK_DD(DUK_DDPRINT("duk__compact_objects: %p", (void *) heap)); + + thr = duk__get_temp_hthread(heap); + DUK_ASSERT(thr != NULL); + +#ifdef DUK_USE_DEBUG + duk__compact_object_list(heap, thr, heap->heap_allocated, &count_check, &count_compact, &count_bytes_saved); + duk__compact_object_list(heap, thr, heap->finalize_list, &count_check, &count_compact, &count_bytes_saved); +#ifdef DUK_USE_REFERENCE_COUNTING + duk__compact_object_list(heap, thr, heap->refzero_list, &count_check, &count_compact, &count_bytes_saved); +#endif +#else + duk__compact_object_list(heap, thr, heap->heap_allocated); + duk__compact_object_list(heap, thr, heap->finalize_list); +#ifdef DUK_USE_REFERENCE_COUNTING + duk__compact_object_list(heap, thr, heap->refzero_list); +#endif +#endif + +#ifdef DUK_USE_DEBUG + DUK_D(DUK_DPRINT("mark-and-sweep compact objects: %ld checked, %ld compaction attempts, %ld bytes saved by compaction", + (long) count_check, (long) count_compact, (long) count_bytes_saved)); +#endif +} + +/* + * Assertion helpers. + */ + +#ifdef DUK_USE_ASSERTIONS +DUK_LOCAL void duk__assert_heaphdr_flags(duk_heap *heap) { + duk_heaphdr *hdr; + + hdr = heap->heap_allocated; + while (hdr) { + DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(hdr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(hdr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(hdr)); + /* may have FINALIZED */ + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } + +#ifdef DUK_USE_REFERENCE_COUNTING + hdr = heap->refzero_list; + while (hdr) { + DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(hdr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(hdr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(hdr)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(hdr)); + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } +#endif /* DUK_USE_REFERENCE_COUNTING */ +} + +#ifdef DUK_USE_REFERENCE_COUNTING +DUK_LOCAL void duk__assert_valid_refcounts(duk_heap *heap) { + duk_heaphdr *hdr = heap->heap_allocated; + while (hdr) { + if (DUK_HEAPHDR_GET_REFCOUNT(hdr) == 0 && + DUK_HEAPHDR_HAS_FINALIZED(hdr)) { + /* An object may be in heap_allocated list with a zero + * refcount if it has just been finalized and is waiting + * to be collected by the next cycle. + */ + } else if (DUK_HEAPHDR_GET_REFCOUNT(hdr) == 0) { + /* An object may be in heap_allocated list with a zero + * refcount also if it is a temporary object created by + * a finalizer; because finalization now runs inside + * mark-and-sweep, such objects will not be queued to + * refzero_list and will thus appear here with refcount + * zero. + */ +#if 0 /* this case can no longer occur because refcount is unsigned */ + } else if (DUK_HEAPHDR_GET_REFCOUNT(hdr) < 0) { + DUK_D(DUK_DPRINT("invalid refcount: %ld, %p -> %!O", + (hdr != NULL ? (long) DUK_HEAPHDR_GET_REFCOUNT(hdr) : (long) 0), + (void *) hdr, (duk_heaphdr *) hdr)); + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(hdr) > 0); +#endif + } + hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } +} +#endif /* DUK_USE_REFERENCE_COUNTING */ +#endif /* DUK_USE_ASSERTIONS */ + +/* + * Finalizer torture. Do one fake finalizer call which causes side effects + * similar to one or more finalizers on actual objects. + */ + +#if defined(DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE) +DUK_LOCAL duk_ret_t duk__markandsweep_fake_finalizer(duk_context *ctx) { + DUK_D(DUK_DPRINT("fake mark-and-sweep torture finalizer executed")); + + /* Require a lot of stack to force a value stack grow/shrink. + * Recursive mark-and-sweep is prevented by allocation macros + * so this won't trigger another mark-and-sweep. + */ + duk_require_stack(ctx, 100000); + + /* XXX: do something to force a callstack grow/shrink, perhaps + * just a manual forced resize or a forced relocating realloc? + */ + + return 0; +} + +DUK_LOCAL void duk__markandsweep_torture_finalizer(duk_hthread *thr) { + duk_context *ctx; + duk_int_t rc; + + DUK_ASSERT(thr != NULL); + ctx = (duk_context *) thr; + + /* Avoid fake finalization when callstack limit has been reached. + * Otherwise a callstack limit error will be created, then refzero'ed. + */ + if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit || + thr->callstack_size + 2 * DUK_CALLSTACK_GROW_STEP >= thr->callstack_max /*approximate*/) { + DUK_D(DUK_DPRINT("call recursion depth reached, avoid fake mark-and-sweep torture finalizer")); + return; + } + + /* Run fake finalizer. Avoid creating unnecessary garbage. */ + duk_push_c_function(ctx, duk__markandsweep_fake_finalizer, 0 /*nargs*/); + rc = duk_pcall(ctx, 0 /*nargs*/); + DUK_UNREF(rc); /* ignored */ + duk_pop(ctx); +} +#endif /* DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE */ + +/* + * Main mark-and-sweep function. + * + * 'flags' represents the features requested by the caller. The current + * heap->mark_and_sweep_base_flags is ORed automatically into the flags; + * the base flags mask typically prevents certain mark-and-sweep operations + * to avoid trouble. + */ + +DUK_INTERNAL duk_bool_t duk_heap_mark_and_sweep(duk_heap *heap, duk_small_uint_t flags) { + duk_hthread *thr; + duk_size_t count_keep_obj; + duk_size_t count_keep_str; +#ifdef DUK_USE_VOLUNTARY_GC + duk_size_t tmp; +#endif + + /* XXX: thread selection for mark-and-sweep is currently a hack. + * If we don't have a thread, the entire mark-and-sweep is now + * skipped (although we could just skip finalizations). + */ + /* XXX: if thr != NULL, the thr may still be in the middle of + * initialization; improve the thread viability test. + */ + thr = duk__get_temp_hthread(heap); + if (thr == NULL) { + DUK_D(DUK_DPRINT("temporary hack: gc skipped because we don't have a temp thread")); + + /* reset voluntary gc trigger count */ +#ifdef DUK_USE_VOLUNTARY_GC + heap->mark_and_sweep_trigger_counter = DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP; +#endif + return 0; /* OK */ + } + + DUK_D(DUK_DPRINT("garbage collect (mark-and-sweep) starting, requested flags: 0x%08lx, effective flags: 0x%08lx", + (unsigned long) flags, (unsigned long) (flags | heap->mark_and_sweep_base_flags))); + + flags |= heap->mark_and_sweep_base_flags; + + /* + * Assertions before + */ + +#ifdef DUK_USE_ASSERTIONS + DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)); + DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap)); + DUK_ASSERT(heap->mark_and_sweep_recursion_depth == 0); + duk__assert_heaphdr_flags(heap); +#ifdef DUK_USE_REFERENCE_COUNTING + /* Note: DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) may be true; a refcount + * finalizer may trigger a mark-and-sweep. + */ + duk__assert_valid_refcounts(heap); +#endif /* DUK_USE_REFERENCE_COUNTING */ +#endif /* DUK_USE_ASSERTIONS */ + + /* + * Begin + */ + + DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap); + + /* + * Mark roots, hoping that recursion limit is not normally hit. + * If recursion limit is hit, run additional reachability rounds + * starting from "temproots" until marking is complete. + * + * Marking happens in two phases: first we mark actual reachability + * roots (and run "temproots" to complete the process). Then we + * check which objects are unreachable and are finalizable; such + * objects are marked as FINALIZABLE and marked as reachability + * (and "temproots" is run again to complete the process). + * + * The heap finalize_list must also be marked as a reachability root. + * There may be objects on the list from a previous round if the + * previous run had finalizer skip flag. + */ + + duk__mark_roots_heap(heap); /* main reachability roots */ +#ifdef DUK_USE_REFERENCE_COUNTING + duk__mark_refzero_list(heap); /* refzero_list treated as reachability roots */ +#endif + duk__mark_temproots_by_heap_scan(heap); /* temproots */ + + duk__mark_finalizable(heap); /* mark finalizable as reachability roots */ + duk__mark_finalize_list(heap); /* mark finalizer work list as reachability roots */ + duk__mark_temproots_by_heap_scan(heap); /* temproots */ + + /* + * Sweep garbage and remove marking flags, and move objects with + * finalizers to the finalizer work list. + * + * Objects to be swept need to get their refcounts finalized before + * they are swept. In other words, their target object refcounts + * need to be decreased. This has to be done before freeing any + * objects to avoid decref'ing dangling pointers (which may happen + * even without bugs, e.g. with reference loops) + * + * Because strings don't point to other heap objects, similar + * finalization is not necessary for strings. + */ + + /* XXX: more emergency behavior, e.g. find smaller hash sizes etc */ + +#ifdef DUK_USE_REFERENCE_COUNTING + duk__finalize_refcounts(heap); +#endif + duk__sweep_heap(heap, flags, &count_keep_obj); +#if defined(DUK_USE_STRTAB_CHAIN) + duk__sweep_stringtable_chain(heap, &count_keep_str); +#elif defined(DUK_USE_STRTAB_PROBE) + duk__sweep_stringtable_probe(heap, &count_keep_str); +#else +#error internal error, invalid strtab options +#endif +#ifdef DUK_USE_REFERENCE_COUNTING + duk__clear_refzero_list_flags(heap); +#endif + duk__clear_finalize_list_flags(heap); + + /* + * Object compaction (emergency only). + * + * Object compaction is a separate step after sweeping, as there is + * more free memory for it to work with. Also, currently compaction + * may insert new objects into the heap allocated list and the string + * table which we don't want to do during a sweep (the reachability + * flags of such objects would be incorrect). The objects inserted + * are currently: + * + * - a temporary duk_hbuffer for a new properties allocation + * - if array part is abandoned, string keys are interned + * + * The object insertions go to the front of the list, so they do not + * cause an infinite loop (they are not compacted). + */ + + if ((flags & DUK_MS_FLAG_EMERGENCY) && + !(flags & DUK_MS_FLAG_NO_OBJECT_COMPACTION)) { + duk__compact_objects(heap); + } + + /* + * String table resize check. + * + * Note: this may silently (and safely) fail if GC is caused by an + * allocation call in stringtable resize_hash(). Resize_hash() + * will prevent a recursive call to itself by setting the + * DUK_MS_FLAG_NO_STRINGTABLE_RESIZE in heap->mark_and_sweep_base_flags. + */ + + /* XXX: stringtable emergency compaction? */ + +#if defined(DUK_USE_MS_STRINGTABLE_RESIZE) + if (!(flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE)) { + DUK_DD(DUK_DDPRINT("resize stringtable: %p", (void *) heap)); + duk_heap_force_strtab_resize(heap); + } else { + DUK_D(DUK_DPRINT("stringtable resize skipped because DUK_MS_FLAG_NO_STRINGTABLE_RESIZE is set")); + } +#endif + + /* + * Finalize objects in the finalization work list. Finalized + * objects are queued back to heap_allocated with FINALIZED set. + * + * Since finalizers may cause arbitrary side effects, they are + * prevented during string table and object property allocation + * resizing using the DUK_MS_FLAG_NO_FINALIZERS flag in + * heap->mark_and_sweep_base_flags. In this case the objects + * remain in the finalization work list after mark-and-sweep + * exits and they may be finalized on the next pass. + * + * Finalization currently happens inside "MARKANDSWEEP_RUNNING" + * protection (no mark-and-sweep may be triggered by the + * finalizers). As a side effect: + * + * 1) an out-of-memory error inside a finalizer will not + * cause a mark-and-sweep and may cause the finalizer + * to fail unnecessarily + * + * 2) any temporary objects whose refcount decreases to zero + * during finalization will not be put into refzero_list; + * they can only be collected by another mark-and-sweep + * + * This is not optimal, but since the sweep for this phase has + * already happened, this is probably good enough for now. + */ + +#if defined(DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE) + /* Cannot simulate individual finalizers because finalize_list only + * contains objects with actual finalizers. But simulate side effects + * from finalization by doing a bogus function call and resizing the + * stacks. + */ + if (flags & DUK_MS_FLAG_NO_FINALIZERS) { + DUK_D(DUK_DPRINT("skip mark-and-sweep torture finalizer, DUK_MS_FLAG_NO_FINALIZERS is set")); + } else if (!(thr->valstack != NULL && thr->callstack != NULL && thr->catchstack != NULL)) { + DUK_D(DUK_DPRINT("skip mark-and-sweep torture finalizer, thread not yet viable")); + } else { + DUK_D(DUK_DPRINT("run mark-and-sweep torture finalizer")); + duk__markandsweep_torture_finalizer(thr); + } +#endif /* DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE */ + + if (flags & DUK_MS_FLAG_NO_FINALIZERS) { + DUK_D(DUK_DPRINT("finalizer run skipped because DUK_MS_FLAG_NO_FINALIZERS is set")); + } else { + duk__run_object_finalizers(heap); + } + + /* + * Finish + */ + + DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap); + + /* + * Assertions after + */ + +#ifdef DUK_USE_ASSERTIONS + DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)); + DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap)); + DUK_ASSERT(heap->mark_and_sweep_recursion_depth == 0); + duk__assert_heaphdr_flags(heap); +#ifdef DUK_USE_REFERENCE_COUNTING + /* Note: DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) may be true; a refcount + * finalizer may trigger a mark-and-sweep. + */ + duk__assert_valid_refcounts(heap); +#endif /* DUK_USE_REFERENCE_COUNTING */ +#endif /* DUK_USE_ASSERTIONS */ + + /* + * Reset trigger counter + */ + +#ifdef DUK_USE_VOLUNTARY_GC + tmp = (count_keep_obj + count_keep_str) / 256; + heap->mark_and_sweep_trigger_counter = (duk_int_t) ( + (tmp * DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT) + + DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD); + DUK_D(DUK_DPRINT("garbage collect (mark-and-sweep) finished: %ld objects kept, %ld strings kept, trigger reset to %ld", + (long) count_keep_obj, (long) count_keep_str, (long) heap->mark_and_sweep_trigger_counter)); +#else + DUK_D(DUK_DPRINT("garbage collect (mark-and-sweep) finished: %ld objects kept, %ld strings kept, no voluntary trigger", + (long) count_keep_obj, (long) count_keep_str)); +#endif + + return 0; /* OK */ +} + +#else /* DUK_USE_MARK_AND_SWEEP */ + +/* no mark-and-sweep gc */ + +#endif /* DUK_USE_MARK_AND_SWEEP */ +#line 1 "duk_heap_memory.c" +/* + * Memory allocation handling. + */ + +/* include removed: duk_internal.h */ + +/* + * Helpers + * + * The fast path checks are done within a macro to ensure "inlining" + * while the slow path actions use a helper (which won't typically be + * inlined in size optimized builds). + */ + +#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_VOLUNTARY_GC) +#define DUK__VOLUNTARY_PERIODIC_GC(heap) do { \ + (heap)->mark_and_sweep_trigger_counter--; \ + if ((heap)->mark_and_sweep_trigger_counter <= 0) { \ + duk__run_voluntary_gc(heap); \ + } \ + } while (0) + +DUK_LOCAL void duk__run_voluntary_gc(duk_heap *heap) { + if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) { + DUK_DD(DUK_DDPRINT("mark-and-sweep in progress -> skip voluntary mark-and-sweep now")); + } else { + duk_small_uint_t flags; + duk_bool_t rc; + + DUK_D(DUK_DPRINT("triggering voluntary mark-and-sweep")); + flags = 0; + rc = duk_heap_mark_and_sweep(heap, flags); + DUK_UNREF(rc); + } +} +#else +#define DUK__VOLUNTARY_PERIODIC_GC(heap) /* no voluntary gc */ +#endif /* DUK_USE_MARK_AND_SWEEP && DUK_USE_VOLUNTARY_GC */ + +/* + * Allocate memory with garbage collection + */ + +#ifdef DUK_USE_MARK_AND_SWEEP +DUK_INTERNAL void *duk_heap_mem_alloc(duk_heap *heap, duk_size_t size) { + void *res; + duk_bool_t rc; + duk_small_int_t i; + + DUK_ASSERT(heap != NULL); + DUK_ASSERT_DISABLE(size >= 0); + + /* + * Voluntary periodic GC (if enabled) + */ + + DUK__VOLUNTARY_PERIODIC_GC(heap); + + /* + * First attempt + */ + +#ifdef DUK_USE_GC_TORTURE + /* simulate alloc failure on every alloc (except when mark-and-sweep is running) */ + if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) { + DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first alloc attempt fails")); + res = NULL; + DUK_UNREF(res); + goto skip_attempt; + } +#endif + res = heap->alloc_func(heap->heap_udata, size); + if (res || size == 0) { + /* for zero size allocations NULL is allowed */ + return res; + } +#ifdef DUK_USE_GC_TORTURE + skip_attempt: +#endif + + DUK_D(DUK_DPRINT("first alloc attempt failed, attempt to gc and retry")); + + /* + * Avoid a GC if GC is already running. This can happen at a late + * stage in a GC when we try to e.g. resize the stringtable + * or compact objects. + */ + + if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) { + DUK_D(DUK_DPRINT("duk_heap_mem_alloc() failed, gc in progress (gc skipped), alloc size %ld", (long) size)); + return NULL; + } + + /* + * Retry with several GC attempts. Initial attempts are made without + * emergency mode; later attempts use emergency mode which minimizes + * memory allocations forcibly. + */ + + for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) { + duk_small_uint_t flags; + + flags = 0; + if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) { + flags |= DUK_MS_FLAG_EMERGENCY; + } + + rc = duk_heap_mark_and_sweep(heap, flags); + DUK_UNREF(rc); + + res = heap->alloc_func(heap->heap_udata, size); + if (res) { + DUK_D(DUK_DPRINT("duk_heap_mem_alloc() succeeded after gc (pass %ld), alloc size %ld", + (long) (i + 1), (long) size)); + return res; + } + } + + DUK_D(DUK_DPRINT("duk_heap_mem_alloc() failed even after gc, alloc size %ld", (long) size)); + return NULL; +} +#else /* DUK_USE_MARK_AND_SWEEP */ +/* + * Compared to a direct macro expansion this wrapper saves a few + * instructions because no heap dereferencing is required. + */ +DUK_INTERNAL void *duk_heap_mem_alloc(duk_heap *heap, duk_size_t size) { + DUK_ASSERT(heap != NULL); + DUK_ASSERT_DISABLE(size >= 0); + + return heap->alloc_func(heap->heap_udata, size); +} +#endif /* DUK_USE_MARK_AND_SWEEP */ + +DUK_INTERNAL void *duk_heap_mem_alloc_zeroed(duk_heap *heap, duk_size_t size) { + void *res; + + DUK_ASSERT(heap != NULL); + DUK_ASSERT_DISABLE(size >= 0); + + res = DUK_ALLOC(heap, size); + if (res) { + /* assume memset with zero size is OK */ + DUK_MEMZERO(res, size); + } + return res; +} + +/* + * Reallocate memory with garbage collection + */ + +#ifdef DUK_USE_MARK_AND_SWEEP +DUK_INTERNAL void *duk_heap_mem_realloc(duk_heap *heap, void *ptr, duk_size_t newsize) { + void *res; + duk_bool_t rc; + duk_small_int_t i; + + DUK_ASSERT(heap != NULL); + /* ptr may be NULL */ + DUK_ASSERT_DISABLE(newsize >= 0); + + /* + * Voluntary periodic GC (if enabled) + */ + + DUK__VOLUNTARY_PERIODIC_GC(heap); + + /* + * First attempt + */ + +#ifdef DUK_USE_GC_TORTURE + /* simulate alloc failure on every realloc (except when mark-and-sweep is running) */ + if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) { + DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first realloc attempt fails")); + res = NULL; + DUK_UNREF(res); + goto skip_attempt; + } +#endif + res = heap->realloc_func(heap->heap_udata, ptr, newsize); + if (res || newsize == 0) { + /* for zero size allocations NULL is allowed */ + return res; + } +#ifdef DUK_USE_GC_TORTURE + skip_attempt: +#endif + + DUK_D(DUK_DPRINT("first realloc attempt failed, attempt to gc and retry")); + + /* + * Avoid a GC if GC is already running. See duk_heap_mem_alloc(). + */ + + if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) { + DUK_D(DUK_DPRINT("duk_heap_mem_realloc() failed, gc in progress (gc skipped), alloc size %ld", (long) newsize)); + return NULL; + } + + /* + * Retry with several GC attempts. Initial attempts are made without + * emergency mode; later attempts use emergency mode which minimizes + * memory allocations forcibly. + */ + + for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) { + duk_small_uint_t flags; + + flags = 0; + if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) { + flags |= DUK_MS_FLAG_EMERGENCY; + } + + rc = duk_heap_mark_and_sweep(heap, flags); + DUK_UNREF(rc); + + res = heap->realloc_func(heap->heap_udata, ptr, newsize); + if (res || newsize == 0) { + DUK_D(DUK_DPRINT("duk_heap_mem_realloc() succeeded after gc (pass %ld), alloc size %ld", + (long) (i + 1), (long) newsize)); + return res; + } + } + + DUK_D(DUK_DPRINT("duk_heap_mem_realloc() failed even after gc, alloc size %ld", (long) newsize)); + return NULL; +} +#else /* DUK_USE_MARK_AND_SWEEP */ +/* saves a few instructions to have this wrapper (see comment on duk_heap_mem_alloc) */ +DUK_INTERNAL void *duk_heap_mem_realloc(duk_heap *heap, void *ptr, duk_size_t newsize) { + DUK_ASSERT(heap != NULL); + /* ptr may be NULL */ + DUK_ASSERT_DISABLE(newsize >= 0); + + return heap->realloc_func(heap->heap_udata, ptr, newsize); +} +#endif /* DUK_USE_MARK_AND_SWEEP */ + +/* + * Reallocate memory with garbage collection, using a callback to provide + * the current allocated pointer. This variant is used when a mark-and-sweep + * (e.g. finalizers) might change the original pointer. + */ + +#ifdef DUK_USE_MARK_AND_SWEEP +DUK_INTERNAL void *duk_heap_mem_realloc_indirect(duk_heap *heap, duk_mem_getptr cb, void *ud, duk_size_t newsize) { + void *res; + duk_bool_t rc; + duk_small_int_t i; + + DUK_ASSERT(heap != NULL); + DUK_ASSERT_DISABLE(newsize >= 0); + + /* + * Voluntary periodic GC (if enabled) + */ + + DUK__VOLUNTARY_PERIODIC_GC(heap); + + /* + * First attempt + */ + +#ifdef DUK_USE_GC_TORTURE + /* simulate alloc failure on every realloc (except when mark-and-sweep is running) */ + if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) { + DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first indirect realloc attempt fails")); + res = NULL; + DUK_UNREF(res); + goto skip_attempt; + } +#endif + res = heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize); + if (res || newsize == 0) { + /* for zero size allocations NULL is allowed */ + return res; + } +#ifdef DUK_USE_GC_TORTURE + skip_attempt: +#endif + + DUK_D(DUK_DPRINT("first indirect realloc attempt failed, attempt to gc and retry")); + + /* + * Avoid a GC if GC is already running. See duk_heap_mem_alloc(). + */ + + if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) { + DUK_D(DUK_DPRINT("duk_heap_mem_realloc_indirect() failed, gc in progress (gc skipped), alloc size %ld", (long) newsize)); + return NULL; + } + + /* + * Retry with several GC attempts. Initial attempts are made without + * emergency mode; later attempts use emergency mode which minimizes + * memory allocations forcibly. + */ + + for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) { + duk_small_uint_t flags; + +#ifdef DUK_USE_ASSERTIONS + void *ptr_pre; /* ptr before mark-and-sweep */ + void *ptr_post; +#endif + +#ifdef DUK_USE_ASSERTIONS + ptr_pre = cb(heap, ud); +#endif + flags = 0; + if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) { + flags |= DUK_MS_FLAG_EMERGENCY; + } + + rc = duk_heap_mark_and_sweep(heap, flags); + DUK_UNREF(rc); +#ifdef DUK_USE_ASSERTIONS + ptr_post = cb(heap, ud); + if (ptr_pre != ptr_post) { + /* useful for debugging */ + DUK_DD(DUK_DDPRINT("note: base pointer changed by mark-and-sweep: %p -> %p", + (void *) ptr_pre, (void *) ptr_post)); + } +#endif + + /* Note: key issue here is to re-lookup the base pointer on every attempt. + * The pointer being reallocated may change after every mark-and-sweep. + */ + + res = heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize); + if (res || newsize == 0) { + DUK_D(DUK_DPRINT("duk_heap_mem_realloc_indirect() succeeded after gc (pass %ld), alloc size %ld", + (long) (i + 1), (long) newsize)); + return res; + } + } + + DUK_D(DUK_DPRINT("duk_heap_mem_realloc_indirect() failed even after gc, alloc size %ld", (long) newsize)); + return NULL; +} +#else /* DUK_USE_MARK_AND_SWEEP */ +/* saves a few instructions to have this wrapper (see comment on duk_heap_mem_alloc) */ +DUK_INTERNAL void *duk_heap_mem_realloc_indirect(duk_heap *heap, duk_mem_getptr cb, void *ud, duk_size_t newsize) { + return heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize); +} +#endif /* DUK_USE_MARK_AND_SWEEP */ + +/* + * Free memory + */ + +#ifdef DUK_USE_MARK_AND_SWEEP +DUK_INTERNAL void duk_heap_mem_free(duk_heap *heap, void *ptr) { + DUK_ASSERT(heap != NULL); + /* ptr may be NULL */ + + /* Must behave like a no-op with NULL and any pointer returned from + * malloc/realloc with zero size. + */ + heap->free_func(heap->heap_udata, ptr); + + /* Count free operations toward triggering a GC but never actually trigger + * a GC from a free. Otherwise code which frees internal structures would + * need to put in NULLs at every turn to ensure the object is always in + * consistent state for a mark-and-sweep. + */ +#ifdef DUK_USE_VOLUNTARY_GC + heap->mark_and_sweep_trigger_counter--; +#endif +} +#else +/* saves a few instructions to have this wrapper (see comment on duk_heap_mem_alloc) */ +DUK_INTERNAL void duk_heap_mem_free(duk_heap *heap, void *ptr) { + DUK_ASSERT(heap != NULL); + /* ptr may be NULL */ + + /* Note: must behave like a no-op with NULL and any pointer + * returned from malloc/realloc with zero size. + */ + heap->free_func(heap->heap_udata, ptr); +} +#endif +#line 1 "duk_heap_misc.c" +/* + * Support functions for duk_heap. + */ + +/* include removed: duk_internal.h */ + +#if defined(DUK_USE_DOUBLE_LINKED_HEAP) && defined(DUK_USE_REFERENCE_COUNTING) +/* arbitrary remove only works with double linked heap, and is only required by + * reference counting so far. + */ +DUK_INTERNAL void duk_heap_remove_any_from_heap_allocated(duk_heap *heap, duk_heaphdr *hdr) { + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(hdr) != DUK_HTYPE_STRING); + + if (DUK_HEAPHDR_GET_PREV(heap, hdr)) { + DUK_HEAPHDR_SET_NEXT(heap, DUK_HEAPHDR_GET_PREV(heap, hdr), DUK_HEAPHDR_GET_NEXT(heap, hdr)); + } else { + heap->heap_allocated = DUK_HEAPHDR_GET_NEXT(heap, hdr); + } + if (DUK_HEAPHDR_GET_NEXT(heap, hdr)) { + DUK_HEAPHDR_SET_PREV(heap, DUK_HEAPHDR_GET_NEXT(heap, hdr), DUK_HEAPHDR_GET_PREV(heap, hdr)); + } else { + ; + } +} +#endif + +DUK_INTERNAL void duk_heap_insert_into_heap_allocated(duk_heap *heap, duk_heaphdr *hdr) { + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(hdr) != DUK_HTYPE_STRING); + +#ifdef DUK_USE_DOUBLE_LINKED_HEAP + if (heap->heap_allocated) { + DUK_ASSERT(DUK_HEAPHDR_GET_PREV(heap, heap->heap_allocated) == NULL); + DUK_HEAPHDR_SET_PREV(heap, heap->heap_allocated, hdr); + } + DUK_HEAPHDR_SET_PREV(heap, hdr, NULL); +#endif + DUK_HEAPHDR_SET_NEXT(heap, hdr, heap->heap_allocated); + heap->heap_allocated = hdr; +} + +#ifdef DUK_USE_INTERRUPT_COUNTER +DUK_INTERNAL void duk_heap_switch_thread(duk_heap *heap, duk_hthread *new_thr) { + duk_hthread *curr_thr; + + DUK_ASSERT(heap != NULL); + + if (new_thr != NULL) { + curr_thr = heap->curr_thread; + if (curr_thr == NULL) { + /* For initial entry use default value; zero forces an + * interrupt before executing the first insturction. + */ + DUK_DD(DUK_DDPRINT("switch thread, initial entry, init default interrupt counter")); + new_thr->interrupt_counter = 0; + new_thr->interrupt_init = 0; + } else { + /* Copy interrupt counter/init value state to new thread (if any). + * It's OK for new_thr to be the same as curr_thr. + */ +#if defined(DUK_USE_DEBUG) + if (new_thr != curr_thr) { + DUK_DD(DUK_DDPRINT("switch thread, not initial entry, copy interrupt counter")); + } +#endif + new_thr->interrupt_counter = curr_thr->interrupt_counter; + new_thr->interrupt_init = curr_thr->interrupt_init; + } + } else { + DUK_DD(DUK_DDPRINT("switch thread, new thread is NULL, no interrupt counter changes")); + } + + heap->curr_thread = new_thr; /* may be NULL */ +} +#endif /* DUK_USE_INTERRUPT_COUNTER */ +#line 1 "duk_heap_refcount.c" +/* + * Reference counting implementation. + */ + +/* include removed: duk_internal.h */ + +#ifdef DUK_USE_REFERENCE_COUNTING + +#ifndef DUK_USE_DOUBLE_LINKED_HEAP +#error internal error, reference counting requires a double linked heap +#endif + +/* + * Misc + */ + +DUK_LOCAL void duk__queue_refzero(duk_heap *heap, duk_heaphdr *hdr) { + /* tail insert: don't disturb head in case refzero is running */ + + if (heap->refzero_list != NULL) { + duk_heaphdr *hdr_prev; + + hdr_prev = heap->refzero_list_tail; + DUK_ASSERT(hdr_prev != NULL); + DUK_ASSERT(DUK_HEAPHDR_GET_NEXT(heap, hdr_prev) == NULL); + + DUK_HEAPHDR_SET_NEXT(heap, hdr, NULL); + DUK_HEAPHDR_SET_PREV(heap, hdr, hdr_prev); + DUK_HEAPHDR_SET_NEXT(heap, hdr_prev, hdr); + heap->refzero_list_tail = hdr; + } else { + DUK_ASSERT(heap->refzero_list_tail == NULL); + DUK_HEAPHDR_SET_NEXT(heap, hdr, NULL); + DUK_HEAPHDR_SET_PREV(heap, hdr, NULL); + heap->refzero_list = hdr; + heap->refzero_list_tail = hdr; + } +} + +/* + * Heap object refcount finalization. + * + * When an object is about to be freed, all other objects it refers to must + * be decref'd. Refcount finalization does NOT free the object or its inner + * allocations (mark-and-sweep shares these helpers), it just manipulates + * the refcounts. + * + * Note that any of the decref's may cause a refcount to drop to zero, BUT + * it will not be processed inline; instead, because refzero is already + * running, the objects will just be queued to refzero list and processed + * later. This eliminates C recursion. + */ + +DUK_LOCAL void duk__refcount_finalize_hobject(duk_hthread *thr, duk_hobject *h) { + duk_uint_fast32_t i; + + DUK_ASSERT(h); + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h) == DUK_HTYPE_OBJECT); + + /* XXX: better to get base and walk forwards? */ + + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) { + duk_hstring *key = DUK_HOBJECT_E_GET_KEY(thr->heap, h, i); + if (!key) { + continue; + } + duk_heaphdr_decref(thr, (duk_heaphdr *) key); + if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h, i)) { + duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, h, i)); + duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, h, i)); + } else { + duk_tval_decref(thr, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h, i)); + } + } + + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) { + duk_tval_decref(thr, DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, h, i)); + } + + /* hash part is a 'weak reference' and does not contribute */ + + duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h)); + + if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) { + duk_hcompiledfunction *f = (duk_hcompiledfunction *) h; + duk_tval *tv, *tv_end; + duk_hobject **funcs, **funcs_end; + + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, f) != NULL); /* compiled functions must be created 'atomically' */ + + tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, f); + tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, f); + while (tv < tv_end) { + duk_tval_decref(thr, tv); + tv++; + } + + funcs = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, f); + funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, f); + while (funcs < funcs_end) { + duk_heaphdr_decref(thr, (duk_heaphdr *) *funcs); + funcs++; + } + + duk_heaphdr_decref(thr, (duk_heaphdr *) DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, f)); + } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { + duk_hnativefunction *f = (duk_hnativefunction *) h; + DUK_UNREF(f); + /* nothing to finalize */ + } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + duk_hbufferobject *b = (duk_hbufferobject *) h; + if (b->buf) { + duk_heaphdr_decref(thr, (duk_heaphdr *) b->buf); + } + } else if (DUK_HOBJECT_IS_THREAD(h)) { + duk_hthread *t = (duk_hthread *) h; + duk_tval *tv; + + tv = t->valstack; + while (tv < t->valstack_end) { + duk_tval_decref(thr, tv); + tv++; + } + + for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) { + duk_activation *act = t->callstack + i; + duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_ACT_GET_FUNC(act)); + duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) act->var_env); + duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) act->lex_env); +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY + duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) act->prev_caller); +#endif + } + +#if 0 /* nothing now */ + for (i = 0; i < (duk_uint_fast32_t) t->catchstack_top; i++) { + duk_catcher *cat = t->catchstack + i; + } +#endif + + for (i = 0; i < DUK_NUM_BUILTINS; i++) { + duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) t->builtins[i]); + } + + duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) t->resumer); + } +} + +DUK_INTERNAL void duk_heaphdr_refcount_finalize(duk_hthread *thr, duk_heaphdr *hdr) { + DUK_ASSERT(hdr); + + switch ((int) DUK_HEAPHDR_GET_TYPE(hdr)) { + case DUK_HTYPE_OBJECT: + duk__refcount_finalize_hobject(thr, (duk_hobject *) hdr); + break; + case DUK_HTYPE_BUFFER: + /* nothing to finalize */ + break; + case DUK_HTYPE_STRING: + /* cannot happen: strings are not put into refzero list (they don't even have the next/prev pointers) */ + default: + DUK_UNREACHABLE(); + } +} + +#if defined(DUK_USE_REFZERO_FINALIZER_TORTURE) +DUK_LOCAL duk_ret_t duk__refcount_fake_finalizer(duk_context *ctx) { + DUK_UNREF(ctx); + DUK_D(DUK_DPRINT("fake refcount torture finalizer executed")); +#if 0 + DUK_DD(DUK_DDPRINT("fake torture finalizer for: %!T", duk_get_tval(ctx, 0))); +#endif + /* Require a lot of stack to force a value stack grow/shrink. */ + duk_require_stack(ctx, 100000); + + /* XXX: do something to force a callstack grow/shrink, perhaps + * just a manual forced resize? + */ + return 0; +} + +DUK_LOCAL void duk__refcount_run_torture_finalizer(duk_hthread *thr, duk_hobject *obj) { + duk_context *ctx; + duk_int_t rc; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + ctx = (duk_context *) thr; + + /* Avoid fake finalization for the duk__refcount_fake_finalizer function + * itself, otherwise we're in infinite recursion. + */ + if (DUK_HOBJECT_HAS_NATIVEFUNCTION(obj)) { + if (((duk_hnativefunction *) obj)->func == duk__refcount_fake_finalizer) { + DUK_DD(DUK_DDPRINT("avoid fake torture finalizer for duk__refcount_fake_finalizer itself")); + return; + } + } + /* Avoid fake finalization when callstack limit has been reached. + * Otherwise a callstack limit error will be created, then refzero'ed, + * and we're in an infinite loop. + */ + if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit || + thr->callstack_size + 2 * DUK_CALLSTACK_GROW_STEP >= thr->callstack_max /*approximate*/) { + DUK_D(DUK_DPRINT("call recursion depth reached, avoid fake torture finalizer")); + return; + } + + /* Run fake finalizer. Avoid creating new refzero queue entries + * so that we are not forced into a forever loop. + */ + duk_push_c_function(ctx, duk__refcount_fake_finalizer, 1 /*nargs*/); + duk_push_hobject(ctx, obj); + rc = duk_pcall(ctx, 1); + DUK_UNREF(rc); /* ignored */ + duk_pop(ctx); +} +#endif /* DUK_USE_REFZERO_FINALIZER_TORTURE */ + +/* + * Refcount memory freeing loop. + * + * Frees objects in the refzero_pending list until the list becomes + * empty. When an object is freed, its references get decref'd and + * may cause further objects to be queued for freeing. + * + * This could be expanded to allow incremental freeing: just bail out + * early and resume at a future alloc/decref/refzero. + */ + +DUK_LOCAL void duk__refzero_free_pending(duk_hthread *thr) { + duk_heaphdr *h1, *h2; + duk_heap *heap; + duk_int_t count = 0; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + heap = thr->heap; + DUK_ASSERT(heap != NULL); + + /* + * Detect recursive invocation + */ + + if (DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap)) { + DUK_DDD(DUK_DDDPRINT("refzero free running, skip run")); + return; + } + + /* + * Churn refzero_list until empty + */ + + DUK_HEAP_SET_REFZERO_FREE_RUNNING(heap); + while (heap->refzero_list) { + duk_hobject *obj; + duk_bool_t rescued = 0; + + /* + * Pick an object from the head (don't remove yet). + */ + + h1 = heap->refzero_list; + obj = (duk_hobject *) h1; + DUK_DD(DUK_DDPRINT("refzero processing %p: %!O", (void *) h1, (duk_heaphdr *) h1)); + DUK_ASSERT(DUK_HEAPHDR_GET_PREV(heap, h1) == NULL); + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(h1) == DUK_HTYPE_OBJECT); /* currently, always the case */ + +#if defined(DUK_USE_REFZERO_FINALIZER_TORTURE) + /* Torture option to shake out finalizer side effect issues: + * make a bogus function call for every finalizable object, + * essentially simulating the case where everything has a + * finalizer. + */ + DUK_DD(DUK_DDPRINT("refzero torture enabled, fake finalizer")); + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h1) == 0); + DUK_HEAPHDR_PREINC_REFCOUNT(h1); /* bump refcount to prevent refzero during finalizer processing */ + duk__refcount_run_torture_finalizer(thr, obj); /* must never longjmp */ + DUK_HEAPHDR_PREDEC_REFCOUNT(h1); /* remove artificial bump */ + DUK_ASSERT_DISABLE(h1->h_refcount >= 0); /* refcount is unsigned, so always true */ +#endif + + /* + * Finalizer check. + * + * Note: running a finalizer may have arbitrary side effects, e.g. + * queue more objects on refzero_list (tail), or even trigger a + * mark-and-sweep. + * + * Note: quick reject check should match vast majority of + * objects and must be safe (not throw any errors, ever). + */ + + /* XXX: If object has FINALIZED, it was finalized by mark-and-sweep on + * its previous run. Any point in running finalizer again here? If + * finalization semantics is changed so that finalizer is only run once, + * checking for FINALIZED would happen here. + */ + + /* A finalizer is looked up from the object and up its prototype chain + * (which allows inherited finalizers). + */ + if (duk_hobject_hasprop_raw(thr, obj, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) { + DUK_DDD(DUK_DDDPRINT("object has a finalizer, run it")); + + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h1) == 0); + DUK_HEAPHDR_PREINC_REFCOUNT(h1); /* bump refcount to prevent refzero during finalizer processing */ + + duk_hobject_run_finalizer(thr, obj); /* must never longjmp */ + + DUK_HEAPHDR_PREDEC_REFCOUNT(h1); /* remove artificial bump */ + DUK_ASSERT_DISABLE(h1->h_refcount >= 0); /* refcount is unsigned, so always true */ + + if (DUK_HEAPHDR_GET_REFCOUNT(h1) != 0) { + DUK_DDD(DUK_DDDPRINT("-> object refcount after finalization non-zero, object will be rescued")); + rescued = 1; + } else { + DUK_DDD(DUK_DDDPRINT("-> object refcount still zero after finalization, object will be freed")); + } + } + + /* Refzero head is still the same. This is the case even if finalizer + * inserted more refzero objects; they are inserted to the tail. + */ + DUK_ASSERT(h1 == heap->refzero_list); + + /* + * Remove the object from the refzero list. This cannot be done + * before a possible finalizer has been executed; the finalizer + * may trigger a mark-and-sweep, and mark-and-sweep must be able + * to traverse a complete refzero_list. + */ + + h2 = DUK_HEAPHDR_GET_NEXT(heap, h1); + if (h2) { + DUK_HEAPHDR_SET_PREV(heap, h2, NULL); /* not strictly necessary */ + heap->refzero_list = h2; + } else { + heap->refzero_list = NULL; + heap->refzero_list_tail = NULL; + } + + /* + * Rescue or free. + */ + + if (rescued) { + /* yes -> move back to heap allocated */ + DUK_DD(DUK_DDPRINT("object rescued during refcount finalization: %p", (void *) h1)); + DUK_HEAPHDR_SET_PREV(heap, h1, NULL); + DUK_HEAPHDR_SET_NEXT(heap, h1, heap->heap_allocated); + heap->heap_allocated = h1; + } else { + /* no -> decref members, then free */ + duk__refcount_finalize_hobject(thr, obj); + duk_heap_free_heaphdr_raw(heap, h1); + } + + count++; + } + DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING(heap); + + DUK_DDD(DUK_DDDPRINT("refzero processed %ld objects", (long) count)); + + /* + * Once the whole refzero cascade has been freed, check for + * a voluntary mark-and-sweep. + */ + +#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_VOLUNTARY_GC) + /* 'count' is more or less comparable to normal trigger counter update + * which happens in memory block (re)allocation. + */ + heap->mark_and_sweep_trigger_counter -= count; + if (heap->mark_and_sweep_trigger_counter <= 0) { + duk_bool_t rc; + duk_small_uint_t flags = 0; /* not emergency */ + DUK_D(DUK_DPRINT("refcount triggering mark-and-sweep")); + rc = duk_heap_mark_and_sweep(heap, flags); + DUK_UNREF(rc); + DUK_D(DUK_DPRINT("refcount triggered mark-and-sweep => rc %ld", (long) rc)); + } +#endif /* DUK_USE_MARK_AND_SWEEP && DUK_USE_VOLUNTARY_GC */ +} + +/* + * Incref and decref functions. + * + * Decref may trigger immediate refzero handling, which may free and finalize + * an arbitrary number of objects. + * + */ + +DUK_INTERNAL void duk_heaphdr_refzero(duk_hthread *thr, duk_heaphdr *h) { + duk_heap *heap; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(h != NULL); + + heap = thr->heap; + DUK_DDD(DUK_DDDPRINT("refzero %p: %!O", (void *) h, (duk_heaphdr *) h)); + +#ifdef DUK_USE_MARK_AND_SWEEP + /* + * If mark-and-sweep is running, don't process 'refzero' situations at all. + * They may happen because mark-and-sweep needs to finalize refcounts for + * each object it sweeps. Otherwise the target objects of swept objects + * would have incorrect refcounts. + * + * Note: mark-and-sweep could use a separate decref handler to avoid coming + * here at all. However, mark-and-sweep may also call finalizers, which + * can do arbitrary operations and would use this decref variant anyway. + */ + if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) { + DUK_DDD(DUK_DDDPRINT("refzero handling suppressed when mark-and-sweep running, object: %p", (void *) h)); + return; + } +#endif + + switch ((duk_small_int_t) DUK_HEAPHDR_GET_TYPE(h)) { + case DUK_HTYPE_STRING: + /* + * Strings have no internal references but do have "weak" + * references in the string cache. Also note that strings + * are not on the heap_allocated list like other heap + * elements. + */ + + duk_heap_strcache_string_remove(heap, (duk_hstring *) h); + duk_heap_string_remove(heap, (duk_hstring *) h); + duk_heap_free_heaphdr_raw(heap, h); + break; + + case DUK_HTYPE_OBJECT: + /* + * Objects have internal references. Must finalize through + * the "refzero" work list. + */ + + duk_heap_remove_any_from_heap_allocated(heap, h); + duk__queue_refzero(heap, h); + duk__refzero_free_pending(thr); + break; + + case DUK_HTYPE_BUFFER: + /* + * Buffers have no internal references. However, a dynamic + * buffer has a separate allocation for the buffer. This is + * freed by duk_heap_free_heaphdr_raw(). + */ + + duk_heap_remove_any_from_heap_allocated(heap, h); + duk_heap_free_heaphdr_raw(heap, h); + break; + + default: + DUK_D(DUK_DPRINT("invalid heap type in decref: %ld", (long) DUK_HEAPHDR_GET_TYPE(h))); + DUK_UNREACHABLE(); + } +} + +#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT) +DUK_INTERNAL void duk_tval_incref(duk_tval *tv) { + DUK_ASSERT(tv != NULL); + + if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { + duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv); + DUK_ASSERT(h != NULL); + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h)); + DUK_ASSERT_DISABLE(h->h_refcount >= 0); + DUK_HEAPHDR_PREINC_REFCOUNT(h); + } +} +#endif + +#if 0 /* unused */ +DUK_INTERNAL void duk_tval_incref_allownull(duk_tval *tv) { + if (tv == NULL) { + return; + } + if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { + duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv); + DUK_ASSERT(h != NULL); + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h)); + DUK_ASSERT_DISABLE(h->h_refcount >= 0); + DUK_HEAPHDR_PREINC_REFCOUNT(h); + } +} +#endif + +DUK_INTERNAL void duk_tval_decref(duk_hthread *thr, duk_tval *tv) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(tv != NULL); + + if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { + duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv); + DUK_ASSERT(h != NULL); + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h)); + duk_heaphdr_decref(thr, h); + } +} + +#if 0 /* unused */ +DUK_INTERNAL void duk_tval_decref_allownull(duk_hthread *thr, duk_tval *tv) { + DUK_ASSERT(thr != NULL); + + if (tv == NULL) { + return; + } + if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { + duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv); + DUK_ASSERT(h != NULL); + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h)); + duk_heaphdr_decref(thr, h); + } +} +#endif + +#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT) +DUK_INTERNAL void duk_heaphdr_incref(duk_heaphdr *h) { + DUK_ASSERT(h != NULL); + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h)); + DUK_ASSERT_DISABLE(DUK_HEAPHDR_GET_REFCOUNT(h) >= 0); + + DUK_HEAPHDR_PREINC_REFCOUNT(h); +} +#endif + +#if 0 /* unused */ +DUK_INTERNAL void duk_heaphdr_incref_allownull(duk_heaphdr *h) { + if (h == NULL) { + return; + } + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h)); + DUK_ASSERT_DISABLE(DUK_HEAPHDR_GET_REFCOUNT(h) >= 0); + + DUK_HEAPHDR_PREINC_REFCOUNT(h); +} +#endif + +DUK_INTERNAL void duk_heaphdr_decref(duk_hthread *thr, duk_heaphdr *h) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(h != NULL); + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h)); + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h) >= 1); + + if (DUK_HEAPHDR_PREDEC_REFCOUNT(h) != 0) { + return; + } + duk_heaphdr_refzero(thr, h); +} + +DUK_INTERNAL void duk_heaphdr_decref_allownull(duk_hthread *thr, duk_heaphdr *h) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + + if (h == NULL) { + return; + } + + DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h)); + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h) >= 1); + + if (DUK_HEAPHDR_PREDEC_REFCOUNT(h) != 0) { + return; + } + duk_heaphdr_refzero(thr, h); +} + +#else + +/* no refcounting */ + +#endif /* DUK_USE_REFERENCE_COUNTING */ +#line 1 "duk_heap_stringcache.c" +/* + * String cache. + * + * Provides a cache to optimize indexed string lookups. The cache keeps + * track of (byte offset, char offset) states for a fixed number of strings. + * Otherwise we'd need to scan from either end of the string, as we store + * strings in (extended) UTF-8. + */ + +/* include removed: duk_internal.h */ + +/* + * Delete references to given hstring from the heap string cache. + * + * String cache references are 'weak': they are not counted towards + * reference counts, nor serve as roots for mark-and-sweep. When an + * object is about to be freed, such references need to be removed. + */ + +DUK_INTERNAL void duk_heap_strcache_string_remove(duk_heap *heap, duk_hstring *h) { + duk_small_int_t i; + for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) { + duk_strcache *c = heap->strcache + i; + if (c->h == h) { + DUK_DD(DUK_DDPRINT("deleting weak strcache reference to hstring %p from heap %p", + (void *) h, (void *) heap)); + c->h = NULL; + + /* XXX: the string shouldn't appear twice, but we now loop to the + * end anyway; if fixed, add a looping assertion to ensure there + * is no duplicate. + */ + } + } +} + +/* + * String scanning helpers + */ + +DUK_LOCAL duk_uint8_t *duk__scan_forwards(duk_uint8_t *p, duk_uint8_t *q, duk_uint_fast32_t n) { + while (n > 0) { + for (;;) { + p++; + if (p >= q) { + return NULL; + } + if ((*p & 0xc0) != 0x80) { + break; + } + } + n--; + } + return p; +} + +DUK_LOCAL duk_uint8_t *duk__scan_backwards(duk_uint8_t *p, duk_uint8_t *q, duk_uint_fast32_t n) { + while (n > 0) { + for (;;) { + p--; + if (p < q) { + return NULL; + } + if ((*p & 0xc0) != 0x80) { + break; + } + } + n--; + } + return p; +} + +/* + * Convert char offset to byte offset + * + * Avoid using the string cache if possible: for ASCII strings byte and + * char offsets are equal and for short strings direct scanning may be + * better than using the string cache (which may evict a more important + * entry). + * + * Typing now assumes 32-bit string byte/char offsets (duk_uint_fast32_t). + * Better typing might be to use duk_size_t. + */ + +DUK_INTERNAL duk_uint_fast32_t duk_heap_strcache_offset_char2byte(duk_hthread *thr, duk_hstring *h, duk_uint_fast32_t char_offset) { + duk_heap *heap; + duk_strcache *sce; + duk_uint_fast32_t byte_offset; + duk_small_int_t i; + duk_bool_t use_cache; + duk_uint_fast32_t dist_start, dist_end, dist_sce; + duk_uint8_t *p_start; + duk_uint8_t *p_end; + duk_uint8_t *p_found; + + if (char_offset > DUK_HSTRING_GET_CHARLEN(h)) { + goto error; + } + + /* + * For ASCII strings, the answer is simple. + */ + + if (DUK_HSTRING_IS_ASCII(h)) { + /* clen == blen -> pure ascii */ + return char_offset; + } + + /* + * For non-ASCII strings, we need to scan forwards or backwards + * from some starting point. The starting point may be the start + * or end of the string, or some cached midpoint in the string + * cache. + * + * For "short" strings we simply scan without checking or updating + * the cache. For longer strings we check and update the cache as + * necessary, inserting a new cache entry if none exists. + */ + + DUK_DDD(DUK_DDDPRINT("non-ascii string %p, char_offset=%ld, clen=%ld, blen=%ld", + (void *) h, (long) char_offset, + (long) DUK_HSTRING_GET_CHARLEN(h), + (long) DUK_HSTRING_GET_BYTELEN(h))); + + heap = thr->heap; + sce = NULL; + use_cache = (DUK_HSTRING_GET_CHARLEN(h) > DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT); + + if (use_cache) { +#ifdef DUK_USE_DDDPRINT + DUK_DDD(DUK_DDDPRINT("stringcache before char2byte (using cache):")); + for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) { + duk_strcache *c = heap->strcache + i; + DUK_DDD(DUK_DDDPRINT(" [%ld] -> h=%p, cidx=%ld, bidx=%ld", + (long) i, (void *) c->h, (long) c->cidx, (long) c->bidx)); + } +#endif + + for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) { + duk_strcache *c = heap->strcache + i; + + if (c->h == h) { + sce = c; + break; + } + } + } + + /* + * Scan from shortest distance: + * - start of string + * - end of string + * - cache entry (if exists) + */ + + DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h) >= char_offset); + dist_start = char_offset; + dist_end = DUK_HSTRING_GET_CHARLEN(h) - char_offset; + dist_sce = 0; DUK_UNREF(dist_sce); /* initialize for debug prints, needed if sce==NULL */ + + p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h); + p_end = (duk_uint8_t *) (p_start + DUK_HSTRING_GET_BYTELEN(h)); + p_found = NULL; + + if (sce) { + if (char_offset >= sce->cidx) { + dist_sce = char_offset - sce->cidx; + if ((dist_sce <= dist_start) && (dist_sce <= dist_end)) { + DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, " + "dist_start=%ld, dist_end=%ld, dist_sce=%ld => " + "scan forwards from sce", + (long) use_cache, (void *) (sce ? sce->h : NULL), + (sce ? (long) sce->cidx : (long) -1), + (sce ? (long) sce->bidx : (long) -1), + (long) dist_start, (long) dist_end, (long) dist_sce)); + + p_found = duk__scan_forwards(p_start + sce->bidx, + p_end, + dist_sce); + goto scan_done; + } + } else { + dist_sce = sce->cidx - char_offset; + if ((dist_sce <= dist_start) && (dist_sce <= dist_end)) { + DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, " + "dist_start=%ld, dist_end=%ld, dist_sce=%ld => " + "scan backwards from sce", + (long) use_cache, (void *) (sce ? sce->h : NULL), + (sce ? (long) sce->cidx : (long) -1), + (sce ? (long) sce->bidx : (long) -1), + (long) dist_start, (long) dist_end, (long) dist_sce)); + + p_found = duk__scan_backwards(p_start + sce->bidx, + p_start, + dist_sce); + goto scan_done; + } + } + } + + /* no sce, or sce scan not best */ + + if (dist_start <= dist_end) { + DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, " + "dist_start=%ld, dist_end=%ld, dist_sce=%ld => " + "scan forwards from string start", + (long) use_cache, (void *) (sce ? sce->h : NULL), + (sce ? (long) sce->cidx : (long) -1), + (sce ? (long) sce->bidx : (long) -1), + (long) dist_start, (long) dist_end, (long) dist_sce)); + + p_found = duk__scan_forwards(p_start, + p_end, + dist_start); + } else { + DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, " + "dist_start=%ld, dist_end=%ld, dist_sce=%ld => " + "scan backwards from string end", + (long) use_cache, (void *) (sce ? sce->h : NULL), + (sce ? (long) sce->cidx : (long) -1), + (sce ? (long) sce->bidx : (long) -1), + (long) dist_start, (long) dist_end, (long) dist_sce)); + + p_found = duk__scan_backwards(p_end, + p_start, + dist_end); + } + + scan_done: + + if (!p_found) { + /* Scan error: this shouldn't normally happen; it could happen if + * string is not valid UTF-8 data, and clen/blen are not consistent + * with the scanning algorithm. + */ + goto error; + } + + DUK_ASSERT(p_found >= p_start); + DUK_ASSERT(p_found <= p_end); /* may be equal */ + byte_offset = (duk_uint32_t) (p_found - p_start); + + DUK_DDD(DUK_DDDPRINT("-> string %p, cidx %ld -> bidx %ld", + (void *) h, (long) char_offset, (long) byte_offset)); + + /* + * Update cache entry (allocating if necessary), and move the + * cache entry to the first place (in an "LRU" policy). + */ + + if (use_cache) { + /* update entry, allocating if necessary */ + if (!sce) { + sce = heap->strcache + DUK_HEAP_STRCACHE_SIZE - 1; /* take last entry */ + sce->h = h; + } + DUK_ASSERT(sce != NULL); + sce->bidx = (duk_uint32_t) (p_found - p_start); + sce->cidx = (duk_uint32_t) char_offset; + + /* LRU: move our entry to first */ + if (sce > &heap->strcache[0]) { + /* + * A C + * B A + * C <- sce ==> B + * D D + */ + duk_strcache tmp; + + tmp = *sce; + DUK_MEMMOVE((void *) (&heap->strcache[1]), + (void *) (&heap->strcache[0]), + (size_t) (((char *) sce) - ((char *) &heap->strcache[0]))); + heap->strcache[0] = tmp; + + /* 'sce' points to the wrong entry here, but is no longer used */ + } +#ifdef DUK_USE_DDDPRINT + DUK_DDD(DUK_DDDPRINT("stringcache after char2byte (using cache):")); + for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) { + duk_strcache *c = heap->strcache + i; + DUK_DDD(DUK_DDDPRINT(" [%ld] -> h=%p, cidx=%ld, bidx=%ld", + (long) i, (void *) c->h, (long) c->cidx, (long) c->bidx)); + } +#endif + } + + return byte_offset; + + error: + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "string scan error"); + return 0; +} +#line 1 "duk_heap_stringtable.c" +/* + * Heap stringtable handling, string interning. + */ + +/* include removed: duk_internal.h */ + +#if defined(DUK_USE_STRTAB_PROBE) +#define DUK__HASH_INITIAL(hash,h_size) DUK_STRTAB_HASH_INITIAL((hash),(h_size)) +#define DUK__HASH_PROBE_STEP(hash) DUK_STRTAB_HASH_PROBE_STEP((hash)) +#define DUK__DELETED_MARKER(heap) DUK_STRTAB_DELETED_MARKER((heap)) +#endif + +/* + * Create a hstring and insert into the heap. The created object + * is directly garbage collectable with reference count zero. + * + * The caller must place the interned string into the stringtable + * immediately (without chance of a longjmp); otherwise the string + * is lost. + */ + +DUK_LOCAL +duk_hstring *duk__alloc_init_hstring(duk_heap *heap, + const duk_uint8_t *str, + duk_uint32_t blen, + duk_uint32_t strhash, + const duk_uint8_t *extdata) { + duk_hstring *res = NULL; + duk_uint8_t *data; + duk_size_t alloc_size; + duk_uarridx_t dummy; + duk_uint32_t clen; + +#if defined(DUK_USE_STRLEN16) + /* If blen <= 0xffffUL, clen is also guaranteed to be <= 0xffffUL. */ + if (blen > 0xffffUL) { + DUK_D(DUK_DPRINT("16-bit string blen/clen active and blen over 16 bits, reject intern")); + return NULL; + } +#endif + + if (extdata) { + alloc_size = (duk_size_t) sizeof(duk_hstring_external); + res = (duk_hstring *) DUK_ALLOC(heap, alloc_size); + if (!res) { + goto alloc_error; + } + DUK_MEMZERO(res, sizeof(duk_hstring_external)); +#ifdef DUK_USE_EXPLICIT_NULL_INIT + DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr); +#endif + DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, DUK_HSTRING_FLAG_EXTDATA); + + ((duk_hstring_external *) res)->extdata = extdata; + } else { + /* NUL terminate for convenient C access */ + alloc_size = (duk_size_t) (sizeof(duk_hstring) + blen + 1); + res = (duk_hstring *) DUK_ALLOC(heap, alloc_size); + if (!res) { + goto alloc_error; + } + DUK_MEMZERO(res, sizeof(duk_hstring)); +#ifdef DUK_USE_EXPLICIT_NULL_INIT + DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr); +#endif + DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, 0); + + data = (duk_uint8_t *) (res + 1); + DUK_MEMCPY(data, str, blen); + data[blen] = (duk_uint8_t) 0; + } + + if (duk_js_to_arrayindex_raw_string(str, blen, &dummy)) { + DUK_HSTRING_SET_ARRIDX(res); + } + + /* All strings beginning with 0xff are treated as "internal", + * even strings interned by the user. This allows user code to + * create internal properties too, and makes behavior consistent + * in case user code happens to use a string also used by Duktape + * (such as string has already been interned and has the 'internal' + * flag set). + */ + if (blen > 0 && str[0] == (duk_uint8_t) 0xff) { + DUK_HSTRING_SET_INTERNAL(res); + } + + DUK_HSTRING_SET_HASH(res, strhash); + DUK_HSTRING_SET_BYTELEN(res, blen); + clen = (duk_uint32_t) duk_unicode_unvalidated_utf8_length(str, (duk_size_t) blen); + DUK_ASSERT(clen <= blen); + DUK_HSTRING_SET_CHARLEN(res, clen); + + DUK_DDD(DUK_DDDPRINT("interned string, hash=0x%08lx, blen=%ld, clen=%ld, has_arridx=%ld, has_extdata=%ld", + (unsigned long) DUK_HSTRING_GET_HASH(res), + (long) DUK_HSTRING_GET_BYTELEN(res), + (long) DUK_HSTRING_GET_CHARLEN(res), + (long) DUK_HSTRING_HAS_ARRIDX(res) ? 1 : 0, + (long) DUK_HSTRING_HAS_EXTDATA(res) ? 1 : 0)); + + return res; + + alloc_error: + DUK_FREE(heap, res); + return NULL; +} + +/* + * String table algorithm: fixed size string table with array chaining + * + * The top level string table has a fixed size, with each slot holding + * either NULL, string pointer, or pointer to a separately allocated + * string pointer list. + * + * This is good for low memory environments using a pool allocator: the + * top level allocation has a fixed size and the pointer lists have quite + * small allocation size, which further matches the typical pool sizes + * needed by objects, strings, property tables, etc. + */ + +#if defined(DUK_USE_STRTAB_CHAIN) + +#if defined(DUK_USE_HEAPPTR16) +DUK_LOCAL duk_bool_t duk__insert_hstring_chain(duk_heap *heap, duk_hstring *h) { + duk_small_uint_t slotidx; + duk_strtab_entry *e; + duk_uint16_t *lst; + duk_uint16_t *new_lst; + duk_size_t i, n; + duk_uint16_t null16 = heap->heapptr_null16; + duk_uint16_t h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h); + + DUK_ASSERT(heap != NULL); + DUK_ASSERT(h != NULL); + + slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE; + DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE); + + e = heap->strtable + slotidx; + if (e->listlen == 0) { + if (e->u.str16 == null16) { + e->u.str16 = h16; + } else { + /* Now two entries in the same slot, alloc list */ + lst = (duk_uint16_t *) DUK_ALLOC(heap, sizeof(duk_uint16_t) * 2); + if (lst == NULL) { + return 1; /* fail */ + } + lst[0] = e->u.str16; + lst[1] = h16; + e->u.strlist16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) lst); + e->listlen = 2; + } + } else { + DUK_ASSERT(e->u.strlist16 != null16); + lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16); + DUK_ASSERT(lst != NULL); + for (i = 0, n = e->listlen; i < n; i++) { + if (lst[i] == null16) { + lst[i] = h16; + return 0; + } + } + + if (e->listlen + 1 == 0) { + /* Overflow, relevant mainly when listlen is 16 bits. */ + return 1; /* fail */ + } + + new_lst = (duk_uint16_t *) DUK_REALLOC(heap, lst, sizeof(duk_uint16_t) * (e->listlen + 1)); + if (new_lst == NULL) { + return 1; /* fail */ + } + new_lst[e->listlen++] = h16; + e->u.strlist16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) new_lst); + } + return 0; +} +#else /* DUK_USE_HEAPPTR16 */ +DUK_LOCAL duk_bool_t duk__insert_hstring_chain(duk_heap *heap, duk_hstring *h) { + duk_small_uint_t slotidx; + duk_strtab_entry *e; + duk_hstring **lst; + duk_hstring **new_lst; + duk_size_t i, n; + + DUK_ASSERT(heap != NULL); + DUK_ASSERT(h != NULL); + + slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE; + DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE); + + e = heap->strtable + slotidx; + if (e->listlen == 0) { + if (e->u.str == NULL) { + e->u.str = h; + } else { + /* Now two entries in the same slot, alloc list */ + lst = (duk_hstring **) DUK_ALLOC(heap, sizeof(duk_hstring *) * 2); + if (lst == NULL) { + return 1; /* fail */ + } + lst[0] = e->u.str; + lst[1] = h; + e->u.strlist = lst; + e->listlen = 2; + } + } else { + DUK_ASSERT(e->u.strlist != NULL); + lst = e->u.strlist; + for (i = 0, n = e->listlen; i < n; i++) { + if (lst[i] == NULL) { + lst[i] = h; + return 0; + } + } + + if (e->listlen + 1 == 0) { + /* Overflow, relevant mainly when listlen is 16 bits. */ + return 1; /* fail */ + } + + new_lst = (duk_hstring **) DUK_REALLOC(heap, e->u.strlist, sizeof(duk_hstring *) * (e->listlen + 1)); + if (new_lst == NULL) { + return 1; /* fail */ + } + new_lst[e->listlen++] = h; + e->u.strlist = new_lst; + } + return 0; +} +#endif /* DUK_USE_HEAPPTR16 */ + +#if defined(DUK_USE_HEAPPTR16) +DUK_LOCAL duk_hstring *duk__find_matching_string_chain(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) { + duk_small_uint_t slotidx; + duk_strtab_entry *e; + duk_uint16_t *lst; + duk_size_t i, n; + duk_uint16_t null16 = heap->heapptr_null16; + + DUK_ASSERT(heap != NULL); + + slotidx = strhash % DUK_STRTAB_CHAIN_SIZE; + DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE); + + e = heap->strtable + slotidx; + if (e->listlen == 0) { + if (e->u.str16 != null16) { + duk_hstring *h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.str16); + DUK_ASSERT(h != NULL); + if (DUK_HSTRING_GET_BYTELEN(h) == blen && + DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(h), blen) == 0) { + return h; + } + } + } else { + DUK_ASSERT(e->u.strlist16 != null16); + lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16); + DUK_ASSERT(lst != NULL); + for (i = 0, n = e->listlen; i < n; i++) { + if (lst[i] != null16) { + duk_hstring *h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, lst[i]); + DUK_ASSERT(h != NULL); + if (DUK_HSTRING_GET_BYTELEN(h) == blen && + DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(h), blen) == 0) { + return h; + } + } + } + } + + return NULL; +} +#else /* DUK_USE_HEAPPTR16 */ +DUK_LOCAL duk_hstring *duk__find_matching_string_chain(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) { + duk_small_uint_t slotidx; + duk_strtab_entry *e; + duk_hstring **lst; + duk_size_t i, n; + + DUK_ASSERT(heap != NULL); + + slotidx = strhash % DUK_STRTAB_CHAIN_SIZE; + DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE); + + e = heap->strtable + slotidx; + if (e->listlen == 0) { + if (e->u.str != NULL && + DUK_HSTRING_GET_BYTELEN(e->u.str) == blen && + DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(e->u.str), blen) == 0) { + return e->u.str; + } + } else { + DUK_ASSERT(e->u.strlist != NULL); + lst = e->u.strlist; + for (i = 0, n = e->listlen; i < n; i++) { + if (lst[i] != NULL && + DUK_HSTRING_GET_BYTELEN(lst[i]) == blen && + DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(lst[i]), blen) == 0) { + return lst[i]; + } + } + } + + return NULL; +} +#endif /* DUK_USE_HEAPPTR16 */ + +#if defined(DUK_USE_HEAPPTR16) +DUK_LOCAL void duk__remove_matching_hstring_chain(duk_heap *heap, duk_hstring *h) { + duk_small_uint_t slotidx; + duk_strtab_entry *e; + duk_uint16_t *lst; + duk_size_t i, n; + duk_uint16_t h16; + duk_uint16_t null16 = heap->heapptr_null16; + + DUK_ASSERT(heap != NULL); + DUK_ASSERT(h != NULL); + + slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE; + DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE); + + DUK_ASSERT(h != NULL); + h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h); + + e = heap->strtable + slotidx; + if (e->listlen == 0) { + if (e->u.str16 == h16) { + e->u.str16 = null16; + return; + } + } else { + DUK_ASSERT(e->u.strlist16 != null16); + lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16); + DUK_ASSERT(lst != NULL); + for (i = 0, n = e->listlen; i < n; i++) { + if (lst[i] == h16) { + lst[i] = null16; + return; + } + } + } + + DUK_D(DUK_DPRINT("failed to find string that should be in stringtable")); + DUK_UNREACHABLE(); + return; +} +#else /* DUK_USE_HEAPPTR16 */ +DUK_LOCAL void duk__remove_matching_hstring_chain(duk_heap *heap, duk_hstring *h) { + duk_small_uint_t slotidx; + duk_strtab_entry *e; + duk_hstring **lst; + duk_size_t i, n; + + DUK_ASSERT(heap != NULL); + DUK_ASSERT(h != NULL); + + slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE; + DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE); + + e = heap->strtable + slotidx; + if (e->listlen == 0) { + DUK_ASSERT(h != NULL); + if (e->u.str == h) { + e->u.str = NULL; + return; + } + } else { + DUK_ASSERT(e->u.strlist != NULL); + lst = e->u.strlist; + for (i = 0, n = e->listlen; i < n; i++) { + DUK_ASSERT(h != NULL); + if (lst[i] == h) { + lst[i] = NULL; + return; + } + } + } + + DUK_D(DUK_DPRINT("failed to find string that should be in stringtable")); + DUK_UNREACHABLE(); + return; +} +#endif /* DUK_USE_HEAPPTR16 */ + +#if defined(DUK_USE_DEBUG) +DUK_INTERNAL void duk_heap_dump_strtab(duk_heap *heap) { + duk_strtab_entry *e; + duk_small_uint_t i; + duk_size_t j, n, used; +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t *lst; + duk_uint16_t null16 = heap->heapptr_null16; +#else + duk_hstring **lst; +#endif + + DUK_ASSERT(heap != NULL); + + for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) { + e = heap->strtable + i; + + if (e->listlen == 0) { +#if defined(DUK_USE_HEAPPTR16) + DUK_DD(DUK_DDPRINT("[%03d] -> plain %d", (int) i, (int) (e->u.str16 != null16 ? 1 : 0))); +#else + DUK_DD(DUK_DDPRINT("[%03d] -> plain %d", (int) i, (int) (e->u.str ? 1 : 0))); +#endif + } else { + used = 0; +#if defined(DUK_USE_HEAPPTR16) + lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16); +#else + lst = e->u.strlist; +#endif + DUK_ASSERT(lst != NULL); + for (j = 0, n = e->listlen; j < n; j++) { +#if defined(DUK_USE_HEAPPTR16) + if (lst[j] != null16) { +#else + if (lst[j] != NULL) { +#endif + used++; + } + } + DUK_DD(DUK_DDPRINT("[%03d] -> array %d/%d", (int) i, (int) used, (int) e->listlen)); + } + } +} +#endif /* DUK_USE_DEBUG */ + +#endif /* DUK_USE_STRTAB_CHAIN */ + +/* + * String table algorithm: closed hashing with a probe sequence + * + * This is the default algorithm and works fine for environments with + * minimal memory constraints. + */ + +#if defined(DUK_USE_STRTAB_PROBE) + +/* Count actually used (non-NULL, non-DELETED) entries. */ +DUK_LOCAL duk_int_t duk__count_used_probe(duk_heap *heap) { + duk_int_t res = 0; + duk_uint_fast32_t i, n; +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t null16 = heap->heapptr_null16; + duk_uint16_t deleted16 = heap->heapptr_deleted16; +#endif + + n = (duk_uint_fast32_t) heap->st_size; + for (i = 0; i < n; i++) { +#if defined(DUK_USE_HEAPPTR16) + if (heap->strtable16[i] != null16 && heap->strtable16[i] != deleted16) { +#else + if (heap->strtable[i] != NULL && heap->strtable[i] != DUK__DELETED_MARKER(heap)) { +#endif + res++; + } + } + return res; +} + +#if defined(DUK_USE_HEAPPTR16) +DUK_LOCAL void duk__insert_hstring_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, duk_uint32_t *p_used, duk_hstring *h) { +#else +DUK_LOCAL void duk__insert_hstring_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_uint32_t *p_used, duk_hstring *h) { +#endif + duk_uint32_t i; + duk_uint32_t step; +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t null16 = heap->heapptr_null16; + duk_uint16_t deleted16 = heap->heapptr_deleted16; +#endif + + DUK_ASSERT(size > 0); + + i = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(h), size); + step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(h)); + for (;;) { +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t e16 = entries16[i]; +#else + duk_hstring *e = entries[i]; +#endif + +#if defined(DUK_USE_HEAPPTR16) + /* XXX: could check for e16 == 0 because NULL is guaranteed to + * encode to zero. + */ + if (e16 == null16) { +#else + if (e == NULL) { +#endif + DUK_DDD(DUK_DDDPRINT("insert hit (null): %ld", (long) i)); +#if defined(DUK_USE_HEAPPTR16) + entries16[i] = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h); +#else + entries[i] = h; +#endif + (*p_used)++; + break; +#if defined(DUK_USE_HEAPPTR16) + } else if (e16 == deleted16) { +#else + } else if (e == DUK__DELETED_MARKER(heap)) { +#endif + /* st_used remains the same, DELETED is counted as used */ + DUK_DDD(DUK_DDDPRINT("insert hit (deleted): %ld", (long) i)); +#if defined(DUK_USE_HEAPPTR16) + entries16[i] = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h); +#else + entries[i] = h; +#endif + break; + } + DUK_DDD(DUK_DDDPRINT("insert miss: %ld", (long) i)); + i = (i + step) % size; + + /* looping should never happen */ + DUK_ASSERT(i != DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(h), size)); + } +} + +#if defined(DUK_USE_HEAPPTR16) +DUK_LOCAL duk_hstring *duk__find_matching_string_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) { +#else +DUK_LOCAL duk_hstring *duk__find_matching_string_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) { +#endif + duk_uint32_t i; + duk_uint32_t step; + + DUK_ASSERT(size > 0); + + i = DUK__HASH_INITIAL(strhash, size); + step = DUK__HASH_PROBE_STEP(strhash); + for (;;) { + duk_hstring *e; +#if defined(DUK_USE_HEAPPTR16) + e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, entries16[i]); +#else + e = entries[i]; +#endif + + if (!e) { + return NULL; + } + if (e != DUK__DELETED_MARKER(heap) && DUK_HSTRING_GET_BYTELEN(e) == blen) { + if (DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(e), blen) == 0) { + DUK_DDD(DUK_DDDPRINT("find matching hit: %ld (step %ld, size %ld)", + (long) i, (long) step, (long) size)); + return e; + } + } + DUK_DDD(DUK_DDDPRINT("find matching miss: %ld (step %ld, size %ld)", + (long) i, (long) step, (long) size)); + i = (i + step) % size; + + /* looping should never happen */ + DUK_ASSERT(i != DUK__HASH_INITIAL(strhash, size)); + } + DUK_UNREACHABLE(); +} + +#if defined(DUK_USE_HEAPPTR16) +DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, duk_hstring *h) { +#else +DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_hstring *h) { +#endif + duk_uint32_t i; + duk_uint32_t step; + duk_uint32_t hash; +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t null16 = heap->heapptr_null16; + duk_uint16_t h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h); +#endif + + DUK_ASSERT(size > 0); + + hash = DUK_HSTRING_GET_HASH(h); + i = DUK__HASH_INITIAL(hash, size); + step = DUK__HASH_PROBE_STEP(hash); + for (;;) { +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t e16 = entries16[i]; +#else + duk_hstring *e = entries[i]; +#endif + +#if defined(DUK_USE_HEAPPTR16) + if (e16 == null16) { +#else + if (!e) { +#endif + DUK_UNREACHABLE(); + break; + } +#if defined(DUK_USE_HEAPPTR16) + if (e16 == h16) { +#else + if (e == h) { +#endif + /* st_used remains the same, DELETED is counted as used */ + DUK_DDD(DUK_DDDPRINT("free matching hit: %ld", (long) i)); +#if defined(DUK_USE_HEAPPTR16) + entries16[i] = heap->heapptr_deleted16; +#else + entries[i] = DUK__DELETED_MARKER(heap); +#endif + break; + } + + DUK_DDD(DUK_DDDPRINT("free matching miss: %ld", (long) i)); + i = (i + step) % size; + + /* looping should never happen */ + DUK_ASSERT(i != DUK__HASH_INITIAL(hash, size)); + } +} + +DUK_LOCAL duk_bool_t duk__resize_strtab_raw_probe(duk_heap *heap, duk_uint32_t new_size) { +#ifdef DUK_USE_MARK_AND_SWEEP + duk_small_uint_t prev_mark_and_sweep_base_flags; +#endif +#ifdef DUK_USE_DEBUG + duk_uint32_t old_used = heap->st_used; +#endif + duk_uint32_t old_size = heap->st_size; +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t *old_entries = heap->strtable16; + duk_uint16_t *new_entries = NULL; +#else + duk_hstring **old_entries = heap->strtable; + duk_hstring **new_entries = NULL; +#endif + duk_uint32_t new_used = 0; + duk_uint32_t i; + +#ifdef DUK_USE_DEBUG + DUK_UNREF(old_used); /* unused with some debug level combinations */ +#endif + +#ifdef DUK_USE_DDDPRINT + DUK_DDD(DUK_DDDPRINT("attempt to resize stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load", + (long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used, + (long) (((double) old_used) / ((double) old_size) * 100.0), + (long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) duk__count_used_probe(heap), + (long) (((double) duk__count_used_probe(heap)) / ((double) new_size) * 100.0))); +#endif + + DUK_ASSERT(new_size > (duk_uint32_t) duk__count_used_probe(heap)); /* required for rehash to succeed, equality not that useful */ + DUK_ASSERT(old_entries); +#ifdef DUK_USE_MARK_AND_SWEEP + DUK_ASSERT((heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE) == 0); +#endif + + /* + * The attempt to allocate may cause a GC. Such a GC must not attempt to resize + * the stringtable (though it can be swept); finalizer execution and object + * compaction must also be postponed to avoid the pressure to add strings to the + * string table. + */ + +#ifdef DUK_USE_MARK_AND_SWEEP + prev_mark_and_sweep_base_flags = heap->mark_and_sweep_base_flags; + heap->mark_and_sweep_base_flags |= \ + DUK_MS_FLAG_NO_STRINGTABLE_RESIZE | /* avoid recursive call here */ + DUK_MS_FLAG_NO_FINALIZERS | /* avoid pressure to add/remove strings */ + DUK_MS_FLAG_NO_OBJECT_COMPACTION; /* avoid array abandoning which interns strings */ +#endif + +#if defined(DUK_USE_HEAPPTR16) + new_entries = (duk_uint16_t *) DUK_ALLOC(heap, sizeof(duk_uint16_t) * new_size); +#else + new_entries = (duk_hstring **) DUK_ALLOC(heap, sizeof(duk_hstring *) * new_size); +#endif + +#ifdef DUK_USE_MARK_AND_SWEEP + heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags; +#endif + + if (!new_entries) { + goto resize_error; + } + +#ifdef DUK_USE_EXPLICIT_NULL_INIT + for (i = 0; i < new_size; i++) { +#if defined(DUK_USE_HEAPPTR16) + new_entries[i] = heap->heapptr_null16; +#else + new_entries[i] = NULL; +#endif + } +#else +#if defined(DUK_USE_HEAPPTR16) + /* Relies on NULL encoding to zero. */ + DUK_MEMZERO(new_entries, sizeof(duk_uint16_t) * new_size); +#else + DUK_MEMZERO(new_entries, sizeof(duk_hstring *) * new_size); +#endif +#endif + + /* Because new_size > duk__count_used_probe(heap), guaranteed to work */ + for (i = 0; i < old_size; i++) { + duk_hstring *e; + +#if defined(DUK_USE_HEAPPTR16) + e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, old_entries[i]); +#else + e = old_entries[i]; +#endif + if (e == NULL || e == DUK__DELETED_MARKER(heap)) { + continue; + } + /* checking for DUK__DELETED_MARKER is not necessary here, but helper does it now */ + duk__insert_hstring_probe(heap, new_entries, new_size, &new_used, e); + } + +#ifdef DUK_USE_DDPRINT + DUK_DD(DUK_DDPRINT("resized stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load", + (long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used, + (long) (((double) old_used) / ((double) old_size) * 100.0), + (long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) new_used, + (long) (((double) new_used) / ((double) new_size) * 100.0))); +#endif + +#if defined(DUK_USE_HEAPPTR16) + DUK_FREE(heap, heap->strtable16); + heap->strtable16 = new_entries; +#else + DUK_FREE(heap, heap->strtable); + heap->strtable = new_entries; +#endif + heap->st_size = new_size; + heap->st_used = new_used; /* may be less, since DELETED entries are NULLed by rehash */ + + return 0; /* OK */ + + resize_error: + DUK_FREE(heap, new_entries); + return 1; /* FAIL */ +} + +DUK_LOCAL duk_bool_t duk__resize_strtab_probe(duk_heap *heap) { + duk_uint32_t new_size; + duk_bool_t ret; + + new_size = (duk_uint32_t) duk__count_used_probe(heap); + if (new_size >= 0x80000000UL) { + new_size = DUK_STRTAB_HIGHEST_32BIT_PRIME; + } else { + new_size = duk_util_get_hash_prime(DUK_STRTAB_GROW_ST_SIZE(new_size)); + new_size = duk_util_get_hash_prime(new_size); + } + DUK_ASSERT(new_size > 0); + + /* rehash even if old and new sizes are the same to get rid of + * DELETED entries. + */ + + ret = duk__resize_strtab_raw_probe(heap, new_size); + + return ret; +} + +DUK_LOCAL duk_bool_t duk__recheck_strtab_size_probe(duk_heap *heap, duk_uint32_t new_used) { + duk_uint32_t new_free; + duk_uint32_t tmp1; + duk_uint32_t tmp2; + + DUK_ASSERT(new_used <= heap->st_size); /* grow by at most one */ + new_free = heap->st_size - new_used; /* unsigned intentionally */ + + /* new_free / size <= 1 / DIV <=> new_free <= size / DIV */ + /* new_used / size <= 1 / DIV <=> new_used <= size / DIV */ + + tmp1 = heap->st_size / DUK_STRTAB_MIN_FREE_DIVISOR; + tmp2 = heap->st_size / DUK_STRTAB_MIN_USED_DIVISOR; + + if (new_free <= tmp1 || new_used <= tmp2) { + /* load factor too low or high, count actually used entries and resize */ + return duk__resize_strtab_probe(heap); + } else { + return 0; /* OK */ + } +} + +#if defined(DUK_USE_DEBUG) +DUK_INTERNAL void duk_heap_dump_strtab(duk_heap *heap) { + duk_uint32_t i; + duk_hstring *h; + + DUK_ASSERT(heap != NULL); +#if defined(DUK_USE_HEAPPTR16) + DUK_ASSERT(heap->strtable16 != NULL); +#else + DUK_ASSERT(heap->strtable != NULL); +#endif + DUK_UNREF(h); + + for (i = 0; i < heap->st_size; i++) { +#if defined(DUK_USE_HEAPPTR16) + h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->strtable16[i]); +#else + h = heap->strtable[i]; +#endif + + DUK_DD(DUK_DDPRINT("[%03d] -> %p", (int) i, (void *) h)); + } +} +#endif /* DUK_USE_DEBUG */ + +#endif /* DUK_USE_STRTAB_PROBE */ + +/* + * Raw intern and lookup + */ + +DUK_LOCAL duk_hstring *duk__do_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) { + duk_hstring *res; + const duk_uint8_t *extdata; + +#if defined(DUK_USE_STRTAB_PROBE) + if (duk__recheck_strtab_size_probe(heap, heap->st_used + 1)) { + return NULL; + } +#endif + + /* For manual testing only. */ +#if 0 + { + duk_size_t i; + DUK_PRINTF("INTERN: \""); + for (i = 0; i < blen; i++) { + duk_uint8_t x = str[i]; + if (x >= 0x20 && x <= 0x7e && x != '"' && x != '\\') { + DUK_PRINTF("%c", (int) x); /* char: use int cast */ + } else { + DUK_PRINTF("\\x%02lx", (long) x); + } + } + DUK_PRINTF("\"\n"); + } +#endif + +#if defined(DUK_USE_HSTRING_EXTDATA) && defined(DUK_USE_EXTSTR_INTERN_CHECK) + extdata = (const duk_uint8_t *) DUK_USE_EXTSTR_INTERN_CHECK(heap->heap_udata, (void *) str, (duk_size_t) blen); +#else + extdata = (const duk_uint8_t *) NULL; +#endif + res = duk__alloc_init_hstring(heap, str, blen, strhash, extdata); + if (!res) { + return NULL; + } + +#if defined(DUK_USE_STRTAB_CHAIN) + if (duk__insert_hstring_chain(heap, res)) { + /* failed */ + DUK_FREE(heap, res); + return NULL; + } +#elif defined(DUK_USE_STRTAB_PROBE) + /* guaranteed to succeed */ + duk__insert_hstring_probe(heap, +#if defined(DUK_USE_HEAPPTR16) + heap->strtable16, +#else + heap->strtable, +#endif + heap->st_size, + &heap->st_used, + res); +#else +#error internal error, invalid strtab options +#endif + + /* Note: hstring is in heap but has refcount zero and is not strongly reachable. + * Caller should increase refcount and make the hstring reachable before any + * operations which require allocation (and possible gc). + */ + + return res; +} + +DUK_LOCAL duk_hstring *duk__do_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t *out_strhash) { + duk_hstring *res; + + DUK_ASSERT(out_strhash); + + *out_strhash = duk_heap_hashstring(heap, str, (duk_size_t) blen); + +#if defined(DUK_USE_STRTAB_CHAIN) + res = duk__find_matching_string_chain(heap, str, blen, *out_strhash); +#elif defined(DUK_USE_STRTAB_PROBE) + res = duk__find_matching_string_probe(heap, +#if defined(DUK_USE_HEAPPTR16) + heap->strtable16, +#else + heap->strtable, +#endif + heap->st_size, + str, + blen, + *out_strhash); +#else +#error internal error, invalid strtab options +#endif + + return res; +} + +/* + * Exposed calls + */ + +#if 0 /*unused*/ +DUK_INTERNAL duk_hstring *duk_heap_string_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen) { + duk_uint32_t strhash; /* dummy */ + return duk__do_lookup(heap, str, blen, &strhash); +} +#endif + +DUK_INTERNAL duk_hstring *duk_heap_string_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen) { + duk_hstring *res; + duk_uint32_t strhash; + + /* caller is responsible for ensuring this */ + DUK_ASSERT(blen <= DUK_HSTRING_MAX_BYTELEN); + + res = duk__do_lookup(heap, str, blen, &strhash); + if (res) { + return res; + } + + res = duk__do_intern(heap, str, blen, strhash); + return res; /* may be NULL */ +} + +DUK_INTERNAL duk_hstring *duk_heap_string_intern_checked(duk_hthread *thr, const duk_uint8_t *str, duk_uint32_t blen) { + duk_hstring *res = duk_heap_string_intern(thr->heap, str, blen); + if (!res) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "failed to intern string"); + } + return res; +} + +#if 0 /*unused*/ +DUK_INTERNAL duk_hstring *duk_heap_string_lookup_u32(duk_heap *heap, duk_uint32_t val) { + char buf[DUK_STRTAB_U32_MAX_STRLEN+1]; + DUK_SNPRINTF(buf, sizeof(buf), "%lu", (unsigned long) val); + buf[sizeof(buf) - 1] = (char) 0; + DUK_ASSERT(DUK_STRLEN(buf) <= DUK_UINT32_MAX); /* formatted result limited */ + return duk_heap_string_lookup(heap, (const duk_uint8_t *) buf, (duk_uint32_t) DUK_STRLEN(buf)); +} +#endif + +DUK_INTERNAL duk_hstring *duk_heap_string_intern_u32(duk_heap *heap, duk_uint32_t val) { + char buf[DUK_STRTAB_U32_MAX_STRLEN+1]; + DUK_SNPRINTF(buf, sizeof(buf), "%lu", (unsigned long) val); + buf[sizeof(buf) - 1] = (char) 0; + DUK_ASSERT(DUK_STRLEN(buf) <= DUK_UINT32_MAX); /* formatted result limited */ + return duk_heap_string_intern(heap, (const duk_uint8_t *) buf, (duk_uint32_t) DUK_STRLEN(buf)); +} + +DUK_INTERNAL duk_hstring *duk_heap_string_intern_u32_checked(duk_hthread *thr, duk_uint32_t val) { + duk_hstring *res = duk_heap_string_intern_u32(thr->heap, val); + if (!res) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "failed to intern string"); + } + return res; +} + +/* find and remove string from stringtable; caller must free the string itself */ +DUK_INTERNAL void duk_heap_string_remove(duk_heap *heap, duk_hstring *h) { + DUK_DDD(DUK_DDDPRINT("remove string from stringtable: %!O", (duk_heaphdr *) h)); + +#if defined(DUK_USE_STRTAB_CHAIN) + duk__remove_matching_hstring_chain(heap, h); +#elif defined(DUK_USE_STRTAB_PROBE) + duk__remove_matching_hstring_probe(heap, +#if defined(DUK_USE_HEAPPTR16) + heap->strtable16, +#else + heap->strtable, +#endif + heap->st_size, + h); +#else +#error internal error, invalid strtab options +#endif +} + +#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_MS_STRINGTABLE_RESIZE) +DUK_INTERNAL void duk_heap_force_strtab_resize(duk_heap *heap) { + /* Force a resize so that DELETED entries are eliminated. + * Another option would be duk__recheck_strtab_size_probe(); + * but since that happens on every intern anyway, this whole + * check can now be disabled. + */ +#if defined(DUK_USE_STRTAB_CHAIN) + DUK_UNREF(heap); +#elif defined(DUK_USE_STRTAB_PROBE) + duk__resize_strtab_probe(heap); +#endif +} +#endif + +#if defined(DUK_USE_STRTAB_CHAIN) +DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap) { + /* Free strings in the stringtable and any allocations needed + * by the stringtable itself. + */ + duk_uint_fast32_t i, j; + duk_strtab_entry *e; +#if defined(DUK_USE_HEAPPTR16) + duk_uint16_t *lst; + duk_uint16_t null16 = heap->heapptr_null16; +#else + duk_hstring **lst; +#endif + duk_hstring *h; + + for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) { + e = heap->strtable + i; + if (e->listlen > 0) { +#if defined(DUK_USE_HEAPPTR16) + lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16); +#else + lst = e->u.strlist; +#endif + DUK_ASSERT(lst != NULL); + + for (j = 0; j < e->listlen; j++) { +#if defined(DUK_USE_HEAPPTR16) + h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, lst[j]); + lst[j] = null16; +#else + h = lst[j]; + lst[j] = NULL; +#endif + /* strings may have inner refs (extdata) in some cases */ + if (h != NULL) { + duk_free_hstring_inner(heap, h); + DUK_FREE(heap, h); + } + } +#if defined(DUK_USE_HEAPPTR16) + e->u.strlist16 = null16; +#else + e->u.strlist = NULL; +#endif + DUK_FREE(heap, lst); + } else { +#if defined(DUK_USE_HEAPPTR16) + h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.str16); + e->u.str16 = null16; +#else + h = e->u.str; + e->u.str = NULL; +#endif + if (h != NULL) { + duk_free_hstring_inner(heap, h); + DUK_FREE(heap, h); + } + } + e->listlen = 0; + } +} +#endif /* DUK_USE_STRTAB_CHAIN */ + +#if defined(DUK_USE_STRTAB_PROBE) +DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap) { + duk_uint_fast32_t i; + duk_hstring *h; + +#if defined(DUK_USE_HEAPPTR16) + if (heap->strtable16) { +#else + if (heap->strtable) { +#endif + for (i = 0; i < (duk_uint_fast32_t) heap->st_size; i++) { +#if defined(DUK_USE_HEAPPTR16) + h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, heap->strtable16[i]); +#else + h = heap->strtable[i]; +#endif + if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) { + continue; + } + DUK_ASSERT(h != NULL); + + /* strings may have inner refs (extdata) in some cases */ + duk_free_hstring_inner(heap, h); + DUK_FREE(heap, h); +#if 0 /* not strictly necessary */ + heap->strtable[i] = NULL; +#endif + } +#if defined(DUK_USE_HEAPPTR16) + DUK_FREE(heap, heap->strtable16); +#else + DUK_FREE(heap, heap->strtable); +#endif +#if 0 /* not strictly necessary */ + heap->strtable = NULL; +#endif + } +} +#endif /* DUK_USE_STRTAB_PROBE */ + +/* Undefine local defines */ +#undef DUK__HASH_INITIAL +#undef DUK__HASH_PROBE_STEP +#undef DUK__DELETED_MARKER +#line 1 "duk_hobject_alloc.c" +/* + * Hobject allocation. + * + * Provides primitive allocation functions for all object types (plain object, + * compiled function, native function, thread). The object return is not yet + * in "heap allocated" list and has a refcount of zero, so caller must careful. + */ + +/* include removed: duk_internal.h */ + +DUK_LOCAL void duk__init_object_parts(duk_heap *heap, duk_hobject *obj, duk_uint_t hobject_flags) { +#ifdef DUK_USE_EXPLICIT_NULL_INIT + DUK_HOBJECT_SET_PROPS(heap, obj, NULL); +#endif + + /* XXX: macro? sets both heaphdr and object flags */ + obj->hdr.h_flags = hobject_flags; + DUK_HEAPHDR_SET_TYPE(&obj->hdr, DUK_HTYPE_OBJECT); /* also goes into flags */ + +#if defined(DUK_USE_HEAPPTR16) + /* Zero encoded pointer is required to match NULL */ + DUK_HEAPHDR_SET_NEXT(heap, &obj->hdr, NULL); +#if defined(DUK_USE_DOUBLE_LINKED_HEAP) + DUK_HEAPHDR_SET_PREV(heap, &obj->hdr, NULL); +#endif +#endif + DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, &obj->hdr); + + /* + * obj->props is intentionally left as NULL, and duk_hobject_props.c must deal + * with this properly. This is intentional: empty objects consume a minimum + * amount of memory. Further, an initial allocation might fail and cause + * 'obj' to "leak" (require a mark-and-sweep) since it is not reachable yet. + */ +} + +/* + * Allocate an duk_hobject. + * + * The allocated object has no allocation for properties; the caller may + * want to force a resize if a desired size is known. + * + * The allocated object has zero reference count and is not reachable. + * The caller MUST make the object reachable and increase its reference + * count before invoking any operation that might require memory allocation. + */ + +DUK_INTERNAL duk_hobject *duk_hobject_alloc(duk_heap *heap, duk_uint_t hobject_flags) { + duk_hobject *res; + + DUK_ASSERT(heap != NULL); + + /* different memory layout, alloc size, and init */ + DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_COMPILEDFUNCTION) == 0); + DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_NATIVEFUNCTION) == 0); + DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_THREAD) == 0); + + res = (duk_hobject *) DUK_ALLOC(heap, sizeof(duk_hobject)); + if (!res) { + return NULL; + } + DUK_MEMZERO(res, sizeof(duk_hobject)); + + duk__init_object_parts(heap, res, hobject_flags); + + return res; +} + +DUK_INTERNAL duk_hcompiledfunction *duk_hcompiledfunction_alloc(duk_heap *heap, duk_uint_t hobject_flags) { + duk_hcompiledfunction *res; + + res = (duk_hcompiledfunction *) DUK_ALLOC(heap, sizeof(duk_hcompiledfunction)); + if (!res) { + return NULL; + } + DUK_MEMZERO(res, sizeof(duk_hcompiledfunction)); + + duk__init_object_parts(heap, &res->obj, hobject_flags); + +#ifdef DUK_USE_EXPLICIT_NULL_INIT +#ifdef DUK_USE_HEAPPTR16 + /* NULL pointer is required to encode to zero, so memset is enough. */ +#else + res->data = NULL; + res->funcs = NULL; + res->bytecode = NULL; +#endif +#endif + + return res; +} + +DUK_INTERNAL duk_hnativefunction *duk_hnativefunction_alloc(duk_heap *heap, duk_uint_t hobject_flags) { + duk_hnativefunction *res; + + res = (duk_hnativefunction *) DUK_ALLOC(heap, sizeof(duk_hnativefunction)); + if (!res) { + return NULL; + } + DUK_MEMZERO(res, sizeof(duk_hnativefunction)); + + duk__init_object_parts(heap, &res->obj, hobject_flags); + +#ifdef DUK_USE_EXPLICIT_NULL_INIT + res->func = NULL; +#endif + + return res; +} + +DUK_INTERNAL duk_hbufferobject *duk_hbufferobject_alloc(duk_heap *heap, duk_uint_t hobject_flags) { + duk_hbufferobject *res; + + res = (duk_hbufferobject *) DUK_ALLOC(heap, sizeof(duk_hbufferobject)); + if (!res) { + return NULL; + } + DUK_MEMZERO(res, sizeof(duk_hbufferobject)); + + duk__init_object_parts(heap, &res->obj, hobject_flags); + +#ifdef DUK_USE_EXPLICIT_NULL_INIT + res->buf = NULL; +#endif + + DUK_ASSERT_HBUFFEROBJECT_VALID(res); + return res; +} + +/* + * Allocate a new thread. + * + * Leaves the built-ins array uninitialized. The caller must either + * initialize a new global context or share existing built-ins from + * another thread. + */ + +DUK_INTERNAL duk_hthread *duk_hthread_alloc(duk_heap *heap, duk_uint_t hobject_flags) { + duk_hthread *res; + + res = (duk_hthread *) DUK_ALLOC(heap, sizeof(duk_hthread)); + if (!res) { + return NULL; + } + DUK_MEMZERO(res, sizeof(duk_hthread)); + + duk__init_object_parts(heap, &res->obj, hobject_flags); + +#ifdef DUK_USE_EXPLICIT_NULL_INIT + res->ptr_curr_pc = NULL; + res->heap = NULL; + res->valstack = NULL; + res->valstack_end = NULL; + res->valstack_bottom = NULL; + res->valstack_top = NULL; + res->callstack = NULL; + res->catchstack = NULL; + res->resumer = NULL; + res->compile_ctx = NULL, +#ifdef DUK_USE_HEAPPTR16 + res->strs16 = NULL; +#else + res->strs = NULL; +#endif + { + int i; + for (i = 0; i < DUK_NUM_BUILTINS; i++) { + res->builtins[i] = NULL; + } + } +#endif + /* when nothing is running, API calls are in non-strict mode */ + DUK_ASSERT(res->strict == 0); + + res->heap = heap; + res->valstack_max = DUK_VALSTACK_DEFAULT_MAX; + res->callstack_max = DUK_CALLSTACK_DEFAULT_MAX; + res->catchstack_max = DUK_CATCHSTACK_DEFAULT_MAX; + + return res; +} + +#if 0 /* unused now */ +DUK_INTERNAL duk_hobject *duk_hobject_alloc_checked(duk_hthread *thr, duk_uint_t hobject_flags) { + duk_hobject *res = duk_hobject_alloc(thr->heap, hobject_flags); + if (!res) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "failed to allocate an object"); + } + return res; +} +#endif +#line 1 "duk_hobject_enum.c" +/* + * Hobject enumeration support. + * + * Creates an internal enumeration state object to be used e.g. with for-in + * enumeration. The state object contains a snapshot of target object keys + * and internal control state for enumeration. Enumerator flags allow caller + * to e.g. request internal/non-enumerable properties, and to enumerate only + * "own" properties. + * + * Also creates the result value for e.g. Object.keys() based on the same + * internal structure. + * + * This snapshot-based enumeration approach is used to simplify enumeration: + * non-snapshot-based approaches are difficult to reconcile with mutating + * the enumeration target, running multiple long-lived enumerators at the + * same time, garbage collection details, etc. The downside is that the + * enumerator object is memory inefficient especially for iterating arrays. + */ + +/* include removed: duk_internal.h */ + +/* XXX: identify enumeration target with an object index (not top of stack) */ + +/* must match exactly the number of internal properties inserted to enumerator */ +#define DUK__ENUM_START_INDEX 2 + +DUK_LOCAL const duk_uint16_t duk__bufferobject_virtual_props[] = { + DUK_STRIDX_LENGTH, + DUK_STRIDX_BYTE_LENGTH, + DUK_STRIDX_BYTE_OFFSET, + DUK_STRIDX_BYTES_PER_ELEMENT +}; + +/* + * Helper to sort array index keys. The keys are in the enumeration object + * entry part, starting from DUK__ENUM_START_INDEX, and the entry part is dense. + * + * We use insertion sort because it is simple (leading to compact code,) + * works nicely in-place, and minimizes operations if data is already sorted + * or nearly sorted (which is a very common case here). It also minimizes + * the use of element comparisons in general. This is nice because element + * comparisons here involve re-parsing the string keys into numbers each + * time, which is naturally very expensive. + * + * Note that the entry part values are all "true", e.g. + * + * "1" -> true, "3" -> true, "2" -> true + * + * so it suffices to only work in the key part without exchanging any keys, + * simplifying the sort. + * + * http://en.wikipedia.org/wiki/Insertion_sort + * + * (Compiles to about 160 bytes now as a stand-alone function.) + */ + +DUK_LOCAL void duk__sort_array_indices(duk_hthread *thr, duk_hobject *h_obj) { + duk_hstring **keys; + duk_hstring **p_curr, **p_insert, **p_end; + duk_hstring *h_curr; + duk_uarridx_t val_highest, val_curr, val_insert; + + DUK_ASSERT(h_obj != NULL); + DUK_ASSERT(DUK_HOBJECT_GET_ENEXT(h_obj) >= 2); /* control props */ + DUK_UNREF(thr); + + if (DUK_HOBJECT_GET_ENEXT(h_obj) <= 1 + DUK__ENUM_START_INDEX) { + return; + } + + keys = DUK_HOBJECT_E_GET_KEY_BASE(thr->heap, h_obj); + p_end = keys + DUK_HOBJECT_GET_ENEXT(h_obj); + keys += DUK__ENUM_START_INDEX; + + DUK_DDD(DUK_DDDPRINT("keys=%p, p_end=%p (after skipping enum props)", + (void *) keys, (void *) p_end)); + +#ifdef DUK_USE_DDDPRINT + { + duk_uint_fast32_t i; + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h_obj); i++) { + DUK_DDD(DUK_DDDPRINT("initial: %ld %p -> %!O", + (long) i, + (void *) DUK_HOBJECT_E_GET_KEY_PTR(thr->heap, h_obj, i), + (duk_heaphdr *) DUK_HOBJECT_E_GET_KEY(thr->heap, h_obj, i))); + } + } +#endif + + val_highest = DUK_HSTRING_GET_ARRIDX_SLOW(keys[0]); + for (p_curr = keys + 1; p_curr < p_end; p_curr++) { + DUK_ASSERT(*p_curr != NULL); + val_curr = DUK_HSTRING_GET_ARRIDX_SLOW(*p_curr); + + if (val_curr >= val_highest) { + DUK_DDD(DUK_DDDPRINT("p_curr=%p, p_end=%p, val_highest=%ld, val_curr=%ld -> " + "already in correct order, next", + (void *) p_curr, (void *) p_end, (long) val_highest, (long) val_curr)); + val_highest = val_curr; + continue; + } + + DUK_DDD(DUK_DDDPRINT("p_curr=%p, p_end=%p, val_highest=%ld, val_curr=%ld -> " + "needs to be inserted", + (void *) p_curr, (void *) p_end, (long) val_highest, (long) val_curr)); + + /* Needs to be inserted; scan backwards, since we optimize + * for the case where elements are nearly in order. + */ + + p_insert = p_curr - 1; + for (;;) { + val_insert = DUK_HSTRING_GET_ARRIDX_SLOW(*p_insert); + if (val_insert < val_curr) { + DUK_DDD(DUK_DDDPRINT("p_insert=%p, val_insert=%ld, val_curr=%ld -> insert after this", + (void *) p_insert, (long) val_insert, (long) val_curr)); + p_insert++; + break; + } + if (p_insert == keys) { + DUK_DDD(DUK_DDDPRINT("p_insert=%p -> out of keys, insert to beginning", (void *) p_insert)); + break; + } + DUK_DDD(DUK_DDDPRINT("p_insert=%p, val_insert=%ld, val_curr=%ld -> search backwards", + (void *) p_insert, (long) val_insert, (long) val_curr)); + p_insert--; + } + + DUK_DDD(DUK_DDDPRINT("final p_insert=%p", (void *) p_insert)); + + /* .-- p_insert .-- p_curr + * v v + * | ... | insert | ... | curr + */ + + h_curr = *p_curr; + DUK_DDD(DUK_DDDPRINT("memmove: dest=%p, src=%p, size=%ld, h_curr=%p", + (void *) (p_insert + 1), (void *) p_insert, + (long) (p_curr - p_insert), (void *) h_curr)); + + DUK_MEMMOVE((void *) (p_insert + 1), + (void *) p_insert, + (size_t) ((p_curr - p_insert) * sizeof(duk_hstring *))); + *p_insert = h_curr; + /* keep val_highest */ + } + +#ifdef DUK_USE_DDDPRINT + { + duk_uint_fast32_t i; + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h_obj); i++) { + DUK_DDD(DUK_DDDPRINT("final: %ld %p -> %!O", + (long) i, + (void *) DUK_HOBJECT_E_GET_KEY_PTR(thr->heap, h_obj, i), + (duk_heaphdr *) DUK_HOBJECT_E_GET_KEY(thr->heap, h_obj, i))); + } + } +#endif +} + +/* + * Create an internal enumerator object E, which has its keys ordered + * to match desired enumeration ordering. Also initialize internal control + * properties for enumeration. + * + * Note: if an array was used to hold enumeration keys instead, an array + * scan would be needed to eliminate duplicates found in the prototype chain. + */ + +DUK_INTERNAL void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint_t enum_flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *enum_target; + duk_hobject *curr; + duk_hobject *res; +#if defined(DUK_USE_ES6_PROXY) + duk_hobject *h_proxy_target; + duk_hobject *h_proxy_handler; + duk_hobject *h_trap_result; +#endif + duk_uint_fast32_t i, len; /* used for array, stack, and entry indices */ + + DUK_ASSERT(ctx != NULL); + + DUK_DDD(DUK_DDDPRINT("create enumerator, stack top: %ld", (long) duk_get_top(ctx))); + + enum_target = duk_require_hobject(ctx, -1); + DUK_ASSERT(enum_target != NULL); + + duk_push_object_internal(ctx); + res = duk_require_hobject(ctx, -1); + + DUK_DDD(DUK_DDDPRINT("created internal object")); + + /* [enum_target res] */ + + /* Target must be stored so that we can recheck whether or not + * keys still exist when we enumerate. This is not done if the + * enumeration result comes from a proxy trap as there is no + * real object to check against. + */ + duk_push_hobject(ctx, enum_target); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET); + + /* Initialize index so that we skip internal control keys. */ + duk_push_int(ctx, DUK__ENUM_START_INDEX); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_NEXT); + + /* + * Proxy object handling + */ + +#if defined(DUK_USE_ES6_PROXY) + if (DUK_LIKELY((enum_flags & DUK_ENUM_NO_PROXY_BEHAVIOR) != 0)) { + goto skip_proxy; + } + if (DUK_LIKELY(!duk_hobject_proxy_check(thr, + enum_target, + &h_proxy_target, + &h_proxy_handler))) { + goto skip_proxy; + } + + DUK_DDD(DUK_DDDPRINT("proxy enumeration")); + duk_push_hobject(ctx, h_proxy_handler); + if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_ENUMERATE)) { + /* No need to replace the 'enum_target' value in stack, only the + * enum_target reference. This also ensures that the original + * enum target is reachable, which keeps the proxy and the proxy + * target reachable. We do need to replace the internal _Target. + */ + DUK_DDD(DUK_DDDPRINT("no enumerate trap, enumerate proxy target instead")); + DUK_DDD(DUK_DDDPRINT("h_proxy_target=%!O", (duk_heaphdr *) h_proxy_target)); + enum_target = h_proxy_target; + + duk_push_hobject(ctx, enum_target); /* -> [ ... enum_target res handler undefined target ] */ + duk_put_prop_stridx(ctx, -4, DUK_STRIDX_INT_TARGET); + + duk_pop_2(ctx); /* -> [ ... enum_target res ] */ + goto skip_proxy; + } + + /* [ ... enum_target res handler trap ] */ + duk_insert(ctx, -2); + duk_push_hobject(ctx, h_proxy_target); /* -> [ ... enum_target res trap handler target ] */ + duk_call_method(ctx, 1 /*nargs*/); /* -> [ ... enum_target res trap_result ] */ + h_trap_result = duk_require_hobject(ctx, -1); + DUK_UNREF(h_trap_result); + + /* Copy trap result keys into the enumerator object. */ + len = (duk_uint_fast32_t) duk_get_length(ctx, -1); + for (i = 0; i < len; i++) { + /* XXX: not sure what the correct semantic details are here, + * e.g. handling of missing values (gaps), handling of non-array + * trap results, etc. + * + * For keys, we simply skip non-string keys which seems to be + * consistent with how e.g. Object.keys() will process proxy trap + * results (ES6, Section 19.1.2.14). + */ + if (duk_get_prop_index(ctx, -1, i) && duk_is_string(ctx, -1)) { + /* [ ... enum_target res trap_result val ] */ + duk_push_true(ctx); + /* [ ... enum_target res trap_result val true ] */ + duk_put_prop(ctx, -4); + } else { + duk_pop(ctx); + } + } + /* [ ... enum_target res trap_result ] */ + duk_pop(ctx); + duk_remove(ctx, -2); + + /* [ ... res ] */ + + /* The internal _Target property is kept pointing to the original + * enumeration target (the proxy object), so that the enumerator + * 'next' operation can read property values if so requested. The + * fact that the _Target is a proxy disables key existence check + * during enumeration. + */ + DUK_DDD(DUK_DDDPRINT("proxy enumeration, final res: %!O", (duk_heaphdr *) res)); + goto compact_and_return; + + skip_proxy: +#endif /* DUK_USE_ES6_PROXY */ + + curr = enum_target; + while (curr) { + /* + * Virtual properties. + * + * String and buffer indices are virtual and always enumerable, + * 'length' is virtual and non-enumerable. Array and arguments + * object props have special behavior but are concrete. + */ + + if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr) || + DUK_HOBJECT_IS_BUFFEROBJECT(curr)) { + /* String and buffer enumeration behavior is identical now, + * so use shared handler. + */ + if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr)) { + duk_hstring *h_val; + h_val = duk_hobject_get_internal_value_string(thr->heap, curr); + DUK_ASSERT(h_val != NULL); /* string objects must not created without internal value */ + len = (duk_uint_fast32_t) DUK_HSTRING_GET_CHARLEN(h_val); + } else { + duk_hbufferobject *h_bufobj; + DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT(curr)); + h_bufobj = (duk_hbufferobject *) curr; + if (h_bufobj == NULL) { + /* Neutered buffer, zero length seems + * like good behavior here. + */ + len = 0; + } else { + /* There's intentionally no check for + * current underlying buffer length. + */ + len = (duk_uint_fast32_t) (h_bufobj->length >> h_bufobj->shift); + } + } + + for (i = 0; i < len; i++) { + duk_hstring *k; + + k = duk_heap_string_intern_u32_checked(thr, i); + DUK_ASSERT(k); + duk_push_hstring(ctx, k); + duk_push_true(ctx); + + /* [enum_target res key true] */ + duk_put_prop(ctx, -3); + + /* [enum_target res] */ + } + + /* 'length' and other virtual properties are not + * enumerable, but are included if non-enumerable + * properties are requested. + */ + + if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) { + duk_uint_fast32_t n; + + if (DUK_HOBJECT_IS_BUFFEROBJECT(curr)) { + n = sizeof(duk__bufferobject_virtual_props) / sizeof(duk_uint16_t); + } else { + DUK_ASSERT(DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr)); + DUK_ASSERT(duk__bufferobject_virtual_props[0] == DUK_STRIDX_LENGTH); + n = 1; /* only 'length' */ + } + + for (i = 0; i < n; i++) { + duk_push_hstring_stridx(ctx, duk__bufferobject_virtual_props[i]); + duk_push_true(ctx); + duk_put_prop(ctx, -3); + } + + } + } else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(curr)) { + if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) { + duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH); + duk_push_true(ctx); + duk_put_prop(ctx, -3); + } + } + + /* + * Array part + * + * Note: ordering between array and entry part must match 'abandon array' + * behavior in duk_hobject_props.c: key order after an array is abandoned + * must be the same. + */ + + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(curr); i++) { + duk_hstring *k; + duk_tval *tv; + + tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, curr, i); + if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + continue; + } + k = duk_heap_string_intern_u32_checked(thr, i); + DUK_ASSERT(k); + + duk_push_hstring(ctx, k); + duk_push_true(ctx); + + /* [enum_target res key true] */ + duk_put_prop(ctx, -3); + + /* [enum_target res] */ + } + + /* + * Entries part + */ + + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(curr); i++) { + duk_hstring *k; + + k = DUK_HOBJECT_E_GET_KEY(thr->heap, curr, i); + if (!k) { + continue; + } + if (!DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(thr->heap, curr, i) && + !(enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE)) { + continue; + } + if (DUK_HSTRING_HAS_INTERNAL(k) && + !(enum_flags & DUK_ENUM_INCLUDE_INTERNAL)) { + continue; + } + if ((enum_flags & DUK_ENUM_ARRAY_INDICES_ONLY) && + (DUK_HSTRING_GET_ARRIDX_SLOW(k) == DUK_HSTRING_NO_ARRAY_INDEX)) { + continue; + } + + DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, curr, i) || + !DUK_TVAL_IS_UNDEFINED_UNUSED(&DUK_HOBJECT_E_GET_VALUE_PTR(thr->heap, curr, i)->v)); + + duk_push_hstring(ctx, k); + duk_push_true(ctx); + + /* [enum_target res key true] */ + duk_put_prop(ctx, -3); + + /* [enum_target res] */ + } + + if (enum_flags & DUK_ENUM_OWN_PROPERTIES_ONLY) { + break; + } + + curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr); + } + + /* [enum_target res] */ + + duk_remove(ctx, -2); + + /* [res] */ + + if ((enum_flags & (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) == + (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) { + /* + * Some E5/E5.1 algorithms require that array indices are iterated + * in a strictly ascending order. This is the case for e.g. + * Array.prototype.forEach() and JSON.stringify() PropertyList + * handling. + * + * To ensure this property for arrays with an array part (and + * arbitrary objects too, since e.g. forEach() can be applied + * to an array), the caller can request that we sort the keys + * here. + */ + + /* XXX: avoid this at least when enum_target is an Array, it has an + * array part, and no ancestor properties were included? Not worth + * it for JSON, but maybe worth it for forEach(). + */ + + /* XXX: may need a 'length' filter for forEach() + */ + DUK_DDD(DUK_DDDPRINT("sort array indices by caller request")); + duk__sort_array_indices(thr, res); + } + +#if defined(DUK_USE_ES6_PROXY) + compact_and_return: +#endif + /* compact; no need to seal because object is internal */ + duk_hobject_compact_props(thr, res); + + DUK_DDD(DUK_DDDPRINT("created enumerator object: %!iT", (duk_tval *) duk_get_tval(ctx, -1))); +} + +/* + * Returns non-zero if a key and/or value was enumerated, and: + * + * [enum] -> [key] (get_value == 0) + * [enum] -> [key value] (get_value == 1) + * + * Returns zero without pushing anything on the stack otherwise. + */ +DUK_INTERNAL duk_bool_t duk_hobject_enumerator_next(duk_context *ctx, duk_bool_t get_value) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *e; + duk_hobject *enum_target; + duk_hstring *res = NULL; + duk_uint_fast32_t idx; + duk_bool_t check_existence; + + DUK_ASSERT(ctx != NULL); + + /* [... enum] */ + + e = duk_require_hobject(ctx, -1); + + /* XXX use get tval ptr, more efficient */ + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_NEXT); + idx = (duk_uint_fast32_t) duk_require_uint(ctx, -1); + duk_pop(ctx); + DUK_DDD(DUK_DDDPRINT("enumeration: index is: %ld", (long) idx)); + + /* Enumeration keys are checked against the enumeration target (to see + * that they still exist). In the proxy enumeration case _Target will + * be the proxy, and checking key existence against the proxy is not + * required (or sensible, as the keys may be fully virtual). + */ + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET); + enum_target = duk_require_hobject(ctx, -1); + DUK_ASSERT(enum_target != NULL); +#if defined(DUK_USE_ES6_PROXY) + check_existence = (!DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(enum_target)); +#else + check_existence = 1; +#endif + duk_pop(ctx); /* still reachable */ + + DUK_DDD(DUK_DDDPRINT("getting next enum value, enum_target=%!iO, enumerator=%!iT", + (duk_heaphdr *) enum_target, (duk_tval *) duk_get_tval(ctx, -1))); + + /* no array part */ + for (;;) { + duk_hstring *k; + + if (idx >= DUK_HOBJECT_GET_ENEXT(e)) { + DUK_DDD(DUK_DDDPRINT("enumeration: ran out of elements")); + break; + } + + /* we know these because enum objects are internally created */ + k = DUK_HOBJECT_E_GET_KEY(thr->heap, e, idx); + DUK_ASSERT(k != NULL); + DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, e, idx)); + DUK_ASSERT(!DUK_TVAL_IS_UNDEFINED_UNUSED(&DUK_HOBJECT_E_GET_VALUE(thr->heap, e, idx).v)); + + idx++; + + /* recheck that the property still exists */ + if (check_existence && !duk_hobject_hasprop_raw(thr, enum_target, k)) { + DUK_DDD(DUK_DDDPRINT("property deleted during enumeration, skip")); + continue; + } + + DUK_DDD(DUK_DDDPRINT("enumeration: found element, key: %!O", (duk_heaphdr *) k)); + res = k; + break; + } + + DUK_DDD(DUK_DDDPRINT("enumeration: updating next index to %ld", (long) idx)); + + duk_push_u32(ctx, (duk_uint32_t) idx); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_NEXT); + + /* [... enum] */ + + if (res) { + duk_push_hstring(ctx, res); + if (get_value) { + duk_push_hobject(ctx, enum_target); + duk_dup(ctx, -2); /* -> [... enum key enum_target key] */ + duk_get_prop(ctx, -2); /* -> [... enum key enum_target val] */ + duk_remove(ctx, -2); /* -> [... enum key val] */ + duk_remove(ctx, -3); /* -> [... key val] */ + } else { + duk_remove(ctx, -2); /* -> [... key] */ + } + return 1; + } else { + duk_pop(ctx); /* -> [...] */ + return 0; + } +} + +/* + * Get enumerated keys in an Ecmascript array. Matches Object.keys() behavior + * described in E5 Section 15.2.3.14. + */ + +DUK_INTERNAL duk_ret_t duk_hobject_get_enumerated_keys(duk_context *ctx, duk_small_uint_t enum_flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *e; + duk_uint_fast32_t i; + duk_uint_fast32_t idx; + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(duk_get_hobject(ctx, -1) != NULL); + DUK_UNREF(thr); + + /* Create a temporary enumerator to get the (non-duplicated) key list; + * the enumerator state is initialized without being needed, but that + * has little impact. + */ + + duk_hobject_enumerator_create(ctx, enum_flags); + duk_push_array(ctx); + + /* [enum_target enum res] */ + + e = duk_require_hobject(ctx, -2); + DUK_ASSERT(e != NULL); + + idx = 0; + for (i = DUK__ENUM_START_INDEX; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(e); i++) { + duk_hstring *k; + + k = DUK_HOBJECT_E_GET_KEY(thr->heap, e, i); + DUK_ASSERT(k); /* enumerator must have no keys deleted */ + + /* [enum_target enum res] */ + duk_push_hstring(ctx, k); + duk_put_prop_index(ctx, -2, idx); + idx++; + } + + /* [enum_target enum res] */ + duk_remove(ctx, -2); + + /* [enum_target res] */ + + return 1; /* return 1 to allow callers to tail call */ +} +#line 1 "duk_hobject_finalizer.c" +/* + * Run an duk_hobject finalizer. Used for both reference counting + * and mark-and-sweep algorithms. Must never throw an error. + * + * There is no return value. Any return value or error thrown by + * the finalizer is ignored (although errors are debug logged). + * + * Notes: + * + * - The thread used for calling the finalizer is the same as the + * 'thr' argument. This may need to change later. + * + * - The finalizer thread 'top' assertions are there because it is + * critical that strict stack policy is observed (i.e. no cruft + * left on the finalizer stack). + */ + +/* include removed: duk_internal.h */ + +DUK_LOCAL duk_ret_t duk__finalize_helper(duk_context *ctx) { + DUK_ASSERT(ctx != NULL); + + DUK_DDD(DUK_DDDPRINT("protected finalization helper running")); + + /* [... obj] */ + + /* XXX: Finalizer lookup should traverse the prototype chain (to allow + * inherited finalizers) but should not invoke accessors or proxy object + * behavior. At the moment this lookup will invoke proxy behavior, so + * caller must ensure that this function is not called if the target is + * a Proxy. + */ + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_FINALIZER); /* -> [... obj finalizer] */ + if (!duk_is_callable(ctx, -1)) { + DUK_DDD(DUK_DDDPRINT("-> no finalizer or finalizer not callable")); + return 0; + } + duk_dup(ctx, -2); /* -> [... obj finalizer obj] */ + DUK_DDD(DUK_DDDPRINT("-> finalizer found, calling finalizer")); + duk_call(ctx, 1); /* -> [... obj retval] */ + DUK_DDD(DUK_DDDPRINT("finalizer finished successfully")); + return 0; + + /* Note: we rely on duk_safe_call() to fix up the stack for the caller, + * so we don't need to pop stuff here. There is no return value; + * caller determines rescued status based on object refcount. + */ +} + +DUK_INTERNAL void duk_hobject_run_finalizer(duk_hthread *thr, duk_hobject *obj) { + duk_context *ctx = (duk_context *) thr; + duk_ret_t rc; +#ifdef DUK_USE_ASSERTIONS + duk_idx_t entry_top; +#endif + + DUK_DDD(DUK_DDDPRINT("running object finalizer for object: %p", (void *) obj)); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT_VALSTACK_SPACE(thr, 1); + +#ifdef DUK_USE_ASSERTIONS + entry_top = duk_get_top(ctx); +#endif + /* + * Get and call the finalizer. All of this must be wrapped + * in a protected call, because even getting the finalizer + * may trigger an error (getter may throw one, for instance). + */ + + /* XXX: use a NULL error handler for the finalizer call? */ + + DUK_DDD(DUK_DDDPRINT("-> finalizer found, calling wrapped finalize helper")); + duk_push_hobject(ctx, obj); /* this also increases refcount by one */ + rc = duk_safe_call(ctx, duk__finalize_helper, 0 /*nargs*/, 1 /*nrets*/); /* -> [... obj retval/error] */ + DUK_ASSERT_TOP(ctx, entry_top + 2); /* duk_safe_call discipline */ + + if (rc != DUK_EXEC_SUCCESS) { + /* Note: we ask for one return value from duk_safe_call to get this + * error debugging here. + */ + DUK_D(DUK_DPRINT("wrapped finalizer call failed for object %p (ignored); error: %!T", + (void *) obj, (duk_tval *) duk_get_tval(ctx, -1))); + } + duk_pop_2(ctx); /* -> [...] */ + + DUK_ASSERT_TOP(ctx, entry_top); +} +#line 1 "duk_hobject_misc.c" +/* + * Misc support functions + */ + +/* include removed: duk_internal.h */ + +DUK_INTERNAL duk_bool_t duk_hobject_prototype_chain_contains(duk_hthread *thr, duk_hobject *h, duk_hobject *p, duk_bool_t ignore_loop) { + duk_uint_t sanity; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(h != NULL); + /* allow 'p' to be NULL; then the result is always false */ + + sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY; + do { + if (h == p) { + return 1; + } + + if (sanity-- == 0) { + if (ignore_loop) { + break; + } else { + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT); + } + } + h = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h); + } while (h); + + return 0; +} + +DUK_INTERNAL void duk_hobject_set_prototype(duk_hthread *thr, duk_hobject *h, duk_hobject *p) { +#ifdef DUK_USE_REFERENCE_COUNTING + duk_hobject *tmp; + + DUK_ASSERT(h); + tmp = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h); + DUK_HOBJECT_SET_PROTOTYPE(thr->heap, h, p); + DUK_HOBJECT_INCREF_ALLOWNULL(thr, p); /* avoid problems if p == h->prototype */ + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); +#else + DUK_ASSERT(h); + DUK_UNREF(thr); + DUK_HOBJECT_SET_PROTOTYPE(thr->heap, h, p); +#endif +} +#line 1 "duk_hobject_pc2line.c" +/* + * Helpers for creating and querying pc2line debug data, which + * converts a bytecode program counter to a source line number. + * + * The run-time pc2line data is bit-packed, and documented in: + * + * doc/function-objects.rst + */ + +/* include removed: duk_internal.h */ + +#if defined(DUK_USE_PC2LINE) + +/* Generate pc2line data for an instruction sequence, leaving a buffer on stack top. */ +DUK_INTERNAL void duk_hobject_pc2line_pack(duk_hthread *thr, duk_compiler_instr *instrs, duk_uint_fast32_t length) { + duk_context *ctx = (duk_context *) thr; + duk_hbuffer_dynamic *h_buf; + duk_bitencoder_ctx be_ctx_alloc; + duk_bitencoder_ctx *be_ctx = &be_ctx_alloc; + duk_uint32_t *hdr; + duk_size_t new_size; + duk_uint_fast32_t num_header_entries; + duk_uint_fast32_t curr_offset; + duk_int_fast32_t curr_line, next_line, diff_line; + duk_uint_fast32_t curr_pc; + duk_uint_fast32_t hdr_index; + + DUK_ASSERT(length <= DUK_COMPILER_MAX_BYTECODE_LENGTH); + + /* XXX: add proper spare handling to dynamic buffer, to minimize + * reallocs; currently there is no spare at all. + */ + + num_header_entries = (length + DUK_PC2LINE_SKIP - 1) / DUK_PC2LINE_SKIP; + curr_offset = (duk_uint_fast32_t) (sizeof(duk_uint32_t) + num_header_entries * sizeof(duk_uint32_t) * 2); + + duk_push_dynamic_buffer(ctx, (duk_size_t) curr_offset); + h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_buf != NULL); + DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf) && !DUK_HBUFFER_HAS_EXTERNAL(h_buf)); + + hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf); + DUK_ASSERT(hdr != NULL); + hdr[0] = (duk_uint32_t) length; /* valid pc range is [0, length[ */ + + curr_pc = 0U; + while (curr_pc < length) { + new_size = (duk_size_t) (curr_offset + DUK_PC2LINE_MAX_DIFF_LENGTH); + duk_hbuffer_resize(thr, h_buf, new_size); + + hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf); + DUK_ASSERT(hdr != NULL); + DUK_ASSERT(curr_pc < length); + hdr_index = 1 + (curr_pc / DUK_PC2LINE_SKIP) * 2; + curr_line = (duk_int_fast32_t) instrs[curr_pc].line; + hdr[hdr_index + 0] = (duk_uint32_t) curr_line; + hdr[hdr_index + 1] = (duk_uint32_t) curr_offset; + +#if 0 + DUK_DDD(DUK_DDDPRINT("hdr[%ld]: pc=%ld line=%ld offset=%ld", + (long) (curr_pc / DUK_PC2LINE_SKIP), + (long) curr_pc, + (long) hdr[hdr_index + 0], + (long) hdr[hdr_index + 1])); +#endif + + DUK_MEMZERO(be_ctx, sizeof(*be_ctx)); + be_ctx->data = ((duk_uint8_t *) hdr) + curr_offset; + be_ctx->length = (duk_size_t) DUK_PC2LINE_MAX_DIFF_LENGTH; + + for (;;) { + curr_pc++; + if ( ((curr_pc % DUK_PC2LINE_SKIP) == 0) || /* end of diff run */ + (curr_pc >= length) ) { /* end of bytecode */ + break; + } + DUK_ASSERT(curr_pc < length); + next_line = (duk_int32_t) instrs[curr_pc].line; + diff_line = next_line - curr_line; + +#if 0 + DUK_DDD(DUK_DDDPRINT("curr_line=%ld, next_line=%ld -> diff_line=%ld", + (long) curr_line, (long) next_line, (long) diff_line)); +#endif + + if (diff_line == 0) { + /* 0 */ + duk_be_encode(be_ctx, 0, 1); + } else if (diff_line >= 1 && diff_line <= 4) { + /* 1 0 <2 bits> */ + duk_be_encode(be_ctx, (0x02 << 2) + (diff_line - 1), 4); + } else if (diff_line >= -0x80 && diff_line <= 0x7f) { + /* 1 1 0 <8 bits> */ + DUK_ASSERT(diff_line + 0x80 >= 0 && diff_line + 0x80 <= 0xff); + duk_be_encode(be_ctx, (0x06 << 8) + (diff_line + 0x80), 11); + } else { + /* 1 1 1 <32 bits> + * Encode in two parts to avoid bitencode 24-bit limitation + */ + duk_be_encode(be_ctx, (0x07 << 16) + ((next_line >> 16) & 0xffffU), 19); + duk_be_encode(be_ctx, next_line & 0xffffU, 16); + } + + curr_line = next_line; + } + + duk_be_finish(be_ctx); + DUK_ASSERT(!be_ctx->truncated); + + /* be_ctx->offset == length of encoded bitstream */ + curr_offset += (duk_uint_fast32_t) be_ctx->offset; + } + + /* compact */ + new_size = (duk_size_t) curr_offset; + duk_hbuffer_resize(thr, h_buf, new_size); + + (void) duk_to_fixed_buffer(ctx, -1, NULL); + + DUK_DDD(DUK_DDDPRINT("final pc2line data: pc_limit=%ld, length=%ld, %lf bits/opcode --> %!ixT", + (long) length, (long) new_size, (double) new_size * 8.0 / (double) length, + (duk_tval *) duk_get_tval(ctx, -1))); +} + +/* PC is unsigned. If caller does PC arithmetic and gets a negative result, + * it will map to a large PC which is out of bounds and causes a zero to be + * returned. + */ +DUK_LOCAL duk_uint_fast32_t duk__hobject_pc2line_query_raw(duk_hthread *thr, duk_hbuffer_fixed *buf, duk_uint_fast32_t pc) { + duk_bitdecoder_ctx bd_ctx_alloc; + duk_bitdecoder_ctx *bd_ctx = &bd_ctx_alloc; + duk_uint32_t *hdr; + duk_uint_fast32_t start_offset; + duk_uint_fast32_t pc_limit; + duk_uint_fast32_t hdr_index; + duk_uint_fast32_t pc_base; + duk_uint_fast32_t n; + duk_uint_fast32_t curr_line; + + DUK_ASSERT(buf != NULL); + DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) buf) && !DUK_HBUFFER_HAS_EXTERNAL((duk_hbuffer *) buf)); + DUK_UNREF(thr); + + /* + * Use the index in the header to find the right starting point + */ + + hdr_index = pc / DUK_PC2LINE_SKIP; + pc_base = hdr_index * DUK_PC2LINE_SKIP; + n = pc - pc_base; + + if (DUK_HBUFFER_FIXED_GET_SIZE(buf) <= sizeof(duk_uint32_t)) { + DUK_DD(DUK_DDPRINT("pc2line lookup failed: buffer is smaller than minimal header")); + goto error; + } + + hdr = (duk_uint32_t *) (void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, buf); + pc_limit = hdr[0]; + if (pc >= pc_limit) { + /* Note: pc is unsigned and cannot be negative */ + DUK_DD(DUK_DDPRINT("pc2line lookup failed: pc out of bounds (pc=%ld, limit=%ld)", + (long) pc, (long) pc_limit)); + goto error; + } + + curr_line = hdr[1 + hdr_index * 2]; + start_offset = hdr[1 + hdr_index * 2 + 1]; + if ((duk_size_t) start_offset > DUK_HBUFFER_FIXED_GET_SIZE(buf)) { + DUK_DD(DUK_DDPRINT("pc2line lookup failed: start_offset out of bounds (start_offset=%ld, buffer_size=%ld)", + (long) start_offset, (long) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) buf))); + goto error; + } + + /* + * Iterate the bitstream (line diffs) until PC is reached + */ + + DUK_MEMZERO(bd_ctx, sizeof(*bd_ctx)); + bd_ctx->data = ((duk_uint8_t *) hdr) + start_offset; + bd_ctx->length = (duk_size_t) (DUK_HBUFFER_FIXED_GET_SIZE(buf) - start_offset); + +#if 0 + DUK_DDD(DUK_DDDPRINT("pc2line lookup: pc=%ld -> hdr_index=%ld, pc_base=%ld, n=%ld, start_offset=%ld", + (long) pc, (long) hdr_index, (long) pc_base, (long) n, (long) start_offset)); +#endif + + while (n > 0) { +#if 0 + DUK_DDD(DUK_DDDPRINT("lookup: n=%ld, curr_line=%ld", (long) n, (long) curr_line)); +#endif + + if (duk_bd_decode_flag(bd_ctx)) { + if (duk_bd_decode_flag(bd_ctx)) { + if (duk_bd_decode_flag(bd_ctx)) { + /* 1 1 1 <32 bits> */ + duk_uint_fast32_t t; + t = duk_bd_decode(bd_ctx, 16); /* workaround: max nbits = 24 now */ + t = (t << 16) + duk_bd_decode(bd_ctx, 16); + curr_line = t; + } else { + /* 1 1 0 <8 bits> */ + duk_uint_fast32_t t; + t = duk_bd_decode(bd_ctx, 8); + curr_line = curr_line + t - 0x80; + } + } else { + /* 1 0 <2 bits> */ + duk_uint_fast32_t t; + t = duk_bd_decode(bd_ctx, 2); + curr_line = curr_line + t + 1; + } + } else { + /* 0: no change */ + } + + n--; + } + + DUK_DDD(DUK_DDDPRINT("pc2line lookup result: pc %ld -> line %ld", (long) pc, (long) curr_line)); + return curr_line; + + error: + DUK_D(DUK_DPRINT("pc2line conversion failed for pc=%ld", (long) pc)); + return 0; +} + +DUK_INTERNAL duk_uint_fast32_t duk_hobject_pc2line_query(duk_context *ctx, duk_idx_t idx_func, duk_uint_fast32_t pc) { + duk_hbuffer_fixed *pc2line; + duk_uint_fast32_t line; + + /* XXX: now that pc2line is used by the debugger quite heavily in + * checked execution, this should be optimized to avoid value stack + * and perhaps also implement some form of pc2line caching (see + * future work in debugger.rst). + */ + + duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_PC2LINE); + pc2line = (duk_hbuffer_fixed *) duk_get_hbuffer(ctx, -1); + if (pc2line != NULL) { + DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) pc2line) && !DUK_HBUFFER_HAS_EXTERNAL((duk_hbuffer *) pc2line)); + line = duk__hobject_pc2line_query_raw((duk_hthread *) ctx, pc2line, (duk_uint_fast32_t) pc); + } else { + line = 0; + } + duk_pop(ctx); + + return line; +} + +#endif /* DUK_USE_PC2LINE */ +#line 1 "duk_hobject_props.c" +/* + * Hobject property set/get functionality. + * + * This is very central functionality for size, performance, and compliance. + * It is also rather intricate; see hobject-algorithms.rst for discussion on + * the algorithms and memory-management.rst for discussion on refcounts and + * side effect issues. + * + * Notes: + * + * - It might be tempting to assert "refcount nonzero" for objects + * being operated on, but that's not always correct: objects with + * a zero refcount may be operated on by the refcount implementation + * (finalization) for instance. Hence, no refcount assertions are made. + * + * - Many operations (memory allocation, identifier operations, etc) + * may cause arbitrary side effects (e.g. through GC and finalization). + * These side effects may invalidate duk_tval pointers which point to + * areas subject to reallocation (like value stack). Heap objects + * themselves have stable pointers. Holding heap object pointers or + * duk_tval copies is not problematic with respect to side effects; + * care must be taken when holding and using argument duk_tval pointers. + * + * - If a finalizer is executed, it may operate on the the same object + * we're currently dealing with. For instance, the finalizer might + * delete a certain property which has already been looked up and + * confirmed to exist. Ideally finalizers would be disabled if GC + * happens during property access. At the moment property table realloc + * disables finalizers, and all DECREFs may cause arbitrary changes so + * handle DECREF carefully. + * + * - The order of operations for a DECREF matters. When DECREF is executed, + * the entire object graph must be consistent; note that a refzero may + * lead to a mark-and-sweep through a refcount finalizer. + */ + +/* + * XXX: array indices are mostly typed as duk_uint32_t here; duk_uarridx_t + * might be more appropriate. + */ + +/* + * XXX: duk_uint_fast32_t should probably be used in many places here. + */ + +/* include removed: duk_internal.h */ + +/* + * Local defines + */ + +#define DUK__NO_ARRAY_INDEX DUK_HSTRING_NO_ARRAY_INDEX + +/* hash probe sequence */ +#define DUK__HASH_INITIAL(hash,h_size) DUK_HOBJECT_HASH_INITIAL((hash),(h_size)) +#define DUK__HASH_PROBE_STEP(hash) DUK_HOBJECT_HASH_PROBE_STEP((hash)) + +/* marker values for hash part */ +#define DUK__HASH_UNUSED DUK_HOBJECT_HASHIDX_UNUSED +#define DUK__HASH_DELETED DUK_HOBJECT_HASHIDX_DELETED + +/* valstack space that suffices for all local calls, including recursion + * of other than Duktape calls (getters etc) + */ +#define DUK__VALSTACK_SPACE 10 + +/* valstack space allocated especially for proxy lookup which does a + * recursive property lookup + */ +#define DUK__VALSTACK_PROXY_LOOKUP 20 + +/* + * Local prototypes + */ + +#define DUK__DESC_FLAG_PUSH_VALUE (1 << 0) /* push value to stack */ +#define DUK__DESC_FLAG_IGNORE_PROTOLOOP (1 << 1) /* don't throw for prototype loop */ + +DUK_LOCAL_DECL duk_bool_t duk__check_arguments_map_for_get(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc); +DUK_LOCAL_DECL void duk__check_arguments_map_for_put(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc, duk_bool_t throw_flag); +DUK_LOCAL_DECL void duk__check_arguments_map_for_delete(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc); + +DUK_LOCAL_DECL duk_bool_t duk__handle_put_array_length_smaller(duk_hthread *thr, duk_hobject *obj, duk_uint32_t old_len, duk_uint32_t new_len, duk_bool_t force_flag, duk_uint32_t *out_result_len); +DUK_LOCAL_DECL duk_bool_t duk__handle_put_array_length(duk_hthread *thr, duk_hobject *obj); + +DUK_LOCAL_DECL duk_bool_t duk__get_property_desc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags); +DUK_LOCAL_DECL duk_bool_t duk__get_own_property_desc_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_uint32_t arr_idx, duk_propdesc *out_desc, duk_small_uint_t flags); +DUK_LOCAL_DECL duk_bool_t duk__get_own_property_desc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags); +DUK_LOCAL duk_uint32_t duk__get_old_array_length(duk_hthread *thr, duk_hobject *obj, duk_propdesc *temp_desc); + +/* + * Misc helpers + */ + +/* Convert a duk_tval number (caller checks) to a 32-bit index. Returns + * DUK__NO_ARRAY_INDEX if the number is not whole or not a valid array + * index. + */ +/* XXX: for fastints, could use a variant which assumes a double duk_tval + * (and doesn't need to check for fastint again). + */ +DUK_LOCAL duk_uint32_t duk__tval_number_to_arr_idx(duk_tval *tv) { + duk_double_t dbl; + duk_uint32_t idx; + + DUK_ASSERT(tv != NULL); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + + dbl = DUK_TVAL_GET_NUMBER(tv); + idx = (duk_uint32_t) dbl; + if ((duk_double_t) idx == dbl) { + /* Is whole and within 32 bit range. If the value happens to be 0xFFFFFFFF, + * it's not a valid array index but will then match DUK__NO_ARRAY_INDEX. + */ + return idx; + } + return DUK__NO_ARRAY_INDEX; +} + +#if defined(DUK_USE_FASTINT) +/* Convert a duk_tval fastint (caller checks) to a 32-bit index. */ +DUK_LOCAL duk_uint32_t duk__tval_fastint_to_arr_idx(duk_tval *tv) { + duk_int64_t t; + + DUK_ASSERT(tv != NULL); + DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv)); + + t = DUK_TVAL_GET_FASTINT(tv); + if ((t & ~0xffffffffULL) != 0) { + /* Catches >0x100000000 and negative values. */ + return DUK__NO_ARRAY_INDEX; + } + + /* If the value happens to be 0xFFFFFFFF, it's not a valid array index + * but will then match DUK__NO_ARRAY_INDEX. + */ + return (duk_uint32_t) t; +} +#endif /* DUK_USE_FASTINT */ + +/* Push an arbitrary duk_tval to the stack, coerce it to string, and return + * both a duk_hstring pointer and an array index (or DUK__NO_ARRAY_INDEX). + */ +DUK_LOCAL duk_uint32_t duk__push_tval_to_hstring_arr_idx(duk_context *ctx, duk_tval *tv, duk_hstring **out_h) { + duk_uint32_t arr_idx; + duk_hstring *h; + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(tv != NULL); + DUK_ASSERT(out_h != NULL); + + duk_push_tval(ctx, tv); + duk_to_string(ctx, -1); + h = duk_get_hstring(ctx, -1); + DUK_ASSERT(h != NULL); + *out_h = h; + + arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(h); + return arr_idx; +} + +/* String is an own (virtual) property of a lightfunc. */ +DUK_LOCAL duk_bool_t duk__key_is_lightfunc_ownprop(duk_hthread *thr, duk_hstring *key) { + return (key == DUK_HTHREAD_STRING_LENGTH(thr) || + key == DUK_HTHREAD_STRING_NAME(thr)); +} + +/* + * Helpers for managing property storage size + */ + +/* Get default hash part size for a certain entry part size. */ +#if defined(DUK_USE_HOBJECT_HASH_PART) +DUK_LOCAL duk_uint32_t duk__get_default_h_size(duk_uint32_t e_size) { + DUK_ASSERT(e_size <= DUK_HOBJECT_MAX_PROPERTIES); + + if (e_size >= DUK_HOBJECT_E_USE_HASH_LIMIT) { + duk_uint32_t res; + + /* result: hash_prime(floor(1.2 * e_size)) */ + res = duk_util_get_hash_prime(e_size + e_size / DUK_HOBJECT_H_SIZE_DIVISOR); + + /* if fails, e_size will be zero = not an issue, except performance-wise */ + DUK_ASSERT(res == 0 || res > e_size); + return res; + } else { + return 0; + } +} +#endif /* USE_PROP_HASH_PART */ + +/* Get minimum entry part growth for a certain size. */ +DUK_LOCAL duk_uint32_t duk__get_min_grow_e(duk_uint32_t e_size) { + duk_uint32_t res; + + DUK_ASSERT(e_size <= DUK_HOBJECT_MAX_PROPERTIES); + + res = (e_size + DUK_HOBJECT_E_MIN_GROW_ADD) / DUK_HOBJECT_E_MIN_GROW_DIVISOR; + DUK_ASSERT(res >= 1); /* important for callers */ + return res; +} + +/* Get minimum array part growth for a certain size. */ +DUK_LOCAL duk_uint32_t duk__get_min_grow_a(duk_uint32_t a_size) { + duk_uint32_t res; + + DUK_ASSERT((duk_size_t) a_size <= DUK_HOBJECT_MAX_PROPERTIES); + + res = (a_size + DUK_HOBJECT_A_MIN_GROW_ADD) / DUK_HOBJECT_A_MIN_GROW_DIVISOR; + DUK_ASSERT(res >= 1); /* important for callers */ + return res; +} + +/* Count actually used entry part entries (non-NULL keys). */ +DUK_LOCAL duk_uint32_t duk__count_used_e_keys(duk_hthread *thr, duk_hobject *obj) { + duk_uint_fast32_t i; + duk_uint_fast32_t n = 0; + duk_hstring **e; + + DUK_ASSERT(obj != NULL); + DUK_UNREF(thr); + + e = DUK_HOBJECT_E_GET_KEY_BASE(thr->heap, obj); + for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) { + if (*e++) { + n++; + } + } + return (duk_uint32_t) n; +} + +/* Count actually used array part entries and array minimum size. + * NOTE: 'out_min_size' can be computed much faster by starting from the + * end and breaking out early when finding first used entry, but this is + * not needed now. + */ +DUK_LOCAL void duk__compute_a_stats(duk_hthread *thr, duk_hobject *obj, duk_uint32_t *out_used, duk_uint32_t *out_min_size) { + duk_uint_fast32_t i; + duk_uint_fast32_t used = 0; + duk_uint_fast32_t highest_idx = (duk_uint_fast32_t) -1; /* see below */ + duk_tval *a; + + DUK_ASSERT(obj != NULL); + DUK_ASSERT(out_used != NULL); + DUK_ASSERT(out_min_size != NULL); + DUK_UNREF(thr); + + a = DUK_HOBJECT_A_GET_BASE(thr->heap, obj); + for (i = 0; i < DUK_HOBJECT_GET_ASIZE(obj); i++) { + duk_tval *tv = a++; + if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + used++; + highest_idx = i; + } + } + + /* Initial value for highest_idx is -1 coerced to unsigned. This + * is a bit odd, but (highest_idx + 1) will then wrap to 0 below + * for out_min_size as intended. + */ + + *out_used = used; + *out_min_size = highest_idx + 1; /* 0 if no used entries */ +} + +/* Check array density and indicate whether or not the array part should be abandoned. */ +DUK_LOCAL duk_bool_t duk__abandon_array_density_check(duk_uint32_t a_used, duk_uint32_t a_size) { + /* + * Array abandon check; abandon if: + * + * new_used / new_size < limit + * new_used < limit * new_size || limit is 3 bits fixed point + * new_used < limit' / 8 * new_size || *8 + * 8*new_used < limit' * new_size || :8 + * new_used < limit' * (new_size / 8) + * + * Here, new_used = a_used, new_size = a_size. + * + * Note: some callers use approximate values for a_used and/or a_size + * (e.g. dropping a '+1' term). This doesn't affect the usefulness + * of the check, but may confuse debugging. + */ + + return (a_used < DUK_HOBJECT_A_ABANDON_LIMIT * (a_size >> 3)); +} + +/* Fast check for extending array: check whether or not a slow density check is required. */ +DUK_LOCAL duk_bool_t duk__abandon_array_slow_check_required(duk_uint32_t arr_idx, duk_uint32_t old_size) { + /* + * In a fast check we assume old_size equals old_used (i.e., existing + * array is fully dense). + * + * Slow check if: + * + * (new_size - old_size) / old_size > limit + * new_size - old_size > limit * old_size + * new_size > (1 + limit) * old_size || limit' is 3 bits fixed point + * new_size > (1 + (limit' / 8)) * old_size || * 8 + * 8 * new_size > (8 + limit') * old_size || : 8 + * new_size > (8 + limit') * (old_size / 8) + * new_size > limit'' * (old_size / 8) || limit'' = 9 -> max 25% increase + * arr_idx + 1 > limit'' * (old_size / 8) + * + * This check doesn't work well for small values, so old_size is rounded + * up for the check (and the '+ 1' of arr_idx can be ignored in practice): + * + * arr_idx > limit'' * ((old_size + 7) / 8) + */ + + return (arr_idx > DUK_HOBJECT_A_FAST_RESIZE_LIMIT * ((old_size + 7) >> 3)); +} + +/* + * Proxy helpers + */ + +#if defined(DUK_USE_ES6_PROXY) +DUK_INTERNAL duk_bool_t duk_hobject_proxy_check(duk_hthread *thr, duk_hobject *obj, duk_hobject **out_target, duk_hobject **out_handler) { + duk_tval *tv_target; + duk_tval *tv_handler; + duk_hobject *h_target; + duk_hobject *h_handler; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(out_target != NULL); + DUK_ASSERT(out_handler != NULL); + + /* Caller doesn't need to check exotic proxy behavior (but does so for + * some fast paths). + */ + if (DUK_LIKELY(!DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) { + return 0; + } + + tv_handler = duk_hobject_find_existing_entry_tval_ptr(thr->heap, obj, DUK_HTHREAD_STRING_INT_HANDLER(thr)); + if (!tv_handler) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REVOKED); + return 0; + } + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_handler)); + h_handler = DUK_TVAL_GET_OBJECT(tv_handler); + DUK_ASSERT(h_handler != NULL); + *out_handler = h_handler; + tv_handler = NULL; /* avoid issues with relocation */ + + tv_target = duk_hobject_find_existing_entry_tval_ptr(thr->heap, obj, DUK_HTHREAD_STRING_INT_TARGET(thr)); + if (!tv_target) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REVOKED); + return 0; + } + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_target)); + h_target = DUK_TVAL_GET_OBJECT(tv_target); + DUK_ASSERT(h_target != NULL); + *out_target = h_target; + tv_target = NULL; /* avoid issues with relocation */ + + return 1; +} +#endif /* DUK_USE_ES6_PROXY */ + +/* Get Proxy target object. If the argument is not a Proxy, return it as is. + * If a Proxy is revoked, an error is thrown. + */ +#if defined(DUK_USE_ES6_PROXY) +DUK_INTERNAL duk_hobject *duk_hobject_resolve_proxy_target(duk_hthread *thr, duk_hobject *obj) { + duk_hobject *h_target; + duk_hobject *h_handler; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + + /* Resolve Proxy targets until Proxy chain ends. No explicit check for + * a Proxy loop: user code cannot create such a loop without tweaking + * internal properties directly. + */ + + while (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) { + if (duk_hobject_proxy_check(thr, obj, &h_target, &h_handler)) { + DUK_ASSERT(h_target != NULL); + obj = h_target; + } else { + break; + } + } + + DUK_ASSERT(obj != NULL); + return obj; +} +#endif /* DUK_USE_ES6_PROXY */ + +#if defined(DUK_USE_ES6_PROXY) +DUK_LOCAL duk_bool_t duk__proxy_check_prop(duk_hthread *thr, duk_hobject *obj, duk_small_uint_t stridx_trap, duk_tval *tv_key, duk_hobject **out_target) { + duk_context *ctx = (duk_context *) thr; + duk_hobject *h_handler; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(tv_key != NULL); + DUK_ASSERT(out_target != NULL); + + if (!duk_hobject_proxy_check(thr, obj, out_target, &h_handler)) { + return 0; + } + DUK_ASSERT(*out_target != NULL); + DUK_ASSERT(h_handler != NULL); + + /* XXX: At the moment Duktape accesses internal keys like _Finalizer using a + * normal property set/get which would allow a proxy handler to interfere with + * such behavior and to get access to internal key strings. This is not a problem + * as such because internal key strings can be created in other ways too (e.g. + * through buffers). The best fix is to change Duktape internal lookups to + * skip proxy behavior. Until that, internal property accesses bypass the + * proxy and are applied to the target (as if the handler did not exist). + * This has some side effects, see test-bi-proxy-internal-keys.js. + */ + + if (DUK_TVAL_IS_STRING(tv_key)) { + duk_hstring *h_key = (duk_hstring *) DUK_TVAL_GET_STRING(tv_key); + DUK_ASSERT(h_key != NULL); + if (DUK_HSTRING_HAS_INTERNAL(h_key)) { + DUK_DDD(DUK_DDDPRINT("internal key, skip proxy handler and apply to target")); + return 0; + } + } + + /* The handler is looked up with a normal property lookup; it may be an + * accessor or the handler object itself may be a proxy object. If the + * handler is a proxy, we need to extend the valstack as we make a + * recursive proxy check without a function call in between (in fact + * there is no limit to the potential recursion here). + * + * (For sanity, proxy creation rejects another proxy object as either + * the handler or the target at the moment so recursive proxy cases + * are not realized now.) + */ + + /* XXX: C recursion limit if proxies are allowed as handler/target values */ + + duk_require_stack(ctx, DUK__VALSTACK_PROXY_LOOKUP); + duk_push_hobject(ctx, h_handler); + if (duk_get_prop_stridx(ctx, -1, stridx_trap)) { + /* -> [ ... handler trap ] */ + duk_insert(ctx, -2); /* -> [ ... trap handler ] */ + + /* stack prepped for func call: [ ... trap handler ] */ + return 1; + } else { + duk_pop_2(ctx); + return 0; + } +} +#endif /* DUK_USE_ES6_PROXY */ + +/* + * Reallocate property allocation, moving properties to the new allocation. + * + * Includes key compaction, rehashing, and can also optionally abandoning + * the array part, 'migrating' array entries into the beginning of the + * new entry part. Arguments are not validated here, so e.g. new_h_size + * MUST be a valid prime. + * + * There is no support for in-place reallocation or just compacting keys + * without resizing the property allocation. This is intentional to keep + * code size minimal. + * + * The implementation is relatively straightforward, except for the array + * abandonment process. Array abandonment requires that new string keys + * are interned, which may trigger GC. All keys interned so far must be + * reachable for GC at all times; valstack is used for that now. + * + * Also, a GC triggered during this reallocation process must not interfere + * with the object being resized. This is currently controlled by using + * heap->mark_and_sweep_base_flags to indicate that no finalizers will be + * executed (as they can affect ANY object) and no objects are compacted + * (it would suffice to protect this particular object only, though). + * + * Note: a non-checked variant would be nice but is a bit tricky to + * implement for the array abandonment process. It's easy for + * everything else. + * + * Note: because we need to potentially resize the valstack (as part + * of abandoning the array part), any tval pointers to the valstack + * will become invalid after this call. + */ + +DUK_LOCAL +void duk__realloc_props(duk_hthread *thr, + duk_hobject *obj, + duk_uint32_t new_e_size, + duk_uint32_t new_a_size, + duk_uint32_t new_h_size, + duk_bool_t abandon_array) { + duk_context *ctx = (duk_context *) thr; +#ifdef DUK_USE_MARK_AND_SWEEP + duk_small_uint_t prev_mark_and_sweep_base_flags; +#endif + duk_uint32_t new_alloc_size; + duk_uint32_t new_e_size_adjusted; + duk_uint8_t *new_p; + duk_hstring **new_e_k; + duk_propvalue *new_e_pv; + duk_uint8_t *new_e_f; + duk_tval *new_a; + duk_uint32_t *new_h; + duk_uint32_t new_e_next; + duk_uint_fast32_t i; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(!abandon_array || new_a_size == 0); /* if abandon_array, new_a_size must be 0 */ + DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL || (DUK_HOBJECT_GET_ESIZE(obj) == 0 && DUK_HOBJECT_GET_ASIZE(obj) == 0)); + DUK_ASSERT(new_h_size == 0 || new_h_size >= new_e_size); /* required to guarantee success of rehashing, + * intentionally use unadjusted new_e_size + */ + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + /* + * Pre resize assertions. + */ + +#ifdef DUK_USE_ASSERTIONS + /* XXX: pre-checks (such as no duplicate keys) */ +#endif + + /* + * For property layout 1, tweak e_size to ensure that the whole entry + * part (key + val + flags) is a suitable multiple for alignment + * (platform specific). + * + * Property layout 2 does not require this tweaking and is preferred + * on low RAM platforms requiring alignment. + */ + +#if defined(DUK_USE_HOBJECT_LAYOUT_2) || defined(DUK_USE_HOBJECT_LAYOUT_3) + DUK_DDD(DUK_DDDPRINT("using layout 2 or 3, no need to pad e_size: %ld", (long) new_e_size)); + new_e_size_adjusted = new_e_size; +#elif defined(DUK_USE_HOBJECT_LAYOUT_1) && (DUK_HOBJECT_ALIGN_TARGET == 1) + DUK_DDD(DUK_DDDPRINT("using layout 1, but no need to pad e_size: %ld", (long) new_e_size)); + new_e_size_adjusted = new_e_size; +#elif defined(DUK_USE_HOBJECT_LAYOUT_1) && ((DUK_HOBJECT_ALIGN_TARGET == 4) || (DUK_HOBJECT_ALIGN_TARGET == 8)) + new_e_size_adjusted = (new_e_size + DUK_HOBJECT_ALIGN_TARGET - 1) & (~(DUK_HOBJECT_ALIGN_TARGET - 1)); + DUK_DDD(DUK_DDDPRINT("using layout 1, and alignment target is %ld, adjusted e_size: %ld -> %ld", + (long) DUK_HOBJECT_ALIGN_TARGET, (long) new_e_size, (long) new_e_size_adjusted)); + DUK_ASSERT(new_e_size_adjusted >= new_e_size); +#else +#error invalid hobject layout defines +#endif + + /* + * Debug logging after adjustment. + */ + + DUK_DDD(DUK_DDDPRINT("attempt to resize hobject %p props (%ld -> %ld bytes), from {p=%p,e_size=%ld,e_next=%ld,a_size=%ld,h_size=%ld} to " + "{e_size=%ld,a_size=%ld,h_size=%ld}, abandon_array=%ld, unadjusted new_e_size=%ld", + (void *) obj, + (long) DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj), + DUK_HOBJECT_GET_ASIZE(obj), + DUK_HOBJECT_GET_HSIZE(obj)), + (long) DUK_HOBJECT_P_COMPUTE_SIZE(new_e_size_adjusted, new_a_size, new_h_size), + (void *) DUK_HOBJECT_GET_PROPS(thr->heap, obj), + (long) DUK_HOBJECT_GET_ESIZE(obj), + (long) DUK_HOBJECT_GET_ENEXT(obj), + (long) DUK_HOBJECT_GET_ASIZE(obj), + (long) DUK_HOBJECT_GET_HSIZE(obj), + (long) new_e_size_adjusted, + (long) new_a_size, + (long) new_h_size, + (long) abandon_array, + (long) new_e_size)); + + /* + * Property count check. This is the only point where we ensure that + * we don't get more (allocated) property space that we can handle. + * There aren't hard limits as such, but some algorithms fail (e.g. + * finding next higher prime, selecting hash part size) if we get too + * close to the 4G property limit. + * + * Since this works based on allocation size (not actually used size), + * the limit is a bit approximate but good enough in practice. + */ + + if (new_e_size_adjusted + new_a_size > DUK_HOBJECT_MAX_PROPERTIES) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_OBJECT_PROPERTY_LIMIT); + } + + /* + * Compute new alloc size and alloc new area. + * + * The new area is allocated as a dynamic buffer and placed into the + * valstack for reachability. The actual buffer is then detached at + * the end. + * + * Note: heap_mark_and_sweep_base_flags are altered here to ensure + * no-one touches this object while we're resizing and rehashing it. + * The flags must be reset on every exit path after it. Finalizers + * and compaction is prevented currently for all objects while it + * would be enough to restrict it only for the current object. + */ + +#ifdef DUK_USE_MARK_AND_SWEEP + prev_mark_and_sweep_base_flags = thr->heap->mark_and_sweep_base_flags; + thr->heap->mark_and_sweep_base_flags |= + DUK_MS_FLAG_NO_FINALIZERS | /* avoid attempts to add/remove object keys */ + DUK_MS_FLAG_NO_OBJECT_COMPACTION; /* avoid attempt to compact the current object */ +#endif + + new_alloc_size = DUK_HOBJECT_P_COMPUTE_SIZE(new_e_size_adjusted, new_a_size, new_h_size); + DUK_DDD(DUK_DDDPRINT("new hobject allocation size is %ld", (long) new_alloc_size)); + if (new_alloc_size == 0) { + /* for zero size, don't push anything on valstack */ + DUK_ASSERT(new_e_size_adjusted == 0); + DUK_ASSERT(new_a_size == 0); + DUK_ASSERT(new_h_size == 0); + new_p = NULL; + } else { + /* This may trigger mark-and-sweep with arbitrary side effects, + * including an attempted resize of the object we're resizing, + * executing a finalizer which may add or remove properties of + * the object we're resizing etc. + */ + + /* Note: buffer is dynamic so that we can 'steal' the actual + * allocation later. + */ + + new_p = (duk_uint8_t *) duk_push_dynamic_buffer(ctx, new_alloc_size); /* errors out if out of memory */ + DUK_ASSERT(new_p != NULL); /* since new_alloc_size > 0 */ + } + + /* Set up pointers to the new property area: this is hidden behind a macro + * because it is memory layout specific. + */ + DUK_HOBJECT_P_SET_REALLOC_PTRS(new_p, new_e_k, new_e_pv, new_e_f, new_a, new_h, + new_e_size_adjusted, new_a_size, new_h_size); + DUK_UNREF(new_h); /* happens when hash part dropped */ + new_e_next = 0; + + /* if new_p == NULL, all of these pointers are NULL */ + DUK_ASSERT((new_p != NULL) || + (new_e_k == NULL && new_e_pv == NULL && new_e_f == NULL && + new_a == NULL && new_h == NULL)); + + DUK_DDD(DUK_DDDPRINT("new alloc size %ld, new_e_k=%p, new_e_pv=%p, new_e_f=%p, new_a=%p, new_h=%p", + (long) new_alloc_size, (void *) new_e_k, (void *) new_e_pv, (void *) new_e_f, + (void *) new_a, (void *) new_h)); + + /* + * Migrate array to start of entries if requested. + * + * Note: from an enumeration perspective the order of entry keys matters. + * Array keys should appear wherever they appeared before the array abandon + * operation. + */ + + if (abandon_array) { + /* + * Note: assuming new_a_size == 0, and that entry part contains + * no conflicting keys, refcounts do not need to be adjusted for + * the values, as they remain exactly the same. + * + * The keys, however, need to be interned, incref'd, and be + * reachable for GC. Any intern attempt may trigger a GC and + * claim any non-reachable strings, so every key must be reachable + * at all times. + * + * A longjmp must not occur here, as the new_p allocation would + * be freed without these keys being decref'd, hence the messy + * decref handling if intern fails. + */ + DUK_ASSERT(new_a_size == 0); + + for (i = 0; i < DUK_HOBJECT_GET_ASIZE(obj); i++) { + duk_tval *tv1; + duk_tval *tv2; + duk_hstring *key; + + DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL); + + tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i); + if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv1)) { + continue; + } + + DUK_ASSERT(new_p != NULL && new_e_k != NULL && + new_e_pv != NULL && new_e_f != NULL); + + /* + * Intern key via the valstack to ensure reachability behaves + * properly. We must avoid longjmp's here so use non-checked + * primitives. + * + * Note: duk_check_stack() potentially reallocs the valstack, + * invalidating any duk_tval pointers to valstack. Callers + * must be careful. + */ + + /* never shrinks; auto-adds DUK_VALSTACK_INTERNAL_EXTRA, which is generous */ + if (!duk_check_stack(ctx, 1)) { + goto abandon_error; + } + DUK_ASSERT_VALSTACK_SPACE(thr, 1); + key = duk_heap_string_intern_u32(thr->heap, i); + if (!key) { + goto abandon_error; + } + duk_push_hstring(ctx, key); /* keep key reachable for GC etc; guaranteed not to fail */ + + /* key is now reachable in the valstack */ + + DUK_HSTRING_INCREF(thr, key); /* second incref for the entry reference */ + new_e_k[new_e_next] = key; + tv2 = &new_e_pv[new_e_next].v; /* array entries are all plain values */ + DUK_TVAL_SET_TVAL(tv2, tv1); + new_e_f[new_e_next] = DUK_PROPDESC_FLAG_WRITABLE | + DUK_PROPDESC_FLAG_ENUMERABLE | + DUK_PROPDESC_FLAG_CONFIGURABLE; + new_e_next++; + + /* Note: new_e_next matches pushed temp key count, and nothing can + * fail above between the push and this point. + */ + } + + DUK_DDD(DUK_DDDPRINT("abandon array: pop %ld key temps from valstack", (long) new_e_next)); + duk_pop_n(ctx, new_e_next); + } + + /* + * Copy keys and values in the entry part (compacting them at the same time). + */ + + for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) { + duk_hstring *key; + + DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL); + + key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i); + if (!key) { + continue; + } + + DUK_ASSERT(new_p != NULL && new_e_k != NULL && + new_e_pv != NULL && new_e_f != NULL); + + new_e_k[new_e_next] = key; + new_e_pv[new_e_next] = DUK_HOBJECT_E_GET_VALUE(thr->heap, obj, i); + new_e_f[new_e_next] = DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, i); + new_e_next++; + } + /* the entries [new_e_next, new_e_size_adjusted[ are left uninitialized on purpose (ok, not gc reachable) */ + + /* + * Copy array elements to new array part. + */ + + if (new_a_size > DUK_HOBJECT_GET_ASIZE(obj)) { + /* copy existing entries as is */ + DUK_ASSERT(new_p != NULL && new_a != NULL); + if (DUK_HOBJECT_GET_ASIZE(obj) > 0) { + /* Avoid zero copy with an invalid pointer. If obj->p is NULL, + * the 'new_a' pointer will be invalid which is not allowed even + * when copy size is zero. + */ + DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL); + DUK_ASSERT(DUK_HOBJECT_GET_ASIZE(obj) > 0); + DUK_MEMCPY((void *) new_a, (void *) DUK_HOBJECT_A_GET_BASE(thr->heap, obj), sizeof(duk_tval) * DUK_HOBJECT_GET_ASIZE(obj)); + } + + /* fill new entries with -unused- (required, gc reachable) */ + for (i = DUK_HOBJECT_GET_ASIZE(obj); i < new_a_size; i++) { + duk_tval *tv = &new_a[i]; + DUK_TVAL_SET_UNDEFINED_UNUSED(tv); + } + } else { +#ifdef DUK_USE_ASSERTIONS + /* caller must have decref'd values above new_a_size (if that is necessary) */ + if (!abandon_array) { + for (i = new_a_size; i < DUK_HOBJECT_GET_ASIZE(obj); i++) { + duk_tval *tv; + tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i); + + /* current assertion is quite strong: decref's and set to unused */ + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv)); + } + } +#endif + if (new_a_size > 0) { + /* Avoid zero copy with an invalid pointer. If obj->p is NULL, + * the 'new_a' pointer will be invalid which is not allowed even + * when copy size is zero. + */ + DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL); + DUK_ASSERT(new_a_size > 0); + DUK_MEMCPY((void *) new_a, (void *) DUK_HOBJECT_A_GET_BASE(thr->heap, obj), sizeof(duk_tval) * new_a_size); + } + } + + /* + * Rebuild the hash part always from scratch (guaranteed to finish). + * + * Any resize of hash part requires rehashing. In addition, by rehashing + * get rid of any elements marked deleted (DUK__HASH_DELETED) which is critical + * to ensuring the hash part never fills up. + */ + +#if defined(DUK_USE_HOBJECT_HASH_PART) + if (DUK_UNLIKELY(new_h_size > 0)) { + DUK_ASSERT(new_h != NULL); + + /* fill new_h with u32 0xff = UNUSED */ + DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL); + DUK_ASSERT(new_h_size > 0); + DUK_MEMSET(new_h, 0xff, sizeof(duk_uint32_t) * new_h_size); + + DUK_ASSERT(new_e_next <= new_h_size); /* equality not actually possible */ + for (i = 0; i < new_e_next; i++) { + duk_hstring *key = new_e_k[i]; + duk_uint32_t j, step; + + DUK_ASSERT(key != NULL); + j = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), new_h_size); + step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(key)); + + for (;;) { + DUK_ASSERT(new_h[j] != DUK__HASH_DELETED); /* should never happen */ + if (new_h[j] == DUK__HASH_UNUSED) { + DUK_DDD(DUK_DDDPRINT("rebuild hit %ld -> %ld", (long) j, (long) i)); + new_h[j] = i; + break; + } + DUK_DDD(DUK_DDDPRINT("rebuild miss %ld, step %ld", (long) j, (long) step)); + j = (j + step) % new_h_size; + + /* guaranteed to finish */ + DUK_ASSERT(j != (duk_uint32_t) DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), new_h_size)); + } + } + } else { + DUK_DDD(DUK_DDDPRINT("no hash part, no rehash")); + } +#endif /* DUK_USE_HOBJECT_HASH_PART */ + + /* + * Nice debug log. + */ + + DUK_DD(DUK_DDPRINT("resized hobject %p props (%ld -> %ld bytes), from {p=%p,e_size=%ld,e_next=%ld,a_size=%ld,h_size=%ld} to " + "{p=%p,e_size=%ld,e_next=%ld,a_size=%ld,h_size=%ld}, abandon_array=%ld, unadjusted new_e_size=%ld", + (void *) obj, + (long) DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj), + DUK_HOBJECT_GET_ASIZE(obj), + DUK_HOBJECT_GET_HSIZE(obj)), + (long) new_alloc_size, + (void *) DUK_HOBJECT_GET_PROPS(thr->heap, obj), + (long) DUK_HOBJECT_GET_ESIZE(obj), + (long) DUK_HOBJECT_GET_ENEXT(obj), + (long) DUK_HOBJECT_GET_ASIZE(obj), + (long) DUK_HOBJECT_GET_HSIZE(obj), + (void *) new_p, + (long) new_e_size_adjusted, + (long) new_e_next, + (long) new_a_size, + (long) new_h_size, + (long) abandon_array, + (long) new_e_size)); + + /* + * All done, switch properties ('p') allocation to new one. + */ + + DUK_FREE(thr->heap, DUK_HOBJECT_GET_PROPS(thr->heap, obj)); /* NULL obj->p is OK */ + DUK_HOBJECT_SET_PROPS(thr->heap, obj, new_p); + DUK_HOBJECT_SET_ESIZE(obj, new_e_size_adjusted); + DUK_HOBJECT_SET_ENEXT(obj, new_e_next); + DUK_HOBJECT_SET_ASIZE(obj, new_a_size); + DUK_HOBJECT_SET_HSIZE(obj, new_h_size); + + if (new_p) { + /* + * Detach actual buffer from dynamic buffer in valstack, and + * pop it from the stack. + * + * XXX: the buffer object is certainly not reachable at this point, + * so it would be nice to free it forcibly even with only + * mark-and-sweep enabled. Not a big issue though. + */ + (void) duk_steal_buffer(ctx, -1, NULL); + duk_pop(ctx); + } else { + DUK_ASSERT(new_alloc_size == 0); + /* no need to pop, nothing was pushed */ + } + + /* clear array part flag only after switching */ + if (abandon_array) { + DUK_HOBJECT_CLEAR_ARRAY_PART(obj); + } + + DUK_DDD(DUK_DDDPRINT("resize result: %!O", (duk_heaphdr *) obj)); + +#ifdef DUK_USE_MARK_AND_SWEEP + thr->heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags; +#endif + + /* + * Post resize assertions. + */ + +#ifdef DUK_USE_ASSERTIONS + /* XXX: post-checks (such as no duplicate keys) */ +#endif + return; + + /* + * Abandon array failed, need to decref keys already inserted + * into the beginning of new_e_k before unwinding valstack. + */ + + abandon_error: + DUK_D(DUK_DPRINT("hobject resize failed during abandon array, decref keys")); + i = new_e_next; + while (i > 0) { + i--; + DUK_ASSERT(new_e_k != NULL); + DUK_ASSERT(new_e_k[i] != NULL); + DUK_HSTRING_DECREF(thr, new_e_k[i]); + } + +#ifdef DUK_USE_MARK_AND_SWEEP + thr->heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags; +#endif + + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_OBJECT_RESIZE_FAILED); +} + +/* + * Helpers to resize properties allocation on specific needs. + */ + +/* Grow entry part allocation for one additional entry. */ +DUK_LOCAL void duk__grow_props_for_new_entry_item(duk_hthread *thr, duk_hobject *obj) { + duk_uint32_t old_e_used; /* actually used, non-NULL entries */ + duk_uint32_t new_e_size; + duk_uint32_t new_a_size; + duk_uint32_t new_h_size; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + + /* Duktape 0.11.0 and prior tried to optimize the resize by not + * counting the number of actually used keys prior to the resize. + * This worked mostly well but also caused weird leak-like behavior + * as in: test-bug-object-prop-alloc-unbounded.js. So, now we count + * the keys explicitly to compute the new entry part size. + */ + + old_e_used = duk__count_used_e_keys(thr, obj); + new_e_size = old_e_used + duk__get_min_grow_e(old_e_used); +#if defined(DUK_USE_HOBJECT_HASH_PART) + new_h_size = duk__get_default_h_size(new_e_size); +#else + new_h_size = 0; +#endif + new_a_size = DUK_HOBJECT_GET_ASIZE(obj); + DUK_ASSERT(new_e_size >= old_e_used + 1); /* duk__get_min_grow_e() is always >= 1 */ + + duk__realloc_props(thr, obj, new_e_size, new_a_size, new_h_size, 0); +} + +/* Grow array part for a new highest array index. */ +DUK_LOCAL void duk__grow_props_for_array_item(duk_hthread *thr, duk_hobject *obj, duk_uint32_t highest_arr_idx) { + duk_uint32_t new_e_size; + duk_uint32_t new_a_size; + duk_uint32_t new_h_size; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(highest_arr_idx >= DUK_HOBJECT_GET_ASIZE(obj)); + + /* minimum new length is highest_arr_idx + 1 */ + + new_e_size = DUK_HOBJECT_GET_ESIZE(obj); + new_h_size = DUK_HOBJECT_GET_HSIZE(obj); + new_a_size = highest_arr_idx + duk__get_min_grow_a(highest_arr_idx); + DUK_ASSERT(new_a_size >= highest_arr_idx + 1); /* duk__get_min_grow_a() is always >= 1 */ + + duk__realloc_props(thr, obj, new_e_size, new_a_size, new_h_size, 0); +} + +/* Abandon array part, moving array entries into entries part. + * This requires a props resize, which is a heavy operation. + * We also compact the entries part while we're at it, although + * this is not strictly required. + */ +DUK_LOCAL void duk__abandon_array_checked(duk_hthread *thr, duk_hobject *obj) { + duk_uint32_t new_e_size; + duk_uint32_t new_a_size; + duk_uint32_t new_h_size; + duk_uint32_t e_used; /* actually used, non-NULL keys */ + duk_uint32_t a_used; + duk_uint32_t a_size; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + + e_used = duk__count_used_e_keys(thr, obj); + duk__compute_a_stats(thr, obj, &a_used, &a_size); + + /* + * Must guarantee all actually used array entries will fit into + * new entry part. Add one growth step to ensure we don't run out + * of space right away. + */ + + new_e_size = e_used + a_used; + new_e_size = new_e_size + duk__get_min_grow_e(new_e_size); + new_a_size = 0; +#if defined(DUK_USE_HOBJECT_HASH_PART) + new_h_size = duk__get_default_h_size(new_e_size); +#else + new_h_size = 0; +#endif + + DUK_DD(DUK_DDPRINT("abandon array part for hobject %p, " + "array stats before: e_used=%ld, a_used=%ld, a_size=%ld; " + "resize to e_size=%ld, a_size=%ld, h_size=%ld", + (void *) obj, (long) e_used, (long) a_used, (long) a_size, + (long) new_e_size, (long) new_a_size, (long) new_h_size)); + + duk__realloc_props(thr, obj, new_e_size, new_a_size, new_h_size, 1); +} + +/* + * Compact an object. Minimizes allocation size for objects which are + * not likely to be extended. This is useful for internal and non- + * extensible objects, but can also be called for non-extensible objects. + * May abandon the array part if it is computed to be too sparse. + * + * This call is relatively expensive, as it needs to scan both the + * entries and the array part. + * + * The call may fail due to allocation error. + */ + +DUK_INTERNAL void duk_hobject_compact_props(duk_hthread *thr, duk_hobject *obj) { + duk_uint32_t e_size; /* currently used -> new size */ + duk_uint32_t a_size; /* currently required */ + duk_uint32_t a_used; /* actually used */ + duk_uint32_t h_size; + duk_bool_t abandon_array; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + + e_size = duk__count_used_e_keys(thr, obj); + duk__compute_a_stats(thr, obj, &a_used, &a_size); + + DUK_DD(DUK_DDPRINT("compacting hobject, used e keys %ld, used a keys %ld, min a size %ld, " + "resized array density would be: %ld/%ld = %lf", + (long) e_size, (long) a_used, (long) a_size, + (long) a_used, (long) a_size, + (double) a_used / (double) a_size)); + + if (duk__abandon_array_density_check(a_used, a_size)) { + DUK_DD(DUK_DDPRINT("decided to abandon array during compaction, a_used=%ld, a_size=%ld", + (long) a_used, (long) a_size)); + abandon_array = 1; + e_size += a_used; + a_size = 0; + } else { + DUK_DD(DUK_DDPRINT("decided to keep array during compaction")); + abandon_array = 0; + } + +#if defined(DUK_USE_HOBJECT_HASH_PART) + if (e_size >= DUK_HOBJECT_E_USE_HASH_LIMIT) { + h_size = duk__get_default_h_size(e_size); + } else { + h_size = 0; + } +#else + h_size = 0; +#endif + + DUK_DD(DUK_DDPRINT("compacting hobject -> new e_size %ld, new a_size=%ld, new h_size=%ld, abandon_array=%ld", + (long) e_size, (long) a_size, (long) h_size, (long) abandon_array)); + + duk__realloc_props(thr, obj, e_size, a_size, h_size, abandon_array); +} + +/* + * Find an existing key from entry part either by linear scan or by + * using the hash index (if it exists). + * + * Sets entry index (and possibly the hash index) to output variables, + * which allows the caller to update the entry and hash entries in-place. + * If entry is not found, both values are set to -1. If entry is found + * but there is no hash part, h_idx is set to -1. + */ + +DUK_INTERNAL void duk_hobject_find_existing_entry(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_int_t *e_idx, duk_int_t *h_idx) { + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + DUK_ASSERT(e_idx != NULL); + DUK_ASSERT(h_idx != NULL); + DUK_UNREF(heap); + + if (DUK_LIKELY(DUK_HOBJECT_GET_HSIZE(obj) == 0)) + { + /* Linear scan: more likely because most objects are small. + * This is an important fast path. + * + * XXX: this might be worth inlining for property lookups. + */ + duk_uint_fast32_t i; + duk_uint_fast32_t n; + duk_hstring **h_keys_base; + DUK_DDD(DUK_DDDPRINT("duk_hobject_find_existing_entry() using linear scan for lookup")); + + h_keys_base = DUK_HOBJECT_E_GET_KEY_BASE(heap, obj); + n = DUK_HOBJECT_GET_ENEXT(obj); + for (i = 0; i < n; i++) { + if (h_keys_base[i] == key) { + *e_idx = i; + *h_idx = -1; + return; + } + } + } +#if defined(DUK_USE_HOBJECT_HASH_PART) + else + { + /* hash lookup */ + duk_uint32_t n; + duk_uint32_t i, step; + duk_uint32_t *h_base; + + DUK_DDD(DUK_DDDPRINT("duk_hobject_find_existing_entry() using hash part for lookup")); + + h_base = DUK_HOBJECT_H_GET_BASE(heap, obj); + n = DUK_HOBJECT_GET_HSIZE(obj); + i = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), n); + step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(key)); + + for (;;) { + duk_uint32_t t; + + DUK_ASSERT_DISABLE(i >= 0); /* unsigned */ + DUK_ASSERT(i < DUK_HOBJECT_GET_HSIZE(obj)); + t = h_base[i]; + DUK_ASSERT(t == DUK__HASH_UNUSED || t == DUK__HASH_DELETED || + (t < DUK_HOBJECT_GET_ESIZE(obj))); /* t >= 0 always true, unsigned */ + + if (t == DUK__HASH_UNUSED) { + break; + } else if (t == DUK__HASH_DELETED) { + DUK_DDD(DUK_DDDPRINT("lookup miss (deleted) i=%ld, t=%ld", + (long) i, (long) t)); + } else { + DUK_ASSERT(t < DUK_HOBJECT_GET_ESIZE(obj)); + if (DUK_HOBJECT_E_GET_KEY(heap, obj, t) == key) { + DUK_DDD(DUK_DDDPRINT("lookup hit i=%ld, t=%ld -> key %p", + (long) i, (long) t, (void *) key)); + *e_idx = t; + *h_idx = i; + return; + } + DUK_DDD(DUK_DDDPRINT("lookup miss i=%ld, t=%ld", + (long) i, (long) t)); + } + i = (i + step) % n; + + /* guaranteed to finish, as hash is never full */ + DUK_ASSERT(i != (duk_uint32_t) DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), n)); + } + } +#endif /* DUK_USE_HOBJECT_HASH_PART */ + + /* not found */ + *e_idx = -1; + *h_idx = -1; +} + +/* For internal use: get non-accessor entry value */ +DUK_INTERNAL duk_tval *duk_hobject_find_existing_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_hstring *key) { + duk_int_t e_idx; + duk_int_t h_idx; + + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + DUK_UNREF(heap); + + duk_hobject_find_existing_entry(heap, obj, key, &e_idx, &h_idx); + if (e_idx >= 0 && !DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, obj, e_idx)) { + return DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx); + } else { + return NULL; + } +} + +/* For internal use: get non-accessor entry value and attributes */ +DUK_INTERNAL duk_tval *duk_hobject_find_existing_entry_tval_ptr_and_attrs(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_int_t *out_attrs) { + duk_int_t e_idx; + duk_int_t h_idx; + + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + DUK_ASSERT(out_attrs != NULL); + DUK_UNREF(heap); + + duk_hobject_find_existing_entry(heap, obj, key, &e_idx, &h_idx); + if (e_idx >= 0 && !DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, obj, e_idx)) { + *out_attrs = DUK_HOBJECT_E_GET_FLAGS(heap, obj, e_idx); + return DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx); + } else { + *out_attrs = 0; + return NULL; + } +} + +/* For internal use: get array part value */ +DUK_INTERNAL duk_tval *duk_hobject_find_existing_array_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_uarridx_t i) { + duk_tval *tv; + + DUK_ASSERT(obj != NULL); + DUK_UNREF(heap); + + if (!DUK_HOBJECT_HAS_ARRAY_PART(obj)) { + return NULL; + } + if (i >= DUK_HOBJECT_GET_ASIZE(obj)) { + return NULL; + } + tv = DUK_HOBJECT_A_GET_VALUE_PTR(heap, obj, i); + return tv; +} + +/* + * Allocate and initialize a new entry, resizing the properties allocation + * if necessary. Returns entry index (e_idx) or throws an error if alloc fails. + * + * Sets the key of the entry (increasing the key's refcount), and updates + * the hash part if it exists. Caller must set value and flags, and update + * the entry value refcount. A decref for the previous value is not necessary. + */ + +DUK_LOCAL duk_bool_t duk__alloc_entry_checked(duk_hthread *thr, duk_hobject *obj, duk_hstring *key) { + duk_uint32_t idx; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + DUK_ASSERT(DUK_HOBJECT_GET_ENEXT(obj) <= DUK_HOBJECT_GET_ESIZE(obj)); + +#ifdef DUK_USE_ASSERTIONS + /* key must not already exist in entry part */ + { + duk_uint_fast32_t i; + for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) { + DUK_ASSERT(DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i) != key); + } + } +#endif + + if (DUK_HOBJECT_GET_ENEXT(obj) >= DUK_HOBJECT_GET_ESIZE(obj)) { + /* only need to guarantee 1 more slot, but allocation growth is in chunks */ + DUK_DDD(DUK_DDDPRINT("entry part full, allocate space for one more entry")); + duk__grow_props_for_new_entry_item(thr, obj); + } + DUK_ASSERT(DUK_HOBJECT_GET_ENEXT(obj) < DUK_HOBJECT_GET_ESIZE(obj)); + idx = DUK_HOBJECT_POSTINC_ENEXT(obj); + + /* previous value is assumed to be garbage, so don't touch it */ + DUK_HOBJECT_E_SET_KEY(thr->heap, obj, idx, key); + DUK_HSTRING_INCREF(thr, key); + +#if defined(DUK_USE_HOBJECT_HASH_PART) + if (DUK_UNLIKELY(DUK_HOBJECT_GET_HSIZE(obj) > 0)) { + duk_uint32_t n; + duk_uint32_t i, step; + duk_uint32_t *h_base = DUK_HOBJECT_H_GET_BASE(thr->heap, obj); + + n = DUK_HOBJECT_GET_HSIZE(obj); + i = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), n); + step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(key)); + + for (;;) { + duk_uint32_t t = h_base[i]; + if (t == DUK__HASH_UNUSED || t == DUK__HASH_DELETED) { + DUK_DDD(DUK_DDDPRINT("duk__alloc_entry_checked() inserted key into hash part, %ld -> %ld", + (long) i, (long) idx)); + DUK_ASSERT_DISABLE(i >= 0); /* unsigned */ + DUK_ASSERT(i < DUK_HOBJECT_GET_HSIZE(obj)); + DUK_ASSERT_DISABLE(idx >= 0); + DUK_ASSERT(idx < DUK_HOBJECT_GET_ESIZE(obj)); + h_base[i] = idx; + break; + } + DUK_DDD(DUK_DDDPRINT("duk__alloc_entry_checked() miss %ld", (long) i)); + i = (i + step) % n; + + /* guaranteed to find an empty slot */ + DUK_ASSERT(i != (duk_uint32_t) DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), DUK_HOBJECT_GET_HSIZE(obj))); + } + } +#endif /* DUK_USE_HOBJECT_HASH_PART */ + + /* Note: we could return the hash index here too, but it's not + * needed right now. + */ + + DUK_ASSERT_DISABLE(idx >= 0); + DUK_ASSERT(idx < DUK_HOBJECT_GET_ESIZE(obj)); + DUK_ASSERT(idx < DUK_HOBJECT_GET_ENEXT(obj)); + return idx; +} + +/* + * Object internal value + * + * Returned value is guaranteed to be reachable / incref'd, caller does not need + * to incref OR decref. No proxies or accessors are invoked, no prototype walk. + */ + +DUK_INTERNAL duk_bool_t duk_hobject_get_internal_value(duk_heap *heap, duk_hobject *obj, duk_tval *tv_out) { + duk_int_t e_idx; + duk_int_t h_idx; + + DUK_ASSERT(heap != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(tv_out != NULL); + + DUK_TVAL_SET_UNDEFINED_UNUSED(tv_out); + + /* always in entry part, no need to look up parents etc */ + duk_hobject_find_existing_entry(heap, obj, DUK_HEAP_STRING_INT_VALUE(heap), &e_idx, &h_idx); + if (e_idx >= 0) { + DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, obj, e_idx)); + DUK_TVAL_SET_TVAL(tv_out, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx)); + return 1; + } + return 0; +} + +DUK_INTERNAL duk_hstring *duk_hobject_get_internal_value_string(duk_heap *heap, duk_hobject *obj) { + duk_tval tv; + + DUK_ASSERT(heap != NULL); + DUK_ASSERT(obj != NULL); + + if (duk_hobject_get_internal_value(heap, obj, &tv)) { + duk_hstring *h; + DUK_ASSERT(DUK_TVAL_IS_STRING(&tv)); + h = DUK_TVAL_GET_STRING(&tv); + return h; + } + + return NULL; +} + +/* + * Arguments handling helpers (argument map mainly). + * + * An arguments object has exotic behavior for some numeric indices. + * Accesses may translate to identifier operations which may have + * arbitrary side effects (potentially invalidating any duk_tval + * pointers). + */ + +/* Lookup 'key' from arguments internal 'map', perform a variable lookup + * if mapped, and leave the result on top of stack (and return non-zero). + * Used in E5 Section 10.6 algorithms [[Get]] and [[GetOwnProperty]]. + */ +DUK_LOCAL +duk_bool_t duk__lookup_arguments_map(duk_hthread *thr, + duk_hobject *obj, + duk_hstring *key, + duk_propdesc *temp_desc, + duk_hobject **out_map, + duk_hobject **out_varenv) { + duk_context *ctx = (duk_context *) thr; + duk_hobject *map; + duk_hobject *varenv; + duk_bool_t rc; + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + DUK_DDD(DUK_DDDPRINT("arguments map lookup: thr=%p, obj=%p, key=%p, temp_desc=%p " + "(obj -> %!O, key -> %!O)", + (void *) thr, (void *) obj, (void *) key, (void *) temp_desc, + (duk_heaphdr *) obj, (duk_heaphdr *) key)); + + if (!duk__get_own_property_desc(thr, obj, DUK_HTHREAD_STRING_INT_MAP(thr), temp_desc, DUK__DESC_FLAG_PUSH_VALUE)) { + DUK_DDD(DUK_DDDPRINT("-> no 'map'")); + return 0; + } + + map = duk_require_hobject(ctx, -1); + DUK_ASSERT(map != NULL); + duk_pop(ctx); /* map is reachable through obj */ + + if (!duk__get_own_property_desc(thr, map, key, temp_desc, DUK__DESC_FLAG_PUSH_VALUE)) { + DUK_DDD(DUK_DDDPRINT("-> 'map' exists, but key not in map")); + return 0; + } + + /* [... varname] */ + DUK_DDD(DUK_DDDPRINT("-> 'map' exists, and contains key, key is mapped to argument/variable binding %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + DUK_ASSERT(duk_is_string(ctx, -1)); /* guaranteed when building arguments */ + + /* get varenv for varname (callee's declarative lexical environment) */ + rc = duk__get_own_property_desc(thr, obj, DUK_HTHREAD_STRING_INT_VARENV(thr), temp_desc, DUK__DESC_FLAG_PUSH_VALUE); + DUK_UNREF(rc); + DUK_ASSERT(rc != 0); /* arguments MUST have an initialized lexical environment reference */ + varenv = duk_require_hobject(ctx, -1); + DUK_ASSERT(varenv != NULL); + duk_pop(ctx); /* varenv remains reachable through 'obj' */ + + DUK_DDD(DUK_DDDPRINT("arguments varenv is: %!dO", (duk_heaphdr *) varenv)); + + /* success: leave varname in stack */ + *out_map = map; + *out_varenv = varenv; + return 1; /* [... varname] */ +} + +/* Lookup 'key' from arguments internal 'map', and leave replacement value + * on stack top if mapped (and return non-zero). + * Used in E5 Section 10.6 algorithm for [[GetOwnProperty]] (used by [[Get]]). + */ +DUK_LOCAL duk_bool_t duk__check_arguments_map_for_get(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc) { + duk_context *ctx = (duk_context *) thr; + duk_hobject *map; + duk_hobject *varenv; + duk_hstring *varname; + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + if (!duk__lookup_arguments_map(thr, obj, key, temp_desc, &map, &varenv)) { + DUK_DDD(DUK_DDDPRINT("arguments: key not mapped, no exotic get behavior")); + return 0; + } + + /* [... varname] */ + + varname = duk_require_hstring(ctx, -1); + DUK_ASSERT(varname != NULL); + duk_pop(ctx); /* varname is still reachable */ + + DUK_DDD(DUK_DDDPRINT("arguments object automatic getvar for a bound variable; " + "key=%!O, varname=%!O", + (duk_heaphdr *) key, + (duk_heaphdr *) varname)); + + (void) duk_js_getvar_envrec(thr, varenv, varname, 1 /*throw*/); + + /* [... value this_binding] */ + + duk_pop(ctx); + + /* leave result on stack top */ + return 1; +} + +/* Lookup 'key' from arguments internal 'map', perform a variable write if mapped. + * Used in E5 Section 10.6 algorithm for [[DefineOwnProperty]] (used by [[Put]]). + * Assumes stack top contains 'put' value (which is NOT popped). + */ +DUK_LOCAL void duk__check_arguments_map_for_put(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc, duk_bool_t throw_flag) { + duk_context *ctx = (duk_context *) thr; + duk_hobject *map; + duk_hobject *varenv; + duk_hstring *varname; + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + if (!duk__lookup_arguments_map(thr, obj, key, temp_desc, &map, &varenv)) { + DUK_DDD(DUK_DDDPRINT("arguments: key not mapped, no exotic put behavior")); + return; + } + + /* [... put_value varname] */ + + varname = duk_require_hstring(ctx, -1); + DUK_ASSERT(varname != NULL); + duk_pop(ctx); /* varname is still reachable */ + + DUK_DDD(DUK_DDDPRINT("arguments object automatic putvar for a bound variable; " + "key=%!O, varname=%!O, value=%!T", + (duk_heaphdr *) key, + (duk_heaphdr *) varname, + (duk_tval *) duk_require_tval(ctx, -1))); + + /* [... put_value] */ + + /* + * Note: although arguments object variable mappings are only established + * for non-strict functions (and a call to a non-strict function created + * the arguments object in question), an inner strict function may be doing + * the actual property write. Hence the throw_flag applied here comes from + * the property write call. + */ + + duk_js_putvar_envrec(thr, varenv, varname, duk_require_tval(ctx, -1), throw_flag); + + /* [... put_value] */ +} + +/* Lookup 'key' from arguments internal 'map', delete mapping if found. + * Used in E5 Section 10.6 algorithm for [[Delete]]. Note that the + * variable/argument itself (where the map points) is not deleted. + */ +DUK_LOCAL void duk__check_arguments_map_for_delete(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc) { + duk_context *ctx = (duk_context *) thr; + duk_hobject *map; + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + if (!duk__get_own_property_desc(thr, obj, DUK_HTHREAD_STRING_INT_MAP(thr), temp_desc, DUK__DESC_FLAG_PUSH_VALUE)) { + DUK_DDD(DUK_DDDPRINT("arguments: key not mapped, no exotic delete behavior")); + return; + } + + map = duk_require_hobject(ctx, -1); + DUK_ASSERT(map != NULL); + duk_pop(ctx); /* map is reachable through obj */ + + DUK_DDD(DUK_DDDPRINT("-> have 'map', delete key %!O from map (if exists)); ignore result", + (duk_heaphdr *) key)); + + /* Note: no recursion issue, we can trust 'map' to behave */ + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_BEHAVIOR(map)); + DUK_DDD(DUK_DDDPRINT("map before deletion: %!O", (duk_heaphdr *) map)); + (void) duk_hobject_delprop_raw(thr, map, key, 0); /* ignore result */ + DUK_DDD(DUK_DDDPRINT("map after deletion: %!O", (duk_heaphdr *) map)); +} + +/* + * Ecmascript compliant [[GetOwnProperty]](P), for internal use only. + * + * If property is found: + * - Fills descriptor fields to 'out_desc' + * - If DUK__DESC_FLAG_PUSH_VALUE is set, pushes a value related to the + * property onto the stack ('undefined' for accessor properties). + * - Returns non-zero + * + * If property is not found: + * - 'out_desc' is left in untouched state (possibly garbage) + * - Nothing is pushed onto the stack (not even with DUK__DESC_FLAG_PUSH_VALUE + * set) + * - Returns zero + * + * Notes: + * + * - Getting a property descriptor may cause an allocation (and hence + * GC) to take place, hence reachability and refcount of all related + * values matter. Reallocation of value stack, properties, etc may + * invalidate many duk_tval pointers (concretely, those which reside + * in memory areas subject to reallocation). However, heap object + * pointers are never affected (heap objects have stable pointers). + * + * - The value of a plain property is always reachable and has a non-zero + * reference count. + * + * - The value of a virtual property is not necessarily reachable from + * elsewhere and may have a refcount of zero. Hence we push it onto + * the valstack for the caller, which ensures it remains reachable + * while it is needed. + * + * - There are no virtual accessor properties. Hence, all getters and + * setters are always related to concretely stored properties, which + * ensures that the get/set functions in the resulting descriptor are + * reachable and have non-zero refcounts. Should there be virtual + * accessor properties later, this would need to change. + */ + +DUK_LOCAL duk_bool_t duk__get_own_property_desc_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_uint32_t arr_idx, duk_propdesc *out_desc, duk_small_uint_t flags) { + duk_context *ctx = (duk_context *) thr; + duk_tval *tv; + + DUK_DDD(DUK_DDDPRINT("duk__get_own_property_desc: thr=%p, obj=%p, key=%p, out_desc=%p, flags=%lx, " + "arr_idx=%ld (obj -> %!O, key -> %!O)", + (void *) thr, (void *) obj, (void *) key, (void *) out_desc, + (long) flags, (long) arr_idx, + (duk_heaphdr *) obj, (duk_heaphdr *) key)); + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + DUK_ASSERT(out_desc != NULL); + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + /* XXX: optimize this filling behavior later */ + out_desc->flags = 0; + out_desc->get = NULL; + out_desc->set = NULL; + out_desc->e_idx = -1; + out_desc->h_idx = -1; + out_desc->a_idx = -1; + + /* + * Array part + */ + + if (DUK_HOBJECT_HAS_ARRAY_PART(obj) && arr_idx != DUK__NO_ARRAY_INDEX) { + if (arr_idx < DUK_HOBJECT_GET_ASIZE(obj)) { + tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx); + if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + DUK_DDD(DUK_DDDPRINT("-> found in array part")); + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_push_tval(ctx, tv); + } + /* implicit attributes */ + out_desc->flags = DUK_PROPDESC_FLAG_WRITABLE | + DUK_PROPDESC_FLAG_CONFIGURABLE | + DUK_PROPDESC_FLAG_ENUMERABLE; + out_desc->a_idx = arr_idx; + goto prop_found; + } + } + /* assume array part is comprehensive (contains all array indexed elements + * or none of them); hence no need to check the entries part here. + */ + DUK_DDD(DUK_DDDPRINT("-> not found as a concrete property (has array part, " + "should be there if present)")); + goto prop_not_found_concrete; + } + + /* + * Entries part + */ + + duk_hobject_find_existing_entry(thr->heap, obj, key, &out_desc->e_idx, &out_desc->h_idx); + if (out_desc->e_idx >= 0) { + duk_int_t e_idx = out_desc->e_idx; + out_desc->flags = DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, e_idx); + if (out_desc->flags & DUK_PROPDESC_FLAG_ACCESSOR) { + DUK_DDD(DUK_DDDPRINT("-> found accessor property in entry part")); + out_desc->get = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, e_idx); + out_desc->set = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, e_idx); + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + /* a dummy undefined value is pushed to make valstack + * behavior uniform for caller + */ + duk_push_undefined(ctx); + } + } else { + DUK_DDD(DUK_DDDPRINT("-> found plain property in entry part")); + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx); + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_push_tval(ctx, tv); + } + } + goto prop_found; + } + + /* + * Not found as a concrete property, check whether a String object + * virtual property matches. + */ + + prop_not_found_concrete: + + if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(obj)) { + DUK_DDD(DUK_DDDPRINT("string object exotic property get for key: %!O, arr_idx: %ld", + (duk_heaphdr *) key, (long) arr_idx)); + + if (arr_idx != DUK__NO_ARRAY_INDEX) { + duk_hstring *h_val; + + DUK_DDD(DUK_DDDPRINT("array index exists")); + + h_val = duk_hobject_get_internal_value_string(thr->heap, obj); + DUK_ASSERT(h_val); + if (arr_idx < DUK_HSTRING_GET_CHARLEN(h_val)) { + DUK_DDD(DUK_DDDPRINT("-> found, array index inside string")); + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_push_hstring(ctx, h_val); + duk_substring(ctx, -1, arr_idx, arr_idx + 1); /* [str] -> [substr] */ + } + out_desc->flags = DUK_PROPDESC_FLAG_ENUMERABLE | /* E5 Section 15.5.5.2 */ + DUK_PROPDESC_FLAG_VIRTUAL; + + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)); + return 1; /* cannot be e.g. arguments exotic, since exotic 'traits' are mutually exclusive */ + } else { + /* index is above internal string length -> property is fully normal */ + DUK_DDD(DUK_DDDPRINT("array index outside string -> normal property")); + } + } else if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { + duk_hstring *h_val; + + DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior")); + + h_val = duk_hobject_get_internal_value_string(thr->heap, obj); + DUK_ASSERT(h_val != NULL); + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_push_uint(ctx, (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h_val)); + } + out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; /* E5 Section 15.5.5.1 */ + + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)); + return 1; /* cannot be arguments exotic */ + } + } else if (DUK_HOBJECT_IS_BUFFEROBJECT(obj)) { + duk_hbufferobject *h_bufobj; + duk_uint_t byte_off; + duk_small_uint_t elem_size; + + h_bufobj = (duk_hbufferobject *) obj; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + DUK_DDD(DUK_DDDPRINT("bufferobject property get for key: %!O, arr_idx: %ld", + (duk_heaphdr *) key, (long) arr_idx)); + + if (arr_idx != DUK__NO_ARRAY_INDEX) { + DUK_DDD(DUK_DDDPRINT("array index exists")); + + /* Careful with wrapping: arr_idx upshift may easily wrap, whereas + * length downshift won't. + */ + if (arr_idx < (h_bufobj->length >> h_bufobj->shift)) { + byte_off = arr_idx << h_bufobj->shift; /* no wrap assuming h_bufobj->length is valid */ + elem_size = 1 << h_bufobj->shift; + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_uint8_t *data; + + if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) { + data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off; + duk_hbufferobject_push_validated_read(ctx, h_bufobj, data, elem_size); + } else { + DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (read zero)")); + duk_push_uint(ctx, 0); + } + } + out_desc->flags = DUK_PROPDESC_FLAG_WRITABLE | + DUK_PROPDESC_FLAG_ENUMERABLE | + DUK_PROPDESC_FLAG_VIRTUAL; + + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)); + return 1; /* cannot be e.g. arguments exotic, since exotic 'traits' are mutually exclusive */ + } else { + /* index is above internal buffer length -> property is fully normal */ + DUK_DDD(DUK_DDDPRINT("array index outside buffer -> normal property")); + } + } else if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { + DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior")); + + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + /* Length in elements: take into account shift, but + * intentionally don't check the underlying buffer here. + */ + duk_push_uint(ctx, h_bufobj->length >> h_bufobj->shift); + } + out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; + + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)); + return 1; /* cannot be arguments exotic */ + } else if (key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr)) { + /* If neutered must return 0; length is zeroed during + * neutering. + */ + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_push_uint(ctx, h_bufobj->length); + } + out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; + return 1; /* cannot be arguments exotic */ + } else if (key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr)) { + /* If neutered must return 0; offset is zeroed during + * neutering. + */ + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_push_uint(ctx, h_bufobj->offset); + } + out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; + return 1; /* cannot be arguments exotic */ + } else if (key == DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)) { + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_push_uint(ctx, 1 << h_bufobj->shift); + } + out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; + return 1; /* cannot be arguments exotic */ + } + } else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(obj)) { + DUK_DDD(DUK_DDDPRINT("duktape/c object exotic property get for key: %!O, arr_idx: %ld", + (duk_heaphdr *) key, (long) arr_idx)); + + if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { + DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior")); + + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_int16_t func_nargs = ((duk_hnativefunction *) obj)->nargs; + duk_push_int(ctx, func_nargs == DUK_HNATIVEFUNCTION_NARGS_VARARGS ? 0 : func_nargs); + } + out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; /* not enumerable */ + + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)); + return 1; /* cannot be arguments exotic */ + } + } + + /* Array properties have exotic behavior but they are concrete, + * so no special handling here. + * + * Arguments exotic behavior (E5 Section 10.6, [[GetOwnProperty]] + * is only relevant as a post-check implemented below; hence no + * check here. + */ + + /* + * Not found as concrete or virtual + */ + + DUK_DDD(DUK_DDDPRINT("-> not found (virtual, entry part, or array part)")); + return 0; + + /* + * Found + * + * Arguments object has exotic post-processing, see E5 Section 10.6, + * description of [[GetOwnProperty]] variant for arguments. + */ + + prop_found: + DUK_DDD(DUK_DDDPRINT("-> property found, checking for arguments exotic post-behavior")); + + /* Notes: + * - only numbered indices are relevant, so arr_idx fast reject is good + * (this is valid unless there are more than 4**32-1 arguments). + * - since variable lookup has no side effects, this can be skipped if + * DUK__DESC_FLAG_PUSH_VALUE is not set. + */ + + if (DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj) && + arr_idx != DUK__NO_ARRAY_INDEX && + (flags & DUK__DESC_FLAG_PUSH_VALUE)) { + duk_propdesc temp_desc; + + /* Magically bound variable cannot be an accessor. However, + * there may be an accessor property (or a plain property) in + * place with magic behavior removed. This happens e.g. when + * a magic property is redefined with defineProperty(). + * Cannot assert for "not accessor" here. + */ + + /* replaces top of stack with new value if necessary */ + DUK_ASSERT((flags & DUK__DESC_FLAG_PUSH_VALUE) != 0); + + if (duk__check_arguments_map_for_get(thr, obj, key, &temp_desc)) { + DUK_DDD(DUK_DDDPRINT("-> arguments exotic behavior overrides result: %!T -> %!T", + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + /* [... old_result result] -> [... result] */ + duk_remove(ctx, -2); + } + } + + return 1; +} + +DUK_LOCAL duk_bool_t duk__get_own_property_desc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + DUK_ASSERT(out_desc != NULL); + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + return duk__get_own_property_desc_raw(thr, obj, key, DUK_HSTRING_GET_ARRIDX_SLOW(key), out_desc, flags); +} + +/* + * Ecmascript compliant [[GetProperty]](P), for internal use only. + * + * If property is found: + * - Fills descriptor fields to 'out_desc' + * - If DUK__DESC_FLAG_PUSH_VALUE is set, pushes a value related to the + * property onto the stack ('undefined' for accessor properties). + * - Returns non-zero + * + * If property is not found: + * - 'out_desc' is left in untouched state (possibly garbage) + * - Nothing is pushed onto the stack (not even with DUK__DESC_FLAG_PUSH_VALUE + * set) + * - Returns zero + * + * May cause arbitrary side effects and invalidate (most) duk_tval + * pointers. + */ + +DUK_LOCAL duk_bool_t duk__get_property_desc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags) { + duk_hobject *curr; + duk_uint32_t arr_idx; + duk_uint_t sanity; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + DUK_ASSERT(out_desc != NULL); + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key); + + DUK_DDD(DUK_DDDPRINT("duk__get_property_desc: thr=%p, obj=%p, key=%p, out_desc=%p, flags=%lx, " + "arr_idx=%ld (obj -> %!O, key -> %!O)", + (void *) thr, (void *) obj, (void *) key, (void *) out_desc, + (long) flags, (long) arr_idx, + (duk_heaphdr *) obj, (duk_heaphdr *) key)); + + curr = obj; + DUK_ASSERT(curr != NULL); + sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY; + do { + if (duk__get_own_property_desc_raw(thr, curr, key, arr_idx, out_desc, flags)) { + /* stack contains value (if requested), 'out_desc' is set */ + return 1; + } + + /* not found in 'curr', next in prototype chain; impose max depth */ + if (sanity-- == 0) { + if (flags & DUK__DESC_FLAG_IGNORE_PROTOLOOP) { + /* treat like property not found */ + break; + } else { + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT); + } + } + curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr); + } while (curr); + + /* out_desc is left untouched (possibly garbage), caller must use return + * value to determine whether out_desc can be looked up + */ + + return 0; +} + +/* + * Shallow fast path checks for accessing array elements with numeric + * indices. The goal is to try to avoid coercing an array index to an + * (interned) string for the most common lookups, in particular, for + * standard Array objects. + * + * Interning is avoided but only for a very narrow set of cases: + * - Object has array part, index is within array allocation, and + * value is not unused (= key exists) + * - Object has no interfering exotic behavior (e.g. arguments or + * string object exotic behaviors interfere, array exotic + * behavior does not). + * + * Current shortcoming: if key does not exist (even if it is within + * the array allocation range) a slow path lookup with interning is + * always required. This can probably be fixed so that there is a + * quick fast path for non-existent elements as well, at least for + * standard Array objects. + */ + +DUK_LOCAL duk_tval *duk__getprop_shallow_fastpath_array_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key) { + duk_tval *tv; + duk_uint32_t idx; + + DUK_UNREF(thr); + + if (!(DUK_HOBJECT_HAS_ARRAY_PART(obj) && + !DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj) && + !DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(obj) && + !DUK_HOBJECT_IS_BUFFEROBJECT(obj) && + !DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) { + /* Must have array part and no conflicting exotic behaviors. + * Doesn't need to have array special behavior, e.g. Arguments + * object has array part. + */ + return NULL; + } + + /* Arrays never have other exotic behaviors. */ + + DUK_DDD(DUK_DDDPRINT("fast path attempt (no exotic string/arguments/buffer " + "behavior, object has array part)")); + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_key)) { + idx = duk__tval_fastint_to_arr_idx(tv_key); + } else +#endif + if (DUK_TVAL_IS_DOUBLE(tv_key)) { + idx = duk__tval_number_to_arr_idx(tv_key); + } else { + DUK_DDD(DUK_DDDPRINT("key is not a number")); + return NULL; + } + + /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which + * is 0xffffffffUL. We don't need to check for that explicitly + * because 0xffffffffUL will never be inside object 'a_size'. + */ + + if (idx >= DUK_HOBJECT_GET_ASIZE(obj)) { + DUK_DDD(DUK_DDDPRINT("key is not an array index or outside array part")); + return NULL; + } + DUK_ASSERT(idx != 0xffffffffUL); + DUK_ASSERT(idx != DUK__NO_ARRAY_INDEX); + + /* XXX: for array instances we could take a shortcut here and assume + * Array.prototype doesn't contain an array index property. + */ + + DUK_DDD(DUK_DDDPRINT("key is a valid array index and inside array part")); + tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, idx); + if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + DUK_DDD(DUK_DDDPRINT("-> fast path successful")); + return tv; + } + + DUK_DDD(DUK_DDDPRINT("fast path attempt failed, fall back to slow path")); + return NULL; +} + +DUK_LOCAL duk_bool_t duk__putprop_shallow_fastpath_array_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key, duk_tval *tv_val, duk_propdesc *temp_desc) { + duk_tval *tv; + duk_uint32_t idx; + duk_tval tv_tmp; + duk_uint32_t old_len, new_len; + + if (!(DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj) && + DUK_HOBJECT_HAS_ARRAY_PART(obj) && + DUK_HOBJECT_HAS_EXTENSIBLE(obj))) { + return 0; + } + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_key)) { + idx = duk__tval_fastint_to_arr_idx(tv_key); + } else +#endif + if (DUK_TVAL_IS_DOUBLE(tv_key)) { + idx = duk__tval_number_to_arr_idx(tv_key); + } else { + DUK_DDD(DUK_DDDPRINT("key is not a number")); + return 0; + } + + /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which + * is 0xffffffffUL. We don't need to check for that explicitly + * because 0xffffffffUL will never be inside object 'a_size'. + */ + + if (idx >= DUK_HOBJECT_GET_ASIZE(obj)) { /* for resizing of array part, use slow path */ + return 0; + } + DUK_ASSERT(idx != 0xffffffffUL); + DUK_ASSERT(idx != DUK__NO_ARRAY_INDEX); + + old_len = duk__get_old_array_length(thr, obj, temp_desc); + + if (idx >= old_len) { + DUK_DDD(DUK_DDDPRINT("write new array entry requires length update " + "(arr_idx=%ld, old_len=%ld)", + (long) idx, (long) old_len)); + if (!(temp_desc->flags & DUK_PROPDESC_FLAG_WRITABLE)) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_WRITABLE); + return 0; /* not reachable */ + } + new_len = idx + 1; + + /* No resize has occurred so temp_desc->e_idx is still OK */ + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, temp_desc->e_idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_FASTINT_U32(tv, new_len); /* no need for decref/incref because value is a number */ +#else + DUK_TVAL_SET_NUMBER(tv, (duk_double_t) new_len); /* no need for decref/incref because value is a number */ +#endif + } else { + ; + } + + tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, idx); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_TVAL(tv, tv_val); + DUK_TVAL_INCREF(thr, tv); + DUK_TVAL_DECREF(thr, &tv_tmp); /* note: may trigger gc and props compaction, must be last */ + + DUK_DDD(DUK_DDDPRINT("array fast path success for index %ld", (long) idx)); + return 1; +} + +/* + * Fast path for bufferobject getprop/putprop + */ + +DUK_LOCAL duk_bool_t duk__getprop_fastpath_bufobj_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key) { + duk_context *ctx; + duk_uint32_t idx; + duk_hbufferobject *h_bufobj; + duk_uint_t byte_off; + duk_small_uint_t elem_size; + duk_uint8_t *data; + + ctx = (duk_context *) thr; + + if (!DUK_HOBJECT_IS_BUFFEROBJECT(obj)) { + return 0; + } + h_bufobj = (duk_hbufferobject *) obj; + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_key)) { + idx = duk__tval_fastint_to_arr_idx(tv_key); + } else +#endif + if (DUK_TVAL_IS_DOUBLE(tv_key)) { + idx = duk__tval_number_to_arr_idx(tv_key); + } else { + return 0; + } + + /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which + * is 0xffffffffUL. We don't need to check for that explicitly + * because 0xffffffffUL will never be inside bufferobject length. + */ + + /* Careful with wrapping (left shifting idx would be unsafe). */ + if (idx >= (h_bufobj->length >> h_bufobj->shift)) { + return 0; + } + DUK_ASSERT(idx != DUK__NO_ARRAY_INDEX); + + byte_off = idx << h_bufobj->shift; /* no wrap assuming h_bufobj->length is valid */ + elem_size = 1 << h_bufobj->shift; + + if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) { + data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off; + duk_hbufferobject_push_validated_read(ctx, h_bufobj, data, elem_size); + } else { + DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (read zero)")); + duk_push_uint(ctx, 0); + } + + return 1; +} + +DUK_LOCAL duk_bool_t duk__putprop_fastpath_bufobj_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key, duk_tval *tv_val) { + duk_context *ctx; + duk_uint32_t idx; + duk_hbufferobject *h_bufobj; + duk_uint_t byte_off; + duk_small_uint_t elem_size; + duk_uint8_t *data; + + ctx = (duk_context *) thr; + + if (!(DUK_HOBJECT_IS_BUFFEROBJECT(obj) && + DUK_TVAL_IS_NUMBER(tv_val))) { + return 0; + } + h_bufobj = (duk_hbufferobject *) obj; + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_key)) { + idx = duk__tval_fastint_to_arr_idx(tv_key); + } else +#endif + if (DUK_TVAL_IS_DOUBLE(tv_key)) { + idx = duk__tval_number_to_arr_idx(tv_key); + } else { + return 0; + } + + /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which + * is 0xffffffffUL. We don't need to check for that explicitly + * because 0xffffffffUL will never be inside bufferobject length. + */ + + /* Careful with wrapping (left shifting idx would be unsafe). */ + if (idx >= (h_bufobj->length >> h_bufobj->shift)) { + return 0; + } + DUK_ASSERT(idx != DUK__NO_ARRAY_INDEX); + + byte_off = idx << h_bufobj->shift; /* no wrap assuming h_bufobj->length is valid */ + elem_size = 1 << h_bufobj->shift; + + /* Value is required to be a number in the fast path so there + * are no side effects in write coercion. + */ + duk_push_tval(ctx, tv_val); + DUK_ASSERT(duk_is_number(ctx, -1)); + + if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) { + data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off; + duk_hbufferobject_validated_write(ctx, h_bufobj, data, elem_size); + } else { + DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (write skipped)")); + } + + duk_pop(ctx); + return 1; +} + +/* + * GETPROP: Ecmascript property read. + */ + +DUK_INTERNAL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key) { + duk_context *ctx = (duk_context *) thr; + duk_tval tv_obj_copy; + duk_tval tv_key_copy; + duk_hobject *curr = NULL; + duk_hstring *key = NULL; + duk_uint32_t arr_idx = DUK__NO_ARRAY_INDEX; + duk_propdesc desc; + duk_uint_t sanity; + + DUK_DDD(DUK_DDDPRINT("getprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)", + (void *) thr, (void *) tv_obj, (void *) tv_key, + (duk_tval *) tv_obj, (duk_tval *) tv_key)); + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(tv_obj != NULL); + DUK_ASSERT(tv_key != NULL); + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + /* + * Make a copy of tv_obj, tv_key, and tv_val to avoid any issues of + * them being invalidated by a valstack resize. + * + * XXX: this is now an overkill for many fast paths. Rework this + * to be faster (although switching to a valstack discipline might + * be a better solution overall). + */ + + DUK_TVAL_SET_TVAL(&tv_obj_copy, tv_obj); + DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key); + tv_obj = &tv_obj_copy; + tv_key = &tv_key_copy; + + /* + * Coercion and fast path processing + */ + + switch (DUK_TVAL_GET_TAG(tv_obj)) { + case DUK_TAG_UNDEFINED: + case DUK_TAG_NULL: { + /* Note: unconditional throw */ + DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject")); + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE); + return 0; + } + + case DUK_TAG_BOOLEAN: { + DUK_DDD(DUK_DDDPRINT("base object is a boolean, start lookup from boolean prototype")); + curr = thr->builtins[DUK_BIDX_BOOLEAN_PROTOTYPE]; + break; + } + + case DUK_TAG_STRING: { + duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj); + duk_int_t pop_count; + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_key)) { + arr_idx = duk__tval_fastint_to_arr_idx(tv_key); + DUK_DDD(DUK_DDDPRINT("base object string, key is a fast-path fastint; arr_idx %ld", (long) arr_idx)); + pop_count = 0; + } else +#endif + if (DUK_TVAL_IS_NUMBER(tv_key)) { + arr_idx = duk__tval_number_to_arr_idx(tv_key); + DUK_DDD(DUK_DDDPRINT("base object string, key is a fast-path number; arr_idx %ld", (long) arr_idx)); + pop_count = 0; + } else { + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + DUK_DDD(DUK_DDDPRINT("base object string, key is a non-fast-path number; after " + "coercion key is %!T, arr_idx %ld", + (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx)); + pop_count = 1; + } + + if (arr_idx != DUK__NO_ARRAY_INDEX && + arr_idx < DUK_HSTRING_GET_CHARLEN(h)) { + duk_pop_n(ctx, pop_count); + duk_push_hstring(ctx, h); + duk_substring(ctx, -1, arr_idx, arr_idx + 1); /* [str] -> [substr] */ + + DUK_DDD(DUK_DDDPRINT("-> %!T (base is string, key is an index inside string length " + "after coercion -> return char)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } + + if (pop_count == 0) { + /* This is a pretty awkward control flow, but we need to recheck the + * key coercion here. + */ + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + DUK_DDD(DUK_DDDPRINT("base object string, key is a non-fast-path number; after " + "coercion key is %!T, arr_idx %ld", + (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx)); + } + + if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { + duk_pop(ctx); /* [key] -> [] */ + duk_push_uint(ctx, (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h)); /* [] -> [res] */ + + DUK_DDD(DUK_DDDPRINT("-> %!T (base is string, key is 'length' after coercion -> " + "return string length)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } + DUK_DDD(DUK_DDDPRINT("base object is a string, start lookup from string prototype")); + curr = thr->builtins[DUK_BIDX_STRING_PROTOTYPE]; + goto lookup; /* avoid double coercion */ + } + + case DUK_TAG_OBJECT: { + duk_tval *tmp; + + curr = DUK_TVAL_GET_OBJECT(tv_obj); + DUK_ASSERT(curr != NULL); + + tmp = duk__getprop_shallow_fastpath_array_tval(thr, curr, tv_key); + if (tmp) { + duk_push_tval(ctx, tmp); + + DUK_DDD(DUK_DDDPRINT("-> %!T (base is object, key is a number, array part " + "fast path)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } + + if (duk__getprop_fastpath_bufobj_tval(thr, curr, tv_key) != 0) { + /* Read value pushed on stack. */ + DUK_DDD(DUK_DDDPRINT("-> %!T (base is bufobj, key is a number, bufferobject " + "fast path)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } + +#if defined(DUK_USE_ES6_PROXY) + if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(curr))) { + duk_hobject *h_target; + + if (duk__proxy_check_prop(thr, curr, DUK_STRIDX_GET, tv_key, &h_target)) { + /* -> [ ... trap handler ] */ + DUK_DDD(DUK_DDDPRINT("-> proxy object 'get' for key %!T", (duk_tval *) tv_key)); + duk_push_hobject(ctx, h_target); /* target */ + duk_push_tval(ctx, tv_key); /* P */ + duk_push_tval(ctx, tv_obj); /* Receiver: Proxy object */ + duk_call_method(ctx, 3 /*nargs*/); + + /* Target object must be checked for a conflicting + * non-configurable property. + */ + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + + if (duk__get_own_property_desc_raw(thr, h_target, key, arr_idx, &desc, DUK__DESC_FLAG_PUSH_VALUE)) { + duk_tval *tv_hook = duk_require_tval(ctx, -3); /* value from hook */ + duk_tval *tv_targ = duk_require_tval(ctx, -1); /* value from target */ + duk_bool_t datadesc_reject; + duk_bool_t accdesc_reject; + + DUK_DDD(DUK_DDDPRINT("proxy 'get': target has matching property %!O, check for " + "conflicting property; tv_hook=%!T, tv_targ=%!T, desc.flags=0x%08lx, " + "desc.get=%p, desc.set=%p", + (duk_heaphdr *) key, (duk_tval *) tv_hook, (duk_tval *) tv_targ, + (unsigned long) desc.flags, + (void *) desc.get, (void *) desc.set)); + + datadesc_reject = !(desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) && + !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && + !(desc.flags & DUK_PROPDESC_FLAG_WRITABLE) && + !duk_js_samevalue(tv_hook, tv_targ); + accdesc_reject = (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) && + !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && + (desc.get == NULL) && + !DUK_TVAL_IS_UNDEFINED(tv_hook); + if (datadesc_reject || accdesc_reject) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED); + } + + duk_pop_2(ctx); + } else { + duk_pop(ctx); + } + return 1; /* return value */ + } + + curr = h_target; /* resume lookup from target */ + DUK_TVAL_SET_OBJECT(tv_obj, curr); + } +#endif /* DUK_USE_ES6_PROXY */ + + if (DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(curr)) { + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + + if (duk__check_arguments_map_for_get(thr, curr, key, &desc)) { + DUK_DDD(DUK_DDDPRINT("-> %!T (base is object with arguments exotic behavior, " + "key matches magically bound property -> skip standard " + "Get with replacement value)", + (duk_tval *) duk_get_tval(ctx, -1))); + + /* no need for 'caller' post-check, because 'key' must be an array index */ + + duk_remove(ctx, -2); /* [key result] -> [result] */ + return 1; + } + + goto lookup; /* avoid double coercion */ + } + break; + } + + /* Buffer has virtual properties similar to string, but indexed values + * are numbers, not 1-byte buffers/strings which would perform badly. + */ + case DUK_TAG_BUFFER: { + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj); + duk_int_t pop_count; + + /* + * Because buffer values are often looped over, a number fast path + * is important. + */ + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_key)) { + arr_idx = duk__tval_fastint_to_arr_idx(tv_key); + DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path fastint; arr_idx %ld", (long) arr_idx)); + pop_count = 0; + } + else +#endif + if (DUK_TVAL_IS_NUMBER(tv_key)) { + arr_idx = duk__tval_number_to_arr_idx(tv_key); + DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path number; arr_idx %ld", (long) arr_idx)); + pop_count = 0; + } else { + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after " + "coercion key is %!T, arr_idx %ld", + (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx)); + pop_count = 1; + } + + if (arr_idx != DUK__NO_ARRAY_INDEX && + arr_idx < DUK_HBUFFER_GET_SIZE(h)) { + duk_pop_n(ctx, pop_count); + duk_push_uint(ctx, ((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h))[arr_idx]); + + DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is an index inside buffer length " + "after coercion -> return byte as number)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } + + if (pop_count == 0) { + /* This is a pretty awkward control flow, but we need to recheck the + * key coercion here. + */ + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after " + "coercion key is %!T, arr_idx %ld", + (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx)); + } + + if (key == DUK_HTHREAD_STRING_LENGTH(thr) || + key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr)) { + duk_pop(ctx); /* [key] -> [] */ + duk_push_uint(ctx, (duk_uint_t) DUK_HBUFFER_GET_SIZE(h)); /* [] -> [res] */ + + DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'length' or 'byteLength' " + "after coercion -> return buffer length)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } else if (key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr)) { + duk_pop(ctx); /* [key] -> [] */ + duk_push_uint(ctx, 0); /* [] -> [res] */ + + DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'byteOffset' after coercion -> " + "return 0 for consistency with Buffer objects)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } else if (key == DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)) { + duk_pop(ctx); /* [key] -> [] */ + duk_push_uint(ctx, 1); /* [] -> [res] */ + + DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'BYTES_PER_ELEMENT' after coercion -> " + "return 1 for consistency with Buffer objects)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } + + DUK_DDD(DUK_DDDPRINT("base object is a buffer, start lookup from buffer prototype")); + curr = thr->builtins[DUK_BIDX_BUFFER_PROTOTYPE]; + goto lookup; /* avoid double coercion */ + } + + case DUK_TAG_POINTER: { + DUK_DDD(DUK_DDDPRINT("base object is a pointer, start lookup from pointer prototype")); + curr = thr->builtins[DUK_BIDX_POINTER_PROTOTYPE]; + break; + } + + case DUK_TAG_LIGHTFUNC: { + duk_int_t lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv_obj); + + /* Must coerce key: if key is an object, it may coerce to e.g. 'length'. */ + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + + if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { + duk_int_t lf_len = DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags); + duk_pop(ctx); + duk_push_int(ctx, lf_len); + return 1; + } else if (key == DUK_HTHREAD_STRING_NAME(thr)) { + duk_pop(ctx); + duk_push_lightfunc_name(ctx, tv_obj); + return 1; + } + + DUK_DDD(DUK_DDDPRINT("base object is a lightfunc, start lookup from function prototype")); + curr = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]; + goto lookup; /* avoid double coercion */ + } + +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: { + /* number */ + DUK_DDD(DUK_DDDPRINT("base object is a number, start lookup from number prototype")); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_obj)); + curr = thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE]; + break; + } + } + + /* key coercion (unless already coerced above) */ + DUK_ASSERT(key == NULL); + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + + /* + * Property lookup + */ + + lookup: + /* [key] (coerced) */ + DUK_ASSERT(curr != NULL); + DUK_ASSERT(key != NULL); + + sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY; + do { + if (!duk__get_own_property_desc_raw(thr, curr, key, arr_idx, &desc, DUK__DESC_FLAG_PUSH_VALUE)) { + goto next_in_chain; + } + + if (desc.get != NULL) { + /* accessor with defined getter */ + DUK_ASSERT((desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) != 0); + + duk_pop(ctx); /* [key undefined] -> [key] */ + duk_push_hobject(ctx, desc.get); + duk_push_tval(ctx, tv_obj); /* note: original, uncoerced base */ +#ifdef DUK_USE_NONSTD_GETTER_KEY_ARGUMENT + duk_dup(ctx, -3); + duk_call_method(ctx, 1); /* [key getter this key] -> [key retval] */ +#else + duk_call_method(ctx, 0); /* [key getter this] -> [key retval] */ +#endif + } else { + /* [key value] or [key undefined] */ + + /* data property or accessor without getter */ + DUK_ASSERT(((desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0) || + (desc.get == NULL)); + + /* if accessor without getter, return value is undefined */ + DUK_ASSERT(((desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0) || + duk_is_undefined(ctx, -1)); + + /* Note: for an accessor without getter, falling through to + * check for "caller" exotic behavior is unnecessary as + * "undefined" will never activate the behavior. But it does + * no harm, so we'll do it anyway. + */ + } + + goto found; /* [key result] */ + + next_in_chain: + /* XXX: option to pretend property doesn't exist if sanity limit is + * hit might be useful. + */ + if (sanity-- == 0) { + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT); + } + curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr); + } while (curr); + + /* + * Not found + */ + + duk_to_undefined(ctx, -1); /* [key] -> [undefined] (default value) */ + + DUK_DDD(DUK_DDDPRINT("-> %!T (not found)", (duk_tval *) duk_get_tval(ctx, -1))); + return 0; + + /* + * Found; post-processing (Function and arguments objects) + */ + + found: + /* [key result] */ + +#if !defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) + /* Special behavior for 'caller' property of (non-bound) function objects + * and non-strict Arguments objects: if 'caller' -value- (!) is a strict + * mode function, throw a TypeError (E5 Sections 15.3.5.4, 10.6). + * Quite interestingly, a non-strict function with no formal arguments + * will get an arguments object -without- special 'caller' behavior! + * + * The E5.1 spec is a bit ambiguous if this special behavior applies when + * a bound function is the base value (not the 'caller' value): Section + * 15.3.4.5 (describing bind()) states that [[Get]] for bound functions + * matches that of Section 15.3.5.4 ([[Get]] for Function instances). + * However, Section 13.3.5.4 has "NOTE: Function objects created using + * Function.prototype.bind use the default [[Get]] internal method." + * The current implementation assumes this means that bound functions + * should not have the special [[Get]] behavior. + * + * The E5.1 spec is also a bit unclear if the TypeError throwing is + * applied if the 'caller' value is a strict bound function. The + * current implementation will throw even for both strict non-bound + * and strict bound functions. + * + * See test-dev-strict-func-as-caller-prop-value.js for quite extensive + * tests. + * + * This exotic behavior is disabled when the non-standard 'caller' property + * is enabled, as it conflicts with the free use of 'caller'. + */ + if (key == DUK_HTHREAD_STRING_CALLER(thr) && + DUK_TVAL_IS_OBJECT(tv_obj)) { + duk_hobject *orig = DUK_TVAL_GET_OBJECT(tv_obj); + DUK_ASSERT(orig != NULL); + + if (DUK_HOBJECT_IS_NONBOUND_FUNCTION(orig) || + DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(orig)) { + duk_hobject *h; + + /* XXX: The TypeError is currently not applied to bound + * functions because the 'strict' flag is not copied by + * bind(). This may or may not be correct, the specification + * only refers to the value being a "strict mode Function + * object" which is ambiguous. + */ + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(orig)); + + h = duk_get_hobject(ctx, -1); /* NULL if not an object */ + if (h && + DUK_HOBJECT_IS_FUNCTION(h) && + DUK_HOBJECT_HAS_STRICT(h)) { + /* XXX: sufficient to check 'strict', assert for 'is function' */ + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_STRICT_CALLER_READ); + } + } + } +#endif /* !DUK_USE_NONSTD_FUNC_CALLER_PROPERTY */ + + duk_remove(ctx, -2); /* [key result] -> [result] */ + + DUK_DDD(DUK_DDDPRINT("-> %!T (found)", (duk_tval *) duk_get_tval(ctx, -1))); + return 1; +} + +/* + * HASPROP: Ecmascript property existence check ("in" operator). + * + * Interestingly, the 'in' operator does not do any coercion of + * the target object. + */ + +DUK_INTERNAL duk_bool_t duk_hobject_hasprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key) { + duk_context *ctx = (duk_context *) thr; + duk_tval tv_key_copy; + duk_hobject *obj; + duk_hstring *key; + duk_uint32_t arr_idx; + duk_bool_t rc; + duk_propdesc desc; + + DUK_DDD(DUK_DDDPRINT("hasprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)", + (void *) thr, (void *) tv_obj, (void *) tv_key, + (duk_tval *) tv_obj, (duk_tval *) tv_key)); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(tv_obj != NULL); + DUK_ASSERT(tv_key != NULL); + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key); + tv_key = &tv_key_copy; + + /* + * The 'in' operator requires an object as its right hand side, + * throwing a TypeError unconditionally if this is not the case. + * + * However, lightfuncs need to behave like fully fledged objects + * here to be maximally transparent, so we need to handle them + * here. + */ + + /* XXX: Refactor key coercion so that it's only called once. It can't + * be trivially lifted here because the object must be type checked + * first. + */ + + if (DUK_TVAL_IS_OBJECT(tv_obj)) { + obj = DUK_TVAL_GET_OBJECT(tv_obj); + DUK_ASSERT(obj != NULL); + + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + } else if (DUK_TVAL_IS_LIGHTFUNC(tv_obj)) { + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + if (duk__key_is_lightfunc_ownprop(thr, key)) { + /* FOUND */ + rc = 1; + goto pop_and_return; + } + + /* If not found, resume existence check from Function.prototype. + * We can just substitute the value in this case; nothing will + * need the original base value (as would be the case with e.g. + * setters/getters. + */ + obj = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]; + } else { + /* Note: unconditional throw */ + DUK_DDD(DUK_DDDPRINT("base object is not an object -> reject")); + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE); + } + + /* XXX: fast path for arrays? */ + + DUK_ASSERT(key != NULL); + DUK_ASSERT(obj != NULL); + DUK_UNREF(arr_idx); + +#if defined(DUK_USE_ES6_PROXY) + if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) { + duk_hobject *h_target; + duk_bool_t tmp_bool; + + /* XXX: the key in 'key in obj' is string coerced before we're called + * (which is the required behavior in E5/E5.1/E6) so the key is a string + * here already. + */ + + if (duk__proxy_check_prop(thr, obj, DUK_STRIDX_HAS, tv_key, &h_target)) { + /* [ ... key trap handler ] */ + DUK_DDD(DUK_DDDPRINT("-> proxy object 'has' for key %!T", (duk_tval *) tv_key)); + duk_push_hobject(ctx, h_target); /* target */ + duk_push_tval(ctx, tv_key); /* P */ + duk_call_method(ctx, 2 /*nargs*/); + tmp_bool = duk_to_boolean(ctx, -1); + if (!tmp_bool) { + /* Target object must be checked for a conflicting + * non-configurable property. + */ + + if (duk__get_own_property_desc_raw(thr, h_target, key, arr_idx, &desc, 0 /*flags*/)) { /* don't push value */ + DUK_DDD(DUK_DDDPRINT("proxy 'has': target has matching property %!O, check for " + "conflicting property; desc.flags=0x%08lx, " + "desc.get=%p, desc.set=%p", + (duk_heaphdr *) key, (unsigned long) desc.flags, + (void *) desc.get, (void *) desc.set)); + /* XXX: Extensibility check for target uses IsExtensible(). If we + * implemented the isExtensible trap and didn't reject proxies as + * proxy targets, it should be respected here. + */ + if (!((desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && /* property is configurable and */ + DUK_HOBJECT_HAS_EXTENSIBLE(h_target))) { /* ... target is extensible */ + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED); + } + } + } + + duk_pop_2(ctx); /* [ key trap_result ] -> [] */ + return tmp_bool; + } + + obj = h_target; /* resume check from proxy target */ + } +#endif /* DUK_USE_ES6_PROXY */ + + /* XXX: inline into a prototype walking loop? */ + + rc = duk__get_property_desc(thr, obj, key, &desc, 0 /*flags*/); /* don't push value */ + /* fall through */ + + pop_and_return: + duk_pop(ctx); /* [ key ] -> [] */ + return rc; +} + +/* + * HASPROP variant used internally. + * + * This primitive must never throw an error, callers rely on this. + * In particular, don't throw an error for prototype loops; instead, + * pretend like the property doesn't exist if a prototype sanity limit + * is reached. + * + * Does not implement proxy behavior: if applied to a proxy object, + * returns key existence on the proxy object itself. + */ + +DUK_INTERNAL duk_bool_t duk_hobject_hasprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key) { + duk_propdesc dummy; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + return duk__get_property_desc(thr, obj, key, &dummy, DUK__DESC_FLAG_IGNORE_PROTOLOOP); /* don't push value */ +} + +/* + * Helper: handle Array object 'length' write which automatically + * deletes properties, see E5 Section 15.4.5.1, step 3. This is + * quite tricky to get right. + * + * Used by duk_hobject_putprop(). + */ + +DUK_LOCAL duk_uint32_t duk__get_old_array_length(duk_hthread *thr, duk_hobject *obj, duk_propdesc *temp_desc) { + duk_bool_t rc; + duk_tval *tv; + duk_uint32_t res; + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + /* This function is only called for objects with array exotic behavior. + * The [[DefineOwnProperty]] algorithm for arrays requires that + * 'length' can never have a value outside the unsigned 32-bit range, + * attempt to write such a value is a RangeError. Here we can thus + * assert for this. When Duktape internals go around the official + * property write interface (doesn't happen often) this assumption is + * easy to accidentally break, so such code must be written carefully. + * See test-bi-array-push-maxlen.js. + */ + + rc = duk__get_own_property_desc_raw(thr, obj, DUK_HTHREAD_STRING_LENGTH(thr), DUK__NO_ARRAY_INDEX, temp_desc, 0 /*flags*/); /* don't push value */ + DUK_UNREF(rc); + DUK_ASSERT(rc != 0); /* arrays MUST have a 'length' property */ + DUK_ASSERT(temp_desc->e_idx >= 0); + + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, temp_desc->e_idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); /* array 'length' is always a number, as we coerce it */ + DUK_ASSERT(DUK_TVAL_GET_NUMBER(tv) >= 0.0); + DUK_ASSERT(DUK_TVAL_GET_NUMBER(tv) <= (double) 0xffffffffUL); + DUK_ASSERT((duk_double_t) (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv) == DUK_TVAL_GET_NUMBER(tv)); +#if defined(DUK_USE_FASTINT) + /* Downgrade checks are not made everywhere, so 'length' is not always + * a fastint (it is a number though). This can be removed once length + * is always guaranteed to be a fastint. + */ + DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv) || DUK_TVAL_IS_DOUBLE(tv)); + if (DUK_TVAL_IS_FASTINT(tv)) { + res = (duk_uint32_t) DUK_TVAL_GET_FASTINT_U32(tv); + } else { + res = (duk_uint32_t) DUK_TVAL_GET_DOUBLE(tv); + } +#else + res = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv); +#endif /* DUK_USE_FASTINT */ + + return res; +} + +DUK_LOCAL duk_uint32_t duk__to_new_array_length_checked(duk_hthread *thr) { + duk_context *ctx = (duk_context *) thr; + duk_uint32_t res; + duk_double_t d; + + /* Input value should be on stack top and will be coerced and + * popped. Refuse to update an Array's 'length' to a value + * outside the 32-bit range. Negative zero is accepted as zero. + */ + + /* XXX: fastint */ + + d = duk_to_number(ctx, -1); + res = (duk_uint32_t) d; + if ((duk_double_t) res != d) { + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_INVALID_ARRAY_LENGTH); + } + duk_pop(ctx); + return res; +} + +/* Delete elements required by a smaller length, taking into account + * potentially non-configurable elements. Returns non-zero if all + * elements could be deleted, and zero if all or some elements could + * not be deleted. Also writes final "target length" to 'out_result_len'. + * This is the length value that should go into the 'length' property + * (must be set by the caller). Never throws an error. + */ +DUK_LOCAL +duk_bool_t duk__handle_put_array_length_smaller(duk_hthread *thr, + duk_hobject *obj, + duk_uint32_t old_len, + duk_uint32_t new_len, + duk_bool_t force_flag, + duk_uint32_t *out_result_len) { + duk_uint32_t target_len; + duk_uint_fast32_t i; + duk_uint32_t arr_idx; + duk_hstring *key; + duk_tval *tv; + duk_tval tv_tmp; + duk_bool_t rc; + + DUK_DDD(DUK_DDDPRINT("new array length smaller than old (%ld -> %ld), " + "probably need to remove elements", + (long) old_len, (long) new_len)); + + /* + * New length is smaller than old length, need to delete properties above + * the new length. + * + * If array part exists, this is straightforward: array entries cannot + * be non-configurable so this is guaranteed to work. + * + * If array part does not exist, array-indexed values are scattered + * in the entry part, and some may not be configurable (preventing length + * from becoming lower than their index + 1). To handle the algorithm + * in E5 Section 15.4.5.1, step l correctly, we scan the entire property + * set twice. + */ + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(new_len < old_len); + DUK_ASSERT(out_result_len != NULL); + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + if (DUK_HOBJECT_HAS_ARRAY_PART(obj)) { + /* + * All defined array-indexed properties are in the array part + * (we assume the array part is comprehensive), and all array + * entries are writable, configurable, and enumerable. Thus, + * nothing can prevent array entries from being deleted. + */ + + DUK_DDD(DUK_DDDPRINT("have array part, easy case")); + + if (old_len < DUK_HOBJECT_GET_ASIZE(obj)) { + /* XXX: assertion that entries >= old_len are already unused */ + i = old_len; + } else { + i = DUK_HOBJECT_GET_ASIZE(obj); + } + DUK_ASSERT(i <= DUK_HOBJECT_GET_ASIZE(obj)); + + while (i > new_len) { + i--; + tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_UNDEFINED_UNUSED(tv); + DUK_TVAL_DECREF(thr, &tv_tmp); + } + + *out_result_len = new_len; + return 1; + } else { + /* + * Entries part is a bit more complex + */ + + /* Stage 1: find highest preventing non-configurable entry (if any). + * When forcing, ignore non-configurability. + */ + + DUK_DDD(DUK_DDDPRINT("no array part, slow case")); + + DUK_DDD(DUK_DDDPRINT("array length write, no array part, stage 1: find target_len " + "(highest preventing non-configurable entry (if any))")); + + target_len = new_len; + if (force_flag) { + DUK_DDD(DUK_DDDPRINT("array length write, no array part; force flag -> skip stage 1")); + goto skip_stage1; + } + for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) { + key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i); + if (!key) { + DUK_DDD(DUK_DDDPRINT("skip entry index %ld: null key", (long) i)); + continue; + } + if (!DUK_HSTRING_HAS_ARRIDX(key)) { + DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key not an array index", (long) i)); + continue; + } + + DUK_ASSERT(DUK_HSTRING_HAS_ARRIDX(key)); /* XXX: macro checks for array index flag, which is unnecessary here */ + arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key); + DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX); + DUK_ASSERT(arr_idx < old_len); /* consistency requires this */ + + if (arr_idx < new_len) { + DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is array index %ld, below new_len", + (long) i, (long) arr_idx)); + continue; + } + if (DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(thr->heap, obj, i)) { + DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is a relevant array index %ld, but configurable", + (long) i, (long) arr_idx)); + continue; + } + + /* relevant array index is non-configurable, blocks write */ + if (arr_idx >= target_len) { + DUK_DDD(DUK_DDDPRINT("entry at index %ld has arr_idx %ld, is not configurable, " + "update target_len %ld -> %ld", + (long) i, (long) arr_idx, (long) target_len, + (long) (arr_idx + 1))); + target_len = arr_idx + 1; + } + } + skip_stage1: + + /* stage 2: delete configurable entries above target length */ + + DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld, target_len=%ld", + (long) old_len, (long) new_len, (long) target_len)); + + DUK_DDD(DUK_DDDPRINT("array length write, no array part, stage 2: remove " + "entries >= target_len")); + + for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) { + key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i); + if (!key) { + DUK_DDD(DUK_DDDPRINT("skip entry index %ld: null key", (long) i)); + continue; + } + if (!DUK_HSTRING_HAS_ARRIDX(key)) { + DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key not an array index", (long) i)); + continue; + } + + DUK_ASSERT(DUK_HSTRING_HAS_ARRIDX(key)); /* XXX: macro checks for array index flag, which is unnecessary here */ + arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key); + DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX); + DUK_ASSERT(arr_idx < old_len); /* consistency requires this */ + + if (arr_idx < target_len) { + DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is array index %ld, below target_len", + (long) i, (long) arr_idx)); + continue; + } + DUK_ASSERT(force_flag || DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(thr->heap, obj, i)); /* stage 1 guarantees */ + + DUK_DDD(DUK_DDDPRINT("delete entry index %ld: key is array index %ld", + (long) i, (long) arr_idx)); + + /* + * Slow delete, but we don't care as we're already in a very slow path. + * The delete always succeeds: key has no exotic behavior, property + * is configurable, and no resize occurs. + */ + rc = duk_hobject_delprop_raw(thr, obj, key, force_flag ? DUK_DELPROP_FLAG_FORCE : 0); + DUK_UNREF(rc); + DUK_ASSERT(rc != 0); + } + + /* stage 3: update length (done by caller), decide return code */ + + DUK_DDD(DUK_DDDPRINT("array length write, no array part, stage 3: update length (done by caller)")); + + *out_result_len = target_len; + + if (target_len == new_len) { + DUK_DDD(DUK_DDDPRINT("target_len matches new_len, return success")); + return 1; + } + DUK_DDD(DUK_DDDPRINT("target_len does not match new_len (some entry prevented " + "full length adjustment), return error")); + return 0; + } + + DUK_UNREACHABLE(); +} + +/* XXX: is valstack top best place for argument? */ +DUK_LOCAL duk_bool_t duk__handle_put_array_length(duk_hthread *thr, duk_hobject *obj) { + duk_context *ctx = (duk_context *) thr; + duk_propdesc desc; + duk_uint32_t old_len; + duk_uint32_t new_len; + duk_uint32_t result_len; + duk_tval *tv; + duk_bool_t rc; + + DUK_DDD(DUK_DDDPRINT("handling a put operation to array 'length' exotic property, " + "new val: %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(obj != NULL); + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + DUK_ASSERT(duk_is_valid_index(ctx, -1)); + + /* + * Get old and new length + */ + + old_len = duk__get_old_array_length(thr, obj, &desc); + duk_dup(ctx, -1); /* [in_val in_val] */ + new_len = duk__to_new_array_length_checked(thr); /* -> [in_val] */ + DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld", (long) old_len, (long) new_len)); + + /* + * Writability check + */ + + if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) { + DUK_DDD(DUK_DDDPRINT("length is not writable, fail")); + return 0; + } + + /* + * New length not lower than old length => no changes needed + * (not even array allocation). + */ + + if (new_len >= old_len) { + DUK_DDD(DUK_DDDPRINT("new length is higher than old length, just update length, no deletions")); + + DUK_ASSERT(desc.e_idx >= 0); + DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx)); + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + /* no decref needed for a number */ +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_FASTINT_U32(tv, new_len); +#else + DUK_TVAL_SET_NUMBER(tv, (duk_double_t) new_len); +#endif + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + return 1; + } + + DUK_DDD(DUK_DDDPRINT("new length is lower than old length, probably must delete entries")); + + /* + * New length lower than old length => delete elements, then + * update length. + * + * Note: even though a bunch of elements have been deleted, the 'desc' is + * still valid as properties haven't been resized (and entries compacted). + */ + + rc = duk__handle_put_array_length_smaller(thr, obj, old_len, new_len, 0 /*force_flag*/, &result_len); + DUK_ASSERT(result_len >= new_len && result_len <= old_len); + + DUK_ASSERT(desc.e_idx >= 0); + DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx)); + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + /* no decref needed for a number */ +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_FASTINT_U32(tv, result_len); +#else + DUK_TVAL_SET_NUMBER(tv, (duk_double_t) result_len); +#endif + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + + /* XXX: shrink array allocation or entries compaction here? */ + + return rc; +} + +/* + * PUTPROP: Ecmascript property write. + * + * Unlike Ecmascript primitive which returns nothing, returns 1 to indicate + * success and 0 to indicate failure (assuming throw is not set). + * + * This is an extremely tricky function. Some examples: + * + * * Currently a decref may trigger a GC, which may compact an object's + * property allocation. Consequently, any entry indices (e_idx) will + * be potentially invalidated by a decref. + * + * * Exotic behaviors (strings, arrays, arguments object) require, + * among other things: + * + * - Preprocessing before and postprocessing after an actual property + * write. For example, array index write requires pre-checking the + * array 'length' property for access control, and may require an + * array 'length' update after the actual write has succeeded (but + * not if it fails). + * + * - Deletion of multiple entries, as a result of array 'length' write. + * + * * Input values are taken as pointers which may point to the valstack. + * If valstack is resized because of the put (this may happen at least + * when the array part is abandoned), the pointers can be invalidated. + * (We currently make a copy of all of the input values to avoid issues.) + */ + +DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key, duk_tval *tv_val, duk_bool_t throw_flag) { + duk_context *ctx = (duk_context *) thr; + duk_tval tv_obj_copy; + duk_tval tv_key_copy; + duk_tval tv_val_copy; + duk_hobject *orig = NULL; /* NULL if tv_obj is primitive */ + duk_hobject *curr; + duk_hstring *key = NULL; + duk_propdesc desc; + duk_tval *tv; + duk_uint32_t arr_idx; + duk_bool_t rc; + duk_int_t e_idx; + duk_uint_t sanity; + duk_uint32_t new_array_length = 0; /* 0 = no update */ + + DUK_DDD(DUK_DDDPRINT("putprop: thr=%p, obj=%p, key=%p, val=%p, throw=%ld " + "(obj -> %!T, key -> %!T, val -> %!T)", + (void *) thr, (void *) tv_obj, (void *) tv_key, (void *) tv_val, + (long) throw_flag, (duk_tval *) tv_obj, (duk_tval *) tv_key, (duk_tval *) tv_val)); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(tv_obj != NULL); + DUK_ASSERT(tv_key != NULL); + DUK_ASSERT(tv_val != NULL); + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + /* + * Make a copy of tv_obj, tv_key, and tv_val to avoid any issues of + * them being invalidated by a valstack resize. + * + * XXX: this is an overkill for some paths, so optimize this later + * (or maybe switch to a stack arguments model entirely). + */ + + DUK_TVAL_SET_TVAL(&tv_obj_copy, tv_obj); + DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key); + DUK_TVAL_SET_TVAL(&tv_val_copy, tv_val); + tv_obj = &tv_obj_copy; + tv_key = &tv_key_copy; + tv_val = &tv_val_copy; + + /* + * Coercion and fast path processing. + */ + + switch (DUK_TVAL_GET_TAG(tv_obj)) { + case DUK_TAG_UNDEFINED: + case DUK_TAG_NULL: { + /* Note: unconditional throw */ + DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject (object=%!iT)", + (duk_tval *) tv_obj)); + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE); + return 0; + } + + case DUK_TAG_BOOLEAN: { + DUK_DDD(DUK_DDDPRINT("base object is a boolean, start lookup from boolean prototype")); + curr = thr->builtins[DUK_BIDX_BOOLEAN_PROTOTYPE]; + break; + } + + case DUK_TAG_STRING: { + duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj); + + /* + * Note: currently no fast path for array index writes. + * They won't be possible anyway as strings are immutable. + */ + + DUK_ASSERT(key == NULL); + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + + if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { + goto fail_not_writable; + } + + if (arr_idx != DUK__NO_ARRAY_INDEX && + arr_idx < DUK_HSTRING_GET_CHARLEN(h)) { + goto fail_not_writable; + } + + DUK_DDD(DUK_DDDPRINT("base object is a string, start lookup from string prototype")); + curr = thr->builtins[DUK_BIDX_STRING_PROTOTYPE]; + goto lookup; /* avoid double coercion */ + } + + case DUK_TAG_OBJECT: { + orig = DUK_TVAL_GET_OBJECT(tv_obj); + DUK_ASSERT(orig != NULL); + + /* The fast path for array property put is not fully compliant: + * If one places conflicting number-indexed properties into + * Array.prototype (for example, a non-writable Array.prototype[7]) + * the fast path will incorrectly ignore them. + * + * This fast path could be made compliant by falling through + * to the slow path if the previous value was UNDEFINED_UNUSED. + * This would also remove the need to check for extensibility. + * Right now a non-extensible array is slower than an extensible + * one as far as writes are concerned. + * + * The fast path behavior is documented in more detail here: + * tests/ecmascript/test-misc-array-fast-write.js + */ + + if (duk__putprop_shallow_fastpath_array_tval(thr, orig, tv_key, tv_val, &desc) != 0) { + DUK_DDD(DUK_DDDPRINT("array fast path success")); + return 1; + } + + if (duk__putprop_fastpath_bufobj_tval(thr, orig, tv_key, tv_val) != 0) { + DUK_DDD(DUK_DDDPRINT("base is bufobj, key is a number, bufferobject fast path")); + return 1; + } + +#if defined(DUK_USE_ES6_PROXY) + if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(orig))) { + duk_hobject *h_target; + duk_bool_t tmp_bool; + + if (duk__proxy_check_prop(thr, orig, DUK_STRIDX_SET, tv_key, &h_target)) { + /* -> [ ... trap handler ] */ + DUK_DDD(DUK_DDDPRINT("-> proxy object 'set' for key %!T", (duk_tval *) tv_key)); + duk_push_hobject(ctx, h_target); /* target */ + duk_push_tval(ctx, tv_key); /* P */ + duk_push_tval(ctx, tv_val); /* V */ + duk_push_tval(ctx, tv_obj); /* Receiver: Proxy object */ + duk_call_method(ctx, 4 /*nargs*/); + tmp_bool = duk_to_boolean(ctx, -1); + duk_pop(ctx); + if (!tmp_bool) { + goto fail_proxy_rejected; + } + + /* Target object must be checked for a conflicting + * non-configurable property. + */ + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + + if (duk__get_own_property_desc_raw(thr, h_target, key, arr_idx, &desc, DUK__DESC_FLAG_PUSH_VALUE)) { + duk_tval *tv_targ = duk_require_tval(ctx, -1); + duk_bool_t datadesc_reject; + duk_bool_t accdesc_reject; + + DUK_DDD(DUK_DDDPRINT("proxy 'set': target has matching property %!O, check for " + "conflicting property; tv_val=%!T, tv_targ=%!T, desc.flags=0x%08lx, " + "desc.get=%p, desc.set=%p", + (duk_heaphdr *) key, (duk_tval *) tv_val, (duk_tval *) tv_targ, + (unsigned long) desc.flags, + (void *) desc.get, (void *) desc.set)); + + datadesc_reject = !(desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) && + !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && + !(desc.flags & DUK_PROPDESC_FLAG_WRITABLE) && + !duk_js_samevalue(tv_val, tv_targ); + accdesc_reject = (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) && + !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && + (desc.set == NULL); + if (datadesc_reject || accdesc_reject) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED); + } + + duk_pop_2(ctx); + } else { + duk_pop(ctx); + } + return 1; /* success */ + } + + orig = h_target; /* resume write to target */ + DUK_TVAL_SET_OBJECT(tv_obj, orig); + } +#endif /* DUK_USE_ES6_PROXY */ + + curr = orig; + break; + } + + case DUK_TAG_BUFFER: { + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj); + duk_int_t pop_count = 0; + + /* + * Because buffer values may be looped over and read/written + * from, an array index fast path is important. + */ + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_key)) { + arr_idx = duk__tval_fastint_to_arr_idx(tv_key); + DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path fastint; arr_idx %ld", (long) arr_idx)); + pop_count = 0; + } else +#endif + if (DUK_TVAL_IS_NUMBER(tv_key)) { + arr_idx = duk__tval_number_to_arr_idx(tv_key); + DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path number; arr_idx %ld", (long) arr_idx)); + pop_count = 0; + } else { + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after " + "coercion key is %!T, arr_idx %ld", + (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx)); + pop_count = 1; + } + + if (arr_idx != DUK__NO_ARRAY_INDEX && + arr_idx < DUK_HBUFFER_GET_SIZE(h)) { + duk_uint8_t *data; + DUK_DDD(DUK_DDDPRINT("writing to buffer data at index %ld", (long) arr_idx)); + data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h); + + /* XXX: duk_to_int() ensures we'll get 8 lowest bits as + * as input is within duk_int_t range (capped outside it). + */ +#if defined(DUK_USE_FASTINT) + /* Buffer writes are often integers. */ + if (DUK_TVAL_IS_FASTINT(tv_val)) { + data[arr_idx] = (duk_uint8_t) DUK_TVAL_GET_FASTINT_U32(tv_val); + } + else +#endif + { + duk_push_tval(ctx, tv_val); + data[arr_idx] = (duk_uint8_t) duk_to_uint32(ctx, -1); + pop_count++; + } + + duk_pop_n(ctx, pop_count); + DUK_DDD(DUK_DDDPRINT("result: success (buffer data write)")); + return 1; + } + + if (pop_count == 0) { + /* This is a pretty awkward control flow, but we need to recheck the + * key coercion here. + */ + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after " + "coercion key is %!T, arr_idx %ld", + (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx)); + } + + if (key == DUK_HTHREAD_STRING_LENGTH(thr) || + key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr) || + key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr) || + key == DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)) { + goto fail_not_writable; + } + + DUK_DDD(DUK_DDDPRINT("base object is a buffer, start lookup from buffer prototype")); + curr = thr->builtins[DUK_BIDX_BUFFER_PROTOTYPE]; + goto lookup; /* avoid double coercion */ + } + + case DUK_TAG_POINTER: { + DUK_DDD(DUK_DDDPRINT("base object is a pointer, start lookup from pointer prototype")); + curr = thr->builtins[DUK_BIDX_POINTER_PROTOTYPE]; + break; + } + + case DUK_TAG_LIGHTFUNC: { + /* All lightfunc own properties are non-writable and the lightfunc + * is considered non-extensible. However, the write may be captured + * by an inherited setter which means we can't stop the lookup here. + */ + + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + + if (duk__key_is_lightfunc_ownprop(thr, key)) { + goto fail_not_writable; + } + + DUK_DDD(DUK_DDDPRINT("base object is a lightfunc, start lookup from function prototype")); + curr = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]; + goto lookup; /* avoid double coercion */ + } + +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: { + /* number */ + DUK_DDD(DUK_DDDPRINT("base object is a number, start lookup from number prototype")); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_obj)); + curr = thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE]; + break; + } + } + + DUK_ASSERT(key == NULL); + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + + lookup: + + /* + * Check whether the property already exists in the prototype chain. + * Note that the actual write goes into the original base object + * (except if an accessor property captures the write). + */ + + /* [key] */ + + DUK_ASSERT(curr != NULL); + sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY; + do { + if (!duk__get_own_property_desc_raw(thr, curr, key, arr_idx, &desc, 0 /*flags*/)) { /* don't push value */ + goto next_in_chain; + } + + if (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) { + /* + * Found existing accessor property (own or inherited). + * Call setter with 'this' set to orig, and value as the only argument. + * + * Note: no exotic arguments object behavior, because [[Put]] never + * calls [[DefineOwnProperty]] (E5 Section 8.12.5, step 5.b). + */ + + duk_hobject *setter; + + DUK_DD(DUK_DDPRINT("put to an own or inherited accessor, calling setter")); + + setter = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, curr, desc.e_idx); + if (!setter) { + goto fail_no_setter; + } + duk_push_hobject(ctx, setter); + duk_push_tval(ctx, tv_obj); /* note: original, uncoerced base */ + duk_push_tval(ctx, tv_val); /* [key setter this val] */ +#ifdef DUK_USE_NONSTD_SETTER_KEY_ARGUMENT + duk_dup(ctx, -4); + duk_call_method(ctx, 2); /* [key setter this val key] -> [key retval] */ +#else + duk_call_method(ctx, 1); /* [key setter this val] -> [key retval] */ +#endif + duk_pop(ctx); /* ignore retval -> [key] */ + goto success_no_arguments_exotic; + } + + if (orig == NULL) { + /* + * Found existing own or inherited plain property, but original + * base is a primitive value. + */ + DUK_DD(DUK_DDPRINT("attempt to create a new property in a primitive base object")); + goto fail_base_primitive; + } + + if (curr != orig) { + /* + * Found existing inherited plain property. + * Do an access control check, and if OK, write + * new property to 'orig'. + */ + if (!DUK_HOBJECT_HAS_EXTENSIBLE(orig)) { + DUK_DD(DUK_DDPRINT("found existing inherited plain property, but original object is not extensible")); + goto fail_not_extensible; + } + if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) { + DUK_DD(DUK_DDPRINT("found existing inherited plain property, original object is extensible, but inherited property is not writable")); + goto fail_not_writable; + } + DUK_DD(DUK_DDPRINT("put to new property, object extensible, inherited property found and is writable")); + goto create_new; + } else { + /* + * Found existing own (non-inherited) plain property. + * Do an access control check and update in place. + */ + + if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) { + DUK_DD(DUK_DDPRINT("found existing own (non-inherited) plain property, but property is not writable")); + goto fail_not_writable; + } + if (desc.flags & DUK_PROPDESC_FLAG_VIRTUAL) { + DUK_DD(DUK_DDPRINT("found existing own (non-inherited) virtual property, property is writable")); + if (DUK_HOBJECT_IS_BUFFEROBJECT(curr)) { + duk_hbufferobject *h_bufobj; + duk_uint_t byte_off; + duk_small_uint_t elem_size; + + h_bufobj = (duk_hbufferobject *) curr; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + DUK_DD(DUK_DDPRINT("writable virtual property is in buffer object")); + + /* Careful with wrapping: arr_idx upshift may easily wrap, whereas + * length downshift won't. + */ + if (arr_idx < (h_bufobj->length >> h_bufobj->shift)) { + duk_uint8_t *data; + DUK_DDD(DUK_DDDPRINT("writing to buffer data at index %ld", (long) arr_idx)); + + DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX); /* index/length check guarantees */ + byte_off = arr_idx << h_bufobj->shift; /* no wrap assuming h_bufobj->length is valid */ + elem_size = 1 << h_bufobj->shift; + + /* Coerce to number before validating pointers etc so that the + * number coercions in duk_hbufferobject_validated_write() are + * guaranteed to be side effect free and not invalidate the + * pointer checks we do here. + */ + duk_push_tval(ctx, tv_val); + duk_to_number(ctx, -1); + + if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) { + data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off; + duk_hbufferobject_validated_write(ctx, h_bufobj, data, elem_size); + } else { + DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (write skipped)")); + } + duk_pop(ctx); + goto success_no_arguments_exotic; + } + } + + goto fail_internal; /* should not happen */ + } + DUK_DD(DUK_DDPRINT("put to existing own plain property, property is writable")); + goto update_old; + } + DUK_UNREACHABLE(); + + next_in_chain: + /* XXX: option to pretend property doesn't exist if sanity limit is + * hit might be useful. + */ + if (sanity-- == 0) { + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT); + } + curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr); + } while (curr); + + /* + * Property not found in prototype chain. + */ + + DUK_DDD(DUK_DDDPRINT("property not found in prototype chain")); + + if (orig == NULL) { + DUK_DD(DUK_DDPRINT("attempt to create a new property in a primitive base object")); + goto fail_base_primitive; + } + + if (!DUK_HOBJECT_HAS_EXTENSIBLE(orig)) { + DUK_DD(DUK_DDPRINT("put to a new property (not found in prototype chain), but original object not extensible")); + goto fail_not_extensible; + } + + goto create_new; + + update_old: + + /* + * Update an existing property of the base object. + */ + + /* [key] */ + + DUK_DDD(DUK_DDDPRINT("update an existing property of the original object")); + + DUK_ASSERT(orig != NULL); + + /* Although there are writable virtual properties (e.g. plain buffer + * and buffer object number indices), they are handled before we come + * here. + */ + DUK_ASSERT((desc.flags & DUK_PROPDESC_FLAG_VIRTUAL) == 0); + DUK_ASSERT(desc.a_idx >= 0 || desc.e_idx >= 0); + + if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) && + key == DUK_HTHREAD_STRING_LENGTH(thr)) { + /* + * Write to 'length' of an array is a very complex case + * handled in a helper which updates both the array elements + * and writes the new 'length'. The write may result in an + * unconditional RangeError or a partial write (indicated + * by a return code). + * + * Note: the helper has an unnecessary writability check + * for 'length', we already know it is writable. + */ + + DUK_DDD(DUK_DDDPRINT("writing existing 'length' property to array exotic, invoke complex helper")); + + /* XXX: the helper currently assumes stack top contains new + * 'length' value and the whole calling convention is not very + * compatible with what we need. + */ + + duk_push_tval(ctx, tv_val); /* [key val] */ + rc = duk__handle_put_array_length(thr, orig); + duk_pop(ctx); /* [key val] -> [key] */ + if (!rc) { + goto fail_array_length_partial; + } + + /* key is 'length', cannot match argument exotic behavior */ + goto success_no_arguments_exotic; + } + + if (desc.e_idx >= 0) { + duk_tval tv_tmp; + + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, desc.e_idx); + DUK_DDD(DUK_DDDPRINT("previous entry value: %!iT", (duk_tval *) tv)); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_TVAL(tv, tv_val); + DUK_TVAL_INCREF(thr, tv); + DUK_TVAL_DECREF(thr, &tv_tmp); /* note: may trigger gc and props compaction, must be last */ + /* don't touch property attributes or hash part */ + DUK_DD(DUK_DDPRINT("put to an existing entry at index %ld -> new value %!iT", + (long) desc.e_idx, (duk_tval *) tv)); + } else { + /* Note: array entries are always writable, so the writability check + * above is pointless for them. The check could be avoided with some + * refactoring but is probably not worth it. + */ + duk_tval tv_tmp; + + DUK_ASSERT(desc.a_idx >= 0); + tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, desc.a_idx); + DUK_DDD(DUK_DDDPRINT("previous array value: %!iT", (duk_tval *) tv)); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_TVAL(tv, tv_val); + DUK_TVAL_INCREF(thr, tv); + DUK_TVAL_DECREF(thr, &tv_tmp); /* note: may trigger gc and props compaction, must be last */ + DUK_DD(DUK_DDPRINT("put to an existing array entry at index %ld -> new value %!iT", + (long) desc.a_idx, (duk_tval *) tv)); + } + + /* Regardless of whether property is found in entry or array part, + * it may have arguments exotic behavior (array indices may reside + * in entry part for abandoned / non-existent array parts). + */ + goto success_with_arguments_exotic; + + create_new: + + /* + * Create a new property in the original object. + * + * Exotic properties need to be reconsidered here from a write + * perspective (not just property attributes perspective). + * However, the property does not exist in the object already, + * so this limits the kind of exotic properties that apply. + */ + + /* [key] */ + + DUK_DDD(DUK_DDDPRINT("create new property to original object")); + + DUK_ASSERT(orig != NULL); + + /* Not possible because array object 'length' is present + * from its creation and cannot be deleted, and is thus + * caught as an existing property above. + */ + DUK_ASSERT(!(DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) && + key == DUK_HTHREAD_STRING_LENGTH(thr))); + + if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) && + arr_idx != DUK__NO_ARRAY_INDEX) { + /* automatic length update */ + duk_uint32_t old_len; + + old_len = duk__get_old_array_length(thr, orig, &desc); + + if (arr_idx >= old_len) { + DUK_DDD(DUK_DDDPRINT("write new array entry requires length update " + "(arr_idx=%ld, old_len=%ld)", + (long) arr_idx, (long) old_len)); + + if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) { + DUK_DD(DUK_DDPRINT("attempt to extend array, but array 'length' is not writable")); + goto fail_not_writable; + } + + /* Note: actual update happens once write has been completed + * without error below. The write should always succeed + * from a specification viewpoint, but we may e.g. run out + * of memory. It's safer in this order. + */ + + DUK_ASSERT(arr_idx != 0xffffffffUL); + new_array_length = arr_idx + 1; /* flag for later write */ + } else { + DUK_DDD(DUK_DDDPRINT("write new array entry does not require length update " + "(arr_idx=%ld, old_len=%ld)", + (long) arr_idx, (long) old_len)); + } + } + + /* write_to_array_part: */ + + /* + * Write to array part? + * + * Note: array abandonding requires a property resize which uses + * 'rechecks' valstack for temporaries and may cause any existing + * valstack pointers to be invalidated. To protect against this, + * tv_obj, tv_key, and tv_val are copies of the original inputs. + */ + + if (arr_idx != DUK__NO_ARRAY_INDEX && + DUK_HOBJECT_HAS_ARRAY_PART(orig)) { + if (arr_idx < DUK_HOBJECT_GET_ASIZE(orig)) { + goto no_array_growth; + } + + /* + * Array needs to grow, but we don't want it becoming too sparse. + * If it were to become sparse, abandon array part, moving all + * array entries into the entries part (for good). + * + * Since we don't keep track of actual density (used vs. size) of + * the array part, we need to estimate somehow. The check is made + * in two parts: + * + * - Check whether the resize need is small compared to the + * current size (relatively); if so, resize without further + * checking (essentially we assume that the original part is + * "dense" so that the result would be dense enough). + * + * - Otherwise, compute the resize using an actual density + * measurement based on counting the used array entries. + */ + + DUK_DDD(DUK_DDDPRINT("write to new array requires array resize, decide whether to do a " + "fast resize without abandon check (arr_idx=%ld, old_size=%ld)", + (long) arr_idx, (long) DUK_HOBJECT_GET_ASIZE(orig))); + + if (duk__abandon_array_slow_check_required(arr_idx, DUK_HOBJECT_GET_ASIZE(orig))) { + duk_uint32_t old_used; + duk_uint32_t old_size; + + DUK_DDD(DUK_DDDPRINT("=> fast check is NOT OK, do slow check for array abandon")); + + duk__compute_a_stats(thr, orig, &old_used, &old_size); + + DUK_DDD(DUK_DDDPRINT("abandon check, array stats: old_used=%ld, old_size=%ld, arr_idx=%ld", + (long) old_used, (long) old_size, (long) arr_idx)); + + /* Note: intentionally use approximations to shave a few instructions: + * a_used = old_used (accurate: old_used + 1) + * a_size = arr_idx (accurate: arr_idx + 1) + */ + if (duk__abandon_array_density_check(old_used, arr_idx)) { + DUK_DD(DUK_DDPRINT("write to new array entry beyond current length, " + "decided to abandon array part (would become too sparse)")); + + /* abandoning requires a props allocation resize and + * 'rechecks' the valstack, invalidating any existing + * valstack value pointers! + */ + duk__abandon_array_checked(thr, orig); + DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(orig)); + + goto write_to_entry_part; + } + + DUK_DDD(DUK_DDDPRINT("=> decided to keep array part")); + } else { + DUK_DDD(DUK_DDDPRINT("=> fast resize is OK")); + } + + DUK_DD(DUK_DDPRINT("write to new array entry beyond current length, " + "decided to extend current allocation")); + + duk__grow_props_for_array_item(thr, orig, arr_idx); + + no_array_growth: + + /* Note: assume array part is comprehensive, so that either + * the write goes to the array part, or we've abandoned the + * array above (and will not come here). + */ + + DUK_ASSERT(DUK_HOBJECT_HAS_ARRAY_PART(orig)); + DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(orig)); + + tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, arr_idx); + /* prev value must be unused, no decref */ + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv)); + DUK_TVAL_SET_TVAL(tv, tv_val); + DUK_TVAL_INCREF(thr, tv); + DUK_DD(DUK_DDPRINT("put to new array entry: %ld -> %!T", + (long) arr_idx, (duk_tval *) tv)); + + /* Note: array part values are [[Writable]], [[Enumerable]], + * and [[Configurable]] which matches the required attributes + * here. + */ + goto entry_updated; + } + + write_to_entry_part: + + /* + * Write to entry part + */ + + /* entry allocation updates hash part and increases the key + * refcount; may need a props allocation resize but doesn't + * 'recheck' the valstack. + */ + e_idx = duk__alloc_entry_checked(thr, orig, key); + DUK_ASSERT(e_idx >= 0); + + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, e_idx); + /* prev value can be garbage, no decref */ + DUK_TVAL_SET_TVAL(tv, tv_val); + DUK_TVAL_INCREF(thr, tv); + DUK_HOBJECT_E_SET_FLAGS(thr->heap, orig, e_idx, DUK_PROPDESC_FLAGS_WEC); + goto entry_updated; + + entry_updated: + + /* + * Possible pending array length update, which must only be done + * if the actual entry write succeeded. + */ + + if (new_array_length > 0) { + /* + * Note: zero works as a "no update" marker because the new length + * can never be zero after a new property is written. + * + * Note: must re-lookup because calls above (e.g. duk__alloc_entry_checked()) + * may realloc and compact properties and hence change e_idx. + */ + + DUK_DDD(DUK_DDDPRINT("write successful, pending array length update to: %ld", + (long) new_array_length)); + + rc = duk__get_own_property_desc_raw(thr, orig, DUK_HTHREAD_STRING_LENGTH(thr), DUK__NO_ARRAY_INDEX, &desc, 0 /*flags*/); /* don't push value */ + DUK_UNREF(rc); + DUK_ASSERT(rc != 0); + DUK_ASSERT(desc.e_idx >= 0); + + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, desc.e_idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + /* no need for decref/incref because value is a number */ +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_FASTINT_U32(tv, new_array_length); +#else + DUK_TVAL_SET_NUMBER(tv, (duk_double_t) new_array_length); +#endif + } + + /* + * Arguments exotic behavior not possible for new properties: all + * magically bound properties are initially present in the arguments + * object, and if they are deleted, the binding is also removed from + * parameter map. + */ + + goto success_no_arguments_exotic; + + success_with_arguments_exotic: + + /* + * Arguments objects have exotic [[DefineOwnProperty]] which updates + * the internal 'map' of arguments for writes to currently mapped + * arguments. More conretely, writes to mapped arguments generate + * a write to a bound variable. + * + * The [[Put]] algorithm invokes [[DefineOwnProperty]] for existing + * data properties and new properties, but not for existing accessors. + * Hence, in E5 Section 10.6 ([[DefinedOwnProperty]] algorithm), we + * have a Desc with 'Value' (and possibly other properties too), and + * we end up in step 5.b.i. + */ + + if (arr_idx != DUK__NO_ARRAY_INDEX && + DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(orig)) { + /* Note: only numbered indices are relevant, so arr_idx fast reject + * is good (this is valid unless there are more than 4**32-1 arguments). + */ + + DUK_DDD(DUK_DDDPRINT("putprop successful, arguments exotic behavior needed")); + + /* Note: we can reuse 'desc' here */ + + /* XXX: top of stack must contain value, which helper doesn't touch, + * rework to use tv_val directly? + */ + + duk_push_tval(ctx, tv_val); + (void) duk__check_arguments_map_for_put(thr, orig, key, &desc, throw_flag); + duk_pop(ctx); + } + /* fall thru */ + + success_no_arguments_exotic: + /* shared exit path now */ + DUK_DDD(DUK_DDDPRINT("result: success")); + duk_pop(ctx); /* remove key */ + return 1; + + fail_proxy_rejected: + DUK_DDD(DUK_DDDPRINT("result: error, proxy rejects")); + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED); + } + /* Note: no key on stack */ + return 0; + + fail_base_primitive: + DUK_DDD(DUK_DDDPRINT("result: error, base primitive")); + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE); + } + duk_pop(ctx); /* remove key */ + return 0; + + fail_not_extensible: + DUK_DDD(DUK_DDDPRINT("result: error, not extensible")); + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_EXTENSIBLE); + } + duk_pop(ctx); /* remove key */ + return 0; + + fail_not_writable: + DUK_DDD(DUK_DDDPRINT("result: error, not writable")); + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_WRITABLE); + } + duk_pop(ctx); /* remove key */ + return 0; + + fail_array_length_partial: + DUK_DDD(DUK_DDDPRINT("result: error, array length write only partially successful")); + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_ARRAY_LENGTH_WRITE_FAILED); + } + duk_pop(ctx); /* remove key */ + return 0; + + fail_no_setter: + DUK_DDD(DUK_DDDPRINT("result: error, accessor property without setter")); + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_SETTER_UNDEFINED); + } + duk_pop(ctx); /* remove key */ + return 0; + + fail_internal: + DUK_DDD(DUK_DDDPRINT("result: error, internal")); + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INTERNAL_ERROR); + } + duk_pop(ctx); /* remove key */ + return 0; +} + +/* + * Ecmascript compliant [[Delete]](P, Throw). + */ + +DUK_INTERNAL duk_bool_t duk_hobject_delprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags) { + duk_propdesc desc; + duk_tval *tv; + duk_tval tv_tmp; + duk_uint32_t arr_idx; + duk_bool_t throw_flag; + duk_bool_t force_flag; + + throw_flag = (flags & DUK_DELPROP_FLAG_THROW); + force_flag = (flags & DUK_DELPROP_FLAG_FORCE); + + DUK_DDD(DUK_DDDPRINT("delprop_raw: thr=%p, obj=%p, key=%p, throw=%ld, force=%ld (obj -> %!O, key -> %!O)", + (void *) thr, (void *) obj, (void *) key, (long) throw_flag, (long) force_flag, + (duk_heaphdr *) obj, (duk_heaphdr *) key)); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key); + + /* 0 = don't push current value */ + if (!duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &desc, 0 /*flags*/)) { /* don't push value */ + DUK_DDD(DUK_DDDPRINT("property not found, succeed always")); + goto success; + } + + if ((desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) == 0 && !force_flag) { + goto fail_not_configurable; + } + if (desc.a_idx < 0 && desc.e_idx < 0) { + /* Currently there are no deletable virtual properties, but + * with force_flag we might attempt to delete one. + */ + goto fail_virtual; + } + + if (desc.a_idx >= 0) { + DUK_ASSERT(desc.e_idx < 0); + + tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, desc.a_idx); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_UNDEFINED_UNUSED(tv); + DUK_TVAL_DECREF(thr, &tv_tmp); + goto success; + } else { + DUK_ASSERT(desc.a_idx < 0); + + /* remove hash entry (no decref) */ +#if defined(DUK_USE_HOBJECT_HASH_PART) + if (desc.h_idx >= 0) { + duk_uint32_t *h_base = DUK_HOBJECT_H_GET_BASE(thr->heap, obj); + + DUK_DDD(DUK_DDDPRINT("removing hash entry at h_idx %ld", (long) desc.h_idx)); + DUK_ASSERT(DUK_HOBJECT_GET_HSIZE(obj) > 0); + DUK_ASSERT((duk_uint32_t) desc.h_idx < DUK_HOBJECT_GET_HSIZE(obj)); + h_base[desc.h_idx] = DUK__HASH_DELETED; + } else { + DUK_ASSERT(DUK_HOBJECT_GET_HSIZE(obj) == 0); + } +#else + DUK_ASSERT(DUK_HOBJECT_GET_HSIZE(obj) == 0); +#endif + + /* remove value */ + DUK_DDD(DUK_DDDPRINT("before removing value, e_idx %ld, key %p, key at slot %p", + (long) desc.e_idx, (void *) key, (void *) DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx))); + DUK_DDD(DUK_DDDPRINT("removing value at e_idx %ld", (long) desc.e_idx)); + if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx)) { + duk_hobject *tmp; + + tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, desc.e_idx); + DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, desc.e_idx, NULL); + DUK_UNREF(tmp); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + + tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, desc.e_idx); + DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, desc.e_idx, NULL); + DUK_UNREF(tmp); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + } else { + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_UNDEFINED_UNUSED(tv); + DUK_TVAL_DECREF(thr, &tv_tmp); + } + /* this is not strictly necessary because if key == NULL, value MUST be ignored */ + DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, desc.e_idx, 0); + DUK_TVAL_SET_UNDEFINED_UNUSED(DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx)); + + /* remove key */ + DUK_DDD(DUK_DDDPRINT("before removing key, e_idx %ld, key %p, key at slot %p", + (long) desc.e_idx, (void *) key, (void *) DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx))); + DUK_DDD(DUK_DDDPRINT("removing key at e_idx %ld", (long) desc.e_idx)); + DUK_ASSERT(key == DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx)); + DUK_HOBJECT_E_SET_KEY(thr->heap, obj, desc.e_idx, NULL); + DUK_HSTRING_DECREF(thr, key); + goto success; + } + + DUK_UNREACHABLE(); + + success: + /* + * Argument exotic [[Delete]] behavior (E5 Section 10.6) is + * a post-check, keeping arguments internal 'map' in sync with + * any successful deletes (note that property does not need to + * exist for delete to 'succeed'). + * + * Delete key from 'map'. Since 'map' only contains array index + * keys, we can use arr_idx for a fast skip. + */ + + DUK_DDD(DUK_DDDPRINT("delete successful, check for arguments exotic behavior")); + + if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)) { + /* Note: only numbered indices are relevant, so arr_idx fast reject + * is good (this is valid unless there are more than 4**32-1 arguments). + */ + + DUK_DDD(DUK_DDDPRINT("delete successful, arguments exotic behavior needed")); + + /* Note: we can reuse 'desc' here */ + (void) duk__check_arguments_map_for_delete(thr, obj, key, &desc); + } + + DUK_DDD(DUK_DDDPRINT("delete successful")); + return 1; + + fail_virtual: + DUK_DDD(DUK_DDDPRINT("delete failed: property found, force flag, but virtual")); + + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROPERTY_IS_VIRTUAL); + } + return 0; + + fail_not_configurable: + DUK_DDD(DUK_DDDPRINT("delete failed: property found, not configurable")); + + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CONFIGURABLE); + } + return 0; +} + +/* + * DELPROP: Ecmascript property deletion. + */ + +DUK_INTERNAL duk_bool_t duk_hobject_delprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key, duk_bool_t throw_flag) { + duk_context *ctx = (duk_context *) thr; + duk_hstring *key = NULL; +#if defined(DUK_USE_ES6_PROXY) + duk_propdesc desc; +#endif + duk_int_t entry_top; + duk_uint32_t arr_idx = DUK__NO_ARRAY_INDEX; + duk_bool_t rc; + + DUK_DDD(DUK_DDDPRINT("delprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)", + (void *) thr, (void *) tv_obj, (void *) tv_key, + (duk_tval *) tv_obj, (duk_tval *) tv_key)); + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(tv_obj != NULL); + DUK_ASSERT(tv_key != NULL); + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + /* Storing the entry top is cheaper here to ensure stack is correct at exit, + * as there are several paths out. + */ + entry_top = duk_get_top(ctx); + + if (DUK_TVAL_IS_UNDEFINED(tv_obj) || + DUK_TVAL_IS_NULL(tv_obj)) { + DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject")); + goto fail_invalid_base_uncond; + } + + duk_push_tval(ctx, tv_obj); + duk_push_tval(ctx, tv_key); + + tv_obj = duk_get_tval(ctx, -2); + if (DUK_TVAL_IS_OBJECT(tv_obj)) { + duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv_obj); + DUK_ASSERT(obj != NULL); + +#if defined(DUK_USE_ES6_PROXY) + if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) { + duk_hobject *h_target; + duk_bool_t tmp_bool; + + /* Note: proxy handling must happen before key is string coerced. */ + + if (duk__proxy_check_prop(thr, obj, DUK_STRIDX_DELETE_PROPERTY, tv_key, &h_target)) { + /* -> [ ... trap handler ] */ + DUK_DDD(DUK_DDDPRINT("-> proxy object 'deleteProperty' for key %!T", (duk_tval *) tv_key)); + duk_push_hobject(ctx, h_target); /* target */ + duk_push_tval(ctx, tv_key); /* P */ + duk_call_method(ctx, 2 /*nargs*/); + tmp_bool = duk_to_boolean(ctx, -1); + duk_pop(ctx); + if (!tmp_bool) { + goto fail_proxy_rejected; /* retval indicates delete failed */ + } + + /* Target object must be checked for a conflicting + * non-configurable property. + */ + arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); + DUK_ASSERT(key != NULL); + + if (duk__get_own_property_desc_raw(thr, h_target, key, arr_idx, &desc, 0 /*flags*/)) { /* don't push value */ + int desc_reject; + + DUK_DDD(DUK_DDDPRINT("proxy 'deleteProperty': target has matching property %!O, check for " + "conflicting property; desc.flags=0x%08lx, " + "desc.get=%p, desc.set=%p", + (duk_heaphdr *) key, (unsigned long) desc.flags, + (void *) desc.get, (void *) desc.set)); + + desc_reject = !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE); + if (desc_reject) { + /* unconditional */ + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED); + } + } + rc = 1; /* success */ + goto done_rc; + } + + obj = h_target; /* resume delete to target */ + } +#endif /* DUK_USE_ES6_PROXY */ + + duk_to_string(ctx, -1); + key = duk_get_hstring(ctx, -1); + DUK_ASSERT(key != NULL); + + rc = duk_hobject_delprop_raw(thr, obj, key, throw_flag ? DUK_DELPROP_FLAG_THROW : 0); + goto done_rc; + } else if (DUK_TVAL_IS_STRING(tv_obj)) { + /* XXX: unnecessary string coercion for array indices, + * intentional to keep small. + */ + duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj); + DUK_ASSERT(h != NULL); + + duk_to_string(ctx, -1); + key = duk_get_hstring(ctx, -1); + DUK_ASSERT(key != NULL); + + if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { + goto fail_not_configurable; + } + + arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key); + + if (arr_idx != DUK__NO_ARRAY_INDEX && + arr_idx < DUK_HSTRING_GET_CHARLEN(h)) { + goto fail_not_configurable; + } + } else if (DUK_TVAL_IS_BUFFER(tv_obj)) { + /* XXX: unnecessary string coercion for array indices, + * intentional to keep small; some overlap with string + * handling. + */ + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj); + DUK_ASSERT(h != NULL); + + duk_to_string(ctx, -1); + key = duk_get_hstring(ctx, -1); + DUK_ASSERT(key != NULL); + + if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { + goto fail_not_configurable; + } + + arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key); + + if (arr_idx != DUK__NO_ARRAY_INDEX && + arr_idx < DUK_HBUFFER_GET_SIZE(h)) { + goto fail_not_configurable; + } + } else if (DUK_TVAL_IS_LIGHTFUNC(tv_obj)) { + /* Lightfunc virtual properties are non-configurable, so + * reject if match any of them. + */ + + duk_to_string(ctx, -1); + key = duk_get_hstring(ctx, -1); + DUK_ASSERT(key != NULL); + + if (duk__key_is_lightfunc_ownprop(thr, key)) { + goto fail_not_configurable; + } + } + + /* non-object base, no offending virtual property */ + rc = 1; + goto done_rc; + + done_rc: + duk_set_top(ctx, entry_top); + return rc; + + fail_invalid_base_uncond: + /* Note: unconditional throw */ + DUK_ASSERT(duk_get_top(ctx) == entry_top); + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE); + return 0; + + fail_proxy_rejected: + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED); + } + duk_set_top(ctx, entry_top); + return 0; + + fail_not_configurable: + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CONFIGURABLE); + } + duk_set_top(ctx, entry_top); + return 0; +} + +/* + * Internal helper to define a property with specific flags, ignoring + * normal semantics such as extensibility, write protection etc. + * Overwrites any existing value and attributes unless caller requests + * that value only be updated if it doesn't already exists. + * + * Does not support: + * - virtual properties (error if write attempted) + * - getter/setter properties (error if write attempted) + * - non-default (!= WEC) attributes for array entries (error if attempted) + * - array abandoning: if array part exists, it is always extended + * - array 'length' updating + * + * Stack: [... in_val] -> [] + * + * Used for e.g. built-in initialization and environment record + * operations. + */ + +DUK_INTERNAL void duk_hobject_define_property_internal(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags) { + duk_context *ctx = (duk_context *) thr; + duk_propdesc desc; + duk_uint32_t arr_idx; + duk_int_t e_idx; + duk_tval tv_tmp; + duk_tval *tv1 = NULL; + duk_tval *tv2 = NULL; + duk_small_uint_t propflags = flags & DUK_PROPDESC_FLAGS_MASK; /* mask out flags not actually stored */ + + DUK_DDD(DUK_DDDPRINT("define new property (internal): thr=%p, obj=%!O, key=%!O, flags=0x%02lx, val=%!T", + (void *) thr, (duk_heaphdr *) obj, (duk_heaphdr *) key, + (unsigned long) flags, (duk_tval *) duk_get_tval(ctx, -1))); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + DUK_ASSERT(duk_is_valid_index(ctx, -1)); /* contains value */ + + arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key); + + if (duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &desc, 0 /*flags*/)) { /* don't push value */ + if (desc.e_idx >= 0) { + if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) { + DUK_DDD(DUK_DDDPRINT("property already exists in the entry part -> skip as requested")); + goto pop_exit; + } + DUK_DDD(DUK_DDDPRINT("property already exists in the entry part -> update value and attributes")); + if (DUK_UNLIKELY(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx))) { + DUK_D(DUK_DPRINT("existing property is an accessor, not supported")); + goto error_internal; + } + + DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, desc.e_idx, propflags); + tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx); + } else if (desc.a_idx >= 0) { + if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) { + DUK_DDD(DUK_DDDPRINT("property already exists in the array part -> skip as requested")); + goto pop_exit; + } + DUK_DDD(DUK_DDDPRINT("property already exists in the array part -> update value (assert attributes)")); + if (propflags != DUK_PROPDESC_FLAGS_WEC) { + DUK_D(DUK_DPRINT("existing property in array part, but propflags not WEC (0x%02lx)", + (unsigned long) propflags)); + goto error_internal; + } + + tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, desc.a_idx); + } else { + if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) { + DUK_DDD(DUK_DDDPRINT("property already exists but is virtual -> skip as requested")); + goto pop_exit; + } + DUK_DDD(DUK_DDDPRINT("property already exists but is virtual -> failure")); + goto error_virtual; + } + + goto write_value; + } + + if (DUK_HOBJECT_HAS_ARRAY_PART(obj)) { + if (arr_idx != DUK__NO_ARRAY_INDEX) { + DUK_DDD(DUK_DDDPRINT("property does not exist, object has array part -> possibly extend array part and write value (assert attributes)")); + DUK_ASSERT(propflags == DUK_PROPDESC_FLAGS_WEC); + + /* always grow the array, no sparse / abandon support here */ + if (arr_idx >= DUK_HOBJECT_GET_ASIZE(obj)) { + duk__grow_props_for_array_item(thr, obj, arr_idx); + } + + DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(obj)); + tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx); + goto write_value; + } + } + + DUK_DDD(DUK_DDDPRINT("property does not exist, object belongs in entry part -> allocate new entry and write value and attributes")); + e_idx = duk__alloc_entry_checked(thr, obj, key); /* increases key refcount */ + DUK_ASSERT(e_idx >= 0); + DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, propflags); + tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx); + /* new entry: previous value is garbage; set to undefined to share write_value */ + DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1); + goto write_value; + + write_value: + /* tv1 points to value storage */ + + tv2 = duk_require_tval(ctx, -1); /* late lookup, avoid side effects */ + DUK_DDD(DUK_DDDPRINT("writing/updating value: %!T -> %!T", + (duk_tval *) tv1, (duk_tval *) tv2)); + + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, tv2); + DUK_TVAL_INCREF(thr, tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + goto pop_exit; + + pop_exit: + duk_pop(ctx); /* remove in_val */ + return; + + error_internal: + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR); + return; + + error_virtual: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_REDEFINE_VIRT_PROP); + return; +} + +/* + * Fast path for defining array indexed values without interning the key. + * This is used by e.g. code for Array prototype and traceback creation so + * must avoid interning. + */ + +DUK_INTERNAL void duk_hobject_define_property_internal_arridx(duk_hthread *thr, duk_hobject *obj, duk_uarridx_t arr_idx, duk_small_uint_t flags) { + duk_context *ctx = (duk_context *) thr; + duk_hstring *key; + duk_tval *tv1, *tv2; + duk_tval tv_tmp; + + DUK_DDD(DUK_DDDPRINT("define new property (internal) arr_idx fast path: thr=%p, obj=%!O, " + "arr_idx=%ld, flags=0x%02lx, val=%!T", + (void *) thr, obj, (long) arr_idx, (unsigned long) flags, + (duk_tval *) duk_get_tval(ctx, -1))); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(obj != NULL); + + if (DUK_HOBJECT_HAS_ARRAY_PART(obj) && + arr_idx != DUK__NO_ARRAY_INDEX && + flags == DUK_PROPDESC_FLAGS_WEC) { + DUK_ASSERT((flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) == 0); /* covered by comparison */ + + DUK_DDD(DUK_DDDPRINT("define property to array part (property may or may not exist yet)")); + + /* always grow the array, no sparse / abandon support here */ + if (arr_idx >= DUK_HOBJECT_GET_ASIZE(obj)) { + duk__grow_props_for_array_item(thr, obj, arr_idx); + } + + DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(obj)); + tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx); + tv2 = duk_require_tval(ctx, -1); + + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, tv2); + DUK_TVAL_INCREF(thr, tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + duk_pop(ctx); /* [ ...val ] -> [ ... ] */ + return; + } + + DUK_DDD(DUK_DDDPRINT("define property fast path didn't work, use slow path")); + + duk_push_uint(ctx, (duk_uint_t) arr_idx); + key = duk_to_hstring(ctx, -1); + DUK_ASSERT(key != NULL); + duk_insert(ctx, -2); /* [ ... val key ] -> [ ... key val ] */ + + duk_hobject_define_property_internal(thr, obj, key, flags); + + duk_pop(ctx); /* [ ... key ] -> [ ... ] */ +} + +/* + * Internal helper for defining an accessor property, ignoring + * normal semantics such as extensibility, write protection etc. + * Overwrites any existing value and attributes. This is called + * very rarely, so the implementation first sets a value to undefined + * and then changes the entry to an accessor (this is to save code space). + */ + +DUK_INTERNAL void duk_hobject_define_accessor_internal(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_hobject *getter, duk_hobject *setter, duk_small_uint_t propflags) { + duk_context *ctx = (duk_context *) thr; + duk_int_t e_idx; + duk_int_t h_idx; + + DUK_DDD(DUK_DDDPRINT("define new accessor (internal): thr=%p, obj=%!O, key=%!O, " + "getter=%!O, setter=%!O, flags=0x%02lx", + (void *) thr, (duk_heaphdr *) obj, (duk_heaphdr *) key, + (duk_heaphdr *) getter, (duk_heaphdr *) setter, + (unsigned long) propflags)); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + DUK_ASSERT((propflags & ~DUK_PROPDESC_FLAGS_MASK) == 0); + /* setter and/or getter may be NULL */ + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + /* force the property to 'undefined' to create a slot for it */ + duk_push_undefined(ctx); + duk_hobject_define_property_internal(thr, obj, key, propflags); + duk_hobject_find_existing_entry(thr->heap, obj, key, &e_idx, &h_idx); + DUK_DDD(DUK_DDDPRINT("accessor slot: e_idx=%ld, h_idx=%ld", (long) e_idx, (long) h_idx)); + DUK_ASSERT(e_idx >= 0); + DUK_ASSERT((duk_uint32_t) e_idx < DUK_HOBJECT_GET_ENEXT(obj)); + + /* no need to decref, as previous value is 'undefined' */ + DUK_HOBJECT_E_SLOT_SET_ACCESSOR(thr->heap, obj, e_idx); + DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, e_idx, getter); + DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, e_idx, setter); + DUK_HOBJECT_INCREF_ALLOWNULL(thr, getter); + DUK_HOBJECT_INCREF_ALLOWNULL(thr, setter); +} + +/* + * Internal helpers for managing object 'length' + */ + +/* XXX: awkward helpers */ + +DUK_INTERNAL void duk_hobject_set_length(duk_hthread *thr, duk_hobject *obj, duk_uint32_t length) { + duk_context *ctx = (duk_context *) thr; + duk_push_hobject(ctx, obj); + duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH); + duk_push_u32(ctx, length); + (void) duk_hobject_putprop(thr, duk_get_tval(ctx, -3), duk_get_tval(ctx, -2), duk_get_tval(ctx, -1), 0); + duk_pop_n(ctx, 3); +} + +DUK_INTERNAL void duk_hobject_set_length_zero(duk_hthread *thr, duk_hobject *obj) { + duk_hobject_set_length(thr, obj, 0); +} + +DUK_INTERNAL duk_uint32_t duk_hobject_get_length(duk_hthread *thr, duk_hobject *obj) { + duk_context *ctx = (duk_context *) thr; + duk_double_t val; + duk_push_hobject(ctx, obj); + duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH); + (void) duk_hobject_getprop(thr, duk_get_tval(ctx, -2), duk_get_tval(ctx, -1)); + val = duk_to_number(ctx, -1); + duk_pop_n(ctx, 3); + if (val >= 0.0 && val < DUK_DOUBLE_2TO32) { + return (duk_uint32_t) val; + } + return 0; +} + +/* + * Object.getOwnPropertyDescriptor() (E5 Sections 15.2.3.3, 8.10.4) + * + * This is an actual function call. + */ + +DUK_INTERNAL duk_ret_t duk_hobject_object_get_own_property_descriptor(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hobject *obj; + duk_hstring *key; + duk_propdesc pd; + duk_bool_t rc; + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + + obj = duk_require_hobject_or_lfunc_coerce(ctx, 0); + (void) duk_to_string(ctx, 1); + key = duk_require_hstring(ctx, 1); + + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + rc = duk__get_own_property_desc(thr, obj, key, &pd, DUK__DESC_FLAG_PUSH_VALUE); + if (!rc) { + duk_push_undefined(ctx); + + /* [obj key undefined] */ + return 1; + } + + duk_push_object(ctx); + + /* [obj key value desc] */ + + if (DUK_PROPDESC_IS_ACCESSOR(&pd)) { + /* If a setter/getter is missing (undefined), the descriptor must + * still have the property present with the value 'undefined'. + */ + if (pd.get) { + duk_push_hobject(ctx, pd.get); + } else { + duk_push_undefined(ctx); + } + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_GET); + if (pd.set) { + duk_push_hobject(ctx, pd.set); + } else { + duk_push_undefined(ctx); + } + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_SET); + } else { + duk_dup(ctx, -2); /* [obj key value desc value] */ + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_VALUE); + duk_push_boolean(ctx, DUK_PROPDESC_IS_WRITABLE(&pd)); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_WRITABLE); + + /* [obj key value desc] */ + } + duk_push_boolean(ctx, DUK_PROPDESC_IS_ENUMERABLE(&pd)); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_ENUMERABLE); + duk_push_boolean(ctx, DUK_PROPDESC_IS_CONFIGURABLE(&pd)); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_CONFIGURABLE); + + /* [obj key value desc] */ + return 1; +} + +/* + * NormalizePropertyDescriptor() related helper. + * + * Internal helper which validates and normalizes a property descriptor + * represented as an Ecmascript object (e.g. argument to defineProperty()). + * The output of this conversion is a set of defprop_flags and possibly + * some values pushed on the value stack; some subset of: property value, + * getter, setter. Caller must manage stack top carefully because the + * number of values pushed depends on the input property descriptor. + * + * The original descriptor object must not be altered in the process. + */ + +/* XXX: very basic optimization -> duk_get_prop_stridx_top */ + +DUK_INTERNAL +void duk_hobject_prepare_property_descriptor(duk_context *ctx, + duk_idx_t idx_in, + duk_uint_t *out_defprop_flags, + duk_idx_t *out_idx_value, + duk_hobject **out_getter, + duk_hobject **out_setter) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_idx_t idx_value = -1; + duk_hobject *getter = NULL; + duk_hobject *setter = NULL; + duk_bool_t is_data_desc = 0; + duk_bool_t is_acc_desc = 0; + duk_uint_t defprop_flags = 0; + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(out_defprop_flags != NULL); + DUK_ASSERT(out_idx_value != NULL); + DUK_ASSERT(out_getter != NULL); + DUK_ASSERT(out_setter != NULL); + + /* Must be an object, otherwise TypeError (E5.1 Section 8.10.5, step 1). */ + idx_in = duk_require_normalize_index(ctx, idx_in); + (void) duk_require_hobject(ctx, idx_in); + + /* The coercion order must match the ToPropertyDescriptor() algorithm + * so that side effects in coercion happen in the correct order. + * (This order also happens to be compatible with duk_def_prop(), + * although it doesn't matter in practice.) + */ + + if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_VALUE)) { + is_data_desc = 1; + defprop_flags |= DUK_DEFPROP_HAVE_VALUE; + idx_value = duk_get_top_index(ctx); + /* Leave 'value' on stack */ + } else { + duk_pop(ctx); + } + + if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_WRITABLE)) { + is_data_desc = 1; + if (duk_to_boolean(ctx, -1)) { + defprop_flags |= DUK_DEFPROP_HAVE_WRITABLE | DUK_DEFPROP_WRITABLE; + } else { + defprop_flags |= DUK_DEFPROP_HAVE_WRITABLE; + } + } + duk_pop(ctx); + + if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_GET)) { + duk_tval *tv = duk_require_tval(ctx, -1); + duk_hobject *h_get; + + if (DUK_TVAL_IS_UNDEFINED(tv)) { + /* undefined is accepted */ + DUK_ASSERT(getter == NULL); + } else { + /* NOTE: lightfuncs are coerced to full functions because + * lightfuncs don't fit into a property value slot. This + * has some side effects, see test-dev-lightfunc-accessor.js. + */ + h_get = duk_get_hobject_or_lfunc_coerce(ctx, -1); + if (h_get == NULL || !DUK_HOBJECT_IS_CALLABLE(h_get)) { + goto type_error; + } + getter = h_get; + } + is_acc_desc = 1; + defprop_flags |= DUK_DEFPROP_HAVE_GETTER; + /* Leave 'getter' on stack */ + } else { + duk_pop(ctx); + } + + if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_SET)) { + duk_tval *tv = duk_require_tval(ctx, -1); + duk_hobject *h_set; + + is_acc_desc = 1; + if (DUK_TVAL_IS_UNDEFINED(tv)) { + /* undefined is accepted */ + DUK_ASSERT(setter == NULL); + } else { + /* NOTE: lightfuncs are coerced to full functions because + * lightfuncs don't fit into a property value slot. This + * has some side effects, see test-dev-lightfunc-accessor.js. + */ + h_set = duk_get_hobject_or_lfunc_coerce(ctx, -1); + if (h_set == NULL || !DUK_HOBJECT_IS_CALLABLE(h_set)) { + goto type_error; + } + setter = h_set; + } + is_acc_desc = 1; + defprop_flags |= DUK_DEFPROP_HAVE_SETTER; + /* Leave 'setter' on stack */ + } else { + duk_pop(ctx); + } + + if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_ENUMERABLE)) { + if (duk_to_boolean(ctx, -1)) { + defprop_flags |= DUK_DEFPROP_HAVE_ENUMERABLE | DUK_DEFPROP_ENUMERABLE; + } else { + defprop_flags |= DUK_DEFPROP_HAVE_ENUMERABLE; + } + } + duk_pop(ctx); + + if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_CONFIGURABLE)) { + if (duk_to_boolean(ctx, -1)) { + defprop_flags |= DUK_DEFPROP_HAVE_CONFIGURABLE | DUK_DEFPROP_CONFIGURABLE; + } else { + defprop_flags |= DUK_DEFPROP_HAVE_CONFIGURABLE; + } + } + duk_pop(ctx); + + if (is_data_desc && is_acc_desc) { + goto type_error; + } + + *out_defprop_flags = defprop_flags; + *out_idx_value = idx_value; + *out_getter = getter; + *out_setter = setter; + + /* [ ... value? getter? setter? ] */ + return; + + type_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_DESCRIPTOR); +} + +/* + * Object.defineProperty() related helper (E5 Section 15.2.3.6) + * + * Inlines all [[DefineOwnProperty]] exotic behaviors. + * + * Note: Ecmascript compliant [[DefineOwnProperty]](P, Desc, Throw) is not + * implemented directly, but Object.defineProperty() serves its purpose. + * We don't need the [[DefineOwnProperty]] internally and we don't have a + * property descriptor with 'missing values' so it's easier to avoid it + * entirely. + * + * Note: this is only called for actual objects, not primitive values. + * This must support virtual properties for full objects (e.g. Strings) + * but not for plain values (e.g. strings). Lightfuncs, even though + * primitive in a sense, are treated like objects and accepted as target + * values. + */ + +/* XXX: this is a major target for size optimization */ +DUK_INTERNAL +void duk_hobject_define_property_helper(duk_context *ctx, + duk_uint_t defprop_flags, + duk_hobject *obj, + duk_hstring *key, + duk_idx_t idx_value, + duk_hobject *get, + duk_hobject *set) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_uint32_t arr_idx; + duk_tval tv; + duk_bool_t has_enumerable; + duk_bool_t has_configurable; + duk_bool_t has_writable; + duk_bool_t has_value; + duk_bool_t has_get; + duk_bool_t has_set; + duk_bool_t is_enumerable; + duk_bool_t is_configurable; + duk_bool_t is_writable; + duk_bool_t throw_flag; + duk_bool_t force_flag; + duk_small_uint_t new_flags; + duk_propdesc curr; + duk_uint32_t arridx_new_array_length; /* != 0 => post-update for array 'length' (used when key is an array index) */ + duk_uint32_t arrlen_old_len; + duk_uint32_t arrlen_new_len; + duk_bool_t pending_write_protect; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(obj != NULL); + DUK_ASSERT(key != NULL); + /* idx_value may be < 0 (no value), set and get may be NULL */ + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + /* All the flags fit in 16 bits, so will fit into duk_bool_t. */ + + has_writable = (defprop_flags & DUK_DEFPROP_HAVE_WRITABLE); + has_enumerable = (defprop_flags & DUK_DEFPROP_HAVE_ENUMERABLE); + has_configurable = (defprop_flags & DUK_DEFPROP_HAVE_CONFIGURABLE); + has_value = (defprop_flags & DUK_DEFPROP_HAVE_VALUE); + has_get = (defprop_flags & DUK_DEFPROP_HAVE_GETTER); + has_set = (defprop_flags & DUK_DEFPROP_HAVE_SETTER); + is_writable = (defprop_flags & DUK_DEFPROP_WRITABLE); + is_enumerable = (defprop_flags & DUK_DEFPROP_ENUMERABLE); + is_configurable = (defprop_flags & DUK_DEFPROP_CONFIGURABLE); + throw_flag = 1; /* Object.defineProperty() calls [[DefineOwnProperty]] with Throw=true */ + force_flag = (defprop_flags & DUK_DEFPROP_FORCE); + + arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key); + + arridx_new_array_length = 0; + pending_write_protect = 0; + arrlen_old_len = 0; + arrlen_new_len = 0; + + DUK_DDD(DUK_DDDPRINT("has_enumerable=%ld is_enumerable=%ld " + "has_configurable=%ld is_configurable=%ld " + "has_writable=%ld is_writable=%ld " + "has_value=%ld value=%!T " + "has_get=%ld get=%p=%!O " + "has_set=%ld set=%p=%!O " + "arr_idx=%ld", + (long) has_enumerable, (long) is_enumerable, + (long) has_configurable, (long) is_configurable, + (long) has_writable, (long) is_writable, + (long) has_value, (duk_tval *) (idx_value >= 0 ? duk_get_tval(ctx, idx_value) : NULL), + (long) has_get, (void *) get, (duk_heaphdr *) get, + (long) has_set, (void *) set, (duk_heaphdr *) set, + (long) arr_idx)); + + /* + * Array exotic behaviors can be implemented at this point. The local variables + * are essentially a 'value copy' of the input descriptor (Desc), which is modified + * by the Array [[DefineOwnProperty]] (E5 Section 15.4.5.1). + */ + + if (!DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj)) { + goto skip_array_exotic; + } + + if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { + /* E5 Section 15.4.5.1, step 3, steps a - i are implemented here, j - n at the end */ + if (!has_value) { + DUK_DDD(DUK_DDDPRINT("exotic array behavior for 'length', but no value in descriptor -> normal behavior")); + goto skip_array_exotic; + } + + DUK_DDD(DUK_DDDPRINT("exotic array behavior for 'length', value present in descriptor -> exotic behavior")); + + /* + * Get old and new length + */ + + /* Note: reuse 'curr' as a temp propdesc */ + arrlen_old_len = duk__get_old_array_length(thr, obj, &curr); + + duk_dup(ctx, idx_value); + arrlen_new_len = duk__to_new_array_length_checked(thr); + duk_push_u32(ctx, arrlen_new_len); + duk_replace(ctx, idx_value); /* step 3.e: replace 'Desc.[[Value]]' */ + + DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld", (long) arrlen_old_len, (long) arrlen_new_len)); + + if (arrlen_new_len >= arrlen_old_len) { + /* standard behavior, step 3.f.i */ + DUK_DDD(DUK_DDDPRINT("new length is same or higher as previous => standard behavior")); + goto skip_array_exotic; + } + DUK_DDD(DUK_DDDPRINT("new length is smaller than previous => exotic post behavior")); + + /* XXX: consolidated algorithm step 15.f -> redundant? */ + if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && !force_flag) { + /* Note: 'curr' refers to 'length' propdesc */ + goto fail_not_writable_array_length; + } + + /* steps 3.h and 3.i */ + if (has_writable && !is_writable) { + DUK_DDD(DUK_DDDPRINT("desc writable is false, force it back to true, and flag pending write protect")); + is_writable = 1; + pending_write_protect = 1; + } + + /* remaining actual steps are carried out if standard DefineOwnProperty succeeds */ + } else if (arr_idx != DUK__NO_ARRAY_INDEX) { + /* XXX: any chance of unifying this with the 'length' key handling? */ + + /* E5 Section 15.4.5.1, step 4 */ + duk_uint32_t old_len; + + /* Note: use 'curr' as a temp propdesc */ + old_len = duk__get_old_array_length(thr, obj, &curr); + + if (arr_idx >= old_len) { + DUK_DDD(DUK_DDDPRINT("defineProperty requires array length update " + "(arr_idx=%ld, old_len=%ld)", + (long) arr_idx, (long) old_len)); + + if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE)) { + /* Note: 'curr' refers to 'length' propdesc */ + goto fail_not_writable_array_length; + } + + /* actual update happens once write has been completed without + * error below. + */ + DUK_ASSERT(arr_idx != 0xffffffffUL); + arridx_new_array_length = arr_idx + 1; + } else { + DUK_DDD(DUK_DDDPRINT("defineProperty does not require length update " + "(arr_idx=%ld, old_len=%ld) -> standard behavior", + (long) arr_idx, (long) old_len)); + } + } + skip_array_exotic: + + /* XXX: There is currently no support for writing buffer object + * indexed elements here. Attempt to do so will succeed and + * write a concrete property into the buffer object. This should + * be fixed at some point but because buffers are a custom feature + * anyway, this is relatively unimportant. + */ + + /* + * Actual Object.defineProperty() default algorithm. + */ + + /* + * First check whether property exists; if not, simple case. This covers + * steps 1-4. + */ + + if (!duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &curr, DUK__DESC_FLAG_PUSH_VALUE)) { + DUK_DDD(DUK_DDDPRINT("property does not exist")); + + if (!DUK_HOBJECT_HAS_EXTENSIBLE(obj) && !force_flag) { + goto fail_not_extensible; + } + + /* XXX: share final setting code for value and flags? difficult because + * refcount code is different. Share entry allocation? But can't allocate + * until array index checked. + */ + + /* steps 4.a and 4.b are tricky */ + if (has_set || has_get) { + duk_int_t e_idx; + + DUK_DDD(DUK_DDDPRINT("create new accessor property")); + + DUK_ASSERT(has_set || set == NULL); + DUK_ASSERT(has_get || get == NULL); + DUK_ASSERT(!has_value); + DUK_ASSERT(!has_writable); + + new_flags = DUK_PROPDESC_FLAG_ACCESSOR; /* defaults, E5 Section 8.6.1, Table 7 */ + if (has_enumerable && is_enumerable) { + new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE; + } + if (has_configurable && is_configurable) { + new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE; + } + + if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_ARRAY_PART(obj)) { + DUK_DDD(DUK_DDDPRINT("accessor cannot go to array part, abandon array")); + duk__abandon_array_checked(thr, obj); + } + + /* write to entry part */ + e_idx = duk__alloc_entry_checked(thr, obj, key); + DUK_ASSERT(e_idx >= 0); + + DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, e_idx, get); + DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, e_idx, set); + DUK_HOBJECT_INCREF_ALLOWNULL(thr, get); + DUK_HOBJECT_INCREF_ALLOWNULL(thr, set); + + DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, new_flags); + goto success_exotics; + } else { + duk_int_t e_idx; + duk_tval *tv2; + + DUK_DDD(DUK_DDDPRINT("create new data property")); + + DUK_ASSERT(!has_set); + DUK_ASSERT(!has_get); + + new_flags = 0; /* defaults, E5 Section 8.6.1, Table 7 */ + if (has_writable && is_writable) { + new_flags |= DUK_PROPDESC_FLAG_WRITABLE; + } + if (has_enumerable && is_enumerable) { + new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE; + } + if (has_configurable && is_configurable) { + new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE; + } + if (has_value) { + duk_tval *tv_tmp = duk_require_tval(ctx, idx_value); + DUK_TVAL_SET_TVAL(&tv, tv_tmp); + } else { + DUK_TVAL_SET_UNDEFINED_ACTUAL(&tv); /* default value */ + } + + if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_ARRAY_PART(obj)) { + if (new_flags == DUK_PROPDESC_FLAGS_WEC) { +#if 0 + DUK_DDD(DUK_DDDPRINT("new data property attributes match array defaults, attempt to write to array part")); + /* may become sparse...*/ +#endif + /* XXX: handling for array part missing now; this doesn't affect + * compliance but causes array entry writes using defineProperty() + * to always abandon array part. + */ + } + DUK_DDD(DUK_DDDPRINT("new data property cannot go to array part, abandon array")); + duk__abandon_array_checked(thr, obj); + /* fall through */ + } + + /* write to entry part */ + e_idx = duk__alloc_entry_checked(thr, obj, key); + DUK_ASSERT(e_idx >= 0); + tv2 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx); + DUK_TVAL_SET_TVAL(tv2, &tv); + DUK_TVAL_INCREF(thr, tv2); + + DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, new_flags); + goto success_exotics; + } + DUK_UNREACHABLE(); + } + + /* we currently assume virtual properties are not configurable (as none of them are) */ + DUK_ASSERT((curr.e_idx >= 0 || curr.a_idx >= 0) || !(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE)); + + /* [obj key desc value get set curr_value] */ + + /* + * Property already exists. Steps 5-6 detect whether any changes need + * to be made. + */ + + if (has_enumerable) { + if (is_enumerable) { + if (!(curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE)) { + goto need_check; + } + } else { + if (curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE) { + goto need_check; + } + } + } + if (has_configurable) { + if (is_configurable) { + if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE)) { + goto need_check; + } + } else { + if (curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) { + goto need_check; + } + } + } + if (has_value) { + duk_tval *tmp1; + duk_tval *tmp2; + + /* attempt to change from accessor to data property */ + if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) { + goto need_check; + } + + tmp1 = duk_require_tval(ctx, -1); /* curr value */ + tmp2 = duk_require_tval(ctx, idx_value); /* new value */ + if (!duk_js_samevalue(tmp1, tmp2)) { + goto need_check; + } + } + if (has_writable) { + /* attempt to change from accessor to data property */ + if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) { + goto need_check; + } + + if (is_writable) { + if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE)) { + goto need_check; + } + } else { + if (curr.flags & DUK_PROPDESC_FLAG_WRITABLE) { + goto need_check; + } + } + } + if (has_set) { + if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) { + if (set != curr.set) { + goto need_check; + } + } else { + goto need_check; + } + } + if (has_get) { + if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) { + if (get != curr.get) { + goto need_check; + } + } else { + goto need_check; + } + } + + /* property exists, either 'desc' is empty, or all values + * match (SameValue) + */ + goto success_no_exotics; + + need_check: + + /* + * Some change(s) need to be made. Steps 7-11. + */ + + /* shared checks for all descriptor types */ + if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) { + if (has_configurable && is_configurable) { + goto fail_not_configurable; + } + if (has_enumerable) { + if (curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE) { + if (!is_enumerable) { + goto fail_not_configurable; + } + } else { + if (is_enumerable) { + goto fail_not_configurable; + } + } + } + } + + /* Reject attempt to change virtual properties: not part of the + * standard algorithm, applies currently to e.g. virtual index + * properties of buffer objects (which are virtual but writable). + * (Cannot "force" modification of a virtual property.) + */ + if (curr.flags & DUK_PROPDESC_FLAG_VIRTUAL) { + goto fail_virtual; + } + + /* descriptor type specific checks */ + if (has_set || has_get) { + /* IsAccessorDescriptor(desc) == true */ + DUK_ASSERT(!has_writable); + DUK_ASSERT(!has_value); + + if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) { + /* curr and desc are accessors */ + if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) { + if (has_set && set != curr.set) { + goto fail_not_configurable; + } + if (has_get && get != curr.get) { + goto fail_not_configurable; + } + } + } else { + duk_bool_t rc; + duk_tval tv_tmp; + duk_tval *tv1; + + /* curr is data, desc is accessor */ + if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) { + goto fail_not_configurable; + } + + DUK_DDD(DUK_DDDPRINT("convert property to accessor property")); + if (curr.a_idx >= 0) { + DUK_DDD(DUK_DDDPRINT("property to convert is stored in an array entry, abandon array and re-lookup")); + duk__abandon_array_checked(thr, obj); + duk_pop(ctx); /* remove old value */ + rc = duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &curr, DUK__DESC_FLAG_PUSH_VALUE); + DUK_UNREF(rc); + DUK_ASSERT(rc != 0); + DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0); + } + + DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx)); + + tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_UNDEFINED_UNUSED(tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); + + DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, NULL); + DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, NULL); + DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx); + DUK_HOBJECT_E_SLOT_SET_ACCESSOR(thr->heap, obj, curr.e_idx); + + DUK_DDD(DUK_DDDPRINT("flags after data->accessor conversion: 0x%02lx", + (unsigned long) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, curr.e_idx))); + + /* re-lookup to update curr.flags + * XXX: would be faster to update directly + */ + duk_pop(ctx); /* remove old value */ + rc = duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &curr, DUK__DESC_FLAG_PUSH_VALUE); + DUK_UNREF(rc); + DUK_ASSERT(rc != 0); + } + } else if (has_value || has_writable) { + /* IsDataDescriptor(desc) == true */ + DUK_ASSERT(!has_set); + DUK_ASSERT(!has_get); + + if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) { + duk_bool_t rc; + duk_hobject *tmp; + + /* curr is accessor, desc is data */ + if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) { + goto fail_not_configurable; + } + + /* curr is accessor -> cannot be in array part */ + DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0); + + DUK_DDD(DUK_DDDPRINT("convert property to data property")); + + DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx)); + tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, curr.e_idx); + DUK_UNREF(tmp); + DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, NULL); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, curr.e_idx); + DUK_UNREF(tmp); + DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, NULL); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + + DUK_TVAL_SET_UNDEFINED_ACTUAL(DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx)); + DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx); + DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR(thr->heap, obj, curr.e_idx); + + DUK_DDD(DUK_DDDPRINT("flags after accessor->data conversion: 0x%02lx", + (unsigned long) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, curr.e_idx))); + + /* re-lookup to update curr.flags + * XXX: would be faster to update directly + */ + duk_pop(ctx); /* remove old value */ + rc = duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &curr, DUK__DESC_FLAG_PUSH_VALUE); + DUK_UNREF(rc); + DUK_ASSERT(rc != 0); + } else { + /* curr and desc are data */ + if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) { + if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && has_writable && is_writable) { + goto fail_not_configurable; + } + /* Note: changing from writable to non-writable is OK */ + if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && has_value) { + duk_tval *tmp1 = duk_require_tval(ctx, -1); /* curr value */ + duk_tval *tmp2 = duk_require_tval(ctx, idx_value); /* new value */ + if (!duk_js_samevalue(tmp1, tmp2)) { + goto fail_not_configurable; + } + } + } + } + } else { + /* IsGenericDescriptor(desc) == true; this means in practice that 'desc' + * only has [[Enumerable]] or [[Configurable]] flag updates, which are + * allowed at this point. + */ + + DUK_ASSERT(!has_value && !has_writable && !has_get && !has_set); + } + + /* + * Start doing property attributes updates. Steps 12-13. + * + * Start by computing new attribute flags without writing yet. + * Property type conversion is done above if necessary. + */ + + new_flags = curr.flags; + + if (has_enumerable) { + if (is_enumerable) { + new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE; + } else { + new_flags &= ~DUK_PROPDESC_FLAG_ENUMERABLE; + } + } + if (has_configurable) { + if (is_configurable) { + new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE; + } else { + new_flags &= ~DUK_PROPDESC_FLAG_CONFIGURABLE; + } + } + if (has_writable) { + if (is_writable) { + new_flags |= DUK_PROPDESC_FLAG_WRITABLE; + } else { + new_flags &= ~DUK_PROPDESC_FLAG_WRITABLE; + } + } + + /* XXX: write protect after flag? -> any chance of handling it here? */ + + DUK_DDD(DUK_DDDPRINT("new flags that we want to write: 0x%02lx", + (unsigned long) new_flags)); + + /* + * Check whether we need to abandon an array part (if it exists) + */ + + if (curr.a_idx >= 0) { + duk_bool_t rc; + + DUK_ASSERT(curr.e_idx < 0); + + if (new_flags == DUK_PROPDESC_FLAGS_WEC) { + duk_tval *tv1, *tv2; + duk_tval tv_tmp; + + DUK_DDD(DUK_DDDPRINT("array index, new property attributes match array defaults, update in-place")); + + DUK_ASSERT(curr.flags == DUK_PROPDESC_FLAGS_WEC); /* must have been, since in array part */ + DUK_ASSERT(!has_set); + DUK_ASSERT(!has_get); + + tv2 = duk_require_tval(ctx, idx_value); + tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, curr.a_idx); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, tv2); + DUK_TVAL_INCREF(thr, tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); + goto success_exotics; + } + + DUK_DDD(DUK_DDDPRINT("array index, new property attributes do not match array defaults, abandon array and re-lookup")); + duk__abandon_array_checked(thr, obj); + duk_pop(ctx); /* remove old value */ + rc = duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &curr, DUK__DESC_FLAG_PUSH_VALUE); + DUK_UNREF(rc); + DUK_ASSERT(rc != 0); + DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0); + } + + DUK_DDD(DUK_DDDPRINT("updating existing property in entry part")); + + /* array case is handled comprehensively above */ + DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0); + + DUK_DDD(DUK_DDDPRINT("update existing property attributes")); + DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, curr.e_idx, new_flags); + + if (has_set) { + duk_hobject *tmp; + + DUK_DDD(DUK_DDDPRINT("update existing property setter")); + DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx)); + + tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, curr.e_idx); + DUK_UNREF(tmp); + DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, set); + DUK_HOBJECT_INCREF_ALLOWNULL(thr, set); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + } + if (has_get) { + duk_hobject *tmp; + + DUK_DDD(DUK_DDDPRINT("update existing property getter")); + DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx)); + + tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, curr.e_idx); + DUK_UNREF(tmp); + DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, get); + DUK_HOBJECT_INCREF_ALLOWNULL(thr, get); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + } + if (has_value) { + duk_tval *tv1, *tv2; + duk_tval tv_tmp; + + DUK_DDD(DUK_DDDPRINT("update existing property value")); + DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx)); + + tv2 = duk_require_tval(ctx, idx_value); + tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, tv2); + DUK_TVAL_INCREF(thr, tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); + } + + /* + * Standard algorithm succeeded without errors, check for exotic post-behaviors. + * + * Arguments exotic behavior in E5 Section 10.6 occurs after the standard + * [[DefineOwnProperty]] has completed successfully. + * + * Array exotic behavior in E5 Section 15.4.5.1 is implemented partly + * prior to the default [[DefineOwnProperty]], but: + * - for an array index key (e.g. "10") the final 'length' update occurs here + * - for 'length' key the element deletion and 'length' update occurs here + */ + + success_exotics: + + /* [obj key desc value get set curr_value] */ + + if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj)) { + if (arridx_new_array_length > 0) { + duk_tval *tmp; + duk_bool_t rc; + + /* + * Note: zero works as a "no update" marker because the new length + * can never be zero after a new property is written. + */ + + /* E5 Section 15.4.5.1, steps 4.e.i - 4.e.ii */ + + DUK_DDD(DUK_DDDPRINT("defineProperty successful, pending array length update to: %ld", + (long) arridx_new_array_length)); + + /* Note: reuse 'curr' */ + rc = duk__get_own_property_desc_raw(thr, obj, DUK_HTHREAD_STRING_LENGTH(thr), DUK__NO_ARRAY_INDEX, &curr, 0 /*flags*/); /* don't push value */ + DUK_UNREF(rc); + DUK_ASSERT(rc != 0); + DUK_ASSERT(curr.e_idx >= 0); + + tmp = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tmp)); + /* no need for decref/incref because value is a number */ +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_FASTINT_U32(tmp, arridx_new_array_length); +#else + DUK_TVAL_SET_NUMBER(tmp, (duk_double_t) arridx_new_array_length); +#endif + } + if (key == DUK_HTHREAD_STRING_LENGTH(thr) && arrlen_new_len < arrlen_old_len) { + /* + * E5 Section 15.4.5.1, steps 3.k - 3.n. The order at the end combines + * the error case 3.l.iii and the success case 3.m-3.n. + * + * Note: 'length' is always in entries part, so no array abandon issues for + * 'writable' update. + */ + + /* XXX: investigate whether write protect can be handled above, if we + * just update length here while ignoring its protected status + */ + + duk_tval *tmp; + duk_uint32_t result_len; + duk_bool_t rc; + + DUK_DDD(DUK_DDDPRINT("defineProperty successful, key is 'length', exotic array behavior, " + "doing array element deletion and length update")); + + rc = duk__handle_put_array_length_smaller(thr, obj, arrlen_old_len, arrlen_new_len, force_flag, &result_len); + + /* update length (curr points to length, and we assume it's still valid) */ + DUK_ASSERT(result_len >= arrlen_new_len && result_len <= arrlen_old_len); + + DUK_ASSERT(curr.e_idx >= 0); + DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx)); + tmp = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tmp)); + /* no decref needed for a number */ +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_FASTINT_U32(tmp, result_len); +#else + DUK_TVAL_SET_NUMBER(tmp, (duk_double_t) result_len); +#endif + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tmp)); + + if (pending_write_protect) { + DUK_DDD(DUK_DDDPRINT("setting array length non-writable (pending writability update)")); + DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx); + } + + /* + * XXX: shrink array allocation or entries compaction here? + */ + + if (!rc) { + goto fail_array_length_partial; + } + } + } else if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)) { + duk_hobject *map; + duk_hobject *varenv; + + DUK_ASSERT(arridx_new_array_length == 0); + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj)); /* traits are separate; in particular, arguments not an array */ + + map = NULL; + varenv = NULL; + if (!duk__lookup_arguments_map(thr, obj, key, &curr, &map, &varenv)) { + goto success_no_exotics; + } + DUK_ASSERT(map != NULL); + DUK_ASSERT(varenv != NULL); + + /* [obj key desc value get set curr_value varname] */ + + if (has_set || has_get) { + /* = IsAccessorDescriptor(Desc) */ + DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map' " + "changed to an accessor, delete arguments binding")); + + (void) duk_hobject_delprop_raw(thr, map, key, 0); /* ignore result */ + } else { + /* Note: this order matters (final value before deleting map entry must be done) */ + DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', " + "check for value update / binding deletion")); + + if (has_value) { + duk_hstring *varname; + + DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', " + "update bound value (variable/argument)")); + + varname = duk_require_hstring(ctx, -1); + DUK_ASSERT(varname != NULL); + + DUK_DDD(DUK_DDDPRINT("arguments object automatic putvar for a bound variable; " + "key=%!O, varname=%!O, value=%!T", + (duk_heaphdr *) key, + (duk_heaphdr *) varname, + (duk_tval *) duk_require_tval(ctx, idx_value))); + + /* strict flag for putvar comes from our caller (currently: fixed) */ + duk_js_putvar_envrec(thr, varenv, varname, duk_require_tval(ctx, idx_value), throw_flag); + } + if (has_writable && !is_writable) { + DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', " + "changed to non-writable, delete arguments binding")); + + (void) duk_hobject_delprop_raw(thr, map, key, 0); /* ignore result */ + } + } + + /* 'varname' is in stack in this else branch, leaving an unbalanced stack below, + * but this doesn't matter now. + */ + } + + success_no_exotics: + return; + + fail_virtual: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROPERTY_IS_VIRTUAL); + return; + + fail_not_writable_array_length: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_ARRAY_LENGTH_NOT_WRITABLE); + return; + + fail_not_extensible: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_EXTENSIBLE); + return; + + fail_not_configurable: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CONFIGURABLE); + return; + + fail_array_length_partial: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_ARRAY_LENGTH_WRITE_FAILED); + return; +} + +/* + * Object.prototype.hasOwnProperty() and Object.prototype.propertyIsEnumerable(). + */ + +DUK_INTERNAL duk_bool_t duk_hobject_object_ownprop_helper(duk_context *ctx, duk_small_uint_t required_desc_flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h_v; + duk_hobject *h_obj; + duk_propdesc desc; + duk_bool_t ret; + + /* coercion order matters */ + h_v = duk_to_hstring(ctx, 0); + DUK_ASSERT(h_v != NULL); + + h_obj = duk_push_this_coercible_to_object(ctx); + DUK_ASSERT(h_obj != NULL); + + ret = duk__get_own_property_desc(thr, h_obj, h_v, &desc, 0 /*flags*/); /* don't push value */ + + duk_push_boolean(ctx, ret && ((desc.flags & required_desc_flags) == required_desc_flags)); + return 1; +} + +/* + * Object.seal() and Object.freeze() (E5 Sections 15.2.3.8 and 15.2.3.9) + * + * Since the algorithms are similar, a helper provides both functions. + * Freezing is essentially sealing + making plain properties non-writable. + * + * Note: virtual (non-concrete) properties which are non-configurable but + * writable would pose some problems, but such properties do not currently + * exist (all virtual properties are non-configurable and non-writable). + * If they did exist, the non-configurability does NOT prevent them from + * becoming non-writable. However, this change should be recorded somehow + * so that it would turn up (e.g. when getting the property descriptor), + * requiring some additional flags in the object. + */ + +DUK_INTERNAL void duk_hobject_object_seal_freeze_helper(duk_hthread *thr, duk_hobject *obj, duk_bool_t is_freeze) { + duk_uint_fast32_t i; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(obj != NULL); + + DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE); + + /* + * Abandon array part because all properties must become non-configurable. + * Note that this is now done regardless of whether this is always the case + * (skips check, but performance problem if caller would do this many times + * for the same object; not likely). + */ + + duk__abandon_array_checked(thr, obj); + DUK_ASSERT(DUK_HOBJECT_GET_ASIZE(obj) == 0); + + for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) { + duk_uint8_t *fp; + + /* since duk__abandon_array_checked() causes a resize, there should be no gaps in keys */ + DUK_ASSERT(DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i) != NULL); + + /* avoid multiple computations of flags address; bypasses macros */ + fp = DUK_HOBJECT_E_GET_FLAGS_PTR(thr->heap, obj, i); + if (is_freeze && !((*fp) & DUK_PROPDESC_FLAG_ACCESSOR)) { + *fp &= ~(DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_CONFIGURABLE); + } else { + *fp &= ~DUK_PROPDESC_FLAG_CONFIGURABLE; + } + } + + DUK_HOBJECT_CLEAR_EXTENSIBLE(obj); + + /* no need to compact since we already did that in duk__abandon_array_checked() + * (regardless of whether an array part existed or not. + */ + + return; +} + +/* + * Object.isSealed() and Object.isFrozen() (E5 Sections 15.2.3.11, 15.2.3.13) + * + * Since the algorithms are similar, a helper provides both functions. + * Freezing is essentially sealing + making plain properties non-writable. + * + * Note: all virtual (non-concrete) properties are currently non-configurable + * and non-writable (and there are no accessor virtual properties), so they don't + * need to be considered here now. + */ + +DUK_INTERNAL duk_bool_t duk_hobject_object_is_sealed_frozen_helper(duk_hthread *thr, duk_hobject *obj, duk_bool_t is_frozen) { + duk_uint_fast32_t i; + + DUK_ASSERT(obj != NULL); + DUK_UNREF(thr); + + /* Note: no allocation pressure, no need to check refcounts etc */ + + /* must not be extensible */ + if (DUK_HOBJECT_HAS_EXTENSIBLE(obj)) { + return 0; + } + + /* all virtual properties are non-configurable and non-writable */ + + /* entry part must not contain any configurable properties, or + * writable properties (if is_frozen). + */ + for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) { + duk_small_uint_t flags; + + if (!DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i)) { + continue; + } + + /* avoid multiple computations of flags address; bypasses macros */ + flags = (duk_small_uint_t) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, i); + + if (flags & DUK_PROPDESC_FLAG_CONFIGURABLE) { + return 0; + } + if (is_frozen && + !(flags & DUK_PROPDESC_FLAG_ACCESSOR) && + (flags & DUK_PROPDESC_FLAG_WRITABLE)) { + return 0; + } + } + + /* array part must not contain any non-unused properties, as they would + * be configurable and writable. + */ + for (i = 0; i < DUK_HOBJECT_GET_ASIZE(obj); i++) { + duk_tval *tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i); + if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + return 0; + } + } + + return 1; +} + +/* + * Object.preventExtensions() and Object.isExtensible() (E5 Sections 15.2.3.10, 15.2.3.13) + * + * Not needed, implemented by macros DUK_HOBJECT_{HAS,CLEAR,SET}_EXTENSIBLE + * and the Object built-in bindings. + */ + +/* Undefine local defines */ + +#undef DUK__NO_ARRAY_INDEX +#undef DUK__HASH_INITIAL +#undef DUK__HASH_PROBE_STEP +#undef DUK__HASH_UNUSED +#undef DUK__HASH_DELETED +#undef DUK__VALSTACK_SPACE +#line 1 "duk_hstring_misc.c" +/* + * Misc support functions + */ + +/* include removed: duk_internal.h */ + +DUK_INTERNAL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr, duk_hstring *h, duk_uint_t pos) { + duk_uint32_t boff; + const duk_uint8_t *p, *p_start, *p_end; + duk_ucodepoint_t cp; + + /* Caller must check character offset to be inside the string. */ + DUK_ASSERT(thr != NULL); + DUK_ASSERT(h != NULL); + DUK_ASSERT_DISABLE(pos >= 0); /* unsigned */ + DUK_ASSERT(pos < (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h)); + + boff = duk_heap_strcache_offset_char2byte(thr, h, (duk_uint32_t) pos); + DUK_DDD(DUK_DDDPRINT("charCodeAt: pos=%ld -> boff=%ld, str=%!O", + (long) pos, (long) boff, (duk_heaphdr *) h)); + DUK_ASSERT_DISABLE(boff >= 0); + DUK_ASSERT(boff < DUK_HSTRING_GET_BYTELEN(h)); + + p_start = DUK_HSTRING_GET_DATA(h); + p_end = p_start + DUK_HSTRING_GET_BYTELEN(h); + p = p_start + boff; + DUK_DDD(DUK_DDDPRINT("p_start=%p, p_end=%p, p=%p", + (void *) p_start, (void *) p_end, (void *) p)); + + /* This may throw an error though not for valid E5 strings. */ + cp = duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end); + return cp; +} +#line 1 "duk_hthread_alloc.c" +/* + * duk_hthread allocation and freeing. + */ + +/* include removed: duk_internal.h */ + +/* + * Allocate initial stacks for a thread. Note that 'thr' must be reachable + * as a garbage collection may be triggered by the allocation attempts. + * Returns zero (without leaking memory) if init fails. + */ + +DUK_INTERNAL duk_bool_t duk_hthread_init_stacks(duk_heap *heap, duk_hthread *thr) { + duk_size_t alloc_size; + duk_size_t i; + + DUK_ASSERT(heap != NULL); + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->valstack == NULL); + DUK_ASSERT(thr->valstack_end == NULL); + DUK_ASSERT(thr->valstack_bottom == NULL); + DUK_ASSERT(thr->valstack_top == NULL); + DUK_ASSERT(thr->callstack == NULL); + DUK_ASSERT(thr->catchstack == NULL); + + /* valstack */ + alloc_size = sizeof(duk_tval) * DUK_VALSTACK_INITIAL_SIZE; + thr->valstack = (duk_tval *) DUK_ALLOC(heap, alloc_size); + if (!thr->valstack) { + goto fail; + } + DUK_MEMZERO(thr->valstack, alloc_size); + thr->valstack_end = thr->valstack + DUK_VALSTACK_INITIAL_SIZE; + thr->valstack_bottom = thr->valstack; + thr->valstack_top = thr->valstack; + + for (i = 0; i < DUK_VALSTACK_INITIAL_SIZE; i++) { + DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->valstack[i]); + } + + /* callstack */ + alloc_size = sizeof(duk_activation) * DUK_CALLSTACK_INITIAL_SIZE; + thr->callstack = (duk_activation *) DUK_ALLOC(heap, alloc_size); + if (!thr->callstack) { + goto fail; + } + DUK_MEMZERO(thr->callstack, alloc_size); + thr->callstack_size = DUK_CALLSTACK_INITIAL_SIZE; + DUK_ASSERT(thr->callstack_top == 0); + + /* catchstack */ + alloc_size = sizeof(duk_catcher) * DUK_CATCHSTACK_INITIAL_SIZE; + thr->catchstack = (duk_catcher *) DUK_ALLOC(heap, alloc_size); + if (!thr->catchstack) { + goto fail; + } + DUK_MEMZERO(thr->catchstack, alloc_size); + thr->catchstack_size = DUK_CATCHSTACK_INITIAL_SIZE; + DUK_ASSERT(thr->catchstack_top == 0); + + return 1; + + fail: + DUK_FREE(heap, thr->valstack); + DUK_FREE(heap, thr->callstack); + DUK_FREE(heap, thr->catchstack); + + thr->valstack = NULL; + thr->callstack = NULL; + thr->catchstack = NULL; + return 0; +} + +/* For indirect allocs. */ + +DUK_INTERNAL void *duk_hthread_get_valstack_ptr(duk_heap *heap, void *ud) { + duk_hthread *thr = (duk_hthread *) ud; + DUK_UNREF(heap); + return (void *) thr->valstack; +} + +DUK_INTERNAL void *duk_hthread_get_callstack_ptr(duk_heap *heap, void *ud) { + duk_hthread *thr = (duk_hthread *) ud; + DUK_UNREF(heap); + return (void *) thr->callstack; +} + +DUK_INTERNAL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud) { + duk_hthread *thr = (duk_hthread *) ud; + DUK_UNREF(heap); + return (void *) thr->catchstack; +} +#line 1 "duk_hthread_builtins.c" +/* + * Initialize built-in objects. Current thread must have a valstack + * and initialization errors may longjmp, so a setjmp() catch point + * must exist. + */ + +/* include removed: duk_internal.h */ + +/* + * Encoding constants, must match genbuiltins.py + */ + +#define DUK__CLASS_BITS 5 +#define DUK__BIDX_BITS 7 +#define DUK__STRIDX_BITS 9 /* XXX: try to optimize to 8 */ +#define DUK__NATIDX_BITS 8 +#define DUK__NUM_NORMAL_PROPS_BITS 6 +#define DUK__NUM_FUNC_PROPS_BITS 6 +#define DUK__PROP_FLAGS_BITS 3 +#define DUK__STRING_LENGTH_BITS 8 +#define DUK__STRING_CHAR_BITS 7 +#define DUK__LENGTH_PROP_BITS 3 +#define DUK__NARGS_BITS 3 +#define DUK__PROP_TYPE_BITS 3 +#define DUK__MAGIC_BITS 16 + +#define DUK__NARGS_VARARGS_MARKER 0x07 +#define DUK__NO_CLASS_MARKER 0x00 /* 0 = DUK_HOBJECT_CLASS_UNUSED */ +#define DUK__NO_BIDX_MARKER 0x7f +#define DUK__NO_STRIDX_MARKER 0xff + +#define DUK__PROP_TYPE_DOUBLE 0 +#define DUK__PROP_TYPE_STRING 1 +#define DUK__PROP_TYPE_STRIDX 2 +#define DUK__PROP_TYPE_BUILTIN 3 +#define DUK__PROP_TYPE_UNDEFINED 4 +#define DUK__PROP_TYPE_BOOLEAN_TRUE 5 +#define DUK__PROP_TYPE_BOOLEAN_FALSE 6 +#define DUK__PROP_TYPE_ACCESSOR 7 + +/* + * Create built-in objects by parsing an init bitstream generated + * by genbuiltins.py. + */ + +DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) { + duk_context *ctx = (duk_context *) thr; + duk_bitdecoder_ctx bd_ctx; + duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */ + duk_hobject *h; + duk_small_uint_t i, j; + + DUK_D(DUK_DPRINT("INITBUILTINS BEGIN")); + + DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx)); + bd->data = (const duk_uint8_t *) duk_builtins_data; + bd->length = (duk_size_t) DUK_BUILTINS_DATA_LENGTH; + + /* + * First create all built-in bare objects on the empty valstack. + * During init, their indices will correspond to built-in indices. + * + * Built-ins will be reachable from both valstack and thr->builtins. + */ + + /* XXX: there is no need to resize valstack because builtin count + * is much less than the default space; assert for it. + */ + + DUK_DD(DUK_DDPRINT("create empty built-ins")); + DUK_ASSERT_TOP(ctx, 0); + for (i = 0; i < DUK_NUM_BUILTINS; i++) { + duk_small_uint_t class_num; + duk_small_int_t len = -1; /* must be signed */ + + class_num = (duk_small_uint_t) duk_bd_decode(bd, DUK__CLASS_BITS); + len = (duk_small_int_t) duk_bd_decode_flagged(bd, DUK__LENGTH_PROP_BITS, (duk_int32_t) -1 /*def_value*/); + + if (class_num == DUK_HOBJECT_CLASS_FUNCTION) { + duk_small_uint_t natidx; + duk_small_uint_t stridx; + duk_int_t c_nargs; /* must hold DUK_VARARGS */ + duk_c_function c_func; + duk_int16_t magic; + + DUK_DDD(DUK_DDDPRINT("len=%ld", (long) len)); + DUK_ASSERT(len >= 0); + + natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS); + stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS); + c_func = duk_bi_native_functions[natidx]; + + c_nargs = (duk_small_uint_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, len /*def_value*/); + if (c_nargs == DUK__NARGS_VARARGS_MARKER) { + c_nargs = DUK_VARARGS; + } + + /* XXX: set magic directly here? (it could share the c_nargs arg) */ + duk_push_c_function_noexotic(ctx, c_func, c_nargs); + + h = duk_require_hobject(ctx, -1); + DUK_ASSERT(h != NULL); + + /* Currently all built-in native functions are strict. + * duk_push_c_function() now sets strict flag, so + * assert for it. + */ + DUK_ASSERT(DUK_HOBJECT_HAS_STRICT(h)); + + /* XXX: function properties */ + + duk_push_hstring_stridx(ctx, stridx); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE); + + /* Almost all global level Function objects are constructable + * but not all: Function.prototype is a non-constructable, + * callable Function. + */ + if (duk_bd_decode_flag(bd)) { + DUK_ASSERT(DUK_HOBJECT_HAS_CONSTRUCTABLE(h)); + } else { + DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h); + } + + /* Cast converts magic to 16-bit signed value */ + magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0 /*def_value*/); + ((duk_hnativefunction *) h)->magic = magic; + } else { + /* XXX: ARRAY_PART for Array prototype? */ + + duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE, + -1); /* no prototype or class yet */ + + h = duk_require_hobject(ctx, -1); + DUK_ASSERT(h != NULL); + } + + DUK_HOBJECT_SET_CLASS_NUMBER(h, class_num); + + thr->builtins[i] = h; + DUK_HOBJECT_INCREF(thr, &h->hdr); + + if (len >= 0) { + /* + * For top-level objects, 'length' property has the following + * default attributes: non-writable, non-enumerable, non-configurable + * (E5 Section 15). + * + * However, 'length' property for Array.prototype has attributes + * expected of an Array instance which are different: writable, + * non-enumerable, non-configurable (E5 Section 15.4.5.2). + * + * This is currently determined implicitly based on class; there are + * no attribute flags in the init data. + */ + + duk_push_int(ctx, len); + duk_xdef_prop_stridx(ctx, + -2, + DUK_STRIDX_LENGTH, + (class_num == DUK_HOBJECT_CLASS_ARRAY ? /* only Array.prototype matches */ + DUK_PROPDESC_FLAGS_W : DUK_PROPDESC_FLAGS_NONE)); + } + + /* enable exotic behaviors last */ + + if (class_num == DUK_HOBJECT_CLASS_ARRAY) { + DUK_HOBJECT_SET_EXOTIC_ARRAY(h); + } + if (class_num == DUK_HOBJECT_CLASS_STRING) { + DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h); + } + + /* some assertions */ + + DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h)); + /* DUK_HOBJECT_FLAG_CONSTRUCTABLE varies */ + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(h)); + DUK_ASSERT(!DUK_HOBJECT_HAS_COMPILEDFUNCTION(h)); + /* DUK_HOBJECT_FLAG_NATIVEFUNCTION varies */ + DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(h)); + DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(h)); /* currently, even for Array.prototype */ + /* DUK_HOBJECT_FLAG_STRICT varies */ + DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(h) || /* all native functions have NEWENV */ + DUK_HOBJECT_HAS_NEWENV(h)); + DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(h)); + DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(h)); + DUK_ASSERT(!DUK_HOBJECT_HAS_ENVRECCLOSED(h)); + /* DUK_HOBJECT_FLAG_EXOTIC_ARRAY varies */ + /* DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ varies */ + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h)); + + DUK_DDD(DUK_DDDPRINT("created built-in %ld, class=%ld, length=%ld", (long) i, (long) class_num, (long) len)); + } + + /* + * Then decode the builtins init data (see genbuiltins.py) to + * init objects + */ + + DUK_DD(DUK_DDPRINT("initialize built-in object properties")); + for (i = 0; i < DUK_NUM_BUILTINS; i++) { + duk_small_uint_t t; + duk_small_uint_t num; + + DUK_DDD(DUK_DDDPRINT("initializing built-in object at index %ld", (long) i)); + h = thr->builtins[i]; + + t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS); + if (t != DUK__NO_BIDX_MARKER) { + DUK_DDD(DUK_DDDPRINT("set internal prototype: built-in %ld", (long) t)); + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[t]); + } + + t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS); + if (t != DUK__NO_BIDX_MARKER) { + /* 'prototype' property for all built-in objects (which have it) has attributes: + * [[Writable]] = false, + * [[Enumerable]] = false, + * [[Configurable]] = false + */ + DUK_DDD(DUK_DDDPRINT("set external prototype: built-in %ld", (long) t)); + duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_PROTOTYPE, t, DUK_PROPDESC_FLAGS_NONE); + } + + t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS); + if (t != DUK__NO_BIDX_MARKER) { + /* 'constructor' property for all built-in objects (which have it) has attributes: + * [[Writable]] = true, + * [[Enumerable]] = false, + * [[Configurable]] = true + */ + DUK_DDD(DUK_DDDPRINT("set external constructor: built-in %ld", (long) t)); + duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_CONSTRUCTOR, t, DUK_PROPDESC_FLAGS_WC); + } + + /* normal valued properties */ + num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_NORMAL_PROPS_BITS); + DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld normal valued properties", (long) i, (long) num)); + for (j = 0; j < num; j++) { + duk_small_uint_t stridx; + duk_small_uint_t prop_flags; + + stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS); + + /* + * Property attribute defaults are defined in E5 Section 15 (first + * few pages); there is a default for all properties and a special + * default for 'length' properties. Variation from the defaults is + * signaled using a single flag bit in the bitstream. + */ + + if (duk_bd_decode_flag(bd)) { + prop_flags = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_FLAGS_BITS); + } else { + if (stridx == DUK_STRIDX_LENGTH) { + prop_flags = DUK_PROPDESC_FLAGS_NONE; + } else { + prop_flags = DUK_PROPDESC_FLAGS_WC; + } + } + + t = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_TYPE_BITS); + + DUK_DDD(DUK_DDDPRINT("built-in %ld, normal-valued property %ld, stridx %ld, flags 0x%02lx, type %ld", + (long) i, (long) j, (long) stridx, (unsigned long) prop_flags, (long) t)); + + switch (t) { + case DUK__PROP_TYPE_DOUBLE: { + duk_double_union du; + duk_small_uint_t k; + + for (k = 0; k < 8; k++) { + /* Encoding endianness must match target memory layout, + * build scripts and genbuiltins.py must ensure this. + */ + du.uc[k] = (duk_uint8_t) duk_bd_decode(bd, 8); + } + + duk_push_number(ctx, du.d); /* push operation normalizes NaNs */ + break; + } + case DUK__PROP_TYPE_STRING: { + duk_small_uint_t n; + duk_small_uint_t k; + duk_uint8_t *p; + + n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRING_LENGTH_BITS); + p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, n); + for (k = 0; k < n; k++) { + *p++ = (duk_uint8_t) duk_bd_decode(bd, DUK__STRING_CHAR_BITS); + } + + duk_to_string(ctx, -1); + break; + } + case DUK__PROP_TYPE_STRIDX: { + duk_small_uint_t n; + + n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS); + DUK_ASSERT_DISABLE(n >= 0); /* unsigned */ + DUK_ASSERT(n < DUK_HEAP_NUM_STRINGS); + duk_push_hstring_stridx(ctx, n); + break; + } + case DUK__PROP_TYPE_BUILTIN: { + duk_small_uint_t bidx; + + bidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS); + DUK_ASSERT(bidx != DUK__NO_BIDX_MARKER); + duk_dup(ctx, (duk_idx_t) bidx); + break; + } + case DUK__PROP_TYPE_UNDEFINED: { + duk_push_undefined(ctx); + break; + } + case DUK__PROP_TYPE_BOOLEAN_TRUE: { + duk_push_true(ctx); + break; + } + case DUK__PROP_TYPE_BOOLEAN_FALSE: { + duk_push_false(ctx); + break; + } + case DUK__PROP_TYPE_ACCESSOR: { + duk_small_uint_t natidx_getter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS); + duk_small_uint_t natidx_setter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS); + duk_c_function c_func_getter; + duk_c_function c_func_setter; + + /* XXX: this is a bit awkward because there is no exposed helper + * in the API style, only this internal helper. + */ + DUK_DDD(DUK_DDDPRINT("built-in accessor property: objidx=%ld, stridx=%ld, getteridx=%ld, setteridx=%ld, flags=0x%04lx", + (long) i, (long) stridx, (long) natidx_getter, (long) natidx_setter, (unsigned long) prop_flags)); + + c_func_getter = duk_bi_native_functions[natidx_getter]; + c_func_setter = duk_bi_native_functions[natidx_setter]; + duk_push_c_function_noconstruct_noexotic(ctx, c_func_getter, 0); /* always 0 args */ + duk_push_c_function_noconstruct_noexotic(ctx, c_func_setter, 1); /* always 1 arg */ + + /* XXX: magic for getter/setter? */ + + prop_flags |= DUK_PROPDESC_FLAG_ACCESSOR; /* accessor flag not encoded explicitly */ + duk_hobject_define_accessor_internal(thr, + duk_require_hobject(ctx, i), + DUK_HTHREAD_GET_STRING(thr, stridx), + duk_require_hobject(ctx, -2), + duk_require_hobject(ctx, -1), + prop_flags); + duk_pop_2(ctx); /* getter and setter, now reachable through object */ + goto skip_value; + } + default: { + /* exhaustive */ + DUK_UNREACHABLE(); + } + } + + DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0); + duk_xdef_prop_stridx(ctx, i, stridx, prop_flags); + + skip_value: + continue; /* avoid empty label at the end of a compound statement */ + } + + /* native function properties */ + num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_FUNC_PROPS_BITS); + DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld function valued properties", (long) i, (long) num)); + for (j = 0; j < num; j++) { + duk_small_uint_t stridx; + duk_small_uint_t natidx; + duk_int_t c_nargs; /* must hold DUK_VARARGS */ + duk_small_uint_t c_length; + duk_int16_t magic; + duk_c_function c_func; + duk_hnativefunction *h_func; +#if defined(DUK_USE_LIGHTFUNC_BUILTINS) + duk_small_int_t lightfunc_eligible; +#endif + + stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS); + natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS); + + c_length = (duk_small_uint_t) duk_bd_decode(bd, DUK__LENGTH_PROP_BITS); + c_nargs = (duk_int_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, (duk_int32_t) c_length /*def_value*/); + if (c_nargs == DUK__NARGS_VARARGS_MARKER) { + c_nargs = DUK_VARARGS; + } + + c_func = duk_bi_native_functions[natidx]; + + DUK_DDD(DUK_DDDPRINT("built-in %ld, function-valued property %ld, stridx %ld, natidx %ld, length %ld, nargs %ld", + (long) i, (long) j, (long) stridx, (long) natidx, (long) c_length, + (c_nargs == DUK_VARARGS ? (long) -1 : (long) c_nargs))); + + /* Cast converts magic to 16-bit signed value */ + magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0); + +#if defined(DUK_USE_LIGHTFUNC_BUILTINS) + lightfunc_eligible = + ((c_nargs >= DUK_LFUNC_NARGS_MIN && c_nargs <= DUK_LFUNC_NARGS_MAX) || (c_nargs == DUK_VARARGS)) && + (c_length <= DUK_LFUNC_LENGTH_MAX) && + (magic >= DUK_LFUNC_MAGIC_MIN && magic <= DUK_LFUNC_MAGIC_MAX); + if (stridx == DUK_STRIDX_EVAL || + stridx == DUK_STRIDX_YIELD || + stridx == DUK_STRIDX_RESUME || + stridx == DUK_STRIDX_REQUIRE) { + /* These functions have trouble working as lightfuncs. + * Some of them have specific asserts and some may have + * additional properties (e.g. 'require.id' may be written). + */ + DUK_D(DUK_DPRINT("reject as lightfunc: stridx=%d, i=%d, j=%d", (int) stridx, (int) i, (int) j)); + lightfunc_eligible = 0; + } + + if (lightfunc_eligible) { + duk_tval tv_lfunc; + duk_small_uint_t lf_nargs = (c_nargs == DUK_VARARGS ? DUK_LFUNC_NARGS_VARARGS : c_nargs); + duk_small_uint_t lf_flags = DUK_LFUNC_FLAGS_PACK(magic, c_length, lf_nargs); + DUK_TVAL_SET_LIGHTFUNC(&tv_lfunc, c_func, lf_flags); + duk_push_tval(ctx, &tv_lfunc); + DUK_D(DUK_DPRINT("built-in function eligible as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld -> %!iT", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic, duk_get_tval(ctx, -1))); + goto lightfunc_skip; + } + + DUK_D(DUK_DPRINT("built-in function NOT ELIGIBLE as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic)); +#endif /* DUK_USE_LIGHTFUNC_BUILTINS */ + + /* [ (builtin objects) ] */ + + duk_push_c_function_noconstruct_noexotic(ctx, c_func, c_nargs); + h_func = duk_require_hnativefunction(ctx, -1); + DUK_UNREF(h_func); + + /* Currently all built-in native functions are strict. + * This doesn't matter for many functions, but e.g. + * String.prototype.charAt (and other string functions) + * rely on being strict so that their 'this' binding is + * not automatically coerced. + */ + DUK_HOBJECT_SET_STRICT((duk_hobject *) h_func); + + /* No built-in functions are constructable except the top + * level ones (Number, etc). + */ + DUK_ASSERT(!DUK_HOBJECT_HAS_CONSTRUCTABLE((duk_hobject *) h_func)); + + /* XXX: any way to avoid decoding magic bit; there are quite + * many function properties and relatively few with magic values. + */ + h_func->magic = magic; + + /* [ (builtin objects) func ] */ + + duk_push_int(ctx, c_length); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE); + + duk_push_hstring_stridx(ctx, stridx); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE); + + /* XXX: other properties of function instances; 'arguments', 'caller'. */ + + DUK_DD(DUK_DDPRINT("built-in object %ld, function property %ld -> %!T", + (long) i, (long) j, (duk_tval *) duk_get_tval(ctx, -1))); + + /* [ (builtin objects) func ] */ + + /* + * The default property attributes are correct for all + * function valued properties of built-in objects now. + */ + +#if defined(DUK_USE_LIGHTFUNC_BUILTINS) + lightfunc_skip: +#endif + + duk_xdef_prop_stridx(ctx, i, stridx, DUK_PROPDESC_FLAGS_WC); + + /* [ (builtin objects) ] */ + } + } + + /* + * Special post-tweaks, for cases not covered by the init data format. + * + * - Set Date.prototype.toGMTString to Date.prototype.toUTCString. + * toGMTString is required to have the same Function object as + * toUTCString in E5 Section B.2.6. Note that while Smjs respects + * this, V8 does not (the Function objects are distinct). + * + * - Make DoubleError non-extensible. + * + * - Add info about most important effective compile options to Duktape. + * + * - Possibly remove some properties (values or methods) which are not + * desirable with current feature options but are not currently + * conditional in init data. + */ + + duk_get_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_UTC_STRING); + duk_xdef_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_GMT_STRING, DUK_PROPDESC_FLAGS_WC); + + h = duk_require_hobject(ctx, DUK_BIDX_DOUBLE_ERROR); + DUK_ASSERT(h != NULL); + DUK_HOBJECT_CLEAR_EXTENSIBLE(h); + +#if !defined(DUK_USE_ES6_OBJECT_PROTO_PROPERTY) + DUK_DD(DUK_DDPRINT("delete Object.prototype.__proto__ built-in which is not enabled in features")); + (void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_PROTOTYPE], DUK_HTHREAD_STRING___PROTO__(thr), DUK_DELPROP_FLAG_THROW); +#endif + +#if !defined(DUK_USE_ES6_OBJECT_SETPROTOTYPEOF) + DUK_DD(DUK_DDPRINT("delete Object.setPrototypeOf built-in which is not enabled in features")); + (void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_CONSTRUCTOR], DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr), DUK_DELPROP_FLAG_THROW); +#endif + + duk_push_string(ctx, + /* Endianness indicator */ +#if defined(DUK_USE_INTEGER_LE) + "l" +#elif defined(DUK_USE_INTEGER_BE) + "b" +#elif defined(DUK_USE_INTEGER_ME) /* integer mixed endian not really used now */ + "m" +#else + "?" +#endif +#if defined(DUK_USE_DOUBLE_LE) + "l" +#elif defined(DUK_USE_DOUBLE_BE) + "b" +#elif defined(DUK_USE_DOUBLE_ME) + "m" +#else + "?" +#endif +#if defined(DUK_USE_BYTEORDER_FORCED) + "f" +#endif + " " + /* Packed or unpacked tval */ +#if defined(DUK_USE_PACKED_TVAL) + "p" +#else + "u" +#endif +#if defined(DUK_USE_FASTINT) + "f" +#endif + " " + /* Low memory options */ +#if defined(DUK_USE_STRTAB_CHAIN) + "c" /* chain */ +#elif defined(DUK_USE_STRTAB_PROBE) + "p" /* probe */ +#else + "?" +#endif +#if !defined(DUK_USE_HEAPPTR16) && !defined(DUK_DATAPTR16) && !defined(DUK_FUNCPTR16) + "n" +#endif +#if defined(DUK_USE_HEAPPTR16) + "h" +#endif +#if defined(DUK_USE_DATAPTR16) + "d" +#endif +#if defined(DUK_USE_FUNCPTR16) + "f" +#endif +#if defined(DUK_USE_REFCOUNT16) + "R" +#endif +#if defined(DUK_USE_STRHASH16) + "H" +#endif +#if defined(DUK_USE_STRLEN16) + "S" +#endif +#if defined(DUK_USE_BUFLEN16) + "B" +#endif +#if defined(DUK_USE_OBJSIZES16) + "O" +#endif +#if defined(DUK_USE_LIGHTFUNC_BUILTINS) + "L" +#endif + " " + /* Object property allocation layout */ +#if defined(DUK_USE_HOBJECT_LAYOUT_1) + "p1" +#elif defined(DUK_USE_HOBJECT_LAYOUT_2) + "p2" +#elif defined(DUK_USE_HOBJECT_LAYOUT_3) + "p3" +#else + "p?" +#endif + " " + /* Alignment guarantee */ +#if (DUK_USE_ALIGN_BY == 4) + "a4" +#elif (DUK_USE_ALIGN_BY == 8) + "a8" +#elif (DUK_USE_ALIGN_BY == 1) + "a1" +#else +#error invalid DUK_USE_ALIGN_BY +#endif + " " + /* Architecture, OS, and compiler strings */ + DUK_USE_ARCH_STRING + " " + DUK_USE_OS_STRING + " " + DUK_USE_COMPILER_STRING); + duk_xdef_prop_stridx(ctx, DUK_BIDX_DUKTAPE, DUK_STRIDX_ENV, DUK_PROPDESC_FLAGS_WC); + + /* + * InitJS code - Ecmascript code evaluated from a built-in source + * which provides e.g. backward compatibility. User can also provide + * JS code to be evaluated at startup. + */ + +#ifdef DUK_USE_BUILTIN_INITJS + /* XXX: compression */ + DUK_DD(DUK_DDPRINT("running built-in initjs")); + duk_eval_string(ctx, (const char *) duk_initjs_data); /* initjs data is NUL terminated */ + duk_pop(ctx); +#endif /* DUK_USE_BUILTIN_INITJS */ + +#ifdef DUK_USE_USER_INITJS + /* XXX: compression (as an option) */ + DUK_DD(DUK_DDPRINT("running user initjs")); + duk_eval_string_noresult(ctx, (const char *) DUK_USE_USER_INITJS); +#endif /* DUK_USE_USER_INITJS */ + + /* + * Since built-ins are not often extended, compact them. + */ + + DUK_DD(DUK_DDPRINT("compact built-ins")); + for (i = 0; i < DUK_NUM_BUILTINS; i++) { + duk_hobject_compact_props(thr, thr->builtins[i]); + } + + DUK_D(DUK_DPRINT("INITBUILTINS END")); + +#ifdef DUK_USE_DDPRINT + for (i = 0; i < DUK_NUM_BUILTINS; i++) { + DUK_DD(DUK_DDPRINT("built-in object %ld after initialization and compacting: %!@iO", + (long) i, (duk_heaphdr *) thr->builtins[i])); + } +#endif + + /* + * Pop built-ins from stack: they are now INCREF'd and + * reachable from the builtins[] array. + */ + + duk_pop_n(ctx, DUK_NUM_BUILTINS); + DUK_ASSERT_TOP(ctx, 0); +} + +DUK_INTERNAL void duk_hthread_copy_builtin_objects(duk_hthread *thr_from, duk_hthread *thr_to) { + duk_small_uint_t i; + + for (i = 0; i < DUK_NUM_BUILTINS; i++) { + thr_to->builtins[i] = thr_from->builtins[i]; + DUK_HOBJECT_INCREF_ALLOWNULL(thr_to, thr_to->builtins[i]); /* side effect free */ + } +} +#line 1 "duk_hthread_misc.c" +/* + * Thread support. + */ + +/* include removed: duk_internal.h */ + +DUK_INTERNAL void duk_hthread_terminate(duk_hthread *thr) { + DUK_ASSERT(thr != NULL); + + /* Order of unwinding is important */ + + duk_hthread_catchstack_unwind(thr, 0); + + duk_hthread_callstack_unwind(thr, 0); /* side effects, possibly errors */ + + thr->valstack_bottom = thr->valstack; + duk_set_top((duk_context *) thr, 0); /* unwinds valstack, updating refcounts */ + + thr->state = DUK_HTHREAD_STATE_TERMINATED; + + /* Here we could remove references to built-ins, but it may not be + * worth the effort because built-ins are quite likely to be shared + * with another (unterminated) thread, and terminated threads are also + * usually garbage collected quite quickly. Also, doing DECREFs + * could trigger finalization, which would run on the current thread + * and have access to only some of the built-ins. Garbage collection + * deals with this correctly already. + */ + + /* XXX: Shrink the stacks to minimize memory usage? May not + * be worth the effort because terminated threads are usually + * garbage collected quite soon. + */ +} + +DUK_INTERNAL duk_activation *duk_hthread_get_current_activation(duk_hthread *thr) { + DUK_ASSERT(thr != NULL); + + if (thr->callstack_top > 0) { + return thr->callstack + thr->callstack_top - 1; + } else { + return NULL; + } +} + +#if defined(DUK_USE_DEBUGGER_SUPPORT) +DUK_INTERNAL duk_uint_fast32_t duk_hthread_get_act_curr_pc(duk_hthread *thr, duk_activation *act) { + duk_instr_t *bcode; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(act != NULL); + DUK_UNREF(thr); + + /* XXX: store 'bcode' pointer to activation for faster lookup? */ + if (act->func && DUK_HOBJECT_IS_COMPILEDFUNCTION(act->func)) { + bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) (act->func)); + return (duk_uint_fast32_t) (act->curr_pc - bcode); + } + return 0; +} +#endif /* DUK_USE_DEBUGGER_SUPPORT */ + +DUK_INTERNAL duk_uint_fast32_t duk_hthread_get_act_prev_pc(duk_hthread *thr, duk_activation *act) { + duk_instr_t *bcode; + duk_uint_fast32_t ret; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(act != NULL); + DUK_UNREF(thr); + + if (act->func && DUK_HOBJECT_IS_COMPILEDFUNCTION(act->func)) { + bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) (act->func)); + ret = (duk_uint_fast32_t) (act->curr_pc - bcode); + if (ret > 0) { + ret--; + } + return ret; + } + return 0; +} + +/* Write bytecode executor's curr_pc back to topmost activation (if any). */ +DUK_INTERNAL void duk_hthread_sync_currpc(duk_hthread *thr) { + duk_activation *act; + + DUK_ASSERT(thr != NULL); + + if (thr->ptr_curr_pc != NULL) { + /* ptr_curr_pc != NULL only when bytecode executor is active. */ + DUK_ASSERT(thr->callstack_top > 0); + act = thr->callstack + thr->callstack_top - 1; + act->curr_pc = *thr->ptr_curr_pc; + } +} + +DUK_INTERNAL void duk_hthread_sync_and_null_currpc(duk_hthread *thr) { + duk_activation *act; + + DUK_ASSERT(thr != NULL); + + if (thr->ptr_curr_pc != NULL) { + /* ptr_curr_pc != NULL only when bytecode executor is active. */ + DUK_ASSERT(thr->callstack_top > 0); + act = thr->callstack + thr->callstack_top - 1; + act->curr_pc = *thr->ptr_curr_pc; + thr->ptr_curr_pc = NULL; + } +} +#line 1 "duk_hthread_stacks.c" +/* + * Manipulation of thread stacks (valstack, callstack, catchstack). + * + * Ideally unwinding of stacks should have no side effects, which would + * then favor separate unwinding and shrink check primitives for each + * stack type. A shrink check may realloc and thus have side effects. + * + * However, currently callstack unwinding itself has side effects, as it + * needs to DECREF multiple objects, close environment records, etc. + * Stacks must thus be unwound in the correct order by the caller. + * + * (XXX: This should be probably reworked so that there is a shared + * unwind primitive which handles all stacks as requested, and knows + * the proper order for unwinding.) + * + * Valstack entries above 'top' are always kept initialized to + * "undefined unused". Callstack and catchstack entries above 'top' + * are not zeroed and are left as garbage. + * + * Value stack handling is mostly a part of the API implementation. + */ + +/* include removed: duk_internal.h */ + +/* check that there is space for at least one new entry */ +DUK_INTERNAL void duk_hthread_callstack_grow(duk_hthread *thr) { + duk_activation *new_ptr; + duk_size_t old_size; + duk_size_t new_size; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT_DISABLE(thr->callstack_top >= 0); /* avoid warning (unsigned) */ + DUK_ASSERT(thr->callstack_size >= thr->callstack_top); + + if (thr->callstack_top < thr->callstack_size) { + return; + } + + old_size = thr->callstack_size; + new_size = old_size + DUK_CALLSTACK_GROW_STEP; + + /* this is a bit approximate (errors out before max is reached); this is OK */ + if (new_size >= thr->callstack_max) { + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_CALLSTACK_LIMIT); + } + + DUK_DD(DUK_DDPRINT("growing callstack %ld -> %ld", (long) old_size, (long) new_size)); + + /* + * Note: must use indirect variant of DUK_REALLOC() because underlying + * pointer may be changed by mark-and-sweep. + */ + + DUK_ASSERT(new_size > 0); + new_ptr = (duk_activation *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_callstack_ptr, (void *) thr, sizeof(duk_activation) * new_size); + if (!new_ptr) { + /* No need for a NULL/zero-size check because new_size > 0) */ + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_REALLOC_FAILED); + } + thr->callstack = new_ptr; + thr->callstack_size = new_size; + + /* note: any entries above the callstack top are garbage and not zeroed */ +} + +DUK_INTERNAL void duk_hthread_callstack_shrink_check(duk_hthread *thr) { + duk_size_t new_size; + duk_activation *p; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT_DISABLE(thr->callstack_top >= 0); /* avoid warning (unsigned) */ + DUK_ASSERT(thr->callstack_size >= thr->callstack_top); + + if (thr->callstack_size - thr->callstack_top < DUK_CALLSTACK_SHRINK_THRESHOLD) { + return; + } + + new_size = thr->callstack_top + DUK_CALLSTACK_SHRINK_SPARE; + DUK_ASSERT(new_size >= thr->callstack_top); + + DUK_DD(DUK_DDPRINT("shrinking callstack %ld -> %ld", (long) thr->callstack_size, (long) new_size)); + + /* + * Note: must use indirect variant of DUK_REALLOC() because underlying + * pointer may be changed by mark-and-sweep. + */ + + /* shrink failure is not fatal */ + p = (duk_activation *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_callstack_ptr, (void *) thr, sizeof(duk_activation) * new_size); + if (p) { + thr->callstack = p; + thr->callstack_size = new_size; + } else { + /* Because new_size != 0, if condition doesn't need to be + * (p != NULL || new_size == 0). + */ + DUK_ASSERT(new_size != 0); + DUK_D(DUK_DPRINT("callstack shrink failed, ignoring")); + } + + /* note: any entries above the callstack top are garbage and not zeroed */ +} + +DUK_INTERNAL void duk_hthread_callstack_unwind(duk_hthread *thr, duk_size_t new_top) { + duk_size_t idx; + + DUK_DDD(DUK_DDDPRINT("unwind callstack top of thread %p from %ld to %ld", + (void *) thr, + (thr != NULL ? (long) thr->callstack_top : (long) -1), + (long) new_top)); + + DUK_ASSERT(thr); + DUK_ASSERT(thr->heap); + DUK_ASSERT_DISABLE(new_top >= 0); /* unsigned */ + DUK_ASSERT((duk_size_t) new_top <= thr->callstack_top); /* cannot grow */ + + /* + * The loop below must avoid issues with potential callstack + * reallocations. A resize (and other side effects) may happen + * e.g. due to finalizer/errhandler calls caused by a refzero or + * mark-and-sweep. Arbitrary finalizers may run, because when + * an environment record is refzero'd, it may refer to arbitrary + * values which also become refzero'd. + * + * So, the pointer 'p' is re-looked-up below whenever a side effect + * might have changed it. + */ + + idx = thr->callstack_top; + while (idx > new_top) { + duk_activation *act; + duk_hobject *func; +#ifdef DUK_USE_REFERENCE_COUNTING + duk_hobject *tmp; +#endif +#ifdef DUK_USE_DEBUGGER_SUPPORT + duk_heap *heap; +#endif + + idx--; + DUK_ASSERT_DISABLE(idx >= 0); /* unsigned */ + DUK_ASSERT((duk_size_t) idx < thr->callstack_size); /* true, despite side effect resizes */ + + act = thr->callstack + idx; + /* With lightfuncs, act 'func' may be NULL */ + +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY + /* + * Restore 'caller' property for non-strict callee functions. + */ + + func = DUK_ACT_GET_FUNC(act); + if (func != NULL && !DUK_HOBJECT_HAS_STRICT(func)) { + duk_tval *tv_caller; + duk_tval tv_tmp; + duk_hobject *h_tmp; + + tv_caller = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_CALLER(thr)); + + /* The act->prev_caller should only be set if the entry for 'caller' + * exists (as it is only set in that case, and the property is not + * configurable), but handle all the cases anyway. + */ + + if (tv_caller) { + DUK_TVAL_SET_TVAL(&tv_tmp, tv_caller); + if (act->prev_caller) { + /* Just transfer the refcount from act->prev_caller to tv_caller, + * so no need for a refcount update. This is the expected case. + */ + DUK_TVAL_SET_OBJECT(tv_caller, act->prev_caller); + act->prev_caller = NULL; + } else { + DUK_TVAL_SET_NULL(tv_caller); /* no incref needed */ + DUK_ASSERT(act->prev_caller == NULL); + } + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + } else { + h_tmp = act->prev_caller; + if (h_tmp) { + act->prev_caller = NULL; + DUK_HOBJECT_DECREF(thr, h_tmp); /* side effects */ + } + } + act = thr->callstack + idx; /* avoid side effects */ + DUK_ASSERT(act->prev_caller == NULL); + } +#endif + + /* + * Unwind debugger state. If we unwind while stepping + * (either step over or step into), pause execution. + */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) + heap = thr->heap; + if (heap->dbg_step_thread == thr && + heap->dbg_step_csindex == idx) { + /* Pause for all step types: step into, step over, step out. + * This is the only place explicitly handling a step out. + */ + DUK_HEAP_SET_PAUSED(heap); + DUK_ASSERT(heap->dbg_step_thread == NULL); + } +#endif + + /* + * Close environment record(s) if they exist. + * + * Only variable environments are closed. If lex_env != var_env, it + * cannot currently contain any register bound declarations. + * + * Only environments created for a NEWENV function are closed. If an + * environment is created for e.g. an eval call, it must not be closed. + */ + + func = DUK_ACT_GET_FUNC(act); + if (func != NULL && !DUK_HOBJECT_HAS_NEWENV(func)) { + DUK_DDD(DUK_DDDPRINT("skip closing environments, envs not owned by this activation")); + goto skip_env_close; + } + /* func is NULL for lightfunc */ + + DUK_ASSERT(act->lex_env == act->var_env); + if (act->var_env != NULL) { + DUK_DDD(DUK_DDDPRINT("closing var_env record %p -> %!O", + (void *) act->var_env, (duk_heaphdr *) act->var_env)); + duk_js_close_environment_record(thr, act->var_env, func, act->idx_bottom); + act = thr->callstack + idx; /* avoid side effect issues */ + } + +#if 0 + if (act->lex_env != NULL) { + if (act->lex_env == act->var_env) { + /* common case, already closed, so skip */ + DUK_DD(DUK_DDPRINT("lex_env and var_env are the same and lex_env " + "already closed -> skip closing lex_env")); + ; + } else { + DUK_DD(DUK_DDPRINT("closing lex_env record %p -> %!O", + (void *) act->lex_env, (duk_heaphdr *) act->lex_env)); + duk_js_close_environment_record(thr, act->lex_env, DUK_ACT_GET_FUNC(act), act->idx_bottom); + act = thr->callstack + idx; /* avoid side effect issues */ + } + } +#endif + + DUK_ASSERT((act->lex_env == NULL) || + ((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) && + (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) && + (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) && + (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL))); + + DUK_ASSERT((act->var_env == NULL) || + ((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) && + (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) && + (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) && + (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL))); + + skip_env_close: + + /* + * Update preventcount + */ + + if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) { + DUK_ASSERT(thr->callstack_preventcount >= 1); + thr->callstack_preventcount--; + } + + /* + * Reference count updates + * + * Note: careful manipulation of refcounts. The top is + * not updated yet, so all the activations are reachable + * for mark-and-sweep (which may be triggered by decref). + * However, the pointers are NULL so this is not an issue. + */ + +#ifdef DUK_USE_REFERENCE_COUNTING + tmp = act->var_env; +#endif + act->var_env = NULL; +#ifdef DUK_USE_REFERENCE_COUNTING + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + act = thr->callstack + idx; /* avoid side effect issues */ +#endif + +#ifdef DUK_USE_REFERENCE_COUNTING + tmp = act->lex_env; +#endif + act->lex_env = NULL; +#ifdef DUK_USE_REFERENCE_COUNTING + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + act = thr->callstack + idx; /* avoid side effect issues */ +#endif + + /* Note: this may cause a corner case situation where a finalizer + * may see a currently reachable activation whose 'func' is NULL. + */ +#ifdef DUK_USE_REFERENCE_COUNTING + tmp = DUK_ACT_GET_FUNC(act); +#endif + act->func = NULL; +#ifdef DUK_USE_REFERENCE_COUNTING + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + act = thr->callstack + idx; /* avoid side effect issues */ + DUK_UNREF(act); +#endif + } + + thr->callstack_top = new_top; + + /* + * We could clear the book-keeping variables for the topmost activation, + * but don't do so now. + */ +#if 0 + if (thr->callstack_top > 0) { + duk_activation *act = thr->callstack + thr->callstack_top - 1; + act->idx_retval = 0; + } +#endif + + /* Note: any entries above the callstack top are garbage and not zeroed. + * Also topmost activation idx_retval is garbage (not zeroed), and must + * be ignored. + */ +} + +DUK_INTERNAL void duk_hthread_catchstack_grow(duk_hthread *thr) { + duk_catcher *new_ptr; + duk_size_t old_size; + duk_size_t new_size; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT_DISABLE(thr->catchstack_top); /* avoid warning (unsigned) */ + DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top); + + if (thr->catchstack_top < thr->catchstack_size) { + return; + } + + old_size = thr->catchstack_size; + new_size = old_size + DUK_CATCHSTACK_GROW_STEP; + + /* this is a bit approximate (errors out before max is reached); this is OK */ + if (new_size >= thr->catchstack_max) { + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_CATCHSTACK_LIMIT); + } + + DUK_DD(DUK_DDPRINT("growing catchstack %ld -> %ld", (long) old_size, (long) new_size)); + + /* + * Note: must use indirect variant of DUK_REALLOC() because underlying + * pointer may be changed by mark-and-sweep. + */ + + DUK_ASSERT(new_size > 0); + new_ptr = (duk_catcher *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_catchstack_ptr, (void *) thr, sizeof(duk_catcher) * new_size); + if (!new_ptr) { + /* No need for a NULL/zero-size check because new_size > 0) */ + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_REALLOC_FAILED); + } + thr->catchstack = new_ptr; + thr->catchstack_size = new_size; + + /* note: any entries above the catchstack top are garbage and not zeroed */ +} + +DUK_INTERNAL void duk_hthread_catchstack_shrink_check(duk_hthread *thr) { + duk_size_t new_size; + duk_catcher *p; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT_DISABLE(thr->catchstack_top >= 0); /* avoid warning (unsigned) */ + DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top); + + if (thr->catchstack_size - thr->catchstack_top < DUK_CATCHSTACK_SHRINK_THRESHOLD) { + return; + } + + new_size = thr->catchstack_top + DUK_CATCHSTACK_SHRINK_SPARE; + DUK_ASSERT(new_size >= thr->catchstack_top); + + DUK_DD(DUK_DDPRINT("shrinking catchstack %ld -> %ld", (long) thr->catchstack_size, (long) new_size)); + + /* + * Note: must use indirect variant of DUK_REALLOC() because underlying + * pointer may be changed by mark-and-sweep. + */ + + /* shrink failure is not fatal */ + p = (duk_catcher *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_catchstack_ptr, (void *) thr, sizeof(duk_catcher) * new_size); + if (p) { + thr->catchstack = p; + thr->catchstack_size = new_size; + } else { + /* Because new_size != 0, if condition doesn't need to be + * (p != NULL || new_size == 0). + */ + DUK_ASSERT(new_size != 0); + DUK_D(DUK_DPRINT("catchstack shrink failed, ignoring")); + } + + /* note: any entries above the catchstack top are garbage and not zeroed */ +} + +DUK_INTERNAL void duk_hthread_catchstack_unwind(duk_hthread *thr, duk_size_t new_top) { + duk_size_t idx; + + DUK_DDD(DUK_DDDPRINT("unwind catchstack top of thread %p from %ld to %ld", + (void *) thr, + (thr != NULL ? (long) thr->catchstack_top : (long) -1), + (long) new_top)); + + DUK_ASSERT(thr); + DUK_ASSERT(thr->heap); + DUK_ASSERT_DISABLE(new_top >= 0); /* unsigned */ + DUK_ASSERT((duk_size_t) new_top <= thr->catchstack_top); /* cannot grow */ + + /* + * Since there are no references in the catcher structure, + * unwinding is quite simple. The only thing we need to + * look out for is popping a possible lexical environment + * established for an active catch clause. + */ + + idx = thr->catchstack_top; + while (idx > new_top) { + duk_catcher *p; + duk_activation *act; + duk_hobject *env; + + idx--; + DUK_ASSERT_DISABLE(idx >= 0); /* unsigned */ + DUK_ASSERT((duk_size_t) idx < thr->catchstack_size); + + p = thr->catchstack + idx; + + if (DUK_CAT_HAS_LEXENV_ACTIVE(p)) { + DUK_DDD(DUK_DDDPRINT("unwinding catchstack idx %ld, callstack idx %ld, callstack top %ld: lexical environment active", + (long) idx, (long) p->callstack_index, (long) thr->callstack_top)); + + /* XXX: Here we have a nasty dependency: the need to manipulate + * the callstack means that catchstack must always be unwound by + * the caller before unwinding the callstack. This should be fixed + * later. + */ + + /* Note that multiple catchstack entries may refer to the same + * callstack entry. + */ + act = thr->callstack + p->callstack_index; + DUK_ASSERT(act >= thr->callstack); + DUK_ASSERT(act < thr->callstack + thr->callstack_top); + + DUK_DDD(DUK_DDDPRINT("catchstack_index=%ld, callstack_index=%ld, lex_env=%!iO", + (long) idx, (long) p->callstack_index, + (duk_heaphdr *) act->lex_env)); + + env = act->lex_env; /* current lex_env of the activation (created for catcher) */ + DUK_ASSERT(env != NULL); /* must be, since env was created when catcher was created */ + act->lex_env = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, env); /* prototype is lex_env before catcher created */ + DUK_HOBJECT_DECREF(thr, env); + + /* There is no need to decref anything else than 'env': if 'env' + * becomes unreachable, refzero will handle decref'ing its prototype. + */ + } + } + + thr->catchstack_top = new_top; + + /* note: any entries above the catchstack top are garbage and not zeroed */ +} +#line 1 "duk_js_call.c" +/* + * Call handling. + * + * The main work horse functions are: + * - duk_handle_call(): call to a C/Ecmascript functions + * - duk_handle_safe_call(): make a protected C call within current activation + * - duk_handle_ecma_call_setup(): Ecmascript-to-Ecmascript calls, including + * tail calls and coroutine resume + */ + +/* include removed: duk_internal.h */ + +/* + * Misc + */ + +#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) +DUK_LOCAL void duk__interrupt_fixup(duk_hthread *thr, duk_hthread *entry_curr_thread) { + /* XXX: Currently the bytecode executor and executor interrupt + * instruction counts are off because we don't execute the + * interrupt handler when we're about to exit from the initial + * user call into Duktape. + * + * If we were to execute the interrupt handler here, the counts + * would match. You can enable this block manually to check + * that this is the case. + */ + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + +#if 0 + if (entry_curr_thread == NULL) { + thr->interrupt_init = thr->interrupt_init - thr->interrupt_counter; + thr->heap->inst_count_interrupt += thr->interrupt_init; + DUK_DD(DUK_DDPRINT("debug test: updated interrupt count on exit to " + "user code, instruction counts: executor=%ld, interrupt=%ld", + (long) thr->heap->inst_count_exec, (long) thr->heap->inst_count_interrupt)); + DUK_ASSERT(thr->heap->inst_count_exec == thr->heap->inst_count_interrupt); + } +#else + DUK_UNREF(thr); + DUK_UNREF(entry_curr_thread); +#endif +} +#endif + +/* + * Arguments object creation. + * + * Creating arguments objects is a bit finicky, see E5 Section 10.6 for the + * specific requirements. Much of the arguments object exotic behavior is + * implemented in duk_hobject_props.c, and is enabled by the object flag + * DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS. + */ + +DUK_LOCAL +void duk__create_arguments_object(duk_hthread *thr, + duk_hobject *func, + duk_hobject *varenv, + duk_idx_t idx_argbase, /* idx of first argument on stack */ + duk_idx_t num_stack_args) { /* num args starting from idx_argbase */ + duk_context *ctx = (duk_context *) thr; + duk_hobject *arg; /* 'arguments' */ + duk_hobject *formals; /* formals for 'func' (may be NULL if func is a C function) */ + duk_idx_t i_arg; + duk_idx_t i_map; + duk_idx_t i_mappednames; + duk_idx_t i_formals; + duk_idx_t i_argbase; + duk_idx_t n_formals; + duk_idx_t idx; + duk_bool_t need_map; + + DUK_DDD(DUK_DDDPRINT("creating arguments object for func=%!iO, varenv=%!iO, " + "idx_argbase=%ld, num_stack_args=%ld", + (duk_heaphdr *) func, (duk_heaphdr *) varenv, + (long) idx_argbase, (long) num_stack_args)); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(func != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_NONBOUND_FUNCTION(func)); + DUK_ASSERT(varenv != NULL); + DUK_ASSERT(idx_argbase >= 0); /* assumed to bottom relative */ + DUK_ASSERT(num_stack_args >= 0); + + need_map = 0; + + i_argbase = idx_argbase; + DUK_ASSERT(i_argbase >= 0); + + duk_push_hobject(ctx, func); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_FORMALS); + formals = duk_get_hobject(ctx, -1); + n_formals = 0; + if (formals) { + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH); + n_formals = (duk_idx_t) duk_require_int(ctx, -1); + duk_pop(ctx); + } + duk_remove(ctx, -2); /* leave formals on stack for later use */ + i_formals = duk_require_top_index(ctx); + + DUK_ASSERT(n_formals >= 0); + DUK_ASSERT(formals != NULL || n_formals == 0); + + DUK_DDD(DUK_DDDPRINT("func=%!O, formals=%!O, n_formals=%ld", + (duk_heaphdr *) func, (duk_heaphdr *) formals, + (long) n_formals)); + + /* [ ... formals ] */ + + /* + * Create required objects: + * - 'arguments' object: array-like, but not an array + * - 'map' object: internal object, tied to 'arguments' + * - 'mappedNames' object: temporary value used during construction + */ + + i_arg = duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_ARRAY_PART | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARGUMENTS), + DUK_BIDX_OBJECT_PROTOTYPE); + DUK_ASSERT(i_arg >= 0); + arg = duk_require_hobject(ctx, -1); + DUK_ASSERT(arg != NULL); + + i_map = duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT), + -1); /* no prototype */ + DUK_ASSERT(i_map >= 0); + + i_mappednames = duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT), + -1); /* no prototype */ + DUK_ASSERT(i_mappednames >= 0); + + /* [... formals arguments map mappedNames] */ + + DUK_DDD(DUK_DDDPRINT("created arguments related objects: " + "arguments at index %ld -> %!O " + "map at index %ld -> %!O " + "mappednames at index %ld -> %!O", + (long) i_arg, (duk_heaphdr *) duk_get_hobject(ctx, i_arg), + (long) i_map, (duk_heaphdr *) duk_get_hobject(ctx, i_map), + (long) i_mappednames, (duk_heaphdr *) duk_get_hobject(ctx, i_mappednames))); + + /* + * Init arguments properties, map, etc. + */ + + duk_push_int(ctx, num_stack_args); + duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_WC); + + /* + * Init argument related properties + */ + + /* step 11 */ + idx = num_stack_args - 1; + while (idx >= 0) { + DUK_DDD(DUK_DDDPRINT("arg idx %ld, argbase=%ld, argidx=%ld", + (long) idx, (long) i_argbase, (long) (i_argbase + idx))); + + DUK_DDD(DUK_DDDPRINT("define arguments[%ld]=arg", (long) idx)); + duk_dup(ctx, i_argbase + idx); + duk_xdef_prop_index_wec(ctx, i_arg, (duk_uarridx_t) idx); + DUK_DDD(DUK_DDDPRINT("defined arguments[%ld]=arg", (long) idx)); + + /* step 11.c is relevant only if non-strict (checked in 11.c.ii) */ + if (!DUK_HOBJECT_HAS_STRICT(func) && idx < n_formals) { + DUK_ASSERT(formals != NULL); + + DUK_DDD(DUK_DDDPRINT("strict function, index within formals (%ld < %ld)", + (long) idx, (long) n_formals)); + + duk_get_prop_index(ctx, i_formals, idx); + DUK_ASSERT(duk_is_string(ctx, -1)); + + duk_dup(ctx, -1); /* [... name name] */ + + if (!duk_has_prop(ctx, i_mappednames)) { + /* steps 11.c.ii.1 - 11.c.ii.4, but our internal book-keeping + * differs from the reference model + */ + + /* [... name] */ + + need_map = 1; + + DUK_DDD(DUK_DDDPRINT("set mappednames[%s]=%ld", + (const char *) duk_get_string(ctx, -1), + (long) idx)); + duk_dup(ctx, -1); /* name */ + duk_push_uint(ctx, (duk_uint_t) idx); /* index */ + duk_to_string(ctx, -1); + duk_xdef_prop_wec(ctx, i_mappednames); /* out of spec, must be configurable */ + + DUK_DDD(DUK_DDDPRINT("set map[%ld]=%s", + (long) idx, + duk_get_string(ctx, -1))); + duk_dup(ctx, -1); /* name */ + duk_xdef_prop_index_wec(ctx, i_map, (duk_uarridx_t) idx); /* out of spec, must be configurable */ + } else { + /* duk_has_prop() popped the second 'name' */ + } + + /* [... name] */ + duk_pop(ctx); /* pop 'name' */ + } + + idx--; + } + + DUK_DDD(DUK_DDDPRINT("actual arguments processed")); + + /* step 12 */ + if (need_map) { + DUK_DDD(DUK_DDDPRINT("adding 'map' and 'varenv' to arguments object")); + + /* should never happen for a strict callee */ + DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(func)); + + duk_dup(ctx, i_map); + duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_INT_MAP, DUK_PROPDESC_FLAGS_NONE); /* out of spec, don't care */ + + /* The variable environment for magic variable bindings needs to be + * given by the caller and recorded in the arguments object. + * + * See E5 Section 10.6, the creation of setters/getters. + * + * The variable environment also provides access to the callee, so + * an explicit (internal) callee property is not needed. + */ + + duk_push_hobject(ctx, varenv); + duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_INT_VARENV, DUK_PROPDESC_FLAGS_NONE); /* out of spec, don't care */ + } + + /* steps 13-14 */ + if (DUK_HOBJECT_HAS_STRICT(func)) { + /* + * Note: callee/caller are throwers and are not deletable etc. + * They could be implemented as virtual properties, but currently + * there is no support for virtual properties which are accessors + * (only plain virtual properties). This would not be difficult + * to change in duk_hobject_props, but we can make the throwers + * normal, concrete properties just as easily. + * + * Note that the specification requires that the *same* thrower + * built-in object is used here! See E5 Section 10.6 main + * algoritm, step 14, and Section 13.2.3 which describes the + * thrower. See test case test-arguments-throwers.js. + */ + + DUK_DDD(DUK_DDDPRINT("strict function, setting caller/callee to throwers")); + + duk_xdef_prop_stridx_thrower(ctx, i_arg, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE); + duk_xdef_prop_stridx_thrower(ctx, i_arg, DUK_STRIDX_CALLEE, DUK_PROPDESC_FLAGS_NONE); + } else { + DUK_DDD(DUK_DDDPRINT("non-strict function, setting callee to actual value")); + duk_push_hobject(ctx, func); + duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_CALLEE, DUK_PROPDESC_FLAGS_WC); + } + + /* set exotic behavior only after we're done */ + if (need_map) { + /* + * Note: exotic behaviors are only enabled for arguments + * objects which have a parameter map (see E5 Section 10.6 + * main algorithm, step 12). + * + * In particular, a non-strict arguments object with no + * mapped formals does *NOT* get exotic behavior, even + * for e.g. "caller" property. This seems counterintuitive + * but seems to be the case. + */ + + /* cannot be strict (never mapped variables) */ + DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(func)); + + DUK_DDD(DUK_DDDPRINT("enabling exotic behavior for arguments object")); + DUK_HOBJECT_SET_EXOTIC_ARGUMENTS(arg); + } else { + DUK_DDD(DUK_DDDPRINT("not enabling exotic behavior for arguments object")); + } + + /* nice log */ + DUK_DDD(DUK_DDDPRINT("final arguments related objects: " + "arguments at index %ld -> %!O " + "map at index %ld -> %!O " + "mappednames at index %ld -> %!O", + (long) i_arg, (duk_heaphdr *) duk_get_hobject(ctx, i_arg), + (long) i_map, (duk_heaphdr *) duk_get_hobject(ctx, i_map), + (long) i_mappednames, (duk_heaphdr *) duk_get_hobject(ctx, i_mappednames))); + + /* [args(n) [crud] formals arguments map mappednames] -> [args [crud] arguments] */ + duk_pop_2(ctx); + duk_remove(ctx, -2); +} + +/* Helper for creating the arguments object and adding it to the env record + * on top of the value stack. This helper has a very strict dependency on + * the shape of the input stack. + */ +DUK_LOCAL +void duk__handle_createargs_for_call(duk_hthread *thr, + duk_hobject *func, + duk_hobject *env, + duk_idx_t num_stack_args) { + duk_context *ctx = (duk_context *) thr; + + DUK_DDD(DUK_DDDPRINT("creating arguments object for function call")); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(func != NULL); + DUK_ASSERT(env != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func)); + DUK_ASSERT(duk_get_top(ctx) >= num_stack_args + 1); + + /* [... arg1 ... argN envobj] */ + + duk__create_arguments_object(thr, + func, + env, + duk_get_top(ctx) - num_stack_args - 1, /* idx_argbase */ + num_stack_args); + + /* [... arg1 ... argN envobj argobj] */ + + duk_xdef_prop_stridx(ctx, + -2, + DUK_STRIDX_LC_ARGUMENTS, + DUK_HOBJECT_HAS_STRICT(func) ? DUK_PROPDESC_FLAGS_E : /* strict: non-deletable, non-writable */ + DUK_PROPDESC_FLAGS_WE); /* non-strict: non-deletable, writable */ + /* [... arg1 ... argN envobj] */ +} + +/* + * Helper for handling a "bound function" chain when a call is being made. + * + * Follows the bound function chain until a non-bound function is found. + * Prepends the bound arguments to the value stack (at idx_func + 2), + * updating 'num_stack_args' in the process. The 'this' binding is also + * updated if necessary (at idx_func + 1). Note that for constructor calls + * the 'this' binding is never updated by [[BoundThis]]. + * + * XXX: bound function chains could be collapsed at bound function creation + * time so that each bound function would point directly to a non-bound + * function. This would make call time handling much easier. + */ + +DUK_LOCAL +void duk__handle_bound_chain_for_call(duk_hthread *thr, + duk_idx_t idx_func, + duk_idx_t *p_num_stack_args, /* may be changed by call */ + duk_bool_t is_constructor_call) { + duk_context *ctx = (duk_context *) thr; + duk_idx_t num_stack_args; + duk_tval *tv_func; + duk_hobject *func; + duk_uint_t sanity; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(p_num_stack_args != NULL); + + /* On entry, item at idx_func is a bound, non-lightweight function, + * but we don't rely on that below. + */ + + num_stack_args = *p_num_stack_args; + + sanity = DUK_HOBJECT_BOUND_CHAIN_SANITY; + do { + duk_idx_t i, len; + + tv_func = duk_require_tval(ctx, idx_func); + DUK_ASSERT(tv_func != NULL); + + if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) { + /* Lightweight function: never bound, so terminate. */ + break; + } else if (DUK_TVAL_IS_OBJECT(tv_func)) { + func = DUK_TVAL_GET_OBJECT(tv_func); + if (!DUK_HOBJECT_HAS_BOUND(func)) { + /* Normal non-bound function. */ + break; + } + } else { + /* Function.prototype.bind() should never let this happen, + * ugly error message is enough. + */ + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR); + } + DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv_func) != NULL); + + /* XXX: this could be more compact by accessing the internal properties + * directly as own properties (they cannot be inherited, and are not + * externally visible). + */ + + DUK_DDD(DUK_DDDPRINT("bound function encountered, ptr=%p, num_stack_args=%ld: %!T", + (void *) DUK_TVAL_GET_OBJECT(tv_func), (long) num_stack_args, tv_func)); + + /* [ ... func this arg1 ... argN ] */ + + if (is_constructor_call) { + /* See: tests/ecmascript/test-spec-bound-constructor.js */ + DUK_DDD(DUK_DDDPRINT("constructor call: don't update this binding")); + } else { + duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_THIS); + duk_replace(ctx, idx_func + 1); /* idx_this = idx_func + 1 */ + } + + /* [ ... func this arg1 ... argN ] */ + + /* XXX: duk_get_length? */ + duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_ARGS); /* -> [ ... func this arg1 ... argN _Args ] */ + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH); /* -> [ ... func this arg1 ... argN _Args length ] */ + len = (duk_idx_t) duk_require_int(ctx, -1); + duk_pop(ctx); + for (i = 0; i < len; i++) { + /* XXX: very slow - better to bulk allocate a gap, and copy + * from args_array directly (we know it has a compact array + * part, etc). + */ + + /* [ ... func this <some bound args> arg1 ... argN _Args ] */ + duk_get_prop_index(ctx, -1, i); + duk_insert(ctx, idx_func + 2 + i); /* idx_args = idx_func + 2 */ + } + num_stack_args += len; /* must be updated to work properly (e.g. creation of 'arguments') */ + duk_pop(ctx); + + /* [ ... func this <bound args> arg1 ... argN ] */ + + duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_TARGET); + duk_replace(ctx, idx_func); /* replace in stack */ + + DUK_DDD(DUK_DDDPRINT("bound function handled, num_stack_args=%ld, idx_func=%ld, curr func=%!T", + (long) num_stack_args, (long) idx_func, duk_get_tval(ctx, idx_func))); + } while (--sanity > 0); + + if (sanity == 0) { + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_BOUND_CHAIN_LIMIT); + } + + DUK_DDD(DUK_DDDPRINT("final non-bound function is: %!T", duk_get_tval(ctx, idx_func))); + +#ifdef DUK_USE_ASSERTIONS + tv_func = duk_require_tval(ctx, idx_func); + DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv_func) || DUK_TVAL_IS_OBJECT(tv_func)); + if (DUK_TVAL_IS_OBJECT(tv_func)) { + func = DUK_TVAL_GET_OBJECT(tv_func); + DUK_ASSERT(func != NULL); + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func)); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func) || + DUK_HOBJECT_HAS_NATIVEFUNCTION(func)); + } +#endif + + /* write back */ + *p_num_stack_args = num_stack_args; +} + +/* + * Helper for setting up var_env and lex_env of an activation, + * assuming it does NOT have the DUK_HOBJECT_FLAG_NEWENV flag. + */ + +DUK_LOCAL +void duk__handle_oldenv_for_call(duk_hthread *thr, + duk_hobject *func, + duk_activation *act) { + duk_tval *tv; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(func != NULL); + DUK_ASSERT(act != NULL); + DUK_ASSERT(!DUK_HOBJECT_HAS_NEWENV(func)); + DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(func)); + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_LEXENV(thr)); + if (tv) { + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); + DUK_ASSERT(DUK_HOBJECT_IS_ENV(DUK_TVAL_GET_OBJECT(tv))); + act->lex_env = DUK_TVAL_GET_OBJECT(tv); + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_VARENV(thr)); + if (tv) { + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); + DUK_ASSERT(DUK_HOBJECT_IS_ENV(DUK_TVAL_GET_OBJECT(tv))); + act->var_env = DUK_TVAL_GET_OBJECT(tv); + } else { + act->var_env = act->lex_env; + } + } else { + act->lex_env = thr->builtins[DUK_BIDX_GLOBAL_ENV]; + act->var_env = act->lex_env; + } + + DUK_HOBJECT_INCREF_ALLOWNULL(thr, act->lex_env); + DUK_HOBJECT_INCREF_ALLOWNULL(thr, act->var_env); +} + +/* + * Helper for updating callee 'caller' property. + */ + +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +DUK_LOCAL void duk__update_func_caller_prop(duk_hthread *thr, duk_hobject *func) { + duk_tval *tv_caller; + duk_hobject *h_tmp; + duk_activation *act_callee; + duk_activation *act_caller; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(func != NULL); + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func)); /* bound chain resolved */ + DUK_ASSERT(thr->callstack_top >= 1); + + if (DUK_HOBJECT_HAS_STRICT(func)) { + /* Strict functions don't get their 'caller' updated. */ + return; + } + + act_callee = thr->callstack + thr->callstack_top - 1; + act_caller = (thr->callstack_top >= 2 ? act_callee - 1 : NULL); + + /* Backup 'caller' property and update its value. */ + tv_caller = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_CALLER(thr)); + if (tv_caller) { + /* If caller is global/eval code, 'caller' should be set to + * 'null'. + * + * XXX: there is no exotic flag to infer this correctly now. + * The NEWENV flag is used now which works as intended for + * everything (global code, non-strict eval code, and functions) + * except strict eval code. Bound functions are never an issue + * because 'func' has been resolved to a non-bound function. + */ + + if (act_caller) { + /* act_caller->func may be NULL in some finalization cases, + * just treat like we don't know the caller. + */ + if (act_caller->func && !DUK_HOBJECT_HAS_NEWENV(act_caller->func)) { + /* Setting to NULL causes 'caller' to be set to + * 'null' as desired. + */ + act_caller = NULL; + } + } + + if (DUK_TVAL_IS_OBJECT(tv_caller)) { + h_tmp = DUK_TVAL_GET_OBJECT(tv_caller); + DUK_ASSERT(h_tmp != NULL); + act_callee->prev_caller = h_tmp; + + /* Previous value doesn't need refcount changes because its ownership + * is transferred to prev_caller. + */ + + if (act_caller) { + DUK_ASSERT(act_caller->func != NULL); + DUK_TVAL_SET_OBJECT(tv_caller, act_caller->func); + DUK_TVAL_INCREF(thr, tv_caller); + } else { + DUK_TVAL_SET_NULL(tv_caller); /* no incref */ + } + } else { + /* 'caller' must only take on 'null' or function value */ + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_caller)); + DUK_ASSERT(act_callee->prev_caller == NULL); + if (act_caller && act_caller->func) { + /* Tolerate act_caller->func == NULL which happens in + * some finalization cases; treat like unknown caller. + */ + DUK_TVAL_SET_OBJECT(tv_caller, act_caller->func); + DUK_TVAL_INCREF(thr, tv_caller); + } else { + DUK_TVAL_SET_NULL(tv_caller); /* no incref */ + } + } + } +} +#endif /* DUK_USE_NONSTD_FUNC_CALLER_PROPERTY */ + +/* + * Determine the effective 'this' binding and coerce the current value + * on the valstack to the effective one (in-place, at idx_this). + * + * The current this value in the valstack (at idx_this) represents either: + * - the caller's requested 'this' binding; or + * - a 'this' binding accumulated from the bound function chain + * + * The final 'this' binding for the target function may still be + * different, and is determined as described in E5 Section 10.4.3. + * + * For global and eval code (E5 Sections 10.4.1 and 10.4.2), we assume + * that the caller has provided the correct 'this' binding explicitly + * when calling, i.e.: + * + * - global code: this=global object + * - direct eval: this=copy from eval() caller's this binding + * - other eval: this=global object + * + * Note: this function may cause a recursive function call with arbitrary + * side effects, because ToObject() may be called. + */ + +DUK_LOCAL +void duk__coerce_effective_this_binding(duk_hthread *thr, + duk_hobject *func, + duk_idx_t idx_this) { + duk_context *ctx = (duk_context *) thr; + duk_small_int_t strict; + + if (func) { + strict = DUK_HOBJECT_HAS_STRICT(func); + } else { + /* Lightfuncs are always considered strict. */ + strict = 1; + } + + if (strict) { + DUK_DDD(DUK_DDDPRINT("this binding: strict -> use directly")); + } else { + duk_tval *tv_this = duk_require_tval(ctx, idx_this); + duk_hobject *obj_global; + + if (DUK_TVAL_IS_OBJECT(tv_this)) { + DUK_DDD(DUK_DDDPRINT("this binding: non-strict, object -> use directly")); + } else if (DUK_TVAL_IS_LIGHTFUNC(tv_this)) { + /* Lightfuncs are treated like objects and not coerced. */ + DUK_DDD(DUK_DDDPRINT("this binding: non-strict, lightfunc -> use directly")); + } else if (DUK_TVAL_IS_UNDEFINED(tv_this) || DUK_TVAL_IS_NULL(tv_this)) { + DUK_DDD(DUK_DDDPRINT("this binding: non-strict, undefined/null -> use global object")); + obj_global = thr->builtins[DUK_BIDX_GLOBAL]; + if (obj_global) { + duk_push_hobject(ctx, obj_global); + } else { + /* + * This may only happen if built-ins are being "torn down". + * This behavior is out of specification scope. + */ + DUK_D(DUK_DPRINT("this binding: wanted to use global object, but it is NULL -> using undefined instead")); + duk_push_undefined(ctx); + } + duk_replace(ctx, idx_this); + } else { + DUK_DDD(DUK_DDDPRINT("this binding: non-strict, not object/undefined/null -> use ToObject(value)")); + duk_to_object(ctx, idx_this); /* may have side effects */ + } + } +} + +/* + * Shared helper for non-bound func lookup. + * + * Returns duk_hobject * to the final non-bound function (NULL for lightfunc). + */ + +DUK_LOCAL +duk_hobject *duk__nonbound_func_lookup(duk_context *ctx, + duk_idx_t idx_func, + duk_idx_t *out_num_stack_args, + duk_tval **out_tv_func, + duk_small_uint_t call_flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv_func; + duk_hobject *func; + + for (;;) { + /* Use loop to minimize code size of relookup after bound function case */ + tv_func = duk_get_tval(ctx, idx_func); + DUK_ASSERT(tv_func != NULL); + + if (DUK_TVAL_IS_OBJECT(tv_func)) { + func = DUK_TVAL_GET_OBJECT(tv_func); + if (!DUK_HOBJECT_IS_CALLABLE(func)) { + goto not_callable_error; + } + if (DUK_HOBJECT_HAS_BOUND(func)) { + duk__handle_bound_chain_for_call(thr, idx_func, out_num_stack_args, call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL); + + /* The final object may be a normal function or a lightfunc. + * We need to re-lookup tv_func because it may have changed + * (also value stack may have been resized). Loop again to + * do that; we're guaranteed not to come here again. + */ + DUK_ASSERT(DUK_TVAL_IS_OBJECT(duk_require_tval(ctx, idx_func)) || + DUK_TVAL_IS_LIGHTFUNC(duk_require_tval(ctx, idx_func))); + continue; + } + } else if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) { + func = NULL; + } else { + goto not_callable_error; + } + break; + } + + DUK_ASSERT((DUK_TVAL_IS_OBJECT(tv_func) && DUK_HOBJECT_IS_CALLABLE(DUK_TVAL_GET_OBJECT(tv_func))) || + DUK_TVAL_IS_LIGHTFUNC(tv_func)); + DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func)); + DUK_ASSERT(func == NULL || (DUK_HOBJECT_IS_COMPILEDFUNCTION(func) || + DUK_HOBJECT_IS_NATIVEFUNCTION(func))); + + *out_tv_func = tv_func; + return func; + + not_callable_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CALLABLE); + DUK_UNREACHABLE(); + return NULL; /* never executed */ +} + +/* + * Value stack resize and stack top adjustment helper + * + * XXX: This should all be merged to duk_valstack_resize_raw(). + */ + +DUK_LOCAL +void duk__adjust_valstack_and_top(duk_hthread *thr, duk_idx_t num_stack_args, duk_idx_t idx_args, duk_idx_t nregs, duk_idx_t nargs, duk_hobject *func) { + duk_context *ctx = (duk_context *) thr; + duk_size_t vs_min_size; + duk_bool_t adjusted_top = 0; + + vs_min_size = (thr->valstack_bottom - thr->valstack) + /* bottom of current func */ + idx_args; /* bottom of new func */ + + if (nregs >= 0) { + DUK_ASSERT(nargs >= 0); + DUK_ASSERT(nregs >= nargs); + vs_min_size += nregs; + } else { + /* 'func' wants stack "as is" */ + vs_min_size += num_stack_args; /* num entries of new func at entry */ + } + if (func == NULL || DUK_HOBJECT_IS_NATIVEFUNCTION(func)) { + vs_min_size += DUK_VALSTACK_API_ENTRY_MINIMUM; /* Duktape/C API guaranteed entries (on top of args) */ + } + vs_min_size += DUK_VALSTACK_INTERNAL_EXTRA; /* + spare */ + + /* XXX: Awkward fix for GH-107: we can't resize the value stack to + * a size smaller than the current top, so the order of the resize + * and adjusting the stack top depends on the current vs. final size + * of the value stack. Ideally duk_valstack_resize_raw() would have + * a combined algorithm to avoid this. + */ + + if (vs_min_size < (duk_size_t) (thr->valstack_top - thr->valstack)) { + DUK_DDD(DUK_DDDPRINT(("final size smaller, set top before resize"))); + + DUK_ASSERT(nregs >= 0); /* can't happen when keeping current stack size */ + duk_set_top(ctx, idx_args + nargs); /* clamp anything above nargs */ + duk_set_top(ctx, idx_args + nregs); /* extend with undefined */ + adjusted_top = 1; + } + + (void) duk_valstack_resize_raw((duk_context *) thr, + vs_min_size, + DUK_VSRESIZE_FLAG_SHRINK | /* flags */ + 0 /* no compact */ | + DUK_VSRESIZE_FLAG_THROW); + + if (!adjusted_top) { + if (nregs >= 0) { + DUK_ASSERT(nregs >= nargs); + duk_set_top(ctx, idx_args + nargs); /* clamp anything above nargs */ + duk_set_top(ctx, idx_args + nregs); /* extend with undefined */ + } + } +} + +/* + * Helper for making various kinds of calls. + * + * Call flags: + * + * DUK_CALL_FLAG_PROTECTED <--> protected call + * DUK_CALL_FLAG_IGNORE_RECLIMIT <--> ignore C recursion limit, + * for errhandler calls + * DUK_CALL_FLAG_CONSTRUCTOR_CALL <--> for 'new Foo()' calls + * + * Input stack (thr): + * + * [ func this arg1 ... argN ] + * + * Output stack (thr): + * + * [ retval ] (DUK_EXEC_SUCCESS) + * [ errobj ] (DUK_EXEC_ERROR (normal error), protected call) + * + * Even when executing a protected call an error may be thrown in rare cases. + * For instance, if we run out of memory when setting up the return stack + * after a caught error, the out of memory is propagated to the caller. + * Similarly, API errors (such as invalid input stack shape and invalid + * indices) cause an error to propagate out of this function. If there is + * no catchpoint for this error, the fatal error handler is called. + * + * See 'execution.rst'. + * + * The allowed thread states for making a call are: + * - thr matches heap->curr_thread, and thr is already RUNNING + * - thr does not match heap->curr_thread (may be NULL or other), + * and thr is INACTIVE (in this case, a setjmp() catchpoint is + * always used for thread book-keeping to work properly) + * + * Like elsewhere, gotos are used to keep indent level minimal and + * avoiding a dozen helpers with awkward plumbing. + * + * Note: setjmp() and local variables have a nasty interaction, + * see execution.rst; non-volatile locals modified after setjmp() + * call are not guaranteed to keep their value. + */ + +DUK_INTERNAL +duk_int_t duk_handle_call(duk_hthread *thr, + duk_idx_t num_stack_args, + duk_small_uint_t call_flags) { + duk_context *ctx = (duk_context *) thr; + duk_size_t entry_valstack_bottom_index; + duk_size_t entry_valstack_end; + duk_size_t entry_callstack_top; + duk_size_t entry_catchstack_top; + duk_int_t entry_call_recursion_depth; + duk_hthread *entry_curr_thread; + duk_uint_fast8_t entry_thread_state; + duk_instr_t **entry_ptr_curr_pc; + volatile duk_bool_t need_setjmp; + duk_jmpbuf * volatile old_jmpbuf_ptr = NULL; /* ptr is volatile (not the target) */ + duk_idx_t idx_func; /* valstack index of 'func' and retval (relative to entry valstack_bottom) */ + duk_idx_t idx_args; /* valstack index of start of args (arg1) (relative to entry valstack_bottom) */ + duk_idx_t nargs; /* # argument registers target function wants (< 0 => "as is") */ + duk_idx_t nregs; /* # total registers target function wants on entry (< 0 => "as is") */ + duk_hobject *func; /* 'func' on stack (borrowed reference) */ + duk_tval *tv_func; /* duk_tval ptr for 'func' on stack (borrowed reference) or tv_func_copy */ + duk_tval tv_func_copy; /* to avoid relookups */ + duk_activation *act; + duk_hobject *env; + duk_jmpbuf our_jmpbuf; + duk_tval tv_tmp; + duk_int_t retval = DUK_EXEC_ERROR; + duk_ret_t rc; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(num_stack_args >= 0); + + /* XXX: currently NULL allocations are not supported; remove if later allowed */ + DUK_ASSERT(thr->valstack != NULL); + DUK_ASSERT(thr->callstack != NULL); + DUK_ASSERT(thr->catchstack != NULL); + + /* + * Preliminaries, required by setjmp() handler. + * + * Must be careful not to throw an unintended error here. + * + * Note: careful with indices like '-x'; if 'x' is zero, it + * refers to valstack_bottom. + */ + + entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack); + entry_valstack_end = (duk_size_t) (thr->valstack_end - thr->valstack); + entry_callstack_top = thr->callstack_top; + entry_catchstack_top = thr->catchstack_top; + entry_call_recursion_depth = thr->heap->call_recursion_depth; + entry_curr_thread = thr->heap->curr_thread; /* Note: may be NULL if first call */ + entry_thread_state = thr->state; + entry_ptr_curr_pc = thr->ptr_curr_pc; /* may be NULL */ + + idx_func = duk_normalize_index(ctx, -num_stack_args - 2); /* idx_func must be valid, note: non-throwing! */ + idx_args = idx_func + 2; /* idx_args is not necessarily valid if num_stack_args == 0 (idx_args then equals top) */ + + /* Need a setjmp() catchpoint if a protected call OR if we need to + * do mandatory cleanup. + */ + need_setjmp = ((call_flags & DUK_CALL_FLAG_PROTECTED) != 0) || (thr->heap->curr_thread != thr); + + DUK_DD(DUK_DDPRINT("duk_handle_call: thr=%p, num_stack_args=%ld, " + "call_flags=0x%08lx (protected=%ld, ignorerec=%ld, constructor=%ld), need_setjmp=%ld, " + "valstack_top=%ld, idx_func=%ld, idx_args=%ld, rec_depth=%ld/%ld, " + "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, " + "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld", + (void *) thr, + (long) num_stack_args, + (unsigned long) call_flags, + (long) ((call_flags & DUK_CALL_FLAG_PROTECTED) != 0 ? 1 : 0), + (long) ((call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) != 0 ? 1 : 0), + (long) ((call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) != 0 ? 1 : 0), + (long) need_setjmp, + (long) duk_get_top(ctx), + (long) idx_func, + (long) idx_args, + (long) thr->heap->call_recursion_depth, + (long) thr->heap->call_recursion_limit, + (long) entry_valstack_bottom_index, + (long) entry_callstack_top, + (long) entry_catchstack_top, + (long) entry_call_recursion_depth, + (void *) entry_curr_thread, + (long) entry_thread_state)); + + /* If thr->ptr_curr_pc is set, sync curr_pc to act->pc. Then NULL + * thr->ptr_curr_pc so that it's not accidentally used with an incorrect + * activation when side effects occur. + */ + duk_hthread_sync_and_null_currpc(thr); + + /* XXX: Multiple tv_func lookups are now avoided by making a local + * copy of tv_func. Another approach would be to compute an offset + * for tv_func from valstack bottom and recomputing the tv_func + * pointer quickly as valstack + offset instead of calling duk_get_tval(). + */ + + if (idx_func < 0 || idx_args < 0) { + /* + * Since stack indices are not reliable, we can't do anything useful + * here. Invoke the existing setjmp catcher, or if it doesn't exist, + * call the fatal error handler. + */ + + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + } + + /* + * Setup a setjmp() catchpoint first because even the call setup + * may fail. + */ + + if (!need_setjmp) { + DUK_DDD(DUK_DDDPRINT("don't need a setjmp catchpoint")); + goto handle_call; + } + + old_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr; + thr->heap->lj.jmpbuf_ptr = &our_jmpbuf; + + if (DUK_SETJMP(thr->heap->lj.jmpbuf_ptr->jb) == 0) { + DUK_DDD(DUK_DDDPRINT("setjmp catchpoint setup complete")); + goto handle_call; + } + + /* + * Error during setup, call, or postprocessing of the call. + * The error value is in heap->lj.value1. + * + * Note: any local variables accessed here must have their value + * assigned *before* the setjmp() call, OR they must be declared + * volatile. Otherwise their value is not guaranteed to be correct. + * + * The following are such variables: + * - duk_handle_call() parameters + * - entry_* + * - idx_func + * - idx_args + * + * The very first thing we do is restore the previous setjmp catcher. + * This means that any error in error handling will propagate outwards + * instead of causing a setjmp() re-entry above. The *only* actual + * errors that should happen here are allocation errors. + */ + + DUK_DDD(DUK_DDDPRINT("error caught during protected duk_handle_call(): %!T", + (duk_tval *) &thr->heap->lj.value1)); + + DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW); + DUK_ASSERT(thr->callstack_top >= entry_callstack_top); + DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top); + + /* We don't need to sync back thr->curr_pc here because the + * bytecode executor always has a setjmp catchpoint which + * does that before errors propagate to here. + */ + + /* + * Restore previous setjmp catchpoint + */ + + /* Note: either pointer may be NULL (at entry), so don't assert */ + DUK_DDD(DUK_DDDPRINT("restore jmpbuf_ptr: %p -> %p", + (void *) (thr && thr->heap ? thr->heap->lj.jmpbuf_ptr : NULL), + (void *) old_jmpbuf_ptr)); + + thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr; + + if (!(call_flags & DUK_CALL_FLAG_PROTECTED)) { + /* + * Caller did not request a protected call but a setjmp + * catchpoint was set up to allow cleanup. So, clean up + * and rethrow. + * + * We must restore curr_thread here to ensure that its + * current value doesn't end up pointing to a thread object + * which has been freed. This is now a problem because some + * call sites (namely duk_safe_call()) *first* unwind stacks + * and only then deal with curr_thread. If those call sites + * were fixed, this wouldn't matter here. + * + * Note: this case happens e.g. when heap->curr_thread is + * NULL on entry. + */ + + DUK_DDD(DUK_DDDPRINT("call is not protected -> clean up and rethrow")); + + /* Restore entry thread executor curr_pc stack frame pointer. */ + thr->ptr_curr_pc = entry_ptr_curr_pc; + + DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread); /* may be NULL */ + thr->state = entry_thread_state; + DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) || /* first call */ + (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) || /* other call */ + (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr)); /* current thread */ + + /* XXX: should setjmp catcher be responsible for this instead? */ + thr->heap->call_recursion_depth = entry_call_recursion_depth; + duk_err_longjmp(thr); + DUK_UNREACHABLE(); + } + + duk_hthread_catchstack_unwind(thr, entry_catchstack_top); + duk_hthread_callstack_unwind(thr, entry_callstack_top); + thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; + + /* [ ... func this (crud) errobj ] */ + + /* XXX: is there space? better implementation: write directly over + * 'func' slot to avoid valstack grow issues. + */ + duk_push_tval(ctx, &thr->heap->lj.value1); + + /* [ ... func this (crud) errobj ] */ + + duk_replace(ctx, idx_func); + duk_set_top(ctx, idx_func + 1); + + /* [ ... errobj ] */ + + /* Ensure there is internal valstack spare before we exit; this may + * throw an alloc error. The same guaranteed size must be available + * as before the call. This is not optimal now: we store the valstack + * allocated size during entry; this value may be higher than the + * minimal guarantee for an application. + */ + + (void) duk_valstack_resize_raw((duk_context *) thr, + entry_valstack_end, /* same as during entry */ + DUK_VSRESIZE_FLAG_SHRINK | /* flags */ + DUK_VSRESIZE_FLAG_COMPACT | + DUK_VSRESIZE_FLAG_THROW); + + /* Note: currently a second setjmp restoration is done at the target; + * this is OK, but could be refactored away. + */ + retval = DUK_EXEC_ERROR; + goto shrink_and_finished; + + handle_call: + /* + * Thread state check and book-keeping. + */ + + if (thr == thr->heap->curr_thread) { + /* same thread */ + if (thr->state != DUK_HTHREAD_STATE_RUNNING) { + /* should actually never happen, but check anyway */ + goto thread_state_error; + } + } else { + /* different thread */ + DUK_ASSERT(thr->heap->curr_thread == NULL || + thr->heap->curr_thread->state == DUK_HTHREAD_STATE_RUNNING); + if (thr->state != DUK_HTHREAD_STATE_INACTIVE) { + goto thread_state_error; + } + DUK_HEAP_SWITCH_THREAD(thr->heap, thr); + thr->state = DUK_HTHREAD_STATE_RUNNING; + + /* Note: multiple threads may be simultaneously in the RUNNING + * state, but not in the same "resume chain". + */ + } + + DUK_ASSERT(thr->heap->curr_thread == thr); + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); + + /* + * C call recursion depth check, which provides a reasonable upper + * bound on maximum C stack size (arbitrary C stack growth is only + * possible by recursive handle_call / handle_safe_call calls). + */ + + DUK_ASSERT(thr->heap->call_recursion_depth >= 0); + DUK_ASSERT(thr->heap->call_recursion_depth <= thr->heap->call_recursion_limit); + + if (call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) { + DUK_DD(DUK_DDPRINT("ignoring reclimit for this call (probably an errhandler call)")); + } else { + if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit) { + /* XXX: error message is a bit misleading: we reached a recursion + * limit which is also essentially the same as a C callstack limit + * (except perhaps with some relaxed threading assumptions). + */ + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_C_CALLSTACK_LIMIT); + } + thr->heap->call_recursion_depth++; + } + + /* + * Check the function type, handle bound function chains, and prepare + * parameters for the rest of the call handling. Also figure out the + * effective 'this' binding, which replaces the current value at + * idx_func + 1. + * + * If the target function is a 'bound' one, follow the chain of 'bound' + * functions until a non-bound function is found. During this process, + * bound arguments are 'prepended' to existing ones, and the "this" + * binding is overridden. See E5 Section 15.3.4.5.1. + * + * Lightfunc detection happens here too. Note that lightweight functions + * can be wrapped by (non-lightweight) bound functions so we must resolve + * the bound function chain first. + */ + + func = duk__nonbound_func_lookup(ctx, idx_func, &num_stack_args, &tv_func, call_flags); + DUK_TVAL_SET_TVAL(&tv_func_copy, tv_func); + tv_func = &tv_func_copy; /* local copy to avoid relookups */ + + DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func)); + DUK_ASSERT(func == NULL || (DUK_HOBJECT_IS_COMPILEDFUNCTION(func) || + DUK_HOBJECT_IS_NATIVEFUNCTION(func))); + + duk__coerce_effective_this_binding(thr, func, idx_func + 1); + DUK_DDD(DUK_DDDPRINT("effective 'this' binding is: %!T", + (duk_tval *) duk_get_tval(ctx, idx_func + 1))); + + /* These base values are never used, but if the compiler doesn't know + * that DUK_ERROR() won't return, these are needed to silence warnings. + * On the other hand, scan-build will warn about the values not being + * used, so add a DUK_UNREF. + */ + nargs = 0; DUK_UNREF(nargs); + nregs = 0; DUK_UNREF(nregs); + + if (func == NULL) { + duk_small_uint_t lf_flags; + + DUK_DDD(DUK_DDDPRINT("lightfunc call handling")); + DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv_func)); + lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv_func); + nargs = DUK_LFUNC_FLAGS_GET_NARGS(lf_flags); + if (nargs == DUK_LFUNC_NARGS_VARARGS) { + nargs = -1; /* vararg */ + } + nregs = nargs; + } else if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { + nargs = ((duk_hcompiledfunction *) func)->nargs; + nregs = ((duk_hcompiledfunction *) func)->nregs; + DUK_ASSERT(nregs >= nargs); + } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(func)) { + /* Note: nargs (and nregs) may be negative for a native, + * function, which indicates that the function wants the + * input stack "as is" (i.e. handles "vararg" arguments). + */ + nargs = ((duk_hnativefunction *) func)->nargs; + nregs = nargs; + } else { + /* XXX: this should be an assert */ + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CALLABLE); + } + + /* [ ... func this arg1 ... argN ] */ + + /* + * Setup a preliminary activation. + * + * Don't touch valstack_bottom or valstack_top yet so that Duktape API + * calls work normally. + */ + + duk_hthread_callstack_grow(thr); + + if (thr->callstack_top > 0) { + /* + * Update idx_retval of current activation. + * + * Although it might seem this is not necessary (bytecode executor + * does this for Ecmascript-to-Ecmascript calls; other calls are + * handled here), this turns out to be necessary for handling yield + * and resume. For them, an Ecmascript-to-native call happens, and + * the Ecmascript call's idx_retval must be set for things to work. + */ + + (thr->callstack + thr->callstack_top - 1)->idx_retval = entry_valstack_bottom_index + idx_func; + } + + DUK_ASSERT(thr->callstack_top < thr->callstack_size); + act = thr->callstack + thr->callstack_top; + thr->callstack_top++; + DUK_ASSERT(thr->callstack_top <= thr->callstack_size); + DUK_ASSERT(thr->valstack_top > thr->valstack_bottom); /* at least effective 'this' */ + DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func)); + + act->flags = 0; + if (func == NULL || DUK_HOBJECT_HAS_STRICT(func)) { + act->flags |= DUK_ACT_FLAG_STRICT; + } + if (call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) { + act->flags |= DUK_ACT_FLAG_CONSTRUCT; + /*act->flags |= DUK_ACT_FLAG_PREVENT_YIELD;*/ + } + if (func == NULL || DUK_HOBJECT_IS_NATIVEFUNCTION(func)) { + /*act->flags |= DUK_ACT_FLAG_PREVENT_YIELD;*/ + } + if (call_flags & DUK_CALL_FLAG_DIRECT_EVAL) { + act->flags |= DUK_ACT_FLAG_DIRECT_EVAL; + } + + /* As a first approximation, all calls except Ecmascript-to-Ecmascript + * calls prevent a yield. + */ + act->flags |= DUK_ACT_FLAG_PREVENT_YIELD; + + act->func = func; /* NULL for lightfunc */ + act->var_env = NULL; + act->lex_env = NULL; +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY + act->prev_caller = NULL; +#endif + act->curr_pc = NULL; +#if defined(DUK_USE_DEBUGGER_SUPPORT) + act->prev_line = 0; +#endif + act->idx_bottom = entry_valstack_bottom_index + idx_args; +#if 0 /* topmost activation idx_retval is considered garbage, no need to init */ + act->idx_retval = 0; +#endif + DUK_TVAL_SET_TVAL(&act->tv_func, tv_func); /* borrowed, no refcount */ + + if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) { + /* duk_hthread_callstack_unwind() will decrease this on unwind */ + thr->callstack_preventcount++; + } + + /* XXX: Is this INCREF necessary? 'func' is always a borrowed + * reference reachable through the value stack? If changed, stack + * unwind code also needs to be fixed to match. + */ + DUK_HOBJECT_INCREF_ALLOWNULL(thr, func); /* act->func */ + +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY + if (func) { + duk__update_func_caller_prop(thr, func); + } + act = thr->callstack + thr->callstack_top - 1; +#endif + + /* [... func this arg1 ... argN] */ + + /* + * Environment record creation and 'arguments' object creation. + * Named function expression name binding is handled by the + * compiler; the compiled function's parent env will contain + * the (immutable) binding already. + * + * This handling is now identical for C and Ecmascript functions. + * C functions always have the 'NEWENV' flag set, so their + * environment record initialization is delayed (which is good). + * + * Delayed creation (on demand) is handled in duk_js_var.c. + */ + + DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func)); /* bound function chain has already been resolved */ + + if (func != NULL && !DUK_HOBJECT_HAS_NEWENV(func)) { + /* use existing env (e.g. for non-strict eval); cannot have + * an own 'arguments' object (but can refer to the existing one) + */ + + DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(func)); + + duk__handle_oldenv_for_call(thr, func, act); + + DUK_ASSERT(act->lex_env != NULL); + DUK_ASSERT(act->var_env != NULL); + goto env_done; + } + + DUK_ASSERT(func == NULL || DUK_HOBJECT_HAS_NEWENV(func)); + + if (func == NULL || !DUK_HOBJECT_HAS_CREATEARGS(func)) { + /* no need to create environment record now; leave as NULL */ + DUK_ASSERT(act->lex_env == NULL); + DUK_ASSERT(act->var_env == NULL); + goto env_done; + } + + /* third arg: absolute index (to entire valstack) of idx_bottom of new activation */ + env = duk_create_activation_environment_record(thr, func, act->idx_bottom); + DUK_ASSERT(env != NULL); + + /* [... func this arg1 ... argN envobj] */ + + DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func)); + duk__handle_createargs_for_call(thr, func, env, num_stack_args); + + /* [... func this arg1 ... argN envobj] */ + + act = thr->callstack + thr->callstack_top - 1; + act->lex_env = env; + act->var_env = env; + DUK_HOBJECT_INCREF(thr, env); + DUK_HOBJECT_INCREF(thr, env); /* XXX: incref by count (2) directly */ + duk_pop(ctx); + + env_done: + /* [... func this arg1 ... argN] */ + + /* + * Setup value stack: clamp to 'nargs', fill up to 'nregs' + * + * Value stack may either grow or shrink, depending on the + * number of func registers and the number of actual arguments. + * If nregs >= 0, func wants args clamped to 'nargs'; else it + * wants all args (= 'num_stack_args'). + */ + + duk__adjust_valstack_and_top(thr, + num_stack_args, + idx_args, + nregs, + nargs, + func); + + /* + * Determine call type; then setup activation and call + */ + + if (func != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { + goto ecmascript_call; + } else { + goto native_call; + } + DUK_UNREACHABLE(); + + /* + * Native (C) call + */ + + native_call: + /* + * Shift to new valstack_bottom. + */ + + thr->valstack_bottom = thr->valstack_bottom + idx_args; + /* keep current valstack_top */ + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + DUK_ASSERT(func == NULL || ((duk_hnativefunction *) func)->func != NULL); + + /* [... func this | arg1 ... argN] ('this' must precede new bottom) */ + + /* + * Actual function call and return value check. + * + * Return values: + * 0 success, no return value (default to 'undefined') + * 1 success, one return value on top of stack + * < 0 error, throw a "magic" error + * other invalid + */ + + /* For native calls must be NULL so we don't sync back */ + DUK_ASSERT(thr->ptr_curr_pc == NULL); + + if (func) { + rc = ((duk_hnativefunction *) func)->func((duk_context *) thr); + } else { + duk_c_function funcptr = DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv_func); + rc = funcptr((duk_context *) thr); + } + + if (rc < 0) { + duk_error_throw_from_negative_rc(thr, rc); + DUK_UNREACHABLE(); + } else if (rc > 1) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, "c function returned invalid rc"); + } + DUK_ASSERT(rc == 0 || rc == 1); + + /* + * Unwind stack(s) and shift back to old valstack_bottom. + */ + + DUK_ASSERT(thr->catchstack_top == entry_catchstack_top); + DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1); + +#if 0 /* should be no need to unwind */ + duk_hthread_catchstack_unwind(thr, entry_catchstack_top); +#endif + duk_hthread_callstack_unwind(thr, entry_callstack_top); + + thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; + /* keep current valstack_top */ + + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1); + + /* + * Manipulate value stack so that return value is on top + * (pushing an 'undefined' if necessary). + */ + + /* XXX: should this happen in the callee's activation or after unwinding? */ + if (rc == 0) { + duk_require_stack(ctx, 1); + duk_push_undefined(ctx); + } + /* [... func this (crud) retval] */ + + DUK_DDD(DUK_DDDPRINT("native call retval -> %!T (rc=%ld)", + (duk_tval *) duk_get_tval(ctx, -1), (long) rc)); + + duk_replace(ctx, idx_func); + duk_set_top(ctx, idx_func + 1); + + /* [... retval] */ + + /* Ensure there is internal valstack spare before we exit; this may + * throw an alloc error. The same guaranteed size must be available + * as before the call. This is not optimal now: we store the valstack + * allocated size during entry; this value may be higher than the + * minimal guarantee for an application. + */ + + (void) duk_valstack_resize_raw((duk_context *) thr, + entry_valstack_end, /* same as during entry */ + DUK_VSRESIZE_FLAG_SHRINK | /* flags */ + DUK_VSRESIZE_FLAG_COMPACT | + DUK_VSRESIZE_FLAG_THROW); + + + /* + * Shrink checks and return with success. + */ + + retval = DUK_EXEC_SUCCESS; + goto shrink_and_finished; + + /* + * Ecmascript call + */ + + ecmascript_call: + + /* + * Shift to new valstack_bottom. + */ + + DUK_ASSERT(func != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func)); + act->curr_pc = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) func); + + thr->valstack_bottom = thr->valstack_bottom + idx_args; + /* keep current valstack_top */ + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + + /* [... func this | arg1 ... argN] ('this' must precede new bottom) */ + + /* + * Bytecode executor call. + * + * Execute bytecode, handling any recursive function calls and + * thread resumptions. Returns when execution would return from + * the entry level activation. When the executor returns, a + * single return value is left on the stack top. + * + * The only possible longjmp() is an error (DUK_LJ_TYPE_THROW), + * other types are handled internally by the executor. + * + */ + + /* thr->ptr_curr_pc is set by bytecode executor early on entry */ + DUK_ASSERT(thr->ptr_curr_pc == NULL); + DUK_DDD(DUK_DDDPRINT("entering bytecode execution")); + duk_js_execute_bytecode(thr); + DUK_DDD(DUK_DDDPRINT("returned from bytecode execution")); + + /* + * Unwind stack(s) and shift back to old valstack_bottom. + */ + + DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1); + + duk_hthread_catchstack_unwind(thr, entry_catchstack_top); + duk_hthread_callstack_unwind(thr, entry_callstack_top); + + thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; + /* keep current valstack_top */ + + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1); + + /* + * Manipulate value stack so that return value is on top. + */ + + /* [... func this (crud) retval] */ + + duk_replace(ctx, idx_func); + duk_set_top(ctx, idx_func + 1); + + /* [... retval] */ + + /* Ensure there is internal valstack spare before we exit; this may + * throw an alloc error. The same guaranteed size must be available + * as before the call. This is not optimal now: we store the valstack + * allocated size during entry; this value may be higher than the + * minimal guarantee for an application. + */ + + (void) duk_valstack_resize_raw((duk_context *) thr, + entry_valstack_end, /* same as during entry */ + DUK_VSRESIZE_FLAG_SHRINK | /* flags */ + DUK_VSRESIZE_FLAG_COMPACT | + DUK_VSRESIZE_FLAG_THROW); + + /* + * Shrink checks and return with success. + */ + + retval = DUK_EXEC_SUCCESS; + goto shrink_and_finished; + + shrink_and_finished: +#if defined(DUK_USE_FASTINT) + /* Explicit check for fastint downgrade. */ + { + duk_tval *tv_fi; + tv_fi = duk_get_tval(ctx, -1); + DUK_ASSERT(tv_fi != NULL); + DUK_TVAL_CHKFAST_INPLACE(tv_fi); + } +#endif + + /* these are "soft" shrink checks, whose failures are ignored */ + /* XXX: would be nice if fast path was inlined */ + duk_hthread_catchstack_shrink_check(thr); + duk_hthread_callstack_shrink_check(thr); + goto finished; + + finished: + if (need_setjmp) { + /* Note: either pointer may be NULL (at entry), so don't assert; + * this is now done potentially twice, which is OK + */ + DUK_DDD(DUK_DDDPRINT("restore jmpbuf_ptr: %p -> %p (possibly already done)", + (void *) (thr && thr->heap ? thr->heap->lj.jmpbuf_ptr : NULL), + (void *) old_jmpbuf_ptr)); + thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr; + + /* These are just convenience "wiping" of state */ + thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN; + thr->heap->lj.iserror = 0; + + /* Side effects should not be an issue here: tv_tmp is local and + * thr->heap (and thr->heap->lj) have a stable pointer. Finalizer + * runs etc capture even out-of-memory errors so nothing should + * throw here. + */ + DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); + DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value1); + DUK_TVAL_DECREF(thr, &tv_tmp); + + DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2); + DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value2); + DUK_TVAL_DECREF(thr, &tv_tmp); + + DUK_DDD(DUK_DDDPRINT("setjmp catchpoint torn down")); + } + + /* Restore entry thread executor curr_pc stack frame pointer. */ + thr->ptr_curr_pc = entry_ptr_curr_pc; + + DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread); /* may be NULL */ + thr->state = (duk_uint8_t) entry_thread_state; + + DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) || /* first call */ + (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) || /* other call */ + (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr)); /* current thread */ + + thr->heap->call_recursion_depth = entry_call_recursion_depth; + + /* If the debugger is active we need to force an interrupt so that + * debugger breakpoints are rechecked. This is important for function + * calls caused by side effects (e.g. when doing a DUK_OP_GETPROP), see + * GH-303. Only needed for success path, error path always causes a + * breakpoint recheck in the executor. It would be enough to set this + * only when returning to an Ecmascript activation, but setting the flag + * on every return should have no ill effect. + */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) + if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) { + DUK_DD(DUK_DDPRINT("returning to ecmascript activation with debugger enabled, force interrupt")); + DUK_ASSERT(thr->interrupt_counter <= thr->interrupt_init); + thr->interrupt_init -= thr->interrupt_counter; + thr->interrupt_counter = 0; + thr->heap->dbg_force_restart = 1; + } +#endif + +#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) + duk__interrupt_fixup(thr, entry_curr_thread); +#endif + + return retval; + + thread_state_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for call (%ld)", (long) thr->state); + DUK_UNREACHABLE(); + return DUK_EXEC_ERROR; /* never executed */ +} + +/* + * Manipulate value stack so that exactly 'num_stack_rets' return + * values are at 'idx_retbase' in every case, assuming there are + * 'rc' return values on top of stack. + * + * This is a bit tricky, because the called C function operates in + * the same activation record and may have e.g. popped the stack + * empty (below idx_retbase). + */ + +DUK_LOCAL void duk__safe_call_adjust_valstack(duk_hthread *thr, duk_idx_t idx_retbase, duk_idx_t num_stack_rets, duk_idx_t num_actual_rets) { + duk_context *ctx = (duk_context *) thr; + duk_idx_t idx_rcbase; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(idx_retbase >= 0); + DUK_ASSERT(num_stack_rets >= 0); + DUK_ASSERT(num_actual_rets >= 0); + + idx_rcbase = duk_get_top(ctx) - num_actual_rets; /* base of known return values */ + + DUK_DDD(DUK_DDDPRINT("adjust valstack after func call: " + "num_stack_rets=%ld, num_actual_rets=%ld, stack_top=%ld, idx_retbase=%ld, idx_rcbase=%ld", + (long) num_stack_rets, (long) num_actual_rets, (long) duk_get_top(ctx), + (long) idx_retbase, (long) idx_rcbase)); + + DUK_ASSERT(idx_rcbase >= 0); /* caller must check */ + + /* ensure space for final configuration (idx_retbase + num_stack_rets) and + * intermediate configurations + */ + duk_require_stack_top(ctx, + (idx_rcbase > idx_retbase ? idx_rcbase : idx_retbase) + + num_stack_rets); + + /* chop extra retvals away / extend with undefined */ + duk_set_top(ctx, idx_rcbase + num_stack_rets); + + if (idx_rcbase >= idx_retbase) { + duk_idx_t count = idx_rcbase - idx_retbase; + duk_idx_t i; + + DUK_DDD(DUK_DDDPRINT("elements at/after idx_retbase have enough to cover func retvals " + "(idx_retbase=%ld, idx_rcbase=%ld)", (long) idx_retbase, (long) idx_rcbase)); + + /* nuke values at idx_retbase to get the first retval (initially + * at idx_rcbase) to idx_retbase + */ + + DUK_ASSERT(count >= 0); + + for (i = 0; i < count; i++) { + /* XXX: inefficient; block remove primitive */ + duk_remove(ctx, idx_retbase); + } + } else { + duk_idx_t count = idx_retbase - idx_rcbase; + duk_idx_t i; + + DUK_DDD(DUK_DDDPRINT("not enough elements at/after idx_retbase to cover func retvals " + "(idx_retbase=%ld, idx_rcbase=%ld)", (long) idx_retbase, (long) idx_rcbase)); + + /* insert 'undefined' values at idx_rcbase to get the + * return values to idx_retbase + */ + + DUK_ASSERT(count > 0); + + for (i = 0; i < count; i++) { + /* XXX: inefficient; block insert primitive */ + duk_push_undefined(ctx); + duk_insert(ctx, idx_rcbase); + } + } +} + +/* + * Make a "C protected call" within the current activation. + * + * The allowed thread states for making a call are the same as for + * duk_handle_call(). + * + * Note that like duk_handle_call(), even if this call is protected, + * there are a few situations where the current (pre-entry) setjmp + * catcher (or a fatal error handler if no such catcher exists) is + * invoked: + * + * - Blatant API argument errors (e.g. num_stack_args is invalid, + * so we can't form a reasonable return stack) + * + * - Errors during error handling, e.g. failure to reallocate + * space in the value stack due to an alloc error + * + * Such errors propagate outwards, ultimately to the fatal error + * handler if nothing else. + */ + +/* XXX: bump preventcount by one for the duration of this call? */ + +DUK_INTERNAL +duk_int_t duk_handle_safe_call(duk_hthread *thr, + duk_safe_call_function func, + duk_idx_t num_stack_args, + duk_idx_t num_stack_rets) { + duk_context *ctx = (duk_context *) thr; + duk_size_t entry_valstack_bottom_index; + duk_size_t entry_callstack_top; + duk_size_t entry_catchstack_top; + duk_int_t entry_call_recursion_depth; + duk_hthread *entry_curr_thread; + duk_uint_fast8_t entry_thread_state; + duk_instr_t **entry_ptr_curr_pc; + duk_jmpbuf *old_jmpbuf_ptr = NULL; + duk_jmpbuf our_jmpbuf; + duk_tval tv_tmp; + duk_idx_t idx_retbase; + duk_int_t retval; + duk_ret_t rc; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + + /* Note: careful with indices like '-x'; if 'x' is zero, it refers to bottom */ + entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack); + entry_callstack_top = thr->callstack_top; + entry_catchstack_top = thr->catchstack_top; + entry_call_recursion_depth = thr->heap->call_recursion_depth; + entry_curr_thread = thr->heap->curr_thread; /* Note: may be NULL if first call */ + entry_thread_state = thr->state; + entry_ptr_curr_pc = thr->ptr_curr_pc; /* may be NULL */ + idx_retbase = duk_get_top(ctx) - num_stack_args; /* Note: not a valid stack index if num_stack_args == 0 */ + + /* Note: cannot portably debug print a function pointer, hence 'func' not printed! */ + DUK_DD(DUK_DDPRINT("duk_handle_safe_call: thr=%p, num_stack_args=%ld, num_stack_rets=%ld, " + "valstack_top=%ld, idx_retbase=%ld, rec_depth=%ld/%ld, " + "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, " + "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld", + (void *) thr, + (long) num_stack_args, + (long) num_stack_rets, + (long) duk_get_top(ctx), + (long) idx_retbase, + (long) thr->heap->call_recursion_depth, + (long) thr->heap->call_recursion_limit, + (long) entry_valstack_bottom_index, + (long) entry_callstack_top, + (long) entry_catchstack_top, + (long) entry_call_recursion_depth, + (void *) entry_curr_thread, + (long) entry_thread_state)); + + if (idx_retbase < 0) { + /* + * Since stack indices are not reliable, we can't do anything useful + * here. Invoke the existing setjmp catcher, or if it doesn't exist, + * call the fatal error handler. + */ + + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + } + + /* setjmp catchpoint setup */ + + old_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr; + thr->heap->lj.jmpbuf_ptr = &our_jmpbuf; + + if (DUK_SETJMP(thr->heap->lj.jmpbuf_ptr->jb) == 0) { + goto handle_call; + } + + /* + * Error during call. The error value is at heap->lj.value1. + * + * Careful with variable accesses here; must be assigned to before + * setjmp() or be declared volatile. See duk_handle_call(). + * + * The following are such variables: + * - duk_handle_safe_call() parameters + * - entry_* + * - idx_retbase + * + * The very first thing we do is restore the previous setjmp catcher. + * This means that any error in error handling will propagate outwards + * instead of causing a setjmp() re-entry above. The *only* actual + * errors that should happen here are allocation errors. + */ + + DUK_DDD(DUK_DDDPRINT("error caught during protected duk_handle_safe_call()")); + + DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW); + DUK_ASSERT(thr->callstack_top >= entry_callstack_top); + DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top); + + /* Note: either pointer may be NULL (at entry), so don't assert; + * these are now restored twice which is OK. + */ + thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr; + + duk_hthread_catchstack_unwind(thr, entry_catchstack_top); + duk_hthread_callstack_unwind(thr, entry_callstack_top); + thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; + + /* [ ... | (crud) ] */ + + /* XXX: space in valstack? see discussion in duk_handle_call. */ + duk_push_tval(ctx, &thr->heap->lj.value1); + + /* [ ... | (crud) errobj ] */ + + DUK_ASSERT(duk_get_top(ctx) >= 1); /* at least errobj must be on stack */ + + /* check that the valstack has space for the final amount and any + * intermediate space needed; this is unoptimal but should be safe + */ + duk_require_stack_top(ctx, idx_retbase + num_stack_rets); /* final configuration */ + duk_require_stack(ctx, num_stack_rets); + + duk__safe_call_adjust_valstack(thr, idx_retbase, num_stack_rets, 1); /* 1 = num actual 'return values' */ + + /* [ ... | ] or [ ... | errobj (M * undefined)] where M = num_stack_rets - 1 */ + + retval = DUK_EXEC_ERROR; + goto shrink_and_finished; + + /* + * Handle call (inside setjmp) + */ + + handle_call: + + DUK_DDD(DUK_DDDPRINT("safe_call setjmp catchpoint setup complete")); + + /* + * Thread state check and book-keeping. + */ + + if (thr == thr->heap->curr_thread) { + /* same thread */ + if (thr->state != DUK_HTHREAD_STATE_RUNNING) { + /* should actually never happen, but check anyway */ + goto thread_state_error; + } + } else { + /* different thread */ + DUK_ASSERT(thr->heap->curr_thread == NULL || + thr->heap->curr_thread->state == DUK_HTHREAD_STATE_RUNNING); + if (thr->state != DUK_HTHREAD_STATE_INACTIVE) { + goto thread_state_error; + } + DUK_HEAP_SWITCH_THREAD(thr->heap, thr); + thr->state = DUK_HTHREAD_STATE_RUNNING; + + /* Note: multiple threads may be simultaneously in the RUNNING + * state, but not in the same "resume chain". + */ + } + + DUK_ASSERT(thr->heap->curr_thread == thr); + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); + + /* + * Recursion limit check. + * + * Note: there is no need for an "ignore recursion limit" flag + * for duk_handle_safe_call now. + */ + + DUK_ASSERT(thr->heap->call_recursion_depth >= 0); + DUK_ASSERT(thr->heap->call_recursion_depth <= thr->heap->call_recursion_limit); + if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit) { + /* XXX: error message is a bit misleading: we reached a recursion + * limit which is also essentially the same as a C callstack limit + * (except perhaps with some relaxed threading assumptions). + */ + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_C_CALLSTACK_LIMIT); + } + thr->heap->call_recursion_depth++; + + /* + * Valstack spare check + */ + + duk_require_stack(ctx, 0); /* internal spare */ + + /* + * Make the C call + */ + + rc = func(ctx); + + DUK_DDD(DUK_DDDPRINT("safe_call, func rc=%ld", (long) rc)); + + /* + * Valstack manipulation for results + */ + + /* we're running inside the caller's activation, so no change in call/catch stack or valstack bottom */ + DUK_ASSERT(thr->callstack_top == entry_callstack_top); + DUK_ASSERT(thr->catchstack_top == entry_catchstack_top); + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT((duk_size_t) (thr->valstack_bottom - thr->valstack) == entry_valstack_bottom_index); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + + if (rc < 0) { + duk_error_throw_from_negative_rc(thr, rc); + } + DUK_ASSERT(rc >= 0); + + if (duk_get_top(ctx) < rc) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, "not enough stack values for safe_call rc"); + } + + duk__safe_call_adjust_valstack(thr, idx_retbase, num_stack_rets, rc); + + /* Note: no need from callstack / catchstack shrink check */ + retval = DUK_EXEC_SUCCESS; + goto finished; + + shrink_and_finished: + /* these are "soft" shrink checks, whose failures are ignored */ + /* XXX: would be nice if fast path was inlined */ + duk_hthread_catchstack_shrink_check(thr); + duk_hthread_callstack_shrink_check(thr); + goto finished; + + finished: + /* Note: either pointer may be NULL (at entry), so don't assert */ + thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr; + + /* These are just convenience "wiping" of state */ + thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN; + thr->heap->lj.iserror = 0; + + /* Side effects should not be an issue here: tv_tmp is local and + * thr->heap (and thr->heap->lj) have a stable pointer. Finalizer + * runs etc capture even out-of-memory errors so nothing should + * throw here. + */ + DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); + DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value1); + DUK_TVAL_DECREF(thr, &tv_tmp); + + DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2); + DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value2); + DUK_TVAL_DECREF(thr, &tv_tmp); + + DUK_DDD(DUK_DDDPRINT("setjmp catchpoint torn down")); + + /* Restore entry thread executor curr_pc stack frame pointer. */ + thr->ptr_curr_pc = entry_ptr_curr_pc; + + /* XXX: because we unwind stacks above, thr->heap->curr_thread is at + * risk of pointing to an already freed thread. This was indeed the + * case in test-bug-multithread-valgrind.c, until duk_handle_call() + * was fixed to restore thr->heap->curr_thread before rethrowing an + * uncaught error. + */ + DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread); /* may be NULL */ + thr->state = (duk_uint8_t) entry_thread_state; + + DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) || /* first call */ + (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) || /* other call */ + (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr)); /* current thread */ + + thr->heap->call_recursion_depth = entry_call_recursion_depth; + + /* stack discipline consistency check */ + DUK_ASSERT(duk_get_top(ctx) == idx_retbase + num_stack_rets); + + /* A debugger forced interrupt check is not needed here, as + * problematic safe calls are not caused by side effects. + */ + +#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) + duk__interrupt_fixup(thr, entry_curr_thread); +#endif + + return retval; + + thread_state_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for safe_call (%ld)", (long) thr->state); + DUK_UNREACHABLE(); + return DUK_EXEC_ERROR; /* never executed */ +} + +/* + * Helper for handling an Ecmascript-to-Ecmascript call or an Ecmascript + * function (initial) Duktape.Thread.resume(). + * + * Compared to normal calls handled by duk_handle_call(), there are a + * bunch of differences: + * + * - the call is never protected + * - there is no C recursion depth increase (hence an "ignore recursion + * limit" flag is not applicable) + * - instead of making the call, this helper just performs the thread + * setup and returns; the bytecode executor then restarts execution + * internally + * - ecmascript functions are never 'vararg' functions (they access + * varargs through the 'arguments' object) + * + * The callstack of the target contains an earlier Ecmascript call in case + * of an Ecmascript-to-Ecmascript call (whose idx_retval is updated), or + * is empty in case of an initial Duktape.Thread.resume(). + * + * The first thing to do here is to figure out whether an ecma-to-ecma + * call is actually possible. It's not always the case if the target is + * a bound function; the final function may be native. In that case, + * return an error so caller can fall back to a normal call path. + */ + +DUK_INTERNAL +duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, + duk_idx_t num_stack_args, + duk_small_uint_t call_flags) { + duk_context *ctx = (duk_context *) thr; + duk_size_t entry_valstack_bottom_index; + duk_idx_t idx_func; /* valstack index of 'func' and retval (relative to entry valstack_bottom) */ + duk_idx_t idx_args; /* valstack index of start of args (arg1) (relative to entry valstack_bottom) */ + duk_idx_t nargs; /* # argument registers target function wants (< 0 => never for ecma calls) */ + duk_idx_t nregs; /* # total registers target function wants on entry (< 0 => never for ecma calls) */ + duk_hobject *func; /* 'func' on stack (borrowed reference) */ + duk_tval *tv_func; /* duk_tval ptr for 'func' on stack (borrowed reference) */ + duk_activation *act; + duk_hobject *env; + duk_bool_t use_tailcall; + duk_instr_t **entry_ptr_curr_pc; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(!((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 && (call_flags & DUK_CALL_FLAG_IS_TAILCALL) != 0)); + + /* XXX: assume these? */ + DUK_ASSERT(thr->valstack != NULL); + DUK_ASSERT(thr->callstack != NULL); + DUK_ASSERT(thr->catchstack != NULL); + + /* no need to handle thread state book-keeping here */ + DUK_ASSERT((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 || + (thr->state == DUK_HTHREAD_STATE_RUNNING && + thr->heap->curr_thread == thr)); + + /* If thr->ptr_curr_pc is set, sync curr_pc to act->pc. Then NULL + * thr->ptr_curr_pc so that it's not accidentally used with an incorrect + * activation when side effects occur. If we end up not making the + * call we must restore the value. + */ + entry_ptr_curr_pc = thr->ptr_curr_pc; + duk_hthread_sync_and_null_currpc(thr); + + /* if a tail call: + * - an Ecmascript activation must be on top of the callstack + * - there cannot be any active catchstack entries + */ +#ifdef DUK_USE_ASSERTIONS + if (call_flags & DUK_CALL_FLAG_IS_TAILCALL) { + duk_size_t our_callstack_index; + duk_size_t i; + + DUK_ASSERT(thr->callstack_top >= 1); + our_callstack_index = thr->callstack_top - 1; + DUK_ASSERT_DISABLE(our_callstack_index >= 0); + DUK_ASSERT(our_callstack_index < thr->callstack_size); + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + our_callstack_index) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + our_callstack_index))); + + /* No entry in the catchstack which would actually catch a + * throw can refer to the callstack entry being reused. + * There *can* be catchstack entries referring to the current + * callstack entry as long as they don't catch (e.g. label sites). + */ + + for (i = 0; i < thr->catchstack_top; i++) { + DUK_ASSERT(thr->catchstack[i].callstack_index < our_callstack_index || /* refer to callstack entries below current */ + DUK_CAT_GET_TYPE(thr->catchstack + i) == DUK_CAT_TYPE_LABEL); /* or a non-catching entry */ + } + } +#endif /* DUK_USE_ASSERTIONS */ + + entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack); + idx_func = duk_normalize_index(thr, -num_stack_args - 2); + idx_args = idx_func + 2; + + DUK_DD(DUK_DDPRINT("handle_ecma_call_setup: thr=%p, " + "num_stack_args=%ld, call_flags=0x%08lx (resume=%ld, tailcall=%ld), " + "idx_func=%ld, idx_args=%ld, entry_valstack_bottom_index=%ld", + (void *) thr, + (long) num_stack_args, + (unsigned long) call_flags, + (long) ((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 ? 1 : 0), + (long) ((call_flags & DUK_CALL_FLAG_IS_TAILCALL) != 0 ? 1 : 0), + (long) idx_func, + (long) idx_args, + (long) entry_valstack_bottom_index)); + + if (idx_func < 0 || idx_args < 0) { + /* XXX: assert? compiler is responsible for this never happening */ + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + } + + /* + * Check the function type, handle bound function chains, and prepare + * parameters for the rest of the call handling. Also figure out the + * effective 'this' binding, which replaces the current value at + * idx_func + 1. + * + * If the target function is a 'bound' one, follow the chain of 'bound' + * functions until a non-bound function is found. During this process, + * bound arguments are 'prepended' to existing ones, and the "this" + * binding is overridden. See E5 Section 15.3.4.5.1. + * + * If the final target function cannot be handled by an ecma-to-ecma + * call, return to the caller with a return value indicating this case. + * The bound chain is resolved and the caller can resume with a plain + * function call. + */ + + func = duk__nonbound_func_lookup(ctx, idx_func, &num_stack_args, &tv_func, call_flags); + if (func == NULL || !DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { + DUK_DDD(DUK_DDDPRINT("final target is a lightfunc/nativefunc, cannot do ecma-to-ecma call")); + thr->ptr_curr_pc = entry_ptr_curr_pc; + return 0; + } + /* XXX: tv_func is not actually needed */ + + DUK_ASSERT(func != NULL); + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func)); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(func)); + + duk__coerce_effective_this_binding(thr, func, idx_func + 1); + DUK_DDD(DUK_DDDPRINT("effective 'this' binding is: %!T", + duk_get_tval(ctx, idx_func + 1))); + + nargs = ((duk_hcompiledfunction *) func)->nargs; + nregs = ((duk_hcompiledfunction *) func)->nregs; + DUK_ASSERT(nregs >= nargs); + + /* [ ... func this arg1 ... argN ] */ + + /* + * Preliminary activation record and valstack manipulation. + * The concrete actions depend on whether the we're dealing + * with a tail call (reuse an existing activation), a resume, + * or a normal call. + * + * The basic actions, in varying order, are: + * + * - Check stack size for call handling + * - Grow call stack if necessary (non-tail-calls) + * - Update current activation (idx_retval) if necessary + * (non-tail, non-resume calls) + * - Move start of args (idx_args) to valstack bottom + * (tail calls) + * + * Don't touch valstack_bottom or valstack_top yet so that Duktape API + * calls work normally. + */ + + /* XXX: some overlapping code; cleanup */ + use_tailcall = call_flags & DUK_CALL_FLAG_IS_TAILCALL; +#if !defined(DUK_USE_TAILCALL) + DUK_ASSERT(use_tailcall == 0); /* compiler ensures this */ +#endif + if (use_tailcall) { + /* tailcall cannot be flagged to resume calls, and a + * previous frame must exist + */ + DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT((call_flags & DUK_CALL_FLAG_IS_RESUME) == 0); + + act = thr->callstack + thr->callstack_top - 1; + if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) { + /* See: test-bug-tailcall-preventyield-assert.c. */ + DUK_DDD(DUK_DDDPRINT("tail call prevented by current activation having DUK_ACT_FLAG_PREVENTYIELD")); + use_tailcall = 0; + } else if (DUK_HOBJECT_HAS_NOTAIL(func)) { + DUK_D(DUK_DPRINT("tail call prevented by function having a notail flag")); + use_tailcall = 0; + } + } + + if (use_tailcall) { + duk_tval *tv1, *tv2; + duk_tval tv_tmp; + duk_size_t cs_index; + duk_int_t i_stk; /* must be signed for loop structure */ + duk_idx_t i_arg; + + /* + * Tailcall handling + * + * Although the callstack entry is reused, we need to explicitly unwind + * the current activation (or simulate an unwind). In particular, the + * current activation must be closed, otherwise something like + * test-bug-reduce-judofyr.js results. Also catchstack needs be unwound + * because there may be non-error-catching label entries in valid tail calls. + */ + + DUK_DDD(DUK_DDDPRINT("is tail call, reusing activation at callstack top, at index %ld", + (long) (thr->callstack_top - 1))); + + /* 'act' already set above */ + + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func)); + DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(func)); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func)); + DUK_ASSERT((act->flags & DUK_ACT_FLAG_PREVENT_YIELD) == 0); + + /* Unwind catchstack entries referring to the callstack entry we're reusing */ + cs_index = thr->callstack_top - 1; + DUK_ASSERT(thr->catchstack_top <= DUK_INT_MAX); /* catchstack limits */ + for (i_stk = (duk_int_t) (thr->catchstack_top - 1); i_stk >= 0; i_stk--) { + duk_catcher *cat = thr->catchstack + i_stk; + if (cat->callstack_index != cs_index) { + /* 'i' is the first entry we'll keep */ + break; + } + } + duk_hthread_catchstack_unwind(thr, i_stk + 1); + + /* Unwind the topmost callstack entry before reusing it */ + DUK_ASSERT(thr->callstack_top > 0); + duk_hthread_callstack_unwind(thr, thr->callstack_top - 1); + + /* Then reuse the unwound activation; callstack was not shrunk so there is always space */ + thr->callstack_top++; + DUK_ASSERT(thr->callstack_top <= thr->callstack_size); + act = thr->callstack + thr->callstack_top - 1; + + /* Start filling in the activation */ + act->func = func; /* don't want an intermediate exposed state with func == NULL */ +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY + act->prev_caller = NULL; +#endif + DUK_ASSERT(func != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func)); + /* don't want an intermediate exposed state with invalid pc */ + act->curr_pc = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) func); +#if defined(DUK_USE_DEBUGGER_SUPPORT) + act->prev_line = 0; +#endif + DUK_TVAL_SET_OBJECT(&act->tv_func, func); /* borrowed, no refcount */ +#ifdef DUK_USE_REFERENCE_COUNTING + DUK_HOBJECT_INCREF(thr, func); + act = thr->callstack + thr->callstack_top - 1; /* side effects (currently none though) */ +#endif + +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +#ifdef DUK_USE_TAILCALL +#error incorrect options: tail calls enabled with function caller property +#endif + /* XXX: this doesn't actually work properly for tail calls, so + * tail calls are disabled when DUK_USE_NONSTD_FUNC_CALLER_PROPERTY + * is in use. + */ + duk__update_func_caller_prop(thr, func); + act = thr->callstack + thr->callstack_top - 1; +#endif + + act->flags = (DUK_HOBJECT_HAS_STRICT(func) ? + DUK_ACT_FLAG_STRICT | DUK_ACT_FLAG_TAILCALLED : + DUK_ACT_FLAG_TAILCALLED); + + DUK_ASSERT(DUK_ACT_GET_FUNC(act) == func); /* already updated */ + DUK_ASSERT(act->var_env == NULL); /* already NULLed (by unwind) */ + DUK_ASSERT(act->lex_env == NULL); /* already NULLed (by unwind) */ + act->idx_bottom = entry_valstack_bottom_index; /* tail call -> reuse current "frame" */ + DUK_ASSERT(nregs >= 0); +#if 0 /* topmost activation idx_retval is considered garbage, no need to init */ + act->idx_retval = 0; +#endif + + /* + * Manipulate valstack so that args are on the current bottom and the + * previous caller's 'this' binding (which is the value preceding the + * current bottom) is replaced with the new 'this' binding: + * + * [ ... this_old | (crud) func this_new arg1 ... argN ] + * --> [ ... this_new | arg1 ... argN ] + * + * For tail calling to work properly, the valstack bottom must not grow + * here; otherwise crud would accumulate on the valstack. + */ + + tv1 = thr->valstack_bottom - 1; + tv2 = thr->valstack_bottom + idx_func + 1; + DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top); /* tv1 is -below- valstack_bottom */ + DUK_ASSERT(tv2 >= thr->valstack_bottom && tv2 < thr->valstack_top); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, tv2); + DUK_TVAL_INCREF(thr, tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + for (i_arg = 0; i_arg < idx_args; i_arg++) { + /* XXX: block removal API primitive */ + /* Note: 'func' is popped from valstack here, but it is + * already reachable from the activation. + */ + duk_remove(ctx, 0); + } + idx_func = 0; DUK_UNREF(idx_func); /* really 'not applicable' anymore, should not be referenced after this */ + idx_args = 0; + + /* [ ... this_new | arg1 ... argN ] */ + } else { + DUK_DDD(DUK_DDDPRINT("not a tail call, pushing a new activation to callstack, to index %ld", + (long) (thr->callstack_top))); + + duk_hthread_callstack_grow(thr); + + if (call_flags & DUK_CALL_FLAG_IS_RESUME) { + DUK_DDD(DUK_DDDPRINT("is resume -> no update to current activation (may not even exist)")); + } else { + DUK_DDD(DUK_DDDPRINT("update to current activation idx_retval")); + DUK_ASSERT(thr->callstack_top < thr->callstack_size); + DUK_ASSERT(thr->callstack_top >= 1); + act = thr->callstack + thr->callstack_top - 1; + DUK_ASSERT(DUK_ACT_GET_FUNC(act) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(act))); + act->idx_retval = entry_valstack_bottom_index + idx_func; + } + + DUK_ASSERT(thr->callstack_top < thr->callstack_size); + act = thr->callstack + thr->callstack_top; + thr->callstack_top++; + DUK_ASSERT(thr->callstack_top <= thr->callstack_size); + + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func)); + DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(func)); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func)); + + act->flags = (DUK_HOBJECT_HAS_STRICT(func) ? + DUK_ACT_FLAG_STRICT : + 0); + act->func = func; + act->var_env = NULL; + act->lex_env = NULL; +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY + act->prev_caller = NULL; +#endif + DUK_ASSERT(func != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func)); + act->curr_pc = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) func); +#if defined(DUK_USE_DEBUGGER_SUPPORT) + act->prev_line = 0; +#endif + act->idx_bottom = entry_valstack_bottom_index + idx_args; + DUK_ASSERT(nregs >= 0); +#if 0 /* topmost activation idx_retval is considered garbage, no need to init */ + act->idx_retval = 0; +#endif + DUK_TVAL_SET_OBJECT(&act->tv_func, func); /* borrowed, no refcount */ + + DUK_HOBJECT_INCREF(thr, func); /* act->func */ + +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY + duk__update_func_caller_prop(thr, func); + act = thr->callstack + thr->callstack_top - 1; +#endif + } + + /* [... func this arg1 ... argN] (not tail call) + * [this | arg1 ... argN] (tail call) + * + * idx_args updated to match + */ + + /* + * Environment record creation and 'arguments' object creation. + * Named function expression name binding is handled by the + * compiler; the compiled function's parent env will contain + * the (immutable) binding already. + * + * Delayed creation (on demand) is handled in duk_js_var.c. + */ + + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func)); /* bound function chain has already been resolved */ + + if (!DUK_HOBJECT_HAS_NEWENV(func)) { + /* use existing env (e.g. for non-strict eval); cannot have + * an own 'arguments' object (but can refer to the existing one) + */ + + duk__handle_oldenv_for_call(thr, func, act); + + DUK_ASSERT(act->lex_env != NULL); + DUK_ASSERT(act->var_env != NULL); + goto env_done; + } + + DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func)); + + if (!DUK_HOBJECT_HAS_CREATEARGS(func)) { + /* no need to create environment record now; leave as NULL */ + DUK_ASSERT(act->lex_env == NULL); + DUK_ASSERT(act->var_env == NULL); + goto env_done; + } + + /* third arg: absolute index (to entire valstack) of idx_bottom of new activation */ + env = duk_create_activation_environment_record(thr, func, act->idx_bottom); + DUK_ASSERT(env != NULL); + + /* [... arg1 ... argN envobj] */ + + /* original input stack before nargs/nregs handling must be + * intact for 'arguments' object + */ + DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func)); + duk__handle_createargs_for_call(thr, func, env, num_stack_args); + + /* [... arg1 ... argN envobj] */ + + act = thr->callstack + thr->callstack_top - 1; + act->lex_env = env; + act->var_env = env; + DUK_HOBJECT_INCREF(thr, act->lex_env); + DUK_HOBJECT_INCREF(thr, act->var_env); + duk_pop(ctx); + + env_done: + /* [... arg1 ... argN] */ + + /* + * Setup value stack: clamp to 'nargs', fill up to 'nregs' + */ + + duk__adjust_valstack_and_top(thr, + num_stack_args, + idx_args, + nregs, + nargs, + func); + + /* + * Shift to new valstack_bottom. + */ + + thr->valstack_bottom = thr->valstack_bottom + idx_args; + /* keep current valstack_top */ + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + + /* + * Return to bytecode executor, which will resume execution from + * the topmost activation. + */ + + return 1; +} +#line 1 "duk_js_compiler.c" +/* + * Ecmascript compiler. + * + * Parses an input string and generates a function template result. + * Compilation may happen in multiple contexts (global code, eval + * code, function code). + * + * The parser uses a traditional top-down recursive parsing for the + * statement level, and an operator precedence based top-down approach + * for the expression level. The attempt is to minimize the C stack + * depth. Bytecode is generated directly without an intermediate + * representation (tree), at the cost of needing two passes over each + * function. + * + * The top-down recursive parser functions are named "duk__parse_XXX". + * + * Recursion limits are in key functions to prevent arbitrary C recursion: + * function body parsing, statement parsing, and expression parsing. + * + * See doc/compiler.rst for discussion on the design. + * + * A few typing notes: + * + * - duk_regconst_t: unsigned, no marker value for "none" + * - duk_reg_t: signed, < 0 = none + * - PC values: duk_int_t, negative values used as markers + */ + +/* include removed: duk_internal.h */ + +/* if highest bit of a register number is set, it refers to a constant instead */ +#define DUK__CONST_MARKER DUK_JS_CONST_MARKER + +/* for array and object literals */ +#define DUK__MAX_ARRAY_INIT_VALUES 20 +#define DUK__MAX_OBJECT_INIT_PAIRS 10 + +/* XXX: hack, remove when const lookup is not O(n) */ +#define DUK__GETCONST_MAX_CONSTS_CHECK 256 + +/* These limits are based on bytecode limits. Max temps is limited + * by duk_hcompiledfunction nargs/nregs fields being 16 bits. + */ +#define DUK__MAX_CONSTS DUK_BC_BC_MAX +#define DUK__MAX_FUNCS DUK_BC_BC_MAX +#define DUK__MAX_TEMPS 0xffffL + +/* Initial bytecode size allocation. */ +#define DUK__BC_INITIAL_INSTS 256 + +#define DUK__RECURSION_INCREASE(comp_ctx,thr) do { \ + DUK_DDD(DUK_DDDPRINT("RECURSION INCREASE: %s:%ld", (const char *) DUK_FILE_MACRO, (long) DUK_LINE_MACRO)); \ + duk__recursion_increase((comp_ctx)); \ + } while (0) + +#define DUK__RECURSION_DECREASE(comp_ctx,thr) do { \ + DUK_DDD(DUK_DDDPRINT("RECURSION DECREASE: %s:%ld", (const char *) DUK_FILE_MACRO, (long) DUK_LINE_MACRO)); \ + duk__recursion_decrease((comp_ctx)); \ + } while (0) + +/* Value stack slot limits: these are quite approximate right now, and + * because they overlap in control flow, some could be eliminated. + */ +#define DUK__COMPILE_ENTRY_SLOTS 8 +#define DUK__FUNCTION_INIT_REQUIRE_SLOTS 16 +#define DUK__FUNCTION_BODY_REQUIRE_SLOTS 16 +#define DUK__PARSE_STATEMENTS_SLOTS 16 +#define DUK__PARSE_EXPR_SLOTS 16 + +/* Temporary structure used to pass a stack allocated region through + * duk_safe_call(). + */ +typedef struct { + duk_small_uint_t flags; + duk_compiler_ctx comp_ctx_alloc; + duk_lexer_point lex_pt_alloc; +} duk__compiler_stkstate; + +/* + * Prototypes + */ + +/* lexing */ +DUK_LOCAL_DECL void duk__advance_helper(duk_compiler_ctx *comp_ctx, duk_small_int_t expect); +DUK_LOCAL_DECL void duk__advance_expect(duk_compiler_ctx *comp_ctx, duk_small_int_t expect); +DUK_LOCAL_DECL void duk__advance(duk_compiler_ctx *ctx); + +/* function helpers */ +DUK_LOCAL_DECL void duk__init_func_valstack_slots(duk_compiler_ctx *comp_ctx); +DUK_LOCAL_DECL void duk__reset_func_for_pass2(duk_compiler_ctx *comp_ctx); +DUK_LOCAL_DECL void duk__init_varmap_and_prologue_for_pass2(duk_compiler_ctx *comp_ctx, duk_reg_t *out_stmt_value_reg); +DUK_LOCAL_DECL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_bool_t force_no_namebind); +DUK_LOCAL_DECL duk_int_t duk__cleanup_varmap(duk_compiler_ctx *comp_ctx); + +/* code emission */ +DUK_LOCAL_DECL duk_int_t duk__get_current_pc(duk_compiler_ctx *comp_ctx); +DUK_LOCAL_DECL duk_compiler_instr *duk__get_instr_ptr(duk_compiler_ctx *comp_ctx, duk_int_t pc); +DUK_LOCAL_DECL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins); +#if 0 /* unused */ +DUK_LOCAL_DECL void duk__emit_op_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t op); +#endif +DUK_LOCAL_DECL void duk__emit_a_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b, duk_regconst_t c); +DUK_LOCAL_DECL void duk__emit_a_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b); +#if 0 /* unused */ +DUK_LOCAL_DECL void duk__emit_a(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a); +#endif +DUK_LOCAL_DECL void duk__emit_a_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t bc); +DUK_LOCAL_DECL void duk__emit_abc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op, duk_regconst_t abc); +DUK_LOCAL_DECL void duk__emit_extraop_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b, duk_regconst_t c); +DUK_LOCAL_DECL void duk__emit_extraop_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b); +DUK_LOCAL_DECL void duk__emit_extraop_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop, duk_regconst_t bc); +DUK_LOCAL_DECL void duk__emit_extraop_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags); +DUK_LOCAL_DECL void duk__emit_load_int32(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val); +DUK_LOCAL_DECL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val); +DUK_LOCAL_DECL void duk__emit_jump(duk_compiler_ctx *comp_ctx, duk_int_t target_pc); +DUK_LOCAL_DECL duk_int_t duk__emit_jump_empty(duk_compiler_ctx *comp_ctx); +DUK_LOCAL_DECL void duk__insert_jump_entry(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc); +DUK_LOCAL_DECL void duk__patch_jump(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc, duk_int_t target_pc); +DUK_LOCAL_DECL void duk__patch_jump_here(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc); +DUK_LOCAL_DECL void duk__patch_trycatch(duk_compiler_ctx *comp_ctx, duk_int_t ldconst_pc, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags); +DUK_LOCAL_DECL void duk__emit_if_false_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst); +DUK_LOCAL_DECL void duk__emit_if_true_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst); +DUK_LOCAL_DECL void duk__emit_invalid(duk_compiler_ctx *comp_ctx); + +/* ivalue/ispec helpers */ +DUK_LOCAL_DECL void duk__copy_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *src, duk_ispec *dst); +DUK_LOCAL_DECL void duk__copy_ivalue(duk_compiler_ctx *comp_ctx, duk_ivalue *src, duk_ivalue *dst); +DUK_LOCAL_DECL duk_bool_t duk__is_whole_get_int32(duk_double_t x, duk_int32_t *ival); +DUK_LOCAL_DECL duk_reg_t duk__alloctemps(duk_compiler_ctx *comp_ctx, duk_small_int_t num); +DUK_LOCAL_DECL duk_reg_t duk__alloctemp(duk_compiler_ctx *comp_ctx); +DUK_LOCAL_DECL void duk__settemp_checkmax(duk_compiler_ctx *comp_ctx, duk_reg_t temp_next); +DUK_LOCAL_DECL duk_regconst_t duk__getconst(duk_compiler_ctx *comp_ctx); +DUK_LOCAL_DECL +duk_regconst_t duk__ispec_toregconst_raw(duk_compiler_ctx *comp_ctx, + duk_ispec *x, + duk_reg_t forced_reg, + duk_small_uint_t flags); +DUK_LOCAL_DECL void duk__ispec_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ispec *x, duk_reg_t forced_reg); +DUK_LOCAL_DECL void duk__ivalue_toplain_raw(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_reg_t forced_reg); +DUK_LOCAL_DECL void duk__ivalue_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *x); +DUK_LOCAL_DECL void duk__ivalue_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *x); +DUK_LOCAL_DECL +duk_regconst_t duk__ivalue_toregconst_raw(duk_compiler_ctx *comp_ctx, + duk_ivalue *x, + duk_reg_t forced_reg, + duk_small_uint_t flags); +DUK_LOCAL_DECL duk_reg_t duk__ivalue_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x); +#if 0 /* unused */ +DUK_LOCAL_DECL duk_reg_t duk__ivalue_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x); +#endif +DUK_LOCAL_DECL void duk__ivalue_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_int_t forced_reg); +DUK_LOCAL_DECL duk_regconst_t duk__ivalue_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *x); + +/* identifier handling */ +DUK_LOCAL_DECL duk_reg_t duk__lookup_active_register_binding(duk_compiler_ctx *comp_ctx); +DUK_LOCAL_DECL duk_bool_t duk__lookup_lhs(duk_compiler_ctx *ctx, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname); + +/* label handling */ +DUK_LOCAL_DECL void duk__add_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_int_t pc_label, duk_int_t label_id); +DUK_LOCAL_DECL void duk__update_label_flags(duk_compiler_ctx *comp_ctx, duk_int_t label_id, duk_small_uint_t flags); +DUK_LOCAL_DECL void duk__lookup_active_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_bool_t is_break, duk_int_t *out_label_id, duk_int_t *out_label_catch_depth, duk_int_t *out_label_pc, duk_bool_t *out_is_closest); +DUK_LOCAL_DECL void duk__reset_labels_to_length(duk_compiler_ctx *comp_ctx, duk_int_t len); + +/* top-down expression parser */ +DUK_LOCAL_DECL void duk__expr_nud(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_ivalue *res); +DUK_LOCAL_DECL duk_small_uint_t duk__expr_lbp(duk_compiler_ctx *comp_ctx); +DUK_LOCAL_DECL duk_bool_t duk__expr_is_empty(duk_compiler_ctx *comp_ctx); + +/* exprtop is the top level variant which resets nud/led counts */ +DUK_LOCAL_DECL void duk__expr(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +DUK_LOCAL_DECL void duk__exprtop(duk_compiler_ctx *ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); + +/* convenience helpers */ +DUK_LOCAL_DECL duk_reg_t duk__expr_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +#if 0 /* unused */ +DUK_LOCAL_DECL duk_reg_t duk__expr_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +#endif +DUK_LOCAL_DECL void duk__expr_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg); +DUK_LOCAL_DECL duk_regconst_t duk__expr_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +DUK_LOCAL_DECL void duk__expr_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +DUK_LOCAL_DECL void duk__expr_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +DUK_LOCAL_DECL duk_reg_t duk__exprtop_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +#if 0 /* unused */ +DUK_LOCAL_DECL duk_reg_t duk__exprtop_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +#endif +DUK_LOCAL_DECL void duk__exprtop_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg); +DUK_LOCAL_DECL duk_regconst_t duk__exprtop_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +#if 0 /* unused */ +DUK_LOCAL_DECL void duk__exprtop_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +#endif + +/* expression parsing helpers */ +DUK_LOCAL_DECL duk_int_t duk__parse_arguments(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL void duk__nud_array_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL void duk__nud_object_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL duk_bool_t duk__nud_object_literal_key_check(duk_compiler_ctx *comp_ctx, duk_small_uint_t new_key_flags); + +/* statement parsing */ +DUK_LOCAL_DECL void duk__parse_var_decl(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t expr_flags, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname); +DUK_LOCAL_DECL void duk__parse_var_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site); +DUK_LOCAL_DECL void duk__parse_switch_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site); +DUK_LOCAL_DECL void duk__parse_if_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL void duk__parse_do_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site); +DUK_LOCAL_DECL void duk__parse_while_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site); +DUK_LOCAL_DECL void duk__parse_break_or_continue_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL void duk__parse_return_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL void duk__parse_throw_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL void duk__parse_try_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL void duk__parse_with_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL void duk__parse_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_bool_t allow_source_elem); +DUK_LOCAL_DECL duk_int_t duk__stmt_label_site(duk_compiler_ctx *comp_ctx, duk_int_t label_id); +DUK_LOCAL_DECL void duk__parse_stmts(duk_compiler_ctx *comp_ctx, duk_bool_t allow_source_elem, duk_bool_t expect_eof); + +DUK_LOCAL_DECL void duk__parse_func_body(duk_compiler_ctx *comp_ctx, duk_bool_t expect_eof, duk_bool_t implicit_return_value, duk_small_int_t expect_token); +DUK_LOCAL_DECL void duk__parse_func_formals(duk_compiler_ctx *comp_ctx); +DUK_LOCAL_DECL void duk__parse_func_like_raw(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget); +DUK_LOCAL_DECL duk_int_t duk__parse_func_like_fnum(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget); + +/* + * Parser control values for tokens. The token table is ordered by the + * DUK_TOK_XXX defines. + * + * The binding powers are for lbp() use (i.e. for use in led() context). + * Binding powers are positive for typing convenience, and bits at the + * top should be reserved for flags. Binding power step must be higher + * than 1 so that binding power "lbp - 1" can be used for right associative + * operators. Currently a step of 2 is used (which frees one more bit for + * flags). + */ + +/* XXX: actually single step levels would work just fine, clean up */ + +/* binding power "levels" (see doc/compiler.rst) */ +#define DUK__BP_INVALID 0 /* always terminates led() */ +#define DUK__BP_EOF 2 +#define DUK__BP_CLOSING 4 /* token closes expression, e.g. ')', ']' */ +#define DUK__BP_FOR_EXPR DUK__BP_CLOSING /* bp to use when parsing a top level Expression */ +#define DUK__BP_COMMA 6 +#define DUK__BP_ASSIGNMENT 8 +#define DUK__BP_CONDITIONAL 10 +#define DUK__BP_LOR 12 +#define DUK__BP_LAND 14 +#define DUK__BP_BOR 16 +#define DUK__BP_BXOR 18 +#define DUK__BP_BAND 20 +#define DUK__BP_EQUALITY 22 +#define DUK__BP_RELATIONAL 24 +#define DUK__BP_SHIFT 26 +#define DUK__BP_ADDITIVE 28 +#define DUK__BP_MULTIPLICATIVE 30 +#define DUK__BP_POSTFIX 32 +#define DUK__BP_CALL 34 +#define DUK__BP_MEMBER 36 + +#define DUK__TOKEN_LBP_BP_MASK 0x1f +#define DUK__TOKEN_LBP_FLAG_NO_REGEXP (1 << 5) /* regexp literal must not follow this token */ +#define DUK__TOKEN_LBP_FLAG_TERMINATES (1 << 6) /* terminates expression; e.g. post-increment/-decrement */ +#define DUK__TOKEN_LBP_FLAG_UNUSED (1 << 7) /* spare */ + +#define DUK__TOKEN_LBP_GET_BP(x) ((duk_small_uint_t) (((x) & DUK__TOKEN_LBP_BP_MASK) * 2)) + +#define DUK__MK_LBP(bp) ((bp) >> 1) /* bp is assumed to be even */ +#define DUK__MK_LBP_FLAGS(bp,flags) (((bp) >> 1) | (flags)) + +DUK_LOCAL const duk_uint8_t duk__token_lbp[] = { + DUK__MK_LBP(DUK__BP_EOF), /* DUK_TOK_EOF */ + DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_IDENTIFIER */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_BREAK */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CASE */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CATCH */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CONTINUE */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_DEBUGGER */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_DEFAULT */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_DELETE */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_DO */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_ELSE */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_FINALLY */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_FOR */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_FUNCTION */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_IF */ + DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_IN */ + DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_INSTANCEOF */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_NEW */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_RETURN */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_SWITCH */ + DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_THIS */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_THROW */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_TRY */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_TYPEOF */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_VAR */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_VOID */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_WHILE */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_WITH */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CLASS */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CONST */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_ENUM */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_EXPORT */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_EXTENDS */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_IMPORT */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_SUPER */ + DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_NULL */ + DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_TRUE */ + DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_FALSE */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_GET */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_SET */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_IMPLEMENTS */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_INTERFACE */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_LET */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_PACKAGE */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_PRIVATE */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_PROTECTED */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_PUBLIC */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_STATIC */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_YIELD */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_LCURLY */ + DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_RCURLY */ + DUK__MK_LBP(DUK__BP_MEMBER), /* DUK_TOK_LBRACKET */ + DUK__MK_LBP_FLAGS(DUK__BP_CLOSING, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_RBRACKET */ + DUK__MK_LBP(DUK__BP_CALL), /* DUK_TOK_LPAREN */ + DUK__MK_LBP_FLAGS(DUK__BP_CLOSING, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_RPAREN */ + DUK__MK_LBP(DUK__BP_MEMBER), /* DUK_TOK_PERIOD */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_SEMICOLON */ + DUK__MK_LBP(DUK__BP_COMMA), /* DUK_TOK_COMMA */ + DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_LT */ + DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_GT */ + DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_LE */ + DUK__MK_LBP(DUK__BP_RELATIONAL), /* DUK_TOK_GE */ + DUK__MK_LBP(DUK__BP_EQUALITY), /* DUK_TOK_EQ */ + DUK__MK_LBP(DUK__BP_EQUALITY), /* DUK_TOK_NEQ */ + DUK__MK_LBP(DUK__BP_EQUALITY), /* DUK_TOK_SEQ */ + DUK__MK_LBP(DUK__BP_EQUALITY), /* DUK_TOK_SNEQ */ + DUK__MK_LBP(DUK__BP_ADDITIVE), /* DUK_TOK_ADD */ + DUK__MK_LBP(DUK__BP_ADDITIVE), /* DUK_TOK_SUB */ + DUK__MK_LBP(DUK__BP_MULTIPLICATIVE), /* DUK_TOK_MUL */ + DUK__MK_LBP(DUK__BP_MULTIPLICATIVE), /* DUK_TOK_DIV */ + DUK__MK_LBP(DUK__BP_MULTIPLICATIVE), /* DUK_TOK_MOD */ + DUK__MK_LBP(DUK__BP_POSTFIX), /* DUK_TOK_INCREMENT */ + DUK__MK_LBP(DUK__BP_POSTFIX), /* DUK_TOK_DECREMENT */ + DUK__MK_LBP(DUK__BP_SHIFT), /* DUK_TOK_ALSHIFT */ + DUK__MK_LBP(DUK__BP_SHIFT), /* DUK_TOK_ARSHIFT */ + DUK__MK_LBP(DUK__BP_SHIFT), /* DUK_TOK_RSHIFT */ + DUK__MK_LBP(DUK__BP_BAND), /* DUK_TOK_BAND */ + DUK__MK_LBP(DUK__BP_BOR), /* DUK_TOK_BOR */ + DUK__MK_LBP(DUK__BP_BXOR), /* DUK_TOK_BXOR */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_LNOT */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_BNOT */ + DUK__MK_LBP(DUK__BP_LAND), /* DUK_TOK_LAND */ + DUK__MK_LBP(DUK__BP_LOR), /* DUK_TOK_LOR */ + DUK__MK_LBP(DUK__BP_CONDITIONAL), /* DUK_TOK_QUESTION */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_COLON */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_EQUALSIGN */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_ADD_EQ */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_SUB_EQ */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_MUL_EQ */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_DIV_EQ */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_MOD_EQ */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_ALSHIFT_EQ */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_ARSHIFT_EQ */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_RSHIFT_EQ */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_BAND_EQ */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_BOR_EQ */ + DUK__MK_LBP(DUK__BP_ASSIGNMENT), /* DUK_TOK_BXOR_EQ */ + DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_NUMBER */ + DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_STRING */ + DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_REGEXP */ +}; + +/* + * Misc helpers + */ + +DUK_LOCAL void duk__recursion_increase(duk_compiler_ctx *comp_ctx) { + DUK_ASSERT(comp_ctx != NULL); + DUK_ASSERT(comp_ctx->recursion_depth >= 0); + if (comp_ctx->recursion_depth >= comp_ctx->recursion_limit) { + DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_COMPILER_RECURSION_LIMIT); + } + comp_ctx->recursion_depth++; +} + +DUK_LOCAL void duk__recursion_decrease(duk_compiler_ctx *comp_ctx) { + DUK_ASSERT(comp_ctx != NULL); + DUK_ASSERT(comp_ctx->recursion_depth > 0); + comp_ctx->recursion_depth--; +} + +DUK_LOCAL duk_bool_t duk__hstring_is_eval_or_arguments(duk_compiler_ctx *comp_ctx, duk_hstring *h) { + DUK_UNREF(comp_ctx); + DUK_ASSERT(h != NULL); + return DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(h); +} + +DUK_LOCAL duk_bool_t duk__hstring_is_eval_or_arguments_in_strict_mode(duk_compiler_ctx *comp_ctx, duk_hstring *h) { + DUK_ASSERT(h != NULL); + return (comp_ctx->curr_func.is_strict && + DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(h)); +} + +/* + * Parser duk__advance() token eating functions + */ + +/* XXX: valstack handling is awkward. Add a valstack helper which + * avoids dup():ing; valstack_copy(src, dst)? + */ + +DUK_LOCAL void duk__advance_helper(duk_compiler_ctx *comp_ctx, duk_small_int_t expect) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_bool_t regexp; + + DUK_ASSERT(comp_ctx->curr_token.t >= 0 && comp_ctx->curr_token.t <= DUK_TOK_MAXVAL); /* MAXVAL is inclusive */ + + /* + * Use current token to decide whether a RegExp can follow. + * + * We can use either 't' or 't_nores'; the latter would not + * recognize keywords. Some keywords can be followed by a + * RegExp (e.g. "return"), so using 't' is better. This is + * not trivial, see doc/compiler.rst. + */ + + regexp = 1; + if (duk__token_lbp[comp_ctx->curr_token.t] & DUK__TOKEN_LBP_FLAG_NO_REGEXP) { + regexp = 0; + } + if (comp_ctx->curr_func.reject_regexp_in_adv) { + comp_ctx->curr_func.reject_regexp_in_adv = 0; + regexp = 0; + } + + if (expect >= 0 && comp_ctx->curr_token.t != expect) { + DUK_D(DUK_DPRINT("parse error: expect=%ld, got=%ld", + (long) expect, (long) comp_ctx->curr_token.t)); + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_PARSE_ERROR); + } + + /* make current token the previous; need to fiddle with valstack "backing store" */ + DUK_MEMCPY(&comp_ctx->prev_token, &comp_ctx->curr_token, sizeof(duk_token)); + duk_copy(ctx, comp_ctx->tok11_idx, comp_ctx->tok21_idx); + duk_copy(ctx, comp_ctx->tok12_idx, comp_ctx->tok22_idx); + + /* parse new token */ + duk_lexer_parse_js_input_element(&comp_ctx->lex, + &comp_ctx->curr_token, + comp_ctx->curr_func.is_strict, + regexp); + + DUK_DDD(DUK_DDDPRINT("advance: curr: tok=%ld/%ld,%ld,term=%ld,%!T,%!T " + "prev: tok=%ld/%ld,%ld,term=%ld,%!T,%!T", + (long) comp_ctx->curr_token.t, + (long) comp_ctx->curr_token.t_nores, + (long) comp_ctx->curr_token.start_line, + (long) comp_ctx->curr_token.lineterm, + (duk_tval *) duk_get_tval(ctx, comp_ctx->tok11_idx), + (duk_tval *) duk_get_tval(ctx, comp_ctx->tok12_idx), + (long) comp_ctx->prev_token.t, + (long) comp_ctx->prev_token.t_nores, + (long) comp_ctx->prev_token.start_line, + (long) comp_ctx->prev_token.lineterm, + (duk_tval *) duk_get_tval(ctx, comp_ctx->tok21_idx), + (duk_tval *) duk_get_tval(ctx, comp_ctx->tok22_idx))); +} + +/* advance, expecting current token to be a specific token; parse next token in regexp context */ +DUK_LOCAL void duk__advance_expect(duk_compiler_ctx *comp_ctx, duk_small_int_t expect) { + duk__advance_helper(comp_ctx, expect); +} + +/* advance, whatever the current token is; parse next token in regexp context */ +DUK_LOCAL void duk__advance(duk_compiler_ctx *comp_ctx) { + duk__advance_helper(comp_ctx, -1); +} + +/* + * Helpers for duk_compiler_func. + */ + +/* init function state: inits valstack allocations */ +DUK_LOCAL void duk__init_func_valstack_slots(duk_compiler_ctx *comp_ctx) { + duk_compiler_func *func = &comp_ctx->curr_func; + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_idx_t entry_top; + + entry_top = duk_get_top(ctx); + + DUK_MEMZERO(func, sizeof(*func)); /* intentional overlap with earlier memzero */ +#ifdef DUK_USE_EXPLICIT_NULL_INIT + func->h_name = NULL; + func->h_consts = NULL; + func->h_funcs = NULL; + func->h_decls = NULL; + func->h_labelnames = NULL; + func->h_labelinfos = NULL; + func->h_argnames = NULL; + func->h_varmap = NULL; +#endif + + duk_require_stack(ctx, DUK__FUNCTION_INIT_REQUIRE_SLOTS); + + DUK_BW_INIT_PUSHBUF(thr, &func->bw_code, DUK__BC_INITIAL_INSTS * sizeof(duk_compiler_instr)); + /* code_idx = entry_top + 0 */ + + duk_push_array(ctx); + func->consts_idx = entry_top + 1; + func->h_consts = duk_get_hobject(ctx, entry_top + 1); + DUK_ASSERT(func->h_consts != NULL); + + duk_push_array(ctx); + func->funcs_idx = entry_top + 2; + func->h_funcs = duk_get_hobject(ctx, entry_top + 2); + DUK_ASSERT(func->h_funcs != NULL); + DUK_ASSERT(func->fnum_next == 0); + + duk_push_array(ctx); + func->decls_idx = entry_top + 3; + func->h_decls = duk_get_hobject(ctx, entry_top + 3); + DUK_ASSERT(func->h_decls != NULL); + + duk_push_array(ctx); + func->labelnames_idx = entry_top + 4; + func->h_labelnames = duk_get_hobject(ctx, entry_top + 4); + DUK_ASSERT(func->h_labelnames != NULL); + + duk_push_dynamic_buffer(ctx, 0); + func->labelinfos_idx = entry_top + 5; + func->h_labelinfos = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, entry_top + 5); + DUK_ASSERT(func->h_labelinfos != NULL); + DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(func->h_labelinfos) && !DUK_HBUFFER_HAS_EXTERNAL(func->h_labelinfos)); + + duk_push_array(ctx); + func->argnames_idx = entry_top + 6; + func->h_argnames = duk_get_hobject(ctx, entry_top + 6); + DUK_ASSERT(func->h_argnames != NULL); + + duk_push_object_internal(ctx); + func->varmap_idx = entry_top + 7; + func->h_varmap = duk_get_hobject(ctx, entry_top + 7); + DUK_ASSERT(func->h_varmap != NULL); +} + +/* reset function state (prepare for pass 2) */ +DUK_LOCAL void duk__reset_func_for_pass2(duk_compiler_ctx *comp_ctx) { + duk_compiler_func *func = &comp_ctx->curr_func; + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + + /* reset bytecode buffer but keep current size; pass 2 will + * require same amount or more. + */ + DUK_BW_RESET_SIZE(thr, &func->bw_code); + + duk_hobject_set_length_zero(thr, func->h_consts); + /* keep func->h_funcs; inner functions are not reparsed to avoid O(depth^2) parsing */ + func->fnum_next = 0; + /* duk_hobject_set_length_zero(thr, func->h_funcs); */ + duk_hobject_set_length_zero(thr, func->h_labelnames); + duk_hbuffer_reset(thr, func->h_labelinfos); + /* keep func->h_argnames; it is fixed for all passes */ + + /* truncated in case pass 3 needed */ + duk_push_object_internal(ctx); + duk_replace(ctx, func->varmap_idx); + func->h_varmap = duk_get_hobject(ctx, func->varmap_idx); + DUK_ASSERT(func->h_varmap != NULL); +} + +/* cleanup varmap from any null entries, compact it, etc; returns number + * of final entries after cleanup. + */ +DUK_LOCAL duk_int_t duk__cleanup_varmap(duk_compiler_ctx *comp_ctx) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_hobject *h_varmap; + duk_hstring *h_key; + duk_tval *tv; + duk_uint32_t i, e_next; + duk_int_t ret; + + /* [ ... varmap ] */ + + h_varmap = duk_get_hobject(ctx, -1); + DUK_ASSERT(h_varmap != NULL); + + ret = 0; + e_next = DUK_HOBJECT_GET_ENEXT(h_varmap); + for (i = 0; i < e_next; i++) { + h_key = DUK_HOBJECT_E_GET_KEY(thr->heap, h_varmap, i); + if (!h_key) { + continue; + } + + DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h_varmap, i)); + + /* The entries can either be register numbers or 'null' values. + * Thus, no need to DECREF them and get side effects. DECREF'ing + * the keys (strings) can cause memory to be freed but no side + * effects as strings don't have finalizers. This is why we can + * rely on the object properties not changing from underneath us. + */ + + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h_varmap, i); + if (!DUK_TVAL_IS_NUMBER(tv)) { + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv)); + DUK_TVAL_SET_UNDEFINED_UNUSED(tv); + DUK_HOBJECT_E_SET_KEY(thr->heap, h_varmap, i, NULL); + DUK_HSTRING_DECREF(thr, h_key); + } else { + ret++; + } + } + + duk_compact(ctx, -1); + + return ret; +} + +/* convert duk_compiler_func into a function template, leaving the result + * on top of stack. + */ +/* XXX: awkward and bloated asm -- use faster internal accesses */ +DUK_LOCAL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_bool_t force_no_namebind) { + duk_compiler_func *func = &comp_ctx->curr_func; + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_hcompiledfunction *h_res; + duk_hbuffer_fixed *h_data; + duk_size_t consts_count; + duk_size_t funcs_count; + duk_size_t code_count; + duk_size_t code_size; + duk_size_t data_size; + duk_size_t i; + duk_tval *p_const; + duk_hobject **p_func; + duk_instr_t *p_instr; + duk_compiler_instr *q_instr; + duk_tval *tv; + + DUK_DDD(DUK_DDDPRINT("converting duk_compiler_func to function/template")); + + /* + * Push result object and init its flags + */ + + /* Valstack should suffice here, required on function valstack init */ + + (void) duk_push_compiledfunction(ctx); + h_res = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1); /* XXX: specific getter */ + DUK_ASSERT(h_res != NULL); + + if (func->is_function) { + DUK_DDD(DUK_DDDPRINT("function -> set NEWENV")); + DUK_HOBJECT_SET_NEWENV((duk_hobject *) h_res); + + if (!func->is_arguments_shadowed) { + /* arguments object would be accessible; note that shadowing + * bindings are arguments or function declarations, neither + * of which are deletable, so this is safe. + */ + + if (func->id_access_arguments || func->may_direct_eval) { + DUK_DDD(DUK_DDDPRINT("function may access 'arguments' object directly or " + "indirectly -> set CREATEARGS")); + DUK_HOBJECT_SET_CREATEARGS((duk_hobject *) h_res); + } + } + } else if (func->is_eval && func->is_strict) { + DUK_DDD(DUK_DDDPRINT("strict eval code -> set NEWENV")); + DUK_HOBJECT_SET_NEWENV((duk_hobject *) h_res); + } else { + /* non-strict eval: env is caller's env or global env (direct vs. indirect call) + * global code: env is is global env + */ + DUK_DDD(DUK_DDDPRINT("non-strict eval code or global code -> no NEWENV")); + DUK_ASSERT(!DUK_HOBJECT_HAS_NEWENV((duk_hobject *) h_res)); + } + + if (func->is_function && !func->is_decl && func->h_name != NULL && !force_no_namebind) { + /* Object literal set/get functions have a name (property + * name) but must not have a lexical name binding, see + * test-bug-getset-func-name.js. + */ + DUK_DDD(DUK_DDDPRINT("function expression with a name -> set NAMEBINDING")); + DUK_HOBJECT_SET_NAMEBINDING((duk_hobject *) h_res); + } + + if (func->is_strict) { + DUK_DDD(DUK_DDDPRINT("function is strict -> set STRICT")); + DUK_HOBJECT_SET_STRICT((duk_hobject *) h_res); + } + + if (func->is_notail) { + DUK_DDD(DUK_DDDPRINT("function is notail -> set NOTAIL")); + DUK_HOBJECT_SET_NOTAIL((duk_hobject *) h_res); + } + + /* + * Build function fixed size 'data' buffer, which contains bytecode, + * constants, and inner function references. + * + * During the building phase 'data' is reachable but incomplete. + * Only incref's occur during building (no refzero or GC happens), + * so the building process is atomic. + */ + + consts_count = duk_hobject_get_length(thr, func->h_consts); + funcs_count = duk_hobject_get_length(thr, func->h_funcs) / 3; + code_count = DUK_BW_GET_SIZE(thr, &func->bw_code) / sizeof(duk_compiler_instr); + code_size = code_count * sizeof(duk_instr_t); + + data_size = consts_count * sizeof(duk_tval) + + funcs_count * sizeof(duk_hobject *) + + code_size; + + DUK_DDD(DUK_DDDPRINT("consts_count=%ld, funcs_count=%ld, code_size=%ld -> " + "data_size=%ld*%ld + %ld*%ld + %ld = %ld", + (long) consts_count, (long) funcs_count, (long) code_size, + (long) consts_count, (long) sizeof(duk_tval), + (long) funcs_count, (long) sizeof(duk_hobject *), + (long) code_size, (long) data_size)); + + duk_push_fixed_buffer(ctx, data_size); + h_data = (duk_hbuffer_fixed *) duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_data != NULL); + + DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, h_res, (duk_hbuffer *) h_data); + DUK_HEAPHDR_INCREF(thr, h_data); + + p_const = (duk_tval *) (void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data); + for (i = 0; i < consts_count; i++) { + DUK_ASSERT(i <= DUK_UARRIDX_MAX); /* const limits */ + tv = duk_hobject_find_existing_array_entry_tval_ptr(thr->heap, func->h_consts, (duk_uarridx_t) i); + DUK_ASSERT(tv != NULL); + DUK_TVAL_SET_TVAL(p_const, tv); + p_const++; + DUK_TVAL_INCREF(thr, tv); /* may be a string constant */ + + DUK_DDD(DUK_DDDPRINT("constant: %!T", (duk_tval *) tv)); + } + + p_func = (duk_hobject **) p_const; + DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, h_res, p_func); + for (i = 0; i < funcs_count; i++) { + duk_hobject *h; + DUK_ASSERT(i * 3 <= DUK_UARRIDX_MAX); /* func limits */ + tv = duk_hobject_find_existing_array_entry_tval_ptr(thr->heap, func->h_funcs, (duk_uarridx_t) (i * 3)); + DUK_ASSERT(tv != NULL); + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(h)); + *p_func++ = h; + DUK_HOBJECT_INCREF(thr, h); + + DUK_DDD(DUK_DDDPRINT("inner function: %p -> %!iO", + (void *) h, (duk_heaphdr *) h)); + } + + p_instr = (duk_instr_t *) p_func; + DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, h_res, p_instr); + + /* copy bytecode instructions one at a time */ + q_instr = (duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(thr, &func->bw_code); + for (i = 0; i < code_count; i++) { + p_instr[i] = q_instr[i].ins; + } + /* Note: 'q_instr' is still used below */ + + DUK_ASSERT((duk_uint8_t *) (p_instr + code_count) == DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data) + data_size); + + duk_pop(ctx); /* 'data' (and everything in it) is reachable through h_res now */ + + /* + * Init object properties + * + * Properties should be added in decreasing order of access frequency. + * (Not very critical for function templates.) + */ + + DUK_DDD(DUK_DDDPRINT("init function properties")); + + /* [ ... res ] */ + + /* _Varmap: omitted if function is guaranteed not to do slow path identifier + * accesses or if it would turn out to be empty of actual register mappings + * after a cleanup. When debugging is enabled, we always need the varmap to + * be able to lookup variables at any point. + */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) + if (1) { +#else + if (func->id_access_slow || /* directly uses slow accesses */ + func->may_direct_eval || /* may indirectly slow access through a direct eval */ + funcs_count > 0) { /* has inner functions which may slow access (XXX: this can be optimized by looking at the inner functions) */ +#endif + duk_int_t num_used; + duk_dup(ctx, func->varmap_idx); + num_used = duk__cleanup_varmap(comp_ctx); + DUK_DDD(DUK_DDDPRINT("cleaned up varmap: %!T (num_used=%ld)", + (duk_tval *) duk_get_tval(ctx, -1), (long) num_used)); + + if (num_used > 0) { + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VARMAP, DUK_PROPDESC_FLAGS_NONE); + } else { + DUK_DDD(DUK_DDDPRINT("varmap is empty after cleanup -> no need to add")); + duk_pop(ctx); + } + } + + /* _Formals: omitted if function is guaranteed not to need a (non-strict) arguments object */ + if (1) { + /* XXX: Add a proper condition. If formals list is omitted, recheck + * handling for 'length' in duk_js_push_closure(); it currently relies + * on _Formals being set. Removal may need to be conditional to debugging + * being enabled/disabled too. + */ + duk_dup(ctx, func->argnames_idx); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_FORMALS, DUK_PROPDESC_FLAGS_NONE); + } + + /* name */ + if (func->h_name) { + duk_push_hstring(ctx, func->h_name); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE); + } + + /* _Source */ +#if defined(DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY) + if (0) { + /* XXX: Currently function source code is not stored, as it is not + * required by the standard. Source code should not be stored by + * default (user should enable it explicitly), and the source should + * probably be compressed with a trivial text compressor; average + * compression of 20-30% is quite easy to achieve even with a trivial + * compressor (RLE + backwards lookup). + * + * Debugging needs source code to be useful: sometimes input code is + * not found in files as it may be generated and then eval()'d, given + * by dynamic C code, etc. + * + * Other issues: + * + * - Need tokenizer indices for start and end to substring + * - Always normalize function declaration part? + * - If we keep _Formals, only need to store body + */ + + /* + * For global or eval code this is straightforward. For functions + * created with the Function constructor we only get the source for + * the body and must manufacture the "function ..." part. + * + * For instance, for constructed functions (v8): + * + * > a = new Function("foo", "bar", "print(foo)"); + * [Function] + * > a.toString() + * 'function anonymous(foo,bar) {\nprint(foo)\n}' + * + * Similarly for e.g. getters (v8): + * + * > x = { get a(foo,bar) { print(foo); } } + * { a: [Getter] } + * > Object.getOwnPropertyDescriptor(x, 'a').get.toString() + * 'function a(foo,bar) { print(foo); }' + */ + +#if 0 + duk_push_string(ctx, "XXX"); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_SOURCE, DUK_PROPDESC_FLAGS_NONE); +#endif + } +#endif /* DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY */ + + /* _Pc2line */ +#if defined(DUK_USE_PC2LINE) + if (1) { + /* + * Size-optimized pc->line mapping. + */ + + DUK_ASSERT(code_count <= DUK_COMPILER_MAX_BYTECODE_LENGTH); + duk_hobject_pc2line_pack(thr, q_instr, (duk_uint_fast32_t) code_count); /* -> pushes fixed buffer */ + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_PC2LINE, DUK_PROPDESC_FLAGS_NONE); + + /* XXX: if assertions enabled, walk through all valid PCs + * and check line mapping. + */ + } +#endif /* DUK_USE_PC2LINE */ + + /* fileName */ + if (comp_ctx->h_filename) { + /* + * Source filename (or equivalent), for identifying thrown errors. + */ + + duk_push_hstring(ctx, comp_ctx->h_filename); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_NONE); + } + + /* + * Init remaining result fields + * + * 'nregs' controls how large a register frame is allocated. + * + * 'nargs' controls how many formal arguments are written to registers: + * r0, ... r(nargs-1). The remaining registers are initialized to + * undefined. + */ + + DUK_ASSERT(func->temp_max >= 0); + h_res->nregs = func->temp_max; + h_res->nargs = duk_hobject_get_length(thr, func->h_argnames); + DUK_ASSERT(h_res->nregs >= h_res->nargs); /* pass2 allocation handles this */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) + h_res->start_line = (duk_uint32_t) func->min_line; + h_res->end_line = (duk_uint32_t) func->max_line; +#endif + + DUK_DD(DUK_DDPRINT("converted function: %!ixT", + (duk_tval *) duk_get_tval(ctx, -1))); + + /* + * Compact the function template. + */ + + duk_compact(ctx, -1); + + /* + * Debug dumping + */ + +#ifdef DUK_USE_DDDPRINT + { + duk_hcompiledfunction *h; + duk_instr_t *p, *p_start, *p_end; + + h = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1); + p_start = (duk_instr_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, h); + p_end = (duk_instr_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, h); + + p = p_start; + while (p < p_end) { + DUK_DDD(DUK_DDDPRINT("BC %04ld: %!I ; 0x%08lx op=%ld (%!C) a=%ld b=%ld c=%ld", + (long) (p - p_start), + (duk_instr_t) (*p), + (unsigned long) (*p), + (long) DUK_DEC_OP(*p), + (long) DUK_DEC_OP(*p), + (long) DUK_DEC_A(*p), + (long) DUK_DEC_B(*p), + (long) DUK_DEC_C(*p))); + p++; + } + } +#endif +} + +/* + * Code emission helpers + * + * Some emission helpers understand the range of target and source reg/const + * values and automatically emit shuffling code if necessary. This is the + * case when the slot in question (A, B, C) is used in the standard way and + * for opcodes the emission helpers explicitly understand (like DUK_OP_CALL). + * + * The standard way is that: + * - slot A is a target register + * - slot B is a source register/constant + * - slot C is a source register/constant + * + * If a slot is used in a non-standard way the caller must indicate this + * somehow. If a slot is used as a target instead of a source (or vice + * versa), this can be indicated with a flag to trigger proper shuffling + * (e.g. DUK__EMIT_FLAG_B_IS_TARGET). If the value in the slot is not + * register/const related at all, the caller must ensure that the raw value + * fits into the corresponding slot so as to not trigger shuffling. The + * caller must set a "no shuffle" flag to ensure compilation fails if + * shuffling were to be triggered because of an internal error. + * + * For slots B and C the raw slot size is 9 bits but one bit is reserved for + * the reg/const indicator. To use the full 9-bit range for a raw value, + * shuffling must be disabled with the DUK__EMIT_FLAG_NO_SHUFFLE_{B,C} flag. + * Shuffling is only done for A, B, and C slots, not the larger BC or ABC slots. + * + * There is call handling specific understanding in the A-B-C emitter to + * convert call setup and call instructions into indirect ones if necessary. + */ + +/* Code emission flags, passed in the 'opcode' field. Opcode + flags + * fit into 16 bits for now, so use duk_small_uint.t. + */ +#define DUK__EMIT_FLAG_NO_SHUFFLE_A (1 << 8) +#define DUK__EMIT_FLAG_NO_SHUFFLE_B (1 << 9) +#define DUK__EMIT_FLAG_NO_SHUFFLE_C (1 << 10) +#define DUK__EMIT_FLAG_A_IS_SOURCE (1 << 11) /* slot A is a source (default: target) */ +#define DUK__EMIT_FLAG_B_IS_TARGET (1 << 12) /* slot B is a target (default: source) */ +#define DUK__EMIT_FLAG_C_IS_TARGET (1 << 13) /* slot C is a target (default: source) */ +#define DUK__EMIT_FLAG_B_IS_TARGETSOURCE (1 << 14) /* slot B is both a target and a source (used by extraops like DUK_EXTRAOP_INSTOF */ +#define DUK__EMIT_FLAG_RESERVE_JUMPSLOT (1 << 15) /* reserve a jumpslot after instr before target spilling, used for NEXTENUM */ + +/* XXX: clarify on when and where DUK__CONST_MARKER is allowed */ +/* XXX: opcode specific assertions on when consts are allowed */ + +/* XXX: macro smaller than call? */ +DUK_LOCAL duk_int_t duk__get_current_pc(duk_compiler_ctx *comp_ctx) { + duk_compiler_func *func; + func = &comp_ctx->curr_func; + return (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &func->bw_code) / sizeof(duk_compiler_instr)); +} + +DUK_LOCAL duk_compiler_instr *duk__get_instr_ptr(duk_compiler_ctx *comp_ctx, duk_int_t pc) { + DUK_ASSERT(pc >= 0); + DUK_ASSERT((duk_size_t) pc < (duk_size_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr))); + return ((duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code)) + pc; +} + +/* emit instruction; could return PC but that's not needed in the majority + * of cases. + */ +DUK_LOCAL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins) { +#if defined(DUK_USE_PC2LINE) + duk_int_t line; +#endif + duk_compiler_instr *instr; + + DUK_DDD(DUK_DDDPRINT("duk__emit: 0x%08lx curr_token.start_line=%ld prev_token.start_line=%ld pc=%ld --> %!I", + (unsigned long) ins, + (long) comp_ctx->curr_token.start_line, + (long) comp_ctx->prev_token.start_line, + (long) duk__get_current_pc(comp_ctx), + (duk_instr_t) ins)); + + instr = (duk_compiler_instr *) (void *) DUK_BW_ENSURE_GETPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr)); + DUK_BW_ADD_PTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr)); + +#if defined(DUK_USE_PC2LINE) + /* The line number tracking is a bit inconsistent right now, which + * affects debugger accuracy. Mostly call sites emit opcodes when + * they have parsed a token (say a terminating semicolon) and called + * duk__advance(). In this case the line number of the previous + * token is the most accurate one (except in prologue where + * prev_token.start_line is 0). This is probably not 100% correct + * right now. + */ + /* approximation, close enough */ + line = comp_ctx->prev_token.start_line; + if (line == 0) { + line = comp_ctx->curr_token.start_line; + } +#endif + + instr->ins = ins; +#if defined(DUK_USE_PC2LINE) + instr->line = line; +#endif +#if defined(DUK_USE_DEBUGGER_SUPPORT) + if (line < comp_ctx->curr_func.min_line) { + comp_ctx->curr_func.min_line = line; + } + if (line > comp_ctx->curr_func.max_line) { + comp_ctx->curr_func.max_line = line; + } +#endif + + /* Limit checks for bytecode byte size and line number. */ + if (DUK_UNLIKELY(DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) > DUK_USE_ESBC_MAX_BYTES)) { + goto fail_bc_limit; + } +#if defined(DUK_USE_PC2LINE) && defined(DUK_USE_ESBC_LIMITS) +#if defined(DUK_USE_BUFLEN16) + /* Buffer length is bounded to 0xffff automatically, avoid compile warning. */ + if (DUK_UNLIKELY(line > DUK_USE_ESBC_MAX_LINENUMBER)) { + goto fail_bc_limit; + } +#else + if (DUK_UNLIKELY(line > DUK_USE_ESBC_MAX_LINENUMBER)) { + goto fail_bc_limit; + } +#endif +#endif + + return; + + fail_bc_limit: + DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_BYTECODE_LIMIT); +} + +/* Update function min/max line from current token. Needed to improve + * function line range information for debugging, so that e.g. opening + * curly brace is covered by line range even when no opcodes are emitted + * for the line containing the brace. + */ +DUK_LOCAL void duk__update_lineinfo_currtoken(duk_compiler_ctx *comp_ctx) { +#if defined(DUK_USE_DEBUGGER_SUPPORT) + duk_int_t line; + + line = comp_ctx->curr_token.start_line; + if (line == 0) { + return; + } + if (line < comp_ctx->curr_func.min_line) { + comp_ctx->curr_func.min_line = line; + } + if (line > comp_ctx->curr_func.max_line) { + comp_ctx->curr_func.max_line = line; + } +#else + DUK_UNREF(comp_ctx); +#endif +} + +#if 0 /* unused */ +DUK_LOCAL void duk__emit_op_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t op) { + duk__emit(comp_ctx, DUK_ENC_OP_ABC(op, 0)); +} +#endif + +/* Important main primitive. */ +DUK_LOCAL void duk__emit_a_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b, duk_regconst_t c) { + duk_instr_t ins = 0; + duk_int_t a_out = -1; + duk_int_t b_out = -1; + duk_int_t c_out = -1; + duk_int_t tmp; + + DUK_DDD(DUK_DDDPRINT("emit: op_flags=%04lx, a=%ld, b=%ld, c=%ld", + (unsigned long) op_flags, (long) a, (long) b, (long) c)); + + /* We could rely on max temp/const checks: if they don't exceed BC + * limit, nothing here can either (just asserts would be enough). + * Currently we check for the limits, which provides additional + * protection against creating invalid bytecode due to compiler + * bugs. + */ + + DUK_ASSERT_DISABLE((op_flags & 0xff) >= DUK_BC_OP_MIN); /* unsigned */ + DUK_ASSERT((op_flags & 0xff) <= DUK_BC_OP_MAX); + + /* Input shuffling happens before the actual operation, while output + * shuffling happens afterwards. Output shuffling decisions are still + * made at the same time to reduce branch clutter; output shuffle decisions + * are recorded into X_out variables. + */ + + /* Slot A */ + +#if defined(DUK_USE_SHUFFLE_TORTURE) + if (a <= DUK_BC_A_MAX && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A)) { +#else + if (a <= DUK_BC_A_MAX) { +#endif + ; + } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A) { + DUK_D(DUK_DPRINT("out of regs: 'a' (reg) needs shuffling but shuffle prohibited, a: %ld", (long) a)); + goto error_outofregs; + } else if (a <= DUK_BC_BC_MAX) { + comp_ctx->curr_func.needs_shuffle = 1; + tmp = comp_ctx->curr_func.shuffle1; + if (op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) { + duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, a)); + } else { + duk_small_int_t op = op_flags & 0xff; + if (op == DUK_OP_CSVAR || op == DUK_OP_CSREG || op == DUK_OP_CSPROP) { + /* Special handling for call setup instructions. The target + * is expressed indirectly, but there is no output shuffling. + */ + DUK_ASSERT((op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) == 0); + duk__emit_load_int32_noshuffle(comp_ctx, tmp, a); + DUK_ASSERT(DUK_OP_CSVARI == DUK_OP_CSVAR + 1); + DUK_ASSERT(DUK_OP_CSREGI == DUK_OP_CSREG + 1); + DUK_ASSERT(DUK_OP_CSPROPI == DUK_OP_CSPROP + 1); + op_flags++; /* indirect opcode follows direct */ + } else { + /* Output shuffle needed after main operation */ + a_out = a; + } + } + a = tmp; + } else { + DUK_D(DUK_DPRINT("out of regs: 'a' (reg) needs shuffling but does not fit into BC, a: %ld", (long) a)); + goto error_outofregs; + } + + /* Slot B */ + + if (b & DUK__CONST_MARKER) { + DUK_ASSERT((op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B) == 0); + DUK_ASSERT((op_flags & DUK__EMIT_FLAG_B_IS_TARGET) == 0); + DUK_ASSERT((op_flags & 0xff) != DUK_OP_CALL); + DUK_ASSERT((op_flags & 0xff) != DUK_OP_NEW); + b = b & ~DUK__CONST_MARKER; +#if defined(DUK_USE_SHUFFLE_TORTURE) + if (0) { +#else + if (b <= 0xff) { +#endif + ins |= DUK_ENC_OP_A_B_C(0, 0, 0x100, 0); /* const flag for B */ + } else if (b <= DUK_BC_BC_MAX) { + comp_ctx->curr_func.needs_shuffle = 1; + tmp = comp_ctx->curr_func.shuffle2; + duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDCONST, tmp, b)); + b = tmp; + } else { + DUK_D(DUK_DPRINT("out of regs: 'b' (const) needs shuffling but does not fit into BC, b: %ld", (long) b)); + goto error_outofregs; + } + } else { +#if defined(DUK_USE_SHUFFLE_TORTURE) + if (b <= 0xff && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B)) { +#else + if (b <= 0xff) { +#endif + ; + } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B) { + if (b > DUK_BC_B_MAX) { + /* Note: 0xff != DUK_BC_B_MAX */ + DUK_D(DUK_DPRINT("out of regs: 'b' (reg) needs shuffling but shuffle prohibited, b: %ld", (long) b)); + goto error_outofregs; + } + } else if (b <= DUK_BC_BC_MAX) { + comp_ctx->curr_func.needs_shuffle = 1; + tmp = comp_ctx->curr_func.shuffle2; + if (op_flags & DUK__EMIT_FLAG_B_IS_TARGET) { + /* Output shuffle needed after main operation */ + b_out = b; + } + if (!(op_flags & DUK__EMIT_FLAG_B_IS_TARGET) || (op_flags & DUK__EMIT_FLAG_B_IS_TARGETSOURCE)) { + duk_small_int_t op = op_flags & 0xff; + if (op == DUK_OP_CALL || op == DUK_OP_NEW || + op == DUK_OP_MPUTOBJ || op == DUK_OP_MPUTARR) { + /* Special handling for CALL/NEW/MPUTOBJ/MPUTARR shuffling. + * For each, slot B identifies the first register of a range + * of registers, so normal shuffling won't work. Instead, + * an indirect version of the opcode is used. + */ + DUK_ASSERT((op_flags & DUK__EMIT_FLAG_B_IS_TARGET) == 0); + duk__emit_load_int32_noshuffle(comp_ctx, tmp, b); + DUK_ASSERT(DUK_OP_CALLI == DUK_OP_CALL + 1); + DUK_ASSERT(DUK_OP_NEWI == DUK_OP_NEW + 1); + DUK_ASSERT(DUK_OP_MPUTOBJI == DUK_OP_MPUTOBJ + 1); + DUK_ASSERT(DUK_OP_MPUTARRI == DUK_OP_MPUTARR + 1); + op_flags++; /* indirect opcode follows direct */ + } else { + duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, b)); + } + } + b = tmp; + } else { + DUK_D(DUK_DPRINT("out of regs: 'b' (reg) needs shuffling but does not fit into BC, b: %ld", (long) b)); + goto error_outofregs; + } + } + + /* Slot C */ + + if (c & DUK__CONST_MARKER) { + DUK_ASSERT((op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C) == 0); + DUK_ASSERT((op_flags & DUK__EMIT_FLAG_C_IS_TARGET) == 0); + c = c & ~DUK__CONST_MARKER; +#if defined(DUK_USE_SHUFFLE_TORTURE) + if (0) { +#else + if (c <= 0xff) { +#endif + ins |= DUK_ENC_OP_A_B_C(0, 0, 0, 0x100); /* const flag for C */ + } else if (c <= DUK_BC_BC_MAX) { + comp_ctx->curr_func.needs_shuffle = 1; + tmp = comp_ctx->curr_func.shuffle3; + duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDCONST, tmp, c)); + c = tmp; + } else { + DUK_D(DUK_DPRINT("out of regs: 'c' (const) needs shuffling but does not fit into BC, c: %ld", (long) c)); + goto error_outofregs; + } + } else { +#if defined(DUK_USE_SHUFFLE_TORTURE) + if (c <= 0xff && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C)) { +#else + if (c <= 0xff) { +#endif + ; + } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C) { + if (c > DUK_BC_C_MAX) { + /* Note: 0xff != DUK_BC_C_MAX */ + DUK_D(DUK_DPRINT("out of regs: 'c' (reg) needs shuffling but shuffle prohibited, c: %ld", (long) c)); + goto error_outofregs; + } + } else if (c <= DUK_BC_BC_MAX) { + comp_ctx->curr_func.needs_shuffle = 1; + tmp = comp_ctx->curr_func.shuffle3; + if (op_flags & DUK__EMIT_FLAG_C_IS_TARGET) { + /* Output shuffle needed after main operation */ + c_out = c; + } else { + duk_small_int_t op = op_flags & 0xff; + if (op == DUK_OP_EXTRA && + (a == DUK_EXTRAOP_INITGET || a == DUK_EXTRAOP_INITSET)) { + /* Special shuffling for INITGET/INITSET, where slot C + * identifies a register pair and cannot be shuffled + * normally. Use an indirect variant instead. + */ + DUK_ASSERT((op_flags & DUK__EMIT_FLAG_C_IS_TARGET) == 0); + duk__emit_load_int32_noshuffle(comp_ctx, tmp, c); + DUK_ASSERT(DUK_EXTRAOP_INITGETI == DUK_EXTRAOP_INITGET + 1); + DUK_ASSERT(DUK_EXTRAOP_INITSETI == DUK_EXTRAOP_INITSET + 1); + a++; /* indirect opcode follows direct */ + } else { + duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, c)); + } + } + c = tmp; + } else { + DUK_D(DUK_DPRINT("out of regs: 'c' (reg) needs shuffling but does not fit into BC, c: %ld", (long) c)); + goto error_outofregs; + } + } + + /* Main operation */ + + DUK_ASSERT_DISABLE(a >= DUK_BC_A_MIN); /* unsigned */ + DUK_ASSERT(a <= DUK_BC_A_MAX); + DUK_ASSERT_DISABLE(b >= DUK_BC_B_MIN); /* unsigned */ + DUK_ASSERT(b <= DUK_BC_B_MAX); + DUK_ASSERT_DISABLE(c >= DUK_BC_C_MIN); /* unsigned */ + DUK_ASSERT(c <= DUK_BC_C_MAX); + + ins |= DUK_ENC_OP_A_B_C(op_flags & 0xff, a, b, c); + duk__emit(comp_ctx, ins); + + /* NEXTENUM needs a jump slot right after the main instruction. + * When the JUMP is taken, output spilling is not needed so this + * workaround is possible. The jump slot PC is exceptionally + * plumbed through comp_ctx to minimize call sites. + */ + if (op_flags & DUK__EMIT_FLAG_RESERVE_JUMPSLOT) { + comp_ctx->emit_jumpslot_pc = duk__get_current_pc(comp_ctx); + duk__emit_abc(comp_ctx, DUK_OP_JUMP, 0); + } + + /* Output shuffling: only one output register is realistically possible. + * + * (Zero would normally be an OK marker value: if the target register + * was zero, it would never be shuffled. But with DUK_USE_SHUFFLE_TORTURE + * this is no longer true, so use -1 as a marker instead.) + */ + + if (a_out >= 0) { + DUK_ASSERT(b_out < 0); + DUK_ASSERT(c_out < 0); + duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, a, a_out)); + } else if (b_out >= 0) { + DUK_ASSERT(a_out < 0); + DUK_ASSERT(c_out < 0); + duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, b, b_out)); + } else if (c_out >= 0) { + DUK_ASSERT(b_out < 0); + DUK_ASSERT(c_out < 0); + duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, c, c_out)); + } + + return; + + error_outofregs: + DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_REG_LIMIT); +} + +DUK_LOCAL void duk__emit_a_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b) { + duk__emit_a_b_c(comp_ctx, op_flags | DUK__EMIT_FLAG_NO_SHUFFLE_C, a, b, 0); +} + +#if 0 /* unused */ +DUK_LOCAL void duk__emit_a(duk_compiler_ctx *comp_ctx, int op_flags, int a) { + duk__emit_a_b_c(comp_ctx, op_flags | DUK__EMIT_FLAG_NO_SHUFFLE_B | DUK__EMIT_FLAG_NO_SHUFFLE_C, a, 0, 0); +} +#endif + +DUK_LOCAL void duk__emit_a_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t bc) { + duk_instr_t ins; + duk_int_t tmp; + + /* allow caller to give a const number with the DUK__CONST_MARKER */ + bc = bc & (~DUK__CONST_MARKER); + + DUK_ASSERT_DISABLE((op_flags & 0xff) >= DUK_BC_OP_MIN); /* unsigned */ + DUK_ASSERT((op_flags & 0xff) <= DUK_BC_OP_MAX); + DUK_ASSERT_DISABLE(bc >= DUK_BC_BC_MIN); /* unsigned */ + DUK_ASSERT(bc <= DUK_BC_BC_MAX); + DUK_ASSERT((bc & DUK__CONST_MARKER) == 0); + + if (bc <= DUK_BC_BC_MAX) { + ; + } else { + /* No BC shuffling now. */ + goto error_outofregs; + } + +#if defined(DUK_USE_SHUFFLE_TORTURE) + if (a <= DUK_BC_A_MAX && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A)) { +#else + if (a <= DUK_BC_A_MAX) { +#endif + ins = DUK_ENC_OP_A_BC(op_flags & 0xff, a, bc); + duk__emit(comp_ctx, ins); + } else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A) { + goto error_outofregs; + } else if (a <= DUK_BC_BC_MAX) { + comp_ctx->curr_func.needs_shuffle = 1; + tmp = comp_ctx->curr_func.shuffle1; + ins = DUK_ENC_OP_A_BC(op_flags & 0xff, tmp, bc); + if (op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) { + duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, a)); + duk__emit(comp_ctx, ins); + } else { + duk__emit(comp_ctx, ins); + duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, tmp, a)); + } + } else { + goto error_outofregs; + } + return; + + error_outofregs: + DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_REG_LIMIT); +} + +DUK_LOCAL void duk__emit_abc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op, duk_regconst_t abc) { + duk_instr_t ins; + + DUK_ASSERT_DISABLE(op >= DUK_BC_OP_MIN); /* unsigned */ + DUK_ASSERT(op <= DUK_BC_OP_MAX); + DUK_ASSERT_DISABLE(abc >= DUK_BC_ABC_MIN); /* unsigned */ + DUK_ASSERT(abc <= DUK_BC_ABC_MAX); + DUK_ASSERT((abc & DUK__CONST_MARKER) == 0); + + if (abc <= DUK_BC_ABC_MAX) { + ; + } else { + goto error_outofregs; + } + ins = DUK_ENC_OP_ABC(op, abc); + DUK_DDD(DUK_DDDPRINT("duk__emit_abc: 0x%08lx line=%ld pc=%ld op=%ld (%!C) abc=%ld (%!I)", + (unsigned long) ins, (long) comp_ctx->curr_token.start_line, + (long) duk__get_current_pc(comp_ctx), (long) op, (long) op, + (long) abc, (duk_instr_t) ins)); + duk__emit(comp_ctx, ins); + return; + + error_outofregs: + DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_REG_LIMIT); +} + +DUK_LOCAL void duk__emit_extraop_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b, duk_regconst_t c) { + DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN); /* unsigned */ + DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX); + /* Setting "no shuffle A" is covered by the assert, but it's needed + * with DUK_USE_SHUFFLE_TORTURE. + */ + duk__emit_a_b_c(comp_ctx, + DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | (extraop_flags & ~0xff), /* transfer flags */ + extraop_flags & 0xff, + b, + c); +} + +DUK_LOCAL void duk__emit_extraop_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b) { + DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN); /* unsigned */ + DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX); + /* Setting "no shuffle A" is covered by the assert, but it's needed + * with DUK_USE_SHUFFLE_TORTURE. + */ + duk__emit_a_b_c(comp_ctx, + DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | (extraop_flags & ~0xff), /* transfer flags */ + extraop_flags & 0xff, + b, + 0); +} + +DUK_LOCAL void duk__emit_extraop_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop, duk_regconst_t bc) { + DUK_ASSERT_DISABLE(extraop >= DUK_BC_EXTRAOP_MIN); /* unsigned */ + DUK_ASSERT(extraop <= DUK_BC_EXTRAOP_MAX); + /* Setting "no shuffle A" is covered by the assert, but it's needed + * with DUK_USE_SHUFFLE_TORTURE. + */ + duk__emit_a_bc(comp_ctx, + DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A, + extraop, + bc); +} + +DUK_LOCAL void duk__emit_extraop_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags) { + DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN); /* unsigned */ + DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX); + /* Setting "no shuffle A" is covered by the assert, but it's needed + * with DUK_USE_SHUFFLE_TORTURE. + */ + duk__emit_a_b_c(comp_ctx, + DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_B | + DUK__EMIT_FLAG_NO_SHUFFLE_C | (extraop_flags & ~0xff), /* transfer flags */ + extraop_flags & 0xff, + 0, + 0); +} + +DUK_LOCAL void duk__emit_load_int32_raw(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val, duk_small_uint_t op_flags) { + /* XXX: Shuffling support could be implemented here so that LDINT+LDINTX + * would only shuffle once (instead of twice). The current code works + * though, and has a smaller compiler footprint. + */ + + if ((val >= (duk_int32_t) DUK_BC_BC_MIN - (duk_int32_t) DUK_BC_LDINT_BIAS) && + (val <= (duk_int32_t) DUK_BC_BC_MAX - (duk_int32_t) DUK_BC_LDINT_BIAS)) { + DUK_DDD(DUK_DDDPRINT("emit LDINT to reg %ld for %ld", (long) reg, (long) val)); + duk__emit_a_bc(comp_ctx, DUK_OP_LDINT | op_flags, reg, (duk_regconst_t) (val + (duk_int32_t) DUK_BC_LDINT_BIAS)); + } else { + duk_int32_t hi = val >> DUK_BC_LDINTX_SHIFT; + duk_int32_t lo = val & ((((duk_int32_t) 1) << DUK_BC_LDINTX_SHIFT) - 1); + DUK_ASSERT(lo >= 0); + DUK_DDD(DUK_DDDPRINT("emit LDINT+LDINTX to reg %ld for %ld -> hi %ld, lo %ld", + (long) reg, (long) val, (long) hi, (long) lo)); + duk__emit_a_bc(comp_ctx, DUK_OP_LDINT | op_flags, reg, (duk_regconst_t) (hi + (duk_int32_t) DUK_BC_LDINT_BIAS)); + duk__emit_a_bc(comp_ctx, DUK_OP_LDINTX | op_flags, reg, (duk_regconst_t) lo); + } +} + +DUK_LOCAL void duk__emit_load_int32(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val) { + duk__emit_load_int32_raw(comp_ctx, reg, val, 0 /*op_flags*/); +} + +#if defined(DUK_USE_SHUFFLE_TORTURE) +/* Used by duk__emit*() calls so that we don't shuffle the loadints that + * are needed to handle indirect opcodes. + */ +DUK_LOCAL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val) { + duk__emit_load_int32_raw(comp_ctx, reg, val, DUK__EMIT_FLAG_NO_SHUFFLE_A /*op_flags*/); +} +#else +DUK_LOCAL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val) { + /* When torture not enabled, can just use the same helper because + * 'reg' won't get spilled. + */ + DUK_ASSERT(reg <= DUK_BC_A_MAX); + duk__emit_load_int32(comp_ctx, reg, val); +} +#endif + +DUK_LOCAL void duk__emit_jump(duk_compiler_ctx *comp_ctx, duk_int_t target_pc) { + duk_int_t curr_pc; + duk_int_t offset; + + curr_pc = (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr)); + offset = (duk_int_t) target_pc - (duk_int_t) curr_pc - 1; + DUK_ASSERT(offset + DUK_BC_JUMP_BIAS >= DUK_BC_ABC_MIN); + DUK_ASSERT(offset + DUK_BC_JUMP_BIAS <= DUK_BC_ABC_MAX); + duk__emit_abc(comp_ctx, DUK_OP_JUMP, (duk_regconst_t) (offset + DUK_BC_JUMP_BIAS)); +} + +DUK_LOCAL duk_int_t duk__emit_jump_empty(duk_compiler_ctx *comp_ctx) { + duk_int_t ret; + + ret = duk__get_current_pc(comp_ctx); /* useful for patching jumps later */ + duk__emit_abc(comp_ctx, DUK_OP_JUMP, 0); + return ret; +} + +/* Insert an empty jump in the middle of code emitted earlier. This is + * currently needed for compiling for-in. + */ +DUK_LOCAL void duk__insert_jump_entry(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc) { +#if defined(DUK_USE_PC2LINE) + duk_int_t line; +#endif + duk_compiler_instr *instr; + duk_size_t offset; + + offset = jump_pc * sizeof(duk_compiler_instr), + instr = (duk_compiler_instr *) (void *) + DUK_BW_INSERT_ENSURE_AREA(comp_ctx->thr, + &comp_ctx->curr_func.bw_code, + offset, + sizeof(duk_compiler_instr)); + +#if defined(DUK_USE_PC2LINE) + line = comp_ctx->curr_token.start_line; /* approximation, close enough */ +#endif + instr->ins = DUK_ENC_OP_ABC(DUK_OP_JUMP, 0); +#if defined(DUK_USE_PC2LINE) + instr->line = line; +#endif + + DUK_BW_ADD_PTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr)); + if (DUK_UNLIKELY(DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) > DUK_USE_ESBC_MAX_BYTES)) { + goto fail_bc_limit; + } + return; + + fail_bc_limit: + DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_BYTECODE_LIMIT); +} + +/* Does not assume that jump_pc contains a DUK_OP_JUMP previously; this is intentional + * to allow e.g. an INVALID opcode be overwritten with a JUMP (label management uses this). + */ +DUK_LOCAL void duk__patch_jump(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc, duk_int_t target_pc) { + duk_compiler_instr *instr; + duk_int_t offset; + + /* allow negative PCs, behave as a no-op */ + if (jump_pc < 0) { + DUK_DDD(DUK_DDDPRINT("duk__patch_jump(): nop call, jump_pc=%ld (<0), target_pc=%ld", + (long) jump_pc, (long) target_pc)); + return; + } + DUK_ASSERT(jump_pc >= 0); + + /* XXX: range assert */ + instr = duk__get_instr_ptr(comp_ctx, jump_pc); + DUK_ASSERT(instr != NULL); + + /* XXX: range assert */ + offset = target_pc - jump_pc - 1; + + instr->ins = DUK_ENC_OP_ABC(DUK_OP_JUMP, offset + DUK_BC_JUMP_BIAS); + DUK_DDD(DUK_DDDPRINT("duk__patch_jump(): jump_pc=%ld, target_pc=%ld, offset=%ld", + (long) jump_pc, (long) target_pc, (long) offset)); +} + +DUK_LOCAL void duk__patch_jump_here(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc) { + duk__patch_jump(comp_ctx, jump_pc, duk__get_current_pc(comp_ctx)); +} + +DUK_LOCAL void duk__patch_trycatch(duk_compiler_ctx *comp_ctx, duk_int_t ldconst_pc, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags) { + duk_compiler_instr *instr; + + DUK_ASSERT((reg_catch & DUK__CONST_MARKER) == 0); + + instr = duk__get_instr_ptr(comp_ctx, ldconst_pc); + DUK_ASSERT(DUK_DEC_OP(instr->ins) == DUK_OP_LDCONST); + DUK_ASSERT(instr != NULL); + if (const_varname & DUK__CONST_MARKER) { + /* Have a catch variable. */ + const_varname = const_varname & (~DUK__CONST_MARKER); + if (reg_catch > DUK_BC_BC_MAX || const_varname > DUK_BC_BC_MAX) { + /* Catch attempts to use out-of-range reg/const. Without this + * check Duktape 0.12.0 could generate invalid code which caused + * an assert failure on execution. This error is triggered e.g. + * for functions with a lot of constants and a try-catch statement. + * Shuffling or opcode semantics change is needed to fix the issue. + * See: test-bug-trycatch-many-constants.js. + */ + DUK_D(DUK_DPRINT("failed to patch trycatch: flags=%ld, reg_catch=%ld, const_varname=%ld (0x%08lx)", + (long) flags, (long) reg_catch, (long) const_varname, (long) const_varname)); + DUK_ERROR(comp_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_REG_LIMIT); + } + instr->ins |= DUK_ENC_OP_A_BC(0, 0, const_varname); + } else { + /* No catch variable, e.g. a try-finally; replace LDCONST with + * NOP to avoid a bogus LDCONST. + */ + instr->ins = DUK_ENC_OP_A(DUK_OP_EXTRA, DUK_EXTRAOP_NOP); + } + + instr = duk__get_instr_ptr(comp_ctx, trycatch_pc); + DUK_ASSERT(instr != NULL); + DUK_ASSERT_DISABLE(flags >= DUK_BC_A_MIN); + DUK_ASSERT(flags <= DUK_BC_A_MAX); + instr->ins = DUK_ENC_OP_A_BC(DUK_OP_TRYCATCH, flags, reg_catch); +} + +DUK_LOCAL void duk__emit_if_false_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst) { + duk__emit_a_b_c(comp_ctx, + DUK_OP_IF | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C, + 0 /*false*/, + regconst, + 0 /*unused*/); +} + +DUK_LOCAL void duk__emit_if_true_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst) { + duk__emit_a_b_c(comp_ctx, + DUK_OP_IF | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C, + 1 /*true*/, + regconst, + 0 /*unused*/); +} + +DUK_LOCAL void duk__emit_invalid(duk_compiler_ctx *comp_ctx) { + duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_INVALID, 0); +} + +/* + * Peephole optimizer for finished bytecode. + * + * Does not remove opcodes; currently only straightens out unconditional + * jump chains which are generated by several control structures. + */ + +DUK_LOCAL void duk__peephole_optimize_bytecode(duk_compiler_ctx *comp_ctx) { + duk_compiler_instr *bc; + duk_small_uint_t iter; + duk_int_t i, n; + duk_int_t count_opt; + + bc = (duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code); +#if defined(DUK_USE_BUFLEN16) + /* No need to assert, buffer size maximum is 0xffff. */ +#else + DUK_ASSERT((duk_size_t) DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr) <= (duk_size_t) DUK_INT_MAX); /* bytecode limits */ +#endif + n = (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr)); + + for (iter = 0; iter < DUK_COMPILER_PEEPHOLE_MAXITER; iter++) { + count_opt = 0; + + for (i = 0; i < n; i++) { + duk_instr_t ins; + duk_int_t target_pc1; + duk_int_t target_pc2; + + ins = bc[i].ins; + if (DUK_DEC_OP(ins) != DUK_OP_JUMP) { + continue; + } + + target_pc1 = i + 1 + DUK_DEC_ABC(ins) - DUK_BC_JUMP_BIAS; + DUK_DDD(DUK_DDDPRINT("consider jump at pc %ld; target_pc=%ld", (long) i, (long) target_pc1)); + DUK_ASSERT(target_pc1 >= 0); + DUK_ASSERT(target_pc1 < n); + + /* Note: if target_pc1 == i, we'll optimize a jump to itself. + * This does not need to be checked for explicitly; the case + * is rare and max iter breaks us out. + */ + + ins = bc[target_pc1].ins; + if (DUK_DEC_OP(ins) != DUK_OP_JUMP) { + continue; + } + + target_pc2 = target_pc1 + 1 + DUK_DEC_ABC(ins) - DUK_BC_JUMP_BIAS; + + DUK_DDD(DUK_DDDPRINT("optimizing jump at pc %ld; old target is %ld -> new target is %ld", + (long) i, (long) target_pc1, (long) target_pc2)); + + bc[i].ins = DUK_ENC_OP_ABC(DUK_OP_JUMP, target_pc2 - (i + 1) + DUK_BC_JUMP_BIAS); + + count_opt++; + } + + DUK_DD(DUK_DDPRINT("optimized %ld jumps on peephole round %ld", (long) count_opt, (long) (iter + 1))); + + if (count_opt == 0) { + break; + } + } +} + +/* + * Intermediate value helpers + */ + +#define DUK__ISREG(comp_ctx,x) (((x) & DUK__CONST_MARKER) == 0) +#define DUK__ISCONST(comp_ctx,x) (((x) & DUK__CONST_MARKER) != 0) +#define DUK__ISTEMP(comp_ctx,x) (DUK__ISREG((comp_ctx), (x)) && (duk_regconst_t) (x) >= (duk_regconst_t) ((comp_ctx)->curr_func.temp_first)) +#define DUK__GETTEMP(comp_ctx) ((comp_ctx)->curr_func.temp_next) +#define DUK__SETTEMP(comp_ctx,x) ((comp_ctx)->curr_func.temp_next = (x)) /* dangerous: must only lower (temp_max not updated) */ +#define DUK__SETTEMP_CHECKMAX(comp_ctx,x) duk__settemp_checkmax((comp_ctx),(x)) +#define DUK__ALLOCTEMP(comp_ctx) duk__alloctemp((comp_ctx)) +#define DUK__ALLOCTEMPS(comp_ctx,count) duk__alloctemps((comp_ctx),(count)) + +/* Flags for intermediate value coercions. A flag for using a forced reg + * is not needed, the forced_reg argument suffices and generates better + * code (it is checked as it is used). + */ +#define DUK__IVAL_FLAG_ALLOW_CONST (1 << 0) /* allow a constant to be returned */ +#define DUK__IVAL_FLAG_REQUIRE_TEMP (1 << 1) /* require a (mutable) temporary as a result */ +#define DUK__IVAL_FLAG_REQUIRE_SHORT (1 << 2) /* require a short (8-bit) reg/const which fits into bytecode B/C slot */ + +/* XXX: some code might benefit from DUK__SETTEMP_IFTEMP(ctx,x) */ + +DUK_LOCAL void duk__copy_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *src, duk_ispec *dst) { + duk_context *ctx = (duk_context *) comp_ctx->thr; + + dst->t = src->t; + dst->regconst = src->regconst; + duk_copy(ctx, src->valstack_idx, dst->valstack_idx); +} + +DUK_LOCAL void duk__copy_ivalue(duk_compiler_ctx *comp_ctx, duk_ivalue *src, duk_ivalue *dst) { + duk_context *ctx = (duk_context *) comp_ctx->thr; + + dst->t = src->t; + dst->op = src->op; + dst->x1.t = src->x1.t; + dst->x1.regconst = src->x1.regconst; + dst->x2.t = src->x2.t; + dst->x2.regconst = src->x2.regconst; + duk_copy(ctx, src->x1.valstack_idx, dst->x1.valstack_idx); + duk_copy(ctx, src->x2.valstack_idx, dst->x2.valstack_idx); +} + +/* XXX: to util */ +DUK_LOCAL duk_bool_t duk__is_whole_get_int32(duk_double_t x, duk_int32_t *ival) { + duk_small_int_t c; + duk_int32_t t; + + c = DUK_FPCLASSIFY(x); + if (c == DUK_FP_NORMAL || (c == DUK_FP_ZERO && !DUK_SIGNBIT(x))) { + /* Don't allow negative zero as it will cause trouble with + * LDINT+LDINTX. But positive zero is OK. + */ + t = (duk_int32_t) x; + if ((duk_double_t) t == x) { + *ival = t; + return 1; + } + } + + return 0; +} + +DUK_LOCAL duk_reg_t duk__alloctemps(duk_compiler_ctx *comp_ctx, duk_small_int_t num) { + duk_reg_t res; + + res = comp_ctx->curr_func.temp_next; + comp_ctx->curr_func.temp_next += num; + + if (comp_ctx->curr_func.temp_next > DUK__MAX_TEMPS) { /* == DUK__MAX_TEMPS is OK */ + DUK_ERROR(comp_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_TEMP_LIMIT); + } + + /* maintain highest 'used' temporary, needed to figure out nregs of function */ + if (comp_ctx->curr_func.temp_next > comp_ctx->curr_func.temp_max) { + comp_ctx->curr_func.temp_max = comp_ctx->curr_func.temp_next; + } + + return res; +} + +DUK_LOCAL duk_reg_t duk__alloctemp(duk_compiler_ctx *comp_ctx) { + return duk__alloctemps(comp_ctx, 1); +} + +DUK_LOCAL void duk__settemp_checkmax(duk_compiler_ctx *comp_ctx, duk_reg_t temp_next) { + comp_ctx->curr_func.temp_next = temp_next; + if (temp_next > comp_ctx->curr_func.temp_max) { + comp_ctx->curr_func.temp_max = temp_next; + } +} + +/* get const for value at valstack top */ +DUK_LOCAL duk_regconst_t duk__getconst(duk_compiler_ctx *comp_ctx) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_compiler_func *f = &comp_ctx->curr_func; + duk_tval *tv1; + duk_int_t i, n, n_check; + + n = (duk_int_t) duk_get_length(ctx, f->consts_idx); + + tv1 = duk_get_tval(ctx, -1); + DUK_ASSERT(tv1 != NULL); + +#if defined(DUK_USE_FASTINT) + /* Explicit check for fastint downgrade. */ + DUK_TVAL_CHKFAST_INPLACE(tv1); +#endif + + /* Sanity workaround for handling functions with a large number of + * constants at least somewhat reasonably. Otherwise checking whether + * we already have the constant would grow very slow (as it is O(N^2)). + */ + n_check = (n > DUK__GETCONST_MAX_CONSTS_CHECK ? DUK__GETCONST_MAX_CONSTS_CHECK : n); + for (i = 0; i < n_check; i++) { + duk_tval *tv2 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, f->h_consts, i); + + /* Strict equality is NOT enough, because we cannot use the same + * constant for e.g. +0 and -0. + */ + if (duk_js_samevalue(tv1, tv2)) { + DUK_DDD(DUK_DDDPRINT("reused existing constant for %!T -> const index %ld", + (duk_tval *) tv1, (long) i)); + duk_pop(ctx); + return (duk_regconst_t) (i | DUK__CONST_MARKER); + } + } + + if (n > DUK__MAX_CONSTS) { + DUK_ERROR(comp_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_CONST_LIMIT); + } + + DUK_DDD(DUK_DDDPRINT("allocating new constant for %!T -> const index %ld", + (duk_tval *) tv1, (long) n)); + (void) duk_put_prop_index(ctx, f->consts_idx, n); /* invalidates tv1, tv2 */ + return (duk_regconst_t) (n | DUK__CONST_MARKER); +} + +/* Get the value represented by an duk_ispec to a register or constant. + * The caller can control the result by indicating whether or not: + * + * (1) a constant is allowed (sometimes the caller needs the result to + * be in a register) + * + * (2) a temporary register is required (usually when caller requires + * the register to be safely mutable; normally either a bound + * register or a temporary register are both OK) + * + * (3) a forced register target needs to be used + * + * Bytecode may be emitted to generate the necessary value. The return + * value is either a register or a constant. + */ + +DUK_LOCAL +duk_regconst_t duk__ispec_toregconst_raw(duk_compiler_ctx *comp_ctx, + duk_ispec *x, + duk_reg_t forced_reg, + duk_small_uint_t flags) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + + DUK_DDD(DUK_DDDPRINT("duk__ispec_toregconst_raw(): x={%ld:%ld:%!T}, " + "forced_reg=%ld, flags 0x%08lx: allow_const=%ld require_temp=%ld require_short=%ld", + (long) x->t, + (long) x->regconst, + (duk_tval *) duk_get_tval(ctx, x->valstack_idx), + (long) forced_reg, + (unsigned long) flags, + (long) ((flags & DUK__IVAL_FLAG_ALLOW_CONST) ? 1 : 0), + (long) ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) ? 1 : 0), + (long) ((flags & DUK__IVAL_FLAG_REQUIRE_SHORT) ? 1 : 0))); + + switch (x->t) { + case DUK_ISPEC_VALUE: { + duk_tval *tv; + + tv = duk_get_tval(ctx, x->valstack_idx); + DUK_ASSERT(tv != NULL); + + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: { + /* Note: although there is no 'undefined' literal, undefined + * values can occur during compilation as a result of e.g. + * the 'void' operator. + */ + duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx)); + duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_LDUNDEF, (duk_regconst_t) dest); + return (duk_regconst_t) dest; + } + case DUK_TAG_NULL: { + duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx)); + duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_LDNULL, (duk_regconst_t) dest); + return (duk_regconst_t) dest; + } + case DUK_TAG_BOOLEAN: { + duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx)); + duk__emit_extraop_bc(comp_ctx, + (DUK_TVAL_GET_BOOLEAN(tv) ? DUK_EXTRAOP_LDTRUE : DUK_EXTRAOP_LDFALSE), + (duk_regconst_t) dest); + return (duk_regconst_t) dest; + } + case DUK_TAG_POINTER: { + DUK_UNREACHABLE(); + break; + } + case DUK_TAG_STRING: { + duk_hstring *h; + duk_reg_t dest; + duk_regconst_t constidx; + + h = DUK_TVAL_GET_STRING(tv); + DUK_UNREF(h); + DUK_ASSERT(h != NULL); + +#if 0 /* XXX: to be implemented? */ + /* Use special opcodes to load short strings */ + if (DUK_HSTRING_GET_BYTELEN(h) <= 2) { + /* Encode into a single opcode (18 bits can encode 1-2 bytes + length indicator) */ + } else if (DUK_HSTRING_GET_BYTELEN(h) <= 6) { + /* Encode into a double constant (53 bits can encode 6*8 = 48 bits + 3-bit length */ + } +#endif + duk_dup(ctx, x->valstack_idx); + constidx = duk__getconst(comp_ctx); + + if (flags & DUK__IVAL_FLAG_ALLOW_CONST) { + return constidx; + } + + dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx)); + duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, constidx); + return (duk_regconst_t) dest; + } + case DUK_TAG_OBJECT: { + DUK_UNREACHABLE(); + break; + } + case DUK_TAG_BUFFER: { + DUK_UNREACHABLE(); + break; + } + case DUK_TAG_LIGHTFUNC: { + DUK_UNREACHABLE(); + break; + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: { + /* number */ + duk_reg_t dest; + duk_regconst_t constidx; + duk_double_t dval; + duk_int32_t ival; + + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + dval = DUK_TVAL_GET_NUMBER(tv); + + if (!(flags & DUK__IVAL_FLAG_ALLOW_CONST)) { + /* A number can be loaded either through a constant, using + * LDINT, or using LDINT+LDINTX. LDINT is always a size win, + * LDINT+LDINTX is not if the constant is used multiple times. + * Currently always prefer LDINT+LDINTX over a double constant. + */ + + if (duk__is_whole_get_int32(dval, &ival)) { + dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx)); + duk__emit_load_int32(comp_ctx, dest, ival); + return (duk_regconst_t) dest; + } + } + + duk_dup(ctx, x->valstack_idx); + constidx = duk__getconst(comp_ctx); + + if (flags & DUK__IVAL_FLAG_ALLOW_CONST) { + return constidx; + } else { + dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx)); + duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, constidx); + return (duk_regconst_t) dest; + } + } + } /* end switch */ + } + case DUK_ISPEC_REGCONST: { + if ((x->regconst & DUK__CONST_MARKER) && !(flags & DUK__IVAL_FLAG_ALLOW_CONST)) { + duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx)); + duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, x->regconst); + return (duk_regconst_t) dest; + } else { + if (forced_reg >= 0) { + if (x->regconst != (duk_regconst_t) forced_reg) { + duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, forced_reg, x->regconst); + } + return (duk_regconst_t) forced_reg; + } else { + if ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) && !DUK__ISTEMP(comp_ctx, x->regconst)) { + duk_reg_t dest = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, (duk_regconst_t) dest, x->regconst); + return (duk_regconst_t) dest; + } else { + return x->regconst; + } + } + } + } + default: { + break; + } + } + + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR); + return 0; +} + +DUK_LOCAL void duk__ispec_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ispec *x, duk_reg_t forced_reg) { + DUK_ASSERT(forced_reg >= 0); + (void) duk__ispec_toregconst_raw(comp_ctx, x, forced_reg, 0 /*flags*/); +} + +/* Coerce an duk_ivalue to a 'plain' value by generating the necessary + * arithmetic operations, property access, or variable access bytecode. + * The duk_ivalue argument ('x') is converted into a plain value as a + * side effect. + */ +DUK_LOCAL void duk__ivalue_toplain_raw(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_reg_t forced_reg) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + + DUK_DDD(DUK_DDDPRINT("duk__ivalue_toplain_raw(): x={t=%ld,op=%ld,x1={%ld:%ld:%!T},x2={%ld:%ld:%!T}}, " + "forced_reg=%ld", + (long) x->t, (long) x->op, + (long) x->x1.t, (long) x->x1.regconst, + (duk_tval *) duk_get_tval(ctx, x->x1.valstack_idx), + (long) x->x2.t, (long) x->x2.regconst, + (duk_tval *) duk_get_tval(ctx, x->x2.valstack_idx), + (long) forced_reg)); + + switch (x->t) { + case DUK_IVAL_PLAIN: { + return; + } + /* XXX: support unary arithmetic ivalues (useful?) */ + case DUK_IVAL_ARITH: + case DUK_IVAL_ARITH_EXTRAOP: { + duk_regconst_t arg1; + duk_regconst_t arg2; + duk_reg_t dest; + duk_tval *tv1; + duk_tval *tv2; + + DUK_DDD(DUK_DDDPRINT("arith to plain conversion")); + + /* inline arithmetic check for constant values */ + /* XXX: use the exactly same arithmetic function here as in executor */ + if (x->x1.t == DUK_ISPEC_VALUE && x->x2.t == DUK_ISPEC_VALUE && x->t == DUK_IVAL_ARITH) { + tv1 = duk_get_tval(ctx, x->x1.valstack_idx); + tv2 = duk_get_tval(ctx, x->x2.valstack_idx); + DUK_ASSERT(tv1 != NULL); + DUK_ASSERT(tv2 != NULL); + + DUK_DDD(DUK_DDDPRINT("arith: tv1=%!T, tv2=%!T", + (duk_tval *) tv1, + (duk_tval *) tv2)); + + if (DUK_TVAL_IS_NUMBER(tv1) && DUK_TVAL_IS_NUMBER(tv2)) { + duk_double_t d1 = DUK_TVAL_GET_NUMBER(tv1); + duk_double_t d2 = DUK_TVAL_GET_NUMBER(tv2); + duk_double_t d3; + duk_bool_t accept = 1; + + DUK_DDD(DUK_DDDPRINT("arith inline check: d1=%lf, d2=%lf, op=%ld", + (double) d1, (double) d2, (long) x->op)); + switch (x->op) { + case DUK_OP_ADD: d3 = d1 + d2; break; + case DUK_OP_SUB: d3 = d1 - d2; break; + case DUK_OP_MUL: d3 = d1 * d2; break; + case DUK_OP_DIV: d3 = d1 / d2; break; + default: accept = 0; break; + } + + if (accept) { + duk_double_union du; + du.d = d3; + DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du); + d3 = du.d; + + x->t = DUK_IVAL_PLAIN; + DUK_ASSERT(x->x1.t == DUK_ISPEC_VALUE); + DUK_TVAL_SET_NUMBER(tv1, d3); /* old value is number: no refcount */ + return; + } + } else if (x->op == DUK_OP_ADD && DUK_TVAL_IS_STRING(tv1) && DUK_TVAL_IS_STRING(tv2)) { + /* inline string concatenation */ + duk_dup(ctx, x->x1.valstack_idx); + duk_dup(ctx, x->x2.valstack_idx); + duk_concat(ctx, 2); + duk_replace(ctx, x->x1.valstack_idx); + x->t = DUK_IVAL_PLAIN; + DUK_ASSERT(x->x1.t == DUK_ISPEC_VALUE); + return; + } + } + + arg1 = duk__ispec_toregconst_raw(comp_ctx, &x->x1, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/); + arg2 = duk__ispec_toregconst_raw(comp_ctx, &x->x2, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/); + + /* If forced reg, use it as destination. Otherwise try to + * use either coerced ispec if it is a temporary. + * + * When using extraops, avoid reusing arg2 as dest because that + * would lead to an LDREG shuffle below. We still can't guarantee + * dest != arg2 because we may have a forced_reg. + */ + if (forced_reg >= 0) { + dest = forced_reg; + } else if (DUK__ISTEMP(comp_ctx, arg1)) { + dest = (duk_reg_t) arg1; + } else if (DUK__ISTEMP(comp_ctx, arg2) && x->t != DUK_IVAL_ARITH_EXTRAOP) { + dest = (duk_reg_t) arg2; + } else { + dest = DUK__ALLOCTEMP(comp_ctx); + } + + /* Extraop arithmetic opcodes must have destination same as + * first source. If second source matches destination we need + * a temporary register to avoid clobbering the second source. + * + * XXX: change calling code to avoid this situation in most cases. + */ + + if (x->t == DUK_IVAL_ARITH_EXTRAOP) { + if (!(DUK__ISREG(comp_ctx, arg1) && (duk_reg_t) arg1 == dest)) { + if (DUK__ISREG(comp_ctx, arg2) && (duk_reg_t) arg2 == dest) { + /* arg2 would be clobbered so reassign it to a temp. */ + duk_reg_t tempreg; + tempreg = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, tempreg, arg2); + arg2 = tempreg; + } + + if (DUK__ISREG(comp_ctx, arg1)) { + duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, dest, arg1); + } else { + DUK_ASSERT(DUK__ISCONST(comp_ctx, arg1)); + duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, dest, arg1); + } + } + + /* Note: special DUK__EMIT_FLAG_B_IS_TARGETSOURCE + * used to indicate that B is both a source and a + * target register. When shuffled, it needs to be + * both input and output shuffled. + */ + DUK_ASSERT(DUK__ISREG(comp_ctx, dest)); + duk__emit_extraop_b_c(comp_ctx, + x->op | DUK__EMIT_FLAG_B_IS_TARGET | + DUK__EMIT_FLAG_B_IS_TARGETSOURCE, + (duk_regconst_t) dest, + (duk_regconst_t) arg2); + + } else { + DUK_ASSERT(DUK__ISREG(comp_ctx, dest)); + duk__emit_a_b_c(comp_ctx, x->op, (duk_regconst_t) dest, arg1, arg2); + } + + x->t = DUK_IVAL_PLAIN; + x->x1.t = DUK_ISPEC_REGCONST; + x->x1.regconst = (duk_regconst_t) dest; + return; + } + case DUK_IVAL_PROP: { + /* XXX: very similar to DUK_IVAL_ARITH - merge? */ + duk_regconst_t arg1; + duk_regconst_t arg2; + duk_reg_t dest; + + /* Need a short reg/const, does not have to be a mutable temp. */ + arg1 = duk__ispec_toregconst_raw(comp_ctx, &x->x1, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/); + arg2 = duk__ispec_toregconst_raw(comp_ctx, &x->x2, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/); + + /* Pick a destination register. If either base value or key + * happens to be a temp value, reuse it as the destination. + * + * XXX: The temp must be a "mutable" one, i.e. such that no + * other expression is using it anymore. Here this should be + * the case because the value of a property access expression + * is neither the base nor the key, but the lookup result. + */ + + if (forced_reg >= 0) { + dest = forced_reg; + } else if (DUK__ISTEMP(comp_ctx, arg1)) { + dest = (duk_reg_t) arg1; + } else if (DUK__ISTEMP(comp_ctx, arg2)) { + dest = (duk_reg_t) arg2; + } else { + dest = DUK__ALLOCTEMP(comp_ctx); + } + + duk__emit_a_b_c(comp_ctx, DUK_OP_GETPROP, (duk_regconst_t) dest, arg1, arg2); + + x->t = DUK_IVAL_PLAIN; + x->x1.t = DUK_ISPEC_REGCONST; + x->x1.regconst = (duk_regconst_t) dest; + return; + } + case DUK_IVAL_VAR: { + /* x1 must be a string */ + duk_reg_t dest; + duk_reg_t reg_varbind; + duk_regconst_t rc_varname; + + DUK_ASSERT(x->x1.t == DUK_ISPEC_VALUE); + + duk_dup(ctx, x->x1.valstack_idx); + if (duk__lookup_lhs(comp_ctx, ®_varbind, &rc_varname)) { + x->t = DUK_IVAL_PLAIN; + x->x1.t = DUK_ISPEC_REGCONST; + x->x1.regconst = (duk_regconst_t) reg_varbind; + } else { + dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx)); + duk__emit_a_bc(comp_ctx, DUK_OP_GETVAR, (duk_regconst_t) dest, rc_varname); + x->t = DUK_IVAL_PLAIN; + x->x1.t = DUK_ISPEC_REGCONST; + x->x1.regconst = (duk_regconst_t) dest; + } + return; + } + case DUK_IVAL_NONE: + default: { + break; + } + } + + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR); + return; +} + +/* evaluate to plain value, no forced register (temp/bound reg both ok) */ +DUK_LOCAL void duk__ivalue_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *x) { + duk__ivalue_toplain_raw(comp_ctx, x, -1 /*forced_reg*/); +} + +/* evaluate to final form (e.g. coerce GETPROP to code), throw away temp */ +DUK_LOCAL void duk__ivalue_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *x) { + duk_reg_t temp; + + /* If duk__ivalue_toplain_raw() allocates a temp, forget it and + * restore next temp state. + */ + temp = DUK__GETTEMP(comp_ctx); + duk__ivalue_toplain_raw(comp_ctx, x, -1 /*forced_reg*/); + DUK__SETTEMP(comp_ctx, temp); +} + +/* Coerce an duk_ivalue to a register or constant; result register may + * be a temp or a bound register. + * + * The duk_ivalue argument ('x') is converted into a regconst as a + * side effect. + */ +DUK_LOCAL +duk_regconst_t duk__ivalue_toregconst_raw(duk_compiler_ctx *comp_ctx, + duk_ivalue *x, + duk_reg_t forced_reg, + duk_small_uint_t flags) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_regconst_t reg; + DUK_UNREF(thr); + DUK_UNREF(ctx); + + DUK_DDD(DUK_DDDPRINT("duk__ivalue_toregconst_raw(): x={t=%ld,op=%ld,x1={%ld:%ld:%!T},x2={%ld:%ld:%!T}}, " + "forced_reg=%ld, flags 0x%08lx: allow_const=%ld require_temp=%ld require_short=%ld", + (long) x->t, (long) x->op, + (long) x->x1.t, (long) x->x1.regconst, + (duk_tval *) duk_get_tval(ctx, x->x1.valstack_idx), + (long) x->x2.t, (long) x->x2.regconst, + (duk_tval *) duk_get_tval(ctx, x->x2.valstack_idx), + (long) forced_reg, + (unsigned long) flags, + (long) ((flags & DUK__IVAL_FLAG_ALLOW_CONST) ? 1 : 0), + (long) ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) ? 1 : 0), + (long) ((flags & DUK__IVAL_FLAG_REQUIRE_SHORT) ? 1 : 0))); + + /* first coerce to a plain value */ + duk__ivalue_toplain_raw(comp_ctx, x, forced_reg); + DUK_ASSERT(x->t == DUK_IVAL_PLAIN); + + /* then to a register */ + reg = duk__ispec_toregconst_raw(comp_ctx, &x->x1, forced_reg, flags); + x->x1.t = DUK_ISPEC_REGCONST; + x->x1.regconst = reg; + + return reg; +} + +DUK_LOCAL duk_reg_t duk__ivalue_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x) { + return duk__ivalue_toregconst_raw(comp_ctx, x, -1, 0 /*flags*/); +} + +#if 0 /* unused */ +DUK_LOCAL duk_reg_t duk__ivalue_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x) { + return duk__ivalue_toregconst_raw(comp_ctx, x, -1, DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/); +} +#endif + +DUK_LOCAL void duk__ivalue_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_int_t forced_reg) { + DUK_ASSERT(forced_reg >= 0); + (void) duk__ivalue_toregconst_raw(comp_ctx, x, forced_reg, 0 /*flags*/); +} + +DUK_LOCAL duk_regconst_t duk__ivalue_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *x) { + return duk__ivalue_toregconst_raw(comp_ctx, x, -1, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/); +} + +/* The issues below can be solved with better flags */ + +/* XXX: many operations actually want toforcedtemp() -- brand new temp? */ +/* XXX: need a toplain_ignore() which will only coerce a value to a temp + * register if it might have a side effect. Side-effect free values do not + * need to be coerced. + */ + +/* + * Identifier handling + */ + +DUK_LOCAL duk_reg_t duk__lookup_active_register_binding(duk_compiler_ctx *comp_ctx) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_hstring *h_varname; + duk_reg_t ret; + + DUK_DDD(DUK_DDDPRINT("resolving identifier reference to '%!T'", + (duk_tval *) duk_get_tval(ctx, -1))); + + /* + * Special name handling + */ + + h_varname = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_varname != NULL); + + if (h_varname == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)) { + DUK_DDD(DUK_DDDPRINT("flagging function as accessing 'arguments'")); + comp_ctx->curr_func.id_access_arguments = 1; + } + + /* + * Inside one or more 'with' statements fall back to slow path always. + * (See e.g. test-stmt-with.js.) + */ + + if (comp_ctx->curr_func.with_depth > 0) { + DUK_DDD(DUK_DDDPRINT("identifier lookup inside a 'with' -> fall back to slow path")); + goto slow_path; + } + + /* + * Any catch bindings ("catch (e)") also affect identifier binding. + * + * Currently, the varmap is modified for the duration of the catch + * clause to ensure any identifier accesses with the catch variable + * name will use slow path. + */ + + duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx); + if (duk_is_number(ctx, -1)) { + ret = duk_to_int(ctx, -1); + duk_pop(ctx); + } else { + duk_pop(ctx); + goto slow_path; + } + + DUK_DDD(DUK_DDDPRINT("identifier lookup -> reg %ld", (long) ret)); + return ret; + + slow_path: + DUK_DDD(DUK_DDDPRINT("identifier lookup -> slow path")); + + comp_ctx->curr_func.id_access_slow = 1; + return (duk_reg_t) -1; +} + +/* Lookup an identifier name in the current varmap, indicating whether the + * identifier is register-bound and if not, allocating a constant for the + * identifier name. Returns 1 if register-bound, 0 otherwise. Caller can + * also check (out_reg_varbind >= 0) to check whether or not identifier is + * register bound. The caller must NOT use out_rc_varname at all unless + * return code is 0 or out_reg_varbind is < 0; this is becuase out_rc_varname + * is unsigned and doesn't have a "unused" / none value. + */ +DUK_LOCAL duk_bool_t duk__lookup_lhs(duk_compiler_ctx *comp_ctx, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_reg_t reg_varbind; + duk_regconst_t rc_varname; + + /* [ ... varname ] */ + + duk_dup_top(ctx); + reg_varbind = duk__lookup_active_register_binding(comp_ctx); + + if (reg_varbind >= 0) { + *out_reg_varbind = reg_varbind; + *out_rc_varname = 0; /* duk_regconst_t is unsigned, so use 0 as dummy value (ignored by caller) */ + duk_pop(ctx); + return 1; + } else { + rc_varname = duk__getconst(comp_ctx); + *out_reg_varbind = -1; + *out_rc_varname = rc_varname; + return 0; + } +} + +/* + * Label handling + * + * Labels are initially added with flags prohibiting both break and continue. + * When the statement type is finally uncovered (after potentially multiple + * labels), all the labels are updated to allow/prohibit break and continue. + */ + +DUK_LOCAL void duk__add_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_int_t pc_label, duk_int_t label_id) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_size_t n; + duk_size_t new_size; + duk_uint8_t *p; + duk_labelinfo *li_start, *li; + + /* Duplicate (shadowing) labels are not allowed, except for the empty + * labels (which are used as default labels for switch and iteration + * statements). + * + * We could also allow shadowing of non-empty pending labels without any + * other issues than breaking the required label shadowing requirements + * of the E5 specification, see Section 12.12. + */ + + p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos); + li_start = (duk_labelinfo *) (void *) p; + li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); + n = (duk_size_t) (li - li_start); + + while (li > li_start) { + li--; + + if (li->h_label == h_label && h_label != DUK_HTHREAD_STRING_EMPTY_STRING(thr)) { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_DUPLICATE_LABEL); + } + } + + duk_push_hstring(ctx, h_label); + DUK_ASSERT(n <= DUK_UARRIDX_MAX); /* label limits */ + (void) duk_put_prop_index(ctx, comp_ctx->curr_func.labelnames_idx, (duk_uarridx_t) n); + + new_size = (n + 1) * sizeof(duk_labelinfo); + duk_hbuffer_resize(thr, comp_ctx->curr_func.h_labelinfos, new_size); + /* XXX: spare handling, slow now */ + + /* relookup after possible realloc */ + p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos); + li_start = (duk_labelinfo *) (void *) p; + DUK_UNREF(li_start); /* silence scan-build warning */ + li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); + li--; + + /* Labels can be used for iteration statements but also for other statements, + * in particular a label can be used for a block statement. All cases of a + * named label accept a 'break' so that flag is set here. Iteration statements + * also allow 'continue', so that flag is updated when we figure out the + * statement type. + */ + + li->flags = DUK_LABEL_FLAG_ALLOW_BREAK; + li->label_id = label_id; + li->h_label = h_label; + li->catch_depth = comp_ctx->curr_func.catch_depth; /* catch depth from current func */ + li->pc_label = pc_label; + + DUK_DDD(DUK_DDDPRINT("registered label: flags=0x%08lx, id=%ld, name=%!O, catch_depth=%ld, pc_label=%ld", + (unsigned long) li->flags, (long) li->label_id, (duk_heaphdr *) li->h_label, + (long) li->catch_depth, (long) li->pc_label)); +} + +/* Update all labels with matching label_id. */ +DUK_LOCAL void duk__update_label_flags(duk_compiler_ctx *comp_ctx, duk_int_t label_id, duk_small_uint_t flags) { + duk_uint8_t *p; + duk_labelinfo *li_start, *li; + + p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(comp_ctx->thr->heap, comp_ctx->curr_func.h_labelinfos); + li_start = (duk_labelinfo *) (void *) p; + li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); + + /* Match labels starting from latest; once label_id no longer matches, we can + * safely exit without checking the rest of the labels (only the topmost labels + * are ever updated). + */ + while (li > li_start) { + li--; + + if (li->label_id != label_id) { + break; + } + + DUK_DDD(DUK_DDDPRINT("updating (overwriting) label flags for li=%p, label_id=%ld, flags=%ld", + (void *) li, (long) label_id, (long) flags)); + + li->flags = flags; + } +} + +/* Lookup active label information. Break/continue distinction is necessary to handle switch + * statement related labels correctly: a switch will only catch a 'break', not a 'continue'. + * + * An explicit label cannot appear multiple times in the active set, but empty labels (unlabelled + * iteration and switch statements) can. A break will match the closest unlabelled or labelled + * statement. A continue will match the closest unlabelled or labelled iteration statement. It is + * a syntax error if a continue matches a labelled switch statement; because an explicit label cannot + * be duplicated, the continue cannot match any valid label outside the switch. + * + * A side effect of these rules is that a LABEL statement related to a switch should never actually + * catch a continue abrupt completion at run-time. Hence an INVALID opcode can be placed in the + * continue slot of the switch's LABEL statement. + */ + +/* XXX: awkward, especially the bunch of separate output values -> output struct? */ +DUK_LOCAL void duk__lookup_active_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_bool_t is_break, duk_int_t *out_label_id, duk_int_t *out_label_catch_depth, duk_int_t *out_label_pc, duk_bool_t *out_is_closest) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_uint8_t *p; + duk_labelinfo *li_start, *li_end, *li; + duk_bool_t match = 0; + + DUK_DDD(DUK_DDDPRINT("looking up active label: label='%!O', is_break=%ld", + (duk_heaphdr *) h_label, (long) is_break)); + + DUK_UNREF(ctx); + + p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos); + li_start = (duk_labelinfo *) (void *) p; + li_end = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); + li = li_end; + + /* Match labels starting from latest label because there can be duplicate empty + * labels in the label set. + */ + while (li > li_start) { + li--; + + if (li->h_label != h_label) { + DUK_DDD(DUK_DDDPRINT("labelinfo[%ld] ->'%!O' != %!O", + (long) (li - li_start), + (duk_heaphdr *) li->h_label, + (duk_heaphdr *) h_label)); + continue; + } + + DUK_DDD(DUK_DDDPRINT("labelinfo[%ld] -> '%!O' label name matches (still need to check type)", + (long) (li - li_start), (duk_heaphdr *) h_label)); + + /* currently all labels accept a break, so no explicit check for it now */ + DUK_ASSERT(li->flags & DUK_LABEL_FLAG_ALLOW_BREAK); + + if (is_break) { + /* break matches always */ + match = 1; + break; + } else if (li->flags & DUK_LABEL_FLAG_ALLOW_CONTINUE) { + /* iteration statements allow continue */ + match = 1; + break; + } else { + /* continue matched this label -- we can only continue if this is the empty + * label, for which duplication is allowed, and thus there is hope of + * finding a match deeper in the label stack. + */ + if (h_label != DUK_HTHREAD_STRING_EMPTY_STRING(thr)) { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_LABEL); + } else { + DUK_DDD(DUK_DDDPRINT("continue matched an empty label which does not " + "allow a continue -> continue lookup deeper in label stack")); + } + } + } + /* XXX: match flag is awkward, rework */ + if (!match) { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_LABEL); + } + + DUK_DDD(DUK_DDDPRINT("label match: %!O -> label_id %ld, catch_depth=%ld, pc_label=%ld", + (duk_heaphdr *) h_label, (long) li->label_id, + (long) li->catch_depth, (long) li->pc_label)); + + *out_label_id = li->label_id; + *out_label_catch_depth = li->catch_depth; + *out_label_pc = li->pc_label; + *out_is_closest = (li == li_end - 1); +} + +DUK_LOCAL void duk__reset_labels_to_length(duk_compiler_ctx *comp_ctx, duk_int_t len) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_size_t new_size; + + /* XXX: duk_set_length */ + new_size = sizeof(duk_labelinfo) * (duk_size_t) len; + duk_push_int(ctx, len); + duk_put_prop_stridx(ctx, comp_ctx->curr_func.labelnames_idx, DUK_STRIDX_LENGTH); + duk_hbuffer_resize(thr, comp_ctx->curr_func.h_labelinfos, new_size); +} + +/* + * Expression parsing: duk__expr_nud(), duk__expr_led(), duk__expr_lbp(), and helpers. + * + * - duk__expr_nud(): ("null denotation"): process prev_token as a "start" of an expression (e.g. literal) + * - duk__expr_led(): ("left denotation"): process prev_token in the "middle" of an expression (e.g. operator) + * - duk__expr_lbp(): ("left-binding power"): return left-binding power of curr_token + */ + +/* object literal key tracking flags */ +#define DUK__OBJ_LIT_KEY_PLAIN (1 << 0) /* key encountered as a plain property */ +#define DUK__OBJ_LIT_KEY_GET (1 << 1) /* key encountered as a getter */ +#define DUK__OBJ_LIT_KEY_SET (1 << 2) /* key encountered as a setter */ + +DUK_LOCAL void duk__nud_array_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { + duk_hthread *thr = comp_ctx->thr; + duk_reg_t reg_obj; /* result reg */ + duk_reg_t reg_temp; /* temp reg */ + duk_reg_t temp_start; /* temp reg value for start of loop */ + duk_small_uint_t max_init_values; /* max # of values initialized in one MPUTARR set */ + duk_small_uint_t num_values; /* number of values in current MPUTARR set */ + duk_uarridx_t curr_idx; /* current (next) array index */ + duk_uarridx_t start_idx; /* start array index of current MPUTARR set */ + duk_uarridx_t init_idx; /* last array index explicitly initialized, +1 */ + duk_bool_t require_comma; /* next loop requires a comma */ + + /* DUK_TOK_LBRACKET already eaten, current token is right after that */ + DUK_ASSERT(comp_ctx->prev_token.t == DUK_TOK_LBRACKET); + + max_init_values = DUK__MAX_ARRAY_INIT_VALUES; /* XXX: depend on available temps? */ + + reg_obj = DUK__ALLOCTEMP(comp_ctx); + duk__emit_extraop_b_c(comp_ctx, + DUK_EXTRAOP_NEWARR | DUK__EMIT_FLAG_B_IS_TARGET, + reg_obj, + 0); /* XXX: patch initial size afterwards? */ + temp_start = DUK__GETTEMP(comp_ctx); + + /* + * Emit initializers in sets of maximum max_init_values. + * Corner cases such as single value initializers do not have + * special handling now. + * + * Elided elements must not be emitted as 'undefined' values, + * because such values would be enumerable (which is incorrect). + * Also note that trailing elisions must be reflected in the + * length of the final array but cause no elements to be actually + * inserted. + */ + + curr_idx = 0; + init_idx = 0; /* tracks maximum initialized index + 1 */ + start_idx = 0; + require_comma = 0; + + for (;;) { + num_values = 0; + DUK__SETTEMP(comp_ctx, temp_start); + + if (comp_ctx->curr_token.t == DUK_TOK_RBRACKET) { + break; + } + + for (;;) { + if (comp_ctx->curr_token.t == DUK_TOK_RBRACKET) { + /* the outer loop will recheck and exit */ + break; + } + + /* comma check */ + if (require_comma) { + if (comp_ctx->curr_token.t == DUK_TOK_COMMA) { + /* comma after a value, expected */ + duk__advance(comp_ctx); + require_comma = 0; + continue; + } else { + goto syntax_error; + } + } else { + if (comp_ctx->curr_token.t == DUK_TOK_COMMA) { + /* elision - flush */ + curr_idx++; + duk__advance(comp_ctx); + /* if num_values > 0, MPUTARR emitted by outer loop after break */ + break; + } + } + /* else an array initializer element */ + + /* initial index */ + if (num_values == 0) { + start_idx = curr_idx; + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__emit_load_int32(comp_ctx, reg_temp, (duk_int32_t) start_idx); + } + + reg_temp = DUK__ALLOCTEMP(comp_ctx); /* alloc temp just in case, to update max temp */ + DUK__SETTEMP(comp_ctx, reg_temp); + duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/); + DUK__SETTEMP(comp_ctx, reg_temp + 1); + + num_values++; + curr_idx++; + require_comma = 1; + + if (num_values >= max_init_values) { + /* MPUTARR emitted by outer loop */ + break; + } + } + + if (num_values > 0) { + /* - A is a source register (it's not a write target, but used + * to identify the target object) but can be shuffled. + * - B cannot be shuffled normally because it identifies a range + * of registers, the emitter has special handling for this + * (the "no shuffle" flag must not be set). + * - C is a non-register number and cannot be shuffled, but + * never needs to be. + */ + duk__emit_a_b_c(comp_ctx, + DUK_OP_MPUTARR | + DUK__EMIT_FLAG_NO_SHUFFLE_C | + DUK__EMIT_FLAG_A_IS_SOURCE, + (duk_regconst_t) reg_obj, + (duk_regconst_t) temp_start, + (duk_regconst_t) num_values); + init_idx = start_idx + num_values; + + /* num_values and temp_start reset at top of outer loop */ + } + } + + DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RBRACKET); + duk__advance(comp_ctx); + + DUK_DDD(DUK_DDDPRINT("array literal done, curridx=%ld, initidx=%ld", + (long) curr_idx, (long) init_idx)); + + /* trailing elisions? */ + if (curr_idx > init_idx) { + /* yes, must set array length explicitly */ + DUK_DDD(DUK_DDDPRINT("array literal has trailing elisions which affect its length")); + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__emit_load_int32(comp_ctx, reg_temp, (duk_int_t) curr_idx); + duk__emit_extraop_b_c(comp_ctx, + DUK_EXTRAOP_SETALEN, + (duk_regconst_t) reg_obj, + (duk_regconst_t) reg_temp); + } + + DUK__SETTEMP(comp_ctx, temp_start); + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_obj; + return; + + syntax_error: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_ARRAY_LITERAL); +} + +/* duplicate/invalid key checks; returns 1 if syntax error */ +DUK_LOCAL duk_bool_t duk__nud_object_literal_key_check(duk_compiler_ctx *comp_ctx, duk_small_uint_t new_key_flags) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_small_uint_t key_flags; + + /* [ ... key_obj key ] */ + + DUK_ASSERT(duk_is_string(ctx, -1)); + + /* + * 'key_obj' tracks keys encountered so far by associating an + * integer with flags with already encountered keys. The checks + * below implement E5 Section 11.1.5, step 4 for production: + * + * PropertyNameAndValueList: PropertyNameAndValueList , PropertyAssignment + */ + + duk_dup(ctx, -1); /* [ ... key_obj key key ] */ + duk_get_prop(ctx, -3); /* [ ... key_obj key val ] */ + key_flags = duk_to_int(ctx, -1); + duk_pop(ctx); /* [ ... key_obj key ] */ + + if (new_key_flags & DUK__OBJ_LIT_KEY_PLAIN) { + if ((key_flags & DUK__OBJ_LIT_KEY_PLAIN) && comp_ctx->curr_func.is_strict) { + /* step 4.a */ + DUK_DDD(DUK_DDDPRINT("duplicate key: plain key appears twice in strict mode")); + return 1; + } + if (key_flags & (DUK__OBJ_LIT_KEY_GET | DUK__OBJ_LIT_KEY_SET)) { + /* step 4.c */ + DUK_DDD(DUK_DDDPRINT("duplicate key: plain key encountered after setter/getter")); + return 1; + } + } else { + if (key_flags & DUK__OBJ_LIT_KEY_PLAIN) { + /* step 4.b */ + DUK_DDD(DUK_DDDPRINT("duplicate key: getter/setter encountered after plain key")); + return 1; + } + if (key_flags & new_key_flags) { + /* step 4.d */ + DUK_DDD(DUK_DDDPRINT("duplicate key: getter/setter encountered twice")); + return 1; + } + } + + new_key_flags |= key_flags; + DUK_DDD(DUK_DDDPRINT("setting/updating key %!T flags: 0x%08lx -> 0x%08lx", + (duk_tval *) duk_get_tval(ctx, -1), + (unsigned long) key_flags, + (unsigned long) new_key_flags)); + duk_dup(ctx, -1); + duk_push_int(ctx, new_key_flags); /* [ ... key_obj key key flags ] */ + duk_put_prop(ctx, -4); /* [ ... key_obj key ] */ + + return 0; +} + +DUK_LOCAL void duk__nud_object_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_reg_t reg_obj; /* result reg */ + duk_reg_t reg_key; /* temp reg for key literal */ + duk_reg_t reg_temp; /* temp reg */ + duk_reg_t temp_start; /* temp reg value for start of loop */ + duk_small_uint_t max_init_pairs; /* max # of key-value pairs initialized in one MPUTOBJ set */ + duk_small_uint_t num_pairs; /* number of pairs in current MPUTOBJ set */ + duk_bool_t first; /* first value: comma must not precede the value */ + duk_bool_t is_set, is_get; /* temps */ + + DUK_ASSERT(comp_ctx->prev_token.t == DUK_TOK_LCURLY); + + max_init_pairs = DUK__MAX_OBJECT_INIT_PAIRS; /* XXX: depend on available temps? */ + + reg_obj = DUK__ALLOCTEMP(comp_ctx); + duk__emit_extraop_b_c(comp_ctx, + DUK_EXTRAOP_NEWOBJ | DUK__EMIT_FLAG_B_IS_TARGET, + reg_obj, + 0); /* XXX: patch initial size afterwards? */ + temp_start = DUK__GETTEMP(comp_ctx); + + /* temp object for tracking / detecting duplicate keys */ + duk_push_object(ctx); + + /* + * Emit initializers in sets of maximum max_init_pairs keys. + * Setter/getter is handled separately and terminates the + * current set of initializer values. Corner cases such as + * single value initializers do not have special handling now. + */ + + first = 1; + for (;;) { + num_pairs = 0; + DUK__SETTEMP(comp_ctx, temp_start); + + if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) { + break; + } + + for (;;) { + /* + * Three possible element formats: + * 1) PropertyName : AssignmentExpression + * 2) get PropertyName () { FunctionBody } + * 3) set PropertyName ( PropertySetParameterList ) { FunctionBody } + * + * PropertyName can be IdentifierName (includes reserved words), a string + * literal, or a number literal. Note that IdentifierName allows 'get' and + * 'set' too, so we need to look ahead to the next token to distinguish: + * + * { get : 1 } + * + * and + * + * { get foo() { return 1 } } + * { get get() { return 1 } } // 'get' as getter propertyname + * + * Finally, a trailing comma is allowed. + * + * Key name is coerced to string at compile time (and ends up as a + * a string constant) even for numeric keys (e.g. "{1:'foo'}"). + * These could be emitted using e.g. LDINT, but that seems hardly + * worth the effort and would increase code size. + */ + + DUK_DDD(DUK_DDDPRINT("object literal inner loop, curr_token->t = %ld", + (long) comp_ctx->curr_token.t)); + + if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) { + /* the outer loop will recheck and exit */ + break; + } + if (num_pairs >= max_init_pairs) { + /* MPUTOBJ emitted by outer loop */ + break; + } + + if (first) { + first = 0; + } else { + if (comp_ctx->curr_token.t != DUK_TOK_COMMA) { + goto syntax_error; + } + duk__advance(comp_ctx); + if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) { + /* trailing comma followed by rcurly */ + break; + } + } + + /* advance to get one step of lookup */ + duk__advance(comp_ctx); + + /* NOTE: "get" and "set" are not officially ReservedWords and the lexer + * currently treats them always like ordinary identifiers (DUK_TOK_GET + * and DUK_TOK_SET are unused). They need to be detected based on the + * identifier string content. + */ + + is_get = (comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER && + comp_ctx->prev_token.str1 == DUK_HTHREAD_STRING_GET(thr)); + is_set = (comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER && + comp_ctx->prev_token.str1 == DUK_HTHREAD_STRING_SET(thr)); + if ((is_get || is_set) && comp_ctx->curr_token.t != DUK_TOK_COLON) { + /* getter/setter */ + duk_int_t fnum; + + if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER || + comp_ctx->curr_token.t_nores == DUK_TOK_STRING) { + /* same handling for identifiers and strings */ + DUK_ASSERT(comp_ctx->curr_token.str1 != NULL); + duk_push_hstring(ctx, comp_ctx->curr_token.str1); + } else if (comp_ctx->curr_token.t == DUK_TOK_NUMBER) { + duk_push_number(ctx, comp_ctx->curr_token.num); + duk_to_string(ctx, -1); + } else { + goto syntax_error; + } + + DUK_ASSERT(duk_is_string(ctx, -1)); + if (duk__nud_object_literal_key_check(comp_ctx, + (is_get ? DUK__OBJ_LIT_KEY_GET : DUK__OBJ_LIT_KEY_SET))) { + goto syntax_error; + } + reg_key = duk__getconst(comp_ctx); + + if (num_pairs > 0) { + /* - A is a source register (it's not a write target, but used + * to identify the target object) but can be shuffled. + * - B cannot be shuffled normally because it identifies a range + * of registers, the emitter has special handling for this + * (the "no shuffle" flag must not be set). + * - C is a non-register number and cannot be shuffled, but + * never needs to be. + */ + duk__emit_a_b_c(comp_ctx, + DUK_OP_MPUTOBJ | + DUK__EMIT_FLAG_NO_SHUFFLE_C | + DUK__EMIT_FLAG_A_IS_SOURCE, + reg_obj, + temp_start, + num_pairs); + num_pairs = 0; + DUK__SETTEMP(comp_ctx, temp_start); + } + + /* curr_token = get/set name */ + fnum = duk__parse_func_like_fnum(comp_ctx, 0 /*is_decl*/, 1 /*is_setget*/); + + DUK_ASSERT(DUK__GETTEMP(comp_ctx) == temp_start); + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_bc(comp_ctx, + DUK_OP_LDCONST, + (duk_regconst_t) reg_temp, + (duk_regconst_t) reg_key); + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_bc(comp_ctx, + DUK_OP_CLOSURE, + (duk_regconst_t) reg_temp, + (duk_regconst_t) fnum); + + /* Slot C is used in a non-standard fashion (range of regs), + * emitter code has special handling for it (must not set the + * "no shuffle" flag). + */ + duk__emit_extraop_b_c(comp_ctx, + (is_get ? DUK_EXTRAOP_INITGET : DUK_EXTRAOP_INITSET), + reg_obj, + temp_start); /* temp_start+0 = key, temp_start+1 = closure */ + + DUK__SETTEMP(comp_ctx, temp_start); + } else { + /* normal key/value */ + if (comp_ctx->prev_token.t_nores == DUK_TOK_IDENTIFIER || + comp_ctx->prev_token.t_nores == DUK_TOK_STRING) { + /* same handling for identifiers and strings */ + DUK_ASSERT(comp_ctx->prev_token.str1 != NULL); + duk_push_hstring(ctx, comp_ctx->prev_token.str1); + } else if (comp_ctx->prev_token.t == DUK_TOK_NUMBER) { + duk_push_number(ctx, comp_ctx->prev_token.num); + duk_to_string(ctx, -1); + } else { + goto syntax_error; + } + + DUK_ASSERT(duk_is_string(ctx, -1)); + if (duk__nud_object_literal_key_check(comp_ctx, DUK__OBJ_LIT_KEY_PLAIN)) { + goto syntax_error; + } + reg_key = duk__getconst(comp_ctx); + + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_bc(comp_ctx, + DUK_OP_LDCONST, + (duk_regconst_t) reg_temp, + (duk_regconst_t) reg_key); + duk__advance_expect(comp_ctx, DUK_TOK_COLON); + + reg_temp = DUK__ALLOCTEMP(comp_ctx); /* alloc temp just in case, to update max temp */ + DUK__SETTEMP(comp_ctx, reg_temp); + duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/); + DUK__SETTEMP(comp_ctx, reg_temp + 1); + + num_pairs++; + } + } + + if (num_pairs > 0) { + /* See MPUTOBJ comments above. */ + duk__emit_a_b_c(comp_ctx, + DUK_OP_MPUTOBJ | + DUK__EMIT_FLAG_NO_SHUFFLE_C | + DUK__EMIT_FLAG_A_IS_SOURCE, + reg_obj, + temp_start, + num_pairs); + + /* num_pairs and temp_start reset at top of outer loop */ + } + } + + DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RCURLY); + duk__advance(comp_ctx); + + DUK__SETTEMP(comp_ctx, temp_start); + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_obj; + + DUK_DDD(DUK_DDDPRINT("final tracking object: %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + duk_pop(ctx); + return; + + syntax_error: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_OBJECT_LITERAL); +} + +/* Parse argument list. Arguments are written to temps starting from + * "next temp". Returns number of arguments parsed. Expects left paren + * to be already eaten, and eats the right paren before returning. + */ +DUK_LOCAL duk_int_t duk__parse_arguments(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { + duk_int_t nargs = 0; + duk_reg_t reg_temp; + + /* Note: expect that caller has already eaten the left paren */ + + DUK_DDD(DUK_DDDPRINT("start parsing arguments, prev_token.t=%ld, curr_token.t=%ld", + (long) comp_ctx->prev_token.t, (long) comp_ctx->curr_token.t)); + + for (;;) { + if (comp_ctx->curr_token.t == DUK_TOK_RPAREN) { + break; + } + if (nargs > 0) { + duk__advance_expect(comp_ctx, DUK_TOK_COMMA); + } + + /* We want the argument expression value to go to "next temp" + * without additional moves. That should almost always be the + * case, but we double check after expression parsing. + * + * This is not the cleanest possible approach. + */ + + reg_temp = DUK__ALLOCTEMP(comp_ctx); /* bump up "allocated" reg count, just in case */ + DUK__SETTEMP(comp_ctx, reg_temp); + + /* binding power must be high enough to NOT allow comma expressions directly */ + duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp); /* always allow 'in', coerce to 'tr' just in case */ + + DUK__SETTEMP(comp_ctx, reg_temp + 1); + nargs++; + + DUK_DDD(DUK_DDDPRINT("argument #%ld written into reg %ld", (long) nargs, (long) reg_temp)); + } + + /* eat the right paren */ + duk__advance_expect(comp_ctx, DUK_TOK_RPAREN); + + DUK_DDD(DUK_DDDPRINT("end parsing arguments")); + + return nargs; +} + +DUK_LOCAL duk_bool_t duk__expr_is_empty(duk_compiler_ctx *comp_ctx) { + /* empty expressions can be detected conveniently with nud/led counts */ + return (comp_ctx->curr_func.nud_count == 0) && + (comp_ctx->curr_func.led_count == 0); +} + +DUK_LOCAL void duk__expr_nud(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_token *tk; + duk_reg_t temp_at_entry; + duk_small_int_t tok; + duk_uint32_t args; /* temp variable to pass constants and flags to shared code */ + + /* + * ctx->prev_token token to process with duk__expr_nud() + * ctx->curr_token updated by caller + * + * Note: the token in the switch below has already been eaten. + */ + + temp_at_entry = DUK__GETTEMP(comp_ctx); + + comp_ctx->curr_func.nud_count++; + + tk = &comp_ctx->prev_token; + tok = tk->t; + res->t = DUK_IVAL_NONE; + + DUK_DDD(DUK_DDDPRINT("duk__expr_nud(), prev_token.t=%ld, allow_in=%ld, paren_level=%ld", + (long) tk->t, (long) comp_ctx->curr_func.allow_in, (long) comp_ctx->curr_func.paren_level)); + + switch (tok) { + + /* PRIMARY EXPRESSIONS */ + + case DUK_TOK_THIS: { + duk_reg_t reg_temp; + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__emit_extraop_bc(comp_ctx, + DUK_EXTRAOP_LDTHIS, + (duk_regconst_t) reg_temp); + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_temp; + return; + } + case DUK_TOK_IDENTIFIER: { + res->t = DUK_IVAL_VAR; + res->x1.t = DUK_ISPEC_VALUE; + duk_push_hstring(ctx, tk->str1); + duk_replace(ctx, res->x1.valstack_idx); + return; + } + case DUK_TOK_NULL: { + duk_push_null(ctx); + goto plain_value; + } + case DUK_TOK_TRUE: { + duk_push_true(ctx); + goto plain_value; + } + case DUK_TOK_FALSE: { + duk_push_false(ctx); + goto plain_value; + } + case DUK_TOK_NUMBER: { + duk_push_number(ctx, tk->num); + goto plain_value; + } + case DUK_TOK_STRING: { + DUK_ASSERT(tk->str1 != NULL); + duk_push_hstring(ctx, tk->str1); + goto plain_value; + } + case DUK_TOK_REGEXP: { +#ifdef DUK_USE_REGEXP_SUPPORT + duk_reg_t reg_temp; + duk_regconst_t rc_re_bytecode; /* const */ + duk_regconst_t rc_re_source; /* const */ + + DUK_ASSERT(tk->str1 != NULL); + DUK_ASSERT(tk->str2 != NULL); + + DUK_DDD(DUK_DDDPRINT("emitting regexp op, str1=%!O, str2=%!O", + (duk_heaphdr *) tk->str1, + (duk_heaphdr *) tk->str2)); + + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk_push_hstring(ctx, tk->str1); + duk_push_hstring(ctx, tk->str2); + + /* [ ... pattern flags ] */ + + duk_regexp_compile(thr); + + /* [ ... escaped_source bytecode ] */ + + rc_re_bytecode = duk__getconst(comp_ctx); + rc_re_source = duk__getconst(comp_ctx); + + duk__emit_a_b_c(comp_ctx, + DUK_OP_REGEXP, + (duk_regconst_t) reg_temp /*a*/, + rc_re_bytecode /*b*/, + rc_re_source /*c*/); + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_temp; + return; +#else /* DUK_USE_REGEXP_SUPPORT */ + goto syntax_error; +#endif /* DUK_USE_REGEXP_SUPPORT */ + } + case DUK_TOK_LBRACKET: { + DUK_DDD(DUK_DDDPRINT("parsing array literal")); + duk__nud_array_literal(comp_ctx, res); + return; + } + case DUK_TOK_LCURLY: { + DUK_DDD(DUK_DDDPRINT("parsing object literal")); + duk__nud_object_literal(comp_ctx, res); + return; + } + case DUK_TOK_LPAREN: { + duk_bool_t prev_allow_in; + + comp_ctx->curr_func.paren_level++; + prev_allow_in = comp_ctx->curr_func.allow_in; + comp_ctx->curr_func.allow_in = 1; /* reset 'allow_in' for parenthesized expression */ + + duk__expr(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); /* Expression, terminates at a ')' */ + + duk__advance_expect(comp_ctx, DUK_TOK_RPAREN); + comp_ctx->curr_func.allow_in = prev_allow_in; + comp_ctx->curr_func.paren_level--; + return; + } + + /* MEMBER/NEW/CALL EXPRESSIONS */ + + case DUK_TOK_NEW: { + /* + * Parsing an expression starting with 'new' is tricky because + * there are multiple possible productions deriving from + * LeftHandSideExpression which begin with 'new'. + * + * We currently resort to one-token lookahead to distinguish the + * cases. Hopefully this is correct. The binding power must be + * such that parsing ends at an LPAREN (CallExpression) but not at + * a PERIOD or LBRACKET (MemberExpression). + * + * See doc/compiler.rst for discussion on the parsing approach, + * and testcases/test-dev-new.js for a bunch of documented tests. + */ + + duk_reg_t reg_target; + duk_int_t nargs; + + DUK_DDD(DUK_DDDPRINT("begin parsing new expression")); + + reg_target = DUK__ALLOCTEMP(comp_ctx); + duk__expr_toforcedreg(comp_ctx, res, DUK__BP_CALL /*rbp_flags*/, reg_target /*forced_reg*/); + DUK__SETTEMP(comp_ctx, reg_target + 1); + + if (comp_ctx->curr_token.t == DUK_TOK_LPAREN) { + /* 'new' MemberExpression Arguments */ + DUK_DDD(DUK_DDDPRINT("new expression has argument list")); + duk__advance(comp_ctx); + nargs = duk__parse_arguments(comp_ctx, res); /* parse args starting from "next temp", reg_target + 1 */ + /* right paren eaten */ + } else { + /* 'new' MemberExpression */ + DUK_DDD(DUK_DDDPRINT("new expression has no argument list")); + nargs = 0; + } + + /* Opcode slot C is used in a non-standard way, so shuffling + * is not allowed. + */ + duk__emit_a_b_c(comp_ctx, + DUK_OP_NEW | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C, + 0 /*unused*/, + reg_target /*target*/, + nargs /*num_args*/); + + DUK_DDD(DUK_DDDPRINT("end parsing new expression")); + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_target; + return; + } + + /* FUNCTION EXPRESSIONS */ + + case DUK_TOK_FUNCTION: { + /* Function expression. Note that any statement beginning with 'function' + * is handled by the statement parser as a function declaration, or a + * non-standard function expression/statement (or a SyntaxError). We only + * handle actual function expressions (occurring inside an expression) here. + * + * O(depth^2) parse count for inner functions is handled by recording a + * lexer offset on the first compilation pass, so that the function can + * be efficiently skipped on the second pass. This is encapsulated into + * duk__parse_func_like_fnum(). + */ + + duk_reg_t reg_temp; + duk_int_t fnum; + + reg_temp = DUK__ALLOCTEMP(comp_ctx); + + /* curr_token follows 'function' */ + fnum = duk__parse_func_like_fnum(comp_ctx, 0 /*is_decl*/, 0 /*is_setget*/); + DUK_DDD(DUK_DDDPRINT("parsed inner function -> fnum %ld", (long) fnum)); + + duk__emit_a_bc(comp_ctx, + DUK_OP_CLOSURE, + (duk_regconst_t) reg_temp /*a*/, + (duk_regconst_t) fnum /*bc*/); + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_temp; + return; + } + + /* UNARY EXPRESSIONS */ + + case DUK_TOK_DELETE: { + /* Delete semantics are a bit tricky. The description in E5 specification + * is kind of confusing, because it distinguishes between resolvability of + * a reference (which is only known at runtime) seemingly at compile time + * (= SyntaxError throwing). + */ + duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */ + if (res->t == DUK_IVAL_VAR) { + /* not allowed in strict mode, regardless of whether resolves; + * in non-strict mode DELVAR handles both non-resolving and + * resolving cases (the specification description is a bit confusing). + */ + + duk_reg_t reg_temp; + duk_reg_t reg_varbind; + duk_regconst_t rc_varname; + + if (comp_ctx->curr_func.is_strict) { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_CANNOT_DELETE_IDENTIFIER); + } + + DUK__SETTEMP(comp_ctx, temp_at_entry); + reg_temp = DUK__ALLOCTEMP(comp_ctx); + + duk_dup(ctx, res->x1.valstack_idx); + if (duk__lookup_lhs(comp_ctx, ®_varbind, &rc_varname)) { + /* register bound variables are non-configurable -> always false */ + duk__emit_extraop_bc(comp_ctx, + DUK_EXTRAOP_LDFALSE, + (duk_regconst_t) reg_temp); + } else { + duk_dup(ctx, res->x1.valstack_idx); + rc_varname = duk__getconst(comp_ctx); + duk__emit_a_b(comp_ctx, + DUK_OP_DELVAR, + (duk_regconst_t) reg_temp, + (duk_regconst_t) rc_varname); + } + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_temp; + } else if (res->t == DUK_IVAL_PROP) { + duk_reg_t reg_temp; + duk_reg_t reg_obj; + duk_regconst_t rc_key; + + DUK__SETTEMP(comp_ctx, temp_at_entry); + reg_temp = DUK__ALLOCTEMP(comp_ctx); + reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/); /* don't allow const */ + rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/); + duk__emit_a_b_c(comp_ctx, + DUK_OP_DELPROP, + (duk_regconst_t) reg_temp, + (duk_regconst_t) reg_obj, + rc_key); + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_temp; + } else { + /* non-Reference deletion is always 'true', even in strict mode */ + duk_push_true(ctx); + goto plain_value; + } + return; + } + case DUK_TOK_VOID: { + duk__expr_toplain_ignore(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */ + duk_push_undefined(ctx); + goto plain_value; + } + case DUK_TOK_TYPEOF: { + /* 'typeof' must handle unresolvable references without throwing + * a ReferenceError (E5 Section 11.4.3). Register mapped values + * will never be unresolvable so special handling is only required + * when an identifier is a "slow path" one. + */ + duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */ + + if (res->t == DUK_IVAL_VAR) { + duk_reg_t reg_varbind; + duk_regconst_t rc_varname; + duk_reg_t reg_temp; + + duk_dup(ctx, res->x1.valstack_idx); + if (!duk__lookup_lhs(comp_ctx, ®_varbind, &rc_varname)) { + DUK_DDD(DUK_DDDPRINT("typeof for an identifier name which could not be resolved " + "at compile time, need to use special run-time handling")); + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__emit_extraop_b_c(comp_ctx, + DUK_EXTRAOP_TYPEOFID | DUK__EMIT_FLAG_B_IS_TARGET, + reg_temp, + rc_varname); + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_temp; + return; + } + } + + args = (DUK_EXTRAOP_TYPEOF << 8) + 0; + goto unary_extraop; + } + case DUK_TOK_INCREMENT: { + args = (DUK_OP_PREINCR << 8) + 0; + goto preincdec; + } + case DUK_TOK_DECREMENT: { + args = (DUK_OP_PREDECR << 8) + 0; + goto preincdec; + } + case DUK_TOK_ADD: { + /* unary plus */ + duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */ + if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE && + duk_is_number(ctx, res->x1.valstack_idx)) { + /* unary plus of a number is identity */ + ; + return; + } + args = (DUK_EXTRAOP_UNP << 8) + 0; + goto unary_extraop; + } + case DUK_TOK_SUB: { + /* unary minus */ + duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */ + if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE && + duk_is_number(ctx, res->x1.valstack_idx)) { + /* this optimization is important to handle negative literals (which are not directly + * provided by the lexical grammar + */ + duk_tval *tv_num = duk_get_tval(ctx, res->x1.valstack_idx); + duk_double_union du; + + DUK_ASSERT(tv_num != NULL); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_num)); + du.d = DUK_TVAL_GET_NUMBER(tv_num); + du.d = -du.d; + DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du); + DUK_TVAL_SET_NUMBER(tv_num, du.d); + return; + } + args = (DUK_EXTRAOP_UNM << 8) + 0; + goto unary_extraop; + } + case DUK_TOK_BNOT: { + duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */ + args = (DUK_EXTRAOP_BNOT << 8) + 0; + goto unary_extraop; + } + case DUK_TOK_LNOT: { + duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */ + if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE) { + /* Very minimal inlining to handle common idioms '!0' and '!1', + * and also boolean arguments like '!false' and '!true'. + */ + duk_tval *tv_val = duk_get_tval(ctx, res->x1.valstack_idx); + + DUK_ASSERT(tv_val != NULL); + if (DUK_TVAL_IS_NUMBER(tv_val)) { + duk_double_t d; + d = DUK_TVAL_GET_NUMBER(tv_val); + if (d == 0.0) { + /* Matches both +0 and -0 on purpose. */ + DUK_DDD(DUK_DDDPRINT("inlined lnot: !0 -> true")); + DUK_TVAL_SET_BOOLEAN_TRUE(tv_val); + return; + } else if (d == 1.0) { + DUK_DDD(DUK_DDDPRINT("inlined lnot: !1 -> false")); + DUK_TVAL_SET_BOOLEAN_FALSE(tv_val); + return; + } + } else if (DUK_TVAL_IS_BOOLEAN(tv_val)) { + duk_small_int_t v; + v = DUK_TVAL_GET_BOOLEAN(tv_val); + DUK_DDD(DUK_DDDPRINT("inlined lnot boolean: %ld", (long) v)); + DUK_ASSERT(v == 0 || v == 1); + DUK_TVAL_SET_BOOLEAN(tv_val, v ^ 0x01); + return; + } + } + args = (DUK_EXTRAOP_LNOT << 8) + 0; + goto unary_extraop; + } + + } /* end switch */ + + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_PARSE_ERROR); + return; + + unary_extraop: + { + /* Note: must coerce to a (writable) temp register, so that e.g. "!x" where x + * is a reg-mapped variable works correctly (does not mutate the variable register). + */ + + duk_reg_t reg_temp; + reg_temp = duk__ivalue_toregconst_raw(comp_ctx, res, -1 /*forced_reg*/, DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/); + duk__emit_extraop_bc(comp_ctx, + (args >> 8), + (duk_regconst_t) reg_temp); + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_temp; + return; + } + + preincdec: + { + /* preincrement and predecrement */ + duk_reg_t reg_res; + duk_small_uint_t args_op = args >> 8; + + /* Specific assumptions for opcode numbering. */ + DUK_ASSERT(DUK_OP_PREINCR + 4 == DUK_OP_PREINCV); + DUK_ASSERT(DUK_OP_PREDECR + 4 == DUK_OP_PREDECV); + DUK_ASSERT(DUK_OP_PREINCR + 8 == DUK_OP_PREINCP); + DUK_ASSERT(DUK_OP_PREDECR + 8 == DUK_OP_PREDECP); + + reg_res = DUK__ALLOCTEMP(comp_ctx); + + duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/); /* UnaryExpression */ + if (res->t == DUK_IVAL_VAR) { + duk_hstring *h_varname; + duk_reg_t reg_varbind; + duk_regconst_t rc_varname; + + h_varname = duk_get_hstring(ctx, res->x1.valstack_idx); + DUK_ASSERT(h_varname != NULL); + + if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) { + goto syntax_error; + } + + duk_dup(ctx, res->x1.valstack_idx); + if (duk__lookup_lhs(comp_ctx, ®_varbind, &rc_varname)) { + duk__emit_a_bc(comp_ctx, + args_op, /* e.g. DUK_OP_PREINCR */ + (duk_regconst_t) reg_res, + (duk_regconst_t) reg_varbind); + } else { + duk__emit_a_bc(comp_ctx, + args_op + 4, /* e.g. DUK_OP_PREINCV */ + (duk_regconst_t) reg_res, + rc_varname); + } + + DUK_DDD(DUK_DDDPRINT("preincdec to '%!O' -> reg_varbind=%ld, rc_varname=%ld", + (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname)); + } else if (res->t == DUK_IVAL_PROP) { + duk_reg_t reg_obj; /* allocate to reg only (not const) */ + duk_regconst_t rc_key; + reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/); /* don't allow const */ + rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/); + duk__emit_a_b_c(comp_ctx, + args_op + 8, /* e.g. DUK_OP_PREINCP */ + (duk_regconst_t) reg_res, + (duk_regconst_t) reg_obj, + rc_key); + } else { + /* Technically return value is not needed because INVLHS will + * unconditially throw a ReferenceError. Coercion is necessary + * for proper semantics (consider ToNumber() called for an object). + * Use DUK_EXTRAOP_UNP with a dummy register to get ToNumber(). + */ + + duk__ivalue_toforcedreg(comp_ctx, res, reg_res); + duk__emit_extraop_bc(comp_ctx, + DUK_EXTRAOP_UNP, + reg_res); /* for side effects, result ignored */ + duk__emit_extraop_only(comp_ctx, + DUK_EXTRAOP_INVLHS); + } + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_res; + DUK__SETTEMP(comp_ctx, reg_res + 1); + return; + } + + plain_value: + { + /* Stack top contains plain value */ + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_VALUE; + duk_replace(ctx, res->x1.valstack_idx); + return; + } + + syntax_error: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_EXPRESSION); +} + +/* XXX: add flag to indicate whether caller cares about return value; this + * affects e.g. handling of assignment expressions. This change needs API + * changes elsewhere too. + */ +DUK_LOCAL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_ivalue *res) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_token *tk; + duk_small_int_t tok; + duk_uint32_t args; /* temp variable to pass constants and flags to shared code */ + + /* + * ctx->prev_token token to process with duk__expr_led() + * ctx->curr_token updated by caller + */ + + comp_ctx->curr_func.led_count++; + + /* The token in the switch has already been eaten here */ + tk = &comp_ctx->prev_token; + tok = tk->t; + + DUK_DDD(DUK_DDDPRINT("duk__expr_led(), prev_token.t=%ld, allow_in=%ld, paren_level=%ld", + (long) tk->t, (long) comp_ctx->curr_func.allow_in, (long) comp_ctx->curr_func.paren_level)); + + /* XXX: default priority for infix operators is duk__expr_lbp(tok) -> get it here? */ + + switch (tok) { + + /* PRIMARY EXPRESSIONS */ + + case DUK_TOK_PERIOD: { + /* Property access expressions are critical for correct LHS ordering, + * see comments in duk__expr()! + */ + + /* XXX: this now coerces an identifier into a GETVAR to a temp, which + * causes an extra LDREG in call setup. It's sufficient to coerce to a + * unary ivalue? + */ + duk__ivalue_toplain(comp_ctx, left); + + /* NB: must accept reserved words as property name */ + if (comp_ctx->curr_token.t_nores != DUK_TOK_IDENTIFIER) { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_EXPECTED_IDENTIFIER); + } + + res->t = DUK_IVAL_PROP; + duk__copy_ispec(comp_ctx, &left->x1, &res->x1); /* left.x1 -> res.x1 */ + DUK_ASSERT(comp_ctx->curr_token.str1 != NULL); + duk_push_hstring(ctx, comp_ctx->curr_token.str1); + duk_replace(ctx, res->x2.valstack_idx); + res->x2.t = DUK_ISPEC_VALUE; + + /* special RegExp literal handling after IdentifierName */ + comp_ctx->curr_func.reject_regexp_in_adv = 1; + + duk__advance(comp_ctx); + return; + } + case DUK_TOK_LBRACKET: { + /* Property access expressions are critical for correct LHS ordering, + * see comments in duk__expr()! + */ + + /* XXX: optimize temp reg use */ + /* XXX: similar coercion issue as in DUK_TOK_PERIOD */ + + /* XXX: coerce to regs? it might be better for enumeration use, where the + * same PROP ivalue is used multiple times. Or perhaps coerce PROP further + * there? + */ + + duk__ivalue_toplain(comp_ctx, left); + duk__expr_toplain(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); /* Expression, ']' terminates */ + duk__advance_expect(comp_ctx, DUK_TOK_RBRACKET); + + res->t = DUK_IVAL_PROP; + duk__copy_ispec(comp_ctx, &res->x1, &res->x2); /* res.x1 -> res.x2 */ + duk__copy_ispec(comp_ctx, &left->x1, &res->x1); /* left.x1 -> res.x1 */ + return; + } + case DUK_TOK_LPAREN: { + /* function call */ + duk_reg_t reg_cs = DUK__ALLOCTEMPS(comp_ctx, 2); + duk_int_t nargs; + duk_small_uint_t call_flags = 0; + + /* + * XXX: attempt to get the call result to "next temp" whenever + * possible to avoid unnecessary register shuffles. + * + * XXX: CSPROP (and CSREG) can overwrite the call target register, and save one temp, + * if the call target is a temporary register and at the top of the temp reg "stack". + */ + + /* + * Setup call: target and 'this' binding. Three cases: + * + * 1. Identifier base (e.g. "foo()") + * 2. Property base (e.g. "foo.bar()") + * 3. Register base (e.g. "foo()()"; i.e. when a return value is a function) + */ + + if (left->t == DUK_IVAL_VAR) { + duk_hstring *h_varname; + duk_reg_t reg_varbind; + duk_regconst_t rc_varname; + + DUK_DDD(DUK_DDDPRINT("function call with identifier base")); + + h_varname = duk_get_hstring(ctx, left->x1.valstack_idx); + DUK_ASSERT(h_varname != NULL); + if (h_varname == DUK_HTHREAD_STRING_EVAL(thr)) { + /* Potential direct eval call detected, flag the CALL + * so that a run-time "direct eval" check is made and + * special behavior may be triggered. Note that this + * does not prevent 'eval' from being register bound. + */ + DUK_DDD(DUK_DDDPRINT("function call with identifier 'eval' " + "-> enabling EVALCALL flag, marking function " + "as may_direct_eval")); + call_flags |= DUK_BC_CALL_FLAG_EVALCALL; + + comp_ctx->curr_func.may_direct_eval = 1; + } + + duk_dup(ctx, left->x1.valstack_idx); + if (duk__lookup_lhs(comp_ctx, ®_varbind, &rc_varname)) { + duk__emit_a_b(comp_ctx, + DUK_OP_CSREG, + (duk_regconst_t) (reg_cs + 0), + (duk_regconst_t) reg_varbind); + } else { + duk__emit_a_b(comp_ctx, + DUK_OP_CSVAR, + (duk_regconst_t) (reg_cs + 0), + rc_varname); + } + } else if (left->t == DUK_IVAL_PROP) { + DUK_DDD(DUK_DDDPRINT("function call with property base")); + + duk__ispec_toforcedreg(comp_ctx, &left->x1, reg_cs + 0); /* base */ + duk__ispec_toforcedreg(comp_ctx, &left->x2, reg_cs + 1); /* key */ + duk__emit_a_b_c(comp_ctx, + DUK_OP_CSPROP, + (duk_regconst_t) (reg_cs + 0), + (duk_regconst_t) (reg_cs + 0), + (duk_regconst_t) (reg_cs + 1)); /* in-place setup */ + } else { + DUK_DDD(DUK_DDDPRINT("function call with register base")); + + duk__ivalue_toforcedreg(comp_ctx, left, reg_cs + 0); + duk__emit_a_b(comp_ctx, + DUK_OP_CSREG, + (duk_regconst_t) (reg_cs + 0), + (duk_regconst_t) (reg_cs + 0)); /* in-place setup */ + } + + DUK__SETTEMP(comp_ctx, reg_cs + 2); + nargs = duk__parse_arguments(comp_ctx, res); /* parse args starting from "next temp" */ + + /* Tailcalls are handled by back-patching the TAILCALL flag to the + * already emitted instruction later (in return statement parser). + * Since A and C have a special meaning here, they cannot be "shuffled". + */ + + duk__emit_a_b_c(comp_ctx, + DUK_OP_CALL | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C, + (duk_regconst_t) call_flags /*flags*/, + (duk_regconst_t) reg_cs /*basereg*/, + (duk_regconst_t) nargs /*numargs*/); + DUK__SETTEMP(comp_ctx, reg_cs + 1); /* result in csreg */ + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_cs; + return; + } + + /* POSTFIX EXPRESSION */ + + case DUK_TOK_INCREMENT: { + args = (DUK_OP_POSTINCR << 8) + 0; + goto postincdec; + } + case DUK_TOK_DECREMENT: { + args = (DUK_OP_POSTDECR << 8) + 0; + goto postincdec; + } + + /* MULTIPLICATIVE EXPRESSION */ + + case DUK_TOK_MUL: { + args = (DUK_OP_MUL << 8) + DUK__BP_MULTIPLICATIVE; /* UnaryExpression */ + goto binary; + } + case DUK_TOK_DIV: { + args = (DUK_OP_DIV << 8) + DUK__BP_MULTIPLICATIVE; /* UnaryExpression */ + goto binary; + } + case DUK_TOK_MOD: { + args = (DUK_OP_MOD << 8) + DUK__BP_MULTIPLICATIVE; /* UnaryExpression */ + goto binary; + } + + /* ADDITIVE EXPRESSION */ + + case DUK_TOK_ADD: { + args = (DUK_OP_ADD << 8) + DUK__BP_ADDITIVE; /* MultiplicativeExpression */ + goto binary; + } + case DUK_TOK_SUB: { + args = (DUK_OP_SUB << 8) + DUK__BP_ADDITIVE; /* MultiplicativeExpression */ + goto binary; + } + + /* SHIFT EXPRESSION */ + + case DUK_TOK_ALSHIFT: { + /* << */ + args = (DUK_OP_BASL << 8) + DUK__BP_SHIFT; + goto binary; + } + case DUK_TOK_ARSHIFT: { + /* >> */ + args = (DUK_OP_BASR << 8) + DUK__BP_SHIFT; + goto binary; + } + case DUK_TOK_RSHIFT: { + /* >>> */ + args = (DUK_OP_BLSR << 8) + DUK__BP_SHIFT; + goto binary; + } + + /* RELATIONAL EXPRESSION */ + + case DUK_TOK_LT: { + /* < */ + args = (DUK_OP_LT << 8) + DUK__BP_RELATIONAL; + goto binary; + } + case DUK_TOK_GT: { + args = (DUK_OP_GT << 8) + DUK__BP_RELATIONAL; + goto binary; + } + case DUK_TOK_LE: { + args = (DUK_OP_LE << 8) + DUK__BP_RELATIONAL; + goto binary; + } + case DUK_TOK_GE: { + args = (DUK_OP_GE << 8) + DUK__BP_RELATIONAL; + goto binary; + } + case DUK_TOK_INSTANCEOF: { + args = (1 << 16 /*is_extra*/) + (DUK_EXTRAOP_INSTOF << 8) + DUK__BP_RELATIONAL; + goto binary; + } + case DUK_TOK_IN: { + args = (1 << 16 /*is_extra*/) + (DUK_EXTRAOP_IN << 8) + DUK__BP_RELATIONAL; + goto binary; + } + + /* EQUALITY EXPRESSION */ + + case DUK_TOK_EQ: { + args = (DUK_OP_EQ << 8) + DUK__BP_EQUALITY; + goto binary; + } + case DUK_TOK_NEQ: { + args = (DUK_OP_NEQ << 8) + DUK__BP_EQUALITY; + goto binary; + } + case DUK_TOK_SEQ: { + args = (DUK_OP_SEQ << 8) + DUK__BP_EQUALITY; + goto binary; + } + case DUK_TOK_SNEQ: { + args = (DUK_OP_SNEQ << 8) + DUK__BP_EQUALITY; + goto binary; + } + + /* BITWISE EXPRESSIONS */ + + case DUK_TOK_BAND: { + args = (DUK_OP_BAND << 8) + DUK__BP_BAND; + goto binary; + } + case DUK_TOK_BXOR: { + args = (DUK_OP_BXOR << 8) + DUK__BP_BXOR; + goto binary; + } + case DUK_TOK_BOR: { + args = (DUK_OP_BOR << 8) + DUK__BP_BOR; + goto binary; + } + + /* LOGICAL EXPRESSIONS */ + + case DUK_TOK_LAND: { + /* syntactically left-associative but parsed as right-associative */ + args = (1 << 8) + DUK__BP_LAND - 1; + goto binary_logical; + } + case DUK_TOK_LOR: { + /* syntactically left-associative but parsed as right-associative */ + args = (0 << 8) + DUK__BP_LOR - 1; + goto binary_logical; + } + + /* CONDITIONAL EXPRESSION */ + + case DUK_TOK_QUESTION: { + /* XXX: common reg allocation need is to reuse a sub-expression's temp reg, + * but only if it really is a temp. Nothing fancy here now. + */ + duk_reg_t reg_temp; + duk_int_t pc_jump1; + duk_int_t pc_jump2; + + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__ivalue_toforcedreg(comp_ctx, left, reg_temp); + duk__emit_if_true_skip(comp_ctx, reg_temp); + pc_jump1 = duk__emit_jump_empty(comp_ctx); /* jump to false */ + duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/); /* AssignmentExpression */ + duk__advance_expect(comp_ctx, DUK_TOK_COLON); + pc_jump2 = duk__emit_jump_empty(comp_ctx); /* jump to end */ + duk__patch_jump_here(comp_ctx, pc_jump1); + duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/); /* AssignmentExpression */ + duk__patch_jump_here(comp_ctx, pc_jump2); + + DUK__SETTEMP(comp_ctx, reg_temp + 1); + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_temp; + return; + } + + /* ASSIGNMENT EXPRESSION */ + + case DUK_TOK_EQUALSIGN: { + /* + * Assignments are right associative, allows e.g. + * a = 5; + * a += b = 9; // same as a += (b = 9) + * -> expression value 14, a = 14, b = 9 + * + * Right associativiness is reflected in the BP for recursion, + * "-1" ensures assignment operations are allowed. + * + * XXX: just use DUK__BP_COMMA (i.e. no need for 2-step bp levels)? + */ + args = (DUK_OP_NONE << 8) + DUK__BP_ASSIGNMENT - 1; /* DUK_OP_NONE marks a 'plain' assignment */ + goto assign; + } + case DUK_TOK_ADD_EQ: { + /* right associative */ + args = (DUK_OP_ADD << 8) + DUK__BP_ASSIGNMENT - 1; + goto assign; + } + case DUK_TOK_SUB_EQ: { + /* right associative */ + args = (DUK_OP_SUB << 8) + DUK__BP_ASSIGNMENT - 1; + goto assign; + } + case DUK_TOK_MUL_EQ: { + /* right associative */ + args = (DUK_OP_MUL << 8) + DUK__BP_ASSIGNMENT - 1; + goto assign; + } + case DUK_TOK_DIV_EQ: { + /* right associative */ + args = (DUK_OP_DIV << 8) + DUK__BP_ASSIGNMENT - 1; + goto assign; + } + case DUK_TOK_MOD_EQ: { + /* right associative */ + args = (DUK_OP_MOD << 8) + DUK__BP_ASSIGNMENT - 1; + goto assign; + } + case DUK_TOK_ALSHIFT_EQ: { + /* right associative */ + args = (DUK_OP_BASL << 8) + DUK__BP_ASSIGNMENT - 1; + goto assign; + } + case DUK_TOK_ARSHIFT_EQ: { + /* right associative */ + args = (DUK_OP_BASR << 8) + DUK__BP_ASSIGNMENT - 1; + goto assign; + } + case DUK_TOK_RSHIFT_EQ: { + /* right associative */ + args = (DUK_OP_BLSR << 8) + DUK__BP_ASSIGNMENT - 1; + goto assign; + } + case DUK_TOK_BAND_EQ: { + /* right associative */ + args = (DUK_OP_BAND << 8) + DUK__BP_ASSIGNMENT - 1; + goto assign; + } + case DUK_TOK_BOR_EQ: { + /* right associative */ + args = (DUK_OP_BOR << 8) + DUK__BP_ASSIGNMENT - 1; + goto assign; + } + case DUK_TOK_BXOR_EQ: { + /* right associative */ + args = (DUK_OP_BXOR << 8) + DUK__BP_ASSIGNMENT - 1; + goto assign; + } + + /* COMMA */ + + case DUK_TOK_COMMA: { + /* right associative */ + + duk__ivalue_toplain_ignore(comp_ctx, left); /* need side effects, not value */ + duk__expr_toplain(comp_ctx, res, DUK__BP_COMMA - 1 /*rbp_flags*/); + + /* return 'res' (of right part) as our result */ + return; + } + + default: { + break; + } + } + + DUK_D(DUK_DPRINT("parse error: unexpected token: %ld", (long) tok)); + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_PARSE_ERROR); + return; + +#if 0 + /* XXX: shared handling for 'duk__expr_lhs'? */ + if (comp_ctx->curr_func.paren_level == 0 && XXX) { + comp_ctx->curr_func.duk__expr_lhs = 0; + } +#endif + + binary: + /* + * Shared handling of binary operations + * + * args = (is_extraop << 16) + (opcode << 8) + rbp + */ + { + duk__ivalue_toplain(comp_ctx, left); + duk__expr_toplain(comp_ctx, res, args & 0xff /*rbp_flags*/); + + /* combine left->x1 and res->x1 (right->x1, really) -> (left->x1 OP res->x1) */ + DUK_ASSERT(left->t == DUK_IVAL_PLAIN); + DUK_ASSERT(res->t == DUK_IVAL_PLAIN); + + res->t = (args >> 16) ? DUK_IVAL_ARITH_EXTRAOP : DUK_IVAL_ARITH; + res->op = (args >> 8) & 0xff; + + res->x2.t = res->x1.t; + res->x2.regconst = res->x1.regconst; + duk_copy(ctx, res->x1.valstack_idx, res->x2.valstack_idx); + + res->x1.t = left->x1.t; + res->x1.regconst = left->x1.regconst; + duk_copy(ctx, left->x1.valstack_idx, res->x1.valstack_idx); + + DUK_DDD(DUK_DDDPRINT("binary op, res: t=%ld, x1.t=%ld, x1.regconst=0x%08lx, x2.t=%ld, x2.regconst=0x%08lx", + (long) res->t, (long) res->x1.t, (unsigned long) res->x1.regconst, (long) res->x2.t, (unsigned long) res->x2.regconst)); + return; + } + + binary_logical: + /* + * Shared handling for logical AND and logical OR. + * + * args = (truthval << 8) + rbp + * + * Truthval determines when to skip right-hand-side. + * For logical AND truthval=1, for logical OR truthval=0. + * + * See doc/compiler.rst for discussion on compiling logical + * AND and OR expressions. The approach here is very simplistic, + * generating extra jumps and multiple evaluations of truth values, + * but generates code on-the-fly with only local back-patching. + * + * Both logical AND and OR are syntactically left-associated. + * However, logical ANDs are compiled as right associative + * expressions, i.e. "A && B && C" as "A && (B && C)", to allow + * skip jumps to skip over the entire tail. Similarly for logical OR. + */ + + { + duk_reg_t reg_temp; + duk_int_t pc_jump; + duk_small_uint_t args_truthval = args >> 8; + duk_small_uint_t args_rbp = args & 0xff; + + /* XXX: unoptimal use of temps, resetting */ + + reg_temp = DUK__ALLOCTEMP(comp_ctx); + + duk__ivalue_toforcedreg(comp_ctx, left, reg_temp); + duk__emit_a_b(comp_ctx, + DUK_OP_IF | DUK__EMIT_FLAG_NO_SHUFFLE_A, + (duk_regconst_t) args_truthval, + (duk_regconst_t) reg_temp); /* skip jump conditionally */ + pc_jump = duk__emit_jump_empty(comp_ctx); + duk__expr_toforcedreg(comp_ctx, res, args_rbp /*rbp_flags*/, reg_temp /*forced_reg*/); + duk__patch_jump_here(comp_ctx, pc_jump); + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_temp; + return; + } + + assign: + /* + * Shared assignment expression handling + * + * args = (opcode << 8) + rbp + * + * If 'opcode' is DUK_OP_NONE, plain assignment without arithmetic. + * Syntactically valid left-hand-side forms which are not accepted as + * left-hand-side values (e.g. as in "f() = 1") must NOT cause a + * SyntaxError, but rather a run-time ReferenceError. + */ + + { + duk_small_uint_t args_op = args >> 8; + duk_small_uint_t args_rbp = args & 0xff; + + /* XXX: here we need to know if 'left' is left-hand-side compatible. + * That information is no longer available from current expr parsing + * state; it would need to be carried into the 'left' ivalue or by + * some other means. + */ + + if (left->t == DUK_IVAL_VAR) { + duk_hstring *h_varname; + duk_reg_t reg_varbind; + duk_regconst_t rc_varname; + duk_regconst_t rc_res; + duk_reg_t reg_temp; + + /* already in fluly evaluated form */ + DUK_ASSERT(left->x1.t == DUK_ISPEC_VALUE); + + duk__expr_toreg(comp_ctx, res, args_rbp /*rbp_flags*/); + DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST); + + h_varname = duk_get_hstring(ctx, left->x1.valstack_idx); + DUK_ASSERT(h_varname != NULL); + + /* E5 Section 11.13.1 (and others for other assignments), step 4 */ + if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) { + goto syntax_error_lvalue; + } + + duk_dup(ctx, left->x1.valstack_idx); + (void) duk__lookup_lhs(comp_ctx, ®_varbind, &rc_varname); + + DUK_DDD(DUK_DDDPRINT("assign to '%!O' -> reg_varbind=%ld, rc_varname=%ld", + (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname)); + + if (args_op == DUK_OP_NONE) { + rc_res = res->x1.regconst; + } else { + reg_temp = DUK__ALLOCTEMP(comp_ctx); + if (reg_varbind >= 0) { + duk__emit_a_b_c(comp_ctx, + args_op, + (duk_regconst_t) reg_temp, + (duk_regconst_t) reg_varbind, + res->x1.regconst); + } else { + duk__emit_a_bc(comp_ctx, + DUK_OP_GETVAR, + (duk_regconst_t) reg_temp, + rc_varname); + duk__emit_a_b_c(comp_ctx, + args_op, + (duk_regconst_t) reg_temp, + (duk_regconst_t) reg_temp, + res->x1.regconst); + } + rc_res = (duk_regconst_t) reg_temp; + } + + if (reg_varbind >= 0) { + duk__emit_a_bc(comp_ctx, + DUK_OP_LDREG, + (duk_regconst_t) reg_varbind, + rc_res); + } else { + /* Only a reg fits into 'A' and reg_res may be a const in + * straight assignment. + * + * XXX: here the current A/B/C split is suboptimal: we could + * just use 9 bits for reg_res (and support constants) and 17 + * instead of 18 bits for the varname const index. + */ + if (DUK__ISCONST(comp_ctx, rc_res)) { + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_bc(comp_ctx, + DUK_OP_LDCONST, + (duk_regconst_t) reg_temp, + rc_res); + rc_res = (duk_regconst_t) reg_temp; + } + duk__emit_a_bc(comp_ctx, + DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE, + rc_res, + rc_varname); + } + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = rc_res; + } else if (left->t == DUK_IVAL_PROP) { + /* E5 Section 11.13.1 (and others) step 4 never matches for prop writes -> no check */ + duk_reg_t reg_obj; + duk_regconst_t rc_key; + duk_regconst_t rc_res; + duk_reg_t reg_temp; + + /* Property access expressions ('a[b]') are critical to correct + * LHS evaluation ordering, see test-dev-assign-eval-order*.js. + * We must make sure that the LHS target slot (base object and + * key) don't change during RHS evaluation. The only concrete + * problem is a register reference to a variable-bound register + * (i.e., non-temp). Require temp regs for both key and base. + * + * Don't allow a constant for the object (even for a number + * etc), as it goes into the 'A' field of the opcode. + */ + + reg_obj = duk__ispec_toregconst_raw(comp_ctx, + &left->x1, + -1 /*forced_reg*/, + DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/); + + rc_key = duk__ispec_toregconst_raw(comp_ctx, + &left->x2, + -1 /*forced_reg*/, + DUK__IVAL_FLAG_REQUIRE_TEMP | DUK__IVAL_FLAG_ALLOW_CONST /*flags*/); + + /* Evaluate RHS only when LHS is safe. */ + duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/); + DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST); + + if (args_op == DUK_OP_NONE) { + rc_res = res->x1.regconst; + } else { + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_b_c(comp_ctx, + DUK_OP_GETPROP, + (duk_regconst_t) reg_temp, + (duk_regconst_t) reg_obj, + rc_key); + duk__emit_a_b_c(comp_ctx, + args_op, + (duk_regconst_t) reg_temp, + (duk_regconst_t) reg_temp, + res->x1.regconst); + rc_res = (duk_regconst_t) reg_temp; + } + + duk__emit_a_b_c(comp_ctx, + DUK_OP_PUTPROP | DUK__EMIT_FLAG_A_IS_SOURCE, + (duk_regconst_t) reg_obj, + rc_key, + rc_res); + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = rc_res; + } else { + /* No support for lvalues returned from new or function call expressions. + * However, these must NOT cause compile-time SyntaxErrors, but run-time + * ReferenceErrors. Both left and right sides of the assignment must be + * evaluated before throwing a ReferenceError. For instance: + * + * f() = g(); + * + * must result in f() being evaluated, then g() being evaluated, and + * finally, a ReferenceError being thrown. See E5 Section 11.13.1. + */ + + duk_regconst_t rc_res; + + /* first evaluate LHS fully to ensure all side effects are out */ + duk__ivalue_toplain_ignore(comp_ctx, left); + + /* then evaluate RHS fully (its value becomes the expression value too) */ + rc_res = duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/); + + duk__emit_extraop_only(comp_ctx, + DUK_EXTRAOP_INVLHS); + + /* XXX: this value is irrelevant because of INVLHS? */ + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = rc_res; + } + + return; + } + + postincdec: + { + /* + * Post-increment/decrement will return the original value as its + * result value. However, even that value will be coerced using + * ToNumber() which is quite awkward. Specific bytecode opcodes + * are used to handle these semantics. + * + * Note that post increment/decrement has a "no LineTerminator here" + * restriction. This is handled by duk__expr_lbp(), which forcibly terminates + * the previous expression if a LineTerminator occurs before '++'/'--'. + */ + + duk_reg_t reg_res; + duk_small_uint_t args_op = args >> 8; + + /* Specific assumptions for opcode numbering. */ + DUK_ASSERT(DUK_OP_POSTINCR + 4 == DUK_OP_POSTINCV); + DUK_ASSERT(DUK_OP_POSTDECR + 4 == DUK_OP_POSTDECV); + DUK_ASSERT(DUK_OP_POSTINCR + 8 == DUK_OP_POSTINCP); + DUK_ASSERT(DUK_OP_POSTDECR + 8 == DUK_OP_POSTDECP); + + reg_res = DUK__ALLOCTEMP(comp_ctx); + + if (left->t == DUK_IVAL_VAR) { + duk_hstring *h_varname; + duk_reg_t reg_varbind; + duk_regconst_t rc_varname; + + h_varname = duk_get_hstring(ctx, left->x1.valstack_idx); + DUK_ASSERT(h_varname != NULL); + + if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) { + goto syntax_error; + } + + duk_dup(ctx, left->x1.valstack_idx); + if (duk__lookup_lhs(comp_ctx, ®_varbind, &rc_varname)) { + duk__emit_a_bc(comp_ctx, + args_op, /* e.g. DUK_OP_POSTINCR */ + (duk_regconst_t) reg_res, + (duk_regconst_t) reg_varbind); + } else { + duk__emit_a_bc(comp_ctx, + args_op + 4, /* e.g. DUK_OP_POSTINCV */ + (duk_regconst_t) reg_res, + rc_varname); + } + + DUK_DDD(DUK_DDDPRINT("postincdec to '%!O' -> reg_varbind=%ld, rc_varname=%ld", + (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname)); + } else if (left->t == DUK_IVAL_PROP) { + duk_reg_t reg_obj; /* allocate to reg only (not const) */ + duk_regconst_t rc_key; + + reg_obj = duk__ispec_toregconst_raw(comp_ctx, &left->x1, -1 /*forced_reg*/, 0 /*flags*/); /* don't allow const */ + rc_key = duk__ispec_toregconst_raw(comp_ctx, &left->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/); + duk__emit_a_b_c(comp_ctx, + args_op + 8, /* e.g. DUK_OP_POSTINCP */ + (duk_regconst_t) reg_res, + (duk_regconst_t) reg_obj, + rc_key); + } else { + /* Technically return value is not needed because INVLHS will + * unconditially throw a ReferenceError. Coercion is necessary + * for proper semantics (consider ToNumber() called for an object). + * Use DUK_EXTRAOP_UNP with a dummy register to get ToNumber(). + */ + duk__ivalue_toforcedreg(comp_ctx, left, reg_res); + duk__emit_extraop_bc(comp_ctx, + DUK_EXTRAOP_UNP, + reg_res); /* for side effects, result ignored */ + duk__emit_extraop_only(comp_ctx, + DUK_EXTRAOP_INVLHS); + } + + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_REGCONST; + res->x1.regconst = (duk_regconst_t) reg_res; + DUK__SETTEMP(comp_ctx, reg_res + 1); + return; + } + + syntax_error: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_EXPRESSION); + return; + + syntax_error_lvalue: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_LVALUE); + return; +} + +DUK_LOCAL duk_small_uint_t duk__expr_lbp(duk_compiler_ctx *comp_ctx) { + duk_small_int_t tok = comp_ctx->curr_token.t; + + DUK_ASSERT(tok >= DUK_TOK_MINVAL && tok <= DUK_TOK_MAXVAL); + DUK_ASSERT(sizeof(duk__token_lbp) == DUK_TOK_MAXVAL + 1); + + /* XXX: integrate support for this into led() instead? + * Similar issue as post-increment/post-decrement. + */ + + /* prevent duk__expr_led() by using a binding power less than anything valid */ + if (tok == DUK_TOK_IN && !comp_ctx->curr_func.allow_in) { + return 0; + } + + if ((tok == DUK_TOK_DECREMENT || tok == DUK_TOK_INCREMENT) && + (comp_ctx->curr_token.lineterm)) { + /* '++' or '--' in a post-increment/decrement position, + * and a LineTerminator occurs between the operator and + * the preceding expression. Force the previous expr + * to terminate, in effect treating e.g. "a,b\n++" as + * "a,b;++" (= SyntaxError). + */ + return 0; + } + + return DUK__TOKEN_LBP_GET_BP(duk__token_lbp[tok]); /* format is bit packed */ +} + +/* + * Expression parsing. + * + * Upon entry to 'expr' and its variants, 'curr_tok' is assumed to be the + * first token of the expression. Upon exit, 'curr_tok' will be the first + * token not part of the expression (e.g. semicolon terminating an expression + * statement). + */ + +#define DUK__EXPR_RBP_MASK 0xff +#define DUK__EXPR_FLAG_REJECT_IN (1 << 8) +#define DUK__EXPR_FLAG_ALLOW_EMPTY (1 << 9) + +/* main expression parser function */ +DUK_LOCAL void duk__expr(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_ivalue tmp_alloc; /* 'res' is used for "left", and 'tmp' for "right" */ + duk_ivalue *tmp = &tmp_alloc; + duk_small_uint_t rbp; + + DUK__RECURSION_INCREASE(comp_ctx, thr); + + duk_require_stack(ctx, DUK__PARSE_EXPR_SLOTS); + + /* filter out flags from exprtop rbp_flags here to save space */ + rbp = rbp_flags & DUK__EXPR_RBP_MASK; + + DUK_DDD(DUK_DDDPRINT("duk__expr(), rbp_flags=%ld, rbp=%ld, allow_in=%ld, paren_level=%ld", + (long) rbp_flags, (long) rbp, (long) comp_ctx->curr_func.allow_in, + (long) comp_ctx->curr_func.paren_level)); + + DUK_MEMZERO(&tmp_alloc, sizeof(tmp_alloc)); + tmp->x1.valstack_idx = duk_get_top(ctx); + tmp->x2.valstack_idx = tmp->x1.valstack_idx + 1; + duk_push_undefined(ctx); + duk_push_undefined(ctx); + + /* XXX: where to release temp regs in intermediate expressions? + * e.g. 1+2+3 -> don't inflate temp register count when parsing this. + * that particular expression temp regs can be forced here. + */ + + /* XXX: increase ctx->expr_tokens here for every consumed token + * (this would be a nice statistic)? + */ + + if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON || comp_ctx->curr_token.t == DUK_TOK_RPAREN) { + /* XXX: possibly incorrect handling of empty expression */ + DUK_DDD(DUK_DDDPRINT("empty expression")); + if (!(rbp_flags & DUK__EXPR_FLAG_ALLOW_EMPTY)) { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_EMPTY_EXPR_NOT_ALLOWED); + } + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_VALUE; + duk_push_undefined(ctx); + duk_replace(ctx, res->x1.valstack_idx); + goto cleanup; + } + + duk__advance(comp_ctx); + duk__expr_nud(comp_ctx, res); /* reuse 'res' as 'left' */ + while (rbp < duk__expr_lbp(comp_ctx)) { + duk__advance(comp_ctx); + duk__expr_led(comp_ctx, res, tmp); + duk__copy_ivalue(comp_ctx, tmp, res); /* tmp -> res */ + } + + cleanup: + /* final result is already in 'res' */ + + duk_pop_2(ctx); + + DUK__RECURSION_DECREASE(comp_ctx, thr); +} + +DUK_LOCAL void duk__exprtop(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { + duk_hthread *thr = comp_ctx->thr; + + /* Note: these variables must reside in 'curr_func' instead of the global + * context: when parsing function expressions, expression parsing is nested. + */ + comp_ctx->curr_func.nud_count = 0; + comp_ctx->curr_func.led_count = 0; + comp_ctx->curr_func.paren_level = 0; + comp_ctx->curr_func.expr_lhs = 1; + comp_ctx->curr_func.allow_in = (rbp_flags & DUK__EXPR_FLAG_REJECT_IN ? 0 : 1); + + duk__expr(comp_ctx, res, rbp_flags); + + if (!(rbp_flags & DUK__EXPR_FLAG_ALLOW_EMPTY) && duk__expr_is_empty(comp_ctx)) { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_EMPTY_EXPR_NOT_ALLOWED); + } +} + +/* A bunch of helpers (for size optimization) that combine duk__expr()/duk__exprtop() + * and result conversions. + * + * Each helper needs at least 2-3 calls to make it worth while to wrap. + */ + +DUK_LOCAL duk_reg_t duk__expr_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { + duk__expr(comp_ctx, res, rbp_flags); + return duk__ivalue_toreg(comp_ctx, res); +} + +#if 0 /* unused */ +DUK_LOCAL duk_reg_t duk__expr_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { + duk__expr(comp_ctx, res, rbp_flags); + return duk__ivalue_totempreg(comp_ctx, res); +} +#endif + +DUK_LOCAL void duk__expr_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg) { + DUK_ASSERT(forced_reg >= 0); + duk__expr(comp_ctx, res, rbp_flags); + duk__ivalue_toforcedreg(comp_ctx, res, forced_reg); +} + +DUK_LOCAL duk_regconst_t duk__expr_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { + duk__expr(comp_ctx, res, rbp_flags); + return duk__ivalue_toregconst(comp_ctx, res); +} + +DUK_LOCAL void duk__expr_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { + duk__expr(comp_ctx, res, rbp_flags); + duk__ivalue_toplain(comp_ctx, res); +} + +DUK_LOCAL void duk__expr_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { + duk__expr(comp_ctx, res, rbp_flags); + duk__ivalue_toplain_ignore(comp_ctx, res); +} + +DUK_LOCAL duk_reg_t duk__exprtop_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { + duk__exprtop(comp_ctx, res, rbp_flags); + return duk__ivalue_toreg(comp_ctx, res); +} + +#if 0 /* unused */ +DUK_LOCAL duk_reg_t duk__exprtop_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { + duk__exprtop(comp_ctx, res, rbp_flags); + return duk__ivalue_totempreg(comp_ctx, res); +} +#endif + +DUK_LOCAL void duk__exprtop_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg) { + DUK_ASSERT(forced_reg >= 0); + duk__exprtop(comp_ctx, res, rbp_flags); + duk__ivalue_toforcedreg(comp_ctx, res, forced_reg); +} + +DUK_LOCAL duk_regconst_t duk__exprtop_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { + duk__exprtop(comp_ctx, res, rbp_flags); + return duk__ivalue_toregconst(comp_ctx, res); +} + +#if 0 /* unused */ +DUK_LOCAL void duk__exprtop_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, int rbp_flags) { + duk__exprtop(comp_ctx, res, rbp_flags); + duk__ivalue_toplain_ignore(comp_ctx, res); +} +#endif + +/* + * Parse an individual source element (top level statement) or a statement. + * + * Handles labeled statements automatically (peeling away labels before + * parsing an expression that follows the label(s)). + * + * Upon entry, 'curr_tok' contains the first token of the statement (parsed + * in "allow regexp literal" mode). Upon exit, 'curr_tok' contains the first + * token following the statement (if the statement has a terminator, this is + * the token after the terminator). + */ + +#ifdef DUK__HAS_VAL +#undef DUK__HAS_VAL +#endif +#ifdef DUK__HAS_TERM +#undef DUK__HAS_TERM +#endif +#ifdef DUK__ALLOW_AUTO_SEMI_ALWAYS +#undef DUK__ALLOW_AUTO_SEMI_ALWAYS +#endif +#ifdef DUK__STILL_PROLOGUE +#undef DUK__STILL_PROLOGUE +#endif +#ifdef DUK__IS_TERMINAL +#undef DUK__IS_TERMINAL +#endif + +#define DUK__HAS_VAL (1 << 0) /* stmt has non-empty value */ +#define DUK__HAS_TERM (1 << 1) /* stmt has explicit/implicit semicolon terminator */ +#define DUK__ALLOW_AUTO_SEMI_ALWAYS (1 << 2) /* allow automatic semicolon even without lineterm (compatibility) */ +#define DUK__STILL_PROLOGUE (1 << 3) /* statement does not terminate directive prologue */ +#define DUK__IS_TERMINAL (1 << 4) /* statement is guaranteed to be terminal (control doesn't flow to next statement) */ + +/* Parse a single variable declaration (e.g. "i" or "i=10"). A leading 'var' + * has already been eaten. These is no return value in 'res', it is used only + * as a temporary. + * + * When called from 'for-in' statement parser, the initializer expression must + * not allow the 'in' token. The caller supply additional expression parsing + * flags (like DUK__EXPR_FLAG_REJECT_IN) in 'expr_flags'. + * + * Finally, out_rc_varname and out_reg_varbind are updated to reflect where + * the identifier is bound: + * + * If register bound: out_reg_varbind >= 0, out_rc_varname == 0 (ignore) + * If not register bound: out_reg_varbind < 0, out_rc_varname >= 0 + * + * These allow the caller to use the variable for further assignment, e.g. + * as is done in 'for-in' parsing. + */ + +DUK_LOCAL void duk__parse_var_decl(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t expr_flags, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_hstring *h_varname; + duk_reg_t reg_varbind; + duk_regconst_t rc_varname; + + /* assume 'var' has been eaten */ + + /* Note: Identifier rejects reserved words */ + if (comp_ctx->curr_token.t != DUK_TOK_IDENTIFIER) { + goto syntax_error; + } + h_varname = comp_ctx->curr_token.str1; + + DUK_ASSERT(h_varname != NULL); + + /* strict mode restrictions (E5 Section 12.2.1) */ + if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) { + goto syntax_error; + } + + /* register declarations in first pass */ + if (comp_ctx->curr_func.in_scanning) { + duk_uarridx_t n; + DUK_DDD(DUK_DDDPRINT("register variable declaration %!O in pass 1", + (duk_heaphdr *) h_varname)); + n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx); + duk_push_hstring(ctx, h_varname); + duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n); + duk_push_int(ctx, DUK_DECL_TYPE_VAR + (0 << 8)); + duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n + 1); + } + + duk_push_hstring(ctx, h_varname); /* push before advancing to keep reachable */ + + /* register binding lookup is based on varmap (even in first pass) */ + duk_dup_top(ctx); + (void) duk__lookup_lhs(comp_ctx, ®_varbind, &rc_varname); + + duk__advance(comp_ctx); /* eat identifier */ + + if (comp_ctx->curr_token.t == DUK_TOK_EQUALSIGN) { + duk__advance(comp_ctx); + + DUK_DDD(DUK_DDDPRINT("vardecl, assign to '%!O' -> reg_varbind=%ld, rc_varname=%ld", + (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname)); + + duk__exprtop(comp_ctx, res, DUK__BP_COMMA | expr_flags /*rbp_flags*/); /* AssignmentExpression */ + + if (reg_varbind >= 0) { + duk__ivalue_toforcedreg(comp_ctx, res, reg_varbind); + } else { + duk_reg_t reg_val; + reg_val = duk__ivalue_toreg(comp_ctx, res); + duk__emit_a_bc(comp_ctx, + DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE, + (duk_regconst_t) reg_val, + rc_varname); + } + } + + duk_pop(ctx); /* pop varname */ + + *out_rc_varname = rc_varname; + *out_reg_varbind = reg_varbind; + + return; + + syntax_error: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_VAR_DECLARATION); +} + +DUK_LOCAL void duk__parse_var_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { + duk_reg_t reg_varbind; + duk_regconst_t rc_varname; + + duk__advance(comp_ctx); /* eat 'var' */ + + for (;;) { + /* rc_varname and reg_varbind are ignored here */ + duk__parse_var_decl(comp_ctx, res, 0, ®_varbind, &rc_varname); + + if (comp_ctx->curr_token.t != DUK_TOK_COMMA) { + break; + } + duk__advance(comp_ctx); + } +} + +DUK_LOCAL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_int_t pc_v34_lhs; /* start variant 3/4 left-hand-side code (L1 in doc/compiler.rst example) */ + duk_reg_t temp_reset; /* knock back "next temp" to this whenever possible */ + duk_reg_t reg_temps; /* preallocated temporaries (2) for variants 3 and 4 */ + + DUK_DDD(DUK_DDDPRINT("start parsing a for/for-in statement")); + + /* Two temporaries are preallocated here for variants 3 and 4 which need + * registers which are never clobbered by expressions in the loop + * (concretely: for the enumerator object and the next enumerated value). + * Variants 1 and 2 "release" these temps. + */ + + reg_temps = DUK__ALLOCTEMPS(comp_ctx, 2); + + temp_reset = DUK__GETTEMP(comp_ctx); + + /* + * For/for-in main variants are: + * + * 1. for (ExpressionNoIn_opt; Expression_opt; Expression_opt) Statement + * 2. for (var VariableDeclarationNoIn; Expression_opt; Expression_opt) Statement + * 3. for (LeftHandSideExpression in Expression) Statement + * 4. for (var VariableDeclarationNoIn in Expression) Statement + * + * Parsing these without arbitrary lookahead or backtracking is relatively + * tricky but we manage to do so for now. + * + * See doc/compiler.rst for a detailed discussion of control flow + * issues, evaluation order issues, etc. + */ + + duk__advance(comp_ctx); /* eat 'for' */ + duk__advance_expect(comp_ctx, DUK_TOK_LPAREN); + + DUK_DDD(DUK_DDDPRINT("detecting for/for-in loop variant, pc=%ld", (long) duk__get_current_pc(comp_ctx))); + + /* a label site has been emitted by duk__parse_stmt() automatically + * (it will also emit the ENDLABEL). + */ + + if (comp_ctx->curr_token.t == DUK_TOK_VAR) { + /* + * Variant 2 or 4 + */ + + duk_reg_t reg_varbind; /* variable binding register if register-bound (otherwise < 0) */ + duk_regconst_t rc_varname; /* variable name reg/const, if variable not register-bound */ + + duk__advance(comp_ctx); /* eat 'var' */ + duk__parse_var_decl(comp_ctx, res, DUK__EXPR_FLAG_REJECT_IN, ®_varbind, &rc_varname); + DUK__SETTEMP(comp_ctx, temp_reset); + + if (comp_ctx->curr_token.t == DUK_TOK_IN) { + /* + * Variant 4 + */ + + DUK_DDD(DUK_DDDPRINT("detected for variant 4: for (var VariableDeclarationNoIn in Expression) Statement")); + pc_v34_lhs = duk__get_current_pc(comp_ctx); /* jump is inserted here */ + if (reg_varbind >= 0) { + duk__emit_a_bc(comp_ctx, + DUK_OP_LDREG, + (duk_regconst_t) reg_varbind, + (duk_regconst_t) (reg_temps + 0)); + } else { + duk__emit_a_bc(comp_ctx, + DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE, + (duk_regconst_t) (reg_temps + 0), + rc_varname); + } + goto parse_3_or_4; + } else { + /* + * Variant 2 + */ + + DUK_DDD(DUK_DDDPRINT("detected for variant 2: for (var VariableDeclarationNoIn; Expression_opt; Expression_opt) Statement")); + for (;;) { + /* more initializers */ + if (comp_ctx->curr_token.t != DUK_TOK_COMMA) { + break; + } + DUK_DDD(DUK_DDDPRINT("variant 2 has another variable initializer")); + + duk__advance(comp_ctx); /* eat comma */ + duk__parse_var_decl(comp_ctx, res, DUK__EXPR_FLAG_REJECT_IN, ®_varbind, &rc_varname); + } + goto parse_1_or_2; + } + } else { + /* + * Variant 1 or 3 + */ + + pc_v34_lhs = duk__get_current_pc(comp_ctx); /* jump is inserted here (variant 3) */ + + /* Note that duk__exprtop() here can clobber any reg above current temp_next, + * so any loop variables (e.g. enumerator) must be "preallocated". + */ + + /* don't coerce yet to a plain value (variant 3 needs special handling) */ + duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_REJECT_IN | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/); /* Expression */ + if (comp_ctx->curr_token.t == DUK_TOK_IN) { + /* + * Variant 3 + */ + + /* XXX: need to determine LHS type, and check that it is LHS compatible */ + DUK_DDD(DUK_DDDPRINT("detected for variant 3: for (LeftHandSideExpression in Expression) Statement")); + if (duk__expr_is_empty(comp_ctx)) { + goto syntax_error; /* LeftHandSideExpression does not allow empty expression */ + } + + if (res->t == DUK_IVAL_VAR) { + duk_reg_t reg_varbind; + duk_regconst_t rc_varname; + + duk_dup(ctx, res->x1.valstack_idx); + if (duk__lookup_lhs(comp_ctx, ®_varbind, &rc_varname)) { + duk__emit_a_bc(comp_ctx, + DUK_OP_LDREG, + (duk_regconst_t) reg_varbind, + (duk_regconst_t) (reg_temps + 0)); + } else { + duk__emit_a_bc(comp_ctx, + DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE, + (duk_regconst_t) (reg_temps + 0), + rc_varname); + } + } else if (res->t == DUK_IVAL_PROP) { + /* Don't allow a constant for the object (even for a number etc), as + * it goes into the 'A' field of the opcode. + */ + duk_reg_t reg_obj; + duk_regconst_t rc_key; + reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/); /* don't allow const */ + rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/); + duk__emit_a_b_c(comp_ctx, + DUK_OP_PUTPROP | DUK__EMIT_FLAG_A_IS_SOURCE, + (duk_regconst_t) reg_obj, + rc_key, + (duk_regconst_t) (reg_temps + 0)); + } else { + duk__ivalue_toplain_ignore(comp_ctx, res); /* just in case */ + duk__emit_extraop_only(comp_ctx, + DUK_EXTRAOP_INVLHS); + } + goto parse_3_or_4; + } else { + /* + * Variant 1 + */ + + DUK_DDD(DUK_DDDPRINT("detected for variant 1: for (ExpressionNoIn_opt; Expression_opt; Expression_opt) Statement")); + duk__ivalue_toplain_ignore(comp_ctx, res); + goto parse_1_or_2; + } + } + + parse_1_or_2: + /* + * Parse variant 1 or 2. The first part expression (which differs + * in the variants) has already been parsed and its code emitted. + * + * reg_temps + 0: unused + * reg_temps + 1: unused + */ + { + duk_regconst_t rc_cond; + duk_int_t pc_l1, pc_l2, pc_l3, pc_l4; + duk_int_t pc_jumpto_l3, pc_jumpto_l4; + duk_bool_t expr_c_empty; + + DUK_DDD(DUK_DDDPRINT("shared code for parsing variants 1 and 2")); + + /* "release" preallocated temps since we won't need them */ + temp_reset = reg_temps + 0; + DUK__SETTEMP(comp_ctx, temp_reset); + + duk__advance_expect(comp_ctx, DUK_TOK_SEMICOLON); + + pc_l1 = duk__get_current_pc(comp_ctx); + duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/); /* Expression_opt */ + if (duk__expr_is_empty(comp_ctx)) { + /* no need to coerce */ + pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx); /* to body */ + pc_jumpto_l4 = -1; /* omitted */ + } else { + rc_cond = duk__ivalue_toregconst(comp_ctx, res); + duk__emit_if_false_skip(comp_ctx, rc_cond); + pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx); /* to body */ + pc_jumpto_l4 = duk__emit_jump_empty(comp_ctx); /* to exit */ + } + DUK__SETTEMP(comp_ctx, temp_reset); + + duk__advance_expect(comp_ctx, DUK_TOK_SEMICOLON); + + pc_l2 = duk__get_current_pc(comp_ctx); + duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/); /* Expression_opt */ + if (duk__expr_is_empty(comp_ctx)) { + /* no need to coerce */ + expr_c_empty = 1; + /* JUMP L1 omitted */ + } else { + duk__ivalue_toplain_ignore(comp_ctx, res); + expr_c_empty = 0; + duk__emit_jump(comp_ctx, pc_l1); + } + DUK__SETTEMP(comp_ctx, temp_reset); + + duk__advance_expect(comp_ctx, DUK_TOK_RPAREN); + + pc_l3 = duk__get_current_pc(comp_ctx); + duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/); + if (expr_c_empty) { + duk__emit_jump(comp_ctx, pc_l1); + } else { + duk__emit_jump(comp_ctx, pc_l2); + } + /* temp reset is not necessary after duk__parse_stmt(), which already does it */ + + pc_l4 = duk__get_current_pc(comp_ctx); + + DUK_DDD(DUK_DDDPRINT("patching jumps: jumpto_l3: %ld->%ld, jumpto_l4: %ld->%ld, " + "break: %ld->%ld, continue: %ld->%ld", + (long) pc_jumpto_l3, (long) pc_l3, (long) pc_jumpto_l4, (long) pc_l4, + (long) (pc_label_site + 1), (long) pc_l4, (long) (pc_label_site + 2), (long) pc_l2)); + + duk__patch_jump(comp_ctx, pc_jumpto_l3, pc_l3); + duk__patch_jump(comp_ctx, pc_jumpto_l4, pc_l4); + duk__patch_jump(comp_ctx, + pc_label_site + 1, + pc_l4); /* break jump */ + duk__patch_jump(comp_ctx, + pc_label_site + 2, + expr_c_empty ? pc_l1 : pc_l2); /* continue jump */ + } + goto finished; + + parse_3_or_4: + /* + * Parse variant 3 or 4. + * + * For variant 3 (e.g. "for (A in C) D;") the code for A (except the + * final property/variable write) has already been emitted. The first + * instruction of that code is at pc_v34_lhs; a JUMP needs to be inserted + * there to satisfy control flow needs. + * + * For variant 4, if the variable declaration had an initializer + * (e.g. "for (var A = B in C) D;") the code for the assignment + * (B) has already been emitted. + * + * Variables set before entering here: + * + * pc_v34_lhs: insert a "JUMP L2" here (see doc/compiler.rst example). + * reg_temps + 0: iteration target value (written to LHS) + * reg_temps + 1: enumerator object + */ + { + duk_int_t pc_l1, pc_l2, pc_l3, pc_l4, pc_l5; + duk_int_t pc_jumpto_l2, pc_jumpto_l3, pc_jumpto_l4, pc_jumpto_l5; + duk_reg_t reg_target; + + DUK_DDD(DUK_DDDPRINT("shared code for parsing variants 3 and 4, pc_v34_lhs=%ld", (long) pc_v34_lhs)); + + DUK__SETTEMP(comp_ctx, temp_reset); + + /* First we need to insert a jump in the middle of previously + * emitted code to get the control flow right. No jumps can + * cross the position where the jump is inserted. See doc/compiler.rst + * for discussion on the intricacies of control flow and side effects + * for variants 3 and 4. + */ + + duk__insert_jump_entry(comp_ctx, pc_v34_lhs); + pc_jumpto_l2 = pc_v34_lhs; /* inserted jump */ + pc_l1 = pc_v34_lhs + 1; /* +1, right after inserted jump */ + + /* The code for writing reg_temps + 0 to the left hand side has already + * been emitted. + */ + + pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx); /* -> loop body */ + + duk__advance(comp_ctx); /* eat 'in' */ + + /* Parse enumeration target and initialize enumerator. For 'null' and 'undefined', + * INITENUM will creates a 'null' enumerator which works like an empty enumerator + * (E5 Section 12.6.4, step 3). Note that INITENUM requires the value to be in a + * register (constant not allowed). + */ + + pc_l2 = duk__get_current_pc(comp_ctx); + reg_target = duk__exprtop_toreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); /* Expression */ + duk__emit_extraop_b_c(comp_ctx, + DUK_EXTRAOP_INITENUM | DUK__EMIT_FLAG_B_IS_TARGET, + (duk_regconst_t) (reg_temps + 1), + (duk_regconst_t) reg_target); + pc_jumpto_l4 = duk__emit_jump_empty(comp_ctx); + DUK__SETTEMP(comp_ctx, temp_reset); + + duk__advance_expect(comp_ctx, DUK_TOK_RPAREN); + + pc_l3 = duk__get_current_pc(comp_ctx); + duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/); + /* temp reset is not necessary after duk__parse_stmt(), which already does it */ + + /* NEXTENUM needs a jump slot right after the main opcode. + * We need the code emitter to reserve the slot: if there's + * target shuffling, the target shuffle opcodes must happen + * after the jump slot (for NEXTENUM the shuffle opcodes are + * not needed if the enum is finished). + */ + pc_l4 = duk__get_current_pc(comp_ctx); + duk__emit_extraop_b_c(comp_ctx, + DUK_EXTRAOP_NEXTENUM | DUK__EMIT_FLAG_B_IS_TARGET | DUK__EMIT_FLAG_RESERVE_JUMPSLOT, + (duk_regconst_t) (reg_temps + 0), + (duk_regconst_t) (reg_temps + 1)); + pc_jumpto_l5 = comp_ctx->emit_jumpslot_pc; /* NEXTENUM jump slot: executed when enum finished */ + duk__emit_jump(comp_ctx, pc_l1); /* jump to next loop, using reg_v34_iter as iterated value */ + + pc_l5 = duk__get_current_pc(comp_ctx); + + /* XXX: since the enumerator may be a memory expensive object, + * perhaps clear it explicitly here? If so, break jump must + * go through this clearing operation. + */ + + DUK_DDD(DUK_DDDPRINT("patching jumps: jumpto_l2: %ld->%ld, jumpto_l3: %ld->%ld, " + "jumpto_l4: %ld->%ld, jumpto_l5: %ld->%ld, " + "break: %ld->%ld, continue: %ld->%ld", + (long) pc_jumpto_l2, (long) pc_l2, (long) pc_jumpto_l3, (long) pc_l3, + (long) pc_jumpto_l4, (long) pc_l4, (long) pc_jumpto_l5, (long) pc_l5, + (long) (pc_label_site + 1), (long) pc_l5, (long) (pc_label_site + 2), (long) pc_l4)); + + duk__patch_jump(comp_ctx, pc_jumpto_l2, pc_l2); + duk__patch_jump(comp_ctx, pc_jumpto_l3, pc_l3); + duk__patch_jump(comp_ctx, pc_jumpto_l4, pc_l4); + duk__patch_jump(comp_ctx, pc_jumpto_l5, pc_l5); + duk__patch_jump(comp_ctx, pc_label_site + 1, pc_l5); /* break jump */ + duk__patch_jump(comp_ctx, pc_label_site + 2, pc_l4); /* continue jump */ + } + goto finished; + + finished: + DUK_DDD(DUK_DDDPRINT("end parsing a for/for-in statement")); + return; + + syntax_error: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_FOR); +} + +DUK_LOCAL void duk__parse_switch_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) { + duk_hthread *thr = comp_ctx->thr; + duk_reg_t temp_at_loop; + duk_regconst_t rc_switch; /* reg/const for switch value */ + duk_regconst_t rc_case; /* reg/const for case value */ + duk_reg_t reg_temp; /* general temp register */ + duk_int_t pc_prevcase = -1; + duk_int_t pc_prevstmt = -1; + duk_int_t pc_default = -1; /* -1 == not set, -2 == pending (next statement list) */ + + /* Note: negative pc values are ignored when patching jumps, so no explicit checks needed */ + + /* + * Switch is pretty complicated because of several conflicting concerns: + * + * - Want to generate code without an intermediate representation, + * i.e., in one go + * + * - Case selectors are expressions, not values, and may thus e.g. throw + * exceptions (which causes evaluation order concerns) + * + * - Evaluation semantics of case selectors and default clause need to be + * carefully implemented to provide correct behavior even with case value + * side effects + * + * - Fall through case and default clauses; avoiding dead JUMPs if case + * ends with an unconditional jump (a break or a continue) + * + * - The same case value may occur multiple times, but evaluation rules + * only process the first match before switching to a "propagation" mode + * where case values are no longer evaluated + * + * See E5 Section 12.11. Also see doc/compiler.rst for compilation + * discussion. + */ + + duk__advance(comp_ctx); + duk__advance_expect(comp_ctx, DUK_TOK_LPAREN); + rc_switch = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); + duk__advance_expect(comp_ctx, DUK_TOK_RPAREN); + duk__advance_expect(comp_ctx, DUK_TOK_LCURLY); + + DUK_DDD(DUK_DDDPRINT("switch value in register %ld", (long) rc_switch)); + + temp_at_loop = DUK__GETTEMP(comp_ctx); + + for (;;) { + duk_int_t num_stmts; + duk_small_int_t tok; + + /* sufficient for keeping temp reg numbers in check */ + DUK__SETTEMP(comp_ctx, temp_at_loop); + + if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) { + break; + } + + /* + * Parse a case or default clause. + */ + + if (comp_ctx->curr_token.t == DUK_TOK_CASE) { + /* + * Case clause. + * + * Note: cannot use reg_case as a temp register (for SEQ target) + * because it may be a constant. + */ + + duk__patch_jump_here(comp_ctx, pc_prevcase); /* chain jumps for case + * evaluation and checking + */ + + duk__advance(comp_ctx); + rc_case = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); + duk__advance_expect(comp_ctx, DUK_TOK_COLON); + + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_b_c(comp_ctx, + DUK_OP_SEQ, + (duk_regconst_t) reg_temp, + rc_switch, + rc_case); + duk__emit_if_true_skip(comp_ctx, (duk_regconst_t) reg_temp); + + /* jump to next case clause */ + pc_prevcase = duk__emit_jump_empty(comp_ctx); /* no match, next case */ + + /* statements go here (if any) on next loop */ + } else if (comp_ctx->curr_token.t == DUK_TOK_DEFAULT) { + /* + * Default clause. + */ + + if (pc_default >= 0) { + goto syntax_error; + } + duk__advance(comp_ctx); + duk__advance_expect(comp_ctx, DUK_TOK_COLON); + + /* Fix for https://github.com/svaarala/duktape/issues/155: + * If 'default' is first clause (detected by pc_prevcase < 0) + * we need to ensure we stay in the matching chain. + */ + if (pc_prevcase < 0) { + DUK_DD(DUK_DDPRINT("default clause is first, emit prevcase jump")); + pc_prevcase = duk__emit_jump_empty(comp_ctx); + } + + /* default clause matches next statement list (if any) */ + pc_default = -2; + } else { + /* Code is not accepted before the first case/default clause */ + goto syntax_error; + } + + /* + * Parse code after the clause. Possible terminators are + * 'case', 'default', and '}'. + * + * Note that there may be no code at all, not even an empty statement, + * between case clauses. This must be handled just like an empty statement + * (omitting seemingly pointless JUMPs), to avoid situations like + * test-bug-case-fallthrough.js. + */ + + num_stmts = 0; + if (pc_default == -2) { + pc_default = duk__get_current_pc(comp_ctx); + } + + /* Note: this is correct even for default clause statements: + * they participate in 'fall-through' behavior even if the + * default clause is in the middle. + */ + duk__patch_jump_here(comp_ctx, pc_prevstmt); /* chain jumps for 'fall-through' + * after a case matches. + */ + + for (;;) { + tok = comp_ctx->curr_token.t; + if (tok == DUK_TOK_CASE || tok == DUK_TOK_DEFAULT || + tok == DUK_TOK_RCURLY) { + break; + } + num_stmts++; + duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/); + } + + /* fall-through jump to next code of next case (backpatched) */ + pc_prevstmt = duk__emit_jump_empty(comp_ctx); + + /* XXX: would be nice to omit this jump when the jump is not + * reachable, at least in the obvious cases (such as the case + * ending with a 'break'. + * + * Perhaps duk__parse_stmt() could provide some info on whether + * the statement is a "dead end"? + * + * If implemented, just set pc_prevstmt to -1 when not needed. + */ + } + + DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RCURLY); + duk__advance(comp_ctx); + + /* default case control flow patchup; note that if pc_prevcase < 0 + * (i.e. no case clauses), control enters default case automatically. + */ + if (pc_default >= 0) { + /* default case exists: go there if no case matches */ + duk__patch_jump(comp_ctx, pc_prevcase, pc_default); + } else { + /* default case does not exist, or no statements present + * after default case: finish case evaluation + */ + duk__patch_jump_here(comp_ctx, pc_prevcase); + } + + /* fall-through control flow patchup; note that pc_prevstmt may be + * < 0 (i.e. no case clauses), in which case this is a no-op. + */ + duk__patch_jump_here(comp_ctx, pc_prevstmt); + + /* continue jump not patched, an INVALID opcode remains there */ + duk__patch_jump_here(comp_ctx, pc_label_site + 1); /* break jump */ + + /* Note: 'fast' breaks will jump to pc_label_site + 1, which will + * then jump here. The double jump will be eliminated by a + * peephole pass, resulting in an optimal jump here. The label + * site jumps will remain in bytecode and will waste code size. + */ + + return; + + syntax_error: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_SWITCH); +} + +DUK_LOCAL void duk__parse_if_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { + duk_reg_t temp_reset; + duk_regconst_t rc_cond; + duk_int_t pc_jump_false; + + DUK_DDD(DUK_DDDPRINT("begin parsing if statement")); + + temp_reset = DUK__GETTEMP(comp_ctx); + + duk__advance(comp_ctx); /* eat 'if' */ + duk__advance_expect(comp_ctx, DUK_TOK_LPAREN); + + rc_cond = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); + duk__emit_if_true_skip(comp_ctx, rc_cond); + pc_jump_false = duk__emit_jump_empty(comp_ctx); /* jump to end or else part */ + DUK__SETTEMP(comp_ctx, temp_reset); + + duk__advance_expect(comp_ctx, DUK_TOK_RPAREN); + + duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/); + + /* The 'else' ambiguity is resolved by 'else' binding to the innermost + * construct, so greedy matching is correct here. + */ + + if (comp_ctx->curr_token.t == DUK_TOK_ELSE) { + duk_int_t pc_jump_end; + + DUK_DDD(DUK_DDDPRINT("if has else part")); + + duk__advance(comp_ctx); + + pc_jump_end = duk__emit_jump_empty(comp_ctx); /* jump from true part to end */ + duk__patch_jump_here(comp_ctx, pc_jump_false); + + duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/); + + duk__patch_jump_here(comp_ctx, pc_jump_end); + } else { + DUK_DDD(DUK_DDDPRINT("if does not have else part")); + + duk__patch_jump_here(comp_ctx, pc_jump_false); + } + + DUK_DDD(DUK_DDDPRINT("end parsing if statement")); +} + +DUK_LOCAL void duk__parse_do_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) { + duk_regconst_t rc_cond; + duk_int_t pc_start; + + DUK_DDD(DUK_DDDPRINT("begin parsing do statement")); + + duk__advance(comp_ctx); /* eat 'do' */ + + pc_start = duk__get_current_pc(comp_ctx); + duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/); + duk__patch_jump_here(comp_ctx, pc_label_site + 2); /* continue jump */ + + duk__advance_expect(comp_ctx, DUK_TOK_WHILE); + duk__advance_expect(comp_ctx, DUK_TOK_LPAREN); + + rc_cond = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); + duk__emit_if_false_skip(comp_ctx, rc_cond); + duk__emit_jump(comp_ctx, pc_start); + /* no need to reset temps, as we're finished emitting code */ + + duk__advance_expect(comp_ctx, DUK_TOK_RPAREN); + + duk__patch_jump_here(comp_ctx, pc_label_site + 1); /* break jump */ + + DUK_DDD(DUK_DDDPRINT("end parsing do statement")); +} + +DUK_LOCAL void duk__parse_while_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) { + duk_reg_t temp_reset; + duk_regconst_t rc_cond; + duk_int_t pc_start; + duk_int_t pc_jump_false; + + DUK_DDD(DUK_DDDPRINT("begin parsing while statement")); + + temp_reset = DUK__GETTEMP(comp_ctx); + + duk__advance(comp_ctx); /* eat 'while' */ + + duk__advance_expect(comp_ctx, DUK_TOK_LPAREN); + + pc_start = duk__get_current_pc(comp_ctx); + duk__patch_jump_here(comp_ctx, pc_label_site + 2); /* continue jump */ + + rc_cond = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); + duk__emit_if_true_skip(comp_ctx, rc_cond); + pc_jump_false = duk__emit_jump_empty(comp_ctx); + DUK__SETTEMP(comp_ctx, temp_reset); + + duk__advance_expect(comp_ctx, DUK_TOK_RPAREN); + + duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/); + duk__emit_jump(comp_ctx, pc_start); + + duk__patch_jump_here(comp_ctx, pc_jump_false); + duk__patch_jump_here(comp_ctx, pc_label_site + 1); /* break jump */ + + DUK_DDD(DUK_DDDPRINT("end parsing while statement")); +} + +DUK_LOCAL void duk__parse_break_or_continue_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { + duk_hthread *thr = comp_ctx->thr; + duk_bool_t is_break = (comp_ctx->curr_token.t == DUK_TOK_BREAK); + duk_int_t label_id; + duk_int_t label_catch_depth; + duk_int_t label_pc; /* points to LABEL; pc+1 = jump site for break; pc+2 = jump site for continue */ + duk_bool_t label_is_closest; + + DUK_UNREF(res); + + duk__advance(comp_ctx); /* eat 'break' or 'continue' */ + + if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON || /* explicit semi follows */ + comp_ctx->curr_token.lineterm || /* automatic semi will be inserted */ + comp_ctx->curr_token.allow_auto_semi) { /* automatic semi will be inserted */ + /* break/continue without label */ + + duk__lookup_active_label(comp_ctx, DUK_HTHREAD_STRING_EMPTY_STRING(thr), is_break, &label_id, &label_catch_depth, &label_pc, &label_is_closest); + } else if (comp_ctx->curr_token.t == DUK_TOK_IDENTIFIER) { + /* break/continue with label (label cannot be a reserved word, production is 'Identifier' */ + DUK_ASSERT(comp_ctx->curr_token.str1 != NULL); + duk__lookup_active_label(comp_ctx, comp_ctx->curr_token.str1, is_break, &label_id, &label_catch_depth, &label_pc, &label_is_closest); + duk__advance(comp_ctx); + } else { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_BREAK_CONT_LABEL); + } + + /* Use a fast break/continue when possible. A fast break/continue is + * just a jump to the LABEL break/continue jump slot, which then jumps + * to an appropriate place (for break, going through ENDLABEL correctly). + * The peephole optimizer will optimize the jump to a direct one. + */ + + if (label_catch_depth == comp_ctx->curr_func.catch_depth && + label_is_closest) { + DUK_DDD(DUK_DDDPRINT("break/continue: is_break=%ld, label_id=%ld, label_is_closest=%ld, " + "label_catch_depth=%ld, catch_depth=%ld " + "-> use fast variant (direct jump)", + (long) is_break, (long) label_id, (long) label_is_closest, + (long) label_catch_depth, (long) comp_ctx->curr_func.catch_depth)); + + duk__emit_jump(comp_ctx, label_pc + (is_break ? 1 : 2)); + } else { + DUK_DDD(DUK_DDDPRINT("break/continue: is_break=%ld, label_id=%ld, label_is_closest=%ld, " + "label_catch_depth=%ld, catch_depth=%ld " + "-> use slow variant (longjmp)", + (long) is_break, (long) label_id, (long) label_is_closest, + (long) label_catch_depth, (long) comp_ctx->curr_func.catch_depth)); + + duk__emit_extraop_bc(comp_ctx, + is_break ? DUK_EXTRAOP_BREAK : DUK_EXTRAOP_CONTINUE, + (duk_regconst_t) label_id); + } +} + +DUK_LOCAL void duk__parse_return_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { + duk_hthread *thr = comp_ctx->thr; + duk_regconst_t rc_val; + duk_small_uint_t ret_flags; + + duk__advance(comp_ctx); /* eat 'return' */ + + /* A 'return' statement is only allowed inside an actual function body, + * not as part of eval or global code. + */ + if (!comp_ctx->curr_func.is_function) { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_RETURN); + } + + /* Use a fast return when possible. A fast return does not cause a longjmp() + * unnecessarily. A fast return can be done when no TCF catchers are active + * (this includes 'try' and 'with' statements). Active label catches do not + * prevent a fast return; they're unwound on return automatically. + */ + + ret_flags = 0; + + if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON || /* explicit semi follows */ + comp_ctx->curr_token.lineterm || /* automatic semi will be inserted */ + comp_ctx->curr_token.allow_auto_semi) { /* automatic semi will be inserted */ + DUK_DDD(DUK_DDDPRINT("empty return value -> undefined")); + rc_val = 0; + } else { + duk_int_t pc_before_expr; + duk_int_t pc_after_expr; + + DUK_DDD(DUK_DDDPRINT("return with a value")); + + DUK_UNREF(pc_before_expr); + DUK_UNREF(pc_after_expr); + + pc_before_expr = duk__get_current_pc(comp_ctx); + rc_val = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); + pc_after_expr = duk__get_current_pc(comp_ctx); + + /* Tail call check: if last opcode emitted was CALL(I), and + * the context allows it, change the CALL(I) to a tail call. + * This doesn't guarantee that a tail call will be allowed at + * runtime, so the RETURN must still be emitted. (Duktape + * 0.10.0 avoided this and simulated a RETURN if a tail call + * couldn't be used at runtime; but this didn't work + * correctly with a thread yield/resume, see + * test-bug-tailcall-thread-yield-resume.js for discussion.) + * + * In addition to the last opcode being CALL, we also need to + * be sure that 'rc_val' is the result register of the CALL(I). + * For instance, for the expression 'return 0, (function () + * { return 1; }), 2' the last opcode emitted is CALL (no + * bytecode is emitted for '2') but 'rc_val' indicates + * constant '2'. Similarly if '2' is replaced by a register + * bound variable, no opcodes are emitted but tail call would + * be incorrect. + * + * This is tricky and easy to get wrong. It would be best to + * track enough expression metadata to check that 'rc_val' came + * from that last CALL instruction. We don't have that metadata + * now, so we check that 'rc_val' is a temporary register result + * (not a constant or a register bound variable). There should + * be no way currently for 'rc_val' to be a temporary for an + * expression following the CALL instruction without emitting + * some opcodes following the CALL. This proxy check is used + * below. + * + * See: test-bug-comma-expr-gh131.js. + * + * The non-standard 'caller' property disables tail calls + * because they pose some special cases which haven't been + * fixed yet. + */ + +#if defined(DUK_USE_TAILCALL) + if (comp_ctx->curr_func.catch_depth == 0 && /* no catchers */ + pc_after_expr > pc_before_expr) { /* at least one opcode emitted */ + duk_compiler_instr *instr; + duk_small_uint_t op; + + instr = duk__get_instr_ptr(comp_ctx, pc_after_expr - 1); + DUK_ASSERT(instr != NULL); + + op = (duk_small_uint_t) DUK_DEC_OP(instr->ins); + if ((op == DUK_OP_CALL || op == DUK_OP_CALLI) && + DUK__ISTEMP(comp_ctx, rc_val) /* see above */) { + DUK_DDD(DUK_DDDPRINT("return statement detected a tail call opportunity: " + "catch depth is 0, duk__exprtop() emitted >= 1 instructions, " + "and last instruction is a CALL " + "-> set TAILCALL flag")); + /* Just flip the single bit. */ + instr->ins |= DUK_ENC_OP_A_B_C(0, DUK_BC_CALL_FLAG_TAILCALL, 0, 0); + } + } +#endif /* DUK_USE_TAILCALL */ + + ret_flags = DUK_BC_RETURN_FLAG_HAVE_RETVAL; + } + + /* XXX: For now, "fast returns" are disabled. The compiler doesn't track + * label site depth so when it emits a fast return, it doesn't know whether + * label sites exist or not. Label sites are emitted for e.g. for loops, + * so it's probably quite relevant to handle them in the executor's fast + * return handler. + */ +#if 0 + if (comp_ctx->curr_func.catch_depth == 0) { + DUK_DDD(DUK_DDDPRINT("fast return allowed -> use fast return")); + ret_flags |= DUK_BC_RETURN_FLAG_FAST; + } else { + DUK_DDD(DUK_DDDPRINT("fast return not allowed -> use slow return")); + } +#endif + + duk__emit_a_b(comp_ctx, + DUK_OP_RETURN | DUK__EMIT_FLAG_NO_SHUFFLE_A, + (duk_regconst_t) ret_flags /*flags*/, + rc_val /*reg*/); +} + +DUK_LOCAL void duk__parse_throw_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { + duk_reg_t reg_val; + + duk__advance(comp_ctx); /* eat 'throw' */ + + /* Unlike break/continue, throw statement does not allow an empty value. */ + + if (comp_ctx->curr_token.lineterm) { + DUK_ERROR(comp_ctx->thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_THROW); + } + + reg_val = duk__exprtop_toreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); + duk__emit_extraop_bc(comp_ctx, + DUK_EXTRAOP_THROW, + (duk_regconst_t) reg_val); +} + +DUK_LOCAL void duk__parse_try_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_reg_t reg_catch; /* reg_catch+0 and reg_catch+1 are reserved for TRYCATCH */ + duk_regconst_t rc_varname = 0; + duk_small_uint_t trycatch_flags = 0; + duk_int_t pc_ldconst = -1; + duk_int_t pc_trycatch = -1; + duk_int_t pc_catch = -1; + duk_int_t pc_finally = -1; + + DUK_UNREF(res); + + /* + * See the following documentation for discussion: + * + * doc/execution.rst: control flow details + * + * Try, catch, and finally "parts" are Blocks, not Statements, so + * they must always be delimited by curly braces. This is unlike e.g. + * the if statement, which accepts any Statement. This eliminates any + * questions of matching parts of nested try statements. The Block + * parsing is implemented inline here (instead of calling out). + * + * Finally part has a 'let scoped' variable, which requires a few kinks + * here. + */ + + comp_ctx->curr_func.catch_depth++; + + duk__advance(comp_ctx); /* eat 'try' */ + + reg_catch = DUK__ALLOCTEMPS(comp_ctx, 2); + + /* The target for this LDCONST may need output shuffling, but we assume + * that 'pc_ldconst' will be the LDCONST that we can patch later. This + * should be the case because there's no input shuffling. (If there's + * no catch clause, this LDCONST will be replaced with a NOP.) + */ + pc_ldconst = duk__get_current_pc(comp_ctx); + duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, reg_catch, 0 /*patched later*/); + + pc_trycatch = duk__get_current_pc(comp_ctx); + duk__emit_invalid(comp_ctx); /* TRYCATCH, cannot emit now (not enough info) */ + duk__emit_invalid(comp_ctx); /* jump for 'catch' case */ + duk__emit_invalid(comp_ctx); /* jump for 'finally' case or end (if no finally) */ + + /* try part */ + duk__advance_expect(comp_ctx, DUK_TOK_LCURLY); + duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/); + /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */ + duk__emit_extraop_only(comp_ctx, + DUK_EXTRAOP_ENDTRY); + + if (comp_ctx->curr_token.t == DUK_TOK_CATCH) { + /* + * The catch variable must be updated to reflect the new allocated + * register for the duration of the catch clause. We need to store + * and restore the original value for the varmap entry (if any). + */ + + /* + * Note: currently register bindings must be fixed for the entire + * function. So, even though the catch variable is in a register + * we know, we must use an explicit environment record and slow path + * accesses to read/write the catch binding to make closures created + * within the catch clause work correctly. This restriction should + * be fixable (at least in common cases) later. + * + * See: test-bug-catch-binding-2.js. + * + * XXX: improve to get fast path access to most catch clauses. + */ + + duk_hstring *h_var; + duk_int_t varmap_value; /* for storing/restoring the varmap binding for catch variable */ + + DUK_DDD(DUK_DDDPRINT("stack top at start of catch clause: %ld", (long) duk_get_top(ctx))); + + trycatch_flags |= DUK_BC_TRYCATCH_FLAG_HAVE_CATCH; + + pc_catch = duk__get_current_pc(comp_ctx); + + duk__advance(comp_ctx); + duk__advance_expect(comp_ctx, DUK_TOK_LPAREN); + + if (comp_ctx->curr_token.t != DUK_TOK_IDENTIFIER) { + /* Identifier, i.e. don't allow reserved words */ + goto syntax_error; + } + h_var = comp_ctx->curr_token.str1; + DUK_ASSERT(h_var != NULL); + + duk_push_hstring(ctx, h_var); /* keep in on valstack, use borrowed ref below */ + + if (comp_ctx->curr_func.is_strict && + ((h_var == DUK_HTHREAD_STRING_EVAL(thr)) || + (h_var == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)))) { + DUK_DDD(DUK_DDDPRINT("catch identifier 'eval' or 'arguments' in strict mode -> SyntaxError")); + goto syntax_error; + } + + duk_dup_top(ctx); + rc_varname = duk__getconst(comp_ctx); + DUK_DDD(DUK_DDDPRINT("catch clause, rc_varname=0x%08lx (%ld)", + (unsigned long) rc_varname, (long) rc_varname)); + + duk__advance(comp_ctx); + duk__advance_expect(comp_ctx, DUK_TOK_RPAREN); + + duk__advance_expect(comp_ctx, DUK_TOK_LCURLY); + + DUK_DDD(DUK_DDDPRINT("varmap before modifying for catch clause: %!iT", + (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx))); + + duk_dup_top(ctx); + duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx); + if (duk_is_undefined(ctx, -1)) { + varmap_value = -2; + } else if (duk_is_null(ctx, -1)) { + varmap_value = -1; + } else { + DUK_ASSERT(duk_is_number(ctx, -1)); + varmap_value = duk_get_int(ctx, -1); + DUK_ASSERT(varmap_value >= 0); + } + duk_pop(ctx); + +#if 0 + /* It'd be nice to do something like this - but it doesn't + * work for closures created inside the catch clause. + */ + duk_dup_top(ctx); + duk_push_int(ctx, (duk_int_t) (reg_catch + 0)); + duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx); +#endif + duk_dup_top(ctx); + duk_push_null(ctx); + duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx); + + duk__emit_a_bc(comp_ctx, + DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE, + (duk_regconst_t) (reg_catch + 0) /*value*/, + rc_varname /*varname*/); + + DUK_DDD(DUK_DDDPRINT("varmap before parsing catch clause: %!iT", + (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx))); + + duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/); + /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */ + + if (varmap_value == -2) { + /* not present */ + duk_del_prop(ctx, comp_ctx->curr_func.varmap_idx); + } else { + if (varmap_value == -1) { + duk_push_null(ctx); + } else { + DUK_ASSERT(varmap_value >= 0); + duk_push_int(ctx, varmap_value); + } + duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx); + } + /* varname is popped by above code */ + + DUK_DDD(DUK_DDDPRINT("varmap after restore catch clause: %!iT", + (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx))); + + duk__emit_extraop_only(comp_ctx, + DUK_EXTRAOP_ENDCATCH); + + /* + * XXX: for now, indicate that an expensive catch binding + * declarative environment is always needed. If we don't + * need it, we don't need the const_varname either. + */ + + trycatch_flags |= DUK_BC_TRYCATCH_FLAG_CATCH_BINDING; + + DUK_DDD(DUK_DDDPRINT("stack top at end of catch clause: %ld", (long) duk_get_top(ctx))); + } + + if (comp_ctx->curr_token.t == DUK_TOK_FINALLY) { + trycatch_flags |= DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY; + + pc_finally = duk__get_current_pc(comp_ctx); + + duk__advance(comp_ctx); + + duk__advance_expect(comp_ctx, DUK_TOK_LCURLY); + duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/); + /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */ + duk__emit_extraop_b(comp_ctx, + DUK_EXTRAOP_ENDFIN, + reg_catch); /* rethrow */ + } + + if (!(trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH) && + !(trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY)) { + /* must have catch and/or finally */ + goto syntax_error; + } + + /* If there's no catch block, rc_varname will be 0 and duk__patch_trycatch() + * will replace the LDCONST with a NOP. For any actual constant (including + * constant 0) the DUK__CONST_MARKER flag will be set in rc_varname. + */ + + duk__patch_trycatch(comp_ctx, + pc_ldconst, + pc_trycatch, + reg_catch, + rc_varname, + trycatch_flags); + + if (trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH) { + DUK_ASSERT(pc_catch >= 0); + duk__patch_jump(comp_ctx, pc_trycatch + 1, pc_catch); + } + + if (trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY) { + DUK_ASSERT(pc_finally >= 0); + duk__patch_jump(comp_ctx, pc_trycatch + 2, pc_finally); + } else { + /* without finally, the second jump slot is used to jump to end of stmt */ + duk__patch_jump_here(comp_ctx, pc_trycatch + 2); + } + + comp_ctx->curr_func.catch_depth--; + return; + + syntax_error: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_TRY); +} + +DUK_LOCAL void duk__parse_with_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { + duk_int_t pc_trycatch; + duk_int_t pc_finished; + duk_reg_t reg_catch; + duk_small_uint_t trycatch_flags; + + if (comp_ctx->curr_func.is_strict) { + DUK_ERROR(comp_ctx->thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_WITH_IN_STRICT_MODE); + } + + comp_ctx->curr_func.catch_depth++; + + duk__advance(comp_ctx); /* eat 'with' */ + + reg_catch = DUK__ALLOCTEMPS(comp_ctx, 2); + + duk__advance_expect(comp_ctx, DUK_TOK_LPAREN); + duk__exprtop_toforcedreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/, reg_catch); + duk__advance_expect(comp_ctx, DUK_TOK_RPAREN); + + pc_trycatch = duk__get_current_pc(comp_ctx); + trycatch_flags = DUK_BC_TRYCATCH_FLAG_WITH_BINDING; + duk__emit_a_bc(comp_ctx, + DUK_OP_TRYCATCH | DUK__EMIT_FLAG_NO_SHUFFLE_A, + (duk_regconst_t) trycatch_flags /*a*/, + (duk_regconst_t) reg_catch /*bc*/); + duk__emit_invalid(comp_ctx); /* catch jump */ + duk__emit_invalid(comp_ctx); /* finished jump */ + + duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/); + duk__emit_extraop_only(comp_ctx, + DUK_EXTRAOP_ENDTRY); + + pc_finished = duk__get_current_pc(comp_ctx); + + duk__patch_jump(comp_ctx, pc_trycatch + 2, pc_finished); + + comp_ctx->curr_func.catch_depth--; +} + +DUK_LOCAL duk_int_t duk__stmt_label_site(duk_compiler_ctx *comp_ctx, duk_int_t label_id) { + /* if a site already exists, nop: max one label site per statement */ + if (label_id >= 0) { + return label_id; + } + + label_id = comp_ctx->curr_func.label_next++; + DUK_DDD(DUK_DDDPRINT("allocated new label id for label site: %ld", (long) label_id)); + + duk__emit_extraop_bc(comp_ctx, + DUK_EXTRAOP_LABEL, + (duk_regconst_t) label_id); + duk__emit_invalid(comp_ctx); + duk__emit_invalid(comp_ctx); + + return label_id; +} + +/* Parse a single statement. + * + * Creates a label site (with an empty label) automatically for iteration + * statements. Also "peels off" any label statements for explicit labels. + */ +DUK_LOCAL void duk__parse_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_bool_t allow_source_elem) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_bool_t dir_prol_at_entry; /* directive prologue status at entry */ + duk_reg_t temp_at_entry; + duk_uarridx_t labels_len_at_entry; + duk_int_t pc_at_entry; /* assumed to also be PC of "LABEL" */ + duk_int_t stmt_id; + duk_small_uint_t stmt_flags = 0; + duk_int_t label_id = -1; + duk_small_uint_t tok; + + DUK__RECURSION_INCREASE(comp_ctx, thr); + + temp_at_entry = DUK__GETTEMP(comp_ctx); + pc_at_entry = duk__get_current_pc(comp_ctx); + labels_len_at_entry = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.labelnames_idx); + stmt_id = comp_ctx->curr_func.stmt_next++; + dir_prol_at_entry = comp_ctx->curr_func.in_directive_prologue; + + DUK_UNREF(stmt_id); + + DUK_DDD(DUK_DDDPRINT("parsing a statement, stmt_id=%ld, temp_at_entry=%ld, labels_len_at_entry=%ld, " + "is_strict=%ld, in_directive_prologue=%ld, catch_depth=%ld", + (long) stmt_id, (long) temp_at_entry, (long) labels_len_at_entry, + (long) comp_ctx->curr_func.is_strict, (long) comp_ctx->curr_func.in_directive_prologue, + (long) comp_ctx->curr_func.catch_depth)); + + /* The directive prologue flag is cleared by default so that it is + * unset for any recursive statement parsing. It is only "revived" + * if a directive is detected. (We could also make directives only + * allowed if 'allow_source_elem' was true.) + */ + comp_ctx->curr_func.in_directive_prologue = 0; + + retry_parse: + + DUK_DDD(DUK_DDDPRINT("try stmt parse, stmt_id=%ld, label_id=%ld, allow_source_elem=%ld, catch_depth=%ld", + (long) stmt_id, (long) label_id, (long) allow_source_elem, + (long) comp_ctx->curr_func.catch_depth)); + + /* + * Detect iteration statements; if encountered, establish an + * empty label. + */ + + tok = comp_ctx->curr_token.t; + if (tok == DUK_TOK_FOR || tok == DUK_TOK_DO || tok == DUK_TOK_WHILE || + tok == DUK_TOK_SWITCH) { + DUK_DDD(DUK_DDDPRINT("iteration/switch statement -> add empty label")); + + label_id = duk__stmt_label_site(comp_ctx, label_id); + duk__add_label(comp_ctx, + DUK_HTHREAD_STRING_EMPTY_STRING(thr), + pc_at_entry /*pc_label*/, + label_id); + } + + /* + * Main switch for statement / source element type. + */ + + switch (comp_ctx->curr_token.t) { + case DUK_TOK_FUNCTION: { + /* + * Function declaration, function expression, or (non-standard) + * function statement. + * + * The E5 specification only allows function declarations at + * the top level (in "source elements"). An ExpressionStatement + * is explicitly not allowed to begin with a "function" keyword + * (E5 Section 12.4). Hence any non-error semantics for such + * non-top-level statements are non-standard. Duktape semantics + * for function statements are modelled after V8, see + * test-dev-func-decl-outside-top.js. + */ + +#if defined(DUK_USE_NONSTD_FUNC_STMT) + /* Lenient: allow function declarations outside top level in + * non-strict mode but reject them in strict mode. + */ + if (allow_source_elem || !comp_ctx->curr_func.is_strict) +#else /* DUK_USE_NONSTD_FUNC_STMT */ + /* Strict: never allow function declarations outside top level. */ + if (allow_source_elem) +#endif /* DUK_USE_NONSTD_FUNC_STMT */ + { + /* FunctionDeclaration: not strictly a statement but handled as such. + * + * O(depth^2) parse count for inner functions is handled by recording a + * lexer offset on the first compilation pass, so that the function can + * be efficiently skipped on the second pass. This is encapsulated into + * duk__parse_func_like_fnum(). + */ + + duk_int_t fnum; + + DUK_DDD(DUK_DDDPRINT("function declaration statement")); + + duk__advance(comp_ctx); /* eat 'function' */ + fnum = duk__parse_func_like_fnum(comp_ctx, 1 /*is_decl*/, 0 /*is_setget*/); + + if (comp_ctx->curr_func.in_scanning) { + duk_uarridx_t n; + duk_hstring *h_funcname; + + duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, fnum * 3); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME); /* -> [ ... func name ] */ + h_funcname = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_funcname != NULL); + + DUK_DDD(DUK_DDDPRINT("register function declaration %!O in pass 1, fnum %ld", + (duk_heaphdr *) h_funcname, (long) fnum)); + n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx); + duk_push_hstring(ctx, h_funcname); + duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n); + duk_push_int(ctx, (duk_int_t) (DUK_DECL_TYPE_FUNC + (fnum << 8))); + duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n + 1); + + duk_pop_n(ctx, 2); + } + + /* no statement value (unlike function expression) */ + stmt_flags = 0; + break; + } else { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_FUNC_STMT_NOT_ALLOWED); + } + break; + } + case DUK_TOK_LCURLY: { + DUK_DDD(DUK_DDDPRINT("block statement")); + duk__advance(comp_ctx); + duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/); + /* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */ + if (label_id >= 0) { + duk__patch_jump_here(comp_ctx, pc_at_entry + 1); /* break jump */ + } + stmt_flags = 0; + break; + } + case DUK_TOK_VAR: { + DUK_DDD(DUK_DDDPRINT("variable declaration statement")); + duk__parse_var_stmt(comp_ctx, res); + stmt_flags = DUK__HAS_TERM; + break; + } + case DUK_TOK_SEMICOLON: { + /* empty statement with an explicit semicolon */ + DUK_DDD(DUK_DDDPRINT("empty statement")); + stmt_flags = DUK__HAS_TERM; + break; + } + case DUK_TOK_IF: { + DUK_DDD(DUK_DDDPRINT("if statement")); + duk__parse_if_stmt(comp_ctx, res); + if (label_id >= 0) { + duk__patch_jump_here(comp_ctx, pc_at_entry + 1); /* break jump */ + } + stmt_flags = 0; + break; + } + case DUK_TOK_DO: { + /* + * Do-while statement is mostly trivial, but there is special + * handling for automatic semicolon handling (triggered by the + * DUK__ALLOW_AUTO_SEMI_ALWAYS) flag related to a bug filed at: + * + * https://bugs.ecmascript.org/show_bug.cgi?id=8 + * + * See doc/compiler.rst for details. + */ + DUK_DDD(DUK_DDDPRINT("do statement")); + DUK_ASSERT(label_id >= 0); + duk__update_label_flags(comp_ctx, + label_id, + DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE); + duk__parse_do_stmt(comp_ctx, res, pc_at_entry); + stmt_flags = DUK__HAS_TERM | DUK__ALLOW_AUTO_SEMI_ALWAYS; /* DUK__ALLOW_AUTO_SEMI_ALWAYS workaround */ + break; + } + case DUK_TOK_WHILE: { + DUK_DDD(DUK_DDDPRINT("while statement")); + DUK_ASSERT(label_id >= 0); + duk__update_label_flags(comp_ctx, + label_id, + DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE); + duk__parse_while_stmt(comp_ctx, res, pc_at_entry); + stmt_flags = 0; + break; + } + case DUK_TOK_FOR: { + /* + * For/for-in statement is complicated to parse because + * determining the statement type (three-part for vs. a + * for-in) requires potential backtracking. + * + * See the helper for the messy stuff. + */ + DUK_DDD(DUK_DDDPRINT("for/for-in statement")); + DUK_ASSERT(label_id >= 0); + duk__update_label_flags(comp_ctx, + label_id, + DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE); + duk__parse_for_stmt(comp_ctx, res, pc_at_entry); + stmt_flags = 0; + break; + } + case DUK_TOK_CONTINUE: + case DUK_TOK_BREAK: { + DUK_DDD(DUK_DDDPRINT("break/continue statement")); + duk__parse_break_or_continue_stmt(comp_ctx, res); + stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL; + break; + } + case DUK_TOK_RETURN: { + DUK_DDD(DUK_DDDPRINT("return statement")); + duk__parse_return_stmt(comp_ctx, res); + stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL; + break; + } + case DUK_TOK_WITH: { + DUK_DDD(DUK_DDDPRINT("with statement")); + comp_ctx->curr_func.with_depth++; + duk__parse_with_stmt(comp_ctx, res); + if (label_id >= 0) { + duk__patch_jump_here(comp_ctx, pc_at_entry + 1); /* break jump */ + } + comp_ctx->curr_func.with_depth--; + stmt_flags = 0; + break; + } + case DUK_TOK_SWITCH: { + /* + * The switch statement is pretty messy to compile. + * See the helper for details. + */ + DUK_DDD(DUK_DDDPRINT("switch statement")); + DUK_ASSERT(label_id >= 0); + duk__update_label_flags(comp_ctx, + label_id, + DUK_LABEL_FLAG_ALLOW_BREAK); /* don't allow continue */ + duk__parse_switch_stmt(comp_ctx, res, pc_at_entry); + stmt_flags = 0; + break; + } + case DUK_TOK_THROW: { + DUK_DDD(DUK_DDDPRINT("throw statement")); + duk__parse_throw_stmt(comp_ctx, res); + stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL; + break; + } + case DUK_TOK_TRY: { + DUK_DDD(DUK_DDDPRINT("try statement")); + duk__parse_try_stmt(comp_ctx, res); + stmt_flags = 0; + break; + } + case DUK_TOK_DEBUGGER: { +#if defined(DUK_USE_DEBUGGER_SUPPORT) + DUK_DDD(DUK_DDDPRINT("debugger statement: debugging enabled, emit debugger opcode")); + duk__emit_extraop_only(comp_ctx, DUK_EXTRAOP_DEBUGGER); +#else + DUK_DDD(DUK_DDDPRINT("debugger statement: ignored")); +#endif + duk__advance(comp_ctx); + stmt_flags = DUK__HAS_TERM; + break; + } + default: { + /* + * Else, must be one of: + * - ExpressionStatement, possibly a directive (String) + * - LabelledStatement (Identifier followed by ':') + * + * Expressions beginning with 'function' keyword are covered by a case + * above (such expressions are not allowed in standard E5 anyway). + * Also expressions starting with '{' are interpreted as block + * statements. See E5 Section 12.4. + * + * Directive detection is tricky; see E5 Section 14.1 on directive + * prologue. A directive is an expression statement with a single + * string literal and an explicit or automatic semicolon. Escape + * characters are significant and no parens etc are allowed: + * + * 'use strict'; // valid 'use strict' directive + * 'use\u0020strict'; // valid directive, not a 'use strict' directive + * ('use strict'); // not a valid directive + * + * The expression is determined to consist of a single string literal + * based on duk__expr_nud() and duk__expr_led() call counts. The string literal + * of a 'use strict' directive is determined to lack any escapes based + * num_escapes count from the lexer. Note that other directives may be + * allowed to contain escapes, so a directive with escapes does not + * terminate a directive prologue. + * + * We rely on the fact that the expression parser will not emit any + * code for a single token expression. However, it will generate an + * intermediate value which we will then successfully ignore. + * + * A similar approach is used for labels. + */ + + duk_bool_t single_token; + + DUK_DDD(DUK_DDDPRINT("expression statement")); + duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); + + single_token = (comp_ctx->curr_func.nud_count == 1 && /* one token */ + comp_ctx->curr_func.led_count == 0); /* no operators */ + + if (single_token && + comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER && + comp_ctx->curr_token.t == DUK_TOK_COLON) { + /* + * Detected label + */ + + duk_hstring *h_lab; + + /* expected ival */ + DUK_ASSERT(res->t == DUK_IVAL_VAR); + DUK_ASSERT(res->x1.t == DUK_ISPEC_VALUE); + DUK_ASSERT(DUK_TVAL_IS_STRING(duk_get_tval(ctx, res->x1.valstack_idx))); + h_lab = comp_ctx->prev_token.str1; + DUK_ASSERT(h_lab != NULL); + + DUK_DDD(DUK_DDDPRINT("explicit label site for label '%!O'", + (duk_heaphdr *) h_lab)); + + duk__advance(comp_ctx); /* eat colon */ + + label_id = duk__stmt_label_site(comp_ctx, label_id); + + duk__add_label(comp_ctx, + h_lab, + pc_at_entry /*pc_label*/, + label_id); + + /* a statement following a label cannot be a source element + * (a function declaration). + */ + allow_source_elem = 0; + + DUK_DDD(DUK_DDDPRINT("label handled, retry statement parsing")); + goto retry_parse; + } + + stmt_flags = 0; + + if (dir_prol_at_entry && /* still in prologue */ + single_token && /* single string token */ + comp_ctx->prev_token.t == DUK_TOK_STRING) { + /* + * Detected a directive + */ + duk_hstring *h_dir; + + /* expected ival */ + DUK_ASSERT(res->t == DUK_IVAL_PLAIN); + DUK_ASSERT(res->x1.t == DUK_ISPEC_VALUE); + DUK_ASSERT(DUK_TVAL_IS_STRING(duk_get_tval(ctx, res->x1.valstack_idx))); + h_dir = comp_ctx->prev_token.str1; + DUK_ASSERT(h_dir != NULL); + + DUK_DDD(DUK_DDDPRINT("potential directive: %!O", h_dir)); + + stmt_flags |= DUK__STILL_PROLOGUE; + + /* Note: escaped characters differentiate directives */ + + if (comp_ctx->prev_token.num_escapes > 0) { + DUK_DDD(DUK_DDDPRINT("directive contains escapes: valid directive " + "but we ignore such directives")); + } else { + /* + * The length comparisons are present to handle + * strings like "use strict\u0000foo" as required. + */ + + if (DUK_HSTRING_GET_BYTELEN(h_dir) == 10 && + DUK_STRNCMP((const char *) DUK_HSTRING_GET_DATA(h_dir), "use strict", 10) == 0) { +#if defined(DUK_USE_STRICT_DECL) + DUK_DDD(DUK_DDDPRINT("use strict directive detected: strict flag %ld -> %ld", + (long) comp_ctx->curr_func.is_strict, (long) 1)); + comp_ctx->curr_func.is_strict = 1; +#else + DUK_DDD(DUK_DDDPRINT("use strict detected but strict declarations disabled, ignoring")); +#endif + } else if (DUK_HSTRING_GET_BYTELEN(h_dir) == 14 && + DUK_STRNCMP((const char *) DUK_HSTRING_GET_DATA(h_dir), "use duk notail", 14) == 0) { + DUK_DDD(DUK_DDDPRINT("use duk notail directive detected: notail flag %ld -> %ld", + (long) comp_ctx->curr_func.is_notail, (long) 1)); + comp_ctx->curr_func.is_notail = 1; + } else { + DUK_DD(DUK_DDPRINT("unknown directive: '%!O', ignoring but not terminating " + "directive prologue", (duk_hobject *) h_dir)); + } + } + } else { + DUK_DDD(DUK_DDDPRINT("non-directive expression statement or no longer in prologue; " + "prologue terminated if still active")); + } + + stmt_flags |= DUK__HAS_VAL | DUK__HAS_TERM; + } + } /* end switch (tok) */ + + /* + * Statement value handling. + * + * Global code and eval code has an implicit return value + * which comes from the last statement with a value + * (technically a non-"empty" continuation, which is + * different from an empty statement). + * + * Since we don't know whether a later statement will + * override the value of the current statement, we need + * to coerce the statement value to a register allocated + * for implicit return values. In other cases we need + * to coerce the statement value to a plain value to get + * any side effects out (consider e.g. "foo.bar;"). + */ + + /* XXX: what about statements which leave a half-cooked value in 'res' + * but have no stmt value? Any such statements? + */ + + if (stmt_flags & DUK__HAS_VAL) { + duk_reg_t reg_stmt_value = comp_ctx->curr_func.reg_stmt_value; + if (reg_stmt_value >= 0) { + duk__ivalue_toforcedreg(comp_ctx, res, reg_stmt_value); + } else { + duk__ivalue_toplain_ignore(comp_ctx, res); + } + } else { + ; + } + + /* + * Statement terminator check, including automatic semicolon + * handling. After this step, 'curr_tok' should be the first + * token after a possible statement terminator. + */ + + if (stmt_flags & DUK__HAS_TERM) { + if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON) { + DUK_DDD(DUK_DDDPRINT("explicit semicolon terminates statement")); + duk__advance(comp_ctx); + } else { + if (comp_ctx->curr_token.allow_auto_semi) { + DUK_DDD(DUK_DDDPRINT("automatic semicolon terminates statement")); + } else if (stmt_flags & DUK__ALLOW_AUTO_SEMI_ALWAYS) { + /* XXX: make this lenience dependent on flags or strictness? */ + DUK_DDD(DUK_DDDPRINT("automatic semicolon terminates statement (allowed for compatibility " + "even though no lineterm present before next token)")); + } else { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_UNTERMINATED_STMT); + } + } + } else { + DUK_DDD(DUK_DDDPRINT("statement has no terminator")); + } + + /* + * Directive prologue tracking. + */ + + if (stmt_flags & DUK__STILL_PROLOGUE) { + DUK_DDD(DUK_DDDPRINT("setting in_directive_prologue")); + comp_ctx->curr_func.in_directive_prologue = 1; + } + + /* + * Cleanups (all statement parsing flows through here). + * + * Pop label site and reset labels. Reset 'next temp' to value at + * entry to reuse temps. + */ + + if (label_id >= 0) { + duk__emit_extraop_bc(comp_ctx, + DUK_EXTRAOP_ENDLABEL, + (duk_regconst_t) label_id); + } + + DUK__SETTEMP(comp_ctx, temp_at_entry); + + duk__reset_labels_to_length(comp_ctx, labels_len_at_entry); + + /* XXX: return indication of "terminalness" (e.g. a 'throw' is terminal) */ + + DUK__RECURSION_DECREASE(comp_ctx, thr); +} + +#undef DUK__HAS_VAL +#undef DUK__HAS_TERM +#undef DUK__ALLOW_AUTO_SEMI_ALWAYS + +/* + * Parse a statement list. + * + * Handles automatic semicolon insertion and implicit return value. + * + * Upon entry, 'curr_tok' should contain the first token of the first + * statement (parsed in the "allow regexp literal" mode). Upon exit, + * 'curr_tok' contains the token following the statement list terminator + * (EOF or closing brace). + */ + +DUK_LOCAL void duk__parse_stmts(duk_compiler_ctx *comp_ctx, duk_bool_t allow_source_elem, duk_bool_t expect_eof) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_ivalue res_alloc; + duk_ivalue *res = &res_alloc; + + /* Setup state. Initial ivalue is 'undefined'. */ + + duk_require_stack(ctx, DUK__PARSE_STATEMENTS_SLOTS); + + /* XXX: 'res' setup can be moved to function body level; in fact, two 'res' + * intermediate values suffice for parsing of each function. Nesting is needed + * for nested functions (which may occur inside expressions). + */ + + DUK_MEMZERO(&res_alloc, sizeof(res_alloc)); + res->t = DUK_IVAL_PLAIN; + res->x1.t = DUK_ISPEC_VALUE; + res->x1.valstack_idx = duk_get_top(ctx); + res->x2.valstack_idx = res->x1.valstack_idx + 1; + duk_push_undefined(ctx); + duk_push_undefined(ctx); + + /* Parse statements until a closing token (EOF or '}') is found. */ + + for (;;) { + /* Check whether statement list ends. */ + + if (expect_eof) { + if (comp_ctx->curr_token.t == DUK_TOK_EOF) { + break; + } + } else { + if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) { + break; + } + } + + /* Check statement type based on the first token type. + * + * Note: expression parsing helpers expect 'curr_tok' to + * contain the first token of the expression upon entry. + */ + + DUK_DDD(DUK_DDDPRINT("TOKEN %ld (non-whitespace, non-comment)", (long) comp_ctx->curr_token.t)); + + duk__parse_stmt(comp_ctx, res, allow_source_elem); + } + + duk__advance(comp_ctx); + + /* Tear down state. */ + + duk_pop_2(ctx); +} + +/* + * Declaration binding instantiation conceptually happens when calling a + * function; for us it essentially means that function prologue. The + * conceptual process is described in E5 Section 10.5. + * + * We need to keep track of all encountered identifiers to (1) create an + * identifier-to-register map ("varmap"); and (2) detect duplicate + * declarations. Identifiers which are not bound to registers still need + * to be tracked for detecting duplicates. Currently such identifiers + * are put into the varmap with a 'null' value, which is later cleaned up. + * + * To support functions with a large number of variable and function + * declarations, registers are not allocated beyond a certain limit; + * after that limit, variables and functions need slow path access. + * Arguments are currently always register bound, which imposes a hard + * (and relatively small) argument count limit. + * + * Some bindings in E5 are not configurable (= deletable) and almost all + * are mutable (writable). Exceptions are: + * + * - The 'arguments' binding, established only if no shadowing argument + * or function declaration exists. We handle 'arguments' creation + * and binding through an explicit slow path environment record. + * + * - The "name" binding for a named function expression. This is also + * handled through an explicit slow path environment record. + */ + +/* XXX: add support for variables to not be register bound always, to + * handle cases with a very large number of variables? + */ + +DUK_LOCAL void duk__init_varmap_and_prologue_for_pass2(duk_compiler_ctx *comp_ctx, duk_reg_t *out_stmt_value_reg) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_hstring *h_name; + duk_bool_t configurable_bindings; + duk_uarridx_t num_args; + duk_uarridx_t num_decls; + duk_regconst_t rc_name; + duk_small_uint_t declvar_flags; + duk_uarridx_t i; +#ifdef DUK_USE_ASSERTIONS + duk_idx_t entry_top; +#endif + +#ifdef DUK_USE_ASSERTIONS + entry_top = duk_get_top(ctx); +#endif + + /* + * Preliminaries + */ + + configurable_bindings = comp_ctx->curr_func.is_eval; + DUK_DDD(DUK_DDDPRINT("configurable_bindings=%ld", (long) configurable_bindings)); + + /* varmap is already in comp_ctx->curr_func.varmap_idx */ + + /* + * Function formal arguments, always bound to registers + * (there's no support for shuffling them now). + */ + + num_args = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.argnames_idx); + DUK_DDD(DUK_DDDPRINT("num_args=%ld", (long) num_args)); + /* XXX: check num_args */ + + for (i = 0; i < num_args; i++) { + duk_get_prop_index(ctx, comp_ctx->curr_func.argnames_idx, i); + h_name = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_name != NULL); + + if (comp_ctx->curr_func.is_strict) { + if (duk__hstring_is_eval_or_arguments(comp_ctx, h_name)) { + DUK_DDD(DUK_DDDPRINT("arg named 'eval' or 'arguments' in strict mode -> SyntaxError")); + goto error_argname; + } + duk_dup_top(ctx); + if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) { + DUK_DDD(DUK_DDDPRINT("duplicate arg name in strict mode -> SyntaxError")); + goto error_argname; + } + + /* Ensure argument name is not a reserved word in current + * (final) strictness. Formal argument parsing may not + * catch reserved names if strictness changes during + * parsing. + * + * We only need to do this in strict mode because non-strict + * keyword are always detected in formal argument parsing. + */ + + if (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(h_name)) { + goto error_argname; + } + } + + /* overwrite any previous binding of the same name; the effect is + * that last argument of a certain name wins. + */ + + /* only functions can have arguments */ + DUK_ASSERT(comp_ctx->curr_func.is_function); + duk_push_uarridx(ctx, i); /* -> [ ... name index ] */ + duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx); /* -> [ ... ] */ + + /* no code needs to be emitted, the regs already have values */ + } + + /* use temp_next for tracking register allocations */ + DUK__SETTEMP_CHECKMAX(comp_ctx, (duk_reg_t) num_args); + + /* + * After arguments, allocate special registers (like shuffling temps) + */ + + if (out_stmt_value_reg) { + *out_stmt_value_reg = DUK__ALLOCTEMP(comp_ctx); + } + if (comp_ctx->curr_func.needs_shuffle) { + duk_reg_t shuffle_base = DUK__ALLOCTEMPS(comp_ctx, 3); + comp_ctx->curr_func.shuffle1 = shuffle_base; + comp_ctx->curr_func.shuffle2 = shuffle_base + 1; + comp_ctx->curr_func.shuffle3 = shuffle_base + 2; + DUK_D(DUK_DPRINT("shuffle registers needed by function, allocated: %ld %ld %ld", + (long) comp_ctx->curr_func.shuffle1, + (long) comp_ctx->curr_func.shuffle2, + (long) comp_ctx->curr_func.shuffle3)); + } + if (comp_ctx->curr_func.temp_next > 0x100) { + DUK_D(DUK_DPRINT("not enough 8-bit regs: temp_next=%ld", (long) comp_ctx->curr_func.temp_next)); + goto error_outofregs; + } + + /* + * Function declarations + */ + + num_decls = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx); + DUK_DDD(DUK_DDDPRINT("num_decls=%ld -> %!T", + (long) num_decls, + (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.decls_idx))); + for (i = 0; i < num_decls; i += 2) { + duk_int_t decl_type; + duk_int_t fnum; + + duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i + 1); /* decl type */ + decl_type = duk_to_int(ctx, -1); + fnum = decl_type >> 8; /* XXX: macros */ + decl_type = decl_type & 0xff; + duk_pop(ctx); + + if (decl_type != DUK_DECL_TYPE_FUNC) { + continue; + } + + duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i); /* decl name */ + + /* XXX: spilling */ + if (comp_ctx->curr_func.is_function) { + duk_reg_t reg_bind; + duk_dup_top(ctx); + if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) { + /* shadowed; update value */ + duk_dup_top(ctx); + duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx); + reg_bind = duk_to_int(ctx, -1); /* [ ... name reg_bind ] */ + duk__emit_a_bc(comp_ctx, + DUK_OP_CLOSURE, + (duk_regconst_t) reg_bind, + (duk_regconst_t) fnum); + } else { + /* function: always register bound */ + reg_bind = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_bc(comp_ctx, + DUK_OP_CLOSURE, + (duk_regconst_t) reg_bind, + (duk_regconst_t) fnum); + duk_push_int(ctx, (duk_int_t) reg_bind); + } + } else { + /* Function declaration for global/eval code is emitted even + * for duplicates, because of E5 Section 10.5, step 5.e of + * E5.1 (special behavior for variable bound to global object). + * + * DECLVAR will not re-declare a variable as such, but will + * update the binding value. + */ + + duk_reg_t reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk_dup_top(ctx); + rc_name = duk__getconst(comp_ctx); + duk_push_null(ctx); + + duk__emit_a_bc(comp_ctx, + DUK_OP_CLOSURE, + (duk_regconst_t) reg_temp, + (duk_regconst_t) fnum); + + declvar_flags = DUK_PROPDESC_FLAG_WRITABLE | + DUK_PROPDESC_FLAG_ENUMERABLE | + DUK_BC_DECLVAR_FLAG_FUNC_DECL; + + if (configurable_bindings) { + declvar_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE; + } + + duk__emit_a_b_c(comp_ctx, + DUK_OP_DECLVAR | DUK__EMIT_FLAG_NO_SHUFFLE_A, + (duk_regconst_t) declvar_flags /*flags*/, + rc_name /*name*/, + (duk_regconst_t) reg_temp /*value*/); + + DUK__SETTEMP(comp_ctx, reg_temp); /* forget temp */ + } + + DUK_DDD(DUK_DDDPRINT("function declaration to varmap: %!T -> %!T", + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + + duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx); /* [ ... name reg/null ] -> [ ... ] */ + } + + /* + * 'arguments' binding is special; if a shadowing argument or + * function declaration exists, an arguments object will + * definitely not be needed, regardless of whether the identifier + * 'arguments' is referenced inside the function body. + */ + + if (duk_has_prop_stridx(ctx, comp_ctx->curr_func.varmap_idx, DUK_STRIDX_LC_ARGUMENTS)) { + DUK_DDD(DUK_DDDPRINT("'arguments' is shadowed by argument or function declaration " + "-> arguments object creation can be skipped")); + comp_ctx->curr_func.is_arguments_shadowed = 1; + } + + /* + * Variable declarations. + * + * Unlike function declarations, variable declaration values don't get + * assigned on entry. If a binding of the same name already exists, just + * ignore it silently. + */ + + for (i = 0; i < num_decls; i += 2) { + duk_int_t decl_type; + + duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i + 1); /* decl type */ + decl_type = duk_to_int(ctx, -1); + decl_type = decl_type & 0xff; + duk_pop(ctx); + + if (decl_type != DUK_DECL_TYPE_VAR) { + continue; + } + + duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i); /* decl name */ + + if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) { + /* shadowed, ignore */ + } else { + duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i); /* decl name */ + h_name = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_name != NULL); + + if (h_name == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr) && + !comp_ctx->curr_func.is_arguments_shadowed) { + /* E5 Section steps 7-8 */ + DUK_DDD(DUK_DDDPRINT("'arguments' not shadowed by a function declaration, " + "but appears as a variable declaration -> treat as " + "a no-op for variable declaration purposes")); + duk_pop(ctx); + continue; + } + + /* XXX: spilling */ + if (comp_ctx->curr_func.is_function) { + duk_reg_t reg_bind = DUK__ALLOCTEMP(comp_ctx); + /* no need to init reg, it will be undefined on entry */ + duk_push_int(ctx, (duk_int_t) reg_bind); + } else { + duk_dup_top(ctx); + rc_name = duk__getconst(comp_ctx); + duk_push_null(ctx); + + declvar_flags = DUK_PROPDESC_FLAG_WRITABLE | + DUK_PROPDESC_FLAG_ENUMERABLE | + DUK_BC_DECLVAR_FLAG_UNDEF_VALUE; + if (configurable_bindings) { + declvar_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE; + } + + duk__emit_a_b_c(comp_ctx, + DUK_OP_DECLVAR | DUK__EMIT_FLAG_NO_SHUFFLE_A, + (duk_regconst_t) declvar_flags /*flags*/, + rc_name /*name*/, + (duk_regconst_t) 0 /*value*/); + } + + duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx); /* [ ... name reg/null ] -> [ ... ] */ + } + } + + /* + * Wrap up + */ + + DUK_DDD(DUK_DDDPRINT("varmap: %!T, is_arguments_shadowed=%ld", + (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx), + (long) comp_ctx->curr_func.is_arguments_shadowed)); + + DUK_ASSERT_TOP(ctx, entry_top); + return; + + error_outofregs: + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_REG_LIMIT); + DUK_UNREACHABLE(); + return; + + error_argname: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_ARG_NAME); + DUK_UNREACHABLE(); + return; +} + +/* + * Parse a function-body-like expression (FunctionBody or Program + * in E5 grammar) using a two-pass parse. The productions appear + * in the following contexts: + * + * - function expression + * - function statement + * - function declaration + * - getter in object literal + * - setter in object literal + * - global code + * - eval code + * - Function constructor body + * + * This function only parses the statement list of the body; the argument + * list and possible function name must be initialized by the caller. + * For instance, for Function constructor, the argument names are originally + * on the value stack. The parsing of statements ends either at an EOF or + * a closing brace; this is controlled by an input flag. + * + * Note that there are many differences affecting parsing and even code + * generation: + * + * - Global and eval code have an implicit return value generated + * by the last statement; function code does not + * + * - Global code, eval code, and Function constructor body end in + * an EOF, other bodies in a closing brace ('}') + * + * Upon entry, 'curr_tok' is ignored and the function will pull in the + * first token on its own. Upon exit, 'curr_tok' is the terminating + * token (EOF or closing brace). + */ + +DUK_LOCAL void duk__parse_func_body(duk_compiler_ctx *comp_ctx, duk_bool_t expect_eof, duk_bool_t implicit_return_value, duk_small_int_t expect_token) { + duk_compiler_func *func; + duk_hthread *thr; + duk_context *ctx; + duk_reg_t reg_stmt_value = -1; + duk_lexer_point lex_pt; + duk_reg_t temp_first; + duk_small_int_t compile_round = 1; + + DUK_ASSERT(comp_ctx != NULL); + + thr = comp_ctx->thr; + ctx = (duk_context *) thr; + DUK_ASSERT(thr != NULL); + + func = &comp_ctx->curr_func; + DUK_ASSERT(func != NULL); + + DUK__RECURSION_INCREASE(comp_ctx, thr); + + duk_require_stack(ctx, DUK__FUNCTION_BODY_REQUIRE_SLOTS); + + /* + * Store lexer position for a later rewind + */ + + DUK_LEXER_GETPOINT(&comp_ctx->lex, &lex_pt); + + /* + * Program code (global and eval code) has an implicit return value + * from the last statement value (e.g. eval("1; 2+3;") returns 3). + * This is not the case with functions. If implicit statement return + * value is requested, all statements are coerced to a register + * allocated here, and used in the implicit return statement below. + */ + + /* XXX: this is pointless here because pass 1 is throw-away */ + if (implicit_return_value) { + reg_stmt_value = DUK__ALLOCTEMP(comp_ctx); + + /* If an implicit return value is needed by caller, it must be + * initialized to 'undefined' because we don't know whether any + * non-empty (where "empty" is a continuation type, and different + * from an empty statement) statements will be executed. + * + * However, since 1st pass is a throwaway one, no need to emit + * it here. + */ +#if 0 + duk__emit_extraop_bc(comp_ctx, + DUK_EXTRAOP_LDUNDEF, + 0); +#endif + } + + /* + * First pass. + * + * Gather variable/function declarations needed for second pass. + * Code generated is dummy and discarded. + */ + + func->in_directive_prologue = 1; + func->in_scanning = 1; + func->may_direct_eval = 0; + func->id_access_arguments = 0; + func->id_access_slow = 0; + func->reg_stmt_value = reg_stmt_value; +#if defined(DUK_USE_DEBUGGER_SUPPORT) + func->min_line = DUK_INT_MAX; + func->max_line = 0; +#endif + + /* duk__parse_stmts() expects curr_tok to be set; parse in "allow regexp literal" mode with current strictness */ + if (expect_token >= 0) { + /* Eating a left curly; regexp mode is allowed by left curly + * based on duk__token_lbp[] automatically. + */ + DUK_ASSERT(expect_token == DUK_TOK_LCURLY); + duk__update_lineinfo_currtoken(comp_ctx); + duk__advance_expect(comp_ctx, expect_token); + } else { + /* Need to set curr_token.t because lexing regexp mode depends on current + * token type. Zero value causes "allow regexp" mode. + */ + comp_ctx->curr_token.t = 0; + duk__advance(comp_ctx); + } + + DUK_DDD(DUK_DDDPRINT("begin 1st pass")); + duk__parse_stmts(comp_ctx, + 1, /* allow source elements */ + expect_eof); /* expect EOF instead of } */ + DUK_DDD(DUK_DDDPRINT("end 1st pass")); + + /* + * Second (and possibly third) pass. + * + * Generate actual code. In most cases the need for shuffle + * registers is detected during pass 1, but in some corner cases + * we'll only detect it during pass 2 and a third pass is then + * needed (see GH-115). + */ + + for (;;) { + duk_bool_t needs_shuffle_before = comp_ctx->curr_func.needs_shuffle; + compile_round++; + + /* + * Rewind lexer. + * + * duk__parse_stmts() expects curr_tok to be set; parse in "allow regexp + * literal" mode with current strictness. + * + * curr_token line number info should be initialized for pass 2 before + * generating prologue, to ensure prologue bytecode gets nice line numbers. + */ + + DUK_DDD(DUK_DDDPRINT("rewind lexer")); + DUK_LEXER_SETPOINT(&comp_ctx->lex, &lex_pt); + comp_ctx->curr_token.t = 0; /* this is needed for regexp mode */ + comp_ctx->curr_token.start_line = 0; /* needed for line number tracking (becomes prev_token.start_line) */ + duk__advance(comp_ctx); + + /* + * Reset function state and perform register allocation, which creates + * 'varmap' for second pass. Function prologue for variable declarations, + * binding value initializations etc is emitted as a by-product. + * + * Strict mode restrictions for duplicate and invalid argument + * names are checked here now that we know whether the function + * is actually strict. See: test-dev-strict-mode-boundary.js. + * + * Inner functions are compiled during pass 1 and are not reset. + */ + + duk__reset_func_for_pass2(comp_ctx); + func->in_directive_prologue = 1; + func->in_scanning = 0; + + /* must be able to emit code, alloc consts, etc. */ + + duk__init_varmap_and_prologue_for_pass2(comp_ctx, + (implicit_return_value ? ®_stmt_value : NULL)); + func->reg_stmt_value = reg_stmt_value; + + temp_first = DUK__GETTEMP(comp_ctx); + + func->temp_first = temp_first; + func->temp_next = temp_first; + func->stmt_next = 0; + func->label_next = 0; + + /* XXX: init or assert catch depth etc -- all values */ + func->id_access_arguments = 0; + func->id_access_slow = 0; + + /* + * Check function name validity now that we know strictness. + * This only applies to function declarations and expressions, + * not setter/getter name. + * + * See: test-dev-strict-mode-boundary.js + */ + + if (func->is_function && !func->is_setget && func->h_name != NULL) { + if (func->is_strict) { + if (duk__hstring_is_eval_or_arguments(comp_ctx, func->h_name)) { + DUK_DDD(DUK_DDDPRINT("func name is 'eval' or 'arguments' in strict mode")); + goto error_funcname; + } + if (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(func->h_name)) { + DUK_DDD(DUK_DDDPRINT("func name is a reserved word in strict mode")); + goto error_funcname; + } + } else { + if (DUK_HSTRING_HAS_RESERVED_WORD(func->h_name) && + !DUK_HSTRING_HAS_STRICT_RESERVED_WORD(func->h_name)) { + DUK_DDD(DUK_DDDPRINT("func name is a reserved word in non-strict mode")); + goto error_funcname; + } + } + } + + /* + * Second pass parsing. + */ + + if (implicit_return_value) { + /* Default implicit return value. */ + duk__emit_extraop_bc(comp_ctx, + DUK_EXTRAOP_LDUNDEF, + 0); + } + + DUK_DDD(DUK_DDDPRINT("begin 2nd pass")); + duk__parse_stmts(comp_ctx, + 1, /* allow source elements */ + expect_eof); /* expect EOF instead of } */ + DUK_DDD(DUK_DDDPRINT("end 2nd pass")); + + duk__update_lineinfo_currtoken(comp_ctx); + + if (needs_shuffle_before == comp_ctx->curr_func.needs_shuffle) { + /* Shuffle decision not changed. */ + break; + } + if (compile_round >= 3) { + /* Should never happen but avoid infinite loop just in case. */ + DUK_D(DUK_DPRINT("more than 3 compile passes needed, should never happen")); + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR); + } + DUK_D(DUK_DPRINT("need additional round to compile function, round now %d", (int) compile_round)); + } + + /* + * Emit a final RETURN. + * + * It would be nice to avoid emitting an unnecessary "return" opcode + * if the current PC is not reachable. However, this cannot be reliably + * detected; even if the previous instruction is an unconditional jump, + * there may be a previous jump which jumps to current PC (which is the + * case for iteration and conditional statements, for instance). + */ + + /* XXX: request a "last statement is terminal" from duk__parse_stmt() and duk__parse_stmts(); + * we could avoid the last RETURN if we could ensure there is no way to get here + * (directly or via a jump) + */ + + DUK_ASSERT(comp_ctx->curr_func.catch_depth == 0); /* fast returns are always OK here */ + if (reg_stmt_value >= 0) { + duk__emit_a_b(comp_ctx, + DUK_OP_RETURN | DUK__EMIT_FLAG_NO_SHUFFLE_A, + (duk_regconst_t) (DUK_BC_RETURN_FLAG_HAVE_RETVAL | DUK_BC_RETURN_FLAG_FAST) /*flags*/, + (duk_regconst_t) reg_stmt_value /*reg*/); + } else { + duk__emit_a_b(comp_ctx, + DUK_OP_RETURN | DUK__EMIT_FLAG_NO_SHUFFLE_A, + (duk_regconst_t) DUK_BC_RETURN_FLAG_FAST /*flags*/, + (duk_regconst_t) 0 /*reg(ignored)*/); + } + + /* + * Peephole optimize JUMP chains. + */ + + duk__peephole_optimize_bytecode(comp_ctx); + + /* + * comp_ctx->curr_func is now ready to be converted into an actual + * function template. + */ + + DUK__RECURSION_DECREASE(comp_ctx, thr); + return; + + error_funcname: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_FUNC_NAME); +} + +/* + * Parse a function-like expression: + * + * - function expression + * - function declaration + * - function statement (non-standard) + * - setter/getter + * + * Adds the function to comp_ctx->curr_func function table and returns the + * function number. + * + * On entry, curr_token points to: + * + * - the token after 'function' for function expression/declaration/statement + * - the token after 'set' or 'get' for setter/getter + */ + +/* Parse formals. */ +DUK_LOCAL void duk__parse_func_formals(duk_compiler_ctx *comp_ctx) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_bool_t first = 1; + duk_uarridx_t n; + + for (;;) { + if (comp_ctx->curr_token.t == DUK_TOK_RPAREN) { + break; + } + + if (first) { + /* no comma */ + first = 0; + } else { + duk__advance_expect(comp_ctx, DUK_TOK_COMMA); + } + + /* Note: when parsing a formal list in non-strict context, e.g. + * "implements" is parsed as an identifier. When the function is + * later detected to be strict, the argument list must be rechecked + * against a larger set of reserved words (that of strict mode). + * This is handled by duk__parse_func_body(). Here we recognize + * whatever tokens are considered reserved in current strictness + * (which is not always enough). + */ + + if (comp_ctx->curr_token.t != DUK_TOK_IDENTIFIER) { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, "expected identifier"); + } + DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_IDENTIFIER); + DUK_ASSERT(comp_ctx->curr_token.str1 != NULL); + DUK_DDD(DUK_DDDPRINT("formal argument: %!O", + (duk_heaphdr *) comp_ctx->curr_token.str1)); + + /* XXX: append primitive */ + duk_push_hstring(ctx, comp_ctx->curr_token.str1); + n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.argnames_idx); + duk_put_prop_index(ctx, comp_ctx->curr_func.argnames_idx, n); + + duk__advance(comp_ctx); /* eat identifier */ + } +} + +/* Parse a function-like expression, assuming that 'comp_ctx->curr_func' is + * correctly set up. Assumes that curr_token is just after 'function' (or + * 'set'/'get' etc). + */ +DUK_LOCAL void duk__parse_func_like_raw(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + + DUK_ASSERT(comp_ctx->curr_func.num_formals == 0); + DUK_ASSERT(comp_ctx->curr_func.is_function == 1); + DUK_ASSERT(comp_ctx->curr_func.is_eval == 0); + DUK_ASSERT(comp_ctx->curr_func.is_global == 0); + DUK_ASSERT(comp_ctx->curr_func.is_setget == is_setget); + DUK_ASSERT(comp_ctx->curr_func.is_decl == is_decl); + + duk__update_lineinfo_currtoken(comp_ctx); + + /* + * Function name (if any) + * + * We don't check for prohibited names here, because we don't + * yet know whether the function will be strict. Function body + * parsing handles this retroactively. + * + * For function expressions and declarations function name must + * be an Identifer (excludes reserved words). For setter/getter + * it is a PropertyName which allows reserved words and also + * strings and numbers (e.g. "{ get 1() { ... } }"). + */ + + if (is_setget) { + /* PropertyName -> IdentifierName | StringLiteral | NumericLiteral */ + if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER || + comp_ctx->curr_token.t == DUK_TOK_STRING) { + duk_push_hstring(ctx, comp_ctx->curr_token.str1); /* keep in valstack */ + } else if (comp_ctx->curr_token.t == DUK_TOK_NUMBER) { + duk_push_number(ctx, comp_ctx->curr_token.num); + duk_to_string(ctx, -1); + } else { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_GETSET_NAME); + } + comp_ctx->curr_func.h_name = duk_get_hstring(ctx, -1); /* borrowed reference */ + DUK_ASSERT(comp_ctx->curr_func.h_name != NULL); + duk__advance(comp_ctx); + } else { + /* Function name is an Identifier (not IdentifierName), but we get + * the raw name (not recognizing keywords) here and perform the name + * checks only after pass 1. + */ + if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER) { + duk_push_hstring(ctx, comp_ctx->curr_token.str1); /* keep in valstack */ + comp_ctx->curr_func.h_name = duk_get_hstring(ctx, -1); /* borrowed reference */ + DUK_ASSERT(comp_ctx->curr_func.h_name != NULL); + duk__advance(comp_ctx); + } else { + /* valstack will be unbalanced, which is OK */ + DUK_ASSERT(!is_setget); + if (is_decl) { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_FUNC_NAME_REQUIRED); + } + } + } + + DUK_DDD(DUK_DDDPRINT("function name: %!O", + (duk_heaphdr *) comp_ctx->curr_func.h_name)); + + /* + * Formal argument list + * + * We don't check for prohibited names or for duplicate argument + * names here, becase we don't yet know whether the function will + * be strict. Function body parsing handles this retroactively. + */ + + duk__advance_expect(comp_ctx, DUK_TOK_LPAREN); + + duk__parse_func_formals(comp_ctx); + + DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RPAREN); + duk__advance(comp_ctx); + + /* + * Parse function body + */ + + duk__parse_func_body(comp_ctx, + 0, /* expect_eof */ + 0, /* implicit_return_value */ + DUK_TOK_LCURLY); /* expect_token */ + + /* + * Convert duk_compiler_func to a function template and add it + * to the parent function table. + */ + + duk__convert_to_func_template(comp_ctx, is_setget /*force_no_namebind*/); /* -> [ ... func ] */ +} + +/* Parse an inner function, adding the function template to the current function's + * function table. Return a function number to be used by the outer function. + * + * Avoiding O(depth^2) inner function parsing is handled here. On the first pass, + * compile and register the function normally into the 'funcs' array, also recording + * a lexer point (offset/line) to the closing brace of the function. On the second + * pass, skip the function and return the same 'fnum' as on the first pass by using + * a running counter. + * + * An unfortunate side effect of this is that when parsing the inner function, almost + * nothing is known of the outer function, i.e. the inner function's scope. We don't + * need that information at the moment, but it would allow some optimizations if it + * were used. + */ +DUK_LOCAL duk_int_t duk__parse_func_like_fnum(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget) { + duk_hthread *thr = comp_ctx->thr; + duk_context *ctx = (duk_context *) thr; + duk_compiler_func old_func; + duk_idx_t entry_top; + duk_int_t fnum; + + /* + * On second pass, skip the function. + */ + + if (!comp_ctx->curr_func.in_scanning) { + duk_lexer_point lex_pt; + + fnum = comp_ctx->curr_func.fnum_next++; + duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 1)); + lex_pt.offset = duk_to_int(ctx, -1); + duk_pop(ctx); + duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 2)); + lex_pt.line = duk_to_int(ctx, -1); + duk_pop(ctx); + + DUK_DDD(DUK_DDDPRINT("second pass of an inner func, skip the function, reparse closing brace; lex offset=%ld, line=%ld", + (long) lex_pt.offset, (long) lex_pt.line)); + + DUK_LEXER_SETPOINT(&comp_ctx->lex, &lex_pt); + comp_ctx->curr_token.t = 0; /* this is needed for regexp mode */ + comp_ctx->curr_token.start_line = 0; /* needed for line number tracking (becomes prev_token.start_line) */ + duk__advance(comp_ctx); + duk__advance_expect(comp_ctx, DUK_TOK_RCURLY); + + return fnum; + } + + /* + * On first pass, perform actual parsing. Remember valstack top on entry + * to restore it later, and switch to using a new function in comp_ctx. + */ + + entry_top = duk_get_top(ctx); + DUK_DDD(DUK_DDDPRINT("before func: entry_top=%ld, curr_tok.start_offset=%ld", + (long) entry_top, (long) comp_ctx->curr_token.start_offset)); + + DUK_MEMCPY(&old_func, &comp_ctx->curr_func, sizeof(duk_compiler_func)); + + DUK_MEMZERO(&comp_ctx->curr_func, sizeof(duk_compiler_func)); + duk__init_func_valstack_slots(comp_ctx); + DUK_ASSERT(comp_ctx->curr_func.num_formals == 0); + + /* inherit initial strictness from parent */ + comp_ctx->curr_func.is_strict = old_func.is_strict; + + DUK_ASSERT(comp_ctx->curr_func.is_notail == 0); + comp_ctx->curr_func.is_function = 1; + DUK_ASSERT(comp_ctx->curr_func.is_eval == 0); + DUK_ASSERT(comp_ctx->curr_func.is_global == 0); + comp_ctx->curr_func.is_setget = is_setget; + comp_ctx->curr_func.is_decl = is_decl; + + /* + * Parse inner function + */ + + duk__parse_func_like_raw(comp_ctx, is_decl, is_setget); /* pushes function template */ + + /* prev_token.start_offset points to the closing brace here; when skipping + * we're going to reparse the closing brace to ensure semicolon insertion + * etc work as expected. + */ + DUK_DDD(DUK_DDDPRINT("after func: prev_tok.start_offset=%ld, curr_tok.start_offset=%ld", + (long) comp_ctx->prev_token.start_offset, (long) comp_ctx->curr_token.start_offset)); + DUK_ASSERT(comp_ctx->lex.input[comp_ctx->prev_token.start_offset] == (duk_uint8_t) DUK_ASC_RCURLY); + + /* XXX: append primitive */ + DUK_ASSERT(duk_get_length(ctx, old_func.funcs_idx) == (duk_size_t) (old_func.fnum_next * 3)); + fnum = old_func.fnum_next++; + + if (fnum > DUK__MAX_FUNCS) { + DUK_ERROR(comp_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_FUNC_LIMIT); + } + + /* array writes autoincrement length */ + (void) duk_put_prop_index(ctx, old_func.funcs_idx, (duk_uarridx_t) (fnum * 3)); + duk_push_size_t(ctx, comp_ctx->prev_token.start_offset); + (void) duk_put_prop_index(ctx, old_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 1)); + duk_push_int(ctx, comp_ctx->prev_token.start_line); + (void) duk_put_prop_index(ctx, old_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 2)); + + /* + * Cleanup: restore original function, restore valstack state. + */ + + DUK_MEMCPY((void *) &comp_ctx->curr_func, (void *) &old_func, sizeof(duk_compiler_func)); + duk_set_top(ctx, entry_top); + + DUK_ASSERT_TOP(ctx, entry_top); + + return fnum; +} + +/* + * Compile input string into an executable function template without + * arguments. + * + * The string is parsed as the "Program" production of Ecmascript E5. + * Compilation context can be either global code or eval code (see E5 + * Sections 14 and 15.1.2.1). + * + * Input stack: [ ... filename ] + * Output stack: [ ... func_template ] + */ + +/* XXX: source code property */ + +DUK_LOCAL duk_ret_t duk__js_compile_raw(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hstring *h_filename; + duk__compiler_stkstate *comp_stk; + duk_compiler_ctx *comp_ctx; + duk_lexer_point *lex_pt; + duk_compiler_func *func; + duk_idx_t entry_top; + duk_bool_t is_strict; + duk_bool_t is_eval; + duk_bool_t is_funcexpr; + duk_small_uint_t flags; + + DUK_ASSERT(thr != NULL); + + /* + * Arguments check + */ + + entry_top = duk_get_top(ctx); + DUK_ASSERT(entry_top >= 2); + + comp_stk = (duk__compiler_stkstate *) duk_require_pointer(ctx, -1); + comp_ctx = &comp_stk->comp_ctx_alloc; + lex_pt = &comp_stk->lex_pt_alloc; + DUK_ASSERT(comp_ctx != NULL); + DUK_ASSERT(lex_pt != NULL); + + flags = comp_stk->flags; + is_eval = (flags & DUK_JS_COMPILE_FLAG_EVAL ? 1 : 0); + is_strict = (flags & DUK_JS_COMPILE_FLAG_STRICT ? 1 : 0); + is_funcexpr = (flags & DUK_JS_COMPILE_FLAG_FUNCEXPR ? 1 : 0); + + h_filename = duk_get_hstring(ctx, -2); /* may be undefined */ + + /* + * Init compiler and lexer contexts + */ + + func = &comp_ctx->curr_func; +#ifdef DUK_USE_EXPLICIT_NULL_INIT + comp_ctx->thr = NULL; + comp_ctx->h_filename = NULL; + comp_ctx->prev_token.str1 = NULL; + comp_ctx->prev_token.str2 = NULL; + comp_ctx->curr_token.str1 = NULL; + comp_ctx->curr_token.str2 = NULL; +#endif + + duk_require_stack(ctx, DUK__COMPILE_ENTRY_SLOTS); + + duk_push_dynamic_buffer(ctx, 0); /* entry_top + 0 */ + duk_push_undefined(ctx); /* entry_top + 1 */ + duk_push_undefined(ctx); /* entry_top + 2 */ + duk_push_undefined(ctx); /* entry_top + 3 */ + duk_push_undefined(ctx); /* entry_top + 4 */ + + comp_ctx->thr = thr; + comp_ctx->h_filename = h_filename; + comp_ctx->tok11_idx = entry_top + 1; + comp_ctx->tok12_idx = entry_top + 2; + comp_ctx->tok21_idx = entry_top + 3; + comp_ctx->tok22_idx = entry_top + 4; + comp_ctx->recursion_limit = DUK_USE_COMPILER_RECLIMIT; + + /* comp_ctx->lex has been pre-initialized by caller: it has been + * zeroed and input/input_length has been set. + */ + comp_ctx->lex.thr = thr; + /* comp_ctx->lex.input and comp_ctx->lex.input_length filled by caller */ + comp_ctx->lex.slot1_idx = comp_ctx->tok11_idx; + comp_ctx->lex.slot2_idx = comp_ctx->tok12_idx; + comp_ctx->lex.buf_idx = entry_top + 0; + comp_ctx->lex.buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, entry_top + 0); + DUK_ASSERT(comp_ctx->lex.buf != NULL); + DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(comp_ctx->lex.buf) && !DUK_HBUFFER_HAS_EXTERNAL(comp_ctx->lex.buf)); + comp_ctx->lex.token_limit = DUK_COMPILER_TOKEN_LIMIT; + + lex_pt->offset = 0; + lex_pt->line = 1; + DUK_LEXER_SETPOINT(&comp_ctx->lex, lex_pt); /* fills window */ + comp_ctx->curr_token.start_line = 0; /* needed for line number tracking (becomes prev_token.start_line) */ + + /* + * Initialize function state for a zero-argument function + */ + + duk__init_func_valstack_slots(comp_ctx); + DUK_ASSERT(func->num_formals == 0); + + if (is_funcexpr) { + /* Name will be filled from function expression, not by caller. + * This case is used by Function constructor and duk_compile() + * API with the DUK_COMPILE_FUNCTION option. + */ + DUK_ASSERT(func->h_name == NULL); + } else { + duk_push_hstring_stridx(ctx, (is_eval ? DUK_STRIDX_EVAL : + DUK_STRIDX_GLOBAL)); + func->h_name = duk_get_hstring(ctx, -1); + } + + /* + * Parse a function body or a function-like expression, depending + * on flags. + */ + + func->is_strict = is_strict; + func->is_setget = 0; + func->is_decl = 0; + + if (is_funcexpr) { + func->is_function = 1; + func->is_eval = 0; + func->is_global = 0; + + duk__advance(comp_ctx); /* init 'curr_token' */ + duk__advance_expect(comp_ctx, DUK_TOK_FUNCTION); + (void) duk__parse_func_like_raw(comp_ctx, + 0, /* is_decl */ + 0); /* is_setget */ + } else { + func->is_function = 0; + func->is_eval = is_eval; + func->is_global = !is_eval; + + duk__parse_func_body(comp_ctx, + 1, /* expect_eof */ + 1, /* implicit_return_value */ + -1); /* expect_token */ + } + + /* + * Convert duk_compiler_func to a function template + */ + + duk__convert_to_func_template(comp_ctx, 0 /*force_no_namebind*/); + + /* + * Wrapping duk_safe_call() will mangle the stack, just return stack top + */ + + /* [ ... filename (temps) func ] */ + + return 1; +} + +DUK_INTERNAL void duk_js_compile(duk_hthread *thr, const duk_uint8_t *src_buffer, duk_size_t src_length, duk_small_uint_t flags) { + duk_context *ctx = (duk_context *) thr; + duk__compiler_stkstate comp_stk; + duk_compiler_ctx *prev_ctx; + duk_ret_t safe_rc; + + /* XXX: this illustrates that a C catchpoint implemented using duk_safe_call() + * is a bit heavy at the moment. The wrapper compiles to ~180 bytes on x64. + * Alternatives would be nice. + */ + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(src_buffer != NULL); + + /* preinitialize lexer state partially */ + DUK_MEMZERO(&comp_stk, sizeof(comp_stk)); + comp_stk.flags = flags; + DUK_LEXER_INITCTX(&comp_stk.comp_ctx_alloc.lex); + comp_stk.comp_ctx_alloc.lex.input = src_buffer; + comp_stk.comp_ctx_alloc.lex.input_length = src_length; + + duk_push_pointer(ctx, (void *) &comp_stk); + + /* [ ... filename &comp_stk ] */ + + prev_ctx = thr->compile_ctx; + thr->compile_ctx = &comp_stk.comp_ctx_alloc; /* for duk_error_augment.c */ + safe_rc = duk_safe_call(ctx, duk__js_compile_raw, 2 /*nargs*/, 1 /*nret*/); + thr->compile_ctx = prev_ctx; + + if (safe_rc != DUK_EXEC_SUCCESS) { + /* Append a "(line NNN)" to the "message" property of any + * error thrown during compilation. Usually compilation + * errors are SyntaxErrors but they can also be out-of-memory + * errors and the like. + * + * Source file/line are added to tracedata directly by + * duk_error_augment.c based on thr->compile_ctx. + */ + + /* [ ... error ] */ + + DUK_DDD(DUK_DDDPRINT("compile error, before adding line info: %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + if (duk_is_object(ctx, -1)) { + /* XXX: Now that fileName and lineNumber are set, this is + * unnecessary. Remove in Duktape 1.3.0? + */ + + if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_MESSAGE)) { + duk_push_sprintf(ctx, " (line %ld)", (long) comp_stk.comp_ctx_alloc.curr_token.start_line); + duk_concat(ctx, 2); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE); + } else { + duk_pop(ctx); + } + } + DUK_DDD(DUK_DDDPRINT("compile error, after adding line info: %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + duk_throw(ctx); + } + + /* [ ... template ] */ +} +#line 1 "duk_js_executor.c" +/* + * Ecmascript bytecode executor. + */ + +/* include removed: duk_internal.h */ + +/* + * Local declarations + */ + +DUK_LOCAL_DECL void duk__reconfig_valstack(duk_hthread *thr, duk_size_t act_idx, duk_small_uint_t retval_count); + +/* + * Arithmetic, binary, and logical helpers. + * + * Note: there is no opcode for logical AND or logical OR; this is on + * purpose, because the evalution order semantics for them make such + * opcodes pretty pointless (short circuiting means they are most + * comfortably implemented as jumps). However, a logical NOT opcode + * is useful. + * + * Note: careful with duk_tval pointers here: they are potentially + * invalidated by any DECREF and almost any API call. + */ + +DUK_LOCAL duk_double_t duk__compute_mod(duk_double_t d1, duk_double_t d2) { + /* + * Ecmascript modulus ('%') does not match IEEE 754 "remainder" + * operation (implemented by remainder() in C99) but does seem + * to match ANSI C fmod(). + * + * Compare E5 Section 11.5.3 and "man fmod". + */ + + return (duk_double_t) DUK_FMOD((double) d1, (double) d2); +} + +DUK_LOCAL void duk__vm_arith_add(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_uint_fast_t idx_z) { + /* + * Addition operator is different from other arithmetic + * operations in that it also provides string concatenation. + * Hence it is implemented separately. + * + * There is a fast path for number addition. Other cases go + * through potentially multiple coercions as described in the + * E5 specification. It may be possible to reduce the number + * of coercions, but this must be done carefully to preserve + * the exact semantics. + * + * E5 Section 11.6.1. + * + * Custom types also have special behavior implemented here. + */ + + duk_context *ctx = (duk_context *) thr; + duk_double_union du; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(tv_x != NULL); /* may be reg or const */ + DUK_ASSERT(tv_y != NULL); /* may be reg or const */ + DUK_ASSERT_DISABLE(idx_z >= 0); /* unsigned */ + DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx)); + + /* + * Fast paths + */ + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) { + duk_int64_t v1, v2, v3; + duk_int32_t v3_hi; + duk_tval tv_tmp; + duk_tval *tv_z; + + /* Input values are signed 48-bit so we can detect overflow + * reliably from high bits or just a comparison. + */ + + v1 = DUK_TVAL_GET_FASTINT(tv_x); + v2 = DUK_TVAL_GET_FASTINT(tv_y); + v3 = v1 + v2; + v3_hi = (duk_int32_t) (v3 >> 32); + if (DUK_LIKELY(v3_hi >= -0x8000LL && v3_hi <= 0x7fffLL)) { + tv_z = thr->valstack_bottom + idx_z; + DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); + DUK_TVAL_SET_FASTINT(tv_z, v3); + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + return; + } else { + /* overflow, fall through */ + ; + } + } +#endif /* DUK_USE_FASTINT */ + + if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) { + duk_tval tv_tmp; + duk_tval *tv_z; + + du.d = DUK_TVAL_GET_NUMBER(tv_x) + DUK_TVAL_GET_NUMBER(tv_y); + DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du); + DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du)); + + tv_z = thr->valstack_bottom + idx_z; + DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); + DUK_TVAL_SET_NUMBER(tv_z, du.d); + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + return; + } + + /* + * Slow path: potentially requires function calls for coercion + */ + + duk_push_tval(ctx, tv_x); + duk_push_tval(ctx, tv_y); + duk_to_primitive(ctx, -2, DUK_HINT_NONE); /* side effects -> don't use tv_x, tv_y after */ + duk_to_primitive(ctx, -1, DUK_HINT_NONE); + + /* As a first approximation, buffer values are coerced to strings + * for addition. This means that adding two buffers currently + * results in a string. + */ + if (duk_check_type_mask(ctx, -2, DUK_TYPE_MASK_STRING | DUK_TYPE_MASK_BUFFER) || + duk_check_type_mask(ctx, -1, DUK_TYPE_MASK_STRING | DUK_TYPE_MASK_BUFFER)) { + duk_to_string(ctx, -2); + duk_to_string(ctx, -1); + duk_concat(ctx, 2); /* [... s1 s2] -> [... s1+s2] */ + duk_replace(ctx, (duk_idx_t) idx_z); /* side effects */ + } else { + duk_double_t d1, d2; + + d1 = duk_to_number(ctx, -2); + d2 = duk_to_number(ctx, -1); + DUK_ASSERT(duk_is_number(ctx, -2)); + DUK_ASSERT(duk_is_number(ctx, -1)); + DUK_ASSERT_DOUBLE_IS_NORMALIZED(d1); + DUK_ASSERT_DOUBLE_IS_NORMALIZED(d2); + + du.d = d1 + d2; + DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du); + DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du)); + + duk_pop_2(ctx); + duk_push_number(ctx, du.d); + duk_replace(ctx, (duk_idx_t) idx_z); /* side effects */ + } +} + +DUK_LOCAL void duk__vm_arith_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_idx_t idx_z, duk_small_uint_fast_t opcode) { + /* + * Arithmetic operations other than '+' have number-only semantics + * and are implemented here. The separate switch-case here means a + * "double dispatch" of the arithmetic opcode, but saves code space. + * + * E5 Sections 11.5, 11.5.1, 11.5.2, 11.5.3, 11.6, 11.6.1, 11.6.2, 11.6.3. + */ + + duk_context *ctx = (duk_context *) thr; + duk_tval tv_tmp; + duk_tval *tv_z; + duk_double_t d1, d2; + duk_double_union du; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(tv_x != NULL); /* may be reg or const */ + DUK_ASSERT(tv_y != NULL); /* may be reg or const */ + DUK_ASSERT_DISABLE(idx_z >= 0); /* unsigned */ + DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx)); + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) { + duk_int64_t v1, v2, v3; + duk_int32_t v3_hi; + + v1 = DUK_TVAL_GET_FASTINT(tv_x); + v2 = DUK_TVAL_GET_FASTINT(tv_y); + + switch (opcode) { + case DUK_OP_SUB: { + v3 = v1 - v2; + break; + } + case DUK_OP_MUL: { + /* Must ensure result is 64-bit (no overflow); a + * simple and sufficient fast path is to allow only + * 32-bit inputs. Avoid zero inputs to avoid + * negative zero issues (-1 * 0 = -0, for instance). + */ + if (v1 >= -0x80000000LL && v1 <= 0x7fffffffLL && v1 != 0 && + v2 >= -0x80000000LL && v2 <= 0x7fffffffLL && v2 != 0) { + v3 = v1 * v2; + } else { + goto skip_fastint; + } + break; + } + case DUK_OP_DIV: { + /* Don't allow a zero divisor. Fast path check by + * "verifying" with multiplication. Also avoid zero + * dividend to avoid negative zero issues (0 / -1 = -0 + * for instance). + */ + if (v1 == 0 || v2 == 0) { + goto skip_fastint; + } + v3 = v1 / v2; + if (v3 * v2 != v1) { + goto skip_fastint; + } + break; + } + case DUK_OP_MOD: { + /* Don't allow a zero divisor. Restrict both v1 and + * v2 to positive values to avoid compiler specific + * behavior. + */ + if (v1 < 1 || v2 < 1) { + goto skip_fastint; + } + v3 = v1 % v2; + DUK_ASSERT(v3 >= 0); + DUK_ASSERT(v3 < v2); + DUK_ASSERT(v1 - (v1 / v2) * v2 == v3); + break; + } + default: { + DUK_UNREACHABLE(); + goto skip_fastint; + } + } + + v3_hi = (duk_int32_t) (v3 >> 32); + if (DUK_LIKELY(v3_hi >= -0x8000LL && v3_hi <= 0x7fffLL)) { + tv_z = thr->valstack_bottom + idx_z; + DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); + DUK_TVAL_SET_FASTINT(tv_z, v3); + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + return; + } + /* fall through if overflow etc */ + } + skip_fastint: +#endif /* DUK_USE_FASTINT */ + + if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) { + /* fast path */ + d1 = DUK_TVAL_GET_NUMBER(tv_x); + d2 = DUK_TVAL_GET_NUMBER(tv_y); + } else { + duk_push_tval(ctx, tv_x); + duk_push_tval(ctx, tv_y); + d1 = duk_to_number(ctx, -2); /* side effects */ + d2 = duk_to_number(ctx, -1); + DUK_ASSERT(duk_is_number(ctx, -2)); + DUK_ASSERT(duk_is_number(ctx, -1)); + DUK_ASSERT_DOUBLE_IS_NORMALIZED(d1); + DUK_ASSERT_DOUBLE_IS_NORMALIZED(d2); + duk_pop_2(ctx); + } + + switch (opcode) { + case DUK_OP_SUB: { + du.d = d1 - d2; + break; + } + case DUK_OP_MUL: { + du.d = d1 * d2; + break; + } + case DUK_OP_DIV: { + du.d = d1 / d2; + break; + } + case DUK_OP_MOD: { + du.d = duk__compute_mod(d1, d2); + break; + } + default: { + DUK_UNREACHABLE(); + du.d = DUK_DOUBLE_NAN; /* should not happen */ + break; + } + } + + /* important to use normalized NaN with 8-byte tagged types */ + DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du); + DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du)); + + tv_z = thr->valstack_bottom + idx_z; + DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); + DUK_TVAL_SET_NUMBER(tv_z, du.d); + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +} + +DUK_LOCAL void duk__vm_bitwise_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_uint_fast_t idx_z, duk_small_uint_fast_t opcode) { + /* + * Binary bitwise operations use different coercions (ToInt32, ToUint32) + * depending on the operation. We coerce the arguments first using + * ToInt32(), and then cast to an 32-bit value if necessary. Note that + * such casts must be correct even if there is no native 32-bit type + * (e.g., duk_int32_t and duk_uint32_t are 64-bit). + * + * E5 Sections 11.10, 11.7.1, 11.7.2, 11.7.3 + */ + + duk_context *ctx = (duk_context *) thr; + duk_tval tv_tmp; + duk_tval *tv_z; + duk_int32_t i1, i2, i3; + duk_uint32_t u1, u2, u3; +#if defined(DUK_USE_FASTINT) + duk_int64_t fi3; +#else + duk_double_t d3; +#endif + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(tv_x != NULL); /* may be reg or const */ + DUK_ASSERT(tv_y != NULL); /* may be reg or const */ + DUK_ASSERT_DISABLE(idx_z >= 0); /* unsigned */ + DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx)); + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) { + i1 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_x); + i2 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_y); + } + else +#endif /* DUK_USE_FASTINT */ + { + duk_push_tval(ctx, tv_x); + duk_push_tval(ctx, tv_y); + i1 = duk_to_int32(ctx, -2); + i2 = duk_to_int32(ctx, -1); + duk_pop_2(ctx); + } + + switch (opcode) { + case DUK_OP_BAND: { + i3 = i1 & i2; + break; + } + case DUK_OP_BOR: { + i3 = i1 | i2; + break; + } + case DUK_OP_BXOR: { + i3 = i1 ^ i2; + break; + } + case DUK_OP_BASL: { + /* Signed shift, named "arithmetic" (asl) because the result + * is signed, e.g. 4294967295 << 1 -> -2. Note that result + * must be masked. + */ + + u2 = ((duk_uint32_t) i2) & 0xffffffffUL; + i3 = i1 << (u2 & 0x1f); /* E5 Section 11.7.1, steps 7 and 8 */ + i3 = i3 & ((duk_int32_t) 0xffffffffUL); /* Note: left shift, should mask */ + break; + } + case DUK_OP_BASR: { + /* signed shift */ + + u2 = ((duk_uint32_t) i2) & 0xffffffffUL; + i3 = i1 >> (u2 & 0x1f); /* E5 Section 11.7.2, steps 7 and 8 */ + break; + } + case DUK_OP_BLSR: { + /* unsigned shift */ + + u1 = ((duk_uint32_t) i1) & 0xffffffffUL; + u2 = ((duk_uint32_t) i2) & 0xffffffffUL; + + /* special result value handling */ + u3 = u1 >> (u2 & 0x1f); /* E5 Section 11.7.2, steps 7 and 8 */ +#if defined(DUK_USE_FASTINT) + fi3 = (duk_int64_t) u3; + goto fastint_result_set; +#else + d3 = (duk_double_t) u3; + goto result_set; +#endif + } + default: { + DUK_UNREACHABLE(); + i3 = 0; /* should not happen */ + break; + } + } + +#if defined(DUK_USE_FASTINT) + /* Result is always fastint compatible. */ + /* XXX: set 32-bit result (but must handle signed and unsigned) */ + fi3 = (duk_int64_t) i3; + + fastint_result_set: + tv_z = thr->valstack_bottom + idx_z; + DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); + DUK_TVAL_SET_FASTINT(tv_z, fi3); + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +#else + d3 = (duk_double_t) i3; + + result_set: + DUK_ASSERT(!DUK_ISNAN(d3)); /* 'd3' is never NaN, so no need to normalize */ + DUK_ASSERT_DOUBLE_IS_NORMALIZED(d3); /* always normalized */ + + tv_z = thr->valstack_bottom + idx_z; + DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); + DUK_TVAL_SET_NUMBER(tv_z, d3); + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +#endif +} + +/* In-place unary operation. */ +DUK_LOCAL void duk__vm_arith_unary_op(duk_hthread *thr, duk_tval *tv_x, duk_idx_t idx_x, duk_small_uint_fast_t opcode) { + /* + * Arithmetic operations other than '+' have number-only semantics + * and are implemented here. The separate switch-case here means a + * "double dispatch" of the arithmetic opcode, but saves code space. + * + * E5 Sections 11.5, 11.5.1, 11.5.2, 11.5.3, 11.6, 11.6.1, 11.6.2, 11.6.3. + */ + + duk_context *ctx = (duk_context *) thr; + duk_double_t d1; + duk_double_union du; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(opcode == DUK_EXTRAOP_UNM || opcode == DUK_EXTRAOP_UNP); + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_x)) { + duk_int64_t v1, v2; + + v1 = DUK_TVAL_GET_FASTINT(tv_x); + if (opcode == DUK_EXTRAOP_UNM) { + /* The smallest fastint is no longer 48-bit when + * negated. Positive zero becames negative zero + * (cannot be represented) when negated. + */ + if (DUK_LIKELY(v1 != DUK_FASTINT_MIN && v1 != 0)) { + v2 = -v1; + DUK_TVAL_SET_FASTINT(tv_x, v2); /* no refcount changes */ + return; + } + } else { + /* ToNumber() for a fastint is a no-op. */ + DUK_ASSERT(opcode == DUK_EXTRAOP_UNP); + return; + } + /* fall through if overflow etc */ + } +#endif /* DUK_USE_FASTINT */ + + if (!DUK_TVAL_IS_NUMBER(tv_x)) { + duk_to_number(ctx, idx_x); /* side effects, perform in-place */ + tv_x = duk_get_tval(ctx, idx_x); + DUK_ASSERT(tv_x != NULL); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x)); + } + + d1 = DUK_TVAL_GET_NUMBER(tv_x); + if (opcode == DUK_EXTRAOP_UNM) { + du.d = -d1; + } else { + /* ToNumber() for a double is a no-op. */ + DUK_ASSERT(opcode == DUK_EXTRAOP_UNP); + du.d = d1; + } + DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du); /* mandatory if du.d is a NaN */ + + DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du)); + +#if defined(DUK_USE_FASTINT) + /* Unary plus is used to force a fastint check, so must include + * downgrade check. + */ + DUK_TVAL_SET_NUMBER_CHKFAST(tv_x, du.d); /* no refcount changes */ +#else + DUK_TVAL_SET_NUMBER(tv_x, du.d); /* no refcount changes */ +#endif +} + +DUK_LOCAL void duk__vm_bitwise_not(duk_hthread *thr, duk_tval *tv_x, duk_small_uint_fast_t idx_z) { + /* + * E5 Section 11.4.8 + */ + + duk_context *ctx = (duk_context *) thr; + duk_tval tv_tmp; + duk_tval *tv_z; + duk_int32_t i1, i2; +#if !defined(DUK_USE_FASTINT) + duk_double_t d2; +#endif + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(tv_x != NULL); /* may be reg or const */ + DUK_ASSERT_DISABLE(idx_z >= 0); + DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx)); + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_x)) { + i1 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_x); + } + else +#endif /* DUK_USE_FASTINT */ + { + duk_push_tval(ctx, tv_x); + i1 = duk_to_int32(ctx, -1); + duk_pop(ctx); + } + + i2 = ~i1; + +#if defined(DUK_USE_FASTINT) + /* Result is always fastint compatible. */ + tv_z = thr->valstack_bottom + idx_z; + DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); + DUK_TVAL_SET_FASTINT_I32(tv_z, i2); + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +#else + d2 = (duk_double_t) i2; + + DUK_ASSERT(!DUK_ISNAN(d2)); /* 'val' is never NaN, so no need to normalize */ + DUK_ASSERT_DOUBLE_IS_NORMALIZED(d2); /* always normalized */ + + tv_z = thr->valstack_bottom + idx_z; + DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); + DUK_TVAL_SET_NUMBER(tv_z, d2); + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +#endif +} + +DUK_LOCAL void duk__vm_logical_not(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_z) { + /* + * E5 Section 11.4.9 + */ + + duk_tval tv_tmp; + duk_bool_t res; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(tv_x != NULL); /* may be reg or const */ + DUK_ASSERT(tv_z != NULL); /* reg */ + + DUK_UNREF(thr); /* w/o refcounts */ + + /* ToBoolean() does not require any operations with side effects so + * we can do it efficiently. For footprint it would be better to use + * duk_js_toboolean() and then push+replace to the result slot. + */ + res = duk_js_toboolean(tv_x); /* does not modify tv_x */ + DUK_ASSERT(res == 0 || res == 1); + res ^= 1; + DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); + DUK_TVAL_SET_BOOLEAN(tv_z, res); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +} + +/* + * Longjmp handler for the bytecode executor (and a bunch of static + * helpers for it). + * + * Any type of longjmp() can be caught here, including intra-function + * longjmp()s like 'break', 'continue', (slow) 'return', 'yield', etc. + * + * Error policy: should not ordinarily throw errors. Errors thrown + * will bubble outwards. + * + * Returns: + * 0 restart execution + * 1 bytecode executor finished + * 2 rethrow longjmp + */ + +/* XXX: duk_api operations for cross-thread reg manipulation? */ +/* XXX: post-condition: value stack must be correct; for ecmascript functions, clamped to 'nregs' */ + +#define DUK__LONGJMP_RESTART 0 /* state updated, restart bytecode execution */ +#define DUK__LONGJMP_FINISHED 1 /* exit bytecode executor with return value */ +#define DUK__LONGJMP_RETHROW 2 /* exit bytecode executor by rethrowing an error to caller */ + +/* only called when act_idx points to an Ecmascript function */ +DUK_LOCAL void duk__reconfig_valstack(duk_hthread *thr, duk_size_t act_idx, duk_small_uint_t retval_count) { + duk_hcompiledfunction *h_func; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT_DISABLE(act_idx >= 0); /* unsigned */ + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + act_idx) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + act_idx))); + DUK_ASSERT_DISABLE(thr->callstack[act_idx].idx_retval >= 0); /* unsigned */ + + thr->valstack_bottom = thr->valstack + thr->callstack[act_idx].idx_bottom; + + /* clamp so that retval is at the top (retval_count == 1) or register just before + * intended retval is at the top (retval_count == 0, happens e.g. with 'finally'). + */ + duk_set_top((duk_context *) thr, + (duk_idx_t) (thr->callstack[act_idx].idx_retval - + thr->callstack[act_idx].idx_bottom + + retval_count)); + + /* + * When returning to an Ecmascript function, extend the valstack + * top to 'nregs' always. + */ + + h_func = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(thr->callstack + act_idx); + + (void) duk_valstack_resize_raw((duk_context *) thr, + (thr->valstack_bottom - thr->valstack) + /* bottom of current func */ + h_func->nregs + /* reg count */ + DUK_VALSTACK_INTERNAL_EXTRA, /* + spare */ + DUK_VSRESIZE_FLAG_SHRINK | /* flags */ + 0 /* no compact */ | + DUK_VSRESIZE_FLAG_THROW); + + duk_set_top((duk_context *) thr, h_func->nregs); +} + +DUK_LOCAL void duk__handle_catch_or_finally(duk_hthread *thr, duk_size_t cat_idx, duk_bool_t is_finally) { + duk_context *ctx = (duk_context *) thr; + duk_tval tv_tmp; + duk_tval *tv1; + + DUK_DDD(DUK_DDDPRINT("handling catch/finally, cat_idx=%ld, is_finally=%ld", + (long) cat_idx, (long) is_finally)); + + /* + * Set caught value and longjmp type to catcher regs. + */ + + DUK_DDD(DUK_DDDPRINT("writing catch registers: idx_base=%ld -> %!T, idx_base+1=%ld -> %!T", + (long) thr->catchstack[cat_idx].idx_base, + (duk_tval *) &thr->heap->lj.value1, + (long) (thr->catchstack[cat_idx].idx_base + 1), + (duk_tval *) &thr->heap->lj.value2)); + + tv1 = thr->valstack + thr->catchstack[cat_idx].idx_base; + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, &thr->heap->lj.value1); + DUK_TVAL_INCREF(thr, tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + tv1 = thr->valstack + thr->catchstack[cat_idx].idx_base + 1; + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_NUMBER(tv1, (duk_double_t) thr->heap->lj.type); /* XXX: set int */ + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv1)); /* no need to incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + /* + * Unwind catchstack and callstack. + * + * The 'cat_idx' catcher is always kept, even when executing finally. + */ + + duk_hthread_catchstack_unwind(thr, cat_idx + 1); + duk_hthread_callstack_unwind(thr, thr->catchstack[cat_idx].callstack_index + 1); + + /* + * Reconfigure valstack to 'nregs' (this is always the case for + * Ecmascript functions). + */ + + DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))); + + thr->valstack_bottom = thr->valstack + (thr->callstack + thr->callstack_top - 1)->idx_bottom; + duk_set_top((duk_context *) thr, ((duk_hcompiledfunction *) DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))->nregs); + + /* + * Reset PC: resume execution from catch or finally jump slot. + */ + + (thr->callstack + thr->callstack_top - 1)->curr_pc = + thr->catchstack[cat_idx].pc_base + (is_finally ? 1 : 0); + + /* + * If entering a 'catch' block which requires an automatic + * catch variable binding, create the lexical environment. + * + * The binding is mutable (= writable) but not deletable. + * Step 4 for the catch production in E5 Section 12.14; + * no value is given for CreateMutableBinding 'D' argument, + * which implies the binding is not deletable. + */ + + if (!is_finally && DUK_CAT_HAS_CATCH_BINDING_ENABLED(&thr->catchstack[cat_idx])) { + duk_activation *act; + duk_hobject *new_env; + duk_hobject *act_lex_env; + + DUK_DDD(DUK_DDDPRINT("catcher has an automatic catch binding")); + + /* Note: 'act' is dangerous here because it may get invalidate at many + * points, so we re-lookup it multiple times. + */ + DUK_ASSERT(thr->callstack_top >= 1); + act = thr->callstack + thr->callstack_top - 1; + + if (act->lex_env == NULL) { + DUK_ASSERT(act->var_env == NULL); + DUK_DDD(DUK_DDDPRINT("delayed environment initialization")); + + /* this may have side effects, so re-lookup act */ + duk_js_init_activation_environment_records_delayed(thr, act); + act = thr->callstack + thr->callstack_top - 1; + } + DUK_ASSERT(act->lex_env != NULL); + DUK_ASSERT(act->var_env != NULL); + DUK_ASSERT(DUK_ACT_GET_FUNC(act) != NULL); + DUK_UNREF(act); /* unreferenced without assertions */ + + act = thr->callstack + thr->callstack_top - 1; + act_lex_env = act->lex_env; + act = NULL; /* invalidated */ + + (void) duk_push_object_helper_proto(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV), + act_lex_env); + new_env = duk_require_hobject(ctx, -1); + DUK_ASSERT(new_env != NULL); + DUK_DDD(DUK_DDDPRINT("new_env allocated: %!iO", (duk_heaphdr *) new_env)); + + /* Note: currently the catch binding is handled without a register + * binding because we don't support dynamic register bindings (they + * must be fixed for an entire function). So, there is no need to + * record regbases etc. + */ + + DUK_ASSERT(thr->catchstack[cat_idx].h_varname != NULL); + duk_push_hstring(ctx, thr->catchstack[cat_idx].h_varname); + duk_push_tval(ctx, &thr->heap->lj.value1); + duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_W); /* writable, not configurable */ + + act = thr->callstack + thr->callstack_top - 1; + act->lex_env = new_env; + DUK_HOBJECT_INCREF(thr, new_env); /* reachable through activation */ + + DUK_CAT_SET_LEXENV_ACTIVE(&thr->catchstack[cat_idx]); + + duk_pop(ctx); + + DUK_DDD(DUK_DDDPRINT("new_env finished: %!iO", (duk_heaphdr *) new_env)); + } + + if (is_finally) { + DUK_CAT_CLEAR_FINALLY_ENABLED(&thr->catchstack[cat_idx]); + } else { + DUK_CAT_CLEAR_CATCH_ENABLED(&thr->catchstack[cat_idx]); + } +} + +DUK_LOCAL void duk__handle_label(duk_hthread *thr, duk_size_t cat_idx) { + duk_activation *act; + + /* no callstack changes, no value stack changes */ + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->callstack_top >= 1); + + act = thr->callstack + thr->callstack_top - 1; + + DUK_ASSERT(DUK_ACT_GET_FUNC(act) != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(act))); + + /* +0 = break, +1 = continue */ + act->curr_pc = thr->catchstack[cat_idx].pc_base + (thr->heap->lj.type == DUK_LJ_TYPE_CONTINUE ? 1 : 0); + act = NULL; /* invalidated */ + + duk_hthread_catchstack_unwind(thr, cat_idx + 1); /* keep label catcher */ + /* no need to unwind callstack */ + + /* valstack should not need changes */ +#if defined(DUK_USE_ASSERTIONS) + act = thr->callstack + thr->callstack_top - 1; + DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack_bottom) == + (duk_size_t) ((duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act))->nregs); +#endif +} + +/* Note: called for DUK_LJ_TYPE_YIELD and for DUK_LJ_TYPE_RETURN, when a + * return terminates a thread and yields to the resumer. + */ +DUK_LOCAL void duk__handle_yield(duk_hthread *thr, duk_hthread *resumer, duk_size_t act_idx) { + duk_tval tv_tmp; + duk_tval *tv1; + + /* this may also be called for DUK_LJ_TYPE_RETURN; this is OK as long as + * lj.value1 is correct. + */ + + DUK_ASSERT(DUK_ACT_GET_FUNC(resumer->callstack + act_idx) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(resumer->callstack + act_idx))); /* resume caller must be an ecmascript func */ + + DUK_DDD(DUK_DDDPRINT("resume idx_retval is %ld", (long) resumer->callstack[act_idx].idx_retval)); + + tv1 = resumer->valstack + resumer->callstack[act_idx].idx_retval; /* return value from Duktape.Thread.resume() */ + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, &thr->heap->lj.value1); + DUK_TVAL_INCREF(thr, tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + duk_hthread_callstack_unwind(resumer, act_idx + 1); /* unwind to 'resume' caller */ + + /* no need to unwind catchstack */ + duk__reconfig_valstack(resumer, act_idx, 1); /* 1 = have retval */ + + /* caller must change active thread, and set thr->resumer to NULL */ +} + +DUK_LOCAL +duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, + duk_hthread *entry_thread, + duk_size_t entry_callstack_top) { + duk_tval tv_tmp; + duk_size_t entry_callstack_index; + duk_small_uint_t retval = DUK__LONGJMP_RESTART; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(entry_thread != NULL); + DUK_ASSERT(entry_callstack_top > 0); /* guarantees entry_callstack_top - 1 >= 0 */ + + entry_callstack_index = entry_callstack_top - 1; + + /* 'thr' is the current thread, as no-one resumes except us and we + * switch 'thr' in that case. + */ + + /* + * (Re)try handling the longjmp. + * + * A longjmp handler may convert the longjmp to a different type and + * "virtually" rethrow by goto'ing to 'check_longjmp'. Before the goto, + * the following must be updated: + * - the heap 'lj' state + * - 'thr' must reflect the "throwing" thread + */ + + check_longjmp: + + DUK_DD(DUK_DDPRINT("handling longjmp: type=%ld, value1=%!T, value2=%!T, iserror=%ld", + (long) thr->heap->lj.type, + (duk_tval *) &thr->heap->lj.value1, + (duk_tval *) &thr->heap->lj.value2, + (long) thr->heap->lj.iserror)); + + switch (thr->heap->lj.type) { + + case DUK_LJ_TYPE_RESUME: { + /* + * Note: lj.value1 is 'value', lj.value2 is 'resumee'. + * This differs from YIELD. + */ + + duk_tval *tv; + duk_tval *tv2; + duk_size_t act_idx; + duk_hthread *resumee; + + /* duk_bi_duk_object_yield() and duk_bi_duk_object_resume() ensure all of these are met */ + + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); /* unchanged by Duktape.Thread.resume() */ + DUK_ASSERT(thr->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.resume() activation */ + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL && + DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)) && + ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))->func == duk_bi_thread_resume); + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL && + DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2))); /* an Ecmascript function */ + DUK_ASSERT_DISABLE((thr->callstack + thr->callstack_top - 2)->idx_retval >= 0); /* unsigned */ + + tv = &thr->heap->lj.value2; /* resumee */ + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); + DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_THREAD(DUK_TVAL_GET_OBJECT(tv))); + resumee = (duk_hthread *) DUK_TVAL_GET_OBJECT(tv); + + DUK_ASSERT(resumee != NULL); + DUK_ASSERT(resumee->resumer == NULL); + DUK_ASSERT(resumee->state == DUK_HTHREAD_STATE_INACTIVE || + resumee->state == DUK_HTHREAD_STATE_YIELDED); /* checked by Duktape.Thread.resume() */ + DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_YIELDED || + resumee->callstack_top >= 2); /* YIELDED: Ecmascript activation + Duktape.Thread.yield() activation */ + DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_YIELDED || + (DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 1) != NULL && + DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 1)) && + ((duk_hnativefunction *) DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 1))->func == duk_bi_thread_yield)); + DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_YIELDED || + (DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 2) != NULL && + DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 2)))); /* an Ecmascript function */ + DUK_ASSERT_DISABLE(resumee->state != DUK_HTHREAD_STATE_YIELDED || + (resumee->callstack + resumee->callstack_top - 2)->idx_retval >= 0); /* idx_retval unsigned */ + DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_INACTIVE || + resumee->callstack_top == 0); /* INACTIVE: no activation, single function value on valstack */ + DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_INACTIVE || + (resumee->valstack_top == resumee->valstack + 1 && + DUK_TVAL_IS_OBJECT(resumee->valstack_top - 1) && + DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_TVAL_GET_OBJECT(resumee->valstack_top - 1)))); + + if (thr->heap->lj.iserror) { + /* + * Throw the error in the resumed thread's context; the + * error value is pushed onto the resumee valstack. + * + * Note: the callstack of the target may empty in this case + * too (i.e. the target thread has never been resumed). The + * value stack will contain the initial function in that case, + * which we simply ignore. + */ + + resumee->resumer = thr; + resumee->state = DUK_HTHREAD_STATE_RUNNING; + thr->state = DUK_HTHREAD_STATE_RESUMED; + DUK_HEAP_SWITCH_THREAD(thr->heap, resumee); + thr = resumee; + + thr->heap->lj.type = DUK_LJ_TYPE_THROW; + + /* thr->heap->lj.value1 is already the value to throw */ + /* thr->heap->lj.value2 is 'thread', will be wiped out at the end */ + + DUK_ASSERT(thr->heap->lj.iserror); /* already set */ + + DUK_DD(DUK_DDPRINT("-> resume with an error, converted to a throw in the resumee, propagate")); + goto check_longjmp; + } else if (resumee->state == DUK_HTHREAD_STATE_YIELDED) { + act_idx = resumee->callstack_top - 2; /* Ecmascript function */ + DUK_ASSERT_DISABLE(resumee->callstack[act_idx].idx_retval >= 0); /* unsigned */ + + tv = resumee->valstack + resumee->callstack[act_idx].idx_retval; /* return value from Duktape.Thread.yield() */ + DUK_ASSERT(tv >= resumee->valstack && tv < resumee->valstack_top); + tv2 = &thr->heap->lj.value1; + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_TVAL(tv, tv2); + DUK_TVAL_INCREF(thr, tv); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + duk_hthread_callstack_unwind(resumee, act_idx + 1); /* unwind to 'yield' caller */ + + /* no need to unwind catchstack */ + + duk__reconfig_valstack(resumee, act_idx, 1); /* 1 = have retval */ + + resumee->resumer = thr; + resumee->state = DUK_HTHREAD_STATE_RUNNING; + thr->state = DUK_HTHREAD_STATE_RESUMED; + DUK_HEAP_SWITCH_THREAD(thr->heap, resumee); +#if 0 + thr = resumee; /* not needed, as we exit right away */ +#endif + DUK_DD(DUK_DDPRINT("-> resume with a value, restart execution in resumee")); + retval = DUK__LONGJMP_RESTART; + goto wipe_and_return; + } else { + duk_small_uint_t call_flags; + duk_bool_t setup_rc; + + /* resumee: [... initial_func] (currently actually: [initial_func]) */ + + duk_push_undefined((duk_context *) resumee); + tv = &thr->heap->lj.value1; + duk_push_tval((duk_context *) resumee, tv); + + /* resumee: [... initial_func undefined(= this) resume_value ] */ + + call_flags = DUK_CALL_FLAG_IS_RESUME; /* is resume, not a tail call */ + + setup_rc = duk_handle_ecma_call_setup(resumee, + 1, /* num_stack_args */ + call_flags); /* call_flags */ + if (setup_rc == 0) { + /* Shouldn't happen but check anyway. */ + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR); + } + + resumee->resumer = thr; + resumee->state = DUK_HTHREAD_STATE_RUNNING; + thr->state = DUK_HTHREAD_STATE_RESUMED; + DUK_HEAP_SWITCH_THREAD(thr->heap, resumee); +#if 0 + thr = resumee; /* not needed, as we exit right away */ +#endif + DUK_DD(DUK_DDPRINT("-> resume with a value, restart execution in resumee")); + retval = DUK__LONGJMP_RESTART; + goto wipe_and_return; + } + DUK_UNREACHABLE(); + break; /* never here */ + } + + case DUK_LJ_TYPE_YIELD: { + /* + * Currently only allowed only if yielding thread has only + * Ecmascript activations (except for the Duktape.Thread.yield() + * call at the callstack top) and none of them constructor + * calls. + * + * This excludes the 'entry' thread which will always have + * a preventcount > 0. + */ + + duk_hthread *resumer; + + /* duk_bi_duk_object_yield() and duk_bi_duk_object_resume() ensure all of these are met */ + + DUK_ASSERT(thr != entry_thread); /* Duktape.Thread.yield() should prevent */ + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); /* unchanged from Duktape.Thread.yield() */ + DUK_ASSERT(thr->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.yield() activation */ + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL && + DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)) && + ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))->func == duk_bi_thread_yield); + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL && + DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2))); /* an Ecmascript function */ + DUK_ASSERT_DISABLE((thr->callstack + thr->callstack_top - 2)->idx_retval >= 0); /* unsigned */ + + resumer = thr->resumer; + + DUK_ASSERT(resumer != NULL); + DUK_ASSERT(resumer->state == DUK_HTHREAD_STATE_RESUMED); /* written by a previous RESUME handling */ + DUK_ASSERT(resumer->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.resume() activation */ + DUK_ASSERT(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 1) != NULL && + DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 1)) && + ((duk_hnativefunction *) DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 1))->func == duk_bi_thread_resume); + DUK_ASSERT(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 2) != NULL && + DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 2))); /* an Ecmascript function */ + DUK_ASSERT_DISABLE((resumer->callstack + resumer->callstack_top - 2)->idx_retval >= 0); /* unsigned */ + + if (thr->heap->lj.iserror) { + thr->state = DUK_HTHREAD_STATE_YIELDED; + thr->resumer = NULL; + resumer->state = DUK_HTHREAD_STATE_RUNNING; + DUK_HEAP_SWITCH_THREAD(thr->heap, resumer); + thr = resumer; + + thr->heap->lj.type = DUK_LJ_TYPE_THROW; + /* lj.value1 is already set */ + DUK_ASSERT(thr->heap->lj.iserror); /* already set */ + + DUK_DD(DUK_DDPRINT("-> yield an error, converted to a throw in the resumer, propagate")); + goto check_longjmp; + } else { + duk__handle_yield(thr, resumer, resumer->callstack_top - 2); + + thr->state = DUK_HTHREAD_STATE_YIELDED; + thr->resumer = NULL; + resumer->state = DUK_HTHREAD_STATE_RUNNING; + DUK_HEAP_SWITCH_THREAD(thr->heap, resumer); +#if 0 + thr = resumer; /* not needed, as we exit right away */ +#endif + + DUK_DD(DUK_DDPRINT("-> yield a value, restart execution in resumer")); + retval = DUK__LONGJMP_RESTART; + goto wipe_and_return; + } + DUK_UNREACHABLE(); + break; /* never here */ + } + + case DUK_LJ_TYPE_RETURN: { + /* + * Four possible outcomes: + * * A 'finally' in the same function catches the 'return'. + * (or) + * * The return happens at the entry level of the bytecode + * executor, so return from the executor (in C stack). + * (or) + * * There is a calling (Ecmascript) activation in the call + * stack => return to it. + * (or) + * * There is no calling activation, and the thread is + * terminated. There is always a resumer in this case, + * which gets the return value similarly to a 'yield' + * (except that the current thread can no longer be + * resumed). + */ + + duk_tval *tv1; + duk_hthread *resumer; + duk_catcher *cat; + duk_size_t orig_callstack_index; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT(thr->catchstack != NULL); + + /* XXX: does not work if thr->catchstack is NULL */ + /* XXX: does not work if thr->catchstack is allocated but lowest pointer */ + + cat = thr->catchstack + thr->catchstack_top - 1; /* may be < thr->catchstack initially */ + DUK_ASSERT(thr->callstack_top > 0); /* ensures callstack_top - 1 >= 0 */ + orig_callstack_index = thr->callstack_top - 1; + + while (cat >= thr->catchstack) { + if (cat->callstack_index != orig_callstack_index) { + break; + } + if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF && + DUK_CAT_HAS_FINALLY_ENABLED(cat)) { + /* 'finally' catches */ + duk__handle_catch_or_finally(thr, + cat - thr->catchstack, + 1); /* is_finally */ + + DUK_DD(DUK_DDPRINT("-> return caught by a finally (in the same function), restart execution")); + retval = DUK__LONGJMP_RESTART; + goto wipe_and_return; + } + cat--; + } + /* if out of catchstack, cat = thr->catchstack - 1 */ + + DUK_DD(DUK_DDPRINT("no catcher in catch stack, return to calling activation / yield")); + + /* return to calling activation (if any) */ + + if (thr == entry_thread && + thr->callstack_top == entry_callstack_top) { + /* return to the bytecode executor caller */ + + duk_push_tval((duk_context *) thr, &thr->heap->lj.value1); + + /* [ ... retval ] */ + + DUK_DD(DUK_DDPRINT("-> return propagated up to entry level, exit bytecode executor")); + retval = DUK__LONGJMP_FINISHED; + goto wipe_and_return; + } + + if (thr->callstack_top >= 2) { + /* there is a caller; it MUST be an Ecmascript caller (otherwise it would + * match entry level check) + */ + + DUK_DDD(DUK_DDDPRINT("slow return to Ecmascript caller, idx_retval=%ld, lj_value1=%!T", + (long) (thr->callstack + thr->callstack_top - 2)->idx_retval, + (duk_tval *) &thr->heap->lj.value1)); + + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2))); /* must be ecmascript */ + + tv1 = thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval; + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, &thr->heap->lj.value1); + DUK_TVAL_INCREF(thr, tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + DUK_DDD(DUK_DDDPRINT("return value at idx_retval=%ld is %!T", + (long) (thr->callstack + thr->callstack_top - 2)->idx_retval, + (duk_tval *) (thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval))); + + duk_hthread_catchstack_unwind(thr, (cat - thr->catchstack) + 1); /* leave 'cat' as top catcher (also works if catchstack exhausted) */ + duk_hthread_callstack_unwind(thr, thr->callstack_top - 1); + duk__reconfig_valstack(thr, thr->callstack_top - 1, 1); /* new top, i.e. callee */ + + DUK_DD(DUK_DDPRINT("-> return not caught, restart execution in caller")); + retval = DUK__LONGJMP_RESTART; + goto wipe_and_return; + } + + DUK_DD(DUK_DDPRINT("no calling activation, thread finishes (similar to yield)")); + + DUK_ASSERT(thr->resumer != NULL); + DUK_ASSERT(thr->resumer->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.resume() activation */ + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1) != NULL && + DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1)) && + ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1))->func == duk_bi_thread_resume); /* Duktape.Thread.resume() */ + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2) != NULL && + DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2))); /* an Ecmascript function */ + DUK_ASSERT_DISABLE((thr->resumer->callstack + thr->resumer->callstack_top - 2)->idx_retval >= 0); /* unsigned */ + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); + DUK_ASSERT(thr->resumer->state == DUK_HTHREAD_STATE_RESUMED); + + resumer = thr->resumer; + + duk__handle_yield(thr, resumer, resumer->callstack_top - 2); + + duk_hthread_terminate(thr); /* updates thread state, minimizes its allocations */ + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_TERMINATED); + + thr->resumer = NULL; + resumer->state = DUK_HTHREAD_STATE_RUNNING; + DUK_HEAP_SWITCH_THREAD(thr->heap, resumer); +#if 0 + thr = resumer; /* not needed */ +#endif + + DUK_DD(DUK_DDPRINT("-> return not caught, thread terminated; handle like yield, restart execution in resumer")); + retval = DUK__LONGJMP_RESTART; + goto wipe_and_return; + } + + case DUK_LJ_TYPE_BREAK: + case DUK_LJ_TYPE_CONTINUE: { + /* + * Find a matching label catcher or 'finally' catcher in + * the same function. + * + * A label catcher must always exist and will match unless + * a 'finally' captures the break/continue first. It is the + * compiler's responsibility to ensure that labels are used + * correctly. + */ + + duk_catcher *cat; + duk_size_t orig_callstack_index; + duk_uint_t lj_label; + + cat = thr->catchstack + thr->catchstack_top - 1; + orig_callstack_index = cat->callstack_index; + + DUK_ASSERT(DUK_TVAL_IS_NUMBER(&thr->heap->lj.value1)); + lj_label = (duk_uint_t) DUK_TVAL_GET_NUMBER(&thr->heap->lj.value1); + + DUK_DDD(DUK_DDDPRINT("handling break/continue with label=%ld, callstack index=%ld", + (long) lj_label, (long) cat->callstack_index)); + + while (cat >= thr->catchstack) { + if (cat->callstack_index != orig_callstack_index) { + break; + } + DUK_DDD(DUK_DDDPRINT("considering catcher %ld: type=%ld label=%ld", + (long) (cat - thr->catchstack), + (long) DUK_CAT_GET_TYPE(cat), + (long) DUK_CAT_GET_LABEL(cat))); + + if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF && + DUK_CAT_HAS_FINALLY_ENABLED(cat)) { + /* finally catches */ + duk__handle_catch_or_finally(thr, + cat - thr->catchstack, + 1); /* is_finally */ + + DUK_DD(DUK_DDPRINT("-> break/continue caught by a finally (in the same function), restart execution")); + retval = DUK__LONGJMP_RESTART; + goto wipe_and_return; + } + if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_LABEL && + (duk_uint_t) DUK_CAT_GET_LABEL(cat) == lj_label) { + /* found label */ + duk__handle_label(thr, + cat - thr->catchstack); + + DUK_DD(DUK_DDPRINT("-> break/continue caught by a label catcher (in the same function), restart execution")); + retval = DUK__LONGJMP_RESTART; + goto wipe_and_return; + } + cat--; + } + + /* should never happen, but be robust */ + DUK_D(DUK_DPRINT("break/continue not caught by anything in the current function (should never happen)")); + goto convert_to_internal_error; + } + + case DUK_LJ_TYPE_THROW: { + /* + * Three possible outcomes: + * * A try or finally catcher is found => resume there. + * (or) + * * The error propagates to the bytecode executor entry + * level (and we're in the entry thread) => rethrow + * with a new longjmp(), after restoring the previous + * catchpoint. + * * The error is not caught in the current thread, so + * the thread finishes with an error. This works like + * a yielded error, except that the thread is finished + * and can no longer be resumed. (There is always a + * resumer in this case.) + * + * Note: until we hit the entry level, there can only be + * Ecmascript activations. + */ + + duk_catcher *cat; + duk_hthread *resumer; + + cat = thr->catchstack + thr->catchstack_top - 1; + while (cat >= thr->catchstack) { + if (thr == entry_thread && + cat->callstack_index < entry_callstack_index) { + /* entry level reached */ + break; + } + + if (DUK_CAT_HAS_CATCH_ENABLED(cat)) { + /* try catches */ + DUK_ASSERT(DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF); + + duk__handle_catch_or_finally(thr, + cat - thr->catchstack, + 0); /* is_finally */ + + DUK_DD(DUK_DDPRINT("-> throw caught by a 'catch' clause, restart execution")); + retval = DUK__LONGJMP_RESTART; + goto wipe_and_return; + } + + if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) { + DUK_ASSERT(DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF); + DUK_ASSERT(!DUK_CAT_HAS_CATCH_ENABLED(cat)); + + duk__handle_catch_or_finally(thr, + cat - thr->catchstack, + 1); /* is_finally */ + + DUK_DD(DUK_DDPRINT("-> throw caught by a 'finally' clause, restart execution")); + retval = DUK__LONGJMP_RESTART; + goto wipe_and_return; + } + + cat--; + } + + if (thr == entry_thread) { + /* not caught by anything before entry level; rethrow and let the + * final catcher unwind everything + */ +#if 0 + duk_hthread_catchstack_unwind(thr, (cat - thr->catchstack) + 1); /* leave 'cat' as top catcher (also works if catchstack exhausted) */ + duk_hthread_callstack_unwind(thr, entry_callstack_index + 1); + +#endif + DUK_D(DUK_DPRINT("-> throw propagated up to entry level, rethrow and exit bytecode executor")); + retval = DUK__LONGJMP_RETHROW; + goto just_return; + /* Note: MUST NOT wipe_and_return here, as heap->lj must remain intact */ + } + + DUK_DD(DUK_DDPRINT("not caught by current thread, yield error to resumer")); + + /* not caught by current thread, thread terminates (yield error to resumer); + * note that this may cause a cascade if the resumer terminates with an uncaught + * exception etc (this is OK, but needs careful testing) + */ + + DUK_ASSERT(thr->resumer != NULL); + DUK_ASSERT(thr->resumer->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.resume() activation */ + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1) != NULL && + DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1)) && + ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1))->func == duk_bi_thread_resume); /* Duktape.Thread.resume() */ + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2) != NULL && + DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2))); /* an Ecmascript function */ + + resumer = thr->resumer; + + /* reset longjmp */ + + DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW); /* already set */ + /* lj.value1 already set */ + + duk_hthread_terminate(thr); /* updates thread state, minimizes its allocations */ + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_TERMINATED); + + thr->resumer = NULL; + resumer->state = DUK_HTHREAD_STATE_RUNNING; + DUK_HEAP_SWITCH_THREAD(thr->heap, resumer); + thr = resumer; + goto check_longjmp; + } + + case DUK_LJ_TYPE_NORMAL: { + DUK_D(DUK_DPRINT("caught DUK_LJ_TYPE_NORMAL, should never happen, treat as internal error")); + goto convert_to_internal_error; + } + + default: { + /* should never happen, but be robust */ + DUK_D(DUK_DPRINT("caught unknown longjmp type %ld, treat as internal error", (long) thr->heap->lj.type)); + goto convert_to_internal_error; + } + + } /* end switch */ + + DUK_UNREACHABLE(); + + wipe_and_return: + /* this is not strictly necessary, but helps debugging */ + thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN; + thr->heap->lj.iserror = 0; + + DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); + DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2); + DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value2); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + just_return: + return retval; + + convert_to_internal_error: + /* This could also be thrown internally (set the error, goto check_longjmp), + * but it's better for internal errors to bubble outwards. + */ + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR_EXEC_LONGJMP); + DUK_UNREACHABLE(); + return retval; +} + +/* XXX: Disabled for 1.0 release. This needs to handle unwinding for label + * sites (which are created for explicit labels but also for control statements + * like for-loops). At that point it's quite close to the "slow return" handler + * except for longjmp(). Perhaps all returns could initially be handled as fast + * returns and only converted to longjmp()s when basic handling won't do? + */ +#if 0 +/* Try a fast return. Return false if fails, so that a slow return can be done + * instead. + */ +DUK_LOCAL +duk_bool_t duk__handle_fast_return(duk_hthread *thr, + duk_tval *tv_retval, + duk_hthread *entry_thread, + duk_size_t entry_callstack_top) { + duk_tval tv_tmp; + duk_tval *tv1; + + /* retval == NULL indicates 'undefined' return value */ + + if (thr == entry_thread && thr->callstack_top == entry_callstack_top) { + DUK_DDD(DUK_DDDPRINT("reject fast return: return would exit bytecode executor to caller")); + return 0; + } + if (thr->callstack_top <= 1) { + DUK_DDD(DUK_DDDPRINT("reject fast return: there is no caller in this callstack (thread yield)")); + return 0; + } + + /* There is a caller, and it must be an Ecmascript caller (otherwise + * it would have matched the entry level check). + */ + DUK_ASSERT(thr->callstack_top >= 2); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2))); /* must be ecmascript */ + + tv1 = thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval; + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + if (tv_retval) { + DUK_TVAL_SET_TVAL(tv1, tv_retval); + DUK_TVAL_INCREF(thr, tv1); + } else { + DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1); + /* no need to incref */ + } + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + + /* No catchstack to unwind. */ +#if 0 + duk_hthread_catchstack_unwind(thr, (cat - thr->catchstack) + 1); /* leave 'cat' as top catcher (also works if catchstack exhausted) */ +#endif + duk_hthread_callstack_unwind(thr, thr->callstack_top - 1); + duk__reconfig_valstack(thr, thr->callstack_top - 1, 1); /* new top, i.e. callee */ + + DUK_DDD(DUK_DDDPRINT("fast return accepted")); + return 1; +} +#endif + +/* + * Executor interrupt handling + * + * The handler is called whenever the interrupt countdown reaches zero + * (or below). The handler must perform whatever checks are activated, + * e.g. check for cumulative step count to impose an execution step + * limit or check for breakpoints or other debugger interaction. + * + * When the actions are done, the handler must reinit the interrupt + * init and counter values. The 'init' value must indicate how many + * bytecode instructions are executed before the next interrupt. The + * counter must interface with the bytecode executor loop. Concretely, + * the new init value is normally one higher than the new counter value. + * For instance, to execute exactly one bytecode instruction the init + * value is set to 1 and the counter to 0. If an error is thrown by the + * interrupt handler, the counters are set to the same value (e.g. both + * to 0 to cause an interrupt when the next bytecode instruction is about + * to be executed after error handling). + * + * Maintaining the init/counter value properly is important for accurate + * behavior. For instance, executor step limit needs a cumulative step + * count which is simply computed as a sum of 'init' values. This must + * work accurately even when single stepping. + */ + +#if defined(DUK_USE_INTERRUPT_COUNTER) + +#define DUK__INT_NOACTION 0 /* no specific action, resume normal execution */ +#define DUK__INT_RESTART 1 /* must "goto restart_execution", e.g. breakpoints changed */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) +DUK_LOCAL void duk__interrupt_handle_debugger(duk_hthread *thr, duk_bool_t *out_immediate, duk_small_uint_t *out_interrupt_retval) { + duk_context *ctx; + duk_activation *act; + duk_breakpoint *bp; + duk_breakpoint **bp_active; + duk_uint_fast32_t line = 0; + duk_bool_t send_status; + duk_bool_t process_messages; + duk_bool_t processed_messages = 0; + + ctx = (duk_context *) thr; + act = thr->callstack + thr->callstack_top - 1; + + /* It might seem that replacing 'thr->heap' with just 'heap' below + * might be a good idea, but it increases code size slightly + * (probably due to unnecessary spilling) at least on x64. + */ + + /* + * Breakpoint and step state checks + */ + + if (act->flags & DUK_ACT_FLAG_BREAKPOINT_ACTIVE || + (thr->heap->dbg_step_thread == thr && + thr->heap->dbg_step_csindex == thr->callstack_top - 1)) { + line = duk_debug_curr_line(thr); + + if (act->prev_line != line) { + /* Stepped? Step out is handled by callstack unwind. */ + if ((thr->heap->dbg_step_type == DUK_STEP_TYPE_INTO || + thr->heap->dbg_step_type == DUK_STEP_TYPE_OVER) && + (thr->heap->dbg_step_thread == thr) && + (thr->heap->dbg_step_csindex == thr->callstack_top - 1) && + (line != thr->heap->dbg_step_startline)) { + DUK_D(DUK_DPRINT("STEP STATE TRIGGERED PAUSE at line %ld", + (long) line)); + + DUK_HEAP_SET_PAUSED(thr->heap); + } + + /* Check for breakpoints only on line transition. + * Breakpoint is triggered when we enter the target + * line from a different line, and the previous line + * was within the same function. + * + * This condition is tricky: the condition used to be + * that transition to -or across- the breakpoint line + * triggered the breakpoint. This seems intuitively + * better because it handles breakpoints on lines with + * no emitted opcodes; but this leads to the issue + * described in: https://github.com/svaarala/duktape/issues/263. + */ + bp_active = thr->heap->dbg_breakpoints_active; + for (;;) { + bp = *bp_active++; + if (bp == NULL) { + break; + } + + DUK_ASSERT(bp->filename != NULL); + if (act->prev_line != bp->line && line == bp->line) { + DUK_D(DUK_DPRINT("BREAKPOINT TRIGGERED at %!O:%ld", + (duk_heaphdr *) bp->filename, (long) bp->line)); + + DUK_HEAP_SET_PAUSED(thr->heap); + } + } + } else { + ; + } + + act->prev_line = line; + } + + /* + * Rate limit check for sending status update or peeking into + * the debug transport. Both can be expensive operations that + * we don't want to do on every opcode. + * + * Making sure the interval remains reasonable on a wide variety + * of targets and bytecode is difficult without a timestamp, so + * we use a Date-provided timestamp for the rate limit check. + * But since it's also expensive to get a timestamp, a bytecode + * counter is used to rate limit getting timestamps. + */ + + if (thr->heap->dbg_state_dirty || thr->heap->dbg_paused) { + send_status = 1; + } else { + send_status = 0; + } + + if (thr->heap->dbg_paused) { + process_messages = 1; + } else { + process_messages = 0; + } + + /* XXX: remove heap->dbg_exec_counter, use heap->inst_count_interrupt instead? */ + thr->heap->dbg_exec_counter += thr->interrupt_init; + if (thr->heap->dbg_exec_counter - thr->heap->dbg_last_counter >= DUK_HEAP_DBG_RATELIMIT_OPCODES) { + /* Overflow of the execution counter is fine and doesn't break + * anything here. + */ + + duk_double_t now, diff_last; + + thr->heap->dbg_last_counter = thr->heap->dbg_exec_counter; + now = DUK_USE_DATE_GET_NOW(ctx); + + diff_last = now - thr->heap->dbg_last_time; + if (diff_last < 0.0 || diff_last >= (duk_double_t) DUK_HEAP_DBG_RATELIMIT_MILLISECS) { + /* Negative value checked so that a "time jump" works + * reasonably. + * + * Same interval is now used for status sending and + * peeking. + */ + + thr->heap->dbg_last_time = now; + send_status = 1; + process_messages = 1; + } + } + + /* + * Send status + */ + + act = NULL; /* may be changed */ + if (send_status) { + duk_debug_send_status(thr); + thr->heap->dbg_state_dirty = 0; + } + + /* + * Process messages. If we're paused, we'll block for new messages. + * if we're not paused, we'll process anything we can peek but won't + * block for more. + */ + + if (process_messages) { + processed_messages = duk_debug_process_messages(thr, 0 /*no_block*/); + } + + /* XXX: any case here where we need to re-send status? */ + + /* Continue checked execution if there are breakpoints or we're stepping. + * Also use checked execution if paused flag is active - it shouldn't be + * because the debug message loop shouldn't terminate if it was. Step out + * is handled by callstack unwind and doesn't need checked execution. + * Note that debugger may have detached due to error or explicit request + * above, so we must recheck attach status. + */ + + if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) { + act = thr->callstack + thr->callstack_top - 1; /* relookup, may have changed */ + if (act->flags & DUK_ACT_FLAG_BREAKPOINT_ACTIVE || + ((thr->heap->dbg_step_type == DUK_STEP_TYPE_INTO || + thr->heap->dbg_step_type == DUK_STEP_TYPE_OVER) && + thr->heap->dbg_step_thread == thr && + thr->heap->dbg_step_csindex == thr->callstack_top - 1) || + thr->heap->dbg_paused) { + *out_immediate = 1; + } + + /* If we processed any debug messages breakpoints may have + * changed; restart execution to re-check active breakpoints. + */ + if (processed_messages) { + DUK_D(DUK_DPRINT("processed debug messages, restart execution to recheck possibly changed breakpoints")); + *out_interrupt_retval = DUK__INT_RESTART; + } + } else { + DUK_D(DUK_DPRINT("debugger became detached, resume normal execution")); + } +} +#endif /* DUK_USE_DEBUGGER_SUPPORT */ + +DUK_LOCAL duk_small_uint_t duk__executor_interrupt(duk_hthread *thr) { + duk_int_t ctr; + duk_activation *act; + duk_hcompiledfunction *fun; + duk_bool_t immediate = 0; + duk_small_uint_t retval; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(thr->callstack != NULL); + DUK_ASSERT(thr->callstack_top > 0); + +#if defined(DUK_USE_DEBUG) + thr->heap->inst_count_interrupt += thr->interrupt_init; + DUK_DD(DUK_DDPRINT("execution interrupt, counter=%ld, init=%ld, " + "instruction counts: executor=%ld, interrupt=%ld", + (long) thr->interrupt_counter, (long) thr->interrupt_init, + (long) thr->heap->inst_count_exec, (long) thr->heap->inst_count_interrupt)); +#endif + + retval = DUK__INT_NOACTION; + ctr = DUK_HTHREAD_INTCTR_DEFAULT; + + /* + * Avoid nested calls. Concretely this happens during debugging, e.g. + * when we eval() an expression. + */ + + if (DUK_HEAP_HAS_INTERRUPT_RUNNING(thr->heap)) { + DUK_DD(DUK_DDPRINT("nested executor interrupt, ignoring")); + + /* Set a high interrupt counter; the original executor + * interrupt invocation will rewrite before exiting. + */ + thr->interrupt_init = ctr; + thr->interrupt_counter = ctr - 1; + return DUK__INT_NOACTION; + } + DUK_HEAP_SET_INTERRUPT_RUNNING(thr->heap); + + act = thr->callstack + thr->callstack_top - 1; + fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION((duk_hobject *) fun)); + DUK_UNREF(fun); + +#if defined(DUK_USE_EXEC_TIMEOUT_CHECK) + /* + * Execution timeout check + */ + + if (DUK_USE_EXEC_TIMEOUT_CHECK(thr->heap->heap_udata)) { + /* Keep throwing an error whenever we get here. The unusual values + * are set this way because no instruction is ever executed, we just + * throw an error until all try/catch/finally and other catchpoints + * have been exhausted. Duktape/C code gets control at each protected + * call but whenever it enters back into Duktape the RangeError gets + * raised. User exec timeout check must consistently indicate a timeout + * until we've fully bubbled out of Duktape. + */ + DUK_D(DUK_DPRINT("execution timeout, throwing a RangeError")); + thr->interrupt_init = 0; + thr->interrupt_counter = 0; + DUK_HEAP_CLEAR_INTERRUPT_RUNNING(thr->heap); + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, "execution timeout"); + } +#endif /* DUK_USE_EXEC_TIMEOUT_CHECK */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) + if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) { + duk__interrupt_handle_debugger(thr, &immediate, &retval); + act = thr->callstack + thr->callstack_top - 1; /* relookup if changed */ + } +#endif /* DUK_USE_DEBUGGER_SUPPORT */ + + /* + * Update the interrupt counter + */ + + if (immediate) { + /* Cause an interrupt after executing one instruction. */ + ctr = 1; + } + + /* The counter value is one less than the init value: init value should + * indicate how many instructions are executed before interrupt. To + * execute 1 instruction (after interrupt handler return), counter must + * be 0. + */ + thr->interrupt_init = ctr; + thr->interrupt_counter = ctr - 1; + DUK_HEAP_CLEAR_INTERRUPT_RUNNING(thr->heap); + + return retval; +} +#endif /* DUK_USE_INTERRUPT_COUNTER */ + +/* + * Debugger handling for executor restart + * + * Check for breakpoints, stepping, etc, and figure out if we should execute + * in checked or normal mode. Note that we can't do this when an activation + * is created, because breakpoint status (and stepping status) may change + * later, so we must recheck every time we're executing an activation. + */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) +DUK_LOCAL void duk__executor_handle_debugger(duk_hthread *thr, duk_activation *act, duk_hcompiledfunction *fun) { + duk_heap *heap; + duk_tval *tv_tmp; + duk_hstring *filename; + duk_small_uint_t bp_idx; + duk_breakpoint **bp_active; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(act != NULL); + DUK_ASSERT(fun != NULL); + + heap = thr->heap; + bp_active = heap->dbg_breakpoints_active; + act->flags &= ~DUK_ACT_FLAG_BREAKPOINT_ACTIVE; + + tv_tmp = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) fun, DUK_HTHREAD_STRING_FILE_NAME(thr)); + if (tv_tmp && DUK_TVAL_IS_STRING(tv_tmp)) { + filename = DUK_TVAL_GET_STRING(tv_tmp); + + /* Figure out all active breakpoints. A breakpoint is + * considered active if the current function's fileName + * matches the breakpoint's fileName, AND there is no + * inner function that has matching line numbers + * (otherwise a breakpoint would be triggered both + * inside and outside of the inner function which would + * be confusing). Example: + * + * function foo() { + * print('foo'); + * function bar() { <-. breakpoints in these + * print('bar'); | lines should not affect + * } <-' foo() execution + * bar(); + * } + * + * We need a few things that are only available when + * debugger support is enabled: (1) a line range for + * each function, and (2) access to the function + * template to access the inner functions (and their + * line ranges). + * + * It's important to have a narrow match for active + * breakpoints so that we don't enter checked execution + * when that's not necessary. For instance, if we're + * running inside a certain function and there's + * breakpoint outside in (after the call site), we + * don't want to slow down execution of the function. + */ + + for (bp_idx = 0; bp_idx < heap->dbg_breakpoint_count; bp_idx++) { + duk_breakpoint *bp = heap->dbg_breakpoints + bp_idx; + duk_hobject **funcs, **funcs_end; + duk_hcompiledfunction *inner_fun; + duk_bool_t bp_match; + + if (bp->filename == filename && + bp->line >= fun->start_line && bp->line <= fun->end_line) { + bp_match = 1; + DUK_DD(DUK_DDPRINT("breakpoint filename and line match: " + "%s:%ld vs. %s (line %ld vs. %ld-%ld)", + DUK_HSTRING_GET_DATA(bp->filename), + (long) bp->line, + DUK_HSTRING_GET_DATA(filename), + (long) bp->line, + (long) fun->start_line, + (long) fun->end_line)); + + funcs = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, fun); + funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, fun); + while (funcs != funcs_end) { + inner_fun = (duk_hcompiledfunction *) *funcs; + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) inner_fun)); + if (bp->line >= inner_fun->start_line && bp->line <= inner_fun->end_line) { + DUK_DD(DUK_DDPRINT("inner function masks ('captures') breakpoint")); + bp_match = 0; + break; + } + funcs++; + } + + if (bp_match) { + /* No need to check for size of bp_active list, + * it's always larger than maximum number of + * breakpoints. + */ + act->flags |= DUK_ACT_FLAG_BREAKPOINT_ACTIVE; + *bp_active = heap->dbg_breakpoints + bp_idx; + bp_active++; + } + } + } + } + + *bp_active = NULL; /* terminate */ + + DUK_DD(DUK_DDPRINT("ACTIVE BREAKPOINTS: %ld", (long) (bp_active - thr->heap->dbg_breakpoints_active))); + + /* Force pause if we were doing "step into" in another activation. */ + if (thr->heap->dbg_step_thread != NULL && + thr->heap->dbg_step_type == DUK_STEP_TYPE_INTO && + (thr->heap->dbg_step_thread != thr || + thr->heap->dbg_step_csindex != thr->callstack_top - 1)) { + DUK_D(DUK_DPRINT("STEP INTO ACTIVE, FORCE PAUSED")); + DUK_HEAP_SET_PAUSED(thr->heap); + } + + /* Force interrupt right away if we're paused or in "checked mode". + * Step out is handled by callstack unwind. + */ + if (act->flags & (DUK_ACT_FLAG_BREAKPOINT_ACTIVE) || + thr->heap->dbg_paused || + (thr->heap->dbg_step_type != DUK_STEP_TYPE_OUT && + thr->heap->dbg_step_csindex == thr->callstack_top - 1)) { + /* We'll need to interrupt early so recompute the init + * counter to reflect the number of bytecode instructions + * executed so that step counts for e.g. debugger rate + * limiting are accurate. + */ + DUK_ASSERT(thr->interrupt_counter <= thr->interrupt_init); + thr->interrupt_init = thr->interrupt_init - thr->interrupt_counter; + thr->interrupt_counter = 0; + } +} +#endif /* DUK_USE_DEBUGGER_SUPPORT */ + +/* + * Ecmascript bytecode executor. + * + * Resume execution for the current thread from its current activation. + * Returns when execution would return from the entry level activation, + * leaving a single return value on top of the stack. Function calls + * and thread resumptions are handled internally. If an error occurs, + * a longjmp() with type DUK_LJ_TYPE_THROW is called on the entry level + * setjmp() jmpbuf. + * + * Ecmascript function calls and coroutine resumptions are handled + * internally without recursive C calls. Other function calls are + * handled using duk_handle_call(), increasing C recursion depth. + * + * There are many other tricky control flow situations, such as: + * + * - Break and continue (fast and slow) + * - Return (fast and slow) + * - Error throwing + * - Thread resume and yield + * + * For more detailed notes, see doc/execution.rst. + * + * Also see doc/code-issues.rst for discussion of setjmp(), longjmp(), + * and volatile. + */ + +#define DUK__STRICT() (DUK_HOBJECT_HAS_STRICT(&(fun)->obj)) +#define DUK__REG(x) (*(thr->valstack_bottom + (x))) +#define DUK__REGP(x) (thr->valstack_bottom + (x)) +#define DUK__CONST(x) (*(consts + (x))) +#define DUK__CONSTP(x) (consts + (x)) +#define DUK__REGCONST(x) ((x) < DUK_BC_REGLIMIT ? DUK__REG((x)) : DUK__CONST((x) - DUK_BC_REGLIMIT)) +#define DUK__REGCONSTP(x) ((x) < DUK_BC_REGLIMIT ? DUK__REGP((x)) : DUK__CONSTP((x) - DUK_BC_REGLIMIT)) + +#ifdef DUK_USE_VERBOSE_EXECUTOR_ERRORS +#define DUK__INTERNAL_ERROR(msg) do { \ + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, (msg)); \ + } while (0) +#else +#define DUK__INTERNAL_ERROR(msg) do { \ + goto internal_error; \ + } while (0) +#endif + +#define DUK__SYNC_CURR_PC() do { \ + duk_activation *act; \ + act = thr->callstack + thr->callstack_top - 1; \ + act->curr_pc = curr_pc; \ + } while (0) +#define DUK__SYNC_AND_NULL_CURR_PC() do { \ + duk_activation *act; \ + act = thr->callstack + thr->callstack_top - 1; \ + act->curr_pc = curr_pc; \ + thr->ptr_curr_pc = NULL; \ + } while (0) + +DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { + /* Entry level info. Although these are assigned to before setjmp() + * a 'volatile' seems to be needed. Note placement of "volatile" for + * pointers. See doc/code-issues.rst for more discussion. + */ + duk_hthread * volatile entry_thread; /* volatile copy of exec_thr */ + volatile duk_size_t entry_callstack_top; + volatile duk_int_t entry_call_recursion_depth; + duk_jmpbuf * volatile entry_jmpbuf_ptr; + + /* current PC, volatile because it is accessed by other functions + * through thr->ptr_to_curr_pc. Critical for performance. It would + * be safest to make this volatile, but that eliminates performance + * benefits. Aliasing guarantees should be enough though. + */ + duk_instr_t *curr_pc; /* stable */ + + /* "hot" variables for interpretation -- not volatile, value not guaranteed in setjmp error handling */ + duk_hthread *thr; /* stable */ + duk_hcompiledfunction *fun; /* stable */ + duk_tval *consts; /* stable */ + /* 'funcs' is quite rarely used, so no local for it */ + + /* "hot" temps for interpretation -- not volatile, value not guaranteed in setjmp error handling */ + duk_uint_fast32_t ins; /* XXX: check performance impact on x64 between fast/non-fast variant */ + + /* jmpbuf */ + duk_jmpbuf jmpbuf; + +#ifdef DUK_USE_INTERRUPT_COUNTER + duk_int_t int_ctr; +#endif + +#ifdef DUK_USE_ASSERTIONS + duk_size_t valstack_top_base; /* valstack top, should match before interpreting each op (no leftovers) */ +#endif + + /* XXX: document assumptions on setjmp and volatile variables + * (see duk_handle_call()). + */ + + /* + * Preliminaries + */ + + DUK_ASSERT(exec_thr != NULL); + DUK_ASSERT(exec_thr->heap != NULL); + DUK_ASSERT(exec_thr->heap->curr_thread != NULL); + DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR((duk_heaphdr *) exec_thr); + DUK_ASSERT(exec_thr->callstack_top >= 1); /* at least one activation, ours */ + DUK_ASSERT(DUK_ACT_GET_FUNC(exec_thr->callstack + exec_thr->callstack_top - 1) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(exec_thr->callstack + exec_thr->callstack_top - 1))); + + entry_thread = exec_thr; /* volatile copy */ + thr = (duk_hthread *) entry_thread; + entry_callstack_top = thr->callstack_top; + entry_call_recursion_depth = thr->heap->call_recursion_depth; + entry_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr; + + /* + * Setjmp catchpoint setup. + * + * Note: we currently assume that the setjmp() catchpoint is + * not re-entrant (longjmp() cannot be called more than once + * for a single setjmp()). + */ + + reset_setjmp_catchpoint: + + DUK_ASSERT(thr != NULL); + thr->heap->lj.jmpbuf_ptr = &jmpbuf; + DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); + + if (DUK_SETJMP(thr->heap->lj.jmpbuf_ptr->jb)) { + /* + * Note: any local variables accessed here must have their value + * assigned *before* the setjmp() call, OR they must be declared + * volatile. Otherwise their value is not guaranteed to be correct. + * + * 'thr' might seem to be a risky variable because it is changed + * for yield and resume. However, yield and resume are handled + * using longjmp()s. + */ + + duk_small_uint_t lj_ret; + duk_hthread *tmp_entry_thread; + duk_size_t tmp_entry_callstack_top; + + DUK_DDD(DUK_DDDPRINT("longjmp caught by bytecode executor")); + + /* Relookup 'thr': it's not volatile so its value is not + * guaranteed. The heap->curr_thread value should always be + * valid here because longjmp callers don't switch threads, + * only the longjmp handler does that (even for RESUME and + * YIELD). + */ + DUK_ASSERT(entry_thread != NULL); + thr = entry_thread->heap->curr_thread; + + /* Don't sync curr_pc when unwinding: with recursive executor + * calls thr->ptr_curr_pc may be dangling. + */ + + /* XXX: signalling the need to shrink check (only if unwound) */ + + /* Must be restored here to handle e.g. yields properly. */ + thr->heap->call_recursion_depth = entry_call_recursion_depth; + + /* Switch to caller's setjmp() catcher so that if an error occurs + * during error handling, it is always propagated outwards instead + * of causing an infinite loop in our own handler. + */ + + DUK_DDD(DUK_DDDPRINT("restore jmpbuf_ptr: %p -> %p", + (void *) ((thr && thr->heap) ? thr->heap->lj.jmpbuf_ptr : NULL), + (void *) entry_jmpbuf_ptr)); + thr->heap->lj.jmpbuf_ptr = (duk_jmpbuf *) entry_jmpbuf_ptr; + + tmp_entry_thread = (duk_hthread *) entry_thread; /* use temps to avoid GH-318 */ + tmp_entry_callstack_top = (duk_size_t) entry_callstack_top; + lj_ret = duk__handle_longjmp(thr, tmp_entry_thread, tmp_entry_callstack_top); + + if (lj_ret == DUK__LONGJMP_RESTART) { + /* + * Restart bytecode execution, possibly with a changed thread. + */ + thr = thr->heap->curr_thread; + goto reset_setjmp_catchpoint; + } else if (lj_ret == DUK__LONGJMP_RETHROW) { + /* + * Rethrow error to calling state. + */ + + /* thread may have changed (e.g. YIELD converted to THROW) */ + thr = thr->heap->curr_thread; + + DUK_ASSERT(thr->heap->lj.jmpbuf_ptr == entry_jmpbuf_ptr); + + duk_err_longjmp(thr); + DUK_UNREACHABLE(); + } else { + /* + * Return from bytecode executor with a return value. + */ + DUK_ASSERT(lj_ret == DUK__LONGJMP_FINISHED); + /* XXX: return assertions for valstack, callstack, catchstack */ + + DUK_ASSERT(thr->heap->lj.jmpbuf_ptr == entry_jmpbuf_ptr); + return; + } + DUK_UNREACHABLE(); + } + + /* + * Restart execution by reloading thread state. + * + * Note that 'thr' and any thread configuration may have changed, + * so all local variables are suspect. + * + * The number of local variables should be kept to a minimum: if + * the variables are spilled, they will need to be loaded from + * memory anyway. + * + * Any 'goto restart_execution;' code path in opcode dispatch must + * ensure 'curr_pc' is synced back to act->curr_pc before the goto + * takes place. + */ + + restart_execution: + + /* Lookup current thread; use the volatile 'entry_thread' for this to + * avoid clobber warnings. (Any valid, reachable 'thr' value would be + * fine for this, so using 'entry_thread' is just to silence warnings.) + */ + thr = entry_thread->heap->curr_thread; + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))); + + thr->ptr_curr_pc = &curr_pc; + + /* Assume interrupt init/counter are properly initialized here. */ + + /* assume that thr->valstack_bottom has been set-up before getting here */ + { + duk_activation *act; + + act = thr->callstack + thr->callstack_top - 1; + fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act); + DUK_ASSERT(fun != NULL); + DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == fun->nregs); + consts = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, fun); + DUK_ASSERT(consts != NULL); + } + +#if defined(DUK_USE_DEBUGGER_SUPPORT) + if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap) && !thr->heap->dbg_processing) { + duk_activation *act; + + thr->heap->dbg_processing = 1; + act = thr->callstack + thr->callstack_top - 1; + duk__executor_handle_debugger(thr, act, fun); + thr->heap->dbg_processing = 0; + } +#endif /* DUK_USE_DEBUGGER_SUPPORT */ + + /* XXX: shrink check flag? */ + + /* + * Bytecode interpreter. + * + * The interpreter must be very careful with memory pointers, as + * many pointers are not guaranteed to be 'stable' and may be + * reallocated and relocated on-the-fly quite easily (e.g. by a + * memory allocation or a property access). + * + * The following are assumed to have stable pointers: + * - the current thread + * - the current function + * - the bytecode, constant table, inner function table of the + * current function (as they are a part of the function allocation) + * + * The following are assumed to have semi-stable pointers: + * - the current activation entry: stable as long as callstack + * is not changed (reallocated by growing or shrinking), or + * by any garbage collection invocation (through finalizers) + * - Note in particular that ANY DECREF can invalidate the + * activation pointer + * + * The following are not assumed to have stable pointers at all: + * - the value stack (registers) of the current thread + * - the catch stack of the current thread + * + * See execution.rst for discussion. + */ + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(fun != NULL); + + DUK_DD(DUK_DDPRINT("restarting execution, thr %p, act idx %ld, fun %p," + "consts %p, funcs %p, lev %ld, regbot %ld, regtop %ld, catchstack_top=%ld, " + "preventcount=%ld", + (void *) thr, + (long) (thr->callstack_top - 1), + (void *) fun, + (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, fun), + (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, fun), + (long) (thr->callstack_top - 1), + (long) (thr->valstack_bottom - thr->valstack), + (long) (thr->valstack_top - thr->valstack), + (long) thr->catchstack_top, + (long) thr->callstack_preventcount)); + +#ifdef DUK_USE_ASSERTIONS + valstack_top_base = (duk_size_t) (thr->valstack_top - thr->valstack); +#endif + + /* Set up curr_pc for opcode dispatch. */ + { + duk_activation *act; + act = thr->callstack + thr->callstack_top - 1; + curr_pc = act->curr_pc; + } + + for (;;) { + DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == fun->nregs); + DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack) == valstack_top_base); + + /* Executor interrupt counter check, used to implement breakpoints, + * debugging interface, execution timeouts, etc. The counter is heap + * specific but is maintained in the current thread to make the check + * as fast as possible. The counter is copied back to the heap struct + * whenever a thread switch occurs by the DUK_HEAP_SWITCH_THREAD() macro. + */ +#ifdef DUK_USE_INTERRUPT_COUNTER + int_ctr = thr->interrupt_counter; + if (DUK_LIKELY(int_ctr > 0)) { + thr->interrupt_counter = int_ctr - 1; + } else { + /* Trigger at zero or below */ + duk_small_uint_t exec_int_ret; + + /* Write curr_pc back for the debugger. */ + DUK_ASSERT(thr->callstack_top > 0); + { + duk_activation *act; + act = thr->callstack + thr->callstack_top - 1; + act->curr_pc = (duk_instr_t *) curr_pc; + } + + /* Force restart caused by a function return; must recheck + * debugger breakpoints before checking line transitions, + * see GH-303. Restart and then handle interrupt_counter + * zero again. + */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) + if (thr->heap->dbg_force_restart) { + DUK_DD(DUK_DDPRINT("dbg_force_restart flag forced restart execution")); /* GH-303 */ + thr->heap->dbg_force_restart = 0; + goto restart_execution; + } +#endif + + exec_int_ret = duk__executor_interrupt(thr); + if (exec_int_ret == DUK__INT_RESTART) { + /* curr_pc synced back above */ + goto restart_execution; + } + } +#endif +#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) + thr->heap->inst_count_exec++; +#endif + +#if defined(DUK_USE_ASSERTIONS) || defined(DUK_USE_DEBUG) + { + duk_activation *act; + act = thr->callstack + thr->callstack_top - 1; + DUK_ASSERT(curr_pc >= DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, fun)); + DUK_ASSERT(curr_pc < DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, fun)); + DUK_UNREF(act); /* if debugging disabled */ + + DUK_DDD(DUK_DDDPRINT("executing bytecode: pc=%ld, ins=0x%08lx, op=%ld, valstack_top=%ld/%ld, nregs=%ld --> %!I", + (long) (curr_pc - DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, fun)), + (unsigned long) *curr_pc, + (long) DUK_DEC_OP(*curr_pc), + (long) (thr->valstack_top - thr->valstack), + (long) (thr->valstack_end - thr->valstack), + (long) (fun ? fun->nregs : -1), + (duk_instr_t) *curr_pc)); + } +#endif + +#if defined(DUK_USE_ASSERTIONS) + /* Quite heavy assert: check that valstack is in correctly + * initialized state. Improper shuffle instructions can + * write beyond valstack_end so this check catches them in + * the act. + */ + { + duk_tval *tv; + tv = thr->valstack_top; + while (tv != thr->valstack_end) { + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv)); + tv++; + } + } +#endif + + ins = *curr_pc++; + + /* Typing: use duk_small_(u)int_fast_t when decoding small + * opcode fields (op, A, B, C) and duk_(u)int_fast_t when + * decoding larger fields (e.g. BC which is 18 bits). Use + * unsigned variant by default, signed when the value is used + * in signed arithmetic. Using variable names such as 'a', 'b', + * 'c', 'bc', etc makes it easier to spot typing mismatches. + */ + + /* XXX: the best typing needs to be validated by perf measurement: + * e.g. using a small type which is the cast to a larger duk_idx_t + * may be slower than declaring the variable as a duk_idx_t in the + * first place. + */ + + /* XXX: use macros for the repetitive tval/refcount handling. */ + + switch ((int) DUK_DEC_OP(ins)) { + /* XXX: switch cast? */ + + case DUK_OP_LDREG: { + duk_small_uint_fast_t a; + duk_uint_fast_t bc; + duk_tval tv_tmp; + duk_tval *tv1, *tv2; + + a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); + bc = DUK_DEC_BC(ins); tv2 = DUK__REGP(bc); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, tv2); + DUK_TVAL_INCREF(thr, tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + break; + } + + case DUK_OP_STREG: { + duk_small_uint_fast_t a; + duk_uint_fast_t bc; + duk_tval tv_tmp; + duk_tval *tv1, *tv2; + + a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); + bc = DUK_DEC_BC(ins); tv2 = DUK__REGP(bc); + DUK_TVAL_SET_TVAL(&tv_tmp, tv2); + DUK_TVAL_SET_TVAL(tv2, tv1); + DUK_TVAL_INCREF(thr, tv2); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + break; + } + + case DUK_OP_LDCONST: { + duk_small_uint_fast_t a; + duk_uint_fast_t bc; + duk_tval tv_tmp; + duk_tval *tv1, *tv2; + + a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); + bc = DUK_DEC_BC(ins); tv2 = DUK__CONSTP(bc); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, tv2); + DUK_TVAL_INCREF(thr, tv2); /* may be e.g. string */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + break; + } + + case DUK_OP_LDINT: { + duk_small_uint_fast_t a; + duk_int_fast_t bc; + duk_tval tv_tmp; + duk_tval *tv1; +#if defined(DUK_USE_FASTINT) + duk_int32_t val; +#else + duk_double_t val; +#endif + +#if defined(DUK_USE_FASTINT) + a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); + bc = DUK_DEC_BC(ins); val = (duk_int32_t) (bc - DUK_BC_LDINT_BIAS); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_FASTINT_I32(tv1, val); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +#else + a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); + bc = DUK_DEC_BC(ins); val = (duk_double_t) (bc - DUK_BC_LDINT_BIAS); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_NUMBER(tv1, val); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +#endif + break; + } + + case DUK_OP_LDINTX: { + duk_small_uint_fast_t a; + duk_tval *tv1; + duk_double_t val; + + /* LDINTX is not necessarily in FASTINT range, so + * no fast path for now. + * + * XXX: perhaps restrict LDINTX to fastint range, wider + * range very rarely needed. + */ + + a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1)); + val = DUK_TVAL_GET_NUMBER(tv1) * ((duk_double_t) (1L << DUK_BC_LDINTX_SHIFT)) + + (duk_double_t) DUK_DEC_BC(ins); +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_NUMBER_CHKFAST(tv1, val); +#else + DUK_TVAL_SET_NUMBER(tv1, val); +#endif + break; + } + + case DUK_OP_MPUTOBJ: + case DUK_OP_MPUTOBJI: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a; + duk_tval *tv1; + duk_hobject *obj; + duk_uint_fast_t idx; + duk_small_uint_fast_t count; + + /* A -> register of target object + * B -> first register of key/value pair list + * C -> number of key/value pairs + */ + + a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1)); + obj = DUK_TVAL_GET_OBJECT(tv1); + + idx = (duk_uint_fast_t) DUK_DEC_B(ins); + if (DUK_DEC_OP(ins) == DUK_OP_MPUTOBJI) { + duk_tval *tv_ind = DUK__REGP(idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind)); + idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind); + } + + count = (duk_small_uint_fast_t) DUK_DEC_C(ins); + +#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK) + if (DUK_UNLIKELY(idx + count * 2 > (duk_uint_fast_t) duk_get_top(ctx))) { + /* XXX: use duk_is_valid_index() instead? */ + /* XXX: improve check; check against nregs, not against top */ + DUK__INTERNAL_ERROR("MPUTOBJ out of bounds"); + } +#endif + + duk_push_hobject(ctx, obj); + + while (count > 0) { + /* XXX: faster initialization (direct access or better primitives) */ + + duk_push_tval(ctx, DUK__REGP(idx)); + DUK_ASSERT(duk_is_string(ctx, -1)); + duk_push_tval(ctx, DUK__REGP(idx + 1)); /* -> [... obj key value] */ + duk_xdef_prop_wec(ctx, -3); /* -> [... obj] */ + + count--; + idx += 2; + } + + duk_pop(ctx); /* [... obj] -> [...] */ + break; + } + + case DUK_OP_MPUTARR: + case DUK_OP_MPUTARRI: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a; + duk_tval *tv1; + duk_hobject *obj; + duk_uint_fast_t idx; + duk_small_uint_fast_t count; + duk_uint32_t arr_idx; + + /* A -> register of target object + * B -> first register of value data (start_index, value1, value2, ..., valueN) + * C -> number of key/value pairs (N) + */ + + a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1)); + obj = DUK_TVAL_GET_OBJECT(tv1); + DUK_ASSERT(obj != NULL); + + idx = (duk_uint_fast_t) DUK_DEC_B(ins); + if (DUK_DEC_OP(ins) == DUK_OP_MPUTARRI) { + duk_tval *tv_ind = DUK__REGP(idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind)); + idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind); + } + + count = (duk_small_uint_fast_t) DUK_DEC_C(ins); + +#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK) + if (idx + count + 1 > (duk_uint_fast_t) duk_get_top(ctx)) { + /* XXX: use duk_is_valid_index() instead? */ + /* XXX: improve check; check against nregs, not against top */ + DUK__INTERNAL_ERROR("MPUTARR out of bounds"); + } +#endif + + tv1 = DUK__REGP(idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1)); + arr_idx = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv1); + idx++; + + duk_push_hobject(ctx, obj); + + while (count > 0) { + /* duk_xdef_prop() will define an own property without any array + * special behaviors. We'll need to set the array length explicitly + * in the end. For arrays with elisions, the compiler will emit an + * explicit SETALEN which will update the length. + */ + + /* XXX: because we're dealing with 'own' properties of a fresh array, + * the array initializer should just ensure that the array has a large + * enough array part and write the values directly into array part, + * and finally set 'length' manually in the end (as already happens now). + */ + + duk_push_tval(ctx, DUK__REGP(idx)); /* -> [... obj value] */ + duk_xdef_prop_index_wec(ctx, -2, arr_idx); /* -> [... obj] */ + + /* XXX: could use at least one fewer loop counters */ + count--; + idx++; + arr_idx++; + } + + /* XXX: E5.1 Section 11.1.4 coerces the final length through + * ToUint32() which is odd but happens now as a side effect of + * 'arr_idx' type. + */ + duk_hobject_set_length(thr, obj, (duk_uint32_t) arr_idx); + + duk_pop(ctx); /* [... obj] -> [...] */ + break; + } + + case DUK_OP_NEW: + case DUK_OP_NEWI: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_uint_fast_t idx; + duk_small_uint_fast_t i; + + /* A -> unused (reserved for flags, for consistency with DUK_OP_CALL) + * B -> target register and start reg: constructor, arg1, ..., argN + * (for DUK_OP_NEWI, 'b' is indirect) + * C -> num args (N) + */ + + /* duk_new() will call the constuctor using duk_handle_call(). + * A constructor call prevents a yield from inside the constructor, + * even if the constructor is an Ecmascript function. + */ + + /* Don't need to sync curr_pc here; duk_new() will do that + * when it augments the created error. + */ + + /* XXX: unnecessary copying of values? Just set 'top' to + * b + c, and let the return handling fix up the stack frame? + */ + + idx = (duk_uint_fast_t) DUK_DEC_B(ins); + if (DUK_DEC_OP(ins) == DUK_OP_NEWI) { + duk_tval *tv_ind = DUK__REGP(idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind)); + idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind); + } + +#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK) + if (idx + c + 1 > (duk_uint_fast_t) duk_get_top(ctx)) { + /* XXX: use duk_is_valid_index() instead? */ + /* XXX: improve check; check against nregs, not against top */ + DUK__INTERNAL_ERROR("NEW out of bounds"); + } +#endif + + duk_require_stack(ctx, (duk_idx_t) c); + duk_push_tval(ctx, DUK__REGP(idx)); + for (i = 0; i < c; i++) { + duk_push_tval(ctx, DUK__REGP(idx + i + 1)); + } + duk_new(ctx, (duk_idx_t) c); /* [... constructor arg1 ... argN] -> [retval] */ + DUK_DDD(DUK_DDDPRINT("NEW -> %!iT", (duk_tval *) duk_get_tval(ctx, -1))); + duk_replace(ctx, (duk_idx_t) idx); + + /* When debugger is enabled, we need to recheck the activation + * status after returning. This is now handled by call handling + * and heap->dbg_force_restart. + */ + break; + } + + case DUK_OP_REGEXP: { +#ifdef DUK_USE_REGEXP_SUPPORT + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + + /* A -> target register + * B -> bytecode (also contains flags) + * C -> escaped source + */ + + duk_push_tval(ctx, DUK__REGCONSTP(c)); + duk_push_tval(ctx, DUK__REGCONSTP(b)); /* -> [ ... escaped_source bytecode ] */ + duk_regexp_create_instance(thr); /* -> [ ... regexp_instance ] */ + DUK_DDD(DUK_DDDPRINT("regexp instance: %!iT", (duk_tval *) duk_get_tval(ctx, -1))); + duk_replace(ctx, (duk_idx_t) a); +#else + /* The compiler should never emit DUK_OP_REGEXP if there is no + * regexp support. + */ + DUK__INTERNAL_ERROR("no regexp support"); +#endif + + break; + } + + case DUK_OP_CSREG: + case DUK_OP_CSREGI: { + /* + * Assuming a register binds to a variable declared within this + * function (a declarative binding), the 'this' for the call + * setup is always 'undefined'. E5 Section 10.2.1.1.6. + */ + + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t b = DUK_DEC_B(ins); /* restricted to regs */ + duk_uint_fast_t idx; + + /* A -> target register (A, A+1) for call setup + * (for DUK_OP_CSREGI, 'a' is indirect) + * B -> register containing target function (not type checked here) + */ + + /* XXX: direct manipulation, or duk_replace_tval() */ + + /* Note: target registers a and a+1 may overlap with DUK__REGP(b). + * Careful here. + */ + + idx = (duk_uint_fast_t) DUK_DEC_A(ins); + if (DUK_DEC_OP(ins) == DUK_OP_CSREGI) { + duk_tval *tv_ind = DUK__REGP(idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind)); + idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind); + } + +#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK) + if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) { + /* XXX: use duk_is_valid_index() instead? */ + /* XXX: improve check; check against nregs, not against top */ + DUK__INTERNAL_ERROR("CSREG out of bounds"); + } +#endif + + duk_push_tval(ctx, DUK__REGP(b)); + duk_replace(ctx, (duk_idx_t) idx); + duk_push_undefined(ctx); + duk_replace(ctx, (duk_idx_t) (idx + 1)); + break; + } + + case DUK_OP_GETVAR: { + duk_context *ctx = (duk_context *) thr; + duk_activation *act; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk_tval *tv1; + duk_hstring *name; + + tv1 = DUK__CONSTP(bc); + DUK_ASSERT(DUK_TVAL_IS_STRING(tv1)); + name = DUK_TVAL_GET_STRING(tv1); + DUK_ASSERT(name != NULL); + DUK_DDD(DUK_DDDPRINT("GETVAR: '%!O'", (duk_heaphdr *) name)); + act = thr->callstack + thr->callstack_top - 1; + (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/); /* -> [... val this] */ + + duk_pop(ctx); /* 'this' binding is not needed here */ + duk_replace(ctx, (duk_idx_t) a); + break; + } + + case DUK_OP_PUTVAR: { + duk_activation *act; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk_tval *tv1; + duk_hstring *name; + + tv1 = DUK__CONSTP(bc); + DUK_ASSERT(DUK_TVAL_IS_STRING(tv1)); + name = DUK_TVAL_GET_STRING(tv1); + DUK_ASSERT(name != NULL); + + /* XXX: putvar takes a duk_tval pointer, which is awkward and + * should be reworked. + */ + + tv1 = DUK__REGP(a); /* val */ + act = thr->callstack + thr->callstack_top - 1; + duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT()); + break; + } + + case DUK_OP_DECLVAR: { + duk_activation *act; + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_tval *tv1; + duk_hstring *name; + duk_small_uint_t prop_flags; + duk_bool_t is_func_decl; + duk_bool_t is_undef_value; + + tv1 = DUK__REGCONSTP(b); + DUK_ASSERT(DUK_TVAL_IS_STRING(tv1)); + name = DUK_TVAL_GET_STRING(tv1); + DUK_ASSERT(name != NULL); + + is_undef_value = ((a & DUK_BC_DECLVAR_FLAG_UNDEF_VALUE) != 0); + is_func_decl = ((a & DUK_BC_DECLVAR_FLAG_FUNC_DECL) != 0); + + /* XXX: declvar takes an duk_tval pointer, which is awkward and + * should be reworked. + */ + + /* Compiler is responsible for selecting property flags (configurability, + * writability, etc). + */ + prop_flags = a & DUK_PROPDESC_FLAGS_MASK; + + if (is_undef_value) { + duk_push_undefined(ctx); + } else { + duk_push_tval(ctx, DUK__REGCONSTP(c)); + } + tv1 = duk_get_tval(ctx, -1); + + act = thr->callstack + thr->callstack_top - 1; + if (duk_js_declvar_activation(thr, act, name, tv1, prop_flags, is_func_decl)) { + /* already declared, must update binding value */ + tv1 = duk_get_tval(ctx, -1); + duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT()); + } + + duk_pop(ctx); + break; + } + + case DUK_OP_DELVAR: { + duk_activation *act; + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_tval *tv1; + duk_hstring *name; + duk_bool_t rc; + + tv1 = DUK__REGCONSTP(b); + DUK_ASSERT(DUK_TVAL_IS_STRING(tv1)); + name = DUK_TVAL_GET_STRING(tv1); + DUK_ASSERT(name != NULL); + DUK_DDD(DUK_DDDPRINT("DELVAR '%!O'", (duk_heaphdr *) name)); + act = thr->callstack + thr->callstack_top - 1; + rc = duk_js_delvar_activation(thr, act, name); + + duk_push_boolean(ctx, rc); + duk_replace(ctx, (duk_idx_t) a); + break; + } + + case DUK_OP_CSVAR: + case DUK_OP_CSVARI: { + /* 'this' value: + * E5 Section 6.b.i + * + * The only (standard) case where the 'this' binding is non-null is when + * (1) the variable is found in an object environment record, and + * (2) that object environment record is a 'with' block. + * + */ + + duk_context *ctx = (duk_context *) thr; + duk_activation *act; + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_uint_fast_t idx; + duk_tval *tv1; + duk_hstring *name; + + tv1 = DUK__REGCONSTP(b); + DUK_ASSERT(DUK_TVAL_IS_STRING(tv1)); + name = DUK_TVAL_GET_STRING(tv1); + DUK_ASSERT(name != NULL); + act = thr->callstack + thr->callstack_top - 1; + (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/); /* -> [... val this] */ + + /* Note: target registers a and a+1 may overlap with DUK__REGCONSTP(b) + * and DUK__REGCONSTP(c). Careful here. + */ + + idx = (duk_uint_fast_t) DUK_DEC_A(ins); + if (DUK_DEC_OP(ins) == DUK_OP_CSVARI) { + duk_tval *tv_ind = DUK__REGP(idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind)); + idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind); + } + +#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK) + if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) { + /* XXX: use duk_is_valid_index() instead? */ + /* XXX: improve check; check against nregs, not against top */ + DUK__INTERNAL_ERROR("CSVAR out of bounds"); + } +#endif + + duk_replace(ctx, (duk_idx_t) (idx + 1)); /* 'this' binding */ + duk_replace(ctx, (duk_idx_t) idx); /* variable value (function, we hope, not checked here) */ + break; + } + + case DUK_OP_CLOSURE: { + duk_context *ctx = (duk_context *) thr; + duk_activation *act; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk_hobject *fun_temp; + + /* A -> target reg + * BC -> inner function index + */ + + DUK_DDD(DUK_DDDPRINT("CLOSURE to target register %ld, fnum %ld (count %ld)", + (long) a, (long) bc, (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, fun))); + + DUK_ASSERT_DISABLE(bc >= 0); /* unsigned */ + DUK_ASSERT((duk_uint_t) bc < (duk_uint_t) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, fun)); + fun_temp = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, fun)[bc]; + DUK_ASSERT(fun_temp != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(fun_temp)); + + DUK_DDD(DUK_DDDPRINT("CLOSURE: function template is: %p -> %!O", + (void *) fun_temp, (duk_heaphdr *) fun_temp)); + + act = thr->callstack + thr->callstack_top - 1; + if (act->lex_env == NULL) { + DUK_ASSERT(act->var_env == NULL); + duk_js_init_activation_environment_records_delayed(thr, act); + } + DUK_ASSERT(act->lex_env != NULL); + DUK_ASSERT(act->var_env != NULL); + + /* functions always have a NEWENV flag, i.e. they get a + * new variable declaration environment, so only lex_env + * matters here. + */ + duk_js_push_closure(thr, + (duk_hcompiledfunction *) fun_temp, + act->var_env, + act->lex_env); + duk_replace(ctx, (duk_idx_t) a); + + break; + } + + case DUK_OP_GETPROP: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_tval *tv_obj; + duk_tval *tv_key; + duk_bool_t rc; + + /* A -> target reg + * B -> object reg/const (may be const e.g. in "'foo'[1]") + * C -> key reg/const + */ + + tv_obj = DUK__REGCONSTP(b); + tv_key = DUK__REGCONSTP(c); + DUK_DDD(DUK_DDDPRINT("GETPROP: a=%ld obj=%!T, key=%!T", + (long) a, + (duk_tval *) DUK__REGCONSTP(b), + (duk_tval *) DUK__REGCONSTP(c))); + rc = duk_hobject_getprop(thr, tv_obj, tv_key); /* -> [val] */ + DUK_UNREF(rc); /* ignore */ + DUK_DDD(DUK_DDDPRINT("GETPROP --> %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + tv_obj = NULL; /* invalidated */ + tv_key = NULL; /* invalidated */ + + duk_replace(ctx, (duk_idx_t) a); /* val */ + break; + } + + case DUK_OP_PUTPROP: { + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_tval *tv_obj; + duk_tval *tv_key; + duk_tval *tv_val; + duk_bool_t rc; + + /* A -> object reg + * B -> key reg/const + * C -> value reg/const + * + * Note: intentional difference to register arrangement + * of e.g. GETPROP; 'A' must contain a register-only value. + */ + + tv_obj = DUK__REGP(a); + tv_key = DUK__REGCONSTP(b); + tv_val = DUK__REGCONSTP(c); + DUK_DDD(DUK_DDDPRINT("PUTPROP: obj=%!T, key=%!T, val=%!T", + (duk_tval *) DUK__REGP(a), + (duk_tval *) DUK__REGCONSTP(b), + (duk_tval *) DUK__REGCONSTP(c))); + rc = duk_hobject_putprop(thr, tv_obj, tv_key, tv_val, DUK__STRICT()); + DUK_UNREF(rc); /* ignore */ + DUK_DDD(DUK_DDDPRINT("PUTPROP --> obj=%!T, key=%!T, val=%!T", + (duk_tval *) DUK__REGP(a), + (duk_tval *) DUK__REGCONSTP(b), + (duk_tval *) DUK__REGCONSTP(c))); + tv_obj = NULL; /* invalidated */ + tv_key = NULL; /* invalidated */ + tv_val = NULL; /* invalidated */ + + break; + } + + case DUK_OP_DELPROP: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_tval *tv_obj; + duk_tval *tv_key; + duk_bool_t rc; + + /* A -> result reg + * B -> object reg + * C -> key reg/const + */ + + tv_obj = DUK__REGP(b); + tv_key = DUK__REGCONSTP(c); + rc = duk_hobject_delprop(thr, tv_obj, tv_key, DUK__STRICT()); + tv_obj = NULL; /* invalidated */ + tv_key = NULL; /* invalidated */ + + duk_push_boolean(ctx, rc); + duk_replace(ctx, (duk_idx_t) a); /* result */ + break; + } + + case DUK_OP_CSPROP: + case DUK_OP_CSPROPI: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_uint_fast_t idx; + duk_tval *tv_obj; + duk_tval *tv_key; + duk_bool_t rc; + + /* E5 Section 11.2.3, step 6.a.i */ + /* E5 Section 10.4.3 */ + + /* XXX: allow object to be a const, e.g. in 'foo'.toString()? + * On the other hand, DUK_REGCONSTP() is slower and generates + * more code. + */ + + tv_obj = DUK__REGP(b); + tv_key = DUK__REGCONSTP(c); + rc = duk_hobject_getprop(thr, tv_obj, tv_key); /* -> [val] */ + DUK_UNREF(rc); /* unused */ + tv_obj = NULL; /* invalidated */ + tv_key = NULL; /* invalidated */ + + /* Note: target registers a and a+1 may overlap with DUK__REGP(b) + * and DUK__REGCONSTP(c). Careful here. + */ + + idx = (duk_uint_fast_t) DUK_DEC_A(ins); + if (DUK_DEC_OP(ins) == DUK_OP_CSPROPI) { + duk_tval *tv_ind = DUK__REGP(idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind)); + idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind); + } + +#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK) + if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) { + /* XXX: use duk_is_valid_index() instead? */ + /* XXX: improve check; check against nregs, not against top */ + DUK__INTERNAL_ERROR("CSPROP out of bounds"); + } +#endif + + duk_push_tval(ctx, DUK__REGP(b)); /* [ ... val obj ] */ + duk_replace(ctx, (duk_idx_t) (idx + 1)); /* 'this' binding */ + duk_replace(ctx, (duk_idx_t) idx); /* val */ + break; + } + + case DUK_OP_ADD: + case DUK_OP_SUB: + case DUK_OP_MUL: + case DUK_OP_DIV: + case DUK_OP_MOD: { + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_small_uint_fast_t op = DUK_DEC_OP(ins); + + if (op == DUK_OP_ADD) { + /* + * Handling DUK_OP_ADD this way is more compact (experimentally) + * than a separate case with separate argument decoding. + */ + duk__vm_arith_add(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c), a); + } else { + duk__vm_arith_binary_op(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c), a, op); + } + break; + } + + case DUK_OP_BAND: + case DUK_OP_BOR: + case DUK_OP_BXOR: + case DUK_OP_BASL: + case DUK_OP_BLSR: + case DUK_OP_BASR: { + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_small_uint_fast_t op = DUK_DEC_OP(ins); + + duk__vm_bitwise_binary_op(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c), a, op); + break; + } + + case DUK_OP_EQ: + case DUK_OP_NEQ: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_bool_t tmp; + + /* E5 Sections 11.9.1, 11.9.3 */ + tmp = duk_js_equals(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c)); + if (DUK_DEC_OP(ins) == DUK_OP_NEQ) { + tmp = !tmp; + } + duk_push_boolean(ctx, tmp); + duk_replace(ctx, (duk_idx_t) a); + break; + } + + case DUK_OP_SEQ: + case DUK_OP_SNEQ: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_bool_t tmp; + + /* E5 Sections 11.9.1, 11.9.3 */ + tmp = duk_js_strict_equals(DUK__REGCONSTP(b), DUK__REGCONSTP(c)); + if (DUK_DEC_OP(ins) == DUK_OP_SNEQ) { + tmp = !tmp; + } + duk_push_boolean(ctx, tmp); + duk_replace(ctx, (duk_idx_t) a); + break; + } + + /* Note: combining comparison ops must be done carefully because + * of uncomparable values (NaN): it's not necessarily true that + * (x >= y) === !(x < y). Also, evaluation order matters, and + * although it would only seem to affect the compiler this is + * actually not the case, because there are also run-time coercions + * of the arguments (with potential side effects). + * + * XXX: can be combined; check code size. + */ + + case DUK_OP_GT: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_bool_t tmp; + + /* x > y --> y < x */ + tmp = duk_js_compare_helper(thr, + DUK__REGCONSTP(c), /* y */ + DUK__REGCONSTP(b), /* x */ + 0); /* flags */ + + duk_push_boolean(ctx, tmp); + duk_replace(ctx, (duk_idx_t) a); + break; + } + + case DUK_OP_GE: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_bool_t tmp; + + /* x >= y --> not (x < y) */ + tmp = duk_js_compare_helper(thr, + DUK__REGCONSTP(b), /* x */ + DUK__REGCONSTP(c), /* y */ + DUK_COMPARE_FLAG_EVAL_LEFT_FIRST | + DUK_COMPARE_FLAG_NEGATE); /* flags */ + + duk_push_boolean(ctx, tmp); + duk_replace(ctx, (duk_idx_t) a); + break; + } + + case DUK_OP_LT: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_bool_t tmp; + + /* x < y */ + tmp = duk_js_compare_helper(thr, + DUK__REGCONSTP(b), /* x */ + DUK__REGCONSTP(c), /* y */ + DUK_COMPARE_FLAG_EVAL_LEFT_FIRST); /* flags */ + + duk_push_boolean(ctx, tmp); + duk_replace(ctx, (duk_idx_t) a); + break; + } + + case DUK_OP_LE: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_bool_t tmp; + + /* x <= y --> not (x > y) --> not (y < x) */ + tmp = duk_js_compare_helper(thr, + DUK__REGCONSTP(c), /* y */ + DUK__REGCONSTP(b), /* x */ + DUK_COMPARE_FLAG_NEGATE); /* flags */ + + duk_push_boolean(ctx, tmp); + duk_replace(ctx, (duk_idx_t) a); + break; + } + + case DUK_OP_IF: { + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_bool_t tmp; + + tmp = duk_js_toboolean(DUK__REGCONSTP(b)); + if (tmp == (duk_bool_t) a) { + /* if boolean matches A, skip next inst */ + curr_pc++; + } else { + ; + } + break; + } + + case DUK_OP_JUMP: { + duk_int_fast_t abc = DUK_DEC_ABC(ins); + + curr_pc += abc - DUK_BC_JUMP_BIAS; + break; + } + + case DUK_OP_RETURN: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + /* duk_small_uint_fast_t c = DUK_DEC_C(ins); */ + duk_tval *tv_val; + + /* A -> flags + * B -> return value reg/const + * C -> currently unused + */ + + /* A fast return avoids full longjmp handling for a set of + * scenarios which hopefully represents the common cases. + * The compiler is responsible for emitting fast returns + * only when they are safe. Currently this means that there + * is nothing on the catch stack (not even label catchers). + * The speed advantage of fast returns (avoiding longjmp) is + * not very high, around 10-15%. + */ +#if 0 /* XXX: Disabled for 1.0 release */ + if (a & DUK_BC_RETURN_FLAG_FAST) { + DUK_DDD(DUK_DDDPRINT("FASTRETURN attempt a=%ld b=%ld", (long) a, (long) b)); + + if (duk__handle_fast_return(thr, + (a & DUK_BC_RETURN_FLAG_HAVE_RETVAL) ? DUK__REGCONSTP(b) : NULL, + entry_thread, + entry_callstack_top)) { + DUK_DDD(DUK_DDDPRINT("FASTRETURN success a=%ld b=%ld", (long) a, (long) b)); + DUK__SYNC_CURR_PC(); + goto restart_execution; + } + } +#endif + + /* No fast return, slow path. */ + DUK_DDD(DUK_DDDPRINT("SLOWRETURN a=%ld b=%ld", (long) a, (long) b)); + + if (a & DUK_BC_RETURN_FLAG_HAVE_RETVAL) { + tv_val = DUK__REGCONSTP(b); +#if defined(DUK_USE_FASTINT) + /* Explicit check for fastint downgrade. Do + * it also for consts for now, which is odd + * but harmless. + */ + /* XXX: restrict to reg values only? */ + + DUK_TVAL_CHKFAST_INPLACE(tv_val); +#endif + duk_push_tval(ctx, tv_val); + } else { + duk_push_undefined(ctx); + } + + duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_RETURN); + + DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* in bytecode executor, should always be set */ + DUK__SYNC_AND_NULL_CURR_PC(); + duk_err_longjmp(thr); + DUK_UNREACHABLE(); + break; + } + + case DUK_OP_CALL: + case DUK_OP_CALLI: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_uint_fast_t idx; + duk_small_uint_t call_flags; + duk_small_uint_t flag_tailcall; + duk_small_uint_t flag_evalcall; + duk_tval *tv_func; + duk_hobject *obj_func; + duk_bool_t setup_rc; + duk_idx_t num_stack_args; + + /* A -> flags + * B -> base register for call (base -> func, base+1 -> this, base+2 -> arg1 ... base+2+N-1 -> argN) + * (for DUK_OP_CALLI, 'b' is indirect) + * C -> nargs + */ + + /* these are not necessarily 0 or 1 (may be other non-zero), that's ok */ + flag_tailcall = (a & DUK_BC_CALL_FLAG_TAILCALL); + flag_evalcall = (a & DUK_BC_CALL_FLAG_EVALCALL); + + idx = (duk_uint_fast_t) DUK_DEC_B(ins); + if (DUK_DEC_OP(ins) == DUK_OP_CALLI) { + duk_tval *tv_ind = DUK__REGP(idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind)); + idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind); + } + +#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK) + if (!duk_is_valid_index(ctx, (duk_idx_t) idx)) { + /* XXX: improve check; check against nregs, not against top */ + DUK__INTERNAL_ERROR("CALL out of bounds"); + } +#endif + + /* + * To determine whether to use an optimized Ecmascript-to-Ecmascript + * call, we need to know whether the final, non-bound function is an + * Ecmascript function. + * + * This is now implemented so that we start to do an ecma-to-ecma call + * setup which will resolve the bound chain as the first thing. If the + * final function is not eligible, the return value indicates that the + * ecma-to-ecma call is not possible. The setup will overwrite the call + * target at DUK__REGP(idx) with the final, non-bound function (which + * may be a lightfunc), and fudge arguments if necessary. + * + * XXX: If an ecma-to-ecma call is not possible, this initial call + * setup will do bound function chain resolution but won't do the + * "effective this binding" resolution which is quite confusing. + * Perhaps add a helper for doing bound function and effective this + * binding resolution - and call that explicitly? Ecma-to-ecma call + * setup and normal function handling can then assume this prestep has + * been done by the caller. + */ + + duk_set_top(ctx, (duk_idx_t) (idx + c + 2)); /* [ ... func this arg1 ... argN ] */ + + call_flags = 0; + if (flag_tailcall) { + /* We request a tail call, but in some corner cases + * call handling can decide that a tail call is + * actually not possible. + * See: test-bug-tailcall-preventyield-assert.c. + */ + call_flags |= DUK_CALL_FLAG_IS_TAILCALL; + } + + /* Compared to duk_handle_call(): + * - protected call: never + * - ignore recursion limit: never + */ + num_stack_args = c; + setup_rc = duk_handle_ecma_call_setup(thr, + num_stack_args, + call_flags); + + if (setup_rc) { + /* Ecma-to-ecma call possible, may or may not be a tail call. + * Avoid C recursion by being clever. + */ + DUK_DDD(DUK_DDDPRINT("ecma-to-ecma call setup possible, restart execution")); + /* curr_pc synced by duk_handle_ecma_call_setup() */ + goto restart_execution; + } + DUK_ASSERT(thr->ptr_curr_pc != NULL); /* restored if ecma-to-ecma setup fails */ + + DUK_DDD(DUK_DDDPRINT("ecma-to-ecma call not possible, target is native (may be lightfunc)")); + + /* Recompute argument count: bound function handling may have shifted. */ + num_stack_args = duk_get_top(ctx) - (idx + 2); + DUK_DDD(DUK_DDDPRINT("recomputed arg count: %ld\n", (long) num_stack_args)); + + tv_func = DUK__REGP(idx); /* Relookup if relocated */ + if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) { + call_flags = 0; /* not protected, respect reclimit, not constructor */ + + /* There is no eval() special handling here: eval() is never + * automatically converted to a lightfunc. + */ + DUK_ASSERT(DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv_func) != duk_bi_global_object_eval); + + duk_handle_call(thr, + num_stack_args, + call_flags); + + /* duk_js_call.c is required to restore the stack reserve + * so we only need to reset the top. + */ + duk_set_top(ctx, (duk_idx_t) fun->nregs); + + /* No need to reinit setjmp() catchpoint, as call handling + * will store and restore our state. + */ + } else { + /* Call setup checks callability. */ + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_func)); + obj_func = DUK_TVAL_GET_OBJECT(tv_func); + DUK_ASSERT(obj_func != NULL); + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(obj_func)); + + /* + * Other cases, use C recursion. + * + * If a tail call was requested we ignore it and execute a normal call. + * Since Duktape 0.11.0 the compiler emits a RETURN opcode even after + * a tail call to avoid test-bug-tailcall-thread-yield-resume.js. + * + * Direct eval call: (1) call target (before following bound function + * chain) is the built-in eval() function, and (2) call was made with + * the identifier 'eval'. + */ + + call_flags = 0; /* not protected, respect reclimit, not constructor */ + + if (DUK_HOBJECT_IS_NATIVEFUNCTION(obj_func) && + ((duk_hnativefunction *) obj_func)->func == duk_bi_global_object_eval) { + if (flag_evalcall) { + DUK_DDD(DUK_DDDPRINT("call target is eval, call identifier was 'eval' -> direct eval")); + call_flags |= DUK_CALL_FLAG_DIRECT_EVAL; + } else { + DUK_DDD(DUK_DDDPRINT("call target is eval, call identifier was not 'eval' -> indirect eval")); + } + } + + duk_handle_call(thr, + num_stack_args, + call_flags); + + /* duk_js_call.c is required to restore the stack reserve + * so we only need to reset the top. + */ + duk_set_top(ctx, (duk_idx_t) fun->nregs); + + /* No need to reinit setjmp() catchpoint, as call handling + * will store and restore our state. + */ + } + + /* When debugger is enabled, we need to recheck the activation + * status after returning. This is now handled by call handling + * and heap->dbg_force_restart. + */ + break; + } + + case DUK_OP_TRYCATCH: { + duk_context *ctx = (duk_context *) thr; + duk_activation *act; + duk_catcher *cat; + duk_tval *tv1; + duk_small_uint_fast_t a; + duk_uint_fast_t bc; + + /* A -> flags + * BC -> reg_catch; base register for two registers used both during + * trycatch setup and when catch is triggered + * + * If DUK_BC_TRYCATCH_FLAG_CATCH_BINDING set: + * reg_catch + 0: catch binding variable name (string). + * Automatic declarative environment is established for + * the duration of the 'catch' clause. + * + * If DUK_BC_TRYCATCH_FLAG_WITH_BINDING set: + * reg_catch + 0: with 'target value', which is coerced to + * an object and then used as a bindind object for an + * environment record. The binding is initialized here, for + * the 'try' clause. + * + * Note that a TRYCATCH generated for a 'with' statement has no + * catch or finally parts. + */ + + /* XXX: TRYCATCH handling should be reworked to avoid creating + * an explicit scope unless it is actually needed (e.g. function + * instances or eval is executed inside the catch block). This + * rework is not trivial because the compiler doesn't have an + * intermediate representation. When the rework is done, the + * opcode format can also be made more straightforward. + */ + + /* XXX: side effect handling is quite awkward here */ + + DUK_DDD(DUK_DDDPRINT("TRYCATCH: reg_catch=%ld, have_catch=%ld, " + "have_finally=%ld, catch_binding=%ld, with_binding=%ld (flags=0x%02lx)", + (long) DUK_DEC_BC(ins), + (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH ? 1 : 0), + (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY ? 1 : 0), + (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_CATCH_BINDING ? 1 : 0), + (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_WITH_BINDING ? 1 : 0), + (unsigned long) DUK_DEC_A(ins))); + + a = DUK_DEC_A(ins); + bc = DUK_DEC_BC(ins); + + act = thr->callstack + thr->callstack_top - 1; + DUK_ASSERT(thr->callstack_top >= 1); + + /* 'with' target must be created first, in case we run out of memory */ + /* XXX: refactor out? */ + + if (a & DUK_BC_TRYCATCH_FLAG_WITH_BINDING) { + DUK_DDD(DUK_DDDPRINT("need to initialize a with binding object")); + + if (act->lex_env == NULL) { + DUK_ASSERT(act->var_env == NULL); + DUK_DDD(DUK_DDDPRINT("delayed environment initialization")); + + /* must relookup act in case of side effects */ + duk_js_init_activation_environment_records_delayed(thr, act); + act = thr->callstack + thr->callstack_top - 1; + } + DUK_ASSERT(act->lex_env != NULL); + DUK_ASSERT(act->var_env != NULL); + + (void) duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJENV), + -1); /* no prototype, updated below */ + + duk_push_tval(ctx, DUK__REGP(bc)); + duk_to_object(ctx, -1); + duk_dup(ctx, -1); + + /* [ ... env target ] */ + /* [ ... env target target ] */ + + duk_xdef_prop_stridx(thr, -3, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE); + duk_xdef_prop_stridx(thr, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE); /* always provideThis=true */ + + /* [ ... env ] */ + + DUK_DDD(DUK_DDDPRINT("environment for with binding: %!iT", + (duk_tval *) duk_get_tval(ctx, -1))); + } + + /* allocate catcher and populate it (should be atomic) */ + + duk_hthread_catchstack_grow(thr); + cat = thr->catchstack + thr->catchstack_top; + DUK_ASSERT(thr->catchstack_top + 1 <= thr->catchstack_size); + thr->catchstack_top++; + + cat->flags = DUK_CAT_TYPE_TCF; + cat->h_varname = NULL; + + if (a & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH) { + cat->flags |= DUK_CAT_FLAG_CATCH_ENABLED; + } + if (a & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY) { + cat->flags |= DUK_CAT_FLAG_FINALLY_ENABLED; + } + if (a & DUK_BC_TRYCATCH_FLAG_CATCH_BINDING) { + DUK_DDD(DUK_DDDPRINT("catch binding flag set to catcher")); + cat->flags |= DUK_CAT_FLAG_CATCH_BINDING_ENABLED; + tv1 = DUK__REGP(bc); + DUK_ASSERT(DUK_TVAL_IS_STRING(tv1)); + + /* borrowed reference; although 'tv1' comes from a register, + * its value was loaded using LDCONST so the constant will + * also exist and be reachable. + */ + cat->h_varname = DUK_TVAL_GET_STRING(tv1); + } else if (a & DUK_BC_TRYCATCH_FLAG_WITH_BINDING) { + /* env created above to stack top */ + duk_hobject *new_env; + + DUK_DDD(DUK_DDDPRINT("lexenv active flag set to catcher")); + cat->flags |= DUK_CAT_FLAG_LEXENV_ACTIVE; + + DUK_DDD(DUK_DDDPRINT("activating object env: %!iT", + (duk_tval *) duk_get_tval(ctx, -1))); + DUK_ASSERT(act->lex_env != NULL); + new_env = duk_get_hobject(ctx, -1); + DUK_ASSERT(new_env != NULL); + + act = thr->callstack + thr->callstack_top - 1; /* relookup (side effects) */ + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, new_env, act->lex_env); + + act = thr->callstack + thr->callstack_top - 1; /* relookup (side effects) */ + act->lex_env = new_env; + DUK_HOBJECT_INCREF(thr, new_env); + duk_pop(ctx); + } else { + ; + } + + /* Registers 'bc' and 'bc + 1' are written in longjmp handling + * and if their previous values (which are temporaries) become + * unreachable -and- have a finalizer, there'll be a function + * call during error handling which is not supported now (GH-287). + * Ensure that both 'bc' and 'bc + 1' have primitive values to + * guarantee no finalizer calls in error handling. Scrubbing also + * ensures finalizers for the previous values run here rather than + * later. Error handling related values are also written to 'bc' + * and 'bc + 1' but those values never become unreachable during + * error handling, so there's no side effect problem even if the + * error value has a finalizer. + */ + duk_to_undefined(ctx, bc); + duk_to_undefined(ctx, bc + 1); + + cat = thr->catchstack + thr->catchstack_top - 1; /* relookup (side effects) */ + cat->callstack_index = thr->callstack_top - 1; + cat->pc_base = (duk_instr_t *) curr_pc; /* pre-incremented, points to first jump slot */ + cat->idx_base = (duk_size_t) (thr->valstack_bottom - thr->valstack) + bc; + + DUK_DDD(DUK_DDDPRINT("TRYCATCH catcher: flags=0x%08lx, callstack_index=%ld, pc_base=%ld, " + "idx_base=%ld, h_varname=%!O", + (unsigned long) cat->flags, (long) cat->callstack_index, + (long) cat->pc_base, (long) cat->idx_base, (duk_heaphdr *) cat->h_varname)); + + curr_pc += 2; /* skip jump slots */ + break; + } + + /* Pre/post inc/dec for register variables, important for loops. */ + case DUK_OP_PREINCR: + case DUK_OP_PREDECR: + case DUK_OP_POSTINCR: + case DUK_OP_POSTDECR: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk_tval *tv1, *tv2; + duk_tval tv_tmp; + duk_double_t x, y, z; + + /* Two lowest bits of opcode are used to distinguish + * variants. Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1). + */ + DUK_ASSERT((DUK_OP_PREINCR & 0x03) == 0x00); + DUK_ASSERT((DUK_OP_PREDECR & 0x03) == 0x01); + DUK_ASSERT((DUK_OP_POSTINCR & 0x03) == 0x02); + DUK_ASSERT((DUK_OP_POSTDECR & 0x03) == 0x03); + + tv1 = DUK__REGP(bc); +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv1)) { + duk_int64_t x_fi, y_fi, z_fi; + x_fi = DUK_TVAL_GET_FASTINT(tv1); + if (ins & DUK_ENC_OP(0x01)) { + if (x_fi == DUK_FASTINT_MIN) { + goto skip_fastint; + } + y_fi = x_fi - 1; + } else { + if (x_fi == DUK_FASTINT_MAX) { + goto skip_fastint; + } + y_fi = x_fi + 1; + } + + DUK_TVAL_SET_FASTINT(tv1, y_fi); /* no need for refcount update */ + + tv2 = DUK__REGP(a); + DUK_TVAL_SET_TVAL(&tv_tmp, tv2); + z_fi = (ins & DUK_ENC_OP(0x02)) ? x_fi : y_fi; + DUK_TVAL_SET_FASTINT(tv2, z_fi); /* no need for incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + break; + } + skip_fastint: +#endif + if (DUK_TVAL_IS_NUMBER(tv1)) { + /* Fast path for the case where the register + * is a number (e.g. loop counter). + */ + + x = DUK_TVAL_GET_NUMBER(tv1); + if (ins & DUK_ENC_OP(0x01)) { + y = x - 1.0; + } else { + y = x + 1.0; + } + + DUK_TVAL_SET_NUMBER(tv1, y); /* no need for refcount update */ + } else { + x = duk_to_number(ctx, bc); + + if (ins & DUK_ENC_OP(0x01)) { + y = x - 1.0; + } else { + y = x + 1.0; + } + + duk_push_number(ctx, y); + duk_replace(ctx, bc); + } + + tv2 = DUK__REGP(a); + DUK_TVAL_SET_TVAL(&tv_tmp, tv2); + z = (ins & DUK_ENC_OP(0x02)) ? x : y; + DUK_TVAL_SET_NUMBER(tv2, z); /* no need for incref */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + break; + } + + /* Preinc/predec for var-by-name, slow path. */ + case DUK_OP_PREINCV: + case DUK_OP_PREDECV: + case DUK_OP_POSTINCV: + case DUK_OP_POSTDECV: { + duk_context *ctx = (duk_context *) thr; + duk_activation *act; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk_double_t x, y; + duk_tval *tv1; + duk_hstring *name; + + /* Two lowest bits of opcode are used to distinguish + * variants. Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1). + */ + DUK_ASSERT((DUK_OP_PREINCV & 0x03) == 0x00); + DUK_ASSERT((DUK_OP_PREDECV & 0x03) == 0x01); + DUK_ASSERT((DUK_OP_POSTINCV & 0x03) == 0x02); + DUK_ASSERT((DUK_OP_POSTDECV & 0x03) == 0x03); + + tv1 = DUK__CONSTP(bc); + DUK_ASSERT(DUK_TVAL_IS_STRING(tv1)); + name = DUK_TVAL_GET_STRING(tv1); + DUK_ASSERT(name != NULL); + act = thr->callstack + thr->callstack_top - 1; + (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/); /* -> [... val this] */ + + /* XXX: fastint fast path would be very useful here */ + + x = duk_to_number(ctx, -2); + duk_pop_2(ctx); + if (ins & DUK_ENC_OP(0x01)) { + y = x - 1.0; + } else { + y = x + 1.0; + } + + duk_push_number(ctx, y); + tv1 = duk_get_tval(ctx, -1); + DUK_ASSERT(tv1 != NULL); + duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT()); + duk_pop(ctx); + + duk_push_number(ctx, (ins & DUK_ENC_OP(0x02)) ? x : y); + duk_replace(ctx, (duk_idx_t) a); + break; + } + + /* Preinc/predec for object properties. */ + case DUK_OP_PREINCP: + case DUK_OP_PREDECP: + case DUK_OP_POSTINCP: + case DUK_OP_POSTDECP: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t a = DUK_DEC_A(ins); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_tval *tv_obj; + duk_tval *tv_key; + duk_tval *tv_val; + duk_bool_t rc; + duk_double_t x, y; + + /* A -> target reg + * B -> object reg/const (may be const e.g. in "'foo'[1]") + * C -> key reg/const + */ + + /* Two lowest bits of opcode are used to distinguish + * variants. Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1). + */ + DUK_ASSERT((DUK_OP_PREINCP & 0x03) == 0x00); + DUK_ASSERT((DUK_OP_PREDECP & 0x03) == 0x01); + DUK_ASSERT((DUK_OP_POSTINCP & 0x03) == 0x02); + DUK_ASSERT((DUK_OP_POSTDECP & 0x03) == 0x03); + + tv_obj = DUK__REGCONSTP(b); + tv_key = DUK__REGCONSTP(c); + rc = duk_hobject_getprop(thr, tv_obj, tv_key); /* -> [val] */ + DUK_UNREF(rc); /* ignore */ + tv_obj = NULL; /* invalidated */ + tv_key = NULL; /* invalidated */ + + x = duk_to_number(ctx, -1); + duk_pop(ctx); + if (ins & DUK_ENC_OP(0x01)) { + y = x - 1.0; + } else { + y = x + 1.0; + } + + duk_push_number(ctx, y); + tv_val = duk_get_tval(ctx, -1); + DUK_ASSERT(tv_val != NULL); + tv_obj = DUK__REGCONSTP(b); + tv_key = DUK__REGCONSTP(c); + rc = duk_hobject_putprop(thr, tv_obj, tv_key, tv_val, DUK__STRICT()); + DUK_UNREF(rc); /* ignore */ + tv_obj = NULL; /* invalidated */ + tv_key = NULL; /* invalidated */ + duk_pop(ctx); + + duk_push_number(ctx, (ins & DUK_ENC_OP(0x02)) ? x : y); + duk_replace(ctx, (duk_idx_t) a); + break; + } + + case DUK_OP_EXTRA: { + /* XXX: shared decoding of 'b' and 'c'? */ + + duk_small_uint_fast_t extraop = DUK_DEC_A(ins); + switch ((int) extraop) { + /* XXX: switch cast? */ + + case DUK_EXTRAOP_NOP: { + /* nop */ + break; + } + + case DUK_EXTRAOP_INVALID: { + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "INVALID opcode (%ld)", (long) DUK_DEC_BC(ins)); + break; + } + + case DUK_EXTRAOP_LDTHIS: { + /* Note: 'this' may be bound to any value, not just an object */ + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk_tval tv_tmp; + duk_tval *tv1, *tv2; + + tv1 = DUK__REGP(bc); + tv2 = thr->valstack_bottom - 1; /* 'this binding' is just under bottom */ + DUK_ASSERT(tv2 >= thr->valstack); + + DUK_DDD(DUK_DDDPRINT("LDTHIS: %!T to r%ld", (duk_tval *) tv2, (long) bc)); + + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_TVAL(tv1, tv2); + DUK_TVAL_INCREF(thr, tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + break; + } + + case DUK_EXTRAOP_LDUNDEF: { + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk_tval tv_tmp; + duk_tval *tv1; + + tv1 = DUK__REGP(bc); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + break; + } + + case DUK_EXTRAOP_LDNULL: { + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk_tval tv_tmp; + duk_tval *tv1; + + tv1 = DUK__REGP(bc); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_NULL(tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + break; + } + + case DUK_EXTRAOP_LDTRUE: + case DUK_EXTRAOP_LDFALSE: { + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk_tval tv_tmp; + duk_tval *tv1; + duk_small_uint_fast_t bval = (extraop == DUK_EXTRAOP_LDTRUE ? 1 : 0); + + tv1 = DUK__REGP(bc); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_BOOLEAN(tv1, bval); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + break; + } + + case DUK_EXTRAOP_NEWOBJ: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t b = DUK_DEC_B(ins); + + duk_push_object(ctx); + duk_replace(ctx, (duk_idx_t) b); + break; + } + + case DUK_EXTRAOP_NEWARR: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t b = DUK_DEC_B(ins); + + duk_push_array(ctx); + duk_replace(ctx, (duk_idx_t) b); + break; + } + + case DUK_EXTRAOP_SETALEN: { + duk_small_uint_fast_t b; + duk_small_uint_fast_t c; + duk_tval *tv1; + duk_hobject *h; + duk_uint32_t len; + + b = DUK_DEC_B(ins); tv1 = DUK__REGP(b); + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1)); + h = DUK_TVAL_GET_OBJECT(tv1); + + c = DUK_DEC_C(ins); tv1 = DUK__REGP(c); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1)); + len = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv1); + + duk_hobject_set_length(thr, h, len); + + break; + } + + case DUK_EXTRAOP_TYPEOF: { + duk_context *ctx = (duk_context *) thr; + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk_push_hstring(ctx, duk_js_typeof(thr, DUK__REGP(bc))); + duk_replace(ctx, (duk_idx_t) bc); + break; + } + + case DUK_EXTRAOP_TYPEOFID: { + duk_context *ctx = (duk_context *) thr; + duk_activation *act; + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_hstring *name; + duk_tval *tv; + + /* B -> target register + * C -> constant index of identifier name + */ + + tv = DUK__REGCONSTP(c); /* XXX: this could be a DUK__CONSTP instead */ + DUK_ASSERT(DUK_TVAL_IS_STRING(tv)); + name = DUK_TVAL_GET_STRING(tv); + act = thr->callstack + thr->callstack_top - 1; + if (duk_js_getvar_activation(thr, act, name, 0 /*throw*/)) { + /* -> [... val this] */ + tv = duk_get_tval(ctx, -2); + duk_push_hstring(ctx, duk_js_typeof(thr, tv)); + duk_replace(ctx, (duk_idx_t) b); + duk_pop_2(ctx); + } else { + /* unresolvable, no stack changes */ + duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_UNDEFINED); + duk_replace(ctx, (duk_idx_t) b); + } + + break; + } + + case DUK_EXTRAOP_INITENUM: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + + /* + * Enumeration semantics come from for-in statement, E5 Section 12.6.4. + * If called with 'null' or 'undefined', this opcode returns 'null' as + * the enumerator, which is special cased in NEXTENUM. This simplifies + * the compiler part + */ + + /* B -> register for writing enumerator object + * C -> value to be enumerated (register) + */ + + if (duk_is_null_or_undefined(ctx, (duk_idx_t) c)) { + duk_push_null(ctx); + duk_replace(ctx, (duk_idx_t) b); + } else { + duk_dup(ctx, (duk_idx_t) c); + duk_to_object(ctx, -1); + duk_hobject_enumerator_create(ctx, 0 /*enum_flags*/); /* [ ... val ] --> [ ... enum ] */ + duk_replace(ctx, (duk_idx_t) b); + } + break; + } + + case DUK_EXTRAOP_NEXTENUM: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + + /* + * NEXTENUM checks whether the enumerator still has unenumerated + * keys. If so, the next key is loaded to the target register + * and the next instruction is skipped. Otherwise the next instruction + * will be executed, jumping out of the enumeration loop. + */ + + /* B -> target register for next key + * C -> enum register + */ + + DUK_DDD(DUK_DDDPRINT("NEXTENUM: b->%!T, c->%!T", + (duk_tval *) duk_get_tval(ctx, (duk_idx_t) b), + (duk_tval *) duk_get_tval(ctx, (duk_idx_t) c))); + + if (duk_is_object(ctx, (duk_idx_t) c)) { + /* XXX: assert 'c' is an enumerator */ + duk_dup(ctx, (duk_idx_t) c); + if (duk_hobject_enumerator_next(ctx, 0 /*get_value*/)) { + /* [ ... enum ] -> [ ... next_key ] */ + DUK_DDD(DUK_DDDPRINT("enum active, next key is %!T, skip jump slot ", + (duk_tval *) duk_get_tval(ctx, -1))); + curr_pc++; + } else { + /* [ ... enum ] -> [ ... ] */ + DUK_DDD(DUK_DDDPRINT("enum finished, execute jump slot")); + duk_push_undefined(ctx); + } + duk_replace(ctx, (duk_idx_t) b); + } else { + /* 'null' enumerator case -> behave as with an empty enumerator */ + DUK_ASSERT(duk_is_null(ctx, (duk_idx_t) c)); + DUK_DDD(DUK_DDDPRINT("enum is null, execute jump slot")); + } + break; + } + + case DUK_EXTRAOP_INITSET: + case DUK_EXTRAOP_INITSETI: + case DUK_EXTRAOP_INITGET: + case DUK_EXTRAOP_INITGETI: { + duk_context *ctx = (duk_context *) thr; + duk_bool_t is_set = (extraop == DUK_EXTRAOP_INITSET || extraop == DUK_EXTRAOP_INITSETI); + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_uint_fast_t idx; + + /* B -> object register + * C -> C+0 contains key, C+1 closure (value) + */ + + /* + * INITSET/INITGET are only used to initialize object literal keys. + * The compiler ensures that there cannot be a previous data property + * of the same name. It also ensures that setter and getter can only + * be initialized once (or not at all). + */ + + idx = (duk_uint_fast_t) DUK_DEC_C(ins); + if (extraop == DUK_EXTRAOP_INITSETI || extraop == DUK_EXTRAOP_INITGETI) { + duk_tval *tv_ind = DUK__REGP(idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind)); + idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind); + } + +#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK) + if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) { + /* XXX: use duk_is_valid_index() instead? */ + /* XXX: improve check; check against nregs, not against top */ + DUK__INTERNAL_ERROR("INITSET/INITGET out of bounds"); + } +#endif + + /* XXX: this is now a very unoptimal implementation -- this can be + * made very simple by direct manipulation of the object internals, + * given the guarantees above. + */ + + duk_push_hobject_bidx(ctx, DUK_BIDX_OBJECT_CONSTRUCTOR); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_DEFINE_PROPERTY); + duk_push_undefined(ctx); + duk_dup(ctx, (duk_idx_t) b); + duk_dup(ctx, (duk_idx_t) (idx + 0)); + duk_push_object(ctx); /* -> [ Object defineProperty undefined obj key desc ] */ + + duk_push_true(ctx); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_ENUMERABLE); + duk_push_true(ctx); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_CONFIGURABLE); + duk_dup(ctx, (duk_idx_t) (idx + 1)); + duk_put_prop_stridx(ctx, -2, (is_set ? DUK_STRIDX_SET : DUK_STRIDX_GET)); + + DUK_DDD(DUK_DDDPRINT("INITGET/INITSET: obj=%!T, key=%!T, desc=%!T", + (duk_tval *) duk_get_tval(ctx, -3), + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + + duk_call_method(ctx, 3); /* -> [ Object res ] */ + duk_pop_2(ctx); + + DUK_DDD(DUK_DDDPRINT("INITGET/INITSET AFTER: obj=%!T", + (duk_tval *) duk_get_tval(ctx, (duk_idx_t) b))); + break; + } + + case DUK_EXTRAOP_ENDTRY: { + duk_catcher *cat; + duk_tval tv_tmp; + duk_tval *tv1; + + DUK_ASSERT(thr->catchstack_top >= 1); + DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1); + + cat = thr->catchstack + thr->catchstack_top - 1; + + DUK_DDD(DUK_DDDPRINT("ENDTRY: clearing catch active flag (regardless of whether it was set or not)")); + DUK_CAT_CLEAR_CATCH_ENABLED(cat); + + if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) { + DUK_DDD(DUK_DDDPRINT("ENDTRY: finally part is active, jump through 2nd jump slot with 'normal continuation'")); + + tv1 = thr->valstack + cat->idx_base; + DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + tv1 = NULL; + + tv1 = thr->valstack + cat->idx_base + 1; + DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_NUMBER(tv1, (duk_double_t) DUK_LJ_TYPE_NORMAL); /* XXX: set int */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + tv1 = NULL; + + DUK_CAT_CLEAR_FINALLY_ENABLED(cat); + } else { + DUK_DDD(DUK_DDDPRINT("ENDTRY: no finally part, dismantle catcher, jump through 2nd jump slot (to end of statement)")); + duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1); + /* no need to unwind callstack */ + } + + curr_pc = cat->pc_base + 1; + break; + } + + case DUK_EXTRAOP_ENDCATCH: { + duk_activation *act; + duk_catcher *cat; + duk_tval tv_tmp; + duk_tval *tv1; + + DUK_ASSERT(thr->catchstack_top >= 1); + DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1); + + cat = thr->catchstack + thr->catchstack_top - 1; + DUK_ASSERT(!DUK_CAT_HAS_CATCH_ENABLED(cat)); /* cleared before entering catch part */ + + act = thr->callstack + thr->callstack_top - 1; + + if (DUK_CAT_HAS_LEXENV_ACTIVE(cat)) { + duk_hobject *prev_env; + + /* 'with' binding has no catch clause, so can't be here unless a normal try-catch */ + DUK_ASSERT(DUK_CAT_HAS_CATCH_BINDING_ENABLED(cat)); + DUK_ASSERT(act->lex_env != NULL); + + DUK_DDD(DUK_DDDPRINT("ENDCATCH: popping catcher part lexical environment")); + + prev_env = act->lex_env; + DUK_ASSERT(prev_env != NULL); + act->lex_env = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, prev_env); + DUK_CAT_CLEAR_LEXENV_ACTIVE(cat); + DUK_HOBJECT_DECREF(thr, prev_env); /* side effects */ + } + + if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) { + DUK_DDD(DUK_DDDPRINT("ENDCATCH: finally part is active, jump through 2nd jump slot with 'normal continuation'")); + + tv1 = thr->valstack + cat->idx_base; + DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1); + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + tv1 = NULL; + + tv1 = thr->valstack + cat->idx_base + 1; + DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top); + DUK_TVAL_SET_TVAL(&tv_tmp, tv1); + DUK_TVAL_SET_NUMBER(tv1, (duk_double_t) DUK_LJ_TYPE_NORMAL); /* XXX: set int */ + DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + tv1 = NULL; + + DUK_CAT_CLEAR_FINALLY_ENABLED(cat); + } else { + DUK_DDD(DUK_DDDPRINT("ENDCATCH: no finally part, dismantle catcher, jump through 2nd jump slot (to end of statement)")); + duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1); + /* no need to unwind callstack */ + } + + curr_pc = cat->pc_base + 1; + break; + } + + case DUK_EXTRAOP_ENDFIN: { + duk_context *ctx = (duk_context *) thr; + duk_catcher *cat; + duk_tval *tv1; + duk_small_uint_fast_t cont_type; + + DUK_ASSERT(thr->catchstack_top >= 1); + DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1); + + cat = thr->catchstack + thr->catchstack_top - 1; + + /* CATCH flag may be enabled or disabled here; it may be enabled if + * the statement has a catch block but the try block does not throw + * an error. + */ + DUK_ASSERT(!DUK_CAT_HAS_FINALLY_ENABLED(cat)); /* cleared before entering finally */ + /* XXX: assert idx_base */ + + DUK_DDD(DUK_DDDPRINT("ENDFIN: completion value=%!T, type=%!T", + (duk_tval *) (thr->valstack + cat->idx_base + 0), + (duk_tval *) (thr->valstack + cat->idx_base + 1))); + + tv1 = thr->valstack + cat->idx_base + 1; /* type */ + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1)); + cont_type = (duk_small_uint_fast_t) DUK_TVAL_GET_NUMBER(tv1); + + if (cont_type == DUK_LJ_TYPE_NORMAL) { + DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with 'normal' (non-abrupt) completion -> " + "dismantle catcher, resume execution after ENDFIN")); + duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1); + /* no need to unwind callstack */ + } else { + DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with abrupt completion, lj_type=%ld -> " + "dismantle catcher, re-throw error", + (long) cont_type)); + + duk_push_tval(ctx, thr->valstack + cat->idx_base); + + /* XXX: assert lj type valid */ + duk_err_setup_heap_ljstate(thr, (duk_small_int_t) cont_type); + + DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* always in executor */ + DUK__SYNC_AND_NULL_CURR_PC(); + duk_err_longjmp(thr); + DUK_UNREACHABLE(); + } + + /* continue execution after ENDFIN */ + break; + } + + case DUK_EXTRAOP_THROW: { + duk_context *ctx = (duk_context *) thr; + duk_uint_fast_t bc = DUK_DEC_BC(ins); + + /* Note: errors are augmented when they are created, not + * when they are thrown. So, don't augment here, it would + * break re-throwing for instance. + */ + + /* Sync so that augmentation sees up-to-date activations, NULL + * thr->ptr_curr_pc so that it's not used if side effects occur + * in augmentation or longjmp handling. + */ + DUK__SYNC_AND_NULL_CURR_PC(); + + duk_dup(ctx, (duk_idx_t) bc); + DUK_DDD(DUK_DDDPRINT("THROW ERROR (BYTECODE): %!dT (before throw augment)", + (duk_tval *) duk_get_tval(ctx, -1))); +#if defined(DUK_USE_AUGMENT_ERROR_THROW) + duk_err_augment_error_throw(thr); + DUK_DDD(DUK_DDDPRINT("THROW ERROR (BYTECODE): %!dT (after throw augment)", + (duk_tval *) duk_get_tval(ctx, -1))); +#endif + + duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW); + + DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* always in executor */ + duk_err_longjmp(thr); + DUK_UNREACHABLE(); + break; + } + + case DUK_EXTRAOP_INVLHS: { + DUK_ERROR(thr, DUK_ERR_REFERENCE_ERROR, "invalid lvalue"); + + DUK_UNREACHABLE(); + break; + } + + case DUK_EXTRAOP_UNM: + case DUK_EXTRAOP_UNP: { + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk__vm_arith_unary_op(thr, DUK__REGP(bc), bc, extraop); + break; + } + + case DUK_EXTRAOP_DEBUGGER: { + /* Opcode only emitted by compiler when debugger + * support is enabled. Ignore it silently without + * debugger support, in case it has been loaded + * from precompiled bytecode. + */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) + DUK_D(DUK_DPRINT("DEBUGGER statement encountered, halt execution")); + if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) { + DUK_HEAP_SET_PAUSED(thr->heap); + DUK__SYNC_CURR_PC(); + goto restart_execution; + } +#else + DUK_D(DUK_DPRINT("DEBUGGER statement ignored, no debugger support")); +#endif + break; + } + + case DUK_EXTRAOP_BREAK: { + duk_context *ctx = (duk_context *) thr; + duk_uint_fast_t bc = DUK_DEC_BC(ins); + + /* always the "slow break" variant (longjmp'ing); a "fast break" is + * simply an DUK_OP_JUMP. + */ + + DUK_DDD(DUK_DDDPRINT("BREAK: %ld", (long) bc)); + + duk_push_uint(ctx, (duk_uint_t) bc); + duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_BREAK); + + DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* always in executor */ + DUK__SYNC_AND_NULL_CURR_PC(); + duk_err_longjmp(thr); + DUK_UNREACHABLE(); + break; + } + + case DUK_EXTRAOP_CONTINUE: { + duk_context *ctx = (duk_context *) thr; + duk_uint_fast_t bc = DUK_DEC_BC(ins); + + /* always the "slow continue" variant (longjmp'ing); a "fast continue" is + * simply an DUK_OP_JUMP. + */ + + DUK_DDD(DUK_DDDPRINT("CONTINUE: %ld", (long) bc)); + + duk_push_uint(ctx, (duk_uint_t) bc); + duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_CONTINUE); + + DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* always in executor */ + DUK__SYNC_AND_NULL_CURR_PC(); + duk_err_longjmp(thr); + DUK_UNREACHABLE(); + break; + } + + case DUK_EXTRAOP_BNOT: { + duk_uint_fast_t bc = DUK_DEC_BC(ins); + + duk__vm_bitwise_not(thr, DUK__REGP(bc), bc); + break; + } + + case DUK_EXTRAOP_LNOT: { + duk_uint_fast_t bc = DUK_DEC_BC(ins); + duk_tval *tv1; + + tv1 = DUK__REGP(bc); + duk__vm_logical_not(thr, tv1, tv1); + break; + } + + case DUK_EXTRAOP_INSTOF: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_bool_t tmp; + + tmp = duk_js_instanceof(thr, DUK__REGP(b), DUK__REGCONSTP(c)); + duk_push_boolean(ctx, tmp); + duk_replace(ctx, (duk_idx_t) b); + break; + } + + case DUK_EXTRAOP_IN: { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_fast_t b = DUK_DEC_B(ins); + duk_small_uint_fast_t c = DUK_DEC_C(ins); + duk_bool_t tmp; + + tmp = duk_js_in(thr, DUK__REGP(b), DUK__REGCONSTP(c)); + duk_push_boolean(ctx, tmp); + duk_replace(ctx, (duk_idx_t) b); + break; + } + + case DUK_EXTRAOP_LABEL: { + duk_catcher *cat; + duk_uint_fast_t bc = DUK_DEC_BC(ins); + + /* allocate catcher and populate it (should be atomic) */ + + duk_hthread_catchstack_grow(thr); + cat = thr->catchstack + thr->catchstack_top; + thr->catchstack_top++; + + cat->flags = DUK_CAT_TYPE_LABEL | (bc << DUK_CAT_LABEL_SHIFT); + cat->callstack_index = thr->callstack_top - 1; + cat->pc_base = (duk_instr_t *) curr_pc; /* pre-incremented, points to first jump slot */ + cat->idx_base = 0; /* unused for label */ + cat->h_varname = NULL; + + DUK_DDD(DUK_DDDPRINT("LABEL catcher: flags=0x%08lx, callstack_index=%ld, pc_base=%ld, " + "idx_base=%ld, h_varname=%!O, label_id=%ld", + (long) cat->flags, (long) cat->callstack_index, (long) cat->pc_base, + (long) cat->idx_base, (duk_heaphdr *) cat->h_varname, (long) DUK_CAT_GET_LABEL(cat))); + + curr_pc += 2; /* skip jump slots */ + break; + } + + case DUK_EXTRAOP_ENDLABEL: { + duk_catcher *cat; +#if defined(DUK_USE_DDDPRINT) || defined(DUK_USE_ASSERTIONS) + duk_uint_fast_t bc = DUK_DEC_BC(ins); +#endif +#if defined(DUK_USE_DDDPRINT) + DUK_DDD(DUK_DDDPRINT("ENDLABEL %ld", (long) bc)); +#endif + + DUK_ASSERT(thr->catchstack_top >= 1); + + cat = thr->catchstack + thr->catchstack_top - 1; + DUK_UNREF(cat); + DUK_ASSERT(DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_LABEL); + DUK_ASSERT((duk_uint_fast_t) DUK_CAT_GET_LABEL(cat) == bc); + + duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1); + /* no need to unwind callstack */ + break; + } + + default: { + DUK__INTERNAL_ERROR("invalid extra opcode"); + } + + } /* end switch */ + + break; + } + + default: { + /* this should never be possible, because the switch-case is + * comprehensive + */ + DUK__INTERNAL_ERROR("invalid opcode"); + break; + } + + } /* end switch */ + } + DUK_UNREACHABLE(); + +#ifndef DUK_USE_VERBOSE_EXECUTOR_ERRORS + internal_error: + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "internal error in bytecode executor"); +#endif +} + +#undef DUK__INTERNAL_ERROR +#undef DUK__SYNC_CURR_PC +#undef DUK__SYNC_AND_NULL_CURR_PC +#line 1 "duk_js_ops.c" +/* + * Ecmascript specification algorithm and conversion helpers. + * + * These helpers encapsulate the primitive Ecmascript operation + * semantics, and are used by the bytecode executor and the API + * (among other places). Note that some primitives are only + * implemented as part of the API and have no "internal" helper. + * (This is the case when an internal helper would not really be + * useful; e.g. the operation is rare, uses value stack heavily, + * etc.) + * + * The operation arguments depend on what is required to implement + * the operation: + * + * - If an operation is simple and stateless, and has no side + * effects, it won't take an duk_hthread argument and its + * arguments may be duk_tval pointers (which are safe as long + * as no side effects take place). + * + * - If complex coercions are required (e.g. a "ToNumber" coercion) + * or errors may be thrown, the operation takes an duk_hthread + * argument. This also implies that the operation may have + * arbitrary side effects, invalidating any duk_tval pointers. + * + * - For operations with potential side effects, arguments can be + * taken in several ways: + * + * a) as duk_tval pointers, which makes sense if the "common case" + * can be resolved without side effects (e.g. coercion); the + * arguments are pushed to the valstack for coercion if + * necessary + * + * b) as duk_tval values + * + * c) implicitly on value stack top + * + * d) as indices to the value stack + * + * Future work: + * + * - Argument styles may not be the most sensible in every case now. + * + * - In-place coercions might be useful for several operations, if + * in-place coercion is OK for the bytecode executor and the API. + */ + +/* include removed: duk_internal.h */ + +/* + * [[DefaultValue]] (E5 Section 8.12.8) + * + * ==> implemented in the API. + */ + +/* + * ToPrimitive() (E5 Section 9.1) + * + * ==> implemented in the API. + */ + +/* + * ToBoolean() (E5 Section 9.2) + */ + +DUK_INTERNAL duk_bool_t duk_js_toboolean(duk_tval *tv) { + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: + case DUK_TAG_NULL: + return 0; + case DUK_TAG_BOOLEAN: + return DUK_TVAL_GET_BOOLEAN(tv); + case DUK_TAG_STRING: { + duk_hstring *h = DUK_TVAL_GET_STRING(tv); + DUK_ASSERT(h != NULL); + return (DUK_HSTRING_GET_BYTELEN(h) > 0 ? 1 : 0); + } + case DUK_TAG_OBJECT: { + return 1; + } + case DUK_TAG_BUFFER: { + /* mimic semantics for strings */ + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h != NULL); + return (DUK_HBUFFER_GET_SIZE(h) > 0 ? 1 : 0); + } + case DUK_TAG_POINTER: { + void *p = DUK_TVAL_GET_POINTER(tv); + return (p != NULL ? 1 : 0); + } + case DUK_TAG_LIGHTFUNC: { + return 1; + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: + if (DUK_TVAL_GET_FASTINT(tv) != 0) { + return 1; + } else { + return 0; + } +#endif + default: { + /* number */ + duk_double_t d; + int c; + DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv)); + d = DUK_TVAL_GET_DOUBLE(tv); + c = DUK_FPCLASSIFY((double) d); + if (c == DUK_FP_ZERO || c == DUK_FP_NAN) { + return 0; + } else { + return 1; + } + } + } + DUK_UNREACHABLE(); +} + +/* + * ToNumber() (E5 Section 9.3) + * + * Value to convert must be on stack top, and is popped before exit. + * + * See: http://www.cs.indiana.edu/~burger/FP-Printing-PLDI96.pdf + * http://www.cs.indiana.edu/~burger/fp/index.html + * + * Notes on the conversion: + * + * - There are specific requirements on the accuracy of the conversion + * through a "Mathematical Value" (MV), so this conversion is not + * trivial. + * + * - Quick rejects (e.g. based on first char) are difficult because + * the grammar allows leading and trailing white space. + * + * - Quick reject based on string length is difficult even after + * accounting for white space; there may be arbitrarily many + * decimal digits. + * + * - Standard grammar allows decimal values ("123"), hex values + * ("0x123") and infinities + * + * - Unlike source code literals, ToNumber() coerces empty strings + * and strings with only whitespace to zero (not NaN). + */ + +/* E5 Section 9.3.1 */ +DUK_LOCAL duk_double_t duk__tonumber_string_raw(duk_hthread *thr) { + duk_context *ctx = (duk_context *) thr; + duk_small_uint_t s2n_flags; + duk_double_t d; + + /* Quite lenient, e.g. allow empty as zero, but don't allow trailing + * garbage. + */ + s2n_flags = DUK_S2N_FLAG_TRIM_WHITE | + DUK_S2N_FLAG_ALLOW_EXP | + DUK_S2N_FLAG_ALLOW_PLUS | + DUK_S2N_FLAG_ALLOW_MINUS | + DUK_S2N_FLAG_ALLOW_INF | + DUK_S2N_FLAG_ALLOW_FRAC | + DUK_S2N_FLAG_ALLOW_NAKED_FRAC | + DUK_S2N_FLAG_ALLOW_EMPTY_FRAC | + DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO | + DUK_S2N_FLAG_ALLOW_LEADING_ZERO | + DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT; + + duk_numconv_parse(ctx, 10 /*radix*/, s2n_flags); + d = duk_get_number(ctx, -1); + duk_pop(ctx); + + return d; +} + +DUK_INTERNAL duk_double_t duk_js_tonumber(duk_hthread *thr, duk_tval *tv) { + duk_context *ctx = (duk_hthread *) thr; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(tv != NULL); + + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: { + /* return a specific NaN (although not strictly necessary) */ + duk_double_union du; + DUK_DBLUNION_SET_NAN(&du); + DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du)); + return du.d; + } + case DUK_TAG_NULL: { + /* +0.0 */ + return 0.0; + } + case DUK_TAG_BOOLEAN: { + if (DUK_TVAL_IS_BOOLEAN_TRUE(tv)) { + return 1.0; + } + return 0.0; + } + case DUK_TAG_STRING: { + duk_hstring *h = DUK_TVAL_GET_STRING(tv); + duk_push_hstring(ctx, h); + return duk__tonumber_string_raw(thr); + } + case DUK_TAG_OBJECT: { + /* Note: ToPrimitive(object,hint) == [[DefaultValue]](object,hint), + * so use [[DefaultValue]] directly. + */ + duk_double_t d; + duk_push_tval(ctx, tv); + duk_to_defaultvalue(ctx, -1, DUK_HINT_NUMBER); /* 'tv' becomes invalid */ + + /* recursive call for a primitive value (guaranteed not to cause second + * recursion). + */ + d = duk_js_tonumber(thr, duk_require_tval(ctx, -1)); + + duk_pop(ctx); + return d; + } + case DUK_TAG_BUFFER: { + /* Coerce like a string. This makes sense because addition also treats + * buffers like strings. + */ + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + duk_push_hbuffer(ctx, h); + duk_to_string(ctx, -1); /* XXX: expensive, but numconv now expects to see a string */ + return duk__tonumber_string_raw(thr); + } + case DUK_TAG_POINTER: { + /* Coerce like boolean */ + void *p = DUK_TVAL_GET_POINTER(tv); + return (p != NULL ? 1.0 : 0.0); + } + case DUK_TAG_LIGHTFUNC: { + /* +(function(){}) -> NaN */ + return DUK_DOUBLE_NAN; + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: + return (duk_double_t) DUK_TVAL_GET_FASTINT(tv); +#endif + default: { + /* number */ + DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv)); + return DUK_TVAL_GET_DOUBLE(tv); + } + } + + DUK_UNREACHABLE(); +} + +/* + * ToInteger() (E5 Section 9.4) + */ + +/* exposed, used by e.g. duk_bi_date.c */ +DUK_INTERNAL duk_double_t duk_js_tointeger_number(duk_double_t x) { + duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x); + + if (c == DUK_FP_NAN) { + return 0.0; + } else if (c == DUK_FP_ZERO || c == DUK_FP_INFINITE) { + /* XXX: FP_ZERO check can be removed, the else clause handles it + * correctly (preserving sign). + */ + return x; + } else { + duk_small_int_t s = (duk_small_int_t) DUK_SIGNBIT(x); + x = DUK_FLOOR(DUK_FABS(x)); /* truncate towards zero */ + if (s) { + x = -x; + } + return x; + } +} + +DUK_INTERNAL duk_double_t duk_js_tointeger(duk_hthread *thr, duk_tval *tv) { + /* XXX: fastint */ + duk_double_t d = duk_js_tonumber(thr, tv); /* invalidates tv */ + return duk_js_tointeger_number(d); +} + +/* + * ToInt32(), ToUint32(), ToUint16() (E5 Sections 9.5, 9.6, 9.7) + */ + +/* combined algorithm matching E5 Sections 9.5 and 9.6 */ +DUK_LOCAL duk_double_t duk__toint32_touint32_helper(duk_double_t x, duk_bool_t is_toint32) { + duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x); + duk_small_int_t s; + + if (c == DUK_FP_NAN || c == DUK_FP_ZERO || c == DUK_FP_INFINITE) { + return 0.0; + } + + + /* x = sign(x) * floor(abs(x)), i.e. truncate towards zero, keep sign */ + s = (duk_small_int_t) DUK_SIGNBIT(x); + x = DUK_FLOOR(DUK_FABS(x)); + if (s) { + x = -x; + } + + /* NOTE: fmod(x) result sign is same as sign of x, which + * differs from what Javascript wants (see Section 9.6). + */ + + x = DUK_FMOD(x, DUK_DOUBLE_2TO32); /* -> x in ]-2**32, 2**32[ */ + + if (x < 0.0) { + x += DUK_DOUBLE_2TO32; + } + /* -> x in [0, 2**32[ */ + + if (is_toint32) { + if (x >= DUK_DOUBLE_2TO31) { + /* x in [2**31, 2**32[ */ + + x -= DUK_DOUBLE_2TO32; /* -> x in [-2**31,2**31[ */ + } + } + + return x; +} + +DUK_INTERNAL duk_int32_t duk_js_toint32(duk_hthread *thr, duk_tval *tv) { + duk_double_t d; + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv)) { + return DUK_TVAL_GET_FASTINT_I32(tv); + } +#endif + + d = duk_js_tonumber(thr, tv); /* invalidates tv */ + d = duk__toint32_touint32_helper(d, 1); + DUK_ASSERT(DUK_FPCLASSIFY(d) == DUK_FP_ZERO || DUK_FPCLASSIFY(d) == DUK_FP_NORMAL); + DUK_ASSERT(d >= -2147483648.0 && d <= 2147483647.0); /* [-0x80000000,0x7fffffff] */ + DUK_ASSERT(d == ((duk_double_t) ((duk_int32_t) d))); /* whole, won't clip */ + return (duk_int32_t) d; +} + + +DUK_INTERNAL duk_uint32_t duk_js_touint32(duk_hthread *thr, duk_tval *tv) { + duk_double_t d; + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv)) { + return DUK_TVAL_GET_FASTINT_U32(tv); + } +#endif + + d = duk_js_tonumber(thr, tv); /* invalidates tv */ + d = duk__toint32_touint32_helper(d, 0); + DUK_ASSERT(DUK_FPCLASSIFY(d) == DUK_FP_ZERO || DUK_FPCLASSIFY(d) == DUK_FP_NORMAL); + DUK_ASSERT(d >= 0.0 && d <= 4294967295.0); /* [0x00000000, 0xffffffff] */ + DUK_ASSERT(d == ((duk_double_t) ((duk_uint32_t) d))); /* whole, won't clip */ + return (duk_uint32_t) d; + +} + +DUK_INTERNAL duk_uint16_t duk_js_touint16(duk_hthread *thr, duk_tval *tv) { + /* should be a safe way to compute this */ + return (duk_uint16_t) (duk_js_touint32(thr, tv) & 0x0000ffffU); +} + +/* + * ToString() (E5 Section 9.8) + * + * ==> implemented in the API. + */ + +/* + * ToObject() (E5 Section 9.9) + * + * ==> implemented in the API. + */ + +/* + * CheckObjectCoercible() (E5 Section 9.10) + * + * Note: no API equivalent now. + */ + +#if 0 /* unused */ +DUK_INTERNAL void duk_js_checkobjectcoercible(duk_hthread *thr, duk_tval *tv_x) { + duk_small_uint_t tag = DUK_TVAL_GET_TAG(tv_x); + + /* Note: this must match ToObject() behavior */ + + if (tag == DUK_TAG_UNDEFINED || + tag == DUK_TAG_NULL || + tag == DUK_TAG_POINTER || + tag == DUK_TAG_BUFFER) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "not object coercible"); + } +} +#endif + +/* + * IsCallable() (E5 Section 9.11) + * + * XXX: API equivalent is a separate implementation now, and this has + * currently no callers. + */ + +#if 0 /* unused */ +DUK_INTERNAL duk_bool_t duk_js_iscallable(duk_tval *tv_x) { + duk_hobject *obj; + + if (!DUK_TVAL_IS_OBJECT(tv_x)) { + return 0; + } + obj = DUK_TVAL_GET_OBJECT(tv_x); + DUK_ASSERT(obj != NULL); + + return DUK_HOBJECT_IS_CALLABLE(obj); +} +#endif + +/* + * Loose equality, strict equality, and SameValue (E5 Sections 11.9.1, 11.9.4, + * 9.12). These have much in common so they can share some helpers. + * + * Future work notes: + * + * - Current implementation (and spec definition) has recursion; this should + * be fixed if possible. + * + * - String-to-number coercion should be possible without going through the + * value stack (and be more compact) if a shared helper is invoked. + */ + +/* Note that this is the same operation for strict and loose equality: + * - E5 Section 11.9.3, step 1.c (loose) + * - E5 Section 11.9.6, step 4 (strict) + */ + +DUK_LOCAL duk_bool_t duk__js_equals_number(duk_double_t x, duk_double_t y) { +#if defined(DUK_USE_PARANOID_MATH) + /* Straightforward algorithm, makes fewer compiler assumptions. */ + duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x); + duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y); + if (cx == DUK_FP_NAN || cy == DUK_FP_NAN) { + return 0; + } + if (cx == DUK_FP_ZERO && cy == DUK_FP_ZERO) { + return 1; + } + if (x == y) { + return 1; + } + return 0; +#else /* DUK_USE_PARANOID_MATH */ + /* Better equivalent algorithm. If the compiler is compliant, C and + * Ecmascript semantics are identical for this particular comparison. + * In particular, NaNs must never compare equal and zeroes must compare + * equal regardless of sign. Could also use a macro, but this inlines + * already nicely (no difference on gcc, for instance). + */ + if (x == y) { + /* IEEE requires that NaNs compare false */ + DUK_ASSERT(DUK_FPCLASSIFY(x) != DUK_FP_NAN); + DUK_ASSERT(DUK_FPCLASSIFY(y) != DUK_FP_NAN); + return 1; + } else { + /* IEEE requires that zeros compare the same regardless + * of their signed, so if both x and y are zeroes, they + * are caught above. + */ + DUK_ASSERT(!(DUK_FPCLASSIFY(x) == DUK_FP_ZERO && DUK_FPCLASSIFY(y) == DUK_FP_ZERO)); + return 0; + } +#endif /* DUK_USE_PARANOID_MATH */ +} + +DUK_LOCAL duk_bool_t duk__js_samevalue_number(duk_double_t x, duk_double_t y) { +#if defined(DUK_USE_PARANOID_MATH) + duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x); + duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y); + + if (cx == DUK_FP_NAN && cy == DUK_FP_NAN) { + /* SameValue(NaN, NaN) = true, regardless of NaN sign or extra bits */ + return 1; + } + if (cx == DUK_FP_ZERO && cy == DUK_FP_ZERO) { + /* Note: cannot assume that a non-zero return value of signbit() would + * always be the same -- hence cannot (portably) use something like: + * + * signbit(x) == signbit(y) + */ + duk_small_int_t sx = (DUK_SIGNBIT(x) ? 1 : 0); + duk_small_int_t sy = (DUK_SIGNBIT(y) ? 1 : 0); + return (sx == sy); + } + + /* normal comparison; known: + * - both x and y are not NaNs (but one of them can be) + * - both x and y are not zero (but one of them can be) + * - x and y may be denormal or infinite + */ + + return (x == y); +#else /* DUK_USE_PARANOID_MATH */ + duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x); + duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y); + + if (x == y) { + /* IEEE requires that NaNs compare false */ + DUK_ASSERT(DUK_FPCLASSIFY(x) != DUK_FP_NAN); + DUK_ASSERT(DUK_FPCLASSIFY(y) != DUK_FP_NAN); + + /* Using classification has smaller footprint than direct comparison. */ + if (DUK_UNLIKELY(cx == DUK_FP_ZERO && cy == DUK_FP_ZERO)) { + /* Note: cannot assume that a non-zero return value of signbit() would + * always be the same -- hence cannot (portably) use something like: + * + * signbit(x) == signbit(y) + */ + duk_small_int_t sx = (DUK_SIGNBIT(x) ? 1 : 0); + duk_small_int_t sy = (DUK_SIGNBIT(y) ? 1 : 0); + return (sx == sy); + } + return 1; + } else { + /* IEEE requires that zeros compare the same regardless + * of their signed, so if both x and y are zeroes, they + * are caught above. + */ + DUK_ASSERT(!(DUK_FPCLASSIFY(x) == DUK_FP_ZERO && DUK_FPCLASSIFY(y) == DUK_FP_ZERO)); + + /* Difference to non-strict/strict comparison is that NaNs compare + * equal and signed zero signs matter. + */ + if (DUK_UNLIKELY(cx == DUK_FP_NAN && cy == DUK_FP_NAN)) { + /* SameValue(NaN, NaN) = true, regardless of NaN sign or extra bits */ + return 1; + } + return 0; + } +#endif /* DUK_USE_PARANOID_MATH */ +} + +DUK_INTERNAL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags) { + duk_context *ctx = (duk_context *) thr; + duk_tval *tv_tmp; + + /* If flags != 0 (strict or SameValue), thr can be NULL. For loose + * equals comparison it must be != NULL. + */ + DUK_ASSERT(flags != 0 || thr != NULL); + + /* + * Same type? + * + * Note: since number values have no explicit tag in the 8-byte + * representation, need the awkward if + switch. + */ + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) { + if (DUK_TVAL_GET_FASTINT(tv_x) == DUK_TVAL_GET_FASTINT(tv_y)) { + return 1; + } else { + return 0; + } + } + else +#endif + if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) { + /* Catches both doubles and cases where only one argument is a fastint */ + if (DUK_UNLIKELY((flags & DUK_EQUALS_FLAG_SAMEVALUE) != 0)) { + /* SameValue */ + return duk__js_samevalue_number(DUK_TVAL_GET_NUMBER(tv_x), + DUK_TVAL_GET_NUMBER(tv_y)); + } else { + /* equals and strict equals */ + return duk__js_equals_number(DUK_TVAL_GET_NUMBER(tv_x), + DUK_TVAL_GET_NUMBER(tv_y)); + } + } else if (DUK_TVAL_GET_TAG(tv_x) == DUK_TVAL_GET_TAG(tv_y)) { + switch (DUK_TVAL_GET_TAG(tv_x)) { + case DUK_TAG_UNDEFINED: + case DUK_TAG_NULL: { + return 1; + } + case DUK_TAG_BOOLEAN: { + return DUK_TVAL_GET_BOOLEAN(tv_x) == DUK_TVAL_GET_BOOLEAN(tv_y); + } + case DUK_TAG_POINTER: { + return DUK_TVAL_GET_POINTER(tv_x) == DUK_TVAL_GET_POINTER(tv_y); + } + case DUK_TAG_STRING: + case DUK_TAG_OBJECT: { + /* heap pointer comparison suffices */ + return DUK_TVAL_GET_HEAPHDR(tv_x) == DUK_TVAL_GET_HEAPHDR(tv_y); + } + case DUK_TAG_BUFFER: { + if ((flags & (DUK_EQUALS_FLAG_STRICT | DUK_EQUALS_FLAG_SAMEVALUE)) != 0) { + /* heap pointer comparison suffices */ + return DUK_TVAL_GET_HEAPHDR(tv_x) == DUK_TVAL_GET_HEAPHDR(tv_y); + } else { + /* non-strict equality for buffers compares contents */ + duk_hbuffer *h_x = DUK_TVAL_GET_BUFFER(tv_x); + duk_hbuffer *h_y = DUK_TVAL_GET_BUFFER(tv_y); + duk_size_t len_x = DUK_HBUFFER_GET_SIZE(h_x); + duk_size_t len_y = DUK_HBUFFER_GET_SIZE(h_y); + void *buf_x; + void *buf_y; + if (len_x != len_y) { + return 0; + } + buf_x = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_x); + buf_y = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y); + /* if len_x == len_y == 0, buf_x and/or buf_y may + * be NULL, but that's OK. + */ + DUK_ASSERT(len_x == len_y); + DUK_ASSERT(len_x == 0 || buf_x != NULL); + DUK_ASSERT(len_y == 0 || buf_y != NULL); + return (DUK_MEMCMP(buf_x, buf_y, len_x) == 0) ? 1 : 0; + } + } + case DUK_TAG_LIGHTFUNC: { + /* At least 'magic' has a significant impact on function + * identity. + */ + duk_small_uint_t lf_flags_x; + duk_small_uint_t lf_flags_y; + duk_c_function func_x; + duk_c_function func_y; + + DUK_TVAL_GET_LIGHTFUNC(tv_x, func_x, lf_flags_x); + DUK_TVAL_GET_LIGHTFUNC(tv_y, func_y, lf_flags_y); + return ((func_x == func_y) && (lf_flags_x == lf_flags_y)) ? 1 : 0; + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: { + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x)); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_y)); + DUK_UNREACHABLE(); + return 0; + } + } + } + + if ((flags & (DUK_EQUALS_FLAG_STRICT | DUK_EQUALS_FLAG_SAMEVALUE)) != 0) { + return 0; + } + + DUK_ASSERT(flags == 0); /* non-strict equality from here on */ + + /* + * Types are different; various cases for non-strict comparison + * + * Since comparison is symmetric, we use a "swap trick" to reduce + * code size. + */ + + /* Undefined/null are considered equal (e.g. "null == undefined" -> true). */ + if ((DUK_TVAL_IS_UNDEFINED(tv_x) && DUK_TVAL_IS_NULL(tv_y)) || + (DUK_TVAL_IS_NULL(tv_x) && DUK_TVAL_IS_UNDEFINED(tv_y))) { + return 1; + } + + /* Number/string-or-buffer -> coerce string to number (e.g. "'1.5' == 1.5" -> true). */ + if (DUK_TVAL_IS_NUMBER(tv_x) && (DUK_TVAL_IS_STRING(tv_y) || DUK_TVAL_IS_BUFFER(tv_y))) { + /* the next 'if' is guaranteed to match after swap */ + tv_tmp = tv_x; + tv_x = tv_y; + tv_y = tv_tmp; + } + if ((DUK_TVAL_IS_STRING(tv_x) || DUK_TVAL_IS_BUFFER(tv_x)) && DUK_TVAL_IS_NUMBER(tv_y)) { + /* XXX: this is possible without resorting to the value stack */ + duk_double_t d1, d2; + d2 = DUK_TVAL_GET_NUMBER(tv_y); + duk_push_tval(ctx, tv_x); + duk_to_string(ctx, -1); /* buffer values are coerced first to string here */ + duk_to_number(ctx, -1); + d1 = duk_require_number(ctx, -1); + duk_pop(ctx); + return duk__js_equals_number(d1, d2); + } + + /* Buffer/string -> compare contents. */ + if (DUK_TVAL_IS_BUFFER(tv_x) && DUK_TVAL_IS_STRING(tv_y)) { + tv_tmp = tv_x; + tv_x = tv_y; + tv_y = tv_tmp; + } + if (DUK_TVAL_IS_STRING(tv_x) && DUK_TVAL_IS_BUFFER(tv_y)) { + duk_hstring *h_x = DUK_TVAL_GET_STRING(tv_x); + duk_hbuffer *h_y = DUK_TVAL_GET_BUFFER(tv_y); + duk_size_t len_x = DUK_HSTRING_GET_BYTELEN(h_x); + duk_size_t len_y = DUK_HBUFFER_GET_SIZE(h_y); + void *buf_x; + void *buf_y; + if (len_x != len_y) { + return 0; + } + buf_x = (void *) DUK_HSTRING_GET_DATA(h_x); + buf_y = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y); + /* if len_x == len_y == 0, buf_x and/or buf_y may + * be NULL, but that's OK. + */ + DUK_ASSERT(len_x == len_y); + DUK_ASSERT(len_x == 0 || buf_x != NULL); + DUK_ASSERT(len_y == 0 || buf_y != NULL); + return (DUK_MEMCMP(buf_x, buf_y, len_x) == 0) ? 1 : 0; + } + + /* Boolean/any -> coerce boolean to number and try again. If boolean is + * compared to a pointer, the final comparison after coercion now always + * yields false (as pointer vs. number compares to false), but this is + * not special cased. + */ + if (DUK_TVAL_IS_BOOLEAN(tv_x)) { + tv_tmp = tv_x; + tv_x = tv_y; + tv_y = tv_tmp; + } + if (DUK_TVAL_IS_BOOLEAN(tv_y)) { + /* ToNumber(bool) is +1.0 or 0.0. Tagged boolean value is always 0 or 1. */ + duk_bool_t rc; + DUK_ASSERT(DUK_TVAL_GET_BOOLEAN(tv_y) == 0 || DUK_TVAL_GET_BOOLEAN(tv_y) == 1); + duk_push_tval(ctx, tv_x); + duk_push_int(ctx, DUK_TVAL_GET_BOOLEAN(tv_y)); + rc = duk_js_equals_helper(thr, duk_get_tval(ctx, -2), duk_get_tval(ctx, -1), 0 /*flags:nonstrict*/); + duk_pop_2(ctx); + return rc; + } + + /* String-number-buffer/object -> coerce object to primitive (apparently without hint), then try again. */ + if ((DUK_TVAL_IS_STRING(tv_x) || DUK_TVAL_IS_NUMBER(tv_x) || DUK_TVAL_IS_BUFFER(tv_x)) && + DUK_TVAL_IS_OBJECT(tv_y)) { + tv_tmp = tv_x; + tv_x = tv_y; + tv_y = tv_tmp; + } + if (DUK_TVAL_IS_OBJECT(tv_x) && + (DUK_TVAL_IS_STRING(tv_y) || DUK_TVAL_IS_NUMBER(tv_y) || DUK_TVAL_IS_BUFFER(tv_y))) { + duk_bool_t rc; + duk_push_tval(ctx, tv_x); + duk_push_tval(ctx, tv_y); + duk_to_primitive(ctx, -2, DUK_HINT_NONE); /* apparently no hint? */ + rc = duk_js_equals_helper(thr, duk_get_tval(ctx, -2), duk_get_tval(ctx, -1), 0 /*flags:nonstrict*/); + duk_pop_2(ctx); + return rc; + } + + /* Nothing worked -> not equal. */ + return 0; +} + +/* + * Comparisons (x >= y, x > y, x <= y, x < y) + * + * E5 Section 11.8.5: implement 'x < y' and then use negate and eval_left_first + * flags to get the rest. + */ + +/* XXX: this should probably just operate on the stack top, because it + * needs to push stuff on the stack anyway... + */ + +DUK_INTERNAL duk_small_int_t duk_js_data_compare(const duk_uint8_t *buf1, const duk_uint8_t *buf2, duk_size_t len1, duk_size_t len2) { + duk_size_t prefix_len; + duk_small_int_t rc; + + prefix_len = (len1 <= len2 ? len1 : len2); + + /* XXX: this special case can now be removed with DUK_MEMCMP */ + /* memcmp() should return zero (equal) for zero length, but avoid + * it because there are some platform specific bugs. Don't use + * strncmp() because it stops comparing at a NUL. + */ + + if (prefix_len == 0) { + rc = 0; + } else { + rc = DUK_MEMCMP((const char *) buf1, + (const char *) buf2, + prefix_len); + } + + if (rc < 0) { + return -1; + } else if (rc > 0) { + return 1; + } + + /* prefix matches, lengths matter now */ + if (len1 < len2) { + /* e.g. "x" < "xx" */ + return -1; + } else if (len1 > len2) { + return 1; + } + + return 0; +} + +DUK_INTERNAL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring *h2) { + /* + * String comparison (E5 Section 11.8.5, step 4), which + * needs to compare codepoint by codepoint. + * + * However, UTF-8 allows us to use strcmp directly: the shared + * prefix will be encoded identically (UTF-8 has unique encoding) + * and the first differing character can be compared with a simple + * unsigned byte comparison (which strcmp does). + * + * This will not work properly for non-xutf-8 strings, but this + * is not an issue for compliance. + */ + + DUK_ASSERT(h1 != NULL); + DUK_ASSERT(h2 != NULL); + + return duk_js_data_compare((const duk_uint8_t *) DUK_HSTRING_GET_DATA(h1), + (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h2), + (duk_size_t) DUK_HSTRING_GET_BYTELEN(h1), + (duk_size_t) DUK_HSTRING_GET_BYTELEN(h2)); +} + +#if 0 /* unused */ +DUK_INTERNAL duk_small_int_t duk_js_buffer_compare(duk_heap *heap, duk_hbuffer *h1, duk_hbuffer *h2) { + /* Similar to String comparison. */ + + DUK_ASSERT(h1 != NULL); + DUK_ASSERT(h2 != NULL); + DUK_UNREF(heap); + + return duk_js_data_compare((const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(heap, h1), + (const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(heap, h2), + (duk_size_t) DUK_HBUFFER_GET_SIZE(h1), + (duk_size_t) DUK_HBUFFER_GET_SIZE(h2)); +} +#endif + +DUK_INTERNAL duk_bool_t duk_js_compare_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags) { + duk_context *ctx = (duk_context *) thr; + duk_double_t d1, d2; + duk_small_int_t c1, c2; + duk_small_int_t s1, s2; + duk_small_int_t rc; + duk_bool_t retval; + + /* Fast path for fastints */ +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) { + duk_int64_t v1 = DUK_TVAL_GET_FASTINT(tv_x); + duk_int64_t v2 = DUK_TVAL_GET_FASTINT(tv_y); + if (v1 < v2) { + /* 'lt is true' */ + retval = 1; + } else { + retval = 0; + } + if (flags & DUK_COMPARE_FLAG_NEGATE) { + retval ^= 1; + } + return retval; + } +#endif /* DUK_USE_FASTINT */ + + /* Fast path for numbers (one of which may be a fastint) */ +#if 1 /* XXX: make fast paths optional for size minimization? */ + if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) { + d1 = DUK_TVAL_GET_NUMBER(tv_x); + d2 = DUK_TVAL_GET_NUMBER(tv_y); + c1 = DUK_FPCLASSIFY(d1); + c2 = DUK_FPCLASSIFY(d2); + + if (c1 == DUK_FP_NORMAL && c2 == DUK_FP_NORMAL) { + /* XXX: this is a very narrow check, and doesn't cover + * zeroes, subnormals, infinities, which compare normally. + */ + + if (d1 < d2) { + /* 'lt is true' */ + retval = 1; + } else { + retval = 0; + } + if (flags & DUK_COMPARE_FLAG_NEGATE) { + retval ^= 1; + } + return retval; + } + } +#endif + + /* Slow path */ + + duk_push_tval(ctx, tv_x); + duk_push_tval(ctx, tv_y); + + if (flags & DUK_COMPARE_FLAG_EVAL_LEFT_FIRST) { + duk_to_primitive(ctx, -2, DUK_HINT_NUMBER); + duk_to_primitive(ctx, -1, DUK_HINT_NUMBER); + } else { + duk_to_primitive(ctx, -1, DUK_HINT_NUMBER); + duk_to_primitive(ctx, -2, DUK_HINT_NUMBER); + } + + /* Note: reuse variables */ + tv_x = duk_get_tval(ctx, -2); + tv_y = duk_get_tval(ctx, -1); + + if (DUK_TVAL_IS_STRING(tv_x) && DUK_TVAL_IS_STRING(tv_y)) { + duk_hstring *h1 = DUK_TVAL_GET_STRING(tv_x); + duk_hstring *h2 = DUK_TVAL_GET_STRING(tv_y); + DUK_ASSERT(h1 != NULL); + DUK_ASSERT(h2 != NULL); + + rc = duk_js_string_compare(h1, h2); + if (rc < 0) { + goto lt_true; + } else { + goto lt_false; + } + } else { + /* Ordering should not matter (E5 Section 11.8.5, step 3.a) but + * preserve it just in case. + */ + + if (flags & DUK_COMPARE_FLAG_EVAL_LEFT_FIRST) { + d1 = duk_to_number(ctx, -2); + d2 = duk_to_number(ctx, -1); + } else { + d2 = duk_to_number(ctx, -1); + d1 = duk_to_number(ctx, -2); + } + + c1 = (duk_small_int_t) DUK_FPCLASSIFY(d1); + s1 = (duk_small_int_t) DUK_SIGNBIT(d1); + c2 = (duk_small_int_t) DUK_FPCLASSIFY(d2); + s2 = (duk_small_int_t) DUK_SIGNBIT(d2); + + if (c1 == DUK_FP_NAN || c2 == DUK_FP_NAN) { + goto lt_undefined; + } + + if (c1 == DUK_FP_ZERO && c2 == DUK_FP_ZERO) { + /* For all combinations: +0 < +0, +0 < -0, -0 < +0, -0 < -0, + * steps e, f, and g. + */ + goto lt_false; + } + + if (d1 == d2) { + goto lt_false; + } + + if (c1 == DUK_FP_INFINITE && s1 == 0) { + /* x == +Infinity */ + goto lt_false; + } + + if (c2 == DUK_FP_INFINITE && s2 == 0) { + /* y == +Infinity */ + goto lt_true; + } + + if (c2 == DUK_FP_INFINITE && s2 != 0) { + /* y == -Infinity */ + goto lt_false; + } + + if (c1 == DUK_FP_INFINITE && s1 != 0) { + /* x == -Infinity */ + goto lt_true; + } + + if (d1 < d2) { + goto lt_true; + } + + goto lt_false; + } + + lt_undefined: + /* Note: undefined from Section 11.8.5 always results in false + * return (see e.g. Section 11.8.3) - hence special treatment here. + */ + retval = 0; + goto cleanup; + + lt_true: + if (flags & DUK_COMPARE_FLAG_NEGATE) { + retval = 0; + goto cleanup; + } else { + retval = 1; + goto cleanup; + } + /* never here */ + + lt_false: + if (flags & DUK_COMPARE_FLAG_NEGATE) { + retval = 1; + goto cleanup; + } else { + retval = 0; + goto cleanup; + } + /* never here */ + + cleanup: + duk_pop_2(ctx); + return retval; +} + +/* + * instanceof + */ + +/* + * E5 Section 11.8.6 describes the main algorithm, which uses + * [[HasInstance]]. [[HasInstance]] is defined for only + * function objects: + * + * - Normal functions: + * E5 Section 15.3.5.3 + * - Functions established with Function.prototype.bind(): + * E5 Section 15.3.4.5.3 + * + * For other objects, a TypeError is thrown. + * + * Limited Proxy support: don't support 'getPrototypeOf' trap but + * continue lookup in Proxy target if the value is a Proxy. + */ + +DUK_INTERNAL duk_bool_t duk_js_instanceof(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y) { + duk_context *ctx = (duk_context *) thr; + duk_hobject *func; + duk_hobject *val; + duk_hobject *proto; + duk_uint_t sanity; + + /* + * Get the values onto the stack first. It would be possible to cover + * some normal cases without resorting to the value stack. + * + * The right hand side could be a light function (as they generally + * behave like objects). Light functions never have a 'prototype' + * property so E5.1 Section 15.3.5.3 step 3 always throws a TypeError. + * Using duk_require_hobject() is thus correct (except for error msg). + */ + + duk_push_tval(ctx, tv_x); + duk_push_tval(ctx, tv_y); + func = duk_require_hobject(ctx, -1); + + /* + * For bound objects, [[HasInstance]] just calls the target function + * [[HasInstance]]. If that is again a bound object, repeat until + * we find a non-bound Function object. + */ + + /* XXX: this bound function resolution also happens elsewhere, + * move into a shared helper. + */ + + sanity = DUK_HOBJECT_BOUND_CHAIN_SANITY; + do { + /* check func supports [[HasInstance]] (this is checked for every function + * in the bound chain, including the final one) + */ + + if (!DUK_HOBJECT_IS_CALLABLE(func)) { + /* + * Note: of native Ecmascript objects, only Function instances + * have a [[HasInstance]] internal property. Custom objects might + * also have it, but not in current implementation. + * + * XXX: add a separate flag, DUK_HOBJECT_FLAG_ALLOW_INSTANCEOF? + */ + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid instanceof rval"); + } + + if (!DUK_HOBJECT_HAS_BOUND(func)) { + break; + } + + /* [ ... lval rval ] */ + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET); /* -> [ ... lval rval new_rval ] */ + duk_replace(ctx, -1); /* -> [ ... lval new_rval ] */ + func = duk_require_hobject(ctx, -1); + + /* func support for [[HasInstance]] checked in the beginning of the loop */ + } while (--sanity > 0); + + if (sanity == 0) { + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_BOUND_CHAIN_LIMIT); + } + + /* + * 'func' is now a non-bound object which supports [[HasInstance]] + * (which here just means DUK_HOBJECT_FLAG_CALLABLE). Move on + * to execute E5 Section 15.3.5.3. + */ + + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func)); + DUK_ASSERT(DUK_HOBJECT_IS_CALLABLE(func)); + + /* [ ... lval rval(func) ] */ + + /* Handle lightfuncs through object coercion for now. */ + /* XXX: direct implementation */ + val = duk_get_hobject_or_lfunc_coerce(ctx, -2); + if (!val) { + goto pop_and_false; + } + + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_PROTOTYPE); /* -> [ ... lval rval rval.prototype ] */ + proto = duk_require_hobject(ctx, -1); + duk_pop(ctx); /* -> [ ... lval rval ] */ + + DUK_ASSERT(val != NULL); + +#if defined(DUK_USE_ES6_PROXY) + val = duk_hobject_resolve_proxy_target(thr, val); + DUK_ASSERT(val != NULL); +#endif + + sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY; + do { + /* + * Note: prototype chain is followed BEFORE first comparison. This + * means that the instanceof lval is never itself compared to the + * rval.prototype property. This is apparently intentional, see E5 + * Section 15.3.5.3, step 4.a. + * + * Also note: + * + * js> (function() {}) instanceof Function + * true + * js> Function instanceof Function + * true + * + * For the latter, h_proto will be Function.prototype, which is the + * built-in Function prototype. Because Function.[[Prototype]] is + * also the built-in Function prototype, the result is true. + */ + + DUK_ASSERT(val != NULL); + val = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, val); + + if (!val) { + goto pop_and_false; + } + + DUK_ASSERT(val != NULL); +#if defined(DUK_USE_ES6_PROXY) + val = duk_hobject_resolve_proxy_target(thr, val); +#endif + + if (val == proto) { + goto pop_and_true; + } + + /* follow prototype chain */ + } while (--sanity > 0); + + if (sanity == 0) { + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT); + } + DUK_UNREACHABLE(); + + pop_and_false: + duk_pop_2(ctx); + return 0; + + pop_and_true: + duk_pop_2(ctx); + return 1; +} + +/* + * in + */ + +/* + * E5 Sections 11.8.7, 8.12.6. + * + * Basically just a property existence check using [[HasProperty]]. + */ + +DUK_INTERNAL duk_bool_t duk_js_in(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y) { + duk_context *ctx = (duk_context *) thr; + duk_bool_t retval; + + /* + * Get the values onto the stack first. It would be possible to cover + * some normal cases without resorting to the value stack (e.g. if + * lval is already a string). + */ + + /* XXX: The ES5/5.1/6 specifications require that the key in 'key in obj' + * must be string coerced before the internal HasProperty() algorithm is + * invoked. A fast path skipping coercion could be safely implemented for + * numbers (as number-to-string coercion has no side effects). For ES6 + * proxy behavior, the trap 'key' argument must be in a string coerced + * form (which is a shame). + */ + + /* TypeError if rval is not an object (or lightfunc which should behave + * like a Function instance). + */ + duk_push_tval(ctx, tv_x); + duk_push_tval(ctx, tv_y); + duk_require_type_mask(ctx, -1, DUK_TYPE_MASK_OBJECT | DUK_TYPE_MASK_LIGHTFUNC); + duk_to_string(ctx, -2); /* coerce lval with ToString() */ + + retval = duk_hobject_hasprop(thr, duk_get_tval(ctx, -1), duk_get_tval(ctx, -2)); + + duk_pop_2(ctx); + return retval; +} + +/* + * typeof + * + * E5 Section 11.4.3. + * + * Very straightforward. The only question is what to return for our + * non-standard tag / object types. + * + * There is an unfortunate string constant define naming problem with + * typeof return values for e.g. "Object" and "object"; careful with + * the built-in string defines. The LC_XXX defines are used for the + * lowercase variants now. + */ + +DUK_INTERNAL duk_hstring *duk_js_typeof(duk_hthread *thr, duk_tval *tv_x) { + duk_small_int_t stridx = 0; + + switch (DUK_TVAL_GET_TAG(tv_x)) { + case DUK_TAG_UNDEFINED: { + stridx = DUK_STRIDX_LC_UNDEFINED; + break; + } + case DUK_TAG_NULL: { + /* Note: not a typo, "object" is returned for a null value */ + stridx = DUK_STRIDX_LC_OBJECT; + break; + } + case DUK_TAG_BOOLEAN: { + stridx = DUK_STRIDX_LC_BOOLEAN; + break; + } + case DUK_TAG_POINTER: { + /* implementation specific */ + stridx = DUK_STRIDX_LC_POINTER; + break; + } + case DUK_TAG_STRING: { + stridx = DUK_STRIDX_LC_STRING; + break; + } + case DUK_TAG_OBJECT: { + duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv_x); + DUK_ASSERT(obj != NULL); + if (DUK_HOBJECT_IS_CALLABLE(obj)) { + stridx = DUK_STRIDX_LC_FUNCTION; + } else { + stridx = DUK_STRIDX_LC_OBJECT; + } + break; + } + case DUK_TAG_BUFFER: { + /* implementation specific */ + stridx = DUK_STRIDX_LC_BUFFER; + break; + } + case DUK_TAG_LIGHTFUNC: { + stridx = DUK_STRIDX_LC_FUNCTION; + break; + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: +#endif + default: { + /* number */ + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x)); + stridx = DUK_STRIDX_LC_NUMBER; + break; + } + } + + DUK_ASSERT(stridx >= 0 && stridx < DUK_HEAP_NUM_STRINGS); + return DUK_HTHREAD_GET_STRING(thr, stridx); +} + +/* + * Array index and length + * + * Array index: E5 Section 15.4 + * Array length: E5 Section 15.4.5.1 steps 3.c - 3.d (array length write) + * + * The DUK_HSTRING_GET_ARRIDX_SLOW() and DUK_HSTRING_GET_ARRIDX_FAST() macros + * call duk_js_to_arrayindex_string_helper(). + */ + +DUK_INTERNAL duk_small_int_t duk_js_to_arrayindex_raw_string(const duk_uint8_t *str, duk_uint32_t blen, duk_uarridx_t *out_idx) { + duk_uarridx_t res, new_res; + + if (blen == 0 || blen > 10) { + goto parse_fail; + } + if (str[0] == (duk_uint8_t) '0' && blen > 1) { + goto parse_fail; + } + + /* Accept 32-bit decimal integers, no leading zeroes, signs, etc. + * Leading zeroes are not accepted (zero index "0" is an exception + * handled above). + */ + + res = 0; + while (blen-- > 0) { + duk_uint8_t c = *str++; + if (c >= (duk_uint8_t) '0' && c <= (duk_uint8_t) '9') { + new_res = res * 10 + (duk_uint32_t) (c - (duk_uint8_t) '0'); + if (new_res < res) { + /* overflow, more than 32 bits -> not an array index */ + goto parse_fail; + } + res = new_res; + } else { + goto parse_fail; + } + } + + *out_idx = res; + return 1; + + parse_fail: + *out_idx = DUK_HSTRING_NO_ARRAY_INDEX; + return 0; +} + +/* Called by duk_hstring.h macros */ +DUK_INTERNAL duk_uarridx_t duk_js_to_arrayindex_string_helper(duk_hstring *h) { + duk_uarridx_t res; + duk_small_int_t rc; + + if (!DUK_HSTRING_HAS_ARRIDX(h)) { + return DUK_HSTRING_NO_ARRAY_INDEX; + } + + rc = duk_js_to_arrayindex_raw_string(DUK_HSTRING_GET_DATA(h), + DUK_HSTRING_GET_BYTELEN(h), + &res); + DUK_UNREF(rc); + DUK_ASSERT(rc != 0); + return res; +} +#line 1 "duk_js_var.c" +/* + * Identifier access and function closure handling. + * + * Provides the primitives for slow path identifier accesses: GETVAR, + * PUTVAR, DELVAR, etc. The fast path, direct register accesses, should + * be used for most identifier accesses. Consequently, these slow path + * primitives should be optimized for maximum compactness. + * + * Ecmascript environment records (declarative and object) are represented + * as internal objects with control keys. Environment records have a + * parent record ("outer environment reference") which is represented by + * the implicit prototype for technical reasons (in other words, it is a + * convenient field). The prototype chain is not followed in the ordinary + * sense for variable lookups. + * + * See identifier-handling.rst for more details on the identifier algorithms + * and the internal representation. See function-objects.rst for details on + * what function templates and instances are expected to look like. + * + * Care must be taken to avoid duk_tval pointer invalidation caused by + * e.g. value stack or object resizing. + * + * TODO: properties for function instances could be initialized much more + * efficiently by creating a property allocation for a certain size and + * filling in keys and values directly (and INCREFing both with "bulk incref" + * primitives. + * + * XXX: duk_hobject_getprop() and duk_hobject_putprop() calls are a bit + * awkward (especially because they follow the prototype chain); rework + * if "raw" own property helpers are added. + */ + +/* include removed: duk_internal.h */ + +/* + * Local result type for duk__get_identifier_reference() lookup. + */ + +typedef struct { + duk_hobject *holder; /* for object-bound identifiers */ + duk_tval *value; /* for register-bound and declarative env identifiers */ + duk_int_t attrs; /* property attributes for identifier (relevant if value != NULL) */ + duk_tval *this_binding; + duk_hobject *env; +} duk__id_lookup_result; + +/* + * Create a new function object based on a "template function" which contains + * compiled bytecode, constants, etc, but lacks a lexical environment. + * + * Ecmascript requires that each created closure is a separate object, with + * its own set of editable properties. However, structured property values + * (such as the formal arguments list and the variable map) are shared. + * Also the bytecode, constants, and inner functions are shared. + * + * See E5 Section 13.2 for detailed requirements on the function objects; + * there are no similar requirements for function "templates" which are an + * implementation dependent internal feature. Also see function-objects.rst + * for a discussion on the function instance properties provided by this + * implementation. + * + * Notes: + * + * * Order of internal properties should match frequency of use, since the + * properties will be linearly scanned on lookup (functions usually don't + * have enough properties to warrant a hash part). + * + * * The created closure is independent of its template; they do share the + * same 'data' buffer object, but the template object itself can be freed + * even if the closure object remains reachable. + */ + +DUK_LOCAL void duk__inc_data_inner_refcounts(duk_hthread *thr, duk_hcompiledfunction *f) { + duk_tval *tv, *tv_end; + duk_hobject **funcs, **funcs_end; + + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, f) != NULL); /* compiled functions must be created 'atomically' */ + DUK_UNREF(thr); + + tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, f); + tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, f); + while (tv < tv_end) { + DUK_TVAL_INCREF(thr, tv); + tv++; + } + + funcs = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, f); + funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, f); + while (funcs < funcs_end) { + DUK_HEAPHDR_INCREF(thr, (duk_heaphdr *) *funcs); + funcs++; + } +} + +/* Push a new closure on the stack. + * + * Note: if fun_temp has NEWENV, i.e. a new lexical and variable declaration + * is created when the function is called, only outer_lex_env matters + * (outer_var_env is ignored and may or may not be same as outer_lex_env). + */ + +DUK_LOCAL const duk_uint16_t duk__closure_copy_proplist[] = { + /* order: most frequent to least frequent */ + DUK_STRIDX_INT_VARMAP, + DUK_STRIDX_INT_FORMALS, + DUK_STRIDX_NAME, + DUK_STRIDX_INT_PC2LINE, + DUK_STRIDX_FILE_NAME, + DUK_STRIDX_INT_SOURCE +}; + +DUK_INTERNAL +void duk_js_push_closure(duk_hthread *thr, + duk_hcompiledfunction *fun_temp, + duk_hobject *outer_var_env, + duk_hobject *outer_lex_env) { + duk_context *ctx = (duk_context *) thr; + duk_hcompiledfunction *fun_clos; + duk_small_uint_t i; + duk_uint_t len_value; + + DUK_ASSERT(fun_temp != NULL); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_temp) != NULL); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_temp) != NULL); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_temp) != NULL); + DUK_ASSERT(outer_var_env != NULL); + DUK_ASSERT(outer_lex_env != NULL); + + duk_push_compiledfunction(ctx); + duk_push_hobject(ctx, &fun_temp->obj); /* -> [ ... closure template ] */ + + fun_clos = (duk_hcompiledfunction *) duk_get_hcompiledfunction(ctx, -2); + DUK_ASSERT(fun_clos != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) fun_clos)); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_clos) == NULL); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_clos) == NULL); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_clos) == NULL); + + DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, fun_clos, DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_temp)); + DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, fun_clos, DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_temp)); + DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, fun_clos, DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_temp)); + + /* Note: all references inside 'data' need to get their refcounts + * upped too. This is the case because refcounts are decreased + * through every function referencing 'data' independently. + */ + + DUK_HBUFFER_INCREF(thr, DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_clos)); + duk__inc_data_inner_refcounts(thr, fun_temp); + + fun_clos->nregs = fun_temp->nregs; + fun_clos->nargs = fun_temp->nargs; +#if defined(DUK_USE_DEBUGGER_SUPPORT) + fun_clos->start_line = fun_temp->start_line; + fun_clos->end_line = fun_temp->end_line; +#endif + + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_clos) != NULL); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_clos) != NULL); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_clos) != NULL); + + /* XXX: could also copy from template, but there's no way to have any + * other value here now (used code has no access to the template). + */ + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, &fun_clos->obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]); + + /* + * Init/assert flags, copying them where appropriate. Some flags + * (like NEWENV) are processed separately below. + */ + + /* XXX: copy flags using a mask */ + + DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(&fun_clos->obj)); + DUK_HOBJECT_SET_CONSTRUCTABLE(&fun_clos->obj); /* Note: not set in template (has no "prototype") */ + DUK_ASSERT(DUK_HOBJECT_HAS_CONSTRUCTABLE(&fun_clos->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(&fun_clos->obj)); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(&fun_clos->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(&fun_clos->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(&fun_clos->obj)); + /* DUK_HOBJECT_FLAG_ARRAY_PART: don't care */ + if (DUK_HOBJECT_HAS_STRICT(&fun_temp->obj)) { + DUK_HOBJECT_SET_STRICT(&fun_clos->obj); + } + if (DUK_HOBJECT_HAS_NOTAIL(&fun_temp->obj)) { + DUK_HOBJECT_SET_NOTAIL(&fun_clos->obj); + } + /* DUK_HOBJECT_FLAG_NEWENV: handled below */ + if (DUK_HOBJECT_HAS_NAMEBINDING(&fun_temp->obj)) { + /* Although NAMEBINDING is not directly needed for using + * function instances, it's needed by bytecode dump/load + * so copy it too. + */ + DUK_HOBJECT_SET_NAMEBINDING(&fun_clos->obj); + } + if (DUK_HOBJECT_HAS_CREATEARGS(&fun_temp->obj)) { + DUK_HOBJECT_SET_CREATEARGS(&fun_clos->obj); + } + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(&fun_clos->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(&fun_clos->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(&fun_clos->obj)); + + /* + * Setup environment record properties based on the template and + * its flags. + * + * If DUK_HOBJECT_HAS_NEWENV(fun_temp) is true, the environment + * records represent identifiers "outside" the function; the + * "inner" environment records are created on demand. Otherwise, + * the environment records are those that will be directly used + * (e.g. for declarations). + * + * _Lexenv is always set; _Varenv defaults to _Lexenv if missing, + * so _Varenv is only set if _Lexenv != _Varenv. + * + * This is relatively complex, see doc/identifier-handling.rst. + */ + + if (DUK_HOBJECT_HAS_NEWENV(&fun_temp->obj)) { + DUK_HOBJECT_SET_NEWENV(&fun_clos->obj); + + if (DUK_HOBJECT_HAS_NAMEBINDING(&fun_temp->obj)) { + duk_hobject *proto; + + /* + * Named function expression, name needs to be bound + * in an intermediate environment record. The "outer" + * lexical/variable environment will thus be: + * + * a) { funcname: <func>, __prototype: outer_lex_env } + * b) { funcname: <func>, __prototype: <globalenv> } (if outer_lex_env missing) + */ + + DUK_ASSERT(duk_has_prop_stridx(ctx, -1, DUK_STRIDX_NAME)); /* required if NAMEBINDING set */ + + if (outer_lex_env) { + proto = outer_lex_env; + } else { + proto = thr->builtins[DUK_BIDX_GLOBAL_ENV]; + } + + /* -> [ ... closure template env ] */ + (void) duk_push_object_helper_proto(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV), + proto); + + /* It's important that duk_xdef_prop() is a 'raw define' so that any + * properties in an ancestor are never an issue (they should never be + * e.g. non-writable, but just in case). + */ + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME); /* -> [ ... closure template env funcname ] */ + duk_dup(ctx, -4); /* -> [ ... closure template env funcname closure ] */ + duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_NONE); /* -> [ ... closure template env ] */ + /* env[funcname] = closure */ + + /* [ ... closure template env ] */ + + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC); + /* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it + * will be ignored anyway + */ + + /* [ ... closure template ] */ + } else { + /* + * Other cases (function declaration, anonymous function expression, + * strict direct eval code). The "outer" environment will be whatever + * the caller gave us. + */ + + duk_push_hobject(ctx, outer_lex_env); /* -> [ ... closure template env ] */ + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC); + /* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it + * will be ignored anyway + */ + + /* [ ... closure template ] */ + } + } else { + /* + * Function gets no new environment when called. This is the + * case for global code, indirect eval code, and non-strict + * direct eval code. There is no direct correspondence to the + * E5 specification, as global/eval code is not exposed as a + * function. + */ + + DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(&fun_temp->obj)); + + duk_push_hobject(ctx, outer_lex_env); /* -> [ ... closure template env ] */ + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC); + + if (outer_var_env != outer_lex_env) { + duk_push_hobject(ctx, outer_var_env); /* -> [ ... closure template env ] */ + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_VARENV, DUK_PROPDESC_FLAGS_WC); + } + } +#ifdef DUK_USE_DDDPRINT + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_INT_VARENV); + duk_get_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV); + DUK_DDD(DUK_DDDPRINT("closure varenv -> %!ipT, lexenv -> %!ipT", + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + duk_pop_2(ctx); +#endif + + /* + * Copy some internal properties directly + * + * The properties will be writable and configurable, but not enumerable. + */ + + /* [ ... closure template ] */ + + DUK_DDD(DUK_DDDPRINT("copying properties: closure=%!iT, template=%!iT", + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + + for (i = 0; i < (duk_small_uint_t) (sizeof(duk__closure_copy_proplist) / sizeof(duk_uint16_t)); i++) { + duk_small_int_t stridx = (duk_small_int_t) duk__closure_copy_proplist[i]; + if (duk_get_prop_stridx(ctx, -1, stridx)) { + /* [ ... closure template val ] */ + DUK_DDD(DUK_DDDPRINT("copying property, stridx=%ld -> found", (long) stridx)); + duk_xdef_prop_stridx(ctx, -3, stridx, DUK_PROPDESC_FLAGS_WC); + } else { + DUK_DDD(DUK_DDDPRINT("copying property, stridx=%ld -> not found", (long) stridx)); + duk_pop(ctx); + } + } + + /* + * "length" maps to number of formals (E5 Section 13.2) for function + * declarations/expressions (non-bound functions). Note that 'nargs' + * is NOT necessarily equal to the number of arguments. + */ + + /* [ ... closure template ] */ + + len_value = 0; + + /* XXX: use helper for size optimization */ + if (duk_get_prop_stridx(ctx, -2, DUK_STRIDX_INT_FORMALS)) { + /* [ ... closure template formals ] */ + DUK_ASSERT(duk_has_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH)); + DUK_ASSERT(duk_get_length(ctx, -1) <= DUK_UINT_MAX); /* formal arg limits */ + len_value = (duk_uint_t) duk_get_length(ctx, -1); + } else { + /* XXX: what to do if _Formals is not empty but compiler has + * optimized it away -- read length from an explicit property + * then? + */ + } + duk_pop(ctx); + + duk_push_uint(ctx, len_value); /* [ ... closure template len_value ] */ + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE); + + /* + * "prototype" is, by default, a fresh object with the "constructor" + * property. + * + * Note that this creates a circular reference for every function + * instance (closure) which prevents refcount-based collection of + * function instances. + * + * XXX: Try to avoid creating the default prototype object, because + * many functions are not used as constructors and the default + * prototype is unnecessary. Perhaps it could be created on-demand + * when it is first accessed? + */ + + /* [ ... closure template ] */ + + duk_push_object(ctx); /* -> [ ... closure template newobj ] */ + duk_dup(ctx, -3); /* -> [ ... closure template newobj closure ] */ + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_CONSTRUCTOR, DUK_PROPDESC_FLAGS_WC); /* -> [ ... closure template newobj ] */ + duk_compact(ctx, -1); /* compact the prototype */ + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_PROTOTYPE, DUK_PROPDESC_FLAGS_W); /* -> [ ... closure template ] */ + + /* + * "arguments" and "caller" must be mapped to throwers for strict + * mode and bound functions (E5 Section 15.3.5). + * + * XXX: This is expensive to have for every strict function instance. + * Try to implement as virtual properties or on-demand created properties. + */ + + /* [ ... closure template ] */ + + if (DUK_HOBJECT_HAS_STRICT(&fun_clos->obj)) { + duk_xdef_prop_stridx_thrower(ctx, -2, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE); + duk_xdef_prop_stridx_thrower(ctx, -2, DUK_STRIDX_LC_ARGUMENTS, DUK_PROPDESC_FLAGS_NONE); + } else { +#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY + DUK_DDD(DUK_DDDPRINT("function is non-strict and non-standard 'caller' property in use, add initial 'null' value")); + duk_push_null(ctx); + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE); +#else + DUK_DDD(DUK_DDDPRINT("function is non-strict and non-standard 'caller' property not used")); +#endif + } + + /* + * "name" is a non-standard property found in at least V8, Rhino, smjs. + * For Rhino and smjs it is non-writable, non-enumerable, and non-configurable; + * for V8 it is writable, non-enumerable, non-configurable. It is also defined + * for an anonymous function expression in which case the value is an empty string. + * We could also leave name 'undefined' for anonymous functions but that would + * differ from behavior of other engines, so use an empty string. + * + * XXX: make optional? costs something per function. + */ + + /* [ ... closure template ] */ + + if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME)) { + /* [ ... closure template name ] */ + DUK_ASSERT(duk_is_string(ctx, -1)); + } else { + /* [ ... closure template undefined ] */ + duk_pop(ctx); + duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING); + } + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE); /* -> [ ... closure template ] */ + + /* + * Compact the closure, in most cases no properties will be added later. + * Also, without this the closures end up having unused property slots + * (e.g. in Duktape 0.9.0, 8 slots would be allocated and only 7 used). + * A better future solution would be to allocate the closure directly + * to correct size (and setup the properties directly without going + * through the API). + */ + + duk_compact(ctx, -2); + + /* + * Some assertions (E5 Section 13.2). + */ + + DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(&fun_clos->obj) == DUK_HOBJECT_CLASS_FUNCTION); + DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, &fun_clos->obj) == thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]); + DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(&fun_clos->obj)); + DUK_ASSERT(duk_has_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH) != 0); + DUK_ASSERT(duk_has_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE) != 0); + DUK_ASSERT(duk_has_prop_stridx(ctx, -2, DUK_STRIDX_NAME) != 0); /* non-standard */ + DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(&fun_clos->obj) || + duk_has_prop_stridx(ctx, -2, DUK_STRIDX_CALLER) != 0); + DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(&fun_clos->obj) || + duk_has_prop_stridx(ctx, -2, DUK_STRIDX_LC_ARGUMENTS) != 0); + + /* + * Finish + */ + + /* [ ... closure template ] */ + + DUK_DDD(DUK_DDDPRINT("created function instance: template=%!iT -> closure=%!iT", + (duk_tval *) duk_get_tval(ctx, -1), + (duk_tval *) duk_get_tval(ctx, -2))); + + duk_pop(ctx); + + /* [ ... closure ] */ +} + +/* + * Delayed activation environment record initialization (for functions + * with NEWENV). + * + * The non-delayed initialization is handled by duk_handle_call(). + */ + +/* shared helper */ +DUK_INTERNAL +duk_hobject *duk_create_activation_environment_record(duk_hthread *thr, + duk_hobject *func, + duk_size_t idx_bottom) { + duk_context *ctx = (duk_context *) thr; + duk_hobject *env; + duk_hobject *parent; + duk_tval *tv; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(func != NULL); + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_LEXENV(thr)); + if (tv) { + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); + DUK_ASSERT(DUK_HOBJECT_IS_ENV(DUK_TVAL_GET_OBJECT(tv))); + parent = DUK_TVAL_GET_OBJECT(tv); + } else { + parent = thr->builtins[DUK_BIDX_GLOBAL_ENV]; + } + + (void) duk_push_object_helper(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV), + -1); /* no prototype, updated below */ + env = duk_require_hobject(ctx, -1); + DUK_ASSERT(env != NULL); + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, env, parent); /* parent env is the prototype */ + + /* open scope information, for compiled functions only */ + + if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { + duk_push_hthread(ctx, thr); + duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_THREAD); + duk_push_hobject(ctx, func); + duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_CALLEE); + duk_push_size_t(ctx, idx_bottom); + duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_REGBASE); + } + + return env; +} + +DUK_INTERNAL +void duk_js_init_activation_environment_records_delayed(duk_hthread *thr, + duk_activation *act) { + duk_context *ctx = (duk_context *) thr; + duk_hobject *func; + duk_hobject *env; + + func = DUK_ACT_GET_FUNC(act); + DUK_ASSERT(func != NULL); + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func)); /* bound functions are never in act 'func' */ + + /* + * Delayed initialization only occurs for 'NEWENV' functions. + */ + + DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func)); + DUK_ASSERT(act->lex_env == NULL); + DUK_ASSERT(act->var_env == NULL); + + env = duk_create_activation_environment_record(thr, func, act->idx_bottom); + DUK_ASSERT(env != NULL); + + DUK_DDD(DUK_DDDPRINT("created delayed fresh env: %!ipO", (duk_heaphdr *) env)); +#ifdef DUK_USE_DDDPRINT + { + duk_hobject *p = env; + while (p) { + DUK_DDD(DUK_DDDPRINT(" -> %!ipO", (duk_heaphdr *) p)); + p = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, p); + } + } +#endif + + act->lex_env = env; + act->var_env = env; + DUK_HOBJECT_INCREF(thr, env); /* XXX: incref by count (here 2 times) */ + DUK_HOBJECT_INCREF(thr, env); + + duk_pop(ctx); +} + +/* + * Closing environment records. + * + * The environment record MUST be closed with the thread where its activation + * is. In other words (if 'env' is open): + * + * - 'thr' must match _env.thread + * - 'func' must match _env.callee + * - 'regbase' must match _env.regbase + * + * These are not looked up from the env to minimize code size. + * + * XXX: should access the own properties directly instead of using the API + */ + +DUK_INTERNAL void duk_js_close_environment_record(duk_hthread *thr, duk_hobject *env, duk_hobject *func, duk_size_t regbase) { + duk_context *ctx = (duk_context *) thr; + duk_uint_fast32_t i; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(env != NULL); + /* func is NULL for lightfuncs */ + + if (!DUK_HOBJECT_IS_DECENV(env) || DUK_HOBJECT_HAS_ENVRECCLOSED(env)) { + DUK_DDD(DUK_DDDPRINT("environment record not a declarative record, " + "or already closed: %!iO", + (duk_heaphdr *) env)); + return; + } + + DUK_DDD(DUK_DDDPRINT("closing environment record: %!iO, func: %!iO, regbase: %ld", + (duk_heaphdr *) env, (duk_heaphdr *) func, (long) regbase)); + + duk_push_hobject(ctx, env); + + /* assertions: env must be closed in the same thread as where it runs */ +#ifdef DUK_USE_ASSERTIONS + { + /* [... env] */ + + if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_CALLEE)) { + DUK_ASSERT(duk_is_object(ctx, -1)); + DUK_ASSERT(duk_get_hobject(ctx, -1) == (duk_hobject *) func); + } + duk_pop(ctx); + + if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_THREAD)) { + DUK_ASSERT(duk_is_object(ctx, -1)); + DUK_ASSERT(duk_get_hobject(ctx, -1) == (duk_hobject *) thr); + } + duk_pop(ctx); + + if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_REGBASE)) { + DUK_ASSERT(duk_is_number(ctx, -1)); + DUK_ASSERT(duk_get_number(ctx, -1) == (double) regbase); + } + duk_pop(ctx); + + /* [... env] */ + } +#endif + + if (func != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { + duk_hobject *varmap; + duk_hstring *key; + duk_tval *tv; + duk_uint_t regnum; + + /* XXX: additional conditions when to close variables? we don't want to do it + * unless the environment may have "escaped" (referenced in a function closure). + * With delayed environments, the existence is probably good enough of a check. + */ + + /* XXX: any way to detect faster whether something needs to be closed? + * We now look up _Callee and then skip the rest. + */ + + /* Note: we rely on the _Varmap having a bunch of nice properties, like: + * - being compacted and unmodified during this process + * - not containing an array part + * - having correct value types + */ + + /* [... env] */ + + if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_CALLEE)) { + DUK_DDD(DUK_DDDPRINT("env has no callee property, nothing to close; re-delete the control properties just in case")); + duk_pop(ctx); + goto skip_varmap; + } + + /* [... env callee] */ + + if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VARMAP)) { + DUK_DDD(DUK_DDDPRINT("callee has no varmap property, nothing to close; delete the control properties")); + duk_pop_2(ctx); + goto skip_varmap; + } + varmap = duk_require_hobject(ctx, -1); + DUK_ASSERT(varmap != NULL); + + DUK_DDD(DUK_DDDPRINT("varmap: %!O", (duk_heaphdr *) varmap)); + + /* [... env callee varmap] */ + + DUK_DDD(DUK_DDDPRINT("copying bound register values, %ld bound regs", (long) DUK_HOBJECT_GET_ENEXT(varmap))); + + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(varmap); i++) { + key = DUK_HOBJECT_E_GET_KEY(thr->heap, varmap, i); + DUK_ASSERT(key != NULL); /* assume keys are compacted */ + + DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, varmap, i)); /* assume plain values */ + + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, varmap, i); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); /* assume value is a number */ + regnum = (duk_uint_t) DUK_TVAL_GET_NUMBER(tv); + DUK_ASSERT_DISABLE(regnum >= 0); /* unsigned */ + DUK_ASSERT(regnum < ((duk_hcompiledfunction *) func)->nregs); /* regnum is sane */ + DUK_ASSERT(thr->valstack + regbase + regnum >= thr->valstack); + DUK_ASSERT(thr->valstack + regbase + regnum < thr->valstack_top); + + /* XXX: slightly awkward */ + duk_push_hstring(ctx, key); + duk_push_tval(ctx, thr->valstack + regbase + regnum); + DUK_DDD(DUK_DDDPRINT("closing identifier '%s' -> reg %ld, value %!T", + (const char *) duk_require_string(ctx, -2), + (long) regnum, + (duk_tval *) duk_get_tval(ctx, -1))); + + /* [... env callee varmap key val] */ + + /* if property already exists, overwrites silently */ + duk_xdef_prop(ctx, -5, DUK_PROPDESC_FLAGS_WE); /* writable but not deletable */ + } + + duk_pop_2(ctx); + + /* [... env] */ + } + + skip_varmap: + + /* [... env] */ + + duk_del_prop_stridx(ctx, -1, DUK_STRIDX_INT_CALLEE); + duk_del_prop_stridx(ctx, -1, DUK_STRIDX_INT_THREAD); + duk_del_prop_stridx(ctx, -1, DUK_STRIDX_INT_REGBASE); + + duk_pop(ctx); + + DUK_HOBJECT_SET_ENVRECCLOSED(env); + + DUK_DDD(DUK_DDDPRINT("environment record after being closed: %!O", + (duk_heaphdr *) env)); +} + +/* + * GETIDREF: a GetIdentifierReference-like helper. + * + * Provides a parent traversing lookup and a single level lookup + * (for HasBinding). + * + * Instead of returning the value, returns a bunch of values allowing + * the caller to read, write, or delete the binding. Value pointers + * are duk_tval pointers which can be mutated directly as long as + * refcounts are properly updated. Note that any operation which may + * reallocate valstacks or compact objects may invalidate the returned + * duk_tval (but not object) pointers, so caller must be very careful. + * + * If starting environment record 'env' is given, 'act' is ignored. + * However, if 'env' is NULL, the caller may identify, in 'act', an + * activation which hasn't had its declarative environment initialized + * yet. The activation registers are then looked up, and its parent + * traversed normally. + * + * The 'out' structure values are only valid if the function returns + * success (non-zero). + */ + +/* lookup name from an open declarative record's registers */ +DUK_LOCAL +duk_bool_t duk__getid_open_decl_env_regs(duk_hthread *thr, + duk_hstring *name, + duk_hobject *env, + duk__id_lookup_result *out) { + duk_hthread *env_thr; + duk_hobject *env_func; + duk_size_t env_regbase; + duk_hobject *varmap; + duk_tval *tv; + duk_size_t reg_rel; + duk_size_t idx; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(name != NULL); + DUK_ASSERT(env != NULL); + DUK_ASSERT(out != NULL); + + DUK_ASSERT(DUK_HOBJECT_IS_DECENV(env)); + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_CALLEE(thr)); + if (!tv) { + /* env is closed, should be missing _Callee, _Thread, _Regbase */ + DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL); + DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL); + DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL); + return 0; + } + + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); + DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_TVAL_GET_OBJECT(tv))); + env_func = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(env_func != NULL); + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env_func, DUK_HTHREAD_STRING_INT_VARMAP(thr)); + if (!tv) { + return 0; + } + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); + varmap = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(varmap != NULL); + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, varmap, name); + if (!tv) { + return 0; + } + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + reg_rel = (duk_size_t) DUK_TVAL_GET_NUMBER(tv); + DUK_ASSERT_DISABLE(reg_rel >= 0); /* unsigned */ + DUK_ASSERT(reg_rel < ((duk_hcompiledfunction *) env_func)->nregs); + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_THREAD(thr)); + DUK_ASSERT(tv != NULL); + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); + DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_THREAD(DUK_TVAL_GET_OBJECT(tv))); + env_thr = (duk_hthread *) DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(env_thr != NULL); + + /* Note: env_thr != thr is quite possible and normal, so careful + * with what thread is used for valstack lookup. + */ + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_REGBASE(thr)); + DUK_ASSERT(tv != NULL); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + env_regbase = (duk_size_t) DUK_TVAL_GET_NUMBER(tv); + + idx = env_regbase + reg_rel; + tv = env_thr->valstack + idx; + DUK_ASSERT(tv >= env_thr->valstack && tv < env_thr->valstack_end); /* XXX: more accurate? */ + + out->value = tv; + out->attrs = DUK_PROPDESC_FLAGS_W; /* registers are mutable, non-deletable */ + out->this_binding = NULL; /* implicit this value always undefined for + * declarative environment records. + */ + out->env = env; + out->holder = NULL; + + return 1; +} + +/* lookup name from current activation record's functions' registers */ +DUK_LOCAL +duk_bool_t duk__getid_activation_regs(duk_hthread *thr, + duk_hstring *name, + duk_activation *act, + duk__id_lookup_result *out) { + duk_tval *tv; + duk_hobject *func; + duk_hobject *varmap; + duk_size_t reg_rel; + duk_size_t idx; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(name != NULL); + DUK_ASSERT(act != NULL); + DUK_ASSERT(out != NULL); + + func = DUK_ACT_GET_FUNC(act); + DUK_ASSERT(func != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func)); + + if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { + return 0; + } + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_VARMAP(thr)); + if (!tv) { + return 0; + } + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); + varmap = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(varmap != NULL); + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, varmap, name); + if (!tv) { + return 0; + } + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + reg_rel = (duk_size_t) DUK_TVAL_GET_NUMBER(tv); + DUK_ASSERT_DISABLE(reg_rel >= 0); + DUK_ASSERT(reg_rel < ((duk_hcompiledfunction *) func)->nregs); + + idx = act->idx_bottom + reg_rel; + DUK_ASSERT(idx >= act->idx_bottom); + tv = thr->valstack + idx; + + out->value = tv; + out->attrs = DUK_PROPDESC_FLAGS_W; /* registers are mutable, non-deletable */ + out->this_binding = NULL; /* implicit this value always undefined for + * declarative environment records. + */ + out->env = NULL; + out->holder = NULL; + + return 1; +} + +DUK_LOCAL +duk_bool_t duk__get_identifier_reference(duk_hthread *thr, + duk_hobject *env, + duk_hstring *name, + duk_activation *act, + duk_bool_t parents, + duk__id_lookup_result *out) { + duk_tval *tv; + duk_tval *tv_target; + duk_tval tv_name; + duk_uint_t sanity; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(env != NULL || act != NULL); + DUK_ASSERT(name != NULL); + DUK_ASSERT(out != NULL); + + DUK_ASSERT(!env || DUK_HOBJECT_IS_ENV(env)); + DUK_ASSERT(!env || !DUK_HOBJECT_HAS_ARRAY_PART(env)); + + /* + * Conceptually, we look for the identifier binding by starting from + * 'env' and following to chain of environment records (represented + * by the prototype chain). + * + * If 'env' is NULL, the current activation does not yet have an + * allocated declarative environment record; this should be treated + * exactly as if the environment record existed but had no bindings + * other than register bindings. + * + * Note: we assume that with the DUK_HOBJECT_FLAG_NEWENV cleared + * the environment will always be initialized immediately; hence + * a NULL 'env' should only happen with the flag set. This is the + * case for: (1) function calls, and (2) strict, direct eval calls. + */ + + if (env == NULL && act != NULL) { + duk_hobject *func; + + DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference: env is NULL, activation is non-NULL -> " + "delayed env case, look up activation regs first")); + + /* + * Try registers + */ + + if (duk__getid_activation_regs(thr, name, act, out)) { + DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: " + "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O " + "(found from register bindings when env=NULL)", + (duk_heaphdr *) name, (duk_tval *) out->value, + (long) out->attrs, (duk_tval *) out->this_binding, + (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder)); + return 1; + } + + DUK_DDD(DUK_DDDPRINT("not found in current activation regs")); + + /* + * Not found in registers, proceed to the parent record. + * Here we need to determine what the parent would be, + * if 'env' was not NULL (i.e. same logic as when initializing + * the record). + * + * Note that environment initialization is only deferred when + * DUK_HOBJECT_HAS_NEWENV is set, and this only happens for: + * - Function code + * - Strict eval code + * + * We only need to check _Lexenv here; _Varenv exists only if it + * differs from _Lexenv (and thus _Lexenv will also be present). + */ + + if (!parents) { + DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference failed, no parent traversal " + "(not found from register bindings when env=NULL)")); + goto fail_not_found; + } + + func = DUK_ACT_GET_FUNC(act); + DUK_ASSERT(func != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func)); + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_LEXENV(thr)); + if (tv) { + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); + env = DUK_TVAL_GET_OBJECT(tv); + } else { + DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_VARENV(thr)) == NULL); + env = thr->builtins[DUK_BIDX_GLOBAL_ENV]; + } + + DUK_DDD(DUK_DDDPRINT("continue lookup from env: %!iO", + (duk_heaphdr *) env)); + } + + /* + * Prototype walking starting from 'env'. + * + * ('act' is not needed anywhere here.) + */ + + sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY; + while (env != NULL) { + duk_small_int_t cl; + duk_int_t attrs; + + DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference, name=%!O, considering env=%p -> %!iO", + (duk_heaphdr *) name, + (void *) env, + (duk_heaphdr *) env)); + + DUK_ASSERT(env != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_ENV(env)); + DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(env)); + + cl = DUK_HOBJECT_GET_CLASS_NUMBER(env); + DUK_ASSERT(cl == DUK_HOBJECT_CLASS_OBJENV || cl == DUK_HOBJECT_CLASS_DECENV); + if (cl == DUK_HOBJECT_CLASS_DECENV) { + /* + * Declarative environment record. + * + * Identifiers can never be stored in ancestors and are + * always plain values, so we can use an internal helper + * and access the value directly with an duk_tval ptr. + * + * A closed environment is only indicated by it missing + * the "book-keeping" properties required for accessing + * register-bound variables. + */ + + if (DUK_HOBJECT_HAS_ENVRECCLOSED(env)) { + /* already closed */ + goto skip_regs; + } + + if (duk__getid_open_decl_env_regs(thr, name, env, out)) { + DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: " + "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O " + "(declarative environment record, scope open, found in regs)", + (duk_heaphdr *) name, (duk_tval *) out->value, + (long) out->attrs, (duk_tval *) out->this_binding, + (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder)); + return 1; + } + skip_regs: + + tv = duk_hobject_find_existing_entry_tval_ptr_and_attrs(thr->heap, env, name, &attrs); + if (tv) { + out->value = tv; + out->attrs = attrs; + out->this_binding = NULL; /* implicit this value always undefined for + * declarative environment records. + */ + out->env = env; + out->holder = env; + + DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: " + "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O " + "(declarative environment record, found in properties)", + (duk_heaphdr *) name, (duk_tval *) out->value, + (long) out->attrs, (duk_tval *) out->this_binding, + (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder)); + return 1; + } + } else { + /* + * Object environment record. + * + * Binding (target) object is an external, uncontrolled object. + * Identifier may be bound in an ancestor property, and may be + * an accessor. Target can also be a Proxy which we must support + * here. + */ + + /* XXX: we could save space by using _Target OR _This. If _Target, assume + * this binding is undefined. If _This, assumes this binding is _This, and + * target is also _This. One property would then be enough. + */ + + duk_hobject *target; + duk_bool_t found; + + DUK_ASSERT(cl == DUK_HOBJECT_CLASS_OBJENV); + + tv_target = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_TARGET(thr)); + DUK_ASSERT(tv_target != NULL); + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_target)); + target = DUK_TVAL_GET_OBJECT(tv_target); + DUK_ASSERT(target != NULL); + + /* Target may be a Proxy or property may be an accessor, so we must + * use an actual, Proxy-aware hasprop check here. + * + * out->holder is NOT set to the actual duk_hobject where the + * property is found, but rather the object binding target object. + */ + + if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(target)) { + DUK_ASSERT(name != NULL); + DUK_TVAL_SET_STRING(&tv_name, name); + + found = duk_hobject_hasprop(thr, tv_target, &tv_name); + } else { + /* XXX: duk_hobject_hasprop() would be correct for + * non-Proxy objects too, but it is about ~20-25% + * slower at present so separate code paths for + * Proxy and non-Proxy now. + */ + found = duk_hobject_hasprop_raw(thr, target, name); + } + + if (found) { + out->value = NULL; /* can't get value, may be accessor */ + out->attrs = 0; /* irrelevant when out->value == NULL */ + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_THIS(thr)); + out->this_binding = tv; /* may be NULL */ + out->env = env; + out->holder = target; + + DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: " + "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O " + "(object environment record)", + (duk_heaphdr *) name, (duk_tval *) out->value, + (long) out->attrs, (duk_tval *) out->this_binding, + (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder)); + return 1; + } + } + + if (!parents) { + DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference failed, no parent traversal " + "(not found from first traversed env)")); + goto fail_not_found; + } + + if (sanity-- == 0) { + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT); + } + env = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, env); + }; + + /* + * Not found (even in global object) + */ + + fail_not_found: + return 0; +} + +/* + * HASVAR: check identifier binding from a given environment record + * without traversing its parents. + * + * This primitive is not exposed to user code as such, but is used + * internally for e.g. declaration binding instantiation. + * + * See E5 Sections: + * 10.2.1.1.1 HasBinding(N) + * 10.2.1.2.1 HasBinding(N) + * + * Note: strictness has no bearing on this check. Hence we don't take + * a 'strict' parameter. + */ + +#if 0 /*unused*/ +DUK_INTERNAL +duk_bool_t duk_js_hasvar_envrec(duk_hthread *thr, + duk_hobject *env, + duk_hstring *name) { + duk__id_lookup_result ref; + duk_bool_t parents; + + DUK_DDD(DUK_DDDPRINT("hasvar: thr=%p, env=%p, name=%!O " + "(env -> %!dO)", + (void *) thr, (void *) env, (duk_heaphdr *) name, + (duk_heaphdr *) env)); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(env != NULL); + DUK_ASSERT(name != NULL); + + DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(env); + DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name); + + DUK_ASSERT(DUK_HOBJECT_IS_ENV(env)); + DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(env)); + + /* lookup results is ignored */ + parents = 0; + return duk__get_identifier_reference(thr, env, name, NULL, parents, &ref); +} +#endif + +/* + * GETVAR + * + * See E5 Sections: + * 11.1.2 Identifier Reference + * 10.3.1 Identifier Resolution + * 11.13.1 Simple Assignment [example of where the Reference is GetValue'd] + * 8.7.1 GetValue (V) + * 8.12.1 [[GetOwnProperty]] (P) + * 8.12.2 [[GetProperty]] (P) + * 8.12.3 [[Get]] (P) + * + * If 'throw' is true, always leaves two values on top of stack: [val this]. + * + * If 'throw' is false, returns 0 if identifier cannot be resolved, and the + * stack will be unaffected in this case. If identifier is resolved, returns + * 1 and leaves [val this] on top of stack. + * + * Note: the 'strict' flag of a reference returned by GetIdentifierReference + * is ignored by GetValue. Hence we don't take a 'strict' parameter. + * + * The 'throw' flag is needed for implementing 'typeof' for an unreferenced + * identifier. An unreference identifier in other contexts generates a + * ReferenceError. + */ + +DUK_LOCAL +duk_bool_t duk__getvar_helper(duk_hthread *thr, + duk_hobject *env, + duk_activation *act, + duk_hstring *name, + duk_bool_t throw_flag) { + duk_context *ctx = (duk_context *) thr; + duk__id_lookup_result ref; + duk_tval tv_tmp_obj; + duk_tval tv_tmp_key; + duk_bool_t parents; + + DUK_DDD(DUK_DDDPRINT("getvar: thr=%p, env=%p, act=%p, name=%!O " + "(env -> %!dO)", + (void *) thr, (void *) env, (void *) act, + (duk_heaphdr *) name, (duk_heaphdr *) env)); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(name != NULL); + /* env and act may be NULL */ + + DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(env); + DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name); + + parents = 1; /* follow parent chain */ + if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) { + if (ref.value) { + DUK_ASSERT(ref.this_binding == NULL); /* always for register bindings */ + duk_push_tval(ctx, ref.value); + duk_push_undefined(ctx); + } else { + DUK_ASSERT(ref.holder != NULL); + + /* Note: getprop may invoke any getter and invalidate any + * duk_tval pointers, so this must be done first. + */ + + if (ref.this_binding) { + duk_push_tval(ctx, ref.this_binding); + } else { + duk_push_undefined(ctx); + } + + DUK_TVAL_SET_OBJECT(&tv_tmp_obj, ref.holder); + DUK_TVAL_SET_STRING(&tv_tmp_key, name); + (void) duk_hobject_getprop(thr, &tv_tmp_obj, &tv_tmp_key); /* [this value] */ + + /* ref.value, ref.this.binding invalidated here by getprop call */ + + duk_insert(ctx, -2); /* [this value] -> [value this] */ + } + + return 1; + } else { + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_REFERENCE_ERROR, + "identifier '%s' undefined", + (const char *) DUK_HSTRING_GET_DATA(name)); + } + + return 0; + } +} + +DUK_INTERNAL +duk_bool_t duk_js_getvar_envrec(duk_hthread *thr, + duk_hobject *env, + duk_hstring *name, + duk_bool_t throw_flag) { + return duk__getvar_helper(thr, env, NULL, name, throw_flag); +} + +DUK_INTERNAL +duk_bool_t duk_js_getvar_activation(duk_hthread *thr, + duk_activation *act, + duk_hstring *name, + duk_bool_t throw_flag) { + DUK_ASSERT(act != NULL); + return duk__getvar_helper(thr, act->lex_env, act, name, throw_flag); +} + +/* + * PUTVAR + * + * See E5 Sections: + * 11.1.2 Identifier Reference + * 10.3.1 Identifier Resolution + * 11.13.1 Simple Assignment [example of where the Reference is PutValue'd] + * 8.7.2 PutValue (V,W) [see especially step 3.b, undefined -> automatic global in non-strict mode] + * 8.12.4 [[CanPut]] (P) + * 8.12.5 [[Put]] (P) + * + * Note: may invalidate any valstack (or object) duk_tval pointers because + * putting a value may reallocate any object or any valstack. Caller beware. + */ + +DUK_LOCAL +void duk__putvar_helper(duk_hthread *thr, + duk_hobject *env, + duk_activation *act, + duk_hstring *name, + duk_tval *val, + duk_bool_t strict) { + duk__id_lookup_result ref; + duk_tval tv_tmp_obj; + duk_tval tv_tmp_key; + duk_bool_t parents; + + DUK_DDD(DUK_DDDPRINT("putvar: thr=%p, env=%p, act=%p, name=%!O, val=%p, strict=%ld " + "(env -> %!dO, val -> %!T)", + (void *) thr, (void *) env, (void *) act, + (duk_heaphdr *) name, (void *) val, (long) strict, + (duk_heaphdr *) env, (duk_tval *) val)); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(name != NULL); + DUK_ASSERT(val != NULL); + /* env and act may be NULL */ + + DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(env); + DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name); + DUK_ASSERT_REFCOUNT_NONZERO_TVAL(val); + + /* + * In strict mode E5 protects 'eval' and 'arguments' from being + * assigned to (or even declared anywhere). Attempt to do so + * should result in a compile time SyntaxError. See the internal + * design documentation for details. + * + * Thus, we should never come here, run-time, for strict code, + * and name 'eval' or 'arguments'. + */ + + DUK_ASSERT(!strict || + (name != DUK_HTHREAD_STRING_EVAL(thr) && + name != DUK_HTHREAD_STRING_LC_ARGUMENTS(thr))); + + /* + * Lookup variable and update in-place if found. + */ + + parents = 1; /* follow parent chain */ + + if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) { + if (ref.value && (ref.attrs & DUK_PROPDESC_FLAG_WRITABLE)) { + /* Update duk_tval in-place if pointer provided and the + * property is writable. If the property is not writable + * (immutable binding), use duk_hobject_putprop() which + * will respect mutability. + */ + duk_tval tv_tmp; + duk_tval *tv_val; + + DUK_ASSERT(ref.this_binding == NULL); /* always for register bindings */ + + tv_val = ref.value; + DUK_ASSERT(tv_val != NULL); + DUK_TVAL_SET_TVAL(&tv_tmp, tv_val); + DUK_TVAL_SET_TVAL(tv_val, val); + DUK_TVAL_INCREF(thr, val); + DUK_TVAL_DECREF(thr, &tv_tmp); /* must be last */ + + /* ref.value and ref.this_binding invalidated here */ + } else { + DUK_ASSERT(ref.holder != NULL); + + DUK_TVAL_SET_OBJECT(&tv_tmp_obj, ref.holder); + DUK_TVAL_SET_STRING(&tv_tmp_key, name); + (void) duk_hobject_putprop(thr, &tv_tmp_obj, &tv_tmp_key, val, strict); + + /* ref.value and ref.this_binding invalidated here */ + } + + return; + } + + /* + * Not found: write to global object (non-strict) or ReferenceError + * (strict); see E5 Section 8.7.2, step 3. + */ + + if (strict) { + DUK_DDD(DUK_DDDPRINT("identifier binding not found, strict => reference error")); + DUK_ERROR(thr, DUK_ERR_REFERENCE_ERROR, "identifier not defined"); + } + + DUK_DDD(DUK_DDDPRINT("identifier binding not found, not strict => set to global")); + + DUK_TVAL_SET_OBJECT(&tv_tmp_obj, thr->builtins[DUK_BIDX_GLOBAL]); + DUK_TVAL_SET_STRING(&tv_tmp_key, name); + (void) duk_hobject_putprop(thr, &tv_tmp_obj, &tv_tmp_key, val, 0); /* 0 = no throw */ + + /* NB: 'val' may be invalidated here because put_value may realloc valstack, + * caller beware. + */ +} + +DUK_INTERNAL +void duk_js_putvar_envrec(duk_hthread *thr, + duk_hobject *env, + duk_hstring *name, + duk_tval *val, + duk_bool_t strict) { + duk__putvar_helper(thr, env, NULL, name, val, strict); +} + +DUK_INTERNAL +void duk_js_putvar_activation(duk_hthread *thr, + duk_activation *act, + duk_hstring *name, + duk_tval *val, + duk_bool_t strict) { + DUK_ASSERT(act != NULL); + duk__putvar_helper(thr, act->lex_env, act, name, val, strict); +} + +/* + * DELVAR + * + * See E5 Sections: + * 11.4.1 The delete operator + * 10.2.1.1.5 DeleteBinding (N) [declarative environment record] + * 10.2.1.2.5 DeleteBinding (N) [object environment record] + * + * Variable bindings established inside eval() are deletable (configurable), + * other bindings are not, including variables declared in global level. + * Registers are always non-deletable, and the deletion of other bindings + * is controlled by the configurable flag. + * + * For strict mode code, the 'delete' operator should fail with a compile + * time SyntaxError if applied to identifiers. Hence, no strict mode + * run-time deletion of identifiers should ever happen. This function + * should never be called from strict mode code! + */ + +DUK_LOCAL +duk_bool_t duk__delvar_helper(duk_hthread *thr, + duk_hobject *env, + duk_activation *act, + duk_hstring *name) { + duk__id_lookup_result ref; + duk_bool_t parents; + + DUK_DDD(DUK_DDDPRINT("delvar: thr=%p, env=%p, act=%p, name=%!O " + "(env -> %!dO)", + (void *) thr, (void *) env, (void *) act, + (duk_heaphdr *) name, (duk_heaphdr *) env)); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(name != NULL); + /* env and act may be NULL */ + + DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name); + + parents = 1; /* follow parent chain */ + + if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) { + if (ref.value && !(ref.attrs & DUK_PROPDESC_FLAG_CONFIGURABLE)) { + /* Identifier found in registers (always non-deletable) + * or declarative environment record and non-configurable. + */ + return 0; + } + DUK_ASSERT(ref.holder != NULL); + + return duk_hobject_delprop_raw(thr, ref.holder, name, 0); + } + + /* + * Not found (even in global object). + * + * In non-strict mode this is a silent SUCCESS (!), see E5 Section 11.4.1, + * step 3.b. In strict mode this case is a compile time SyntaxError so + * we should not come here. + */ + + DUK_DDD(DUK_DDDPRINT("identifier to be deleted not found: name=%!O " + "(treated as silent success)", + (duk_heaphdr *) name)); + return 1; +} + +#if 0 /*unused*/ +DUK_INTERNAL +duk_bool_t duk_js_delvar_envrec(duk_hthread *thr, + duk_hobject *env, + duk_hstring *name) { + return duk__delvar_helper(thr, env, NULL, name); +} +#endif + +DUK_INTERNAL +duk_bool_t duk_js_delvar_activation(duk_hthread *thr, + duk_activation *act, + duk_hstring *name) { + DUK_ASSERT(act != NULL); + return duk__delvar_helper(thr, act->lex_env, act, name); +} + +/* + * DECLVAR + * + * See E5 Sections: + * 10.4.3 Entering Function Code + * 10.5 Declaration Binding Instantion + * 12.2 Variable Statement + * 11.1.2 Identifier Reference + * 10.3.1 Identifier Resolution + * + * Variable declaration behavior is mainly discussed in Section 10.5, + * and is not discussed in the execution semantics (Sections 11-13). + * + * Conceptually declarations happen when code (global, eval, function) + * is entered, before any user code is executed. In practice, register- + * bound identifiers are 'declared' automatically (by virtue of being + * allocated to registers with the initial value 'undefined'). Other + * identifiers are declared in the function prologue with this primitive. + * + * Since non-register bindings eventually back to an internal object's + * properties, the 'prop_flags' argument is used to specify binding + * type: + * + * - Immutable binding: set DUK_PROPDESC_FLAG_WRITABLE to false + * - Non-deletable binding: set DUK_PROPDESC_FLAG_CONFIGURABLE to false + * - The flag DUK_PROPDESC_FLAG_ENUMERABLE should be set, although it + * doesn't really matter for internal objects + * + * All bindings are non-deletable mutable bindings except: + * + * - Declarations in eval code (mutable, deletable) + * - 'arguments' binding in strict function code (immutable) + * - Function name binding of a function expression (immutable) + * + * Declarations may go to declarative environment records (always + * so for functions), but may also go to object environment records + * (e.g. global code). The global object environment has special + * behavior when re-declaring a function (but not a variable); see + * E5.1 specification, Section 10.5, step 5.e. + * + * Declarations always go to the 'top-most' environment record, i.e. + * we never check the record chain. It's not an error even if a + * property (even an immutable or non-deletable one) of the same name + * already exists. + * + * If a declared variable already exists, its value needs to be updated + * (if possible). Returns 1 if a PUTVAR needs to be done by the caller; + * otherwise returns 0. + */ + +DUK_LOCAL +duk_bool_t duk__declvar_helper(duk_hthread *thr, + duk_hobject *env, + duk_hstring *name, + duk_tval *val, + duk_small_int_t prop_flags, + duk_bool_t is_func_decl) { + duk_context *ctx = (duk_context *) thr; + duk_hobject *holder; + duk_bool_t parents; + duk__id_lookup_result ref; + duk_tval *tv; + + DUK_DDD(DUK_DDDPRINT("declvar: thr=%p, env=%p, name=%!O, val=%!T, prop_flags=0x%08lx, is_func_decl=%ld " + "(env -> %!iO)", + (void *) thr, (void *) env, (duk_heaphdr *) name, + (duk_tval *) val, (unsigned long) prop_flags, + (unsigned int) is_func_decl, (duk_heaphdr *) env)); + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(env != NULL); + DUK_ASSERT(name != NULL); + DUK_ASSERT(val != NULL); + + /* Note: in strict mode the compiler should reject explicit + * declaration of 'eval' or 'arguments'. However, internal + * bytecode may declare 'arguments' in the function prologue. + * We don't bother checking (or asserting) for these now. + */ + + /* Note: val is a stable duk_tval pointer. The caller makes + * a value copy into its stack frame, so 'tv_val' is not subject + * to side effects here. + */ + + /* + * Check whether already declared. + * + * We need to check whether the binding exists in the environment + * without walking its parents. However, we still need to check + * register-bound identifiers and the prototype chain of an object + * environment target object. + */ + + parents = 0; /* just check 'env' */ + if (duk__get_identifier_reference(thr, env, name, NULL, parents, &ref)) { + duk_int_t e_idx; + duk_int_t h_idx; + duk_small_int_t flags; + + /* + * Variable already declared, ignore re-declaration. + * The only exception is the updated behavior of E5.1 for + * global function declarations, E5.1 Section 10.5, step 5.e. + * This behavior does not apply to global variable declarations. + */ + + if (!(is_func_decl && env == thr->builtins[DUK_BIDX_GLOBAL_ENV])) { + DUK_DDD(DUK_DDDPRINT("re-declare a binding, ignoring")); + return 1; /* 1 -> needs a PUTVAR */ + } + + /* + * Special behavior in E5.1. + * + * Note that even though parents == 0, the conflicting property + * may be an inherited property (currently our global object's + * prototype is Object.prototype). Step 5.e first operates on + * the existing property (which is potentially in an ancestor) + * and then defines a new property in the global object (and + * never modifies the ancestor). + * + * Also note that this logic would become even more complicated + * if the conflicting property might be a virtual one. Object + * prototype has no virtual properties, though. + * + * XXX: this is now very awkward, rework. + */ + + DUK_DDD(DUK_DDDPRINT("re-declare a function binding in global object, " + "updated E5.1 processing")); + + DUK_ASSERT(ref.holder != NULL); + holder = ref.holder; + + /* holder will be set to the target object, not the actual object + * where the property was found (see duk__get_identifier_reference()). + */ + DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(holder) == DUK_HOBJECT_CLASS_GLOBAL); + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(holder)); /* global object doesn't have array part */ + + /* XXX: use a helper for prototype traversal; no loop check here */ + /* must be found: was found earlier, and cannot be inherited */ + for (;;) { + DUK_ASSERT(holder != NULL); + duk_hobject_find_existing_entry(thr->heap, holder, name, &e_idx, &h_idx); + if (e_idx >= 0) { + break; + } + /* SCANBUILD: NULL pointer dereference, doesn't actually trigger, + * asserted above. + */ + holder = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, holder); + } + DUK_ASSERT(holder != NULL); + DUK_ASSERT(e_idx >= 0); + /* SCANBUILD: scan-build produces a NULL pointer dereference warning + * below; it never actually triggers because holder is actually never + * NULL. + */ + + /* ref.holder is global object, holder is the object with the + * conflicting property. + */ + + flags = DUK_HOBJECT_E_GET_FLAGS(thr->heap, holder, e_idx); + if (!(flags & DUK_PROPDESC_FLAG_CONFIGURABLE)) { + if (flags & DUK_PROPDESC_FLAG_ACCESSOR) { + DUK_DDD(DUK_DDDPRINT("existing property is a non-configurable " + "accessor -> reject")); + goto fail_existing_attributes; + } + if (!((flags & DUK_PROPDESC_FLAG_WRITABLE) && + (flags & DUK_PROPDESC_FLAG_ENUMERABLE))) { + DUK_DDD(DUK_DDDPRINT("existing property is a non-configurable " + "plain property which is not writable and " + "enumerable -> reject")); + goto fail_existing_attributes; + } + + DUK_DDD(DUK_DDDPRINT("existing property is not configurable but " + "is plain, enumerable, and writable -> " + "allow redeclaration")); + } + + if (holder == ref.holder) { + /* XXX: if duk_hobject_define_property_internal() was updated + * to handle a pre-existing accessor property, this would be + * a simple call (like for the ancestor case). + */ + DUK_DDD(DUK_DDDPRINT("redefine, offending property in global object itself")); + + if (flags & DUK_PROPDESC_FLAG_ACCESSOR) { + duk_hobject *tmp; + + tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, holder, e_idx); + DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, holder, e_idx, NULL); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + DUK_UNREF(tmp); + tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, holder, e_idx); + DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, holder, e_idx, NULL); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + DUK_UNREF(tmp); + } else { + duk_tval tv_tmp; + + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx); + DUK_TVAL_SET_TVAL(&tv_tmp, tv); + DUK_TVAL_SET_UNDEFINED_UNUSED(tv); + DUK_TVAL_DECREF(thr, &tv_tmp); + } + + /* Here val would be potentially invalid if we didn't make + * a value copy at the caller. + */ + + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx); + DUK_TVAL_SET_TVAL(tv, val); + DUK_TVAL_INCREF(thr, tv); + DUK_HOBJECT_E_SET_FLAGS(thr->heap, holder, e_idx, prop_flags); + + DUK_DDD(DUK_DDDPRINT("updated global binding, final result: " + "value -> %!T, prop_flags=0x%08lx", + (duk_tval *) DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx), + (unsigned long) prop_flags)); + } else { + DUK_DDD(DUK_DDDPRINT("redefine, offending property in ancestor")); + + DUK_ASSERT(ref.holder == thr->builtins[DUK_BIDX_GLOBAL]); + duk_push_tval(ctx, val); + duk_hobject_define_property_internal(thr, ref.holder, name, prop_flags); + } + + return 0; + } + + /* + * Not found (in registers or record objects). Declare + * to current variable environment. + */ + + /* + * Get holder object + */ + + if (DUK_HOBJECT_IS_DECENV(env)) { + holder = env; + } else { + DUK_ASSERT(DUK_HOBJECT_IS_OBJENV(env)); + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_TARGET(thr)); + DUK_ASSERT(tv != NULL); + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); + holder = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(holder != NULL); + } + + /* + * Define new property + * + * Note: this may fail if the holder is not extensible. + */ + + /* XXX: this is awkward as we use an internal method which doesn't handle + * extensibility etc correctly. Basically we'd want to do a [[DefineOwnProperty]] + * or Object.defineProperty() here. + */ + + if (!DUK_HOBJECT_HAS_EXTENSIBLE(holder)) { + goto fail_not_extensible; + } + + duk_push_hobject(ctx, holder); + duk_push_hstring(ctx, name); + duk_push_tval(ctx, val); + duk_xdef_prop(ctx, -3, prop_flags); /* [holder name val] -> [holder] */ + duk_pop(ctx); + + return 0; + + fail_existing_attributes: + fail_not_extensible: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "declaration failed"); + return 0; +} + +DUK_INTERNAL +duk_bool_t duk_js_declvar_activation(duk_hthread *thr, + duk_activation *act, + duk_hstring *name, + duk_tval *val, + duk_small_int_t prop_flags, + duk_bool_t is_func_decl) { + duk_hobject *env; + duk_tval tv_val_copy; + + /* + * Make a value copy of the input val. This ensures that + * side effects cannot invalidate the pointer. + */ + + DUK_TVAL_SET_TVAL(&tv_val_copy, val); + val = &tv_val_copy; + + /* + * Delayed env creation check + */ + + if (!act->var_env) { + DUK_ASSERT(act->lex_env == NULL); + duk_js_init_activation_environment_records_delayed(thr, act); + } + DUK_ASSERT(act->lex_env != NULL); + DUK_ASSERT(act->var_env != NULL); + + env = act->var_env; + DUK_ASSERT(env != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_ENV(env)); + + return duk__declvar_helper(thr, env, name, val, prop_flags, is_func_decl); +} +#line 1 "duk_lexer.c" +/* + * Lexer for source files, ToNumber() string conversions, RegExp expressions, + * and JSON. + * + * Provides a stream of Ecmascript tokens from an UTF-8/CESU-8 buffer. The + * caller can also rewind the token stream into a certain position which is + * needed by the compiler part for multi-pass scanning. Tokens are + * represented as duk_token structures, and contain line number information. + * Token types are identified with DUK_TOK_* defines. + * + * Characters are decoded into a fixed size lookup window consisting of + * decoded Unicode code points, with window positions past the end of the + * input filled with an invalid codepoint (-1). The tokenizer can thus + * perform multiple character lookups efficiently and with few sanity + * checks (such as access outside the end of the input), which keeps the + * tokenization code small at the cost of performance. + * + * Character data in tokens, such as identifier names and string literals, + * is encoded into CESU-8 format on-the-fly while parsing the token in + * question. The string data is made reachable to garbage collection by + * placing the token-related values in value stack entries allocated for + * this purpose by the caller. The characters exist in Unicode code point + * form only in the fixed size lookup window, which keeps character data + * expansion (of especially ASCII data) low. + * + * Token parsing supports the full range of Unicode characters as described + * in the E5 specification. Parsing has been optimized for ASCII characters + * because ordinary Ecmascript code consists almost entirely of ASCII + * characters. Matching of complex Unicode codepoint sets (such as in the + * IdentifierStart and IdentifierPart productions) is optimized for size, + * and is done using a linear scan of a bit-packed list of ranges. This is + * very slow, but should never be entered unless the source code actually + * contains Unicode characters. + * + * Ecmascript tokenization is partially context sensitive. First, + * additional future reserved words are recognized in strict mode (see E5 + * Section 7.6.1.2). Second, a forward slash character ('/') can be + * recognized either as starting a RegExp literal or as a division operator, + * depending on context. The caller must provide necessary context flags + * when requesting a new token. + * + * Future work: + * + * * Make line number tracking optional, as it consumes space. + * + * * Add a feature flag for disabling UTF-8 decoding of input, as most + * source code is ASCII. Because of Unicode escapes written in ASCII, + * this does not allow Unicode support to be removed from e.g. + * duk_unicode_is_identifier_start() nor does it allow removal of CESU-8 + * encoding of e.g. string literals. + * + * * Add a feature flag for disabling Unicode compliance of e.g. identifier + * names. This allows for a build more than a kilobyte smaller, because + * Unicode ranges needed by duk_unicode_is_identifier_start() and + * duk_unicode_is_identifier_part() can be dropped. String literals + * should still be allowed to contain escaped Unicode, so this still does + * not allow removal of CESU-8 encoding of e.g. string literals. + * + * * Character lookup tables for codepoints above BMP could be stripped. + * + * * Strictly speaking, E5 specification requires that source code consists + * of 16-bit code units, and if not, must be conceptually converted to + * that format first. The current lexer processes Unicode code points + * and allows characters outside the BMP. These should be converted to + * surrogate pairs while reading the source characters into the window, + * not after tokens have been formed (as is done now). However, the fix + * is not trivial because two characters are decoded from one codepoint. + * + * * Optimize for speed as well as size. Large if-else ladders are (at + * least potentially) slow. + */ + +/* include removed: duk_internal.h */ + +/* + * Various defines and file specific helper macros + */ + +#define DUK__MAX_RE_DECESC_DIGITS 9 +#define DUK__MAX_RE_QUANT_DIGITS 9 /* Does not allow e.g. 2**31-1, but one more would allow overflows of u32. */ + +/* whether to use macros or helper function depends on call count */ +#define DUK__ISDIGIT(x) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_9) +#define DUK__ISHEXDIGIT(x) duk__is_hex_digit((x)) +#define DUK__ISOCTDIGIT(x) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_7) +#define DUK__ISDIGIT03(x) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_3) +#define DUK__ISDIGIT47(x) ((x) >= DUK_ASC_4 && (x) <= DUK_ASC_7) + +/* lexer character window helpers */ +#define DUK__LOOKUP(lex_ctx,index) ((lex_ctx)->window[(index)].codepoint) +#define DUK__ADVANCECHARS(lex_ctx,count) duk__advance_bytes((lex_ctx), (count) * sizeof(duk_lexer_codepoint)) +#define DUK__ADVANCEBYTES(lex_ctx,count) duk__advance_bytes((lex_ctx), (count)) +#define DUK__INITBUFFER(lex_ctx) duk__initbuffer((lex_ctx)) +#define DUK__APPENDBUFFER(lex_ctx,x) duk__appendbuffer((lex_ctx), (duk_codepoint_t) (x)) + +/* lookup shorthands (note: assume context variable is named 'lex_ctx') */ +#define DUK__L0() DUK__LOOKUP(lex_ctx, 0) +#define DUK__L1() DUK__LOOKUP(lex_ctx, 1) +#define DUK__L2() DUK__LOOKUP(lex_ctx, 2) +#define DUK__L3() DUK__LOOKUP(lex_ctx, 3) +#define DUK__L4() DUK__LOOKUP(lex_ctx, 4) +#define DUK__L5() DUK__LOOKUP(lex_ctx, 5) + +/* packed advance/token number macro used by multiple functions */ +#define DUK__ADVTOK(advbytes,tok) ((((advbytes) * sizeof(duk_lexer_codepoint)) << 8) + (tok)) + +/* + * Advance lookup window by N characters, filling in new characters as + * necessary. After returning caller is guaranteed a character window of + * at least DUK_LEXER_WINDOW_SIZE characters. + * + * The main function duk__advance_bytes() is called at least once per every + * token so it has a major lexer/compiler performance impact. There are two + * variants for the main duk__advance_bytes() algorithm: a sliding window + * approach which is slightly faster at the cost of larger code footprint, + * and a simple copying one. + * + * Decoding directly from the source string would be another lexing option. + * But the lookup window based approach has the advantage of hiding the + * source string and its encoding effectively which gives more flexibility + * going forward to e.g. support chunked streaming of source from flash. + * + * Decodes UTF-8/CESU-8 leniently with support for code points from U+0000 to + * U+10FFFF, causing an error if the input is unparseable. Leniency means: + * + * * Unicode code point validation is intentionally not performed, + * except to check that the codepoint does not exceed 0x10ffff. + * + * * In particular, surrogate pairs are allowed and not combined, which + * allows source files to represent all SourceCharacters with CESU-8. + * Broken surrogate pairs are allowed, as Ecmascript does not mandate + * their validation. + * + * * Allow non-shortest UTF-8 encodings. + * + * Leniency here causes few security concerns because all character data is + * decoded into Unicode codepoints before lexer processing, and is then + * re-encoded into CESU-8. The source can be parsed as strict UTF-8 with + * a compiler option. However, Ecmascript source characters include -all- + * 16-bit unsigned integer codepoints, so leniency seems to be appropriate. + * + * Note that codepoints above the BMP are not strictly SourceCharacters, + * but the lexer still accepts them as such. Before ending up in a string + * or an identifier name, codepoints above BMP are converted into surrogate + * pairs and then CESU-8 encoded, resulting in 16-bit Unicode data as + * expected by Ecmascript. + * + * An alternative approach to dealing with invalid or partial sequences + * would be to skip them and replace them with e.g. the Unicode replacement + * character U+FFFD. This has limited utility because a replacement character + * will most likely cause a parse error, unless it occurs inside a string. + * Further, Ecmascript source is typically pure ASCII. + * + * See: + * + * http://en.wikipedia.org/wiki/UTF-8 + * http://en.wikipedia.org/wiki/CESU-8 + * http://tools.ietf.org/html/rfc3629 + * http://en.wikipedia.org/wiki/UTF-8#Invalid_byte_sequences + * + * Future work: + * + * * Reject other invalid Unicode sequences (see Wikipedia entry for examples) + * in strict UTF-8 mode. + * + * * Size optimize. An attempt to use a 16-byte lookup table for the first + * byte resulted in a code increase though. + * + * * Is checking against maximum 0x10ffff really useful? 4-byte encoding + * imposes a certain limit anyway. + * + * * Support chunked streaming of source code. Can be implemented either + * by streaming chunks of bytes or chunks of codepoints. + */ + +#if defined(DUK_USE_LEXER_SLIDING_WINDOW) +DUK_LOCAL void duk__fill_lexer_buffer(duk_lexer_ctx *lex_ctx, duk_small_uint_t start_offset_bytes) { + duk_lexer_codepoint *cp, *cp_end; + duk_ucodepoint_t x; + duk_small_uint_t contlen; + const duk_uint8_t *p, *p_end; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + duk_ucodepoint_t mincp; +#endif + duk_int_t input_line; + + /* Use temporaries and update lex_ctx only when finished. */ + input_line = lex_ctx->input_line; + p = lex_ctx->input + lex_ctx->input_offset; + p_end = lex_ctx->input + lex_ctx->input_length; + + cp = (duk_lexer_codepoint *) (void *) ((duk_uint8_t *) lex_ctx->buffer + start_offset_bytes); + cp_end = lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE; + + for (; cp != cp_end; cp++) { + cp->offset = (duk_size_t) (p - lex_ctx->input); + cp->line = input_line; + + /* XXX: potential issue with signed pointers, p_end < p. */ + if (DUK_UNLIKELY(p >= p_end)) { + /* If input_offset were assigned a negative value, it would + * result in a large positive value. Most likely it would be + * larger than input_length and be caught here. In any case + * no memory unsafe behavior would happen. + */ + cp->codepoint = -1; + continue; + } + + x = (duk_ucodepoint_t) (*p++); + + /* Fast path. */ + + if (DUK_LIKELY(x < 0x80UL)) { + DUK_ASSERT(x != 0x2028UL && x != 0x2029UL); /* not LS/PS */ + if (DUK_UNLIKELY(x <= 0x000dUL)) { + if ((x == 0x000aUL) || + ((x == 0x000dUL) && (p >= p_end || *p != 0x000aUL))) { + /* lookup for 0x000a above assumes shortest encoding now */ + + /* E5 Section 7.3, treat the following as newlines: + * LF + * CR [not followed by LF] + * LS + * PS + * + * For CR LF, CR is ignored if it is followed by LF, and the LF will bump + * the line number. + */ + input_line++; + } + } + + cp->codepoint = (duk_codepoint_t) x; + continue; + } + + /* Slow path. */ + + if (x < 0xc0UL) { + /* 10xx xxxx -> invalid */ + goto error_encoding; + } else if (x < 0xe0UL) { + /* 110x xxxx 10xx xxxx */ + contlen = 1; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + mincp = 0x80UL; +#endif + x = x & 0x1fUL; + } else if (x < 0xf0UL) { + /* 1110 xxxx 10xx xxxx 10xx xxxx */ + contlen = 2; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + mincp = 0x800UL; +#endif + x = x & 0x0fUL; + } else if (x < 0xf8UL) { + /* 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx */ + contlen = 3; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + mincp = 0x10000UL; +#endif + x = x & 0x07UL; + } else { + /* no point in supporting encodings of 5 or more bytes */ + goto error_encoding; + } + + DUK_ASSERT(p_end >= p); + if ((duk_size_t) contlen > (duk_size_t) (p_end - p)) { + goto error_clipped; + } + + while (contlen > 0) { + duk_small_uint_t y; + y = *p++; + if ((y & 0xc0U) != 0x80U) { + /* check that byte has the form 10xx xxxx */ + goto error_encoding; + } + x = x << 6; + x += y & 0x3fUL; + contlen--; + } + + /* check final character validity */ + + if (x > 0x10ffffUL) { + goto error_encoding; + } +#ifdef DUK_USE_STRICT_UTF8_SOURCE + if (x < mincp || (x >= 0xd800UL && x <= 0xdfffUL) || x == 0xfffeUL) { + goto error_encoding; + } +#endif + + DUK_ASSERT(x != 0x000aUL && x != 0x000dUL); + if ((x == 0x2028UL) || (x == 0x2029UL)) { + input_line++; + } + + cp->codepoint = (duk_codepoint_t) x; + } + + lex_ctx->input_offset = (duk_size_t) (p - lex_ctx->input); + lex_ctx->input_line = input_line; + return; + + error_clipped: /* clipped codepoint */ + error_encoding: /* invalid codepoint encoding or codepoint */ + lex_ctx->input_offset = (duk_size_t) (p - lex_ctx->input); + lex_ctx->input_line = input_line; + + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "char decode failed"); +} + +DUK_LOCAL void duk__advance_bytes(duk_lexer_ctx *lex_ctx, duk_small_uint_t count_bytes) { + duk_small_uint_t used_bytes, avail_bytes; + + DUK_ASSERT_DISABLE(count_bytes >= 0); /* unsigned */ + DUK_ASSERT(count_bytes <= (duk_small_uint_t) (DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint))); + DUK_ASSERT(lex_ctx->window >= lex_ctx->buffer); + DUK_ASSERT(lex_ctx->window < lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE); + DUK_ASSERT((duk_uint8_t *) lex_ctx->window + count_bytes <= (duk_uint8_t *) lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE * sizeof(duk_lexer_codepoint)); + + /* Zero 'count' is also allowed to make call sites easier. + * Arithmetic in bytes generates better code in GCC. + */ + + lex_ctx->window = (duk_lexer_codepoint *) (void *) ((duk_uint8_t *) lex_ctx->window + count_bytes); /* avoid multiply */ + used_bytes = (duk_small_uint_t) ((duk_uint8_t *) lex_ctx->window - (duk_uint8_t *) lex_ctx->buffer); + avail_bytes = DUK_LEXER_BUFFER_SIZE * sizeof(duk_lexer_codepoint) - used_bytes; + if (avail_bytes < (duk_small_uint_t) (DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint))) { + /* Not enough data to provide a full window, so "scroll" window to + * start of buffer and fill up the rest. + */ + DUK_MEMMOVE((void *) lex_ctx->buffer, + (const void *) lex_ctx->window, + (size_t) avail_bytes); + lex_ctx->window = lex_ctx->buffer; + duk__fill_lexer_buffer(lex_ctx, avail_bytes); + } +} + +DUK_LOCAL void duk__init_lexer_window(duk_lexer_ctx *lex_ctx) { + lex_ctx->window = lex_ctx->buffer; + duk__fill_lexer_buffer(lex_ctx, 0); +} +#else /* DUK_USE_LEXER_SLIDING_WINDOW */ +DUK_LOCAL duk_codepoint_t duk__read_char(duk_lexer_ctx *lex_ctx) { + duk_ucodepoint_t x; + duk_small_uint_t len; + duk_small_uint_t i; + const duk_uint8_t *p; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + duk_ucodepoint_t mincp; +#endif + duk_size_t input_offset; + + input_offset = lex_ctx->input_offset; + if (DUK_UNLIKELY(input_offset >= lex_ctx->input_length)) { + /* If input_offset were assigned a negative value, it would + * result in a large positive value. Most likely it would be + * larger than input_length and be caught here. In any case + * no memory unsafe behavior would happen. + */ + return -1; + } + + p = lex_ctx->input + input_offset; + x = (duk_ucodepoint_t) (*p); + + if (DUK_LIKELY(x < 0x80UL)) { + /* 0xxx xxxx -> fast path */ + + /* input offset tracking */ + lex_ctx->input_offset++; + + DUK_ASSERT(x != 0x2028UL && x != 0x2029UL); /* not LS/PS */ + if (DUK_UNLIKELY(x <= 0x000dUL)) { + if ((x == 0x000aUL) || + ((x == 0x000dUL) && (lex_ctx->input_offset >= lex_ctx->input_length || + lex_ctx->input[lex_ctx->input_offset] != 0x000aUL))) { + /* lookup for 0x000a above assumes shortest encoding now */ + + /* E5 Section 7.3, treat the following as newlines: + * LF + * CR [not followed by LF] + * LS + * PS + * + * For CR LF, CR is ignored if it is followed by LF, and the LF will bump + * the line number. + */ + lex_ctx->input_line++; + } + } + + return (duk_codepoint_t) x; + } + + /* Slow path. */ + + if (x < 0xc0UL) { + /* 10xx xxxx -> invalid */ + goto error_encoding; + } else if (x < 0xe0UL) { + /* 110x xxxx 10xx xxxx */ + len = 2; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + mincp = 0x80UL; +#endif + x = x & 0x1fUL; + } else if (x < 0xf0UL) { + /* 1110 xxxx 10xx xxxx 10xx xxxx */ + len = 3; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + mincp = 0x800UL; +#endif + x = x & 0x0fUL; + } else if (x < 0xf8UL) { + /* 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx */ + len = 4; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + mincp = 0x10000UL; +#endif + x = x & 0x07UL; + } else { + /* no point in supporting encodings of 5 or more bytes */ + goto error_encoding; + } + + DUK_ASSERT(lex_ctx->input_length >= lex_ctx->input_offset); + if ((duk_size_t) len > (duk_size_t) (lex_ctx->input_length - lex_ctx->input_offset)) { + goto error_clipped; + } + + p++; + for (i = 1; i < len; i++) { + duk_small_uint_t y; + y = *p++; + if ((y & 0xc0U) != 0x80U) { + /* check that byte has the form 10xx xxxx */ + goto error_encoding; + } + x = x << 6; + x += y & 0x3fUL; + } + + /* check final character validity */ + + if (x > 0x10ffffUL) { + goto error_encoding; + } +#ifdef DUK_USE_STRICT_UTF8_SOURCE + if (x < mincp || (x >= 0xd800UL && x <= 0xdfffUL) || x == 0xfffeUL) { + goto error_encoding; + } +#endif + + /* input offset tracking */ + lex_ctx->input_offset += len; + + /* line tracking */ + DUK_ASSERT(x != 0x000aUL && x != 0x000dUL); + if ((x == 0x2028UL) || (x == 0x2029UL)) { + lex_ctx->input_line++; + } + + return (duk_codepoint_t) x; + + error_clipped: /* clipped codepoint */ + error_encoding: /* invalid codepoint encoding or codepoint */ + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "char decode failed"); + return 0; +} + +DUK_LOCAL void duk__advance_bytes(duk_lexer_ctx *lex_ctx, duk_small_uint_t count_bytes) { + duk_small_uint_t keep_bytes; + duk_lexer_codepoint *cp, *cp_end; + + DUK_ASSERT_DISABLE(count_bytes >= 0); /* unsigned */ + DUK_ASSERT(count_bytes <= (duk_small_uint_t) (DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint))); + + /* Zero 'count' is also allowed to make call sites easier. */ + + keep_bytes = DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint) - count_bytes; + DUK_MEMMOVE((void *) lex_ctx->window, + (const void *) ((duk_uint8_t *) lex_ctx->window + count_bytes), + (duk_size_t) keep_bytes); + + cp = (duk_lexer_codepoint *) ((duk_uint8_t *) lex_ctx->window + keep_bytes); + cp_end = lex_ctx->window + DUK_LEXER_WINDOW_SIZE; + for (; cp != cp_end; cp++) { + cp->offset = lex_ctx->input_offset; + cp->line = lex_ctx->input_line; + cp->codepoint = duk__read_char(lex_ctx); + } +} + +DUK_LOCAL void duk__init_lexer_window(duk_lexer_ctx *lex_ctx) { + /* Call with count == DUK_LEXER_WINDOW_SIZE to fill buffer initially. */ + duk__advance_bytes(lex_ctx, DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint)); /* fill window */ +} +#endif /* DUK_USE_LEXER_SLIDING_WINDOW */ + +/* + * (Re)initialize the temporary byte buffer. May be called extra times + * with little impact. + */ + +DUK_LOCAL void duk__initbuffer(duk_lexer_ctx *lex_ctx) { + /* Reuse buffer as is unless buffer has grown large. */ + if (DUK_HBUFFER_DYNAMIC_GET_SIZE(lex_ctx->buf) < DUK_LEXER_TEMP_BUF_LIMIT) { + /* Keep current size */ + } else { + duk_hbuffer_resize(lex_ctx->thr, lex_ctx->buf, DUK_LEXER_TEMP_BUF_LIMIT); + } + + DUK_BW_INIT_WITHBUF(lex_ctx->thr, &lex_ctx->bw, lex_ctx->buf); +} + +/* + * Append a Unicode codepoint to the temporary byte buffer. Performs + * CESU-8 surrogate pair encoding for codepoints above the BMP. + * Existing surrogate pairs are allowed and also encoded into CESU-8. + */ + +DUK_LOCAL void duk__appendbuffer(duk_lexer_ctx *lex_ctx, duk_codepoint_t x) { + /* + * Since character data is only generated by decoding the source or by + * the compiler itself, we rely on the input codepoints being correct + * and avoid a check here. + * + * Character data can also come here through decoding of Unicode + * escapes ("\udead\ubeef") so all 16-but unsigned values can be + * present, even when the source file itself is strict UTF-8. + */ + + DUK_ASSERT(x >= 0 && x <= 0x10ffff); + + DUK_BW_WRITE_ENSURE_CESU8(lex_ctx->thr, &lex_ctx->bw, (duk_ucodepoint_t) x); +} + +/* + * Intern the temporary byte buffer into a valstack slot + * (in practice, slot1 or slot2). + */ + +DUK_LOCAL void duk__internbuffer(duk_lexer_ctx *lex_ctx, duk_idx_t valstack_idx) { + duk_context *ctx = (duk_context *) lex_ctx->thr; + + DUK_ASSERT(valstack_idx == lex_ctx->slot1_idx || valstack_idx == lex_ctx->slot2_idx); + + DUK_BW_PUSH_AS_STRING(lex_ctx->thr, &lex_ctx->bw); + duk_replace(ctx, valstack_idx); +} + +/* + * Init lexer context + */ + +DUK_INTERNAL void duk_lexer_initctx(duk_lexer_ctx *lex_ctx) { + DUK_ASSERT(lex_ctx != NULL); + + DUK_MEMZERO(lex_ctx, sizeof(*lex_ctx)); +#ifdef DUK_USE_EXPLICIT_NULL_INIT +#if defined(DUK_USE_LEXER_SLIDING_WINDOW) + lex_ctx->window = NULL; +#endif + lex_ctx->thr = NULL; + lex_ctx->input = NULL; + lex_ctx->buf = NULL; +#endif +} + +/* + * Set lexer input position and reinitialize lookup window. + */ + +/* NB: duk_lexer_getpoint() is a macro only */ + +DUK_INTERNAL void duk_lexer_setpoint(duk_lexer_ctx *lex_ctx, duk_lexer_point *pt) { + DUK_ASSERT_DISABLE(pt->offset >= 0); /* unsigned */ + DUK_ASSERT(pt->line >= 1); + lex_ctx->input_offset = pt->offset; + lex_ctx->input_line = pt->line; + duk__init_lexer_window(lex_ctx); +} + +/* + * Lexing helpers + */ + +/* numeric value of a hex digit (also covers octal and decimal digits) */ +DUK_LOCAL duk_codepoint_t duk__hexval(duk_lexer_ctx *lex_ctx, duk_codepoint_t x) { + duk_small_int_t t; + + /* Here 'x' is a Unicode codepoint */ + if (DUK_LIKELY(x >= 0 && x <= 0xff)) { + t = duk_hex_dectab[x]; + if (DUK_LIKELY(t >= 0)) { + return t; + } + } + + /* Throwing an error this deep makes the error rather vague, but + * saves hundreds of bytes of code. + */ + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "decode error"); + return 0; +} + +/* having this as a separate function provided a size benefit */ +DUK_LOCAL duk_bool_t duk__is_hex_digit(duk_codepoint_t x) { + if (DUK_LIKELY(x >= 0 && x <= 0xff)) { + return (duk_hex_dectab[x] >= 0); + } + return 0; +} + +DUK_LOCAL duk_codepoint_t duk__decode_hexesc_from_window(duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset) { + /* validation performed by duk__hexval */ + return (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset].codepoint) << 4) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 1].codepoint)); +} + +DUK_LOCAL duk_codepoint_t duk__decode_uniesc_from_window(duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset) { + /* validation performed by duk__hexval */ + return (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset].codepoint) << 12) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 1].codepoint) << 8) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 2].codepoint) << 4) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 3].codepoint)); +} + +/* + * Parse Ecmascript source InputElementDiv or InputElementRegExp + * (E5 Section 7), skipping whitespace, comments, and line terminators. + * + * Possible results are: + * (1) a token + * (2) a line terminator (skipped) + * (3) a comment (skipped) + * (4) EOF + * + * White space is automatically skipped from the current position (but + * not after the input element). If input has already ended, returns + * DUK_TOK_EOF indefinitely. If a parse error occurs, uses an DUK_ERROR() + * macro call (and hence a longjmp through current heap longjmp context). + * Comments and line terminator tokens are automatically skipped. + * + * The input element being matched is determined by regexp_mode; if set, + * parses a InputElementRegExp, otherwise a InputElementDiv. The + * difference between these are handling of productions starting with a + * forward slash. + * + * If strict_mode is set, recognizes additional future reserved words + * specific to strict mode, and refuses to parse octal literals. + * + * The matching strategy below is to (currently) use a six character + * lookup window to quickly determine which production is the -longest- + * matching one, and then parse that. The top-level if-else clauses + * match the first character, and the code blocks for each clause + * handle -all- alternatives for that first character. Ecmascript + * specification uses the "longest match wins" semantics, so the order + * of the if-clauses matters. + * + * Misc notes: + * + * * Ecmascript numeric literals do not accept a sign character. + * Consequently e.g. "-1.0" is parsed as two tokens: a negative + * sign and a positive numeric literal. The compiler performs + * the negation during compilation, so this has no adverse impact. + * + * * There is no token for "undefined": it is just a value available + * from the global object (or simply established by doing a reference + * to an undefined value). + * + * * Some contexts want Identifier tokens, which are IdentifierNames + * excluding reserved words, while some contexts want IdentifierNames + * directly. In the latter case e.g. "while" is interpreted as an + * identifier name, not a DUK_TOK_WHILE token. The solution here is + * to provide both token types: DUK_TOK_WHILE goes to 't' while + * DUK_TOK_IDENTIFIER goes to 't_nores', and 'slot1' always contains + * the identifier / keyword name. + * + * * Directive prologue needs to identify string literals such as + * "use strict" and 'use strict', which are sensitive to line + * continuations and escape sequences. For instance, "use\u0020strict" + * is a valid directive but is distinct from "use strict". The solution + * here is to decode escapes while tokenizing, but to keep track of the + * number of escapes. Directive detection can then check that the + * number of escapes is zero. + * + * * Multi-line comments with one or more internal LineTerminator are + * treated like a line terminator to comply with automatic semicolon + * insertion. + */ + +DUK_INTERNAL +void duk_lexer_parse_js_input_element(duk_lexer_ctx *lex_ctx, + duk_token *out_token, + duk_bool_t strict_mode, + duk_bool_t regexp_mode) { + duk_codepoint_t x; /* temporary, must be signed and 32-bit to hold Unicode code points */ + duk_small_uint_t advtok = 0; /* (advance << 8) + token_type, updated at function end, + * init is unnecessary but suppresses "may be used uninitialized" warnings. + */ + duk_bool_t got_lineterm = 0; /* got lineterm preceding non-whitespace, non-lineterm token */ + + if (++lex_ctx->token_count >= lex_ctx->token_limit) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_RANGE_ERROR, "token limit"); + return; /* unreachable */ + } + + out_token->t = DUK_TOK_EOF; + out_token->t_nores = -1; /* marker: copy t if not changed */ +#if 0 /* not necessary to init, disabled for faster parsing */ + out_token->num = DUK_DOUBLE_NAN; + out_token->str1 = NULL; + out_token->str2 = NULL; +#endif + out_token->num_escapes = 0; + /* out_token->lineterm set by caller */ + + /* This would be nice, but parsing is faster without resetting the + * value slots. The only side effect is that references to temporary + * string values may linger until lexing is finished; they're then + * freed normally. + */ +#if 0 + duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); + duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx); +#endif + + /* 'advtok' indicates how much to advance and which token id to assign + * at the end. This shared functionality minimizes code size. All + * code paths are required to set 'advtok' to some value, so no default + * init value is used. Code paths calling DUK_ERROR() never return so + * they don't need to set advtok. + */ + + /* + * Matching order: + * + * Punctuator first chars, also covers comments, regexps + * LineTerminator + * Identifier or reserved word, also covers null/true/false literals + * NumericLiteral + * StringLiteral + * EOF + * + * The order does not matter as long as the longest match is + * always correctly identified. There are order dependencies + * in the clauses, so it's not trivial to convert to a switch. + */ + + restart_lineupdate: + out_token->start_line = lex_ctx->window[0].line; + + restart: + out_token->start_offset = lex_ctx->window[0].offset; + + x = DUK__L0(); + + switch (x) { + case DUK_ASC_SPACE: + case DUK_ASC_HT: /* fast paths for space and tab */ + DUK__ADVANCECHARS(lex_ctx, 1); + goto restart; + case DUK_ASC_LF: /* LF line terminator; CR LF and Unicode lineterms are handled in slow path */ + DUK__ADVANCECHARS(lex_ctx, 1); + got_lineterm = 1; + goto restart_lineupdate; + case DUK_ASC_SLASH: /* '/' */ + if (DUK__L1() == '/') { + /* + * E5 Section 7.4, allow SourceCharacter (which is any 16-bit + * code point). + */ + + /* DUK__ADVANCECHARS(lex_ctx, 2) would be correct here, but it unnecessary */ + for (;;) { + x = DUK__L0(); + if (x < 0 || duk_unicode_is_line_terminator(x)) { + break; + } + DUK__ADVANCECHARS(lex_ctx, 1); + } + goto restart; /* line terminator will be handled on next round */ + } else if (DUK__L1() == '*') { + /* + * E5 Section 7.4. If the multi-line comment contains a newline, + * it is treated like a single line terminator for automatic + * semicolon insertion. + */ + + duk_bool_t last_asterisk = 0; + DUK__ADVANCECHARS(lex_ctx, 2); + for (;;) { + x = DUK__L0(); + if (x < 0) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "eof while parsing multiline comment"); + } + DUK__ADVANCECHARS(lex_ctx, 1); + if (last_asterisk && x == '/') { + break; + } + if (duk_unicode_is_line_terminator(x)) { + got_lineterm = 1; + } + last_asterisk = (x == '*'); + } + goto restart_lineupdate; + } else if (regexp_mode) { +#ifdef DUK_USE_REGEXP_SUPPORT + /* + * "/" followed by something in regexp mode. See E5 Section 7.8.5. + * + * RegExp parsing is a bit complex. First, the regexp body is delimited + * by forward slashes, but the body may also contain forward slashes as + * part of an escape sequence or inside a character class (delimited by + * square brackets). A mini state machine is used to implement these. + * + * Further, an early (parse time) error must be thrown if the regexp + * would cause a run-time error when used in the expression new RegExp(...). + * Parsing here simply extracts the (candidate) regexp, and also accepts + * invalid regular expressions (which are delimited properly). The caller + * (compiler) must perform final validation and regexp compilation. + * + * RegExp first char may not be '/' (single line comment) or '*' (multi- + * line comment). These have already been checked above, so there is no + * need below for special handling of the first regexp character as in + * the E5 productions. + * + * About unicode escapes within regexp literals: + * + * E5 Section 7.8.5 grammar does NOT accept \uHHHH escapes. + * However, Section 6 states that regexps accept the escapes, + * see paragraph starting with "In string literals...". + * The regexp grammar, which sees the decoded regexp literal + * (after lexical parsing) DOES have a \uHHHH unicode escape. + * So, for instance: + * + * /\u1234/ + * + * should first be parsed by the lexical grammar as: + * + * '\' 'u' RegularExpressionBackslashSequence + * '1' RegularExpressionNonTerminator + * '2' RegularExpressionNonTerminator + * '3' RegularExpressionNonTerminator + * '4' RegularExpressionNonTerminator + * + * and the escape itself is then parsed by the regexp engine. + * This is the current implementation. + * + * Minor spec inconsistency: + * + * E5 Section 7.8.5 RegularExpressionBackslashSequence is: + * + * \ RegularExpressionNonTerminator + * + * while Section A.1 RegularExpressionBackslashSequence is: + * + * \ NonTerminator + * + * The latter is not normative and a typo. + * + */ + + /* first, parse regexp body roughly */ + + duk_small_int_t state = 0; /* 0=base, 1=esc, 2=class, 3=class+esc */ + + DUK__INITBUFFER(lex_ctx); + for (;;) { + DUK__ADVANCECHARS(lex_ctx, 1); /* skip opening slash on first loop */ + x = DUK__L0(); + if (x < 0 || duk_unicode_is_line_terminator(x)) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "eof or line terminator while parsing regexp"); + } + x = DUK__L0(); /* re-read to avoid spill / fetch */ + if (state == 0) { + if (x == '/') { + DUK__ADVANCECHARS(lex_ctx, 1); /* eat closing slash */ + break; + } else if (x == '\\') { + state = 1; + } else if (x == '[') { + state = 2; + } + } else if (state == 1) { + state = 0; + } else if (state == 2) { + if (x == ']') { + state = 0; + } else if (x == '\\') { + state = 3; + } + } else { /* state == 3 */ + state = 2; + } + DUK__APPENDBUFFER(lex_ctx, x); + } + duk__internbuffer(lex_ctx, lex_ctx->slot1_idx); + out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); + + /* second, parse flags */ + + DUK__INITBUFFER(lex_ctx); + for (;;) { + x = DUK__L0(); + if (!duk_unicode_is_identifier_part(x)) { + break; + } + x = DUK__L0(); /* re-read to avoid spill / fetch */ + DUK__APPENDBUFFER(lex_ctx, x); + DUK__ADVANCECHARS(lex_ctx, 1); + } + duk__internbuffer(lex_ctx, lex_ctx->slot2_idx); + out_token->str2 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx); + + DUK__INITBUFFER(lex_ctx); /* free some memory */ + + /* validation of the regexp is caller's responsibility */ + + advtok = DUK__ADVTOK(0, DUK_TOK_REGEXP); +#else + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "regexp support disabled"); +#endif + } else if (DUK__L1() == '=') { + /* "/=" and not in regexp mode */ + advtok = DUK__ADVTOK(2, DUK_TOK_DIV_EQ); + } else { + /* "/" and not in regexp mode */ + advtok = DUK__ADVTOK(1, DUK_TOK_DIV); + } + break; + case DUK_ASC_LCURLY: /* '{' */ + advtok = DUK__ADVTOK(1, DUK_TOK_LCURLY); + break; + case DUK_ASC_RCURLY: /* '}' */ + advtok = DUK__ADVTOK(1, DUK_TOK_RCURLY); + break; + case DUK_ASC_LPAREN: /* '(' */ + advtok = DUK__ADVTOK(1, DUK_TOK_LPAREN); + break; + case DUK_ASC_RPAREN: /* ')' */ + advtok = DUK__ADVTOK(1, DUK_TOK_RPAREN); + break; + case DUK_ASC_LBRACKET: /* '[' */ + advtok = DUK__ADVTOK(1, DUK_TOK_LBRACKET); + break; + case DUK_ASC_RBRACKET: /* ']' */ + advtok = DUK__ADVTOK(1, DUK_TOK_RBRACKET); + break; + case DUK_ASC_PERIOD: /* '.' */ + if (DUK__ISDIGIT(DUK__L1())) { + /* Period followed by a digit can only start DecimalLiteral + * (handled in slow path). We could jump straight into the + * DecimalLiteral handling but should avoid goto to inside + * a block. + */ + goto slow_path; + } + advtok = DUK__ADVTOK(1, DUK_TOK_PERIOD); + break; + case DUK_ASC_SEMICOLON: /* ';' */ + advtok = DUK__ADVTOK(1, DUK_TOK_SEMICOLON); + break; + case DUK_ASC_COMMA: /* ',' */ + advtok = DUK__ADVTOK(1, DUK_TOK_COMMA); + break; + case DUK_ASC_LANGLE: /* '<' */ + if (DUK__L1() == '<' && DUK__L2() == '=') { + advtok = DUK__ADVTOK(3, DUK_TOK_ALSHIFT_EQ); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_LE); + } else if (DUK__L1() == '<') { + advtok = DUK__ADVTOK(2, DUK_TOK_ALSHIFT); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_LT); + } + break; + case DUK_ASC_RANGLE: /* '>' */ + if (DUK__L1() == '>' && DUK__L2() == '>' && DUK__L3() == '=') { + advtok = DUK__ADVTOK(4, DUK_TOK_RSHIFT_EQ); + } else if (DUK__L1() == '>' && DUK__L2() == '>') { + advtok = DUK__ADVTOK(3, DUK_TOK_RSHIFT); + } else if (DUK__L1() == '>' && DUK__L2() == '=') { + advtok = DUK__ADVTOK(3, DUK_TOK_ARSHIFT_EQ); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_GE); + } else if (DUK__L1() == '>') { + advtok = DUK__ADVTOK(2, DUK_TOK_ARSHIFT); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_GT); + } + break; + case DUK_ASC_EQUALS: /* '=' */ + if (DUK__L1() == '=' && DUK__L2() == '=') { + advtok = DUK__ADVTOK(3, DUK_TOK_SEQ); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_EQUALSIGN); + } + break; + case DUK_ASC_EXCLAMATION: /* '!' */ + if (DUK__L1() == '=' && DUK__L2() == '=') { + advtok = DUK__ADVTOK(3, DUK_TOK_SNEQ); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_NEQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_LNOT); + } + break; + case DUK_ASC_PLUS: /* '+' */ + if (DUK__L1() == '+') { + advtok = DUK__ADVTOK(2, DUK_TOK_INCREMENT); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_ADD_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_ADD); + } + break; + case DUK_ASC_MINUS: /* '-' */ + if (DUK__L1() == '-') { + advtok = DUK__ADVTOK(2, DUK_TOK_DECREMENT); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_SUB_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_SUB); + } + break; + case DUK_ASC_STAR: /* '*' */ + if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_MUL_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_MUL); + } + break; + case DUK_ASC_PERCENT: /* '%' */ + if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_MOD_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_MOD); + } + break; + case DUK_ASC_AMP: /* '&' */ + if (DUK__L1() == '&') { + advtok = DUK__ADVTOK(2, DUK_TOK_LAND); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_BAND_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_BAND); + } + break; + case DUK_ASC_PIPE: /* '|' */ + if (DUK__L1() == '|') { + advtok = DUK__ADVTOK(2, DUK_TOK_LOR); + } else if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_BOR_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_BOR); + } + break; + case DUK_ASC_CARET: /* '^' */ + if (DUK__L1() == '=') { + advtok = DUK__ADVTOK(2, DUK_TOK_BXOR_EQ); + } else { + advtok = DUK__ADVTOK(1, DUK_TOK_BXOR); + } + break; + case DUK_ASC_TILDE: /* '~' */ + advtok = DUK__ADVTOK(1, DUK_TOK_BNOT); + break; + case DUK_ASC_QUESTION: /* '?' */ + advtok = DUK__ADVTOK(1, DUK_TOK_QUESTION); + break; + case DUK_ASC_COLON: /* ':' */ + advtok = DUK__ADVTOK(1, DUK_TOK_COLON); + break; + case DUK_ASC_DOUBLEQUOTE: /* '"' */ + case DUK_ASC_SINGLEQUOTE: { /* '\'' */ + duk_small_int_t quote = x; /* Note: duk_uint8_t type yields larger code */ + duk_small_int_t adv; + + DUK__INITBUFFER(lex_ctx); + for (;;) { + DUK__ADVANCECHARS(lex_ctx, 1); /* eat opening quote on first loop */ + x = DUK__L0(); + if (x < 0 || duk_unicode_is_line_terminator(x)) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "eof or line terminator while parsing string literal"); + } + if (x == quote) { + DUK__ADVANCECHARS(lex_ctx, 1); /* eat closing quote */ + break; + } + if (x == '\\') { + /* DUK__L0 -> '\' char + * DUK__L1 ... DUK__L5 -> more lookup + */ + + x = DUK__L1(); + + /* How much to advance before next loop; note that next loop + * will advance by 1 anyway, so -1 from the total escape + * length (e.g. len('\uXXXX') - 1 = 6 - 1). As a default, + * 1 is good. + */ + adv = 2 - 1; /* note: long live range */ + + if (x < 0) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "eof while parsing string literal"); + } + if (duk_unicode_is_line_terminator(x)) { + /* line continuation */ + if (x == 0x000d && DUK__L2() == 0x000a) { + /* CR LF again a special case */ + adv = 3 - 1; + } + } else if (x == '\'') { + DUK__APPENDBUFFER(lex_ctx, 0x0027); + } else if (x == '"') { + DUK__APPENDBUFFER(lex_ctx, 0x0022); + } else if (x == '\\') { + DUK__APPENDBUFFER(lex_ctx, 0x005c); + } else if (x == 'b') { + DUK__APPENDBUFFER(lex_ctx, 0x0008); + } else if (x == 'f') { + DUK__APPENDBUFFER(lex_ctx, 0x000c); + } else if (x == 'n') { + DUK__APPENDBUFFER(lex_ctx, 0x000a); + } else if (x == 'r') { + DUK__APPENDBUFFER(lex_ctx, 0x000d); + } else if (x == 't') { + DUK__APPENDBUFFER(lex_ctx, 0x0009); + } else if (x == 'v') { + DUK__APPENDBUFFER(lex_ctx, 0x000b); + } else if (x == 'x') { + adv = 4 - 1; + DUK__APPENDBUFFER(lex_ctx, duk__decode_hexesc_from_window(lex_ctx, 2)); + } else if (x == 'u') { + adv = 6 - 1; + DUK__APPENDBUFFER(lex_ctx, duk__decode_uniesc_from_window(lex_ctx, 2)); + } else if (DUK__ISDIGIT(x)) { + duk_codepoint_t ch = 0; /* initialized to avoid warnings of unused var */ + + /* + * Octal escape or zero escape: + * \0 (lookahead not DecimalDigit) + * \1 ... \7 (lookahead not DecimalDigit) + * \ZeroToThree OctalDigit (lookahead not DecimalDigit) + * \FourToSeven OctalDigit (no lookahead restrictions) + * \ZeroToThree OctalDigit OctalDigit (no lookahead restrictions) + * + * Zero escape is part of the standard syntax. Octal escapes are + * defined in E5 Section B.1.2, and are only allowed in non-strict mode. + * Any other productions starting with a decimal digit are invalid. + */ + + if (x == '0' && !DUK__ISDIGIT(DUK__L2())) { + /* Zero escape (also allowed in non-strict mode) */ + ch = 0; + /* adv = 2 - 1 default OK */ +#ifdef DUK_USE_OCTAL_SUPPORT + } else if (strict_mode) { + /* No other escape beginning with a digit in strict mode */ + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid escape while parsing string literal"); + } else if (DUK__ISDIGIT03(x) && DUK__ISOCTDIGIT(DUK__L2()) && DUK__ISOCTDIGIT(DUK__L3())) { + /* Three digit octal escape, digits validated. */ + adv = 4 - 1; + ch = (duk__hexval(lex_ctx, x) << 6) + + (duk__hexval(lex_ctx, DUK__L2()) << 3) + + duk__hexval(lex_ctx, DUK__L3()); + } else if (((DUK__ISDIGIT03(x) && !DUK__ISDIGIT(DUK__L3())) || DUK__ISDIGIT47(x)) && + DUK__ISOCTDIGIT(DUK__L2())) { + /* Two digit octal escape, digits validated. + * + * The if-condition is a bit tricky. We could catch e.g. + * '\039' in the three-digit escape and fail it there (by + * validating the digits), but we want to avoid extra + * additional validation code. + */ + adv = 3 - 1; + ch = (duk__hexval(lex_ctx, x) << 3) + + duk__hexval(lex_ctx, DUK__L2()); + } else if (DUK__ISDIGIT(x) && !DUK__ISDIGIT(DUK__L2())) { + /* One digit octal escape, digit validated. */ + /* adv = 2 default OK */ + ch = duk__hexval(lex_ctx, x); +#else + /* fall through to error */ +#endif + } else { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid escape while parsing string literal"); + } + + DUK__APPENDBUFFER(lex_ctx, ch); + } else { + /* escaped NonEscapeCharacter */ + DUK__APPENDBUFFER(lex_ctx, x); + } + DUK__ADVANCECHARS(lex_ctx, adv); + + /* Track number of escapes; count not really needed but directive + * prologues need to detect whether there were any escapes or line + * continuations or not. + */ + out_token->num_escapes++; + } else { + /* part of string */ + DUK__APPENDBUFFER(lex_ctx, x); + } + } + + duk__internbuffer(lex_ctx, lex_ctx->slot1_idx); + out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); + + DUK__INITBUFFER(lex_ctx); /* free some memory */ + + advtok = DUK__ADVTOK(0, DUK_TOK_STRING); + break; + } + default: + goto slow_path; + } /* switch */ + + goto skip_slow_path; + + slow_path: + if (duk_unicode_is_line_terminator(x)) { + if (x == 0x000d && DUK__L1() == 0x000a) { + /* + * E5 Section 7.3: CR LF is detected as a single line terminator for + * line numbers. Here we also detect it as a single line terminator + * token. + */ + DUK__ADVANCECHARS(lex_ctx, 2); + } else { + DUK__ADVANCECHARS(lex_ctx, 1); + } + got_lineterm = 1; + goto restart_lineupdate; + } else if (duk_unicode_is_identifier_start(x) || x == '\\') { + /* + * Parse an identifier and then check whether it is: + * - reserved word (keyword or other reserved word) + * - "null" (NullLiteral) + * - "true" (BooleanLiteral) + * - "false" (BooleanLiteral) + * - anything else => identifier + * + * This does not follow the E5 productions cleanly, but is + * useful and compact. + * + * Note that identifiers may contain Unicode escapes, + * see E5 Sections 6 and 7.6. They must be decoded first, + * and the result checked against allowed characters. + * The above if-clause accepts an identifier start and an + * '\' character -- no other token can begin with a '\'. + * + * Note that "get" and "set" are not reserved words in E5 + * specification so they are recognized as plain identifiers + * (the tokens DUK_TOK_GET and DUK_TOK_SET are actually not + * used now). The compiler needs to work around this. + * + * Strictly speaking, following Ecmascript longest match + * specification, an invalid escape for the first character + * should cause a syntax error. However, an invalid escape + * for IdentifierParts should just terminate the identifier + * early (longest match), and let the next tokenization + * fail. For instance Rhino croaks with 'foo\z' when + * parsing the identifier. This has little practical impact. + */ + + duk_small_int_t i, i_end; + duk_bool_t first = 1; + duk_hstring *str; + + DUK__INITBUFFER(lex_ctx); + for (;;) { + /* re-lookup first char on first loop */ + if (DUK__L0() == '\\') { + duk_codepoint_t ch; + if (DUK__L1() != 'u') { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid unicode escape while parsing identifier"); + } + + ch = duk__decode_uniesc_from_window(lex_ctx, 2); + + /* IdentifierStart is stricter than IdentifierPart, so if the first + * character is escaped, must have a stricter check here. + */ + if (!(first ? duk_unicode_is_identifier_start(ch) : duk_unicode_is_identifier_part(ch))) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid unicode escaped character while parsing identifier"); + } + DUK__APPENDBUFFER(lex_ctx, ch); + DUK__ADVANCECHARS(lex_ctx, 6); + + /* Track number of escapes: necessary for proper keyword + * detection. + */ + out_token->num_escapes++; + } else { + /* Note: first character is checked against this. But because + * IdentifierPart includes all IdentifierStart characters, and + * the first character (if unescaped) has already been checked + * in the if condition, this is OK. + */ + if (!duk_unicode_is_identifier_part(DUK__L0())) { + break; + } + DUK__APPENDBUFFER(lex_ctx, DUK__L0()); + DUK__ADVANCECHARS(lex_ctx, 1); + } + first = 0; + } + + duk__internbuffer(lex_ctx, lex_ctx->slot1_idx); + out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); + str = out_token->str1; + DUK_ASSERT(str != NULL); + out_token->t_nores = DUK_TOK_IDENTIFIER; + + DUK__INITBUFFER(lex_ctx); /* free some memory */ + + /* + * Interned identifier is compared against reserved words, which are + * currently interned into the heap context. See genstrings.py. + * + * Note that an escape in the identifier disables recognition of + * keywords; e.g. "\u0069f = 1;" is a valid statement (assigns to + * identifier named "if"). This is not necessarily compliant, + * see test-dec-escaped-char-in-keyword.js. + * + * Note: "get" and "set" are awkward. They are not officially + * ReservedWords (and indeed e.g. "var set = 1;" is valid), and + * must come out as DUK_TOK_IDENTIFIER. The compiler needs to + * work around this a bit. + */ + + /* XXX: optimize by adding the token numbers directly into the + * always interned duk_hstring objects (there should be enough + * flag bits free for that)? + */ + + i_end = (strict_mode ? DUK_STRIDX_END_RESERVED : DUK_STRIDX_START_STRICT_RESERVED); + + advtok = DUK__ADVTOK(0, DUK_TOK_IDENTIFIER); + if (out_token->num_escapes == 0) { + for (i = DUK_STRIDX_START_RESERVED; i < i_end; i++) { + DUK_ASSERT(i >= 0 && i < DUK_HEAP_NUM_STRINGS); + if (DUK_HTHREAD_GET_STRING(lex_ctx->thr, i) == str) { + advtok = DUK__ADVTOK(0, DUK_STRIDX_TO_TOK(i)); + break; + } + } + } + } else if (DUK__ISDIGIT(x) || (x == '.')) { + /* Note: decimal number may start with a period, but must be followed by a digit */ + + /* + * DecimalLiteral, HexIntegerLiteral, OctalIntegerLiteral + * "pre-parsing", followed by an actual, accurate parser step. + * + * Note: the leading sign character ('+' or '-') is -not- part of + * the production in E5 grammar, and that the a DecimalLiteral + * starting with a '0' must be followed by a non-digit. Leading + * zeroes are syntax errors and must be checked for. + * + * XXX: the two step parsing process is quite awkward, it would + * be more straightforward to allow numconv to parse the longest + * valid prefix (it already does that, it only needs to indicate + * where the input ended). However, the lexer decodes characters + * using a lookup window, so this is not a trivial change. + */ + + /* XXX: because of the final check below (that the literal is not + * followed by a digit), this could maybe be simplified, if we bail + * out early from a leading zero (and if there are no periods etc). + * Maybe too complex. + */ + + duk_double_t val; + duk_bool_t int_only = 0; + duk_bool_t allow_hex = 0; + duk_small_int_t state; /* 0=before period/exp, + * 1=after period, before exp + * 2=after exp, allow '+' or '-' + * 3=after exp and exp sign + */ + duk_small_uint_t s2n_flags; + duk_codepoint_t y; + + DUK__INITBUFFER(lex_ctx); + y = DUK__L1(); + if (x == '0' && (y == 'x' || y == 'X')) { + DUK__APPENDBUFFER(lex_ctx, x); + DUK__APPENDBUFFER(lex_ctx, y); + DUK__ADVANCECHARS(lex_ctx, 2); + int_only = 1; + allow_hex = 1; +#ifdef DUK_USE_OCTAL_SUPPORT + } else if (!strict_mode && x == '0' && DUK__ISDIGIT(y)) { + /* Note: if DecimalLiteral starts with a '0', it can only be + * followed by a period or an exponent indicator which starts + * with 'e' or 'E'. Hence the if-check above ensures that + * OctalIntegerLiteral is the only valid NumericLiteral + * alternative at this point (even if y is, say, '9'). + */ + + DUK__APPENDBUFFER(lex_ctx, x); + DUK__ADVANCECHARS(lex_ctx, 1); + int_only = 1; +#endif + } + + state = 0; + for (;;) { + x = DUK__L0(); /* re-lookup curr char on first round */ + if (DUK__ISDIGIT(x)) { + /* Note: intentionally allow leading zeroes here, as the + * actual parser will check for them. + */ + if (state == 2) { + state = 3; + } + } else if (allow_hex && DUK__ISHEXDIGIT(x)) { + /* Note: 'e' and 'E' are also accepted here. */ + ; + } else if (x == '.') { + if (state >= 1 || int_only) { + break; + } else { + state = 1; + } + } else if (x == 'e' || x == 'E') { + if (state >= 2 || int_only) { + break; + } else { + state = 2; + } + } else if (x == '-' || x == '+') { + if (state != 2) { + break; + } else { + state = 3; + } + } else { + break; + } + DUK__APPENDBUFFER(lex_ctx, x); + DUK__ADVANCECHARS(lex_ctx, 1); + } + + /* XXX: better coercion */ + duk__internbuffer(lex_ctx, lex_ctx->slot1_idx); + + s2n_flags = DUK_S2N_FLAG_ALLOW_EXP | + DUK_S2N_FLAG_ALLOW_FRAC | + DUK_S2N_FLAG_ALLOW_NAKED_FRAC | + DUK_S2N_FLAG_ALLOW_EMPTY_FRAC | +#ifdef DUK_USE_OCTAL_SUPPORT + (strict_mode ? 0 : DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT) | +#endif + DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT; + + duk_dup((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); + duk_numconv_parse((duk_context *) lex_ctx->thr, 10 /*radix*/, s2n_flags); + val = duk_to_number((duk_context *) lex_ctx->thr, -1); + if (DUK_ISNAN(val)) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "invalid numeric literal"); + } + duk_replace((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); /* could also just pop? */ + + DUK__INITBUFFER(lex_ctx); /* free some memory */ + + /* Section 7.8.3 (note): NumericLiteral must be followed by something other than + * IdentifierStart or DecimalDigit. + */ + + if (DUK__ISDIGIT(DUK__L0()) || duk_unicode_is_identifier_start(DUK__L0())) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "invalid numeric literal"); + } + + out_token->num = val; + advtok = DUK__ADVTOK(0, DUK_TOK_NUMBER); + } else if (duk_unicode_is_whitespace(DUK__LOOKUP(lex_ctx, 0))) { + DUK__ADVANCECHARS(lex_ctx, 1); + goto restart; + } else if (x < 0) { + advtok = DUK__ADVTOK(0, DUK_TOK_EOF); + } else { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "error parsing token"); + } + skip_slow_path: + + /* + * Shared exit path + */ + + DUK__ADVANCEBYTES(lex_ctx, advtok >> 8); + out_token->t = advtok & 0xff; + if (out_token->t_nores < 0) { + out_token->t_nores = out_token->t; + } + out_token->lineterm = got_lineterm; + + /* Automatic semicolon insertion is allowed if a token is preceded + * by line terminator(s), or terminates a statement list (right curly + * or EOF). + */ + if (got_lineterm || out_token->t == DUK_TOK_RCURLY || out_token->t == DUK_TOK_EOF) { + out_token->allow_auto_semi = 1; + } else { + out_token->allow_auto_semi = 0; + } +} + +#ifdef DUK_USE_REGEXP_SUPPORT + +/* + * Parse a RegExp token. The grammar is described in E5 Section 15.10. + * Terminal constructions (such as quantifiers) are parsed directly here. + * + * 0xffffffffU is used as a marker for "infinity" in quantifiers. Further, + * DUK__MAX_RE_QUANT_DIGITS limits the maximum number of digits that + * will be accepted for a quantifier. + */ + +DUK_INTERNAL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token *out_token) { + duk_small_int_t advtok = 0; /* init is unnecessary but suppresses "may be used uninitialized" warnings */ + duk_codepoint_t x, y; + + if (++lex_ctx->token_count >= lex_ctx->token_limit) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_RANGE_ERROR, "token limit"); + return; /* unreachable */ + } + + DUK_MEMZERO(out_token, sizeof(*out_token)); + + x = DUK__L0(); + y = DUK__L1(); + + DUK_DDD(DUK_DDDPRINT("parsing regexp token, L0=%ld, L1=%ld", (long) x, (long) y)); + + switch (x) { + case '|': { + advtok = DUK__ADVTOK(1, DUK_RETOK_DISJUNCTION); + break; + } + case '^': { + advtok = DUK__ADVTOK(1, DUK_RETOK_ASSERT_START); + break; + } + case '$': { + advtok = DUK__ADVTOK(1, DUK_RETOK_ASSERT_END); + break; + } + case '?': { + out_token->qmin = 0; + out_token->qmax = 1; + if (y == '?') { + advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER); + out_token->greedy = 0; + } else { + advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER); + out_token->greedy = 1; + } + break; + } + case '*': { + out_token->qmin = 0; + out_token->qmax = DUK_RE_QUANTIFIER_INFINITE; + if (y == '?') { + advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER); + out_token->greedy = 0; + } else { + advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER); + out_token->greedy = 1; + } + break; + } + case '+': { + out_token->qmin = 1; + out_token->qmax = DUK_RE_QUANTIFIER_INFINITE; + if (y == '?') { + advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER); + out_token->greedy = 0; + } else { + advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER); + out_token->greedy = 1; + } + break; + } + case '{': { + /* Production allows 'DecimalDigits', including leading zeroes */ + duk_uint_fast32_t val1 = 0; + duk_uint_fast32_t val2 = DUK_RE_QUANTIFIER_INFINITE; + duk_small_int_t digits = 0; + for (;;) { + DUK__ADVANCECHARS(lex_ctx, 1); /* eat '{' on entry */ + x = DUK__L0(); + if (DUK__ISDIGIT(x)) { + if (digits >= DUK__MAX_RE_QUANT_DIGITS) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp quantifier (too many digits)"); + } + digits++; + val1 = val1 * 10 + (duk_uint_fast32_t) duk__hexval(lex_ctx, x); + } else if (x == ',') { + if (val2 != DUK_RE_QUANTIFIER_INFINITE) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp quantifier (double comma)"); + } + if (DUK__L1() == '}') { + /* form: { DecimalDigits , }, val1 = min count */ + if (digits == 0) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp quantifier (missing digits)"); + } + out_token->qmin = val1; + out_token->qmax = DUK_RE_QUANTIFIER_INFINITE; + DUK__ADVANCECHARS(lex_ctx, 2); + break; + } + val2 = val1; + val1 = 0; + digits = 0; /* not strictly necessary because of lookahead '}' above */ + } else if (x == '}') { + if (digits == 0) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp quantifier (missing digits)"); + } + if (val2 != DUK_RE_QUANTIFIER_INFINITE) { + /* val2 = min count, val1 = max count */ + out_token->qmin = val2; + out_token->qmax = val1; + } else { + /* val1 = count */ + out_token->qmin = val1; + out_token->qmax = val1; + } + DUK__ADVANCECHARS(lex_ctx, 1); + break; + } else { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp quantifier (unknown char)"); + } + } + if (DUK__L0() == '?') { + out_token->greedy = 0; + DUK__ADVANCECHARS(lex_ctx, 1); + } else { + out_token->greedy = 1; + } + advtok = DUK__ADVTOK(0, DUK_RETOK_QUANTIFIER); + break; + } + case '.': { + advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_PERIOD); + break; + } + case '\\': { + /* The E5.1 specification does not seem to allow IdentifierPart characters + * to be used as identity escapes. Unfortunately this includes '$', which + * cannot be escaped as '\$'; it needs to be escaped e.g. as '\u0024'. + * Many other implementations (including V8 and Rhino, for instance) do + * accept '\$' as a valid identity escape, which is quite pragmatic. + * See: test-regexp-identity-escape-dollar.js. + */ + + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_CHAR); /* default: char escape (two chars) */ + if (y == 'b') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ASSERT_WORD_BOUNDARY); + } else if (y == 'B') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY); + } else if (y == 'f') { + out_token->num = 0x000c; + } else if (y == 'n') { + out_token->num = 0x000a; + } else if (y == 't') { + out_token->num = 0x0009; + } else if (y == 'r') { + out_token->num = 0x000d; + } else if (y == 'v') { + out_token->num = 0x000b; + } else if (y == 'c') { + x = DUK__L2(); + if ((x >= 'a' && x <= 'z') || + (x >= 'A' && x <= 'Z')) { + out_token->num = (x % 32); + advtok = DUK__ADVTOK(3, DUK_RETOK_ATOM_CHAR); + } else { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp control escape"); + } + } else if (y == 'x') { + out_token->num = duk__decode_hexesc_from_window(lex_ctx, 2); + advtok = DUK__ADVTOK(4, DUK_RETOK_ATOM_CHAR); + } else if (y == 'u') { + out_token->num = duk__decode_uniesc_from_window(lex_ctx, 2); + advtok = DUK__ADVTOK(6, DUK_RETOK_ATOM_CHAR); + } else if (y == 'd') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_DIGIT); + } else if (y == 'D') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_DIGIT); + } else if (y == 's') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_WHITE); + } else if (y == 'S') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_WHITE); + } else if (y == 'w') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_WORD_CHAR); + } else if (y == 'W') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_WORD_CHAR); + } else if (DUK__ISDIGIT(y)) { + /* E5 Section 15.10.2.11 */ + if (y == '0') { + if (DUK__ISDIGIT(DUK__L2())) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp escape"); + } + out_token->num = 0x0000; + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_CHAR); + } else { + /* XXX: shared parsing? */ + duk_uint_fast32_t val = 0; + duk_small_int_t i; + for (i = 0; ; i++) { + if (i >= DUK__MAX_RE_DECESC_DIGITS) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp escape (decimal escape too long)"); + } + DUK__ADVANCECHARS(lex_ctx, 1); /* eat backslash on entry */ + x = DUK__L0(); + if (!DUK__ISDIGIT(x)) { + break; + } + val = val * 10 + (duk_uint_fast32_t) duk__hexval(lex_ctx, x); + } + /* DUK__L0() cannot be a digit, because the loop doesn't terminate if it is */ + advtok = DUK__ADVTOK(0, DUK_RETOK_ATOM_BACKREFERENCE); + out_token->num = val; + } + } else if ((y >= 0 && !duk_unicode_is_identifier_part(y)) || +#if defined(DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE) + y == '$' || +#endif + y == DUK_UNICODE_CP_ZWNJ || + y == DUK_UNICODE_CP_ZWJ) { + /* IdentityEscape, with dollar added as a valid additional + * non-standard escape (see test-regexp-identity-escape-dollar.js). + * Careful not to match end-of-buffer (<0) here. + */ + out_token->num = y; + } else { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp escape"); + } + break; + } + case '(': { + /* XXX: naming is inconsistent: ATOM_END_GROUP ends an ASSERT_START_LOOKAHEAD */ + + if (y == '?') { + if (DUK__L2() == '=') { + /* (?= */ + advtok = DUK__ADVTOK(3, DUK_RETOK_ASSERT_START_POS_LOOKAHEAD); + } else if (DUK__L2() == '!') { + /* (?! */ + advtok = DUK__ADVTOK(3, DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD); + } else if (DUK__L2() == ':') { + /* (?: */ + advtok = DUK__ADVTOK(3, DUK_RETOK_ATOM_START_NONCAPTURE_GROUP); + } + } else { + /* ( */ + advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_START_CAPTURE_GROUP); + } + break; + } + case ')': { + advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_END_GROUP); + break; + } + case '[': { + /* + * To avoid creating a heavy intermediate value for the list of ranges, + * only the start token ('[' or '[^') is parsed here. The regexp + * compiler parses the ranges itself. + */ + advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_START_CHARCLASS); + if (y == '^') { + advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_START_CHARCLASS_INVERTED); + } + break; + } + case ']': + case '}': { + /* Although these could be parsed as PatternCharacters unambiguously (here), + * E5 Section 15.10.1 grammar explicitly forbids these as PatternCharacters. + */ + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp character"); + break; + } + case -1: { + /* EOF */ + advtok = DUK__ADVTOK(0, DUK_TOK_EOF); + break; + } + default: { + /* PatternCharacter, all excluded characters are matched by cases above */ + advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_CHAR); + out_token->num = x; + break; + } + } + + /* + * Shared exit path + */ + + DUK__ADVANCEBYTES(lex_ctx, advtok >> 8); + out_token->t = advtok & 0xff; +} + +/* + * Special parser for character classes; calls callback for every + * range parsed and returns the number of ranges present. + */ + +/* XXX: this duplicates functionality in duk_regexp.c where a similar loop is + * required anyway. We could use that BUT we need to update the regexp compiler + * 'nranges' too. Work this out a bit more cleanly to save space. + */ + +/* XXX: the handling of character range detection is a bit convoluted. + * Try to simplify and make smaller. + */ + +/* XXX: logic for handling character ranges is now incorrect, it will accept + * e.g. [\d-z] whereas it should croak from it? SMJS accepts this too, though. + * + * Needs a read through and a lot of additional tests. + */ + +DUK_LOCAL +void duk__emit_u16_direct_ranges(duk_lexer_ctx *lex_ctx, + duk_re_range_callback gen_range, + void *userdata, + duk_uint16_t *ranges, + duk_small_int_t num) { + duk_uint16_t *ranges_end; + + DUK_UNREF(lex_ctx); + + ranges_end = ranges + num; + while (ranges < ranges_end) { + /* mark range 'direct', bypass canonicalization (see Wiki) */ + gen_range(userdata, (duk_codepoint_t) ranges[0], (duk_codepoint_t) ranges[1], 1); + ranges += 2; + } +} + +DUK_INTERNAL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range_callback gen_range, void *userdata) { + duk_codepoint_t start = -1; + duk_codepoint_t ch; + duk_codepoint_t x; + duk_bool_t dash = 0; + + DUK_DD(DUK_DDPRINT("parsing regexp ranges")); + + for (;;) { + x = DUK__L0(); + DUK__ADVANCECHARS(lex_ctx, 1); + + ch = -1; /* not strictly necessary, but avoids "uninitialized variable" warnings */ + DUK_UNREF(ch); + + if (x < 0) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "eof while parsing character class"); + } else if (x == ']') { + DUK_ASSERT(!dash); /* lookup should prevent this */ + if (start >= 0) { + gen_range(userdata, start, start, 0); + } + break; + } else if (x == '-') { + if (start >= 0 && !dash && DUK__L0() != ']') { + /* '-' as a range indicator */ + dash = 1; + continue; + } else { + /* '-' verbatim */ + ch = x; + } + } else if (x == '\\') { + /* + * The escapes are same as outside a character class, except that \b has a + * different meaning, and \B and backreferences are prohibited (see E5 + * Section 15.10.2.19). However, it's difficult to share code because we + * handle e.g. "\n" very differently: here we generate a single character + * range for it. + */ + + x = DUK__L0(); + DUK__ADVANCECHARS(lex_ctx, 1); + + if (x == 'b') { + /* Note: '\b' in char class is different than outside (assertion), + * '\B' is not allowed and is caught by the duk_unicode_is_identifier_part() + * check below. + */ + ch = 0x0008; + } else if (x == 'f') { + ch = 0x000c; + } else if (x == 'n') { + ch = 0x000a; + } else if (x == 't') { + ch = 0x0009; + } else if (x == 'r') { + ch = 0x000d; + } else if (x == 'v') { + ch = 0x000b; + } else if (x == 'c') { + x = DUK__L0(); + DUK__ADVANCECHARS(lex_ctx, 1); + if ((x >= 'a' && x <= 'z') || + (x >= 'A' && x <= 'Z')) { + ch = (x % 32); + } else { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp control escape"); + return; /* never reached, but avoids warnings of + * potentially unused variables. + */ + } + } else if (x == 'x') { + ch = duk__decode_hexesc_from_window(lex_ctx, 0); + DUK__ADVANCECHARS(lex_ctx, 2); + } else if (x == 'u') { + ch = duk__decode_uniesc_from_window(lex_ctx, 0); + DUK__ADVANCECHARS(lex_ctx, 4); + } else if (x == 'd') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_digit, + sizeof(duk_unicode_re_ranges_digit) / sizeof(duk_uint16_t)); + ch = -1; + } else if (x == 'D') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_not_digit, + sizeof(duk_unicode_re_ranges_not_digit) / sizeof(duk_uint16_t)); + ch = -1; + } else if (x == 's') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_white, + sizeof(duk_unicode_re_ranges_white) / sizeof(duk_uint16_t)); + ch = -1; + } else if (x == 'S') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_not_white, + sizeof(duk_unicode_re_ranges_not_white) / sizeof(duk_uint16_t)); + ch = -1; + } else if (x == 'w') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_wordchar, + sizeof(duk_unicode_re_ranges_wordchar) / sizeof(duk_uint16_t)); + ch = -1; + } else if (x == 'W') { + duk__emit_u16_direct_ranges(lex_ctx, + gen_range, + userdata, + duk_unicode_re_ranges_not_wordchar, + sizeof(duk_unicode_re_ranges_not_wordchar) / sizeof(duk_uint16_t)); + ch = -1; + } else if (DUK__ISDIGIT(x)) { + /* DecimalEscape, only \0 is allowed, no leading zeroes are allowed */ + if (x == '0' && !DUK__ISDIGIT(DUK__L0())) { + ch = 0x0000; + } else { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid decimal escape"); + } + } else if (!duk_unicode_is_identifier_part(x) +#if defined(DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE) + || x == '$' +#endif + ) { + /* IdentityEscape */ + ch = x; + } else { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid regexp escape"); + } + } else { + /* character represents itself */ + ch = x; + } + + /* ch is a literal character here or -1 if parsed entity was + * an escape such as "\s". + */ + + if (ch < 0) { + /* multi-character sets not allowed as part of ranges, see + * E5 Section 15.10.2.15, abstract operation CharacterRange. + */ + if (start >= 0) { + if (dash) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid range"); + } else { + gen_range(userdata, start, start, 0); + start = -1; + /* dash is already 0 */ + } + } + } else { + if (start >= 0) { + if (dash) { + if (start > ch) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid range"); + } + gen_range(userdata, start, ch, 0); + start = -1; + dash = 0; + } else { + gen_range(userdata, start, start, 0); + start = ch; + /* dash is already 0 */ + } + } else { + start = ch; + } + } + } + + return; +} + +#endif /* DUK_USE_REGEXP_SUPPORT */ +#line 1 "duk_numconv.c" +/* + * Number-to-string and string-to-number conversions. + * + * Slow path number-to-string and string-to-number conversion is based on + * a Dragon4 variant, with fast paths for small integers. Big integer + * arithmetic is needed for guaranteeing that the conversion is correct + * and uses a minimum number of digits. The big number arithmetic has a + * fixed maximum size and does not require dynamic allocations. + * + * See: doc/number-conversion.rst. + */ + +/* include removed: duk_internal.h */ + +#define DUK__IEEE_DOUBLE_EXP_BIAS 1023 +#define DUK__IEEE_DOUBLE_EXP_MIN (-1022) /* biased exp == 0 -> denormal, exp -1022 */ + +#define DUK__DIGITCHAR(x) duk_lc_digits[(x)] + +/* + * Tables generated with src/gennumdigits.py. + * + * duk__str2num_digits_for_radix indicates, for each radix, how many input + * digits should be considered significant for string-to-number conversion. + * The input is also padded to this many digits to give the Dragon4 + * conversion enough (apparent) precision to work with. + * + * duk__str2num_exp_limits indicates, for each radix, the radix-specific + * minimum/maximum exponent values (for a Dragon4 integer mantissa) + * below and above which the number is guaranteed to underflow to zero + * or overflow to Infinity. This allows parsing to keep bigint values + * bounded. + */ + +DUK_LOCAL const duk_uint8_t duk__str2num_digits_for_radix[] = { + 69, 44, 35, 30, 27, 25, 23, 22, 20, 20, /* 2 to 11 */ + 20, 19, 19, 18, 18, 17, 17, 17, 16, 16, /* 12 to 21 */ + 16, 16, 16, 15, 15, 15, 15, 15, 15, 14, /* 22 to 31 */ + 14, 14, 14, 14, 14 /* 31 to 36 */ +}; + +typedef struct { + duk_int16_t upper; + duk_int16_t lower; +} duk__exp_limits; + +DUK_LOCAL const duk__exp_limits duk__str2num_exp_limits[] = { + { 957, -1147 }, { 605, -725 }, { 479, -575 }, { 414, -496 }, + { 372, -446 }, { 342, -411 }, { 321, -384 }, { 304, -364 }, + { 291, -346 }, { 279, -334 }, { 268, -323 }, { 260, -312 }, + { 252, -304 }, { 247, -296 }, { 240, -289 }, { 236, -283 }, + { 231, -278 }, { 227, -273 }, { 223, -267 }, { 220, -263 }, + { 216, -260 }, { 213, -256 }, { 210, -253 }, { 208, -249 }, + { 205, -246 }, { 203, -244 }, { 201, -241 }, { 198, -239 }, + { 196, -237 }, { 195, -234 }, { 193, -232 }, { 191, -230 }, + { 190, -228 }, { 188, -226 }, { 187, -225 }, +}; + +/* + * Limited functionality bigint implementation. + * + * Restricted to non-negative numbers with less than 32 * DUK__BI_MAX_PARTS bits, + * with the caller responsible for ensuring this is never exceeded. No memory + * allocation (except stack) is needed for bigint computation. Operations + * have been tailored for number conversion needs. + * + * Argument order is "assignment order", i.e. target first, then arguments: + * x <- y * z --> duk__bi_mul(x, y, z); + */ + +/* This upper value has been experimentally determined; debug build will check + * bigint size with assertions. + */ +#define DUK__BI_MAX_PARTS 37 /* 37x32 = 1184 bits */ + +#ifdef DUK_USE_DDDPRINT +#define DUK__BI_PRINT(name,x) duk__bi_print((name),(x)) +#else +#define DUK__BI_PRINT(name,x) +#endif + +/* Current size is about 152 bytes. */ +typedef struct { + duk_small_int_t n; + duk_uint32_t v[DUK__BI_MAX_PARTS]; /* low to high */ +} duk__bigint; + +#ifdef DUK_USE_DDDPRINT +DUK_LOCAL void duk__bi_print(const char *name, duk__bigint *x) { + /* Overestimate required size; debug code so not critical to be tight. */ + char buf[DUK__BI_MAX_PARTS * 9 + 64]; + char *p = buf; + duk_small_int_t i; + + /* No NUL term checks in this debug code. */ + p += DUK_SPRINTF(p, "%p n=%ld", (void *) x, (long) x->n); + if (x->n == 0) { + p += DUK_SPRINTF(p, " 0"); + } + for (i = x->n - 1; i >= 0; i--) { + p += DUK_SPRINTF(p, " %08lx", (unsigned long) x->v[i]); + } + + DUK_DDD(DUK_DDDPRINT("%s: %s", (const char *) name, (const char *) buf)); +} +#endif + +#ifdef DUK_USE_ASSERTIONS +DUK_LOCAL duk_small_int_t duk__bi_is_valid(duk__bigint *x) { + return (duk_small_int_t) + ( ((x->n >= 0) && (x->n <= DUK__BI_MAX_PARTS)) /* is valid size */ && + ((x->n == 0) || (x->v[x->n - 1] != 0)) /* is normalized */ ); +} +#endif + +DUK_LOCAL void duk__bi_normalize(duk__bigint *x) { + duk_small_int_t i; + + for (i = x->n - 1; i >= 0; i--) { + if (x->v[i] != 0) { + break; + } + } + + /* Note: if 'x' is zero, x->n becomes 0 here */ + x->n = i + 1; + DUK_ASSERT(duk__bi_is_valid(x)); +} + +/* x <- y */ +DUK_LOCAL void duk__bi_copy(duk__bigint *x, duk__bigint *y) { + duk_small_int_t n; + + n = y->n; + x->n = n; + if (n == 0) { + return; + } + DUK_MEMCPY((void *) x->v, (void *) y->v, (size_t) (sizeof(duk_uint32_t) * n)); +} + +DUK_LOCAL void duk__bi_set_small(duk__bigint *x, duk_uint32_t v) { + if (v == 0U) { + x->n = 0; + } else { + x->n = 1; + x->v[0] = v; + } + DUK_ASSERT(duk__bi_is_valid(x)); +} + +/* Return value: <0 <=> x < y + * 0 <=> x == y + * >0 <=> x > y + */ +DUK_LOCAL int duk__bi_compare(duk__bigint *x, duk__bigint *y) { + duk_small_int_t i, nx, ny; + duk_uint32_t tx, ty; + + DUK_ASSERT(duk__bi_is_valid(x)); + DUK_ASSERT(duk__bi_is_valid(y)); + + nx = x->n; + ny = y->n; + if (nx > ny) { + goto ret_gt; + } + if (nx < ny) { + goto ret_lt; + } + for (i = nx - 1; i >= 0; i--) { + tx = x->v[i]; + ty = y->v[i]; + + if (tx > ty) { + goto ret_gt; + } + if (tx < ty) { + goto ret_lt; + } + } + + return 0; + + ret_gt: + return 1; + + ret_lt: + return -1; +} + +/* x <- y + z */ +#ifdef DUK_USE_64BIT_OPS +DUK_LOCAL void duk__bi_add(duk__bigint *x, duk__bigint *y, duk__bigint *z) { + duk_uint64_t tmp; + duk_small_int_t i, ny, nz; + + DUK_ASSERT(duk__bi_is_valid(y)); + DUK_ASSERT(duk__bi_is_valid(z)); + + if (z->n > y->n) { + duk__bigint *t; + t = y; y = z; z = t; + } + DUK_ASSERT(y->n >= z->n); + + ny = y->n; nz = z->n; + tmp = 0U; + for (i = 0; i < ny; i++) { + DUK_ASSERT(i < DUK__BI_MAX_PARTS); + tmp += y->v[i]; + if (i < nz) { + tmp += z->v[i]; + } + x->v[i] = (duk_uint32_t) (tmp & 0xffffffffUL); + tmp = tmp >> 32; + } + if (tmp != 0U) { + DUK_ASSERT(i < DUK__BI_MAX_PARTS); + x->v[i++] = (duk_uint32_t) tmp; + } + x->n = i; + DUK_ASSERT(x->n <= DUK__BI_MAX_PARTS); + + /* no need to normalize */ + DUK_ASSERT(duk__bi_is_valid(x)); +} +#else /* DUK_USE_64BIT_OPS */ +DUK_LOCAL void duk__bi_add(duk__bigint *x, duk__bigint *y, duk__bigint *z) { + duk_uint32_t carry, tmp1, tmp2; + duk_small_int_t i, ny, nz; + + DUK_ASSERT(duk__bi_is_valid(y)); + DUK_ASSERT(duk__bi_is_valid(z)); + + if (z->n > y->n) { + duk__bigint *t; + t = y; y = z; z = t; + } + DUK_ASSERT(y->n >= z->n); + + ny = y->n; nz = z->n; + carry = 0U; + for (i = 0; i < ny; i++) { + /* Carry is detected based on wrapping which relies on exact 32-bit + * types. + */ + DUK_ASSERT(i < DUK__BI_MAX_PARTS); + tmp1 = y->v[i]; + tmp2 = tmp1; + if (i < nz) { + tmp2 += z->v[i]; + } + + /* Careful with carry condition: + * - If carry not added: 0x12345678 + 0 + 0xffffffff = 0x12345677 (< 0x12345678) + * - If carry added: 0x12345678 + 1 + 0xffffffff = 0x12345678 (== 0x12345678) + */ + if (carry) { + tmp2++; + carry = (tmp2 <= tmp1 ? 1U : 0U); + } else { + carry = (tmp2 < tmp1 ? 1U : 0U); + } + + x->v[i] = tmp2; + } + if (carry) { + DUK_ASSERT(i < DUK__BI_MAX_PARTS); + DUK_ASSERT(carry == 1U); + x->v[i++] = carry; + } + x->n = i; + DUK_ASSERT(x->n <= DUK__BI_MAX_PARTS); + + /* no need to normalize */ + DUK_ASSERT(duk__bi_is_valid(x)); +} +#endif /* DUK_USE_64BIT_OPS */ + +/* x <- y + z */ +DUK_LOCAL void duk__bi_add_small(duk__bigint *x, duk__bigint *y, duk_uint32_t z) { + duk__bigint tmp; + + DUK_ASSERT(duk__bi_is_valid(y)); + + /* XXX: this could be optimized; there is only one call site now though */ + duk__bi_set_small(&tmp, z); + duk__bi_add(x, y, &tmp); + + DUK_ASSERT(duk__bi_is_valid(x)); +} + +#if 0 /* unused */ +/* x <- x + y, use t as temp */ +DUK_LOCAL void duk__bi_add_copy(duk__bigint *x, duk__bigint *y, duk__bigint *t) { + duk__bi_add(t, x, y); + duk__bi_copy(x, t); +} +#endif + +/* x <- y - z, require x >= y => z >= 0, i.e. y >= z */ +#ifdef DUK_USE_64BIT_OPS +DUK_LOCAL void duk__bi_sub(duk__bigint *x, duk__bigint *y, duk__bigint *z) { + duk_small_int_t i, ny, nz; + duk_uint32_t ty, tz; + duk_int64_t tmp; + + DUK_ASSERT(duk__bi_is_valid(y)); + DUK_ASSERT(duk__bi_is_valid(z)); + DUK_ASSERT(duk__bi_compare(y, z) >= 0); + DUK_ASSERT(y->n >= z->n); + + ny = y->n; nz = z->n; + tmp = 0; + for (i = 0; i < ny; i++) { + ty = y->v[i]; + if (i < nz) { + tz = z->v[i]; + } else { + tz = 0; + } + tmp = (duk_int64_t) ty - (duk_int64_t) tz + tmp; + x->v[i] = (duk_uint32_t) (tmp & 0xffffffffUL); + tmp = tmp >> 32; /* 0 or -1 */ + } + DUK_ASSERT(tmp == 0); + + x->n = i; + duk__bi_normalize(x); /* need to normalize, may even cancel to 0 */ + DUK_ASSERT(duk__bi_is_valid(x)); +} +#else +DUK_LOCAL void duk__bi_sub(duk__bigint *x, duk__bigint *y, duk__bigint *z) { + duk_small_int_t i, ny, nz; + duk_uint32_t tmp1, tmp2, borrow; + + DUK_ASSERT(duk__bi_is_valid(y)); + DUK_ASSERT(duk__bi_is_valid(z)); + DUK_ASSERT(duk__bi_compare(y, z) >= 0); + DUK_ASSERT(y->n >= z->n); + + ny = y->n; nz = z->n; + borrow = 0U; + for (i = 0; i < ny; i++) { + /* Borrow is detected based on wrapping which relies on exact 32-bit + * types. + */ + tmp1 = y->v[i]; + tmp2 = tmp1; + if (i < nz) { + tmp2 -= z->v[i]; + } + + /* Careful with borrow condition: + * - If borrow not subtracted: 0x12345678 - 0 - 0xffffffff = 0x12345679 (> 0x12345678) + * - If borrow subtracted: 0x12345678 - 1 - 0xffffffff = 0x12345678 (== 0x12345678) + */ + if (borrow) { + tmp2--; + borrow = (tmp2 >= tmp1 ? 1U : 0U); + } else { + borrow = (tmp2 > tmp1 ? 1U : 0U); + } + + x->v[i] = tmp2; + } + DUK_ASSERT(borrow == 0U); + + x->n = i; + duk__bi_normalize(x); /* need to normalize, may even cancel to 0 */ + DUK_ASSERT(duk__bi_is_valid(x)); +} +#endif + +#if 0 /* unused */ +/* x <- y - z */ +DUK_LOCAL void duk__bi_sub_small(duk__bigint *x, duk__bigint *y, duk_uint32_t z) { + duk__bigint tmp; + + DUK_ASSERT(duk__bi_is_valid(y)); + + /* XXX: this could be optimized */ + duk__bi_set_small(&tmp, z); + duk__bi_sub(x, y, &tmp); + + DUK_ASSERT(duk__bi_is_valid(x)); +} +#endif + +/* x <- x - y, use t as temp */ +DUK_LOCAL void duk__bi_sub_copy(duk__bigint *x, duk__bigint *y, duk__bigint *t) { + duk__bi_sub(t, x, y); + duk__bi_copy(x, t); +} + +/* x <- y * z */ +DUK_LOCAL void duk__bi_mul(duk__bigint *x, duk__bigint *y, duk__bigint *z) { + duk_small_int_t i, j, nx, nz; + + DUK_ASSERT(duk__bi_is_valid(y)); + DUK_ASSERT(duk__bi_is_valid(z)); + + nx = y->n + z->n; /* max possible */ + DUK_ASSERT(nx <= DUK__BI_MAX_PARTS); + + if (nx == 0) { + /* Both inputs are zero; cases where only one is zero can go + * through main algorithm. + */ + x->n = 0; + return; + } + + DUK_MEMZERO((void *) x->v, (size_t) (sizeof(duk_uint32_t) * nx)); + x->n = nx; + + nz = z->n; + for (i = 0; i < y->n; i++) { +#ifdef DUK_USE_64BIT_OPS + duk_uint64_t tmp = 0U; + for (j = 0; j < nz; j++) { + tmp += (duk_uint64_t) y->v[i] * (duk_uint64_t) z->v[j] + x->v[i+j]; + x->v[i+j] = (duk_uint32_t) (tmp & 0xffffffffUL); + tmp = tmp >> 32; + } + if (tmp > 0) { + DUK_ASSERT(i + j < nx); + DUK_ASSERT(i + j < DUK__BI_MAX_PARTS); + DUK_ASSERT(x->v[i+j] == 0U); + x->v[i+j] = (duk_uint32_t) tmp; + } +#else + /* + * Multiply + add + carry for 32-bit components using only 16x16->32 + * multiplies and carry detection based on unsigned overflow. + * + * 1st mult, 32-bit: (A*2^16 + B) + * 2nd mult, 32-bit: (C*2^16 + D) + * 3rd add, 32-bit: E + * 4th add, 32-bit: F + * + * (AC*2^16 + B) * (C*2^16 + D) + E + F + * = AC*2^32 + AD*2^16 + BC*2^16 + BD + E + F + * = AC*2^32 + (AD + BC)*2^16 + (BD + E + F) + * = AC*2^32 + AD*2^16 + BC*2^16 + (BD + E + F) + */ + duk_uint32_t a, b, c, d, e, f; + duk_uint32_t r, s, t; + + a = y->v[i]; b = a & 0xffffUL; a = a >> 16; + + f = 0; + for (j = 0; j < nz; j++) { + c = z->v[j]; d = c & 0xffffUL; c = c >> 16; + e = x->v[i+j]; + + /* build result as: (r << 32) + s: start with (BD + E + F) */ + r = 0; + s = b * d; + + /* add E */ + t = s + e; + if (t < s) { r++; } /* carry */ + s = t; + + /* add F */ + t = s + f; + if (t < s) { r++; } /* carry */ + s = t; + + /* add BC*2^16 */ + t = b * c; + r += (t >> 16); + t = s + ((t & 0xffffUL) << 16); + if (t < s) { r++; } /* carry */ + s = t; + + /* add AD*2^16 */ + t = a * d; + r += (t >> 16); + t = s + ((t & 0xffffUL) << 16); + if (t < s) { r++; } /* carry */ + s = t; + + /* add AC*2^32 */ + t = a * c; + r += t; + + DUK_DDD(DUK_DDDPRINT("ab=%08lx cd=%08lx ef=%08lx -> rs=%08lx %08lx", + (unsigned long) y->v[i], (unsigned long) z->v[j], + (unsigned long) x->v[i+j], (unsigned long) r, + (unsigned long) s)); + + x->v[i+j] = s; + f = r; + } + if (f > 0U) { + DUK_ASSERT(i + j < nx); + DUK_ASSERT(i + j < DUK__BI_MAX_PARTS); + DUK_ASSERT(x->v[i+j] == 0U); + x->v[i+j] = (duk_uint32_t) f; + } +#endif /* DUK_USE_64BIT_OPS */ + } + + duk__bi_normalize(x); + DUK_ASSERT(duk__bi_is_valid(x)); +} + +/* x <- y * z */ +DUK_LOCAL void duk__bi_mul_small(duk__bigint *x, duk__bigint *y, duk_uint32_t z) { + duk__bigint tmp; + + DUK_ASSERT(duk__bi_is_valid(y)); + + /* XXX: this could be optimized */ + duk__bi_set_small(&tmp, z); + duk__bi_mul(x, y, &tmp); + + DUK_ASSERT(duk__bi_is_valid(x)); +} + +/* x <- x * y, use t as temp */ +DUK_LOCAL void duk__bi_mul_copy(duk__bigint *x, duk__bigint *y, duk__bigint *t) { + duk__bi_mul(t, x, y); + duk__bi_copy(x, t); +} + +/* x <- x * y, use t as temp */ +DUK_LOCAL void duk__bi_mul_small_copy(duk__bigint *x, duk_uint32_t y, duk__bigint *t) { + duk__bi_mul_small(t, x, y); + duk__bi_copy(x, t); +} + +DUK_LOCAL int duk__bi_is_even(duk__bigint *x) { + DUK_ASSERT(duk__bi_is_valid(x)); + return (x->n == 0) || ((x->v[0] & 0x01) == 0); +} + +DUK_LOCAL int duk__bi_is_zero(duk__bigint *x) { + DUK_ASSERT(duk__bi_is_valid(x)); + return (x->n == 0); /* this is the case for normalized numbers */ +} + +/* Bigint is 2^52. Used to detect normalized IEEE double mantissa values + * which are at the lowest edge (next floating point value downwards has + * a different exponent). The lowest mantissa has the form: + * + * 1000........000 (52 zeroes; only "hidden bit" is set) + */ +DUK_LOCAL duk_small_int_t duk__bi_is_2to52(duk__bigint *x) { + DUK_ASSERT(duk__bi_is_valid(x)); + return (duk_small_int_t) + (x->n == 2) && (x->v[0] == 0U) && (x->v[1] == (1U << (52-32))); +} + +/* x <- (1<<y) */ +DUK_LOCAL void duk__bi_twoexp(duk__bigint *x, duk_small_int_t y) { + duk_small_int_t n, r; + + n = (y / 32) + 1; + DUK_ASSERT(n > 0); + r = y % 32; + DUK_MEMZERO((void *) x->v, sizeof(duk_uint32_t) * n); + x->n = n; + x->v[n - 1] = (((duk_uint32_t) 1) << r); +} + +/* x <- b^y; use t1 and t2 as temps */ +DUK_LOCAL void duk__bi_exp_small(duk__bigint *x, duk_small_int_t b, duk_small_int_t y, duk__bigint *t1, duk__bigint *t2) { + /* Fast path the binary case */ + + DUK_ASSERT(x != t1 && x != t2 && t1 != t2); /* distinct bignums, easy mistake to make */ + DUK_ASSERT(b >= 0); + DUK_ASSERT(y >= 0); + + if (b == 2) { + duk__bi_twoexp(x, y); + return; + } + + /* http://en.wikipedia.org/wiki/Exponentiation_by_squaring */ + + DUK_DDD(DUK_DDDPRINT("exp_small: b=%ld, y=%ld", (long) b, (long) y)); + + duk__bi_set_small(x, 1); + duk__bi_set_small(t1, b); + for (;;) { + /* Loop structure ensures that we don't compute t1^2 unnecessarily + * on the final round, as that might create a bignum exceeding the + * current DUK__BI_MAX_PARTS limit. + */ + if (y & 0x01) { + duk__bi_mul_copy(x, t1, t2); + } + y = y >> 1; + if (y == 0) { + break; + } + duk__bi_mul_copy(t1, t1, t2); + } + + DUK__BI_PRINT("exp_small result", x); +} + +/* + * A Dragon4 number-to-string variant, based on: + * + * Guy L. Steele Jr., Jon L. White: "How to Print Floating-Point Numbers + * Accurately" + * + * Robert G. Burger, R. Kent Dybvig: "Printing Floating-Point Numbers + * Quickly and Accurately" + * + * The current algorithm is based on Figure 1 of the Burger-Dybvig paper, + * i.e. the base implementation without logarithm estimation speedups + * (these would increase code footprint considerably). Fixed-format output + * does not follow the suggestions in the paper; instead, we generate an + * extra digit and round-with-carry. + * + * The same algorithm is used for number parsing (with b=10 and B=2) + * by generating one extra digit and doing rounding manually. + * + * See doc/number-conversion.rst for limitations. + */ + +/* Maximum number of digits generated. */ +#define DUK__MAX_OUTPUT_DIGITS 1040 /* (Number.MAX_VALUE).toString(2).length == 1024, + spare */ + +/* Maximum number of characters in formatted value. */ +#define DUK__MAX_FORMATTED_LENGTH 1040 /* (-Number.MAX_VALUE).toString(2).length == 1025, + spare */ + +/* Number and (minimum) size of bigints in the nc_ctx structure. */ +#define DUK__NUMCONV_CTX_NUM_BIGINTS 7 +#define DUK__NUMCONV_CTX_BIGINTS_SIZE (sizeof(duk__bigint) * DUK__NUMCONV_CTX_NUM_BIGINTS) + +typedef struct { + /* Currently about 7*152 = 1064 bytes. The space for these + * duk__bigints is used also as a temporary buffer for generating + * the final string. This is a bit awkard; a union would be + * more correct. + */ + duk__bigint f, r, s, mp, mm, t1, t2; + + duk_small_int_t is_s2n; /* if 1, doing a string-to-number; else doing a number-to-string */ + duk_small_int_t is_fixed; /* if 1, doing a fixed format output (not free format) */ + duk_small_int_t req_digits; /* requested number of output digits; 0 = free-format */ + duk_small_int_t abs_pos; /* digit position is absolute, not relative */ + duk_small_int_t e; /* exponent for 'f' */ + duk_small_int_t b; /* input radix */ + duk_small_int_t B; /* output radix */ + duk_small_int_t k; /* see algorithm */ + duk_small_int_t low_ok; /* see algorithm */ + duk_small_int_t high_ok; /* see algorithm */ + duk_small_int_t unequal_gaps; /* m+ != m- (very rarely) */ + + /* Buffer used for generated digits, values are in the range [0,B-1]. */ + duk_uint8_t digits[DUK__MAX_OUTPUT_DIGITS]; + duk_small_int_t count; /* digit count */ +} duk__numconv_stringify_ctx; + +/* Note: computes with 'idx' in assertions, so caller beware. + * 'idx' is preincremented, i.e. '1' on first call, because it + * is more convenient for the caller. + */ +#define DUK__DRAGON4_OUTPUT_PREINC(nc_ctx,preinc_idx,x) do { \ + DUK_ASSERT((preinc_idx) - 1 >= 0); \ + DUK_ASSERT((preinc_idx) - 1 < DUK__MAX_OUTPUT_DIGITS); \ + ((nc_ctx)->digits[(preinc_idx) - 1]) = (duk_uint8_t) (x); \ + } while (0) + +DUK_LOCAL duk_size_t duk__dragon4_format_uint32(duk_uint8_t *buf, duk_uint32_t x, duk_small_int_t radix) { + duk_uint8_t *p; + duk_size_t len; + duk_small_int_t dig; + duk_small_int_t t; + + DUK_ASSERT(radix >= 2 && radix <= 36); + + /* A 32-bit unsigned integer formats to at most 32 digits (the + * worst case happens with radix == 2). Output the digits backwards, + * and use a memmove() to get them in the right place. + */ + + p = buf + 32; + for (;;) { + t = x / radix; + dig = x - t * radix; + x = t; + + DUK_ASSERT(dig >= 0 && dig < 36); + *(--p) = DUK__DIGITCHAR(dig); + + if (x == 0) { + break; + } + } + len = (duk_size_t) ((buf + 32) - p); + + DUK_MEMMOVE((void *) buf, (void *) p, (size_t) len); + + return len; +} + +DUK_LOCAL void duk__dragon4_prepare(duk__numconv_stringify_ctx *nc_ctx) { + duk_small_int_t lowest_mantissa; + +#if 1 + /* Assume IEEE round-to-even, so that shorter encoding can be used + * when round-to-even would produce correct result. By removing + * this check (and having low_ok == high_ok == 0) the results would + * still be accurate but in some cases longer than necessary. + */ + if (duk__bi_is_even(&nc_ctx->f)) { + DUK_DDD(DUK_DDDPRINT("f is even")); + nc_ctx->low_ok = 1; + nc_ctx->high_ok = 1; + } else { + DUK_DDD(DUK_DDDPRINT("f is odd")); + nc_ctx->low_ok = 0; + nc_ctx->high_ok = 0; + } +#else + /* Note: not honoring round-to-even should work but now generates incorrect + * results. For instance, 1e23 serializes to "a000...", i.e. the first digit + * equals the radix (10). Scaling stops one step too early in this case. + * Don't know why this is the case, but since this code path is unused, it + * doesn't matter. + */ + nc_ctx->low_ok = 0; + nc_ctx->high_ok = 0; +#endif + + /* For string-to-number, pretend we never have the lowest mantissa as there + * is no natural "precision" for inputs. Having lowest_mantissa == 0, we'll + * fall into the base cases for both e >= 0 and e < 0. + */ + if (nc_ctx->is_s2n) { + lowest_mantissa = 0; + } else { + lowest_mantissa = duk__bi_is_2to52(&nc_ctx->f); + } + + nc_ctx->unequal_gaps = 0; + if (nc_ctx->e >= 0) { + /* exponent non-negative (and thus not minimum exponent) */ + + if (lowest_mantissa) { + /* (>= e 0) AND (= f (expt b (- p 1))) + * + * be <- (expt b e) == b^e + * be1 <- (* be b) == (expt b (+ e 1)) == b^(e+1) + * r <- (* f be1 2) == 2 * f * b^(e+1) [if b==2 -> f * b^(e+2)] + * s <- (* b 2) [if b==2 -> 4] + * m+ <- be1 == b^(e+1) + * m- <- be == b^e + * k <- 0 + * B <- B + * low_ok <- round + * high_ok <- round + */ + + DUK_DDD(DUK_DDDPRINT("non-negative exponent (not smallest exponent); " + "lowest mantissa value for this exponent -> " + "unequal gaps")); + + duk__bi_exp_small(&nc_ctx->mm, nc_ctx->b, nc_ctx->e, &nc_ctx->t1, &nc_ctx->t2); /* mm <- b^e */ + duk__bi_mul_small(&nc_ctx->mp, &nc_ctx->mm, nc_ctx->b); /* mp <- b^(e+1) */ + duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, 2); + duk__bi_mul(&nc_ctx->r, &nc_ctx->t1, &nc_ctx->mp); /* r <- (2 * f) * b^(e+1) */ + duk__bi_set_small(&nc_ctx->s, nc_ctx->b * 2); /* s <- 2 * b */ + nc_ctx->unequal_gaps = 1; + } else { + /* (>= e 0) AND (not (= f (expt b (- p 1)))) + * + * be <- (expt b e) == b^e + * r <- (* f be 2) == 2 * f * b^e [if b==2 -> f * b^(e+1)] + * s <- 2 + * m+ <- be == b^e + * m- <- be == b^e + * k <- 0 + * B <- B + * low_ok <- round + * high_ok <- round + */ + + DUK_DDD(DUK_DDDPRINT("non-negative exponent (not smallest exponent); " + "not lowest mantissa for this exponent -> " + "equal gaps")); + + duk__bi_exp_small(&nc_ctx->mm, nc_ctx->b, nc_ctx->e, &nc_ctx->t1, &nc_ctx->t2); /* mm <- b^e */ + duk__bi_copy(&nc_ctx->mp, &nc_ctx->mm); /* mp <- b^e */ + duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, 2); + duk__bi_mul(&nc_ctx->r, &nc_ctx->t1, &nc_ctx->mp); /* r <- (2 * f) * b^e */ + duk__bi_set_small(&nc_ctx->s, 2); /* s <- 2 */ + } + } else { + /* When doing string-to-number, lowest_mantissa is always 0 so + * the exponent check, while incorrect, won't matter. + */ + if (nc_ctx->e > DUK__IEEE_DOUBLE_EXP_MIN /*not minimum exponent*/ && + lowest_mantissa /* lowest mantissa for this exponent*/) { + /* r <- (* f b 2) [if b==2 -> (* f 4)] + * s <- (* (expt b (- 1 e)) 2) == b^(1-e) * 2 [if b==2 -> b^(2-e)] + * m+ <- b == 2 + * m- <- 1 + * k <- 0 + * B <- B + * low_ok <- round + * high_ok <- round + */ + + DUK_DDD(DUK_DDDPRINT("negative exponent; not minimum exponent and " + "lowest mantissa for this exponent -> " + "unequal gaps")); + + duk__bi_mul_small(&nc_ctx->r, &nc_ctx->f, nc_ctx->b * 2); /* r <- (2 * b) * f */ + duk__bi_exp_small(&nc_ctx->t1, nc_ctx->b, 1 - nc_ctx->e, &nc_ctx->s, &nc_ctx->t2); /* NB: use 's' as temp on purpose */ + duk__bi_mul_small(&nc_ctx->s, &nc_ctx->t1, 2); /* s <- b^(1-e) * 2 */ + duk__bi_set_small(&nc_ctx->mp, 2); + duk__bi_set_small(&nc_ctx->mm, 1); + nc_ctx->unequal_gaps = 1; + } else { + /* r <- (* f 2) + * s <- (* (expt b (- e)) 2) == b^(-e) * 2 [if b==2 -> b^(1-e)] + * m+ <- 1 + * m- <- 1 + * k <- 0 + * B <- B + * low_ok <- round + * high_ok <- round + */ + + DUK_DDD(DUK_DDDPRINT("negative exponent; minimum exponent or not " + "lowest mantissa for this exponent -> " + "equal gaps")); + + duk__bi_mul_small(&nc_ctx->r, &nc_ctx->f, 2); /* r <- 2 * f */ + duk__bi_exp_small(&nc_ctx->t1, nc_ctx->b, -nc_ctx->e, &nc_ctx->s, &nc_ctx->t2); /* NB: use 's' as temp on purpose */ + duk__bi_mul_small(&nc_ctx->s, &nc_ctx->t1, 2); /* s <- b^(-e) * 2 */ + duk__bi_set_small(&nc_ctx->mp, 1); + duk__bi_set_small(&nc_ctx->mm, 1); + } + } +} + +DUK_LOCAL void duk__dragon4_scale(duk__numconv_stringify_ctx *nc_ctx) { + duk_small_int_t k = 0; + + /* This is essentially the 'scale' algorithm, with recursion removed. + * Note that 'k' is either correct immediately, or will move in one + * direction in the loop. There's no need to do the low/high checks + * on every round (like the Scheme algorithm does). + * + * The scheme algorithm finds 'k' and updates 's' simultaneously, + * while the logical algorithm finds 'k' with 's' having its initial + * value, after which 's' is updated separately (see the Burger-Dybvig + * paper, Section 3.1, steps 2 and 3). + * + * The case where m+ == m- (almost always) is optimized for, because + * it reduces the bigint operations considerably and almost always + * applies. The scale loop only needs to work with m+, so this works. + */ + + /* XXX: this algorithm could be optimized quite a lot by using e.g. + * a logarithm based estimator for 'k' and performing B^n multiplication + * using a lookup table or using some bit-representation based exp + * algorithm. Currently we just loop, with significant performance + * impact for very large and very small numbers. + */ + + DUK_DDD(DUK_DDDPRINT("scale: B=%ld, low_ok=%ld, high_ok=%ld", + (long) nc_ctx->B, (long) nc_ctx->low_ok, (long) nc_ctx->high_ok)); + DUK__BI_PRINT("r(init)", &nc_ctx->r); + DUK__BI_PRINT("s(init)", &nc_ctx->s); + DUK__BI_PRINT("mp(init)", &nc_ctx->mp); + DUK__BI_PRINT("mm(init)", &nc_ctx->mm); + + for (;;) { + DUK_DDD(DUK_DDDPRINT("scale loop (inc k), k=%ld", (long) k)); + DUK__BI_PRINT("r", &nc_ctx->r); + DUK__BI_PRINT("s", &nc_ctx->s); + DUK__BI_PRINT("m+", &nc_ctx->mp); + DUK__BI_PRINT("m-", &nc_ctx->mm); + + duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp); /* t1 = (+ r m+) */ + if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) >= (nc_ctx->high_ok ? 0 : 1)) { + DUK_DDD(DUK_DDDPRINT("k is too low")); + /* r <- r + * s <- (* s B) + * m+ <- m+ + * m- <- m- + * k <- (+ k 1) + */ + + duk__bi_mul_small_copy(&nc_ctx->s, nc_ctx->B, &nc_ctx->t1); + k++; + } else { + break; + } + } + + /* k > 0 -> k was too low, and cannot be too high */ + if (k > 0) { + goto skip_dec_k; + } + + for (;;) { + DUK_DDD(DUK_DDDPRINT("scale loop (dec k), k=%ld", (long) k)); + DUK__BI_PRINT("r", &nc_ctx->r); + DUK__BI_PRINT("s", &nc_ctx->s); + DUK__BI_PRINT("m+", &nc_ctx->mp); + DUK__BI_PRINT("m-", &nc_ctx->mm); + + duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp); /* t1 = (+ r m+) */ + duk__bi_mul_small(&nc_ctx->t2, &nc_ctx->t1, nc_ctx->B); /* t2 = (* (+ r m+) B) */ + if (duk__bi_compare(&nc_ctx->t2, &nc_ctx->s) <= (nc_ctx->high_ok ? -1 : 0)) { + DUK_DDD(DUK_DDDPRINT("k is too high")); + /* r <- (* r B) + * s <- s + * m+ <- (* m+ B) + * m- <- (* m- B) + * k <- (- k 1) + */ + duk__bi_mul_small_copy(&nc_ctx->r, nc_ctx->B, &nc_ctx->t1); + duk__bi_mul_small_copy(&nc_ctx->mp, nc_ctx->B, &nc_ctx->t1); + if (nc_ctx->unequal_gaps) { + DUK_DDD(DUK_DDDPRINT("m+ != m- -> need to update m- too")); + duk__bi_mul_small_copy(&nc_ctx->mm, nc_ctx->B, &nc_ctx->t1); + } + k--; + } else { + break; + } + } + + skip_dec_k: + + if (!nc_ctx->unequal_gaps) { + DUK_DDD(DUK_DDDPRINT("equal gaps, copy m- from m+")); + duk__bi_copy(&nc_ctx->mm, &nc_ctx->mp); /* mm <- mp */ + } + nc_ctx->k = k; + + DUK_DDD(DUK_DDDPRINT("final k: %ld", (long) k)); + DUK__BI_PRINT("r(final)", &nc_ctx->r); + DUK__BI_PRINT("s(final)", &nc_ctx->s); + DUK__BI_PRINT("mp(final)", &nc_ctx->mp); + DUK__BI_PRINT("mm(final)", &nc_ctx->mm); +} + +DUK_LOCAL void duk__dragon4_generate(duk__numconv_stringify_ctx *nc_ctx) { + duk_small_int_t tc1, tc2; /* terminating conditions */ + duk_small_int_t d; /* current digit */ + duk_small_int_t count = 0; /* digit count */ + + /* + * Digit generation loop. + * + * Different termination conditions: + * + * 1. Free format output. Terminate when shortest accurate + * representation found. + * + * 2. Fixed format output, with specific number of digits. + * Ignore termination conditions, terminate when digits + * generated. Caller requests an extra digit and rounds. + * + * 3. Fixed format output, with a specific absolute cut-off + * position (e.g. 10 digits after decimal point). Note + * that we always generate at least one digit, even if + * the digit is below the cut-off point already. + */ + + for (;;) { + DUK_DDD(DUK_DDDPRINT("generate loop, count=%ld, k=%ld, B=%ld, low_ok=%ld, high_ok=%ld", + (long) count, (long) nc_ctx->k, (long) nc_ctx->B, + (long) nc_ctx->low_ok, (long) nc_ctx->high_ok)); + DUK__BI_PRINT("r", &nc_ctx->r); + DUK__BI_PRINT("s", &nc_ctx->s); + DUK__BI_PRINT("m+", &nc_ctx->mp); + DUK__BI_PRINT("m-", &nc_ctx->mm); + + /* (quotient-remainder (* r B) s) using a dummy subtraction loop */ + duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->r, nc_ctx->B); /* t1 <- (* r B) */ + d = 0; + for (;;) { + if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) < 0) { + break; + } + duk__bi_sub_copy(&nc_ctx->t1, &nc_ctx->s, &nc_ctx->t2); /* t1 <- t1 - s */ + d++; + } + duk__bi_copy(&nc_ctx->r, &nc_ctx->t1); /* r <- (remainder (* r B) s) */ + /* d <- (quotient (* r B) s) (in range 0...B-1) */ + DUK_DDD(DUK_DDDPRINT("-> d(quot)=%ld", (long) d)); + DUK__BI_PRINT("r(rem)", &nc_ctx->r); + + duk__bi_mul_small_copy(&nc_ctx->mp, nc_ctx->B, &nc_ctx->t2); /* m+ <- (* m+ B) */ + duk__bi_mul_small_copy(&nc_ctx->mm, nc_ctx->B, &nc_ctx->t2); /* m- <- (* m- B) */ + DUK__BI_PRINT("mp(upd)", &nc_ctx->mp); + DUK__BI_PRINT("mm(upd)", &nc_ctx->mm); + + /* Terminating conditions. For fixed width output, we just ignore the + * terminating conditions (and pretend that tc1 == tc2 == false). The + * the current shortcut for fixed-format output is to generate a few + * extra digits and use rounding (with carry) to finish the output. + */ + + if (nc_ctx->is_fixed == 0) { + /* free-form */ + tc1 = (duk__bi_compare(&nc_ctx->r, &nc_ctx->mm) <= (nc_ctx->low_ok ? 0 : -1)); + + duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp); /* t1 <- (+ r m+) */ + tc2 = (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) >= (nc_ctx->high_ok ? 0 : 1)); + + DUK_DDD(DUK_DDDPRINT("tc1=%ld, tc2=%ld", (long) tc1, (long) tc2)); + } else { + /* fixed-format */ + tc1 = 0; + tc2 = 0; + } + + /* Count is incremented before DUK__DRAGON4_OUTPUT_PREINC() call + * on purpose, which is taken into account by the macro. + */ + count++; + + if (tc1) { + if (tc2) { + /* tc1 = true, tc2 = true */ + duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->r, 2); + if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) < 0) { /* (< (* r 2) s) */ + DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=true, 2r > s: output d --> %ld (k=%ld)", + (long) d, (long) nc_ctx->k)); + DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d); + } else { + DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=true, 2r <= s: output d+1 --> %ld (k=%ld)", + (long) (d + 1), (long) nc_ctx->k)); + DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d + 1); + } + break; + } else { + /* tc1 = true, tc2 = false */ + DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=false: output d --> %ld (k=%ld)", + (long) d, (long) nc_ctx->k)); + DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d); + break; + } + } else { + if (tc2) { + /* tc1 = false, tc2 = true */ + DUK_DDD(DUK_DDDPRINT("tc1=false, tc2=true: output d+1 --> %ld (k=%ld)", + (long) (d + 1), (long) nc_ctx->k)); + DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d + 1); + break; + } else { + /* tc1 = false, tc2 = false */ + DUK_DDD(DUK_DDDPRINT("tc1=false, tc2=false: output d --> %ld (k=%ld)", + (long) d, (long) nc_ctx->k)); + DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d); + + /* r <- r (updated above: r <- (remainder (* r B) s) + * s <- s + * m+ <- m+ (updated above: m+ <- (* m+ B) + * m- <- m- (updated above: m- <- (* m- B) + * B, low_ok, high_ok are fixed + */ + + /* fall through and continue for-loop */ + } + } + + /* fixed-format termination conditions */ + if (nc_ctx->is_fixed) { + if (nc_ctx->abs_pos) { + int pos = nc_ctx->k - count + 1; /* count is already incremented, take into account */ + DUK_DDD(DUK_DDDPRINT("fixed format, absolute: abs pos=%ld, k=%ld, count=%ld, req=%ld", + (long) pos, (long) nc_ctx->k, (long) count, (long) nc_ctx->req_digits)); + if (pos <= nc_ctx->req_digits) { + DUK_DDD(DUK_DDDPRINT("digit position reached req_digits, end generate loop")); + break; + } + } else { + DUK_DDD(DUK_DDDPRINT("fixed format, relative: k=%ld, count=%ld, req=%ld", + (long) nc_ctx->k, (long) count, (long) nc_ctx->req_digits)); + if (count >= nc_ctx->req_digits) { + DUK_DDD(DUK_DDDPRINT("digit count reached req_digits, end generate loop")); + break; + } + } + } + } /* for */ + + nc_ctx->count = count; + + DUK_DDD(DUK_DDDPRINT("generate finished")); + +#ifdef DUK_USE_DDDPRINT + { + duk_uint8_t buf[2048]; + duk_small_int_t i, t; + DUK_MEMZERO(buf, sizeof(buf)); + for (i = 0; i < nc_ctx->count; i++) { + t = nc_ctx->digits[i]; + if (t < 0 || t > 36) { + buf[i] = (duk_uint8_t) '?'; + } else { + buf[i] = (duk_uint8_t) DUK__DIGITCHAR(t); + } + } + DUK_DDD(DUK_DDDPRINT("-> generated digits; k=%ld, digits='%s'", + (long) nc_ctx->k, (const char *) buf)); + } +#endif +} + +/* Round up digits to a given position. If position is out-of-bounds, + * does nothing. If carry propagates over the first digit, a '1' is + * prepended to digits and 'k' will be updated. Return value indicates + * whether carry propagated over the first digit. + * + * Note that nc_ctx->count is NOT updated based on the rounding position + * (it is updated only if carry overflows over the first digit and an + * extra digit is prepended). + */ +DUK_LOCAL duk_small_int_t duk__dragon4_fixed_format_round(duk__numconv_stringify_ctx *nc_ctx, duk_small_int_t round_idx) { + duk_small_int_t t; + duk_uint8_t *p; + duk_uint8_t roundup_limit; + duk_small_int_t ret = 0; + + /* + * round_idx points to the digit which is considered for rounding; the + * digit to its left is the final digit of the rounded value. If round_idx + * is zero, rounding will be performed; the result will either be an empty + * rounded value or if carry happens a '1' digit is generated. + */ + + if (round_idx >= nc_ctx->count) { + DUK_DDD(DUK_DDDPRINT("round_idx out of bounds (%ld >= %ld (count)) -> no rounding", + (long) round_idx, (long) nc_ctx->count)); + return 0; + } else if (round_idx < 0) { + DUK_DDD(DUK_DDDPRINT("round_idx out of bounds (%ld < 0) -> no rounding", + (long) round_idx)); + return 0; + } + + /* + * Round-up limit. + * + * For even values, divides evenly, e.g. 10 -> roundup_limit=5. + * + * For odd values, rounds up, e.g. 3 -> roundup_limit=2. + * If radix is 3, 0/3 -> down, 1/3 -> down, 2/3 -> up. + */ + roundup_limit = (duk_uint8_t) ((nc_ctx->B + 1) / 2); + + p = &nc_ctx->digits[round_idx]; + if (*p >= roundup_limit) { + DUK_DDD(DUK_DDDPRINT("fixed-format rounding carry required")); + /* carry */ + for (;;) { + *p = 0; + if (p == &nc_ctx->digits[0]) { + DUK_DDD(DUK_DDDPRINT("carry propagated to first digit -> special case handling")); + DUK_MEMMOVE((void *) (&nc_ctx->digits[1]), + (void *) (&nc_ctx->digits[0]), + (size_t) (sizeof(char) * nc_ctx->count)); + nc_ctx->digits[0] = 1; /* don't increase 'count' */ + nc_ctx->k++; /* position of highest digit changed */ + nc_ctx->count++; /* number of digits changed */ + ret = 1; + break; + } + + DUK_DDD(DUK_DDDPRINT("fixed-format rounding carry: B=%ld, roundup_limit=%ld, p=%p, digits=%p", + (long) nc_ctx->B, (long) roundup_limit, (void *) p, (void *) nc_ctx->digits)); + p--; + t = *p; + DUK_DDD(DUK_DDDPRINT("digit before carry: %ld", (long) t)); + if (++t < nc_ctx->B) { + DUK_DDD(DUK_DDDPRINT("rounding carry terminated")); + *p = t; + break; + } + + DUK_DDD(DUK_DDDPRINT("wraps, carry to next digit")); + } + } + + return ret; +} + +#define DUK__NO_EXP (65536) /* arbitrary marker, outside valid exp range */ + +DUK_LOCAL void duk__dragon4_convert_and_push(duk__numconv_stringify_ctx *nc_ctx, + duk_context *ctx, + duk_small_int_t radix, + duk_small_int_t digits, + duk_small_uint_t flags, + duk_small_int_t neg) { + duk_small_int_t k; + duk_small_int_t pos, pos_end; + duk_small_int_t expt; + duk_small_int_t dig; + duk_uint8_t *q; + duk_uint8_t *buf; + + /* + * The string conversion here incorporates all the necessary Ecmascript + * semantics without attempting to be generic. nc_ctx->digits contains + * nc_ctx->count digits (>= 1), with the topmost digit's 'position' + * indicated by nc_ctx->k as follows: + * + * digits="123" count=3 k=0 --> 0.123 + * digits="123" count=3 k=1 --> 1.23 + * digits="123" count=3 k=5 --> 12300 + * digits="123" count=3 k=-1 --> 0.0123 + * + * Note that the identifier names used for format selection are different + * in Burger-Dybvig paper and Ecmascript specification (quite confusingly + * so, because e.g. 'k' has a totally different meaning in each). See + * documentation for discussion. + * + * Ecmascript doesn't specify any specific behavior for format selection + * (e.g. when to use exponent notation) for non-base-10 numbers. + * + * The bigint space in the context is reused for string output, as there + * is more than enough space for that (>1kB at the moment), and we avoid + * allocating even more stack. + */ + + DUK_ASSERT(DUK__NUMCONV_CTX_BIGINTS_SIZE >= DUK__MAX_FORMATTED_LENGTH); + DUK_ASSERT(nc_ctx->count >= 1); + + k = nc_ctx->k; + buf = (duk_uint8_t *) &nc_ctx->f; /* XXX: union would be more correct */ + q = buf; + + /* Exponent handling: if exponent format is used, record exponent value and + * fake k such that one leading digit is generated (e.g. digits=123 -> "1.23"). + * + * toFixed() prevents exponent use; otherwise apply a set of criteria to + * match the other API calls (toString(), toPrecision, etc). + */ + + expt = DUK__NO_EXP; + if (!nc_ctx->abs_pos /* toFixed() */) { + if ((flags & DUK_N2S_FLAG_FORCE_EXP) || /* exponential notation forced */ + ((flags & DUK_N2S_FLAG_NO_ZERO_PAD) && /* fixed precision and zero padding would be required */ + (k - digits >= 1)) || /* (e.g. k=3, digits=2 -> "12X") */ + ((k > 21 || k <= -6) && (radix == 10))) { /* toString() conditions */ + DUK_DDD(DUK_DDDPRINT("use exponential notation: k=%ld -> expt=%ld", + (long) k, (long) (k - 1))); + expt = k - 1; /* e.g. 12.3 -> digits="123" k=2 -> 1.23e1 */ + k = 1; /* generate mantissa with a single leading whole number digit */ + } + } + + if (neg) { + *q++ = '-'; + } + + /* Start position (inclusive) and end position (exclusive) */ + pos = (k >= 1 ? k : 1); + if (nc_ctx->is_fixed) { + if (nc_ctx->abs_pos) { + /* toFixed() */ + pos_end = -digits; + } else { + pos_end = k - digits; + } + } else { + pos_end = k - nc_ctx->count; + } + if (pos_end > 0) { + pos_end = 0; + } + + DUK_DDD(DUK_DDDPRINT("expt=%ld, k=%ld, count=%ld, pos=%ld, pos_end=%ld, is_fixed=%ld, " + "digits=%ld, abs_pos=%ld", + (long) expt, (long) k, (long) nc_ctx->count, (long) pos, (long) pos_end, + (long) nc_ctx->is_fixed, (long) digits, (long) nc_ctx->abs_pos)); + + /* Digit generation */ + while (pos > pos_end) { + DUK_DDD(DUK_DDDPRINT("digit generation: pos=%ld, pos_end=%ld", + (long) pos, (long) pos_end)); + if (pos == 0) { + *q++ = (duk_uint8_t) '.'; + } + if (pos > k) { + *q++ = (duk_uint8_t) '0'; + } else if (pos <= k - nc_ctx->count) { + *q++ = (duk_uint8_t) '0'; + } else { + dig = nc_ctx->digits[k - pos]; + DUK_ASSERT(dig >= 0 && dig < nc_ctx->B); + *q++ = (duk_uint8_t) DUK__DIGITCHAR(dig); + } + + pos--; + } + DUK_ASSERT(pos <= 1); + + /* Exponent */ + if (expt != DUK__NO_EXP) { + /* + * Exponent notation for non-base-10 numbers isn't specified in Ecmascript + * specification, as it never explicitly turns up: non-decimal numbers can + * only be formatted with Number.prototype.toString([radix]) and for that, + * behavior is not explicitly specified. + * + * Logical choices include formatting the exponent as decimal (e.g. binary + * 100000 as 1e+5) or in current radix (e.g. binary 100000 as 1e+101). + * The Dragon4 algorithm (in the original paper) prints the exponent value + * in the target radix B. However, for radix values 15 and above, the + * exponent separator 'e' is no longer easily parseable. Consider, for + * instance, the number "1.faecee+1c". + */ + + duk_size_t len; + char expt_sign; + + *q++ = 'e'; + if (expt >= 0) { + expt_sign = '+'; + } else { + expt_sign = '-'; + expt = -expt; + } + *q++ = (duk_uint8_t) expt_sign; + len = duk__dragon4_format_uint32(q, (duk_uint32_t) expt, radix); + q += len; + } + + duk_push_lstring(ctx, (const char *) buf, (size_t) (q - buf)); +} + +/* + * Conversion helpers + */ + +DUK_LOCAL void duk__dragon4_double_to_ctx(duk__numconv_stringify_ctx *nc_ctx, duk_double_t x) { + duk_double_union u; + duk_uint32_t tmp; + duk_small_int_t expt; + + /* + * seeeeeee eeeeffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff + * A B C D E F G H + * + * s sign bit + * eee... exponent field + * fff... fraction + * + * ieee value = 1.ffff... * 2^(e - 1023) (normal) + * = 0.ffff... * 2^(-1022) (denormal) + * + * algorithm v = f * b^e + */ + + DUK_DBLUNION_SET_DOUBLE(&u, x); + + nc_ctx->f.n = 2; + + tmp = DUK_DBLUNION_GET_LOW32(&u); + nc_ctx->f.v[0] = tmp; + tmp = DUK_DBLUNION_GET_HIGH32(&u); + nc_ctx->f.v[1] = tmp & 0x000fffffUL; + expt = (duk_small_int_t) ((tmp >> 20) & 0x07ffUL); + + if (expt == 0) { + /* denormal */ + expt = DUK__IEEE_DOUBLE_EXP_MIN - 52; + duk__bi_normalize(&nc_ctx->f); + } else { + /* normal: implicit leading 1-bit */ + nc_ctx->f.v[1] |= 0x00100000UL; + expt = expt - DUK__IEEE_DOUBLE_EXP_BIAS - 52; + DUK_ASSERT(duk__bi_is_valid(&nc_ctx->f)); /* true, because v[1] has at least one bit set */ + } + + DUK_ASSERT(duk__bi_is_valid(&nc_ctx->f)); + + nc_ctx->e = expt; +} + +DUK_LOCAL void duk__dragon4_ctx_to_double(duk__numconv_stringify_ctx *nc_ctx, duk_double_t *x) { + duk_double_union u; + duk_small_int_t expt; + duk_small_int_t i; + duk_small_int_t bitstart; + duk_small_int_t bitround; + duk_small_int_t bitidx; + duk_small_int_t skip_round; + duk_uint32_t t, v; + + DUK_ASSERT(nc_ctx->count == 53 + 1); + + /* Sometimes this assert is not true right now; it will be true after + * rounding. See: test-bug-numconv-mantissa-assert.js. + */ + DUK_ASSERT_DISABLE(nc_ctx->digits[0] == 1); /* zero handled by caller */ + + /* Should not be required because the code below always sets both high + * and low parts, but at least gcc-4.4.5 fails to deduce this correctly + * (perhaps because the low part is set (seemingly) conditionally in a + * loop), so this is here to avoid the bogus warning. + */ + DUK_MEMZERO((void *) &u, sizeof(u)); + + /* + * Figure out how generated digits match up with the mantissa, + * and then perform rounding. If mantissa overflows, need to + * recompute the exponent (it is bumped and may overflow to + * infinity). + * + * For normal numbers the leading '1' is hidden and ignored, + * and the last bit is used for rounding: + * + * rounding pt + * <--------52------->| + * 1 x x x x ... x x x x|y ==> x x x x ... x x x x + * + * For denormals, the leading '1' is included in the number, + * and the rounding point is different: + * + * rounding pt + * <--52 or less--->| + * 1 x x x x ... x x|x x y ==> 0 0 ... 1 x x ... x x + * + * The largest denormals will have a mantissa beginning with + * a '1' (the explicit leading bit); smaller denormals will + * have leading zero bits. + * + * If the exponent would become too high, the result becomes + * Infinity. If the exponent is so small that the entire + * mantissa becomes zero, the result becomes zero. + * + * Note: the Dragon4 'k' is off-by-one with respect to the IEEE + * exponent. For instance, k==0 indicates that the leading '1' + * digit is at the first binary fraction position (0.1xxx...); + * the corresponding IEEE exponent would be -1. + */ + + skip_round = 0; + + recheck_exp: + + expt = nc_ctx->k - 1; /* IEEE exp without bias */ + if (expt > 1023) { + /* Infinity */ + bitstart = -255; /* needed for inf: causes mantissa to become zero, + * and rounding to be skipped. + */ + expt = 2047; + } else if (expt >= -1022) { + /* normal */ + bitstart = 1; /* skip leading digit */ + expt += DUK__IEEE_DOUBLE_EXP_BIAS; + DUK_ASSERT(expt >= 1 && expt <= 2046); + } else { + /* denormal or zero */ + bitstart = 1023 + expt; /* expt==-1023 -> bitstart=0 (leading 1); + * expt==-1024 -> bitstart=-1 (one left of leading 1), etc + */ + expt = 0; + } + bitround = bitstart + 52; + + DUK_DDD(DUK_DDDPRINT("ieee expt=%ld, bitstart=%ld, bitround=%ld", + (long) expt, (long) bitstart, (long) bitround)); + + if (!skip_round) { + if (duk__dragon4_fixed_format_round(nc_ctx, bitround)) { + /* Corner case: see test-numconv-parse-mant-carry.js. We could + * just bump the exponent and update bitstart, but it's more robust + * to recompute (but avoid rounding twice). + */ + DUK_DDD(DUK_DDDPRINT("rounding caused exponent to be bumped, recheck exponent")); + skip_round = 1; + goto recheck_exp; + } + } + + /* + * Create mantissa + */ + + t = 0; + for (i = 0; i < 52; i++) { + bitidx = bitstart + 52 - 1 - i; + if (bitidx >= nc_ctx->count) { + v = 0; + } else if (bitidx < 0) { + v = 0; + } else { + v = nc_ctx->digits[bitidx]; + } + DUK_ASSERT(v == 0 || v == 1); + t += v << (i % 32); + if (i == 31) { + /* low 32 bits is complete */ + DUK_DBLUNION_SET_LOW32(&u, t); + t = 0; + } + } + /* t has high mantissa */ + + DUK_DDD(DUK_DDDPRINT("mantissa is complete: %08lx %08lx", + (unsigned long) t, + (unsigned long) DUK_DBLUNION_GET_LOW32(&u))); + + DUK_ASSERT(expt >= 0 && expt <= 0x7ffL); + t += expt << 20; +#if 0 /* caller handles sign change */ + if (negative) { + t |= 0x80000000U; + } +#endif + DUK_DBLUNION_SET_HIGH32(&u, t); + + DUK_DDD(DUK_DDDPRINT("number is complete: %08lx %08lx", + (unsigned long) DUK_DBLUNION_GET_HIGH32(&u), + (unsigned long) DUK_DBLUNION_GET_LOW32(&u))); + + *x = DUK_DBLUNION_GET_DOUBLE(&u); +} + +/* + * Exposed number-to-string API + * + * Input: [ number ] + * Output: [ string ] + */ + +DUK_INTERNAL void duk_numconv_stringify(duk_context *ctx, duk_small_int_t radix, duk_small_int_t digits, duk_small_uint_t flags) { + duk_double_t x; + duk_small_int_t c; + duk_small_int_t neg; + duk_uint32_t uval; + duk__numconv_stringify_ctx nc_ctx_alloc; /* large context; around 2kB now */ + duk__numconv_stringify_ctx *nc_ctx = &nc_ctx_alloc; + + x = (duk_double_t) duk_require_number(ctx, -1); + duk_pop(ctx); + + /* + * Handle special cases (NaN, infinity, zero). + */ + + c = (duk_small_int_t) DUK_FPCLASSIFY(x); + if (DUK_SIGNBIT((double) x)) { + x = -x; + neg = 1; + } else { + neg = 0; + } + + /* NaN sign bit is platform specific with unpacked, un-normalized NaNs */ + DUK_ASSERT(c == DUK_FP_NAN || DUK_SIGNBIT((double) x) == 0); + + if (c == DUK_FP_NAN) { + duk_push_hstring_stridx(ctx, DUK_STRIDX_NAN); + return; + } else if (c == DUK_FP_INFINITE) { + if (neg) { + /* -Infinity */ + duk_push_hstring_stridx(ctx, DUK_STRIDX_MINUS_INFINITY); + } else { + /* Infinity */ + duk_push_hstring_stridx(ctx, DUK_STRIDX_INFINITY); + } + return; + } else if (c == DUK_FP_ZERO) { + /* We can't shortcut zero here if it goes through special formatting + * (such as forced exponential notation). + */ + ; + } + + /* + * Handle integers in 32-bit range (that is, [-(2**32-1),2**32-1]) + * specially, as they're very likely for embedded programs. This + * is now done for all radix values. We must be careful not to use + * the fast path when special formatting (e.g. forced exponential) + * is in force. + * + * XXX: could save space by supporting radix 10 only and using + * sprintf "%lu" for the fast path and for exponent formatting. + */ + + uval = (unsigned int) x; + if (((double) uval) == x && /* integer number in range */ + flags == 0) { /* no special formatting */ + /* use bigint area as a temp */ + duk_uint8_t *buf = (duk_uint8_t *) (&nc_ctx->f); + duk_uint8_t *p = buf; + + DUK_ASSERT(DUK__NUMCONV_CTX_BIGINTS_SIZE >= 32 + 1); /* max size: radix=2 + sign */ + if (neg && uval != 0) { + /* no negative sign for zero */ + *p++ = (duk_uint8_t) '-'; + } + p += duk__dragon4_format_uint32(p, uval, radix); + duk_push_lstring(ctx, (const char *) buf, (duk_size_t) (p - buf)); + return; + } + + /* + * Dragon4 setup. + * + * Convert double from IEEE representation for conversion; + * normal finite values have an implicit leading 1-bit. The + * slow path algorithm doesn't handle zero, so zero is special + * cased here but still creates a valid nc_ctx, and goes + * through normal formatting in case special formatting has + * been requested (e.g. forced exponential format: 0 -> "0e+0"). + */ + + /* Would be nice to bulk clear the allocation, but the context + * is 1-2 kilobytes and nothing should rely on it being zeroed. + */ +#if 0 + DUK_MEMZERO((void *) nc_ctx, sizeof(*nc_ctx)); /* slow init, do only for slow path cases */ +#endif + + nc_ctx->is_s2n = 0; + nc_ctx->b = 2; + nc_ctx->B = radix; + nc_ctx->abs_pos = 0; + if (flags & DUK_N2S_FLAG_FIXED_FORMAT) { + nc_ctx->is_fixed = 1; + if (flags & DUK_N2S_FLAG_FRACTION_DIGITS) { + /* absolute req_digits; e.g. digits = 1 -> last digit is 0, + * but add an extra digit for rounding. + */ + nc_ctx->abs_pos = 1; + nc_ctx->req_digits = (-digits + 1) - 1; + } else { + nc_ctx->req_digits = digits + 1; + } + } else { + nc_ctx->is_fixed = 0; + nc_ctx->req_digits = 0; + } + + if (c == DUK_FP_ZERO) { + /* Zero special case: fake requested number of zero digits; ensure + * no sign bit is printed. Relative and absolute fixed format + * require separate handling. + */ + duk_small_int_t count; + if (nc_ctx->is_fixed) { + if (nc_ctx->abs_pos) { + count = digits + 2; /* lead zero + 'digits' fractions + 1 for rounding */ + } else { + count = digits + 1; /* + 1 for rounding */ + } + } else { + count = 1; + } + DUK_DDD(DUK_DDDPRINT("count=%ld", (long) count)); + DUK_ASSERT(count >= 1); + DUK_MEMZERO((void *) nc_ctx->digits, count); + nc_ctx->count = count; + nc_ctx->k = 1; /* 0.000... */ + neg = 0; + goto zero_skip; + } + + duk__dragon4_double_to_ctx(nc_ctx, x); /* -> sets 'f' and 'e' */ + DUK__BI_PRINT("f", &nc_ctx->f); + DUK_DDD(DUK_DDDPRINT("e=%ld", (long) nc_ctx->e)); + + /* + * Dragon4 slow path digit generation. + */ + + duk__dragon4_prepare(nc_ctx); /* setup many variables in nc_ctx */ + + DUK_DDD(DUK_DDDPRINT("after prepare:")); + DUK__BI_PRINT("r", &nc_ctx->r); + DUK__BI_PRINT("s", &nc_ctx->s); + DUK__BI_PRINT("mp", &nc_ctx->mp); + DUK__BI_PRINT("mm", &nc_ctx->mm); + + duk__dragon4_scale(nc_ctx); + + DUK_DDD(DUK_DDDPRINT("after scale; k=%ld", (long) nc_ctx->k)); + DUK__BI_PRINT("r", &nc_ctx->r); + DUK__BI_PRINT("s", &nc_ctx->s); + DUK__BI_PRINT("mp", &nc_ctx->mp); + DUK__BI_PRINT("mm", &nc_ctx->mm); + + duk__dragon4_generate(nc_ctx); + + /* + * Convert and push final string. + */ + + zero_skip: + + if (flags & DUK_N2S_FLAG_FIXED_FORMAT) { + /* Perform fixed-format rounding. */ + duk_small_int_t roundpos; + if (flags & DUK_N2S_FLAG_FRACTION_DIGITS) { + /* 'roundpos' is relative to nc_ctx->k and increases to the right + * (opposite of how 'k' changes). + */ + roundpos = -digits; /* absolute position for digit considered for rounding */ + roundpos = nc_ctx->k - roundpos; + } else { + roundpos = digits; + } + DUK_DDD(DUK_DDDPRINT("rounding: k=%ld, count=%ld, digits=%ld, roundpos=%ld", + (long) nc_ctx->k, (long) nc_ctx->count, (long) digits, (long) roundpos)); + (void) duk__dragon4_fixed_format_round(nc_ctx, roundpos); + + /* Note: 'count' is currently not adjusted by rounding (i.e. the + * digits are not "chopped off". That shouldn't matter because + * the digit position (absolute or relative) is passed on to the + * convert-and-push function. + */ + } + + duk__dragon4_convert_and_push(nc_ctx, ctx, radix, digits, flags, neg); +} + +/* + * Exposed string-to-number API + * + * Input: [ string ] + * Output: [ number ] + * + * If number parsing fails, a NaN is pushed as the result. If number parsing + * fails due to an internal error, an InternalError is thrown. + */ + +DUK_INTERNAL void duk_numconv_parse(duk_context *ctx, duk_small_int_t radix, duk_small_uint_t flags) { + duk_hthread *thr = (duk_hthread *) ctx; + duk__numconv_stringify_ctx nc_ctx_alloc; /* large context; around 2kB now */ + duk__numconv_stringify_ctx *nc_ctx = &nc_ctx_alloc; + duk_double_t res; + duk_hstring *h_str; + duk_small_int_t expt; + duk_small_int_t expt_neg; + duk_small_int_t expt_adj; + duk_small_int_t neg; + duk_small_int_t dig; + duk_small_int_t dig_whole; + duk_small_int_t dig_lzero; + duk_small_int_t dig_frac; + duk_small_int_t dig_expt; + duk_small_int_t dig_prec; + const duk__exp_limits *explim; + const duk_uint8_t *p; + duk_small_int_t ch; + + /* This seems to waste a lot of stack frame entries, but good compilers + * will compute these as needed below. Some of these initial flags are + * also modified in the code below, so they can't all be removed. + */ + duk_small_int_t trim_white = (flags & DUK_S2N_FLAG_TRIM_WHITE); + duk_small_int_t allow_expt = (flags & DUK_S2N_FLAG_ALLOW_EXP); + duk_small_int_t allow_garbage = (flags & DUK_S2N_FLAG_ALLOW_GARBAGE); + duk_small_int_t allow_plus = (flags & DUK_S2N_FLAG_ALLOW_PLUS); + duk_small_int_t allow_minus = (flags & DUK_S2N_FLAG_ALLOW_MINUS); + duk_small_int_t allow_infinity = (flags & DUK_S2N_FLAG_ALLOW_INF); + duk_small_int_t allow_frac = (flags & DUK_S2N_FLAG_ALLOW_FRAC); + duk_small_int_t allow_naked_frac = (flags & DUK_S2N_FLAG_ALLOW_NAKED_FRAC); + duk_small_int_t allow_empty_frac = (flags & DUK_S2N_FLAG_ALLOW_EMPTY_FRAC); + duk_small_int_t allow_empty = (flags & DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO); + duk_small_int_t allow_leading_zero = (flags & DUK_S2N_FLAG_ALLOW_LEADING_ZERO); + duk_small_int_t allow_auto_hex_int = (flags & DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT); + duk_small_int_t allow_auto_oct_int = (flags & DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT); + + DUK_DDD(DUK_DDDPRINT("parse number: %!T, radix=%ld, flags=0x%08lx", + (duk_tval *) duk_get_tval(ctx, -1), + (long) radix, (unsigned long) flags)); + + DUK_ASSERT(radix >= 2 && radix <= 36); + DUK_ASSERT(radix - 2 < (duk_small_int_t) sizeof(duk__str2num_digits_for_radix)); + + /* + * Preliminaries: trim, sign, Infinity check + * + * We rely on the interned string having a NUL terminator, which will + * cause a parse failure wherever it is encountered. As a result, we + * don't need separate pointer checks. + * + * There is no special parsing for 'NaN' in the specification although + * 'Infinity' (with an optional sign) is allowed in some contexts. + * Some contexts allow plus/minus sign, while others only allow the + * minus sign (like JSON.parse()). + * + * Automatic hex number detection (leading '0x' or '0X') and octal + * number detection (leading '0' followed by at least one octal digit) + * is done here too. + */ + + if (trim_white) { + /* Leading / trailing whitespace is sometimes accepted and + * sometimes not. After white space trimming, all valid input + * characters are pure ASCII. + */ + duk_trim(ctx, -1); + } + h_str = duk_require_hstring(ctx, -1); + DUK_ASSERT(h_str != NULL); + p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_str); + + neg = 0; + ch = *p; + if (ch == (duk_small_int_t) '+') { + if (!allow_plus) { + DUK_DDD(DUK_DDDPRINT("parse failed: leading plus sign not allowed")); + goto parse_fail; + } + p++; + } else if (ch == (duk_small_int_t) '-') { + if (!allow_minus) { + DUK_DDD(DUK_DDDPRINT("parse failed: leading minus sign not allowed")); + goto parse_fail; + } + p++; + neg = 1; + } + + ch = *p; + if (allow_infinity && ch == (duk_small_int_t) 'I') { + /* Don't check for Infinity unless the context allows it. + * 'Infinity' is a valid integer literal in e.g. base-36: + * + * parseInt('Infinity', 36) + * 1461559270678 + */ + + const duk_uint8_t *q; + + /* borrow literal Infinity from builtin string */ + q = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(DUK_HTHREAD_STRING_INFINITY(thr)); + if (DUK_STRNCMP((const char *) p, (const char *) q, 8) == 0) { + if (!allow_garbage && (p[8] != (duk_uint8_t) 0)) { + DUK_DDD(DUK_DDDPRINT("parse failed: trailing garbage after matching 'Infinity' not allowed")); + goto parse_fail; + } else { + res = DUK_DOUBLE_INFINITY; + goto negcheck_and_ret; + } + } + } + if (ch == (duk_small_int_t) '0') { + duk_small_int_t detect_radix = 0; + ch = p[1]; + if (allow_auto_hex_int && (ch == (duk_small_int_t) 'x' || ch == (duk_small_int_t) 'X')) { + DUK_DDD(DUK_DDDPRINT("detected 0x/0X hex prefix, changing radix and preventing fractions and exponent")); + detect_radix = 16; + allow_empty = 0; /* interpret e.g. '0x' and '0xg' as a NaN (= parse error) */ + p += 2; + } else if (allow_auto_oct_int && (ch >= (duk_small_int_t) '0' && ch <= (duk_small_int_t) '9')) { + DUK_DDD(DUK_DDDPRINT("detected 0n oct prefix, changing radix and preventing fractions and exponent")); + detect_radix = 8; + allow_empty = 1; /* interpret e.g. '09' as '0', not NaN */ + p += 1; + } + if (detect_radix > 0) { + radix = detect_radix; + allow_expt = 0; + allow_frac = 0; + allow_naked_frac = 0; + allow_empty_frac = 0; + allow_leading_zero = 1; /* allow e.g. '0x0009' and '00077' */ + } + } + + /* + * Scan number and setup for Dragon4. + * + * The fast path case is detected during setup: an integer which + * can be converted without rounding, no net exponent. The fast + * path could be implemented as a separate scan, but may not really + * be worth it: the multiplications for building 'f' are not + * expensive when 'f' is small. + * + * The significand ('f') must contain enough bits of (apparent) + * accuracy, so that Dragon4 will generate enough binary output digits. + * For decimal numbers, this means generating a 20-digit significand, + * which should yield enough practical accuracy to parse IEEE doubles. + * In fact, the Ecmascript specification explicitly allows an + * implementation to treat digits beyond 20 as zeroes (and even + * to round the 20th digit upwards). For non-decimal numbers, the + * appropriate number of digits has been precomputed for comparable + * accuracy. + * + * Digit counts: + * + * [ dig_lzero ] + * | + * .+-..---[ dig_prec ]----. + * | || | + * 0000123.456789012345678901234567890e+123456 + * | | | | | | + * `--+--' `------[ dig_frac ]-------' `-+--' + * | | + * [ dig_whole ] [ dig_expt ] + * + * dig_frac and dig_expt are -1 if not present + * dig_lzero is only computed for whole number part + * + * Parsing state + * + * Parsing whole part dig_frac < 0 AND dig_expt < 0 + * Parsing fraction part dig_frac >= 0 AND dig_expt < 0 + * Parsing exponent part dig_expt >= 0 (dig_frac may be < 0 or >= 0) + * + * Note: in case we hit an implementation limit (like exponent range), + * we should throw an error, NOT return NaN or Infinity. Even with + * very large exponent (or significand) values the final result may be + * finite, so NaN/Infinity would be incorrect. + */ + + duk__bi_set_small(&nc_ctx->f, 0); + dig_prec = 0; + dig_lzero = 0; + dig_whole = 0; + dig_frac = -1; + dig_expt = -1; + expt = 0; + expt_adj = 0; /* essentially tracks digit position of lowest 'f' digit */ + expt_neg = 0; + for (;;) { + ch = *p++; + + DUK_DDD(DUK_DDDPRINT("parse digits: p=%p, ch='%c' (%ld), expt=%ld, expt_adj=%ld, " + "dig_whole=%ld, dig_frac=%ld, dig_expt=%ld, dig_lzero=%ld, dig_prec=%ld", + (void *) p, (int) ((ch >= 0x20 && ch <= 0x7e) ? ch : '?'), (long) ch, + (long) expt, (long) expt_adj, (long) dig_whole, (long) dig_frac, + (long) dig_expt, (long) dig_lzero, (long) dig_prec)); + DUK__BI_PRINT("f", &nc_ctx->f); + + /* Most common cases first. */ + if (ch >= (duk_small_int_t) '0' && ch <= (duk_small_int_t) '9') { + dig = (int) ch - '0' + 0; + } else if (ch == (duk_small_int_t) '.') { + /* A leading digit is not required in some cases, e.g. accept ".123". + * In other cases (JSON.parse()) a leading digit is required. This + * is checked for after the loop. + */ + if (dig_frac >= 0 || dig_expt >= 0) { + if (allow_garbage) { + DUK_DDD(DUK_DDDPRINT("garbage termination (invalid period)")); + break; + } else { + DUK_DDD(DUK_DDDPRINT("parse failed: period not allowed")); + goto parse_fail; + } + } + + if (!allow_frac) { + /* Some contexts don't allow fractions at all; this can't be a + * post-check because the state ('f' and expt) would be incorrect. + */ + if (allow_garbage) { + DUK_DDD(DUK_DDDPRINT("garbage termination (invalid first period)")); + break; + } else { + DUK_DDD(DUK_DDDPRINT("parse failed: fraction part not allowed")); + } + } + + DUK_DDD(DUK_DDDPRINT("start fraction part")); + dig_frac = 0; + continue; + } else if (ch == (duk_small_int_t) 0) { + DUK_DDD(DUK_DDDPRINT("NUL termination")); + break; + } else if (allow_expt && dig_expt < 0 && (ch == (duk_small_int_t) 'e' || ch == (duk_small_int_t) 'E')) { + /* Note: we don't parse back exponent notation for anything else + * than radix 10, so this is not an ambiguous check (e.g. hex + * exponent values may have 'e' either as a significand digit + * or as an exponent separator). + * + * If the exponent separator occurs twice, 'e' will be interpreted + * as a digit (= 14) and will be rejected as an invalid decimal + * digit. + */ + + DUK_DDD(DUK_DDDPRINT("start exponent part")); + + /* Exponent without a sign or with a +/- sign is accepted + * by all call sites (even JSON.parse()). + */ + ch = *p; + if (ch == (duk_small_int_t) '-') { + expt_neg = 1; + p++; + } else if (ch == (duk_small_int_t) '+') { + p++; + } + dig_expt = 0; + continue; + } else if (ch >= (duk_small_int_t) 'a' && ch <= (duk_small_int_t) 'z') { + dig = (duk_small_int_t) (ch - (duk_small_int_t) 'a' + 0x0a); + } else if (ch >= (duk_small_int_t) 'A' && ch <= (duk_small_int_t) 'Z') { + dig = (duk_small_int_t) (ch - (duk_small_int_t) 'A' + 0x0a); + } else { + dig = 255; /* triggers garbage digit check below */ + } + DUK_ASSERT((dig >= 0 && dig <= 35) || dig == 255); + + if (dig >= radix) { + if (allow_garbage) { + DUK_DDD(DUK_DDDPRINT("garbage termination")); + break; + } else { + DUK_DDD(DUK_DDDPRINT("parse failed: trailing garbage or invalid digit")); + goto parse_fail; + } + } + + if (dig_expt < 0) { + /* whole or fraction digit */ + + if (dig_prec < duk__str2num_digits_for_radix[radix - 2]) { + /* significant from precision perspective */ + + duk_small_int_t f_zero = duk__bi_is_zero(&nc_ctx->f); + if (f_zero && dig == 0) { + /* Leading zero is not counted towards precision digits; not + * in the integer part, nor in the fraction part. + */ + if (dig_frac < 0) { + dig_lzero++; + } + } else { + /* XXX: join these ops (multiply-accumulate), but only if + * code footprint decreases. + */ + duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, radix); + duk__bi_add_small(&nc_ctx->f, &nc_ctx->t1, dig); + dig_prec++; + } + } else { + /* Ignore digits beyond a radix-specific limit, but note them + * in expt_adj. + */ + expt_adj++; + } + + if (dig_frac >= 0) { + dig_frac++; + expt_adj--; + } else { + dig_whole++; + } + } else { + /* exponent digit */ + + expt = expt * radix + dig; + if (expt > DUK_S2N_MAX_EXPONENT) { + /* impose a reasonable exponent limit, so that exp + * doesn't need to get tracked using a bigint. + */ + DUK_DDD(DUK_DDDPRINT("parse failed: exponent too large")); + goto parse_int_error; + } + dig_expt++; + } + } + + /* Leading zero. */ + + if (dig_lzero > 0 && dig_whole > 1) { + if (!allow_leading_zero) { + DUK_DDD(DUK_DDDPRINT("parse failed: leading zeroes not allowed in integer part")); + goto parse_fail; + } + } + + /* Validity checks for various fraction formats ("0.1", ".1", "1.", "."). */ + + if (dig_whole == 0) { + if (dig_frac == 0) { + /* "." is not accepted in any format */ + DUK_DDD(DUK_DDDPRINT("parse failed: plain period without leading or trailing digits")); + goto parse_fail; + } else if (dig_frac > 0) { + /* ".123" */ + if (!allow_naked_frac) { + DUK_DDD(DUK_DDDPRINT("parse failed: fraction part not allowed without " + "leading integer digit(s)")); + goto parse_fail; + } + } else { + /* empty ("") is allowed in some formats (e.g. Number(''), as zero */ + if (!allow_empty) { + DUK_DDD(DUK_DDDPRINT("parse failed: empty string not allowed (as zero)")); + goto parse_fail; + } + } + } else { + if (dig_frac == 0) { + /* "123." is allowed in some formats */ + if (!allow_empty_frac) { + DUK_DDD(DUK_DDDPRINT("parse failed: empty fractions")); + goto parse_fail; + } + } else if (dig_frac > 0) { + /* "123.456" */ + ; + } else { + /* "123" */ + ; + } + } + + /* Exponent without digits (e.g. "1e" or "1e+"). If trailing garbage is + * allowed, ignore exponent part as garbage (= parse as "1", i.e. exp 0). + */ + + if (dig_expt == 0) { + if (!allow_garbage) { + DUK_DDD(DUK_DDDPRINT("parse failed: empty exponent")); + goto parse_fail; + } + DUK_ASSERT(expt == 0); + } + + if (expt_neg) { + expt = -expt; + } + DUK_DDD(DUK_DDDPRINT("expt=%ld, expt_adj=%ld, net exponent -> %ld", + (long) expt, (long) expt_adj, (long) (expt + expt_adj))); + expt += expt_adj; + + /* Fast path check. */ + + if (nc_ctx->f.n <= 1 && /* 32-bit value */ + expt == 0 /* no net exponent */) { + /* Fast path is triggered for no exponent and also for balanced exponent + * and fraction parts, e.g. for "1.23e2" == "123". Remember to respect + * zero sign. + */ + + /* XXX: could accept numbers larger than 32 bits, e.g. up to 53 bits? */ + DUK_DDD(DUK_DDDPRINT("fast path number parse")); + if (nc_ctx->f.n == 1) { + res = (double) nc_ctx->f.v[0]; + } else { + res = 0.0; + } + goto negcheck_and_ret; + } + + /* Significand ('f') padding. */ + + while (dig_prec < duk__str2num_digits_for_radix[radix - 2]) { + /* Pad significand with "virtual" zero digits so that Dragon4 will + * have enough (apparent) precision to work with. + */ + DUK_DDD(DUK_DDDPRINT("dig_prec=%ld, pad significand with zero", (long) dig_prec)); + duk__bi_mul_small_copy(&nc_ctx->f, radix, &nc_ctx->t1); + DUK__BI_PRINT("f", &nc_ctx->f); + expt--; + dig_prec++; + } + + DUK_DDD(DUK_DDDPRINT("final exponent: %ld", (long) expt)); + + /* Detect zero special case. */ + + if (nc_ctx->f.n == 0) { + /* This may happen even after the fast path check, if exponent is + * not balanced (e.g. "0e1"). Remember to respect zero sign. + */ + DUK_DDD(DUK_DDDPRINT("significand is zero")); + res = 0.0; + goto negcheck_and_ret; + } + + + /* Quick reject of too large or too small exponents. This check + * would be incorrect for zero (e.g. "0e1000" is zero, not Infinity) + * so zero check must be above. + */ + + explim = &duk__str2num_exp_limits[radix - 2]; + if (expt > explim->upper) { + DUK_DDD(DUK_DDDPRINT("exponent too large -> infinite")); + res = (duk_double_t) DUK_DOUBLE_INFINITY; + goto negcheck_and_ret; + } else if (expt < explim->lower) { + DUK_DDD(DUK_DDDPRINT("exponent too small -> zero")); + res = (duk_double_t) 0.0; + goto negcheck_and_ret; + } + + nc_ctx->is_s2n = 1; + nc_ctx->e = expt; + nc_ctx->b = radix; + nc_ctx->B = 2; + nc_ctx->is_fixed = 1; + nc_ctx->abs_pos = 0; + nc_ctx->req_digits = 53 + 1; + + DUK__BI_PRINT("f", &nc_ctx->f); + DUK_DDD(DUK_DDDPRINT("e=%ld", (long) nc_ctx->e)); + + /* + * Dragon4 slow path (binary) digit generation. + * An extra digit is generated for rounding. + */ + + duk__dragon4_prepare(nc_ctx); /* setup many variables in nc_ctx */ + + DUK_DDD(DUK_DDDPRINT("after prepare:")); + DUK__BI_PRINT("r", &nc_ctx->r); + DUK__BI_PRINT("s", &nc_ctx->s); + DUK__BI_PRINT("mp", &nc_ctx->mp); + DUK__BI_PRINT("mm", &nc_ctx->mm); + + duk__dragon4_scale(nc_ctx); + + DUK_DDD(DUK_DDDPRINT("after scale; k=%ld", (long) nc_ctx->k)); + DUK__BI_PRINT("r", &nc_ctx->r); + DUK__BI_PRINT("s", &nc_ctx->s); + DUK__BI_PRINT("mp", &nc_ctx->mp); + DUK__BI_PRINT("mm", &nc_ctx->mm); + + duk__dragon4_generate(nc_ctx); + + DUK_ASSERT(nc_ctx->count == 53 + 1); + + /* + * Convert binary digits into an IEEE double. Need to handle + * denormals and rounding correctly. + */ + + duk__dragon4_ctx_to_double(nc_ctx, &res); + goto negcheck_and_ret; + + negcheck_and_ret: + if (neg) { + res = -res; + } + duk_pop(ctx); + duk_push_number(ctx, (double) res); + DUK_DDD(DUK_DDDPRINT("result: %!T", (duk_tval *) duk_get_tval(ctx, -1))); + return; + + parse_fail: + DUK_DDD(DUK_DDDPRINT("parse failed")); + duk_pop(ctx); + duk_push_nan(ctx); + return; + + parse_int_error: + DUK_DDD(DUK_DDDPRINT("parse failed, internal error, can't return a value")); + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "number parse error"); + return; +} +#line 1 "duk_regexp_compiler.c" +/* + * Regexp compilation. + * + * See doc/regexp.rst for a discussion of the compilation approach and + * current limitations. + * + * Regexp bytecode assumes jumps can be expressed with signed 32-bit + * integers. Consequently the bytecode size must not exceed 0x7fffffffL. + * The implementation casts duk_size_t (buffer size) to duk_(u)int32_t + * in many places. Although this could be changed, the bytecode format + * limit would still prevent regexps exceeding the signed 32-bit limit + * from working. + * + * XXX: The implementation does not prevent bytecode from exceeding the + * maximum supported size. This could be done by limiting the maximum + * input string size (assuming an upper bound can be computed for number + * of bytecode bytes emitted per input byte) or checking buffer maximum + * size when emitting bytecode (slower). + */ + +/* include removed: duk_internal.h */ + +#ifdef DUK_USE_REGEXP_SUPPORT + +/* + * Helper macros + */ + +#define DUK__RE_INITIAL_BUFSIZE 64 + +#undef DUK__RE_BUFLEN +#define DUK__RE_BUFLEN(re_ctx) \ + DUK_BW_GET_SIZE(re_ctx->thr, &re_ctx->bw) + +/* + * Disjunction struct: result of parsing a disjunction + */ + +typedef struct { + /* Number of characters that the atom matches (e.g. 3 for 'abc'), + * -1 if atom is complex and number of matched characters either + * varies or is not known. + */ + duk_int32_t charlen; + +#if 0 + /* These are not needed to implement quantifier capture handling, + * but might be needed at some point. + */ + + /* re_ctx->captures at start and end of atom parsing. + * Since 'captures' indicates highest capture number emitted + * so far in a DUK_REOP_SAVE, the captures numbers saved by + * the atom are: ]start_captures,end_captures]. + */ + duk_uint32_t start_captures; + duk_uint32_t end_captures; +#endif +} duk__re_disjunction_info; + +/* + * Encoding helpers + * + * Some of the typing is bytecode based, e.g. slice sizes are unsigned 32-bit + * even though the buffer operations will use duk_size_t. + */ + +/* XXX: the insert helpers should ensure that the bytecode result is not + * larger than expected (or at least assert for it). Many things in the + * bytecode, like skip offsets, won't work correctly if the bytecode is + * larger than say 2G. + */ + +DUK_LOCAL duk_uint32_t duk__encode_i32(duk_int32_t x) { + if (x < 0) { + return ((duk_uint32_t) (-x)) * 2 + 1; + } else { + return ((duk_uint32_t) x) * 2; + } +} + +/* XXX: return type should probably be duk_size_t, or explicit checks are needed for + * maximum size. + */ +DUK_LOCAL duk_uint32_t duk__insert_u32(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_uint32_t x) { + duk_uint8_t buf[DUK_UNICODE_MAX_XUTF8_LENGTH]; + duk_small_int_t len; + + len = duk_unicode_encode_xutf8((duk_ucodepoint_t) x, buf); + DUK_BW_INSERT_ENSURE_BYTES(re_ctx->thr, &re_ctx->bw, offset, buf, len); + return (duk_uint32_t) len; +} + +DUK_LOCAL duk_uint32_t duk__append_u32(duk_re_compiler_ctx *re_ctx, duk_uint32_t x) { + duk_uint8_t buf[DUK_UNICODE_MAX_XUTF8_LENGTH]; + duk_small_int_t len; + + len = duk_unicode_encode_xutf8((duk_ucodepoint_t) x, buf); + DUK_BW_WRITE_ENSURE_BYTES(re_ctx->thr, &re_ctx->bw, buf, len); + return (duk_uint32_t) len; +} + +DUK_LOCAL duk_uint32_t duk__insert_i32(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_int32_t x) { + return duk__insert_u32(re_ctx, offset, duk__encode_i32(x)); +} + +#if 0 /* unused */ +DUK_LOCAL duk_uint32_t duk__append_i32(duk_re_compiler_ctx *re_ctx, duk_int32_t x) { + return duk__append_u32(re_ctx, duk__encode_i32(x)); +} +#endif + +/* special helper for emitting u16 lists (used for character ranges for built-in char classes) */ +DUK_LOCAL void duk__append_u16_list(duk_re_compiler_ctx *re_ctx, duk_uint16_t *values, duk_uint32_t count) { + /* Call sites don't need the result length so it's not accumulated. */ + while (count > 0) { + (void) duk__append_u32(re_ctx, (duk_uint32_t) (*values++)); + count--; + } +} + +DUK_LOCAL void duk__insert_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_uint32_t data_offset, duk_uint32_t data_length) { + DUK_BW_INSERT_ENSURE_SLICE(re_ctx->thr, &re_ctx->bw, offset, data_offset, data_length); +} + +DUK_LOCAL void duk__append_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t data_offset, duk_uint32_t data_length) { + DUK_BW_WRITE_ENSURE_SLICE(re_ctx->thr, &re_ctx->bw, data_offset, data_length); +} + +DUK_LOCAL void duk__remove_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t data_offset, duk_uint32_t data_length) { + DUK_BW_REMOVE_ENSURE_SLICE(re_ctx->thr, &re_ctx->bw, data_offset, data_length); +} + +/* + * Insert a jump offset at 'offset' to complete an instruction + * (the jump offset is always the last component of an instruction). + * The 'skip' argument must be computed relative to 'offset', + * -without- taking into account the skip field being inserted. + * + * ... A B C ins X Y Z ... (ins may be a JUMP, SPLIT1/SPLIT2, etc) + * => ... A B C ins SKIP X Y Z + * + * Computing the final (adjusted) skip value, which is relative to the + * first byte of the next instruction, is a bit tricky because of the + * variable length UTF-8 encoding. See doc/regexp.rst for discussion. + */ +DUK_LOCAL duk_uint32_t duk__insert_jump_offset(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_int32_t skip) { + duk_small_int_t len; + + /* XXX: solve into closed form (smaller code) */ + + if (skip < 0) { + /* two encoding attempts suffices */ + len = duk_unicode_get_xutf8_length((duk_codepoint_t) duk__encode_i32(skip)); + len = duk_unicode_get_xutf8_length((duk_codepoint_t) duk__encode_i32(skip - (duk_int32_t) len)); + DUK_ASSERT(duk_unicode_get_xutf8_length(duk__encode_i32(skip - (duk_int32_t) len)) == len); /* no change */ + skip -= (duk_int32_t) len; + } + return duk__insert_i32(re_ctx, offset, skip); +} + +DUK_LOCAL duk_uint32_t duk__append_jump_offset(duk_re_compiler_ctx *re_ctx, duk_int32_t skip) { + return (duk_uint32_t) duk__insert_jump_offset(re_ctx, (duk_uint32_t) DUK__RE_BUFLEN(re_ctx), skip); +} + +/* + * duk_re_range_callback for generating character class ranges. + * + * When ignoreCase is false, the range is simply emitted as is. + * We don't, for instance, eliminate duplicates or overlapping + * ranges in a character class. + * + * When ignoreCase is true, the range needs to be normalized through + * canonicalization. Unfortunately a canonicalized version of a + * continuous range is not necessarily continuous (e.g. [x-{] is + * continuous but [X-{] is not). The current algorithm creates the + * canonicalized range(s) space efficiently at the cost of compile + * time execution time (see doc/regexp.rst for discussion). + * + * Note that the ctx->nranges is a context-wide temporary value + * (this is OK because there cannot be multiple character classes + * being parsed simultaneously). + */ + +DUK_LOCAL void duk__generate_ranges(void *userdata, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct) { + duk_re_compiler_ctx *re_ctx = (duk_re_compiler_ctx *) userdata; + + DUK_DD(DUK_DDPRINT("duk__generate_ranges(): re_ctx=%p, range=[%ld,%ld] direct=%ld", + (void *) re_ctx, (long) r1, (long) r2, (long) direct)); + + if (!direct && (re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE)) { + /* + * Canonicalize a range, generating result ranges as necessary. + * Needs to exhaustively scan the entire range (at most 65536 + * code points). If 'direct' is set, caller (lexer) has ensured + * that the range is already canonicalization compatible (this + * is used to avoid unnecessary canonicalization of built-in + * ranges like \W, which are not affected by canonicalization). + * + * NOTE: here is one place where we don't want to support chars + * outside the BMP, because the exhaustive search would be + * massively larger. + */ + + duk_codepoint_t i; + duk_codepoint_t t; + duk_codepoint_t r_start, r_end; + + r_start = duk_unicode_re_canonicalize_char(re_ctx->thr, r1); + r_end = r_start; + for (i = r1 + 1; i <= r2; i++) { + t = duk_unicode_re_canonicalize_char(re_ctx->thr, i); + if (t == r_end + 1) { + r_end = t; + } else { + DUK_DD(DUK_DDPRINT("canonicalized, emit range: [%ld,%ld]", (long) r_start, (long) r_end)); + duk__append_u32(re_ctx, (duk_uint32_t) r_start); + duk__append_u32(re_ctx, (duk_uint32_t) r_end); + re_ctx->nranges++; + r_start = t; + r_end = t; + } + } + DUK_DD(DUK_DDPRINT("canonicalized, emit range: [%ld,%ld]", (long) r_start, (long) r_end)); + duk__append_u32(re_ctx, (duk_uint32_t) r_start); + duk__append_u32(re_ctx, (duk_uint32_t) r_end); + re_ctx->nranges++; + } else { + DUK_DD(DUK_DDPRINT("direct, emit range: [%ld,%ld]", (long) r1, (long) r2)); + duk__append_u32(re_ctx, (duk_uint32_t) r1); + duk__append_u32(re_ctx, (duk_uint32_t) r2); + re_ctx->nranges++; + } +} + +/* + * Parse regexp Disjunction. Most of regexp compilation happens here. + * + * Handles Disjunction, Alternative, and Term productions directly without + * recursion. The only constructs requiring recursion are positive/negative + * lookaheads, capturing parentheses, and non-capturing parentheses. + * + * The function determines whether the entire disjunction is a 'simple atom' + * (see doc/regexp.rst discussion on 'simple quantifiers') and if so, + * returns the atom character length which is needed by the caller to keep + * track of its own atom character length. A disjunction with more than one + * alternative is never considered a simple atom (although in some cases + * that might be the case). + * + * Return value: simple atom character length or < 0 if not a simple atom. + * Appends the bytecode for the disjunction matcher to the end of the temp + * buffer. + * + * Regexp top level structure is: + * + * Disjunction = Term* + * | Term* | Disjunction + * + * Term = Assertion + * | Atom + * | Atom Quantifier + * + * An empty Term sequence is a valid disjunction alternative (e.g. /|||c||/). + * + * Notes: + * + * * Tracking of the 'simple-ness' of the current atom vs. the entire + * disjunction are separate matters. For instance, the disjunction + * may be complex, but individual atoms may be simple. Furthermore, + * simple quantifiers are used whenever possible, even if the + * disjunction as a whole is complex. + * + * * The estimate of whether an atom is simple is conservative now, + * and it would be possible to expand it. For instance, captures + * cause the disjunction to be marked complex, even though captures + * -can- be handled by simple quantifiers with some minor modifications. + * + * * Disjunction 'tainting' as 'complex' is handled at the end of the + * main for loop collectively for atoms. Assertions, quantifiers, + * and '|' tokens need to taint the result manually if necessary. + * Assertions cannot add to result char length, only atoms (and + * quantifiers) can; currently quantifiers will taint the result + * as complex though. + */ + +DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t expect_eof, duk__re_disjunction_info *out_atom_info) { + duk_int32_t atom_start_offset = -1; /* negative -> no atom matched on previous round */ + duk_int32_t atom_char_length = 0; /* negative -> complex atom */ + duk_uint32_t atom_start_captures = re_ctx->captures; /* value of re_ctx->captures at start of atom */ + duk_int32_t unpatched_disjunction_split = -1; + duk_int32_t unpatched_disjunction_jump = -1; + duk_uint32_t entry_offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx); + duk_int32_t res_charlen = 0; /* -1 if disjunction is complex, char length if simple */ + duk__re_disjunction_info tmp_disj; + + DUK_ASSERT(out_atom_info != NULL); + + if (re_ctx->recursion_depth >= re_ctx->recursion_limit) { + DUK_ERROR(re_ctx->thr, DUK_ERR_RANGE_ERROR, + DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT); + } + re_ctx->recursion_depth++; + +#if 0 + out_atom_info->start_captures = re_ctx->captures; +#endif + + for (;;) { + /* atom_char_length, atom_start_offset, atom_start_offset reflect the + * atom matched on the previous loop. If a quantifier is encountered + * on this loop, these are needed to handle the quantifier correctly. + * new_atom_char_length etc are for the atom parsed on this round; + * they're written to atom_char_length etc at the end of the round. + */ + duk_int32_t new_atom_char_length; /* char length of the atom parsed in this loop */ + duk_int32_t new_atom_start_offset; /* bytecode start offset of the atom parsed in this loop + * (allows quantifiers to copy the atom bytecode) + */ + duk_uint32_t new_atom_start_captures; /* re_ctx->captures at the start of the atom parsed in this loop */ + + duk_lexer_parse_re_token(&re_ctx->lex, &re_ctx->curr_token); + + DUK_DD(DUK_DDPRINT("re token: %ld (num=%ld, char=%c)", + (long) re_ctx->curr_token.t, + (long) re_ctx->curr_token.num, + (re_ctx->curr_token.num >= 0x20 && re_ctx->curr_token.num <= 0x7e) ? + (int) re_ctx->curr_token.num : (int) '?')); + + /* set by atom case clauses */ + new_atom_start_offset = -1; + new_atom_char_length = -1; + new_atom_start_captures = re_ctx->captures; + + switch (re_ctx->curr_token.t) { + case DUK_RETOK_DISJUNCTION: { + /* + * The handling here is a bit tricky. If a previous '|' has been processed, + * we have a pending split1 and a pending jump (for a previous match). These + * need to be back-patched carefully. See docs for a detailed example. + */ + + /* patch pending jump and split */ + if (unpatched_disjunction_jump >= 0) { + duk_uint32_t offset; + + DUK_ASSERT(unpatched_disjunction_split >= 0); + offset = unpatched_disjunction_jump; + offset += duk__insert_jump_offset(re_ctx, + offset, + (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - offset)); + /* offset is now target of the pending split (right after jump) */ + duk__insert_jump_offset(re_ctx, + unpatched_disjunction_split, + offset - unpatched_disjunction_split); + } + + /* add a new pending split to the beginning of the entire disjunction */ + (void) duk__insert_u32(re_ctx, + entry_offset, + DUK_REOP_SPLIT1); /* prefer direct execution */ + unpatched_disjunction_split = entry_offset + 1; /* +1 for opcode */ + + /* add a new pending match jump for latest finished alternative */ + duk__append_u32(re_ctx, DUK_REOP_JUMP); + unpatched_disjunction_jump = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); + + /* 'taint' result as complex */ + res_charlen = -1; + break; + } + case DUK_RETOK_QUANTIFIER: { + if (atom_start_offset < 0) { + DUK_ERROR(re_ctx->thr, DUK_ERR_SYNTAX_ERROR, + DUK_STR_INVALID_QUANTIFIER_NO_ATOM); + } + if (re_ctx->curr_token.qmin > re_ctx->curr_token.qmax) { + DUK_ERROR(re_ctx->thr, DUK_ERR_SYNTAX_ERROR, + DUK_STR_INVALID_QUANTIFIER_VALUES); + } + if (atom_char_length >= 0) { + /* + * Simple atom + * + * If atom_char_length is zero, we'll have unbounded execution time for e.g. + * /()*x/.exec('x'). We can't just skip the match because it might have some + * side effects (for instance, if we allowed captures in simple atoms, the + * capture needs to happen). The simple solution below is to force the + * quantifier to match at most once, since the additional matches have no effect. + * + * With a simple atom there can be no capture groups, so no captures need + * to be reset. + */ + duk_int32_t atom_code_length; + duk_uint32_t offset; + duk_uint32_t qmin, qmax; + + qmin = re_ctx->curr_token.qmin; + qmax = re_ctx->curr_token.qmax; + if (atom_char_length == 0) { + /* qmin and qmax will be 0 or 1 */ + if (qmin > 1) { + qmin = 1; + } + if (qmax > 1) { + qmax = 1; + } + } + + duk__append_u32(re_ctx, DUK_REOP_MATCH); /* complete 'sub atom' */ + atom_code_length = (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - atom_start_offset); + + offset = atom_start_offset; + if (re_ctx->curr_token.greedy) { + offset += duk__insert_u32(re_ctx, offset, DUK_REOP_SQGREEDY); + offset += duk__insert_u32(re_ctx, offset, qmin); + offset += duk__insert_u32(re_ctx, offset, qmax); + offset += duk__insert_u32(re_ctx, offset, atom_char_length); + offset += duk__insert_jump_offset(re_ctx, offset, atom_code_length); + } else { + offset += duk__insert_u32(re_ctx, offset, DUK_REOP_SQMINIMAL); + offset += duk__insert_u32(re_ctx, offset, qmin); + offset += duk__insert_u32(re_ctx, offset, qmax); + offset += duk__insert_jump_offset(re_ctx, offset, atom_code_length); + } + DUK_UNREF(offset); /* silence scan-build warning */ + } else { + /* + * Complex atom + * + * The original code is used as a template, and removed at the end + * (this differs from the handling of simple quantifiers). + * + * NOTE: there is no current solution for empty atoms in complex + * quantifiers. This would need some sort of a 'progress' instruction. + * + * XXX: impose limit on maximum result size, i.e. atom_code_len * atom_copies? + */ + duk_int32_t atom_code_length; + duk_uint32_t atom_copies; + duk_uint32_t tmp_qmin, tmp_qmax; + + /* pre-check how many atom copies we're willing to make (atom_copies not needed below) */ + atom_copies = (re_ctx->curr_token.qmax == DUK_RE_QUANTIFIER_INFINITE) ? + re_ctx->curr_token.qmin : re_ctx->curr_token.qmax; + if (atom_copies > DUK_RE_MAX_ATOM_COPIES) { + DUK_ERROR(re_ctx->thr, DUK_ERR_RANGE_ERROR, + DUK_STR_QUANTIFIER_TOO_MANY_COPIES); + } + + /* wipe the capture range made by the atom (if any) */ + DUK_ASSERT(atom_start_captures <= re_ctx->captures); + if (atom_start_captures != re_ctx->captures) { + DUK_ASSERT(atom_start_captures < re_ctx->captures); + DUK_DDD(DUK_DDDPRINT("must wipe ]atom_start_captures,re_ctx->captures]: ]%ld,%ld]", + (long) atom_start_captures, (long) re_ctx->captures)); + + /* insert (DUK_REOP_WIPERANGE, start, count) in reverse order so the order ends up right */ + duk__insert_u32(re_ctx, atom_start_offset, (re_ctx->captures - atom_start_captures) * 2); + duk__insert_u32(re_ctx, atom_start_offset, (atom_start_captures + 1) * 2); + duk__insert_u32(re_ctx, atom_start_offset, DUK_REOP_WIPERANGE); + } else { + DUK_DDD(DUK_DDDPRINT("no need to wipe captures: atom_start_captures == re_ctx->captures == %ld", + (long) atom_start_captures)); + } + + atom_code_length = (duk_int32_t) DUK__RE_BUFLEN(re_ctx) - atom_start_offset; + + /* insert the required matches (qmin) by copying the atom */ + tmp_qmin = re_ctx->curr_token.qmin; + tmp_qmax = re_ctx->curr_token.qmax; + while (tmp_qmin > 0) { + duk__append_slice(re_ctx, atom_start_offset, atom_code_length); + tmp_qmin--; + if (tmp_qmax != DUK_RE_QUANTIFIER_INFINITE) { + tmp_qmax--; + } + } + DUK_ASSERT(tmp_qmin == 0); + + /* insert code for matching the remainder - infinite or finite */ + if (tmp_qmax == DUK_RE_QUANTIFIER_INFINITE) { + /* reuse last emitted atom for remaining 'infinite' quantifier */ + + if (re_ctx->curr_token.qmin == 0) { + /* Special case: original qmin was zero so there is nothing + * to repeat. Emit an atom copy but jump over it here. + */ + duk__append_u32(re_ctx, DUK_REOP_JUMP); + duk__append_jump_offset(re_ctx, atom_code_length); + duk__append_slice(re_ctx, atom_start_offset, atom_code_length); + } + if (re_ctx->curr_token.greedy) { + duk__append_u32(re_ctx, DUK_REOP_SPLIT2); /* prefer jump */ + } else { + duk__append_u32(re_ctx, DUK_REOP_SPLIT1); /* prefer direct */ + } + duk__append_jump_offset(re_ctx, -atom_code_length - 1); /* -1 for opcode */ + } else { + /* + * The remaining matches are emitted as sequence of SPLITs and atom + * copies; the SPLITs skip the remaining copies and match the sequel. + * This sequence needs to be emitted starting from the last copy + * because the SPLITs are variable length due to the variable length + * skip offset. This causes a lot of memory copying now. + * + * Example structure (greedy, match maximum # atoms): + * + * SPLIT1 LSEQ + * (atom) + * SPLIT1 LSEQ ; <- the byte length of this instruction is needed + * (atom) ; to encode the above SPLIT1 correctly + * ... + * LSEQ: + */ + duk_uint32_t offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx); + while (tmp_qmax > 0) { + duk__insert_slice(re_ctx, offset, atom_start_offset, atom_code_length); + if (re_ctx->curr_token.greedy) { + duk__insert_u32(re_ctx, offset, DUK_REOP_SPLIT1); /* prefer direct */ + } else { + duk__insert_u32(re_ctx, offset, DUK_REOP_SPLIT2); /* prefer jump */ + } + duk__insert_jump_offset(re_ctx, + offset + 1, /* +1 for opcode */ + (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - (offset + 1))); + tmp_qmax--; + } + } + + /* remove the original 'template' atom */ + duk__remove_slice(re_ctx, atom_start_offset, atom_code_length); + } + + /* 'taint' result as complex */ + res_charlen = -1; + break; + } + case DUK_RETOK_ASSERT_START: { + duk__append_u32(re_ctx, DUK_REOP_ASSERT_START); + break; + } + case DUK_RETOK_ASSERT_END: { + duk__append_u32(re_ctx, DUK_REOP_ASSERT_END); + break; + } + case DUK_RETOK_ASSERT_WORD_BOUNDARY: { + duk__append_u32(re_ctx, DUK_REOP_ASSERT_WORD_BOUNDARY); + break; + } + case DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY: { + duk__append_u32(re_ctx, DUK_REOP_ASSERT_NOT_WORD_BOUNDARY); + break; + } + case DUK_RETOK_ASSERT_START_POS_LOOKAHEAD: + case DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD: { + duk_uint32_t offset; + duk_uint32_t opcode = (re_ctx->curr_token.t == DUK_RETOK_ASSERT_START_POS_LOOKAHEAD) ? + DUK_REOP_LOOKPOS : DUK_REOP_LOOKNEG; + + offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx); + duk__parse_disjunction(re_ctx, 0, &tmp_disj); + duk__append_u32(re_ctx, DUK_REOP_MATCH); + + (void) duk__insert_u32(re_ctx, offset, opcode); + (void) duk__insert_jump_offset(re_ctx, + offset + 1, /* +1 for opcode */ + (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - (offset + 1))); + + /* 'taint' result as complex -- this is conservative, + * as lookaheads do not backtrack. + */ + res_charlen = -1; + break; + } + case DUK_RETOK_ATOM_PERIOD: { + new_atom_char_length = 1; + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); + duk__append_u32(re_ctx, DUK_REOP_PERIOD); + break; + } + case DUK_RETOK_ATOM_CHAR: { + /* Note: successive characters could be joined into string matches + * but this is not trivial (consider e.g. '/xyz+/); see docs for + * more discussion. + */ + duk_uint32_t ch; + + new_atom_char_length = 1; + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); + duk__append_u32(re_ctx, DUK_REOP_CHAR); + ch = re_ctx->curr_token.num; + if (re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE) { + ch = duk_unicode_re_canonicalize_char(re_ctx->thr, ch); + } + duk__append_u32(re_ctx, ch); + break; + } + case DUK_RETOK_ATOM_DIGIT: + case DUK_RETOK_ATOM_NOT_DIGIT: { + new_atom_char_length = 1; + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); + duk__append_u32(re_ctx, + (re_ctx->curr_token.t == DUK_RETOK_ATOM_DIGIT) ? + DUK_REOP_RANGES : DUK_REOP_INVRANGES); + duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_digit) / (2 * sizeof(duk_uint16_t))); + duk__append_u16_list(re_ctx, duk_unicode_re_ranges_digit, sizeof(duk_unicode_re_ranges_digit) / sizeof(duk_uint16_t)); + break; + } + case DUK_RETOK_ATOM_WHITE: + case DUK_RETOK_ATOM_NOT_WHITE: { + new_atom_char_length = 1; + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); + duk__append_u32(re_ctx, + (re_ctx->curr_token.t == DUK_RETOK_ATOM_WHITE) ? + DUK_REOP_RANGES : DUK_REOP_INVRANGES); + duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_white) / (2 * sizeof(duk_uint16_t))); + duk__append_u16_list(re_ctx, duk_unicode_re_ranges_white, sizeof(duk_unicode_re_ranges_white) / sizeof(duk_uint16_t)); + break; + } + case DUK_RETOK_ATOM_WORD_CHAR: + case DUK_RETOK_ATOM_NOT_WORD_CHAR: { + new_atom_char_length = 1; + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); + duk__append_u32(re_ctx, + (re_ctx->curr_token.t == DUK_RETOK_ATOM_WORD_CHAR) ? + DUK_REOP_RANGES : DUK_REOP_INVRANGES); + duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_wordchar) / (2 * sizeof(duk_uint16_t))); + duk__append_u16_list(re_ctx, duk_unicode_re_ranges_wordchar, sizeof(duk_unicode_re_ranges_wordchar) / sizeof(duk_uint16_t)); + break; + } + case DUK_RETOK_ATOM_BACKREFERENCE: { + duk_uint32_t backref = (duk_uint32_t) re_ctx->curr_token.num; + if (backref > re_ctx->highest_backref) { + re_ctx->highest_backref = backref; + } + new_atom_char_length = -1; /* mark as complex */ + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); + duk__append_u32(re_ctx, DUK_REOP_BACKREFERENCE); + duk__append_u32(re_ctx, backref); + break; + } + case DUK_RETOK_ATOM_START_CAPTURE_GROUP: { + duk_uint32_t cap; + + new_atom_char_length = -1; /* mark as complex (capture handling) */ + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); + cap = ++re_ctx->captures; + duk__append_u32(re_ctx, DUK_REOP_SAVE); + duk__append_u32(re_ctx, cap * 2); + duk__parse_disjunction(re_ctx, 0, &tmp_disj); /* retval (sub-atom char length) unused, tainted as complex above */ + duk__append_u32(re_ctx, DUK_REOP_SAVE); + duk__append_u32(re_ctx, cap * 2 + 1); + break; + } + case DUK_RETOK_ATOM_START_NONCAPTURE_GROUP: { + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); + duk__parse_disjunction(re_ctx, 0, &tmp_disj); + new_atom_char_length = tmp_disj.charlen; + break; + } + case DUK_RETOK_ATOM_START_CHARCLASS: + case DUK_RETOK_ATOM_START_CHARCLASS_INVERTED: { + /* + * Range parsing is done with a special lexer function which calls + * us for every range parsed. This is different from how rest of + * the parsing works, but avoids a heavy, arbitrary size intermediate + * value type to hold the ranges. + * + * Another complication is the handling of character ranges when + * case insensitive matching is used (see docs for discussion). + * The range handler callback given to the lexer takes care of this + * as well. + * + * Note that duplicate ranges are not eliminated when parsing character + * classes, so that canonicalization of + * + * [0-9a-fA-Fx-{] + * + * creates the result (note the duplicate ranges): + * + * [0-9A-FA-FX-Z{-{] + * + * where [x-{] is split as a result of canonicalization. The duplicate + * ranges are not a semantics issue: they work correctly. + */ + + duk_uint32_t offset; + + DUK_DD(DUK_DDPRINT("character class")); + + /* insert ranges instruction, range count patched in later */ + new_atom_char_length = 1; + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); + duk__append_u32(re_ctx, + (re_ctx->curr_token.t == DUK_RETOK_ATOM_START_CHARCLASS) ? + DUK_REOP_RANGES : DUK_REOP_INVRANGES); + offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx); /* patch in range count later */ + + /* parse ranges until character class ends */ + re_ctx->nranges = 0; /* note: ctx-wide temporary */ + duk_lexer_parse_re_ranges(&re_ctx->lex, duk__generate_ranges, (void *) re_ctx); + + /* insert range count */ + duk__insert_u32(re_ctx, offset, re_ctx->nranges); + break; + } + case DUK_RETOK_ATOM_END_GROUP: { + if (expect_eof) { + DUK_ERROR(re_ctx->thr, DUK_ERR_SYNTAX_ERROR, + DUK_STR_UNEXPECTED_CLOSING_PAREN); + } + goto done; + } + case DUK_RETOK_EOF: { + if (!expect_eof) { + DUK_ERROR(re_ctx->thr, DUK_ERR_SYNTAX_ERROR, + DUK_STR_UNEXPECTED_END_OF_PATTERN); + } + goto done; + } + default: { + DUK_ERROR(re_ctx->thr, DUK_ERR_SYNTAX_ERROR, + DUK_STR_UNEXPECTED_REGEXP_TOKEN); + } + } + + /* a complex (new) atom taints the result */ + if (new_atom_start_offset >= 0) { + if (new_atom_char_length < 0) { + res_charlen = -1; + } else if (res_charlen >= 0) { + /* only advance if not tainted */ + res_charlen += new_atom_char_length; + } + } + + /* record previous atom info in case next token is a quantifier */ + atom_start_offset = new_atom_start_offset; + atom_char_length = new_atom_char_length; + atom_start_captures = new_atom_start_captures; + } + + done: + + /* finish up pending jump and split for last alternative */ + if (unpatched_disjunction_jump >= 0) { + duk_uint32_t offset; + + DUK_ASSERT(unpatched_disjunction_split >= 0); + offset = unpatched_disjunction_jump; + offset += duk__insert_jump_offset(re_ctx, + offset, + (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - offset)); + /* offset is now target of the pending split (right after jump) */ + duk__insert_jump_offset(re_ctx, + unpatched_disjunction_split, + offset - unpatched_disjunction_split); + } + +#if 0 + out_atom_info->end_captures = re_ctx->captures; +#endif + out_atom_info->charlen = res_charlen; + DUK_DDD(DUK_DDDPRINT("parse disjunction finished: charlen=%ld", + (long) out_atom_info->charlen)); + + re_ctx->recursion_depth--; +} + +/* + * Flags parsing (see E5 Section 15.10.4.1). + */ + +DUK_LOCAL duk_uint32_t duk__parse_regexp_flags(duk_hthread *thr, duk_hstring *h) { + const duk_uint8_t *p; + const duk_uint8_t *p_end; + duk_uint32_t flags = 0; + + p = DUK_HSTRING_GET_DATA(h); + p_end = p + DUK_HSTRING_GET_BYTELEN(h); + + /* Note: can be safely scanned as bytes (undecoded) */ + + while (p < p_end) { + duk_uint8_t c = *p++; + switch ((int) c) { + case (int) 'g': { + if (flags & DUK_RE_FLAG_GLOBAL) { + goto error; + } + flags |= DUK_RE_FLAG_GLOBAL; + break; + } + case (int) 'i': { + if (flags & DUK_RE_FLAG_IGNORE_CASE) { + goto error; + } + flags |= DUK_RE_FLAG_IGNORE_CASE; + break; + } + case (int) 'm': { + if (flags & DUK_RE_FLAG_MULTILINE) { + goto error; + } + flags |= DUK_RE_FLAG_MULTILINE; + break; + } + default: { + goto error; + } + } + } + + return flags; + + error: + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_REGEXP_FLAGS); + return 0; /* never here */ +} + +/* + * Create escaped RegExp source (E5 Section 15.10.3). + * + * The current approach is to special case the empty RegExp + * ('' -> '(?:)') and otherwise replace unescaped '/' characters + * with '\/' regardless of where they occur in the regexp. + * + * Note that normalization does not seem to be necessary for + * RegExp literals (e.g. '/foo/') because to be acceptable as + * a RegExp literal, the text between forward slashes must + * already match the escaping requirements (e.g. must not contain + * unescaped forward slashes or be empty). Escaping IS needed + * for expressions like 'new Regexp("...", "")' however. + * Currently, we re-escape in either case. + * + * Also note that we process the source here in UTF-8 encoded + * form. This is correct, because any non-ASCII characters are + * passed through without change. + */ + +DUK_LOCAL void duk__create_escaped_source(duk_hthread *thr, int idx_pattern) { + duk_context *ctx = (duk_context *) thr; + duk_hstring *h; + const duk_uint8_t *p; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; + duk_uint8_t *q; + duk_size_t i, n; + duk_uint_fast8_t c_prev, c; + + h = duk_get_hstring(ctx, idx_pattern); + DUK_ASSERT(h != NULL); + p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h); + n = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h); + + if (n == 0) { + /* return '(?:)' */ + duk_push_hstring_stridx(ctx, DUK_STRIDX_ESCAPED_EMPTY_REGEXP); + return; + } + + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(thr, bw, n); + q = DUK_BW_GET_PTR(thr, bw); + + c_prev = (duk_uint_fast8_t) 0; + + for (i = 0; i < n; i++) { + c = p[i]; + + q = DUK_BW_ENSURE_RAW(thr, bw, 2, q); + + if (c == (duk_uint_fast8_t) '/' && c_prev != (duk_uint_fast8_t) '\\') { + /* Unescaped '/' ANYWHERE in the regexp (in disjunction, + * inside a character class, ...) => same escape works. + */ + *q++ = DUK_ASC_BACKSLASH; + } + *q++ = (duk_uint8_t) c; + + c_prev = c; + } + + DUK_BW_SETPTR_AND_COMPACT(thr, bw, q); + duk_to_string(ctx, -1); /* -> [ ... escaped_source ] */ +} + +/* + * Exposed regexp compilation primitive. + * + * Sets up a regexp compilation context, and calls duk__parse_disjunction() to do the + * actual parsing. Handles generation of the compiled regexp header and the + * "boilerplate" capture of the matching substring (save 0 and 1). Also does some + * global level regexp checks after recursive compilation has finished. + * + * An escaped version of the regexp source, suitable for use as a RegExp instance + * 'source' property (see E5 Section 15.10.3), is also left on the stack. + * + * Input stack: [ pattern flags ] + * Output stack: [ bytecode escaped_source ] (both as strings) + */ + +DUK_INTERNAL void duk_regexp_compile(duk_hthread *thr) { + duk_context *ctx = (duk_context *) thr; + duk_re_compiler_ctx re_ctx; + duk_lexer_point lex_point; + duk_hstring *h_pattern; + duk_hstring *h_flags; + duk__re_disjunction_info ign_disj; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + + /* + * Args validation + */ + + /* TypeError if fails */ + h_pattern = duk_require_hstring(ctx, -2); + h_flags = duk_require_hstring(ctx, -1); + + /* + * Create normalized 'source' property (E5 Section 15.10.3). + */ + + /* [ ... pattern flags ] */ + + duk__create_escaped_source(thr, -2); + + /* [ ... pattern flags escaped_source ] */ + + /* + * Init compilation context + */ + + /* [ ... pattern flags escaped_source buffer ] */ + + DUK_MEMZERO(&re_ctx, sizeof(re_ctx)); + DUK_LEXER_INITCTX(&re_ctx.lex); /* duplicate zeroing, expect for (possible) NULL inits */ + re_ctx.thr = thr; + re_ctx.lex.thr = thr; + re_ctx.lex.input = DUK_HSTRING_GET_DATA(h_pattern); + re_ctx.lex.input_length = DUK_HSTRING_GET_BYTELEN(h_pattern); + re_ctx.lex.token_limit = DUK_RE_COMPILE_TOKEN_LIMIT; + re_ctx.recursion_limit = DUK_USE_REGEXP_COMPILER_RECLIMIT; + re_ctx.re_flags = duk__parse_regexp_flags(thr, h_flags); + + DUK_BW_INIT_PUSHBUF(thr, &re_ctx.bw, DUK__RE_INITIAL_BUFSIZE); + + DUK_DD(DUK_DDPRINT("regexp compiler ctx initialized, flags=0x%08lx, recursion_limit=%ld", + (unsigned long) re_ctx.re_flags, (long) re_ctx.recursion_limit)); + + /* + * Init lexer + */ + + lex_point.offset = 0; /* expensive init, just want to fill window */ + lex_point.line = 1; + DUK_LEXER_SETPOINT(&re_ctx.lex, &lex_point); + + /* + * Compilation + */ + + DUK_D(DUK_DPRINT("starting regexp compilation")); + + duk__append_u32(&re_ctx, DUK_REOP_SAVE); + duk__append_u32(&re_ctx, 0); + duk__parse_disjunction(&re_ctx, 1 /*expect_eof*/, &ign_disj); + duk__append_u32(&re_ctx, DUK_REOP_SAVE); + duk__append_u32(&re_ctx, 1); + duk__append_u32(&re_ctx, DUK_REOP_MATCH); + + /* + * Check for invalid backreferences; note that it is NOT an error + * to back-reference a capture group which has not yet been introduced + * in the pattern (as in /\1(foo)/); in fact, the backreference will + * always match! It IS an error to back-reference a capture group + * which will never be introduced in the pattern. Thus, we can check + * for such references only after parsing is complete. + */ + + if (re_ctx.highest_backref > re_ctx.captures) { + DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_BACKREFS); + } + + /* + * Emit compiled regexp header: flags, ncaptures + * (insertion order inverted on purpose) + */ + + duk__insert_u32(&re_ctx, 0, (re_ctx.captures + 1) * 2); + duk__insert_u32(&re_ctx, 0, re_ctx.re_flags); + + /* [ ... pattern flags escaped_source buffer ] */ + + DUK_BW_COMPACT(thr, &re_ctx.bw); + duk_to_string(ctx, -1); /* coerce to string */ + + /* [ ... pattern flags escaped_source bytecode ] */ + + /* + * Finalize stack + */ + + duk_remove(ctx, -4); /* -> [ ... flags escaped_source bytecode ] */ + duk_remove(ctx, -3); /* -> [ ... escaped_source bytecode ] */ + + DUK_D(DUK_DPRINT("regexp compilation successful, bytecode: %!T, escaped source: %!T", + (duk_tval *) duk_get_tval(ctx, -1), (duk_tval *) duk_get_tval(ctx, -2))); +} + +/* + * Create a RegExp instance (E5 Section 15.10.7). + * + * Note: the output stack left by duk_regexp_compile() is directly compatible + * with the input here. + * + * Input stack: [ escaped_source bytecode ] (both as strings) + * Output stack: [ RegExp ] + */ + +DUK_INTERNAL void duk_regexp_create_instance(duk_hthread *thr) { + duk_context *ctx = (duk_context *) thr; + duk_hobject *h; + duk_hstring *h_bc; + duk_small_int_t re_flags; + + /* [ ... escape_source bytecode ] */ + + h_bc = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_bc != NULL); + DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(h_bc) >= 1); /* always at least the header */ + DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h_bc) >= 1); + DUK_ASSERT((duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0] < 0x80); /* flags always encodes to 1 byte */ + re_flags = (duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0]; + + /* [ ... escaped_source bytecode ] */ + + duk_push_object(ctx); + h = duk_get_hobject(ctx, -1); + DUK_ASSERT(h != NULL); + duk_insert(ctx, -3); + + /* [ ... regexp_object escaped_source bytecode ] */ + + DUK_HOBJECT_SET_CLASS_NUMBER(h, DUK_HOBJECT_CLASS_REGEXP); + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[DUK_BIDX_REGEXP_PROTOTYPE]); + + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_BYTECODE, DUK_PROPDESC_FLAGS_NONE); + + /* [ ... regexp_object escaped_source ] */ + + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_SOURCE, DUK_PROPDESC_FLAGS_NONE); + + /* [ ... regexp_object ] */ + + duk_push_boolean(ctx, (re_flags & DUK_RE_FLAG_GLOBAL)); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_GLOBAL, DUK_PROPDESC_FLAGS_NONE); + + duk_push_boolean(ctx, (re_flags & DUK_RE_FLAG_IGNORE_CASE)); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_IGNORE_CASE, DUK_PROPDESC_FLAGS_NONE); + + duk_push_boolean(ctx, (re_flags & DUK_RE_FLAG_MULTILINE)); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MULTILINE, DUK_PROPDESC_FLAGS_NONE); + + duk_push_int(ctx, 0); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LAST_INDEX, DUK_PROPDESC_FLAGS_W); + + /* [ ... regexp_object ] */ +} + +#undef DUK__RE_BUFLEN + +#else /* DUK_USE_REGEXP_SUPPORT */ + +/* regexp support disabled */ + +#endif /* DUK_USE_REGEXP_SUPPORT */ +#line 1 "duk_regexp_executor.c" +/* + * Regexp executor. + * + * Safety: the Ecmascript executor should prevent user from reading and + * replacing regexp bytecode. Even so, the executor must validate all + * memory accesses etc. When an invalid access is detected (e.g. a 'save' + * opcode to invalid, unallocated index) it should fail with an internal + * error but not cause a segmentation fault. + * + * Notes: + * + * - Backtrack counts are limited to unsigned 32 bits but should + * technically be duk_size_t for strings longer than 4G chars. + * This also requires a regexp bytecode change. + */ + +/* include removed: duk_internal.h */ + +#ifdef DUK_USE_REGEXP_SUPPORT + +/* + * Helpers for UTF-8 handling + * + * For bytecode readers the duk_uint32_t and duk_int32_t types are correct + * because they're used for more than just codepoints. + */ + +DUK_LOCAL duk_uint32_t duk__bc_get_u32(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **pc) { + return (duk_uint32_t) duk_unicode_decode_xutf8_checked(re_ctx->thr, pc, re_ctx->bytecode, re_ctx->bytecode_end); +} + +DUK_LOCAL duk_int32_t duk__bc_get_i32(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **pc) { + duk_uint32_t t; + + /* signed integer encoding needed to work with UTF-8 */ + t = (duk_uint32_t) duk_unicode_decode_xutf8_checked(re_ctx->thr, pc, re_ctx->bytecode, re_ctx->bytecode_end); + if (t & 1) { + return -((duk_int32_t) (t >> 1)); + } else { + return (duk_int32_t) (t >> 1); + } +} + +DUK_LOCAL const duk_uint8_t *duk__utf8_backtrack(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_uint_fast32_t count) { + const duk_uint8_t *p; + + /* Note: allow backtracking from p == ptr_end */ + p = *ptr; + if (p < ptr_start || p > ptr_end) { + goto fail; + } + + while (count > 0) { + for (;;) { + p--; + if (p < ptr_start) { + goto fail; + } + if ((*p & 0xc0) != 0x80) { + /* utf-8 continuation bytes have the form 10xx xxxx */ + break; + } + } + count--; + } + *ptr = p; + return p; + + fail: + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_REGEXP_BACKTRACK_FAILED); + return NULL; /* never here */ +} + +DUK_LOCAL const duk_uint8_t *duk__utf8_advance(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_uint_fast32_t count) { + const duk_uint8_t *p; + + p = *ptr; + if (p < ptr_start || p >= ptr_end) { + goto fail; + } + + while (count > 0) { + for (;;) { + p++; + + /* Note: if encoding ends by hitting end of input, we don't check that + * the encoding is valid, we just assume it is. + */ + if (p >= ptr_end || ((*p & 0xc0) != 0x80)) { + /* utf-8 continuation bytes have the form 10xx xxxx */ + break; + } + } + count--; + } + + *ptr = p; + return p; + + fail: + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_REGEXP_ADVANCE_FAILED); + return NULL; /* never here */ +} + +/* + * Helpers for dealing with the input string + */ + +/* Get a (possibly canonicalized) input character from current sp. The input + * itself is never modified, and captures always record non-canonicalized + * characters even in case-insensitive matching. + */ +DUK_LOCAL duk_codepoint_t duk__inp_get_cp(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **sp) { + duk_codepoint_t res = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(re_ctx->thr, sp, re_ctx->input, re_ctx->input_end); + if (re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE) { + res = duk_unicode_re_canonicalize_char(re_ctx->thr, res); + } + return res; +} + +DUK_LOCAL const duk_uint8_t *duk__inp_backtrack(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **sp, duk_uint_fast32_t count) { + return duk__utf8_backtrack(re_ctx->thr, sp, re_ctx->input, re_ctx->input_end, count); +} + +/* Backtrack utf-8 input and return a (possibly canonicalized) input character. */ +DUK_LOCAL duk_codepoint_t duk__inp_get_prev_cp(duk_re_matcher_ctx *re_ctx, const duk_uint8_t *sp) { + /* note: caller 'sp' is intentionally not updated here */ + (void) duk__inp_backtrack(re_ctx, &sp, (duk_uint_fast32_t) 1); + return duk__inp_get_cp(re_ctx, &sp); +} + +/* + * Regexp recursive matching function. + * + * Returns 'sp' on successful match (points to character after last matched one), + * NULL otherwise. + * + * The C recursion depth limit check is only performed in this function, this + * suffices because the function is present in all true recursion required by + * regexp execution. + */ + +DUK_LOCAL const duk_uint8_t *duk__match_regexp(duk_re_matcher_ctx *re_ctx, const duk_uint8_t *pc, const duk_uint8_t *sp) { + if (re_ctx->recursion_depth >= re_ctx->recursion_limit) { + DUK_ERROR(re_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT); + } + re_ctx->recursion_depth++; + + for (;;) { + duk_small_int_t op; + + if (re_ctx->steps_count >= re_ctx->steps_limit) { + DUK_ERROR(re_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT); + } + re_ctx->steps_count++; + + op = (duk_small_int_t) duk__bc_get_u32(re_ctx, &pc); + + DUK_DDD(DUK_DDDPRINT("match: rec=%ld, steps=%ld, pc (after op)=%ld, sp=%ld, op=%ld", + (long) re_ctx->recursion_depth, + (long) re_ctx->steps_count, + (long) (pc - re_ctx->bytecode), + (long) (sp - re_ctx->input), + (long) op)); + + switch (op) { + case DUK_REOP_MATCH: { + goto match; + } + case DUK_REOP_CHAR: { + /* + * Byte-based matching would be possible for case-sensitive + * matching but not for case-insensitive matching. So, we + * match by decoding the input and bytecode character normally. + * + * Bytecode characters are assumed to be already canonicalized. + * Input characters are canonicalized automatically by + * duk__inp_get_cp() if necessary. + * + * There is no opcode for matching multiple characters. The + * regexp compiler has trouble joining strings efficiently + * during compilation. See doc/regexp.rst for more discussion. + */ + duk_codepoint_t c1, c2; + + c1 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc); + DUK_ASSERT(!(re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE) || + c1 == duk_unicode_re_canonicalize_char(re_ctx->thr, c1)); /* canonicalized by compiler */ + if (sp >= re_ctx->input_end) { + goto fail; + } + c2 = duk__inp_get_cp(re_ctx, &sp); + DUK_DDD(DUK_DDDPRINT("char match, c1=%ld, c2=%ld", (long) c1, (long) c2)); + if (c1 != c2) { + goto fail; + } + break; + } + case DUK_REOP_PERIOD: { + duk_codepoint_t c; + + if (sp >= re_ctx->input_end) { + goto fail; + } + c = duk__inp_get_cp(re_ctx, &sp); + if (duk_unicode_is_line_terminator(c)) { + /* E5 Sections 15.10.2.8, 7.3 */ + goto fail; + } + break; + } + case DUK_REOP_RANGES: + case DUK_REOP_INVRANGES: { + duk_uint32_t n; + duk_codepoint_t c; + duk_small_int_t match; + + n = duk__bc_get_u32(re_ctx, &pc); + if (sp >= re_ctx->input_end) { + goto fail; + } + c = duk__inp_get_cp(re_ctx, &sp); + + match = 0; + while (n) { + duk_codepoint_t r1, r2; + r1 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc); + r2 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc); + DUK_DDD(DUK_DDDPRINT("matching ranges/invranges, n=%ld, r1=%ld, r2=%ld, c=%ld", + (long) n, (long) r1, (long) r2, (long) c)); + if (c >= r1 && c <= r2) { + /* Note: don't bail out early, we must read all the ranges from + * bytecode. Another option is to skip them efficiently after + * breaking out of here. Prefer smallest code. + */ + match = 1; + } + n--; + } + + if (op == DUK_REOP_RANGES) { + if (!match) { + goto fail; + } + } else { + DUK_ASSERT(op == DUK_REOP_INVRANGES); + if (match) { + goto fail; + } + } + break; + } + case DUK_REOP_ASSERT_START: { + duk_codepoint_t c; + + if (sp <= re_ctx->input) { + break; + } + if (!(re_ctx->re_flags & DUK_RE_FLAG_MULTILINE)) { + goto fail; + } + c = duk__inp_get_prev_cp(re_ctx, sp); + if (duk_unicode_is_line_terminator(c)) { + /* E5 Sections 15.10.2.8, 7.3 */ + break; + } + goto fail; + } + case DUK_REOP_ASSERT_END: { + duk_codepoint_t c; + const duk_uint8_t *tmp_sp; + + if (sp >= re_ctx->input_end) { + break; + } + if (!(re_ctx->re_flags & DUK_RE_FLAG_MULTILINE)) { + goto fail; + } + tmp_sp = sp; + c = duk__inp_get_cp(re_ctx, &tmp_sp); + if (duk_unicode_is_line_terminator(c)) { + /* E5 Sections 15.10.2.8, 7.3 */ + break; + } + goto fail; + } + case DUK_REOP_ASSERT_WORD_BOUNDARY: + case DUK_REOP_ASSERT_NOT_WORD_BOUNDARY: { + /* + * E5 Section 15.10.2.6. The previous and current character + * should -not- be canonicalized as they are now. However, + * canonicalization does not affect the result of IsWordChar() + * (which depends on Unicode characters never canonicalizing + * into ASCII characters) so this does not matter. + */ + duk_small_int_t w1, w2; + + if (sp <= re_ctx->input) { + w1 = 0; /* not a wordchar */ + } else { + duk_codepoint_t c; + c = duk__inp_get_prev_cp(re_ctx, sp); + w1 = duk_unicode_re_is_wordchar(c); + } + if (sp >= re_ctx->input_end) { + w2 = 0; /* not a wordchar */ + } else { + const duk_uint8_t *tmp_sp = sp; /* dummy so sp won't get updated */ + duk_codepoint_t c; + c = duk__inp_get_cp(re_ctx, &tmp_sp); + w2 = duk_unicode_re_is_wordchar(c); + } + + if (op == DUK_REOP_ASSERT_WORD_BOUNDARY) { + if (w1 == w2) { + goto fail; + } + } else { + DUK_ASSERT(op == DUK_REOP_ASSERT_NOT_WORD_BOUNDARY); + if (w1 != w2) { + goto fail; + } + } + break; + } + case DUK_REOP_JUMP: { + duk_int32_t skip; + + skip = duk__bc_get_i32(re_ctx, &pc); + pc += skip; + break; + } + case DUK_REOP_SPLIT1: { + /* split1: prefer direct execution (no jump) */ + const duk_uint8_t *sub_sp; + duk_int32_t skip; + + skip = duk__bc_get_i32(re_ctx, &pc); + sub_sp = duk__match_regexp(re_ctx, pc, sp); + if (sub_sp) { + sp = sub_sp; + goto match; + } + pc += skip; + break; + } + case DUK_REOP_SPLIT2: { + /* split2: prefer jump execution (not direct) */ + const duk_uint8_t *sub_sp; + duk_int32_t skip; + + skip = duk__bc_get_i32(re_ctx, &pc); + sub_sp = duk__match_regexp(re_ctx, pc + skip, sp); + if (sub_sp) { + sp = sub_sp; + goto match; + } + break; + } + case DUK_REOP_SQMINIMAL: { + duk_uint32_t q, qmin, qmax; + duk_int32_t skip; + const duk_uint8_t *sub_sp; + + qmin = duk__bc_get_u32(re_ctx, &pc); + qmax = duk__bc_get_u32(re_ctx, &pc); + skip = duk__bc_get_i32(re_ctx, &pc); + DUK_DDD(DUK_DDDPRINT("minimal quantifier, qmin=%lu, qmax=%lu, skip=%ld", + (unsigned long) qmin, (unsigned long) qmax, (long) skip)); + + q = 0; + while (q <= qmax) { + if (q >= qmin) { + sub_sp = duk__match_regexp(re_ctx, pc + skip, sp); + if (sub_sp) { + sp = sub_sp; + goto match; + } + } + sub_sp = duk__match_regexp(re_ctx, pc, sp); + if (!sub_sp) { + break; + } + sp = sub_sp; + q++; + } + goto fail; + } + case DUK_REOP_SQGREEDY: { + duk_uint32_t q, qmin, qmax, atomlen; + duk_int32_t skip; + const duk_uint8_t *sub_sp; + + qmin = duk__bc_get_u32(re_ctx, &pc); + qmax = duk__bc_get_u32(re_ctx, &pc); + atomlen = duk__bc_get_u32(re_ctx, &pc); + skip = duk__bc_get_i32(re_ctx, &pc); + DUK_DDD(DUK_DDDPRINT("greedy quantifier, qmin=%lu, qmax=%lu, atomlen=%lu, skip=%ld", + (unsigned long) qmin, (unsigned long) qmax, (unsigned long) atomlen, (long) skip)); + + q = 0; + while (q < qmax) { + sub_sp = duk__match_regexp(re_ctx, pc, sp); + if (!sub_sp) { + break; + } + sp = sub_sp; + q++; + } + while (q >= qmin) { + sub_sp = duk__match_regexp(re_ctx, pc + skip, sp); + if (sub_sp) { + sp = sub_sp; + goto match; + } + if (q == qmin) { + break; + } + + /* Note: if atom were to contain e.g. captures, we would need to + * re-match the atom to get correct captures. Simply quantifiers + * do not allow captures in their atom now, so this is not an issue. + */ + + DUK_DDD(DUK_DDDPRINT("greedy quantifier, backtrack %ld characters (atomlen)", + (long) atomlen)); + sp = duk__inp_backtrack(re_ctx, &sp, (duk_uint_fast32_t) atomlen); + q--; + } + goto fail; + } + case DUK_REOP_SAVE: { + duk_uint32_t idx; + const duk_uint8_t *old; + const duk_uint8_t *sub_sp; + + idx = duk__bc_get_u32(re_ctx, &pc); + if (idx >= re_ctx->nsaved) { + /* idx is unsigned, < 0 check is not necessary */ + DUK_D(DUK_DPRINT("internal error, regexp save index insane: idx=%ld", (long) idx)); + goto internal_error; + } + old = re_ctx->saved[idx]; + re_ctx->saved[idx] = sp; + sub_sp = duk__match_regexp(re_ctx, pc, sp); + if (sub_sp) { + sp = sub_sp; + goto match; + } + re_ctx->saved[idx] = old; + goto fail; + } + case DUK_REOP_WIPERANGE: { + /* Wipe capture range and save old values for backtracking. + * + * XXX: this typically happens with a relatively small idx_count. + * It might be useful to handle cases where the count is small + * (say <= 8) by saving the values in stack instead. This would + * reduce memory churn and improve performance, at the cost of a + * slightly higher code footprint. + */ + duk_uint32_t idx_start, idx_count; +#ifdef DUK_USE_EXPLICIT_NULL_INIT + duk_uint32_t idx_end, idx; +#endif + duk_uint8_t **range_save; + const duk_uint8_t *sub_sp; + + idx_start = duk__bc_get_u32(re_ctx, &pc); + idx_count = duk__bc_get_u32(re_ctx, &pc); + DUK_DDD(DUK_DDDPRINT("wipe saved range: start=%ld, count=%ld -> [%ld,%ld] (captures [%ld,%ld])", + (long) idx_start, (long) idx_count, + (long) idx_start, (long) (idx_start + idx_count - 1), + (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2))); + if (idx_start + idx_count > re_ctx->nsaved || idx_count == 0) { + /* idx is unsigned, < 0 check is not necessary */ + DUK_D(DUK_DPRINT("internal error, regexp wipe indices insane: idx_start=%ld, idx_count=%ld", + (long) idx_start, (long) idx_count)); + goto internal_error; + } + DUK_ASSERT(idx_count > 0); + + duk_require_stack((duk_context *) re_ctx->thr, 1); + range_save = (duk_uint8_t **) duk_push_fixed_buffer((duk_context *) re_ctx->thr, + sizeof(duk_uint8_t *) * idx_count); + DUK_ASSERT(range_save != NULL); + DUK_MEMCPY(range_save, re_ctx->saved + idx_start, sizeof(duk_uint8_t *) * idx_count); +#ifdef DUK_USE_EXPLICIT_NULL_INIT + idx_end = idx_start + idx_count; + for (idx = idx_start; idx < idx_end; idx++) { + re_ctx->saved[idx] = NULL; + } +#else + DUK_MEMZERO((void *) (re_ctx->saved + idx_start), sizeof(duk_uint8_t *) * idx_count); +#endif + + sub_sp = duk__match_regexp(re_ctx, pc, sp); + if (sub_sp) { + /* match: keep wiped/resaved values */ + DUK_DDD(DUK_DDDPRINT("match: keep wiped/resaved values [%ld,%ld] (captures [%ld,%ld])", + (long) idx_start, (long) (idx_start + idx_count - 1), + (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2))); + duk_pop((duk_context *) re_ctx->thr); + sp = sub_sp; + goto match; + } + + /* fail: restore saves */ + DUK_DDD(DUK_DDDPRINT("fail: restore wiped/resaved values [%ld,%ld] (captures [%ld,%ld])", + (long) idx_start, (long) (idx_start + idx_count - 1), + (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2))); + DUK_MEMCPY((void *) (re_ctx->saved + idx_start), + (const void *) range_save, + sizeof(duk_uint8_t *) * idx_count); + duk_pop((duk_context *) re_ctx->thr); + goto fail; + } + case DUK_REOP_LOOKPOS: + case DUK_REOP_LOOKNEG: { + /* + * Needs a save of multiple saved[] entries depending on what range + * may be overwritten. Because the regexp parser does no such analysis, + * we currently save the entire saved array here. Lookaheads are thus + * a bit expensive. Note that the saved array is not needed for just + * the lookahead sub-match, but for the matching of the entire sequel. + * + * The temporary save buffer is pushed on to the valstack to handle + * errors correctly. Each lookahead causes a C recursion and pushes + * more stuff on the value stack. If the C recursion limit is less + * than the value stack spare, there is no need to check the stack. + * We do so regardless, just in case. + */ + + duk_int32_t skip; + duk_uint8_t **full_save; + const duk_uint8_t *sub_sp; + + DUK_ASSERT(re_ctx->nsaved > 0); + + duk_require_stack((duk_context *) re_ctx->thr, 1); + full_save = (duk_uint8_t **) duk_push_fixed_buffer((duk_context *) re_ctx->thr, + sizeof(duk_uint8_t *) * re_ctx->nsaved); + DUK_ASSERT(full_save != NULL); + DUK_MEMCPY(full_save, re_ctx->saved, sizeof(duk_uint8_t *) * re_ctx->nsaved); + + skip = duk__bc_get_i32(re_ctx, &pc); + sub_sp = duk__match_regexp(re_ctx, pc, sp); + if (op == DUK_REOP_LOOKPOS) { + if (!sub_sp) { + goto lookahead_fail; + } + } else { + if (sub_sp) { + goto lookahead_fail; + } + } + sub_sp = duk__match_regexp(re_ctx, pc + skip, sp); + if (sub_sp) { + /* match: keep saves */ + duk_pop((duk_context *) re_ctx->thr); + sp = sub_sp; + goto match; + } + + /* fall through */ + + lookahead_fail: + /* fail: restore saves */ + DUK_MEMCPY((void *) re_ctx->saved, + (const void *) full_save, + sizeof(duk_uint8_t *) * re_ctx->nsaved); + duk_pop((duk_context *) re_ctx->thr); + goto fail; + } + case DUK_REOP_BACKREFERENCE: { + /* + * Byte matching for back-references would be OK in case- + * sensitive matching. In case-insensitive matching we need + * to canonicalize characters, so back-reference matching needs + * to be done with codepoints instead. So, we just decode + * everything normally here, too. + * + * Note: back-reference index which is 0 or higher than + * NCapturingParens (= number of capturing parens in the + * -entire- regexp) is a compile time error. However, a + * backreference referring to a valid capture which has + * not matched anything always succeeds! See E5 Section + * 15.10.2.9, step 5, sub-step 3. + */ + duk_uint32_t idx; + const duk_uint8_t *p; + + idx = duk__bc_get_u32(re_ctx, &pc); + idx = idx << 1; /* backref n -> saved indices [n*2, n*2+1] */ + if (idx < 2 || idx + 1 >= re_ctx->nsaved) { + /* regexp compiler should catch these */ + DUK_D(DUK_DPRINT("internal error, backreference index insane")); + goto internal_error; + } + if (!re_ctx->saved[idx] || !re_ctx->saved[idx+1]) { + /* capture is 'undefined', always matches! */ + DUK_DDD(DUK_DDDPRINT("backreference: saved[%ld,%ld] not complete, always match", + (long) idx, (long) (idx + 1))); + break; + } + DUK_DDD(DUK_DDDPRINT("backreference: match saved[%ld,%ld]", (long) idx, (long) (idx + 1))); + + p = re_ctx->saved[idx]; + while (p < re_ctx->saved[idx+1]) { + duk_codepoint_t c1, c2; + + /* Note: not necessary to check p against re_ctx->input_end: + * the memory access is checked by duk__inp_get_cp(), while + * valid compiled regexps cannot write a saved[] entry + * which points to outside the string. + */ + if (sp >= re_ctx->input_end) { + goto fail; + } + c1 = duk__inp_get_cp(re_ctx, &p); + c2 = duk__inp_get_cp(re_ctx, &sp); + if (c1 != c2) { + goto fail; + } + } + break; + } + default: { + DUK_D(DUK_DPRINT("internal error, regexp opcode error: %ld", (long) op)); + goto internal_error; + } + } + } + + match: + re_ctx->recursion_depth--; + return sp; + + fail: + re_ctx->recursion_depth--; + return NULL; + + internal_error: + DUK_ERROR(re_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_REGEXP_INTERNAL_ERROR); + return NULL; /* never here */ +} + +/* + * Exposed matcher function which provides the semantics of RegExp.prototype.exec(). + * + * RegExp.prototype.test() has the same semantics as exec() but does not return the + * result object (which contains the matching string and capture groups). Currently + * there is no separate test() helper, so a temporary result object is created and + * discarded if test() is needed. This is intentional, to save code space. + * + * Input stack: [ ... re_obj input ] + * Output stack: [ ... result ] + */ + +DUK_LOCAL void duk__regexp_match_helper(duk_hthread *thr, duk_small_int_t force_global) { + duk_context *ctx = (duk_context *) thr; + duk_re_matcher_ctx re_ctx; + duk_hobject *h_regexp; + duk_hstring *h_bytecode; + duk_hstring *h_input; + const duk_uint8_t *pc; + const duk_uint8_t *sp; + duk_small_int_t match = 0; + duk_small_int_t global; + duk_uint_fast32_t i; + double d; + duk_uint32_t char_offset; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(ctx != NULL); + + DUK_DD(DUK_DDPRINT("regexp match: regexp=%!T, input=%!T", + (duk_tval *) duk_get_tval(ctx, -2), + (duk_tval *) duk_get_tval(ctx, -1))); + + /* + * Regexp instance check, bytecode check, input coercion. + * + * See E5 Section 15.10.6. + */ + + /* TypeError if wrong; class check, see E5 Section 15.10.6 */ + h_regexp = duk_require_hobject_with_class(ctx, -2, DUK_HOBJECT_CLASS_REGEXP); + DUK_ASSERT(h_regexp != NULL); + DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(h_regexp) == DUK_HOBJECT_CLASS_REGEXP); + DUK_UNREF(h_regexp); + + duk_to_string(ctx, -1); + h_input = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_input != NULL); + + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_INT_BYTECODE); /* [ ... re_obj input ] -> [ ... re_obj input bc ] */ + h_bytecode = duk_require_hstring(ctx, -1); /* no regexp instance should exist without a non-configurable bytecode property */ + DUK_ASSERT(h_bytecode != NULL); + + /* + * Basic context initialization. + * + * Some init values are read from the bytecode header + * whose format is (UTF-8 codepoints): + * + * uint flags + * uint nsaved (even, 2n+2 where n = num captures) + */ + + /* [ ... re_obj input bc ] */ + + DUK_MEMZERO(&re_ctx, sizeof(re_ctx)); + + re_ctx.thr = thr; + re_ctx.input = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); + re_ctx.input_end = re_ctx.input + DUK_HSTRING_GET_BYTELEN(h_input); + re_ctx.bytecode = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_bytecode); + re_ctx.bytecode_end = re_ctx.bytecode + DUK_HSTRING_GET_BYTELEN(h_bytecode); + re_ctx.saved = NULL; + re_ctx.recursion_limit = DUK_USE_REGEXP_EXECUTOR_RECLIMIT; + re_ctx.steps_limit = DUK_RE_EXECUTE_STEPS_LIMIT; + + /* read header */ + pc = re_ctx.bytecode; + re_ctx.re_flags = duk__bc_get_u32(&re_ctx, &pc); + re_ctx.nsaved = duk__bc_get_u32(&re_ctx, &pc); + re_ctx.bytecode = pc; + + DUK_ASSERT(DUK_RE_FLAG_GLOBAL < 0x10000UL); /* must fit into duk_small_int_t */ + global = (duk_small_int_t) (force_global | (re_ctx.re_flags & DUK_RE_FLAG_GLOBAL)); + + DUK_ASSERT(re_ctx.nsaved >= 2); + DUK_ASSERT((re_ctx.nsaved % 2) == 0); + + duk_push_fixed_buffer(ctx, sizeof(duk_uint8_t *) * re_ctx.nsaved); + re_ctx.saved = (const duk_uint8_t **) duk_get_buffer(ctx, -1, NULL); + DUK_ASSERT(re_ctx.saved != NULL); + + /* [ ... re_obj input bc saved_buf ] */ + + /* buffer is automatically zeroed */ +#ifdef DUK_USE_EXPLICIT_NULL_INIT + for (i = 0; i < re_ctx.nsaved; i++) { + re_ctx.saved[i] = (duk_uint8_t *) NULL; + } +#endif + + DUK_DDD(DUK_DDDPRINT("regexp ctx initialized, flags=0x%08lx, nsaved=%ld, recursion_limit=%ld, steps_limit=%ld", + (unsigned long) re_ctx.re_flags, (long) re_ctx.nsaved, (long) re_ctx.recursion_limit, + (long) re_ctx.steps_limit)); + + /* + * Get starting character offset for match, and initialize 'sp' based on it. + * + * Note: lastIndex is non-configurable so it must be present (we check the + * internal class of the object above, so we know it is). User code can set + * its value to an arbitrary (garbage) value though; E5 requires that lastIndex + * be coerced to a number before using. The code below works even if the + * property is missing: the value will then be coerced to zero. + * + * Note: lastIndex may be outside Uint32 range even after ToInteger() coercion. + * For instance, ToInteger(+Infinity) = +Infinity. We track the match offset + * as an integer, but pre-check it to be inside the 32-bit range before the loop. + * If not, the check in E5 Section 15.10.6.2, step 9.a applies. + */ + + /* XXX: lastIndex handling produces a lot of asm */ + + /* [ ... re_obj input bc saved_buf ] */ + + duk_get_prop_stridx(ctx, -4, DUK_STRIDX_LAST_INDEX); /* -> [ ... re_obj input bc saved_buf lastIndex ] */ + (void) duk_to_int(ctx, -1); /* ToInteger(lastIndex) */ + d = duk_get_number(ctx, -1); /* integer, but may be +/- Infinite, +/- zero (not NaN, though) */ + duk_pop(ctx); + + if (global) { + if (d < 0.0 || d > (double) DUK_HSTRING_GET_CHARLEN(h_input)) { + /* match fail */ + char_offset = 0; /* not really necessary */ + DUK_ASSERT(match == 0); + goto match_over; + } + char_offset = (duk_uint32_t) d; + } else { + /* lastIndex must be ignored for non-global regexps, but get the + * value for (theoretical) side effects. No side effects can + * really occur, because lastIndex is a normal property and is + * always non-configurable for RegExp instances. + */ + char_offset = (duk_uint32_t) 0; + } + + sp = re_ctx.input + duk_heap_strcache_offset_char2byte(thr, h_input, char_offset); + + /* + * Match loop. + * + * Try matching at different offsets until match found or input exhausted. + */ + + /* [ ... re_obj input bc saved_buf ] */ + + DUK_ASSERT(match == 0); + + for (;;) { + /* char offset in [0, h_input->clen] (both ends inclusive), checked before entry */ + DUK_ASSERT_DISABLE(char_offset >= 0); + DUK_ASSERT(char_offset <= DUK_HSTRING_GET_CHARLEN(h_input)); + + /* Note: ctx.steps is intentionally not reset, it applies to the entire unanchored match */ + DUK_ASSERT(re_ctx.recursion_depth == 0); + + DUK_DDD(DUK_DDDPRINT("attempt match at char offset %ld; %p [%p,%p]", + (long) char_offset, (void *) sp, (void *) re_ctx.input, + (void *) re_ctx.input_end)); + + /* + * Note: + * + * - duk__match_regexp() is required not to longjmp() in ordinary "non-match" + * conditions; a longjmp() will terminate the entire matching process. + * + * - Clearing saved[] is not necessary because backtracking does it + * + * - Backtracking also rewinds ctx.recursion back to zero, unless an + * internal/limit error occurs (which causes a longjmp()) + * + * - If we supported anchored matches, we would break out here + * unconditionally; however, Ecmascript regexps don't have anchored + * matches. It might make sense to implement a fast bail-out if + * the regexp begins with '^' and sp is not 0: currently we'll just + * run through the entire input string, trivially failing the match + * at every non-zero offset. + */ + + if (duk__match_regexp(&re_ctx, re_ctx.bytecode, sp) != NULL) { + DUK_DDD(DUK_DDDPRINT("match at offset %ld", (long) char_offset)); + match = 1; + break; + } + + /* advance by one character (code point) and one char_offset */ + char_offset++; + if (char_offset > DUK_HSTRING_GET_CHARLEN(h_input)) { + /* + * Note: + * + * - Intentionally attempt (empty) match at char_offset == k_input->clen + * + * - Negative char_offsets have been eliminated and char_offset is duk_uint32_t + * -> no need or use for a negative check + */ + + DUK_DDD(DUK_DDDPRINT("no match after trying all sp offsets")); + break; + } + + /* avoid calling at end of input, will DUK_ERROR (above check suffices to avoid this) */ + (void) duk__utf8_advance(thr, &sp, re_ctx.input, re_ctx.input_end, (duk_uint_fast32_t) 1); + } + + match_over: + + /* + * Matching complete, create result array or return a 'null'. Update lastIndex + * if necessary. See E5 Section 15.10.6.2. + * + * Because lastIndex is a character (not byte) offset, we need the character + * length of the match which we conveniently get as a side effect of interning + * the matching substring (0th index of result array). + * + * saved[0] start pointer (~ byte offset) of current match + * saved[1] end pointer (~ byte offset) of current match (exclusive) + * char_offset start character offset of current match (-> .index of result) + * char_end_offset end character offset (computed below) + */ + + /* [ ... re_obj input bc saved_buf ] */ + + if (match) { +#ifdef DUK_USE_ASSERTIONS + duk_hobject *h_res; +#endif + duk_uint32_t char_end_offset = 0; + + DUK_DDD(DUK_DDDPRINT("regexp matches at char_offset %ld", (long) char_offset)); + + DUK_ASSERT(re_ctx.nsaved >= 2); /* must have start and end */ + DUK_ASSERT((re_ctx.nsaved % 2) == 0); /* and even number */ + + /* XXX: Array size is known before and (2 * re_ctx.nsaved) but not taken + * advantage of now. The array is not compacted either, as regexp match + * objects are usually short lived. + */ + + duk_push_array(ctx); + +#ifdef DUK_USE_ASSERTIONS + h_res = duk_require_hobject(ctx, -1); + DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h_res)); + DUK_ASSERT(DUK_HOBJECT_HAS_EXOTIC_ARRAY(h_res)); + DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(h_res) == DUK_HOBJECT_CLASS_ARRAY); +#endif + + /* [ ... re_obj input bc saved_buf res_obj ] */ + + duk_push_u32(ctx, char_offset); + duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INDEX); + + duk_dup(ctx, -4); + duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INPUT); + + for (i = 0; i < re_ctx.nsaved; i += 2) { + /* Captures which are undefined have NULL pointers and are returned + * as 'undefined'. The same is done when saved[] pointers are insane + * (this should, of course, never happen in practice). + */ + if (re_ctx.saved[i] && re_ctx.saved[i+1] && re_ctx.saved[i+1] >= re_ctx.saved[i]) { + duk_hstring *h_saved; + + duk_push_lstring(ctx, + (char *) re_ctx.saved[i], + (duk_size_t) (re_ctx.saved[i+1] - re_ctx.saved[i])); + h_saved = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_saved != NULL); + + if (i == 0) { + /* Assumes that saved[0] and saved[1] are always + * set by regexp bytecode (if not, char_end_offset + * will be zero). Also assumes clen reflects the + * correct char length. + */ + char_end_offset = char_offset + DUK_HSTRING_GET_CHARLEN(h_saved); + } + } else { + duk_push_undefined(ctx); + } + + /* [ ... re_obj input bc saved_buf res_obj val ] */ + duk_put_prop_index(ctx, -2, i / 2); + } + + /* [ ... re_obj input bc saved_buf res_obj ] */ + + /* NB: 'length' property is automatically updated by the array setup loop */ + + if (global) { + /* global regexp: lastIndex updated on match */ + duk_push_u32(ctx, char_end_offset); + duk_put_prop_stridx(ctx, -6, DUK_STRIDX_LAST_INDEX); + } else { + /* non-global regexp: lastIndex never updated on match */ + ; + } + } else { + /* + * No match, E5 Section 15.10.6.2, step 9.a.i - 9.a.ii apply, regardless + * of 'global' flag of the RegExp. In particular, if lastIndex is invalid + * initially, it is reset to zero. + */ + + DUK_DDD(DUK_DDDPRINT("regexp does not match")); + + duk_push_null(ctx); + + /* [ ... re_obj input bc saved_buf res_obj ] */ + + duk_push_int(ctx, 0); + duk_put_prop_stridx(ctx, -6, DUK_STRIDX_LAST_INDEX); + } + + /* [ ... re_obj input bc saved_buf res_obj ] */ + + duk_insert(ctx, -5); + + /* [ ... res_obj re_obj input bc saved_buf ] */ + + duk_pop_n(ctx, 4); + + /* [ ... res_obj ] */ + + /* XXX: these last tricks are unnecessary if the function is made + * a genuine native function. + */ +} + +DUK_INTERNAL void duk_regexp_match(duk_hthread *thr) { + duk__regexp_match_helper(thr, 0 /*force_global*/); +} + +/* This variant is needed by String.prototype.split(); it needs to perform + * global-style matching on a cloned RegExp which is potentially non-global. + */ +DUK_INTERNAL void duk_regexp_match_force_global(duk_hthread *thr) { + duk__regexp_match_helper(thr, 1 /*force_global*/); +} + +#else /* DUK_USE_REGEXP_SUPPORT */ + +/* regexp support disabled */ + +#endif /* DUK_USE_REGEXP_SUPPORT */ +#line 1 "duk_replacements.c" +/* + * Replacements for missing platform functions. + * + * Unlike the originals, fpclassify() and signbit() replacements don't + * work on any floating point types, only doubles. The C typing here + * mimics the standard prototypes. + */ + +/* include removed: duk_internal.h */ + +#ifdef DUK_USE_COMPUTED_NAN +DUK_INTERNAL double duk_computed_nan; +#endif + +#ifdef DUK_USE_COMPUTED_INFINITY +DUK_INTERNAL double duk_computed_infinity; +#endif + +#ifdef DUK_USE_REPL_FPCLASSIFY +DUK_INTERNAL int duk_repl_fpclassify(double x) { + duk_double_union u; + duk_uint_fast16_t expt; + duk_small_int_t mzero; + + u.d = x; + expt = (duk_uint_fast16_t) (u.us[DUK_DBL_IDX_US0] & 0x7ff0UL); + if (expt > 0x0000UL && expt < 0x7ff0UL) { + /* expt values [0x001,0x7fe] = normal */ + return DUK_FP_NORMAL; + } + + mzero = (u.ui[DUK_DBL_IDX_UI1] == 0 && (u.ui[DUK_DBL_IDX_UI0] & 0x000fffffUL) == 0); + if (expt == 0x0000UL) { + /* expt 0x000 is zero/subnormal */ + if (mzero) { + return DUK_FP_ZERO; + } else { + return DUK_FP_SUBNORMAL; + } + } else { + /* expt 0xfff is infinite/nan */ + if (mzero) { + return DUK_FP_INFINITE; + } else { + return DUK_FP_NAN; + } + } +} +#endif + +#ifdef DUK_USE_REPL_SIGNBIT +DUK_INTERNAL int duk_repl_signbit(double x) { + duk_double_union u; + u.d = x; + return (int) (u.uc[DUK_DBL_IDX_UC0] & 0x80UL); +} +#endif + +#ifdef DUK_USE_REPL_ISFINITE +DUK_INTERNAL int duk_repl_isfinite(double x) { + int c = DUK_FPCLASSIFY(x); + if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) { + return 0; + } else { + return 1; + } +} +#endif + +#ifdef DUK_USE_REPL_ISNAN +DUK_INTERNAL int duk_repl_isnan(double x) { + int c = DUK_FPCLASSIFY(x); + return (c == DUK_FP_NAN); +} +#endif + +#ifdef DUK_USE_REPL_ISINF +DUK_INTERNAL int duk_repl_isinf(double x) { + int c = DUK_FPCLASSIFY(x); + return (c == DUK_FP_INFINITE); +} +#endif +#line 1 "duk_selftest.c" +/* + * Self tests to ensure execution environment is sane. Intended to catch + * compiler/platform problems which cannot be detected at compile time. + */ + +/* include removed: duk_internal.h */ + +#if defined(DUK_USE_SELF_TESTS) + +/* + * Unions and structs for self tests + */ + +typedef union { + double d; + duk_uint8_t c[8]; +} duk__test_double_union; + +#define DUK__DBLUNION_CMP_TRUE(a,b) do { \ + if (DUK_MEMCMP((void *) (a), (void *) (b), sizeof(duk__test_double_union)) != 0) { \ + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double union compares false (expected true)"); \ + } \ + } while (0) + +#define DUK__DBLUNION_CMP_FALSE(a,b) do { \ + if (DUK_MEMCMP((void *) (a), (void *) (b), sizeof(duk__test_double_union)) == 0) { \ + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double union compares true (expected false)"); \ + } \ + } while (0) + +typedef union { + duk_uint32_t i; + duk_uint8_t c[8]; +} duk__test_u32_union; + +/* + * Various sanity checks for typing + */ + +DUK_LOCAL void duk__selftest_types(void) { + if (!(sizeof(duk_int8_t) == 1 && + sizeof(duk_uint8_t) == 1 && + sizeof(duk_int16_t) == 2 && + sizeof(duk_uint16_t) == 2 && + sizeof(duk_int32_t) == 4 && + sizeof(duk_uint32_t) == 4)) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_(u)int{8,16,32}_t size"); + } +#if defined(DUK_USE_64BIT_OPS) + if (!(sizeof(duk_int64_t) == 8 && + sizeof(duk_uint64_t) == 8)) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_(u)int64_t size"); + } +#endif + + if (!(sizeof(duk_size_t) >= sizeof(duk_uint_t))) { + /* Some internal code now assumes that all duk_uint_t values + * can be expressed with a duk_size_t. + */ + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_size_t is smaller than duk_uint_t"); + } + if (!(sizeof(duk_int_t) >= 4)) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_int_t is not 32 bits"); + } +} + +/* + * Packed tval sanity + */ + +DUK_LOCAL void duk__selftest_packed_tval(void) { +#if defined(DUK_USE_PACKED_TVAL) + if (sizeof(void *) > 4) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: packed duk_tval in use but sizeof(void *) > 4"); + } +#endif +} + +/* + * Two's complement arithmetic. + */ + +DUK_LOCAL void duk__selftest_twos_complement(void) { + volatile int test; + test = -1; + if (((duk_uint8_t *) &test)[0] != (duk_uint8_t) 0xff) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: two's complement arithmetic"); + } +} + +/* + * Byte order. Important to self check, because on some exotic platforms + * there is no actual detection but rather assumption based on platform + * defines. + */ + +DUK_LOCAL void duk__selftest_byte_order(void) { + duk__test_u32_union u1; + duk__test_double_union u2; + + /* + * >>> struct.pack('>d', 102030405060).encode('hex') + * '4237c17c6dc40000' + */ +#if defined(DUK_USE_INTEGER_LE) + u1.c[0] = 0xef; u1.c[1] = 0xbe; u1.c[2] = 0xad; u1.c[3] = 0xde; +#elif defined(DUK_USE_INTEGER_ME) +#error integer mixed endian not supported now +#elif defined(DUK_USE_INTEGER_BE) + u1.c[0] = 0xde; u1.c[1] = 0xad; u1.c[2] = 0xbe; u1.c[3] = 0xef; +#else +#error unknown integer endianness +#endif + +#if defined(DUK_USE_DOUBLE_LE) + u2.c[0] = 0x00; u2.c[1] = 0x00; u2.c[2] = 0xc4; u2.c[3] = 0x6d; + u2.c[4] = 0x7c; u2.c[5] = 0xc1; u2.c[6] = 0x37; u2.c[7] = 0x42; +#elif defined(DUK_USE_DOUBLE_ME) + u2.c[0] = 0x7c; u2.c[1] = 0xc1; u2.c[2] = 0x37; u2.c[3] = 0x42; + u2.c[4] = 0x00; u2.c[5] = 0x00; u2.c[6] = 0xc4; u2.c[7] = 0x6d; +#elif defined(DUK_USE_DOUBLE_BE) + u2.c[0] = 0x42; u2.c[1] = 0x37; u2.c[2] = 0xc1; u2.c[3] = 0x7c; + u2.c[4] = 0x6d; u2.c[5] = 0xc4; u2.c[6] = 0x00; u2.c[7] = 0x00; +#else +#error unknown double endianness +#endif + + if (u1.i != (duk_uint32_t) 0xdeadbeefUL) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_uint32_t byte order"); + } + + if (u2.d != (double) 102030405060.0) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double byte order"); + } +} + +/* + * DUK_BSWAP macros + */ + +DUK_LOCAL void duk__selftest_bswap_macros(void) { + duk_uint32_t x32; + duk_uint16_t x16; + duk_double_union du; + duk_double_t du_diff; + + x16 = 0xbeefUL; + x16 = DUK_BSWAP16(x16); + if (x16 != (duk_uint16_t) 0xefbeUL) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: DUK_BSWAP16"); + } + + x32 = 0xdeadbeefUL; + x32 = DUK_BSWAP32(x32); + if (x32 != (duk_uint32_t) 0xefbeaddeUL) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: DUK_BSWAP32"); + } + + /* >>> struct.unpack('>d', '4000112233445566'.decode('hex')) + * (2.008366013071895,) + */ + + du.uc[0] = 0x40; du.uc[1] = 0x00; du.uc[2] = 0x11; du.uc[3] = 0x22; + du.uc[4] = 0x33; du.uc[5] = 0x44; du.uc[6] = 0x55; du.uc[7] = 0x66; + DUK_DBLUNION_DOUBLE_NTOH(&du); + du_diff = du.d - 2.008366013071895; +#if 0 + DUK_FPRINTF(DUK_STDERR, "du_diff: %lg\n", (double) du_diff); +#endif + if (du_diff > 1e-15) { + /* Allow very small lenience because some compilers won't parse + * exact IEEE double constants (happened in matrix testing with + * Linux gcc-4.8 -m32 at least). + */ +#if 0 + DUK_FPRINTF(DUK_STDERR, "Result of DUK_DBLUNION_DOUBLE_NTOH: %02x %02x %02x %02x %02x %02x %02x %02x\n", + (unsigned int) du.uc[0], (unsigned int) du.uc[1], + (unsigned int) du.uc[2], (unsigned int) du.uc[3], + (unsigned int) du.uc[4], (unsigned int) du.uc[5], + (unsigned int) du.uc[6], (unsigned int) du.uc[7]); +#endif + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: DUK_DBLUNION_DOUBLE_NTOH"); + } +} + +/* + * Basic double / byte union memory layout. + */ + +DUK_LOCAL void duk__selftest_double_union_size(void) { + if (sizeof(duk__test_double_union) != 8) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: invalid union size"); + } +} + +/* + * Union aliasing, see misc/clang_aliasing.c. + */ + +DUK_LOCAL void duk__selftest_double_aliasing(void) { + duk__test_double_union a, b; + + /* This testcase fails when Emscripten-generated code runs on Firefox. + * It's not an issue because the failure should only affect packed + * duk_tval representation, which is not used with Emscripten. + */ +#if defined(DUK_USE_NO_DOUBLE_ALIASING_SELFTEST) +#if defined(DUK_USE_PACKED_TVAL) +#error inconsistent defines: skipping double aliasing selftest when using packed duk_tval +#endif + return; +#endif + + /* Test signaling NaN and alias assignment in all + * endianness combinations. + */ + + /* little endian */ + a.c[0] = 0x11; a.c[1] = 0x22; a.c[2] = 0x33; a.c[3] = 0x44; + a.c[4] = 0x00; a.c[5] = 0x00; a.c[6] = 0xf1; a.c[7] = 0xff; + b = a; + DUK__DBLUNION_CMP_TRUE(&a, &b); + + /* big endian */ + a.c[0] = 0xff; a.c[1] = 0xf1; a.c[2] = 0x00; a.c[3] = 0x00; + a.c[4] = 0x44; a.c[5] = 0x33; a.c[6] = 0x22; a.c[7] = 0x11; + b = a; + DUK__DBLUNION_CMP_TRUE(&a, &b); + + /* mixed endian */ + a.c[0] = 0x00; a.c[1] = 0x00; a.c[2] = 0xf1; a.c[3] = 0xff; + a.c[4] = 0x11; a.c[5] = 0x22; a.c[6] = 0x33; a.c[7] = 0x44; + b = a; + DUK__DBLUNION_CMP_TRUE(&a, &b); +} + +/* + * Zero sign, see misc/tcc_zerosign2.c. + */ + +DUK_LOCAL void duk__selftest_double_zero_sign(void) { + volatile duk__test_double_union a, b; + + a.d = 0.0; + b.d = -a.d; + DUK__DBLUNION_CMP_FALSE(&a, &b); +} + +/* + * Struct size/alignment if platform requires it + * + * There are some compiler specific struct padding pragmas etc in use, this + * selftest ensures they're correctly detected and used. + */ + +DUK_LOCAL void duk__selftest_struct_align(void) { +#if (DUK_USE_ALIGN_BY == 4) + if ((sizeof(duk_hbuffer_fixed) % 4) != 0) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: sizeof(duk_hbuffer_fixed) not aligned to 4"); + } +#elif (DUK_USE_ALIGN_BY == 8) + if ((sizeof(duk_hbuffer_fixed) % 8) != 0) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: sizeof(duk_hbuffer_fixed) not aligned to 8"); + } +#elif (DUK_USE_ALIGN_BY == 1) + /* no check */ +#else +#error invalid DUK_USE_ALIGN_BY +#endif +} + +/* + * 64-bit arithmetic + * + * There are some platforms/compilers where 64-bit types are available + * but don't work correctly. Test for known cases. + */ + +DUK_LOCAL void duk__selftest_64bit_arithmetic(void) { +#if defined(DUK_USE_64BIT_OPS) + volatile duk_int64_t i; + volatile duk_double_t d; + + /* Catch a double-to-int64 cast issue encountered in practice. */ + d = 2147483648.0; + i = (duk_int64_t) d; + if (i != 0x80000000LL) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: casting 2147483648.0 to duk_int64_t failed"); + } +#else + /* nop */ +#endif +} + +/* + * Casting + */ + +DUK_LOCAL void duk__selftest_cast_double_to_small_uint(void) { + /* + * https://github.com/svaarala/duktape/issues/127#issuecomment-77863473 + */ + + duk_double_t d1, d2; + duk_small_uint_t u; + + duk_double_t d1v, d2v; + duk_small_uint_t uv; + + /* Test without volatiles */ + + d1 = 1.0; + u = (duk_small_uint_t) d1; + d2 = (duk_double_t) u; + + if (!(d1 == 1.0 && u == 1 && d2 == 1.0 && d1 == d2)) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to duk_small_uint_t cast failed"); + } + + /* Same test with volatiles */ + + d1v = 1.0; + uv = (duk_small_uint_t) d1v; + d2v = (duk_double_t) uv; + + if (!(d1v == 1.0 && uv == 1 && d2v == 1.0 && d1v == d2v)) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to duk_small_uint_t cast failed"); + } +} + +DUK_LOCAL void duk__selftest_cast_double_to_uint32(void) { + /* + * This test fails on an exotic ARM target; double-to-uint + * cast is incorrectly clamped to -signed- int highest value. + * + * https://github.com/svaarala/duktape/issues/336 + */ + + duk_double_t dv; + duk_uint32_t uv; + + dv = 3735928559.0; /* 0xdeadbeef in decimal */ + uv = (duk_uint32_t) dv; + + if (uv != 0xdeadbeefUL) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to duk_uint32_t cast failed"); + } +} + +/* + * Self test main + */ + +DUK_INTERNAL void duk_selftest_run_tests(void) { + duk__selftest_types(); + duk__selftest_packed_tval(); + duk__selftest_twos_complement(); + duk__selftest_byte_order(); + duk__selftest_bswap_macros(); + duk__selftest_double_union_size(); + duk__selftest_double_aliasing(); + duk__selftest_double_zero_sign(); + duk__selftest_struct_align(); + duk__selftest_64bit_arithmetic(); + duk__selftest_cast_double_to_small_uint(); + duk__selftest_cast_double_to_uint32(); +} + +#undef DUK__DBLUNION_CMP_TRUE +#undef DUK__DBLUNION_CMP_FALSE + +#endif /* DUK_USE_SELF_TESTS */ +/* include removed: duk_internal.h */ +#line 2 "duk_tval.c" + +#if defined(DUK_USE_FASTINT) + +/* + * Manually optimized double-to-fastint downgrade check. + * + * This check has a large impact on performance, especially for fastint + * slow paths, so must be changed carefully. The code should probably be + * optimized for the case where the result does not fit into a fastint, + * to minimize the penalty for "slow path code" dealing with fractions etc. + * + * At least on one tested soft float ARM platform double-to-int64 coercion + * is very slow (and sometimes produces incorrect results, see self tests). + * This algorithm combines a fastint compatibility check and extracting the + * integer value from an IEEE double for setting the tagged fastint. For + * other platforms a more naive approach might be better. + * + * See doc/fastint.rst for details. + */ + +DUK_INTERNAL DUK_ALWAYS_INLINE void duk_tval_set_number_chkfast(duk_tval *tv, duk_double_t x) { + duk_double_union du; + duk_int64_t i; + duk_small_int_t expt; + duk_small_int_t shift; + + /* XXX: optimize for packed duk_tval directly? */ + + du.d = x; + i = (duk_int64_t) DUK_DBLUNION_GET_INT64(&du); + expt = (duk_small_int_t) ((i >> 52) & 0x07ff); + shift = expt - 1023; + + if (shift >= 0 && shift <= 46) { /* exponents 1023 to 1069 */ + duk_int64_t t; + + if (((0x000fffffffffffffLL >> shift) & i) == 0) { + t = i | 0x0010000000000000LL; /* implicit leading one */ + t = t & 0x001fffffffffffffLL; + t = t >> (52 - shift); + if (i < 0) { + t = -t; + } + DUK_TVAL_SET_FASTINT(tv, t); + return; + } + } else if (shift == -1023) { /* exponent 0 */ + if (i >= 0 && (i & 0x000fffffffffffffLL) == 0) { + /* Note: reject negative zero. */ + DUK_TVAL_SET_FASTINT(tv, (duk_int64_t) 0); + return; + } + } else if (shift == 47) { /* exponent 1070 */ + if (i < 0 && (i & 0x000fffffffffffffLL) == 0) { + DUK_TVAL_SET_FASTINT(tv, (duk_int64_t) DUK_FASTINT_MIN); + return; + } + } + + DUK_TVAL_SET_DOUBLE(tv, x); + return; +} + +/* + * Manually optimized number-to-double conversion + */ + +#if defined(DUK_USE_FASTINT) && defined(DUK_USE_PACKED_TVAL) +DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_packed(duk_tval *tv) { + duk_double_union du; + duk_uint64_t t; + + t = (duk_uint64_t) DUK_DBLUNION_GET_UINT64(tv); + if ((t >> 48) != DUK_TAG_FASTINT) { + return tv->d; + } else if (t & 0x0000800000000000ULL) { + t = (duk_uint64_t) (-((duk_int64_t) t)); /* avoid unary minus on unsigned */ + t = t & 0x0000ffffffffffffULL; /* negative */ + t |= 0xc330000000000000ULL; + DUK_DBLUNION_SET_UINT64(&du, t); + return du.d + 4503599627370496.0; /* 1 << 52 */ + } else if (t != 0) { + t &= 0x0000ffffffffffffULL; /* positive */ + t |= 0x4330000000000000ULL; + DUK_DBLUNION_SET_UINT64(&du, t); + return du.d - 4503599627370496.0; /* 1 << 52 */ + } else { + return 0.0; /* zero */ + } +} +#endif /* DUK_USE_FASTINT && DUK_USE_PACKED_TVAL */ + +#if 0 /* unused */ +#if defined(DUK_USE_FASTINT) && !defined(DUK_USE_PACKED_TVAL) +DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_unpacked(duk_tval *tv) { + duk_double_union du; + duk_uint64_t t; + + DUK_ASSERT(tv->t == DUK__TAG_NUMBER || tv->t == DUK_TAG_FASTINT); + + if (tv->t == DUK_TAG_FASTINT) { + if (tv->v.fi >= 0) { + t = 0x4330000000000000ULL | (duk_uint64_t) tv->v.fi; + DUK_DBLUNION_SET_UINT64(&du, t); + return du.d - 4503599627370496.0; /* 1 << 52 */ + } else { + t = 0xc330000000000000ULL | (duk_uint64_t) (-tv->v.fi); + DUK_DBLUNION_SET_UINT64(&du, t); + return du.d + 4503599627370496.0; /* 1 << 52 */ + } + } else { + return tv->v.d; + } +} +#endif /* DUK_USE_FASTINT && DUK_USE_PACKED_TVAL */ +#endif /* 0 */ + +#if defined(DUK_USE_FASTINT) && !defined(DUK_USE_PACKED_TVAL) +DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_unpacked_fastint(duk_tval *tv) { + duk_double_union du; + duk_uint64_t t; + + DUK_ASSERT(tv->t == DUK_TAG_FASTINT); + + if (tv->v.fi >= 0) { + t = 0x4330000000000000ULL | (duk_uint64_t) tv->v.fi; + DUK_DBLUNION_SET_UINT64(&du, t); + return du.d - 4503599627370496.0; /* 1 << 52 */ + } else { + t = 0xc330000000000000ULL | (duk_uint64_t) (-tv->v.fi); + DUK_DBLUNION_SET_UINT64(&du, t); + return du.d + 4503599627370496.0; /* 1 << 52 */ + } +} +#endif /* DUK_USE_FASTINT && DUK_USE_PACKED_TVAL */ + +#endif /* DUK_USE_FASTINT */ +#line 1 "duk_unicode_tables.c" +/* + * Unicode support tables automatically generated during build. + */ + +/* include removed: duk_internal.h */ + +/* + * Unicode tables containing ranges of Unicode characters in a + * packed format. These tables are used to match non-ASCII + * characters of complex productions by resorting to a linear + * range-by-range comparison. This is very slow, but is expected + * to be very rare in practical Ecmascript source code, and thus + * compactness is most important. + * + * The tables are matched using uni_range_match() and the format + * is described in src/extract_chars.py. + */ + +#ifdef DUK_USE_SOURCE_NONBMP +/* IdentifierStart production with ASCII excluded */ +/* duk_unicode_ids_noa[] */ +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +const duk_uint8_t duk_unicode_ids_noa[791] = { +249,176,176,80,111,7,47,15,47,254,11,197,191,0,72,2,15,115,66,19,57,2,34,2, +240,66,244,50,247,185,248,234,241,99,8,241,127,58,240,182,47,31,241,191,21, +18,245,50,15,1,24,27,35,15,2,2,240,239,15,244,156,15,10,241,26,21,6,240, +101,10,4,15,9,240,159,157,242,100,15,4,8,159,1,98,102,115,19,240,98,98,4, +52,15,2,14,18,47,0,31,5,85,19,240,98,98,18,18,31,17,50,15,5,47,2,130,34, +240,98,98,18,68,15,4,15,1,31,21,115,19,240,98,98,18,68,15,16,18,47,1,15,3, +2,84,34,52,18,2,20,20,36,191,8,15,38,114,34,240,114,146,68,15,12,23,31,21, +114,34,240,114,146,68,15,18,2,31,1,31,4,114,34,241,147,15,2,15,3,31,10,86, +240,36,240,130,130,3,111,44,242,2,29,111,44,18,3,18,3,7,50,98,34,2,3,18,50, +26,3,66,15,7,31,20,15,49,114,241,79,13,79,101,241,191,6,15,2,85,52,4,24,37, +205,15,3,241,107,241,178,4,255,224,59,35,54,32,35,63,25,35,63,17,35,54,32, +35,62,47,41,35,63,51,241,127,0,240,47,69,223,254,21,227,240,18,240,166,243, +180,47,1,194,63,0,240,47,0,240,47,0,194,47,1,242,79,21,5,15,53,244,137,241, +146,6,243,107,240,223,37,240,227,76,241,207,7,111,42,240,122,242,95,68,15, +79,241,255,3,111,41,240,238,31,2,241,111,12,241,79,27,43,241,79,93,50,63,0, +251,15,50,255,224,8,53,63,22,53,55,32,32,32,47,15,63,37,38,32,66,38,67,53, +92,98,38,246,96,224,240,44,245,112,80,57,32,68,112,32,32,35,42,51,100,80, +240,63,25,255,233,107,241,242,241,242,247,87,63,3,241,107,242,106,15,2,240, +122,98,98,98,98,98,98,98,111,66,15,254,12,146,240,184,132,52,95,70,114,47, +74,35,111,25,79,78,240,63,11,242,127,0,255,224,244,255,240,0,138,143,60, +255,240,4,11,239,38,255,227,127,243,95,30,63,253,79,0,177,240,111,31,240, +47,9,159,64,241,152,63,87,51,33,240,9,244,39,34,35,47,7,240,255,36,240,15, +34,243,5,64,240,15,12,191,7,240,191,13,143,31,240,224,242,47,25,240,146,39, +240,111,7,64,111,32,32,65,52,48,32,240,162,241,85,53,53,166,38,248,63,19, +240,255,255,0,26,150,223,7,95,33,255,240,0,255,143,254,2,3,242,227,245,175, +24,109,70,2,146,194,66,2,18,18,245,207,19,255,224,93,240,79,48,63,38,241, +171,246,100,47,119,241,111,10,127,10,207,73,69,53,53,50,241,91,47,10,47,3, +33,46,61,241,79,107,243,127,37,255,223,13,79,33,242,31,15,240,63,11,242, +127,14,63,20,87,36,241,207,142,255,226,86,83,2,241,194,20,3,240,127,156, +240,107,240,175,184,15,1,50,34,240,191,30,240,223,117,242,107,240,107,240, +63,127,243,159,254,42,239,37,243,223,29,255,238,68,255,226,97,248,63,83, +255,234,145,255,227,33,255,240,2,44,95,254,18,191,255,0,52,187,31,255,0,18, +242,244,82,243,114,19,3,19,50,178,2,98,243,18,51,114,98,240,194,50,66,4,98, +255,224,70,63,9,47,9,47,15,47,9,47,15,47,9,47,15,47,9,47,15,47,9,39,255, +240,1,114,143,255,0,149,201,241,191,254,242,124,252,239,255,0,46,214,255, +225,16,0, +}; +#else +/* IdentifierStart production with ASCII and non-BMP excluded */ +/* duk_unicode_ids_noabmp[] */ +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +const duk_uint8_t duk_unicode_ids_noabmp[611] = { +249,176,176,80,111,7,47,15,47,254,11,197,191,0,72,2,15,115,66,19,57,2,34,2, +240,66,244,50,247,185,248,234,241,99,8,241,127,58,240,182,47,31,241,191,21, +18,245,50,15,1,24,27,35,15,2,2,240,239,15,244,156,15,10,241,26,21,6,240, +101,10,4,15,9,240,159,157,242,100,15,4,8,159,1,98,102,115,19,240,98,98,4, +52,15,2,14,18,47,0,31,5,85,19,240,98,98,18,18,31,17,50,15,5,47,2,130,34, +240,98,98,18,68,15,4,15,1,31,21,115,19,240,98,98,18,68,15,16,18,47,1,15,3, +2,84,34,52,18,2,20,20,36,191,8,15,38,114,34,240,114,146,68,15,12,23,31,21, +114,34,240,114,146,68,15,18,2,31,1,31,4,114,34,241,147,15,2,15,3,31,10,86, +240,36,240,130,130,3,111,44,242,2,29,111,44,18,3,18,3,7,50,98,34,2,3,18,50, +26,3,66,15,7,31,20,15,49,114,241,79,13,79,101,241,191,6,15,2,85,52,4,24,37, +205,15,3,241,107,241,178,4,255,224,59,35,54,32,35,63,25,35,63,17,35,54,32, +35,62,47,41,35,63,51,241,127,0,240,47,69,223,254,21,227,240,18,240,166,243, +180,47,1,194,63,0,240,47,0,240,47,0,194,47,1,242,79,21,5,15,53,244,137,241, +146,6,243,107,240,223,37,240,227,76,241,207,7,111,42,240,122,242,95,68,15, +79,241,255,3,111,41,240,238,31,2,241,111,12,241,79,27,43,241,79,93,50,63,0, +251,15,50,255,224,8,53,63,22,53,55,32,32,32,47,15,63,37,38,32,66,38,67,53, +92,98,38,246,96,224,240,44,245,112,80,57,32,68,112,32,32,35,42,51,100,80, +240,63,25,255,233,107,241,242,241,242,247,87,63,3,241,107,242,106,15,2,240, +122,98,98,98,98,98,98,98,111,66,15,254,12,146,240,184,132,52,95,70,114,47, +74,35,111,25,79,78,240,63,11,242,127,0,255,224,244,255,240,0,138,143,60, +255,240,4,11,239,38,255,227,127,243,95,30,63,253,79,0,177,240,111,31,240, +47,9,159,64,241,152,63,87,51,33,240,9,244,39,34,35,47,7,240,255,36,240,15, +34,243,5,64,240,15,12,191,7,240,191,13,143,31,240,224,242,47,25,240,146,39, +240,111,7,64,111,32,32,65,52,48,32,240,162,241,85,53,53,166,38,248,63,19, +240,255,255,0,26,150,223,7,95,33,255,240,0,255,143,254,2,3,242,227,245,175, +24,109,70,2,146,194,66,2,18,18,245,207,19,255,224,93,240,79,48,63,38,241, +171,246,100,47,119,241,111,10,127,10,207,73,69,53,53,50,0, +}; +#endif + +#ifdef DUK_USE_SOURCE_NONBMP +/* IdentifierStart production with Letter and ASCII excluded */ +/* duk_unicode_ids_m_let_noa[] */ +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +const duk_uint8_t duk_unicode_ids_m_let_noa[42] = { +255,240,0,94,18,255,233,99,241,51,63,254,215,32,240,184,240,2,255,240,6,89, +249,255,240,4,148,79,37,255,224,192,9,15,120,79,255,0,15,30,245,48, +}; +#else +/* IdentifierStart production with Letter, ASCII, and non-BMP excluded */ +/* duk_unicode_ids_m_let_noabmp[] */ +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +const duk_uint8_t duk_unicode_ids_m_let_noabmp[24] = { +255,240,0,94,18,255,233,99,241,51,63,254,215,32,240,184,240,2,255,240,6,89, +249,0, +}; +#endif + +#ifdef DUK_USE_SOURCE_NONBMP +/* IdentifierPart production with IdentifierStart and ASCII excluded */ +/* duk_unicode_idp_m_ids_noa[] */ +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +const duk_uint8_t duk_unicode_idp_m_ids_noa[397] = { +255,225,243,246,15,254,0,116,255,191,29,32,33,33,32,243,170,242,47,15,112, +245,118,53,49,35,57,240,144,241,15,11,244,218,240,25,241,56,241,67,40,34, +36,241,210,249,99,242,130,47,2,38,177,57,240,50,242,160,38,49,50,160,177, +57,240,50,242,160,36,81,50,64,240,107,64,194,242,160,39,34,34,240,97,57, +240,50,242,160,38,49,50,145,177,57,240,64,242,212,66,35,160,240,9,240,50, +242,198,34,35,129,193,57,240,65,242,160,38,34,35,129,193,57,240,65,242,198, +34,35,160,177,57,240,65,243,128,85,32,39,240,65,242,240,54,215,41,244,144, +53,33,197,57,243,1,121,192,32,32,81,242,63,4,33,106,47,20,160,245,111,4,41, +211,82,34,54,67,235,46,255,225,179,47,254,42,98,240,242,240,241,241,1,243, +79,14,160,57,241,50,57,248,16,246,139,91,185,245,47,1,129,121,242,244,242, +185,47,13,58,121,245,132,242,31,1,201,240,56,210,241,9,105,241,237,242,47, +4,153,121,246,130,47,5,80,80,251,255,23,240,115,255,225,0,31,35,31,5,15, +109,197,4,191,254,175,34,247,240,245,47,16,255,225,30,95,91,31,255,0,100, +121,159,55,13,31,100,31,254,0,64,64,80,240,148,244,161,242,79,1,201,127,2, +240,9,240,231,240,188,241,227,242,29,240,25,244,29,208,145,57,241,48,242, +96,34,49,97,32,255,224,21,114,19,159,255,0,62,24,15,254,29,95,0,240,38,209, +240,162,251,41,241,112,255,225,177,15,254,25,105,255,228,75,34,22,63,26,37, +15,254,75,66,242,126,241,25,240,34,241,250,255,240,10,249,228,69,151,54, +241,3,248,98,255,228,125,242,47,255,12,23,244,254,0, +}; +#else +/* IdentifierPart production with IdentifierStart, ASCII, and non-BMP excluded */ +/* duk_unicode_idp_m_ids_noabmp[] */ +/* + * Automatically generated by extract_chars.py, do not edit! + */ + +const duk_uint8_t duk_unicode_idp_m_ids_noabmp[348] = { +255,225,243,246,15,254,0,116,255,191,29,32,33,33,32,243,170,242,47,15,112, +245,118,53,49,35,57,240,144,241,15,11,244,218,240,25,241,56,241,67,40,34, +36,241,210,249,99,242,130,47,2,38,177,57,240,50,242,160,38,49,50,160,177, +57,240,50,242,160,36,81,50,64,240,107,64,194,242,160,39,34,34,240,97,57, +240,50,242,160,38,49,50,145,177,57,240,64,242,212,66,35,160,240,9,240,50, +242,198,34,35,129,193,57,240,65,242,160,38,34,35,129,193,57,240,65,242,198, +34,35,160,177,57,240,65,243,128,85,32,39,240,65,242,240,54,215,41,244,144, +53,33,197,57,243,1,121,192,32,32,81,242,63,4,33,106,47,20,160,245,111,4,41, +211,82,34,54,67,235,46,255,225,179,47,254,42,98,240,242,240,241,241,1,243, +79,14,160,57,241,50,57,248,16,246,139,91,185,245,47,1,129,121,242,244,242, +185,47,13,58,121,245,132,242,31,1,201,240,56,210,241,9,105,241,237,242,47, +4,153,121,246,130,47,5,80,80,251,255,23,240,115,255,225,0,31,35,31,5,15, +109,197,4,191,254,175,34,247,240,245,47,16,255,225,30,95,91,31,255,0,100, +121,159,55,13,31,100,31,254,0,64,64,80,240,148,244,161,242,79,1,201,127,2, +240,9,240,231,240,188,241,227,242,29,240,25,244,29,208,145,57,241,48,242, +96,34,49,97,32,255,224,21,114,19,159,255,0,62,24,15,254,29,95,0,240,38,209, +240,162,251,41,241,112,0, +}; +#endif + +/* + * Case conversion tables generated using src/extract_caseconv.py. + */ + +/* duk_unicode_caseconv_uc[] */ +/* duk_unicode_caseconv_lc[] */ + +/* + * Automatically generated by extract_caseconv.py, do not edit! + */ + +const duk_uint8_t duk_unicode_caseconv_uc[1288] = { +132,3,128,3,0,184,7,192,6,192,112,35,242,199,224,64,74,192,49,32,128,162, +128,108,65,1,189,129,254,131,3,173,3,136,6,7,98,7,34,68,15,12,14,140,72,30, +104,28,112,32,67,0,65,4,0,138,0,128,4,1,88,65,76,83,15,128,15,132,8,31,16, +31,24,12,62,64,62,80,32,124,192,124,224,64,250,0,250,64,97,246,1,246,129,3, +238,3,247,64,135,220,135,242,2,15,187,15,237,2,31,120,31,248,4,62,244,63, +212,8,125,240,127,232,16,253,128,253,192,33,253,1,253,128,67,252,3,253,0, +136,92,8,88,8,18,104,18,91,26,44,48,44,0,94,90,0,33,64,155,253,7,252,132, +212,0,32,32,32,6,0,76,192,76,129,128,157,0,156,136,1,75,1,74,46,2,244,2, +242,12,6,12,6,8,16,13,8,13,0,48,27,64,27,48,64,57,192,57,162,0,119,192,119, +132,128,252,128,252,20,2,35,2,34,18,4,142,4,140,20,13,196,13,192,16,30,200, +30,192,192,70,16,70,2,32,145,96,145,70,193,48,129,48,67,130,104,130,104,44, +30,1,30,0,150,61,66,61,64,192,125,68,125,100,33,99,65,99,56,50,200,18,200, +6,69,157,133,157,96,169,144,105,144,11,211,64,211,64,12,167,35,167,34,15, +78,103,78,100,126,157,234,157,228,21,59,253,59,240,90,122,26,122,0,163,128, +214,128,214,2,1,197,1,196,6,3,140,3,136,12,7,200,7,196,16,20,0,13,48,32,63, +128,63,112,69,142,101,142,64,130,1,136,1,135,4,3,114,3,112,8,26,120,202, +120,176,65,1,30,1,29,130,2,105,1,150,5,255,96,22,160,115,128,31,224,47,0, +38,32,9,32,47,224,10,96,48,0,72,96,50,64,50,32,50,160,62,192,51,32,51,0,51, +64,71,160,51,192,68,0,53,0,52,224,55,224,62,224,59,160,49,192,62,96,62,32, +74,5,141,224,74,37,141,160,74,69,142,0,74,96,48,32,74,128,48,192,75,32,49, +224,75,96,50,0,76,0,50,96,76,96,50,128,76,180,241,160,77,0,50,224,77,101, +140,64,78,37,141,192,78,64,51,160,78,160,51,224,79,165,140,128,81,0,53,192, +81,32,72,128,81,128,72,160,82,64,54,224,104,160,115,32,110,224,110,192,117, +128,112,192,120,64,116,96,121,128,113,128,122,0,114,64,122,32,115,0,122, +160,116,192,122,192,116,0,122,224,121,224,126,0,115,64,126,32,116,32,126, +64,127,32,126,160,114,160,153,224,152,3,175,52,239,163,175,165,140,99,211, +99,204,3,247,192,115,35,252,163,253,132,41,196,38,68,48,132,48,101,140,37, +140,5,140,160,71,69,140,192,71,217,128,55,224,5,48,5,48,20,152,10,240,1,56, +7,194,0,74,3,12,3,144,192,230,64,194,0,192,64,236,48,58,80,48,128,48,16,88, +120,20,212,21,72,122,90,0,72,3,49,30,151,128,21,0,194,7,166,32,5,112,48, +161,233,152,1,100,12,40,122,106,0,65,2,190,31,80,128,233,64,196,199,212, +176,58,80,49,48,48,1,245,76,14,148,12,76,12,4,125,91,3,165,3,19,3,66,31, +128,135,194,0,230,71,224,97,240,144,57,145,248,40,124,40,14,100,126,14,31, +11,3,153,31,132,135,195,0,230,71,225,97,240,208,57,145,248,104,124,56,14, +100,126,30,31,15,3,153,31,136,135,194,0,230,71,226,97,240,144,57,145,248, +168,124,40,14,100,126,46,31,11,3,153,31,140,135,195,0,230,71,227,97,240, +208,57,145,248,232,124,56,14,100,126,62,31,15,3,153,31,144,135,202,0,230, +71,228,97,242,144,57,145,249,40,124,168,14,100,126,78,31,43,3,153,31,148, +135,203,0,230,71,229,97,242,208,57,145,249,104,124,184,14,100,126,94,31,47, +3,153,31,152,135,202,0,230,71,230,97,242,144,57,145,249,168,124,168,14,100, +126,110,31,43,3,153,31,156,135,203,0,230,71,231,97,242,208,57,145,249,232, +124,184,14,100,126,126,31,47,3,153,31,160,135,218,0,230,71,232,97,246,144, +57,145,250,40,125,168,14,100,126,142,31,107,3,153,31,164,135,219,0,230,71, +233,97,246,208,57,145,250,104,125,184,14,100,126,158,31,111,3,153,31,168, +135,218,0,230,71,234,97,246,144,57,145,250,168,125,168,14,100,126,174,31, +107,3,153,31,172,135,219,0,230,71,235,97,246,208,57,145,250,232,125,184,14, +100,126,190,31,111,3,153,31,178,135,238,128,230,71,236,224,57,16,57,145, +251,72,14,24,14,100,126,218,3,145,3,66,31,183,192,228,64,208,128,230,71, +239,32,57,16,57,145,252,40,127,40,14,100,127,14,3,151,3,153,31,196,128,226, +64,230,71,241,160,57,112,52,33,252,124,14,92,13,8,14,100,127,50,3,151,3, +153,31,210,192,230,64,194,0,192,7,244,240,57,144,48,128,48,17,253,104,14, +100,13,8,127,95,3,153,3,8,3,66,31,226,192,233,64,194,0,192,7,248,240,58,80, +48,128,48,17,254,72,14,132,12,76,127,154,3,165,3,66,31,231,192,233,64,194, +0,208,135,252,161,255,160,57,145,255,56,14,164,14,100,127,210,3,143,3,153, +31,246,128,234,64,208,135,253,240,58,144,52,32,57,145,255,200,14,164,14, +103,236,2,0,70,0,70,251,1,128,17,128,18,126,192,160,4,96,4,207,176,60,1,24, +1,24,1,39,236,19,0,70,0,70,0,76,251,5,128,20,192,21,62,193,160,5,48,5,79, +177,56,21,16,21,27,236,82,5,68,5,53,251,21,129,81,1,78,254,197,160,84,224, +84,111,177,120,21,16,20,244, +}; +const duk_uint8_t duk_unicode_caseconv_lc[616] = { +144,3,0,3,128,184,6,192,7,192,112,24,144,37,96,64,54,32,81,64,128,226,0, +235,65,129,199,1,230,130,3,145,3,177,34,7,70,7,134,36,15,244,13,236,24,32, +0,34,129,0,65,0,67,4,0,166,32,172,41,132,40,11,64,19,15,132,15,128,8,31,24, +31,16,12,62,80,62,64,32,124,224,124,192,64,250,64,250,0,97,246,129,246,1,3, +241,3,240,2,7,230,7,228,4,15,212,15,208,8,31,184,31,176,4,63,116,62,224,8, +127,32,125,200,32,254,192,254,128,33,253,161,247,96,67,253,3,252,0,135,250, +135,222,129,15,252,15,188,2,31,250,31,124,4,66,192,66,224,64,146,216,147, +64,209,96,1,97,130,242,199,224,35,240,95,228,63,232,38,161,1,0,1,1,48,2, +100,2,102,12,4,228,4,232,64,10,80,10,89,112,23,144,23,160,96,48,64,48,96, +128,104,0,104,65,128,217,128,218,2,1,203,1,204,18,3,188,3,190,36,7,200,7, +204,16,15,192,15,201,64,34,32,34,49,32,72,192,72,225,64,220,0,220,65,1,236, +1,236,140,4,96,4,97,34,9,20,9,22,108,19,4,19,8,56,38,128,38,138,193,224,1, +224,25,99,212,3,212,44,7,214,71,212,66,22,51,150,52,3,44,128,44,129,100,89, +214,89,216,10,153,2,153,4,189,52,5,52,8,202,114,42,114,48,244,230,84,230, +103,233,222,105,222,129,83,191,83,191,133,167,160,167,161,10,48,13,48,20,0, +32,26,192,26,208,64,56,128,56,192,192,113,64,113,129,1,251,129,252,2,44, +114,44,115,4,16,12,56,12,64,32,27,128,27,144,64,211,197,211,198,2,8,6,88,9, +164,16,17,216,17,224,47,245,1,120,0,255,1,129,2,83,1,134,2,84,1,142,1,221, +1,143,2,89,1,144,2,91,1,145,1,146,1,147,2,96,1,148,2,99,1,151,2,104,1,152, +1,153,1,157,2,114,1,159,2,117,1,167,1,168,1,174,2,136,1,183,2,146,1,241,1, +243,1,246,1,149,1,247,1,191,2,32,1,158,2,58,44,101,2,61,1,154,2,62,44,102, +2,67,1,128,2,68,2,137,2,69,2,140,3,118,3,119,3,134,3,172,3,140,3,204,3,207, +3,215,3,244,3,184,3,249,3,242,4,192,4,207,30,158,0,223,31,188,31,179,31, +204,31,195,31,236,31,229,31,252,31,243,33,38,3,201,33,42,0,107,33,43,0,229, +33,50,33,78,33,131,33,132,44,96,44,97,44,98,2,107,44,99,29,125,44,100,2, +125,44,109,2,81,44,110,2,113,44,111,2,80,44,112,2,82,167,125,29,121,167, +141,2,101,2,2,97,0,52,129,131,128, +}; +#line 1 "duk_util_bitdecoder.c" +/* + * Bitstream decoder. + */ + +/* include removed: duk_internal.h */ + +/* Decode 'bits' bits from the input stream (bits must be 1...24). + * When reading past bitstream end, zeroes are shifted in. The result + * is signed to match duk_bd_decode_flagged. + */ +DUK_INTERNAL duk_int32_t duk_bd_decode(duk_bitdecoder_ctx *ctx, duk_small_int_t bits) { + duk_small_int_t shift; + duk_uint32_t mask; + duk_uint32_t tmp; + + /* Note: cannot read more than 24 bits without possibly shifting top bits out. + * Fixable, but adds complexity. + */ + DUK_ASSERT(bits >= 1 && bits <= 24); + + while (ctx->currbits < bits) { +#if 0 + DUK_DDD(DUK_DDDPRINT("decode_bits: shift more data (bits=%ld, currbits=%ld)", + (long) bits, (long) ctx->currbits)); +#endif + ctx->currval <<= 8; + if (ctx->offset < ctx->length) { + /* If ctx->offset >= ctx->length, we "shift zeroes in" + * instead of croaking. + */ + ctx->currval |= ctx->data[ctx->offset++]; + } + ctx->currbits += 8; + } +#if 0 + DUK_DDD(DUK_DDDPRINT("decode_bits: bits=%ld, currbits=%ld, currval=0x%08lx", + (long) bits, (long) ctx->currbits, (unsigned long) ctx->currval)); +#endif + + /* Extract 'top' bits of currval; note that the extracted bits do not need + * to be cleared, we just ignore them on next round. + */ + shift = ctx->currbits - bits; + mask = (1 << bits) - 1; + tmp = (ctx->currval >> shift) & mask; + ctx->currbits = shift; /* remaining */ + +#if 0 + DUK_DDD(DUK_DDDPRINT("decode_bits: %ld bits -> 0x%08lx (%ld), currbits=%ld, currval=0x%08lx", + (long) bits, (unsigned long) tmp, (long) tmp, (long) ctx->currbits, (unsigned long) ctx->currval)); +#endif + + return tmp; +} + +DUK_INTERNAL duk_small_int_t duk_bd_decode_flag(duk_bitdecoder_ctx *ctx) { + return (duk_small_int_t) duk_bd_decode(ctx, 1); +} + +/* Decode a one-bit flag, and if set, decode a value of 'bits', otherwise return + * default value. Return value is signed so that negative marker value can be + * used by caller as a "not present" value. + */ +DUK_INTERNAL duk_int32_t duk_bd_decode_flagged(duk_bitdecoder_ctx *ctx, duk_small_int_t bits, duk_int32_t def_value) { + if (duk_bd_decode_flag(ctx)) { + return (duk_int32_t) duk_bd_decode(ctx, bits); + } else { + return def_value; + } +} +#line 1 "duk_util_bitencoder.c" +/* + * Bitstream encoder. + */ + +/* include removed: duk_internal.h */ + +DUK_INTERNAL void duk_be_encode(duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits) { + duk_uint8_t tmp; + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(ctx->currbits < 8); + + /* This limitation would be fixable but adds unnecessary complexity. */ + DUK_ASSERT(bits >= 1 && bits <= 24); + + ctx->currval = (ctx->currval << bits) | data; + ctx->currbits += bits; + + while (ctx->currbits >= 8) { + if (ctx->offset < ctx->length) { + tmp = (duk_uint8_t) ((ctx->currval >> (ctx->currbits - 8)) & 0xff); + ctx->data[ctx->offset++] = tmp; + } else { + /* If buffer has been exhausted, truncate bitstream */ + ctx->truncated = 1; + } + + ctx->currbits -= 8; + } +} + +DUK_INTERNAL void duk_be_finish(duk_bitencoder_ctx *ctx) { + duk_small_int_t npad; + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(ctx->currbits < 8); + + npad = (duk_small_int_t) (8 - ctx->currbits); + if (npad > 0) { + duk_be_encode(ctx, 0, npad); + } + DUK_ASSERT(ctx->currbits == 0); +} +#line 1 "duk_util_bufwriter.c" +/* + * Fast buffer writer with spare management. + */ + +/* include removed: duk_internal.h */ + +/* + * Macro support functions (use only macros in calling code) + */ + +DUK_LOCAL void duk__bw_update_ptrs(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t curr_offset, duk_size_t new_length) { + duk_uint8_t *p; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw_ctx != NULL); + DUK_UNREF(thr); + + p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, bw_ctx->buf); + DUK_ASSERT(p != NULL || (DUK_HBUFFER_DYNAMIC_GET_SIZE(bw_ctx->buf) == 0 && curr_offset == 0 && new_length == 0)); + bw_ctx->p = p + curr_offset; + bw_ctx->p_base = p; + bw_ctx->p_limit = p + new_length; +} + +DUK_INTERNAL void duk_bw_init(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_hbuffer_dynamic *h_buf) { + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw_ctx != NULL); + DUK_ASSERT(h_buf != NULL); + DUK_UNREF(thr); + + bw_ctx->buf = h_buf; + duk__bw_update_ptrs(thr, bw_ctx, 0, DUK_HBUFFER_DYNAMIC_GET_SIZE(h_buf)); +} + +DUK_INTERNAL void duk_bw_init_pushbuf(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t buf_size) { + duk_context *ctx; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw_ctx != NULL); + ctx = (duk_context *) thr; + + (void) duk_push_dynamic_buffer(ctx, buf_size); + bw_ctx->buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); + duk__bw_update_ptrs(thr, bw_ctx, 0, buf_size); +} + +/* Resize target buffer for requested size. Called by the macro only when the + * fast path test (= there is space) fails. + */ +DUK_INTERNAL duk_uint8_t *duk_bw_resize(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz) { + duk_size_t curr_off; + duk_size_t add_sz; + duk_size_t new_sz; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw_ctx != NULL); + + /* We could do this operation without caller updating bw_ctx->ptr, + * but by writing it back here we can share code better. + */ + + curr_off = (duk_size_t) (bw_ctx->p - bw_ctx->p_base); + add_sz = (curr_off >> DUK_BW_SPARE_SHIFT) + DUK_BW_SPARE_ADD; + new_sz = curr_off + sz + add_sz; + if (new_sz < curr_off) { + /* overflow */ + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_BUFFER_TOO_LONG); + return NULL; /* not reachable */ + } +#if 0 /* for manual torture testing: tight allocation, useful with valgrind */ + new_sz = curr_off + sz; +#endif + + /* This is important to ensure dynamic buffer data pointer is not + * NULL (which is possible if buffer size is zero), which in turn + * causes portability issues with e.g. memmove() and memcpy(). + */ + DUK_ASSERT(new_sz >= 1); + + DUK_DD(DUK_DDPRINT("resize bufferwriter from %ld to %ld (add_sz=%ld)", (long) curr_off, (long) new_sz, (long) add_sz)); + + duk_hbuffer_resize(thr, bw_ctx->buf, new_sz); + duk__bw_update_ptrs(thr, bw_ctx, curr_off, new_sz); + return bw_ctx->p; +} + +/* Make buffer compact, matching current written size. */ +DUK_INTERNAL void duk_bw_compact(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx) { + duk_size_t len; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw_ctx != NULL); + DUK_UNREF(thr); + + len = (duk_size_t) (bw_ctx->p - bw_ctx->p_base); + duk_hbuffer_resize(thr, bw_ctx->buf, len); + duk__bw_update_ptrs(thr, bw_ctx, len, len); +} + +DUK_INTERNAL void duk_bw_write_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len) { + duk_uint8_t *p_base; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + p_base = bw->p_base; + DUK_MEMCPY((void *) bw->p, + (const void *) (p_base + src_off), + (duk_size_t) len); + bw->p += len; +} + +DUK_INTERNAL void duk_bw_write_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + DUK_BW_ENSURE(thr, bw, len); + duk_bw_write_raw_slice(thr, bw, src_off, len); +} + +DUK_INTERNAL void duk_bw_insert_raw_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len) { + duk_uint8_t *p_base; + duk_size_t buf_sz, move_sz; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(buf != NULL); + DUK_UNREF(thr); + + p_base = bw->p_base; + buf_sz = bw->p - p_base; + move_sz = buf_sz - dst_off; + + DUK_ASSERT(p_base != NULL); /* buffer size is >= 1 */ + DUK_MEMMOVE((void *) (p_base + dst_off + len), + (const void *) (p_base + dst_off), + (duk_size_t) move_sz); + DUK_MEMCPY((void *) (p_base + dst_off), + (const void *) buf, + (duk_size_t) len); + bw->p += len; +} + +DUK_INTERNAL void duk_bw_insert_ensure_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(buf != NULL); + DUK_UNREF(thr); + + DUK_BW_ENSURE(thr, bw, len); + duk_bw_insert_raw_bytes(thr, bw, dst_off, buf, len); +} + +DUK_INTERNAL void duk_bw_insert_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len) { + duk_uint8_t *p_base; + duk_size_t buf_sz, move_sz; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + p_base = bw->p_base; + + /* Don't support "straddled" source now. */ + DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len); + + if (dst_off <= src_off) { + /* Target is before source. Source offset is expressed as + * a "before change" offset. Account for the memmove. + */ + src_off += len; + } + + buf_sz = bw->p - p_base; + move_sz = buf_sz - dst_off; + + DUK_ASSERT(p_base != NULL); /* buffer size is >= 1 */ + DUK_MEMMOVE((void *) (p_base + dst_off + len), + (const void *) (p_base + dst_off), + (duk_size_t) move_sz); + DUK_MEMCPY((void *) (p_base + dst_off), + (const void *) (p_base + src_off), + (duk_size_t) len); + bw->p += len; +} + +DUK_INTERNAL void duk_bw_insert_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + /* Don't support "straddled" source now. */ + DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len); + + DUK_BW_ENSURE(thr, bw, len); + duk_bw_insert_raw_slice(thr, bw, dst_off, src_off, len); +} + +DUK_INTERNAL duk_uint8_t *duk_bw_insert_raw_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) { + duk_uint8_t *p_base, *p_dst, *p_src; + duk_size_t buf_sz, move_sz; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + p_base = bw->p_base; + buf_sz = bw->p - p_base; + move_sz = buf_sz - off; + p_dst = p_base + off + len; + p_src = p_base + off; + DUK_MEMMOVE((void *) p_dst, (const void *) p_src, move_sz); + return p_src; /* point to start of 'reserved area' */ +} + +DUK_INTERNAL duk_uint8_t *duk_bw_insert_ensure_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + DUK_BW_ENSURE(thr, bw, len); + return duk_bw_insert_raw_area(thr, bw, off, len); +} + +DUK_INTERNAL void duk_bw_remove_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) { + duk_size_t move_sz; + + duk_uint8_t *p_base; + duk_uint8_t *p_src; + duk_uint8_t *p_dst; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(off + len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + p_base = bw->p_base; + p_dst = p_base + off; + p_src = p_dst + len; + move_sz = (duk_size_t) (bw->p - p_src); + DUK_MEMMOVE((void *) p_dst, + (const void *) p_src, + move_sz); + bw->p -= len; +} + +/* + * Macro support functions for reading/writing raw data. + * + * These are done using mempcy to ensure they're valid even for unaligned + * reads/writes on platforms where alignment counts. On x86 at least gcc + * is able to compile these into a bswap+mov. "Always inline" is used to + * ensure these macros compile to minimal code. + * + * Not really bufwriter related, but currently used together. + */ + +DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint16_t duk_raw_read_u16_be(duk_uint8_t **p) { + union { + duk_uint8_t b[2]; + duk_uint16_t x; + } u; + + DUK_MEMCPY((void *) u.b, (const void *) (*p), 2); + u.x = DUK_NTOH16(u.x); + *p += 2; + return u.x; +} + +DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint32_t duk_raw_read_u32_be(duk_uint8_t **p) { + union { + duk_uint8_t b[4]; + duk_uint32_t x; + } u; + + DUK_MEMCPY((void *) u.b, (const void *) (*p), 4); + u.x = DUK_NTOH32(u.x); + *p += 4; + return u.x; +} + +DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_raw_read_double_be(duk_uint8_t **p) { + duk_double_union du; + union { + duk_uint8_t b[4]; + duk_uint32_t x; + } u; + + DUK_MEMCPY((void *) u.b, (const void *) (*p), 4); + u.x = DUK_NTOH32(u.x); + du.ui[DUK_DBL_IDX_UI0] = u.x; + DUK_MEMCPY((void *) u.b, (const void *) (*p + 4), 4); + u.x = DUK_NTOH32(u.x); + du.ui[DUK_DBL_IDX_UI1] = u.x; + *p += 8; + + return du.d; +} + +DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u16_be(duk_uint8_t **p, duk_uint16_t val) { + union { + duk_uint8_t b[2]; + duk_uint16_t x; + } u; + + u.x = DUK_HTON16(val); + DUK_MEMCPY((void *) (*p), (const void *) u.b, 2); + *p += 2; +} + +DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u32_be(duk_uint8_t **p, duk_uint32_t val) { + union { + duk_uint8_t b[4]; + duk_uint32_t x; + } u; + + u.x = DUK_HTON32(val); + DUK_MEMCPY((void *) (*p), (const void *) u.b, 4); + *p += 4; +} + +DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_double_be(duk_uint8_t **p, duk_double_t val) { + duk_double_union du; + union { + duk_uint8_t b[4]; + duk_uint32_t x; + } u; + + du.d = val; + u.x = du.ui[DUK_DBL_IDX_UI0]; + u.x = DUK_HTON32(u.x); + DUK_MEMCPY((void *) (*p), (const void *) u.b, 4); + u.x = du.ui[DUK_DBL_IDX_UI1]; + u.x = DUK_HTON32(u.x); + DUK_MEMCPY((void *) (*p + 4), (const void *) u.b, 4); + *p += 8; +} +#line 1 "duk_util_hashbytes.c" +/* + * Hash function duk_util_hashbytes(). + * + * Currently, 32-bit MurmurHash2. + * + * Don't rely on specific hash values; hash function may be endianness + * dependent, for instance. + */ + +/* include removed: duk_internal.h */ + +/* 'magic' constants for Murmurhash2 */ +#define DUK__MAGIC_M ((duk_uint32_t) 0x5bd1e995UL) +#define DUK__MAGIC_R 24 + +DUK_INTERNAL duk_uint32_t duk_util_hashbytes(const duk_uint8_t *data, duk_size_t len, duk_uint32_t seed) { + duk_uint32_t h = seed ^ ((duk_uint32_t) len); + + while (len >= 4) { + /* Portability workaround is required for platforms without + * unaligned access. The replacement code emulates little + * endian access even on big endian architectures, which is + * OK as long as it is consistent for a build. + */ +#ifdef DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS + duk_uint32_t k = *((duk_uint32_t *) (void *) data); +#else + duk_uint32_t k = ((duk_uint32_t) data[0]) | + (((duk_uint32_t) data[1]) << 8) | + (((duk_uint32_t) data[2]) << 16) | + (((duk_uint32_t) data[3]) << 24); +#endif + + k *= DUK__MAGIC_M; + k ^= k >> DUK__MAGIC_R; + k *= DUK__MAGIC_M; + h *= DUK__MAGIC_M; + h ^= k; + data += 4; + len -= 4; + } + + switch (len) { + case 3: h ^= data[2] << 16; + case 2: h ^= data[1] << 8; + case 1: h ^= data[0]; + h *= DUK__MAGIC_M; + } + + h ^= h >> 13; + h *= DUK__MAGIC_M; + h ^= h >> 15; + + return h; +} +#line 1 "duk_util_tinyrandom.c" +/* + * A tiny random number generator. + * + * Currently used for Math.random(). + * + * http://www.woodmann.com/forum/archive/index.php/t-3100.html + */ + +/* include removed: duk_internal.h */ + +#define DUK__UPDATE_RND(rnd) do { \ + (rnd) += ((rnd) * (rnd)) | 0x05; \ + (rnd) = ((rnd) & 0xffffffffU); /* if duk_uint32_t is exactly 32 bits, this is a NOP */ \ + } while (0) + +#define DUK__RND_BIT(rnd) ((rnd) >> 31) /* only use the highest bit */ + +DUK_INTERNAL duk_uint32_t duk_util_tinyrandom_get_bits(duk_hthread *thr, duk_small_int_t n) { + duk_small_int_t i; + duk_uint32_t res = 0; + duk_uint32_t rnd; + + rnd = thr->heap->rnd_state; + + for (i = 0; i < n; i++) { + DUK__UPDATE_RND(rnd); + res <<= 1; + res += DUK__RND_BIT(rnd); + } + + thr->heap->rnd_state = rnd; + + return res; +} + +DUK_INTERNAL duk_double_t duk_util_tinyrandom_get_double(duk_hthread *thr) { + duk_double_t t; + duk_small_int_t n; + duk_uint32_t rnd; + + /* + * XXX: could make this a lot faster if we create the double memory + * representation directly. Feasible easily (must be uniform random). + */ + + rnd = thr->heap->rnd_state; + + n = 53; /* enough to cover the whole mantissa */ + t = 0.0; + + do { + DUK__UPDATE_RND(rnd); + t += DUK__RND_BIT(rnd); + t /= 2.0; + } while (--n); + + thr->heap->rnd_state = rnd; + + DUK_ASSERT(t >= (duk_double_t) 0.0); + DUK_ASSERT(t < (duk_double_t) 1.0); + + return t; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extern/duktape/duktape.h Mon Sep 28 13:18:14 2015 +0200 @@ -0,0 +1,1524 @@ +/* + * Duktape public API for Duktape 1.3.0. + * See the API reference for documentation on call semantics. + * The exposed API is inside the DUK_API_PUBLIC_H_INCLUDED + * include guard. Other parts of the header are Duktape + * internal and related to platform/compiler/feature detection. + * + * Git commit 675165f35ea3a5bac34ff4d0a58b007cc2f442dc (v1.3.0). + * + * See Duktape AUTHORS.rst and LICENSE.txt for copyright and + * licensing information. + */ + +/* LICENSE.txt */ +/* + * =============== + * Duktape license + * =============== + * + * (http://opensource.org/licenses/MIT) + * + * Copyright (c) 2013-2015 by Duktape authors (see AUTHORS.rst) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +/* AUTHORS.rst */ +/* + * =============== + * Duktape authors + * =============== + * + * Copyright + * ========= + * + * Duktape copyrights are held by its authors. Each author has a copyright + * to their contribution, and agrees to irrevocably license the contribution + * under the Duktape ``LICENSE.txt``. + * + * Authors + * ======= + * + * Please include an e-mail address, a link to your GitHub profile, or something + * similar to allow your contribution to be identified accurately. + * + * The following people have contributed code, website contents, or Wiki contents, + * and agreed to irrevocably license their contributions under the Duktape + * ``LICENSE.txt`` (in order of appearance): + * + * * Sami Vaarala <sami.vaarala@iki.fi> + * * Niki Dobrev + * * Andreas \u00d6man <andreas@lonelycoder.com> + * * L\u00e1szl\u00f3 Lang\u00f3 <llango.u-szeged@partner.samsung.com> + * * Legimet <legimet.calc@gmail.com> + * * Karl Skomski <karl@skomski.com> + * * Bruce Pascoe <fatcerberus1@gmail.com> + * + * Other contributions + * =================== + * + * The following people have contributed something other than code (e.g. reported + * bugs, provided ideas, etc; roughly in order of appearance): + * + * * Greg Burns + * * Anthony Rabine + * * Carlos Costa + * * Aur\u00e9lien Bouilland + * * Preet Desai (Pris Matic) + * * judofyr (http://www.reddit.com/user/judofyr) + * * Jason Woofenden + * * Micha\u0142 Przyby\u015b + * * Anthony Howe + * * Conrad Pankoff + * * Jim Schimpf + * * Rajaran Gaunker (https://github.com/zimbabao) + * * Andreas \u00d6man + * * Doug Sanden + * * Josh Engebretson (https://github.com/JoshEngebretson) + * * Remo Eichenberger (https://github.com/remoe) + * * Mamod Mehyar (https://github.com/mamod) + * * David Demelier (https://github.com/markand) + * * Tim Caswell (https://github.com/creationix) + * * Mitchell Blank Jr (https://github.com/mitchblank) + * * https://github.com/yushli + * * Seo Sanghyeon (https://github.com/sanxiyn) + * * Han ChoongWoo (https://github.com/tunz) + * * Joshua Peek (https://github.com/josh) + * * Bruce E. Pascoe (https://github.com/fatcerberus) + * * https://github.com/Kelledin + * * https://github.com/sstruchtrup + * * Michael Drake (https://github.com/tlsa) + * * https://github.com/chris-y + * + * If you are accidentally missing from this list, send me an e-mail + * (``sami.vaarala@iki.fi``) and I'll fix the omission. + */ + +#ifndef DUKTAPE_H_INCLUDED +#define DUKTAPE_H_INCLUDED + +#define DUK_SINGLE_FILE + +/* External duk_config.h provides platform/compiler/OS dependent + * typedefs and macros, and DUK_USE_xxx config options so that + * the rest of Duktape doesn't need to do any feature detection. + */ +#include "duk_config.h" + +/* + * BEGIN PUBLIC API + */ + +#ifndef DUK_API_PUBLIC_H_INCLUDED +#define DUK_API_PUBLIC_H_INCLUDED + +/* + * Avoid C++ name mangling + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Some defines forwarded from feature detection + */ + +#undef DUK_API_VARIADIC_MACROS +#ifdef DUK_USE_VARIADIC_MACROS +#define DUK_API_VARIADIC_MACROS +#endif + +#define DUK_API_NORETURN(decl) DUK_NORETURN(decl) + +/* + * Public API specific typedefs + * + * Many types are wrapped by Duktape for portability to rare platforms + * where e.g. 'int' is a 16-bit type. See practical typing discussion + * in Duktape web documentation. + */ + +struct duk_memory_functions; +struct duk_function_list_entry; +struct duk_number_list_entry; + +/* duk_context is now defined in duk_config.h because it may also be + * referenced there by prototypes. + */ +typedef struct duk_memory_functions duk_memory_functions; +typedef struct duk_function_list_entry duk_function_list_entry; +typedef struct duk_number_list_entry duk_number_list_entry; + +typedef duk_ret_t (*duk_c_function)(duk_context *ctx); +typedef void *(*duk_alloc_function) (void *udata, duk_size_t size); +typedef void *(*duk_realloc_function) (void *udata, void *ptr, duk_size_t size); +typedef void (*duk_free_function) (void *udata, void *ptr); +typedef void (*duk_fatal_function) (duk_context *ctx, duk_errcode_t code, const char *msg); +typedef void (*duk_decode_char_function) (void *udata, duk_codepoint_t codepoint); +typedef duk_codepoint_t (*duk_map_char_function) (void *udata, duk_codepoint_t codepoint); +typedef duk_ret_t (*duk_safe_call_function) (duk_context *ctx); +typedef duk_size_t (*duk_debug_read_function) (void *udata, char *buffer, duk_size_t length); +typedef duk_size_t (*duk_debug_write_function) (void *udata, const char *buffer, duk_size_t length); +typedef duk_size_t (*duk_debug_peek_function) (void *udata); +typedef void (*duk_debug_read_flush_function) (void *udata); +typedef void (*duk_debug_write_flush_function) (void *udata); +typedef void (*duk_debug_detached_function) (void *udata); + +struct duk_memory_functions { + duk_alloc_function alloc_func; + duk_realloc_function realloc_func; + duk_free_function free_func; + void *udata; +}; + +struct duk_function_list_entry { + const char *key; + duk_c_function value; + duk_idx_t nargs; +}; + +struct duk_number_list_entry { + const char *key; + duk_double_t value; +}; + +/* + * Constants + */ + +/* Duktape version, (major * 10000) + (minor * 100) + patch. Allows C code + * to #ifdef against Duktape API version. The same value is also available + * to Ecmascript code in Duktape.version. Unofficial development snapshots + * have 99 for patch level (e.g. 0.10.99 would be a development version + * after 0.10.0 but before the next official release). + */ +#define DUK_VERSION 10300L + +/* Git describe for Duktape build. Useful for non-official snapshot builds + * so that application code can easily log which Duktape snapshot was used. + * Not available in the Ecmascript environment. + */ +#define DUK_GIT_DESCRIBE "v1.3.0" + +/* Duktape debug protocol version used by this build. */ +#define DUK_DEBUG_PROTOCOL_VERSION 1 + +/* Used to represent invalid index; if caller uses this without checking, + * this index will map to a non-existent stack entry. Also used in some + * API calls as a marker to denote "no value". + */ +#define DUK_INVALID_INDEX DUK_IDX_MIN + +/* Indicates that a native function does not have a fixed number of args, + * and the argument stack should not be capped/extended at all. + */ +#define DUK_VARARGS ((duk_int_t) (-1)) + +/* Number of value stack entries (in addition to actual call arguments) + * guaranteed to be allocated on entry to a Duktape/C function. + */ +#define DUK_API_ENTRY_STACK 64 + +/* Value types, used by e.g. duk_get_type() */ +#define DUK_TYPE_NONE 0 /* no value, e.g. invalid index */ +#define DUK_TYPE_UNDEFINED 1 /* Ecmascript undefined */ +#define DUK_TYPE_NULL 2 /* Ecmascript null */ +#define DUK_TYPE_BOOLEAN 3 /* Ecmascript boolean: 0 or 1 */ +#define DUK_TYPE_NUMBER 4 /* Ecmascript number: double */ +#define DUK_TYPE_STRING 5 /* Ecmascript string: CESU-8 / extended UTF-8 encoded */ +#define DUK_TYPE_OBJECT 6 /* Ecmascript object: includes objects, arrays, functions, threads */ +#define DUK_TYPE_BUFFER 7 /* fixed or dynamic, garbage collected byte buffer */ +#define DUK_TYPE_POINTER 8 /* raw void pointer */ +#define DUK_TYPE_LIGHTFUNC 9 /* lightweight function pointer */ + +/* Value mask types, used by e.g. duk_get_type_mask() */ +#define DUK_TYPE_MASK_NONE (1 << DUK_TYPE_NONE) +#define DUK_TYPE_MASK_UNDEFINED (1 << DUK_TYPE_UNDEFINED) +#define DUK_TYPE_MASK_NULL (1 << DUK_TYPE_NULL) +#define DUK_TYPE_MASK_BOOLEAN (1 << DUK_TYPE_BOOLEAN) +#define DUK_TYPE_MASK_NUMBER (1 << DUK_TYPE_NUMBER) +#define DUK_TYPE_MASK_STRING (1 << DUK_TYPE_STRING) +#define DUK_TYPE_MASK_OBJECT (1 << DUK_TYPE_OBJECT) +#define DUK_TYPE_MASK_BUFFER (1 << DUK_TYPE_BUFFER) +#define DUK_TYPE_MASK_POINTER (1 << DUK_TYPE_POINTER) +#define DUK_TYPE_MASK_LIGHTFUNC (1 << DUK_TYPE_LIGHTFUNC) +#define DUK_TYPE_MASK_THROW (1 << 10) /* internal flag value: throw if mask doesn't match */ + +/* Coercion hints */ +#define DUK_HINT_NONE 0 /* prefer number, unless input is a Date, in which + * case prefer string (E5 Section 8.12.8) + */ +#define DUK_HINT_STRING 1 /* prefer string */ +#define DUK_HINT_NUMBER 2 /* prefer number */ + +/* Enumeration flags for duk_enum() */ +#define DUK_ENUM_INCLUDE_NONENUMERABLE (1 << 0) /* enumerate non-numerable properties in addition to enumerable */ +#define DUK_ENUM_INCLUDE_INTERNAL (1 << 1) /* enumerate internal properties (regardless of enumerability) */ +#define DUK_ENUM_OWN_PROPERTIES_ONLY (1 << 2) /* don't walk prototype chain, only check own properties */ +#define DUK_ENUM_ARRAY_INDICES_ONLY (1 << 3) /* only enumerate array indices */ +#define DUK_ENUM_SORT_ARRAY_INDICES (1 << 4) /* sort array indices, use with DUK_ENUM_ARRAY_INDICES_ONLY */ +#define DUK_ENUM_NO_PROXY_BEHAVIOR (1 << 5) /* enumerate a proxy object itself without invoking proxy behavior */ + +/* Compilation flags for duk_compile() and duk_eval() */ +#define DUK_COMPILE_EVAL (1 << 0) /* compile eval code (instead of global code) */ +#define DUK_COMPILE_FUNCTION (1 << 1) /* compile function code (instead of global code) */ +#define DUK_COMPILE_STRICT (1 << 2) /* use strict (outer) context for global, eval, or function code */ +#define DUK_COMPILE_SAFE (1 << 3) /* (internal) catch compilation errors */ +#define DUK_COMPILE_NORESULT (1 << 4) /* (internal) omit eval result */ +#define DUK_COMPILE_NOSOURCE (1 << 5) /* (internal) no source string on stack */ +#define DUK_COMPILE_STRLEN (1 << 6) /* (internal) take strlen() of src_buffer (avoids double evaluation in macro) */ + +/* Flags for duk_def_prop() and its variants */ +#define DUK_DEFPROP_WRITABLE (1 << 0) /* set writable (effective if DUK_DEFPROP_HAVE_WRITABLE set) */ +#define DUK_DEFPROP_ENUMERABLE (1 << 1) /* set enumerable (effective if DUK_DEFPROP_HAVE_ENUMERABLE set) */ +#define DUK_DEFPROP_CONFIGURABLE (1 << 2) /* set configurable (effective if DUK_DEFPROP_HAVE_CONFIGURABLE set) */ +#define DUK_DEFPROP_HAVE_WRITABLE (1 << 3) /* set/clear writable */ +#define DUK_DEFPROP_HAVE_ENUMERABLE (1 << 4) /* set/clear enumerable */ +#define DUK_DEFPROP_HAVE_CONFIGURABLE (1 << 5) /* set/clear configurable */ +#define DUK_DEFPROP_HAVE_VALUE (1 << 6) /* set value (given on value stack) */ +#define DUK_DEFPROP_HAVE_GETTER (1 << 7) /* set getter (given on value stack) */ +#define DUK_DEFPROP_HAVE_SETTER (1 << 8) /* set setter (given on value stack) */ +#define DUK_DEFPROP_FORCE (1 << 9) /* force change if possible, may still fail for e.g. virtual properties */ + +/* Flags for duk_push_thread_raw() */ +#define DUK_THREAD_NEW_GLOBAL_ENV (1 << 0) /* create a new global environment */ + +/* Flags for duk_push_string_file_raw() */ +#define DUK_STRING_PUSH_SAFE (1 << 0) /* no error if file does not exist */ + +/* Duktape specific error codes */ +#define DUK_ERR_NONE 0 /* no error (e.g. from duk_get_error_code()) */ +#define DUK_ERR_UNIMPLEMENTED_ERROR 50 /* UnimplementedError */ +#define DUK_ERR_UNSUPPORTED_ERROR 51 /* UnsupportedError */ +#define DUK_ERR_INTERNAL_ERROR 52 /* InternalError */ +#define DUK_ERR_ALLOC_ERROR 53 /* AllocError */ +#define DUK_ERR_ASSERTION_ERROR 54 /* AssertionError */ +#define DUK_ERR_API_ERROR 55 /* APIError */ +#define DUK_ERR_UNCAUGHT_ERROR 56 /* UncaughtError */ + +/* Ecmascript E5 specification error codes */ +#define DUK_ERR_ERROR 100 /* Error */ +#define DUK_ERR_EVAL_ERROR 101 /* EvalError */ +#define DUK_ERR_RANGE_ERROR 102 /* RangeError */ +#define DUK_ERR_REFERENCE_ERROR 103 /* ReferenceError */ +#define DUK_ERR_SYNTAX_ERROR 104 /* SyntaxError */ +#define DUK_ERR_TYPE_ERROR 105 /* TypeError */ +#define DUK_ERR_URI_ERROR 106 /* URIError */ + +/* Return codes for C functions (shortcut for throwing an error) */ +#define DUK_RET_UNIMPLEMENTED_ERROR (-DUK_ERR_UNIMPLEMENTED_ERROR) +#define DUK_RET_UNSUPPORTED_ERROR (-DUK_ERR_UNSUPPORTED_ERROR) +#define DUK_RET_INTERNAL_ERROR (-DUK_ERR_INTERNAL_ERROR) +#define DUK_RET_ALLOC_ERROR (-DUK_ERR_ALLOC_ERROR) +#define DUK_RET_ASSERTION_ERROR (-DUK_ERR_ASSERTION_ERROR) +#define DUK_RET_API_ERROR (-DUK_ERR_API_ERROR) +#define DUK_RET_UNCAUGHT_ERROR (-DUK_ERR_UNCAUGHT_ERROR) +#define DUK_RET_ERROR (-DUK_ERR_ERROR) +#define DUK_RET_EVAL_ERROR (-DUK_ERR_EVAL_ERROR) +#define DUK_RET_RANGE_ERROR (-DUK_ERR_RANGE_ERROR) +#define DUK_RET_REFERENCE_ERROR (-DUK_ERR_REFERENCE_ERROR) +#define DUK_RET_SYNTAX_ERROR (-DUK_ERR_SYNTAX_ERROR) +#define DUK_RET_TYPE_ERROR (-DUK_ERR_TYPE_ERROR) +#define DUK_RET_URI_ERROR (-DUK_ERR_URI_ERROR) + +/* Return codes for protected calls (duk_safe_call(), duk_pcall()). */ +#define DUK_EXEC_SUCCESS 0 +#define DUK_EXEC_ERROR 1 + +/* Log levels */ +#define DUK_LOG_TRACE 0 +#define DUK_LOG_DEBUG 1 +#define DUK_LOG_INFO 2 +#define DUK_LOG_WARN 3 +#define DUK_LOG_ERROR 4 +#define DUK_LOG_FATAL 5 + +/* + * If no variadic macros, __FILE__ and __LINE__ are passed through globals + * which is ugly and not thread safe. + */ + +#ifndef DUK_API_VARIADIC_MACROS +DUK_EXTERNAL_DECL const char *duk_api_global_filename; +DUK_EXTERNAL_DECL duk_int_t duk_api_global_line; +#endif + +/* + * Context management + */ + +DUK_EXTERNAL_DECL +duk_context *duk_create_heap(duk_alloc_function alloc_func, + duk_realloc_function realloc_func, + duk_free_function free_func, + void *heap_udata, + duk_fatal_function fatal_handler); +DUK_EXTERNAL_DECL void duk_destroy_heap(duk_context *ctx); + +#define duk_create_heap_default() \ + duk_create_heap(NULL, NULL, NULL, NULL, NULL) + +/* + * Memory management + * + * Raw functions have no side effects (cannot trigger GC). + */ + +DUK_EXTERNAL_DECL void *duk_alloc_raw(duk_context *ctx, duk_size_t size); +DUK_EXTERNAL_DECL void duk_free_raw(duk_context *ctx, void *ptr); +DUK_EXTERNAL_DECL void *duk_realloc_raw(duk_context *ctx, void *ptr, duk_size_t size); +DUK_EXTERNAL_DECL void *duk_alloc(duk_context *ctx, duk_size_t size); +DUK_EXTERNAL_DECL void duk_free(duk_context *ctx, void *ptr); +DUK_EXTERNAL_DECL void *duk_realloc(duk_context *ctx, void *ptr, duk_size_t size); +DUK_EXTERNAL_DECL void duk_get_memory_functions(duk_context *ctx, duk_memory_functions *out_funcs); +DUK_EXTERNAL_DECL void duk_gc(duk_context *ctx, duk_uint_t flags); + +/* + * Error handling + */ + +DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_throw(duk_context *ctx)); +DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char *err_msg)); + +DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_error_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...)); + +#ifdef DUK_API_VARIADIC_MACROS +#define duk_error(ctx,err_code,...) \ + duk_error_raw((ctx), (duk_errcode_t) (err_code), (const char *) (__FILE__), (duk_int_t) (__LINE__), __VA_ARGS__) +#else +DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_error_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...)); +/* One problem with this macro is that expressions like the following fail + * to compile: "(void) duk_error(...)". But because duk_error() is noreturn, + * they make little sense anyway. + */ +#define duk_error \ + (duk_api_global_filename = (const char *) (__FILE__), \ + duk_api_global_line = (duk_int_t) (__LINE__), \ + duk_error_stash) /* last value is func pointer, arguments follow in parens */ +#endif + +DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_error_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap)); +#define duk_error_va(ctx,err_code,fmt,ap) \ + duk_error_va_raw((ctx), (duk_errcode_t) (err_code), (const char *) (__FILE__), (duk_int_t) (__LINE__), (fmt), (ap)) + +/* + * Other state related functions + */ + +DUK_EXTERNAL_DECL duk_bool_t duk_is_strict_call(duk_context *ctx); +DUK_EXTERNAL_DECL duk_bool_t duk_is_constructor_call(duk_context *ctx); + +/* + * Stack management + */ + +DUK_EXTERNAL_DECL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_require_valid_index(duk_context *ctx, duk_idx_t index); + +DUK_EXTERNAL_DECL duk_idx_t duk_get_top(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_set_top(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_idx_t duk_get_top_index(duk_context *ctx); +DUK_EXTERNAL_DECL duk_idx_t duk_require_top_index(duk_context *ctx); + +/* Although extra/top could be an unsigned type here, using a signed type + * makes the API more robust to calling code calculation errors or corner + * cases (where caller might occasionally come up with negative values). + * Negative values are treated as zero, which is better than casting them + * to a large unsigned number. (This principle is used elsewhere in the + * API too.) + */ +DUK_EXTERNAL_DECL duk_bool_t duk_check_stack(duk_context *ctx, duk_idx_t extra); +DUK_EXTERNAL_DECL void duk_require_stack(duk_context *ctx, duk_idx_t extra); +DUK_EXTERNAL_DECL duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top); +DUK_EXTERNAL_DECL void duk_require_stack_top(duk_context *ctx, duk_idx_t top); + +/* + * Stack manipulation (other than push/pop) + */ + +DUK_EXTERNAL_DECL void duk_swap(duk_context *ctx, duk_idx_t index1, duk_idx_t index2); +DUK_EXTERNAL_DECL void duk_swap_top(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_dup(duk_context *ctx, duk_idx_t from_index); +DUK_EXTERNAL_DECL void duk_dup_top(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_insert(duk_context *ctx, duk_idx_t to_index); +DUK_EXTERNAL_DECL void duk_replace(duk_context *ctx, duk_idx_t to_index); +DUK_EXTERNAL_DECL void duk_copy(duk_context *ctx, duk_idx_t from_index, duk_idx_t to_index); +DUK_EXTERNAL_DECL void duk_remove(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_xcopymove_raw(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count, duk_bool_t is_copy); + +#define duk_xmove_top(to_ctx,from_ctx,count) \ + duk_xcopymove_raw((to_ctx), (from_ctx), (count), 0 /*is_copy*/) +#define duk_xcopy_top(to_ctx,from_ctx,count) \ + duk_xcopymove_raw((to_ctx), (from_ctx), (count), 1 /*is_copy*/) + +/* + * Push operations + * + * Push functions return the absolute (relative to bottom of frame) + * position of the pushed value for convenience. + * + * Note: duk_dup() is technically a push. + */ + +DUK_EXTERNAL_DECL void duk_push_undefined(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_push_null(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_push_boolean(duk_context *ctx, duk_bool_t val); +DUK_EXTERNAL_DECL void duk_push_true(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_push_false(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_push_number(duk_context *ctx, duk_double_t val); +DUK_EXTERNAL_DECL void duk_push_nan(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_push_int(duk_context *ctx, duk_int_t val); +DUK_EXTERNAL_DECL void duk_push_uint(duk_context *ctx, duk_uint_t val); +DUK_EXTERNAL_DECL const char *duk_push_string(duk_context *ctx, const char *str); +DUK_EXTERNAL_DECL const char *duk_push_lstring(duk_context *ctx, const char *str, duk_size_t len); +DUK_EXTERNAL_DECL void duk_push_pointer(duk_context *ctx, void *p); +DUK_EXTERNAL_DECL const char *duk_push_sprintf(duk_context *ctx, const char *fmt, ...); +DUK_EXTERNAL_DECL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap); + +DUK_EXTERNAL_DECL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags); +#define duk_push_string_file(ctx,path) \ + duk_push_string_file_raw((ctx), (path), 0) + +DUK_EXTERNAL_DECL void duk_push_this(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_push_current_function(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_push_current_thread(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_push_global_object(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_push_heap_stash(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_push_global_stash(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_push_thread_stash(duk_context *ctx, duk_context *target_ctx); + +DUK_EXTERNAL_DECL duk_idx_t duk_push_object(duk_context *ctx); +DUK_EXTERNAL_DECL duk_idx_t duk_push_array(duk_context *ctx); +DUK_EXTERNAL_DECL duk_idx_t duk_push_c_function(duk_context *ctx, duk_c_function func, duk_idx_t nargs); +DUK_EXTERNAL_DECL duk_idx_t duk_push_c_lightfunc(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_idx_t length, duk_int_t magic); +DUK_EXTERNAL_DECL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags); + +#define duk_push_thread(ctx) \ + duk_push_thread_raw((ctx), 0 /*flags*/) + +#define duk_push_thread_new_globalenv(ctx) \ + duk_push_thread_raw((ctx), DUK_THREAD_NEW_GLOBAL_ENV /*flags*/) + +DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...); + +#ifdef DUK_API_VARIADIC_MACROS +#define duk_push_error_object(ctx,err_code,...) \ + duk_push_error_object_raw((ctx), (err_code), (const char *) (__FILE__), (duk_int_t) (__LINE__), __VA_ARGS__) +#else +DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...); +/* Note: parentheses are required so that the comma expression works in assignments. */ +#define duk_push_error_object \ + (duk_api_global_filename = (const char *) (__FILE__), \ + duk_api_global_line = (duk_int_t) (__LINE__), \ + duk_push_error_object_stash) /* last value is func pointer, arguments follow in parens */ +#endif + +DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap); +#define duk_push_error_object_va(ctx,err_code,fmt,ap) \ + duk_push_error_object_va_raw((ctx), (err_code), (const char *) (__FILE__), (duk_int_t) (__LINE__), (fmt), (ap)) + +#define DUK_BUF_FLAG_DYNAMIC (1 << 0) /* internal flag: dynamic buffer */ +#define DUK_BUF_FLAG_EXTERNAL (1 << 1) /* internal flag: external buffer */ +#define DUK_BUF_FLAG_NOZERO (1 << 2) /* internal flag: don't zero allocated buffer */ + +DUK_EXTERNAL_DECL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_small_uint_t flags); + +#define duk_push_buffer(ctx,size,dynamic) \ + duk_push_buffer_raw((ctx), (size), (dynamic) ? DUK_BUF_FLAG_DYNAMIC : 0); +#define duk_push_fixed_buffer(ctx,size) \ + duk_push_buffer_raw((ctx), (size), 0 /*flags*/) +#define duk_push_dynamic_buffer(ctx,size) \ + duk_push_buffer_raw((ctx), (size), DUK_BUF_FLAG_DYNAMIC /*flags*/) +#define duk_push_external_buffer(ctx) \ + ((void) duk_push_buffer_raw((ctx), 0, DUK_BUF_FLAG_DYNAMIC | DUK_BUF_FLAG_EXTERNAL)) + +#define DUK_BUFOBJ_CREATE_ARRBUF (1 << 4) /* internal flag: create backing ArrayBuffer; keep in one byte */ +#define DUK_BUFOBJ_DUKTAPE_BUFFER 0 +#define DUK_BUFOBJ_NODEJS_BUFFER 1 +#define DUK_BUFOBJ_ARRAYBUFFER 2 +#define DUK_BUFOBJ_DATAVIEW (3 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_INT8ARRAY (4 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_UINT8ARRAY (5 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_UINT8CLAMPEDARRAY (6 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_INT16ARRAY (7 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_UINT16ARRAY (8 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_INT32ARRAY (9 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_UINT32ARRAY (10 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_FLOAT32ARRAY (11 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_FLOAT64ARRAY (12 | DUK_BUFOBJ_CREATE_ARRBUF) + +DUK_EXTERNAL_DECL void duk_push_buffer_object(duk_context *ctx, duk_idx_t idx_buffer, duk_size_t byte_offset, duk_size_t byte_length, duk_uint_t flags); + +DUK_EXTERNAL_DECL duk_idx_t duk_push_heapptr(duk_context *ctx, void *ptr); + +/* + * Pop operations + */ + +DUK_EXTERNAL_DECL void duk_pop(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_pop_n(duk_context *ctx, duk_idx_t count); +DUK_EXTERNAL_DECL void duk_pop_2(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_pop_3(duk_context *ctx); + +/* + * Type checks + * + * duk_is_none(), which would indicate whether index it outside of stack, + * is not needed; duk_is_valid_index() gives the same information. + */ + +DUK_EXTERNAL_DECL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t index, duk_int_t type); +DUK_EXTERNAL_DECL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t index, duk_uint_t mask); + +DUK_EXTERNAL_DECL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_null_or_undefined(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_lightfunc(duk_context *ctx, duk_idx_t index); + +DUK_EXTERNAL_DECL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_c_function(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index); + +DUK_EXTERNAL_DECL duk_bool_t duk_is_callable(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_external_buffer(duk_context *ctx, duk_idx_t index); + +#define duk_is_primitive(ctx,index) \ + duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_UNDEFINED | \ + DUK_TYPE_MASK_NULL | \ + DUK_TYPE_MASK_BOOLEAN | \ + DUK_TYPE_MASK_NUMBER | \ + DUK_TYPE_MASK_STRING | \ + DUK_TYPE_MASK_BUFFER | \ + DUK_TYPE_MASK_POINTER | \ + DUK_TYPE_MASK_LIGHTFUNC) + +#define duk_is_object_coercible(ctx,index) \ + duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \ + DUK_TYPE_MASK_NUMBER | \ + DUK_TYPE_MASK_STRING | \ + DUK_TYPE_MASK_OBJECT | \ + DUK_TYPE_MASK_BUFFER | \ + DUK_TYPE_MASK_POINTER | \ + DUK_TYPE_MASK_LIGHTFUNC) + +DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index); +#define duk_is_error(ctx,index) \ + (duk_get_error_code((ctx), (index)) != 0) + +/* + * Get operations: no coercion, returns default value for invalid + * indices and invalid value types. + * + * duk_get_undefined() and duk_get_null() would be pointless and + * are not included. + */ + +DUK_EXTERNAL_DECL duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_int_t duk_get_int(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL const char *duk_get_string(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL const char *duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len); +DUK_EXTERNAL_DECL void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size); +DUK_EXTERNAL_DECL void *duk_get_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size); +DUK_EXTERNAL_DECL void *duk_get_pointer(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_context *duk_get_context(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void *duk_get_heapptr(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index); + +/* + * Require operations: no coercion, throw error if index or type + * is incorrect. No defaulting. + */ + +#define duk_require_type_mask(ctx,index,mask) \ + ((void) duk_check_type_mask((ctx), (index), (mask) | DUK_TYPE_MASK_THROW)) + +DUK_EXTERNAL_DECL void duk_require_undefined(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_require_null(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_int_t duk_require_int(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL const char *duk_require_string(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL const char *duk_require_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len); +DUK_EXTERNAL_DECL void *duk_require_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size); +DUK_EXTERNAL_DECL void *duk_require_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size); +DUK_EXTERNAL_DECL void *duk_require_pointer(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index); + +#define duk_require_object_coercible(ctx,index) \ + ((void) duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \ + DUK_TYPE_MASK_NUMBER | \ + DUK_TYPE_MASK_STRING | \ + DUK_TYPE_MASK_OBJECT | \ + DUK_TYPE_MASK_BUFFER | \ + DUK_TYPE_MASK_POINTER | \ + DUK_TYPE_MASK_LIGHTFUNC | \ + DUK_TYPE_MASK_THROW)) + +/* + * Coercion operations: in-place coercion, return coerced value where + * applicable. If index is invalid, throw error. Some coercions may + * throw an expected error (e.g. from a toString() or valueOf() call) + * or an internal error (e.g. from out of memory). + */ + +DUK_EXTERNAL_DECL void duk_to_undefined(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_to_null(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_int_t duk_to_int(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL const char *duk_to_string(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL const char *duk_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len); +DUK_EXTERNAL_DECL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_uint_t flags); +DUK_EXTERNAL_DECL void *duk_to_pointer(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_to_object(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int_t hint); +DUK_EXTERNAL_DECL void duk_to_primitive(duk_context *ctx, duk_idx_t index, duk_int_t hint); + +#define DUK_BUF_MODE_FIXED 0 /* internal: request fixed buffer result */ +#define DUK_BUF_MODE_DYNAMIC 1 /* internal: request dynamic buffer result */ +#define DUK_BUF_MODE_DONTCARE 2 /* internal: don't care about fixed/dynamic nature */ + +#define duk_to_buffer(ctx,index,out_size) \ + duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DONTCARE) +#define duk_to_fixed_buffer(ctx,index,out_size) \ + duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_FIXED) +#define duk_to_dynamic_buffer(ctx,index,out_size) \ + duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DYNAMIC) + +/* safe variants of a few coercion operations */ +DUK_EXTERNAL_DECL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len); +#define duk_safe_to_string(ctx,index) \ + duk_safe_to_lstring((ctx), (index), NULL) + +/* + * Misc conversion + */ + +DUK_EXTERNAL_DECL const char *duk_base64_encode(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_base64_decode(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL const char *duk_hex_encode(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_hex_decode(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL const char *duk_json_encode(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_json_decode(duk_context *ctx, duk_idx_t index); + +/* + * Buffer + */ + +DUK_EXTERNAL_DECL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size); +DUK_EXTERNAL_DECL void *duk_steal_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size); +DUK_EXTERNAL_DECL void duk_config_buffer(duk_context *ctx, duk_idx_t index, void *ptr, duk_size_t len); + +/* + * Property access + * + * The basic function assumes key is on stack. The _string variant takes + * a C string as a property name, while the _index variant takes an array + * index as a property name (e.g. 123 is equivalent to the key "123"). + */ + +DUK_EXTERNAL_DECL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_index); +DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key); +DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index); +DUK_EXTERNAL_DECL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_index); +DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key); +DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index); +DUK_EXTERNAL_DECL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index); +DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key); +DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index); +DUK_EXTERNAL_DECL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index); +DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key); +DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index); +DUK_EXTERNAL_DECL void duk_def_prop(duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags); + +DUK_EXTERNAL_DECL duk_bool_t duk_get_global_string(duk_context *ctx, const char *key); +DUK_EXTERNAL_DECL duk_bool_t duk_put_global_string(duk_context *ctx, const char *key); + +/* + * Object prototype + */ + +DUK_EXTERNAL_DECL void duk_get_prototype(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_set_prototype(duk_context *ctx, duk_idx_t index); + +/* + * Object finalizer + */ + +DUK_EXTERNAL_DECL void duk_get_finalizer(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_set_finalizer(duk_context *ctx, duk_idx_t index); + +/* + * Global object + */ + +DUK_EXTERNAL_DECL void duk_set_global_object(duk_context *ctx); + +/* + * Duktape/C function magic value + */ + +DUK_EXTERNAL_DECL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_set_magic(duk_context *ctx, duk_idx_t index, duk_int_t magic); +DUK_EXTERNAL_DECL duk_int_t duk_get_current_magic(duk_context *ctx); + +/* + * Module helpers: put multiple function or constant properties + */ + +DUK_EXTERNAL_DECL void duk_put_function_list(duk_context *ctx, duk_idx_t obj_index, const duk_function_list_entry *funcs); +DUK_EXTERNAL_DECL void duk_put_number_list(duk_context *ctx, duk_idx_t obj_index, const duk_number_list_entry *numbers); + +/* + * Variable access + */ + +/* XXX: These calls are incomplete and not usable now. They are not (yet) + * part of the public API. + */ +DUK_EXTERNAL_DECL void duk_get_var(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_put_var(duk_context *ctx); +DUK_EXTERNAL_DECL duk_bool_t duk_del_var(duk_context *ctx); +DUK_EXTERNAL_DECL duk_bool_t duk_has_var(duk_context *ctx); + +/* + * Object operations + */ + +DUK_EXTERNAL_DECL void duk_compact(duk_context *ctx, duk_idx_t obj_index); +DUK_EXTERNAL_DECL void duk_enum(duk_context *ctx, duk_idx_t obj_index, duk_uint_t enum_flags); +DUK_EXTERNAL_DECL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_index, duk_bool_t get_value); + +/* + * String manipulation + */ + +DUK_EXTERNAL_DECL void duk_concat(duk_context *ctx, duk_idx_t count); +DUK_EXTERNAL_DECL void duk_join(duk_context *ctx, duk_idx_t count); +DUK_EXTERNAL_DECL void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decode_char_function callback, void *udata); +DUK_EXTERNAL_DECL void duk_map_string(duk_context *ctx, duk_idx_t index, duk_map_char_function callback, void *udata); +DUK_EXTERNAL_DECL void duk_substring(duk_context *ctx, duk_idx_t index, duk_size_t start_char_offset, duk_size_t end_char_offset); +DUK_EXTERNAL_DECL void duk_trim(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t index, duk_size_t char_offset); + +/* + * Ecmascript operators + */ + +DUK_EXTERNAL_DECL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2); +DUK_EXTERNAL_DECL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2); +DUK_EXTERNAL_DECL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t index1, duk_idx_t index2); + +/* + * Function (method) calls + */ + +DUK_EXTERNAL_DECL void duk_call(duk_context *ctx, duk_idx_t nargs); +DUK_EXTERNAL_DECL void duk_call_method(duk_context *ctx, duk_idx_t nargs); +DUK_EXTERNAL_DECL void duk_call_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs); +DUK_EXTERNAL_DECL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs); +DUK_EXTERNAL_DECL duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs); +DUK_EXTERNAL_DECL duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs); +DUK_EXTERNAL_DECL void duk_new(duk_context *ctx, duk_idx_t nargs); +DUK_EXTERNAL_DECL duk_int_t duk_pnew(duk_context *ctx, duk_idx_t nargs); +DUK_EXTERNAL_DECL duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function func, duk_idx_t nargs, duk_idx_t nrets); + +/* + * Thread management + */ + +/* There are currently no native functions to yield/resume, due to the internal + * limitations on coroutine handling. These will be added later. + */ + +/* + * Compilation and evaluation + */ + +DUK_EXTERNAL_DECL duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags); +DUK_EXTERNAL_DECL duk_int_t duk_compile_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags); + +/* plain */ +#define duk_eval(ctx) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + (void) duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL)) + +#define duk_eval_noresult(ctx) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + (void) duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT)) + +#define duk_peval(ctx) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE)) + +#define duk_peval_noresult(ctx) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT)) + +#define duk_compile(ctx,flags) \ + ((void) duk_compile_raw((ctx), NULL, 0, (flags))) + +#define duk_pcompile(ctx,flags) \ + (duk_compile_raw((ctx), NULL, 0, (flags) | DUK_COMPILE_SAFE)) + +/* string */ +#define duk_eval_string(ctx,src) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + (void) duk_eval_raw((ctx), (src), 0, DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN)) + +#define duk_eval_string_noresult(ctx,src) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + (void) duk_eval_raw((ctx), (src), 0, DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT)) + +#define duk_peval_string(ctx,src) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + duk_eval_raw((ctx), (src), 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN)) + +#define duk_peval_string_noresult(ctx,src) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + duk_eval_raw((ctx), (src), 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT)) + +#define duk_compile_string(ctx,flags,src) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + (void) duk_compile_raw((ctx), (src), 0, (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN)) + +#define duk_compile_string_filename(ctx,flags,src) \ + ((void) duk_compile_raw((ctx), (src), 0, (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN)) + +#define duk_pcompile_string(ctx,flags,src) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + duk_compile_raw((ctx), (src), 0, (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN)) + +#define duk_pcompile_string_filename(ctx,flags,src) \ + (duk_compile_raw((ctx), (src), 0, (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN)) + +/* lstring */ +#define duk_eval_lstring(ctx,buf,len) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + (void) duk_eval_raw((ctx), buf, len, DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE)) + +#define duk_eval_lstring_noresult(ctx,buf,len) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + (void) duk_eval_raw((ctx), buf, len, DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT)) + +#define duk_peval_lstring(ctx,buf,len) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + duk_eval_raw((ctx), buf, len, DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_SAFE)) + +#define duk_peval_lstring_noresult(ctx,buf,len) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + duk_eval_raw((ctx), buf, len, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT)) + +#define duk_compile_lstring(ctx,flags,buf,len) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + (void) duk_compile_raw((ctx), buf, len, (flags) | DUK_COMPILE_NOSOURCE)) + +#define duk_compile_lstring_filename(ctx,flags,buf,len) \ + ((void) duk_compile_raw((ctx), buf, len, (flags) | DUK_COMPILE_NOSOURCE)) + +#define duk_pcompile_lstring(ctx,flags,buf,len) \ + ((void) duk_push_string((ctx), (const char *) (__FILE__)), \ + duk_compile_raw((ctx), buf, len, (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE)) + +#define duk_pcompile_lstring_filename(ctx,flags,buf,len) \ + (duk_compile_raw((ctx), buf, len, (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE)) + +/* file */ +#define duk_eval_file(ctx,path) \ + ((void) duk_push_string_file_raw((ctx), (path), 0), \ + (void) duk_push_string((ctx), (path)), \ + (void) duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL)) + +#define duk_eval_file_noresult(ctx,path) \ + ((void) duk_push_string_file_raw((ctx), (path), 0), \ + (void) duk_push_string((ctx), (path)), \ + (void) duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT)) + +#define duk_peval_file(ctx,path) \ + ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \ + (void) duk_push_string((ctx), (path)), \ + duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE)) + +#define duk_peval_file_noresult(ctx,path) \ + ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \ + (void) duk_push_string((ctx), (path)), \ + duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT)) + +#define duk_compile_file(ctx,flags,path) \ + ((void) duk_push_string_file_raw((ctx), (path), 0), \ + (void) duk_push_string((ctx), (path)), \ + (void) duk_compile_raw((ctx), NULL, 0, (flags))) + +#define duk_pcompile_file(ctx,flags,path) \ + ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \ + (void) duk_push_string((ctx), (path)), \ + duk_compile_raw((ctx), NULL, 0, (flags) | DUK_COMPILE_SAFE)) + +/* + * Bytecode load/dump + */ + +DUK_EXTERNAL_DECL void duk_dump_function(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_load_function(duk_context *ctx); + +/* + * Logging + */ + +DUK_EXTERNAL_DECL void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, ...); +DUK_EXTERNAL_DECL void duk_log_va(duk_context *ctx, duk_int_t level, const char *fmt, va_list ap); + +/* + * Debugging + */ + +DUK_EXTERNAL_DECL void duk_push_context_dump(duk_context *ctx); + +#if defined(DUK_USE_FILE_IO) +/* internal use */ +#define duk_dump_context_filehandle(ctx,fh) \ + (duk_push_context_dump((ctx)), \ + DUK_FPRINTF((fh), "%s\n", duk_safe_to_string(ctx, -1)), \ + duk_pop(ctx)) + +/* external use */ +#define duk_dump_context_stdout(ctx) \ + duk_dump_context_filehandle((ctx), DUK_STDOUT) +#define duk_dump_context_stderr(ctx) \ + duk_dump_context_filehandle((ctx), DUK_STDERR) +#else /* DUK_USE_FILE_IO */ +#define duk_dump_context_stdout(ctx) ((void) 0) +#define duk_dump_context_stderr(ctx) ((void) 0) +#endif /* DUK_USE_FILE_IO */ + +/* + * Debugger (debug protocol) + */ + +DUK_EXTERNAL_DECL void duk_debugger_attach(duk_context *ctx, + duk_debug_read_function read_cb, + duk_debug_write_function write_cb, + duk_debug_peek_function peek_cb, + duk_debug_read_flush_function read_flush_cb, + duk_debug_write_flush_function write_flush_cb, + duk_debug_detached_function detached_cb, + void *udata); +DUK_EXTERNAL_DECL void duk_debugger_detach(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_debugger_cooperate(duk_context *ctx); + +/* + * Date provider related constants + * + * NOTE: These are "semi public" - you should only use these if you write + * your own platform specific Date provider, see doc/datetime.rst. + */ + +/* Millisecond count constants. */ +#define DUK_DATE_MSEC_SECOND 1000L +#define DUK_DATE_MSEC_MINUTE (60L * 1000L) +#define DUK_DATE_MSEC_HOUR (60L * 60L * 1000L) +#define DUK_DATE_MSEC_DAY (24L * 60L * 60L * 1000L) + +/* Ecmascript date range is 100 million days from Epoch: + * > 100e6 * 24 * 60 * 60 * 1000 // 100M days in millisecs + * 8640000000000000 + * (= 8.64e15) + */ +#define DUK_DATE_MSEC_100M_DAYS (8.64e15) +#define DUK_DATE_MSEC_100M_DAYS_LEEWAY (8.64e15 + 24 * 3600e3) + +/* Ecmascript year range: + * > new Date(100e6 * 24 * 3600e3).toISOString() + * '+275760-09-13T00:00:00.000Z' + * > new Date(-100e6 * 24 * 3600e3).toISOString() + * '-271821-04-20T00:00:00.000Z' + */ +#define DUK_DATE_MIN_ECMA_YEAR (-271821L) +#define DUK_DATE_MAX_ECMA_YEAR 275760L + +/* Part indices for internal breakdowns. Part order from DUK_DATE_IDX_YEAR + * to DUK_DATE_IDX_MILLISECOND matches argument ordering of Ecmascript API + * calls (like Date constructor call). Some functions in duk_bi_date.c + * depend on the specific ordering, so change with care. 16 bits are not + * enough for all parts (year, specifically). + * + * (Must be in-sync with genbuiltins.py.) + */ +#define DUK_DATE_IDX_YEAR 0 /* year */ +#define DUK_DATE_IDX_MONTH 1 /* month: 0 to 11 */ +#define DUK_DATE_IDX_DAY 2 /* day within month: 0 to 30 */ +#define DUK_DATE_IDX_HOUR 3 +#define DUK_DATE_IDX_MINUTE 4 +#define DUK_DATE_IDX_SECOND 5 +#define DUK_DATE_IDX_MILLISECOND 6 +#define DUK_DATE_IDX_WEEKDAY 7 /* weekday: 0 to 6, 0=sunday, 1=monday, etc */ +#define DUK_DATE_IDX_NUM_PARTS 8 + +/* Internal API call flags, used for various functions in this file. + * Certain flags are used by only certain functions, but since the flags + * don't overlap, a single flags value can be passed around to multiple + * functions. + * + * The unused top bits of the flags field are also used to pass values + * to helpers (duk__get_part_helper() and duk__set_part_helper()). + * + * (Must be in-sync with genbuiltins.py.) + */ + +/* NOTE: when writing a Date provider you only need a few specific + * flags from here, the rest are internal. Avoid using anything you + * don't need. + */ + +#define DUK_DATE_FLAG_NAN_TO_ZERO (1 << 0) /* timeval breakdown: internal time value NaN -> zero */ +#define DUK_DATE_FLAG_NAN_TO_RANGE_ERROR (1 << 1) /* timeval breakdown: internal time value NaN -> RangeError (toISOString) */ +#define DUK_DATE_FLAG_ONEBASED (1 << 2) /* timeval breakdown: convert month and day-of-month parts to one-based (default is zero-based) */ +#define DUK_DATE_FLAG_EQUIVYEAR (1 << 3) /* timeval breakdown: replace year with equivalent year in the [1971,2037] range for DST calculations */ +#define DUK_DATE_FLAG_LOCALTIME (1 << 4) /* convert time value to local time */ +#define DUK_DATE_FLAG_SUB1900 (1 << 5) /* getter: subtract 1900 from year when getting year part */ +#define DUK_DATE_FLAG_TOSTRING_DATE (1 << 6) /* include date part in string conversion result */ +#define DUK_DATE_FLAG_TOSTRING_TIME (1 << 7) /* include time part in string conversion result */ +#define DUK_DATE_FLAG_TOSTRING_LOCALE (1 << 8) /* use locale specific formatting if available */ +#define DUK_DATE_FLAG_TIMESETTER (1 << 9) /* setter: call is a time setter (affects hour, min, sec, ms); otherwise date setter (affects year, month, day-in-month) */ +#define DUK_DATE_FLAG_YEAR_FIXUP (1 << 10) /* setter: perform 2-digit year fixup (00...99 -> 1900...1999) */ +#define DUK_DATE_FLAG_SEP_T (1 << 11) /* string conversion: use 'T' instead of ' ' as a separator */ +#define DUK_DATE_FLAG_VALUE_SHIFT 12 /* additional values begin at bit 12 */ + +/* + * C++ name mangling + */ + +#ifdef __cplusplus +/* end 'extern "C"' wrapper */ +} +#endif + +#endif /* DUK_API_PUBLIC_H_INCLUDED */ + +/* + * END PUBLIC API + */ + +/* + * Union to access IEEE double memory representation, indexes for double + * memory representation, and some macros for double manipulation. + * + * Also used by packed duk_tval. Use a union for bit manipulation to + * minimize aliasing issues in practice. The C99 standard does not + * guarantee that this should work, but it's a very widely supported + * practice for low level manipulation. + * + * IEEE double format summary: + * + * seeeeeee eeeeffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff + * A B C D E F G H + * + * s sign bit + * eee... exponent field + * fff... fraction + * + * See http://en.wikipedia.org/wiki/Double_precision_floating-point_format. + * + * NaNs are represented as exponent 0x7ff and mantissa != 0. The NaN is a + * signaling NaN when the highest bit of the mantissa is zero, and a quiet + * NaN when the highest bit is set. + * + * At least three memory layouts are relevant here: + * + * A B C D E F G H Big endian (e.g. 68k) DUK_USE_DOUBLE_BE + * H G F E D C B A Little endian (e.g. x86) DUK_USE_DOUBLE_LE + * D C B A H G F E Mixed/cross endian (e.g. ARM) DUK_USE_DOUBLE_ME + * + * ARM is a special case: ARM double values are in mixed/cross endian + * format while ARM duk_uint64_t values are in standard little endian + * format (H G F E D C B A). When a double is read as a duk_uint64_t + * from memory, the register will contain the (logical) value + * E F G H A B C D. This requires some special handling below. + * + * Indexes of various types (8-bit, 16-bit, 32-bit) in memory relative to + * the logical (big endian) order: + * + * byte order duk_uint8_t duk_uint16_t duk_uint32_t + * BE 01234567 0123 01 + * LE 76543210 3210 10 + * ME (ARM) 32107654 1032 01 + * + * Some processors may alter NaN values in a floating point load+store. + * For instance, on X86 a FLD + FSTP may convert a signaling NaN to a + * quiet one. This is catastrophic when NaN space is used in packed + * duk_tval values. See: misc/clang_aliasing.c. + */ + +#ifndef DUK_DBLUNION_H_INCLUDED +#define DUK_DBLUNION_H_INCLUDED + +/* + * Union for accessing double parts, also serves as packed duk_tval + */ + +union duk_double_union { + double d; + float f[2]; +#ifdef DUK_USE_64BIT_OPS + duk_uint64_t ull[1]; +#endif + duk_uint32_t ui[2]; + duk_uint16_t us[4]; + duk_uint8_t uc[8]; +#ifdef DUK_USE_PACKED_TVAL_POSSIBLE + void *vp[2]; /* used by packed duk_tval, assumes sizeof(void *) == 4 */ +#endif +}; + +typedef union duk_double_union duk_double_union; + +/* + * Indexes of various types with respect to big endian (logical) layout + */ + +#if defined(DUK_USE_DOUBLE_LE) +#ifdef DUK_USE_64BIT_OPS +#define DUK_DBL_IDX_ULL0 0 +#endif +#define DUK_DBL_IDX_UI0 1 +#define DUK_DBL_IDX_UI1 0 +#define DUK_DBL_IDX_US0 3 +#define DUK_DBL_IDX_US1 2 +#define DUK_DBL_IDX_US2 1 +#define DUK_DBL_IDX_US3 0 +#define DUK_DBL_IDX_UC0 7 +#define DUK_DBL_IDX_UC1 6 +#define DUK_DBL_IDX_UC2 5 +#define DUK_DBL_IDX_UC3 4 +#define DUK_DBL_IDX_UC4 3 +#define DUK_DBL_IDX_UC5 2 +#define DUK_DBL_IDX_UC6 1 +#define DUK_DBL_IDX_UC7 0 +#define DUK_DBL_IDX_VP0 DUK_DBL_IDX_UI0 /* packed tval */ +#define DUK_DBL_IDX_VP1 DUK_DBL_IDX_UI1 /* packed tval */ +#elif defined(DUK_USE_DOUBLE_BE) +#ifdef DUK_USE_64BIT_OPS +#define DUK_DBL_IDX_ULL0 0 +#endif +#define DUK_DBL_IDX_UI0 0 +#define DUK_DBL_IDX_UI1 1 +#define DUK_DBL_IDX_US0 0 +#define DUK_DBL_IDX_US1 1 +#define DUK_DBL_IDX_US2 2 +#define DUK_DBL_IDX_US3 3 +#define DUK_DBL_IDX_UC0 0 +#define DUK_DBL_IDX_UC1 1 +#define DUK_DBL_IDX_UC2 2 +#define DUK_DBL_IDX_UC3 3 +#define DUK_DBL_IDX_UC4 4 +#define DUK_DBL_IDX_UC5 5 +#define DUK_DBL_IDX_UC6 6 +#define DUK_DBL_IDX_UC7 7 +#define DUK_DBL_IDX_VP0 DUK_DBL_IDX_UI0 /* packed tval */ +#define DUK_DBL_IDX_VP1 DUK_DBL_IDX_UI1 /* packed tval */ +#elif defined(DUK_USE_DOUBLE_ME) +#ifdef DUK_USE_64BIT_OPS +#define DUK_DBL_IDX_ULL0 0 /* not directly applicable, byte order differs from a double */ +#endif +#define DUK_DBL_IDX_UI0 0 +#define DUK_DBL_IDX_UI1 1 +#define DUK_DBL_IDX_US0 1 +#define DUK_DBL_IDX_US1 0 +#define DUK_DBL_IDX_US2 3 +#define DUK_DBL_IDX_US3 2 +#define DUK_DBL_IDX_UC0 3 +#define DUK_DBL_IDX_UC1 2 +#define DUK_DBL_IDX_UC2 1 +#define DUK_DBL_IDX_UC3 0 +#define DUK_DBL_IDX_UC4 7 +#define DUK_DBL_IDX_UC5 6 +#define DUK_DBL_IDX_UC6 5 +#define DUK_DBL_IDX_UC7 4 +#define DUK_DBL_IDX_VP0 DUK_DBL_IDX_UI0 /* packed tval */ +#define DUK_DBL_IDX_VP1 DUK_DBL_IDX_UI1 /* packed tval */ +#else +#error internal error +#endif + +/* + * Helper macros for reading/writing memory representation parts, used + * by duk_numconv.c and duk_tval.h. + */ + +#define DUK_DBLUNION_SET_DOUBLE(u,v) do { \ + (u)->d = (v); \ + } while (0) + +#define DUK_DBLUNION_SET_HIGH32(u,v) do { \ + (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) (v); \ + } while (0) + +#ifdef DUK_USE_64BIT_OPS +#ifdef DUK_USE_DOUBLE_ME +#define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u,v) do { \ + (u)->ull[DUK_DBL_IDX_ULL0] = (duk_uint64_t) (v); \ + } while (0) +#else +#define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u,v) do { \ + (u)->ull[DUK_DBL_IDX_ULL0] = ((duk_uint64_t) (v)) << 32; \ + } while (0) +#endif +#else /* DUK_USE_64BIT_OPS */ +#define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u,v) do { \ + (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) (v); \ + (u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) 0; \ + } while (0) +#endif /* DUK_USE_64BIT_OPS */ + +#define DUK_DBLUNION_SET_LOW32(u,v) do { \ + (u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (v); \ + } while (0) + +#define DUK_DBLUNION_GET_DOUBLE(u) ((u)->d) +#define DUK_DBLUNION_GET_HIGH32(u) ((u)->ui[DUK_DBL_IDX_UI0]) +#define DUK_DBLUNION_GET_LOW32(u) ((u)->ui[DUK_DBL_IDX_UI1]) + +#ifdef DUK_USE_64BIT_OPS +#ifdef DUK_USE_DOUBLE_ME +#define DUK_DBLUNION_SET_UINT64(u,v) do { \ + (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) ((v) >> 32); \ + (u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (v); \ + } while (0) +#define DUK_DBLUNION_GET_UINT64(u) \ + ((((duk_uint64_t) (u)->ui[DUK_DBL_IDX_UI0]) << 32) | \ + ((duk_uint64_t) (u)->ui[DUK_DBL_IDX_UI1])) +#else +#define DUK_DBLUNION_SET_UINT64(u,v) do { \ + (u)->ull[DUK_DBL_IDX_ULL0] = (duk_uint64_t) (v); \ + } while (0) +#define DUK_DBLUNION_GET_UINT64(u) ((u)->ull[DUK_DBL_IDX_ULL0]) +#endif +#define DUK_DBLUNION_SET_INT64(u,v) DUK_DBLUNION_SET_UINT64((u), (duk_uint64_t) (v)) +#define DUK_DBLUNION_GET_INT64(u) ((duk_int64_t) DUK_DBLUNION_GET_UINT64((u))) +#endif /* DUK_USE_64BIT_OPS */ + +/* + * Double NaN manipulation macros related to NaN normalization needed when + * using the packed duk_tval representation. NaN normalization is necessary + * to keep double values compatible with the duk_tval format. + * + * When packed duk_tval is used, the NaN space is used to store pointers + * and other tagged values in addition to NaNs. Actual NaNs are normalized + * to a specific format. The macros below are used by the implementation + * to check and normalize NaN values when they might be created. The macros + * are essentially NOPs when the non-packed duk_tval representation is used. + * + * A FULL check is exact and checks all bits. A NOTFULL check is used by + * the packed duk_tval and works correctly for all NaNs except those that + * begin with 0x7ff0. Since the 'normalized NaN' values used with packed + * duk_tval begin with 0x7ff8, the partial check is reliable when packed + * duk_tval is used. + * + * The ME variant below is specifically for ARM byte order, which has the + * feature that while doubles have a mixed byte order (32107654), unsigned + * long long values has a little endian byte order (76543210). When writing + * a logical double value through a ULL pointer, the 32-bit words need to be + * swapped; hence the #ifdefs below for ULL writes with DUK_USE_DOUBLE_ME. + * This is not full ARM support but suffices for some environments. + */ + +#ifdef DUK_USE_64BIT_OPS +#ifdef DUK_USE_DOUBLE_ME +#define DUK__DBLUNION_SET_NAN_FULL(u) do { \ + (u)->ull[DUK_DBL_IDX_ULL0] = 0x000000007ff80000ULL; \ + } while (0) +#else +#define DUK__DBLUNION_SET_NAN_FULL(u) do { \ + (u)->ull[DUK_DBL_IDX_ULL0] = 0x7ff8000000000000ULL; \ + } while (0) +#endif +#else /* DUK_USE_64BIT_OPS */ +#define DUK__DBLUNION_SET_NAN_FULL(u) do { \ + (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) 0x7ff80000UL; \ + (u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) 0x00000000UL; \ + } while (0) +#endif /* DUK_USE_64BIT_OPS */ + +#define DUK__DBLUNION_SET_NAN_NOTFULL(u) do { \ + (u)->us[DUK_DBL_IDX_US0] = 0x7ff8UL; \ + } while (0) + +#ifdef DUK_USE_64BIT_OPS +#ifdef DUK_USE_DOUBLE_ME +#define DUK__DBLUNION_IS_NAN_FULL(u) \ + /* E == 0x7ff, F != 0 => NaN */ \ + ((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \ + ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0xffffffff000fffffULL) != 0)) +#else +#define DUK__DBLUNION_IS_NAN_FULL(u) \ + /* E == 0x7ff, F != 0 => NaN */ \ + ((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \ + ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0x000fffffffffffffULL) != 0)) +#endif +#else /* DUK_USE_64BIT_OPS */ +#define DUK__DBLUNION_IS_NAN_FULL(u) \ + /* E == 0x7ff, F != 0 => NaN */ \ + ((((u)->ui[DUK_DBL_IDX_UI0] & 0x7ff00000UL) == 0x7ff00000UL) && \ + (((u)->ui[DUK_DBL_IDX_UI0] & 0x000fffffUL) != 0 || \ + (u)->ui[DUK_DBL_IDX_UI1] != 0)) +#endif /* DUK_USE_64BIT_OPS */ + +#define DUK__DBLUNION_IS_NAN_NOTFULL(u) \ + /* E == 0x7ff, topmost four bits of F != 0 => assume NaN */ \ + ((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \ + (((u)->us[DUK_DBL_IDX_US0] & 0x000fUL) != 0x0000UL)) + +#ifdef DUK_USE_64BIT_OPS +#ifdef DUK_USE_DOUBLE_ME +#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \ + ((u)->ull[DUK_DBL_IDX_ULL0] == 0x000000007ff80000ULL) +#else +#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \ + ((u)->ull[DUK_DBL_IDX_ULL0] == 0x7ff8000000000000ULL) +#endif +#else /* DUK_USE_64BIT_OPS */ +#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \ + (((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff80000UL) && \ + ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL)) +#endif /* DUK_USE_64BIT_OPS */ + +#define DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL(u) \ + /* E == 0x7ff, F == 8 => normalized NaN */ \ + ((u)->us[DUK_DBL_IDX_US0] == 0x7ff8UL) + +#define DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL(u) do { \ + if (DUK__DBLUNION_IS_NAN_FULL((u))) { \ + DUK__DBLUNION_SET_NAN_FULL((u)); \ + } \ + } while (0) + +#define DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL(u) do { \ + if (DUK__DBLUNION_IS_NAN_NOTFULL((u))) { \ + DUK__DBLUNION_SET_NAN_NOTFULL((u)); \ + } \ + } while (0) + +/* Concrete macros for NaN handling used by the implementation internals. + * Chosen so that they match the duk_tval representation: with a packed + * duk_tval, ensure NaNs are properly normalized; with a non-packed duk_tval + * these are essentially NOPs. + */ + +#if defined(DUK_USE_PACKED_TVAL) +#if defined(DUK_USE_FULL_TVAL) +#define DUK_DBLUNION_NORMALIZE_NAN_CHECK(u) DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL((u)) +#define DUK_DBLUNION_IS_NAN(u) DUK__DBLUNION_IS_NAN_FULL((u)) +#define DUK_DBLUNION_IS_NORMALIZED_NAN(u) DUK__DBLUNION_IS_NORMALIZED_NAN_FULL((u)) +#define DUK_DBLUNION_SET_NAN(d) DUK__DBLUNION_SET_NAN_FULL((d)) +#else +#define DUK_DBLUNION_NORMALIZE_NAN_CHECK(u) DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL((u)) +#define DUK_DBLUNION_IS_NAN(u) DUK__DBLUNION_IS_NAN_NOTFULL((u)) +#define DUK_DBLUNION_IS_NORMALIZED_NAN(u) DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL((u)) +#define DUK_DBLUNION_SET_NAN(d) DUK__DBLUNION_SET_NAN_NOTFULL((d)) +#endif +#define DUK_DBLUNION_IS_NORMALIZED(u) \ + (!DUK_DBLUNION_IS_NAN((u)) || /* either not a NaN */ \ + DUK_DBLUNION_IS_NORMALIZED_NAN((u))) /* or is a normalized NaN */ +#else /* DUK_USE_PACKED_TVAL */ +#define DUK_DBLUNION_NORMALIZE_NAN_CHECK(u) /* nop: no need to normalize */ +#define DUK_DBLUNION_IS_NAN(u) (DUK_ISNAN((u)->d)) +#define DUK_DBLUNION_IS_NORMALIZED_NAN(u) (DUK_ISNAN((u)->d)) +#define DUK_DBLUNION_IS_NORMALIZED(u) 1 /* all doubles are considered normalized */ +#define DUK_DBLUNION_SET_NAN(u) do { \ + /* in non-packed representation we don't care about which NaN is used */ \ + (u)->d = DUK_DOUBLE_NAN; \ + } while (0) +#endif /* DUK_USE_PACKED_TVAL */ + +/* XXX: native 64-bit byteswaps when available */ + +/* 64-bit byteswap, same operation independent of target endianness. */ +#define DUK_DBLUNION_BSWAP64(u) do { \ + duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \ + duk__bswaptmp1 = (u)->ui[0]; \ + duk__bswaptmp2 = (u)->ui[1]; \ + duk__bswaptmp1 = DUK_BSWAP32(duk__bswaptmp1); \ + duk__bswaptmp2 = DUK_BSWAP32(duk__bswaptmp2); \ + (u)->ui[0] = duk__bswaptmp2; \ + (u)->ui[1] = duk__bswaptmp1; \ + } while (0) + +/* Byteswap an IEEE double in the duk_double_union from host to network + * order. For a big endian target this is a no-op. + */ +#if defined(DUK_USE_DOUBLE_LE) +#define DUK_DBLUNION_DOUBLE_HTON(u) do { \ + duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \ + duk__bswaptmp1 = (u)->ui[0]; \ + duk__bswaptmp2 = (u)->ui[1]; \ + duk__bswaptmp1 = DUK_BSWAP32(duk__bswaptmp1); \ + duk__bswaptmp2 = DUK_BSWAP32(duk__bswaptmp2); \ + (u)->ui[0] = duk__bswaptmp2; \ + (u)->ui[1] = duk__bswaptmp1; \ + } while (0) +#elif defined(DUK_USE_DOUBLE_ME) +#define DUK_DBLUNION_DOUBLE_HTON(u) do { \ + duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \ + duk__bswaptmp1 = (u)->ui[0]; \ + duk__bswaptmp2 = (u)->ui[1]; \ + duk__bswaptmp1 = DUK_BSWAP32(duk__bswaptmp1); \ + duk__bswaptmp2 = DUK_BSWAP32(duk__bswaptmp2); \ + (u)->ui[0] = duk__bswaptmp1; \ + (u)->ui[1] = duk__bswaptmp2; \ + } while (0) +#elif defined(DUK_USE_DOUBLE_BE) +#define DUK_DBLUNION_DOUBLE_HTON(u) do { } while (0) +#else +#error internal error, double endianness insane +#endif + +/* Reverse operation is the same. */ +#define DUK_DBLUNION_DOUBLE_NTOH(u) DUK_DBLUNION_DOUBLE_HTON((u)) + +#endif /* DUK_DBLUNION_H_INCLUDED */ + +#endif /* DUKTAPE_H_INCLUDED */