mruby.nim

#
#* mruby - An embeddable Ruby implementation
#*
#* Copyright (c) mruby developers 2010-2014
#*
#* 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: http://www.opensource.org/licenses/mit-license.php ]
#

{.passL: "-lmruby".}
{.pragma: h, header: "<mruby.h>".}
{.pragma: hc, header:"<mruby/compile.h>".}

type 
  mrb_code* {.importc,h.} = uint32
  mrb_aspec* {.importc,h.} = uint32
type 
  mrb_irep* {.importc,h.} = object 
  
type 
  mrb_sym* {.importc,h.} = cshort

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_value* {.importc,h.} = object
  
  iv_tbl {.importc,h.} = object
  kh_mt  {.importc,h.} = object
  
  RProc* {.importc,h.} = object 
    irep*: ptr mrb_irep   #  MRB_OBJECT_HEADER;
                          #  union {
    func*: mrb_func_t     #  } body;
    target_class*: ptr RClass
    env*: ptr REnv
 
  mrb_allocf* = proc (mrb: ptr mrb_state; a3: pointer; a4: csize; ud: pointer): pointer{.cdecl.}


  REnv* {.importc,h.} = object 
    stack*: ptr mrb_value #  MRB_OBJECT_HEADER;
    mid*: mrb_sym
    cioff*: cint

  RClass* {.importc,h.} = object 
    iv*: ptr iv_tbl       #  MRB_OBJECT_HEADER;
    mt*: ptr kh_mt
    super*: ptr RClass

  mrb_callinfo* {.importc,h.} = object 
    mid*: mrb_sym
    rproc*: ptr RProc
    stackent*: ptr mrb_value
    nregs*: cint
    argc*: cint
    pc*: ptr mrb_code       # return address 
    err*: ptr mrb_code      # error position 
    acc*: cint
    target_class*: ptr RClass
    ridx*: cint
    eidx*: cint
    env*: ptr REnv


  mrb_fiber_state* {.importc,h.} = enum 
    MRB_FIBER_CREATED = 0, MRB_FIBER_RUNNING, MRB_FIBER_RESUMED, 
    MRB_FIBER_TERMINATED

  mrb_context* {.importc,h.} = object 
    prev*: ptr mrb_context
    stack*: ptr mrb_value # stack of virtual machine 
    stbase*: ptr mrb_value
    stend*: ptr mrb_value
    ci*: ptr mrb_callinfo
    cibase*: ptr mrb_callinfo
    ciend*: ptr mrb_callinfo
    rescue*: ptr ptr mrb_code # exception handler stack 
    rsize*: cint
    ensure*: ptr ptr RProc # ensure handler stack 
    esize*: cint
    status*: mrb_fiber_state
    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 
  
  gc_state* {.importc,h.} = enum 
    GC_STATE_NONE = 0, GC_STATE_MARK, GC_STATE_SWEEP
 
  heap_page = object
  
  mrb_bool* = uint8
  
  mrb_pool*{.importc,h.} = object
  
  PState* = ptr mrb_state
  mrb_state* {.importc,h.} = object 
    jmp*: pointer
    allocf*: mrb_allocf     # memory allocation function 
    c*: ptr mrb_context
    root_c*: ptr mrb_context
    exc*: ptr RObject       # exception 
    globals*: ptr iv_tbl    # global variable table 
    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
    float_class*: ptr RClass
    fixnum_class*: ptr RClass
    true_class*: ptr RClass
    false_class*: ptr RClass
    nil_class*: ptr RClass
    symbol_class*: ptr RClass
    kernel_module*: ptr RClass
    heaps*: ptr heap_page   # heaps for GC 
    sweeps*: ptr heap_page
    free_heaps*: ptr heap_page
    live*: csize           # 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*: 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
    gc_threshold*: csize
    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
    mems*: pointer
    symidx*: mrb_sym
    name2sym*: pointer # kh_n2s   # symbol table \
                            ##ifdef ENABLE_DEBUG
    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
    ud*: pointer            # auxiliary data 

type
    mrb_vtype* {.importc,h.}= enum 
      MRB_TT_FALSE = 1,     #   1 
      MRB_TT_FREE,          #   2 
      MRB_TT_TRUE,          #   3 
      MRB_TT_FIXNUM,        #   4 
      MRB_TT_SYMBOL,        #   5 
      MRB_TT_UNDEF,         #   6 
      MRB_TT_FLOAT,         #   7 
      MRB_TT_CPTR,          #   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_FILE,          #  20 
      MRB_TT_ENV,           #  21 
      MRB_TT_DATA,          #  22 
      MRB_TT_FIBER,         #  23 
      MRB_TT_MAXDEFINE      #  24 

when defined(MRB_INT64): 
  type 
    mrb_int* = int64
  #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
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

type mrb_parser_state* {.importc,hc.} = object
{.push callconv: cdecl.}
{.push importc.}
{.push header:"<mruby.h>".}
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): 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
discard """
proc mrb_open_allocf*(a2: mrb_allocf; ud: pointer): ptr mrb_state {.importc.}
proc mrb_close*(a2: 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)) """

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"))
 """
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.}
 """
# 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.}
{.pop.}
{.pop.}

when isMainModule:

  var state: PState
  state = mrb_open()
  
  let v:mrb_value = state.mrb_load_string "p 'Hello, world!'"
  

test.c

//compile with `gcc -o test test.c -lm -lmruby`
#include <mruby.h>
#include <mruby/compile.h>

int main(void) {
mrb_state *state;
state = mrb_open();
mrb_load_string(state, "p 'Hello, world!'");

return 0;
}