Support multiple primary functions in a single snapshot. (#1797)

This patch adds an extension to snapshots which allows storing multiple position independent primary functions in a single snapshot data. A new application called jerry-snapshot is added to the project to manage snapshots. Currently the only option is merging snapshots. JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com
2017-10-12 14:43:32 +02:00
parent 9f0cf9ef1c
commit fe26674752
17 changed files with 1280 additions and 462 deletions
@@ -4236,6 +4236,85 @@ main (void)

 - [jerry_init](#jerry_init)
 - [jerry_cleanup](#jerry_cleanup)
+- [jerry_exec_snapshot_at](#jerry_exec_snapshot_at)
+- [jerry_parse_and_save_snapshot](#jerry_parse_and_save_snapshot)
+
+
+## jerry_exec_snapshot_at
+
+**Summary**
+
+Execute the selected snapshot function from the specified buffer.
+
+Same function as [jerry_exec_snapshot](#jerry_exec_snapshot) except
+the executed function index can be specified.
+
+*Note*: Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+is no longer needed.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerry_exec_snapshot_at (const uint32_t *snapshot_p,
+                        size_t snapshot_size,
+                        size_t func_index,
+                        bool copy_bytecode);
+```
+
+- `snapshot_p` - pointer to snapshot
+- `snapshot_size` - size of snapshot
+- `func_index` - index of executed function
+- `copy_bytecode` - flag, indicating whether the passed snapshot buffer should be copied to the
+   engine's memory. If set the engine should not reference the buffer after the function returns
+   (in this case, the passed buffer could be freed after the call). Otherwise (if the flag is not
+   set) - the buffer could only be freed after the engine stops (i.e. after call to jerry_cleanup).
+- return value
+  - result of bytecode, if run was successful
+  - thrown error, otherwise
+
+**Example**
+
+[doctest]: # ()
+
+```c
+#include <string.h>
+#include "jerryscript.h"
+
+int
+main (void)
+{
+  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_init (JERRY_INIT_EMPTY);
+  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));
+  jerry_cleanup ();
+
+  jerry_init (JERRY_INIT_EMPTY);
+
+  jerry_value_t res = jerry_exec_snapshot_at (global_mode_snapshot_buffer,
+                                              global_mode_snapshot_size,
+                                              0,
+                                              false);
+
+  jerry_release_value (res);
+
+  jerry_cleanup ();
+  return 0;
+}
+```
+
+**See also**
+
+- [jerry_init](#jerry_init)
+- [jerry_cleanup](#jerry_cleanup)
+- [jerry_exec_snapshot](#jerry_exec_snapshot)
 - [jerry_parse_and_save_snapshot](#jerry_parse_and_save_snapshot)