nifs.c

Include dependency graph for nifs.c:

Defines

_GNU_SOURCE

MAX_NIF_NAME_LEN 260

FLOAT_BUF_SIZE 64

RAISE(a, b)

ctx->x[0] = (a); \

ctx->x[1] = (b); \

return

term_invalid_term();

MAX(x, y) (((x) > (y)) ? (x) : (y))

NOT_FOUND (0xFF)

DECLARE_MATH_NIF_FUN(moniker)     static term nif_math_##moniker(Context *ctx, int argc, term argv[]);

DEFINE_MATH_NIF(moniker)     static const struct Nif

math_##moniker##_nif =  \

{                                               \

.base.type =

NIFFunctionType

,               \

.nif_ptr = nif_math_##moniker               \

};

IF_HAVE_OPEN_CLOSE(expr) NULL

IF_HAVE_MKFIFO(expr) NULL

IF_HAVE_UNLINK(expr) NULL

IF_HAVE_CLOCK_SETTIME_OR_SETTIMEOFDAY(expr) NULL

IF_HAVE_OPENDIR_READDIR_CLOSEDIR(expr) NULL

DEFINE_UNARY_MATH_OP(moniker)     static avm_float_t math_##moniker(avm_float_t

x)                    \

{                                                                   \

return moniker(x);                                              \

}                                                                   \

\

static

term nif_math_##moniker(Context *ctx, int argc, term

argv[]) \

{                                                                   \

UNUSED(argc);                                                   \         VALIDATE_VALUE(argv[0], term_is_number);                        \         term t = math_unary_op

(ctx, argv[0], math_##moniker);           \

if (

term_is_atom(t)) {                                          \             RAISE_ERROR

(t);                                             \

} else {                                                        \

return t;                                                   \

}                                                               \

}

DEFINE_BINARY_MATH_OP(moniker)     static avm_float_t math_##moniker(avm_float_t x, avm_float_t

y)     \

{                                                                   \

return moniker(x, y);                                           \

}                                                                   \

\

static

term nif_math_##moniker(Context *ctx, int argc, term

argv[]) \

{                                                                   \

UNUSED(argc);                                                   \         VALIDATE_VALUE(argv[0], term_is_number);                        \         VALIDATE_VALUE(argv[1], term_is_number);                        \         term t = math_binary_op

(ctx, argv[0], argv[1], math_##moniker); \

if (

term_is_atom(t)) {                                          \             RAISE_ERROR

(t);                                             \

} else {                                                        \

return t;                                                   \

}                                                               \

}

Typedefs

typedef void *(*context_iterator)(Context *ctx, void *accum)

typedef avm_float_t (*unary_math_f)(avm_float_t x)

typedef avm_float_t (*binary_math_f)(avm_float_t x, avm_float_t y)

Functions

static NativeHandlerResult process_echo_mailbox(Context *ctx)

static NativeHandlerResult process_console_mailbox(Context *ctx)

static term make_list_from_utf8_buf(const uint8_t *buf, size_t buf_len, Context *ctx)

static term make_list_from_ascii_buf(const uint8_t *buf, size_t len, Context *ctx)

static term binary_to_atom(Context *ctx, int argc, term argv[], int create_new)

static term list_to_atom(Context *ctx, int argc, term argv[], int create_new)

static term nif_binary_at_2(Context *ctx, int argc, term argv[])

static term nif_binary_copy(Context *ctx, int argc, term argv[])

static term nif_binary_first_1(Context *ctx, int argc, term argv[])

static term nif_binary_last_1(Context *ctx, int argc, term argv[])

static term nif_binary_part_3(Context *ctx, int argc, term argv[])

static term nif_binary_split(Context *ctx, int argc, term argv[])

static term nif_calendar_system_time_to_universal_time_2(Context *ctx, int argc, term argv[])

static term nif_erlang_delete_element_2(Context *ctx, int argc, term argv[])

static term nif_erlang_atom_to_binary(Context *ctx, int argc, term argv[])

static term nif_erlang_atom_to_list_1(Context *ctx, int argc, term argv[])

static term nif_erlang_binary_to_atom_2(Context *ctx, int argc, term argv[])

static term nif_erlang_binary_to_float_1(Context *ctx, int argc, term argv[])

static term nif_erlang_binary_to_integer(Context *ctx, int argc, term argv[])

static term nif_erlang_binary_to_list_1(Context *ctx, int argc, term argv[])

static term nif_erlang_binary_to_existing_atom_2(Context *ctx, int argc, term argv[])

static term nif_erlang_concat_2(Context *ctx, int argc, term argv[])

static term nif_erlang_display_1(Context *ctx, int argc, term argv[])

static term nif_erlang_erase_1(Context *ctx, int argc, term argv[])

static term nif_erlang_error(Context *ctx, int argc, term argv[])

static term nif_erlang_exit(Context *ctx, int argc, term argv[])

static term nif_erlang_make_fun_3(Context *ctx, int argc, term argv[])

static term nif_erlang_make_ref_0(Context *ctx, int argc, term argv[])

static term nif_erlang_make_tuple_2(Context *ctx, int argc, term argv[])

static term nif_erlang_insert_element_3(Context *ctx, int argc, term argv[])

static term nif_erlang_integer_to_binary_2(Context *ctx, int argc, term argv[])

static term nif_erlang_integer_to_list_2(Context *ctx, int argc, term argv[])

static term nif_erlang_is_process_alive_1(Context *ctx, int argc, term argv[])

static term nif_erlang_link(Context *ctx, int argc, term argv[])

static term nif_erlang_float_to_binary(Context *ctx, int argc, term argv[])

static term nif_erlang_float_to_list(Context *ctx, int argc, term argv[])

static term nif_erlang_list_to_binary_1(Context *ctx, int argc, term argv[])

static term nif_erlang_list_to_integer(Context *ctx, int argc, term argv[])

static term nif_erlang_list_to_float_1(Context *ctx, int argc, term argv[])

static term nif_erlang_list_to_atom_1(Context *ctx, int argc, term argv[])

static term nif_erlang_list_to_existing_atom_1(Context *ctx, int argc, term argv[])

static term nif_erlang_monotonic_time_1(Context *ctx, int argc, term argv[])

static term nif_erlang_iolist_size_1(Context *ctx, int argc, term argv[])

static term nif_erlang_iolist_to_binary_1(Context *ctx, int argc, term argv[])

static term nif_erlang_open_port_2(Context *ctx, int argc, term argv[])

static term nif_erlang_register_2(Context *ctx, int argc, term argv[])

static term nif_erlang_unregister_1(Context *ctx, int argc, term argv[])

static term nif_erlang_send_2(Context *ctx, int argc, term argv[])

static term nif_erlang_setelement_3(Context *ctx, int argc, term argv[])

static term nif_erlang_spawn_opt(Context *ctx, int argc, term argv[])

static term nif_erlang_spawn_fun_opt(Context *ctx, int argc, term argv[])

static term nif_erlang_whereis_1(Context *ctx, int argc, term argv[])

static term nif_erlang_system_time_1(Context *ctx, int argc, term argv[])

static term nif_erlang_tuple_to_list_1(Context *ctx, int argc, term argv[])

static term nif_erlang_list_to_tuple_1(Context *ctx, int argc, term argv[])

static term nif_erlang_universaltime_0(Context *ctx, int argc, term argv[])

static term nif_erlang_localtime(Context *ctx, int argc, term argv[])

static term nif_erlang_timestamp_0(Context *ctx, int argc, term argv[])

static term nif_erts_debug_flat_size(Context *ctx, int argc, term argv[])

static term nif_erlang_process_flag(Context *ctx, int argc, term argv[])

static term nif_erlang_processes(Context *ctx, int argc, term argv[])

static term nif_erlang_process_info(Context *ctx, int argc, term argv[])

static term nif_erlang_put_2(Context *ctx, int argc, term argv[])

static term nif_erlang_system_info(Context *ctx, int argc, term argv[])

static term nif_erlang_system_flag(Context *ctx, int argc, term argv[])

static term nif_erlang_binary_to_term(Context *ctx, int argc, term argv[])

static term nif_erlang_term_to_binary(Context *ctx, int argc, term argv[])

static term nif_erlang_throw(Context *ctx, int argc, term argv[])

static term nif_erlang_raise(Context *ctx, int argc, term argv[])

static term nif_ets_new(Context *ctx, int argc, term argv[])

static term nif_ets_insert(Context *ctx, int argc, term argv[])

static term nif_ets_lookup(Context *ctx, int argc, term argv[])

static term nif_ets_lookup_element(Context *ctx, int argc, term argv[])

static term nif_ets_delete(Context *ctx, int argc, term argv[])

static term nif_erlang_pid_to_list(Context *ctx, int argc, term argv[])

static term nif_erlang_ref_to_list(Context *ctx, int argc, term argv[])

static term nif_erlang_fun_to_list(Context *ctx, int argc, term argv[])

static term nif_erlang_function_exported(Context *ctx, int argc, term argv[])

static term nif_erlang_garbage_collect(Context *ctx, int argc, term argv[])

static term nif_erlang_group_leader(Context *ctx, int argc, term argv[])

static term nif_erlang_get_module_info(Context *ctx, int argc, term argv[])

static term nif_erlang_memory(Context *ctx, int argc, term argv[])

static term nif_erlang_monitor(Context *ctx, int argc, term argv[])

static term nif_erlang_demonitor(Context *ctx, int argc, term argv[])

static term nif_erlang_unlink(Context *ctx, int argc, term argv[])

static term nif_atomvm_add_avm_pack_binary(Context *ctx, int argc, term argv[])

static term nif_atomvm_add_avm_pack_file(Context *ctx, int argc, term argv[])

static term nif_atomvm_close_avm_pack(Context *ctx, int argc, term argv[])

static term nif_atomvm_get_start_beam(Context *ctx, int argc, term argv[])

static term nif_atomvm_read_priv(Context *ctx, int argc, term argv[])

static term nif_console_print(Context *ctx, int argc, term argv[])

static term nif_base64_encode(Context *ctx, int argc, term argv[])

static term nif_base64_decode(Context *ctx, int argc, term argv[])

static term nif_base64_encode_to_string(Context *ctx, int argc, term argv[])

static term nif_base64_decode_to_string(Context *ctx, int argc, term argv[])

static term nif_code_all_available(Context *ctx, int argc, term argv[])

static term nif_code_all_loaded(Context *ctx, int argc, term argv[])

static term nif_code_load_abs(Context *ctx, int argc, term argv[])

static term nif_code_load_binary(Context *ctx, int argc, term argv[])

static term nif_code_ensure_loaded(Context *ctx, int argc, term argv[])

static term nif_lists_reverse(Context *ctx, int argc, term argv[])

static term nif_maps_from_keys(Context *ctx, int argc, term argv[])

static term nif_maps_next(Context *ctx, int argc, term argv[])

static term nif_unicode_characters_to_list(Context *ctx, int argc, term argv[])

static term nif_unicode_characters_to_binary(Context *ctx, int argc, term argv[])

static term nif_math_cos(Context *ctx, int argc, term argv[])

static term nif_math_acos(Context *ctx, int argc, term argv[])

static term nif_math_acosh(Context *ctx, int argc, term argv[])

static term nif_math_asin(Context *ctx, int argc, term argv[])

static term nif_math_asinh(Context *ctx, int argc, term argv[])

static term nif_math_atan(Context *ctx, int argc, term argv[])

static term nif_math_atan2(Context *ctx, int argc, term argv[])

static term nif_math_atanh(Context *ctx, int argc, term argv[])

static term nif_math_ceil(Context *ctx, int argc, term argv[])

static term nif_math_cosh(Context *ctx, int argc, term argv[])

static term nif_math_exp(Context *ctx, int argc, term argv[])

static term nif_math_floor(Context *ctx, int argc, term argv[])

static term nif_math_fmod(Context *ctx, int argc, term argv[])

static term nif_math_log(Context *ctx, int argc, term argv[])

static term nif_math_log10(Context *ctx, int argc, term argv[])

static term nif_math_log2(Context *ctx, int argc, term argv[])

static term nif_math_pow(Context *ctx, int argc, term argv[])

static term nif_math_sin(Context *ctx, int argc, term argv[])

static term nif_math_sinh(Context *ctx, int argc, term argv[])

static term nif_math_sqrt(Context *ctx, int argc, term argv[])

static term nif_math_tan(Context *ctx, int argc, term argv[])

static term nif_math_tanh(Context *ctx, int argc, term argv[])

const struct Nif *nifs_get(AtomString module, AtomString function, int arity)

static inline term make_maybe_boxed_int64(Context *ctx, avm_int64_t value)

static bool is_tagged_tuple(term t, term tag, int size)

static NativeHandlerResult process_console_message(Context *ctx, term msg)

static term do_spawn(Context *ctx, Context *new_ctx, term opts_term)

static term build_datetime_from_tm(Context *ctx, struct tm *broken_down_time)

static bool is_valid_float_string(const char *str, int len)

static term parse_float(Context *ctx, const char *buf, int len)

static size_t lltoa(avm_int64_t int_value, unsigned base, char *integer_string)

static int format_float(term value, int scientific, int decimals, int compact, char *out_buf, int outbuf_len)

int get_float_format_opts(term opts, int *scientific, int *decimals, int *compact)

static avm_int_t to_digit_index(avm_int_t character)

static term nif_erlang_process_flag_3(Context *ctx, Context *target, term flag, term value)

static void *nif_increment_context_count(Context *ctx, void *accum)

static void *nif_increment_port_count(Context *ctx, void *accum)

static void *nif_cons_context(Context *ctx, void *p)

static void *nif_iterate_processes(GlobalContext *glb, context_iterator fun, void *accum)

static size_t nif_num_processes(GlobalContext *glb)

static size_t nif_num_ports(GlobalContext *glb)

static term nif_list_processes(Context *ctx)

static inline bool is_ets_table_id(term t)

static void refc_binary_avm_pack_destructor(struct AVMPackData *obj, GlobalContext *global)

static term open_avm_error_tuple(Context *ctx, enum OpenAVMResult result)

static term base64_encode(Context *ctx, int argc, term argv[], bool return_binary)

static inline uint8_t find_index(uint8_t c)

static term base64_decode(Context *ctx, int argc, term argv[], bool return_binary)

static void *nif_code_all_available_fold(void *accum, const void *section_ptr, uint32_t section_size, const void *beam_ptr, uint32_t flags, const char *section_name)

static int sort_keys_uniq(term *keys, int size, GlobalContext *global)

static void maybe_clear_exceptions()

static term get_exception(avm_float_t f)

static term math_unary_op(Context *ctx, term x_term, unary_math_f f)

static term math_binary_op(Context *ctx, term x_term, term y_term, binary_math_f f)

static avm_float_t math_cos(avm_float_t x)

static avm_float_t math_acos(avm_float_t x)

static avm_float_t math_acosh(avm_float_t x)

static avm_float_t math_asin(avm_float_t x)

static avm_float_t math_asinh(avm_float_t x)

static avm_float_t math_atan(avm_float_t x)

static avm_float_t math_atan2(avm_float_t x, avm_float_t y)

static avm_float_t math_atanh(avm_float_t x)

static avm_float_t math_ceil(avm_float_t x)

static avm_float_t math_cosh(avm_float_t x)

static avm_float_t math_exp(avm_float_t x)

static avm_float_t math_floor(avm_float_t x)

static avm_float_t math_fmod(avm_float_t x, avm_float_t y)

static avm_float_t math_log(avm_float_t x)

static avm_float_t math_log10(avm_float_t x)

static avm_float_t math_log2(avm_float_t x)

static avm_float_t math_pow(avm_float_t x, avm_float_t y)

static avm_float_t math_sin(avm_float_t x)

static avm_float_t math_sinh(avm_float_t x)

static avm_float_t math_sqrt(avm_float_t x)

static avm_float_t math_tan(avm_float_t x)

static avm_float_t math_tanh(avm_float_t x)

Variables

static const char *const trace_calls_atom   = "\xB" "trace_calls"

static const char *const trace_call_args_atom   = "\xF" "trace_call_args"

static const char *const trace_returns_atom   = "\xD" "trace_returns"

static const char *const trace_send_atom   = "\xA" "trace_send"

static const char *const trace_receive_atom   = "\xD" "trace_receive"

static const struct Nif binary_at_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_binary_at_2}

static const struct Nif binary_copy_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_binary_copy}

static const struct Nif binary_first_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_binary_first_1}

static const struct Nif binary_last_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_binary_last_1}

static const struct Nif binary_part_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_binary_part_3}

static const struct Nif binary_split_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_binary_split}

static const struct Nif make_ref_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_make_ref_0}

static const struct Nif atom_to_binary_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_atom_to_binary}

static const struct Nif atom_to_list_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_atom_to_list_1}

static const struct Nif binary_to_atom_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_binary_to_atom_2}

static const struct Nif binary_to_float_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_binary_to_float_1}

static const struct Nif binary_to_integer_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_binary_to_integer}

static const struct Nif binary_to_list_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_binary_to_list_1}

static const struct Nif binary_to_existing_atom_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_binary_to_existing_atom_2}

static const struct Nif delete_element_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_delete_element_2}

static const struct Nif display_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_display_1}

static const struct Nif erase_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_erase_1}

static const struct Nif error_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_error}

static const struct Nif exit_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_exit}

static const struct Nif insert_element_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_insert_element_3}

static const struct Nif integer_to_binary_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_integer_to_binary_2}

static const struct Nif integer_to_list_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_integer_to_list_2}

static const struct Nif float_to_binary_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_float_to_binary}

static const struct Nif float_to_list_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_float_to_list}

static const struct Nif is_process_alive_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_is_process_alive_1}

static const struct Nif list_to_atom_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_list_to_atom_1}

static const struct Nif list_to_existing_atom_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_list_to_existing_atom_1}

static const struct Nif list_to_binary_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_list_to_binary_1}

static const struct Nif list_to_integer_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_list_to_integer}

static const struct Nif list_to_float_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_list_to_float_1}

static const struct Nif list_to_tuple_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_list_to_tuple_1}

static const struct Nif iolist_size_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_iolist_size_1}

static const struct Nif iolist_to_binary_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_iolist_to_binary_1}

static const struct Nif open_port_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_open_port_2}

static const struct Nif make_tuple_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_make_tuple_2}

static const struct Nif register_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_register_2}

static const struct Nif unregister_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_unregister_1}

static const struct Nif spawn_opt_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_spawn_opt}

static const struct Nif spawn_fun_opt_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_spawn_fun_opt}

static const struct Nif send_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_send_2}

static const struct Nif setelement_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_setelement_3}

static const struct Nif whereis_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_whereis_1}

static const struct Nif concat_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_concat_2}

static const struct Nif monotonic_time_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_monotonic_time_1}

static const struct Nif system_time_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_system_time_1}

static const struct Nif universaltime_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_universaltime_0}

static const struct Nif localtime_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_localtime}

static const struct Nif timestamp_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_timestamp_0}

static const struct Nif system_time_to_universal_time_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_calendar_system_time_to_universal_time_2}

static const struct Nif tuple_to_list_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_tuple_to_list_1}

static const struct Nif flat_size_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erts_debug_flat_size}

static const struct Nif process_flag_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_process_flag}

static const struct Nif processes_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_processes}

static const struct Nif process_info_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_process_info}

static const struct Nif put_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_put_2}

static const struct Nif system_info_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_system_info}

static const struct Nif system_flag_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_system_flag}

static const struct Nif binary_to_term_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_binary_to_term}

static const struct Nif term_to_binary_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_term_to_binary}

static const struct Nif throw_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_throw}

static const struct Nif pid_to_list_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_pid_to_list}

static const struct Nif ref_to_list_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_ref_to_list}

static const struct Nif fun_to_list_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_fun_to_list}

static const struct Nif function_exported_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_function_exported}

static const struct Nif garbage_collect_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_garbage_collect}

static const struct Nif make_fun_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_make_fun_3}

static const struct Nif memory_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_memory}

static const struct Nif monitor_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_monitor}

static const struct Nif demonitor_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_demonitor}

static const struct Nif link_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_link}

static const struct Nif unlink_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_unlink}

static const struct Nif group_leader_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_group_leader}

static const struct Nif get_module_info_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_get_module_info}

static const struct Nif raise_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_erlang_raise}

static const struct Nif ets_new_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_ets_new}

static const struct Nif ets_insert_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_ets_insert}

static const struct Nif ets_lookup_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_ets_lookup}

static const struct Nif ets_lookup_element_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_ets_lookup_element}

static const struct Nif ets_delete_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_ets_delete}

static const struct Nif atomvm_add_avm_pack_binary_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_atomvm_add_avm_pack_binary}

static const struct Nif atomvm_add_avm_pack_file_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_atomvm_add_avm_pack_file}

static const struct Nif atomvm_close_avm_pack_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_atomvm_close_avm_pack}

static const struct Nif atomvm_get_start_beam_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_atomvm_get_start_beam}

static const struct Nif atomvm_read_priv_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_atomvm_read_priv}

static const struct Nif console_print_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_console_print}

static const struct Nif base64_encode_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_base64_encode}

static const struct Nif base64_decode_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_base64_decode}

static const struct Nif base64_encode_to_string_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_base64_encode_to_string}

static const struct Nif base64_decode_to_string_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_base64_decode_to_string}

static const struct Nif code_all_available_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_code_all_available}

static const struct Nif code_all_loaded_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_code_all_loaded}

static const struct Nif code_load_abs_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_code_load_abs}

static const struct Nif code_load_binary_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_code_load_binary}

static const struct Nif code_ensure_loaded_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_code_ensure_loaded}

static const struct Nif lists_reverse_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_lists_reverse}

static const struct Nif maps_from_keys_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_maps_from_keys}

static const struct Nif maps_next_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_maps_next}

static const struct Nif unicode_characters_to_list_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_unicode_characters_to_list}

static const struct Nif unicode_characters_to_binary_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_unicode_characters_to_binary}

static const struct Nif math_cos_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_cos}

static const struct Nif math_acos_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_acos}

static const struct Nif math_acosh_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_acosh}

static const struct Nif math_asin_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_asin}

static const struct Nif math_asinh_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_asinh}

static const struct Nif math_atan_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_atan}

static const struct Nif math_atan2_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_atan2}

static const struct Nif math_atanh_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_atanh}

static const struct Nif math_ceil_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_ceil}

static const struct Nif math_cosh_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_cosh}

static const struct Nif math_exp_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_exp}

static const struct Nif math_floor_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_floor}

static const struct Nif math_fmod_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_fmod}

static const struct Nif math_log_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_log}

static const struct Nif math_log10_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_log10}

static const struct Nif math_log2_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_log2}

static const struct Nif math_pow_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_pow}

static const struct Nif math_sin_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_sin}

static const struct Nif math_sinh_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_sinh}

static const struct Nif math_sqrt_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_sqrt}

static const struct Nif math_tan_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_tan}

static const struct Nif math_tanh_nif = {.base.type = NIFFunctionType, .nif_ptr = nif_math_tanh}

static const struct AVMPackInfo refc_binary_avm_pack_info = {.destructor = refc_binary_avm_pack_destructor}

static char b64_table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

static const char *const embedded_atom   = "\x8" "embedded"

struct ContextAccumulator

Collaboration diagram for ContextAccumulator:

Public Members

Context *ctx

term result

struct RefcBinaryAVMPack

Collaboration diagram for RefcBinaryAVMPack:

Public Members

struct AVMPackData base

struct RefcBinary *refc

struct CodeAllAvailableAcc

Collaboration diagram for CodeAllAvailableAcc:

Public Members

Context *ctx

struct AVMPackData *avmpack_data

term result

size_t acc_count