Skip to content

Instantly share code, notes, and snippets.

@lihaochen910

lihaochen910/mruby.nim

Last active January 5, 2022 14:06
Show Gist options
  • Save lihaochen910/8069c3c912868309331b22ebc184009f to your computer and use it in GitHub Desktop.
Save lihaochen910/8069c3c912868309331b22ebc184009f to your computer and use it in GitHub Desktop.
Download ZIP
The bindings for mruby(3.0.0) to Nim.
Raw
mruby.nim
#
#* mruby - An embeddable Ruby implementation
#*
#* Copyright (c) mruby developers 2010-2021
#*
#* Permission is hereby granted, free of charge, to any person obtaining
#* a copy of this software and associated documentation files (the
#* "Software"), to deal in the Software without restriction, including
#* without limitation the rights to use, copy, modify, merge, publish,
#* distribute, sublicense, and/or sell copies of the Software, and to
#* permit persons to whom the Software is furnished to do so, subject to
#* the following conditions:
#*
#* The above copyright notice and this permission notice shall be
#* included in all copies or substantial portions of the Software.
#*
#* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
#* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
#* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
#* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
#* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
#* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
#* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#*
#* [ MIT license: https://www.opensource.org/licenses/mit-license.php ]
#
type va_list {.importc: "va_list", header: "<stdarg.h>".} = object
{.passL: "-lmruby".}
{.pragma: h, header: "<mruby.h>".}
{.pragma: hc, header: "<mruby/compile.h>".}
type
mrb_code* {.importc,h.} = uint8
mrb_aspec* {.importc,h.} = uint32
type
mrb_irep* {.importc, header: "<mruby/irep.h>".} = object # mruby/irep.h
type
mrb_sym* {.importc,h.} = uint32 # cshort # mruby/value.h
type
mrb_bool {.importc,h.} = uint8 # mruby/value.h
when not(defined(MRB_GC_ARENA_SIZE)):
const
MRB_GC_ARENA_SIZE* = 100
type
mrb_func_t* {.importc,h.} = proc (mrb: ptr mrb_state; a3: mrb_value): mrb_value
mrb_atexit_func* {.importc,h.} = proc (mrb: ptr mrb_state)
mrb_value* {.importc,h.} = object
iv_tbl {.importc,h.} = object # mruby/variable.c
# kh_mt {.importc,h.} = object
mt_tbl {.importc,h.} = object # mruby/class.c
# symbol_name {.importc, header: "<src/symbol.h>".} = object # src/symbol.c
# lit*: mrb_bool
# prew*: uint8
# slen*: uint16
# name*: cstring
RProc* {.importc,h.} = object
irep*: ptr mrb_irep # MRB_OBJECT_HEADER;
# union {
rfunc*: mrb_func_t # } body;
upper*: ref RProc
target_class*: ptr RClass # union {
env*: ptr REnv # } body;
mrb_allocf* = proc (mrb: ptr mrb_state; a3: pointer; a4: csize_t; ud: pointer): pointer {.cdecl.}
REnv* {.importc,h.} = object
stack*: ptr mrb_value # MRB_OBJECT_HEADER;
cxt*: mrb_context
mid*: mrb_sym
# cioff*: cint
RClass* {.importc,h.} = object
iv*: ptr iv_tbl # MRB_OBJECT_HEADER;
mt*: ptr mt_tbl
super*: ptr RClass
mrb_callinfo* {.importc,h.} = object
mid*: mrb_sym
argc*: cshort
acc*: cshort
rproc*: ptr RProc
stack*: ptr mrb_value
pc*: ptr mrb_code # current address on iseq of this proc
env*: ptr REnv # union {
target_class*: ptr RClass # } body;
mrb_fiber_state* {.importc,h.} = enum
MRB_FIBER_CREATED = 0, MRB_FIBER_RUNNING, MRB_FIBER_RESUMED,
MRB_FIBER_SUSPENDED, MRB_FIBER_TRANSFERRED, MRB_FIBER_TERMINATED
mrb_context* {.importc,h.} = object
prev*: ptr mrb_context
stbase*: ptr mrb_value # stack of virtual machine
stend*: ptr mrb_value
ci*: ptr mrb_callinfo
cibase*: ptr mrb_callinfo
ciend*: ptr mrb_callinfo
status*: mrb_fiber_state
vmexec*: mrb_bool
fib*: ptr RFiber
RObject* {.importc,h.} = object
iv*: ptr iv_tbl # MRB_OBJECT_HEADER;
RFiber* {.importc,h.} = object
cxt*: ptr mrb_context # MRB_OBJECT_HEADER;
RBasic* {.importc,h.} = object
mrb_gc_state* {.importc,h.} = enum
MRB_GC_STATE_ROOT = 0, MRB_GC_STATE_MARK, MRB_GC_STATE_SWEEP
mrb_heap_page = object
mrb_pool* {.importc,h.} = object
mrb_gc* {.importc,h.} = object
PState* = ptr mrb_state
mrb_state* {.importc,h.} = object
jmp*: pointer
allocf*: mrb_allocf # memory allocation function
allocf_ud*: pointer # auxiliary data of allocf
c*: ptr mrb_context
root_c*: ptr mrb_context
globals*: ptr iv_tbl # global variable table
exc*: ptr RObject # exception
top_self*: ptr RObject
object_class*: ptr RClass # Object class
class_class*: ptr RClass
module_class*: ptr RClass
proc_class*: ptr RClass
string_class*: ptr RClass
array_class*: ptr RClass
hash_class*: ptr RClass
range_class*: ptr RClass
when not(defined(MRB_NO_FLOAT)):
float_class*: ptr RClass
integer_class*: ptr RClass
true_class*: ptr RClass
false_class*: ptr RClass
nil_class*: ptr RClass
symbol_class*: ptr RClass
kernel_module*: ptr RClass
gc*: mrb_gc
heaps*: ptr mrb_heap_page # heaps for GC
sweeps*: ptr mrb_heap_page
free_heaps*: ptr mrb_heap_page
live*: csize_t # count of live objects
when defined(MRB_GC_FIXED_ARENA):
arena*: array[MRB_GC_ARENA_SIZE, ptr RBasic] # GC protection array
else:
arena*: ptr ptr RBasic # GC protection array
arena_capa*: cint ##endif
arena_idx*: cint
gc_state*: mrb_gc_state # state of gc
current_white_part*: cint # make white object by white_part
gray_list*: ptr RBasic # list of gray objects to be traversed incrementally
atomic_gray_list*: ptr RBasic # list of objects to be traversed atomically
gc_live_after_mark*: csize_t
gc_threshold*: csize_t
gc_interval_ratio*: cint
gc_step_ratio*: cint
gc_disabled*: mrb_bool #:1;
gc_full*: mrb_bool #:1;
is_generational_gc_mode*: mrb_bool #:1;
out_of_memory*: mrb_bool #:1;
majorgc_old_threshold*: csize_t
mems*: pointer
symidx*: mrb_sym
symtbl*: pointer # struct symbol_name* # symbol table
##ifdef MRB_USE_DEBUG_HOOK
code_fetch_hook*: proc (mrb: ptr mrb_state; irep: ptr mrb_irep;
pc: ptr mrb_code; regs: ptr mrb_value) {.cdecl.}
debug_op_hook*: proc (mrb: ptr mrb_state; irep: ptr mrb_irep;
pc: ptr mrb_code; regs: ptr mrb_value) {.cdecl.}
##endif
eException_class*: ptr RClass
eStandardError_class*: ptr RClass
nomem_err*: ptr RObject
stack_err*: ptr RObject
ud*: pointer # auxiliary data
atexit_stack_len*: uint16
type
mrb_vtype* {.importc,h.} = enum
MRB_TT_FALSE = 1, # 1
MRB_TT_TRUE, # 2
MRB_TT_FLOAT, # 3
MRB_TT_INTEGER, # 4
MRB_TT_SYMBOL, # 5
MRB_TT_UNDEF, # 6
MRB_TT_CPTR, # 7
MRB_TT_FREE, # 8
MRB_TT_OBJECT, # 9
MRB_TT_CLASS, # 10
MRB_TT_MODULE, # 11
MRB_TT_ICLASS, # 12
MRB_TT_SCLASS, # 13
MRB_TT_PROC, # 14
MRB_TT_ARRAY, # 15
MRB_TT_HASH, # 16
MRB_TT_STRING, # 17
MRB_TT_RANGE, # 18
MRB_TT_EXCEPTION, # 19
MRB_TT_ENV, # 20
MRB_TT_DATA, # 21
MRB_TT_FIBER, # 22
MRB_TT_ISTRUCT, # 23
MRB_TT_BREAK, # 24
MRB_TT_MAXDEFINE # 25
when defined(MRB_INT64):
type
mrb_int* = int64 # mruby/value.h
mrb_uint* = uint64 # mruby/value.h
const
mrb_int_bit* = 64
#const
# MRB_INT_MIN* = int64.low
# MRB_INT_MAX* = INT64.high
# PRIdMRB_INT* = PRId64
# PRIiMRB_INT* = PRIi64
# PRIoMRB_INT* = PRIo64
# PRIxMRB_INT* = PRIx64
# PRIXMRB_INT* = PRIX64
# elif defined(MRB_INT16):
# type
# mrb_int* = int16
# #const
# # MRB_INT_MIN* = INT16.low
# # MRB_INT_MAX* = INT16.high
else:
type
mrb_int* = int32
mrb_uint* = uint32 # mruby/value.h
const
mrb_int_bit* = 32
const
mrb_int_min* = mrb_int.low
mrb_int_max* = mrb_int.high
#const
# MRB_INT_MIN* = INT32.low
# MRB_INT_MAX* = INT32.high
# PRIdMRB_INT* = PRId32
# PRIiMRB_INT* = PRIi32
# PRIoMRB_INT* = PRIo32
# PRIxMRB_INT* = PRIx32
# PRIXMRB_INT* = PRIX32
when defined(MRB_USE_FLOAT32):
type
mrb_float* = cfloat # mruby/value.h
else:
type
mrb_float* = cdouble # mruby/value.h
type mrb_parser_state* {.importc,hc.} = object
{.push callconv: cdecl.}
{.push importc.}
{.push header:"<mruby.h>".}
proc mrb_define_class*(mrb: ptr mrb_state; name: cstring; super: ptr RClass): ptr RClass
proc mrb_define_class_id*(mrb: ptr mrb_state; name: mrb_sym; super: ptr RClass): ptr RClass
proc mrb_define_module*(mrb: ptr mrb_state; name: cstring): ptr RClass
proc mrb_define_module_id*(mrb: ptr mrb_state; name: mrb_sym): ptr RClass
proc mrb_singleton_class*(mrb: ptr mrb_state; val: mrb_value): mrb_value
proc mrb_singleton_class_ptr*(mrb: ptr mrb_state; val: mrb_value): ptr RClass
proc mrb_include_module*(mrb: ptr mrb_state; cla: ptr RClass; included: ptr RClass)
proc mrb_prepend_module*(mrb: ptr mrb_state; cla: ptr RClass; prepended: ptr RClass)
proc mrb_define_method*(mrb: ptr mrb_state; cla: ptr RClass; name: cstring;
f: mrb_func_t; aspec: mrb_aspec)
proc mrb_define_method_id*(mrb: ptr mrb_state; cla: ptr RClass; mid: mrb_sym;
f: mrb_func_t; aspec: mrb_aspec)
proc mrb_define_class_method*(mrb: ptr mrb_state; cla: ptr RClass; name: cstring;
fun: mrb_func_t; aspec: mrb_aspec)
proc mrb_define_class_method_id*(mrb: ptr mrb_state; cla: ptr RClass; name: mrb_sym;
fun: mrb_func_t; aspec: mrb_aspec)
proc mrb_define_singleton_method*(mrb: ptr mrb_state; cla: ptr RObject; name: cstring;
fun: mrb_func_t; aspec: mrb_aspec)
proc mrb_define_singleton_method_id*(mrb: ptr mrb_state; cla: ptr RClass; name: mrb_sym;
fun: mrb_func_t; aspec: mrb_aspec)
proc mrb_define_module_function*(mrb: ptr mrb_state; cla: ptr RClass; name: cstring;
fun: mrb_func_t; aspec: mrb_aspec)
proc mrb_define_module_function_id*(mrb: ptr mrb_state; cla: ptr RClass; name: mrb_sym;
fun: mrb_func_t; aspec: mrb_aspec)
proc mrb_define_const*(mrb: ptr mrb_state; cla: ptr RClass; name: cstring;
val: mrb_value)
proc mrb_define_const_id*(mrb: ptr mrb_state; cla: ptr RClass; name: mrb_sym;
val: mrb_value)
proc mrb_undef_method*(mrb: ptr mrb_state; cla: ptr RClass; name: cstring)
proc mrb_undef_method_id*(mrb: ptr mrb_state; cla: ptr RClass; name: mrb_sym)
proc mrb_undef_class_method*(mrb: ptr mrb_state; cla: ptr RClass; name: cstring)
proc mrb_undef_class_method_id*(mrb: ptr mrb_state; cla: ptr RClass; name: mrb_sym)
proc mrb_obj_new*(mrb: ptr mrb_state; c: ptr RClass; argc: cint;
argv: ptr mrb_value): mrb_value
template mrb_class_new_instance*(mrb, argc, argv, c: untyped): untyped =
mrb_obj_new(mrb, c, argc, argv)
proc mrb_class_new*(mrb: ptr mrb_state; super: ptr RClass): ptr RClass
proc mrb_module_new*(mrb: ptr mrb_state): ptr RClass
proc mrb_class_defined*(mrb: ptr mrb_state; name: cstring): mrb_bool
proc mrb_class_defined_id*(mrb: ptr mrb_state; name: mrb_sym): mrb_bool
proc mrb_class_get*(mrb: ptr mrb_state; name: cstring): ptr RClass
proc mrb_class_get_id*(mrb: ptr mrb_state; name: mrb_sym): ptr RClass
proc mrb_exc_get_id*(mrb: ptr mrb_state; name: cstring): ptr RClass
template mrb_exc_get*(mrb, name: untyped): untyped =
mrb_exc_get_id(mrb, mrb_intern_cstr(mrb, name))
proc mrb_class_defined_under*(mrb: ptr mrb_state; outer: ptr RClass; name: cstring): mrb_bool
proc mrb_class_defined_under_id*(mrb: ptr mrb_state; outer: ptr RClass; name: mrb_sym): mrb_bool
proc mrb_class_get_under*(mrb: ptr mrb_state; outer: ptr RClass; name: cstring): ptr RClass
proc mrb_class_get_under_id*(mrb: ptr mrb_state; outer: ptr RClass; name: mrb_sym): ptr RClass
proc mrb_module_get*(mrb: ptr mrb_state; name: cstring): ptr RClass
proc mrb_module_get_id*(mrb: ptr mrb_state; name: mrb_sym): ptr RClass
proc mrb_module_get_under*(mrb: ptr mrb_state; outer: ptr RClass; name: cstring): ptr RClass
proc mrb_module_get_under_id*(mrb: ptr mrb_state; outer: ptr RClass; name: mrb_sym): ptr RClass
proc mrb_notimplement*(mrb: ptr mrb_state)
proc mrb_notimplement_m*(mrb: ptr mrb_state, m: mrb_value): mrb_value
proc mrb_obj_dup*(mrb: ptr mrb_state; obj: mrb_value): mrb_value
proc mrb_obj_respond_to*(mrb: ptr mrb_state; c: ptr RClass; mid: mrb_sym): mrb_bool
proc mrb_define_class_under*(mrb: ptr mrb_state; outer: ptr RClass; name: cstring;
super: ptr RClass): ptr RClass
proc mrb_define_class_under_id*(mrb: ptr mrb_state; outer: ptr RClass; name: mrb_sym;
super: ptr RClass): ptr RClass
proc mrb_define_module_under*(mrb: ptr mrb_state; outer: ptr RClass; name: cstring): ptr RClass
proc mrb_define_module_under_id*(mrb: ptr mrb_state; outer: ptr RClass; name: mrb_sym): ptr RClass
template MRB_ARGS_REQ*(n: untyped): untyped =
( mrb_aspec((n) and 0x1f) shl 18)
template MRB_ARGS_OPT*(n: untyped): untyped =
( mrb_aspec((n) and 0x1f) shl 13)
template MRB_ARGS_ARG*(n1, n2: untyped): untyped =
( MRB_ARGS_REQ(n1) or MRB_ARGS_OPT(n2) )
template MRB_ARGS_REST*(): untyped =
mrb_aspec( 1 shl 12 )
template MRB_ARGS_POST*(n: untyped): untyped =
( mrb_aspec((n) and 0x1f) shl 7 )
template MRB_ARGS_KEY*(n1, n2: untyped): untyped =
# ( mrb_aspec( (((n1) and 0x1f) shl 2) or ((n2)?(1 shl 1):0) ) )
( mrb_aspec( (((n1) and 0x1f) shl 2) or (if n2 != 0: (1 shl 1) else: 0) ) )
template MRB_ARGS_BLOCK*(): untyped =
mrb_aspec(1)
template MRB_ARGS_ANY*(): untyped =
MRB_ARGS_REST()
template MRB_ARGS_NONE*(): untyped =
mrb_aspec(0)
type mrb_args_format* {.importc,h.} = cstring
proc mrb_get_args*(mrb: ptr mrb_state; format: mrb_args_format): cint
proc mrb_get_mid*(mrb: ptr mrb_state): mrb_sym
proc mrb_get_argc*(mrb: ptr mrb_state): mrb_int
proc mrb_get_argv*(mrb: ptr mrb_state): ptr mrb_value
proc mrb_get_arg1*(mrb: ptr mrb_state): mrb_value
proc mrb_funcall*(mrb: ptr mrb_state; val: mrb_value; name: cstring; argc: mrb_int): mrb_value {.varargs.}
proc mrb_funcall_id*(mrb: ptr mrb_state; val: mrb_value; mid: mrb_sym; argc: mrb_int): mrb_value {.varargs.}
proc mrb_funcall_argv*(mrb: ptr mrb_state; val: mrb_value; name: mrb_sym;
argc: mrb_int; argv: ptr mrb_value): mrb_value
proc mrb_funcall_with_block*(mrb: ptr mrb_state; val: mrb_value; name: mrb_sym;
argc: mrb_int; argv: ptr mrb_value; blk: mrb_value): mrb_value
proc mrb_intern_cstr*(mrb: ptr mrb_state; str: cstring): mrb_sym
proc mrb_intern*(mrb: ptr mrb_state; str: cstring; s: csize_t): mrb_sym
proc mrb_intern_static*(mrb: ptr mrb_state; str: cstring; s: csize_t): mrb_sym
template mrb_intern_lit*(mrb, lit: untyped): untyped =
mrb_intern_static(mrb, (lit), sizeof(lit) - 1)
proc mrb_intern_str*(mrb: ptr mrb_state; s: mrb_value): mrb_sym
proc mrb_intern_check_cstr*(mrb: ptr mrb_state; s: cstring): mrb_sym
proc mrb_intern_check*(mrb: ptr mrb_state; s: cstring; cs: csize_t): mrb_sym
proc mrb_intern_check_str*(mrb: ptr mrb_state; v: mrb_value): mrb_sym
proc mrb_check_intern_cstr*(mrb: ptr mrb_state; s: cstring): mrb_value
proc mrb_check_intern*(mrb: ptr mrb_state; s: cstring; cs: csize_t): mrb_value
proc mrb_check_intern_str*(mrb: ptr mrb_state; s: mrb_value): mrb_value
proc mrb_sym_name*(mrb: ptr mrb_state; s: mrb_sym): cstring
proc mrb_sym_name_len*(mrb: ptr mrb_state; s: mrb_sym; ss: ptr mrb_int): cstring
proc mrb_sym_dump*(mrb: ptr mrb_state; s: mrb_sym): cstring
proc mrb_sym_str*(mrb: ptr mrb_state; s: mrb_sym): mrb_value
proc mrb_sym2name*(mrb: ptr mrb_state; s: mrb_sym): cstring
proc mrb_sym2name_len*(mrb: ptr mrb_state; s: mrb_sym; ss: ptr csize_t): cstring
proc mrb_sym2str*(mrb: ptr mrb_state; s: mrb_sym): mrb_value
proc mrb_malloc*(mrb: ptr mrb_state; s: csize_t): pointer
proc mrb_calloc*(mrb: ptr mrb_state; s1: csize_t; s2: csize_t): pointer
proc mrb_realloc*(mrb: ptr mrb_state; a3: pointer; a4: csize_t): pointer
proc mrb_realloc_simple*(mrb: ptr mrb_state; a3: pointer; a4: csize_t): pointer
proc mrb_malloc_simple*(mrb: ptr mrb_state; a3: csize_t): pointer
proc mrb_obj_alloc*(mrb: ptr mrb_state; a3: mrb_vtype; a4: ptr RClass): ptr RBasic
proc mrb_free*(mrb: ptr mrb_state; a3: pointer)
proc mrb_str_new*(mrb: ptr mrb_state; p: cstring; len: csize_t): mrb_value
proc mrb_str_new_cstr*(mrb: ptr mrb_state; a3: cstring): mrb_value
proc mrb_str_new_static*(mrb: ptr mrb_state; p: cstring; len: csize_t): mrb_value
template mrb_str_new_lit*(mrb, lit: untyped): untyped =
mrb_str_new_static(mrb, (lit), sizeof(lit) - 1)
proc mrb_obj_freeze*(mrb: ptr mrb_state; v: mrb_value): mrb_value
template mrb_str_new_frozen*(mrb, p, l: untyped): untyped =
mrb_obj_freeze(mrb, mrb_str_new(mrb, p, l))
template mrb_str_new_cstr_frozen*(mrb, p: untyped): untyped =
mrb_obj_freeze(mrb, mrb_str_new_cstr(mrb, p))
template mrb_str_new_static_frozen*(mrb, p, l: untyped): untyped =
mrb_obj_freeze(mrb, mrb_str_new_static(mrb, p, l))
template mrb_str_new_lit_frozen*(mrb, lit: untyped): untyped =
mrb_obj_freeze(mrb, mrb_str_new_lit(mrb, lit))
discard """ proc mrb_define_class*(a2: ptr mrb_state; a3: cstring; a4: ptr RClass): ptr RClass {.importc.}
proc mrb_define_module*(a2: ptr mrb_state; a3: cstring): ptr RClass {.importc.}
proc mrb_singleton_class*(a2: ptr mrb_state; a3: mrb_value): mrb_value {.importc.}
proc mrb_include_module*(a2: ptr mrb_state; a3: ptr RClass; a4: ptr RClass) {.importc.}
proc mrb_define_method*(a2: ptr mrb_state; a3: ptr RClass; a4: cstring;
a5: mrb_func_t; a6: mrb_aspec) {.importc.}
proc mrb_define_class_method*(a2: ptr mrb_state; a3: ptr RClass; a4: cstring;
a5: mrb_func_t; a6: mrb_aspec) {.importc.}
proc mrb_define_singleton_method*(a2: ptr mrb_state; a3: ptr RObject;
a4: cstring; a5: mrb_func_t; a6: mrb_aspec) {.importc.}
proc mrb_define_module_function*(a2: ptr mrb_state; a3: ptr RClass;
a4: cstring; a5: mrb_func_t; a6: mrb_aspec) {.importc.}
proc mrb_define_const*(a2: ptr mrb_state; a3: ptr RClass; name: cstring;
a5: mrb_value) {.importc.}
proc mrb_undef_method*(a2: ptr mrb_state; a3: ptr RClass; a4: cstring) {.importc.}
proc mrb_undef_class_method*(a2: ptr mrb_state; a3: ptr RClass; a4: cstring) {.importc.}
proc mrb_obj_new*(mrb: ptr mrb_state; c: ptr RClass; argc: cint;
argv: ptr mrb_value): mrb_value {.importc.}
template mrb_class_new_instance*(mrb, argc, argv, c: expr): expr =
mrb_obj_new(mrb, c, argc, argv)
proc mrb_instance_new*(mrb: ptr mrb_state; cv: mrb_value): mrb_value {.importc.}
proc mrb_class_new*(mrb: ptr mrb_state; super: ptr RClass): ptr RClass {.importc.}
proc mrb_module_new*(mrb: ptr mrb_state): ptr RClass {.importc.}
proc mrb_class_defined*(mrb: ptr mrb_state; name: cstring): mrb_bool {.importc.}
proc mrb_class_get*(mrb: ptr mrb_state; name: cstring): ptr RClass {.importc.}
proc mrb_class_get_under*(mrb: ptr mrb_state; outer: ptr RClass; name: cstring): ptr RClass {.importc.}
proc mrb_module_get*(mrb: ptr mrb_state; name: cstring): ptr RClass {.importc.}
proc mrb_module_get_under*(mrb: ptr mrb_state; outer: ptr RClass;
name: cstring): ptr RClass {.importc.}
proc mrb_obj_dup*(mrb: ptr mrb_state; obj: mrb_value): mrb_value {.importc.}
proc mrb_check_to_integer*(mrb: ptr mrb_state; val: mrb_value; `method`: cstring): mrb_value {.importc.}
proc mrb_obj_respond_to*(mrb: ptr mrb_state; c: ptr RClass; mid: mrb_sym): mrb_bool {.importc.}
proc mrb_define_class_under*(mrb: ptr mrb_state; outer: ptr RClass;
name: cstring; super: ptr RClass): ptr RClass {.importc.}
proc mrb_define_module_under*(mrb: ptr mrb_state; outer: ptr RClass;
name: cstring): ptr RClass {.importc.}
# required arguments
##define MRB_ARGS_REQ(n) ((mrb_aspec)((n)&0x1f) << 18)
# optional arguments
##define MRB_ARGS_OPT(n) ((mrb_aspec)((n)&0x1f) << 13)
# mandatory and optinal arguments
template MRB_ARGS_ARG*(n1, n2: expr): expr =
(MRB_ARGS_REQ(n1) or MRB_ARGS_OPT(n2))
# rest argument
##define MRB_ARGS_REST() ((mrb_aspec)(1 << 12))
# required arguments after rest
##define MRB_ARGS_POST(n) ((mrb_aspec)((n)&0x1f) << 7)
# keyword arguments (n of keys, kdict)
##define MRB_ARGS_KEY(n1,n2) ((mrb_aspec)((((n1)&0x1f) << 2) | ((n2)?(1<<1):0)))
# block argument
template MRB_ARGS_BLOCK*(): expr =
mrb_aspec(1)
# accept any number of arguments
template MRB_ARGS_ANY*(): expr =
ARGS_REST()
# accept no arguments
template MRB_ARGS_NONE*(): expr =
cast[(mrb_aspec)](0)
# compatibility macros; will be removed
template ARGS_REQ*(n: expr): expr =
MRB_ARGS_REQ(n)
template ARGS_OPT*(n: expr): expr =
MRB_ARGS_OPT(n)
template ARGS_REST*(): expr =
MRB_ARGS_REST()
template ARGS_POST*(n: expr): expr =
MRB_ARGS_POST()
template ARGS_KEY*(n1, n2: expr): expr =
MRB_ARGS_KEY(n1, n2)
template ARGS_BLOCK*(): expr =
MRB_ARGS_BLOCK()
template ARGS_ANY*(): expr =
MRB_ARGS_ANY()
template ARGS_NONE*(): expr =
MRB_ARGS_NONE()
proc mrb_get_args*(mrb: ptr mrb_state; format: cstring): cint {.varargs,importc.}
proc mrb_funcall*(a2: ptr mrb_state; a3: mrb_value; a4: cstring; a5: cint): mrb_value {.
varargs,importc.}
proc mrb_funcall_argv*(a2: ptr mrb_state; a3: mrb_value; a4: mrb_sym;
a5: cint; a6: ptr mrb_value): mrb_value {.importc.}
proc mrb_funcall_with_block*(a2: ptr mrb_state; a3: mrb_value; a4: mrb_sym;
a5: cint; a6: ptr mrb_value; a7: mrb_value): mrb_value {.importc.}
proc mrb_intern_cstr*(a2: ptr mrb_state; a3: cstring): mrb_sym {.importc.}
proc mrb_intern*(a2: ptr mrb_state; a3: cstring; a4: csize_t): mrb_sym {.importc.}
proc mrb_intern_static*(a2: ptr mrb_state; a3: cstring; a4: csize): mrb_sym {.importc.}
template mrb_intern_lit*(mrb, lit: expr): expr =
mrb_intern_static(mrb, (lit), sizeof(lit) - 1)
proc mrb_intern_str*(a2: ptr mrb_state; a3: mrb_value): mrb_sym {.importc.}
proc mrb_check_intern_cstr*(a2: ptr mrb_state; a3: cstring): mrb_value {.importc.}
proc mrb_check_intern*(a2: ptr mrb_state; a3: cstring; a4: csize): mrb_value {.importc.}
proc mrb_check_intern_str*(a2: ptr mrb_state; a3: mrb_value): mrb_value {.importc.}
proc mrb_sym2name*(a2: ptr mrb_state; a3: mrb_sym): cstring {.importc.}
proc mrb_sym2name_len*(a2: ptr mrb_state; a3: mrb_sym; a4: ptr csize): cstring {.importc.}
proc mrb_sym2str*(a2: ptr mrb_state; a3: mrb_sym): mrb_value {.importc.}
proc mrb_malloc*(a2: ptr mrb_state; a3: csize): pointer {.importc.}
# raise RuntimeError if no mem
proc mrb_calloc*(a2: ptr mrb_state; a3: csize; a4: csize): pointer {.importc.}
# ditto
proc mrb_realloc*(a2: ptr mrb_state; a3: pointer; a4: csize): pointer {.importc.}
# ditto
proc mrb_realloc_simple*(a2: ptr mrb_state; a3: pointer; a4: csize): pointer {.importc.}
# return NULL if no memory available
proc mrb_malloc_simple*(a2: ptr mrb_state; a3: csize): pointer {.importc.}
# return NULL if no memory available
proc mrb_obj_alloc*(a2: ptr mrb_state; a3: mrb_vtype; a4: ptr RClass): ptr RBasic {.importc.}
proc mrb_free*(a2: ptr mrb_state; a3: pointer) {.importc.}
proc mrb_str_new*(mrb: ptr mrb_state; p: cstring; len: csize): mrb_value {.importc.}
proc mrb_str_new_cstr*(a2: ptr mrb_state; a3: cstring): mrb_value {.importc.}
proc mrb_str_new_static*(mrb: ptr mrb_state; p: cstring; len: csize): mrb_value {.importc.}
template mrb_str_new_lit*(mrb, lit: expr): expr =
mrb_str_new_static(mrb, (lit), sizeof(lit) - 1)
"""
proc mrb_open*(): PState
proc mrb_open_allocf*(f: mrb_allocf, ud: pointer): PState
proc mrb_open_core*(f: mrb_allocf, ud: pointer): PState
proc mrb_close*(mrb: ptr mrb_state)
proc mrb_default_allocf*(mrb: ptr mrb_state, ud: pointer, size: csize_t, ud2: pointer): pointer
proc mrb_top_self*(mrb: ptr mrb_state): mrb_value
proc mrb_top_run*(mrb: ptr mrb_state, rproc: ptr RProc, self: mrb_value, stack_keep: mrb_int): mrb_value
proc mrb_vm_run*(mrb: ptr mrb_state, rproc: ptr RProc, self: mrb_value, stack_keep: mrb_int): mrb_value
proc mrb_vm_exec*(mrb: ptr mrb_state, rproc: ptr RProc, iseq: ptr mrb_code): mrb_value
proc mrb_p*(a2: ptr mrb_state, a3: mrb_value)
proc mrb_obj_id*(obj: mrb_value): mrb_int
proc mrb_obj_to_sym*(mrb: ptr mrb_state, name: mrb_value): mrb_sym
proc mrb_obj_eq*(a2: ptr mrb_state, a3: mrb_value, a4: mrb_value): mrb_bool
proc mrb_obj_equal*(a2: ptr mrb_state; a3: mrb_value; a4: mrb_value): mrb_bool
proc mrb_equal*(mrb: ptr mrb_state; obj1: mrb_value; obj2: mrb_value): mrb_bool
proc mrb_convert_to_integer*(mrb: ptr mrb_state; val: mrb_value; base: mrb_int): mrb_value
proc mrb_Integer*(mrb: ptr mrb_state; val: mrb_value): mrb_value
# when not(defined(MRB_NO_FLOAT)):
# proc mrb_Float*(mrb: ptr mrb_state; val: mrb_value): mrb_value
proc mrb_inspect*(mrb: ptr mrb_state; obj: mrb_value): mrb_value
proc mrb_eql*(mrb: ptr mrb_state; obj1: mrb_value; obj2: mrb_value): mrb_bool
proc mrb_cmp*(mrb: ptr mrb_state; obj1: mrb_value; obj2: mrb_value): mrb_int
proc mrb_gc_arena_save*(mrb: ptr mrb_state): int
proc mrb_gc_arena_restore*(mrb: ptr mrb_state, idx: int)
proc mrb_garbage_collect*(mrb: ptr mrb_state)
proc mrb_full_gc*(mrb: ptr mrb_state)
proc mrb_incremental_gc*(mrb: ptr mrb_state)
proc mrb_gc_mark*(mrb: ptr mrb_state, b: ptr RBasic)
proc mrb_field_write_barrier*(mrb: ptr mrb_state, b1: ptr RBasic, b2: ptr RBasic)
proc mrb_write_barrier*(mrb: ptr mrb_state, b1: ptr RBasic)
proc mrb_type_convert*(mrb: ptr mrb_state; val: mrb_value;
typ: mrb_vtype; tmethod: mrb_sym): mrb_value
proc mrb_check_convert_type*(mrb: ptr mrb_state; val: mrb_value;
typ: mrb_vtype; tmethod: mrb_sym): mrb_value
proc mrb_any_to_s*(mrb: ptr mrb_state; obj: mrb_value): mrb_value
proc mrb_obj_classname*(mrb: ptr mrb_state; obj: mrb_value): cstring
proc mrb_obj_class*(mrb: ptr mrb_state; obj: mrb_value): ptr RClass
proc mrb_class_path*(mrb: ptr mrb_state; c: ptr RClass): mrb_value
proc mrb_obj_is_kind_of*(mrb: ptr mrb_state; obj: mrb_value; c: ptr RClass): mrb_bool
proc mrb_obj_inspect*(mrb: ptr mrb_state; self: mrb_value): mrb_value
proc mrb_obj_clone*(mrb: ptr mrb_state; self: mrb_value): mrb_value
discard """
proc mrb_open_allocf*(a2: mrb_allocf; ud: pointer): ptr mrb_state {.importc.}
proc mrb_top_self*(a2: ptr mrb_state): mrb_value {.importc.}
proc mrb_run*(a2: ptr mrb_state; a3: ptr RProc; a4: mrb_value): mrb_value {.importc.}
proc mrb_context_run*(a2: ptr mrb_state; a3: ptr RProc; a4: mrb_value;
a5: cuint): mrb_value {.importc.}
proc mrb_p*(a2: ptr mrb_state; a3: mrb_value) {.importc.}
proc mrb_obj_id*(obj: mrb_value): mrb_int {.importc.}
proc mrb_obj_to_sym*(mrb: ptr mrb_state; name: mrb_value): mrb_sym {.importc.}
proc mrb_obj_eq*(a2: ptr mrb_state; a3: mrb_value; a4: mrb_value): mrb_bool {.importc.}
proc mrb_obj_equal*(a2: ptr mrb_state; a3: mrb_value; a4: mrb_value): mrb_bool {.importc.}
proc mrb_equal*(mrb: ptr mrb_state; obj1: mrb_value; obj2: mrb_value): mrb_bool {.importc.}
proc mrb_Integer*(mrb: ptr mrb_state; val: mrb_value): mrb_value {.importc.}
proc mrb_Float*(mrb: ptr mrb_state; val: mrb_value): mrb_value {.importc.}
proc mrb_inspect*(mrb: ptr mrb_state; obj: mrb_value): mrb_value {.importc.}
proc mrb_eql*(mrb: ptr mrb_state; obj1: mrb_value; obj2: mrb_value): mrb_bool {.importc.}
proc mrb_garbage_collect*(a2: ptr mrb_state) {.importc.}
proc mrb_full_gc*(a2: ptr mrb_state) {.importc.}
proc mrb_incremental_gc*(a2: ptr mrb_state) {.importc.}
proc mrb_gc_arena_save*(a2: ptr mrb_state): cint {.importc.}
proc mrb_gc_arena_restore*(a2: ptr mrb_state; a3: cint) {.importc.}
proc mrb_gc_mark*(a2: ptr mrb_state; a3: ptr RBasic) {.importc.}
template mrb_gc_mark_value*(mrb, val: expr): stmt =
if mrb_type(val) >= MRB_TT_HAS_BASIC:
mrb_gc_mark((mrb), mrb_basic_ptr(val))
proc mrb_field_write_barrier*(a2: ptr mrb_state; a3: ptr RBasic;
a4: ptr RBasic) {.importc.}
template mrb_field_write_barrier_value*(mrb, obj, val: expr): stmt =
if (val.tt >= MRB_TT_HAS_BASIC):
mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val))
proc mrb_write_barrier*(a2: ptr mrb_state; a3: ptr RBasic) {.importc.}
proc mrb_check_convert_type*(mrb: ptr mrb_state; val: mrb_value;
typ: mrb_vtype; tname: cstring; methd: cstring): mrb_value {.importc.}
proc mrb_any_to_s*(mrb: ptr mrb_state; obj: mrb_value): mrb_value {.importc.}
proc mrb_obj_classname*(mrb: ptr mrb_state; obj: mrb_value): cstring {.importc.}
proc mrb_obj_class*(mrb: ptr mrb_state; obj: mrb_value): ptr RClass {.importc.}
proc mrb_class_path*(mrb: ptr mrb_state; c: ptr RClass): mrb_value {.importc.}
proc mrb_convert_type*(mrb: ptr mrb_state; val: mrb_value; typ: mrb_vtype;
tname: cstring; methd: cstring): mrb_value {.importc.}
proc mrb_obj_is_kind_of*(mrb: ptr mrb_state; obj: mrb_value; c: ptr RClass): mrb_bool {.importc.}
proc mrb_obj_inspect*(mrb: ptr mrb_state; self: mrb_value): mrb_value {.importc.}
proc mrb_obj_clone*(mrb: ptr mrb_state; self: mrb_value): mrb_value {.importc.} """
# need to include <ctype.h> to use these macros
discard """ when not(defined(ISPRINT)):
##define ISASCII(c) isascii((int)(unsigned char)(c))
template ISASCII*(c: expr): expr =
1
template ISPRINT*(c: expr): expr =
(ISASCII(c) and isprint(cast[cint](cast[cuchar]((c)))))
template ISSPACE*(c: expr): expr =
(ISASCII(c) and isspace(cast[cint](cast[cuchar]((c)))))
template ISUPPER*(c: expr): expr =
(ISASCII(c) and isupper(cast[cint](cast[cuchar]((c)))))
template ISLOWER*(c: expr): expr =
(ISASCII(c) and islower(cast[cint](cast[cuchar]((c)))))
template ISALNUM*(c: expr): expr =
(ISASCII(c) and isalnum(cast[cint](cast[cuchar]((c)))))
template ISALPHA*(c: expr): expr =
(ISASCII(c) and isalpha(cast[cint](cast[cuchar]((c)))))
template ISDIGIT*(c: expr): expr =
(ISASCII(c) and isdigit(cast[cint](cast[cuchar]((c)))))
template ISXDIGIT*(c: expr): expr =
(ISASCII(c) and isxdigit(cast[cint](cast[cuchar]((c)))))
template TOUPPER*(c: expr): expr =
(if ISASCII(c): toupper(cast[cint](cast[cuchar]((c)))) else: (c))
template TOLOWER*(c: expr): expr =
(if ISASCII(c): tolower(cast[cint](cast[cuchar]((c)))) else: (c)) """
proc mrb_exc_new*(mrb: ptr mrb_state; c: ptr RClass; pointr: cstring; len: csize_t): mrb_value
proc mrb_exc_raise*(mrb: ptr mrb_state; exc: mrb_value)
proc mrb_raise*(mrb: ptr mrb_state; c: ptr RClass; msg: cstring)
proc mrb_raisef*(mrb: ptr mrb_state; c: ptr RClass; fmt: cstring)
proc mrb_name_error*(mrb: ptr mrb_state; id: mrb_sym; fmt: cstring)
proc mrb_frozen_error*(mrb: ptr mrb_state; frozen_obj: pointer)
proc mrb_argnum_error*(mrb: ptr mrb_state; argc: mrb_int; min: int; max: int)
proc mrb_warn*(mrb: ptr mrb_state; fmt: cstring)
proc mrb_bug*(mrb: ptr mrb_state; fmt: cstring)
proc mrb_print_backtrace*(mrb: ptr mrb_state)
proc mrb_print_error*(mrb: ptr mrb_state)
proc mrb_vformat*(mrb: ptr mrb_state; format: cstring; ap: va_list): mrb_value {.cdecl.}
discard """ proc mrb_exc_new*(mrb: ptr mrb_state; c: ptr RClass; pointr: cstring; len: clong): mrb_value {.importc.}
proc mrb_exc_raise*(mrb: ptr mrb_state; exc: mrb_value) {.importc.}
proc mrb_raise*(mrb: ptr mrb_state; c: ptr RClass; msg: cstring) {.importc.}
proc mrb_raisef*(mrb: ptr mrb_state; c: ptr RClass; fmt: cstring) {.varargs,importc.}
proc mrb_name_error*(mrb: ptr mrb_state; id: mrb_sym; fmt: cstring) {.varargs,importc.}
proc mrb_warn*(mrb: ptr mrb_state; fmt: cstring) {.varargs,importc.}
proc mrb_bug*(mrb: ptr mrb_state; fmt: cstring) {.varargs,importc.}
proc mrb_print_backtrace*(mrb: ptr mrb_state) {.importc.}
proc mrb_print_error*(mrb: ptr mrb_state) {.importc.} """
# macros to get typical exception objects
# note:
# + those E_* macros requires mrb_state* variable named mrb.
# + exception objects obtained from those macros are local to mrb
discard """ #
template E_RUNTIME_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "RuntimeError"))
template E_TYPE_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "TypeError"))
template E_ARGUMENT_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "ArgumentError"))
template E_INDEX_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "IndexError"))
template E_RANGE_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "RangeError"))
template E_NAME_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "NameError"))
template E_NOMETHOD_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "NoMethodError"))
template E_SCRIPT_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "ScriptError"))
template E_SYNTAX_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "SyntaxError"))
template E_LOCALJUMP_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "LocalJumpError"))
template E_REGEXP_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "RegexpError"))
template E_NOTIMP_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "NotImplementedError"))
template E_FLOATDOMAIN_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "FloatDomainError"))
template E_KEY_ERROR* (mrb:expr): expr = (mrb_class_get(mrb, "KeyError"))
"""
proc mrb_yield*(mrb: ptr mrb_state; b: mrb_value; arg: mrb_value): mrb_value
proc mrb_yield_argv*(mrb: ptr mrb_state; b: mrb_value; argc: cint;
argv: ptr mrb_value): mrb_value
proc mrb_yield_with_class*(mrb: ptr mrb_state; b: mrb_value; argc: cint;
argv: ptr mrb_value; c: ptr RClass): mrb_value
proc mrb_yield_cont*(mrb: ptr mrb_state; b: mrb_value; self: mrb_value;
argc: cint; argv: ptr mrb_value): mrb_value
proc mrb_gc_protect*(mrb: ptr mrb_state; obj: mrb_value)
proc mrb_gc_register*(mrb: ptr mrb_state; obj: mrb_value)
proc mrb_gc_unregister*(mrb: ptr mrb_state; obj: mrb_value)
proc mrb_to_int*(mrb: ptr mrb_state; val: mrb_value): mrb_value
proc mrb_to_str*(mrb: ptr mrb_state; val: mrb_value): mrb_value
proc mrb_check_type*(mrb: ptr mrb_state; x: mrb_value; t: mrb_vtype)
proc mrb_check_frozen*(mrb: ptr mrb_state; o: pointer)
proc mrb_define_alias*(mrb: ptr mrb_state; c: ptr RClass; a: cstring;
b: cstring)
proc mrb_define_alias_id*(mrb: ptr mrb_state; c: ptr RClass; a: mrb_sym;
b: mrb_sym)
proc mrb_class_name*(mrb: ptr mrb_state; klass: ptr RClass): cstring
proc mrb_define_global_const*(mrb: ptr mrb_state; name: cstring;
val: mrb_value)
proc mrb_attr_get*(mrb: ptr mrb_state; obj: mrb_value; id: mrb_sym): mrb_value
proc mrb_respond_to*(mrb: ptr mrb_state; obj: mrb_value; mid: mrb_sym): mrb_bool
proc mrb_obj_is_instance_of*(mrb: ptr mrb_state; obj: mrb_value; c: ptr RClass): mrb_bool
proc mrb_func_basic_p*(mrb: ptr mrb_state; obj: mrb_value; mid: mrb_sym; f: mrb_func_t): mrb_bool
discard """ proc mrb_yield*(mrb: ptr mrb_state; b: mrb_value; arg: mrb_value): mrb_value {.importc.}
proc mrb_yield_argv*(mrb: ptr mrb_state; b: mrb_value; argc: cint;
argv: ptr mrb_value): mrb_value {.importc.}
proc mrb_gc_protect*(mrb: ptr mrb_state; obj: mrb_value) {.importc.}
proc mrb_to_int*(mrb: ptr mrb_state; val: mrb_value): mrb_value {.importc.}
proc mrb_check_type*(mrb: ptr mrb_state; x: mrb_value; t: mrb_vtype) {.importc.}
type
call_type* {.size: sizeof(cint).} = enum
CALL_PUBLIC, CALL_FCALL, CALL_VCALL, CALL_TYPE_MAX
proc mrb_define_alias*(mrb: ptr mrb_state; klass: ptr RClass; name1: cstring;
name2: cstring) {.importc.}
proc mrb_class_name*(mrb: ptr mrb_state; klass: ptr RClass): cstring {.importc.}
proc mrb_define_global_const*(mrb: ptr mrb_state; name: cstring;
val: mrb_value) {.importc.}
proc mrb_attr_get*(mrb: ptr mrb_state; obj: mrb_value; id: mrb_sym): mrb_value {.importc.}
proc mrb_respond_to*(mrb: ptr mrb_state; obj: mrb_value; mid: mrb_sym): mrb_bool {.importc.}
proc mrb_obj_is_instance_of*(mrb: ptr mrb_state; obj: mrb_value; c: ptr RClass): mrb_bool {.importc.}
# memory pool implementation
proc mrb_pool_open*(a2: ptr mrb_state): ptr mrb_pool {.importc.}
proc mrb_pool_close*(a2: ptr mrb_pool) {.importc.}
proc mrb_pool_alloc*(a2: ptr mrb_pool; a3: csize): pointer {.importc.}
proc mrb_pool_realloc*(a2: ptr mrb_pool; a3: pointer; oldlen: csize;
newlen: csize): pointer {.importc.}
proc mrb_pool_can_realloc*(a2: ptr mrb_pool; a3: pointer; a4: csize): mrb_bool {.importc.}
proc mrb_alloca*(mrb: ptr mrb_state; a3: csize): pointer {.importc.}
"""
proc mrb_fiber_resume*(mrb: ptr mrb_state; fib: mrb_value; argc: mrb_int; argv: ptr mrb_value): mrb_value
proc mrb_fiber_yield*(mrb: ptr mrb_state; argc: mrb_int; argv: ptr mrb_value): mrb_value
proc mrb_fiber_alive_p*(mrb: ptr mrb_state; fib: mrb_value): mrb_value
proc mrb_stack_extend*(mrb: ptr mrb_state; i: mrb_int)
proc mrb_pool_open*(mrb: ptr mrb_state): ptr mrb_pool
proc mrb_pool_close*(p: ptr mrb_pool)
proc mrb_pool_alloc*(p: ptr mrb_pool; a3: csize_t): pointer
proc mrb_pool_realloc*(a2: ptr mrb_pool; a3: pointer; oldlen: csize_t;
newlen: csize_t): pointer
proc mrb_pool_can_realloc*(a2: ptr mrb_pool; a3: pointer; a4: csize_t): mrb_bool
proc mrb_alloca*(mrb: ptr mrb_state; a3: csize_t): pointer
proc mrb_state_atexit*(mrb: ptr mrb_state; f: mrb_atexit_func)
proc mrb_show_version*(mrb: ptr mrb_state)
proc mrb_show_copyright*(mrb: ptr mrb_state)
proc mrb_format*(mrb: ptr mrb_state; format: cstring): mrb_value
# compile.h
{.pop.}
{.push header:"<mruby/compile.h>".}
#mrb_value mrb_load_string(mrb_state *mrb, const char *s);
proc mrb_load_string* (mrb:PState; s:cstring): mrb_value
{.pop.} # end <mruby/compile.h>
{.pop.} # end <mruby.h>
{.pop.} # end importc
############################################################
when isMainModule:
var state: PState
state = mrb_open()
state.mrb_show_version()
state.mrb_show_copyright()
import os
if fileExists "main.rb":
let v: mrb_value = state.mrb_load_string readAll(open("main.rb"))
discard v
else:
echo "main.rb not found."
state.mrb_close()
Raw
nim.cfg
--passC:"-I$HOME/GitWorkspace/mruby/include"
--passL:"-L$HOME/GitWorkspace/mruby/build/host/lib"
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment