duktape/RELEASES.rst

================
Duktape releases
================

Released
========

0.1.0 (2013-02-14)
------------------

* Initial alpha release

* Core features work: compiler, executor, regexps, garbage collection

* Most built-ins incomplete or missing

0.2.0 (2013-02-27)
------------------

* Built-ins implemented: Boolean, Date, JSON

* Date built-in has initial, minimal local time / locale support

* Initial internal documentation: regexp, datetime, json

0.3.0 (2013-03-16)
------------------

* Built-ins implemented: global object, Object, String

0.4.0 (2013-03-31)
------------------

* Built-ins: Array, Number, completing built-ins

0.5.0 (2013-05-17)
------------------

* Built-in number conversion primitives

* Cleanup built-ins, improve test cases for built-ins

0.6.0 (2013-09-21)
------------------

* First round of public API cleanup, and add basic API documentation

* First version of duktape.org website

0.7.0 (2013-10-30)
------------------

* Traceback support improved

* Clean up and document error object properties

* Add prototype objects for buffer and pointer values, and make them object
  coercible

* Proper support for big, little, and "middle endian" environments

* Single file combined source distributable

* Portability and bug fixes

0.8.0 (2013-12-18)
------------------

* Remove DUK_PROFILE model, explicit DUK_OPT_xxx feature options added for
  tuning the build (see web docs)

* Register shuffling added to compiler which mostly eliminates constant and
  temporary register limits

* Reduce code footprint, make built-in data 'const' so that it compiles
  into the 'text' section

* Augment errors created when a built-in error constructor is called as
  a normal function (e.g. "var e = Error('test')")

* Enforce string/buffer length limits to avoid corner cases with strings
  and buffers close to size_t limit

* Ecmascript E5.1 test cases and fixes

* Mark-and-sweep stringtable leak fixed, affected mostly builds without
  reference counting

* Run a few mark-and-sweep passes in duk_destroy_heap() to give finalizers
  a chance to run in most (but not all) cases

* Coroutine yield fixes

* Portability and bug fixes

0.9.0 (2014-02-02)
------------------

* Added duk_gc() API call to force GC, implemented duk_map_string() and
  duk_decode_string()

* Added extended JSON format variants JSONX and JSONC; NULL pointer
  values string now coerce to "null" instead of e.g. "(nil)" to match
  JSONX format

* Added input line number to compiler error messages (e.g. SyntaxErrors)

* Added support for function declarations outside function or program top
  level (also known as "function statements"), with V8-like semantics

* Renamed __duk__ to Duktape for more consistency with Ecmascript conventions

* Removed somewhat useless Duktape.build property and added Duktape.env

* Replaced Duktape.addr() and Duktape.refc() with Duktape.info() which gives
  more internal info

* Merged Duktape.setFinalizer() and Duktape.getFinalizer() into a single
  Duktape.fin() call

* Some compatibility properties available for now (e.g. __duk__), but these
  will be removed after this release

* Removed array size limit for very large array joins

* Improve Unicode handling of Greek final sigma

* Make mark-and-sweep interval relative to current heap size (measured as
  combined object and string count)

* Add DUK_OPT_NO_VOLUNTARY_GC to disable voluntary mark-and-sweep entirely;
  this is useful in timing sensitive applications like games

* Preliminary internal support for periodic bytecode executor interrupts
  which can be used to implement executor step limits, profiling, and
  debugging

* More feature options for build tuning

* More self tests to detect obscure compiler bugs, two's complement
  arithmetic, etc (enable with DUK_OPT_SELF_TESTS)

* Fixed several compile warnings, fixed warnings generated by GCC -Wextra

* Fixed some incorrect assertions (with no underlying bug)

* Fixed a coroutine termination bug which caused assertion errors and
  occasional segfaults when an uncaught error terminated a thread with
  a catch point active

* Fixed a tailcall bug: the current activation was not closed which
  caused variable lookups to fail if an inner function accessed
  variables in the surrounding activation

* Fixed a few bound constructor bugs

* Fixed handling of "get" and "set": they were handled as reserved words
  which prevented valid statements like "var set = 1;"

* Fixed a switch-case bug where code was accepted before the first
  case/default clause

* Fixed a switch-case bug where successive case clauses with no code
  in-between was not handled correctly

* Fixed a for statement control flow bug when the third clause of the for
  statement was empty and a continue was used

* Fixed error lineNumber bug triggered when there was more than 127
  source lines between successive compiled statements

* Fixed some line terminator handling issues

* Fixed relational operator ToPrimitive() coercion order, for some
  operators coercion order was reversed

* Fixed 'with' statement in strict mode (did not throw SyntaxError)

* Fixed strictness handling of an indirect eval call from a strict
  function (eval incorrectly inherited strict mode)

* Several test262 and underscore.js test case fixes (other than above)

* Windows compatibility for both WIN32 and WIN64, tested with MinGW (x86),
  MINGW-w64 (x64), VS2010 Express (x32), VS2013 Express (x32 and x64)

* Portability fixes for non-C99 platforms (like MSVC in VS2010)

* Drop 'full distributable' build, which is replaced by the public GitHub
  repo; simplify Makefiles etc accordingly (this change is not visible in
  the source distributable)

0.10.0 (2014-04-13)
-------------------

* Avoid "out of regs" for large expressions by adding more comprehensive
  register shuffling and indirect variants of several bytecode opcodes

* Change error handler model: error handlers are now set explicitly to
  Duktape.errcreate and Duktape.errthrow, and can interact with both error
  creation and error throwing

* Incompatible API change: errhandler_index argument has been removed
  from all protected API calls as unnecessary

* Add duk_push_heap_stash(), duk_push_global_stash(), and
  duk_push_thread_stash() to provide C code with stashes for storing
  values invisible to Ecmascript code

* Add duk_safe_to_string() and duk_safe_to_lstring() to make it easier
  to write result printing in C

* Add protected variants of eval/compile: duk_peval(), duk_peval_string(),
  duk_peval_file(), duk_pcompile(), duk_pcompile_string(), duk_pcompile_file()

* duk_pcall_prop() now catches invalid stack index errors and property
  lookup errors which happen before the actual call

* Add duk_put_function_list() and duk_put_number_list() to make it easier
  to define modules from C code

* Add Duktape.compact(), Duktape.line(), and Duktape.act()

* Add a "use duk notail" directive which indicates that an Ecmascript
  function should never be tail called

* Add a barebones built-in logging framework with both Ecmascript and C
  APIs and easy customization

* Add a message argument to fatal handler function callback, simplify
  internal fatal error and panic handling

* Compact function templates and instances to reduce memory footprint

* Execute finalizers for all objects, even reachable ones, when a heap
  is freed to allow native resources to be freed reliably

* "new Object()" now promotes plain buffer and pointer values to Buffer
  and Pointer objects

* Buffer values now have virtual numeric index properties and a virtual
  'length' property, so that you can do x = buf[123], buf[123] = x and
  buf.length

* Buffer data areas no longer have an automatic NUL terminator to avoid
  rounding user-requested allocation sizes upwards unnecessarily

* Buffer constructor behavior changes: number argument creates a buffer
  of a certain size; optional second argument indicates whether a buffer
  should be dynamic or fixed

* Change Array.prototype.splice() behavior so that if 2nd argument
  (deleteCount) is not given, splice to end of array instead of treating
  like deleteCount was zero: the new behavior is non-standard but is the
  real world behavior used by V8, Rhino, Spidermonkey, etc

* Add an automatic 'length' property to Duktape/C functions

* Add a feature option to provide a 'caller' property for non-strict
  functions, with behavior similar to the (non-standard) behavior in
  e.g. V8 and Rhino

* Add a feature option to disable automatic zeroing of data areas of
  buffer values

* Improve self tests to include byte order validation

* Allow the global eval() function to be called from C code (causes an
  indirect eval); this was at least an issue with a bound eval() call

* Fix O(depth^2) inner function parsing issue, inner functions are now
  only parsed once and deeply nested inner functions are no longer a
  performance issue

* On platforms requiring a specific alignment, use an alternate object
  property table memory layout to reduce memory footprint

* Wrap remaining platform calls through macro wrappers to allow easier
  targeted fixes if necessary

* Fix a regexp bug: non-capturing groups inside quantifier expressions
  were matched incorrectly

* Fix a regexp bug: capture groups were not reset to 'undefined' when
  a quantified with capture groups was re-matched by a quantifier

* Fix a tailcall bug which caused assertion failures when a tailcall was
  made from inside a switch-case

* Fix a with statement bug which caused assertion failures when a break or
  continue jumped out of the with statement

* Fix a try-catch-finally broken assertion when finally block had finished
  (ENDFIN opcode)

* Portability fixes for Crossbridge (Flash), NetBSD (endianness detection
  and a few Math.pow() fixes), OpenBSD (endianness detection),
  QNX (endianness and other fixes)

* Warning fixes for non-default feature options and a few exotic compilers

* Duktape can now be compiled with Emscripten and executed with e.g. V8,
  "Dukweb" provides an example where Duktape runs on a web page, with
  Duktape and the browser Javascript environment interacting

0.11.0 (2014-07-11)
-------------------

* Add a built-in module loader (i.e. a require() function) based on CommonJS
  modules v1.1.1; user must always provide a module search function
  (Duktape.modSearch)

* Add Object.setPrototypeOf() and Object.prototype.__proto__, both borrowed
  from ES6 draft, to improve internal prototype handling

* Add proxy objects borrowed from ES6 draft to allow property virtualization,
  subset limited to the following traps: has, get, set, deleteProperty,
  enumerate, ownKeys

* Add property name as a non-standard setter/getter argument to make it
  possible to share a single setter/getter pair for multiple properties

* Allow non-standard dollar escape inside character classes (previously
  they were already allowed elsewhere), to support non-standard regexps
  like /[\\$]/

* Add debug API calls to dump the stack top and values in the current context,
  see e.g. duk_dump_context_stdout

* Add convenience API calls: duk_push_uint(), duk_get_global_string()

* Add more variants for eval/compile (such as duk_eval_lstring() and
  duk_compile_lstring()) and avoid interning the source code when compiling
  from a user provided string (useful in low memory environments)

* Add duk_copy() API call, essentially shorthand for duk_dup() + duk_replace()

* Align duk_to_fixed_buffer() arguments and return value with duk_to_buffer()
  (this is an API incompatible change); add duk_to_dynamic_buffer()

* Implement the DUK_COMPILE_FUNCTION flag for duk_compile()

* Remove Duktape.line() as redundant to Duktape.act()

* Serialize negative zero as '-0' in JSONX and JSONC

* Public API C typing wrapped behind typedefs to allow porting to more exotic
  platforms, e.g. platforms where "int" is a 16-bit type; API docs updated to
  describe how type wrapping affects calling code (see new section "C types")

* Internal C typing wrapped throughout to allow porting to more exotic
  platforms, e.g. platforms where "int" is a 16-bit type

* Rename some feature options (DUK_OPT_xxx) for consistency, please check
  any options you use against the up-to-date options list

* Rename Duktape.errcreate and Duktape.errthrow to Duktape.errCreate and
  Duktape.errThrow for naming consistency

* Rename Duktape's custom JSONX format to avoid confusion with JSONx
  (XML encoding for JSON); new names are JX and JC ('jx' and 'jc' in APIs,
  DUK_OPT_NO_JX and DUK_OPT_NO_JC in feature options)

* Compact the automatic function .prototype property, which previously had
  1 unused property slot

* Use 'anon' instead of 'empty' for the function name in toString() coercion
  of an anonymous function, matching traceback behavior

* The expressions !0 and !1 are now constant folded by the compiler as they're
  often found in minified code; also !true and !false are constant folded

* Remove the 256 character limitation for duk_log(), log messages can now be
  arbitrarily long but short messages (<= 256) are still formatted efficiently
  using a stack buffer

* Improve non-C99 build: type detection should now work on (some) 64-bit
  platforms too, and non-debug build should now generate much fewer (or no)
  warnings; this also improves C++ build

* Add support for X32 ABI (gcc -mx32 option)

* Move platform and feature detection into duktape.h, also for internal
  types, which allows type wrappers to be applied to the public API

* Add a safety limit for compiled bytecode byte size and maximum line number
  used to ensure pc-to-line internal data structure limits are not exceeded

* Fix a number conversion related incorrect assertion triggered by the
  test262 test suite

* Fix JSON.parse() handling for '__proto__' named own property, which
  should be parsed as a normal property of that name instead of changing
  the object's prototype

* Fix a duk_push_sprintf() bug: for long formatted strings Duktape would
  reuse a va_list without copying it, which lead to memory unsafe behavior

* Fix a 'delete' bug: if delete target was a string and key was 'length' or
  a valid character index, value stack was left in an inconsistent state in
  non-strict mode (caused an assertion failure)

* Fix a rare math optimization issue in the Date built-in, which caused a
  corner case test (test-bi-date-canceling.js) to fail on e.g. 64-bit Ubuntu,
  gcc 4.8.1, -m32, and no -std=c99

* Fix a few corner case pointer wrapping bugs in duk_set_top() and a few
  other value stack index handling functions

* Portability fix for avoiding potentially non-portable signed integer
  constants internally (e.g. use 0x7fffffffL - 1L instead of -0x80000000L);
  this fixed a concrete problem with at least VS2010 + x64

* Portability fix for avoiding direct function pointers to built-in functions
  (especially math functions) because they may be implemented as inline
  functions or macros on some platforms or polyfill headers

* Portability fixes for MSVC, avoid secure CRT warnings to work better with
  Windows Store apps

* Portability fixes for VS2010, avoid ending up with a packed value
  representation on x64 when standard integer headers are not available
  (also added a self test to catch such cases)

* Reduce warnings generated by /Wp64 option of VS2010 when compiling for
  x86; the remainings warnings are harmless and cannot be completely removed,
  see guide documentation for more information

* Portability fix for DUK_OPT_SEGFAULT_ON_PANIC when C99 types are not
  available

* Portability fixes for uclibc, use a replacement for e.g. fpclassify()
  because it is broken in some uclibc versions still in use (affected at
  least some mixed endian ARM environments)

* Portability fixes for newer Emscripten version, Dukweb.js now works with
  Firefox

* A few polyfills for non-standard but still commonly used features are
  provided in the distributable polyfills/ directory

* AUTHORS.txt is now included in the distributable, and both LICENSE.txt and
  AUTHORS.txt are embedded into duktape.c and duktape.h to ensure they're
  automatically included when used in another project

0.12.0 (2014-09-26)
-------------------

* Beta release for stabilization: feature freeze until 1.0.0 release, most
  work will be testing, bug fixes, and documentation

* Remove undocumented duk_xmove(), add duk_xmove_top() and duk_xcopy_top()
  (duk_xcopy_top() provides the same semantics as the earlier undocumented
  duk_xmove())

* Change strictness behavior for Duktape API calls: all API calls now have
  Ecmascript strict semantics, even when a call is made with an empty call
  stack outside of any Duktape/C function

* Change strictness handling of duk_eval() and variants so that all code is
  evaluated in non-strict mode by default (unless the code itself contains
  a "use strict" directive); without this change the strictness would depend
  on whether a Duktape/C function call was active or not

* Change Array.prototype.concat() and Array.prototype.map() behavior so that
  trailing non-existent elements are counted towards the result array length;
  this behavior seems to be non-standard but is the real world behavior used
  by V8, Rhino, and Spidermonkey at least

* Add API call duk_set_global_object() which allows the global object of a
  context to be replaced; this is useful as an initial mechanism for proper
  sandboxing of Ecmascript code

* Add API calls duk_get_prototype() and duk_set_prototype() for getting and
  setting an object's "internal prototype" from C code

* Add API calls duk_get_finalizer() and duk_set_finalizer() for getting and
  setting an object's finalizer from C code

* Add API calls for function "magic" which allows a 16-bit signed integer
  to be associated (cheaply) with a Duktape/C function

* Treat any strings whose byte representation begins with 0xFF as internal,
  so that user code can use hidden internal properties like Duktape does
  internally; such properties are not enumerated or returned by e.g.
  getOwnPropertyNames()

* Fix the object property allocation resizing algorithm to avoid unbounded
  memory usage with some insert/delete sequences
  (see test-bug-object-prop-alloc-unbounded.js)

* Use an equivalent year (matching leap-year-ness and weekday of Jan 1) for
  local tzoffset calculations outside the [1971,2037] year range to improve
  local time handling

* Use gmtime() + localtime() on Unix (instead of gmtime() twice) for local
  tzoffset, fixing some DST cases

* Improve parsing of a local time (new Date(2012, 1, 2, 3, 4, 5)) using an
  iterative algorithm to get a more accurate tzoffset/DST estimate

* Apply E5.1 Section 15.3.5.4 TypeError throwing also when the property value
  is a bound strict function, previously the special "caller" property
  behavior was only applied when "caller" value was a non-bound strict mode
  function

* Reject deletion of plain buffer indexed elements (previously this behavior
  was implemented only for Buffer objects), i.e. delete returns false (in
  non-strict functions) or throws a TypeError (in strict functions)

* Reject empty throw statement ('throw;') and reject a newline which occurs
  between a 'throw' and its argument

* Disable internal interrupt mechanism in anticipation of 1.0 release since
  there will be no API to use it

* Fix value stack reserve handling for function calls: a function call
  (Ecmascript or Duktape/C) might reduce the valstack "checked size" which
  was previously requested by user code (for more detail, see API test case
  test-dev-valstack-checked-size-call.c)

* Fix finalizer handling for Proxy objects: if a Proxy object was reachable
  at heap destruction and the target object had a finalizer, the finalizer
  would also be executed for the Proxy object

* Fix a few Date bugs for large out-of-range years which caused some assert
  failures and incorrect behavior when year was out of Ecmascript range (e.g.
  year 870e6 and year -200e6)

* Minor compile warnings fixes for non-default options (e.g. when reference
  counting is disabled)

* Make objects and functions defined by included polyfills non-enumerable so
  that they don't enumerate e.g. in a for-in loop

* A few more polyfills

1.0.0 (2014-10-26)
------------------

* Feature complete baseline release

* Add convenience API call: duk_put_global_string()

* Rename duk_is_fixed() to duk_is_fixed_buffer() and duk_is_dynamic() to
  duk_is_dynamic_buffer() for consistency with other API calls

* Rename Duktape internal keys to start with an uppercase character (e.g.
  "\\xFFValue") so that user internal keys which begin with a lowercase
  character (e.g. "\\xFFptr") won't conflict by default

* Add OS and compiler strings to Duktape.env

* Make error 'tracedata' an internal property for better sandboxing

* Rename members of struct duk_memory_functions to have a "_func" suffix,
  to avoid conflicting with standard library names (which is problematic if
  the standard names are #defines)

* Add DUK_OPT_DLL_BUILD, which should be enabled for both Duktape and
  application build when Duktape is built as a DLL; on Windows it makes
  Duktape use __declspec(dllexport) and __declspec(dllimport) for public
  API symbols

* Rename RELEASES.txt, AUTHORS.txt, and README.txt files to .rst suffix for
  better automatic formatting

* Fix a mark-and-sweep finalizer bug which could cause memory safety issues
  when finalizer execution was disabled for a mark-and-sweep round

* Fix a mark-and-sweep zero-size realloc() bug which could happen when an
  initial zero-size realloc() failed (this shouldn't normally happen but
  was triggered by GC torture testing)

* Fix an assertion failure when using labelled block statements; some
  labelled block statements still cause an internal error ("INVALID
  opcode 0") but don't cause assert failures

* Fix an assertion failure when using a try-catch in a function with a lot
  of constants (more than 511 string or non-integer constants); a compile
  error happens now instead to prevent unsafe behavior

* Fix duk_dump_context_stderr() which incorrectly dumped to stdout

* Fix require() resolution of relative module identifiers, which was off by
  one component (see GH-48)

* Fix DUK_INVALID_INDEX define value, it used INT_MIN directly

* Fix return value of Duktape.gc() to return true (instead of false) for
  a successful mark-and-sweep

* Fix duk_peval_file(), duk_peval_file_noresult() and duk_pcompile_file()
  to avoid throwing an error for a missing file

* Fix compile error for DUK_OPT_NO_FILE_IO

* Regexp internal limit errors changed from Error to RangeError

* Change command line example to be "barebones" by default, with readline
  enabled via DUK_CMDLINE_FANCY

* Use variadic macros for VS2005+

1.0.1 (2014-10-31)
------------------

* Fix compile error for DUK_OPT_NO_PC2LINE

* Fix fileName for functions defined in a module loaded using require(),
  previously fileName would always be duk_bi_global.c which is misleading
  (see GH-58)

1.0.2 (2014-11-08)
------------------

* Quick fix for C++ compilation issue caused by Duktape using both
  static declaration and a static define which is not allowed in C++;
  the quick fix is to avoid "static" entirely with C++ (GH-63)

1.1.0 (2015-01-09)
------------------

* Main release goal: improved low memory support to allow Duktape to run
  better on devices with 128kB (or even 96kB) system memory; with the changes
  in this release, Duktape initial RAM usage is reduced from about 46kB to
  22kB for a 32-bit target when all low memory features are enabled

* Add lightfunc (DUK_TYPE_LIGHTFUNC) primitive type, representing a
  Duktape/C function with a plain tagged value without any heap allocations

* Add duk_push_c_lightfunc() and duk_is_lightfunc() API calls to push user
  lightfuncs on the value stack and to check if a value is a lightfunc

* Add feature option DUK_OPT_LIGHTFUNC_BUILTINS which causes Duktape to use
  lightfuncs for almost all built-in functions, saving around 14kB of Duktape
  heap on 32-bit platforms

* Add multiple feature options to use 16-bit fields and pointer compression
  for reducing memory usage on low memory systems, see doc/low-memory.rst
  for detailed discussion

* Add DUK_OPT_EXTERNAL_STRINGS to enable support for external strings which
  are like dynamic buffers: a fixed size string header is allocated from the
  Duktape heap, but the data is behind a pointer

* Add DUK_OPT_EXTSTR_INTERN_CHECK and DUK_OPT_EXTSTR_FREE (used with
  DUK_OPT_EXTERNAL_STRINGS) to allow string data to be held outside the
  Duktape heap, which is useful in low memory environments; see
  doc/low-memory.rst for detailed discussion

* Add DUK_OPT_STRTAB_CHAIN and DUK_OPT_STRTAB_CHAIN_SIZE=nnn which enable
  an alternate string table algorithm intended for low memory environments;
  the algorithm uses separate chaining with arrays, making allocation
  behavior easier to handle using a pool allocator, see doc/low-memory.rst

* Add duk_def_prop() which allows creation of accessor (getter/setter)
  properties and other custom properties from C code (instead of using
  Object.defineProperty() from Ecmascript code)

* Add duk_is_error() API call to check if a value inherits from Error

* Add duk_get_error_code() API call to check if a value inherits from
  Error, and if so, map its error class to DUK_ERR_xxx codes so that
  checking for built-in errors is more convenient

* Add duk_get_heapptr(), duk_require_heapptr(), and duk_push_heapptr()
  to get borrowed void pointer references to Duktape heap objects
  (objects, strings, buffers)

* Add vararg variants duk_error_va(), duk_push_error_object_va(), and
  duk_log_va()

* Add DUK_GIT_DESCRIBE macro to the C API (with no Ecmascript equivalent)
  to allow application code to e.g. log more detailed version information
  relevant for non-official snapshot builds

* Add feature option DUK_OPT_NO_STRICT_DECL to disable support for "use
  strict" declarations which may be useful with legacy code bases

* Add DUK_OPT_SETJMP, DUK_OPT_UNDERSCORE_SETJMP, and DUK_OPT_SIGSETJMP to
  force an alternative provider for long control transfers; _setjmp() or
  sigsetjmp() (with savesigs set to 0) can be a lot faster than setjmp()
  if the platform's setjmp() implementation saves the signal mask (GH-55)

* Default to ``_setjmp`` for long control transfers on OSX/iPhone (when
  __APPLE__ is defined) (GH-55)

* Add SuperH detection support

* Change JSON.stringify() to escape U+2028 and U+2029 by default to make
  the output a valid Javascript string, so that it can be embedded in a
  web page or parsed with eval (see GH-68)

* Change JSON.parse() to include a byte offset with a syntax error to help
  pinpoint JSON errors

* Make Function.prototype.name writable so that application code can set
  a 'name' property on Duktape/C functions (GH-79)

* Change buffer maximum size check to compare against allocated size
  (including spare) instead of requested size (without spare), this has
  a practical impact only when using 16-bit buffer size field

* Use deep C stack for dukweb.js to remove some compiler recursion limit
  limitations (see GH-67)

* Add an example allocator with alloc/realloc/free logging, which is
  useful when optimizing e.g. pool sizes for low memory targets

* Add an example allocator with memory wiping, red zones for invalid
  writes, and forced address change on realloc, which can be used for
  detecting memory safety issues on platforms where valgrind is not
  available

* Add an example allocator with a hybrid model where a fixed set of small
  pools are used to reduce allocator churn, but the allocator falls back
  to malloc, realloc, and free for larger allocation sizes or when there
  are no free pool entries

* Add an SPDX 1.2 license into the distributable

* Fix INVALID opcode error for some labelled non-iteration statements
  (see GH-85)

* Fix a few missing "volatile" attributes in the bytecode executor which
  affected setjmp handling in clang (especially for _setjmp and sigsetjmp),
  also fix a few setjmp clobber warnings in executor

* Fix compile error for DUK_OPT_NO_PC2LINE

* Better fix for C++ compilation issue caused by Duktape using both
  static declaration and a static define which is not allowed in C++
  (see GH-63)

* Fix compiler specific behavior when assigning a string to a buffer index
  (e.g. buf[3] = 'x'), now NaN coerces consistently to zero (this was the
  behavior on most compilers but e.g. on Linux MIPS NaN coerced to 255)

* Fix fileName for functions defined in a module loaded using require(),
  previously fileName would always be duk_bi_global.c which is misleading
  (see GH-58)

* Fix object literal getter/setter definition to avoid creating a binding
  for the function (property) name, so that a setter/getter can access an
  outside variable with the same name as the get/set property (see
  test-bug-getset-func-name.js for details)

* Fix JSON.parse() syntax error for explicitly positive exponents (e.g.
  '1.5e+2') (GH-93)

* Fix duk_push_error_object() return value for platforms where variadic
  macros are not available

* Don't fail compilation if SIZE_MAX is < 0xffffffffUL, to allow compilation
  on platforms where SIZE_MAX is (apparently) incorrectly defined

* Fix several compile warnings with gcc 4.9.2 (GH-91)

* Fix MinGW and Cygwin GCC compile warning "visibility attribute not
  supported in this configuration; ignored" when using separate sources

* Fix MSVC const difference warning

* Fix <inttypes.h> issue for older C++ compilers by defining
  __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS before including
  stdint.h and inttypes.h

* Fix various warnings and errors detected in option matrix testing

1.1.1 (2015-02-17)
------------------

* Fix Unicode handling of CJK ideographs and Hangul which were incorrectly
  not accepted in identifier names (see GH-103)

* Fix function parsing bug where the left curly brace opening the function
  body was not checked and Duktape would accept e.g. "function () [}"
  (see GH-106)

* Fix compiler register limit bug where an Ecmascript function with
  [65536,262143] VM registers would be compiled into incorrect bytecode
  instead of being rejected with an internal error (see GH-111)

* Fix compiler shuffle register handling by doing a pass 3 compile if
  necessary, fixing "CSPROPI target is not a number" error (GH-115)

* Fix value stack setup bug which caused a segfault with large number of
  arguments (GH-107)

1.1.2 (2015-03-17)
------------------

* Fix assignment evaluation order issue which affected expressions like
  "a[i] = b[i++]" (GH-118)

* Fix incorrect parsing of zero escape in regexp class ("[\0]") (GH-122)

* Fix tailcall issue in return comma expression when a function call
  in the comma expression was followed by a constant value or a register
  bound variable, e.g. 'return 0, (function { return 1; })(), 2;' would
  return 1 instead of 2 (GH-131)

* Fix for-in statement shuffle bug which caused enumeration to fail
  in large functions which enable register shuffling (GH-132)

* Fix shuffle handling issue for PUTPROP opcode, discovered by shuffle
  torture tests (GH-135)

Planned
=======

1.2.0 (2015-XX-XX)
------------------

* Main release goals: debugger support and performance improvements

* Add first iteration of experimental debugger support which is based on a
  narrow debug API and a standard debug protocol; Duktape also provides an
  example debug client with a web UI, and a JSON debug proxy

* Add support "fastints", i.e. for using integer arithmetic when possible
  in a transparent manner (improves performance for some workloads on soft
  float and some hard float platforms)

* Add iPhone/iOS strings to Duktape.env

* Add DUK_OPT_EXEC_TIMEOUT_CHECK(), an experimental bytecode execution timeout
  mechanism to safely bail out if script execution takes too long; this
  protects against accidental errors but is not (yet) intended to protect
  against deliberately malicious code

* Accept 32-bit codepoints in String.fromCharCode() to better support non-BMP
  strings (GH-120)

* Internal performance improvement: direct refcount manipulation from macros
  instead of doing a helper function call

* Internal performance improvement: hex encode/decode optimizations

* Internal performance improvement: shorter internal chain for API push
  functions like duk_push_undefined()

* Performance improvement: array write fast path when writing to "dense"
  Array instances using a numeric index

* Add internal type tag to Duktape.info() result for non-heap-allocated types
  (useful for some testing)

* Improve MIPS32/MIPS64 detection, architecture strings in Duktape.env
  also updated ("mips32" or "mips64") (GH-102)

* Fix Unicode handling of CJK ideographs and Hangul which were incorrectly
  not accepted in identifier names (see GH-103)

* Fix function parsing bug where the left curly brace opening the function
  body was not checked and Duktape would accept e.g. "function () [}"
  (see GH-106)

* Fix compiler register limit bug where an Ecmascript function with
  [65536,262143] VM registers would be compiled into incorrect bytecode
  instead of being rejected with an internal error (see GH-111)

* Fix buffer assignment to allow negative values: buf[3] = -1 now yields 0xFF
  (in Duktape 1.1 yields 0x00 because negative values are capped to 0)

* Fix compiler shuffle register handling by doing a pass 3 compile if
  necessary, fixing "CSPROPI target is not a number" error (GH-115)

* Fix value stack setup bug which caused a segfault with large number of
  arguments (GH-107)

* Fix incorrect parsing of zero escape in regexp class ("[\0]") (GH-122)

* Fix assignment evaluation order issue which affected expressions like
  "a[i] = b[i++]" (GH-118)

* Fix tailcall issue in return comma expression when a function call
  in the comma expression was followed by a constant value or a register
  bound variable, e.g. 'return 0, (function { return 1; })(), 2;' would
  return 1 instead of 2 (GH-131)

* Fix for-in statement shuffle bug which caused enumeration to fail
  in large functions which enable register shuffling (GH-132)

* Fix shuffle handling issue for PUTPROP opcode, discovered by shuffle
  torture tests (GH-135)

* Fix a potential crash risk in Duktape.info() caused by a live pointer being
  used across a possible realloc

* Fix Duktape.act() lineNumber bug, PC used for lineNumber was off-by-one
  which sometimes resulted in incorrect linenumbers (GH-143)

* Fix incorrect switch-case matching when default clause is the first clause
  in a switch statement (GH-155)

* Add support for TI-Nspire (using Ndless, see GH-113)

2.0.0 (XXXX-XX-XX)
------------------

* Rework Duktape module loading model to be more flexible

* Ecmascript 6 features will be implemented in v2.x.x at the earliest
  (some individual features may be cherry picked into v1.x.x)