Support static snapshots. (#2239)

Unlike normal snapshots, no part of a static snapshot is loaded into
the RAM when executed from ROM. Static snapshots rely heavily on
external magic strings.

JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com

1 files changed, 147 insertions, 0 deletions

diff --git a/docs/02.API-REFERENCE.md b/docs/02.API-REFERENCE.md
index dec8efa0..30840ae4 100644
--- a/docs/02.API-REFERENCE.md
+++ b/docs/02.API-REFERENCE.md
@@ -4736,6 +4736,77 @@ main (void)
 - [jerry_init](#jerry_init)
 - [jerry_cleanup](#jerry_cleanup)
 - [jerry_exec_snapshot](#jerry_exec_snapshot)
+- [jerry_parse_and_save_static_snapshot](#jerry_parse_and_save_static_snapshot)
+
+
+## jerry_parse_and_save_static_snapshot
+
+**Summary**
+
+Generate static snapshot from the specified source code.
+
+Unlike normal snaphots static snaphots are fully executed from ROM. Not
+even their header is loaded into the RAM. However they can only depend
+on magic strings and 28 bit integer numbers. Regular expression literals
+are not supported as well.
+
+**Prototype**
+
+```c
+size_t
+jerry_parse_and_save_static_snapshot (const jerry_char_t *source_p,
+                                      size_t source_size,
+                                      bool is_for_global,
+                                      bool is_strict,
+                                      uint32_t *buffer_p,
+                                      size_t buffer_size);
+```
+
+- `source_p` - script source, it must be a valid utf8 string.
+- `source_size` - script source size, in bytes.
+- `is_for_global` - snapshot would be executed as global (true) or eval (false).
+- `is_strict` - strict mode
+- `buffer_p` - buffer to save snapshot to.
+- `buffer_size` - the buffer's size.
+- return value
+  - the size of snapshot, if it was generated succesfully (i.e. there are no syntax errors in source
+    code, buffer size is sufficient, only magic strings are used by the snapshot, and snapshot support
+    is enabled in current configuration through JERRY_ENABLE_SNAPSHOT_SAVE)
+  - 0 otherwise.
+
+**Example**
+
+[doctest]: # ()
+
+```c
+#include <string.h>
+#include "jerryscript.h"
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  static uint32_t global_mode_snapshot_buffer[256];
+  const jerry_char_t *code_to_snapshot_p = (const jerry_char_t *) "(function () { return 'string'; }) ();";
+
+  size_t global_mode_snapshot_size = jerry_parse_and_save_static_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 ();
+}
+```
+
+**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)
 
 
 ## jerry_parse_and_save_function_snapshot
@@ -4808,6 +4879,82 @@ main (void)
 - [jerry_init](#jerry_init)
 - [jerry_cleanup](#jerry_cleanup)
 - [jerry_load_function_snapshot_at](#jerry_load_function_snapshot_at)
+- [jerry_parse_and_save_static_function_snapshot](#jerry_parse_and_save_static_function_snapshot)
+
+
+## jerry_parse_and_save_static_function_snapshot
+
+**Summary**
+
+Generate static function snapshot from the specified source code
+with the given function body and arguments.
+
+Unlike normal snaphots static snaphots are fully executed from ROM. Not
+even their header is loaded into the RAM. However they can only depend
+on magic strings and 28 bit integer numbers. Regular expression literals
+are not supported as well.
+
+**Prototype**
+
+```c
+size_t
+jerry_parse_and_save_static_function_snapshot (const jerry_char_t *source_p,
+                                               size_t source_size,
+                                               const jerry_char_t *args_p,
+                                               size_t args_size,
+                                               bool is_strict,
+                                               uint32_t *buffer_p,
+                                               size_t buffer_size)
+```
+
+- `source_p` - script source, it must be a valid utf8 string.
+- `source_size` - script source size, in bytes.
+- `args_p` - function arguments, it must be a valid utf8 string.
+- `args_size` - function argument size, in bytes.
+- `is_strict` - strict mode
+- `buffer_p` - buffer to save snapshot to.
+- `buffer_size` - the buffer's size.
+- return value
+  - the size of snapshot, if it was generated succesfully (i.e. there are no syntax errors in source
+    code, buffer size is sufficient, only magic strings are used by the snapshot, and snapshot support
+    is enabled in current configuration through JERRY_ENABLE_SNAPSHOT_SAVE)
+  - 0 otherwise.
+
+**Example**
+
+[doctest]: # ()
+
+```c
+#include <string.h>
+#include "jerryscript.h"
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  static uint32_t func_snapshot_buffer[256];
+  const jerry_char_t *args_p = (const jerry_char_t *) "string, bind";
+  const jerry_char_t *src_p = (const jerry_char_t *) "return bind(string)";
+
+  size_t func_snapshot_size = jerry_parse_and_save_static_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));
+
+  jerry_cleanup ();
+}
+```
+
+**See also**
+
+- [jerry_init](#jerry_init)
+- [jerry_cleanup](#jerry_cleanup)
+- [jerry_load_function_snapshot_at](#jerry_load_function_snapshot_at)
+- [jerry_parse_and_save_function_snapshot](#jerry_parse_and_save_function_snapshot)
 
 
 ## jerry_exec_snapshot