Update the webpage (jerryscript.net) (#5203)

JerryScript-DCO-1.0-Signed-off-by: Laszlo Lango laszlo.lango@h-lab.eu

.gitignore

@@ -1,40 +1,2 @@
-# Produced files
-
-build/*
-
-# IDE related files
-nbproject
-**.sublime-project
-**.sublime-workspace
-.idea
-
-# Random Trash
-*.swp
-*.swo
-*~
-core
-vgcore.*
-**.orig
-**.directory
-**.patch
-.tags*
-cscope.*
-__pycache__
-*.pyc
-
-# ctags and ID database
-tags
-ID
-
-# targets
-jerry_targetjs.h
-targets/mbedk64f/libjerry
-targets/mbedk64f/build
-targets/mbedk64f/yotta_modules
-targets/mbedk64f/yotta_targets
-.output
-targets/esp8266/output.map
-targets/esp8266/libs
-
-# Generated documentation
-docs/doxygen
+_site
+.sass-cache

.travis.yml

@@ -1,30 +1,13 @@
 language: c
-
 os: linux
-dist: trusty
-sudo: required
-
-before_install:
-  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then tools/apt-get-install-deps.sh; fi
-  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then tools/apt-get-install-qemu-arm.sh; fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then tools/brew-install-deps.sh; fi
 
 install:
+  - wget https://raw.githubusercontent.com/${TRAVIS_REPO_SLUG}/master/tools/check-signed-off.sh
+  - chmod u+x check-signed-off.sh
+script: ./check-signed-off.sh --gh-actions
 
-script: "python tools/run-tests.py $OPTS"
-
-env:
-  - OPTS="--check-signed-off --check-cppcheck --check-vera"
-  - OPTS="--jerry-tests --jerry-test-suite"
-  - OPTS="--jerry-tests --jerry-test-suite --toolchain=cmake/toolchain_linux_armv7l.cmake" TIMEOUT=300
-  - OPTS=--buildoption-test
-  - OPTS=--unittests
-
-matrix:
-  include:
-    - os: osx
-      env: OPTS="--jerry-tests --jerry-test-suite"
-    - os: osx
-      env: OPTS=--unittests
-  allow_failures:
-    - os: osx
+branches:
+  only:
+  - master
+  - gh-pages
+  - /.*/

00.GETTING-STARTED.md

@@ -0,0 +1,196 @@
+---
+layout: page
+title: Getting Started
+category: navbar
+permalink: /getting-started/
+---
+
+* toc
+{:toc}
+
+## Setting up prerequisites
+
+Currently, only Ubuntu 18.04+ is officially supported as primary development environment.
+
+There are several dependencies, that should be installed manually. The following list is the absolute minimum for building:
+
+- `gcc` or any C99-compliant compiler (native or cross, e.g., arm-none-eabi)
+- `cmake` >= `2.8.12.2`
+
+Several scripts and tools help the building and development process, thus it is recommended to have the following installed as well:
+
+- `bash` >= `4.3.11`
+- `cppcheck` >= `1.61`
+- `clang-format-10` >= `10.0.0`
+- `python` >= `2.7.6`
+
+```bash
+sudo apt-get install gcc gcc-arm-none-eabi cmake cppcheck clang-format-10 python
+```
+
+To make our scripts run correctly, several shell utilities should be available on the system:
+
+- `awk`
+- `bc`
+- `find`
+- `sed`
+
+## Building JerryScript
+
+**To build debug version for Linux**
+
+```bash
+python tools/build.py --debug
+```
+
+**To build debug version for Linux without LTO (Link Time Optimization)**
+
+```bash
+python tools/build.py --debug --lto=off
+```
+
+**To enable more verbose outputs for debugging**
+
+```bash
+tools/build.py --debug --logging=on --error-messages=on --line-info=on
+```
+
+**Add custom arguments to CMake**
+
+```bash
+python tools/build.py --cmake-param=CMAKE_PARAM
+```
+
+**Set a profile mode (es.next, minimal)**
+
+```bash
+python tools/build.py --profile=es.next|minimal
+```
+
+See also the related [README.md](https://github.com/jerryscript-project/jerryscript/blob/master/jerry-core/profiles/README.md).
+
+**Use (compiler-default, external) libc**
+
+The default libc is the compiler-default libc but you can use an external libc as well:
+
+- compiler-default libc:
+
+```bash
+python tools/build.py
+```
+
+- external libc:
+
+```bash
+python tools/build.py --compile-flag="-nostdlib -I/path/to/ext-libc/include" --link-lib="ext-c"
+```
+
+**Add toolchain file**
+
+The ```cmake``` dir already contains some usable toolchain files, which you can use in the following format:
+
+```bash
+python tools/build.py --toolchain=TOOLCHAIN
+```
+
+For example the cross-compile to RaspberryPi 2 is something like this:
+
+```bash
+python tools/build.py --toolchain=cmake/toolchain_linux_armv7l.cmake
+```
+
+**Use system memory allocator**
+
+```bash
+python tools/build.py --system-allocator=on
+```
+
+*Note*: System allocator is only supported on 32 bit systems.
+
+**Enable 32bit compressed pointers**
+
+```bash
+python tools/build.py --cpointer-32bit=on
+```
+
+*Note*: There is no compression/decompression on 32 bit systems, if enabled.
+
+**Change default heap size (512K)**
+
+```bash
+python tools/build.py --mem-heap=256
+```
+
+If you would like to use more than 512K, then you must enable the 32 bit compressed pointers.
+
+```bash
+python tools/build.py --cpointer-32bit=on --mem-heap=1024
+```
+
+*Note*: The heap size will be allocated statically at compile time, when JerryScript memory
+allocator is used.
+
+**To build with libfuzzer support**
+
+```bash
+CC=clang python tools/build.py --libfuzzer=on --compile-flag=-fsanitize=address --lto=off
+```
+
+Check the documentation of libfuzzer to get the runtime settings of the created fuzzer
+binary: https://llvm.org/docs/LibFuzzer.html.
+
+**To get a list of all the available buildoptions for Linux**
+
+```bash
+python tools/build.py --help
+```
+
+## Checking patch
+
+```bash
+python tools/run-tests.py --precommit
+```
+
+### Running only one type of test
+
+**To run build option tests**
+
+```bash
+python tools/run-tests.py --buildoption-test
+```
+
+**To run unittests**
+
+```bash
+python tools/run-tests.py --unittests
+```
+
+**To run jerry-tests**
+
+```bash
+python tools/run-tests.py --jerry-tests
+```
+
+**To run signed-off check**
+
+```bash
+python tools/run-tests.py --check-signed-off
+```
+
+**To run cppcheck**
+
+```bash
+python tools/run-tests.py --check-cppcheck
+```
+
+**To run format check**
+
+```bash
+python tools/run-tests.py --check-format
+```
+
+**To get a list of all the available test options**
+
+```bash
+python tools/run-tests.py --help
+```

01.CONFIGURATION.md

@@ -0,0 +1,410 @@
+---
+layout: page
+title: Configuration
+category: navbar
+permalink: /configuration/
+---
+
+* toc
+{:toc}
+
+# Configuration
+
+JerryScript provides a large number of configuration options which can be used to enable or disable specific features, allowing users to fine tune the engine to best suit their needs.
+A configuration option's value can be changed either by providing specific C preprocessor definitions, by adding CMake definitions, or by using the arguments of the `tools/build.py` script.
+This document lists the available configuration options, shows the configuration name for C, CMake, and python, and provides a brief description that explains the effect of the options.
+
+
+### Amalgamated build
+
+Enables the amalgamated build process, which aggregates the contents of each source file per library
+(i.e., JerryScript's core, port, and math libraries), and uses these combined files to compile the project.
+This process can provide comparable results to link-time optimization, and can be useful when LTO is not available otherwise.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `<none>`                                     |
+| CMake:  | `-DENABLE_AMALGAM=ON/OFF`                    |
+| Python: | `--amalgam=ON/OFF`                           |
+
+See also: [Amalgamated sources](#amalgamated-sources)
+
+### Jerry debugger
+
+Enables debugger support in the engine, which can be used to debug running JavaScript code. For more information on using the debugger see [Debugger](07.DEBUGGER.md).
+The debugger is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_DEBUGGER=0/1`                       |
+| CMake:  | `-DJERRY_DEBUGGER=ON/OFF`                    |
+| Python: | `--jerry-debugger=ON/OFF`                    |
+
+### Line information
+
+By default, all source code information is discarded after parsing is complete. This option can be used to augment the created bytecode to provide line information during runtime,
+that can be used by the debugger to identify the currently executed source context. See [Debugger](07.DEBUGGER.md).
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_LINE_INFO=0/1`                      |
+| CMake:  | `-DJERRY_LINE_INFO=ON/OFF`                   |
+| Python: | `--line-info=ON/OFF`                         |
+
+### Profiles
+
+This option can be used to enable/disable available JavaScript language features by providing profile files. Profile files contain a list of C definitions that configure each individual feature.
+The `path` value for CMake and Python arguments should be a file path to the profile file, or one of `es.next` or `minimal`, which are the pre-defined profiles.
+To see how a profile file should be created, or what configuration options are available in C, see the profile [README](https://github.com/jerryscript-project/jerryscript/blob/master/jerry-core/profiles/README.md).
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `<see description>`                          |
+| CMake:  | `-DJERRY_PROFILE="path"`                     |
+| Python: | `--profile="path"`                           |
+
+### Promise callback
+
+Enables Promise event notification support. This feature allows setting a user callback, which is called when certain Promise related events occur such as
+creating a new Promise, resolving a Promise with a value, etc.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_PROMISE_CALLBACK=0/1`               |
+| CMake:  | `-DJERRY_PROMISE_CALLBACK=ON/OFF`            |
+| Python: | `--promise-callback=ON/OFF`                  |
+
+### External context
+
+Enables external context support in the engine. By default, JerryScript uses a statically allocated context to store the current state of the engine internals.
+When this option is enabled, an externally allocated memory region can be provided through the port API to the engine, to be used as the context.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_EXTERNAL_CONTEXT=0/1`               |
+| CMake:  | `-DJERRY_EXTERNAL_CONTEXT=ON/OFF`            |
+| Python: | `--external-context=ON/OFF`                  |
+
+### Snapshot execution
+
+This option can be used to enable snapshot execution in the engine.
+This option is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_SNAPSHOT_EXEC=0/1`                  |
+| CMake:  | `-DJERRY_SNAPSHOT_EXEC=ON/OFF`               |
+| Python: | `--snapshot-exec=ON/OFF`                     |
+
+### Snapshot saving
+
+This option can be used to enable snapshot saving in the engine.
+This option is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_SNAPSHOT_SAVE=0/1`                  |
+| CMake:  | `-DJERRY_SNAPSHOT_SAVE=ON/OFF`               |
+| Python: | `--snapshot-save=ON/OFF`                     |
+
+### Jerry parser
+
+This option can be used to enable or disable the parser. When the parser is disabled all features that depend on source parsing are unavailable (eg. `jerry_parse`, `eval`, Function constructor).
+This option can be useful in combination with the snapshot feature. The parser is enabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_PARSER=0/1`                         |
+| CMake:  | `-DJERRY_PARSER=ON/OFF`                      |
+| Python: | `--js-parser=ON/OFF`                         |
+
+### Dump bytecode
+
+This option can be used to display created bytecode in a human readable format. See [Internals](04.INTERNALS.md#byte-code) for more details.
+This option is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_PARSER_DUMP_BYTE_CODE=0/1`          |
+| CMake:  | `-DJERRY_PARSER_DUMP_BYTE_CODE=ON/OFF`       |
+| Python: | `--show-opcodes=ON/OFF`                      |
+
+### Dump RegExp bytecode
+
+This option can be used to display created RegExp bytecode in a human readable format. The RegExp bytecode is different from the bytecode used by the virtual machine.
+This option is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_REGEXP_DUMP_BYTE_CODE=0/1`          |
+| CMake:  | `-DJERRY_REGEXP_DUMP_BYTE_CODE=ON/OFF`       |
+| Python: | `--show-regexp-opcodes=ON/OFF`               |
+
+### Strict RegExp
+
+This option can be used to enable strict RegExp mode. The standard RegExp syntax is a lot stricter than what is common in current JavaScript implementations.
+When enabled, this flag disables all of the non-standard, quality-of-life RegExp features, that are implemented to provide compatibility with other commonly used engines.
+This option is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_REGEXP_STRICT_MODE=0/1`             |
+| CMake:  | `-DJERRY_REGEXP_STRICT_MODE=ON/OFF`          |
+| Python: | `--regexp-strict-mode=ON/OFF`                |
+
+### Error messages
+
+Enables error messages for thrown Error objects. By default, error messages are omitted to reduce memory usage.
+Enabling this feature provides detailed error messages where available, like line information for Syntax errors, variable names for Reference errors, Type/Range error messages for built-in routines, etc.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_ERROR_MESSAGES=0/1`                 |
+| CMake:  | `-DJERRY_ERROR_MESSAGES=ON/OFF`              |
+| Python: | `--error-messages=ON/OFF`                    |
+
+### Logging
+
+This option can be used to enable log messages during runtime. When enabled the engine will use the `jerry_port_log` port API function to print relevant log messages.
+This feature is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_LOGGING=0/1`                        |
+| CMake:  | `-DJERRY_LOGGING=ON/OFF`                     |
+| Python: | `--logging=ON/OFF`                           |
+
+### LCache
+
+This option enables the LCache, allowing faster access to object properties. The LCache uses a statically allocated hash-map, which increases memory consumption.
+See [Internals](04.INTERNALS.md#lcache) for further details.
+This option is enabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_LCACHE=0/1`                         |
+| CMake:  | `<none>`                                     |
+| Python: | `<none>`                                     |
+
+### Property hashmaps
+
+This option enables the creation of hashmaps for object properties, which allows faster property access, at the cost of increased memory consumption.
+See [Internals](04.INTERNALS.md#property-hashmap) for further details.
+This option is enabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_PROPERTY_HASHMAP=0/1`               |
+| CMake:  | `<none>`                                     |
+| Python: | `<none>`                                     |
+
+### Memory statistics
+
+This option can be used to provide memory usage statistics either upon engine termination, or during runtime using the `jerry_heap_stats` jerry API function.
+The feature can create a significant performance overhead, and should only be used for measurement purposes. This option is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_MEM_STATS=0/1`                      |
+| CMake:  | `-DJERRY_MEM_STATS=ON/OFF`                   |
+| Python: | `--mem-stats=ON/OFF`                         |
+
+### Heap size
+
+This option can be used to adjust the size of the internal heap, represented in kilobytes. The provided value should be an integer. Values larger than 512 require 32-bit compressed pointers to be enabled.
+The default value is 512.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_GLOBAL_HEAP_SIZE=(int)`             |
+| CMake:  | `-DJERRY_GLOBAL_HEAP_SIZE=(int)`             |
+| Python: | `--mem-heap=(int)`                           |
+
+### Garbage collection limit
+
+This option can be used to adjust the maximum allowed heap usage increase until triggering the next garbage collection, in bytes.
+When the total allocated memory size reaches the current gc limit, garbage collection will be triggered to try and reduce clutter from unreachable objects.
+If the total allocated memory can't be reduced below the current limit, then the limit will be increased by the amount specified via this option.
+Similarly, when the total allocated memory goes well below the current gc limit, the limit is reduced by this amount.
+The default value is 1/32 of the total heap size, but not greater than 8192 bytes.
+A value of 0 will use the default value.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_GC_LIMIT=(int)`                     |
+| CMake:  | `-DJERRY_GC_LIMIT=(int)`                     |
+| Python: | `--gc-limit=(int)`                           |
+
+### GC mark recursion limit
+
+This option can be used to adjust the maximum recursion depth during the GC mark phase. The provided value should be an integer, which represents the allowed number of recursive calls. Increasing the depth of the recursion reduces the time of GC cycles, however increases stack usage.
+A value of 0 will prevent any recursive GC calls.
+
+| Options |                                                   |
+|---------|---------------------------------------------------|
+| C:      | `-DJERRY_GC_MARK_LIMIT=(int)`                     |
+| CMake:  | `-DJERRY_GC_MARK_LIMIT=(int)`                     |
+| Python: | `--gc-mark-limit=(int)`                           |
+
+### Stack limit
+
+This option can be used to cap the stack usage of the engine, and prevent stack overflows due to recursion. The provided value should be an integer, which represents the allowed stack usage in kilobytes.
+The default value is 0 (unlimited).
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_STACK_LIMIT=(int)`                  |
+| CMake:  | `-DJERRY_STACK_LIMIT=(int)`                  |
+| Python: | `--stack-limit=(int)`                        |
+
+### 32-bit compressed pointers
+
+Enables 32-bit pointers instead of the default 16-bit compressed pointers. This allows the engine to use a much larger heap, but also comes with slightly increased memory usage, as objects can't be packed as tightly.
+This option must be enabled when using the system allocator.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_CPOINTER_32_BIT=0/1`                |
+| CMake:  | `-DJERRY_CPOINTER_32_BIT=ON/OFF`             |
+| Python: | `--cpointer-32bit=ON/OFF`                    |
+
+### System allocator
+
+This option enables the use of malloc/free instead of the internal JerryScript allocator. This feature requires 32-bit compressed pointers, and is unsupported on 64-bit architectures.
+This option is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_SYSTEM_ALLOCATOR=0/1`               |
+| CMake:  | `-DJERRY_SYSTEM_ALLOCATOR=ON/OFF`            |
+| Python: | `--system-allocator=ON/OFF`                  |
+
+### Valgrind support
+
+This option enables valgrind support for the internal allocator. When enabled, valgrind will be able to properly identify allocated memory regions, and report leaks or out-of-bounds memory accesses.
+This option is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_VALGRIND=0/1`                       |
+| CMake:  | `-DJERRY_VALGRIND=ON/OFF`                    |
+| Python: | `--valgrind=ON/OFF`                          |
+
+### Memory stress test
+
+This option can be used to stress test memory management, by running garbage collection before every allocation attempt.
+This option is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_MEM_GC_BEFORE_EACH_ALLOC=0/1`       |
+| CMake:  | `-DJERRY_MEM_GC_BEFORE_EACH_ALLOC=ON/OFF`    |
+| Python: | `--mem-stress-test=ON/OFF`                   |
+
+### MSVC CRT
+
+This option enables the use of the MSVC CRT library and is disabled by default.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `<none>`                                     |
+| CMake:  | `-DENABLE_STATIC_CRT=ON/OFF`                 |
+| Python: | `--static-crt=ON/OFF`                        |
+
+### Architecture
+
+Specify the platform name if it is supported by the generator.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `<none>`                                     |
+| CMake:  | `-A (string)`                                |
+| Python: | `--arch=(string)`                            |
+
+### Tostring function
+
+Enable function toString.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_FUNCTION_TO_STRING=0/1`             |
+| CMake:  | `-DJERRY_FUNCTION_TO_STRING=ON/OFF`          |
+| Python: | `--function-to-string=ON/OFF`                |
+
+
+### VM throw
+
+Enable VM throw.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_VM_THROW=0/1`                       |
+| CMake:  | `-DJERRY_VM_THROW=ON/OFF`                    |
+| Python: | `--vm-throw=ON/OFF`                          |
+
+
+### Promise callback
+
+Enable Promise callback.
+
+| Options |                                              |
+|---------|----------------------------------------------|
+| C:      | `-DJERRY_PROMISE_CALLBACK=0/1`               |
+| CMake:  | `-DJERRY_PROMISE_CALLBACK=ON/OFF`            |
+| Python: | `--promise-callback=ON/OFF`                  |
+
+
+# Amalgamated sources
+
+The sources of JerryScript can be combined into a handful of files to allow their easy integration
+in other projects. To achieve this, the following command can be executed to create a set of files
+into the `amalgam` directory:
+
+```sh
+$ python tools/amalgam.py --output-dir amalgam --jerry-core --jerry-port --jerry-math
+```
+
+(Note: In the example above, the command is executed from the project's root directory, but that is
+not mandatory.)
+
+The command creates the following files in the `amalgam` dir:
+
+* `jerryscript.c`
+* `jerryscript.h`
+* `jerryscript-config.h`
+* `jerryscript-port.c`
+* `jerryscript-math.c`
+* `math.h`
+
+**Important**: the `jerryscript-config.h` contains the configurations mentioned above and
+should be adapted to the required use-case. See the file contents for more details and for the
+default configuration. (Note: This config file is created from the the `jerry-core/config.h` file.)
+
+These files can be directly compiled with an application using the JerryScript API.
+E.g., using a command similar to the one below:
+
+```sh
+$ gcc -Wall -o demo_app demo_app.c amalgam/jerryscript.c amalgam/jerryscript-port.c amalgam/jerryscript-math.c -Iamalgam/
+```
+
+(Note: The headers must be available on the include path.)
+
+This approach is also under the hood of the [amalgamated build](#amalgamated-build) process.
+
+# Target specific information
+
+## x86 with GCC
+
+When building for Intel 32 bit architecture it is possible that GCC uses conservative options, thus assuming the most
+basic floating-point support (that is it does not generate SSE or others instructions).
+However this could lead to loss off precision and/or different results than what is required by the JavaScript standard
+in regards of floating-point values and arithmetic.
+
+To resolve this precision problem it is advised to use at least SSE2.
+To do this with GCC please provide the `-mfpmath=sse -msse2` options during build.
+
+These options can also be specified via the `build.py` script:
+
+```sh
+$ ./tools/build.py --compile-flag=-mfpmath=sse --compile-flag=-msse2 --compile-flag=-m32
+```

04.INTERNALS.md

@@ -1,5 +1,15 @@
+---
+layout: page
+title: Internals
+category: documents
+permalink: /internals/
+---
+
+* toc
+{:toc}
+
 # High-Level Design
-![High-Level Design](img/engines_high_level_design.png)
+![High-Level Design]({{ site.github.url }}/img/engines_high_level_design.png){: class="thumbnail center-block img-responsive" }
 
 The diagram above shows the interactions between the major components of JerryScript: Parser and Virtual Machine (VM). Parser performs translation of input ECMAScript application into the byte-code with the specified format (refer to [Bytecode](#byte-code) and [Parser](#parser) page for details). Prepared bytecode is executed by the Virtual Machine that performs interpretation (refer to [Virtual Machine](#virtual-machine) and [ECMA](#ecma) pages for details).
 
@@ -23,39 +33,39 @@ Expression parser is responsible for parsing JavaScript expressions. It is imple
 
 JavaScript statements are parsed by this component. It uses the [Expression parser](#expression-parser) to parse the constituent expressions. The implementation of Statement parser is located in `./jerry-core/parser/js/js-parser-statm.c`.
 
-Function `parser_parse_source` carries out the parsing and compiling of the input EcmaScript source code. When a function appears in the source `parser_parse_source` calls `parser_parse_function` which is responsible for processing the source code of functions recursively including argument parsing and context handling. After the parsing, function `parser_post_processing` dumps the created opcodes and returns an `ecma_compiled_code_t*` that points to the compiled bytecode sequence.
+Function `parser_parse_source` carries out the parsing and compiling of the input ECMAScript source code. When a function appears in the source `parser_parse_source` calls `parser_parse_function` which is responsible for processing the source code of functions recursively including argument parsing and context handling. After the parsing, function `parser_post_processing` dumps the created opcodes and returns an `ecma_compiled_code_t*` that points to the compiled bytecode sequence.
 
 The interactions between the major components shown on the following figure.
 
-![Parser dependency](img/parser_dependency.png)
+![Parser dependency]({{ site.github.url }}/img/parser_dependency.png){: class="thumbnail center-block img-responsive" }
 
 # Byte-code
 
-This section describes the compact byte-code (CBC) byte-code representation. The key focus is reducing memory consumption of the byte-code representation without sacrificing considerable performance. Other byte-code representations often focus on performance only so inventing this representation is an original research.
+This section describes the compact byte-code (CBC) representation. The key focus is reducing memory consumption of the byte-code representation without sacrificing considerable performance. Other byte-code representations often focus on performance only so inventing this representation is an original research.
 
-CBC is a CISC like instruction set which assigns shorter instructions for frequent operations. Many instructions represent multiple atomic tasks which reduces the byte code size. This technique is basically a data compression method.
+CBC is a CISC like instruction set which assigns shorter instructions for frequent operations. Many instructions represent multiple atomic tasks which reduces the bytecode size. This technique is basically a data compression method.
 
 ## Compiled Code Format
 
-The memory layout of the compiled byte code is the following.
+The memory layout of the compiled bytecode is the following.
 
-![CBC layout](img/CBC_layout.png)
+![CBC layout]({{ site.github.url }}/img/CBC_layout.png){: class="thumbnail center-block img-responsive" }
 
 The header is a `cbc_compiled_code` structure with several fields. These fields contain the key properties of the compiled code.
 
-The literals part is an array of ecma values. These values can contain any EcmaScript value types, e.g. strings, numbers, function and regexp templates. The number of literals is stored in the `literal_end` field of the header.
+The literals part is an array of ecma values. These values can contain any ECMAScript value types, e.g. strings, numbers, functions and regexp templates. The number of literals is stored in the `literal_end` field of the header.
 
-CBC instruction list is a sequence of byte code instructions which represents the compiled code.
+CBC instruction list is a sequence of bytecode instructions which represents the compiled code.
 
 ## Byte-code Format
 
 The memory layout of a byte-code is the following:
 
-![byte-code layout](img/opcode_layout.png)
+![byte-code layout]({{ site.github.url }}/img/opcode_layout.png){: class="thumbnail center-block img-responsive" }
 
 Each byte-code starts with an opcode. The opcode is one byte long for frequent and two byte long for rare instructions. The first byte of the rare instructions is always zero (`CBC_EXT_OPCODE`), and the second byte represents the extended opcode. The name of common and rare instructions start with `CBC_` and `CBC_EXT_` prefix respectively.
 
-The maximum number of opcodes is 511, since 255 common (zero value excluded) and 256 rare instructions can be defined. Currently around 230 frequent and 120 rare instructions are available.
+The maximum number of opcodes is 511, since 255 common (zero value excluded) and 256 rare instructions can be defined. Currently around 215 frequent and 70 rare instructions are available.
 
 There are three types of bytecode arguments in CBC:
 
@@ -63,7 +73,7 @@ There are three types of bytecode arguments in CBC:
 
  * __literal argument__: An integer index which is greater or equal than zero and less than the `literal_end` field of the header. For further information see next section Literals (next).
 
- * __relative branch__: An 1-3 byte long offset. The branch argument might also represent the end of an instruction range. For example the branch argument of `CBC_EXT_WITH_CREATE_CONTEXT` shows the end of a `with` statement. More precisely the position after the last instruction.
+ * __relative branch__: An 1-3 byte long offset. The branch argument might also represent the end of an instruction range. For example the branch argument of `CBC_EXT_WITH_CREATE_CONTEXT` shows the end of a `with` statement. More precisely the position after the last instruction in the with clause.
 
 Argument combinations are limited to the following seven forms:
 
@@ -78,7 +88,7 @@ Argument combinations are limited to the following seven forms:
 ## Literals
 
 Literals are organized into groups whose represent various literal types. Having these groups consuming less space than assigning flag bits to each literal.
-(In the followings, the mentioned ranges represent those indicies which are greater than or equal to the left side and less than the right side of the range. For example a range between `ident_end` and `literal_end` fields of the byte-code header contains those indicies, which are greater than or equal to `ident_end`
+(In the followings, the mentioned ranges represent those indices which are greater than or equal to the left side and less than the right side of the range. For example a range between `ident_end` and `literal_end` fields of the byte-code header contains those indices, which are greater than or equal to `ident_end`
 and less than `literal_end`. If `ident_end` equals to `literal_end` the range is empty.)
 
 The two major group of literals are _identifiers_ and _values_.
@@ -135,26 +145,24 @@ Byte-codes can be placed into four main categories.
 
 Byte-codes of this category serve for placing objects onto the stack. As there are many instructions representing multiple atomic tasks in CBC, there are also many instructions for pushing objects onto the stack according to the number and the type of the arguments. The following table list a few of these opcodes with a brief description.
 
-<span class="CSSTableGenerator" markdown="block">
+<div class="CSSTableGenerator" markdown="block">
 
-| byte-code             | description                                          |
-| --------------------- | ---------------------------------------------------- |
-| CBC_PUSH_LITERAL      | Pushes the value of the given literal argument.      |
-| CBC_PUSH_TWO_LITERALS | Pushes the value of the given two literal arguments. |
-| CBC_PUSH_UNDEFINED    | Pushes an undefined value.                           |
-| CBC_PUSH_TRUE         | Pushes a logical true.                               |
+| byte-code             | description                                           |
+| CBC_PUSH_LITERAL      | Pushes the value of the given literal argument.       |
+| CBC_PUSH_TWO_LITERALS | Pushes the values of the given two literal arguments. |
+| CBC_PUSH_UNDEFINED    | Pushes an undefined value.                            |
+| CBC_PUSH_TRUE         | Pushes a logical true.                                |
 | CBC_PUSH_PROP_LITERAL | Pushes a property whose base object is popped from the stack, and the property name is passed as a literal argument. |
 
-</span>
+</div>
 
 ### Call Byte-codes
 
 The byte-codes of this category perform calls in different ways.
 
-<span class="CSSTableGenerator" markdown="block">
+<div class="CSSTableGenerator" markdown="block">
 
 | byte-code             | description                                                                          |
-| --------------------- | ------------------------------------------------------------------------------------ |
 | CBC_CALL0             | Calls a function without arguments. The return value won't be pushed onto the stack. |
 | CBC_CALL1             | Calls a function with one argument. The return value won't be pushed onto the stack. |
 | CBC_CALL              | Calls a function with n arguments. n is passed as a byte argument. The return value won't be pushed onto the stack. |
@@ -162,16 +170,15 @@ The byte-codes of this category perform calls in different ways.
 | CBC_CALL1_PUSH_RESULT | Calls a function with one argument. The return value will be pushed onto the stack.  |
 | CBC_CALL2_PROP        | Calls a property function with two arguments. The base object, the property name, and the two arguments are on the stack. |
 
-</span>
+</div>
 
 ### Arithmetic, Logical, Bitwise and Assignment Byte-codes
 
 The opcodes of this category perform arithmetic, logical, bitwise and assignment operations.
 
-<span class="CSSTableGenerator" markdown="block">
+<div class="CSSTableGenerator" markdown="block">
 
 | byte-code               | description                                                                                         |
-| ----------------------- | --------------------------------------------------------------------------------------------------- |
 | CBC_LOGICAL_NOT         | Negates the logical value that popped from the stack. The result is pushed onto the stack.          |
 | CBC_LOGICAL_NOT_LITERAL | Negates the logical value that given in literal argument. The result is pushed onto the stack.      |
 | CBC_ADD                 | Adds two values that are popped from the stack. The result is pushed onto the stack.                |
@@ -180,25 +187,24 @@ The opcodes of this category perform arithmetic, logical, bitwise and assignment
 | CBC_ASSIGN              | Assigns a value to a property. It has three arguments: base object, property name, value to assign. |
 | CBC_ASSIGN_PUSH_RESULT  | Assigns a value to a property. It has three arguments: base object, property name, value to assign. The result will be pushed onto the stack. |
 
-</span>
+</div>
 
 ### Branch Byte-codes
 
 Branch byte-codes are used to perform conditional and unconditional jumps in the byte-code. The arguments of these instructions are 1-3 byte long relative offsets. The number of bytes is part of the opcode, so each byte-code with a branch argument has three forms. The direction (forward, backward) is also defined by the opcode since the offset is an unsigned value. Thus, certain branch instructions has six forms. Some examples can be found in the following table.
 
-<span class="CSSTableGenerator" markdown="block">
+<div class="CSSTableGenerator" markdown="block">
 
 | byte-code                  | description                                                 |
-| -------------------------- | ----------------------------------------------------------- |
 | CBC_JUMP_FORWARD           | Jumps forward by the 1 byte long relative offset argument.  |
 | CBC_JUMP_FORWARD_2         | Jumps forward by the 2 byte long relative offset argument.  |
 | CBC_JUMP_FORWARD_3         | Jumps forward by the 3 byte long relative offset argument.  |
 | CBC_JUMP_BACKWARD          | Jumps backward by the 1 byte long relative offset argument. |
 | CBC_JUMP_BACKWARD_2        | Jumps backward by the 2 byte long relative offset argument. |
 | CBC_JUMP_BACKWARD_3        | Jumps backward by the 3 byte long relative offset argument. |
-| CBC_BRANCH_IF_TRUE_FORWARD | Jumps if the value on the top of the stack is true by the 1 byte long relative offset argument. |
+| CBC_BRANCH_IF_TRUE_FORWARD | Jumps forward if the value on the top of the stack is true by the 1 byte long relative offset argument. |
 
-</span>
+</div>
 
 ## Snapshot
 
@@ -219,14 +225,16 @@ ECMA component of the engine is responsible for the following notions:
 
 ## Data Representation
 
-The major structure for data representation is `ECMA_value`. The lower two bits of this structure encode value tag, which determines the type of the value:
+The major structure for data representation is `ECMA_value`. The lower three bits of this structure encode value tag, which determines the type of the value:
 
 * simple
 * number
 * string
 * object
+* symbol
+* error
 
-![ECMA value representation](img/ecma_value.png)
+![ECMA value representation]({{ site.github.url }}/img/ecma_value.png){: class="thumbnail center-block img-responsive" }
 
 In case of number, string and object the value contains an encoded pointer, and
 simple value is a pre-defined constant which can be:
@@ -241,26 +249,27 @@ simple value is a pre-defined constant which can be:
 
 Compressed pointers were introduced to save heap space.
 
-![Compressed Pointer](img/ecma_compressed.png)
+![Compressed Pointer]({{ site.github.url }}/img/ecma_compressed.png){: class="thumbnail center-block img-responsive" }
 
-These pointers are 8 byte aligned 16 bit long pointers which can address 512 Kb of memory which is also the maximum size of the JerryScript heap.
-
-ECMA data elements are allocated in pools (pools are allocated on heap)
-Chunk size of the pool is 8 bytes (reduces fragmentation).
+These pointers are 8 byte aligned 16 bit long pointers which can address 512 Kb of
+memory which is also the maximum size of the JerryScript heap. To support even more
+memory the size of compressed pointers can be extended to 32 bit to cover the entire
+address space of a 32 bit system by passing "--cpointer_32_bit on" to the build
+system. These "uncompressed pointers" increases the memory consumption by around 20%.
 
 ### Number
 
 There are two possible representation of numbers according to standard IEEE 754:
 The default is 8-byte (double),
-but the engine supports the 4-byte (single precision) representation by setting CONFIG_ECMA_NUMBER_TYPE as well.
+but the engine supports the 4-byte (single precision) representation by setting JERRY_NUMBER_TYPE_FLOAT64 to 0 as well.
 
-![Number](img/number.png)
+![Number]({{ site.github.url }}/img/number.png){: class="thumbnail center-block img-responsive" }
 
 Several references to single allocated number are not supported. Each reference holds its own copy of a number.
 
 ### String
 
-Strings in JerryScript are not just character sequences, but can hold numbers and so-called magic ids too. For common character sequences there is a table in the read only memory that contains magic id and character sequence pairs. If a string is already in this table, the magic id of its string is stored, not the character sequence itself. Using numbers speeds up the property access. These techniques save memory.
+Strings in JerryScript are not just character sequences, but can hold numbers and so-called magic ids too. For common character sequences (defined in `./jerry-core/lit/lit-magic-strings.ini`) there is a table in the read only memory that contains magic id and character sequence pairs. If a string is already in this table, the magic id of its string is stored, not the character sequence itself. Using numbers speeds up the property access. These techniques save memory.
 
 ### Object / Lexical Environment
 
@@ -268,21 +277,21 @@ An object can be a conventional data object or a lexical environment object. Unl
 
 [Lexical environments](http://www.ecma-international.org/ecma-262/5.1/#sec-10.2) are implemented as objects in JerryScript, since lexical environments contains key-value pairs (called bindings) like objects. This simplifies the implementation and reduces code size.
 
-![Object/Lexicat environment structures](img/ecma_object.png)
+![Object/Lexical environment structures]({{ site.github.url }}/img/ecma_object.png){: class="thumbnail center-block img-responsive" }
 
 The objects are represented as following structure:
 
   * Reference counter - number of hard (non-property) references
   * Next object pointer for the garbage collector
-  * GC's visited flag
   * type (function object, lexical environment, etc.)
 
 ### Properties of Objects
 
-![Object properties](img/ecma_object_property.png)
+![Object properties]({{ site.github.url }}/img/ecma_object_property.png){: class="thumbnail center-block img-responsive" }
 
 Objects have a linked list that contains their properties. This list actually contains property pairs, in order to save memory described in the followings:
-A property is 7 bit long and its type field is 2 bit long which consumes 9 bit which does not fit into 1 byte but consumes 2 bytes. Hence, placing together two properties (14 bit) with the 2 bit long type field fits into 2 bytes.
+A property has a one byte long descriptor, a two byte long name and four byte long value. Hence 14 bytes consumed by a property pair. Another two bytes is
+used to show the next property pair, so the total size (16 byte) is divisible by 8.
 
 #### Property Hashmap
 
@@ -310,7 +319,7 @@ Internal properties are special properties that carry meta-information that cann
 
 LCache is a hashmap for finding a property specified by an object and by a property name. The object-name-property layout of the LCache presents multiple times in a row as it is shown in the figure below.
 
-![LCache](img/ecma_lcache.png)
+![LCache]({{ site.github.url }}/img/ecma_lcache.png){: class="thumbnail center-block img-responsive" }
 
 When a property access occurs, a hash value is extracted from the demanded property name and than this hash is used to index the LCache. After that, in the indexed row the specified object and property name will be searched.
 
@@ -322,7 +331,7 @@ Collections are array-like data structures, which are optimized to save memory.
 
 ### Exception Handling
 
-In order to implement a sense of exception handling, the return values of JerryScript functions are able to indicate their faulty or "exceptional" operation. The return values are actually ECMA values (see section [Data Representation](#data-representation)) in which the error bit is set if an erroneous operation is occurred.
+In order to implement a sense of exception handling, the return values of JerryScript functions are able to indicate their faulty or "exceptional" operation. The return values are ECMA values (see section [Data Representation](#data-representation)) and if an erroneous operation occurred the ECMA_VALUE_ERROR simple value is returned.
 
 ### Value Management and Ownership
 

05.PORT-API.md

@@ -0,0 +1,286 @@
+---
+layout: page
+title: Port API
+category: documents
+permalink: /port-api/
+---
+
+* toc
+{:toc}
+
+# Reference
+
+## Process management
+
+It is questionable whether a library should be able to terminate an application. Any API function can signal an error (ex.: cannot allocate memory), so the engine use the termination approach with this port function.
+
+```c
+/**
+ * Init the program
+ */
+void jerry_port_init (void);
+```
+
+```c
+/**
+ * Signal the port that jerry experienced a fatal failure from which it cannot
+ * recover.
+ *
+ * @param code gives the cause of the error.
+ *
+ * Note:
+ *      Jerry expects the function not to return.
+ *
+ * Example: a libc-based port may implement this with exit() or abort(), or both.
+ */
+void jerry_port_fatal (jerry_fatal_code_t code);
+```
+
+Error codes
+
+```c
+typedef enum
+{
+  JERRY_FATAL_OUT_OF_MEMORY = 10,
+  JERRY_FATAL_REF_COUNT_LIMIT = 12,
+  JERRY_FATAL_DISABLED_BYTE_CODE = 13,
+  JERRY_FATAL_UNTERMINATED_GC_LOOPS = 14,
+  JERRY_FATAL_FAILED_ASSERTION = 120
+} jerry_fatal_code_t;
+```
+
+```c
+/**
+ * Makes the process sleep for a given time.
+ *
+ * Note:
+ *      This port function is called by jerry-core when JERRY_DEBUGGER is set to 1.
+ *      Otherwise this function is not used.
+ *
+ * @param sleep_time milliseconds to sleep.
+ */
+void jerry_port_sleep (uint32_t sleep_time);
+```
+
+## External context
+
+Allows the user to provide external buffer for isolated engine contexts, so that user
+can configure the heap size at runtime and run multiple JS applications
+simultaneously.
+
+```c
+/**
+ * Allocate a new context for the engine.
+ *
+ * This port function is called by jerry_init when JERRY_EXTERNAL_CONTEXT is enabled. Otherwise this function is not
+ * used. The engine will pass the size required for the context structure. An implementation must make sure to
+ * allocate at least this amount.
+ *
+ * Excess allocated space will be used as the engine heap when jerryscript is configured to use it's internal allocator,
+ * this can be used to control the internal heap size.
+ *
+ * NOTE: The allocated memory must be pointer-aligned, otherwise the behavior is
+ *       undefined.
+ *
+ * @param context_size: the size of the internal context structure
+ *
+ * @return total size of the allocated buffer
+ */
+size_t jerry_port_context_alloc (size_t context_size);
+```
+
+```c
+/**
+ * Get the currently active context of the engine.
+ *
+ * This port function is called by jerry-core when JERRY_EXTERNAL_CONTEXT is enabled.
+ * Otherwise this function is not used.
+ *
+ * @return the pointer to the currently used engine context.
+ */
+struct jerry_context_t *jerry_port_context_get (void);
+```
+
+```c
+/**
+ * Free the currently used context.
+ *
+ * This port function is called by jerry_cleanup when JERRY_EXTERNAL_CONTEXT is enabled.
+ * Otherwise this function is not used.
+ *
+ * @return the pointer to the engine context.
+ */
+void jerry_port_context_free (void);
+```
+
+## I/O
+
+```c
+/**
+ * Display or log a debug/error message.
+ *
+ * The message is passed as a zero-terminated string. Messages may be logged in parts, which
+ * will result in multiple calls to this functions. The implementation should consider
+ * this before appending or prepending strings to the argument.
+ *
+ * This function is called with messages coming from the jerry engine as
+ * the result of some abnormal operation or describing its internal operations
+ * (e.g., data structure dumps or tracing info).
+ *
+ * The implementation can decide whether error and debug messages are logged to
+ * the console, or saved to a database or to a file.
+ */
+void jerry_port_log (const char *message_p);
+```
+
+```c
+/**
+ * Print a buffer to standard output
+ *
+ * This port function is never called from jerry-core directly, it is only used by jerry-ext components to print
+ * information.
+ *
+ * @param buffer_p: input buffer
+ * @param buffer_size: data size
+ */
+void jerry_port_print_buffer (const jerry_char_t *buffer_p, jerry_size_t buffer_size);
+```
+
+```c
+/**
+ * Read a line from standard input.
+ *
+ * The implementation should allocate storage necessary for the string. The result string should include the ending line
+ * terminator character(s) and should be zero terminated.
+ *
+ * An implementation may return NULL to signal that the end of input is reached, or an error occured.
+ *
+ * When a non-NULL value is returned, the caller will pass the returned value to `jerry_port_line_free` when the line is
+ * no longer needed. This can be used to finalize dynamically allocated buffers if necessary.
+ *
+ * This port function is never called from jerry-core directly, it is only used by some jerry-ext components that
+ * require user input.
+ *
+ * @param out_size_p: size of the input string in bytes, excluding terminating zero byte
+ *
+ * @return pointer to the buffer storing the string,
+ *         or NULL if end of input
+ */
+jerry_char_t *jerry_port_line_read (jerry_size_t *out_size_p);
+```
+
+```c
+/**
+ * Free a line buffer allocated by jerry_port_line_read
+ *
+ * @param buffer_p: buffer returned by jerry_port_line_read
+ */
+void jerry_port_line_free (jerry_char_t *buffer_p);
+```
+
+## Filesystem
+
+```
+/**
+ * Canonicalize a file path.
+ *
+ * If possible, the implementation should resolve symbolic links and other directory references found in the input path,
+ * and create a fully canonicalized file path as the result.
+ *
+ * The function may return with NULL in case an error is encountered, in which case the calling operation will not
+ * proceed.
+ *
+ * The implementation should allocate storage for the result path as necessary. Non-NULL return values will be passed
+ * to `jerry_port_path_free` when the result is no longer needed by the caller, which can be used to finalize
+ * dynamically allocated buffers.
+ *
+ * NOTE: The implementation must not return directly with the input, as the input buffer is released after the call.
+ *
+ * @param path_p: zero-terminated string containing the input path
+ * @param path_size: size of the input path string in bytes, excluding terminating zero
+ *
+ * @return buffer with the normalized path if the operation is successful,
+ *         NULL otherwise
+ */
+jerry_char_t *jerry_port_path_normalize (const jerry_char_t *path_p, jerry_size_t path_size);
+```
+
+```c
+/**
+ * Free a path buffer returned by jerry_port_path_normalize.
+ *
+ * @param path_p: the path buffer to free
+ */
+void jerry_port_path_free (jerry_char_t *path_p);
+```
+
+```c
+/**
+ * Get the offset of the basename component in the input path.
+ *
+ * The implementation should return the offset of the first character after the last path separator found in the path.
+ * This is used by the caller to split the path into a directory name and a file name.
+ *
+ * @param path_p: input zero-terminated path string
+ *
+ * @return offset of the basename component in the input path
+ */
+jerry_size_t jerry_port_path_base (const jerry_char_t *path_p);
+```
+
+```c
+/**
+ * Open a source file and read its contents into a buffer.
+ *
+ * When the source file is no longer needed by the caller, the returned pointer will be passed to
+ * `jerry_port_source_free`, which can be used to finalize the buffer.
+ *
+ * @param file_name_p: Path that points to the source file in the filesystem.
+ * @param out_size_p: The opened file's size in bytes.
+ *
+ * @return pointer to the buffer which contains the content of the file.
+ */
+jerry_char_t *jerry_port_source_read (const char *file_name_p, jerry_size_t *out_size_p);
+```
+
+```c
+/**
+ * Free a source file buffer.
+ *
+ * @param buffer_p: buffer returned by jerry_port_source_read
+ */
+void jerry_port_source_free (jerry_char_t *buffer_p);
+```
+
+## Date
+
+```c
+/**
+ * Get local time zone adjustment in milliseconds for the given input time.
+ *
+ * The argument is a time value representing milliseconds since unix epoch.
+ *
+ * Ideally, this function should satisfy the stipulations applied to LocalTZA
+ * in section 21.4.1.7 of the ECMAScript version 12.0, as if called with isUTC true.
+ *
+ * This port function can be called by jerry-core when JERRY_BUILTIN_DATE is enabled.
+ * Otherwise this function is not used.
+ *
+ * @param unix_ms: time value in milliseconds since unix epoch
+ *
+ * @return local time offset in milliseconds applied to UTC for the given time value
+ */
+int32_t jerry_port_local_tza (double unix_ms);
+```
+
+```c
+/**
+ * Get the current system time in UTC.
+ *
+ * This port function is called by jerry-core when JERRY_BUILTIN_DATE is enabled.
+ * It can also be used in the implementing application to initialize the random number generator.
+ *
+ * @return milliseconds since Unix epoch
+ */
+double jerry_port_current_time (void);
+```

06.REFERENCE-COUNTING.md

@@ -0,0 +1,186 @@
+---
+layout: page
+title: Reference Counting
+category: documents
+permalink: /reference-counting/
+---
+
+* toc
+{:toc}
+
+## Reference counting in JerryScript
+
+In JerryScript all `jerry_value_t` values are independent
+references to internal objects. Values returned by JerryScript
+API functions are always live references and must be released
+by `jerry_value_free`.
+
+```c
+  jerry_value_t global = jerry_current_realm ();
+
+  /* The value stored in the 'global' variable contains a live
+   * reference to the global object. The system also keeps its
+   * own live reference to the global object. These two references
+   * are independent, and both must be destroyed before the global
+   * object can be freed. */
+
+  jerry_value_free (global);
+
+  /* Without jerry_value_free() the global object will not
+   * be freed even by jerry_cleanup(). After the reference
+   * is released it becomes a dead reference and cannot be
+   * used anymore. */
+```
+
+Multiple references might refer to the same internal object
+even though their `jerry_value_t` representation might be different.
+
+```c
+  jerry_value_t pi_ref1 = jerry_number (3.14);
+  jerry_value_t pi_ref2 = jerry_value_copy (pi_ref1);
+
+  /* Both pi_ref1 and pi_ref2 refer to the same 3.14 value
+   * although they might not be equal in C (pi_ref1 != pi_ref2). */
+
+  /* Both references must be released. */
+  jerry_value_free (pi_ref1);
+  jerry_value_free (pi_ref2);
+```
+
+Releasing the same `jerry_value_t` twice to release two live
+references is not allowed and it might cause crashes. Hence the
+following code is an **INCORRECT WAY** of releasing the 3.14 value.
+
+```c
+  jerry_value_free (pi_ref1);
+  jerry_value_free (pi_ref1);
+```
+
+JerryScript API functions returning with a `jerry_value_t` always
+return with a new live reference. Passing a `jerry_value_t` to
+an API function never releases its reference (unless explicitly
+stated in the documentation). The next example shows this
+behaviour through property getting and setting.
+
+```c
+  jerry_value_t prop_value = jerry_object_get (...);
+
+  /* The prop_value must be released later because both the base
+   * object and the prop_value have an independent reference to
+   * the same JavaScript value. When the operation fails, the
+   * prop_value contains a live reference to an error object.
+   * This reference must be released as well. */
+
+  if (jerry_value_is_exception (prop_value))
+  {
+    /* Errors can be handled here. */
+  }
+  else
+  {
+    /* The application has a live reference to the property
+     * value even if the base object is freed by the garbage
+     * collector. */
+  }
+
+  /* The prop_value must be released. */
+  jerry_value_free (prop_value);
+
+  /* Property setting is the same. */
+
+  jerry_value_t new_prop_value = jerry_number (2.718);
+  jerry_value_t result = jerry_object_set (..., new_prop_value);
+
+  /* If the property set is successful, a new reference is created
+   * for the value referenced by new_prop_value. The new_prop_value
+   * reference must be released regardless of whether the operation
+   * is successful. */
+
+  /* The new_prop_value can be passed to other JerryScript API
+   * functions before the jerry_value_free () call. */
+
+  jerry_value_free (new_prop_value);
+
+  /* The reference stored in the 'result' variable is live whether
+   * the operation is successful or not, and must also be freed. */
+
+  if (jerry_value_is_exception (result))
+  {
+    /* Errors can be handled here. */
+  }
+  else
+  {
+    /* A reference to a true primitive value is returned. */
+  }
+
+  jerry_value_free (result);
+```
+
+The simplest form of setting a property without error checking
+is the following:
+
+```c
+  /* There are no 'ifs' in this snippet. */
+  jerry_value_free (jerry_object_set (..., new_prop_value));
+  jerry_value_free (new_prop_value);
+```
+
+The reference returned by a `jerry_external_handler_t` callback
+transfers the ownership of the live reference. Otherwise the
+referenced object could be freed by the garbage collector.
+
+```c
+jerry_value_t my_external_handler (const jerry_value_t function_obj,
+                                   const jerry_value_t this_val,
+                                   const jerry_value_t args_p[],
+                                   const jerry_length_t args_count
+{
+  /* Do not release function_obj, this_val, and args_p because
+   * these references are automatically released after the handler
+   * is returned. This approach reduces code size which is useful
+   * on embedded systems. However you can create other references
+   * to them by calling jerry_value_copy () if needed. */
+
+  /* Since the ownership of the reference is transferred to the
+   * caller the following snippet is valid. */
+
+  /* If the value to be returned is needed for other purposes the
+   * jerry_value_copy () can be used to create new references. */
+  return jerry_string (...);
+}
+```
+
+Duplicating a `jerry_value_t` in C does not create another live reference.
+
+```c
+  jerry_value_t undef = jerry_undefined ();
+  jerry_value_t undef2 = undef;
+
+  /* Releasing either undef or undef2 is valid but not both.
+   * After the release both references become dead (invalid). */
+  jerry_value_free (undef2);
+
+  /* Dead references can be reassigned again. */
+  undef = jerry_boolean (true);
+```
+
+References can be duplicated in C as long as only one of them is freed.
+
+```c
+  jerry_value_t a = jerry_boolean (true);
+
+  jerry_value_t b = a;
+  jerry_value_t c = a;
+
+  /* A new reference is assigned to 'a'. */
+  a = jerry_boolean (false);
+
+  [...]
+
+  jerry_value_free (a);
+  /* The 'a' (boolean false) reference becomes dead (invalid). */
+
+  jerry_value_free (c);
+  /* Both 'b' and 'c' (boolean true) references become dead. */
+
+  /* Since all references are released, no memory leak occurs. */
+```

07.DEBUGGER.md

@@ -0,0 +1,425 @@
+---
+layout: page
+title: Debugger
+category: documents
+permalink: /debugger/
+---
+
+* toc
+{:toc}
+
+## JerryScript debugger interface
+
+JerryScript provides a remote debugger which allows debugging
+JavaScript programs. The debugger has two main components:
+a server which is part of the JerryScript binary and a
+separate client application. Currently a Python-based debugger
+client is available in the /jerry-debugger subdirectory.
+This simple application demonstrates the communication protocol
+between the client and server, and can be reused by integrated
+development environments.
+
+## Setting up the debugger server
+
+The following arguments must be passed to `tools/build.py`:
+
+`--jerry-debugger=on`
+
+The transport layer of the communication protocol is pluggable.
+At the moment, a WebSocket-based implementation is provided as a
+JerryScript extension, which transmits messages over TCP/IP networks.
+If necessary/implemented, any reliable stream or datagram based
+protocol can be used for transmitting debugger messages.
+
+## Debugging JavaScript applications
+
+The debugger client must be connected to the server before the
+JavaScript application runs. On-the-fly attachment is supported
+for more than one file, right after the engine initialization
+(this feature is available with the python client). The debugging
+information (e.g. line index of each possible breakpoint location)
+is not preserved by JerryScript. The client is expected to be run
+on a system with much more resources and it should be capable of
+storing this information. JerryScript frees all debug information
+after it is transmitted to the client to save memory.
+
+The following argument makes JerryScript wait for a client
+connection:
+
+`--start-debug-server`
+
+The following argument makes JerryScript wait for a client
+source code:
+
+`--debugger-wait-source`
+
+It is also recommended to increase the log level to see
+the *Waiting for client connection* message:
+
+`--log-level 2`
+
+The Python client can connect to the server by specifying its
+IP address on the command line. The address can be localhost
+if the server and the client are running on the same machine.
+
+After the connection is established the execution can be
+controlled by the debugger. The debugger always stops at
+the first possible breakpoint location. The effect is the
+same as using the `stop` command. This allows inserting
+breakpoints right before the meaningful part of the execution
+starts.
+
+All available commands of the client can be queried by the
+`help` command.
+
+## Integrating debugger support into applications using JerryScript
+
+When using the extension-provided WebSocket transport layer, the
+debugger can be enabled by calling `jerryx_debugger_after_connect
+(jerryx_debugger_tcp_create (debug_port) && jerryx_debugger_ws_create ())`
+after the `jerry_init ()` function. It initializes the debugger and
+blocks until a client connects.
+(Custom transport layers may be implemented and initialized similarly.
+Currently, `jerryx_debugger_rp_create ()` for raw packet transport layer and
+`jerryx_debugger_serial_create (const char* config)` for serial protocol
+are also available.)
+
+The source name provided to `jerry_parse ()` is used by the client
+to identify the source name of the source code. This source name
+is usually a file name.
+
+## JerryScript debugger C-API interface
+
+The following section describes the debugger functions
+available to the host application.
+
+## JerryScript debugger types
+
+## jerry_debugger_wait_for_source_callback_t
+
+**Summary**
+
+This callback function is called by
+[jerry_debugger_wait_for_client_source](#jerry_debugger_wait_for_client_source)
+when a source code is received successfully.
+
+**Prototype**
+
+```c
+typedef jerry_value_t
+(*jerry_debugger_wait_for_source_callback_t) (const jerry_char_t *source_name_p,
+                                              size_t source_name_size,
+                                              const jerry_char_t *source_p,
+                                              size_t source_size,
+                                              void *user_p);
+```
+
+- `source_name_p` - source (usually a file) name of the source code
+- `source_name_size` - size of source name
+- `source_p` - source code character data
+- `source_size` - size of source code
+- `user_p` - custom pointer passed to [jerry_debugger_wait_for_client_source](#jerry_debugger_wait_for_client_source)
+
+
+## JerryScript debugger functions
+
+### jerry_debugger_is_connected
+
+**Summary**
+
+Returns true if a remote debugger client is connected.
+
+**Prototype**
+
+```c
+bool
+jerry_debugger_is_connected (void);
+```
+
+**Example**
+
+[doctest]: # (test="link")
+
+```c
+#include <stdio.h>
+
+#include "jerryscript.h"
+#include "jerryscript-ext/debugger.h"
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+  jerryx_debugger_after_connect (jerryx_debugger_tcp_create (5001)
+                                 && jerryx_debugger_ws_create ());
+
+  if (jerry_debugger_is_connected ())
+  {
+    printf ("A remote debugger client is connected.");
+  }
+
+  jerry_cleanup ();
+}
+```
+
+### jerry_debugger_stop
+
+**Summary**
+
+Stops execution at the next available breakpoint if a remote
+debugger client is connected and the engine is not waiting at
+a breakpoint. The engine will stop regardless the breakpoint
+is enabled or not.
+
+**Prototype**
+
+```c
+void
+jerry_debugger_stop (void)
+```
+
+**Example**
+
+[doctest]: # (test="link")
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/debugger.h"
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+  jerryx_debugger_after_connect (jerryx_debugger_tcp_create (5001)
+                                 && jerryx_debugger_ws_create ());
+
+  jerry_debugger_stop ();
+
+  jerry_cleanup ();
+}
+```
+
+**See also**
+
+- [jerry_debugger_continue](#jerry_debugger_continue)
+
+### jerry_debugger_continue
+
+**Summary**
+
+If the engine would stop at the next available breakpoint it
+cancels this effect. The engine will still stop at enabled
+breakpoints. This function effectively negates the effect of
+[jerry_debugger_stop ()](#jerry_debugger_stop) calls or stop
+requests issued by the debugger client.
+
+**Prototype**
+
+```c
+void
+jerry_debugger_continue (void)
+```
+
+**Example**
+
+[doctest]: # (test="link")
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/debugger.h"
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+  jerryx_debugger_after_connect (jerryx_debugger_tcp_create (5001)
+                                 && jerryx_debugger_ws_create ());
+
+  jerry_debugger_continue ();
+
+  jerry_cleanup ();
+}
+```
+
+**See also**
+
+- [jerry_debugger_stop](#jerry_debugger_stop)
+
+### jerry_debugger_stop_at_breakpoint
+
+**Summary**
+
+Enables or disables stopping at breakpoints. When stopping is
+disabled all breakpoints are ignored including user enabled
+breakpoints. This allows hidden execution of ECMAScript code.
+
+**Prototype**
+
+```c
+void
+jerry_debugger_stop_at_breakpoint (bool enable_stop_at_breakpoint)
+```
+
+- `enable_stop_at_breakpoint` - enable (=`true`) or disable (=`false`) stopping at breakpoints
+
+**Example**
+
+[doctest]: # (test="link")
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/debugger.h"
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+  jerryx_debugger_after_connect (jerryx_debugger_tcp_create (5001)
+                                 && jerryx_debugger_ws_create ());
+
+  jerry_debugger_stop_at_breakpoint (true);
+
+  // Protected execution of JavaScript code.
+  const jerry_char_t script[] = "42";
+  jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
+
+  jerry_debugger_stop_at_breakpoint (false);
+
+  jerry_cleanup ();
+}
+```
+
+### jerry_debugger_wait_for_client_source
+
+**Summary**
+
+Asks the client to provide the next source code. The function
+waits until the whole source code is received. As a reply the
+the client may request a context reset or notify that no more
+source is available. These notifications are passed back as the
+return value of the function.
+
+**Prototype**
+
+```c
+jerry_debugger_wait_for_source_status_t
+jerry_debugger_wait_for_client_source (jerry_debugger_wait_for_source_callback_t callback_p,
+                                       void *user_p,
+                                       jerry_value_t *return_value)
+```
+
+**Example**
+
+[doctest]: # (test="link")
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/debugger.h"
+
+/**
+ * Runs the source code received by jerry_debugger_wait_for_client_source.
+ */
+static jerry_value_t
+wait_for_source_callback (const jerry_char_t *source_name_p, /**< source name */
+                          size_t source_name_size, /**< size of source name */
+                          const jerry_char_t *source_p, /**< source code */
+                          size_t source_size, /**< source code size */
+                          void *user_p /**< user pointer */)
+{
+  (void) user_p;
+
+  jerry_parse_options_t parse_options;
+  parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
+  parse_options.source_name = jerry_string ((const jerry_char_t *) source_name_p,
+                                              (jerry_size_t) source_name_size,
+                                              JERRY_ENCODING_UTF8);
+
+  jerry_value_t ret_val = jerry_parse (source_p,
+                                       source_size,
+                                       &parse_options);
+  jerry_value_free (parse_options.source_name);
+
+  if (!jerry_value_is_exception (ret_val))
+  {
+    jerry_value_t func_val = ret_val;
+    ret_val = jerry_run (func_val);
+    jerry_value_free (func_val);
+  }
+
+  return ret_val;
+} /* wait_for_source_callback */
+
+int
+main (void)
+{
+  jerry_debugger_wait_for_source_status_t receive_status;
+
+  do
+  {
+    /* Create a new JerryScript instance when a context reset is
+     * received. Applications usually registers their core bindings
+     * here as well (e.g. print, setTimeout). */
+    jerry_init (JERRY_INIT_EMPTY);
+    jerryx_debugger_after_connect (jerryx_debugger_tcp_create (5001)
+                                   && jerryx_debugger_ws_create ());
+
+    do
+    {
+      jerry_value_t run_result;
+
+      receive_status = jerry_debugger_wait_for_client_source (wait_for_source_callback,
+                                                              NULL,
+                                                              &run_result);
+
+      jerry_value_free (run_result);
+    }
+    while (receive_status == JERRY_DEBUGGER_SOURCE_RECEIVED);
+
+    jerry_cleanup ();
+  }
+  while (receive_status == JERRY_DEBUGGER_CONTEXT_RESET_RECEIVED);
+
+  if (receive_status == JERRY_DEBUGGER_SOURCE_RECEIVE_FAILED)
+  {
+    // Handle the failure (e.g. display an error).
+  }
+  return 0;
+}
+```
+
+### jerry_debugger_send_output
+
+**Summary**
+
+Sends the program's output to the debugger client.
+
+**Prototype**
+
+```c
+void
+jerry_debugger_send_output (const jerry_char_t *buffer, jerry_size_t str_size)
+```
+
+**Example**
+
+[doctest]: # (test="link")
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/debugger.h"
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+  jerryx_debugger_after_connect (jerryx_debugger_tcp_create (5001)
+                                 && jerryx_debugger_ws_create ());
+
+  jerry_char_t my_output[] = "Hey, this should be sent too!";
+  jerry_size_t my_output_size = sizeof (my_output);
+
+  jerry_debugger_send_output (my_output, my_output_size);
+
+  jerry_cleanup ();
+}
+```

08.CODING-STANDARDS.md

@@ -0,0 +1,813 @@
+---
+layout: page
+title: Coding Standards
+category: documents
+permalink: /coding-standards/
+---
+
+* toc
+{:toc}
+
+# JerryScript Coding Standards
+
+This text is a brief overview of JerryScript Coding Standards.
+Each rule starts with a short description followed by several
+examples. We believe examples are better than long explanations.
+Please follow these guidelines when you submit a patch for
+review.
+
+## General rules
+
+* Indentation is two spaces.
+* Tab characters are not allowed.
+* Maximum line length is 120 characters (excluding newline).
+* No trailing white space is allowed.
+* Run `tools/run-tests.py --check-format` to check several
+  of the coding conventions automatically.
+
+## Comments
+
+Only block comments (`/* */`) are allowed in JerryScript.
+Comments should be complete sentences (e.g. start with an
+upper case letter), except for return value, field and
+argument descriptions (see the exceptions below). The
+text part of a comment should focus on explaining *why*
+the code is doing something rather than *what* the code
+is doing.
+
+```diff
++++ Good +++
+```
+
+```c
+  /* A perfect comment. */
+
+  /* A perfect multiline
+   * comment. Each line should
+   * start with an asterisk. */
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+  // Double slash comments are not allowed.
+
+  /* not a complete sentence */
+
+  /* A bad multiline
+     comment. */
+```
+
+All types, constants and functions require a description in
+JerryScript. These comments should start with `/**`. The starting
+`/**` and ending `*/` must be on separate lines.
+
+```diff
++++ Good +++
+```
+
+```c
+/**
+ * A correct description.
+ */
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+/** An incorrect description. */
+```
+
+## Preprocessor defines
+
+The name of a preprocessor macro must be an uppercase string
+and these macros must be preceded by a description.
+Abbreviations are allowed but not preferred in new code.
+
+```diff
++++ Good +++
+```
+
+```c
+/**
+ * Short description about the constant.
+ */
+#define JERRY_VALUE_SEVEN 7
+
+/**
+ * Short description about the macro function.
+ */
+#define JERRY_ADD_TWO_NUMBERS(arg1, arg2) \
+  ((arg1) + (arg2))
+
+/**
+ * Although this is correct, a reviewer might request
+ * to change NUMS to NUMBERS. Hence it is recommended
+ * to use NUMBERS in the first place.
+ */
+#define JERRY_ADD_TWO_NUMS(arg1, arg2) \
+  ((arg1) + (arg2))
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+#define JERRY_CONSTANT_WITHOUT_DESCRIPTION 5
+
+#define JeRrY_mIxEd_CaSe_NaMe "str"
+```
+
+## Conditional preprocessor directives
+
+A comment is required after `#else` and `#endif` in JerryScript.
+The defined keyword should be omitted from these comments.
+
+```diff
++++ Good +++
+```
+
+```c
+#ifdef JERRY_A
+
+#else /* !JERRY_A */
+
+#endif /* JERRY_A */
+
+#ifdef JERRY_A
+#if defined JERRY_B && defined JERRY_C && (JERRY_C > 6)
+
+#else /* !(JERRY_B && JERRY_C && (JERRY_C > 6)) */
+
+#endif /* JERRY_B && JERRY_C && (JERRY_C > 6) */
+#endif /* JERRY_A */
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+#ifdef JERRY_A
+
+#endif
+
+#ifdef JERRY_A
+
+#endif /* defined JERRY_A */
+
+#ifdef JERRY_B
+  /* Missing comment after else. */
+#else
+
+#endif /* JERRY_B */
+```
+
+## Code blocks
+
+Each code block must be enclosed in curly braces even
+if it is a single line statement. These braces must
+be on separate lines. There must be a single space
+before the opening parenthesis of the expression
+after if/while/switch keywords.
+
+```diff
++++ Good +++
+```
+
+```c
+if (value > 6)
+{
+  function_call ();
+}
+
+if (value > 1)
+{
+  function_call_a ();
+}
+else
+{
+  function_call_b ();
+}
+
+do
+{
+  function_call ();
+  value++;
+}
+while (value < 6);
+
+switch (value)
+{
+  case A:
+  {
+    /* FALLTHRU comment is allowed if a
+     * switch-case is not terminated by
+     * break/continue/return. */
+
+    /* FALLTHRU */
+  }
+  case B:
+  case C:
+  {
+    break;
+  }
+  case D:
+  {
+    /* We can use continue if we are in a loop. */
+    continue;
+  }
+  default:
+  {
+    return;
+  }
+}
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+if (value > 6)
+  function_call_a ();
+else
+  function_call_b ();
+
+if (value > 6) {
+  function_call_a ();
+}
+
+if (value > 6) function_call_a ();
+else { function_call_b (); }
+
+if
+(value > 6)
+{
+}
+
+switch (value) {
+  case 0: break;
+  default: {
+    return 5;
+  }
+}
+
+switch (value)
+{
+  case A:
+  {
+    if (value > 6)
+    {
+      CASE B:
+      {
+        /* This is allowed in C but
+         * not in JerryScript. */
+        break;
+      }
+    }
+  }
+}
+
+do
+  value++;
+while (value < 5);
+
+do {
+  value++;
+} while (value < 5);
+
+do
+{
+  value++;
+} while (value < 5);
+```
+
+## Newlines
+
+A newline in JerryScript is a separator which separates different
+parts of the source code. Its primary purpose is to improve
+readability. Unlike other rules developers have some freedom
+to add newlines to their code. However there are some rules.
+
+* Only a single newline separator is allowed.
+* Source files must be terminated by a newline.
+* Global declarations must be separated by a newline.
+* Newlines are not allowed after an opening curly brace or before
+  a closing curly brace
+* No newlines are allowed between control statements (if-else, while,
+  for, switch, etc.) and their code blocks.
+* There should be a newline after the variable declarations
+  if they are the first statements of a block.
+
+```diff
++++ Good +++
+```
+
+```c
+if (a > 5)
+{
+  /* Newline must be present after the first
+   * variable declarations of a code block. */
+  int j = a - 1;
+  int k = a * 2;
+
+  return j + k;
+}
+
+while (a < 5)
+{
+  a++;
+
+  /* It is recommended to put a newline after
+   * intermediate variable declarations. */
+  int i = a * 2;
+
+  b = i - 3;
+}
+
+/* It is a recommended to put newlines around asserts. */
+a = b + 5;
+
+JERRY_ASSERT (a < 20);
+
+c = a + 7;
+
+/* It is a good practice to put a newline after a multiline
+ * function call (see Function calls later). */
+f (a,
+   b,
+   c);
+
+a = 6;
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+/* No newlines are allowed after an opening curly
+ * brace or before a closing curly brace */
+
+while (a > 0)
+{
+
+  a = 6;
+
+}
+
+if (a > 5)
+{
+  while (b < 6)
+  {
+
+    b++;
+  }
+
+}
+
+
+/* Two or more newlines are not allowed. */
+a = 6;
+
+
+b = 7;
+
+/* No newlines are allowed between control statements
+ * and their code blocks. */
+
+if (a > 6)
+
+{
+}
+
+else
+
+{
+}
+
+do
+
+{
+}
+
+while (a < 6);
+```
+
+## Expressions
+
+Spaces are required around binary operators. No space is
+needed otherwise.
+
+```diff
++++ Good +++
+```
+
+```c
+a = b + c;
+a = (b + c) << 3;
+a = b = c + ~d;
+a += ++c + d++;
+call_function (a * (b + !!c) - d + (e % f));
+if (a)
+{
+}
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+a=b+c;
+a = b+c;
+a  +=  c  +  ( d );
+/* Introduce temporary variables or macros
+ * if the expression is too long. Occurs rarely.. */
+a = b
+  + c;
+if ( a + b > 0 )
+{
+}
+```
+
+## Logical operators
+
+All expressions with && and || logical operators must be
+enclosed in parentheses. A single and multiline form is
+allowed for these expressions. In the latter case each
+line must start with the logical operator and each line
+must be aligned to the column right after the opening
+parenthesis.
+
+```diff
++++ Good +++
+```
+
+```c
+/* Single line form. */
+a = ((c && d) || (e && f));
+
+a = (c
+     && d);
+
+a = (c
+     && (d || e)
+     && f);
+
+do
+{
+}
+while (a
+       && b);
+
+/* This form is rarely used but it is ok. */
+if (a
+    && (b
+        || c
+        || d)
+    && e)
+{
+}
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+if (a || b ||
+    c)
+{
+}
+
+/* Parentheses are missing. */
+a = b || c;
+
+/* Misaligned &&. */
+if (a
+  && b)
+{
+}
+```
+
+## Ternary conditional operators
+
+A special form of ternary conditional operators are allowed
+in JerryScript where the ? and : operators are on separate
+lines in the same column.
+
+```diff
++++ Good +++
+```
+
+```c
+a = (b ? c
+       : d);
+
+/* Single line form is accepted as well. */
+a = (b ? c : d);
+
+/* This form is rarely used but it is ok. */
+if (a ? b
+      : (c ? d
+           : e))
+{
+}
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+a = b ?
+    c : d;
+
+while (a ? b
+       : c)
+{
+}
+
+if (a
+    ? b
+    : c)
+{
+}
+```
+
+## Function calls
+
+There must be a space after the function name. Each argument
+must be in the same or separated lines. In the former case
+there must be a space before the next argument and in the
+latter case all arguments must be aligned to the same column.
+
+```diff
++++ Good +++
+```
+
+```c
+function_a ();
+function_b (a);
+function_c (a, b, c);
+
+function_c (a,
+            b,
+            c);
+
+function_c (a,
+            b,
+            function_c (a,
+                        b,
+                        c);
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+/* No space before the opening parenthesis. */
+function_f();
+
+function_f (
+);
+
+function_g(a);
+
+function_g
+  (a
+  );
+
+/* Two arguments on the same line. */
+function_h (a, b,
+            c);
+
+function_h (a,
+            b, c);
+
+/* Misaligned arguments. */
+function_h (a,
+     b,
+     c);
+```
+
+## Variable declarations
+
+JerryScript is a pure C99 codebase so variable
+declarations can be anywhere in the code including
+inside for-loops. It is recommended to declare a
+variable before the first use.
+
+```diff
++++ Good +++
+```
+
+```c
+for (int i = 0; i < 10; i++)
+{
+  int j = i + 1;
+  while (j < 10)
+  {
+    ++j;
+  }
+}
+
+/* Multiline form of for loops. */
+for (int i = 0;
+     i < 10;
+     i++)
+{
+}
+```
+
+## Type casting
+
+There must be a space after the closing parenthesis
+of the type cast. Type casting has no multiline form
+in JerryScript.
+
+```diff
++++ Good +++
+```
+
+```c
+int a = (int) double_variable;
+
+int a = (int) (long) (float) double_variable;
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+/* Wrong spaces. */
+int a = ( int )double_variable;
+
+/* No multiline form. */
+int a = (int)
+        double_variable;
+```
+
+## Pointers and asterisk character
+
+Each pointer in JerryScript must be a lowercase string
+which is ending with a `_p` suffix. Furthermore there
+must be a space before the asterisk character.
+
+```diff
++++ Good +++
+```
+
+```c
+  int *int_p;
+
+  /* No need to add multiple _p-s for multiple indirections.
+   * It is recommended to avoid these constructs using typedef
+   * declarations. A reviewer might request such a change. */
+  int ***int_p;
+
+  /* This rule applies for type casting as well. */
+  char = *(char *) type_p;
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+  /* No _p after the name. */
+  int *ptr;
+
+  /* Wrong asterisk position. */
+  int* ptr_p;
+
+  char_p = * (char*)type_p;
+```
+
+## Types
+
+Each type in JerryScript must be a lowercase string
+which ends with a `_t` suffix. Furthermore each type
+declaration must be preceded by a short description
+of the type and each field must have a short description
+as well.
+
+```diff
++++ Good +++
+```
+
+```c
+/**
+ * Short description of the following structure.
+ */
+typedef struct
+{
+  /* Field descriptions do not start with capital letters
+   * and there is no full stop at the end. */
+  field1_t field1; /**< description of field 1 */
+  field2_t field2; /**< description of field 2 */
+
+  field_n_t field_n; /**< description of field n */
+} structure_name_t;
+
+/**
+ * Another integer type.
+ */
+typedef int jerry_int;
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+typedef struct
+{
+  field_t field_without_description;
+} structure_without_description_t;
+
+typedef struct { int a; } single_line_struct;
+
+typedef
+union {
+}
+wrong_newlines_t;
+
+/*
+  * Bad comment format.
+   */
+typedef
+char wrong_newlines_again_t;
+```
+
+### Type usage conventions
+
+ - Passing the number of arguments for a function call is always `uint32_t`
+ - String size/length/position related operation should use `lit_utf8_size_t`
+ - Extended objects internal fields must be `uint32_t`
+
+## Function declarations
+
+Function declarations in JerryScript are verbose but this format
+reduces the maintenance cost and allows faster understanding of
+the code.
+
+```diff
++++ Good +++
+```
+
+```c
+/**
+ * Short overview about the purpose of this function.
+ *
+ * A more detailed explanation if needed.
+ *
+ * Note:
+ *   Extra notes if needed.
+ *
+ * @return short description about the value
+ *         returned by the function
+ */
+return_value_type_t
+function_name (argument1, /**< description of argument1 */
+               argument2, /**< description of argument2 */
+               ...
+               argument_n, /**< description of argument n */
+{
+
+  /* Function body. */
+
+} /* function_name */
+```
+
+```diff
+--- Bad ---
+```
+
+```c
+static int
+print (char *text) /**< description of text argument */
+{
+  /* Missing comment before the function. */
+} /* print */
+
+/**
+ * Prints the text received by the function.
+ *
+ * @return number of characters printed by the function
+ */
+int print(char *text)
+{
+  /* No description of text argument. */
+  /* Missing comment at the end of the function. */
+}
+```

09.EXT-REFERENCE-ARG.md

@@ -0,0 +1,904 @@
+---
+layout: page
+title: 'Extension API: Argument Validation'
+category: documents
+permalink: /ext-reference-arg/
+---
+
+* toc
+{:toc}
+
+# jerryx_arg types
+
+## jerryx_arg_t
+
+**Summary**
+
+The structure defining a single validation/transformation step.
+
+*Note*: For commonly used validators, `arg.h` provides helpers to create the `jerryx_arg_t`s.
+For example, `jerryx_arg_number ()`, `jerryx_arg_boolean ()`, etc.
+
+**Prototype**
+
+```c
+typedef struct
+{
+  /** the transform function */
+  jerryx_arg_transform_func_t func;
+  /** pointer to destination where func should store the result */
+  void *dest;
+  /** extra information, specific to func */
+  uintptr_t extra_info;
+} jerryx_arg_t;
+```
+
+**See also**
+
+- [jerryx_arg_number](#jerryx_arg_number)
+- [jerryx_arg_boolean](#jerryx_arg_boolean)
+- [jerryx_arg_string](#jerryx_arg_string)
+- [jerryx_arg_utf8_string](#jerryx_arg_utf8_string)
+- [jerryx_arg_function](#jerryx_arg_function)
+- [jerryx_arg_native_pointer](#jerryx_arg_native_pointer)
+- [jerryx_arg_ignore](#jerryx_arg_ignore)
+- [jerryx_arg_object_properties](#jerryx_arg_object_properties)
+
+## jerryx_arg_object_props_t
+
+**Summary**
+
+The structure is used in `jerryx_arg_object_properties`. It provides the properties' names,
+its corresponding JS-to-C mapping and other related information.
+
+**Prototype**
+
+```c
+typedef struct
+{
+  const jerry_char_t **name_p; /**< property name list of the JS object */
+  jerry_length_t name_cnt; /**< count of the name list */
+  const jerryx_arg_t *c_arg_p; /**< points to the array of transformation steps */
+  jerry_length_t c_arg_cnt; /**< the count of the `c_arg_p` array */
+} jerryx_arg_object_props_t;
+```
+
+**See also**
+
+- [jerryx_arg_object_properties](#jerryx_arg_object_properties)
+
+## jerryx_arg_array_items_t
+
+**Summary**
+
+The structure is used in `jerryx_arg_array`. It provides the array items' corresponding
+JS-to-C mappings and count.
+
+**Prototype**
+
+```c
+typedef struct
+{
+  const jerryx_arg_t *c_arg_p; /**< points to the array of transformation steps */
+  jerry_length_t c_arg_cnt; /**< the count of the `c_arg_p` array */
+} jerryx_arg_array_items_t;
+```
+
+**See also**
+
+- [jerryx_arg_array](#jerryx_arg_array)
+
+## jerryx_arg_transform_func_t
+
+**Summary**
+
+Signature of the transform function.
+
+Users can create custom transformations by implementing a transform function
+and using `jerryx_arg_custom ()`.
+
+The function is expected to return `undefined` if it ran successfully or
+return an `Error` in case it failed. The function can use the iterator and the
+helpers `jerryx_arg_js_iterator_pop ()` and `jerryx_arg_js_iterator_peek ()` to
+get the next input value.
+
+*Note*: A transform function is allowed to consume any number of input values!
+This enables complex validation like handling different JS function signatures,
+mapping multiple input arguments to a C struct, etc.
+
+The function is expected to store the result of
+a successful transformation into `c_arg_p->dest`. In case the validation did
+not pass, the transform should not modify `c_arg_p->dest`.
+
+Additional parameters can be provided to the function through `c_arg_p->extra_info`.
+
+**Prototype**
+
+```c
+typedef jerry_value_t (*jerryx_arg_transform_func_t) (jerryx_arg_js_iterator_t *js_arg_iter_p,
+                                                      const jerryx_arg_t *c_arg_p);
+```
+
+**See also**
+
+- [jerryx_arg_custom](#jerryx_arg_custom)
+- [jerryx_arg_js_iterator_pop](#jerryx_arg_js_iterator_pop)
+- [jerryx_arg_js_iterator_peek](#jerryx_arg_js_iterator_peek)
+
+
+## jerryx_arg_coerce_t
+
+Enum that indicates whether an argument is allowed to be coerced into the expected JS type.
+
+ - JERRYX_ARG_COERCE - the transform will invoke toNumber, toBoolean, toString, etc.
+ - JERRYX_ARG_NO_COERCE - the type coercion is not allowed. The transform will fail if the type does not match the expectation.
+
+**See also**
+
+- [jerryx_arg_number](#jerryx_arg_number)
+- [jerryx_arg_boolean](#jerryx_arg_boolean)
+- [jerryx_arg_string](#jerryx_arg_string)
+
+## jerryx_arg_optional_t
+
+Enum that indicates whether an argument is optional or required.
+
+ - JERRYX_ARG_OPTIONAL - The argument is optional. If the argument is `undefined` the transform is successful and `c_arg_p->dest` remains untouched.
+ - JERRYX_ARG_REQUIRED - The argument is required. If the argument is `undefined` the transform will fail and `c_arg_p->dest` remains untouched.
+
+**See also**
+
+- [jerryx_arg_number](#jerryx_arg_number)
+- [jerryx_arg_boolean](#jerryx_arg_boolean)
+- [jerryx_arg_string](#jerryx_arg_string)
+- [jerryx_arg_function](#jerryx_arg_function)
+- [jerryx_arg_native_pointer](#jerryx_arg_native_pointer)
+
+## jerryx_arg_round_t
+
+Enum that indicates the rounding policy which will be chosen to transform an integer.
+
+ - JERRYX_ARG_ROUND - use round() method.
+ - JERRYX_ARG_FLOOR - use floor() method.
+ - JERRYX_ARG_CEIL - use ceil() method.
+
+**See also**
+
+- [jerryx_arg_uint8](#jerryx_arg_uint8)
+- [jerryx_arg_uint16](#jerryx_arg_uint16)
+- [jerryx_arg_uint32](#jerryx_arg_uint32)
+- [jerryx_arg_int8](#jerryx_arg_int8)
+- [jerryx_arg_int16](#jerryx_arg_int16)
+- [jerryx_arg_int32](#jerryx_arg_int32)
+
+
+## jerryx_arg_clamp_t
+
+ Indicates the clamping policy which will be chosen to transform an integer.
+ If the policy is NO_CLAMP, and the number is out of range,
+ then the transformer will throw a range error.
+
+ - JERRYX_ARG_CLAMP - clamp the number when it is out of range
+ - JERRYX_ARG_NO_CLAMP - throw a range error
+
+**See also**
+
+- [jerryx_arg_uint8](#jerryx_arg_uint8)
+- [jerryx_arg_uint16](#jerryx_arg_uint16)
+- [jerryx_arg_uint32](#jerryx_arg_uint32)
+- [jerryx_arg_int8](#jerryx_arg_int8)
+- [jerryx_arg_int16](#jerryx_arg_int16)
+- [jerryx_arg_int32](#jerryx_arg_int32)
+
+# Main functions
+
+## jerryx_arg_transform_this_and_args
+
+**Summary**
+
+Validate the this value and the JS arguments, and assign them to the native arguments.
+This function is useful to perform input validation inside external function handlers (see `jerry_external_handler_t`).
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_arg_transform_this_and_args (const jerry_value_t this_val,
+                                    const jerry_value_t *js_arg_p,
+                                    const jerry_length_t js_arg_cnt,
+                                    const jerryx_arg_t *c_arg_p,
+                                    jerry_length_t c_arg_cnt)
+```
+
+ - `this_val` - `this` value. Note this is processed as the first value, before the array of arguments.
+ - `js_arg_p` - points to the array with JS arguments.
+ - `js_arg_cnt` - the count of the `js_arg_p` array.
+ - `c_arg_p` - points to the array of validation/transformation steps
+ - `c_arg_cnt` - the count of the `c_arg_p` array.
+ - return value - a `jerry_value_t` representing `undefined` if all validators passed or an `Error` if a validator failed.
+
+**Example**
+
+[doctest]: # (test="compile")
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/arg.h"
+
+/* JS signature: function (requiredBool, requiredString, optionalNumber) */
+static jerry_value_t
+my_external_handler (const jerry_value_t function_obj,
+                     const jerry_value_t this_val,
+                     const jerry_value_t args_p[],
+                     const jerry_length_t args_count)
+{
+  bool required_bool;
+  char required_str[16];
+  double optional_num = 1234.567;  // default value
+
+  /* "mapping" defines the steps to transform input arguments to C variables. */
+  const jerryx_arg_t mapping[] =
+  {
+    /* `this` is the first value. No checking needed on `this` for this function. */
+    jerryx_arg_ignore (),
+
+    jerryx_arg_boolean (&required_bool, JERRYX_ARG_NO_COERCE, JERRYX_ARG_REQUIRED),
+    jerryx_arg_string (required_str, sizeof (required_str), JERRYX_ARG_NO_COERCE, JERRYX_ARG_REQUIRED),
+    jerryx_arg_number (&optional_num, JERRYX_ARG_NO_COERCE, JERRYX_ARG_OPTIONAL),
+  };
+
+  /* Validate and transform. */
+  const jerry_value_t rv = jerryx_arg_transform_this_and_args (this_val,
+                                                               args_p,
+                                                               args_count,
+                                                               mapping,
+                                                               4);
+
+  if (jerry_value_is_exception (rv))
+  {
+    /* Handle error. */
+    return rv;
+  }
+
+  /*
+   * Validated and transformed successfully!
+   * required_bool, required_str and optional_num can now be used.
+   */
+
+  return jerry_undefined (); /* Or return something more meaningful. */
+}
+```
+
+**See also**
+
+- [jerryx_arg_ignore](#jerryx_arg_ignore)
+- [jerryx_arg_number](#jerryx_arg_number)
+- [jerryx_arg_boolean](#jerryx_arg_boolean)
+- [jerryx_arg_string](#jerryx_arg_string)
+- [jerryx_arg_function](#jerryx_arg_function)
+- [jerryx_arg_native_pointer](#jerryx_arg_native_pointer)
+- [jerryx_arg_custom](#jerryx_arg_custom)
+- [jerryx_arg_object_properties](#jerryx_arg_object_properties)
+
+
+## jerryx_arg_transform_args
+
+**Summary**
+
+Validate an array of `jerry_value_t` and assign them to the native arguments.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_arg_transform_args (const jerry_value_t *js_arg_p,
+                           const jerry_length_t js_arg_cnt,
+                           const jerryx_arg_t *c_arg_p,
+                           jerry_length_t c_arg_cnt)
+```
+
+ - `js_arg_p` - points to the array with JS arguments.
+ - `js_arg_cnt` - the count of the `js_arg_p` array.
+ - `c_arg_p` - points to the array of validation/transformation steps
+ - `c_arg_cnt` - the count of the `c_arg_p` array.
+ - return value - a `jerry_value_t` representing `undefined` if all validators passed or an `Error` if a validator failed.
+
+**See also**
+
+- [jerryx_arg_transform_this_and_args](#jerryx_arg_transform_this_and_args)
+
+
+## jerryx_arg_transform_object_properties
+
+**Summary**
+
+Validate the properties of a JS object and assign them to the native arguments.
+
+*Note*: This function transforms properties of a single JS object into native C values.
+To transform multiple objects in one pass (for example when converting multiple arguments
+to an external handler), please use `jerryx_arg_object_properties` together with
+`jerryx_arg_transform_this_and_args` or `jerryx_arg_transform_args`.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_arg_transform_object_properties (const jerry_value_t obj_val,
+                                        const jerry_char_t **name_p,
+                                        const jerry_length_t name_cnt,
+                                        const jerryx_arg_t *c_arg_p,
+                                        jerry_length_t c_arg_cnt);
+
+```
+
+ - `obj_val` - the JS object.
+ - `name_p` - points to the array of property names.
+ - `name_cnt` - the count of the `name_p` array.
+ - `c_arg_p` - points to the array of validation/transformation steps
+ - `c_arg_cnt` - the count of the `c_arg_p` array.
+ - return value - a `jerry_value_t` representing `undefined` if all validators passed or an `Error` if a validator failed.
+
+**See also**
+
+- [jerryx_arg_object_properties](#jerryx_arg_object_properties)
+
+## jerryx_arg_transform_array
+
+**Summary**
+
+Validate the JS array and assign its items to the native arguments.
+
+*Note*: This function transforms items of a single JS array into native C values.
+To transform multiple JS arguments in one pass, please use `jerryx_arg_array` together with
+`jerryx_arg_transform_this_and_args` or `jerryx_arg_transform_args`.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_arg_transform_array (const jerry_value_t array_val,
+                            const jerryx_arg_t *c_arg_p,
+                            jerry_length_t c_arg_cnt);
+
+```
+
+ - `array_val` - the JS array.
+ - `c_arg_p` - points to the array of validation/transformation steps
+ - `c_arg_cnt` - the count of the `c_arg_p` array.
+ - return value - a `jerry_value_t` representing `undefined` if all validators passed or an `Error` if a validator failed.
+
+**See also**
+
+- [jerryx_arg_array](#jerryx_arg_array)
+
+## jerryx_arg_transform_optional
+
+**Summary**
+
+The common function to deal with optional arguments. The core transform function is provided by argument `func`.
+
+**Prototype**
+
+```c
+jerry_value_t jerryx_arg_transform_optional (jerryx_arg_js_iterator_t *js_arg_iter_p,
+                                             const jerryx_arg_t *c_arg_p,
+                                             jerryx_arg_transform_func_t func);
+```
+
+ - `js_arg_iter_p` - the JS arg iterator.
+ - `c_arg_p` - the native arg.
+ - `func` - the core transform function.
+ - return value - a `jerry_value_t` representing `undefined` if all validators passed or an `Error` if a validator failed.
+
+**See also**
+
+- [jerryx_arg_transform_func_t](#jerryx_arg_transform_func_t)
+
+# Helpers for commonly used validations
+
+## jerryx_arg_uint8
+
+## jerryx_arg_uint16
+
+## jerryx_arg_uint32
+
+## jerryx_arg_int8
+
+## jerryx_arg_int16
+
+## jerryx_arg_int32
+
+**Summary**
+
+All above jerryx_arg_[u]intX functions are used to create a validation/transformation step
+(`jerryx_arg_t`) that expects to consume one `number` JS argument
+and stores it into a C integer (uint8, int8, uint16, ...)
+
+**Prototype**
+
+Take jerryx_arg_int32 as an example
+
+```c
+static inline jerryx_arg_t
+jerryx_arg_int32 (int32_t *dest,
+                  jerryx_arg_round_t round_flag,
+                  jerryx_arg_clamp_t clamp_flag,
+                  jerryx_arg_coerce_t coerce_flag,
+                  jerryx_arg_optional_t opt_flag);
+```
+
+ - return value - the created `jerryx_arg_t` instance.
+ - `dest` - pointer to the `int32_t` where the result should be stored.
+ - `round_flag` - the rounding policy.
+ - `clamp_flag` - the clamping policy.
+ - `coerce_flag` - whether type coercion is allowed.
+ - `opt_flag` - whether the argument is optional.
+
+**See also**
+
+- [jerryx_arg_transform_this_and_args](#jerryx_arg_transform_this_and_args)
+
+
+## jerryx_arg_number
+
+**Summary**
+
+Create a validation/transformation step (`jerryx_arg_t`) that expects to consume
+one `number` JS argument and stores it into a C `double`.
+
+**Prototype**
+
+```c
+static inline jerryx_arg_t
+jerryx_arg_number (double *dest,
+                   jerryx_arg_coerce_t coerce_flag,
+                   jerryx_arg_optional_t opt_flag)
+```
+
+ - return value - the created `jerryx_arg_t` instance.
+ - `dest` - pointer to the `double` where the result should be stored.
+ - `coerce_flag` - whether type coercion is allowed.
+ - `opt_flag` - whether the argument is optional.
+
+**See also**
+
+- [jerryx_arg_transform_this_and_args](#jerryx_arg_transform_this_and_args)
+
+## jerryx_arg_boolean
+
+**Summary**
+
+Create a validation/transformation step (`jerryx_arg_t`) that expects to
+consume one `boolean` JS argument and stores it into a C `bool`.
+
+**Prototype**
+
+```c
+static inline jerryx_arg_t
+jerryx_arg_boolean (bool *dest,
+                    jerryx_arg_coerce_t coerce_flag,
+                    jerryx_arg_optional_t opt_flag)
+```
+ - return value - the created `jerryx_arg_t` instance.
+ - `dest` - pointer to the `bool` where the result should be stored.
+ - `coerce_flag` - whether type coercion is allowed.
+ - `opt_flag` - whether the argument is optional.
+
+**See also**
+
+- [jerryx_arg_transform_this_and_args](#jerryx_arg_transform_this_and_args)
+
+
+## jerryx_arg_string
+
+**Summary**
+
+Create a validation/transformation step (`jerryx_arg_t`) that expects to
+consume one `string` JS argument and stores it into a CESU-8 C `char` array.
+
+**Prototype**
+
+```c
+static inline jerryx_arg_t
+jerryx_arg_string (char *dest,
+                   uint32_t size,
+                   jerryx_arg_coerce_t coerce_flag,
+                   jerryx_arg_optional_t opt_flag)
+```
+
+ - return value - the created `jerryx_arg_t` instance.
+ - `dest` - pointer to the native char array where the result should be stored.
+ - `size` - the size of native char array.
+ - `coerce_flag` - whether type coercion is allowed.
+ - `opt_flag` - whether the argument is optional.
+
+**See also**
+
+- [jerryx_arg_transform_this_and_args](#jerryx_arg_transform_this_and_args)
+- [jerry_arg_utf8_string](#jerry_arg_utf8_string)
+
+
+## jerryx_arg_utf8_string
+
+**Summary**
+
+Create a validation/transformation step (`jerryx_arg_t`) that expects to
+consume one `string` JS argument and stores it into a UTF-8 C `char` array.
+
+**Prototype**
+
+```c
+static inline jerryx_arg_t
+jerryx_arg_utf8_string (char *dest,
+                        uint32_t size,
+                        jerryx_arg_coerce_t coerce_flag,
+                        jerryx_arg_optional_t opt_flag)
+```
+
+ - return value - the created `jerryx_arg_t` instance.
+ - `dest` - pointer to the native char array where the result should be stored.
+ - `size` - the size of native char array.
+ - `coerce_flag` - whether type coercion is allowed.
+ - `opt_flag` - whether the argument is optional.
+
+**See also**
+
+- [jerryx_arg_transform_this_and_args](#jerryx_arg_transform_this_and_args)
+- [jerry_arg_string](#jerry_arg_string)
+
+
+## jerryx_arg_function
+
+**Summary**
+
+Create a validation/transformation step (`jerryx_arg_t`) that expects to
+consume one `function` JS argument and stores it into a C `jerry_value_t`.
+
+**Prototype**
+
+```c
+static inline jerryx_arg_t
+jerryx_arg_function (jerry_value_t *dest,
+                     jerryx_arg_optional_t opt_flag)
+
+```
+ - return value - the created `jerryx_arg_t` instance.
+ - `dest` - pointer to the `jerry_value_t` where the result should be stored.
+ - `opt_flag` - whether the argument is optional.
+
+**See also**
+
+- [jerryx_arg_transform_this_and_args](#jerryx_arg_transform_this_and_args)
+
+## jerryx_arg_native_pointer
+
+**Summary**
+
+Create a validation/transformation step (`jerryx_arg_t`) that expects to
+consume one `object` JS argument that is 'backed' with a native pointer with
+a given type info. In case the native pointer info matches, the transform
+will succeed and the object's native pointer will be assigned to `*dest`.
+
+**Prototype**
+
+```c
+static inline jerryx_arg_t
+jerryx_arg_native_pointer (void **dest,
+                           const jerry_object_native_info_t *info_p,
+                           jerryx_arg_optional_t opt_flag)
+```
+ - return value - the created `jerryx_arg_t` instance.
+ - `dest` - pointer to where the resulting native pointer should be stored.
+ - `info_p` - expected the type info.
+ - `opt_flag` - whether the argument is optional.
+
+**See also**
+
+- [jerryx_arg_transform_this_and_args](#jerryx_arg_transform_this_and_args)
+
+## jerryx_arg_object_properties
+
+**Summary**
+
+Create a validation/transformation step (`jerryx_arg_t`) that expects to
+consume one `object` JS argument and call `jerryx_arg_transform_object_properties` inside
+to transform its properties to native arguments.
+User should prepare the `jerryx_arg_object_props_t` instance, and pass it to this function.
+
+**Prototype**
+
+```c
+static inline jerryx_arg_t
+jerryx_arg_object_properties (const jerryx_arg_object_props_t *obj_prop_p,
+                              jerryx_arg_optional_t opt_flag);
+```
+ - return value - the created `jerryx_arg_t` instance.
+ - `obj_prop_p` - provides information for properties transform.
+ - `opt_flag` - whether the argument is optional.
+
+**Example**
+
+[doctest]: # (test="compile")
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/arg.h"
+
+/**
+ * The binding function expects args_p[0] is an object, which has 3 properties:
+ *     "enable": boolean
+ *     "data": number
+ *     "extra_data": number, optional
+ */
+static jerry_value_t
+my_external_handler (const jerry_value_t function_obj,
+                     const jerry_value_t this_val,
+                     const jerry_value_t args_p[],
+                     const jerry_length_t args_count)
+{
+  bool required_bool;
+  double required_num;
+  double optional_num = 1234.567;  // default value
+
+  /* "prop_name_p" defines the name list of the expected properties' names. */
+  const char *prop_name_p[] = { "enable", "data", "extra_data" };
+
+  /* "prop_mapping" defines the steps to transform properties to C variables. */
+  const jerryx_arg_t prop_mapping[] =
+  {
+    jerryx_arg_boolean (&required_bool, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
+    jerryx_arg_number (&required_num, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
+    jerryx_arg_number (&optional_num, JERRYX_ARG_COERCE, JERRYX_ARG_OPTIONAL)
+  };
+
+  /* Prepare the jerryx_arg_object_props_t instance. */
+  const jerryx_arg_object_props_t prop_info =
+  {
+    .name_p = (const jerry_char_t **) prop_name_p,
+    .name_cnt = 3,
+    .c_arg_p = prop_mapping,
+    .c_arg_cnt = 3
+  };
+
+  /* It is the mapping used in the jerryx_arg_transform_args. */
+  const jerryx_arg_t mapping[] =
+  {
+    jerryx_arg_object_properties (&prop_info, JERRYX_ARG_REQUIRED)
+  };
+
+  /* Validate and transform. */
+  const jerry_value_t rv = jerryx_arg_transform_args (args_p,
+                                                      args_count,
+                                                      mapping,
+                                                      1);
+
+  if (jerry_value_is_exception (rv))
+  {
+    /* Handle error. */
+    return rv;
+  }
+
+  /*
+   * Validated and transformed successfully!
+   * required_bool, required_num and optional_num can now be used.
+   */
+
+   return jerry_undefined (); /* Or return something more meaningful. */
+}
+
+```
+
+ **See also**
+
+- [jerryx_arg_transform_this_and_args](#jerryx_arg_transform_this_and_args)
+- [jerryx_arg_transform_object_properties](#jerryx_arg_transform_object_properties)
+
+## jerryx_arg_array
+
+**Summary**
+
+Create a validation/transformation step (`jerryx_arg_t`) that expects to
+consume one `array` JS argument and call `jerryx_arg_transform_array_items` inside
+to transform its items to native arguments.
+User should prepare the `jerryx_arg_array_items_t` instance, and pass it to this function.
+
+**Prototype**
+
+```c
+static inline jerryx_arg_t
+jerryx_arg_array (const jerryx_arg_array_items_t *array_items_p, jerryx_arg_optional_t opt_flag);
+```
+ - return value - the created `jerryx_arg_t` instance.
+ - `array_items_p` - provides items information for transform.
+ - `opt_flag` - whether the argument is optional.
+
+**Example**
+
+[doctest]: # (test="compile")
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/arg.h"
+
+/**
+ * The binding function expects args_p[0] is an array, which has 3 items:
+ *     first: boolean
+ *     second: number
+ *     third: number, optional
+ */
+static jerry_value_t
+my_external_handler (const jerry_value_t function_obj,
+                     const jerry_value_t this_val,
+                     const jerry_value_t args_p[],
+                     const jerry_length_t args_count)
+{
+  bool required_bool;
+  double required_num;
+  double optional_num = 1234.567;  // default value
+
+  /* "item_mapping" defines the steps to transform array items to C variables. */
+  const jerryx_arg_t item_mapping[] =
+  {
+    jerryx_arg_boolean (&required_bool, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
+    jerryx_arg_number (&required_num, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
+    jerryx_arg_number (&optional_num, JERRYX_ARG_COERCE, JERRYX_ARG_OPTIONAL)
+  };
+
+  /* Prepare the jerryx_arg_array_items_t instance. */
+  const jerryx_arg_array_items_t array_info =
+  {
+    .c_arg_p = item_mapping,
+    .c_arg_cnt = 3
+  };
+
+  /* It is the mapping used in the jerryx_arg_transform_args. */
+  const jerryx_arg_t mapping[] =
+  {
+    jerryx_arg_array (&array_info, JERRYX_ARG_REQUIRED)
+  };
+
+  /* Validate and transform. */
+  const jerry_value_t rv = jerryx_arg_transform_args (args_p,
+                                                      args_count,
+                                                      mapping,
+                                                      1);
+
+  if (jerry_value_is_exception (rv))
+  {
+    /* Handle error. */
+    return rv;
+  }
+
+  /*
+   * Validated and transformed successfully!
+   * required_bool, required_num and optional_num can now be used.
+   */
+
+   return jerry_undefined (); /* Or return something more meaningful. */
+}
+
+```
+
+ **See also**
+
+- [jerryx_arg_transform_this_and_args](#jerryx_arg_transform_this_and_args)
+- [jerryx_arg_transform_object_properties](#jerryx_arg_transform_object_properties)
+
+# Functions to create custom validations
+
+## jerryx_arg_ignore
+
+**Summary**
+
+Create a jerryx_arg_t instance for ignored argument.
+
+**Prototype**
+
+```c
+static inline jerryx_arg_t jerryx_arg_ignore (void);
+```
+ - return value - the created `jerryx_arg_t` instance.
+
+**See also**
+
+- [jerryx_arg_t](#jerryx_arg_t)
+
+## jerryx_arg_custom
+
+**Summary**
+
+Create a jerryx_arg_t instance with custom transform.
+
+**Prototype**
+
+```c
+static inline jerryx_arg_t
+jerryx_arg_custom (void *dest,
+                   uintptr_t extra_info,
+                   jerryx_arg_transform_func_t func)
+
+```
+ - return value - the created `jerryx_arg_t` instance.
+ - `dest` - pointer to the native argument where the result should be stored.
+ - `extra_info` - the extra parameter data, specific to the transform function.
+ - `func` - the custom transform function.
+
+**See also**
+
+- [jerryx_arg_transform_this_and_args](#jerryx_arg_transform_this_and_args)
+
+
+
+## jerryx_arg_js_iterator_pop
+
+**Summary**
+
+Pop the current `jerry_value_t` argument from the iterator.
+It will change the `js_arg_idx` and `js_arg_p` value in the iterator.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_arg_js_iterator_pop (jerryx_arg_js_iterator_t *js_arg_iter_p)
+```
+ - return value - the `jerry_value_t` argument that was popped.
+ - `js_arg_iter_p` - the JS arg iterator from which to pop.
+
+## jerryx_arg_js_iterator_peek
+
+**Summary**
+
+Get the current JS argument from the iterator, without moving the iterator forward.
+*Note:* Unlike `jerryx_arg_js_iterator_pop ()`, it will not change `js_arg_idx` and
+`js_arg_p` value in the iterator.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_arg_js_iterator_peek (jerryx_arg_js_iterator_t *js_arg_iter_p)
+```
+ - return value - the current `jerry_value_t` argument.
+ - `js_arg_iter_p` - the JS arg iterator from which to peek.
+
+## jerryx_arg_js_iterator_restore
+
+**Summary**
+
+Restore the last item popped from the stack.  This can be called as
+many times as there are arguments on the stack -- if called when the
+first element in the array is the current top of the stack, this
+function does nothing.
+
+*Note:* This function relies on the underlying implementation of the
+arg stack as an array, as its function is to simply back up the "top
+of stack" pointer to point to the previous element of the array.
+
+*Note:* Like `jerryx_arg_js_iterator_pop ()`, this function will
+change the `js_arg_idx` and `js_arg_p` values in the iterator.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_arg_js_iterator_restore (jerryx_arg_js_iterator_t *js_arg_iter_p)
+```
+ - return value - the the new top of the stack.
+ - `js_arg_iter_p` - the JS arg iterator to restore.
+
+
+## jerryx_arg_js_iterator_index
+
+**Summary**
+
+Get the index of the current JS argument from the iterator.
+
+**Prototype**
+
+```c
+jerry_length_t
+jerryx_arg_js_iterator_index (jerryx_arg_js_iterator_t *js_arg_iter_p)
+```
+ - return value - the index of current JS argument.
+ - `js_arg_iter_p` - the JS arg iterator from which to peek.

10.EXT-REFERENCE-HANDLER.md

@@ -0,0 +1,417 @@
+---
+layout: page
+title: 'Extension API: External Function Handlers'
+category: documents
+permalink: /ext-reference-handler/
+---
+
+* toc
+{:toc}
+
+# Common methods to handle properties
+
+The `jerryscript-ext/properties.h` header defines a set of convenience methods
+which makes the property access a bit straightforward.
+
+# Utility to register multiple properties in bulk
+
+In some cases it is useful to register multiple properties for a given object
+for this the following utility structures and methods are provided.
+
+## jerryx_property_entry
+
+**Summary**
+
+Structure to define an array of properties with `name` and `value` fields which
+can be registered to a target object.
+
+The engine must be initialized before specifying the `jerry_value_t` in the struct.
+
+
+**Prototype**
+
+```c
+typedef struct {
+  const char *name;
+  jerry_value_t value;
+} jerryx_property_entry;
+```
+
+**See also**
+
+- [jerryx_set_properties](#jerryx_set_properties)
+
+
+## jerryx_register_result
+
+**Summary**
+
+Structure returned as the result of the [jerryx_set_properties](#jerryx_set_properties) operation.
+The `result` field will either be a JavaScript undefined value or an error object.
+In every case the `registered` field is used to indicated the number of
+successfully registered methods.
+
+This must be passed for the [jerryx_release_property_entry](#jerryx_release_property_entry) method
+after the property registration.
+
+If any error occurred during the property registration the `result` field of the structure
+must be manually released after processing the error value.
+
+**Prototype**
+
+```c
+typedef struct {
+  jerry_value_t result;
+  uint32_t registered;
+} jerryx_register_result;
+```
+
+**See also**
+
+- [jerryx_set_properties](#jerryx_set_properties)
+- [jerryx_release_property_entry](#jerryx_release_property_entry)
+
+
+## jerryx_set_properties
+
+**Summary**
+
+Set multiple properties on a target object.
+
+The properties are an array of (name, jerry_value_t) pairs and
+this list must end with a (NULL, 0) entry.
+
+Important notes:
+* Each property value in the input array is released after a successful property registration.
+* The method [jerryx_release_property_entry](#jerryx_release_property_entry) must be called if there is any failed registration
+  to release the values in the entries array.
+  It is safe to call this cleanup method in every case not just in case of failure.
+* If the error value is reported via the result it must be freed manually.
+
+**Prototype**
+
+```c
+jerryx_register_result
+jerryx_set_properties (const jerry_value_t target_object,
+                       const jerryx_property_entry entries[]);
+```
+
+- `target_object` - object on which the entries will be set.
+- `entries` - array of (name, jerry_value_t) pairs.
+- return a [jerryx_register_result](#jerryx_register_result).
+   - if everything is ok, the struct's `result` field is set to a JS undefined value.
+   - otherwise the `result` field is an error object indicating the problem.
+   - in every case the `registered` field contains the number of successfully registered properties.
+
+**Example**
+
+[doctest]: # ()
+
+```c
+#include <stdio.h>
+#include "jerryscript.h"
+#include "jerryscript-ext/handlers.h"
+#include "jerryscript-ext/properties.h"
+
+static jerry_value_t
+handler (const jerry_call_info_t *call_info_p,
+         const jerry_value_t args_p[],
+         const jerry_length_t args_cnt)
+{
+  printf ("native handler called!\n");
+
+  return jerry_boolean (true);
+}
+
+int
+main (int argc, char **argv)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  jerryx_property_entry methods[] =
+  {
+    { "demo", jerry_function_external (handler) },
+    { NULL, 0 },
+  };
+
+  jerry_value_t global = jerry_current_realm ();
+  jerryx_register_result reg = jerryx_set_properties (global, methods);
+  /* if `reg.result` is undefined all methods are registered */
+  if (jerry_value_is_exception (reg.result))
+  {
+    printf ("Only registered %d properties\r\n", reg.registered);
+    /* clean up not registered property values */
+    jerryx_release_property_entry (methods, reg);
+
+    /* clean up the error */
+    jerry_value_free (reg.result);
+  }
+
+  jerry_value_free (global);
+
+  jerry_cleanup();
+
+  return 0;
+}
+```
+
+**Convenience macros**
+
+To make property registration convenient, there are a set of macros to use
+when setting a property entry:
+
+* `JERRYX_PROPERTY_NUMBER(NAME, NUMBER)` - creates a number entry.
+* `JERRYX_PROPERTY_STRING(NAME, STR, SIZE)` - creates an UTF-8 string entry using `SIZE` bytes from the string.
+* `JERRYX_PROPERTY_STRING_SZ(NAME, STR)` - creates an ASCII string entry. This string must be zero terminated.
+* `JERRYX_PROPERTY_BOOLEAN(NAME, VALUE)` - creates a boolean entry.
+* `JERRYX_PROPERTY_FUNCTION(NAME, NATIVE)` - creates a native C function entry.
+* `JERRYX_PROPERTY_UNDEFINED(NAME)` - creates an undefined property entry.
+* `JERRYX_PROPERTY_LIST_END()` - indicates the end of the property list.
+
+**Example usage of Convenience macros**
+
+[doctest]: # ()
+
+```c
+#include <stdio.h>
+#include "jerryscript.h"
+#include "jerryscript-ext/handlers.h"
+#include "jerryscript-ext/properties.h"
+
+static jerry_value_t
+handler (const jerry_call_info_t *call_info_p,
+         const jerry_value_t args_p[],
+         const jerry_length_t args_cnt)
+{
+  printf ("native handler called!\n");
+
+  return jerry_boolean (true);
+}
+
+int
+main (int argc, char **argv)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  /**
+   * Create a array of properties to be registered.
+   * This must be done after initializing the engine as creating `jerry_value_t`
+   * elements are invalid before `jerry_init`.
+   */
+  jerryx_property_entry methods[] =
+  {
+    JERRYX_PROPERTY_FUNCTION ("demo", handler),
+    JERRYX_PROPERTY_NUMBER ("test_num", 2.3),
+    JERRYX_PROPERTY_UNDEFINED ("this_is_undefined"),
+    JERRYX_PROPERTY_LIST_END(),
+  };
+
+  jerry_value_t global = jerry_current_realm ();
+  jerryx_register_result reg = jerryx_set_properties (global, methods);
+  /* if `reg.result` is undefined all methods are registered */
+  if (jerry_value_is_exception (reg.result))
+  {
+    printf ("Only registered %d properties\r\n", reg.registered);
+    /* clean up not registered property values */
+    jerryx_release_property_entry (methods, reg);
+
+    /* clean up the error */
+    jerry_value_free (reg.result);
+  }
+
+  jerry_value_free (global);
+
+  jerry_cleanup();
+
+  return 0;
+}
+```
+
+
+**See also**
+
+- [jerryx_property_entry](#jerryx_property_entry)
+- [jerryx_release_property_entry](#jerryx_release_property_entry)
+- [jerryx_register_result](#jerryx_register_result)
+
+## jerryx_release_property_entry
+
+**Summary**
+
+Release all `jerry_value_t` in a `jerryx_property_entry` array based on a previous [jerryx_set_properties](#jerryx_set_properties) call
+and also the error value (if any) in the `jerryx_register_result` structure.
+In case of a successful registration it is safe to call this method.
+
+After the method call the `entries` array should not be used as all values are released.
+
+**Prototype**
+
+```
+void
+jerryx_release_property_entry (const jerryx_property_entry entries[],
+                               const jerryx_register_result register_result);
+```
+
+- `entries` - array of [jerryx_property_entry](#jerryx_property_entry).
+- `register_result` - result of a previous [jerryx_set_properties](#jerryx_set_properties) call.
+
+**Example**
+
+For example usage see [jerryx_set_properties](#jerryx_set_properties).
+
+
+#  Common external function handlers
+
+## jerryx_handler_assert
+
+**Summary**
+
+Hard assert for scripts. The routine calls `jerry_port_fatal` on assertion failure.
+
+If the `JERRY_FEATURE_LINE_INFO` runtime feature is enabled (build option: `JERRY_LINE_INFO`)
+a backtrace is also printed out.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_handler_assert (const jerry_call_info_t *call_info_p,
+                       const jerry_value_t args_p[],
+                       const jerry_length_t args_cnt);
+```
+
+- `call_info_p` - pointer to a [jerry_call_info_t](#jerry_call_info_t)
+                  structure which holds call related information (unused).
+- `args_p` - the array of function arguments.
+- `args_cnt` - the number of function arguments.
+- return value - `jerry_value_t` representing boolean true, if only one argument
+  was passed and that argument was a boolean true. Note that the function does
+  not return otherwise.
+
+**See also**
+
+- [jerryx_register_global](#jerryx_register_global)
+
+
+## jerryx_handler_gc
+
+**Summary**
+
+Expose garbage collector to scripts. If the first argument of the function
+is logical true, it performs a high pressure gc. Otherwise a low pressure
+gc is performed, which is also the default if no parameters passed.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_handler_gc (const jerry_call_info_t *call_info_p,
+                   const jerry_value_t args_p[],
+                   const jerry_length_t args_cnt);
+```
+
+- `call_info_p` - pointer to a [jerry_call_info_t](#jerry_call_info_t)
+                  structure which holds call related information (unused).
+- `args_p` - the array of function arguments (unused).
+- `args_cnt` - the number of function arguments (unused).
+- return value - `jerry_value_t` representing `undefined`.
+
+**See also**
+
+- [jerryx_register_global](#jerryx_register_global)
+
+
+## jerryx_handler_print
+
+**Summary**
+
+Provide a `print` implementation for scripts. The routine converts all of its
+arguments to strings and outputs them by using `jerry_port_print_buffer`.
+The NULL character is output as "\u0000", other characters are output bytewise.
+
+*Note*: This implementation does not use standard C `printf` to print its
+output. This allows more flexibility but also extends the core JerryScript
+engine port API. Applications that want to use `jerryx_handler_print` must
+ensure that their port implementation also provides
+`jerry_port_print_buffer`.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_handler_print (const jerry_call_info_t *call_info_p,
+                      const jerry_value_t args_p[],
+                      const jerry_length_t args_cnt);
+```
+
+- `call_info_p` - pointer to a [jerry_call_info_t](#jerry_call_info_t)
+                  structure which holds call related information (unused).
+- `args_p` - the array of function arguments.
+- `args_cnt` - the number of function arguments.
+- return value - `jerry_value_t` representing `undefined` if all arguments could
+  be converted to strings, an `Error` otherwise.
+
+**See also**
+
+- [jerryx_register_global](#jerryx_register_global)
+- [jerry_port_print_buffer](05.PORT-API.md#jerry_port_print_buffer)
+
+
+# Handler registration helper
+
+## jerryx_register_global
+
+**Summary**
+
+Register a JavaScript function in the global object.
+
+*Note*: Returned value must be freed with `jerry_value_free`, when it is no
+longer needed.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_register_global (const char *name_p,
+                        jerry_external_handler_t handler_p);
+```
+
+- `name_p` - the name of the function to be registered.
+- `handler_p` - the address of the external function handler.
+- return value - `jerry_value_t` representing boolean true, if the operation was
+  successful, an `Error` otherwise.
+
+**Example**
+
+[doctest]: # (test="compile")
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/handlers.h"
+#include "jerryscript-ext/properties.h"
+
+static const struct {
+  const char *name_p;
+  jerry_external_handler_t handler_p;
+} common_functions[] =
+{
+  { "assert", jerryx_handler_assert },
+  { "gc", jerryx_handler_gc },
+  { "print", jerryx_handler_print },
+  { NULL, NULL }
+};
+
+static void
+register_common_functions (void)
+{
+  jerry_value_t ret = jerry_undefined ();
+
+  for (int i = 0; common_functions[i].name_p != NULL && !jerry_value_is_exception (ret); i++)
+  {
+    ret = jerryx_register_global (common_functions[i].name_p,
+                                  common_functions[i].handler_p);
+  }
+
+  jerry_value_free (ret);
+}
+```

11.EXT-REFERENCE-AUTORELEASE.md

@@ -0,0 +1,60 @@
+---
+layout: page
+title: 'Extension API: Autorelease Values'
+category: documents
+permalink: /ext-reference-autorelease/
+---
+
+* toc
+{:toc}
+
+#  Autorelease values
+
+## JERRYX_AR_VALUE_T
+
+**Summary**
+
+Macro for `const jerry_value_t` for which jerry_value_free() is
+automatically called when the variable goes out of scope.
+
+*Note*: The macro depends on compiler support. For GCC and LLVM/clang, the macro is implemented
+using the `__cleanup__` variable attribute. For other compilers, no support has been added yet.
+
+**Example**
+
+[doctest]: # (test="compile", name="11.EXT-REFERENCE-AUTORELEASE.c")
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/autorelease.h"
+
+static void
+foo (bool enable)
+{
+  JERRYX_AR_VALUE_T bar = jerry_string_sz ("...");
+
+  if (enable)
+  {
+    JERRYX_AR_VALUE_T baz = jerry_current_realm ();
+
+    /* bar and baz can now be used. */
+
+    /*
+     * jerry_value_free (baz) and jerry_value_free (bar) is called automatically before
+     * returning, because `baz` and `bar` go out of scope.
+     */
+    return;
+  }
+
+  /*
+   * jerry_value_free (bar) is called automatically when the function returns,
+   * because `bar` goes out of scope.
+   */
+}
+```
+
+**See also**
+
+- [jerry_value_t](../api-reference#jerry_value_t)
+- [jerry_value_copy](../api-reference#jerry_value_copy)
+- [jerry_value_free](../api-reference#jerry_value_free)

12.EXT-REFERENCE-MODULE.md

@@ -0,0 +1,324 @@
+---
+layout: page
+title: 'Extension API: Module Support'
+category: documents
+permalink: /ext-reference-module/
+---
+
+* toc
+{:toc}
+
+#  Module API
+
+This is a JerryScript extension that provides a means of loading modules. Fundamentally, a module is a name (stored as
+a string) that resolves to a `jerry_value_t`. This extension provides the function `jerryx_module_resolve()` which
+accepts the name of the module being requested as well as an array of so-called "resolvers" - structures containing two
+function pointers: one for a function which computes a canonical name for the requested module or returns a reference
+to the requested name, and one that converts a canonical name to a `jerry_value_t`, thus "resolving" or "loading" the
+requested module.
+
+The resolvers are first called in sequence to each compute the canonical name of the requested module. This is
+accomplished by calling the `get_canonical_name` function pointer they provide. If the function pointer is `NULL`, the
+requested module name is assumed to be what the resolver considers to be its canonical name. `jerryx_module_resolve`
+searches its cache of loaded modules for each canonical name as returned by a `get_canonical_name` function pointer. If
+one of the loaded modules in the cache corresponds to a canonical name, it is returned.
+
+If no cached module is found, `jerryx_module_resolve` calls each resolver's `resolve` function pointer, passing it its
+previously computed interpretation of the requested module's canonical name. If the resolver successfully creates the
+`jerry_value_t` that represents the loaded module, it returns `true` and the `jerry_value_t` in its out parameter.
+
+When `jerryx_module_resolve` receives a value of `true` from a resolver, it stops iterating over the remaining
+resolvers in the sequence and, if the `jerry_value_t` returned from the resolver's `resolve` does not have the error
+flag set, it will add the `jerry_value_t` to its cache under the module's canonical name and return it. Thus, on
+subsequent calls to `jerryx_module_resolve` with a module name whose canonical name is associated with the
+`jerry_value_t`, no `resolve` callback need be called again.
+
+The purpose of having resolvers is to be able to account for the fact that different types of modules may be structured
+differently and thus, for each type of module a module resolver must be supplied at the point where an instance of that
+type of module is requested.
+
+Individual modules may be removed from the cache by calling `jerryx_module_clear_cache`. This function behaves
+identically to `jerryx_module_resolve` in that it first checks the cache for the requested module, except that it
+removes the module if found. Additionally, it clears the entire cache of all modules if called using a JavaScript value
+of `undefined` as its first parameter.
+
+Additionally, this extension provides a means of easily defining so-called "native" JerryScript modules which can be
+resolved using the native JerryScript module resolver `jerryx_module_native_resolver`, which can be passed to
+`jerryx_module_resolve()`. Native modules are registered during application startup and by calling `dlopen()` by means
+of library constructors, support for which can be turned on using the `FEATURE_INIT_FINI` build flag. In the absence of
+such a flag, the module registration and unregistration functions are exposed as global symbols which can be called
+explicitly. Note: On windows, `FEATURE_INIT_FINI` build flag only supported with GNU toolchain or Microsoft Visual C/C++ Compiler
+2008 and upper.
+
+## jerryx_module_resolve
+
+**Summary**
+
+Load a copy of a module into the current context or return one that was already loaded if it is found.
+
+For each resolver passed in via `resolvers_p`, its `get_canonical_name` function pointer gets called in order to
+establish the resolver's interpretation of what the canonical name for the module should be. If `get_canonical_name` is
+`NULL`, it is assumed that the requested module's name as passed in is its canonical name.
+
+Then, for each resolver passed in via `resolvers_p`, its `resolve` function pointer gets called with its interpretation
+of what the module's canonical name should be, as computed in the previous step.
+
+If the resolver's `resolve` function pointer returns `true`, the `jerry_value_t` returned in its out-parameter will be
+returned by `jerryx_module_resolve` as the result of the request. If no error flag is set on the `jerry_value_t` it
+will be cached under its canonical name so as to avoid loading the same module twice in the event of a subsequent call
+to `jerryx_module_resolve` with a module name whose canonical name matches an already loaded module.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerryx_module_resolve (const jerry_value_t name,
+                       const jerryx_module_resolver_t **resolvers_p,
+                       size_t resolver_count);
+```
+
+- `name` - the name of the module to load
+- `resolvers_p` - the list of resolvers to call in sequence
+- `resolver_count` - the number of resolvers in `resolvers_p`
+- return value - `jerry_value_t` representing the module that was loaded, or the error that occurred in the process.
+
+
+## jerryx_module_clear_cache
+
+**Summary**
+
+Remove a module from the current context's cache, or clear the cache entirely.
+
+**Prototype**
+
+```c
+void
+jerryx_module_clear_cache (const jerry_value_t name,
+                           const jerryx_module_resolver_t **resolvers_p,
+                           size_t resolver_count);
+```
+
+- `name` - the name of the module to remove from cache or a JavaScript `undefined` to clear the entire cache
+- `resolvers_p` - the list of resolvers to call in sequence
+- `resolver_count` - the number of resolvers in `resolvers_p`
+
+
+## jerryx_module_native_resolver
+
+**Summary**
+
+The resolver for native JerryScript modules. A pointer to this structure can be passed in the second parameter to
+`jerryx_module_resolve` to search for the module among the native JerryScript modules built into the binary. This
+function is available only if the preprocessor directive `JERRYX_NATIVE_MODULES_SUPPORTED` is defined.
+
+**Prototype**
+
+```c
+extern jerry_module_resolver_t jerryx_native_module_resolver;
+```
+
+# Module data types
+
+## jerryx_module_get_canonical_name_t
+
+**Summary**
+
+The function pointer type for converting a module's requested name to its canonical name.
+
+**Prototype**
+
+```c
+typedef jerry_value_t (*jerryx_module_get_canonical_name_t) (const jerry_value_t name);
+```
+
+## jerryx_module_resolve_t
+
+**Summary**
+
+Function pointer type for module resolution.
+
+**Prototype**
+
+```c
+typedef bool (*jerryx_module_resolve_t) (const jerry_value_t canonical_name,
+                                        jerry_value_t *result);
+```
+
+## jerryx_module_resolver_t
+
+**Summary**
+
+Structure defining a module resolver.
+
+**Prototype**
+
+```c
+typedef struct
+{
+  jerryx_module_get_canonical_name_t get_canonical_name_p;
+  jerryx_module_resolve_t resolve_p;
+} jerryx_module_resolver_t;
+```
+
+- `get_canonical_name_p` - function pointer to be called when the canonical name corresponding to the requested name
+of a module must be established.
+- `resolve_p` - function pointer to be called when a module with the given canonical name needs to be converted to the
+`jerry_value_t` that will become the loaded module.
+
+**Example**
+```c
+static bool
+load_and_evaluate_js_file (const jerry_value_t name, jerry_value_t *result)
+{
+  bool return_value = false;
+  char *js_file_contents = NULL;
+  int file_size = 0;
+
+  jerry_size_t name_size = jerry_string_size (name, JERRY_ENCODING_UTF8);
+  jerry_char_t name_string[name_size + 1];
+  jerry_string_to_buffer (name, JERRY_ENCODING_UTF8, name_string, name_size);
+  name_string[name_size] = 0;
+
+  FILE *js_file = fopen (name_string, "r");
+
+  if (js_file)
+  {
+    /* We have successfully opened the file. Now, we establish its size. */
+    file_size = fseek (js_file, 0, SEEK_END);
+    fseek (js_file, 0, SEEK_SET);
+
+    /* We allocate enough memory to store the contents of the file. */
+    js_file_contents = malloc (file_size);
+    if (js_file_contents)
+    {
+      /* We read the file into memory and call jerry_eval (), assigning the result to the out-parameter. */
+      fread (js_file_contents, file_size, 1, js_file);
+      (*result) = jerry_eval (js_file_contents, file_size, JERRY_PARSE_NO_OPTS);
+
+      /* We release the memory holding the contents of the file. */
+      free (js_file_contents);
+      return_value = true;
+    }
+
+    /* We close the file. */
+    fclose (js_file);
+  }
+
+  return return_value;
+}
+
+static jerry_value_t
+canonicalize_file_path (const jerry_value_t name)
+{
+  jerry_value_t absolute_path;
+
+  /**
+   * Since a file on the file system can be referred to by multiple relative paths, but only by one absolute path, the
+   * absolute path becomes the canonical name for the module. Thus, to establish this canonical name, we must search
+   * name for "./" and "../", follow symlinks, etc., then create absolute_path via jerry_string () and return
+   * it, because it is the canonical name for this module. Thus, we avoid loading the same JavaScript file twice.
+   */
+
+  return absolute_path;
+}
+
+static jerryx_module_resolver_t js_file_loader
+{
+  canonicalize_file_path,
+  load_and_evaluate_js_file
+};
+```
+
+We can now load JavaScript files:
+```c
+static const jerryx_module_resolver_t *resolvers[] =
+{
+  /*
+   * Consult the resolver for native JerryScript modules first, in case the requested module is a native JerryScript
+   * module.
+   */
+  &jerryx_module_native_resolver,
+
+  /*
+   * If the requested module is not a native JerryScript module, assume it is a JavaScript file on disk and use the
+   * above-defined JavaScript file loader to load it.
+   */
+  &js_file_loader
+};
+jerry_value_t js_module = jerryx_module_resolve (requested_module, resolvers, 2);
+```
+
+# Module helper macros
+
+## JERRYX_NATIVE_MODULE
+
+**Summary**
+
+Helper macro to define a native JerryScript module. Currently declares a global static structure of type
+`jerryx_native_module_t` and a constructor/destructor pair that calls `jerryx_native_module_register()` resp.
+`jerryx_native_module_unregister()`. If the extension is built without the FEATURE_INIT_FINI flag, indicating that
+support for library constructors and destructors is absent, the constructor and destructor are declared as global
+symbols so that they may be called explicitly from within the application.
+
+**Note**: The helper macro must appear at the bottom of a source file, and no semicolon must follow it.
+
+**Prototype**
+```c
+#define JERRYX_NATIVE_MODULE(module_name, on_resolve_cb)
+```
+
+- `module_name` - the name of the module without quotes. This value is used as the prefix for the registration and unregistration functions. For example, when `module_name` is `example_module`, this results in the declaration of two functions `example_module_register()` and `example_module_unregister()`. These functions are declared global if support for library constructors/destructors is absent, allowing you to call them from other parts of the code by
+first forward-declaring them.
+- `on_resolve_cb` - the function of type `jerryx_native_module_on_resolve_t` that will be called when the module needs to be
+loaded.
+
+**Example**
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/module.h"
+
+static jerry_value_t
+my_module_on_resolve (void)
+{
+  return jerry_function_external (very_useful_function);
+} /* my_module_on_resolve */
+
+/* Note that there is no semicolon at the end of the next line. This is how it must be. */
+JERRYX_NATIVE_MODULE (my_module, my_module_on_resolve)
+```
+
+**Example Usage When Library Constructors Are Unavailable**
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/module.h"
+
+/**
+ * Forward-declare the module registration and unregistration function.
+ */
+extern void my_module_register (void);
+extern void my_module_unregister (void);
+int
+main (int argc, char **argv)
+{
+  jerryx_module_resolver_t resolvers[] =
+  {
+    jerryx_native_module_resolver
+  };
+
+  /* This plays the role of the library constructor. */
+  my_module_register ();
+
+  jerry_init (JERRY_INIT_EMPTY);
+  ...
+  jerry_value_t my_module = jerryx_module_resolve ("my_module", resolvers, 1);
+  ...
+  jerry_cleanup ();
+
+  /* This plays the role of the library destructor */
+  my_module_unregister();
+
+  return 0;
+}
+```

13.DEBUGGER-TRANSPORT.md

@@ -0,0 +1,230 @@
+---
+layout: page
+title: 'Debugger Transport'
+category: documents
+permalink: /debugger-transport/
+---
+
+* toc
+{:toc}
+
+# JerryScript debugger transport interface
+
+The transport interface support allows dynamic selection of transportation
+layers which can encode/decode or send/receive messages transmitted between
+the debugger client and server.
+
+# Types
+
+## jerry_debugger_transport_receive_context_t
+
+**Summary**
+
+This context represents the current status of processing received data.
+The final state is returned by
+[jerry_debugger_transport_receive](#jerry_debugger_transport_receive)
+and must be passed to
+[jerry_debugger_transport_receive_completed](#jerry_debugger_transport_receive_completed)
+after the message is processed.
+
+**Prototype**
+
+```c
+typedef struct
+{
+  uint8_t *buffer_p; /**< buffer for storing the received data */
+  size_t received_length; /**< number of currently received bytes */
+  uint8_t *message_p; /**< start of the received message */
+  size_t message_length; /**< length of the received message */
+  size_t message_total_length; /**< total length for datagram protocols,
+                                *   0 for stream protocols */
+} jerry_debugger_transport_receive_context_t;
+```
+
+## jerry_debugger_transport_header_t
+
+**Summary**
+
+Shared header for each transport interface. It mostly contains callback functions
+used by the JerryScript debugger server.
+
+**Prototype**
+
+```c
+typedef struct jerry_debugger_transport_layer_t
+{
+  /* The following fields must be filled before calling jerry_debugger_transport_add(). */
+  jerry_debugger_transport_close_t close; /**< close connection callback */
+  jerry_debugger_transport_send_t send;  /**< send data callback */
+  jerry_debugger_transport_receive_t receive; /**< receive data callback */
+
+  /* The following fields are filled by jerry_debugger_transport_add(). */
+  struct jerry_debugger_transport_layer_t *next_p; /**< next transport layer */
+} jerry_debugger_transport_header_t;
+```
+
+## jerry_debugger_transport_close_t
+
+**Summary**
+
+Called when the connection is closed. Must release all resources (including the
+memory area for the transport interface) allocated for the transport interface.
+
+**Prototype**
+
+```c
+typedef void (*jerry_debugger_transport_close_t) (struct jerry_debugger_transport_interface_t *header_p);
+```
+
+## jerry_debugger_transport_send_t
+
+**Summary**
+
+Called when a message needs to be sent. Must either transmit the message or call
+the `header_p->next_p->send()` method.
+
+**Prototype**
+
+```c
+typedef bool (*jerry_debugger_transport_send_t) (struct jerry_debugger_transport_interface_t *header_p,
+                                                 uint8_t *message_p,
+                                                 size_t message_length);
+```
+
+## jerry_debugger_transport_receive_t
+
+**Summary**
+
+Called during message processing. If messages are available it must return with
+the next message.
+
+**Prototype**
+
+```c
+typedef bool (*jerry_debugger_transport_receive_t) (struct jerry_debugger_transport_interface_t *header_p,
+                                                    jerry_debugger_transport_receive_context_t *context_p);
+```
+
+# Transport interface API functions
+
+## jerry_debugger_transport_add
+
+**Summary**
+
+Add a new interface to the transportation interface chain. The interface
+will be the first item of the interface chain.
+
+**Prototype**
+
+```c
+void jerry_debugger_transport_add (jerry_debugger_transport_header_t *header_p,
+                                   size_t send_message_header_size,
+                                   size_t max_send_message_size,
+                                   size_t receive_message_header_size,
+                                   size_t max_receive_message_size);
+```
+
+- `header_p`: header of a transportation interface.
+- `send_message_header_size`: size of the outgoing message header, can be 0.
+- `max_send_message_size`: maximum outgoing message size supported by the interface.
+- `receive_message_header_size`: size of the incoming message header, can be 0.
+- `max_receive_message_size`: maximum incoming message size supported by the interface.
+
+## jerry_debugger_transport_start
+
+**Summary**
+
+Starts the communication to the debugger client. Must be called after the
+connection is successfully established.
+
+**Prototype**
+
+```c
+void jerry_debugger_transport_start (void);
+```
+
+## jerry_debugger_transport_is_connected
+
+**Summary**
+
+Tells whether a debugger client is connected to the debugger server.
+
+**Prototype**
+
+```c
+bool jerry_debugger_transport_is_connected (void);
+```
+
+- return value: `true`, if a client is connected, `false` otherwise.
+
+## jerry_debugger_transport_close
+
+**Summary**
+
+Disconnect from the current debugger client. It does nothing if a client is
+not connected.
+
+**Prototype**
+
+```c
+void jerry_debugger_transport_close (void);
+```
+
+## jerry_debugger_transport_send
+
+**Summary**
+
+Send message to the client.
+
+**Prototype**
+
+```c
+bool jerry_debugger_transport_send (const uint8_t *message_p, size_t message_length);
+```
+
+- `message_p`: message to be sent.
+- `message_length`: message length in bytes.
+- return value: `true`, if a client is still connected, `false` otherwise.
+
+## jerry_debugger_transport_receive
+
+**Summary**
+
+Receive message from the client.
+
+**Prototype**
+
+```c
+bool jerry_debugger_transport_receive (jerry_debugger_transport_receive_context_t *context_p);
+```
+
+- `context_p`: an unused [jerry_debugger_transport_receive_context_t](#jerry_debugger_transport_receive_context_t).
+- return value: `true`, if a client is still connected, `false` otherwise.
+
+## jerry_debugger_transport_receive_completed
+
+**Summary**
+
+Must be called after [jerry_debugger_transport_receive](#jerry_debugger_transport_receive)
+returns with a valid message. Must not be called otherwise.
+
+**Prototype**
+
+```c
+void jerry_debugger_transport_receive_completed (jerry_debugger_transport_receive_context_t *context_p);
+```
+
+- `context_p`: a [jerry_debugger_transport_receive_context_t](#jerry_debugger_transport_receive_context_t)
+               passed to [jerry_debugger_transport_receive](#jerry_debugger_transport_receive).
+
+## jerry_debugger_transport_sleep
+
+**Summary**
+
+Can be used to wait for incoming messages. Currently the delay is 100ms.
+
+**Prototype**
+
+```c
+void jerry_debugger_transport_sleep (void);
+```

14.EXT-REFERENCE-HANDLE-SCOPE.md

@@ -0,0 +1,122 @@
+---
+layout: page
+title: 'Extension API: Handle Scope'
+category: documents
+permalink: /ext-reference-handle-scope/
+---
+
+* toc
+{:toc}
+
+# Handle Scope
+
+## jerryx_handle_scope
+
+**Summary**
+It is often necessary to make the lifespan of handles shorter than the lifespan of a native method. Even though the native code could only use the most recent handle, all of the associated objects would also be kept alive since they all share the same scope.
+
+To handle this case, JerryScript HandleScope extension provides the ability to establish a new 'scope' to which newly created handles will be associated. Once those handles are no longer required, the scope can be 'closed' and any handles associated with the scope are invalidated. The methods available to open/close scopes are `jerryx_open_handle_scope` and `jerryx_close_handle_scope`.
+
+JerryScript only supports a single nested hierarchy of scopes. There is only one active scope at any time, and all new handles will be associated with that scope while it is active. Scopes must be closed in the reverse order from which they are opened. In addition, all scopes created within a native method must be closed before returning from that method.
+
+**Example**
+
+[doctest]: # ()
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/handle-scope.h"
+
+static jerry_value_t
+create_object (void)
+{
+  jerry_value_t obj = jerry_object ();
+  return obj;
+} /* create_object */
+
+static void
+test_handle_scope_val (void)
+{
+  jerryx_handle_scope scope;
+  jerryx_open_handle_scope (&scope);
+  jerry_value_t obj = jerryx_create_handle (create_object ());
+
+  jerryx_close_handle_scope (scope);
+  // now obj has been released
+} /* test_handle_scope_val */
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  test_handle_scope_val ();
+  jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
+
+  jerry_cleanup ();
+} /* main */
+```
+
+## jerryx_escapable_handle_scope
+
+**Summary**
+
+It is necessary in common cases that a handle has to be promote to outer scope and prevent from been garbage collected. To handle this case, a escapable handle scope has been proposed from which one object can be promoted to the outer scope. The method available to escape an object from been release at current scope is `jerryx_escape_handle`.
+
+**Example**
+
+[doctest]: # ()
+
+```c
+#include "jerryscript.h"
+#include "jerryscript-ext/handle-scope.h"
+
+static jerry_value_t
+create_object (void)
+{
+  jerryx_escapable_handle_scope scope;
+  jerryx_open_escapable_handle_scope (&scope);
+  jerry_value_t obj = jerryx_create_handle (jerry_object ());
+
+  jerry_value_t escaped_obj;
+  jerryx_escape_handle(scope, obj, &escaped_obj);
+  jerryx_close_handle_scope (scope);
+  // escaped_obj has now been escaped to outer scope, thus not released at this point
+
+  return escaped_obj;
+} /* create_object */
+
+static void
+test_handle_scope_val (void)
+{
+  jerryx_handle_scope scope;
+  jerryx_open_handle_scope (&scope);
+  jerry_value_t obj = create_object ();
+
+  jerryx_close_handle_scope (scope);
+  // now obj has been released
+} /* test_handle_scope_val */
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  test_handle_scope_val ();
+  jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
+
+  jerry_cleanup ();
+} /* main */
+```
+
+**See also**
+
+- [jerry_value_t](../api-reference#jerry_value_t)
+- [jerry_value_copy](../api-reference#jerry_value_copy)
+- [jerry_value_free](../api-reference#jerry_value_free)
+
+## Pre-allocated list of handle scopes and handles
+
+To prevent trapping into system calls frequently, a pre-allocated dedicated list mechanism has been introduced to the implementation of JerryX handle scope.
+
+To change the size of pre-allocation list, use build definition `JERRYX_HANDLE_PRELIST_SIZE` and `JERRYX_SCOPE_PRELIST_SIZE` to alter the default value of 20.

15.MODULE-SYSTEM.md

@@ -0,0 +1,169 @@
+---
+layout: page
+title: 'Module System (EcmaScript2015)'
+category: documents
+permalink: /module-system/
+---
+
+* toc
+{:toc}
+
+# ES6 module support for JerryScript
+
+The module system allows users to write import and export statements in scripts, which can be used to separate the logic of the application into custom modules.
+The standard's relevant part can be found [here](https://www.ecma-international.org/ecma-262/6.0/#sec-modules).
+Embedders wishing to use native builtin modules with ES6 imports can use the [Port API](05.PORT-API.md#jerry-module-system) to do so.
+
+## General
+
+If a script contains import statements, then JerryScript will open and evaluate the the referenced modules before the main script runs, resolving and creating bindings for the referenced identifiers in the process.
+It is not necessary to use any specific filename extensions for modules, JerryScript will try to open the given file paths as they are, but will try to normalize them before doing so. The exact normalization process is dependant on the port implementation provided. It is the user's responsibility to verify that the given files are valid ECMAScript modules.
+
+main.js
+
+```js
+import { exported_value } from "./module.js"
+
+print (exported_value);
+```
+
+module.js
+
+```js
+var exported_value = 42;
+
+export exported_value;
+```
+
+## Supported features
+
+* exporting identifiers from the module's lexical environment
+  * specifying export names for the exported values
+* importing exported identifiers from a module
+  * specifying local binding names for the imported values
+* module namespace imports
+  * `import * as module from 'module.js`
+* indirect export statements
+  * `export {variable} from 'module.js'`
+* star export statements
+  * `export * from 'module.js'`
+* importing a module for side-effects
+  * `import 'module.js'`
+* default import and export statements
+  * `export default local_identifier`
+  * `import def from 'module.js'`
+* anonymous default exports
+  * `export default function () {}`
+
+### Example
+
+```js
+import {
+  engine,
+  version as v
+} from "./module.js"
+
+import { getFeatureDetails } from "./module_2.js"
+
+var version = "v3.1415";
+
+print("> main.js");
+
+print(">> Engine: " + engine);
+print(">> Version: " + v);
+
+print (">> " + getFeatureDetails());
+print (">> Script version: " + version);
+```
+
+```js
+// module.js
+var _engine = "JerryScript";
+export _engine as engine;
+
+export var version = "1.0 (e92ae0fb)";
+```
+
+```js
+// module_2.js
+var featureName = "ECMAScript modules";
+var year = 2018;
+
+export function getFeatureDetails() {
+  return "Feature name: " + featureName + " | developed in " + year;
+}
+```
+
+### Module namespace import statements
+
+A module namespace object can be imported. In this case the local binding will contain an object holding the exported values of the module, including local exports and all indirect exports. Ambiguous exported names are excluded from the namespace object.
+
+```js
+import * as module from './module.js';
+
+print(">> Engine: " + module.engine);
+print(">> Version: " + module.version);
+```
+
+### Indirect export statements
+
+An export statement can transitively export variables from another module, either via named indirect exports or a star export statement. In this case the resolving process will follow the chain until it reaches a module containing a local binding for that export name. If there are multiple modules which satisfy the export, that means the export is ambiguous, and will result in a SyntaxError.
+
+```js
+import { a, b } from 'module.js'
+
+print (a + b);
+```
+
+```js
+// module.js
+export var a = 2;
+export { b } from 'module2.js'
+```
+
+```js
+// module2.js
+export var b = 40;
+```
+
+### Default imports and exports
+
+Each module can optionally provide a single default export by using the `export default` statement. Default exports can either reference identifiers in the module's lexical environment, or be an anonymous default export, in which case they will only be accessible by an importing script.
+
+```js
+import defaultExport, { b as c } from 'module.js'
+
+print (defaultExport); // 2
+print (c ()); // 42
+```
+
+```js
+// module.js
+export default 2;
+export function b () {
+  return 42;
+}
+```
+
+### Importing modules for side-effects
+
+Evaluate a module without importing anything. Any errors encountered in the module will be propagated.
+
+```js
+import 'module.js' // > module.js
+// "> module.js" is printed
+b (); // (ReferenceError) b is not defined
+```
+
+```js
+// module.js
+export function b () {
+  print ("> module.js");
+  return 42;
+}
+b ();
+```
+
+## Unsupported features
+
+* **snapshot**

16.MIGRATION-GUIDE.md

@@ -0,0 +1,783 @@
+---
+layout: page
+title: Migration Guide
+category: documents
+permalink: /migration-guide/
+---
+
+* toc
+{:toc}
+
+# Migration guide
+
+This guide intends to describe the major changes between the JerryScript 1.0 and 2.0 versions.
+In addition it is designed to provide a guide on how to modify the 1.0 version code to a
+2.0 compliant code.
+
+During the development it was important to minimize the changes in the API functions and types.
+Each API method removal or change is described below providing a ***before*** and ***after***
+code example.
+For more information on the current API methods please check the [API reference](02.API-REFERENCE.md) document.
+
+# Short list of removed/renamed headers, types, functions, and macros
+
+***Removed legacy headers***
+
+- `jerry-internal.h`
+
+***Renamed headers***
+
+- `jerry-api.h` to `jerryscript.h`
+- `jerry-port.h` to `jerryscript-port.h`
+
+***Removed API types***
+
+- `jerry_char_ptr_t` usage replaced with `jerry_char_t *`
+- `jerry_object_free_callback_t` replaced by `jerry_object_native_free_callback_t`
+
+***Removed API methods***
+
+- `jerry_get_memory_limits`
+- `jerry_get_object_native_handle` replaced by `jerry_get_object_native_pointer`
+- `jerry_set_object_native_handle` replaced by `jerry_set_object_native_pointer`
+- `jerry_value_set_abort_flag` replaced by `jerry_create_abort_from_value`
+- `jerry_value_has_abort_flag` replaced by `jerry_value_is_abort`
+- `jerry_value_set_error_flag` replaced by `jerry_create_error_from_value`
+- `jerry_value_has_error_flag` replaced by `jerry_value_is_error`
+- `jerry_value_clear_error_flag` replaced by `jerry_get_value_from_error`
+- `jerry_get_value_without_error_flag` replaced by `jerry_get_value_from_error`
+- `jerry_parse_and_save_snapshot` replaced by `jerry_generate_snapshot`
+- `jerry_parse_and_save_function_snapshot` replaced by `jerry_generate_function_snapshot`
+
+
+***Removed unused configuration macros***
+
+- `CONFIG_MEM_DATA_LIMIT_MINUS_HEAP_SIZE`
+- `CONFIG_MEM_STACK_LIMIT`
+- `CONFIG_VM_STACK_FRAME_INLINED_VALUES_NUMBER`
+- `CONFIG_ECMA_GLOBAL_ENVIRONMENT_DECLARATIVE`
+- All `CONFIG_..` macros have been renamed to use the `JERRY_` prefix format.
+
+
+# Modified API functions
+
+## Error manipulating functions
+
+The most important changes in the API are related to error handling and manipulation.
+
+### jerry_value_set_abort_flag
+
+This function was replaced with  [`jerry_create_abort_from_value`](02.API-REFERENCE.md#jerry_create_abort_from_value).
+Take note of the second argument of the new `jerry_create_abort_from_value` function which controls if the
+first argument should be usable after the call or not.
+
+**Before**
+
+```c
+{
+  jerry_value_t value;
+  // create or acquire value
+  // ...
+
+  jerry_value_set_abort_flag (&value);
+
+  jerry_release_value (value);
+}
+```
+
+**After**
+
+```c
+{
+  jerry_value_t value;
+  // create or acquire value
+  // ...
+
+  jerry_value_t abort = jerry_create_abort_from_value (value, true);
+  // using the 'value' variable after release is invalid
+
+  jerry_release_value (abort);
+}
+```
+
+- OR
+
+```c
+{
+  jerry_value_t value;
+  ... // create or acquire value
+
+  jerry_value_t abort = jerry_create_abort_from_value (value, false);
+  // both 'abort' and 'value' can be used and must be released when they are no longer needed
+
+  jerry_release_value (abort);
+  jerry_release_value (value);
+}
+```
+
+### jerry_value_has_abort_flag
+
+This function was renamed to  [`jerry_value_is_abort`](02.API-REFERENCE.md#jerry_value_is_abort).
+
+**Before**
+
+```c
+{
+  jerry_value_t value;
+  // create or acquire value
+  // ...
+
+  if (jerry_value_has_abort_flag (value))
+  {
+    // ...
+  }
+
+  jerry_release_value (value);
+}
+```
+
+**After**
+
+```c
+{
+  jerry_value_t value;
+  // create or acquire value
+  // ...
+
+  if (jerry_value_is_abort (value))
+  {
+    // ...
+  }
+
+  jerry_release_value (value);
+}
+```
+
+### jerry_value_set_error_flag
+
+This function was replaced with  [`jerry_create_error_from_value`](02.API-REFERENCE.md#jerry_create_error_from_value).
+Take note of the second argument of the new `jerry_create_error_from_value` function which controls if the
+first argument should be usable after the call or not.
+
+**Before**
+
+```c
+{
+  jerry_value_t value;
+  // create or acquire value
+  // ...
+
+  jerry_value_set_error_flag (&value);
+
+  jerry_release_value (value);
+}
+```
+
+**After**
+
+```c
+{
+  jerry_value_t value;
+  // create or acquire value
+  // ...
+
+  jerry_value_t error = jerry_create_error_from_value (value, true);
+  // using the 'value' variable after release is invalid
+
+  jerry_release_value (error);
+}
+```
+
+- OR
+
+```c
+{
+  jerry_value_t value;
+  // create or acquire value
+  // ...
+
+  jerry_value_t error = jerry_create_error_from_value (value, false);
+  // both 'error' and 'value' can be used and must be released when they are no longer needed
+
+  jerry_release_value (error);
+  jerry_release_value (value);
+}
+```
+
+### jerry_value_has_error_flag
+
+This function was renamed to  [`jerry_value_is_error`](02.API-REFERENCE.md#jerry_value_is_error).
+
+**Before**
+
+```c
+{
+  jerry_value_t value;
+  // create or acquire value
+  // ...
+
+  if (jerry_value_has_error_flag (value))
+  {
+    // ...
+  }
+
+  jerry_release_value (value);
+}
+```
+
+**After**
+
+```c
+{
+  jerry_value_t value;
+  // create or acquire value
+  // ...
+
+  if (jerry_value_is_error (value))
+  {
+    // ...
+  }
+
+  jerry_release_value (value);
+}
+```
+
+### jerry_value_clear_error_flag AND jerry_get_value_without_error_flag
+
+These functions were merged into [`jerry_get_value_from_error`](02.API-REFERENCE.md#jerry_get_value_from_error).
+Please note the second argument of the new function which controls if the first argument passed should be released
+or not.
+
+**Before**
+
+```c
+{
+  jerry_value_t value;
+  // create or acquire value
+  // ...
+
+  jerry_value_set_error_flag (&value);
+  jerry_value_clear_error_flag (&value);
+  // or
+  jerry_value_t real_value = jerry_get_value_without_error_flag (value);
+
+  jerry_release_value (value);
+  jerry_release_value (real_value);
+}
+```
+
+**After**
+
+```c
+{
+  jerry_value_t value;
+  // create or acquire value
+  // ...
+
+  jerry_value_t error = jerry_create_error_from_value (value, true);
+
+  jerry_value_t real_value = jerry_get_value_from_error (error, true);
+
+  jerry_release_value (real_value);
+}
+```
+
+## Other functions changed
+
+### jerry_register_magic_strings
+
+In case of the `jerry_register_magic_strings` function the change is that
+the first argument's base type `jerry_char_ptr_t` was changed to `jerry_char_t*`.
+For more details see: [`jerry_register_magic_strings`](02.API-REFERENCE.md#jerry_register_magic_strings).
+
+In the following code parts please take note of the type used for the `magic_string_items` array.
+
+**Before**
+
+```c
+{
+  // must be static, because 'jerry_register_magic_strings' does not copy
+  // the items must be sorted by size at first, then lexicographically
+  static const jerry_char_ptr_t magic_string_items[] = {
+                                                          (const jerry_char_ptr_t) "magicstring1",
+                                                          (const jerry_char_ptr_t) "magicstring2",
+                                                          (const jerry_char_ptr_t) "magicstring3"
+                                                        };
+  uint32_t num_magic_string_items = (uint32_t) (sizeof (magic_string_items) / sizeof (jerry_char_ptr_t));
+
+  // must be static, because 'jerry_register_magic_strings' does not copy
+  static const jerry_length_t magic_string_lengths[] = { 12, 12, 12 };
+  jerry_register_magic_strings (magic_string_items, num_magic_string_items, magic_string_lengths);
+}
+```
+
+**After**
+
+```c
+{
+  // must be static, because 'jerry_register_magic_strings' does not copy
+  // the items must be sorted by size at first, then lexicographically
+  static const jerry_char_t *magic_string_items[] = {
+                                                      (const jerry_char_t *) "magicstring1",
+                                                      (const jerry_char_t *) "magicstring2",
+                                                      (const jerry_char_t *) "magicstring3"
+                                                    };
+  uint32_t num_magic_string_items = (uint32_t) (sizeof (magic_string_items) / sizeof (jerry_char_t *));
+
+  // must be static, because 'jerry_register_magic_strings' does not copy
+  static const jerry_length_t magic_string_lengths[] = { 12, 12, 12 };
+  jerry_register_magic_strings (magic_string_items, num_magic_string_items, magic_string_lengths);
+}
+```
+
+## Snapshot generating API
+
+### jerry_parse_and_save_snapshot
+
+This function was replaced with [`jerry_generate_snapshot`](02.API-REFERENCE.md#jerry_generate_snapshot).
+The function returns an error object if there was any problem during snapshot generation and
+if there was no problem the return value is a number value containing the snapshot size in bytes.
+
+**Before**
+
+```c
+{
+  static uint32_t global_mode_snapshot_buffer[256];
+  const jerry_char_t *code_to_snapshot_p = (const jerry_char_t *) "(function () { return 'string from snapshot'; }) ();";
+
+  size_t global_mode_snapshot_size =
+    jerry_parse_and_save_snapshot (code_to_snapshot_p,
+                                   strlen ((const char *) code_to_snapshot_p),
+                                   true,
+                                   false,
+                                   global_mode_snapshot_buffer,
+                                   sizeof (global_mode_snapshot_buffer) / sizeof (uint32_t));
+  // use "global_mode_snapshot_buffer"
+}
+```
+
+**After**
+
+```c
+{
+  static uint32_t global_mode_snapshot_buffer[256];
+  const jerry_char_t *code_to_snapshot_p = (const jerry_char_t *) "(function () { return 'string from snapshot'; }) ();";
+
+  jerry_value_t generate_result;
+  generate_result = jerry_generate_snapshot (NULL,
+                                             0,
+                                             code_to_snapshot_p,
+                                             strlen ((const char *) code_to_snapshot_p),
+                                             global_mode_snapshot_buffer,
+                                             sizeof (global_mode_snapshot_buffer) / sizeof (uint32_t));
+  if (jerry_value_is_error (generate_result))
+  {
+    // There was a problem during snapshot generation, for example there is a SyntaxError.
+    // Use the "generate_result" to check the error.
+  }
+  else
+  {
+    size_t snapshot_size = (size_t) jerry_get_number_value (generate_result);
+    // use "global_mode_snapshot_buffer"
+  }
+  jerry_release_value (generate_result);
+}
+```
+
+### jerry_parse_and_save_function_snapshot
+
+This function was replaced with [`jerry_generate_function_snapshot`](02.API-REFERENCE.md#jerry_parse_and_save_function_snapshot).
+The function returns an error object if there was any problem during snapshot generation and
+if there was no problem the return value is a number value containing the snapshot size in bytes.
+
+**Before**
+
+```c
+{
+  static uint32_t func_snapshot_buffer[1024];
+
+  const jerry_char_t *args_p = (const jerry_char_t *) "a, b";
+  const jerry_char_t *src_p = (const jerry_char_t *) "return a + b;";
+
+  size_t func_snapshot_size =
+  jerry_parse_and_save_function_snapshot (src_p,
+                                          strlen ((const char *) src_p),
+                                          args_p,
+                                          strlen ((const char *) args_p),
+                                          false,
+                                          func_snapshot_buffer,
+                                          sizeof (func_snapshot_buffer) / sizeof (uint32_t));
+  // check "function_snapshot_size" and use "func_snapshot_buffer"
+}
+```
+
+**After**
+
+```c
+{
+  static uint32_t func_snapshot_buffer[1024];
+
+  const jerry_char_t *args_p = (const jerry_char_t *) "a, b";
+  const jerry_char_t *src_p = (const jerry_char_t *) "return a + b;";
+
+  jerry_value_t generate_result;
+  generate_result = jerry_generate_function_snapshot (NULL,
+                                                      0,
+                                                      src_p,
+                                                      strlen ((const char *) src_p),
+                                                      args_p,
+                                                      strlen ((const char *) args_p),
+                                                      0,
+                                                      func_snapshot_buffer,
+                                                      sizeof (func_snapshot_buffer) / sizeof (uint32_t));
+  if (jerry_value_is_error (generate_result))
+  {
+    // There was a problem during snapshot generation, for example there is a SyntaxError.
+    // Use the "generate_result" to check the error.
+  }
+  else
+  {
+    size_t snapshot_size = (size_t) jerry_get_number_value (generate_result);
+    // use "func_snapshot_buffer"
+  }
+
+  jerry_release_value (generate_result)
+}
+```
+
+## Garbage collection
+
+### jerry_gc
+
+The [`jerry_gc`](02.API-REFERENCE.md#jerry_gc) function was modified to handle an argument which represents the pressure for the garbage collector.
+For more information checkout the [`jerry_gc_mode_t`](02.API-REFERENCE.md#jerry_gc_mode_t) reference.
+
+**Before**
+
+```c
+{
+  jerry_gc ();
+}
+```
+
+**After**
+
+```c
+{
+  jerry_gc (JERRY_GC_PRESSURE_LOW);
+}
+```
+
+## jerry_eval
+
+The third argument of [`jerry_eval`](02.API-REFERENCE.md#jerry_eval) has been changed
+from `bool` to [`jerry_parse_opts_t`](02.API-REFERENCE.md#jerry_parse_opts_t).
+
+**Before**
+
+```c
+const jerry_char_t *str_to_eval = (const jerry_char_t *) "1 + 1";
+jerry_value_t ret_val = jerry_eval (str_to_eval,
+                                    strlen ((const char *) str_to_eval),
+                                    false);
+```
+
+**After**
+
+```c
+const jerry_char_t *str_to_eval = (const jerry_char_t *) "1 + 1";
+jerry_value_t ret_val = jerry_eval (str_to_eval,
+                                    strlen ((const char *) str_to_eval),
+                                    JERRY_PARSE_NO_OPTS);
+```
+
+## Port API
+
+### jerry_port_get_time_zone
+
+The port API of handling timezones has been changed. The previous interface did not
+allow timezones to be handled correctly, even if the host system was up to the task.
+Check [the related issue](https://github.com/jerryscript-project/jerryscript/issues/1661)
+for more details.
+
+The new port API function name is [jerry_port_get_local_time_zone_adjustment](05.PORT-API.md#date-1].
+
+Below is the default implementations for both versions:
+
+**Before**
+
+```c
+bool jerry_port_get_time_zone (jerry_time_zone_t *tz_p)
+{
+  struct timeval tv;
+  struct timezone tz;
+
+  /* gettimeofday may not fill tz, so zero-initializing */
+  tz.tz_minuteswest = 0;
+  tz.tz_dsttime = 0;
+
+  if (gettimeofday (&tv, &tz) != 0)
+  {
+    return false;
+  }
+
+  tz_p->offset = tz.tz_minuteswest;
+  tz_p->daylight_saving_time = tz.tz_dsttime > 0 ? 1 : 0;
+
+  return true;
+} /* jerry_port_get_time_zone */
+```
+
+**After**
+
+```c
+double jerry_port_get_local_time_zone_adjustment (double unix_ms,
+                                                  bool is_utc)
+{
+  struct tm tm;
+  time_t now = (time_t) (unix_ms / 1000);
+  localtime_r (&now, &tm);
+  if (!is_utc)
+  {
+    now -= tm.tm_gmtoff;
+    localtime_r (&now, &tm);
+  }
+  return ((double) tm.tm_gmtoff) * 1000;
+} /* jerry_port_get_local_time_zone_adjustment */
+```
+
+## Native pointers
+
+The assignment of native pointers (previously called handles) have been changed
+since v1.0. In the previous version only one native pointer could be assigned to
+a `jerry_value_t`. Now it is allowed to register multiple native infos, which
+can be accessed with the corresponding
+[`jerry_object_native_info_t`](02.API-REFERENCE.md#jerry_object_native_info_t).
+The old functions were removed and replaced by new ones.
+
+- `jerry_object_free_callback_t` callback type is replaced by `jerry_object_native_info_t`
+- `jerry_get_object_native_handle` is replaced by [`jerry_get_object_native_pointer`](02.API-REFERENCE.md#jerry_get_object_native_pointer)
+- `jerry_set_object_native_handle` is replaced by [`jerry_set_object_native_pointer`](02.API-REFERENCE.md#jerry_set_object_native_pointer)
+
+**Before**
+
+```c
+struct
+{
+  int data;
+} my_info;
+
+static void
+handler_construct_freecb (uintptr_t native_p)
+{
+  // Invoked when the JS object is released and the
+  // native data should be freed.
+
+  struct my_info *info = (struct my_info *) native_p;
+  free (info);
+}
+
+void
+demo (void)
+{
+  jerry_value_t this_val;
+  // create or acquire this_val
+  // ...
+
+  struct my_info *info = (struct my_info *) malloc (sizeof (struct my_info));
+  info->data = 11;
+
+  // setting the native handle
+  jerry_set_object_native_handle (this_val,
+                                  (uintptr_t) info,
+                                  handler_construct_freecb);
+  // ...
+  // reading back the native handle
+  uintptr_t ptr = (uintptr_t) NULL;
+  bool is_ok = jerry_get_object_native_handle (this_val, &ptr);
+  if (is_ok)
+  {
+    struct my_info *obj_info = (struct my_info *) ptr;
+    // use "obj_info"
+  }
+}
+```
+
+
+**After**
+
+```c
+struct
+{
+  int data;
+} my_info;
+
+static void
+handler_construct_freecb (void *native_p)
+{
+  // Invoked when the JS object is released and the
+  // native data should be freed.
+
+  struct my_info *info = (struct my_info *) native_p;
+  free (info);
+}
+
+static const jerry_object_native_info_t my_info_type_info =
+{
+  .free_cb = handler_construct_freecb
+};
+
+void
+demo (void)
+{
+  jerry_value_t this_val;
+  // create or acquire this_val
+  // ...
+
+  struct my_info *info = (struct my_info *) malloc (sizeof (struct my_info));
+  info->data = 11;
+
+  // setting the native handle
+  jerry_set_object_native_pointer (this_val,
+                                   info,
+                                   &my_info_type_info);
+  // ...
+  // reading back the native handle pointed by the "my_info_type_info" variable
+  void *ptr = NULL;
+  bool has_p = jerry_get_object_native_pointer (this_val, &ptr, &my_info_type_info);
+  if (has_p)
+  {
+    struct my_info *obj_info = (struct my_info *) ptr;
+    // use "obj_info"
+  }
+}
+```
+
+# New API functions
+
+In this section the new API functions are listed.
+
+## Built-in objects
+
+***ArrayBuffer***
+
+- [`jerry_create_arraybuffer`](02.API-REFERENCE.md#jerry_create_arraybuffer)
+- [`jerry_create_arraybuffer_external`](02.API-REFERENCE.md#jerry_create_arraybuffer_external)
+- [`jerry_get_arraybuffer_pointer`](02.API-REFERENCE.md#jerry_get_arraybuffer_pointer)
+
+***DataView***
+
+- [`jerry_create_dataview`](02.API-REFERENCE.md#jerry_create_dataview)
+- [`jerry_value_is_dataview`](02.API-REFERENCE.md#jerry_value_is_dataview)
+- [`jerry_get_dataview_buffer`](02.API-REFERENCE.md#jerry_get_dataview_buffer)
+
+***JSON***
+
+- [`jerry_json_parse`](02.API-REFERENCE.md#jerry_json_parse)
+- [`jerry_json_stringify`](02.API-REFERENCE.md#jerry_json_stringify)
+
+***Number***
+
+- [`jerry_create_number_infinity`](02.API-REFERENCE.md#jerry_create_number_infinity)
+- [`jerry_create_number_nan`](02.API-REFERENCE.md#jerry_create_number_nan)
+
+***Promise***
+
+- [`jerry_run_all_enqueued_jobs`](02.API-REFERENCE.md#jerry_run_all_enqueued_jobs)
+- [`jerry_create_promise`](02.API-REFERENCE.md#jerry_create_promise)
+- [`jerry_resolve_or_reject_promise`](02.API-REFERENCE.md#jerry_resolve_or_reject_promise)
+- [`jerry_value_is_promise`](02.API-REFERENCE.md#jerry_value_is_promise)
+
+***RegExp***
+
+- [`jerry_create_regexp`](02.API-REFERENCE.md#jerry_create_regexp)
+- [`jerry_create_regexp_sz`](02.API-REFERENCE.md#jerry_create_regexp_sz)
+
+***String***
+
+- [`jerry_substring_to_utf8_char_buffer`](02.API-REFERENCE.md#jerry_substring_to_utf8_char_buffer)
+- [`jerry_get_utf8_string_size`](02.API-REFERENCE.md#jerry_get_utf8_string_size)
+- [`jerry_get_utf8_string_length`](02.API-REFERENCE.md#jerry_get_utf8_string_length)
+- [`jerry_create_string_from_utf8`](02.API-REFERENCE.md#jerry_create_string_from_utf8)
+- [`jerry_create_string_sz_from_utf8`](02.API-REFERENCE.md#jerry_create_string_sz_from_utf8)
+
+***Symbol***
+
+- [`jerry_create_symbol`](02.API-REFERENCE.md#jerry_create_symbol)
+- [`jerry_get_symbol_descriptive_string`](02.API-REFERENCE.md#jerry_get_symbol_descriptive_string)
+- [`jerry_value_is_symbol`](02.API-REFERENCE.md#jerry_value_is_symbol)
+
+***TypedArray***
+
+- [`jerry_create_typedarray`](02.API-REFERENCE.md#jerry_create_typedarray)
+- [`jerry_create_typedarray_for_arraybuffer`](02.API-REFERENCE.md#jerry_create_typedarray_for_arraybuffer)
+- [`jerry_create_typedarray_for_arraybuffer_sz`](02.API-REFERENCE.md#jerry_create_typedarray_for_arraybuffer_sz)
+- [`jerry_get_typedarray_type`](02.API-REFERENCE.md#jerry_get_typedarray_type)
+- [`jerry_get_typedarray_length`](02.API-REFERENCE.md#jerry_get_typedarray_length)
+- [`jerry_get_typedarray_buffer`](02.API-REFERENCE.md#jerry_get_typedarray_buffer)
+- [`jerry_value_is_typedarray`](02.API-REFERENCE.md#jerry_value_is_typedarray)
+
+
+## Instances and memory management
+
+***JerryScript instances***
+
+- [`jerry_create_context`](02.API-REFERENCE.md#jerry_create_context)
+- [`jerry_get_context_data`](02.API-REFERENCE.md#jerry_get_context_data)
+
+***Memory management***
+
+- [`jerry_heap_alloc`](02.API-REFERENCE.md#jerry_heap_alloc)
+- [`jerry_heap_free`](02.API-REFERENCE.md#jerry_heap_free)
+
+
+## Operations with JavaScript values
+
+***Binary operations***
+
+- [`jerry_binary_operation`](02.API-REFERENCE.md#jerry_binary_operation)
+
+***Error manipulating***
+
+- [`jerry_get_error_type`](02.API-REFERENCE.md#jerry_get_error_type)
+- [`jerry_get_backtrace`](02.API-REFERENCE.md#jerry_get_backtrace)
+
+***Native pointers***
+
+- [`jerry_delete_object_native_pointer`](02.API-REFERENCE.md#jerry_delete_object_native_pointer)
+- [`jerry_objects_foreach_by_native_info`](02.API-REFERENCE.md#jerry_objects_foreach_by_native_info)
+
+***Property***
+
+- [`jerry_delete_property_by_index`](02.API-REFERENCE.md#jerry_delete_property_by_index)
+- [`jerry_objects_foreach`](02.API-REFERENCE.md#jerry_objects_foreach)
+
+
+## Debugger
+
+- [`jerry_debugger_is_connected`](07.DEBUGGER.md#jerry_debugger_is_connected)
+- [`jerry_debugger_stop`](07.DEBUGGER.md#jerry_debugger_stop)
+- [`jerry_debugger_continue`](07.DEBUGGER.md#jerry_debugger_continue)
+- [`jerry_debugger_stop_at_breakpoint`](07.DEBUGGER.md#jerry_debugger_stop_at_breakpoint)
+- [`jerry_debugger_wait_for_client_source`](07.DEBUGGER.md#jerry_debugger_wait_for_client_source)
+- [`jerry_debugger_send_output`](07.DEBUGGER.md#jerry_debugger_send_output)
+- [`jerry_debugger_send_log`](07.DEBUGGER.md#jerry_debugger_send_log)
+
+
+## Other
+
+- [`jerry_is_feature_enabled`](02.API-REFERENCE.md#jerry_is_feature_enabled)
+- [`jerry_parse_and_save_literals`](02.API-REFERENCE.md#jerry_parse_and_save_literals)
+- [`jerry_set_vm_exec_stop_callback`](02.API-REFERENCE.md#jerry_set_vm_exec_stop_callback)
+
+
+## Port API functions
+
+- [`jerry_port_normalize_path`](05.PORT-API.md#jerry_port_normalize_path)
+- [`jerry_port_read_source`](05.PORT-API.md#jerry_port_read_source)
+- [`jerry_port_release_source`](05.PORT-API.md#jerry_port_release_source)
+- [`jerry_port_print_char`](05.PORT-API.md#jerry_port_print_char)
+- [`jerry_port_get_current_context`](05.PORT-API.md#jerry_port_get_current_context)
+- [`jerry_port_fatal`](05.PORT-API.md#jerry_port_fatal)
+- [`jerry_port_sleep`](05.PORT-API.md#jerry_port_sleep)
+- [`jerry_port_print_byte`](05.PORT-API.md#jerry_port_print_byte)

CMakeLists.txt

@@ -1,230 +0,0 @@
-# Copyright 2015-2016 Samsung Electronics Co., Ltd.
-# Copyright 2016 University of Szeged.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-cmake_minimum_required (VERSION 2.8.12)
-project (Jerry C ASM)
-
-# Determining platform
-set(PLATFORM "${CMAKE_SYSTEM_NAME}")
-string(TOUPPER "${PLATFORM}" PLATFORM)
-
-# Remove rdynamic option
-set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS )
-
-# Components
-set(JERRY_CORE    ON  CACHE BOOL "Use jerry-core?")
-set(JERRY_LIBC    ON  CACHE BOOL "Use jerry-libc?")
-set(JERRY_LIBM    ON  CACHE BOOL "Use jerry-libm?")
-set(JERRY_CMDLINE ON  CACHE BOOL "Use jerry command line tool?")
-set(UNITTESTS     OFF CACHE BOOL "Use unit tests?")
-
-# Optional build settings
-set(PORT_DIR                  "${CMAKE_SOURCE_DIR}/targets/default" CACHE STRING "Should we use default or external port?")
-set(COMPILER_DEFAULT_LIBC     OFF                                   CACHE BOOL   "Enable compiler default libc?")
-set(ENABLE_LTO                OFF                                   CACHE BOOL   "Enable LTO build?")
-set(ENABLE_ALL_IN_ONE         ON                                    CACHE BOOL   "Enable all-in-one build?")
-set(ENABLE_STRIP              ON                                    CACHE BOOL   "Discards all symbols from object files?")
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-if("${PLATFORM}" STREQUAL "DARWIN")
-  set(ENABLE_LTO "OFF")
-  set(ENABLE_ALL_IN_ONE "ON")
-  set(JERRY_LIBC "OFF")
-  set(JERRY_LIBM "OFF")
-  set(COMPILER_DEFAULT_LIBC "ON")
-endif()
-
-if(JERRY_LIBC AND COMPILER_DEFAULT_LIBC)
-  message(FATAL_ERROR "JERRY_LIBC and COMPILER_DEFAULT_LIBC is enabled at the same time!")
-endif()
-
-# Status messages
-message(STATUS "CMAKE_SYSTEM_NAME         " ${CMAKE_SYSTEM_NAME})
-message(STATUS "CMAKE_SYSTEM_PROCESSOR    " ${CMAKE_SYSTEM_PROCESSOR})
-message(STATUS "CMAKE_BUILD_TYPE          " ${CMAKE_BUILD_TYPE})
-message(STATUS "JERRY_CORE                " ${JERRY_CORE})
-message(STATUS "JERRY_LIBC                " ${JERRY_LIBC})
-message(STATUS "JERRY_LIBM                " ${JERRY_LIBM})
-message(STATUS "JERRY_CMDLINE             " ${JERRY_CMDLINE})
-message(STATUS "UNITTESTS                 " ${UNITTESTS})
-message(STATUS "PORT_DIR                  " ${PORT_DIR})
-message(STATUS "COMPILER_DEFAULT_LIBC     " ${COMPILER_DEFAULT_LIBC})
-message(STATUS "ENABLE_LTO                " ${ENABLE_LTO})
-message(STATUS "ENABLE_ALL_IN_ONE         " ${ENABLE_ALL_IN_ONE})
-message(STATUS "ENABLE_STRIP              " ${ENABLE_STRIP})
-
-# Setup directories
-# Project binary dir
-set(PROJECT_BINARY_DIR "${CMAKE_BINARY_DIR}")
-
-# Library output directory
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib/")
-
-# Executable output directory
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin/")
-
-# Archive targets output Directory
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib/")
-
-# Compile/link flags
-# Helper macros
-macro(jerry_add_flags VAR)
-  foreach(_flag ${ARGN})
-    set(${VAR} "${${VAR}} ${_flag}")
-  endforeach()
-endmacro()
-
-macro(jerry_add_compile_flags)
-  jerry_add_flags(CMAKE_C_FLAGS ${ARGV})
-endmacro()
-
-macro(jerry_add_compile_warnings)
-  foreach(_warning ${ARGV})
-    jerry_add_compile_flags(-W${_warning})
-    if(CMAKE_COMPILER_IS_GNUCC)
-      jerry_add_compile_flags(-Werror=${_warning})
-    endif()
-  endforeach()
-endmacro()
-
-macro(jerry_add_link_flags)
-  jerry_add_flags(LINKER_FLAGS_COMMON ${ARGV})
-endmacro()
-
-# build mode specific compile/link flags
-set(CMAKE_C_FLAGS_RELEASE "-Os")
-
-# Architecture-specific compile/link flags
-jerry_add_compile_flags(${FLAGS_COMMON_ARCH})
-jerry_add_flags(CMAKE_EXE_LINKER_FLAGS ${FLAGS_COMMON_ARCH})
-
-# LTO
-if(ENABLE_LTO)
-  jerry_add_compile_flags(-flto)
-  jerry_add_link_flags(-flto)
-  if(CMAKE_COMPILER_IS_GNUCC)
-    if(NOT "${PLATFORM}" STREQUAL "DARWIN")
-      jerry_add_compile_flags(-fno-fat-lto-objects)
-    endif()
-    # Use gcc-ar and gcc-ranlib to support LTO
-    set(CMAKE_AR "gcc-ar")
-    set(CMAKE_RANLIB "gcc-ranlib")
-  endif()
-endif()
-
-# Define _BSD_SOURCE if we use default port and compiler default libc
-if(${PORT_DIR} STREQUAL "${CMAKE_SOURCE_DIR}/targets/default" AND COMPILER_DEFAULT_LIBC)
-  set(DEFINES_JERRY ${DEFINES_JERRY} _BSD_SOURCE)
-endif()
-
-# Imported targets prefix
-set(PREFIX_IMPORTED_LIB imported_)
-
-# Imported libraries
-if(("${PLATFORM}" STREQUAL "DARWIN") AND (NOT CMAKE_COMPILER_IS_GNUCC))
-  # libclang_rt.osx
-  set(IMPORTED_LIB "${PREFIX_IMPORTED_LIB}libclang_rt.osx")
-  add_library(${IMPORTED_LIB} STATIC IMPORTED)
-  execute_process(COMMAND ${CMAKE_C_COMPILER} ${FLAGS_COMMON_ARCH} -print-file-name=
-                  OUTPUT_VARIABLE IMPORTED_LIBCLANG_RT_LOCATION
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
-  set(IMPORTED_LIBCLANG_RT_LOCATION "${IMPORTED_LIBCLANG_RT_LOCATION}/lib/darwin/libclang_rt.osx.a")
-  set_property(TARGET ${IMPORTED_LIB}
-               PROPERTY IMPORTED_LOCATION ${IMPORTED_LIBCLANG_RT_LOCATION})
-else()
-  # libgcc
-  set(IMPORTED_LIB "${PREFIX_IMPORTED_LIB}libgcc")
-  add_library(${IMPORTED_LIB} STATIC IMPORTED)
-  execute_process(COMMAND ${CMAKE_C_COMPILER} ${FLAGS_COMMON_ARCH} -print-file-name=libgcc.a
-                  OUTPUT_VARIABLE IMPORTED_LIBGCC_LOCATION
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
-  set_property(TARGET ${IMPORTED_LIB}
-               PROPERTY IMPORTED_LOCATION ${IMPORTED_LIBGCC_LOCATION})
-endif()
-
-# Compiler / Linker flags
-jerry_add_compile_flags(-fno-builtin)
-if(("${PLATFORM}" STREQUAL "DARWIN"))
-  jerry_add_link_flags(-lSystem)
-else()
-  jerry_add_link_flags(-Wl,-z,noexecstack)
-endif()
-
-# Turn off linking to compiler's default libc, in case jerry-libc or external is used
-if(NOT COMPILER_DEFAULT_LIBC)
-  jerry_add_link_flags(-nostdlib)
-endif()
-
-# Turn off stack protector
-jerry_add_compile_flags(-fno-stack-protector)
-
-# Debug information
-jerry_add_compile_flags(-g -gdwarf-4)
-
-jerry_add_compile_warnings(all extra format-nonliteral init-self conversion sign-conversion format-security missing-declarations)
-jerry_add_compile_flags(-Wno-stack-protector -Wno-attributes)
-
-if(CMAKE_COMPILER_IS_GNUCC)
-  if(JERRY_LIBC)
-    jerry_add_compile_flags(-Werror)
-  endif()
-  jerry_add_compile_warnings(logical-op)
-else()
-  jerry_add_compile_flags(-Wno-nested-anon-types)
-endif()
-
-if(DEFINED EXTERNAL_COMPILE_FLAGS)
-  jerry_add_compile_flags(${EXTERNAL_COMPILE_FLAGS})
-endif()
-
-if(DEFINED EXTERNAL_LINKER_FLAGS)
-  jerry_add_link_flags(${EXTERNAL_LINKER_FLAGS})
-endif()
-
-# C
-jerry_add_compile_flags(-std=c99 -pedantic)
-
-# Strip binary
-if(ENABLE_STRIP AND NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
-  jerry_add_link_flags(-s)
-endif()
-
-# Jerry's libc
-if(JERRY_LIBC)
-  add_subdirectory(jerry-libc)
-endif()
-
-# Jerry's libm
-if(JERRY_LIBM)
-  add_subdirectory(jerry-libm)
-endif()
-
-# Jerry's core
-if(JERRY_CORE)
-  add_subdirectory(jerry-core)
-endif()
-
-# Jerry commandline tool
-if(JERRY_CMDLINE)
-  add_subdirectory(jerry-main)
-endif()
-
-# Unittests
-if(UNITTESTS)
-  add_subdirectory(tests/unit)
-endif()

CNAME

@@ -0,0 +1 @@
+jerryscript.net

LICENSE

@@ -1,13 +0,0 @@
-Copyright 2014-2016 Samsung Electronics Co., Ltd.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

README.md

@@ -1,46 +0,0 @@
-![](https://github.com/Samsung/jerryscript/blob/master/LOGO.png)
-# JerryScript: JavaScript engine for the Internet of Things
-[![License](https://img.shields.io/badge/licence-Apache%202.0-brightgreen.svg?style=flat)](LICENSE)
-[![Build Status](https://travis-ci.org/Samsung/jerryscript.svg?branch=master)](https://travis-ci.org/Samsung/jerryscript)
-
-JerryScript is a lightweight JavaScript engine for resource-constrained devices such as microcontrollers. It can run on devices with less than 64 KB of RAM and less than 200 KB of flash memory.
-
-Key characteristics of JerryScript:
-* Full ECMAScript 5.1 standard compliance
-* 160K binary size when compiled for ARM Thumb-2
-* Heavily optimized for low memory consumption
-* Written in C99 for maximum portability
-* Snapshot support for precompiling JavaScript source code to byte code
-* Mature C API, easy to embed in applications
-
-Additional information can be found on our [project page](http://samsung.github.io/jerryscript) and [Wiki](https://github.com/Samsung/jerryscript/wiki).
-
-IRC channel: #jerryscript on [freenode](https://freenode.net)  
-Mailing list: jerryscript-dev@gna.org, you can subscribe [here](https://mail.gna.org/listinfo/jerryscript-dev) and access the mailing list archive [here](https://mail.gna.org/public/jerryscript-dev).
-
-## Quick Start
-### Getting the sources
-```bash
-git clone https://github.com/Samsung/jerryscript.git
-cd jerryscript
-```
-
-### Building JerryScript
-```bash
-python tools/build.py
-```
-
-For additional information see [Getting Started](docs/01.GETTING-STARTED.md).
-
-## Documentation
-- [Getting Started](docs/01.GETTING-STARTED.md)
-- [API Reference](docs/02.API-REFERENCE.md)
-- [API Example](docs/03.API-EXAMPLE.md)
-- [Internals](docs/04.INTERNALS.md)
-
-## License
-JerryScript is Open Source software under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). Complete license and copyright information can be found in the source code.
-
-> Copyright 2015 Samsung Electronics Co., Ltd.
-
-> Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

_config.yml

@@ -0,0 +1,4 @@
+# Site settings
+title: JerryScript Engine
+description: JerryScript is a very lightweight JavaScript engine with capability to run on microcontrollers with less than 8KB of RAM.
+# baseurl: "/jerryscript" # the subpath of your site, e.g. /blog/

_includes/footer.html

@@ -0,0 +1,5 @@
+<footer class="footer">
+  <div class="container">
+      <p class="copyright_and_license_notice">JerryScript is an open source project under the <a href="http://www.apache.org/licenses/">Apache License, Version 2.0.</a></p>
+   </div>
+</footer>

_includes/head.html

@@ -0,0 +1,22 @@
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+
+  <meta name="description" content="{% if page.excerpt %}{{ page.excerpt | strip_html | strip_newlines | truncate: 160 }}{% else %}{{ site.description }}{% endif %}">
+  <meta name="author" content="JerryScript">
+
+  <title>JavaScript engine for Internet of Things{% if page.title %}: {{ page.title }} {% endif %}</title>
+
+  <!-- Bootstrap core CSS -->
+  <link rel="stylesheet" href="{{ '/css/bootstrap.min.css' | relative_url }}">
+  <link rel="stylesheet" href="{{ '/css/table.css' | relative_url }}">
+  <link rel="stylesheet" href="{{ '/css/bytecode.css' | relative_url }}">
+  <link rel="stylesheet" href="{{ '/css/block.css' | relative_url }}">
+  <link rel="stylesheet" href="{{ '/css/main.css' | relative_url }}">
+  <link rel="stylesheet" href="{{ '/css/img.css' | relative_url }}">
+
+  <script>
+    window.addEventListener("hashchange", function() { scrollBy(0, -50) });
+  </script>
+</head>

_includes/header.html

@@ -0,0 +1,47 @@
+<nav class="navbar navbar-inverse navbar-fixed-top">
+  <div class="container">
+    <div class="navbar-header">
+      <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
+        <span class="sr-only">Toggle navigation</span>
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+      </button>
+      <a class="navbar-brand" href="{{ '/' | relative_url }}"><b>JerryScript</b></a>
+    </div>
+    <div id="navbar" class="collapse navbar-collapse">
+      <ul class="nav navbar-nav">
+        {% if page.url == "/" %}
+          <li class="active"><a href="{{ '/' | relative_url }}">Home</a></li>
+        {% else %}
+          <li><a href="{{ '/' | relative_url }}">Home</a></li>
+        {% endif %}
+        <li><a href="https://www.iotjs.net">Powering <b>IoT.js</b></a></li>
+      </ul>
+      <ul class="nav navbar-nav navbar-right">
+        {% for p in site.pages %}
+          {% if p.title %}
+            {% if p.category == "navbar" %}
+              {% if page.url == p.url %}
+                <li class="active"><a href="{{ p.url | relative_url }}" >{{ p.title }}</a></li>
+              {% else %}
+                <li><a href="{{ p.url | relative_url }}" >{{ p.title }}</a></li>
+              {% endif %}
+            {% endif %}
+          {% endif %}
+        {% endfor %}
+        <li class="dropdown"><a class="dropdown-toggle" data-toggle="dropdown" href="#">Documents <span class="caret"></span></a>
+          <ul class="dropdown-menu">
+            {% assign doclist = site.pages | sort: 'title' %}
+            {% for p in doclist %}
+              {% if p.title and p.category == "documents" %}
+                <li><a href="{{ p.url | relative_url }}" >{{ p.title }}</a></li>
+              {% endif %}
+            {% endfor %}
+          </ul>
+        </li>
+      </ul>
+    </div><!--/.nav-collapse -->
+  </div>
+</nav>
+<a href="https://github.com/jerryscript-project/jerryscript"><img style="position: absolute; top: 50; right: 0; border: 0;" src="https://github.blog/wp-content/uploads/2008/12/forkme_right_orange_ff7600.png" alt="Fork me on GitHub" data-canonical-src="https://s3.amazonaws.com/github/ribbons/forkme_right_orange_ff7600.png"></a>

_layouts/default.html

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+
+  {% include head.html %}
+
+  <body>
+
+    {% include header.html %}
+
+    <div class="container">
+        {{ content }}
+    </div><!-- /.container -->
+
+    {% include footer.html %}
+
+    <!-- Bootstrap core JavaScript -->
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.2/jquery.min.js"></script>
+    <script src="{{ '/js/bootstrap.min.js' | relative_url }}"></script>
+
+  </body>
+</html>

_layouts/page.html

@@ -0,0 +1,14 @@
+---
+layout: default
+---
+<div class="post">
+
+  <header class="post-header">
+    <h1 class="post-title">{{ page.title }}</h1>
+  </header>
+
+  <article class="post-content">
+    {{ content }}
+  </article>
+
+</div>

_layouts/post.html

@@ -0,0 +1,15 @@
+---
+layout: default
+---
+<div class="post">
+
+  <header class="post-header">
+    <h1 class="post-title">{{ page.title }}</h1>
+    <p class="post-meta">{{ page.date | date: "%b %-d, %Y" }}{% if page.author %} • {{ page.author }}{% endif %}{% if page.meta %} • {{ page.meta }}{% endif %}</p>
+  </header>
+
+  <article class="post-content">
+    {{ content }}
+  </article>
+
+</div>

_sass/_base.scss

@@ -0,0 +1,264 @@
+/**
+ * Reset some basic elements
+ */
+/*body, h1, h2, h3, h4, h5, h6,
+p, blockquote, pre, hr,
+dl, dd, ol, ul, figure {
+    margin: 0;
+    padding: 0;
+}*/
+
+p {
+    margin: 0;
+    padding: 0;
+    text-align: justify;
+    -moz-text-align-last: left;
+    text-align-last: left;
+}
+
+/**
+ * Basic styling
+ */
+body {
+    /*font-family: $base-font-family;*/
+    font-size: $base-font-size;
+    line-height: $base-line-height;
+    /*font-weight: 300;*/
+    color: $text-color;
+    background-color: white;
+    -webkit-text-size-adjust: 100%;
+}
+
+
+/**
+ * Set `margin-bottom` to maintain vertical rhythm
+ */
+/*h1, h2, h3, h4, h5, h6,*/
+p, blockquote, pre,
+ul, ol, dl, figure,
+%vertical-rhythm {
+    margin-bottom: $spacing-unit / 2;
+}
+
+/**
+ * Styles from index
+ */
+ html {
+      position: relative;
+       min-height: 100%;
+ }
+ body {
+   padding-top: 50px;
+   margin-bottom: 50px;
+ }
+ .footer {
+   position: absolute;
+   bottom: 0;
+   width: 100%;
+   height: 40px;
+   background-color: #f5f5f5;
+ }
+ .project_title h1{
+    font-size: 64px; text-align: center;
+    font-weight: bold;
+  }
+ .project_title {
+   padding: 40px 20px;
+    text-align: center;
+    border-radius: 6px;
+
+    p {
+      text-align: center;
+      -moz-text-align-last: center;
+    }
+  }
+  .lead {
+      color:#245580;
+  }
+  .project_overview {
+      font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;
+      font-size: 18px;
+      padding: 40px; padding-bottom: 20px;
+      background-color: #f5f5f5;
+  }
+  .learn_more {
+      font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;
+      font-size: 18px;
+      padding: 40px; padding-bottom: 20px;
+  }
+  .container .copyright_and_license_notice {
+      margin: 8px 0;
+      font-size:14px; text-align: center;
+      color:#3C3C3C;
+  }
+
+
+/**
+ * Images
+ */
+img {
+    max-width: 100%;
+    vertical-align: middle;
+    display: block;
+    margin: 0 auto;
+    max-height: 80%;
+    max-width: 100%;
+}
+
+
+
+/**
+ * Figures
+ */
+figure > img {
+    display: block;
+}
+
+figcaption {
+    font-size: $small-font-size;
+}
+
+
+
+/**
+ * Lists
+ */
+/*ul, ol {
+    margin-left: $spacing-unit;
+}*/
+
+li {
+    > ul,
+    > ol {
+         margin-bottom: 0;
+    }
+}
+
+
+
+/**
+ * Headings
+ */
+h1, h2, h3, h4, h5, h6 {
+    font-weight: 300;
+}
+
+
+
+/**
+ * Links
+ */
+a {
+    color: $brand-color;
+    text-decoration: none;
+
+    &:visited {
+        color: darken($brand-color, 15%);
+    }
+
+    &:hover {
+        color: $text-color;
+        text-decoration: underline;
+    }
+}
+
+
+
+/**
+ * Blockquotes
+ */
+blockquote {
+    color: $grey-color;
+    border-left: 4px solid $grey-color-light;
+    padding-left: $spacing-unit / 2;
+    font-size: 18px;
+    letter-spacing: -1px;
+    font-style: italic;
+
+    > :last-child {
+        margin-bottom: 0;
+    }
+}
+
+
+
+/**
+ * Code formatting
+ */
+pre,
+code {
+    font-size: 15px;
+    border: 1px solid $grey-color-light;
+    border-radius: 3px;
+    background-color: #f7f7f7;
+    font-family: Courier;
+}
+
+code {
+    padding: 1px 5px;
+}
+
+pre {
+    padding: 8px 12px;
+
+    > code {
+        border: 0;
+        padding-right: 0;
+        padding-left: 0;
+    }
+}
+
+
+
+/**
+ * Wrapper
+ */
+.wrapper {
+    max-width: -webkit-calc(#{$content-width} - (#{$spacing-unit} * 2));
+    max-width:         calc(#{$content-width} - (#{$spacing-unit} * 2));
+    margin-right: auto;
+    margin-left: auto;
+    padding-right: $spacing-unit;
+    padding-left: $spacing-unit;
+    @extend %clearfix;
+
+    @include media-query($on-laptop) {
+        max-width: -webkit-calc(#{$content-width} - (#{$spacing-unit}));
+        max-width:         calc(#{$content-width} - (#{$spacing-unit}));
+        padding-right: $spacing-unit / 2;
+        padding-left: $spacing-unit / 2;
+    }
+}
+
+
+
+/**
+ * Clearfix
+ */
+%clearfix {
+
+    &:after {
+        content: "";
+        display: table;
+        clear: both;
+    }
+}
+
+
+
+/**
+ * Icons
+ */
+.icon {
+
+    > svg {
+        display: inline-block;
+        width: 16px;
+        height: 16px;
+        vertical-align: middle;
+
+        path {
+            fill: $grey-color;
+        }
+    }
+}

_sass/_layout.scss

@@ -0,0 +1,266 @@
+/**
+ * Site header
+ */
+.site-header {
+    border-bottom: 5px solid #1B73BA;
+    min-height: 64px;
+
+    // Positioning context for the mobile navigation icon
+    position: relative;
+}
+
+.site-title {
+    font-size: 36px;
+    line-height: 64px;
+    letter-spacing: -1px;
+    margin-bottom: 0;
+    float: left;
+
+    &,
+    &:visited {
+        color: white;
+        /*font-family: Verdana;*/
+    }
+}
+
+.site-nav {
+    float: right;
+    line-height: 64px;
+
+    .menu-icon {
+        display: none;
+    }
+
+    .page-link {
+        color: white;
+        line-height: $base-line-height;
+        font-size: 24px;
+
+        // Gaps between nav items, but not on the first one
+        &:not(:first-child) {
+            margin-left: 20px;
+        }
+
+        vertical-align: middle;
+    }
+
+    @include media-query($on-palm) {
+        position: absolute;
+        top: 14px;
+        right: 30px;
+        background-color: white;
+        border: 1px solid $grey-color-light;
+        border-radius: 5px;
+        text-align: right;
+
+        .menu-icon {
+            display: block;
+            float: right;
+            width: 36px;
+            height: 26px;
+            line-height: 0;
+            padding-top: 10px;
+            text-align: center;
+
+            > svg {
+                width: 18px;
+                height: 15px;
+
+                path {
+                    fill: $grey-color-dark;
+                }
+            }
+        }
+
+        .trigger {
+            clear: both;
+            display: none;
+        }
+
+        .page-link {
+            padding: 5px 10px;
+            vertical-align: middle;
+            color: #2388DB;
+            display: block;
+        }
+    }
+}
+
+
+
+/**
+ * Site footer
+ */
+.site-footer {
+    border-top: 5px solid #1B73BA;
+    background-color: #2388DB;
+    position: absolute;
+    bottom: 0;
+    width: 100%;
+}
+
+.footer-heading {
+    font-size: 18px;
+    margin-bottom: $spacing-unit / 2;
+}
+
+.footer-copy {
+    font-size: 14px;
+    text-align: center;
+    color: white;
+    a {
+        color: white;
+    }
+}
+
+.contact-list,
+.social-media-list {
+    list-style: none;
+    margin-left: 0;
+}
+
+.footer-col-wrapper {
+    font-size: 15px;
+    color: $grey-color;
+    margin-left: -$spacing-unit / 2;
+    @extend %clearfix;
+}
+
+.footer-col {
+    float: left;
+    margin-bottom: $spacing-unit / 2;
+    padding-left: $spacing-unit / 2;
+}
+
+.footer-col-1 {
+    width: -webkit-calc(35% - (#{$spacing-unit} / 2));
+    width:         calc(35% - (#{$spacing-unit} / 2));
+}
+
+.footer-col-2 {
+    width: -webkit-calc(20% - (#{$spacing-unit} / 2));
+    width:         calc(20% - (#{$spacing-unit} / 2));
+}
+
+.footer-col-3 {
+    width: -webkit-calc(45% - (#{$spacing-unit} / 2));
+    width:         calc(45% - (#{$spacing-unit} / 2));
+}
+
+@include media-query($on-laptop) {
+    .footer-col-1,
+    .footer-col-2 {
+        width: -webkit-calc(50% - (#{$spacing-unit} / 2));
+        width:         calc(50% - (#{$spacing-unit} / 2));
+    }
+
+    .footer-col-3 {
+        width: -webkit-calc(100% - (#{$spacing-unit} / 2));
+        width:         calc(100% - (#{$spacing-unit} / 2));
+    }
+}
+
+@include media-query($on-palm) {
+    .footer-col {
+        float: none;
+        width: -webkit-calc(100% - (#{$spacing-unit} / 2));
+        width:         calc(100% - (#{$spacing-unit} / 2));
+    }
+}
+
+
+
+/**
+ * Page content
+ */
+.page-content {
+    padding: $spacing-unit 0;
+}
+
+.page-heading {
+    font-size: 20px;
+}
+
+.post-list {
+    margin-left: 0;
+    list-style: none;
+
+    > li {
+        margin-bottom: $spacing-unit;
+    }
+}
+
+.post-meta {
+    font-size: $small-font-size;
+    color: $grey-color;
+}
+
+.post-link {
+    display: block;
+    font-size: 24px;
+}
+
+
+
+/**
+ * Posts
+ */
+/*.post-header {
+    margin-bottom: $spacing-unit;
+}
+
+.post-title {
+    font-size: 32px;
+    letter-spacing: -1px;
+    line-height: 1;
+    margin-top: 10px;
+    margin-bottom: 10px;
+
+    @include media-query($on-laptop) {
+        font-size: 28px;
+    }
+}*/
+
+.post-content {
+    margin-bottom: $spacing-unit;
+
+    h1 {
+        font-size: 30px;
+        color: #2388DB;
+        margin-top: 10px;
+        margin-bottom: 5px;
+
+        @include media-query($on-laptop) {
+            font-size: 32px;
+        }
+    }
+
+    h2 {
+        font-size: 22px;
+        color: #2388DB;
+        margin-top: 10px;
+        margin-bottom: 5px;
+
+        @include media-query($on-laptop) {
+            font-size: 26px;
+        }
+    }
+
+    h3 {
+        font-size: 18px;
+        color: #2388DB;
+
+        @include media-query($on-laptop) {
+            font-size: 20px;
+        }
+    }
+
+    h4 {
+        font-size: 16px;
+        color: #2388DB;
+
+        @include media-query($on-laptop) {
+            font-size: 18px;
+        }
+    }
+}

_sass/_syntax-highlighting.scss

@@ -0,0 +1,67 @@
+/**
+ * Syntax highlighting styles
+ */
+.highlight {
+    background: #fff;
+    @extend %vertical-rhythm;
+
+    .c     { color: #998; font-style: italic } // Comment
+    .err   { color: #a61717; background-color: #e3d2d2 } // Error
+    .k     { font-weight: bold } // Keyword
+    .o     { font-weight: bold } // Operator
+    .cm    { color: #998; font-style: italic } // Comment.Multiline
+    .cp    { color: #999; font-weight: bold } // Comment.Preproc
+    .c1    { color: #998; font-style: italic } // Comment.Single
+    .cs    { color: #999; font-weight: bold; font-style: italic } // Comment.Special
+    .gd    { color: #000; background-color: #fdd } // Generic.Deleted
+    .gd .x { color: #000; background-color: #faa } // Generic.Deleted.Specific
+    .ge    { font-style: italic } // Generic.Emph
+    .gr    { color: #a00 } // Generic.Error
+    .gh    { color: #999 } // Generic.Heading
+    .gi    { color: #000; background-color: #dfd } // Generic.Inserted
+    .gi .x { color: #000; background-color: #afa } // Generic.Inserted.Specific
+    .go    { color: #888 } // Generic.Output
+    .gp    { color: #555 } // Generic.Prompt
+    .gs    { font-weight: bold } // Generic.Strong
+    .gu    { color: #aaa } // Generic.Subheading
+    .gt    { color: #a00 } // Generic.Traceback
+    .kc    { font-weight: bold } // Keyword.Constant
+    .kd    { font-weight: bold } // Keyword.Declaration
+    .kp    { font-weight: bold } // Keyword.Pseudo
+    .kr    { font-weight: bold } // Keyword.Reserved
+    .kt    { color: #458; font-weight: bold } // Keyword.Type
+    .m     { color: #099 } // Literal.Number
+    .s     { color: #d14 } // Literal.String
+    .na    { color: #008080 } // Name.Attribute
+    .nb    { color: #0086B3 } // Name.Builtin
+    .nc    { color: #458; font-weight: bold } // Name.Class
+    .no    { color: #008080 } // Name.Constant
+    .ni    { color: #800080 } // Name.Entity
+    .ne    { color: #900; font-weight: bold } // Name.Exception
+    .nf    { color: #900; font-weight: bold } // Name.Function
+    .nn    { color: #555 } // Name.Namespace
+    .nt    { color: #000080 } // Name.Tag
+    .nv    { color: #008080 } // Name.Variable
+    .ow    { font-weight: bold } // Operator.Word
+    .w     { color: #bbb } // Text.Whitespace
+    .mf    { color: #099 } // Literal.Number.Float
+    .mh    { color: #099 } // Literal.Number.Hex
+    .mi    { color: #099 } // Literal.Number.Integer
+    .mo    { color: #099 } // Literal.Number.Oct
+    .sb    { color: #d14 } // Literal.String.Backtick
+    .sc    { color: #d14 } // Literal.String.Char
+    .sd    { color: #d14 } // Literal.String.Doc
+    .s2    { color: #d14 } // Literal.String.Double
+    .se    { color: #d14 } // Literal.String.Escape
+    .sh    { color: #d14 } // Literal.String.Heredoc
+    .si    { color: #d14 } // Literal.String.Interpol
+    .sx    { color: #d14 } // Literal.String.Other
+    .sr    { color: #009926 } // Literal.String.Regex
+    .s1    { color: #d14 } // Literal.String.Single
+    .ss    { color: #990073 } // Literal.String.Symbol
+    .bp    { color: #999 } // Name.Builtin.Pseudo
+    .vc    { color: #008080 } // Name.Variable.Class
+    .vg    { color: #008080 } // Name.Variable.Global
+    .vi    { color: #008080 } // Name.Variable.Instance
+    .il    { color: #099 } // Literal.Number.Integer.Long
+}

benchmark/benchmark.css

@@ -0,0 +1,6 @@
+.graph-container {
+ width: 800px;
+ height: 400px;
+ display: inline-block;
+}
+

benchmark/benchmark.html

@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+  <title>jerryscript benchmark</title>
+  
+  <!--link rel="stylesheet" type="text/css" src="benchmark.css"-->
+  <link rel="stylesheet" type="text/css" href="benchmark.css">
+  <script type="text/javascript" src="https://www.google.com/jsapi"></script>
+  <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.4/jquery.min.js"></script>
+  <script type='text/javascript' src="common.js"></script>
+  <script type='text/javascript' src="benchmark.js"></script>
+</head>
+
+<body>
+
+<h1>Jerryscript Benchmark</h1>
+<p>
+  Show data
+  <a href="?show=sum">by_sum</a> /
+  <a href="?show=max">by max</a>
+  value of subtests
+</p>
+
+<div class="container">
+
+<div id="wrapper_sunspider-1.0.2" class="content">
+<h3>sunspider-1.0.2</h3>
+<div id="chart_sunspider-1.0.2_memory" class="graph-container">loading...</div>
+<div id="chart_sunspider-1.0.2_performance" class="graph-container">loading...</div>
+</div>
+
+<div id="wrapper_ubench">
+<h3>ubench</h3>
+<div id="chart_ubench_memory" class="graph-container">loading...</div>
+<div id="chart_ubench_performance" class="graph-container">loading...</div>
+</div>
+
+</div><!-- container -->
+
+<p>
+  <span style="font-weight: bold; color: blue;">lower is better</span>
+  for both memory and performance.
+</p>
+
+</body>
+
+</html>
+

benchmark/benchmark.js

@@ -0,0 +1,237 @@
+///////////////////////////////////////////
+// helper functions
+///////////////////////////////////////////
+
+Array.prototype.clone = function() {
+  return this.slice(0);
+};
+
+Array.prototype.sum = function() {
+  return this.reduce(function(a, b) { return a + b; });
+};
+
+Array.prototype.max = function() {
+  return this.reduce(function(a, b) { return Math.max(a, b); });
+};
+
+Date.prototype.toFormattedString = function() {
+  var yyyy = this.getFullYear().toString();
+  var mm = (this.getMonth() + 1).toString();
+  var dd = this.getDate().toString();
+  mm = mm[1] ? mm : '0' + mm;
+  dd = dd[1] ? dd : '0' + dd;
+  return yyyy + '-' + mm + '-' + dd;
+};
+
+Object.values = function(obj) {
+  return Object.keys(obj).map(function(key) { return obj[key]; });
+};
+
+Object.sum = function(obj) {
+  return Object.values(obj).sum();
+};
+
+Object.maxKey = function(obj) {
+  var key, val = -Infinity;
+  for (var p in obj) {
+    if (val < obj[p]) {
+      key = p;
+      val = obj[p];
+    }
+  }
+  return key;
+};
+
+function wrapTooltip(content) {
+  return '<div style="padding: 0.5em; font-family: consolas; line-height: 1.5em;">' + content + '</div>';
+}
+
+function wrapHyperlink(address, text) {
+  return '<a href="' + address + '" target="_blank">' + text + '</a>'
+}
+
+///////////////////////////////////////////
+// main module
+///////////////////////////////////////////
+
+var isSum = true;
+
+var benchmarks = ['sunspider-1.0.2', 'ubench'];
+var measureTypes = ['memory', 'performance'];
+var measureUnits = {'memory': 'kb', 'performance': 's'};
+var engines = ['jerryscript', 'jerryscript-snapshot', 'jerryscript_cbc', 'duktape'];
+var link_main = {
+  'jerryscript':     'http://www.jerryscript.net',
+  'jerryscript_cbc': 'http://www.jerryscript.net',
+  'duktape':         'http://duktape.org'
+};
+var link_code = {
+  'jerryscript':     'https://github.com/Samsung/jerryscript/commit/',
+  'jerryscript_cbc': 'https://github.com/Samsung/jerryscript/commit/',
+  'duktape':         'https://github.com/svaarala/duktape/commit/'
+};
+var beginDate = new Date('2015-07-11');
+
+var benchmarkData = {};
+
+google.load('visualization', '1', {packages: ['corechart', 'line']});
+google.setOnLoadCallback(main);
+
+function main() {
+  // get params
+  var data_src = getParameterByName('src') || 'data';
+  var show = getParameterByName('show') || 'sum';
+
+  isSum = show === 'sum';
+
+  // fetch data via ajax
+  var today = new Date();
+  for (var d = beginDate; d <= today; d.setDate(d.getDate() + 1)) {
+    var curDate = (new Date(d)).toFormattedString();
+    $.ajax({
+      _date: curDate,
+      url: data_src + '/' + curDate + '.json',
+      dataType: 'json',
+      success: function(data) {
+        benchmarkData[this._date] = data;
+      },
+      error: function(request, status, error) {
+      }
+    });
+  }
+}
+
+$(document).ajaxStop(function () {
+  benchmarks.forEach(function(benchmark) {
+  measureTypes.forEach(function(measureType) {
+    // transform data for internal use
+    var transData = {}, transInfo = {};
+    $.each(benchmarkData, function(date, element) {
+      transData[date] = [];
+      transInfo[date] = element['info'];
+      engines.forEach(function(engine, index) {
+        var sum = undefined;   // default value
+        var max = undefined;   // default value
+        var maxTest = '';      // default value
+        var numTests = 0;
+        var benchmark_obj = element[benchmark];
+        if (benchmark_obj) {
+          var record =  benchmark_obj[measureType][engine];
+          if (record && Object.keys(record).length > 0) {
+            sum = Object.sum(record);
+            maxTest = Object.maxKey(record);
+            max = record[maxTest];
+            numTests = Object.values(record).length;
+          }
+        }
+        transData[date][index] = {
+          tests: numTests,
+          sum: sum,
+          max: max,
+          maxTest: maxTest,
+          score: isSum ? sum : max
+        };
+      });
+    });
+
+    // transform data for google charts
+    var data = new google.visualization.DataTable();
+    data.addColumn('date', 'Date');
+    engines.forEach(function(engine) {
+      data.addColumn('number', engine);
+      data.addColumn({type: 'string', role: 'tooltip', 'p': {'html': true}});
+    });
+    var arrayData = Object.keys(transData).sort().map(function(date) {
+      // data
+      var row = Object.values(transData[date]);
+      // tooltip
+      var tooltips = row.clone().map(function(value, index) {
+        var engine = engines[index];
+        var engine_pure = engine.split('-')[0];
+        var info = transInfo[date] ? transInfo[date][engine_pure] : undefined;
+        var score = value.score ? value.score.toFixed(2) + measureUnits[measureType] : '';
+        var tests = value.tests || 0;
+        var max_test = value.maxTest || '';
+
+        var info_text = '';
+        if (info && info.version)
+          info_text = wrapHyperlink(link_code[engine_pure] + info.version, info.version);
+        var engine_text = wrapHyperlink(link_main[engine_pure], engine);
+        var score_text = score;
+        if (isSum) {
+          score_text += ' (' + tests + ' subtests)';
+        }
+        else {
+          score_text += ' (' + max_test + ')';
+        }
+        score_text += ' ' + wrapHyperlink('details.html?' + $.param({date: date, engine: engine, benchmark:benchmark}), 'details');
+
+        var textData = [
+            ['source&nbsp; ', engine_text],
+            ['version ', info_text],
+            ['date&nbsp;&nbsp;&nbsp; ', date],
+            ['score&nbsp;&nbsp; ', score_text]];
+
+        return wrapTooltip(textData.map(function(v) { return v.join(': '); }).join('<br />'));
+      });
+
+      // zip data and tooltips
+      // so the array will be like [data, tooltip, data, tooltip, ...]
+      row = row.map(function (v, i) {
+        return [v.score, tooltips[i]];
+      }).reduce(function(a, b) {
+        return a.concat(b)
+      });
+      return [new Date(date)].concat(row);
+    });
+    data.addRows(arrayData);
+
+    // chart options
+    var options = {
+      title: measureType,
+      titleTextStyle: {
+        fontSize: 20,
+        bold: true
+      },
+      legend: { position: 'bottom', alignment: 'vertical' },
+      backgroundColor: '#f8f8f8',
+      hAxis: {
+        title: 'Date',
+        textStyle: {
+          fontSize: 12,
+          bold: false
+        },
+        titleTextStyle: {
+          fontSize: 16,
+          bold: true
+        },
+        format: 'yyyy-MM-dd'
+      },
+      vAxis: {
+        minValue: 0,
+        title: measureType + ' (' + measureUnits[measureType] + ')',
+        textStyle: {
+          fontSize: 12,
+          bold: false
+        },
+        titleTextStyle: {
+          fontSize: 16,
+          bold: true
+        }
+      },
+      tooltip: {
+        isHtml: true,
+        trigger: 'both'
+      }
+    };
+
+    // draw chart
+    var divObj = document.getElementById(
+        ['chart', benchmark, measureType].join('_'));
+    if (divObj) {
+      var chart = new google.visualization.LineChart(divObj);
+      chart.draw(data, options);
+    }
+  });
+  });
+});

benchmark/common.js

@@ -0,0 +1,7 @@
+function getParameterByName(name) {
+  name = name.replace(/[\[]/, "\\[").replace(/[\]]/, "\\]");
+  var regex = new RegExp("[\\?&]" + name + "=([^&#]*)"),
+      results = regex.exec(location.search);
+  return results === null ? "" : decodeURIComponent(results[1].replace(/\+/g, " "));
+}
+

benchmark/data/2015-07-11.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "9c559216b7b72cf5073cc4dea644ae332d3c140b",
+            "size": 173764
+        },
+        "duktape": {
+            "version": "cd2c19761b07e8d675f2079328fbfc9dd9c3b83a",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.55867,
+                "3d-cube.js": 6.03467,
+                "access-fannkuch.js": 15.6373,
+                "access-nbody.js": 7.07733,
+                "bitops-bitwise-and.js": 5.27733,
+                "math-partial-sums.js": 3.052,
+                "controlflow-recursive.js": 4.31333,
+                "bitops-bits-in-byte.js": 7.08667,
+                "access-binary-trees.js": 3.68267,
+                "bitops-3bit-bits-in-byte.js": 5.06267,
+                "string-fasta.js": 36.3067,
+                "math-cordic.js": 8.172
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.048,
+                "3d-cube.js": 1.17333,
+                "access-fannkuch.js": 1.988,
+                "access-nbody.js": 1.74667,
+                "bitops-bitwise-and.js": 7.30267,
+                "math-partial-sums.js": 2.80933,
+                "controlflow-recursive.js": 1.24933,
+                "bitops-bits-in-byte.js": 0.934667,
+                "access-binary-trees.js": 1.292,
+                "bitops-3bit-bits-in-byte.js": 0.593333,
+                "string-fasta.js": 4.72533,
+                "math-cordic.js": 2.544
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 160,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 84,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.3133,
+                "function-empty.js": 31.348,
+                "function-excess-args.js": 61.9253,
+                "function-closure.js": 5.09867,
+                "function-missing-args.js": 64.3867,
+                "loop-sum.js": 50.6907,
+                "loop-empty-resolve.js": 5.14533,
+                "function-correct-args.js": 86.9693,
+                "function-sum.js": 47.9907
+            },
+            "duktape": {
+                "loop-empty.js": 56.012,
+                "function-empty.js": 40.1773,
+                "function-excess-args.js": 32.252,
+                "function-closure.js": 19.872,
+                "function-missing-args.js": 31.0453,
+                "loop-sum.js": 73.62,
+                "loop-empty-resolve.js": 6.752,
+                "function-correct-args.js": 32.336,
+                "function-sum.js": 26.736
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-12.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "9c559216b7b72cf5073cc4dea644ae332d3c140b",
+            "size": 173764
+        },
+        "duktape": {
+            "version": "cd2c19761b07e8d675f2079328fbfc9dd9c3b83a",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.55467,
+                "3d-cube.js": 6.02533,
+                "access-fannkuch.js": 15.612,
+                "access-nbody.js": 7.05467,
+                "bitops-bitwise-and.js": 5.276,
+                "math-partial-sums.js": 3.05467,
+                "controlflow-recursive.js": 4.33333,
+                "bitops-bits-in-byte.js": 7.08267,
+                "access-binary-trees.js": 3.676,
+                "bitops-3bit-bits-in-byte.js": 5.05467,
+                "string-fasta.js": 36.324,
+                "math-cordic.js": 8.176
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.052,
+                "3d-cube.js": 1.17733,
+                "access-fannkuch.js": 1.98533,
+                "access-nbody.js": 1.74533,
+                "bitops-bitwise-and.js": 7.31867,
+                "math-partial-sums.js": 2.80933,
+                "controlflow-recursive.js": 1.248,
+                "bitops-bits-in-byte.js": 0.936,
+                "access-binary-trees.js": 1.29867,
+                "bitops-3bit-bits-in-byte.js": 0.592,
+                "string-fasta.js": 4.73067,
+                "math-cordic.js": 2.53867
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 160,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 84,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.3093,
+                "function-empty.js": 31.2987,
+                "function-excess-args.js": 61.9293,
+                "function-closure.js": 5.09467,
+                "function-missing-args.js": 64.3147,
+                "loop-sum.js": 50.704,
+                "loop-empty-resolve.js": 5.14533,
+                "function-correct-args.js": 86.956,
+                "function-sum.js": 48.032
+            },
+            "duktape": {
+                "loop-empty.js": 56.0093,
+                "function-empty.js": 40.1587,
+                "function-excess-args.js": 32.276,
+                "function-closure.js": 19.924,
+                "function-missing-args.js": 31.044,
+                "loop-sum.js": 73.604,
+                "loop-empty-resolve.js": 6.748,
+                "function-correct-args.js": 32.4333,
+                "function-sum.js": 26.86
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-13.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "13cf31413f6a3a1683c62ac4ed3f19d98d9b2cd2",
+            "size": 173764
+        },
+        "duktape": {
+            "version": "cd2c19761b07e8d675f2079328fbfc9dd9c3b83a",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.55467,
+                "3d-cube.js": 6.03333,
+                "access-fannkuch.js": 15.6333,
+                "access-nbody.js": 7.07867,
+                "bitops-bitwise-and.js": 5.27733,
+                "math-partial-sums.js": 3.05333,
+                "controlflow-recursive.js": 4.34267,
+                "bitops-bits-in-byte.js": 7.09733,
+                "access-binary-trees.js": 3.68267,
+                "bitops-3bit-bits-in-byte.js": 5.04533,
+                "string-fasta.js": 36.2973,
+                "math-cordic.js": 8.18133
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.04933,
+                "3d-cube.js": 1.176,
+                "access-fannkuch.js": 1.98267,
+                "access-nbody.js": 1.74933,
+                "bitops-bitwise-and.js": 7.272,
+                "math-partial-sums.js": 2.812,
+                "controlflow-recursive.js": 1.248,
+                "bitops-bits-in-byte.js": 0.934667,
+                "access-binary-trees.js": 1.30133,
+                "bitops-3bit-bits-in-byte.js": 0.590667,
+                "string-fasta.js": 4.72133,
+                "math-cordic.js": 2.544
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 160,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 84,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.3107,
+                "function-empty.js": 31.348,
+                "function-excess-args.js": 61.94,
+                "function-closure.js": 5.09467,
+                "function-missing-args.js": 64.3307,
+                "loop-sum.js": 50.6613,
+                "loop-empty-resolve.js": 5.14,
+                "function-correct-args.js": 86.944,
+                "function-sum.js": 47.968
+            },
+            "duktape": {
+                "loop-empty.js": 56.0307,
+                "function-empty.js": 40.1453,
+                "function-excess-args.js": 32.2893,
+                "function-closure.js": 19.9533,
+                "function-missing-args.js": 31.0787,
+                "loop-sum.js": 73.6507,
+                "loop-empty-resolve.js": 6.74133,
+                "function-correct-args.js": 32.324,
+                "function-sum.js": 26.808
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-14.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "bc0ca7be5d1081e8a1115b870237f8d3f19b32d9",
+            "size": 173768
+        },
+        "duktape": {
+            "version": "cd2c19761b07e8d675f2079328fbfc9dd9c3b83a",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.60933,
+                "3d-cube.js": 5.968,
+                "access-fannkuch.js": 15.7533,
+                "access-nbody.js": 7.09867,
+                "bitops-bitwise-and.js": 5.572,
+                "math-partial-sums.js": 3.12667,
+                "controlflow-recursive.js": 4.45333,
+                "bitops-bits-in-byte.js": 7.13067,
+                "access-binary-trees.js": 3.73733,
+                "bitops-3bit-bits-in-byte.js": 5.11333,
+                "string-fasta.js": 36.2867,
+                "math-cordic.js": 8.26933
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.05067,
+                "3d-cube.js": 1.17867,
+                "access-fannkuch.js": 1.984,
+                "access-nbody.js": 1.748,
+                "bitops-bitwise-and.js": 7.3,
+                "math-partial-sums.js": 2.812,
+                "controlflow-recursive.js": 1.248,
+                "bitops-bits-in-byte.js": 0.937333,
+                "access-binary-trees.js": 1.296,
+                "bitops-3bit-bits-in-byte.js": 0.590667,
+                "string-fasta.js": 4.74133,
+                "math-cordic.js": 2.54533
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 232,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 84,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 46.3,
+                "function-empty.js": 34.4373,
+                "function-excess-args.js": 64.692,
+                "function-closure.js": 5.40933,
+                "function-missing-args.js": 67.6853,
+                "loop-sum.js": 51.9187,
+                "loop-empty-resolve.js": 5.256,
+                "function-correct-args.js": 90.2733,
+                "function-sum.js": 49.968
+            },
+            "duktape": {
+                "loop-empty.js": 56.0267,
+                "function-empty.js": 40.184,
+                "function-excess-args.js": 32.332,
+                "function-closure.js": 19.8213,
+                "function-missing-args.js": 31.0187,
+                "loop-sum.js": 73.6293,
+                "loop-empty-resolve.js": 6.752,
+                "function-correct-args.js": 32.332,
+                "function-sum.js": 26.8
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-15.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "7ccec19c268352314d1e48365d17f65e3dd6287f",
+            "size": 173768
+        },
+        "duktape": {
+            "version": "cd2c19761b07e8d675f2079328fbfc9dd9c3b83a",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.688,
+                "3d-cube.js": 6.64267,
+                "access-fannkuch.js": 16.1907,
+                "access-nbody.js": 7.11467,
+                "bitops-bitwise-and.js": 5.28533,
+                "math-partial-sums.js": 3.376,
+                "controlflow-recursive.js": 4.44267,
+                "bitops-bits-in-byte.js": 7.784,
+                "access-binary-trees.js": 3.35333,
+                "bitops-3bit-bits-in-byte.js": 5.348,
+                "string-fasta.js": 36.2507,
+                "math-cordic.js": 8.64933
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.052,
+                "3d-cube.js": 1.176,
+                "access-fannkuch.js": 1.988,
+                "access-nbody.js": 1.74267,
+                "bitops-bitwise-and.js": 7.29067,
+                "math-partial-sums.js": 2.812,
+                "controlflow-recursive.js": 1.24667,
+                "bitops-bits-in-byte.js": 0.933333,
+                "access-binary-trees.js": 1.3,
+                "bitops-3bit-bits-in-byte.js": 0.592,
+                "string-fasta.js": 4.736,
+                "math-cordic.js": 2.536
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.1187,
+                "function-empty.js": 32.1413,
+                "function-excess-args.js": 62.8133,
+                "function-closure.js": 5.26133,
+                "function-missing-args.js": 65.0187,
+                "loop-sum.js": 50.4533,
+                "loop-empty-resolve.js": 5.12267,
+                "function-correct-args.js": 87.9467,
+                "function-sum.js": 48.66
+            },
+            "duktape": {
+                "loop-empty.js": 55.9547,
+                "function-empty.js": 40.1253,
+                "function-excess-args.js": 32.284,
+                "function-closure.js": 19.904,
+                "function-missing-args.js": 30.9787,
+                "loop-sum.js": 73.6333,
+                "loop-empty-resolve.js": 6.76133,
+                "function-correct-args.js": 32.2893,
+                "function-sum.js": 26.732
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-16.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "351df6184c62b74f1246e9400fb5180d94882baf",
+            "size": 181960
+        },
+        "duktape": {
+            "version": "cd2c19761b07e8d675f2079328fbfc9dd9c3b83a",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.76133,
+                "3d-cube.js": 6.68267,
+                "access-fannkuch.js": 16.3613,
+                "access-nbody.js": 7.14133,
+                "bitops-bitwise-and.js": 5.38267,
+                "math-partial-sums.js": 3.38933,
+                "controlflow-recursive.js": 4.48,
+                "bitops-bits-in-byte.js": 7.872,
+                "access-binary-trees.js": 3.35467,
+                "bitops-3bit-bits-in-byte.js": 5.39733,
+                "string-fasta.js": 36.2213,
+                "math-cordic.js": 8.69733
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.05467,
+                "3d-cube.js": 1.176,
+                "access-fannkuch.js": 1.984,
+                "access-nbody.js": 1.74267,
+                "bitops-bitwise-and.js": 7.31067,
+                "math-partial-sums.js": 2.812,
+                "controlflow-recursive.js": 1.24667,
+                "bitops-bits-in-byte.js": 0.936,
+                "access-binary-trees.js": 1.296,
+                "bitops-3bit-bits-in-byte.js": 0.592,
+                "string-fasta.js": 4.724,
+                "math-cordic.js": 2.54133
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.9093,
+                "function-empty.js": 32.7053,
+                "function-excess-args.js": 63.4707,
+                "function-closure.js": 5.25467,
+                "function-missing-args.js": 65.5867,
+                "loop-sum.js": 50.8587,
+                "loop-empty-resolve.js": 5.12933,
+                "function-correct-args.js": 88.4387,
+                "function-sum.js": 49.2533
+            },
+            "duktape": {
+                "loop-empty.js": 55.9947,
+                "function-empty.js": 40.1507,
+                "function-excess-args.js": 32.3307,
+                "function-closure.js": 19.8693,
+                "function-missing-args.js": 31.0453,
+                "loop-sum.js": 73.56,
+                "loop-empty-resolve.js": 6.75067,
+                "function-correct-args.js": 32.3373,
+                "function-sum.js": 26.8133
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-17.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "6038173e76265ab30ae7b5b70a4d20633e1de9b7",
+            "size": 181960
+        },
+        "duktape": {
+            "version": "cd2c19761b07e8d675f2079328fbfc9dd9c3b83a",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.76133,
+                "3d-cube.js": 6.68667,
+                "access-fannkuch.js": 16.3267,
+                "access-nbody.js": 7.148,
+                "bitops-bitwise-and.js": 5.37733,
+                "math-partial-sums.js": 3.39067,
+                "controlflow-recursive.js": 4.47467,
+                "bitops-bits-in-byte.js": 7.864,
+                "access-binary-trees.js": 3.35867,
+                "bitops-3bit-bits-in-byte.js": 5.39733,
+                "string-fasta.js": 36.228,
+                "math-cordic.js": 8.69333
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.036,
+                "3d-cube.js": 1.17333,
+                "access-fannkuch.js": 1.98133,
+                "access-nbody.js": 1.744,
+                "bitops-bitwise-and.js": 7.31467,
+                "math-partial-sums.js": 2.81067,
+                "controlflow-recursive.js": 1.25067,
+                "bitops-bits-in-byte.js": 0.932,
+                "access-binary-trees.js": 1.29733,
+                "bitops-3bit-bits-in-byte.js": 0.590667,
+                "string-fasta.js": 4.73333,
+                "math-cordic.js": 2.54267
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.9267,
+                "function-empty.js": 32.6907,
+                "function-excess-args.js": 63.228,
+                "function-closure.js": 5.24933,
+                "function-missing-args.js": 65.5267,
+                "loop-sum.js": 50.884,
+                "loop-empty-resolve.js": 5.15067,
+                "function-correct-args.js": 88.4173,
+                "function-sum.js": 49.3293
+            },
+            "duktape": {
+                "loop-empty.js": 56.0027,
+                "function-empty.js": 40.2107,
+                "function-excess-args.js": 32.3027,
+                "function-closure.js": 19.8653,
+                "function-missing-args.js": 31.0053,
+                "loop-sum.js": 73.58,
+                "loop-empty-resolve.js": 6.75467,
+                "function-correct-args.js": 32.3627,
+                "function-sum.js": 26.7067
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-18.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "bbfddea032fc622cef6279b308f5d77e135dd19b",
+            "size": 181960
+        },
+        "duktape": {
+            "version": "cd2c19761b07e8d675f2079328fbfc9dd9c3b83a",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.788,
+                "3d-cube.js": 6.72267,
+                "access-fannkuch.js": 16.44,
+                "access-nbody.js": 7.212,
+                "bitops-bitwise-and.js": 5.38533,
+                "math-partial-sums.js": 3.40267,
+                "controlflow-recursive.js": 4.492,
+                "bitops-bits-in-byte.js": 7.92133,
+                "access-binary-trees.js": 3.384,
+                "bitops-3bit-bits-in-byte.js": 5.41867,
+                "string-fasta.js": 36.2507,
+                "math-cordic.js": 8.73733
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.052,
+                "3d-cube.js": 1.17867,
+                "access-fannkuch.js": 1.98533,
+                "access-nbody.js": 1.744,
+                "bitops-bitwise-and.js": 7.312,
+                "math-partial-sums.js": 2.808,
+                "controlflow-recursive.js": 1.248,
+                "bitops-bits-in-byte.js": 0.936,
+                "access-binary-trees.js": 1.30133,
+                "bitops-3bit-bits-in-byte.js": 0.590667,
+                "string-fasta.js": 4.732,
+                "math-cordic.js": 2.53867
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.7227,
+                "function-empty.js": 32.936,
+                "function-excess-args.js": 63.6613,
+                "function-closure.js": 5.272,
+                "function-missing-args.js": 65.7773,
+                "loop-sum.js": 51.1173,
+                "loop-empty-resolve.js": 5.20533,
+                "function-correct-args.js": 88.6173,
+                "function-sum.js": 49.4933
+            },
+            "duktape": {
+                "loop-empty.js": 55.9933,
+                "function-empty.js": 40.156,
+                "function-excess-args.js": 32.304,
+                "function-closure.js": 19.9813,
+                "function-missing-args.js": 31.028,
+                "loop-sum.js": 73.5627,
+                "loop-empty-resolve.js": 6.744,
+                "function-correct-args.js": 32.3827,
+                "function-sum.js": 26.8253
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-19.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "bbfddea032fc622cef6279b308f5d77e135dd19b",
+            "size": 181960
+        },
+        "duktape": {
+            "version": "cd2c19761b07e8d675f2079328fbfc9dd9c3b83a",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.788,
+                "3d-cube.js": 6.69867,
+                "access-fannkuch.js": 16.4787,
+                "access-nbody.js": 7.20533,
+                "bitops-bitwise-and.js": 5.38267,
+                "math-partial-sums.js": 3.40267,
+                "controlflow-recursive.js": 4.472,
+                "bitops-bits-in-byte.js": 7.90933,
+                "access-binary-trees.js": 3.37067,
+                "bitops-3bit-bits-in-byte.js": 5.428,
+                "string-fasta.js": 36.272,
+                "math-cordic.js": 8.74133
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.05467,
+                "3d-cube.js": 1.17733,
+                "access-fannkuch.js": 1.98133,
+                "access-nbody.js": 1.74667,
+                "bitops-bitwise-and.js": 7.30133,
+                "math-partial-sums.js": 2.82267,
+                "controlflow-recursive.js": 1.248,
+                "bitops-bits-in-byte.js": 0.934667,
+                "access-binary-trees.js": 1.30133,
+                "bitops-3bit-bits-in-byte.js": 0.592,
+                "string-fasta.js": 4.71733,
+                "math-cordic.js": 2.544
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.7107,
+                "function-empty.js": 32.9267,
+                "function-excess-args.js": 63.78,
+                "function-closure.js": 5.26267,
+                "function-missing-args.js": 65.8,
+                "loop-sum.js": 51.1907,
+                "loop-empty-resolve.js": 5.22,
+                "function-correct-args.js": 88.6333,
+                "function-sum.js": 49.5533
+            },
+            "duktape": {
+                "loop-empty.js": 55.8693,
+                "function-empty.js": 40.2093,
+                "function-excess-args.js": 32.308,
+                "function-closure.js": 19.9347,
+                "function-missing-args.js": 31.012,
+                "loop-sum.js": 73.4987,
+                "loop-empty-resolve.js": 6.73467,
+                "function-correct-args.js": 32.3253,
+                "function-sum.js": 26.748
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-20.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "bbfddea032fc622cef6279b308f5d77e135dd19b",
+            "size": 181960
+        },
+        "duktape": {
+            "version": "6fed0c9a7a0c96c69918821063d26525b40f80b4",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.77867,
+                "3d-cube.js": 6.708,
+                "access-fannkuch.js": 16.472,
+                "access-nbody.js": 7.212,
+                "bitops-bitwise-and.js": 5.396,
+                "math-partial-sums.js": 3.39867,
+                "controlflow-recursive.js": 4.488,
+                "bitops-bits-in-byte.js": 7.92133,
+                "access-binary-trees.js": 3.38267,
+                "bitops-3bit-bits-in-byte.js": 5.41867,
+                "string-fasta.js": 36.264,
+                "math-cordic.js": 8.74667
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.056,
+                "3d-cube.js": 1.17867,
+                "access-fannkuch.js": 1.98,
+                "access-nbody.js": 1.74133,
+                "bitops-bitwise-and.js": 7.308,
+                "math-partial-sums.js": 2.81333,
+                "controlflow-recursive.js": 1.25067,
+                "bitops-bits-in-byte.js": 0.933333,
+                "access-binary-trees.js": 1.3,
+                "bitops-3bit-bits-in-byte.js": 0.593333,
+                "string-fasta.js": 4.73867,
+                "math-cordic.js": 2.53867
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.644,
+                "function-empty.js": 32.9213,
+                "function-excess-args.js": 63.7093,
+                "function-closure.js": 5.27467,
+                "function-missing-args.js": 65.8,
+                "loop-sum.js": 51.216,
+                "loop-empty-resolve.js": 5.22,
+                "function-correct-args.js": 88.652,
+                "function-sum.js": 49.4493
+            },
+            "duktape": {
+                "loop-empty.js": 56.04,
+                "function-empty.js": 40.184,
+                "function-excess-args.js": 32.2707,
+                "function-closure.js": 19.864,
+                "function-missing-args.js": 31.0587,
+                "loop-sum.js": 73.5787,
+                "loop-empty-resolve.js": 6.74933,
+                "function-correct-args.js": 32.4067,
+                "function-sum.js": 26.796
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-21.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "c7a47c17918e32267628218e164f5ee4e97e54d6",
+            "size": 181960
+        },
+        "duktape": {
+            "version": "6fed0c9a7a0c96c69918821063d26525b40f80b4",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.72,
+                "3d-cube.js": 6.67467,
+                "access-fannkuch.js": 16.1787,
+                "access-nbody.js": 7.136,
+                "bitops-bitwise-and.js": 5.35467,
+                "math-partial-sums.js": 3.36533,
+                "controlflow-recursive.js": 4.504,
+                "bitops-bits-in-byte.js": 7.968,
+                "access-binary-trees.js": 3.37467,
+                "bitops-3bit-bits-in-byte.js": 5.444,
+                "string-fasta.js": 36.4587,
+                "math-cordic.js": 8.66933
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.056,
+                "3d-cube.js": 1.17733,
+                "access-fannkuch.js": 1.988,
+                "access-nbody.js": 1.748,
+                "bitops-bitwise-and.js": 7.31333,
+                "math-partial-sums.js": 2.812,
+                "controlflow-recursive.js": 1.25067,
+                "bitops-bits-in-byte.js": 0.936,
+                "access-binary-trees.js": 1.30133,
+                "bitops-3bit-bits-in-byte.js": 0.590667,
+                "string-fasta.js": 4.74267,
+                "math-cordic.js": 2.54
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.1773,
+                "function-empty.js": 32.72,
+                "function-excess-args.js": 63.996,
+                "function-closure.js": 5.44933,
+                "function-missing-args.js": 66.0,
+                "loop-sum.js": 50.388,
+                "loop-empty-resolve.js": 5.16933,
+                "function-correct-args.js": 89.492,
+                "function-sum.js": 49.6773
+            },
+            "duktape": {
+                "loop-empty.js": 55.932,
+                "function-empty.js": 40.176,
+                "function-excess-args.js": 32.1893,
+                "function-closure.js": 19.8467,
+                "function-missing-args.js": 31.044,
+                "loop-sum.js": 73.6827,
+                "loop-empty-resolve.js": 6.75067,
+                "function-correct-args.js": 32.3013,
+                "function-sum.js": 26.7853
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-22.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "7c1622855da1c4757d9c76c3bcdac3e47408ed76",
+            "size": 186056
+        },
+        "duktape": {
+            "version": "8e9117160b252d93a936d1231c84388adedefb32",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.76267,
+                "3d-cube.js": 6.704,
+                "access-fannkuch.js": 16.532,
+                "access-nbody.js": 7.40533,
+                "bitops-bitwise-and.js": 5.32133,
+                "math-partial-sums.js": 3.47733,
+                "controlflow-recursive.js": 4.572,
+                "bitops-bits-in-byte.js": 7.81733,
+                "access-binary-trees.js": 3.46533,
+                "bitops-3bit-bits-in-byte.js": 5.404,
+                "string-fasta.js": 36.3987,
+                "math-cordic.js": 8.79867
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.05333,
+                "3d-cube.js": 1.17467,
+                "access-fannkuch.js": 1.98267,
+                "access-nbody.js": 1.74933,
+                "bitops-bitwise-and.js": 7.308,
+                "math-partial-sums.js": 2.812,
+                "controlflow-recursive.js": 1.25067,
+                "bitops-bits-in-byte.js": 0.933333,
+                "access-binary-trees.js": 1.3,
+                "bitops-3bit-bits-in-byte.js": 0.590667,
+                "string-fasta.js": 4.73867,
+                "math-cordic.js": 2.54133
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 46.2027,
+                "function-empty.js": 32.7427,
+                "function-excess-args.js": 65.0587,
+                "function-closure.js": 5.44533,
+                "function-missing-args.js": 67.048,
+                "loop-sum.js": 51.3,
+                "loop-empty-resolve.js": 5.16267,
+                "function-correct-args.js": 90.692,
+                "function-sum.js": 50.68
+            },
+            "duktape": {
+                "loop-empty.js": 56.0573,
+                "function-empty.js": 40.1853,
+                "function-excess-args.js": 32.288,
+                "function-closure.js": 19.956,
+                "function-missing-args.js": 31.0013,
+                "loop-sum.js": 73.5787,
+                "loop-empty-resolve.js": 6.75467,
+                "function-correct-args.js": 32.268,
+                "function-sum.js": 26.74
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-23.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "63083b3b51157b0f02d1170fc0296845f2bcf79f",
+            "size": 186056
+        },
+        "duktape": {
+            "version": "30613ee6f7248d88abde62d0492cd1ee88e3eda3",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.76667,
+                "3d-cube.js": 6.74,
+                "access-fannkuch.js": 16.3733,
+                "access-nbody.js": 7.19067,
+                "bitops-bitwise-and.js": 5.488,
+                "math-partial-sums.js": 3.416,
+                "controlflow-recursive.js": 4.53467,
+                "bitops-bits-in-byte.js": 7.988,
+                "access-binary-trees.js": 3.41067,
+                "bitops-3bit-bits-in-byte.js": 5.48267,
+                "string-fasta.js": 36.5333,
+                "math-cordic.js": 8.828
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.052,
+                "3d-cube.js": 1.176,
+                "access-fannkuch.js": 1.98,
+                "access-nbody.js": 1.74,
+                "bitops-bitwise-and.js": 7.292,
+                "math-partial-sums.js": 2.81333,
+                "controlflow-recursive.js": 1.24933,
+                "bitops-bits-in-byte.js": 0.934667,
+                "access-binary-trees.js": 1.29733,
+                "bitops-3bit-bits-in-byte.js": 0.589333,
+                "string-fasta.js": 4.73867,
+                "math-cordic.js": 2.54
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 47.124,
+                "function-empty.js": 33.7227,
+                "function-excess-args.js": 64.1573,
+                "function-closure.js": 5.46667,
+                "function-missing-args.js": 66.4093,
+                "loop-sum.js": 52.38,
+                "loop-empty-resolve.js": 5.32,
+                "function-correct-args.js": 89.7587,
+                "function-sum.js": 50.136
+            },
+            "duktape": {
+                "loop-empty.js": 56.0293,
+                "function-empty.js": 40.168,
+                "function-excess-args.js": 32.2987,
+                "function-closure.js": 19.952,
+                "function-missing-args.js": 31.0747,
+                "loop-sum.js": 73.6333,
+                "loop-empty-resolve.js": 6.75867,
+                "function-correct-args.js": 32.3653,
+                "function-sum.js": 26.792
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-24.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "11c310322b0b09e8d60c72ee5263798938a8d9e0",
+            "size": 186056
+        },
+        "duktape": {
+            "version": "5b2a3f53f020b816957129ac448efad1b701e895",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.73067,
+                "3d-cube.js": 6.70267,
+                "access-fannkuch.js": 16.3107,
+                "access-nbody.js": 7.104,
+                "bitops-bitwise-and.js": 5.34267,
+                "math-partial-sums.js": 3.36533,
+                "controlflow-recursive.js": 4.492,
+                "bitops-bits-in-byte.js": 7.97467,
+                "access-binary-trees.js": 3.392,
+                "bitops-3bit-bits-in-byte.js": 5.464,
+                "string-fasta.js": 36.4493,
+                "math-cordic.js": 8.74533
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.03467,
+                "3d-cube.js": 1.16933,
+                "access-fannkuch.js": 1.97867,
+                "access-nbody.js": 1.748,
+                "bitops-bitwise-and.js": 7.26267,
+                "math-partial-sums.js": 2.82,
+                "controlflow-recursive.js": 1.24933,
+                "bitops-bits-in-byte.js": 0.936,
+                "access-binary-trees.js": 1.29867,
+                "bitops-3bit-bits-in-byte.js": 0.589333,
+                "string-fasta.js": 4.66933,
+                "math-cordic.js": 2.54
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.8547,
+                "function-empty.js": 33.0987,
+                "function-excess-args.js": 63.9347,
+                "function-closure.js": 5.32667,
+                "function-missing-args.js": 66.0027,
+                "loop-sum.js": 50.5773,
+                "loop-empty-resolve.js": 5.224,
+                "function-correct-args.js": 88.84,
+                "function-sum.js": 49.6773
+            },
+            "duktape": {
+                "loop-empty.js": 55.7987,
+                "function-empty.js": 39.904,
+                "function-excess-args.js": 31.932,
+                "function-closure.js": 19.5653,
+                "function-missing-args.js": 30.6627,
+                "loop-sum.js": 73.58,
+                "loop-empty-resolve.js": 6.73333,
+                "function-correct-args.js": 32.0533,
+                "function-sum.js": 26.408
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-25.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "fc45b805794b335210a989a0a1d6d63598b84f91",
+            "size": 190152
+        },
+        "duktape": {
+            "version": "948d625b259e442581196842f4feba86f6ae94b9",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.74,
+                "3d-cube.js": 6.66667,
+                "access-fannkuch.js": 16.128,
+                "access-nbody.js": 7.08267,
+                "bitops-bitwise-and.js": 5.33467,
+                "math-partial-sums.js": 3.35067,
+                "controlflow-recursive.js": 4.536,
+                "bitops-bits-in-byte.js": 7.88933,
+                "access-binary-trees.js": 3.408,
+                "bitops-3bit-bits-in-byte.js": 5.41867,
+                "string-fasta.js": 36.5733,
+                "math-cordic.js": 8.70133
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.02933,
+                "3d-cube.js": 1.172,
+                "access-fannkuch.js": 1.97867,
+                "access-nbody.js": 1.752,
+                "bitops-bitwise-and.js": 7.27733,
+                "math-partial-sums.js": 2.808,
+                "controlflow-recursive.js": 1.25067,
+                "bitops-bits-in-byte.js": 0.934667,
+                "access-binary-trees.js": 1.29733,
+                "bitops-3bit-bits-in-byte.js": 0.592,
+                "string-fasta.js": 4.656,
+                "math-cordic.js": 2.54667
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.2413,
+                "function-empty.js": 32.808,
+                "function-excess-args.js": 63.4547,
+                "function-closure.js": 5.32667,
+                "function-missing-args.js": 65.5533,
+                "loop-sum.js": 50.62,
+                "loop-empty-resolve.js": 5.12133,
+                "function-correct-args.js": 89.024,
+                "function-sum.js": 49.3933
+            },
+            "duktape": {
+                "loop-empty.js": 55.8333,
+                "function-empty.js": 39.8667,
+                "function-excess-args.js": 31.936,
+                "function-closure.js": 19.6213,
+                "function-missing-args.js": 30.712,
+                "loop-sum.js": 73.6693,
+                "loop-empty-resolve.js": 6.73333,
+                "function-correct-args.js": 32.14,
+                "function-sum.js": 26.4307
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-26.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "fc45b805794b335210a989a0a1d6d63598b84f91",
+            "size": 190152
+        },
+        "duktape": {
+            "version": "6865293847bfeefd449da482a20d25c85096b4c8",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.74267,
+                "3d-cube.js": 6.66133,
+                "access-fannkuch.js": 16.0933,
+                "access-nbody.js": 7.07333,
+                "bitops-bitwise-and.js": 5.32933,
+                "math-partial-sums.js": 3.34133,
+                "controlflow-recursive.js": 4.516,
+                "bitops-bits-in-byte.js": 7.88667,
+                "access-binary-trees.js": 3.408,
+                "bitops-3bit-bits-in-byte.js": 5.40933,
+                "string-fasta.js": 36.56,
+                "math-cordic.js": 8.704
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.03467,
+                "3d-cube.js": 1.16533,
+                "access-fannkuch.js": 1.968,
+                "access-nbody.js": 1.74133,
+                "bitops-bitwise-and.js": 7.28533,
+                "math-partial-sums.js": 2.82667,
+                "controlflow-recursive.js": 1.252,
+                "bitops-bits-in-byte.js": 0.930667,
+                "access-binary-trees.js": 1.29467,
+                "bitops-3bit-bits-in-byte.js": 0.588,
+                "string-fasta.js": 4.66533,
+                "math-cordic.js": 2.512
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.28,
+                "function-empty.js": 32.8533,
+                "function-excess-args.js": 63.3933,
+                "function-closure.js": 5.31733,
+                "function-missing-args.js": 65.5333,
+                "loop-sum.js": 50.6213,
+                "loop-empty-resolve.js": 5.132,
+                "function-correct-args.js": 89.0427,
+                "function-sum.js": 49.4067
+            },
+            "duktape": {
+                "loop-empty.js": 55.756,
+                "function-empty.js": 39.8907,
+                "function-excess-args.js": 31.948,
+                "function-closure.js": 19.4587,
+                "function-missing-args.js": 30.7013,
+                "loop-sum.js": 73.6293,
+                "loop-empty-resolve.js": 6.72667,
+                "function-correct-args.js": 32.1413,
+                "function-sum.js": 26.3787
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-27.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "fc45b805794b335210a989a0a1d6d63598b84f91",
+            "size": 190152
+        },
+        "duktape": {
+            "version": "1f2368ec5b2120c1da1c8e92d57720d044950784",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.74,
+                "3d-cube.js": 6.68,
+                "access-fannkuch.js": 16.072,
+                "access-nbody.js": 7.068,
+                "bitops-bitwise-and.js": 5.33067,
+                "math-partial-sums.js": 3.352,
+                "controlflow-recursive.js": 4.54667,
+                "bitops-bits-in-byte.js": 7.87867,
+                "access-binary-trees.js": 3.41333,
+                "bitops-3bit-bits-in-byte.js": 5.40133,
+                "string-fasta.js": 36.584,
+                "math-cordic.js": 8.70533
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.03333,
+                "3d-cube.js": 1.172,
+                "access-fannkuch.js": 1.97733,
+                "access-nbody.js": 1.75067,
+                "bitops-bitwise-and.js": 7.28,
+                "math-partial-sums.js": 2.82933,
+                "controlflow-recursive.js": 1.252,
+                "bitops-bits-in-byte.js": 0.929333,
+                "access-binary-trees.js": 1.29867,
+                "bitops-3bit-bits-in-byte.js": 0.590667,
+                "string-fasta.js": 4.68933,
+                "math-cordic.js": 2.54
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.26,
+                "function-empty.js": 32.8307,
+                "function-excess-args.js": 63.544,
+                "function-closure.js": 5.308,
+                "function-missing-args.js": 65.572,
+                "loop-sum.js": 50.6853,
+                "loop-empty-resolve.js": 5.13333,
+                "function-correct-args.js": 89.0667,
+                "function-sum.js": 49.3453
+            },
+            "duktape": {
+                "loop-empty.js": 55.8827,
+                "function-empty.js": 40.3307,
+                "function-excess-args.js": 32.3413,
+                "function-closure.js": 19.5213,
+                "function-missing-args.js": 31.0227,
+                "loop-sum.js": 73.584,
+                "loop-empty-resolve.js": 6.74133,
+                "function-correct-args.js": 32.088,
+                "function-sum.js": 26.4693
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-28.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "e34ab90e61baa478191819eb18700b69717fa743",
+            "size": 190152
+        },
+        "duktape": {
+            "version": "9509fd1af58392b6c2b30ca0058f58e1b7d92040",
+            "size": 157632
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.724,
+                "3d-cube.js": 6.63333,
+                "access-fannkuch.js": 16.0973,
+                "access-nbody.js": 7.10933,
+                "bitops-bitwise-and.js": 5.24667,
+                "math-partial-sums.js": 3.37867,
+                "controlflow-recursive.js": 4.456,
+                "bitops-bits-in-byte.js": 7.84133,
+                "access-binary-trees.js": 3.39067,
+                "bitops-3bit-bits-in-byte.js": 5.40933,
+                "string-fasta.js": 36.2413,
+                "math-cordic.js": 8.64533
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.05067,
+                "3d-cube.js": 1.17467,
+                "access-fannkuch.js": 1.988,
+                "access-nbody.js": 1.77333,
+                "bitops-bitwise-and.js": 7.33733,
+                "math-partial-sums.js": 2.86533,
+                "controlflow-recursive.js": 1.25733,
+                "bitops-bits-in-byte.js": 0.934667,
+                "access-binary-trees.js": 1.304,
+                "bitops-3bit-bits-in-byte.js": 0.596,
+                "string-fasta.js": 4.724,
+                "math-cordic.js": 2.552
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 44.6973,
+                "function-empty.js": 32.3533,
+                "function-excess-args.js": 63.688,
+                "function-closure.js": 5.33333,
+                "function-missing-args.js": 66.304,
+                "loop-sum.js": 50.248,
+                "loop-empty-resolve.js": 5.11467,
+                "function-correct-args.js": 88.8973,
+                "function-sum.js": 49.5947
+            },
+            "duktape": {
+                "loop-empty.js": 55.868,
+                "function-empty.js": 40.3413,
+                "function-excess-args.js": 32.252,
+                "function-closure.js": 19.644,
+                "function-missing-args.js": 30.936,
+                "loop-sum.js": 74.3347,
+                "loop-empty-resolve.js": 6.75333,
+                "function-correct-args.js": 32.3173,
+                "function-sum.js": 26.5133
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-29.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "3fbe54393f4900ea03b452326d1e96dbd9bf2d3a",
+            "size": 190152
+        },
+        "duktape": {
+            "version": "a9423c5e963d9241479a678fb62f408c3718ca0c",
+            "size": 161728
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.71333,
+                "3d-cube.js": 6.632,
+                "access-fannkuch.js": 16.308,
+                "access-nbody.js": 7.18267,
+                "bitops-bitwise-and.js": 5.44667,
+                "math-partial-sums.js": 3.37467,
+                "controlflow-recursive.js": 4.49733,
+                "bitops-bits-in-byte.js": 7.85067,
+                "access-binary-trees.js": 3.40267,
+                "bitops-3bit-bits-in-byte.js": 5.372,
+                "string-fasta.js": 36.2293,
+                "math-cordic.js": 8.67733
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.104,
+                "3d-cube.js": 1.156,
+                "access-fannkuch.js": 1.97867,
+                "access-nbody.js": 1.756,
+                "bitops-bitwise-and.js": 7.84267,
+                "math-partial-sums.js": 2.84667,
+                "controlflow-recursive.js": 1.23467,
+                "bitops-bits-in-byte.js": 0.928,
+                "access-binary-trees.js": 1.26667,
+                "bitops-3bit-bits-in-byte.js": 0.584,
+                "string-fasta.js": 4.78667,
+                "math-cordic.js": 2.42
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.516,
+                "function-empty.js": 33.4613,
+                "function-excess-args.js": 63.976,
+                "function-closure.js": 5.36533,
+                "function-missing-args.js": 66.1973,
+                "loop-sum.js": 50.7027,
+                "loop-empty-resolve.js": 5.14933,
+                "function-correct-args.js": 89.6493,
+                "function-sum.js": 49.7267
+            },
+            "duktape": {
+                "loop-empty.js": 58.4453,
+                "function-empty.js": 39.8,
+                "function-excess-args.js": 31.952,
+                "function-closure.js": 19.9787,
+                "function-missing-args.js": 30.604,
+                "loop-sum.js": 91.8493,
+                "loop-empty-resolve.js": 7.044,
+                "function-correct-args.js": 32.036,
+                "function-sum.js": 26.5227
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-30.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "8cd1ade51592e3fba0a926418b1c9990a4c409f3",
+            "size": 190152
+        },
+        "duktape": {
+            "version": "9f7eee025386711fa15d6af0ed4715650db1816a",
+            "size": 161728
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.73333,
+                "3d-cube.js": 6.64933,
+                "access-fannkuch.js": 16.2613,
+                "access-nbody.js": 7.17333,
+                "bitops-bitwise-and.js": 5.41733,
+                "math-partial-sums.js": 3.39333,
+                "controlflow-recursive.js": 4.52667,
+                "bitops-bits-in-byte.js": 7.904,
+                "access-binary-trees.js": 3.408,
+                "bitops-3bit-bits-in-byte.js": 5.42,
+                "string-fasta.js": 36.5933,
+                "math-cordic.js": 8.69067
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.10533,
+                "3d-cube.js": 1.156,
+                "access-fannkuch.js": 1.98,
+                "access-nbody.js": 1.76133,
+                "bitops-bitwise-and.js": 7.86667,
+                "math-partial-sums.js": 2.84133,
+                "controlflow-recursive.js": 1.24,
+                "bitops-bits-in-byte.js": 0.925333,
+                "access-binary-trees.js": 1.27733,
+                "bitops-3bit-bits-in-byte.js": 0.585333,
+                "string-fasta.js": 4.784,
+                "math-cordic.js": 2.40933
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.3547,
+                "function-empty.js": 32.6187,
+                "function-excess-args.js": 64.6893,
+                "function-closure.js": 5.36267,
+                "function-missing-args.js": 67.2133,
+                "loop-sum.js": 50.888,
+                "loop-empty-resolve.js": 5.11467,
+                "function-correct-args.js": 90.4067,
+                "function-sum.js": 50.272
+            },
+            "duktape": {
+                "loop-empty.js": 58.4093,
+                "function-empty.js": 39.7973,
+                "function-excess-args.js": 31.9133,
+                "function-closure.js": 19.804,
+                "function-missing-args.js": 30.5973,
+                "loop-sum.js": 91.7947,
+                "loop-empty-resolve.js": 7.04533,
+                "function-correct-args.js": 32.0293,
+                "function-sum.js": 26.512
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-07-31.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "c715a7cd1de6c498420ed024fb03674e5d74754d",
+            "size": 190152
+        },
+        "duktape": {
+            "version": "9f7eee025386711fa15d6af0ed4715650db1816a",
+            "size": 161728
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.82,
+                "3d-cube.js": 6.796,
+                "access-fannkuch.js": 16.8853,
+                "access-nbody.js": 7.4,
+                "bitops-bitwise-and.js": 5.40533,
+                "math-partial-sums.js": 3.432,
+                "controlflow-recursive.js": 4.604,
+                "bitops-bits-in-byte.js": 7.97333,
+                "access-binary-trees.js": 3.46933,
+                "bitops-3bit-bits-in-byte.js": 5.45867,
+                "string-fasta.js": 36.8493,
+                "math-cordic.js": 8.83733
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.10667,
+                "3d-cube.js": 1.15733,
+                "access-fannkuch.js": 1.98133,
+                "access-nbody.js": 1.76933,
+                "bitops-bitwise-and.js": 7.85733,
+                "math-partial-sums.js": 2.84267,
+                "controlflow-recursive.js": 1.236,
+                "bitops-bits-in-byte.js": 0.933333,
+                "access-binary-trees.js": 1.276,
+                "bitops-3bit-bits-in-byte.js": 0.586667,
+                "string-fasta.js": 4.792,
+                "math-cordic.js": 2.412
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 46.232,
+                "function-empty.js": 33.7587,
+                "function-excess-args.js": 65.288,
+                "function-closure.js": 5.53733,
+                "function-missing-args.js": 67.288,
+                "loop-sum.js": 51.2053,
+                "loop-empty-resolve.js": 5.24267,
+                "function-correct-args.js": 90.7587,
+                "function-sum.js": 50.7853
+            },
+            "duktape": {
+                "loop-empty.js": 58.3533,
+                "function-empty.js": 39.8053,
+                "function-excess-args.js": 31.848,
+                "function-closure.js": 19.8907,
+                "function-missing-args.js": 30.6013,
+                "loop-sum.js": 91.8027,
+                "loop-empty-resolve.js": 7.052,
+                "function-correct-args.js": 32.0187,
+                "function-sum.js": 26.528
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-08-01.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "f7781bb7bcfeee5913cf772d3b577e9798040b7f",
+            "size": 190156
+        },
+        "duktape": {
+            "version": "a67f893abfb26088e3cda67d5f2f3373ddf9277a",
+            "size": 161728
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.736,
+                "3d-cube.js": 6.67067,
+                "access-fannkuch.js": 16.3533,
+                "access-nbody.js": 7.23867,
+                "bitops-bitwise-and.js": 5.38267,
+                "math-partial-sums.js": 3.42,
+                "controlflow-recursive.js": 4.52667,
+                "bitops-bits-in-byte.js": 7.90267,
+                "access-binary-trees.js": 3.40533,
+                "bitops-3bit-bits-in-byte.js": 5.412,
+                "string-fasta.js": 36.5333,
+                "math-cordic.js": 8.696
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.108,
+                "3d-cube.js": 1.15333,
+                "access-fannkuch.js": 1.98133,
+                "access-nbody.js": 1.76,
+                "bitops-bitwise-and.js": 7.86267,
+                "math-partial-sums.js": 2.85733,
+                "controlflow-recursive.js": 1.23867,
+                "bitops-bits-in-byte.js": 0.928,
+                "access-binary-trees.js": 1.27733,
+                "bitops-3bit-bits-in-byte.js": 0.588,
+                "string-fasta.js": 4.784,
+                "math-cordic.js": 2.41867
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.5853,
+                "function-empty.js": 33.1587,
+                "function-excess-args.js": 64.6413,
+                "function-closure.js": 5.48133,
+                "function-missing-args.js": 66.916,
+                "loop-sum.js": 50.68,
+                "loop-empty-resolve.js": 5.19467,
+                "function-correct-args.js": 89.8747,
+                "function-sum.js": 50.1747
+            },
+            "duktape": {
+                "loop-empty.js": 58.4013,
+                "function-empty.js": 39.7947,
+                "function-excess-args.js": 31.928,
+                "function-closure.js": 19.9387,
+                "function-missing-args.js": 30.5333,
+                "loop-sum.js": 91.864,
+                "loop-empty-resolve.js": 7.05067,
+                "function-correct-args.js": 31.9747,
+                "function-sum.js": 26.5387
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-08-02.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "f7781bb7bcfeee5913cf772d3b577e9798040b7f",
+            "size": 190156
+        },
+        "duktape": {
+            "version": "a67f893abfb26088e3cda67d5f2f3373ddf9277a",
+            "size": 161728
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.73867,
+                "3d-cube.js": 6.68133,
+                "access-fannkuch.js": 16.3653,
+                "access-nbody.js": 7.23467,
+                "bitops-bitwise-and.js": 5.37467,
+                "math-partial-sums.js": 3.416,
+                "controlflow-recursive.js": 4.52667,
+                "bitops-bits-in-byte.js": 7.90533,
+                "access-binary-trees.js": 3.428,
+                "bitops-3bit-bits-in-byte.js": 5.40667,
+                "string-fasta.js": 36.5853,
+                "math-cordic.js": 8.70933
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.09867,
+                "3d-cube.js": 1.156,
+                "access-fannkuch.js": 1.98,
+                "access-nbody.js": 1.75867,
+                "bitops-bitwise-and.js": 7.83067,
+                "math-partial-sums.js": 2.84133,
+                "controlflow-recursive.js": 1.24133,
+                "bitops-bits-in-byte.js": 0.930667,
+                "access-binary-trees.js": 1.28,
+                "bitops-3bit-bits-in-byte.js": 0.588,
+                "string-fasta.js": 4.78667,
+                "math-cordic.js": 2.41733
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.5747,
+                "function-empty.js": 33.128,
+                "function-excess-args.js": 64.6227,
+                "function-closure.js": 5.48667,
+                "function-missing-args.js": 66.848,
+                "loop-sum.js": 50.6933,
+                "loop-empty-resolve.js": 5.18933,
+                "function-correct-args.js": 89.9933,
+                "function-sum.js": 50.2107
+            },
+            "duktape": {
+                "loop-empty.js": 58.364,
+                "function-empty.js": 39.7947,
+                "function-excess-args.js": 31.924,
+                "function-closure.js": 19.8027,
+                "function-missing-args.js": 30.5667,
+                "loop-sum.js": 91.8733,
+                "loop-empty-resolve.js": 7.044,
+                "function-correct-args.js": 32.0093,
+                "function-sum.js": 26.5013
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-08-03.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "f7781bb7bcfeee5913cf772d3b577e9798040b7f",
+            "size": 190156
+        },
+        "duktape": {
+            "version": "a67f893abfb26088e3cda67d5f2f3373ddf9277a",
+            "size": 161728
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.74133,
+                "3d-cube.js": 6.736,
+                "access-fannkuch.js": 16.36,
+                "access-nbody.js": 7.228,
+                "bitops-bitwise-and.js": 5.388,
+                "math-partial-sums.js": 3.424,
+                "controlflow-recursive.js": 4.54933,
+                "bitops-bits-in-byte.js": 7.91333,
+                "access-binary-trees.js": 3.41467,
+                "bitops-3bit-bits-in-byte.js": 5.41733,
+                "string-fasta.js": 36.5973,
+                "math-cordic.js": 8.71067
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.108,
+                "3d-cube.js": 1.16,
+                "access-fannkuch.js": 1.98,
+                "access-nbody.js": 1.74267,
+                "bitops-bitwise-and.js": 7.86267,
+                "math-partial-sums.js": 2.844,
+                "controlflow-recursive.js": 1.24267,
+                "bitops-bits-in-byte.js": 0.932,
+                "access-binary-trees.js": 1.28,
+                "bitops-3bit-bits-in-byte.js": 0.590667,
+                "string-fasta.js": 4.79333,
+                "math-cordic.js": 2.40667
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.6093,
+                "function-empty.js": 33.1693,
+                "function-excess-args.js": 64.6187,
+                "function-closure.js": 5.47867,
+                "function-missing-args.js": 66.88,
+                "loop-sum.js": 50.724,
+                "loop-empty-resolve.js": 5.19333,
+                "function-correct-args.js": 89.9587,
+                "function-sum.js": 50.244
+            },
+            "duktape": {
+                "loop-empty.js": 58.436,
+                "function-empty.js": 39.776,
+                "function-excess-args.js": 31.9373,
+                "function-closure.js": 19.84,
+                "function-missing-args.js": 30.592,
+                "loop-sum.js": 91.836,
+                "loop-empty-resolve.js": 7.03867,
+                "function-correct-args.js": 32.032,
+                "function-sum.js": 26.5307
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-08-04.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "c41f76aba2473e9c241e06b12a4309fa265c857b",
+            "size": 190156
+        },
+        "duktape": {
+            "version": "bdd02a059f4658b87a03ddc2156f111693743b27",
+            "size": 161728
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.74533,
+                "3d-cube.js": 6.71733,
+                "access-fannkuch.js": 16.5987,
+                "access-nbody.js": 7.35067,
+                "bitops-bitwise-and.js": 5.49733,
+                "math-partial-sums.js": 3.408,
+                "controlflow-recursive.js": 4.444,
+                "bitops-bits-in-byte.js": 7.82667,
+                "access-binary-trees.js": 3.43333,
+                "bitops-3bit-bits-in-byte.js": 5.372,
+                "string-fasta.js": 36.4347,
+                "math-cordic.js": 8.71333
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.104,
+                "3d-cube.js": 1.15867,
+                "access-fannkuch.js": 1.98667,
+                "access-nbody.js": 1.76133,
+                "bitops-bitwise-and.js": 7.86267,
+                "math-partial-sums.js": 2.848,
+                "controlflow-recursive.js": 1.23733,
+                "bitops-bits-in-byte.js": 0.932,
+                "access-binary-trees.js": 1.28267,
+                "bitops-3bit-bits-in-byte.js": 0.588,
+                "string-fasta.js": 4.78933,
+                "math-cordic.js": 2.41467
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 140,
+                "math-partial-sums.js": 144,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 140,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 140,
+                "string-fasta.js": 156,
+                "math-cordic.js": 144
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.28,
+                "function-empty.js": 33.6253,
+                "function-excess-args.js": 64.1067,
+                "function-closure.js": 5.33467,
+                "function-missing-args.js": 66.324,
+                "loop-sum.js": 50.5907,
+                "loop-empty-resolve.js": 5.12667,
+                "function-correct-args.js": 89.5387,
+                "function-sum.js": 50.012
+            },
+            "duktape": {
+                "loop-empty.js": 58.424,
+                "function-empty.js": 39.804,
+                "function-excess-args.js": 31.9427,
+                "function-closure.js": 19.876,
+                "function-missing-args.js": 30.6187,
+                "loop-sum.js": 91.7333,
+                "loop-empty-resolve.js": 7.03067,
+                "function-correct-args.js": 31.9987,
+                "function-sum.js": 26.5133
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 140,
+                "function-excess-args.js": 140,
+                "function-closure.js": 472,
+                "function-missing-args.js": 140,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 140,
+                "function-sum.js": 140
+            }
+        }
+    }
+}

benchmark/data/2015-08-05.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "af56cd8465e530428e5be6ac9074201a21e36da3",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "0b005c676c66f76431f2af7d8eacd1f81fb238fb",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.78933,
+                "3d-cube.js": 6.70267,
+                "access-fannkuch.js": 16.34,
+                "access-nbody.js": 7.20667,
+                "bitops-bitwise-and.js": 5.37733,
+                "math-partial-sums.js": 3.39867,
+                "controlflow-recursive.js": 4.56533,
+                "bitops-bits-in-byte.js": 7.88667,
+                "access-binary-trees.js": 3.40933,
+                "bitops-3bit-bits-in-byte.js": 5.47467,
+                "string-fasta.js": 36.264,
+                "math-cordic.js": 8.81467
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.072,
+                "3d-cube.js": 1.164,
+                "access-fannkuch.js": 1.98,
+                "access-nbody.js": 1.76267,
+                "bitops-bitwise-and.js": 10.2053,
+                "math-partial-sums.js": 2.89467,
+                "controlflow-recursive.js": 1.224,
+                "bitops-bits-in-byte.js": 0.941333,
+                "access-binary-trees.js": 1.28533,
+                "bitops-3bit-bits-in-byte.js": 0.582667,
+                "string-fasta.js": 4.836,
+                "math-cordic.js": 2.44533
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 52,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 45.324,
+                "function-empty.js": 33.2627,
+                "function-excess-args.js": 64.176,
+                "function-closure.js": 5.41867,
+                "function-missing-args.js": 66.308,
+                "loop-sum.js": 50.596,
+                "loop-empty-resolve.js": 5.17467,
+                "function-correct-args.js": 89.4587,
+                "function-sum.js": 50.1053
+            },
+            "duktape": {
+                "loop-empty.js": 76.2387,
+                "function-empty.js": 48.284,
+                "function-excess-args.js": 38.3613,
+                "function-closure.js": 20.072,
+                "function-missing-args.js": 36.796,
+                "loop-sum.js": 89.8813,
+                "loop-empty-resolve.js": 9.072,
+                "function-correct-args.js": 38.2333,
+                "function-sum.js": 31.528
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-06.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "caeae0f6212dfee662a4082862ca78c66827102b",
+            "size": 190156
+        },
+        "duktape": {
+            "version": "8e948aa60d0b468396f4b00b22b427d548d4c011",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.87467,
+                "3d-cube.js": 6.69067,
+                "access-fannkuch.js": 16.6013,
+                "access-nbody.js": 7.148,
+                "bitops-bitwise-and.js": 5.296,
+                "math-partial-sums.js": 3.39867,
+                "controlflow-recursive.js": 4.556,
+                "bitops-bits-in-byte.js": 7.68667,
+                "access-binary-trees.js": 3.39733,
+                "bitops-3bit-bits-in-byte.js": 5.368,
+                "string-fasta.js": 36.0893,
+                "math-cordic.js": 8.97733
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.07333,
+                "3d-cube.js": 1.16133,
+                "access-fannkuch.js": 1.98533,
+                "access-nbody.js": 1.76267,
+                "bitops-bitwise-and.js": 10.22,
+                "math-partial-sums.js": 2.90133,
+                "controlflow-recursive.js": 1.21867,
+                "bitops-bits-in-byte.js": 0.941333,
+                "access-binary-trees.js": 1.28933,
+                "bitops-3bit-bits-in-byte.js": 0.581333,
+                "string-fasta.js": 4.83867,
+                "math-cordic.js": 2.44133
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 172,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 52
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 43.5427,
+                "function-empty.js": 33.8133,
+                "function-excess-args.js": 77.4747,
+                "function-closure.js": 5.29867,
+                "function-missing-args.js": 66.4987,
+                "loop-sum.js": 49.368,
+                "loop-empty-resolve.js": 5.092,
+                "function-correct-args.js": 104.023,
+                "function-sum.js": 53.3507
+            },
+            "duktape": {
+                "loop-empty.js": 76.292,
+                "function-empty.js": 48.228,
+                "function-excess-args.js": 38.3267,
+                "function-closure.js": 20.0667,
+                "function-missing-args.js": 36.7933,
+                "loop-sum.js": 90.108,
+                "loop-empty-resolve.js": 9.10267,
+                "function-correct-args.js": 38.2467,
+                "function-sum.js": 31.5667
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 36,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-07.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "a19dd0523e5e48f7496fe60caa3f195193f638d2",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "322ccf9a10675a07d594bda9fac9e1ff72ee3f03",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.85333,
+                "3d-cube.js": 6.732,
+                "access-fannkuch.js": 16.7347,
+                "access-nbody.js": 7.37733,
+                "bitops-bitwise-and.js": 5.39467,
+                "math-partial-sums.js": 3.50533,
+                "controlflow-recursive.js": 4.51067,
+                "bitops-bits-in-byte.js": 7.568,
+                "access-binary-trees.js": 3.416,
+                "bitops-3bit-bits-in-byte.js": 5.32533,
+                "string-fasta.js": 36.3853,
+                "math-cordic.js": 8.94533
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.072,
+                "3d-cube.js": 1.16,
+                "access-fannkuch.js": 1.98267,
+                "access-nbody.js": 1.764,
+                "bitops-bitwise-and.js": 10.2133,
+                "math-partial-sums.js": 2.89333,
+                "controlflow-recursive.js": 1.224,
+                "bitops-bits-in-byte.js": 0.941333,
+                "access-binary-trees.js": 1.292,
+                "bitops-3bit-bits-in-byte.js": 0.581333,
+                "string-fasta.js": 4.82933,
+                "math-cordic.js": 2.436
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 172,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 236,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 52
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 44.7613,
+                "function-empty.js": 34.164,
+                "function-excess-args.js": 77.7893,
+                "function-closure.js": 5.352,
+                "function-missing-args.js": 67.1813,
+                "loop-sum.js": 50.2573,
+                "loop-empty-resolve.js": 5.17467,
+                "function-correct-args.js": 103.824,
+                "function-sum.js": 53.8987
+            },
+            "duktape": {
+                "loop-empty.js": 76.276,
+                "function-empty.js": 48.252,
+                "function-excess-args.js": 38.4093,
+                "function-closure.js": 20.1427,
+                "function-missing-args.js": 36.7787,
+                "loop-sum.js": 90.1533,
+                "loop-empty-resolve.js": 9.092,
+                "function-correct-args.js": 38.3093,
+                "function-sum.js": 31.528
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 36,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-08.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "640370da43b51c934205df3a0de597079a8f6a3c",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "322ccf9a10675a07d594bda9fac9e1ff72ee3f03",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.872,
+                "3d-cube.js": 6.72,
+                "access-fannkuch.js": 16.8653,
+                "access-nbody.js": 7.25733,
+                "bitops-bitwise-and.js": 5.368,
+                "math-partial-sums.js": 3.444,
+                "controlflow-recursive.js": 4.50267,
+                "bitops-bits-in-byte.js": 7.66133,
+                "access-binary-trees.js": 3.44133,
+                "bitops-3bit-bits-in-byte.js": 5.39333,
+                "string-fasta.js": 36.1267,
+                "math-cordic.js": 8.96267
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.076,
+                "3d-cube.js": 1.16533,
+                "access-fannkuch.js": 1.97733,
+                "access-nbody.js": 1.76267,
+                "bitops-bitwise-and.js": 10.2133,
+                "math-partial-sums.js": 2.9,
+                "controlflow-recursive.js": 1.224,
+                "bitops-bits-in-byte.js": 0.941333,
+                "access-binary-trees.js": 1.28267,
+                "bitops-3bit-bits-in-byte.js": 0.58,
+                "string-fasta.js": 4.83733,
+                "math-cordic.js": 2.44533
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 172,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 232,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 52
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 44.3067,
+                "function-empty.js": 33.5453,
+                "function-excess-args.js": 77.4547,
+                "function-closure.js": 5.372,
+                "function-missing-args.js": 66.632,
+                "loop-sum.js": 49.936,
+                "loop-empty-resolve.js": 5.168,
+                "function-correct-args.js": 104.269,
+                "function-sum.js": 53.64
+            },
+            "duktape": {
+                "loop-empty.js": 76.2893,
+                "function-empty.js": 48.2293,
+                "function-excess-args.js": 38.3893,
+                "function-closure.js": 20.2013,
+                "function-missing-args.js": 36.804,
+                "loop-sum.js": 90.2027,
+                "loop-empty-resolve.js": 9.088,
+                "function-correct-args.js": 38.2853,
+                "function-sum.js": 31.5
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 36,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-09.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "640370da43b51c934205df3a0de597079a8f6a3c",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "75dab4ae685a75d5293d794969330c2657aab50c",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.85867,
+                "3d-cube.js": 6.71733,
+                "access-fannkuch.js": 16.8627,
+                "access-nbody.js": 7.24,
+                "bitops-bitwise-and.js": 5.36533,
+                "math-partial-sums.js": 3.44667,
+                "controlflow-recursive.js": 4.50533,
+                "bitops-bits-in-byte.js": 7.64667,
+                "access-binary-trees.js": 3.444,
+                "bitops-3bit-bits-in-byte.js": 5.37067,
+                "string-fasta.js": 36.0787,
+                "math-cordic.js": 8.98133
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.088,
+                "3d-cube.js": 1.168,
+                "access-fannkuch.js": 1.98,
+                "access-nbody.js": 1.79333,
+                "bitops-bitwise-and.js": 10.2667,
+                "math-partial-sums.js": 2.93467,
+                "controlflow-recursive.js": 1.23467,
+                "bitops-bits-in-byte.js": 0.950667,
+                "access-binary-trees.js": 1.304,
+                "bitops-3bit-bits-in-byte.js": 0.588,
+                "string-fasta.js": 4.87867,
+                "math-cordic.js": 2.468
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 172,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 232,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 52
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 44.2787,
+                "function-empty.js": 33.588,
+                "function-excess-args.js": 77.652,
+                "function-closure.js": 5.37467,
+                "function-missing-args.js": 66.524,
+                "loop-sum.js": 49.9,
+                "loop-empty-resolve.js": 5.156,
+                "function-correct-args.js": 104.297,
+                "function-sum.js": 53.6587
+            },
+            "duktape": {
+                "loop-empty.js": 75.9933,
+                "function-empty.js": 48.6013,
+                "function-excess-args.js": 38.676,
+                "function-closure.js": 20.268,
+                "function-missing-args.js": 37.1173,
+                "loop-sum.js": 90.4187,
+                "loop-empty-resolve.js": 9.05733,
+                "function-correct-args.js": 38.5267,
+                "function-sum.js": 31.7907
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 36,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-10.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "640370da43b51c934205df3a0de597079a8f6a3c",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "217e3b95910d70ed15cfd5a813fb2a5c95fabf13",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.86267,
+                "3d-cube.js": 6.71067,
+                "access-fannkuch.js": 16.8333,
+                "access-nbody.js": 7.22933,
+                "bitops-bitwise-and.js": 5.36933,
+                "math-partial-sums.js": 3.456,
+                "controlflow-recursive.js": 4.50667,
+                "bitops-bits-in-byte.js": 7.64667,
+                "access-binary-trees.js": 3.43867,
+                "bitops-3bit-bits-in-byte.js": 5.37067,
+                "string-fasta.js": 36.1053,
+                "math-cordic.js": 9.01733
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.08533,
+                "3d-cube.js": 1.168,
+                "access-fannkuch.js": 1.97867,
+                "access-nbody.js": 1.792,
+                "bitops-bitwise-and.js": 10.1947,
+                "math-partial-sums.js": 2.936,
+                "controlflow-recursive.js": 1.23333,
+                "bitops-bits-in-byte.js": 0.950667,
+                "access-binary-trees.js": 1.30667,
+                "bitops-3bit-bits-in-byte.js": 0.585333,
+                "string-fasta.js": 4.89467,
+                "math-cordic.js": 2.46667
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 172,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 232,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 52
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 44.2627,
+                "function-empty.js": 33.5067,
+                "function-excess-args.js": 77.5333,
+                "function-closure.js": 5.38667,
+                "function-missing-args.js": 66.6,
+                "loop-sum.js": 49.968,
+                "loop-empty-resolve.js": 5.15467,
+                "function-correct-args.js": 103.957,
+                "function-sum.js": 53.6747
+            },
+            "duktape": {
+                "loop-empty.js": 75.5853,
+                "function-empty.js": 48.436,
+                "function-excess-args.js": 38.4107,
+                "function-closure.js": 20.204,
+                "function-missing-args.js": 36.9653,
+                "loop-sum.js": 89.996,
+                "loop-empty-resolve.js": 8.99467,
+                "function-correct-args.js": 38.2187,
+                "function-sum.js": 31.636
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 36,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-11.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "e22a085fc1385f2e0d60eb324063b344c239a949",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "f28f6c2bbb3781711609d401cda6a3b9f6a7d29f",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.864,
+                "3d-cube.js": 6.74667,
+                "access-fannkuch.js": 16.6253,
+                "access-nbody.js": 7.23733,
+                "bitops-bitwise-and.js": 5.33067,
+                "math-partial-sums.js": 3.48667,
+                "controlflow-recursive.js": 4.56,
+                "bitops-bits-in-byte.js": 7.70267,
+                "access-binary-trees.js": 3.41467,
+                "bitops-3bit-bits-in-byte.js": 5.424,
+                "string-fasta.js": 36.5293,
+                "math-cordic.js": 8.99733
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.092,
+                "3d-cube.js": 1.168,
+                "access-fannkuch.js": 1.98,
+                "access-nbody.js": 1.79333,
+                "bitops-bitwise-and.js": 10.2107,
+                "math-partial-sums.js": 2.93867,
+                "controlflow-recursive.js": 1.23467,
+                "bitops-bits-in-byte.js": 0.948,
+                "access-binary-trees.js": 1.30267,
+                "bitops-3bit-bits-in-byte.js": 0.588,
+                "string-fasta.js": 4.89067,
+                "math-cordic.js": 2.46267
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 172,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 232,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 92,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 52
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 44.6253,
+                "function-empty.js": 33.7853,
+                "function-excess-args.js": 77.5427,
+                "function-closure.js": 5.32,
+                "function-missing-args.js": 66.38,
+                "loop-sum.js": 50.0413,
+                "loop-empty-resolve.js": 5.2,
+                "function-correct-args.js": 103.961,
+                "function-sum.js": 54.2893
+            },
+            "duktape": {
+                "loop-empty.js": 75.564,
+                "function-empty.js": 48.3947,
+                "function-excess-args.js": 38.4213,
+                "function-closure.js": 20.2053,
+                "function-missing-args.js": 36.9187,
+                "loop-sum.js": 90.0107,
+                "loop-empty-resolve.js": 9.00533,
+                "function-correct-args.js": 38.3107,
+                "function-sum.js": 31.6707
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 36,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-12.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "c4b1f02947aee10f8ca20ea17da340f8c5fe5a3a",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "a773df04bdc84c842bceaeb918bd910579ea8841",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.72667,
+                "3d-cube.js": 6.67733,
+                "access-fannkuch.js": 16.4707,
+                "access-nbody.js": 7.12667,
+                "bitops-bitwise-and.js": 5.21067,
+                "math-partial-sums.js": 3.38667,
+                "controlflow-recursive.js": 3.98,
+                "bitops-bits-in-byte.js": 7.572,
+                "access-binary-trees.js": 3.336,
+                "bitops-3bit-bits-in-byte.js": 5.276,
+                "string-fasta.js": 36.096,
+                "math-cordic.js": 8.82933
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.092,
+                "3d-cube.js": 1.16267,
+                "access-fannkuch.js": 1.984,
+                "access-nbody.js": 1.796,
+                "bitops-bitwise-and.js": 10.2013,
+                "math-partial-sums.js": 2.93067,
+                "controlflow-recursive.js": 1.23333,
+                "bitops-bits-in-byte.js": 0.949333,
+                "access-binary-trees.js": 1.30133,
+                "bitops-3bit-bits-in-byte.js": 0.586667,
+                "string-fasta.js": 4.88267,
+                "math-cordic.js": 2.46533
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 172,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 216,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 100,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 52
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 43.996,
+                "function-empty.js": 33.328,
+                "function-excess-args.js": 74.8947,
+                "function-closure.js": 5.452,
+                "function-missing-args.js": 66.6867,
+                "loop-sum.js": 49.4373,
+                "loop-empty-resolve.js": 5.09333,
+                "function-correct-args.js": 102.744,
+                "function-sum.js": 51.856
+            },
+            "duktape": {
+                "loop-empty.js": 75.584,
+                "function-empty.js": 48.396,
+                "function-excess-args.js": 38.3987,
+                "function-closure.js": 20.1213,
+                "function-missing-args.js": 36.9253,
+                "loop-sum.js": 89.7707,
+                "loop-empty-resolve.js": 9.00267,
+                "function-correct-args.js": 38.3653,
+                "function-sum.js": 31.6947
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 36,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-13.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "4ee30cba5d68586d4d248660df83dac316c7603a",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "3e95145cc06041751b51656156177601b97e0197",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.83733,
+                "3d-cube.js": 6.72933,
+                "access-fannkuch.js": 16.7347,
+                "access-nbody.js": 7.388,
+                "bitops-bitwise-and.js": 5.22,
+                "math-partial-sums.js": 3.49333,
+                "controlflow-recursive.js": 4.028,
+                "bitops-bits-in-byte.js": 7.576,
+                "access-binary-trees.js": 3.35867,
+                "bitops-3bit-bits-in-byte.js": 5.308,
+                "string-fasta.js": 36.5467,
+                "math-cordic.js": 8.93733
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.09067,
+                "3d-cube.js": 1.164,
+                "access-fannkuch.js": 1.98,
+                "access-nbody.js": 1.792,
+                "bitops-bitwise-and.js": 10.1787,
+                "math-partial-sums.js": 2.93333,
+                "controlflow-recursive.js": 1.22933,
+                "bitops-bits-in-byte.js": 0.945333,
+                "access-binary-trees.js": 1.30133,
+                "bitops-3bit-bits-in-byte.js": 0.586667,
+                "string-fasta.js": 4.884,
+                "math-cordic.js": 2.45467
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 172,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 216,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 100,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 52
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 43.992,
+                "function-empty.js": 33.7067,
+                "function-excess-args.js": 76.0,
+                "function-closure.js": 5.48667,
+                "function-missing-args.js": 67.536,
+                "loop-sum.js": 49.9027,
+                "loop-empty-resolve.js": 5.12,
+                "function-correct-args.js": 103.776,
+                "function-sum.js": 52.864
+            },
+            "duktape": {
+                "loop-empty.js": 75.608,
+                "function-empty.js": 48.348,
+                "function-excess-args.js": 38.444,
+                "function-closure.js": 20.3053,
+                "function-missing-args.js": 36.9387,
+                "loop-sum.js": 89.8893,
+                "loop-empty-resolve.js": 8.99467,
+                "function-correct-args.js": 38.38,
+                "function-sum.js": 31.6613
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 28,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 36,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-14.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "8f594aebfad8860cfd25a9d9d875233122081bd3",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "0d0d23c6fd5103a81398241217af2a98cca6f5d7",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.04133,
+                "3d-cube.js": 5.98,
+                "access-fannkuch.js": 14.4653,
+                "access-nbody.js": 6.49467,
+                "bitops-bitwise-and.js": 4.32,
+                "math-partial-sums.js": 3.144,
+                "controlflow-recursive.js": 3.57333,
+                "bitops-bits-in-byte.js": 6.808,
+                "access-binary-trees.js": 3.51333,
+                "bitops-3bit-bits-in-byte.js": 4.804,
+                "string-fasta.js": 36.448,
+                "math-cordic.js": 7.64267
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.08533,
+                "3d-cube.js": 1.168,
+                "access-fannkuch.js": 1.98,
+                "access-nbody.js": 1.79333,
+                "bitops-bitwise-and.js": 10.188,
+                "math-partial-sums.js": 2.924,
+                "controlflow-recursive.js": 1.236,
+                "bitops-bits-in-byte.js": 0.950667,
+                "access-binary-trees.js": 1.30533,
+                "bitops-3bit-bits-in-byte.js": 0.586667,
+                "string-fasta.js": 4.87067,
+                "math-cordic.js": 2.45867
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 44,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 36,
+                "access-binary-trees.js": 104,
+                "bitops-3bit-bits-in-byte.js": 40,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 40.5107,
+                "function-empty.js": 31.772,
+                "function-excess-args.js": 69.3707,
+                "function-closure.js": 5.752,
+                "function-missing-args.js": 70.0893,
+                "loop-sum.js": 44.7947,
+                "loop-empty-resolve.js": 4.61333,
+                "function-correct-args.js": 98.256,
+                "function-sum.js": 47.4067
+            },
+            "duktape": {
+                "loop-empty.js": 75.6147,
+                "function-empty.js": 48.3933,
+                "function-excess-args.js": 38.44,
+                "function-closure.js": 20.1813,
+                "function-missing-args.js": 36.9267,
+                "loop-sum.js": 89.9187,
+                "loop-empty-resolve.js": 8.99867,
+                "function-correct-args.js": 38.3147,
+                "function-sum.js": 31.6547
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-15.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "38fa391cd8eef20d9b8b9c32453b89bacf7de436",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "6600dde85e0c930021e23a43fe59d3762b9bb58c",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.952,
+                "3d-cube.js": 5.88667,
+                "access-fannkuch.js": 14.0573,
+                "access-nbody.js": 6.26667,
+                "bitops-bitwise-and.js": 4.15467,
+                "math-partial-sums.js": 2.996,
+                "controlflow-recursive.js": 3.50933,
+                "bitops-bits-in-byte.js": 6.648,
+                "access-binary-trees.js": 3.42267,
+                "bitops-3bit-bits-in-byte.js": 4.67867,
+                "string-fasta.js": 36.1147,
+                "math-cordic.js": 7.376
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.1,
+                "3d-cube.js": 1.17733,
+                "access-fannkuch.js": 1.976,
+                "access-nbody.js": 1.80933,
+                "bitops-bitwise-and.js": 10.7587,
+                "math-partial-sums.js": 2.95333,
+                "controlflow-recursive.js": 1.232,
+                "bitops-bits-in-byte.js": 0.946667,
+                "access-binary-trees.js": 1.30667,
+                "bitops-3bit-bits-in-byte.js": 0.582667,
+                "string-fasta.js": 4.93467,
+                "math-cordic.js": 2.53067
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 44,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 36,
+                "access-binary-trees.js": 104,
+                "bitops-3bit-bits-in-byte.js": 40,
+                "string-fasta.js": 48,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.392,
+                "function-empty.js": 29.98,
+                "function-excess-args.js": 67.7107,
+                "function-closure.js": 5.56933,
+                "function-missing-args.js": 68.216,
+                "loop-sum.js": 43.216,
+                "loop-empty-resolve.js": 4.51067,
+                "function-correct-args.js": 96.5427,
+                "function-sum.js": 45.5333
+            },
+            "duktape": {
+                "loop-empty.js": 80.2533,
+                "function-empty.js": 50.3467,
+                "function-excess-args.js": 40.1013,
+                "function-closure.js": 20.9413,
+                "function-missing-args.js": 38.5253,
+                "loop-sum.js": 95.8627,
+                "loop-empty-resolve.js": 9.588,
+                "function-correct-args.js": 39.956,
+                "function-sum.js": 33.0053
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-16.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "38fa391cd8eef20d9b8b9c32453b89bacf7de436",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "d4bb9798b4145ec3a8cf156abf877f30d98b0e5c",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.95467,
+                "3d-cube.js": 5.89467,
+                "access-fannkuch.js": 14.0667,
+                "access-nbody.js": 6.27867,
+                "bitops-bitwise-and.js": 4.15333,
+                "math-partial-sums.js": 3.00533,
+                "controlflow-recursive.js": 3.512,
+                "bitops-bits-in-byte.js": 6.66933,
+                "access-binary-trees.js": 3.45467,
+                "bitops-3bit-bits-in-byte.js": 4.672,
+                "string-fasta.js": 36.0947,
+                "math-cordic.js": 7.39733
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.09733,
+                "3d-cube.js": 1.172,
+                "access-fannkuch.js": 1.97467,
+                "access-nbody.js": 1.81467,
+                "bitops-bitwise-and.js": 10.7333,
+                "math-partial-sums.js": 2.94267,
+                "controlflow-recursive.js": 1.24,
+                "bitops-bits-in-byte.js": 0.946667,
+                "access-binary-trees.js": 1.30133,
+                "bitops-3bit-bits-in-byte.js": 0.588,
+                "string-fasta.js": 4.93467,
+                "math-cordic.js": 2.52533
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 44,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 36,
+                "access-binary-trees.js": 104,
+                "bitops-3bit-bits-in-byte.js": 40,
+                "string-fasta.js": 48,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.3813,
+                "function-empty.js": 29.9053,
+                "function-excess-args.js": 67.7147,
+                "function-closure.js": 5.596,
+                "function-missing-args.js": 68.2693,
+                "loop-sum.js": 43.2253,
+                "loop-empty-resolve.js": 4.52,
+                "function-correct-args.js": 96.496,
+                "function-sum.js": 45.488
+            },
+            "duktape": {
+                "loop-empty.js": 80.3747,
+                "function-empty.js": 50.256,
+                "function-excess-args.js": 40.0373,
+                "function-closure.js": 20.904,
+                "function-missing-args.js": 38.5627,
+                "loop-sum.js": 95.7053,
+                "loop-empty-resolve.js": 9.572,
+                "function-correct-args.js": 39.8453,
+                "function-sum.js": 32.9227
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-17.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "38fa391cd8eef20d9b8b9c32453b89bacf7de436",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "8a90f515606ca59394b8d8351bde6876c6ab4b73",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.94133,
+                "3d-cube.js": 5.896,
+                "access-fannkuch.js": 14.0533,
+                "access-nbody.js": 6.272,
+                "bitops-bitwise-and.js": 4.156,
+                "math-partial-sums.js": 2.99467,
+                "controlflow-recursive.js": 3.508,
+                "bitops-bits-in-byte.js": 6.652,
+                "access-binary-trees.js": 3.44667,
+                "bitops-3bit-bits-in-byte.js": 4.66667,
+                "string-fasta.js": 36.1653,
+                "math-cordic.js": 7.39867
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.10133,
+                "3d-cube.js": 1.17333,
+                "access-fannkuch.js": 1.97467,
+                "access-nbody.js": 1.812,
+                "bitops-bitwise-and.js": 10.7387,
+                "math-partial-sums.js": 2.94133,
+                "controlflow-recursive.js": 1.244,
+                "bitops-bits-in-byte.js": 0.944,
+                "access-binary-trees.js": 1.304,
+                "bitops-3bit-bits-in-byte.js": 0.585333,
+                "string-fasta.js": 4.95333,
+                "math-cordic.js": 2.52533
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 44,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 36,
+                "access-binary-trees.js": 104,
+                "bitops-3bit-bits-in-byte.js": 40,
+                "string-fasta.js": 48,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.3893,
+                "function-empty.js": 30.0227,
+                "function-excess-args.js": 67.6693,
+                "function-closure.js": 5.59733,
+                "function-missing-args.js": 68.188,
+                "loop-sum.js": 43.1947,
+                "loop-empty-resolve.js": 4.51333,
+                "function-correct-args.js": 96.5373,
+                "function-sum.js": 45.5427
+            },
+            "duktape": {
+                "loop-empty.js": 80.3133,
+                "function-empty.js": 50.2827,
+                "function-excess-args.js": 40.1213,
+                "function-closure.js": 20.884,
+                "function-missing-args.js": 38.572,
+                "loop-sum.js": 95.768,
+                "loop-empty-resolve.js": 9.56267,
+                "function-correct-args.js": 39.8013,
+                "function-sum.js": 32.9413
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-18.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "ab47365b710c72536d6dfb85ea1fb4f1290da723",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "51661c12265f0ae04239a3256e6d5428d1b3aaf5",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.03733,
+                "3d-cube.js": 5.88667,
+                "access-fannkuch.js": 14.2493,
+                "access-nbody.js": 6.32133,
+                "bitops-bitwise-and.js": 4.168,
+                "math-partial-sums.js": 3.02533,
+                "controlflow-recursive.js": 3.55467,
+                "bitops-bits-in-byte.js": 6.64,
+                "access-binary-trees.js": 3.10533,
+                "bitops-3bit-bits-in-byte.js": 4.64,
+                "string-fasta.js": 35.7107,
+                "math-cordic.js": 7.412
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.096,
+                "3d-cube.js": 1.17733,
+                "access-fannkuch.js": 1.97867,
+                "access-nbody.js": 1.80933,
+                "bitops-bitwise-and.js": 10.7267,
+                "math-partial-sums.js": 2.944,
+                "controlflow-recursive.js": 1.24,
+                "bitops-bits-in-byte.js": 0.944,
+                "access-binary-trees.js": 1.30267,
+                "bitops-3bit-bits-in-byte.js": 0.586667,
+                "string-fasta.js": 4.94533,
+                "math-cordic.js": 2.528
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 160,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 96,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.8707,
+                "function-empty.js": 31.6013,
+                "function-excess-args.js": 67.7427,
+                "function-closure.js": 5.62133,
+                "function-missing-args.js": 68.0613,
+                "loop-sum.js": 44.2693,
+                "loop-empty-resolve.js": 4.58133,
+                "function-correct-args.js": 98.768,
+                "function-sum.js": 45.412
+            },
+            "duktape": {
+                "loop-empty.js": 80.336,
+                "function-empty.js": 50.2373,
+                "function-excess-args.js": 40.1067,
+                "function-closure.js": 20.8853,
+                "function-missing-args.js": 38.516,
+                "loop-sum.js": 95.82,
+                "loop-empty-resolve.js": 9.556,
+                "function-correct-args.js": 39.8453,
+                "function-sum.js": 32.9293
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-19.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "ab47365b710c72536d6dfb85ea1fb4f1290da723",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "e55e469c68b90f0aac86eca7c058b8347ef2f03e",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 4.04,
+                "3d-cube.js": 5.89067,
+                "access-fannkuch.js": 14.2387,
+                "access-nbody.js": 6.33467,
+                "bitops-bitwise-and.js": 4.16267,
+                "math-partial-sums.js": 3.016,
+                "controlflow-recursive.js": 3.56267,
+                "bitops-bits-in-byte.js": 6.65067,
+                "access-binary-trees.js": 3.11467,
+                "bitops-3bit-bits-in-byte.js": 4.63333,
+                "string-fasta.js": 35.7867,
+                "math-cordic.js": 7.41867
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.10133,
+                "3d-cube.js": 1.17467,
+                "access-fannkuch.js": 1.97733,
+                "access-nbody.js": 1.81467,
+                "bitops-bitwise-and.js": 10.7213,
+                "math-partial-sums.js": 2.948,
+                "controlflow-recursive.js": 1.23867,
+                "bitops-bits-in-byte.js": 0.945333,
+                "access-binary-trees.js": 1.30667,
+                "bitops-3bit-bits-in-byte.js": 0.588,
+                "string-fasta.js": 4.94,
+                "math-cordic.js": 2.52267
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 160,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 68,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 96,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.836,
+                "function-empty.js": 31.6013,
+                "function-excess-args.js": 67.7533,
+                "function-closure.js": 5.62533,
+                "function-missing-args.js": 68.1773,
+                "loop-sum.js": 44.212,
+                "loop-empty-resolve.js": 4.58133,
+                "function-correct-args.js": 98.704,
+                "function-sum.js": 45.508
+            },
+            "duktape": {
+                "loop-empty.js": 80.2453,
+                "function-empty.js": 50.2667,
+                "function-excess-args.js": 40.108,
+                "function-closure.js": 20.96,
+                "function-missing-args.js": 38.5333,
+                "loop-sum.js": 95.8133,
+                "loop-empty-resolve.js": 9.58267,
+                "function-correct-args.js": 39.848,
+                "function-sum.js": 32.9507
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-20.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "e0dee65a368b8ca7fa69c81af9517dd8824d98ed",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "e55e469c68b90f0aac86eca7c058b8347ef2f03e",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.84,
+                "3d-cube.js": 5.76133,
+                "access-fannkuch.js": 14.12,
+                "access-nbody.js": 5.88133,
+                "bitops-bitwise-and.js": 4.08267,
+                "math-partial-sums.js": 2.82667,
+                "controlflow-recursive.js": 3.572,
+                "bitops-bits-in-byte.js": 6.55067,
+                "access-binary-trees.js": 3.08933,
+                "bitops-3bit-bits-in-byte.js": 4.62667,
+                "string-fasta.js": 28.856,
+                "math-cordic.js": 7.268
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.1,
+                "3d-cube.js": 1.176,
+                "access-fannkuch.js": 1.97867,
+                "access-nbody.js": 1.808,
+                "bitops-bitwise-and.js": 10.728,
+                "math-partial-sums.js": 2.94667,
+                "controlflow-recursive.js": 1.24,
+                "bitops-bits-in-byte.js": 0.942667,
+                "access-binary-trees.js": 1.30133,
+                "bitops-3bit-bits-in-byte.js": 0.585333,
+                "string-fasta.js": 4.93867,
+                "math-cordic.js": 2.52267
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 76,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 96,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.3613,
+                "function-empty.js": 31.3627,
+                "function-excess-args.js": 67.7373,
+                "function-closure.js": 5.828,
+                "function-missing-args.js": 68.468,
+                "loop-sum.js": 41.2827,
+                "loop-empty-resolve.js": 4.568,
+                "function-correct-args.js": 98.716,
+                "function-sum.js": 45.82
+            },
+            "duktape": {
+                "loop-empty.js": 80.284,
+                "function-empty.js": 50.2653,
+                "function-excess-args.js": 40.064,
+                "function-closure.js": 20.9013,
+                "function-missing-args.js": 38.5107,
+                "loop-sum.js": 95.784,
+                "loop-empty-resolve.js": 9.56133,
+                "function-correct-args.js": 39.86,
+                "function-sum.js": 32.9187
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-21.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "b3b87add02f42eac1df89320ac08b760a58abfa1",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "e55e469c68b90f0aac86eca7c058b8347ef2f03e",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.86667,
+                "3d-cube.js": 5.73467,
+                "access-fannkuch.js": 13.9827,
+                "access-nbody.js": 5.864,
+                "bitops-bitwise-and.js": 4.05333,
+                "math-partial-sums.js": 2.84933,
+                "controlflow-recursive.js": 3.60933,
+                "bitops-bits-in-byte.js": 6.60267,
+                "access-binary-trees.js": 3.10533,
+                "bitops-3bit-bits-in-byte.js": 4.62667,
+                "string-fasta.js": 29.0307,
+                "math-cordic.js": 7.27333
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.09733,
+                "3d-cube.js": 1.17467,
+                "access-fannkuch.js": 1.976,
+                "access-nbody.js": 1.80933,
+                "bitops-bitwise-and.js": 10.7053,
+                "math-partial-sums.js": 2.94,
+                "controlflow-recursive.js": 1.24133,
+                "bitops-bits-in-byte.js": 0.945333,
+                "access-binary-trees.js": 1.30267,
+                "bitops-3bit-bits-in-byte.js": 0.586667,
+                "string-fasta.js": 4.93867,
+                "math-cordic.js": 2.52267
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 76,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 96,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.2213,
+                "function-empty.js": 31.66,
+                "function-excess-args.js": 68.3853,
+                "function-closure.js": 5.90267,
+                "function-missing-args.js": 69.144,
+                "loop-sum.js": 40.7867,
+                "loop-empty-resolve.js": 4.53067,
+                "function-correct-args.js": 99.3,
+                "function-sum.js": 46.172
+            },
+            "duktape": {
+                "loop-empty.js": 80.2987,
+                "function-empty.js": 50.2067,
+                "function-excess-args.js": 40.1227,
+                "function-closure.js": 20.9413,
+                "function-missing-args.js": 38.5147,
+                "loop-sum.js": 95.7587,
+                "loop-empty-resolve.js": 9.56533,
+                "function-correct-args.js": 39.84,
+                "function-sum.js": 32.9507
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-22.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "b3b87add02f42eac1df89320ac08b760a58abfa1",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "e55e469c68b90f0aac86eca7c058b8347ef2f03e",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.86267,
+                "3d-cube.js": 5.74667,
+                "access-fannkuch.js": 14.0147,
+                "access-nbody.js": 5.872,
+                "bitops-bitwise-and.js": 4.05333,
+                "math-partial-sums.js": 2.84667,
+                "controlflow-recursive.js": 3.57867,
+                "bitops-bits-in-byte.js": 6.59867,
+                "access-binary-trees.js": 3.088,
+                "bitops-3bit-bits-in-byte.js": 4.62667,
+                "string-fasta.js": 29.0707,
+                "math-cordic.js": 7.26267
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.1,
+                "3d-cube.js": 1.17333,
+                "access-fannkuch.js": 1.97333,
+                "access-nbody.js": 1.81067,
+                "bitops-bitwise-and.js": 10.7213,
+                "math-partial-sums.js": 2.93733,
+                "controlflow-recursive.js": 1.236,
+                "bitops-bits-in-byte.js": 0.945333,
+                "access-binary-trees.js": 1.3,
+                "bitops-3bit-bits-in-byte.js": 0.588,
+                "string-fasta.js": 4.94533,
+                "math-cordic.js": 2.52533
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 76,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 96,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.1573,
+                "function-empty.js": 31.672,
+                "function-excess-args.js": 68.3653,
+                "function-closure.js": 5.916,
+                "function-missing-args.js": 69.1267,
+                "loop-sum.js": 40.7987,
+                "loop-empty-resolve.js": 4.52533,
+                "function-correct-args.js": 99.2413,
+                "function-sum.js": 46.0987
+            },
+            "duktape": {
+                "loop-empty.js": 80.2853,
+                "function-empty.js": 50.2733,
+                "function-excess-args.js": 40.1053,
+                "function-closure.js": 20.8933,
+                "function-missing-args.js": 38.528,
+                "loop-sum.js": 95.696,
+                "loop-empty-resolve.js": 9.56267,
+                "function-correct-args.js": 39.812,
+                "function-sum.js": 32.9333
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-23.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "b3b87add02f42eac1df89320ac08b760a58abfa1",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "dabddfb6f8df5a9ccf44908055fefbc74c3a5643",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.86,
+                "3d-cube.js": 5.744,
+                "access-fannkuch.js": 14.0093,
+                "access-nbody.js": 5.88667,
+                "bitops-bitwise-and.js": 4.05467,
+                "math-partial-sums.js": 2.844,
+                "controlflow-recursive.js": 3.61067,
+                "bitops-bits-in-byte.js": 6.59467,
+                "access-binary-trees.js": 3.10933,
+                "bitops-3bit-bits-in-byte.js": 4.63067,
+                "string-fasta.js": 29.0493,
+                "math-cordic.js": 7.268
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.09867,
+                "3d-cube.js": 1.17467,
+                "access-fannkuch.js": 1.98,
+                "access-nbody.js": 1.808,
+                "bitops-bitwise-and.js": 10.728,
+                "math-partial-sums.js": 2.948,
+                "controlflow-recursive.js": 1.24,
+                "bitops-bits-in-byte.js": 0.941333,
+                "access-binary-trees.js": 1.3,
+                "bitops-3bit-bits-in-byte.js": 0.582667,
+                "string-fasta.js": 4.94933,
+                "math-cordic.js": 2.52933
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 76,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 96,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.2573,
+                "function-empty.js": 31.672,
+                "function-excess-args.js": 68.308,
+                "function-closure.js": 5.91467,
+                "function-missing-args.js": 69.0693,
+                "loop-sum.js": 40.8067,
+                "loop-empty-resolve.js": 4.53333,
+                "function-correct-args.js": 99.2293,
+                "function-sum.js": 46.152
+            },
+            "duktape": {
+                "loop-empty.js": 80.3027,
+                "function-empty.js": 50.2733,
+                "function-excess-args.js": 40.092,
+                "function-closure.js": 20.848,
+                "function-missing-args.js": 38.5133,
+                "loop-sum.js": 95.736,
+                "loop-empty-resolve.js": 9.556,
+                "function-correct-args.js": 39.8573,
+                "function-sum.js": 32.9067
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-24.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "b3b87add02f42eac1df89320ac08b760a58abfa1",
+            "size": 194252
+        },
+        "duktape": {
+            "version": "dabddfb6f8df5a9ccf44908055fefbc74c3a5643",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.872,
+                "3d-cube.js": 5.82533,
+                "access-fannkuch.js": 14.0027,
+                "access-nbody.js": 5.87333,
+                "bitops-bitwise-and.js": 4.05067,
+                "math-partial-sums.js": 2.852,
+                "controlflow-recursive.js": 3.62133,
+                "bitops-bits-in-byte.js": 6.60133,
+                "access-binary-trees.js": 3.10667,
+                "bitops-3bit-bits-in-byte.js": 4.62133,
+                "string-fasta.js": 29.0347,
+                "math-cordic.js": 7.26933
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.10267,
+                "3d-cube.js": 1.18133,
+                "access-fannkuch.js": 1.97733,
+                "access-nbody.js": 1.81333,
+                "bitops-bitwise-and.js": 10.732,
+                "math-partial-sums.js": 2.94667,
+                "controlflow-recursive.js": 1.24,
+                "bitops-bits-in-byte.js": 0.948,
+                "access-binary-trees.js": 1.30133,
+                "bitops-3bit-bits-in-byte.js": 0.585333,
+                "string-fasta.js": 4.94667,
+                "math-cordic.js": 2.52533
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 76,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 96,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.1907,
+                "function-empty.js": 31.656,
+                "function-excess-args.js": 68.3493,
+                "function-closure.js": 5.91733,
+                "function-missing-args.js": 69.1347,
+                "loop-sum.js": 40.8133,
+                "loop-empty-resolve.js": 4.536,
+                "function-correct-args.js": 99.2427,
+                "function-sum.js": 46.0933
+            },
+            "duktape": {
+                "loop-empty.js": 80.2773,
+                "function-empty.js": 50.2373,
+                "function-excess-args.js": 40.056,
+                "function-closure.js": 20.8573,
+                "function-missing-args.js": 38.5093,
+                "loop-sum.js": 95.7973,
+                "loop-empty-resolve.js": 9.57333,
+                "function-correct-args.js": 39.84,
+                "function-sum.js": 32.9573
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-25.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "e4843ece763cd4f977d98eaf6f68148ba1ee50fd",
+            "size": 198352
+        },
+        "duktape": {
+            "version": "64560f815f1bb762460d02a8df0cac2f93d07eaf",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.81067,
+                "3d-cube.js": 5.78933,
+                "access-fannkuch.js": 14.14,
+                "access-nbody.js": 5.94667,
+                "bitops-bitwise-and.js": 4.13867,
+                "math-partial-sums.js": 2.83867,
+                "controlflow-recursive.js": 3.59867,
+                "bitops-bits-in-byte.js": 6.68267,
+                "access-binary-trees.js": 3.096,
+                "bitops-3bit-bits-in-byte.js": 4.67333,
+                "string-fasta.js": 28.672,
+                "math-cordic.js": 7.328
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.06533,
+                "3d-cube.js": 1.104,
+                "access-fannkuch.js": 1.816,
+                "access-nbody.js": 1.70667,
+                "bitops-bitwise-and.js": 10.284,
+                "math-partial-sums.js": 2.86133,
+                "controlflow-recursive.js": 1.21067,
+                "bitops-bits-in-byte.js": 0.849333,
+                "access-binary-trees.js": 1.284,
+                "bitops-3bit-bits-in-byte.js": 0.566667,
+                "string-fasta.js": 4.84,
+                "math-cordic.js": 2.36667
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 76,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 96,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.0827,
+                "function-empty.js": 31.8293,
+                "function-excess-args.js": 68.6413,
+                "function-closure.js": 5.81467,
+                "function-missing-args.js": 69.048,
+                "loop-sum.js": 41.196,
+                "loop-empty-resolve.js": 4.512,
+                "function-correct-args.js": 100.0,
+                "function-sum.js": 45.936
+            },
+            "duktape": {
+                "loop-empty.js": 76.6493,
+                "function-empty.js": 48.9467,
+                "function-excess-args.js": 38.7307,
+                "function-closure.js": 20.084,
+                "function-missing-args.js": 37.3213,
+                "loop-sum.js": 91.512,
+                "loop-empty-resolve.js": 9.104,
+                "function-correct-args.js": 38.396,
+                "function-sum.js": 31.9747
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-26.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "bf780ad3dc6fe336d6741a8cdc9d6d4f51f3e95e",
+            "size": 198328
+        },
+        "duktape": {
+            "version": "50171d671af34f2c403acf61c6dc83f2d2561e24",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.864,
+                "3d-cube.js": 5.8,
+                "access-fannkuch.js": 14.3773,
+                "access-nbody.js": 5.92933,
+                "bitops-bitwise-and.js": 4.13733,
+                "math-partial-sums.js": 2.84267,
+                "controlflow-recursive.js": 3.58933,
+                "bitops-bits-in-byte.js": 6.70133,
+                "access-binary-trees.js": 3.08667,
+                "bitops-3bit-bits-in-byte.js": 4.66,
+                "string-fasta.js": 28.9347,
+                "math-cordic.js": 7.35467
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.07733,
+                "3d-cube.js": 1.104,
+                "access-fannkuch.js": 1.824,
+                "access-nbody.js": 1.70533,
+                "bitops-bitwise-and.js": 10.3147,
+                "math-partial-sums.js": 2.87333,
+                "controlflow-recursive.js": 1.208,
+                "bitops-bits-in-byte.js": 0.857333,
+                "access-binary-trees.js": 1.28267,
+                "bitops-3bit-bits-in-byte.js": 0.566667,
+                "string-fasta.js": 4.82667,
+                "math-cordic.js": 2.368
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 76,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 96,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 60,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.3013,
+                "function-empty.js": 31.532,
+                "function-excess-args.js": 67.956,
+                "function-closure.js": 5.76933,
+                "function-missing-args.js": 68.6813,
+                "loop-sum.js": 41.9653,
+                "loop-empty-resolve.js": 4.54533,
+                "function-correct-args.js": 99.0587,
+                "function-sum.js": 45.6547
+            },
+            "duktape": {
+                "loop-empty.js": 76.5387,
+                "function-empty.js": 48.5947,
+                "function-excess-args.js": 38.568,
+                "function-closure.js": 20.1053,
+                "function-missing-args.js": 37.2773,
+                "loop-sum.js": 91.2093,
+                "loop-empty-resolve.js": 9.11333,
+                "function-correct-args.js": 38.2867,
+                "function-sum.js": 31.888
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-27.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "bf780ad3dc6fe336d6741a8cdc9d6d4f51f3e95e",
+            "size": 198328
+        },
+        "duktape": {
+            "version": "8b5bcca3cfab0ef9fff55422530e6e5a2d7eec04",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.88133,
+                "3d-cube.js": 5.796,
+                "access-fannkuch.js": 14.3467,
+                "access-nbody.js": 5.94,
+                "bitops-bitwise-and.js": 4.13333,
+                "math-partial-sums.js": 2.85333,
+                "controlflow-recursive.js": 3.58667,
+                "bitops-bits-in-byte.js": 6.70667,
+                "access-binary-trees.js": 3.10133,
+                "bitops-3bit-bits-in-byte.js": 4.656,
+                "string-fasta.js": 28.9267,
+                "math-cordic.js": 7.36933
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.06667,
+                "3d-cube.js": 1.10533,
+                "access-fannkuch.js": 1.81733,
+                "access-nbody.js": 1.69867,
+                "bitops-bitwise-and.js": 10.32,
+                "math-partial-sums.js": 2.87067,
+                "controlflow-recursive.js": 1.21333,
+                "bitops-bits-in-byte.js": 0.856,
+                "access-binary-trees.js": 1.28667,
+                "bitops-3bit-bits-in-byte.js": 0.561333,
+                "string-fasta.js": 4.832,
+                "math-cordic.js": 2.37867
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 52,
+                "3d-cube.js": 168,
+                "access-fannkuch.js": 48,
+                "access-nbody.js": 76,
+                "bitops-bitwise-and.js": 28,
+                "math-partial-sums.js": 40,
+                "controlflow-recursive.js": 224,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 96,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 60,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.4,
+                "function-empty.js": 31.5533,
+                "function-excess-args.js": 68.0027,
+                "function-closure.js": 5.76267,
+                "function-missing-args.js": 68.8507,
+                "loop-sum.js": 41.9147,
+                "loop-empty-resolve.js": 4.548,
+                "function-correct-args.js": 99.0587,
+                "function-sum.js": 45.676
+            },
+            "duktape": {
+                "loop-empty.js": 76.7093,
+                "function-empty.js": 48.948,
+                "function-excess-args.js": 38.708,
+                "function-closure.js": 20.2333,
+                "function-missing-args.js": 37.3493,
+                "loop-sum.js": 90.9467,
+                "loop-empty-resolve.js": 9.15467,
+                "function-correct-args.js": 38.4253,
+                "function-sum.js": 32.0293
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 24,
+                "function-empty.js": 24,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 24,
+                "loop-empty-resolve.js": 24,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-28.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "10e5f3530d1bce030ef1006c682735e389b8bcef",
+            "size": 198328
+        },
+        "duktape": {
+            "version": "dfc66cd923ac8185524647138c518f4dfae46163",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.20667,
+                "3d-cube.js": 3.768,
+                "access-fannkuch.js": 10.156,
+                "access-nbody.js": 4.74933,
+                "bitops-bitwise-and.js": 4.192,
+                "math-partial-sums.js": 2.576,
+                "controlflow-recursive.js": 3.15333,
+                "bitops-bits-in-byte.js": 4.40933,
+                "access-binary-trees.js": 2.81867,
+                "bitops-3bit-bits-in-byte.js": 3.27067,
+                "string-fasta.js": 27.6907,
+                "math-cordic.js": 4.84933
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.05867,
+                "3d-cube.js": 1.10933,
+                "access-fannkuch.js": 1.81467,
+                "access-nbody.js": 1.696,
+                "bitops-bitwise-and.js": 10.3,
+                "math-partial-sums.js": 2.88133,
+                "controlflow-recursive.js": 1.22133,
+                "bitops-bits-in-byte.js": 0.848,
+                "access-binary-trees.js": 1.30133,
+                "bitops-3bit-bits-in-byte.js": 0.557333,
+                "string-fasta.js": 4.83333,
+                "math-cordic.js": 2.35867
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 40,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 40.192,
+                "function-empty.js": 29.8107,
+                "function-excess-args.js": 64.968,
+                "function-closure.js": 5.21467,
+                "function-missing-args.js": 64.6507,
+                "loop-sum.js": 42.6293,
+                "loop-empty-resolve.js": 4.62933,
+                "function-correct-args.js": 92.8987,
+                "function-sum.js": 43.9893
+            },
+            "duktape": {
+                "loop-empty.js": 76.5493,
+                "function-empty.js": 49.4,
+                "function-excess-args.js": 38.8493,
+                "function-closure.js": 20.2453,
+                "function-missing-args.js": 37.4987,
+                "loop-sum.js": 91.0907,
+                "loop-empty-resolve.js": 9.10667,
+                "function-correct-args.js": 38.6453,
+                "function-sum.js": 32.2707
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 28,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 28,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-29.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "a00079e8ff203e1a373ed0ada152bdcac37fc90c",
+            "size": 194232
+        },
+        "duktape": {
+            "version": "589b96fc9bba5996b143b6459414ab8456abd6d4",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.188,
+                "3d-cube.js": 3.72667,
+                "access-fannkuch.js": 9.93467,
+                "access-nbody.js": 4.66,
+                "bitops-bitwise-and.js": 4.17867,
+                "math-partial-sums.js": 2.57333,
+                "controlflow-recursive.js": 3.176,
+                "bitops-bits-in-byte.js": 4.47867,
+                "access-binary-trees.js": 2.82133,
+                "bitops-3bit-bits-in-byte.js": 3.32133,
+                "string-fasta.js": 27.8453,
+                "math-cordic.js": 4.896
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.05867,
+                "3d-cube.js": 1.11067,
+                "access-fannkuch.js": 1.82533,
+                "access-nbody.js": 1.70667,
+                "bitops-bitwise-and.js": 10.2733,
+                "math-partial-sums.js": 2.876,
+                "controlflow-recursive.js": 1.21733,
+                "bitops-bits-in-byte.js": 0.848,
+                "access-binary-trees.js": 1.30667,
+                "bitops-3bit-bits-in-byte.js": 0.564,
+                "string-fasta.js": 4.83733,
+                "math-cordic.js": 2.36667
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 36,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 40.2973,
+                "function-empty.js": 31.3387,
+                "function-excess-args.js": 66.4893,
+                "function-closure.js": 5.35467,
+                "function-missing-args.js": 66.096,
+                "loop-sum.js": 42.3813,
+                "loop-empty-resolve.js": 4.65467,
+                "function-correct-args.js": 94.284,
+                "function-sum.js": 45.1453
+            },
+            "duktape": {
+                "loop-empty.js": 76.5573,
+                "function-empty.js": 49.392,
+                "function-excess-args.js": 38.8667,
+                "function-closure.js": 20.2667,
+                "function-missing-args.js": 37.5067,
+                "loop-sum.js": 91.032,
+                "loop-empty-resolve.js": 9.108,
+                "function-correct-args.js": 38.664,
+                "function-sum.js": 32.2707
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 28,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 28,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-30.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "a00079e8ff203e1a373ed0ada152bdcac37fc90c",
+            "size": 194232
+        },
+        "duktape": {
+            "version": "8bc77c5ca3a2a59dc8306ea7e6bcf6d5463d645f",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.19333,
+                "3d-cube.js": 3.73867,
+                "access-fannkuch.js": 9.95733,
+                "access-nbody.js": 4.66533,
+                "bitops-bitwise-and.js": 4.18267,
+                "math-partial-sums.js": 2.57067,
+                "controlflow-recursive.js": 3.17867,
+                "bitops-bits-in-byte.js": 4.484,
+                "access-binary-trees.js": 2.82533,
+                "bitops-3bit-bits-in-byte.js": 3.31733,
+                "string-fasta.js": 27.8453,
+                "math-cordic.js": 4.90267
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.05867,
+                "3d-cube.js": 1.10933,
+                "access-fannkuch.js": 1.82133,
+                "access-nbody.js": 1.72933,
+                "bitops-bitwise-and.js": 10.3333,
+                "math-partial-sums.js": 2.892,
+                "controlflow-recursive.js": 1.22933,
+                "bitops-bits-in-byte.js": 0.853333,
+                "access-binary-trees.js": 1.312,
+                "bitops-3bit-bits-in-byte.js": 0.561333,
+                "string-fasta.js": 4.84667,
+                "math-cordic.js": 2.388
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 36,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 40.2187,
+                "function-empty.js": 31.2347,
+                "function-excess-args.js": 66.456,
+                "function-closure.js": 5.37067,
+                "function-missing-args.js": 66.0053,
+                "loop-sum.js": 42.2627,
+                "loop-empty-resolve.js": 4.65333,
+                "function-correct-args.js": 94.192,
+                "function-sum.js": 45.12
+            },
+            "duktape": {
+                "loop-empty.js": 76.7293,
+                "function-empty.js": 49.772,
+                "function-excess-args.js": 39.3213,
+                "function-closure.js": 20.292,
+                "function-missing-args.js": 37.7653,
+                "loop-sum.js": 91.5947,
+                "loop-empty-resolve.js": 9.13467,
+                "function-correct-args.js": 39.0187,
+                "function-sum.js": 32.5347
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 28,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 28,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-08-31.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "a26c45421988d138a01408ecfefb80816e3bcf81",
+            "size": 194232
+        },
+        "duktape": {
+            "version": "95681fbe0d5bd548c9ea918d10eb5a4daa7df96d",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.18933,
+                "3d-cube.js": 3.74,
+                "access-fannkuch.js": 9.92,
+                "access-nbody.js": 4.66,
+                "bitops-bitwise-and.js": 4.19333,
+                "math-partial-sums.js": 2.57333,
+                "controlflow-recursive.js": 3.18133,
+                "bitops-bits-in-byte.js": 4.48667,
+                "access-binary-trees.js": 2.82667,
+                "bitops-3bit-bits-in-byte.js": 3.32267,
+                "string-fasta.js": 27.7667,
+                "math-cordic.js": 4.908
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.06933,
+                "3d-cube.js": 1.11867,
+                "access-fannkuch.js": 1.808,
+                "access-nbody.js": 1.724,
+                "bitops-bitwise-and.js": 10.644,
+                "math-partial-sums.js": 2.99067,
+                "controlflow-recursive.js": 1.26533,
+                "bitops-bits-in-byte.js": 0.850667,
+                "access-binary-trees.js": 1.31467,
+                "bitops-3bit-bits-in-byte.js": 0.557333,
+                "string-fasta.js": 4.92267,
+                "math-cordic.js": 2.46133
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 36,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 40.764,
+                "function-empty.js": 31.32,
+                "function-excess-args.js": 66.4547,
+                "function-closure.js": 5.34667,
+                "function-missing-args.js": 66.1093,
+                "loop-sum.js": 42.3773,
+                "loop-empty-resolve.js": 4.708,
+                "function-correct-args.js": 94.272,
+                "function-sum.js": 45.268
+            },
+            "duktape": {
+                "loop-empty.js": 79.004,
+                "function-empty.js": 50.3947,
+                "function-excess-args.js": 39.7,
+                "function-closure.js": 20.4093,
+                "function-missing-args.js": 38.4667,
+                "loop-sum.js": 95.6813,
+                "loop-empty-resolve.js": 9.42933,
+                "function-correct-args.js": 39.512,
+                "function-sum.js": 32.7507
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 28,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 28,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-09-01.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "a26c45421988d138a01408ecfefb80816e3bcf81",
+            "size": 194232
+        },
+        "duktape": {
+            "version": "95681fbe0d5bd548c9ea918d10eb5a4daa7df96d",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.19867,
+                "3d-cube.js": 3.75333,
+                "access-fannkuch.js": 9.93867,
+                "access-nbody.js": 4.668,
+                "bitops-bitwise-and.js": 4.19733,
+                "math-partial-sums.js": 2.57733,
+                "controlflow-recursive.js": 3.18667,
+                "bitops-bits-in-byte.js": 4.50933,
+                "access-binary-trees.js": 2.83067,
+                "bitops-3bit-bits-in-byte.js": 3.33067,
+                "string-fasta.js": 27.6893,
+                "math-cordic.js": 4.908
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.06933,
+                "3d-cube.js": 1.12133,
+                "access-fannkuch.js": 1.79867,
+                "access-nbody.js": 1.72267,
+                "bitops-bitwise-and.js": 10.588,
+                "math-partial-sums.js": 2.98,
+                "controlflow-recursive.js": 1.26533,
+                "bitops-bits-in-byte.js": 0.849333,
+                "access-binary-trees.js": 1.30933,
+                "bitops-3bit-bits-in-byte.js": 0.56,
+                "string-fasta.js": 4.90933,
+                "math-cordic.js": 2.46133
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 36,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 144,
+                "3d-cube.js": 188,
+                "access-fannkuch.js": 148,
+                "access-nbody.js": 156,
+                "bitops-bitwise-and.js": 144,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 184,
+                "bitops-bits-in-byte.js": 144,
+                "access-binary-trees.js": 208,
+                "bitops-3bit-bits-in-byte.js": 144,
+                "string-fasta.js": 156,
+                "math-cordic.js": 148
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 40.712,
+                "function-empty.js": 31.3,
+                "function-excess-args.js": 66.3573,
+                "function-closure.js": 5.34667,
+                "function-missing-args.js": 66.104,
+                "loop-sum.js": 42.2333,
+                "loop-empty-resolve.js": 4.69867,
+                "function-correct-args.js": 94.3267,
+                "function-sum.js": 45.276
+            },
+            "duktape": {
+                "loop-empty.js": 79.0093,
+                "function-empty.js": 50.352,
+                "function-excess-args.js": 39.632,
+                "function-closure.js": 20.3333,
+                "function-missing-args.js": 38.452,
+                "loop-sum.js": 95.7187,
+                "loop-empty-resolve.js": 9.41067,
+                "function-correct-args.js": 39.468,
+                "function-sum.js": 32.7947
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 28,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 28,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 140,
+                "function-empty.js": 144,
+                "function-excess-args.js": 144,
+                "function-closure.js": 472,
+                "function-missing-args.js": 144,
+                "loop-sum.js": 140,
+                "loop-empty-resolve.js": 140,
+                "function-correct-args.js": 144,
+                "function-sum.js": 144
+            }
+        }
+    }
+}

benchmark/data/2015-09-02.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "a26c45421988d138a01408ecfefb80816e3bcf81",
+            "size": 194232
+        },
+        "duktape": {
+            "version": "cbb85c1c99736b22a2f336f8a863d176e20089c9",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.20533,
+                "3d-cube.js": 3.74133,
+                "access-fannkuch.js": 9.94133,
+                "access-nbody.js": 4.664,
+                "bitops-bitwise-and.js": 4.188,
+                "math-partial-sums.js": 2.57467,
+                "controlflow-recursive.js": 3.176,
+                "bitops-bits-in-byte.js": 4.48933,
+                "access-binary-trees.js": 2.82933,
+                "bitops-3bit-bits-in-byte.js": 3.324,
+                "string-fasta.js": 27.708,
+                "math-cordic.js": 4.90933
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.08267,
+                "3d-cube.js": 1.12533,
+                "access-fannkuch.js": 1.82667,
+                "access-nbody.js": 1.77067,
+                "bitops-bitwise-and.js": 10.896,
+                "math-partial-sums.js": 3.02267,
+                "controlflow-recursive.js": 1.24133,
+                "bitops-bits-in-byte.js": 0.833333,
+                "access-binary-trees.js": 1.312,
+                "bitops-3bit-bits-in-byte.js": 0.552,
+                "string-fasta.js": 4.96267,
+                "math-cordic.js": 2.48667
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 36,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 36,
+                "string-fasta.js": 52,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 152,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 152,
+                "access-nbody.js": 160,
+                "bitops-bitwise-and.js": 148,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 192,
+                "bitops-bits-in-byte.js": 148,
+                "access-binary-trees.js": 216,
+                "bitops-3bit-bits-in-byte.js": 148,
+                "string-fasta.js": 160,
+                "math-cordic.js": 152
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 40.76,
+                "function-empty.js": 31.2413,
+                "function-excess-args.js": 66.4693,
+                "function-closure.js": 5.36267,
+                "function-missing-args.js": 66.1213,
+                "loop-sum.js": 42.3547,
+                "loop-empty-resolve.js": 4.708,
+                "function-correct-args.js": 94.296,
+                "function-sum.js": 45.2467
+            },
+            "duktape": {
+                "loop-empty.js": 80.4693,
+                "function-empty.js": 50.7293,
+                "function-excess-args.js": 39.8867,
+                "function-closure.js": 20.6187,
+                "function-missing-args.js": 38.8387,
+                "loop-sum.js": 96.9093,
+                "loop-empty-resolve.js": 9.564,
+                "function-correct-args.js": 39.796,
+                "function-sum.js": 32.96
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 28,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 28,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 144,
+                "function-empty.js": 148,
+                "function-excess-args.js": 148,
+                "function-closure.js": 476,
+                "function-missing-args.js": 148,
+                "loop-sum.js": 144,
+                "loop-empty-resolve.js": 144,
+                "function-correct-args.js": 148,
+                "function-sum.js": 148
+            }
+        }
+    }
+}

benchmark/data/2015-09-03.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "5a09ff2d36d983354df04f526e619e5c3ff22825",
+            "size": 194244
+        },
+        "duktape": {
+            "version": "cbb85c1c99736b22a2f336f8a863d176e20089c9",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.168,
+                "3d-cube.js": 3.74133,
+                "access-fannkuch.js": 10.0507,
+                "access-nbody.js": 4.684,
+                "bitops-bitwise-and.js": 4.12533,
+                "math-partial-sums.js": 2.52,
+                "controlflow-recursive.js": 3.17067,
+                "bitops-bits-in-byte.js": 4.42133,
+                "access-binary-trees.js": 2.81067,
+                "bitops-3bit-bits-in-byte.js": 3.288,
+                "string-fasta.js": 27.7827,
+                "math-cordic.js": 4.84667
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.084,
+                "3d-cube.js": 1.12667,
+                "access-fannkuch.js": 1.828,
+                "access-nbody.js": 1.76533,
+                "bitops-bitwise-and.js": 10.8867,
+                "math-partial-sums.js": 3.01867,
+                "controlflow-recursive.js": 1.24133,
+                "bitops-bits-in-byte.js": 0.844,
+                "access-binary-trees.js": 1.31333,
+                "bitops-3bit-bits-in-byte.js": 0.552,
+                "string-fasta.js": 4.96267,
+                "math-cordic.js": 2.47733
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 36,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 40,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 152,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 152,
+                "access-nbody.js": 160,
+                "bitops-bitwise-and.js": 148,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 192,
+                "bitops-bits-in-byte.js": 148,
+                "access-binary-trees.js": 216,
+                "bitops-3bit-bits-in-byte.js": 148,
+                "string-fasta.js": 160,
+                "math-cordic.js": 152
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.872,
+                "function-empty.js": 29.7347,
+                "function-excess-args.js": 65.4187,
+                "function-closure.js": 5.252,
+                "function-missing-args.js": 64.7933,
+                "loop-sum.js": 42.06,
+                "loop-empty-resolve.js": 4.57867,
+                "function-correct-args.js": 93.34,
+                "function-sum.js": 44.3213
+            },
+            "duktape": {
+                "loop-empty.js": 80.4213,
+                "function-empty.js": 50.6827,
+                "function-excess-args.js": 39.8933,
+                "function-closure.js": 20.648,
+                "function-missing-args.js": 38.864,
+                "loop-sum.js": 96.8747,
+                "loop-empty-resolve.js": 9.564,
+                "function-correct-args.js": 39.8173,
+                "function-sum.js": 32.9587
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 32,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 32,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 144,
+                "function-empty.js": 148,
+                "function-excess-args.js": 148,
+                "function-closure.js": 476,
+                "function-missing-args.js": 148,
+                "loop-sum.js": 144,
+                "loop-empty-resolve.js": 144,
+                "function-correct-args.js": 148,
+                "function-sum.js": 148
+            }
+        }
+    }
+}

benchmark/data/2015-09-04.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "5a09ff2d36d983354df04f526e619e5c3ff22825",
+            "size": 194244
+        },
+        "duktape": {
+            "version": "565dd9e0a04a83b18384a426142d7b0c3bfb18b9",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.18,
+                "3d-cube.js": 3.73733,
+                "access-fannkuch.js": 10.048,
+                "access-nbody.js": 4.67467,
+                "bitops-bitwise-and.js": 4.12933,
+                "math-partial-sums.js": 2.52,
+                "controlflow-recursive.js": 3.17467,
+                "bitops-bits-in-byte.js": 4.42,
+                "access-binary-trees.js": 2.80667,
+                "bitops-3bit-bits-in-byte.js": 3.28933,
+                "string-fasta.js": 27.8507,
+                "math-cordic.js": 4.84533
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.07067,
+                "3d-cube.js": 1.12267,
+                "access-fannkuch.js": 1.81733,
+                "access-nbody.js": 1.688,
+                "bitops-bitwise-and.js": 10.368,
+                "math-partial-sums.js": 2.928,
+                "controlflow-recursive.js": 1.24267,
+                "bitops-bits-in-byte.js": 0.841333,
+                "access-binary-trees.js": 1.292,
+                "bitops-3bit-bits-in-byte.js": 0.554667,
+                "string-fasta.js": 4.92,
+                "math-cordic.js": 2.47067
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 36,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 40,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 152,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 152,
+                "access-nbody.js": 160,
+                "bitops-bitwise-and.js": 148,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 192,
+                "bitops-bits-in-byte.js": 148,
+                "access-binary-trees.js": 216,
+                "bitops-3bit-bits-in-byte.js": 148,
+                "string-fasta.js": 160,
+                "math-cordic.js": 152
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.9907,
+                "function-empty.js": 29.7133,
+                "function-excess-args.js": 65.444,
+                "function-closure.js": 5.256,
+                "function-missing-args.js": 64.7373,
+                "loop-sum.js": 41.948,
+                "loop-empty-resolve.js": 4.60133,
+                "function-correct-args.js": 93.276,
+                "function-sum.js": 44.3293
+            },
+            "duktape": {
+                "loop-empty.js": 76.0667,
+                "function-empty.js": 49.1147,
+                "function-excess-args.js": 38.7933,
+                "function-closure.js": 20.288,
+                "function-missing-args.js": 37.5787,
+                "loop-sum.js": 91.8787,
+                "loop-empty-resolve.js": 9.06267,
+                "function-correct-args.js": 38.6813,
+                "function-sum.js": 32.092
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 32,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 32,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 144,
+                "function-empty.js": 148,
+                "function-excess-args.js": 148,
+                "function-closure.js": 476,
+                "function-missing-args.js": 148,
+                "loop-sum.js": 144,
+                "loop-empty-resolve.js": 144,
+                "function-correct-args.js": 148,
+                "function-sum.js": 148
+            }
+        }
+    }
+}

benchmark/data/2015-09-05.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "5a09ff2d36d983354df04f526e619e5c3ff22825",
+            "size": 194244
+        },
+        "duktape": {
+            "version": "b492c79f2c3a1f2e54086ea5a7a1b5cb01596a65",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.17867,
+                "3d-cube.js": 3.73067,
+                "access-fannkuch.js": 10.0467,
+                "access-nbody.js": 4.67067,
+                "bitops-bitwise-and.js": 4.128,
+                "math-partial-sums.js": 2.516,
+                "controlflow-recursive.js": 3.184,
+                "bitops-bits-in-byte.js": 4.42667,
+                "access-binary-trees.js": 2.804,
+                "bitops-3bit-bits-in-byte.js": 3.288,
+                "string-fasta.js": 27.8933,
+                "math-cordic.js": 4.84933
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.07067,
+                "3d-cube.js": 1.11733,
+                "access-fannkuch.js": 1.816,
+                "access-nbody.js": 1.688,
+                "bitops-bitwise-and.js": 10.38,
+                "math-partial-sums.js": 2.93067,
+                "controlflow-recursive.js": 1.248,
+                "bitops-bits-in-byte.js": 0.84,
+                "access-binary-trees.js": 1.292,
+                "bitops-3bit-bits-in-byte.js": 0.552,
+                "string-fasta.js": 4.90667,
+                "math-cordic.js": 2.46933
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 36,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 40,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 152,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 152,
+                "access-nbody.js": 160,
+                "bitops-bitwise-and.js": 148,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 192,
+                "bitops-bits-in-byte.js": 148,
+                "access-binary-trees.js": 216,
+                "bitops-3bit-bits-in-byte.js": 148,
+                "string-fasta.js": 160,
+                "math-cordic.js": 152
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.9173,
+                "function-empty.js": 29.668,
+                "function-excess-args.js": 65.3573,
+                "function-closure.js": 5.25867,
+                "function-missing-args.js": 64.7613,
+                "loop-sum.js": 42.06,
+                "loop-empty-resolve.js": 4.59067,
+                "function-correct-args.js": 93.216,
+                "function-sum.js": 44.2347
+            },
+            "duktape": {
+                "loop-empty.js": 75.952,
+                "function-empty.js": 49.1613,
+                "function-excess-args.js": 38.8573,
+                "function-closure.js": 20.228,
+                "function-missing-args.js": 37.484,
+                "loop-sum.js": 92.02,
+                "loop-empty-resolve.js": 9.10133,
+                "function-correct-args.js": 38.7547,
+                "function-sum.js": 32.08
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 32,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 32,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 144,
+                "function-empty.js": 148,
+                "function-excess-args.js": 148,
+                "function-closure.js": 476,
+                "function-missing-args.js": 148,
+                "loop-sum.js": 144,
+                "loop-empty-resolve.js": 144,
+                "function-correct-args.js": 148,
+                "function-sum.js": 148
+            }
+        }
+    }
+}

benchmark/data/2015-09-06.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "5a09ff2d36d983354df04f526e619e5c3ff22825",
+            "size": 194244
+        },
+        "duktape": {
+            "version": "e2ab21201fc23c26f6a371ea08e79133e88221c9",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.15867,
+                "3d-cube.js": 3.73467,
+                "access-fannkuch.js": 10.0547,
+                "access-nbody.js": 4.62133,
+                "bitops-bitwise-and.js": 4.13067,
+                "math-partial-sums.js": 2.516,
+                "controlflow-recursive.js": 3.17467,
+                "bitops-bits-in-byte.js": 4.42667,
+                "access-binary-trees.js": 2.80133,
+                "bitops-3bit-bits-in-byte.js": 3.284,
+                "string-fasta.js": 27.872,
+                "math-cordic.js": 4.848
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.06667,
+                "3d-cube.js": 1.112,
+                "access-fannkuch.js": 1.82,
+                "access-nbody.js": 1.684,
+                "bitops-bitwise-and.js": 10.3627,
+                "math-partial-sums.js": 2.92667,
+                "controlflow-recursive.js": 1.248,
+                "bitops-bits-in-byte.js": 0.837333,
+                "access-binary-trees.js": 1.29467,
+                "bitops-3bit-bits-in-byte.js": 0.552,
+                "string-fasta.js": 4.896,
+                "math-cordic.js": 2.46533
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 36,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 40,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 152,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 152,
+                "access-nbody.js": 160,
+                "bitops-bitwise-and.js": 148,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 192,
+                "bitops-bits-in-byte.js": 148,
+                "access-binary-trees.js": 216,
+                "bitops-3bit-bits-in-byte.js": 148,
+                "string-fasta.js": 160,
+                "math-cordic.js": 152
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.9267,
+                "function-empty.js": 29.6867,
+                "function-excess-args.js": 65.4787,
+                "function-closure.js": 5.248,
+                "function-missing-args.js": 64.7707,
+                "loop-sum.js": 42.032,
+                "loop-empty-resolve.js": 4.6,
+                "function-correct-args.js": 93.3573,
+                "function-sum.js": 44.2933
+            },
+            "duktape": {
+                "loop-empty.js": 76.0547,
+                "function-empty.js": 49.1267,
+                "function-excess-args.js": 38.824,
+                "function-closure.js": 20.2853,
+                "function-missing-args.js": 37.5893,
+                "loop-sum.js": 91.8747,
+                "loop-empty-resolve.js": 9.11067,
+                "function-correct-args.js": 38.6787,
+                "function-sum.js": 32.0907
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 32,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 32,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 144,
+                "function-empty.js": 148,
+                "function-excess-args.js": 148,
+                "function-closure.js": 476,
+                "function-missing-args.js": 148,
+                "loop-sum.js": 144,
+                "loop-empty-resolve.js": 144,
+                "function-correct-args.js": 148,
+                "function-sum.js": 148
+            }
+        }
+    }
+}

benchmark/data/2015-09-07.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "5a09ff2d36d983354df04f526e619e5c3ff22825",
+            "size": 194244
+        },
+        "duktape": {
+            "version": "146fb34eab8f844bed999b0f188c0d3a08d86b11",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.17333,
+                "3d-cube.js": 3.73333,
+                "access-fannkuch.js": 10.0413,
+                "access-nbody.js": 4.65867,
+                "bitops-bitwise-and.js": 4.11867,
+                "math-partial-sums.js": 2.51867,
+                "controlflow-recursive.js": 3.176,
+                "bitops-bits-in-byte.js": 4.412,
+                "access-binary-trees.js": 2.80667,
+                "bitops-3bit-bits-in-byte.js": 3.28133,
+                "string-fasta.js": 27.8627,
+                "math-cordic.js": 4.84667
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.05467,
+                "3d-cube.js": 1.112,
+                "access-fannkuch.js": 1.81867,
+                "access-nbody.js": 1.67867,
+                "bitops-bitwise-and.js": 10.368,
+                "math-partial-sums.js": 2.908,
+                "controlflow-recursive.js": 1.23733,
+                "bitops-bits-in-byte.js": 0.84,
+                "access-binary-trees.js": 1.292,
+                "bitops-3bit-bits-in-byte.js": 0.553333,
+                "string-fasta.js": 4.91067,
+                "math-cordic.js": 2.448
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 36,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 40,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 152,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 152,
+                "access-nbody.js": 160,
+                "bitops-bitwise-and.js": 148,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 192,
+                "bitops-bits-in-byte.js": 148,
+                "access-binary-trees.js": 216,
+                "bitops-3bit-bits-in-byte.js": 148,
+                "string-fasta.js": 160,
+                "math-cordic.js": 152
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 39.8893,
+                "function-empty.js": 29.74,
+                "function-excess-args.js": 65.3933,
+                "function-closure.js": 5.264,
+                "function-missing-args.js": 64.6907,
+                "loop-sum.js": 42.0533,
+                "loop-empty-resolve.js": 4.60267,
+                "function-correct-args.js": 93.2973,
+                "function-sum.js": 44.112
+            },
+            "duktape": {
+                "loop-empty.js": 75.9253,
+                "function-empty.js": 48.592,
+                "function-excess-args.js": 38.3813,
+                "function-closure.js": 20.44,
+                "function-missing-args.js": 37.2347,
+                "loop-sum.js": 91.824,
+                "loop-empty-resolve.js": 9.06,
+                "function-correct-args.js": 38.3333,
+                "function-sum.js": 31.78
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 32,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 32,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 144,
+                "function-empty.js": 148,
+                "function-excess-args.js": 148,
+                "function-closure.js": 476,
+                "function-missing-args.js": 148,
+                "loop-sum.js": 144,
+                "loop-empty-resolve.js": 144,
+                "function-correct-args.js": 148,
+                "function-sum.js": 148
+            }
+        }
+    }
+}

benchmark/data/2015-09-08.json

@@ -0,0 +1,124 @@
+{
+    "info": {
+        "jerryscript": {
+            "version": "ed321da8c190507fb5a1eb1405bbdb0653e86825",
+            "size": 194244
+        },
+        "duktape": {
+            "version": "a9003d1838aed9fac3bac490941e5a21d7069417",
+            "size": 165824
+        }
+    },
+    "sunspider-1.0.2": {
+        "performance": {
+            "jerryscript": {
+                "math-spectral-norm.js": 3.148,
+                "3d-cube.js": 3.70667,
+                "access-fannkuch.js": 9.82533,
+                "access-nbody.js": 4.64,
+                "bitops-bitwise-and.js": 4.03067,
+                "math-partial-sums.js": 2.51333,
+                "controlflow-recursive.js": 3.12933,
+                "bitops-bits-in-byte.js": 4.39333,
+                "access-binary-trees.js": 2.776,
+                "bitops-3bit-bits-in-byte.js": 3.256,
+                "string-fasta.js": 27.7893,
+                "math-cordic.js": 4.82133
+            },
+            "duktape": {
+                "math-spectral-norm.js": 1.06533,
+                "3d-cube.js": 1.11733,
+                "access-fannkuch.js": 1.81467,
+                "access-nbody.js": 1.68933,
+                "bitops-bitwise-and.js": 10.4813,
+                "math-partial-sums.js": 2.94933,
+                "controlflow-recursive.js": 1.248,
+                "bitops-bits-in-byte.js": 0.84,
+                "access-binary-trees.js": 1.292,
+                "bitops-3bit-bits-in-byte.js": 0.549333,
+                "string-fasta.js": 4.924,
+                "math-cordic.js": 2.46267
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "math-spectral-norm.js": 48,
+                "3d-cube.js": 132,
+                "access-fannkuch.js": 36,
+                "access-nbody.js": 64,
+                "bitops-bitwise-and.js": 32,
+                "math-partial-sums.js": 36,
+                "controlflow-recursive.js": 212,
+                "bitops-bits-in-byte.js": 32,
+                "access-binary-trees.js": 88,
+                "bitops-3bit-bits-in-byte.js": 40,
+                "string-fasta.js": 56,
+                "math-cordic.js": 48
+            },
+            "duktape": {
+                "math-spectral-norm.js": 152,
+                "3d-cube.js": 192,
+                "access-fannkuch.js": 152,
+                "access-nbody.js": 160,
+                "bitops-bitwise-and.js": 148,
+                "math-partial-sums.js": 148,
+                "controlflow-recursive.js": 192,
+                "bitops-bits-in-byte.js": 148,
+                "access-binary-trees.js": 216,
+                "bitops-3bit-bits-in-byte.js": 148,
+                "string-fasta.js": 160,
+                "math-cordic.js": 152
+            }
+        }
+    },
+    "ubench": {
+        "performance": {
+            "jerryscript": {
+                "loop-empty.js": 38.6813,
+                "function-empty.js": 28.9587,
+                "function-excess-args.js": 64.3267,
+                "function-closure.js": 5.196,
+                "function-missing-args.js": 63.836,
+                "loop-sum.js": 41.1787,
+                "loop-empty-resolve.js": 4.48133,
+                "function-correct-args.js": 92.2947,
+                "function-sum.js": 43.544
+            },
+            "duktape": {
+                "loop-empty.js": 76.8507,
+                "function-empty.js": 49.2813,
+                "function-excess-args.js": 38.7987,
+                "function-closure.js": 20.484,
+                "function-missing-args.js": 37.5693,
+                "loop-sum.js": 92.92,
+                "loop-empty-resolve.js": 9.17467,
+                "function-correct-args.js": 38.7213,
+                "function-sum.js": 31.976
+            }
+        },
+        "memory": {
+            "jerryscript": {
+                "loop-empty.js": 32,
+                "function-empty.js": 32,
+                "function-excess-args.js": 32,
+                "function-closure.js": 32,
+                "function-missing-args.js": 32,
+                "loop-sum.js": 32,
+                "loop-empty-resolve.js": 32,
+                "function-correct-args.js": 32,
+                "function-sum.js": 32
+            },
+            "duktape": {
+                "loop-empty.js": 144,
+                "function-empty.js": 148,
+                "function-excess-args.js": 148,
+                "function-closure.js": 476,
+                "function-missing-args.js": 148,
+                "loop-sum.js": 144,
+                "loop-empty-resolve.js": 144,
+                "function-correct-args.js": 148,
+                "function-sum.js": 148
+            }
+        }
+    }
+}