static int
strip(mrb_state *mrb, struct strip_args *args)
{
int i;
for (i = args->argc_start; i < args->argc; ++i) {
char *filename;
FILE *rfile;
mrb_irep *irep;
FILE *wfile;
int dump_result;
filename = args->argv[i];
rfile = fopen(filename, "rb");
if (rfile == NULL) {
fprintf(stderr, "can't open file for reading %s\n", filename);
return EXIT_FAILURE;
}
irep = mrb_read_irep_file(mrb, rfile);
fclose(rfile);
if (irep == NULL) {
fprintf(stderr, "can't read irep file %s\n", filename);
return EXIT_FAILURE;
}
/* clear lv if --lvar is enabled */
if (args->lvar) {
irep_remove_lv(mrb, irep);
}
wfile = fopen(filename, "wb");
if (wfile == NULL) {
fprintf(stderr, "can't open file for writing %s\n", filename);
mrb_irep_decref(mrb, irep);
return EXIT_FAILURE;
}
/* debug flag must always be false */
dump_result = mrb_dump_irep_binary(mrb, irep, FALSE, wfile);
fclose(wfile);
mrb_irep_decref(mrb, irep);
if (dump_result != MRB_DUMP_OK) {
fprintf(stderr, "error occurred during dumping %s\n", filename);
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
void
mrb_irep_free(mrb_state *mrb, mrb_irep *irep)
{
size_t i;
if (!(irep->flags & MRB_ISEQ_NO_FREE))
mrb_free(mrb, irep->iseq);
for (i=0; i<irep->plen; i++) {
if (mrb_type(irep->pool[i]) == MRB_TT_STRING) {
mrb_gc_free_str(mrb, RSTRING(irep->pool[i]));
mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
}
#ifdef MRB_WORD_BOXING
else if (mrb_type(irep->pool[i]) == MRB_TT_FLOAT) {
mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
}
#endif
}
mrb_free(mrb, irep->pool);
mrb_free(mrb, irep->syms);
for (i=0; i<irep->rlen; i++) {
mrb_irep_decref(mrb, irep->reps[i]);
}
mrb_free(mrb, irep->reps);
mrb_free(mrb, irep->lv);
mrb_free(mrb, (void *)irep->filename);
mrb_free(mrb, irep->lines);
mrb_debug_info_free(mrb, irep->debug_info);
mrb_free(mrb, irep);
}
void mrb_irep_free(MemManager &mm, mrb_irep *irep)
{
if (!(irep->flags & MRB_ISEQ_NO_FREE))
mm._free(irep->iseq);
for (int i=0; i<irep->plen; i++) {
if (mrb_type(irep->pool[i]) == MRB_TT_STRING) {
if ((irep->pool[i].ptr<RString>()->flags & MRB_STR_NOFREE) == 0) {
mm._free(irep->pool[i].ptr<RString>()->m_ptr);
}
mm._free(irep->pool[i].basic_ptr());
}
#ifdef MRB_WORD_BOXING
else if (mrb_type(irep->pool[i]) == MRB_TT_FLOAT) {
mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
}
#endif
}
mm._free(irep->pool);
mm._free(irep->syms);
for (int i=0; i<irep->rlen; i++) {
mrb_irep_decref(mm, irep->reps[i]);
}
mm._free(irep->reps);
mm._free((void *)irep->filename);
mm._free(irep->lines);
mrb_debug_info_free(mm, irep->debug_info);
mm._free(irep);
}
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);
struct RProc *proc;
if (!irep) {
irep_error(mrb);
return mrb_nil_value();
}
proc = mrb_proc_new(mrb, irep);
mrb_irep_decref(mrb, irep);
if (c && c->no_exec) return mrb_obj_value(proc);
return mrb_top_run(mrb, proc, mrb_top_self(mrb), 0);
}
static mrb_value
load_irep(mrb_state *mrb, mrb_irep *irep, mrbc_context *c)
{
struct RProc *proc;
if (!irep) {
irep_error(mrb);
return mrb_nil_value();
}
proc = mrb_proc_new(mrb, irep);
proc->c = NULL;
mrb_irep_decref(mrb, irep);
if (c && c->dump_result) mrb_codedump_all(mrb, proc);
if (c && c->no_exec) return mrb_obj_value(proc);
return mrb_top_run(mrb, proc, mrb_top_self(mrb), 0);
}
mrb_value
mrb_load_irep_file_cxt(mrb_state *mrb, FILE* fp, mrbc_context *c)
{
mrb_irep *irep = mrb_read_irep_file(mrb, fp);
mrb_value val;
struct RProc *proc;
if (!irep) {
irep_error(mrb);
return mrb_nil_value();
}
proc = mrb_proc_new(mrb, irep);
mrb_irep_decref(mrb, irep);
if (c && c->no_exec) return mrb_obj_value(proc);
val = mrb_toplevel_run(mrb, proc);
return val;
}
void
mrb_irep_free(mrb_state *mrb, mrb_irep *irep)
{
size_t i;
if (!(irep->flags & MRB_ISEQ_NO_FREE))
mrb_free(mrb, irep->iseq);
for (i=0; i<irep->plen; i++) {
if (mrb_type(irep->pool[i]) == MRB_TT_STRING) {
if ((mrb_str_ptr(irep->pool[i])->flags & (MRB_STR_NOFREE|MRB_STR_EMBED)) == 0) {
mrb_free(mrb, RSTRING_PTR(irep->pool[i]));
}
mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
}
#ifdef MRB_WORD_BOXING
else if (mrb_type(irep->pool[i]) == MRB_TT_FLOAT) {
mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
}
#endif
}
mrb_free(mrb, irep->pool);
mrb_free(mrb, irep->syms);
for (i=0; i<irep->rlen; i++) {
mrb_irep_decref(mrb, irep->reps[i]);
}
mrb_free(mrb, irep->reps);
mrb_free(mrb, (void *)irep->filename);
mrb_free(mrb, irep->lines);
mrb_free(mrb, irep->prof_info);
if (irep->jit_entry_tab) {
int i;
int j;
for (i = 0; i < irep->ilen; i++) {
for (j = 0; j < irep->jit_entry_tab[i].size; j++) {
if (irep->jit_entry_tab[i].body[j].reginfo) {
mrb_free(mrb, irep->jit_entry_tab[i].body[j].reginfo);
}
}
}
mrb_free(mrb, irep->jit_entry_tab->body);
mrb_free(mrb, irep->jit_entry_tab);
}
mrb_debug_info_free(mrb, irep->debug_info);
mrb_free(mrb, irep);
}
static void
obj_free(mrb_state *mrb, struct RBasic *obj)
{
DEBUG(printf("obj_free(%p,tt=%d)\n",obj,obj->tt));
switch (obj->tt) {
/* immediate - no mark */
case MRB_TT_TRUE:
case MRB_TT_FIXNUM:
case MRB_TT_SYMBOL:
/* cannot happen */
return;
case MRB_TT_FLOAT:
#ifdef MRB_WORD_BOXING
break;
#else
return;
#endif
case MRB_TT_OBJECT:
mrb_gc_free_iv(mrb, (struct RObject*)obj);
break;
case MRB_TT_CLASS:
case MRB_TT_MODULE:
case MRB_TT_SCLASS:
mrb_gc_free_mt(mrb, (struct RClass*)obj);
mrb_gc_free_iv(mrb, (struct RObject*)obj);
break;
case MRB_TT_ENV:
{
struct REnv *e = (struct REnv*)obj;
if (!MRB_ENV_STACK_SHARED_P(e)) {
mrb_free(mrb, e->stack);
e->stack = NULL;
}
}
break;
case MRB_TT_FIBER:
{
struct mrb_context *c = ((struct RFiber*)obj)->cxt;
if (c != mrb->root_c)
mrb_free_context(mrb, c);
}
break;
case MRB_TT_ARRAY:
if (obj->flags & MRB_ARY_SHARED)
mrb_ary_decref(mrb, ((struct RArray*)obj)->aux.shared);
else
mrb_free(mrb, ((struct RArray*)obj)->ptr);
break;
case MRB_TT_HASH:
mrb_gc_free_iv(mrb, (struct RObject*)obj);
mrb_gc_free_hash(mrb, (struct RHash*)obj);
break;
case MRB_TT_STRING:
mrb_gc_free_str(mrb, (struct RString*)obj);
break;
case MRB_TT_PROC:
{
struct RProc *p = (struct RProc*)obj;
if (!MRB_PROC_CFUNC_P(p) && p->body.irep) {
mrb_irep_decref(mrb, p->body.irep);
}
}
break;
case MRB_TT_RANGE:
mrb_free(mrb, ((struct RRange*)obj)->edges);
break;
case MRB_TT_DATA:
{
struct RData *d = (struct RData*)obj;
if (d->type && d->type->dfree) {
d->type->dfree(mrb, d->data);
}
mrb_gc_free_iv(mrb, (struct RObject*)obj);
}
break;
default:
break;
}
obj->tt = MRB_TT_FREE;
}
static void
obj_free(mrb_state *mrb, struct RBasic *obj, int end)
{
DEBUG(fprintf(stderr, "obj_free(%p,tt=%d)\n",obj,obj->tt));
switch (obj->tt) {
/* immediate - no mark */
case MRB_TT_TRUE:
case MRB_TT_FIXNUM:
case MRB_TT_SYMBOL:
/* cannot happen */
return;
case MRB_TT_FLOAT:
#ifdef MRB_WORD_BOXING
break;
#else
return;
#endif
case MRB_TT_OBJECT:
mrb_gc_free_iv(mrb, (struct RObject*)obj);
break;
case MRB_TT_EXCEPTION:
mrb_gc_free_iv(mrb, (struct RObject*)obj);
break;
case MRB_TT_CLASS:
case MRB_TT_MODULE:
case MRB_TT_SCLASS:
mrb_gc_free_mt(mrb, (struct RClass*)obj);
mrb_gc_free_iv(mrb, (struct RObject*)obj);
break;
case MRB_TT_ICLASS:
if (MRB_FLAG_TEST(obj, MRB_FLAG_IS_ORIGIN))
mrb_gc_free_mt(mrb, (struct RClass*)obj);
break;
case MRB_TT_ENV:
{
struct REnv *e = (struct REnv*)obj;
if (MRB_ENV_STACK_SHARED_P(e)) {
/* cannot be freed */
return;
}
mrb_free(mrb, e->stack);
e->stack = NULL;
}
break;
case MRB_TT_FIBER:
{
struct mrb_context *c = ((struct RFiber*)obj)->cxt;
if (!end && c && c != mrb->root_c) {
mrb_callinfo *ci = c->ci;
mrb_callinfo *ce = c->cibase;
while (ce <= ci) {
struct REnv *e = ci->env;
if (e && !is_dead(&mrb->gc, e) &&
e->tt == MRB_TT_ENV && MRB_ENV_STACK_SHARED_P(e)) {
mrb_env_unshare(mrb, e);
}
ci--;
}
mrb_free_context(mrb, c);
}
}
break;
case MRB_TT_ARRAY:
if (ARY_SHARED_P(obj))
mrb_ary_decref(mrb, ((struct RArray*)obj)->aux.shared);
else
mrb_free(mrb, ((struct RArray*)obj)->ptr);
break;
case MRB_TT_HASH:
mrb_gc_free_iv(mrb, (struct RObject*)obj);
mrb_gc_free_hash(mrb, (struct RHash*)obj);
break;
case MRB_TT_STRING:
mrb_gc_free_str(mrb, (struct RString*)obj);
break;
case MRB_TT_PROC:
{
struct RProc *p = (struct RProc*)obj;
if (!MRB_PROC_CFUNC_P(p) && p->body.irep) {
mrb_irep_decref(mrb, p->body.irep);
}
}
break;
case MRB_TT_RANGE:
mrb_free(mrb, ((struct RRange*)obj)->edges);
break;
case MRB_TT_DATA:
{
struct RData *d = (struct RData*)obj;
if (d->type && d->type->dfree) {
d->type->dfree(mrb, d->data);
}
mrb_gc_free_iv(mrb, (struct RObject*)obj);
}
break;
default:
break;
}
obj->tt = MRB_TT_FREE;
}
