wasm 0.0.1 → 0.0.2

data/assets/mruby/include/mruby/dump.h

@@ -0,0 +1,196 @@
+/*
+** mruby/dump.h - mruby binary dumper (mrbc binary format)
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_DUMP_H
+#define MRUBY_DUMP_H
+
+#include <mruby.h>
+#include <mruby/irep.h>
+#include "common.h"
+
+/**
+ * Dumping compiled mruby script.
+ */
+MRB_BEGIN_DECL
+
+#define DUMP_DEBUG_INFO 1
+#define DUMP_ENDIAN_BIG 2
+#define DUMP_ENDIAN_LIL 4
+#define DUMP_ENDIAN_NAT 6
+#define DUMP_ENDIAN_MASK 6
+
+int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size);
+#ifndef MRB_DISABLE_STDIO
+int mrb_dump_irep_binary(mrb_state*, mrb_irep*, uint8_t, FILE*);
+int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, uint8_t flags, FILE *f, const char *initname);
+mrb_irep *mrb_read_irep_file(mrb_state*, FILE*);
+MRB_API mrb_value mrb_load_irep_file(mrb_state*,FILE*);
+MRB_API mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*);
+#endif
+MRB_API mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
+
+/* dump/load error code
+ *
+ * NOTE: MRB_DUMP_GENERAL_FAILURE is caused by
+ * unspecified issues like malloc failed.
+ */
+#define MRB_DUMP_OK                     0
+#define MRB_DUMP_GENERAL_FAILURE      (-1)
+#define MRB_DUMP_WRITE_FAULT          (-2)
+#define MRB_DUMP_READ_FAULT           (-3)
+#define MRB_DUMP_CRC_ERROR            (-4)
+#define MRB_DUMP_INVALID_FILE_HEADER  (-5)
+#define MRB_DUMP_INVALID_IREP         (-6)
+#define MRB_DUMP_INVALID_ARGUMENT     (-7)
+
+/* null symbol length */
+#define MRB_DUMP_NULL_SYM_LEN         0xFFFF
+
+/* Rite Binary File header */
+#define RITE_BINARY_IDENT              "RITE"
+#define RITE_BINARY_IDENT_LIL          "ETIR"
+#define RITE_BINARY_FORMAT_VER         "0004"
+#define RITE_COMPILER_NAME             "MATZ"
+#define RITE_COMPILER_VERSION          "0000"
+
+#define RITE_VM_VER                    "0000"
+
+#define RITE_BINARY_EOF                "END\0"
+#define RITE_SECTION_IREP_IDENT        "IREP"
+#define RITE_SECTION_LINENO_IDENT      "LINE"
+#define RITE_SECTION_DEBUG_IDENT       "DBG\0"
+#define RITE_SECTION_LV_IDENT          "LVAR"
+
+#define MRB_DUMP_DEFAULT_STR_LEN      128
+#define MRB_DUMP_ALIGNMENT            sizeof(uint32_t)
+
+/* binary header */
+struct rite_binary_header {
+  uint8_t binary_ident[4];    /* Binary Identifier */
+  uint8_t binary_version[4];  /* Binary Format Version */
+  uint8_t binary_crc[2];      /* Binary CRC */
+  uint8_t binary_size[4];     /* Binary Size */
+  uint8_t compiler_name[4];   /* Compiler name */
+  uint8_t compiler_version[4];
+};
+
+/* section header */
+#define RITE_SECTION_HEADER \
+  uint8_t section_ident[4]; \
+  uint8_t section_size[4]
+
+struct rite_section_header {
+  RITE_SECTION_HEADER;
+};
+
+struct rite_section_irep_header {
+  RITE_SECTION_HEADER;
+
+  uint8_t rite_version[4];    /* Rite Instruction Specification Version */
+};
+
+struct rite_section_lineno_header {
+  RITE_SECTION_HEADER;
+};
+
+struct rite_section_debug_header {
+  RITE_SECTION_HEADER;
+};
+
+struct rite_section_lv_header {
+  RITE_SECTION_HEADER;
+};
+
+#define RITE_LV_NULL_MARK              UINT16_MAX
+
+struct rite_binary_footer {
+  RITE_SECTION_HEADER;
+};
+
+static inline int
+bigendian_p()
+{
+  int i;
+  char *p;
+
+  i = 1;
+  p = (char*)&i;
+  return p[0]?0:1;
+}
+
+static inline size_t
+uint8_to_bin(uint8_t s, uint8_t *bin)
+{
+  *bin = s;
+  return sizeof(uint8_t);
+}
+
+static inline size_t
+uint16_to_bin(uint16_t s, uint8_t *bin)
+{
+  *bin++ = (s >> 8) & 0xff;
+  *bin   = s & 0xff;
+  return sizeof(uint16_t);
+}
+
+static inline size_t
+uint32_to_bin(uint32_t l, uint8_t *bin)
+{
+  *bin++ = (l >> 24) & 0xff;
+  *bin++ = (l >> 16) & 0xff;
+  *bin++ = (l >> 8) & 0xff;
+  *bin   = l & 0xff;
+  return sizeof(uint32_t);
+}
+
+static inline size_t
+uint32l_to_bin(uint32_t l, uint8_t *bin)
+{
+  bin[3] = (l >> 24) & 0xff;
+  bin[2] = (l >> 16) & 0xff;
+  bin[1] = (l >> 8) & 0xff;
+  bin[0] = l & 0xff;
+  return sizeof(uint32_t);
+}
+
+static inline uint32_t
+bin_to_uint32(const uint8_t *bin)
+{
+  return (uint32_t)bin[0] << 24 |
+         (uint32_t)bin[1] << 16 |
+         (uint32_t)bin[2] << 8  |
+         (uint32_t)bin[3];
+}
+
+static inline uint32_t
+bin_to_uint32l(const uint8_t *bin)
+{
+  return (uint32_t)bin[3] << 24 |
+         (uint32_t)bin[2] << 16 |
+         (uint32_t)bin[1] << 8  |
+         (uint32_t)bin[0];
+}
+
+static inline uint16_t
+bin_to_uint16(const uint8_t *bin)
+{
+  return (uint16_t)bin[0] << 8 |
+         (uint16_t)bin[1];
+}
+
+static inline uint8_t
+bin_to_uint8(const uint8_t *bin)
+{
+  return (uint8_t)bin[0];
+}
+
+MRB_END_DECL
+
+/** @internal crc.c */
+uint16_t
+calc_crc_16_ccitt(const uint8_t *src, size_t nbytes, uint16_t crc);
+
+#endif  /* MRUBY_DUMP_H */

data/assets/mruby/include/mruby/error.h

@@ -0,0 +1,75 @@
+/*
+** mruby/error.h - Exception class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_ERROR_H
+#define MRUBY_ERROR_H
+
+#include "common.h"
+
+/**
+ * MRuby error handling.
+ */
+MRB_BEGIN_DECL
+
+struct RException {
+  MRB_OBJECT_HEADER;
+  struct iv_tbl *iv;
+};
+
+#define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v))
+
+MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg);
+MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str);
+#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
+MRB_API mrb_value mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
+MRB_API mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc);
+MRB_API mrb_value mrb_get_backtrace(mrb_state *mrb);
+MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, const char *fmt, ...);
+
+/* declaration for fail method */
+MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
+
+struct RBreak {
+  MRB_OBJECT_HEADER;
+  struct RProc *proc;
+  mrb_value val;
+};
+
+/**
+ * Protect
+ *
+ * @mrbgem mruby-error
+ */
+MRB_API mrb_value mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state);
+
+/**
+ * Ensure
+ *
+ * @mrbgem mruby-error
+ */
+MRB_API mrb_value mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
+                             mrb_func_t ensure, mrb_value e_data);
+
+/**
+ * Rescue
+ *
+ * @mrbgem mruby-error
+ */
+MRB_API mrb_value mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
+                             mrb_func_t rescue, mrb_value r_data);
+
+/**
+ * Rescue exception
+ *
+ * @mrbgem mruby-error
+ */
+MRB_API mrb_value mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
+                                        mrb_func_t rescue, mrb_value r_data,
+                                        mrb_int len, struct RClass **classes);
+
+MRB_END_DECL
+
+#endif  /* MRUBY_ERROR_H */

data/assets/mruby/include/mruby/gc.h

@@ -0,0 +1,91 @@
+/*
+** mruby/gc.h - garbage collector for mruby
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_GC_H
+#define MRUBY_GC_H
+
+#include "common.h"
+
+/**
+ * Uncommon memory management stuffs.
+ */
+MRB_BEGIN_DECL
+
+
+struct mrb_state;
+
+#define MRB_EACH_OBJ_OK 0
+#define MRB_EACH_OBJ_BREAK 1
+typedef int (mrb_each_object_callback)(struct mrb_state *mrb, struct RBasic *obj, void *data);
+void mrb_objspace_each_objects(struct mrb_state *mrb, mrb_each_object_callback *callback, void *data);
+MRB_API void mrb_free_context(struct mrb_state *mrb, struct mrb_context *c);
+
+#ifndef MRB_GC_ARENA_SIZE
+#define MRB_GC_ARENA_SIZE 100
+#endif
+
+typedef enum {
+  MRB_GC_STATE_ROOT = 0,
+  MRB_GC_STATE_MARK,
+  MRB_GC_STATE_SWEEP
+} mrb_gc_state;
+
+/* Disable MSVC warning "C4200: nonstandard extension used: zero-sized array
+ * in struct/union" when in C++ mode */
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4200)
+#endif
+
+typedef struct mrb_heap_page {
+  struct RBasic *freelist;
+  struct mrb_heap_page *prev;
+  struct mrb_heap_page *next;
+  struct mrb_heap_page *free_next;
+  struct mrb_heap_page *free_prev;
+  mrb_bool old:1;
+  void *objects[];
+} mrb_heap_page;
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+typedef struct mrb_gc {
+  mrb_heap_page *heaps;                /* heaps for GC */
+  mrb_heap_page *sweeps;
+  mrb_heap_page *free_heaps;
+  size_t live; /* count of live objects */
+#ifdef MRB_GC_FIXED_ARENA
+  struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */
+#else
+  struct RBasic **arena;                   /* GC protection array */
+  int arena_capa;
+#endif
+  int arena_idx;
+
+  mrb_gc_state state; /* state of gc */
+  int current_white_part; /* make white object by white_part */
+  struct RBasic *gray_list; /* list of gray objects to be traversed incrementally */
+  struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */
+  size_t live_after_mark;
+  size_t threshold;
+  int interval_ratio;
+  int step_ratio;
+  mrb_bool iterating     :1;
+  mrb_bool disabled      :1;
+  mrb_bool full          :1;
+  mrb_bool generational  :1;
+  mrb_bool out_of_memory :1;
+  size_t majorgc_old_threshold;
+} mrb_gc;
+
+MRB_API mrb_bool
+mrb_object_dead_p(struct mrb_state *mrb, struct RBasic *object);
+
+MRB_END_DECL
+
+#endif  /* MRUBY_GC_H */

data/assets/mruby/include/mruby/hash.h

@@ -0,0 +1,182 @@
+/*
+** mruby/hash.h - Hash class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_HASH_H
+#define MRUBY_HASH_H
+
+#include "common.h"
+#include <mruby/khash.h>
+
+/**
+ * Hash class
+ */
+MRB_BEGIN_DECL
+
+struct RHash {
+  MRB_OBJECT_HEADER;
+  struct iv_tbl *iv;
+  struct kh_ht *ht;
+};
+
+#define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
+#define mrb_hash_value(p)  mrb_obj_value((void*)(p))
+
+MRB_API mrb_value mrb_hash_new_capa(mrb_state*, mrb_int);
+
+/*
+ * Initializes a new hash.
+ *
+ * Equivalent to:
+ *
+ *      Hash.new
+ *
+ * @param mrb The mruby state reference.
+ * @return The initialized hash.
+ */
+MRB_API mrb_value mrb_hash_new(mrb_state *mrb);
+
+/*
+ * Sets a keys and values to hashes.
+ *
+ * Equivalent to:
+ *
+ *      hash[key] = val
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @param key The key to set.
+ * @param val The value to set.
+ * @return The value.
+ */
+MRB_API void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
+
+/*
+ * Gets a value from a key. If the key is not found, the default of the
+ * hash is used.
+ *
+ * Equivalent to:
+ *
+ *     hash[key]
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @param key The key to get.
+ * @return The found value.
+ */
+MRB_API mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
+
+/*
+ * Gets a value from a key. If the key is not found, the default parameter is
+ * used.
+ *
+ * Equivalent to:
+ *
+ *     hash.hash_key?(key) ? hash[key] : def
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @param key The key to get.
+ * @param def The default value.
+ * @return The found value.
+ */
+MRB_API mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def);
+
+/*
+ * Deletes hash key and value pair.
+ *
+ * Equivalent to:
+ *
+ *     hash.delete(key)
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @param key The key to delete.
+ * @return The deleted value.
+ */
+MRB_API mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
+
+/*
+ * Gets an array of keys.
+ *
+ * Equivalent to:
+ *
+ *     hash.keys
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @return An array with the keys of the hash.
+ */
+MRB_API mrb_value mrb_hash_keys(mrb_state *mrb, mrb_value hash);
+MRB_API mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash);
+
+/*
+ * Check if the hash is empty
+ *
+ * Equivalent to:
+ *
+ *     hash.empty?
+ *
+ * @param mrb The mruby state reference.
+ * @param self The target hash.
+ * @return True if the hash is empty, false otherwise.
+ */
+MRB_API mrb_value mrb_hash_empty_p(mrb_state *mrb, mrb_value self);
+
+/*
+ * Gets an array of values.
+ *
+ * Equivalent to:
+ *
+ *     hash.values
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @return An array with the values of the hash.
+ */
+MRB_API mrb_value mrb_hash_values(mrb_state *mrb, mrb_value hash);
+
+/*
+ * Clears the hash.
+ *
+ * Equivalent to:
+ *
+ *     hash.clear
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @return The hash
+ */
+MRB_API mrb_value mrb_hash_clear(mrb_state *mrb, mrb_value hash);
+
+/* declaration of struct kh_ht */
+/* be careful when you touch the internal */
+typedef struct {
+  mrb_value v;
+  mrb_int n;
+} mrb_hash_value;
+
+KHASH_DECLARE(ht, mrb_value, mrb_hash_value, TRUE)
+
+/* RHASH_TBL allocates st_table if not available. */
+#define RHASH(obj)   ((struct RHash*)(mrb_ptr(obj)))
+#define RHASH_TBL(h)          (RHASH(h)->ht)
+#define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone"))
+#define RHASH_PROCDEFAULT(h)  RHASH_IFNONE(h)
+MRB_API struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
+
+#define MRB_HASH_DEFAULT      1
+#define MRB_HASH_PROC_DEFAULT 2
+#define MRB_RHASH_DEFAULT_P(h) (RHASH(h)->flags & MRB_HASH_DEFAULT)
+#define MRB_RHASH_PROCDEFAULT_P(h) (RHASH(h)->flags & MRB_HASH_PROC_DEFAULT)
+
+/* GC functions */
+void mrb_gc_mark_hash(mrb_state*, struct RHash*);
+size_t mrb_gc_mark_hash_size(mrb_state*, struct RHash*);
+void mrb_gc_free_hash(mrb_state*, struct RHash*);
+
+MRB_END_DECL
+
+#endif  /* MRUBY_HASH_H */