예제 #1
0
파일: i2c.c 프로젝트: pbosetti/mruby-mraa
mrb_value
mrb_mraa_i2c_read(mrb_state *mrb, mrb_value self){
    mraa_i2c_context i2c;
    mrb_int length;

    uint8_t *rbuf;
    mrb_int num_of_read;
    int ai, i;

    mrb_value mrv_rbuf;

    Data_Get_Struct(mrb, self, &mrb_mraa_i2c_ctx_type, i2c);

    mrb_get_args(mrb, "i", &length);

    rbuf = (uint8_t*)mrb_malloc(mrb, sizeof(uint8_t) * length);
    memset(rbuf, 0, sizeof(uint8_t) * length);

    num_of_read = mraa_i2c_read(i2c, rbuf, length);

    mrv_rbuf = mrb_ary_new_capa(mrb, num_of_read);
    ai = mrb_gc_arena_save(mrb);
    for (i = 0; i < num_of_read; i++){
        mrb_ary_push(mrb, mrv_rbuf, mrb_fixnum_value(rbuf[i]));
        mrb_gc_arena_restore(mrb, ai);
    }

    mrb_free(mrb, rbuf);

    return mrb_assoc_new(mrb, mrv_rbuf, mrb_fixnum_value(num_of_read));
}
예제 #2
0
파일: array.c 프로젝트: NARKOZ/mruby
static void
ary_modify(mrb_state *mrb, struct RArray *a)
{
  if (a->flags & MRB_ARY_SHARED) {
    mrb_shared_array *shared = a->aux.shared;

    if (shared->refcnt == 1 && a->ptr == shared->ptr) {
      a->ptr = shared->ptr;
      a->aux.capa = a->len;
      mrb_free(mrb, shared);
    }
    else {
      mrb_value *ptr, *p;
      mrb_int len;

      p = a->ptr;
      len = a->len * sizeof(mrb_value);
      ptr = (mrb_value *)mrb_malloc(mrb, len);
      if (p) {
        array_copy(ptr, p, a->len);
      }
      a->ptr = ptr;
      a->aux.capa = a->len;
      mrb_ary_decref(mrb, shared);
    }
    a->flags &= ~MRB_ARY_SHARED;
  }
}
예제 #3
0
파일: time.c 프로젝트: jinleileiking/mruby
/* Initializes a time by setting the amount of milliseconds since the epoch.*/
static mrb_value
mrb_time_initialize(mrb_state *mrb, mrb_value self)
{
  mrb_int ayear = 0, amonth = 1, aday = 1, ahour = 0,
  amin = 0, asec = 0, ausec = 0;
  int n;
  struct mrb_time *tm;

  tm = (struct mrb_time*)DATA_PTR(self);
  if (tm) {
    mrb_free(mrb, tm);
  }
  DATA_TYPE(self) = &mrb_time_type;
  DATA_PTR(self) = NULL;

  n = mrb_get_args(mrb, "|iiiiiii",
       &ayear, &amonth, &aday, &ahour, &amin, &asec, &ausec);
  if (n == 0) {
    tm = current_mrb_time(mrb);
  }
  else {
    tm = time_mktime(mrb, ayear, amonth, aday, ahour, amin, asec, ausec, MRB_TIMEZONE_LOCAL);
  }
  DATA_PTR(self) = tm;
  return self;
}
예제 #4
0
파일: i2c.c 프로젝트: pbosetti/mruby-mraa
mrb_value
mrb_mraa_i2c_write(mrb_state *mrb, mrb_value self){
    mraa_i2c_context i2c;
    mrb_value mrv_wbuf;
    mrb_int length;

    mraa_result_t result;
    uint8_t *wbuf;
    mrb_int argc;
    
    Data_Get_Struct(mrb, self, &mrb_mraa_i2c_ctx_type, i2c);

    argc = mrb_get_args(mrb, "o|i", &mrv_wbuf, &length);

    result = MRAA_ERROR_INVALID_PARAMETER;
    if (mrb_array_p(mrv_wbuf)){
        int i;
        if (argc == 1){
            length = RARRAY_LEN(mrv_wbuf);
        }

        wbuf = (uint8_t *)mrb_malloc(mrb, sizeof(uint8_t) * length);
        memset(wbuf, 0, sizeof(uint8_t) * length);
        for (i = 0; i < length; i++){
            wbuf[i] = mrb_fixnum(mrb_ary_ref(mrb, mrv_wbuf, i));
        }
        result = mraa_i2c_write(i2c, wbuf, length);
        mrb_free(mrb, wbuf);
    }

    return mrb_fixnum_value(result);
}
예제 #5
0
파일: string.c 프로젝트: nin2/mruby
static mrb_value
mrb_str_reverse_bang(mrb_state *mrb, mrb_value str)
{
  int utf8_len = mrb_utf8_strlen(str);
  if (utf8_len > 1) {
    int len = RSTRING_LEN(str);
    char *buf = (char *)mrb_malloc(mrb, len);
    unsigned char* p = (unsigned char*)buf;
    unsigned char* e = (unsigned char*)buf + len;
    unsigned char* r = (unsigned char*)RSTRING_END(str);
    
    memcpy(buf, RSTRING_PTR(str), len);
    mrb_str_modify(mrb, mrb_str_ptr(str));
    
    while (p<e) {
      int clen = utf8len(p);
      r -= clen;
      memcpy(r, p, clen);
      p += clen;
    }
    mrb_free(mrb, buf);
  }
  
  return str;
}
예제 #6
0
static void
mrb_cp_mat2x2_free(mrb_state* mrb, void* ptr)
{
  if (ptr) {
    mrb_free(mrb, ptr);
  }
}
예제 #7
0
파일: random.c 프로젝트: tankerwng/mruby
static mrb_value 
mrb_random_init(mrb_state *mrb, mrb_value self)
{
  mrb_value seed;
  mt_state *t;
  
  DATA_TYPE(self) = &mt_state_type;
  DATA_PTR(self) = NULL;
  
  /* avoid memory leaks */
  t = (mt_state*)DATA_PTR(self);
  if (t) {
    mrb_free(mrb, t);
  }  

  t = (mt_state *)mrb_malloc(mrb, sizeof(mt_state));
  t->mti = N + 1;

  seed = get_opt(mrb);
  seed = mrb_random_mt_srand(mrb, t, seed);
  if (mrb_nil_p(seed)) {
    t->has_seed = FALSE;
  }
  else {
    mrb_assert(mrb_fixnum_p(seed));
    t->has_seed = TRUE;
    t->seed = mrb_fixnum(seed);
  }
  
  DATA_PTR(self) = t;
  
  return self;
}
예제 #8
0
파일: dump.c 프로젝트: kano4/mruby
int
mrb_dump_irep_cfunc(mrb_state *mrb, size_t start_index, int debug_info, FILE *fp, const char *initname)
{
  uint8_t *bin = NULL;
  size_t bin_size = 0, bin_idx = 0;
  int result;

  if (fp == NULL || initname == NULL || !is_valid_c_symbol_name(initname)) {
    return MRB_DUMP_INVALID_ARGUMENT;
  }

  result = mrb_dump_irep(mrb, start_index, debug_info, &bin, &bin_size);
  if (result == MRB_DUMP_OK) {
    fprintf(fp, "#include <stdint.h>\n"); // for uint8_t under at least Darwin
    fprintf(fp, "const uint8_t %s[] = {", initname);
    while (bin_idx < bin_size) {
      if (bin_idx % 16 == 0 ) fputs("\n", fp);
      fprintf(fp, "0x%02x,", bin[bin_idx++]);
    }
    fputs("\n};\n", fp);
  }

  mrb_free(mrb, bin);
  return result;
}
예제 #9
0
파일: backtrace.c 프로젝트: okkez/mruby
void
mrb_free_backtrace(mrb_state *mrb)
{
  mrb->backtrace.exc = 0;
  mrb->backtrace.n = 0;
  mrb->backtrace.n_allocated = 0;
  mrb_free(mrb, mrb->backtrace.entries);
}
예제 #10
0
static void
lib_hmac_free(mrb_state *mrb, void *ptr)
{
  struct mrb_hmac *hmac = ptr;

  memset(&hmac->ctx, 0, sizeof(hmac->ctx));
  mrb_free(mrb, hmac);
}
/* :nodoc: */
static void rb_lmc_cache_destructor(mrb_state *mrb, void *p)
{
  rb_lmc_handle_t *h;
  lmc_error_t e;

  h = (rb_lmc_handle_t *)p;
  if (!h || (h->open == 0) || !h->lmc)
    return;

  if (!local_memcache_free(h->lmc, &e)) {
    mrb_free(mrb, p);
    rb_lmc_raise_exception(mrb, &e);
    return;
  }

  mrb_free(mrb, p);
}
예제 #12
0
static void mrb_shared_sample_buffer_unref(mrb_state *mrb, mrb_shared_sample_buffer *b)
{
  if (!b) return;
  b->refcnt -= 1;
  if (b->refcnt <= 0) {
    mrb_free(mrb, b);
  }
}
예제 #13
0
파일: dl.c 프로젝트: mattn/mruby-uv
static void
mrb_uv_dlfree(mrb_state *mrb, void *p)
{
  if (p) {
    uv_dlclose((uv_lib_t*)p);
    mrb_free(mrb, p);
  }
}
예제 #14
0
/*********************************************************
 * UV::Mutex
 *********************************************************/
void
mrb_uv_mutex_free(mrb_state *mrb, void *p)
{
  if (p) {
    uv_mutex_destroy((uv_mutex_t*)p);
    mrb_free(mrb, p);
  }
}
예제 #15
0
static void
mrb_uv_cond_free(mrb_state *mrb, void* p)
{
  if (p) {
    uv_cond_destroy((uv_cond_t*)p);
    mrb_free(mrb, p);
  }
}
예제 #16
0
static void
mrb_uv_key_free(mrb_state *mrb, void* p)
{
  if (p) {
    uv_key_delete((uv_key_t*)p);
    mrb_free(mrb, p);
  }
}
예제 #17
0
void
mrb_uv_sem_free(mrb_state *mrb, void *p)
{
  if(!p) { return; }

  uv_sem_destroy((uv_sem_t*)p);
  mrb_free(mrb, p);
}
예제 #18
0
static void
free_breakpoint( mrb_state *mrb, mrb_debug_breakpoint *bp )
{
  switch(bp->type) {
    case MRB_DEBUG_BPTYPE_LINE:
      mrb_free(mrb, (void*)bp->point.linepoint.file);
      break;
    case MRB_DEBUG_BPTYPE_METHOD:
      mrb_free(mrb, (void*)bp->point.methodpoint.method_name);
      if(bp->point.methodpoint.class_name != NULL) {
        mrb_free(mrb, (void*)bp->point.methodpoint.class_name);
      }
      break;
    default:
      break;
  }
}
예제 #19
0
/*********************************************************
 * UV::Barrier
 *********************************************************/
static void
mrb_uv_barrier_free(mrb_state *mrb, void *p)
{
  if(p) {
    uv_barrier_destroy((uv_barrier_t*)p);
    mrb_free(mrb, p);
  }
}
예제 #20
0
static mrb_value
mrb_uv_barrier_destroy(mrb_state *mrb, mrb_value self)
{
  uv_barrier_destroy((uv_barrier_t*)mrb_uv_get_ptr(mrb, self, &barrier_type));
  mrb_free(mrb, DATA_PTR(self));
  DATA_PTR(self) = NULL;
  return self;
}
예제 #21
0
 static void
 destroy_hook(mrb_state *mrb, void* ptr)
 {
     DataClass *obj = reinterpret_cast<DataClass*>(ptr);
     obj->destroy(mrb);
     obj->~DataClass();
     mrb_free(mrb, obj);
 }
예제 #22
0
static void mrb_sample_buffer_destroy(mrb_state *mrb, void *x)
{
  mrb_sample_buffer *b = x;
  if (b) {
    mrb_shared_sample_buffer_unref(mrb, b->shared);
    mrb_free(mrb, b);
  }
}
예제 #23
0
파일: dl.c 프로젝트: mattn/mruby-uv
void
mrb_uv_dlclose(mrb_state *mrb, mrb_value dl)
{
  uv_lib_t *lib = (uv_lib_t*)mrb_uv_get_ptr(mrb, dl, &dl_type);
  uv_dlclose(lib);
  mrb_free(mrb, DATA_PTR(dl));
  DATA_PTR(dl) = NULL;
}
예제 #24
0
파일: gc.c 프로젝트: Everysick/mruby
void
mrb_gc_destroy(mrb_state *mrb, mrb_gc *gc)
{
  free_heap(mrb, gc);
#ifndef MRB_GC_FIXED_ARENA
  mrb_free(mrb, gc->arena);
#endif
}
예제 #25
0
static void
mrb_uv_rwlock_free(mrb_state *mrb, void *p)
{
  if (p) {
    uv_rwlock_destroy((uv_rwlock_t*)p);
    mrb_free(mrb, p);
  }
}
예제 #26
0
파일: load.c 프로젝트: nkshigeru/mruby
int
mrb_read_irep_file(mrb_state *mrb, FILE* fp)
{
  int ret, i;
  uint32_t  len, rlen = 0;
  unsigned char hex8[8], hcrc[4];
  unsigned char *dst, *rite_dst = NULL;
  rite_binary_header  bin_header;
  RiteFILE ritefp = { 0 };
  RiteFILE *rfp;

  if ((mrb == NULL) || (fp == NULL)) {
    return MRB_DUMP_INVALID_ARGUMENT;
  }
  ritefp.fp = fp;
  rfp = &ritefp;

  //Read File Header Section
  ret = load_rite_header(fp, &bin_header, hcrc);
  if (ret != MRB_DUMP_OK)
    return ret;

  len = sizeof(rite_binary_header) + bin_to_uint32(bin_header.rbds);
  rite_dst = (unsigned char *)mrb_malloc(mrb, len);
  if (rite_dst == NULL)
    return MRB_DUMP_GENERAL_FAILURE;

  dst = rite_dst;
  memset(dst, 0x00, len);
  *(rite_binary_header *)dst = bin_header;
  dst += sizeof(rite_binary_header);
  dst += hex_to_bin16(dst, hcrc);

  //Read Binary Data Section
  len = bin_to_uint16(bin_header.nirep);
  for (i=0; i<len; i++) {
    rite_fgets(rfp, hex8, sizeof(hex8), TRUE);                      //record len
    dst += hex_to_bin32(dst, hex8);
    ret = load_rite_irep_record(mrb, rfp, dst, &rlen);
    if (ret != MRB_DUMP_OK) //irep info
      goto error_exit;
    dst += rlen;
  }
  rite_fgets(rfp, hex8, sizeof(hex8), TRUE);                        //dummy record len
  hex_to_bin32(dst, hex8);  /* dst += hex_to_bin32(dst, hex8); */
  if (0 != hex_to_uint32(hex8)) {
    ret = MRB_DUMP_INVALID_IREP;
    goto error_exit;
  }

  if (ret == MRB_DUMP_OK)
    ret = mrb_read_irep(mrb, (char*)rite_dst);

error_exit:
  mrb_free(mrb, rite_dst);

  return ret;
}
예제 #27
0
static mrb_value
mrb_sdl2_mixer_chunk_initialize(mrb_state *mrb, mrb_value self)
{
  Mix_Chunk *chunk = NULL;
  mrb_sdl2_mixer_chunk_data_t *data =
    (mrb_sdl2_mixer_chunk_data_t*)DATA_PTR(self);

  if (NULL == data) {
    data = (mrb_sdl2_mixer_chunk_data_t*)mrb_malloc(mrb, sizeof(mrb_sdl2_mixer_chunk_data_t));
    if (NULL == data) {
      mrb_raise(mrb, E_RUNTIME_ERROR, "insufficient memory.");
    }
    data->chunk = NULL;
  }
  SDL_RWops *rwops;
  bool str = false;
  if (1 == mrb->c->ci->argc) {
    mrb_value v;
    mrb_get_args(mrb, "o", &v);
    if (mrb_type(v) == MRB_TT_STRING) {
      rwops = SDL_RWFromFile(RSTRING_PTR(v), "r");
      str = true;
    }
    else if (mrb_type(v) == MRB_TT_OBJECT)
      rwops = mrb_sdl2_rwops_get_ptr(mrb, v);
    chunk = Mix_LoadWAV_RW(rwops, 0);
  } else {
    mrb_free(mrb, data);
    mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments.");
  }
  if (NULL == chunk) {
    mrb_free(mrb, data);
    if (str)
      SDL_FreeRW(rwops);
    mruby_sdl2_raise_error(mrb);
  }
  if (str)
    SDL_FreeRW(rwops);

  data->chunk = chunk;

  DATA_PTR(self) = data;
  DATA_TYPE(self) = &mrb_sdl2_mixer_chunk_data_type;
  return self;
}
예제 #28
0
파일: io.c 프로젝트: bigted6969/mruby-io
static void
mrb_io_free(mrb_state *mrb, void *ptr)
{
  struct mrb_io *io = (struct mrb_io *)ptr;
  if (io != NULL) {
    fptr_finalize(mrb, io, TRUE);
    mrb_free(mrb, io);
  }
}
예제 #29
0
static void
mrb_buffer_free(mrb_state *mrb, void *ptr)
{
     struct buffer *bp;
     bp = (struct buffer *)ptr;
     if (bfind(bp->b_bname, FALSE) == NULL) {
	  mrb_free(mrb, ptr);
     }
}
예제 #30
0
파일: mrdb.c 프로젝트: Asmod4n/mruby
void
mrb_debug_context_free(mrb_state *mrb)
{
  if (_debug_context) {
    mrb_debug_delete_break_all(mrb, _debug_context);
    mrb_free(mrb, _debug_context);
    _debug_context = NULL;
  }
}