add MRB_API modifiers to mruby API functions

src/array.c

@@ -51,14 +51,14 @@ ary_new_capa(mrb_state *mrb, mrb_int capa)
   return a;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_new_capa(mrb_state *mrb, mrb_int capa)
 {
   struct RArray *a = ary_new_capa(mrb, capa);
   return mrb_obj_value(a);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_new(mrb_state *mrb)
 {
   return mrb_ary_new_capa(mrb, 0);
@@ -88,7 +88,7 @@ array_copy(mrb_value *dst, const mrb_value *src, mrb_int size)
   }
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals)
 {
   mrb_value ary;
@@ -102,7 +102,7 @@ mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals)
   return ary;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr)
 {
   struct RArray *a;
@@ -153,7 +153,7 @@ ary_modify(mrb_state *mrb, struct RArray *a)
   }
 }
 
-void
+MRB_API void
 mrb_ary_modify(mrb_state *mrb, struct RArray* a)
 {
   mrb_write_barrier(mrb, (struct RBasic*)a);
@@ -227,7 +227,7 @@ ary_shrink_capa(mrb_state *mrb, struct RArray *a)
   }
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len)
 {
   mrb_int old_len;
@@ -272,7 +272,7 @@ ary_concat(mrb_state *mrb, struct RArray *a, mrb_value *ptr, mrb_int blen)
   a->len = len;
 }
 
-void
+MRB_API void
 mrb_ary_concat(mrb_state *mrb, mrb_value self, mrb_value other)
 {
   struct RArray *a2 = mrb_ary_ptr(other);
@@ -321,7 +321,7 @@ ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, mrb_int len)
   a->len = len;
 }
 
-void
+MRB_API void
 mrb_ary_replace(mrb_state *mrb, mrb_value self, mrb_value other)
 {
   struct RArray *a2 = mrb_ary_ptr(other);
@@ -410,7 +410,7 @@ mrb_ary_reverse(mrb_state *mrb, mrb_value self)
   return ary;
 }
 
-void
+MRB_API void
 mrb_ary_push(mrb_state *mrb, mrb_value ary, mrb_value elem)
 {
   struct RArray *a = mrb_ary_ptr(ary);
@@ -436,7 +436,7 @@ mrb_ary_push_m(mrb_state *mrb, mrb_value self)
   return self;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_pop(mrb_state *mrb, mrb_value ary)
 {
   struct RArray *a = mrb_ary_ptr(ary);
@@ -447,7 +447,7 @@ mrb_ary_pop(mrb_state *mrb, mrb_value ary)
 
 #define ARY_SHIFT_SHARED_MIN 10
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_shift(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
@@ -483,7 +483,7 @@ mrb_ary_shift(mrb_state *mrb, mrb_value self)
    item = 0
    self.unshift item
    p self #=> [0, 1, 2, 3] */
-mrb_value
+MRB_API mrb_value
 mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item)
 {
   struct RArray *a = mrb_ary_ptr(self);
@@ -536,7 +536,7 @@ mrb_ary_unshift_m(mrb_state *mrb, mrb_value self)
   return self;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n)
 {
   struct RArray *a = mrb_ary_ptr(ary);
@@ -548,7 +548,7 @@ mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n)
   return a->ptr[n];
 }
 
-void
+MRB_API void
 mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val)
 {
   struct RArray *a = mrb_ary_ptr(ary);
@@ -572,7 +572,7 @@ mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val)
   mrb_field_write_barrier_value(mrb, (struct RBasic*)a, val);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_value rpl)
 {
   struct RArray *a = mrb_ary_ptr(ary);
@@ -893,7 +893,7 @@ mrb_ary_rindex_m(mrb_state *mrb, mrb_value self)
   return mrb_nil_value();
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_splat(mrb_state *mrb, mrb_value v)
 {
   if (mrb_array_p(v)) {
@@ -915,7 +915,7 @@ mrb_ary_size(mrb_state *mrb, mrb_value self)
   return mrb_fixnum_value(a->len);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_clear(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
@@ -942,13 +942,13 @@ mrb_ary_empty_p(mrb_state *mrb, mrb_value self)
   return mrb_bool_value(a->len == 0);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_check_array_type(mrb_state *mrb, mrb_value ary)
 {
   return mrb_check_convert_type(mrb, ary, MRB_TT_ARRAY, "Array", "to_ary");
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_entry(mrb_value ary, mrb_int offset)
 {
   if (offset < 0) {
@@ -1012,7 +1012,7 @@ join_ary(mrb_state *mrb, mrb_value ary, mrb_value sep, mrb_value list)
   return result;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep)
 {
   sep = mrb_obj_as_string(mrb, sep);

src/backtrace.c

@@ -144,7 +144,7 @@ exc_output_backtrace(mrb_state *mrb, struct RObject *exc, output_stream_func fun
    overwritten.  So invoke these functions just after detecting exceptions.
 */
 
-void
+MRB_API void
 mrb_print_backtrace(mrb_state *mrb)
 {
   if (!mrb->exc || mrb_obj_is_kind_of(mrb, mrb_obj_value(mrb->exc), E_SYSSTACK_ERROR)) {
@@ -153,7 +153,7 @@ mrb_print_backtrace(mrb_state *mrb)
   exc_output_backtrace(mrb, mrb->exc, print_backtrace_i, (void*)stderr);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_exc_backtrace(mrb_state *mrb, mrb_value self)
 {
   mrb_value ary;
@@ -164,7 +164,7 @@ mrb_exc_backtrace(mrb_state *mrb, mrb_value self)
   return ary;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_get_backtrace(mrb_state *mrb)
 {
   mrb_value ary;
@@ -181,18 +181,18 @@ mrb_get_backtrace(mrb_state *mrb)
 
 #else
 
-void
+MRB_API void
 mrb_print_backtrace(mrb_state *mrb)
 {
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_exc_backtrace(mrb_state *mrb, mrb_value self)
 {
   return mrb_ary_new(mrb);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_get_backtrace(mrb_state *mrb)
 {
   return mrb_ary_new(mrb);

src/class.c

@@ -122,7 +122,7 @@ module_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id)
   return mrb_class_ptr(c);
 }
 
-struct RClass*
+MRB_API struct RClass*
 mrb_class_outer_module(mrb_state *mrb, struct RClass *c)
 {
   mrb_value outer;
@@ -146,25 +146,25 @@ define_module(mrb_state *mrb, mrb_sym name, struct RClass *outer)
   return m;
 }
 
-struct RClass*
+MRB_API struct RClass*
 mrb_define_module_id(mrb_state *mrb, mrb_sym name)
 {
   return define_module(mrb, name, mrb->object_class);
 }
 
-struct RClass*
+MRB_API struct RClass*
 mrb_define_module(mrb_state *mrb, const char *name)
 {
   return define_module(mrb, mrb_intern_cstr(mrb, name), mrb->object_class);
 }
 
-struct RClass*
+MRB_API struct RClass*
 mrb_vm_define_module(mrb_state *mrb, mrb_value outer, mrb_sym id)
 {
   return define_module(mrb, id, mrb_class_ptr(outer));
 }
 
-struct RClass *
+MRB_API struct RClass*
 mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name)
 {
   mrb_sym id = mrb_intern_cstr(mrb, name);
@@ -195,7 +195,7 @@ define_class(mrb_state *mrb, mrb_sym name, struct RClass *super, struct RClass *
   return c;
 }
 
-struct RClass*
+MRB_API struct RClass*
 mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super)
 {
   if (!super) {
@@ -204,7 +204,7 @@ mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super)
   return define_class(mrb, name, super, mrb->object_class);
 }
 
-struct RClass*
+MRB_API struct RClass*
 mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super)
 {
   return mrb_define_class_id(mrb, mrb_intern_cstr(mrb, name), super);
@@ -218,7 +218,7 @@ mrb_class_inherited(mrb_state *mrb, struct RClass *super, struct RClass *klass)
   mrb_funcall(mrb, mrb_obj_value(super), "inherited", 1, mrb_obj_value(klass));
 }
 
-struct RClass*
+MRB_API struct RClass*
 mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id)
 {
   struct RClass *s;
@@ -248,7 +248,7 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id
   return c;
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_class_defined(mrb_state *mrb, const char *name)
 {
   mrb_value sym = mrb_check_intern_cstr(mrb, name);
@@ -258,25 +258,25 @@ mrb_class_defined(mrb_state *mrb, const char *name)
   return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), mrb_symbol(sym));
 }
 
-struct RClass *
+MRB_API struct RClass *
 mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
 {
   return class_from_sym(mrb, outer, mrb_intern_cstr(mrb, name));
 }
 
-struct RClass *
+MRB_API struct RClass *
 mrb_class_get(mrb_state *mrb, const char *name)
 {
   return mrb_class_get_under(mrb, mrb->object_class, name);
 }
 
-struct RClass *
+MRB_API struct RClass *
 mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
 {
   return module_from_sym(mrb, outer, mrb_intern_cstr(mrb, name));
 }
 
-struct RClass *
+MRB_API struct RClass *
 mrb_module_get(mrb_state *mrb, const char *name)
 {
   return mrb_module_get_under(mrb, mrb->object_class, name);
@@ -298,7 +298,7 @@ mrb_module_get(mrb_state *mrb, const char *name)
  * \note if a class named \a name is already defined and its superclass is
  *       \a super, the function just returns the defined class.
  */
-struct RClass *
+MRB_API struct RClass *
 mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super)
 {
   mrb_sym id = mrb_intern_cstr(mrb, name);
@@ -315,7 +315,7 @@ mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, s
   return c;
 }
 
-void
+MRB_API void
 mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, struct RProc *p)
 {
   khash_t(mt) *h = c->mt;
@@ -329,7 +329,7 @@ mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, struct RPro
   }
 }
 
-void
+MRB_API void
 mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec)
 {
   struct RProc *p;
@@ -341,13 +341,13 @@ mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t f
   mrb_gc_arena_restore(mrb, ai);
 }
 
-void
+MRB_API void
 mrb_define_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
 {
   mrb_define_method_id(mrb, c, mrb_intern_cstr(mrb, name), func, aspec);
 }
 
-void
+MRB_API void
 mrb_define_method_vm(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_value body)
 {
   khash_t(mt) *h = c->mt;
@@ -422,7 +422,7 @@ to_hash(mrb_state *mrb, mrb_value val)
     |:      optional                              Next argument of '|' and later are optional.
     ?:      optional given [mrb_bool]             true if preceding argument (optional) is given.
  */
-mrb_int
+MRB_API mrb_int
 mrb_get_args(mrb_state *mrb, const char *format, ...)
 {
   char c;
@@ -543,9 +543,9 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
     case 'z':
       {
         mrb_value ss;
-        char **ps;
+        const char **ps;
 
-        ps = va_arg(ap, char**);
+        ps = va_arg(ap, const char**);
         if (i < argc) {
           ss = to_str(mrb, *sp++);
           *ps = mrb_string_value_cstr(mrb, &ss);
@@ -739,7 +739,7 @@ boot_defclass(mrb_state *mrb, struct RClass *super)
   return c;
 }
 
-void
+MRB_API void
 mrb_include_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
 {
   struct RClass *ins_pos;
@@ -989,27 +989,27 @@ mrb_singleton_class(mrb_state *mrb, mrb_value v)
   return mrb_obj_value(obj->c);
 }
 
-void
+MRB_API void
 mrb_define_singleton_method(mrb_state *mrb, struct RObject *o, const char *name, mrb_func_t func, mrb_aspec aspec)
 {
   prepare_singleton_class(mrb, (struct RBasic*)o);
   mrb_define_method_id(mrb, o->c, mrb_intern_cstr(mrb, name), func, aspec);
 }
 
-void
+MRB_API void
 mrb_define_class_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
 {
   mrb_define_singleton_method(mrb, (struct RObject*)c, name, func, aspec);
 }
 
-void
+MRB_API void
 mrb_define_module_function(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
 {
   mrb_define_class_method(mrb, c, name, func, aspec);
   mrb_define_method(mrb, c, name, func, aspec);
 }
 
-struct RProc*
+MRB_API struct RProc*
 mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
 {
   khiter_t k;
@@ -1033,7 +1033,7 @@ mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
   return 0;                  /* no method */
 }
 
-struct RProc*
+MRB_API struct RProc*
 mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid)
 {
   struct RProc *m;
@@ -1077,7 +1077,7 @@ mrb_instance_alloc(mrb_state *mrb, mrb_value cv)
  *
  */
 
-mrb_value
+MRB_API mrb_value
 mrb_instance_new(mrb_state *mrb, mrb_value cv)
 {
   mrb_value obj, blk;
@@ -1091,7 +1091,7 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv)
   return obj;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv)
 {
   mrb_value obj;
@@ -1221,7 +1221,7 @@ mrb_bob_missing(mrb_state *mrb, mrb_value mod)
   return mrb_nil_value();
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mid)
 {
   khiter_t k;
@@ -1245,13 +1245,13 @@ mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mid)
   return FALSE;         /* no method */
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid)
 {
   return mrb_obj_respond_to(mrb, mrb_class(mrb, obj), mid);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_class_path(mrb_state *mrb, struct RClass *c)
 {
   mrb_value path;
@@ -1291,7 +1291,7 @@ mrb_class_path(mrb_state *mrb, struct RClass *c)
   return path;
 }
 
-struct RClass *
+MRB_API struct RClass *
 mrb_class_real(struct RClass* cl)
 {
   if (cl == 0)
@@ -1302,7 +1302,7 @@ mrb_class_real(struct RClass* cl)
   return cl;
 }
 
-const char*
+MRB_API const char*
 mrb_class_name(mrb_state *mrb, struct RClass* c)
 {
   mrb_value path = mrb_class_path(mrb, c);
@@ -1314,7 +1314,7 @@ mrb_class_name(mrb_state *mrb, struct RClass* c)
   return RSTRING_PTR(path);
 }
 
-const char*
+MRB_API const char*
 mrb_obj_classname(mrb_state *mrb, mrb_value obj)
 {
   return mrb_class_name(mrb, mrb_obj_class(mrb, obj));
@@ -1346,7 +1346,7 @@ mrb_check_inheritable(mrb_state *mrb, struct RClass *super)
  * \exception TypeError \a super is not inheritable.
  * \exception TypeError \a super is the Class class.
  */
-struct RClass *
+MRB_API struct RClass*
 mrb_class_new(mrb_state *mrb, struct RClass *super)
 {
   struct RClass *c;
@@ -1366,7 +1366,7 @@ mrb_class_new(mrb_state *mrb, struct RClass *super)
 /*!
  * Creates a new module.
  */
-struct RClass *
+MRB_API struct RClass*
 mrb_module_new(mrb_state *mrb)
 {
   struct RClass *m = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_MODULE, mrb->module_class);
@@ -1389,13 +1389,13 @@ mrb_module_new(mrb_state *mrb)
  *     self.class   #=> Object
  */
 
-struct RClass*
+MRB_API struct RClass*
 mrb_obj_class(mrb_state *mrb, mrb_value obj)
 {
     return mrb_class_real(mrb_class(mrb, obj));
 }
 
-void
+MRB_API void
 mrb_alias_method(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b)
 {
   struct RProc *m = mrb_method_search(mrb, c, b);
@@ -1505,13 +1505,13 @@ undef_method(mrb_state *mrb, struct RClass *c, mrb_sym a)
   }
 }
 
-void
+MRB_API void
 mrb_undef_method(mrb_state *mrb, struct RClass *c, const char *name)
 {
   undef_method(mrb, c, mrb_intern_cstr(mrb, name));
 }
 
-void
+MRB_API void
 mrb_undef_class_method(mrb_state *mrb, struct RClass *c, const char *name)
 {
   mrb_undef_method(mrb,  mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name);
@@ -1946,7 +1946,7 @@ mrb_mod_eqq(mrb_state *mrb, mrb_value mod)
   return mrb_bool_value(eqq);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_mod_module_function(mrb_state *mrb, mrb_value mod)
 {
   mrb_value *argv;

src/debug.c

@@ -49,7 +49,7 @@ select_line_type(const uint16_t *lines, size_t lines_len)
       ? mrb_debug_line_ary : mrb_debug_line_flat_map;
 }
 
-char const*
+MRB_API char const*
 mrb_debug_get_filename(mrb_irep *irep, uint32_t pc)
 {
   if (irep && pc < irep->ilen) {
@@ -62,7 +62,7 @@ mrb_debug_get_filename(mrb_irep *irep, uint32_t pc)
   return NULL;
 }
 
-int32_t
+MRB_API int32_t
 mrb_debug_get_line(mrb_irep *irep, uint32_t pc)
 {
   if (irep && pc < irep->ilen) {
@@ -106,7 +106,7 @@ mrb_debug_get_line(mrb_irep *irep, uint32_t pc)
   return -1;
 }
 
-mrb_irep_debug_info *
+MRB_API mrb_irep_debug_info *
 mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep)
 {
   static const mrb_irep_debug_info initial = { 0, 0, NULL };
@@ -119,7 +119,7 @@ mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep)
   return ret;
 }
 
-mrb_irep_debug_info_file *
+MRB_API mrb_irep_debug_info_file *
 mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
                            uint32_t start_pos, uint32_t end_pos)
 {
@@ -198,7 +198,7 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
   return ret;
 }
 
-void
+MRB_API void
 mrb_debug_info_free(mrb_state *mrb, mrb_irep_debug_info *d)
 {
   uint32_t i;

src/error.c

@@ -18,14 +18,14 @@
 #include "mruby/class.h"
 #include "mrb_throw.h"
 
-mrb_value
+MRB_API mrb_value
 mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len)
 {
   mrb_value arg = mrb_str_new(mrb, ptr, len);
   return mrb_obj_new(mrb, c, 1, &arg);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str)
 {
   str = mrb_str_to_str(mrb, str);
@@ -202,7 +202,7 @@ exc_debug_info(mrb_state *mrb, struct RObject *exc)
   }
 }
 
-mrb_noreturn void
+MRB_API mrb_noreturn void
 mrb_exc_raise(mrb_state *mrb, mrb_value exc)
 {
   mrb->exc = mrb_obj_ptr(exc);
@@ -216,7 +216,7 @@ mrb_exc_raise(mrb_state *mrb, mrb_value exc)
   MRB_THROW(mrb->jmp);
 }
 
-mrb_noreturn void
+MRB_API mrb_noreturn void
 mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg)
 {
   mrb_value mesg;
@@ -224,7 +224,7 @@ mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg)
   mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mesg));
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_vformat(mrb_state *mrb, const char *format, va_list ap)
 {
   const char *p = format;
@@ -265,7 +265,7 @@ mrb_vformat(mrb_state *mrb, const char *format, va_list ap)
   }
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_format(mrb_state *mrb, const char *format, ...)
 {
   va_list ap;
@@ -278,7 +278,7 @@ mrb_format(mrb_state *mrb, const char *format, ...)
   return str;
 }
 
-mrb_noreturn void
+MRB_API mrb_noreturn void
 mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...)
 {
   va_list args;
@@ -290,7 +290,7 @@ mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...)
   mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mesg));
 }
 
-mrb_noreturn void
+MRB_API mrb_noreturn void
 mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...)
 {
   mrb_value exc;
@@ -306,7 +306,7 @@ mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...)
   mrb_exc_raise(mrb, exc);
 }
 
-void
+MRB_API void
 mrb_warn(mrb_state *mrb, const char *fmt, ...)
 {
 #ifdef ENABLE_STDIO
@@ -321,7 +321,7 @@ mrb_warn(mrb_state *mrb, const char *fmt, ...)
 #endif
 }
 
-mrb_noreturn void
+MRB_API mrb_noreturn void
 mrb_bug(mrb_state *mrb, const char *fmt, ...)
 {
 #ifdef ENABLE_STDIO
@@ -396,13 +396,13 @@ exception_call:
   return mesg;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_make_exception(mrb_state *mrb, int argc, const mrb_value *argv)
 {
   return make_exception(mrb, argc, argv, TRUE);
 }
 
-void
+MRB_API void
 mrb_sys_fail(mrb_state *mrb, const char *mesg)
 {
   struct RClass *sce;
@@ -423,7 +423,7 @@ mrb_sys_fail(mrb_state *mrb, const char *mesg)
   }
 }
 
-mrb_noreturn void
+MRB_API mrb_noreturn void
 mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_int argc, const mrb_value *argv, char const* fmt, ...)
 {
   mrb_value exc;

src/etc.c

@@ -11,7 +11,7 @@
 #include "mruby/re.h"
 #include "mruby/irep.h"
 
-struct RData*
+MRB_API struct RData*
 mrb_data_object_alloc(mrb_state *mrb, struct RClass *klass, void *ptr, const mrb_data_type *type)
 {
   struct RData *data;
@@ -23,7 +23,7 @@ mrb_data_object_alloc(mrb_state *mrb, struct RClass *klass, void *ptr, const mrb
   return data;
 }
 
-void
+MRB_API void
 mrb_data_check_type(mrb_state *mrb, mrb_value obj, const mrb_data_type *type)
 {
   if (mrb_special_const_p(obj) || (mrb_type(obj) != MRB_TT_DATA)) {
@@ -45,7 +45,7 @@ mrb_data_check_type(mrb_state *mrb, mrb_value obj, const mrb_data_type *type)
   }
 }
 
-void *
+MRB_API void*
 mrb_data_check_get_ptr(mrb_state *mrb, mrb_value obj, const mrb_data_type *type)
 {
   if (mrb_special_const_p(obj) || (mrb_type(obj) != MRB_TT_DATA)) {
@@ -57,14 +57,14 @@ mrb_data_check_get_ptr(mrb_state *mrb, mrb_value obj, const mrb_data_type *type)
   return DATA_PTR(obj);
 }
 
-void *
+MRB_API void*
 mrb_data_get_ptr(mrb_state *mrb, mrb_value obj, const mrb_data_type *type)
 {
   mrb_data_check_type(mrb, obj, type);
   return DATA_PTR(obj);
 }
 
-mrb_sym
+MRB_API mrb_sym
 mrb_obj_to_sym(mrb_state *mrb, mrb_value name)
 {
   mrb_value tmp;
@@ -88,7 +88,7 @@ mrb_obj_to_sym(mrb_state *mrb, mrb_value name)
   return id;
 }
 
-mrb_int
+MRB_API mrb_int
 mrb_float_id(mrb_float f)
 {
   const char *p = (const char*)&f;
@@ -104,7 +104,7 @@ mrb_float_id(mrb_float f)
   return id;
 }
 
-mrb_int
+MRB_API mrb_int
 mrb_obj_id(mrb_value obj)
 {
   mrb_int tt = mrb_type(obj);
@@ -147,7 +147,7 @@ mrb_obj_id(mrb_value obj)
 }
 
 #ifdef MRB_WORD_BOXING
-mrb_value
+MRB_API mrb_value
 mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f)
 {
   mrb_value v;
@@ -157,7 +157,7 @@ mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f)
   return v;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_word_boxing_float_pool(mrb_state *mrb, mrb_float f)
 {
   struct RFloat *nf = (struct RFloat *)mrb_malloc(mrb, sizeof(struct RFloat));
@@ -167,7 +167,7 @@ mrb_word_boxing_float_pool(mrb_state *mrb, mrb_float f)
   return mrb_obj_value(nf);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_word_boxing_cptr_value(mrb_state *mrb, void *p)
 {
   mrb_value v;
@@ -178,7 +178,7 @@ mrb_word_boxing_cptr_value(mrb_state *mrb, void *p)
 }
 #endif  /* MRB_WORD_BOXING */
 
-mrb_bool
+MRB_API mrb_bool
 mrb_regexp_p(mrb_state *mrb, mrb_value v)
 {
   return mrb_class_defined(mrb, REGEXP_CLASS) && mrb_obj_is_kind_of(mrb, v, mrb_class_get(mrb, REGEXP_CLASS));

src/gc.c

@@ -168,7 +168,7 @@ gettimeofday_time(void)
 #define GC_STEP_SIZE 1024
 
 
-void*
+MRB_API void*
 mrb_realloc_simple(mrb_state *mrb, void *p,  size_t len)
 {
   void *p2;
@@ -183,7 +183,7 @@ mrb_realloc_simple(mrb_state *mrb, void *p,  size_t len)
 }
 
 
-void*
+MRB_API void*
 mrb_realloc(mrb_state *mrb, void *p, size_t len)
 {
   void *p2;
@@ -205,19 +205,19 @@ mrb_realloc(mrb_state *mrb, void *p, size_t len)
   return p2;
 }
 
-void*
+MRB_API void*
 mrb_malloc(mrb_state *mrb, size_t len)
 {
   return mrb_realloc(mrb, 0, len);
 }
 
-void*
+MRB_API void*
 mrb_malloc_simple(mrb_state *mrb, size_t len)
 {
   return mrb_realloc_simple(mrb, 0, len);
 }
 
-void*
+MRB_API void*
 mrb_calloc(mrb_state *mrb, size_t nelem, size_t len)
 {
   void *p;
@@ -239,7 +239,7 @@ mrb_calloc(mrb_state *mrb, size_t nelem, size_t len)
   return p;
 }
 
-void
+MRB_API void
 mrb_free(mrb_state *mrb, void *p)
 {
   (mrb->allocf)(mrb, p, 0, mrb->allocf_ud);
@@ -386,14 +386,14 @@ gc_protect(mrb_state *mrb, struct RBasic *p)
   mrb->arena[mrb->arena_idx++] = p;
 }
 
-void
+MRB_API void
 mrb_gc_protect(mrb_state *mrb, mrb_value obj)
 {
   if (mrb_special_const_p(obj)) return;
   gc_protect(mrb, mrb_basic_ptr(obj));
 }
 
-struct RBasic*
+MRB_API struct RBasic*
 mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls)
 {
   struct RBasic *p;
@@ -989,7 +989,7 @@ clear_all_old(mrb_state *mrb)
   mrb->atomic_gray_list = mrb->gray_list = NULL;
 }
 
-void
+MRB_API void
 mrb_incremental_gc(mrb_state *mrb)
 {
   if (mrb->gc_disabled) return;
@@ -1027,7 +1027,7 @@ mrb_incremental_gc(mrb_state *mrb)
 }
 
 /* Perform a full gc cycle */
-void
+MRB_API void
 mrb_full_gc(mrb_state *mrb)
 {
   if (mrb->gc_disabled) return;
@@ -1055,19 +1055,19 @@ mrb_full_gc(mrb_state *mrb)
   GC_TIME_STOP_AND_REPORT;
 }
 
-void
+MRB_API void
 mrb_garbage_collect(mrb_state *mrb)
 {
   mrb_full_gc(mrb);
 }
 
-int
+MRB_API int
 mrb_gc_arena_save(mrb_state *mrb)
 {
   return mrb->arena_idx;
 }
 
-void
+MRB_API void
 mrb_gc_arena_restore(mrb_state *mrb, int idx)
 {
 #ifndef MRB_GC_FIXED_ARENA
@@ -1092,7 +1092,7 @@ mrb_gc_arena_restore(mrb_state *mrb, int idx)
  *   Paint obj(Black) -> value(White) to obj(Black) -> value(Gray).
  */
 
-void
+MRB_API void
 mrb_field_write_barrier(mrb_state *mrb, struct RBasic *obj, struct RBasic *value)
 {
   if (!is_black(obj)) return;
@@ -1119,7 +1119,7 @@ mrb_field_write_barrier(mrb_state *mrb, struct RBasic *obj, struct RBasic *value
  *   e.g. Set element on Array.
  */
 
-void
+MRB_API void
 mrb_write_barrier(mrb_state *mrb, struct RBasic *obj)
 {
   if (!is_black(obj)) return;

src/hash.c

@@ -144,7 +144,7 @@ mrb_gc_free_hash(mrb_state *mrb, struct RHash *hash)
 }
 
 
-mrb_value
+MRB_API mrb_value
 mrb_hash_new_capa(mrb_state *mrb, int capa)
 {
   struct RHash *h;
@@ -158,13 +158,13 @@ mrb_hash_new_capa(mrb_state *mrb, int capa)
   return mrb_obj_value(h);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_hash_new(mrb_state *mrb)
 {
   return mrb_hash_new_capa(mrb, 0);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
@@ -183,7 +183,7 @@ mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
   return RHASH_IFNONE(hash);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
@@ -199,7 +199,7 @@ mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def)
   return def;
 }
 
-void
+MRB_API void
 mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val)
 {
   khash_t(ht) *h;
@@ -253,13 +253,13 @@ mrb_hash_dup(mrb_state *mrb, mrb_value hash)
   return mrb_obj_value(ret);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_check_hash_type(mrb_state *mrb, mrb_value hash)
 {
   return mrb_check_convert_type(mrb, hash, MRB_TT_HASH, "Hash", "to_hash");
 }
 
-khash_t(ht) *
+MRB_API khash_t(ht)*
 mrb_hash_tbl(mrb_state *mrb, mrb_value hash)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
@@ -478,7 +478,7 @@ mrb_hash_set_default_proc(mrb_state *mrb, mrb_value hash)
   return ifnone;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
@@ -588,7 +588,7 @@ mrb_hash_shift(mrb_state *mrb, mrb_value hash)
  *
  */
 
-mrb_value
+MRB_API mrb_value
 mrb_hash_clear(mrb_state *mrb, mrb_value hash)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
@@ -659,7 +659,7 @@ mrb_hash_size_m(mrb_state *mrb, mrb_value self)
  *     {}.empty?   #=> true
  *
  */
-mrb_value
+MRB_API mrb_value
 mrb_hash_empty_p(mrb_state *mrb, mrb_value self)
 {
   khash_t(ht) *h = RHASH_TBL(self);
@@ -695,7 +695,7 @@ mrb_hash_to_hash(mrb_state *mrb, mrb_value hash)
  *
  */
 
-mrb_value
+MRB_API mrb_value
 mrb_hash_keys(mrb_state *mrb, mrb_value hash)
 {
   khash_t(ht) *h = RHASH_TBL(hash);

src/kernel.c

@@ -49,7 +49,7 @@ mrb_obj_basic_to_s_p(mrb_state *mrb, mrb_value obj)
  *     [ 1, 2, 3..4, 'five' ].inspect   #=> "[1, 2, 3..4, \"five\"]"
  *     Time.new.inspect                 #=> "2008-03-08 19:43:39 +0900"
  */
-mrb_value
+MRB_API mrb_value
 mrb_obj_inspect(mrb_state *mrb, mrb_value obj)
 {
   if ((mrb_type(obj) == MRB_TT_OBJECT) && mrb_obj_basic_to_s_p(mrb, obj)) {
@@ -311,7 +311,7 @@ init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj)
  *
  *  Some Class(True False Nil Symbol Fixnum Float) Object  cannot clone.
  */
-mrb_value
+MRB_API mrb_value
 mrb_obj_clone(mrb_state *mrb, mrb_value self)
 {
   struct RObject *p;
@@ -347,7 +347,7 @@ mrb_obj_clone(mrb_state *mrb, mrb_value self)
  *  the class.
  */
 
-mrb_value
+MRB_API mrb_value
 mrb_obj_dup(mrb_state *mrb, mrb_value obj)
 {
   struct RBasic *p;
@@ -427,7 +427,7 @@ mrb_obj_extend_m(mrb_state *mrb, mrb_value self)
  *  <code>Hash</code>. Any hash value that exceeds the capacity of a
  *  <code>Fixnum</code> will be truncated before being used.
  */
-mrb_value
+MRB_API mrb_value
 mrb_obj_hash(mrb_state *mrb, mrb_value self)
 {
   return mrb_fixnum_value(mrb_obj_id(self));
@@ -451,7 +451,7 @@ mrb_obj_init_copy(mrb_state *mrb, mrb_value self)
 /* implementation of instance_eval */
 mrb_value mrb_obj_instance_eval(mrb_state*, mrb_value);
 
-mrb_bool
+MRB_API mrb_bool
 mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c)
 {
   if (mrb_obj_class(mrb, obj) == c) return TRUE;
@@ -855,7 +855,7 @@ mrb_obj_public_methods(mrb_state *mrb, mrb_value self)
  *     raise "Failed to create socket"
  *     raise ArgumentError, "No parameters", caller
  */
-mrb_value
+MRB_API mrb_value
 mrb_f_raise(mrb_state *mrb, mrb_value self)
 {
   mrb_value a[2], exc;

src/load.c

@@ -506,7 +506,7 @@ read_binary_header(const uint8_t *bin, size_t *bin_size, uint16_t *crc)
   return MRB_DUMP_OK;
 }
 
-mrb_irep*
+MRB_API mrb_irep*
 mrb_read_irep(mrb_state *mrb, const uint8_t *bin)
 {
   int result;
@@ -570,7 +570,7 @@ irep_error(mrb_state *mrb)
   mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "irep load error"));
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_load_irep_cxt(mrb_state *mrb, const uint8_t *bin, mrbc_context *c)
 {
   mrb_irep *irep = mrb_read_irep(mrb, bin);
@@ -588,7 +588,7 @@ mrb_load_irep_cxt(mrb_state *mrb, const uint8_t *bin, mrbc_context *c)
   return val;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_load_irep(mrb_state *mrb, const uint8_t *bin)
 {
   return mrb_load_irep_cxt(mrb, bin, NULL);
@@ -688,7 +688,7 @@ read_section_irep_file(mrb_state *mrb, FILE *fp)
   return read_irep_record_file(mrb, fp);
 }
 
-mrb_irep*
+MRB_API mrb_irep*
 mrb_read_irep_file(mrb_state *mrb, FILE* fp)
 {
   mrb_irep *irep = NULL;
@@ -801,7 +801,7 @@ mrb_read_irep_file(mrb_state *mrb, FILE* fp)
 
 void mrb_codedump_all(mrb_state*, struct RProc*);
 
-mrb_value
+MRB_API mrb_value
 mrb_load_irep_file_cxt(mrb_state *mrb, FILE* fp, mrbc_context *c)
 {
   mrb_irep *irep = mrb_read_irep_file(mrb, fp);
@@ -820,7 +820,7 @@ mrb_load_irep_file_cxt(mrb_state *mrb, FILE* fp, mrbc_context *c)
   return val;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_load_irep_file(mrb_state *mrb, FILE* fp)
 {
   return mrb_load_irep_file_cxt(mrb, fp, NULL);

src/numeric.c

@@ -27,7 +27,7 @@
 #define FLO_EPSILON DBL_EPSILON
 #endif
 
-mrb_float
+MRB_API mrb_float
 mrb_to_flo(mrb_state *mrb, mrb_value val)
 {
   switch (mrb_type(val)) {
@@ -76,7 +76,7 @@ num_pow(mrb_state *mrb, mrb_value x)
  * result.
  */
 
-mrb_value
+MRB_API mrb_value
 mrb_num_div(mrb_state *mrb, mrb_value x, mrb_value y)
 {
   return mrb_float_value(mrb, mrb_to_flo(mrb, x) / mrb_to_flo(mrb, y));
@@ -1076,7 +1076,7 @@ fix_to_f(mrb_state *mrb, mrb_value num)
  *     FloatDomainError: Infinity
  */
 /* ------------------------------------------------------------------------*/
-mrb_value
+MRB_API mrb_value
 mrb_flo_to_fixnum(mrb_state *mrb, mrb_value x)
 {
   mrb_int z;
@@ -1174,7 +1174,7 @@ fix_minus(mrb_state *mrb, mrb_value self)
 }
 
 
-mrb_value
+MRB_API mrb_value
 mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, int base)
 {
   char buf[MRB_INT_BIT+1];

src/object.c

@@ -9,7 +9,7 @@
 #include "mruby/numeric.h"
 #include "mruby/string.h"
 
-mrb_bool
+MRB_API mrb_bool
 mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
 {
   if (mrb_type(v1) != mrb_type(v2)) return FALSE;
@@ -31,14 +31,14 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
   }
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_obj_equal(mrb_state *mrb, mrb_value v1, mrb_value v2)
 {
   /* temporary definition */
   return mrb_obj_eq(mrb, v1, v2);
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
 {
   mrb_value result;
@@ -319,7 +319,7 @@ convert_type(mrb_state *mrb, mrb_value val, const char *tname, const char *metho
   return mrb_funcall_argv(mrb, val, m, 0, 0);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method)
 {
   mrb_value v;
@@ -332,7 +332,7 @@ mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method)
   return v;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method)
 {
   mrb_value v;
@@ -346,7 +346,7 @@ mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char
   return v;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method)
 {
   mrb_value v;
@@ -386,7 +386,7 @@ static const struct types {
     {-1,  0}
 };
 
-void
+MRB_API void
 mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
 {
   const struct types *type = builtin_types;
@@ -434,7 +434,7 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
  *  initial execution context of Ruby programs returns ``main.''
  */
 
-mrb_value
+MRB_API mrb_value
 mrb_any_to_s(mrb_state *mrb, mrb_value obj)
 {
   mrb_value str = mrb_str_buf_new(mrb, 20);
@@ -475,7 +475,7 @@ mrb_any_to_s(mrb_state *mrb, mrb_value obj)
  *     b.kind_of? M       #=> true
  */
 
-mrb_bool
+MRB_API mrb_bool
 mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c)
 {
   struct RClass *cl = mrb_class(mrb, obj);
@@ -513,7 +513,7 @@ mrb_to_integer(mrb_state *mrb, mrb_value val, const char *method)
   return v;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_to_int(mrb_state *mrb, mrb_value val)
 {
   return mrb_to_integer(mrb, val, "to_int");
@@ -558,13 +558,13 @@ arg_error:
   return tmp;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_Integer(mrb_state *mrb, mrb_value val)
 {
   return mrb_convert_to_integer(mrb, val, 0);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_Float(mrb_state *mrb, mrb_value val)
 {
   if (mrb_nil_p(val)) {
@@ -585,13 +585,13 @@ mrb_Float(mrb_state *mrb, mrb_value val)
   }
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_inspect(mrb_state *mrb, mrb_value obj)
 {
   return mrb_obj_as_string(mrb, mrb_funcall(mrb, obj, "inspect", 0));
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
 {
   if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;

src/print.c

@@ -23,7 +23,7 @@ printstr(mrb_state *mrb, mrb_value obj)
 #endif
 }
 
-void
+MRB_API void
 mrb_p(mrb_state *mrb, mrb_value obj)
 {
 #ifdef ENABLE_STDIO
@@ -33,7 +33,7 @@ mrb_p(mrb_state *mrb, mrb_value obj)
 #endif
 }
 
-void
+MRB_API void
 mrb_print_error(mrb_state *mrb)
 {
 #ifdef ENABLE_STDIO
@@ -48,7 +48,7 @@ mrb_print_error(mrb_state *mrb)
 #endif
 }
 
-void
+MRB_API void
 mrb_show_version(mrb_state *mrb)
 {
   mrb_value msg;
@@ -58,7 +58,7 @@ mrb_show_version(mrb_state *mrb)
   printstr(mrb, mrb_str_new_lit(mrb, "\n"));
 }
 
-void
+MRB_API void
 mrb_show_copyright(mrb_state *mrb)
 {
   mrb_value msg;

src/proc.c

@@ -75,7 +75,7 @@ mrb_proc_new_cfunc(mrb_state *mrb, mrb_func_t func)
   return p;
 }
 
-struct RProc *
+MRB_API struct RProc *
 mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals)
 {
   struct RProc *p = mrb_proc_new_cfunc(mrb, func);

src/range.c

@@ -33,7 +33,7 @@ range_check(mrb_state *mrb, mrb_value a, mrb_value b)
   }
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_range_new(mrb_state *mrb, mrb_value beg, mrb_value end, mrb_bool excl)
 {
   struct RRange *r;
@@ -234,7 +234,7 @@ mrb_range_include(mrb_state *mrb, mrb_value range)
   return mrb_bool_value(include_p);
 }
 
-mrb_bool
+MRB_API mrb_bool
 range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_bool trunc)
 {
   mrb_int beg, end, b, e;

src/state.c

@@ -22,7 +22,7 @@ inspect_main(mrb_state *mrb, mrb_value mod)
   return mrb_str_new_lit(mrb, "main");
 }
 
-mrb_state*
+MRB_API mrb_state*
 mrb_open_core(mrb_allocf f, void *ud)
 {
   static const mrb_state mrb_state_zero = { 0 };
@@ -70,7 +70,7 @@ struct alloca_header {
   char buf[];
 };
 
-void*
+MRB_API void*
 mrb_alloca(mrb_state *mrb, size_t size)
 {
   struct alloca_header *p;
@@ -97,7 +97,7 @@ mrb_alloca_free(mrb_state *mrb)
   }
 }
 
-mrb_state*
+MRB_API mrb_state*
 mrb_open(void)
 {
   mrb_state *mrb = mrb_open_allocf(mrb_default_allocf, NULL);
@@ -105,7 +105,7 @@ mrb_open(void)
   return mrb;
 }
 
-mrb_state*
+MRB_API mrb_state*
 mrb_open_allocf(mrb_allocf f, void *ud)
 {
   mrb_state *mrb = mrb_open_core(f, ud);
@@ -216,7 +216,7 @@ mrb_str_pool(mrb_state *mrb, mrb_value str)
   return mrb_obj_value(ns);
 }
 
-void
+MRB_API void
 mrb_free_context(mrb_state *mrb, struct mrb_context *c)
 {
   if (!c) return;
@@ -227,7 +227,7 @@ mrb_free_context(mrb_state *mrb, struct mrb_context *c)
   mrb_free(mrb, c);
 }
 
-void
+MRB_API void
 mrb_close(mrb_state *mrb)
 {
   if (mrb->atexit_stack_len > 0) {
@@ -265,7 +265,7 @@ mrb_add_irep(mrb_state *mrb)
   return irep;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_top_self(mrb_state *mrb)
 {
   if (!mrb->top_self) {
@@ -276,7 +276,7 @@ mrb_top_self(mrb_state *mrb)
   return mrb_obj_value(mrb->top_self);
 }
 
-void
+MRB_API void
 mrb_state_atexit(mrb_state *mrb, mrb_atexit_func f)
 {
 #ifdef MRB_FIXED_STATE_ATEXIT_STACK

src/string.c

@@ -29,7 +29,7 @@ typedef struct mrb_shared_string {
 static mrb_value str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2);
 static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len);
 
-mrb_int
+MRB_API mrb_int
 mrb_str_strlen(mrb_state *mrb, struct RString *s)
 {
   mrb_int i, max = RSTR_LEN(s);
@@ -76,7 +76,7 @@ str_decref(mrb_state *mrb, mrb_shared_string *shared)
   }
 }
 
-void
+MRB_API void
 mrb_str_modify(mrb_state *mrb, struct RString *s)
 {
   if (RSTR_SHARED_P(s)) {
@@ -120,7 +120,7 @@ mrb_str_modify(mrb_state *mrb, struct RString *s)
   }
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len)
 {
   mrb_int slen;
@@ -186,7 +186,7 @@ mrb_str_new_empty(mrb_state *mrb, mrb_value str)
 # define MRB_STR_BUF_MIN_SIZE 128
 #endif
 
-mrb_value
+MRB_API mrb_value
 mrb_str_buf_new(mrb_state *mrb, size_t capa)
 {
   struct RString *s;
@@ -248,7 +248,7 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, size_t len)
   RSTR_PTR(s)[total] = '\0';   /* sentinel */
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_str_new(mrb_state *mrb, const char *p, size_t len)
 {
   return mrb_obj_value(str_new(mrb, p, len));
@@ -261,7 +261,7 @@ mrb_str_new(mrb_state *mrb, const char *p, size_t len)
  *  Returns a new string object containing a copy of <i>str</i>.
  */
 
-mrb_value
+MRB_API mrb_value
 mrb_str_new_cstr(mrb_state *mrb, const char *p)
 {
   struct RString *s;
@@ -279,7 +279,7 @@ mrb_str_new_cstr(mrb_state *mrb, const char *p)
   return mrb_obj_value(s);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_str_new_static(mrb_state *mrb, const char *p, size_t len)
 {
   struct RString *s;
@@ -306,7 +306,7 @@ mrb_gc_free_str(mrb_state *mrb, struct RString *str)
     mrb_free(mrb, str->as.heap.ptr);
 }
 
-char *
+MRB_API const char*
 mrb_str_to_cstr(mrb_state *mrb, mrb_value str0)
 {
   struct RString *s;
@@ -366,7 +366,7 @@ str_make_shared(mrb_state *mrb, struct RString *s)
  *
  *  Returns a new string object containing a copy of <i>str</i>.
  */
-void
+MRB_API void
 mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other)
 {
   struct RString *s1 = mrb_str_ptr(self), *s2;
@@ -445,7 +445,7 @@ mrb_str_bytesize(mrb_state *mrb, mrb_value self)
  *
  *  Returns a new string object containing a copy of <i>str</i>.
  */
-mrb_value
+MRB_API mrb_value
 mrb_str_size(mrb_state *mrb, mrb_value self)
 {
   struct RString *s = mrb_str_ptr(self);
@@ -506,7 +506,7 @@ mrb_str_times(mrb_state *mrb, mrb_value self)
  *                     =  0
  *                     <  -1
  */
-int
+MRB_API int
 mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2)
 {
   mrb_int len;
@@ -592,7 +592,7 @@ str_eql(mrb_state *mrb, const mrb_value str1, const mrb_value str2)
   return FALSE;
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2)
 {
   if (mrb_immediate_p(str2)) return FALSE;
@@ -643,7 +643,7 @@ mrb_str_to_str(mrb_state *mrb, mrb_value str)
   return str;
 }
 
-char *
+MRB_API const char*
 mrb_string_value_ptr(mrb_state *mrb, mrb_value ptr)
 {
   mrb_value str = mrb_str_to_str(mrb, ptr);
@@ -736,7 +736,7 @@ mrb_str_index(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int offset)
   return pos + offset;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_str_dup(mrb_state *mrb, mrb_value str)
 {
   struct RString *s = mrb_str_ptr(str);
@@ -1435,13 +1435,13 @@ mrb_str_init(mrb_state *mrb, mrb_value self)
  *
  *     'cat and dog'.to_sym   #=> :"cat and dog"
  */
-mrb_value
+MRB_API mrb_value
 mrb_str_intern(mrb_state *mrb, mrb_value self)
 {
   return mrb_symbol_value(mrb_intern_str(mrb, self));
 }
 /* ---------------------------------- */
-mrb_value
+MRB_API mrb_value
 mrb_obj_as_string(mrb_state *mrb, mrb_value obj)
 {
   mrb_value str;
@@ -1455,7 +1455,7 @@ mrb_obj_as_string(mrb_state *mrb, mrb_value obj)
   return str;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_ptr_to_str(mrb_state *mrb, void *p)
 {
   struct RString *p_str;
@@ -1485,13 +1485,13 @@ mrb_ptr_to_str(mrb_state *mrb, void *p)
   return mrb_obj_value(p_str);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_string_type(mrb_state *mrb, mrb_value str)
 {
   return mrb_convert_type(mrb, str, MRB_TT_STRING, "String", "to_str");
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_check_string_type(mrb_state *mrb, mrb_value str)
 {
   return mrb_check_convert_type(mrb, str, MRB_TT_STRING, "String", "to_str");
@@ -1849,7 +1849,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
   return result;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck)
 {
   const char *p;
@@ -1996,7 +1996,7 @@ bad:
   return mrb_fixnum_value(0);
 }
 
-char *
+MRB_API const char*
 mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr)
 {
   struct RString *ps = mrb_str_ptr(*ptr);
@@ -2010,10 +2010,10 @@ mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr)
   return p;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck)
 {
-  char *s;
+  const char *s;
   mrb_int len;
 
   str = mrb_str_to_str(mrb, str);
@@ -2066,7 +2066,7 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self)
   return mrb_str_to_inum(mrb, self, base, FALSE);
 }
 
-double
+MRB_API double
 mrb_cstr_to_dbl(mrb_state *mrb, const char * p, mrb_bool badcheck)
 {
   char *end;
@@ -2132,7 +2132,7 @@ bad:
   return d;
 }
 
-double
+MRB_API double
 mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck)
 {
   char *s;
@@ -2362,26 +2362,26 @@ mrb_str_dump(mrb_state *mrb, mrb_value str)
   return mrb_obj_value(result);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len)
 {
   str_buf_cat(mrb, mrb_str_ptr(str), ptr, len);
   return str;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_str_cat_cstr(mrb_state *mrb, mrb_value str, const char *ptr)
 {
   return mrb_str_cat(mrb, str, ptr, strlen(ptr));
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_str_cat_str(mrb_state *mrb, mrb_value str, mrb_value str2)
 {
   return mrb_str_cat(mrb, str, RSTRING_PTR(str2), RSTRING_LEN(str2));
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2)
 {
   str2 = mrb_str_to_str(mrb, str2);

src/symbol.c

@@ -69,31 +69,31 @@ sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit)
   return sym;
 }
 
-mrb_sym
+MRB_API mrb_sym
 mrb_intern(mrb_state *mrb, const char *name, size_t len)
 {
   return sym_intern(mrb, name, len, FALSE);
 }
 
-mrb_sym
+MRB_API mrb_sym
 mrb_intern_static(mrb_state *mrb, const char *name, size_t len)
 {
   return sym_intern(mrb, name, len, TRUE);
 }
 
-mrb_sym
+MRB_API mrb_sym
 mrb_intern_cstr(mrb_state *mrb, const char *name)
 {
   return mrb_intern(mrb, name, strlen(name));
 }
 
-mrb_sym
+MRB_API mrb_sym
 mrb_intern_str(mrb_state *mrb, mrb_value str)
 {
   return mrb_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
 {
   khash_t(n2s) *h = mrb->name2sym;
@@ -113,20 +113,20 @@ mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
   return mrb_nil_value();
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_check_intern_cstr(mrb_state *mrb, const char *name)
 {
   return mrb_check_intern(mrb, name, (mrb_int)strlen(name));
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_check_intern_str(mrb_state *mrb, mrb_value str)
 {
   return mrb_check_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
 }
 
 /* lenp must be a pointer to a size_t variable */
-const char*
+MRB_API const char*
 mrb_sym2name_len(mrb_state *mrb, mrb_sym sym, mrb_int *lenp)
 {
   khash_t(n2s) *h = mrb->name2sym;
@@ -233,7 +233,7 @@ sym_equal(mrb_state *mrb, mrb_value sym1)
  *
  *     :fred.id2name   #=> "fred"
  */
-mrb_value
+static mrb_value
 mrb_sym_to_s(mrb_state *mrb, mrb_value sym)
 {
   mrb_sym id = mrb_symbol(sym);
@@ -409,7 +409,7 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
   return str;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_sym2str(mrb_state *mrb, mrb_sym sym)
 {
   mrb_int len;
@@ -419,7 +419,7 @@ mrb_sym2str(mrb_state *mrb, mrb_sym sym)
   return mrb_str_new_static(mrb, name, len);
 }
 
-const char*
+MRB_API const char*
 mrb_sym2name(mrb_state *mrb, mrb_sym sym)
 {
   mrb_int len;

src/variable.c

@@ -466,7 +466,7 @@ obj_iv_p(mrb_value obj)
   }
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym)
 {
   mrb_value v;
@@ -476,7 +476,7 @@ mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym)
   return mrb_nil_value();
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 {
   if (obj_iv_p(obj)) {
@@ -485,7 +485,7 @@ mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
   return mrb_nil_value();
 }
 
-void
+MRB_API void
 mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 {
   iv_tbl *t = obj->iv;
@@ -497,7 +497,7 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   iv_put(mrb, t, sym, v);
 }
 
-void
+MRB_API void
 mrb_obj_iv_ifnone(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 {
   iv_tbl *t = obj->iv;
@@ -512,7 +512,7 @@ mrb_obj_iv_ifnone(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   iv_put(mrb, t, sym, v);
 }
 
-void
+MRB_API void
 mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v)
 {
   if (obj_iv_p(obj)) {
@@ -523,7 +523,7 @@ mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v)
   }
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_obj_iv_defined(mrb_state *mrb, struct RObject *obj, mrb_sym sym)
 {
   iv_tbl *t;
@@ -535,14 +535,14 @@ mrb_obj_iv_defined(mrb_state *mrb, struct RObject *obj, mrb_sym sym)
   return FALSE;
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_iv_defined(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 {
   if (!obj_iv_p(obj)) return FALSE;
   return mrb_obj_iv_defined(mrb, mrb_obj_ptr(obj), sym);
 }
 
-void
+MRB_API void
 mrb_iv_copy(mrb_state *mrb, mrb_value dest, mrb_value src)
 {
   struct RObject *d = mrb_obj_ptr(dest);
@@ -609,7 +609,7 @@ mrb_obj_iv_inspect(mrb_state *mrb, struct RObject *obj)
   return mrb_any_to_s(mrb, mrb_obj_value(obj));
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 {
   if (obj_iv_p(obj)) {
@@ -729,7 +729,7 @@ mrb_mod_class_variables(mrb_state *mrb, mrb_value mod)
   return ary;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym)
 {
   struct RClass * cls = c;
@@ -750,13 +750,13 @@ mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym)
   return mrb_nil_value();
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_cv_get(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 {
   return mrb_mod_cv_get(mrb, mrb_class_ptr(mod), sym);
 }
 
-void
+MRB_API void
 mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
 {
   struct RClass * cls = c;
@@ -782,13 +782,13 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
   iv_put(mrb, cls->iv, sym, v);
 }
 
-void
+MRB_API void
 mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v)
 {
   mrb_mod_cv_set(mrb, mrb_class_ptr(mod), sym, v);
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym)
 {
   while (c) {
@@ -802,13 +802,13 @@ mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym)
   return FALSE;
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 {
   return mrb_mod_cv_defined(mrb, mrb_class_ptr(mod), sym);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym)
 {
   struct RClass *c = mrb->c->ci->proc->target_class;
@@ -818,7 +818,7 @@ mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym)
   return mrb_mod_cv_get(mrb, c, sym);
 }
 
-void
+MRB_API void
 mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 {
   struct RClass *c = mrb->c->ci->proc->target_class;
@@ -827,7 +827,7 @@ mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
   mrb_mod_cv_set(mrb, c, sym, v);
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_const_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 {
   struct RClass *m = mrb_class_ptr(mod);
@@ -878,7 +878,7 @@ L_RETRY:
   return mrb_funcall_argv(mrb, mrb_obj_value(base), mrb_intern_lit(mrb, "const_missing"), 1, &name);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_const_get(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 {
   mod_const_check(mrb, mod);
@@ -910,14 +910,14 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
   return const_get(mrb, c, sym);
 }
 
-void
+MRB_API void
 mrb_const_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v)
 {
   mod_const_check(mrb, mod);
   mrb_iv_set(mrb, mod, sym, v);
 }
 
- void
+void
 mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 {
   struct RClass *c = mrb->c->ci->proc->target_class;
@@ -926,20 +926,20 @@ mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
   mrb_obj_iv_set(mrb, (struct RObject*)c, sym, v);
 }
 
-void
+MRB_API void
 mrb_const_remove(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 {
   mod_const_check(mrb, mod);
   mrb_iv_remove(mrb, mod, sym);
 }
 
-void
+MRB_API void
 mrb_define_const(mrb_state *mrb, struct RClass *mod, const char *name, mrb_value v)
 {
   mrb_obj_iv_set(mrb, (struct RObject*)mod, mrb_intern_cstr(mrb, name), v);
 }
 
-void
+MRB_API void
 mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val)
 {
   mrb_define_const(mrb, mrb->object_class, name, val);
@@ -987,7 +987,7 @@ mrb_mod_constants(mrb_state *mrb, mrb_value mod)
   return ary;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_gv_get(mrb_state *mrb, mrb_sym sym)
 {
   mrb_value v;
@@ -1000,7 +1000,7 @@ mrb_gv_get(mrb_state *mrb, mrb_sym sym)
   return mrb_nil_value();
 }
 
-void
+MRB_API void
 mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 {
   iv_tbl *t;
@@ -1014,7 +1014,7 @@ mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
   iv_put(mrb, t, sym, v);
 }
 
-void
+MRB_API void
 mrb_gv_remove(mrb_state *mrb, mrb_sym sym)
 {
   if (!mrb->globals) {
@@ -1086,7 +1086,7 @@ retry:
   return FALSE;
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id)
 {
   return mrb_const_defined_0(mrb, klass, id, TRUE, FALSE);

src/vm.c

@@ -292,7 +292,7 @@ ecall(mrb_state *mrb, int i)
 #define MRB_FUNCALL_ARGC_MAX 16
 #endif
 
-mrb_value
+MRB_API mrb_value
 mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, mrb_int argc, ...)
 {
   mrb_value argv[MRB_FUNCALL_ARGC_MAX];
@@ -312,7 +312,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, mrb_int argc, ...)
   return mrb_funcall_argv(mrb, self, mid, argc, argv);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, const mrb_value *argv, mrb_value blk)
 {
   mrb_value val;
@@ -404,7 +404,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc
   return val;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, const mrb_value *argv)
 {
   return mrb_funcall_with_block(mrb, self, mid, argc, argv, mrb_nil_value());
@@ -429,7 +429,7 @@ mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, cons
  *     k = Klass.new
  *     k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"
  */
-mrb_value
+MRB_API mrb_value
 mrb_f_send(mrb_state *mrb, mrb_value self)
 {
   mrb_sym name;
@@ -573,7 +573,7 @@ mrb_obj_instance_eval(mrb_state *mrb, mrb_value self)
   return eval_under(mrb, self, b, c);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv, mrb_value self, struct RClass *c)
 {
   struct RProc *p;
@@ -620,7 +620,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value
   return val;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv)
 {
   struct RProc *p = mrb_proc_ptr(b);
@@ -628,7 +628,7 @@ mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv)
   return mrb_yield_with_class(mrb, b, argc, argv, p->env->stack[0], p->target_class);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg)
 {
   struct RProc *p = mrb_proc_ptr(b);
@@ -713,7 +713,7 @@ void mrb_gv_val_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
 
 #define CALL_MAXARGS 127
 
-mrb_value
+MRB_API mrb_value
 mrb_context_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep)
 {
   /* mrb_assert(mrb_proc_cfunc_p(proc)) */
@@ -2360,13 +2360,13 @@ RETRY_TRY_BLOCK:
   MRB_END_EXC(&c_jmp);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 {
   return mrb_context_run(mrb, proc, self, mrb->c->ci->argc + 2); /* argc + 2 (receiver and block) */
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_toplevel_run_keep(mrb_state *mrb, struct RProc *proc, unsigned int stack_keep)
 {
   mrb_callinfo *ci;
@@ -2384,7 +2384,7 @@ mrb_toplevel_run_keep(mrb_state *mrb, struct RProc *proc, unsigned int stack_kee
   return v;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_toplevel_run(mrb_state *mrb, struct RProc *proc)
 {
   return mrb_toplevel_run_keep(mrb, proc, 0);