admin/mruby-mruby
1
0
Fork 0
mirror of https://github.com/mruby/mruby synced 2026-06-08 16:11:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix spaces in the type cast expressions (cosmetic changes)

Browse Source
This commit is contained in:
Yukihiro "Matz" Matsumoto
2023-05-18 23:17:52 +09:00
parent cead78b394
commit eea72ec84a
42 changed files with 145 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/mruby.h
+2 -2
View File
@@ -1308,12 +1308,12 @@ MRB_API mrb_int mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
MRB_API void mrb_garbage_collect(mrb_state*);
MRB_API void mrb_full_gc(mrb_state*);
MRB_API void mrb_incremental_gc(mrb_state *);
MRB_API void mrb_incremental_gc(mrb_state*);
MRB_API void mrb_gc_mark(mrb_state*,struct RBasic*);
#define mrb_gc_mark_value(mrb,val) do {\
if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
} while (0)
MRB_API void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic*);
MRB_API void mrb_field_write_barrier(mrb_state*, struct RBasic*, struct RBasic*);
#define mrb_field_write_barrier_value(mrb, obj, val) do{\
if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
} while (0)
include/mruby/data.h
+2 -2
View File
@@ -41,12 +41,12 @@ MRB_API struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass
#define Data_Make_Struct(mrb,klass,strct,type,sval,data_obj) do { \
(data_obj) = Data_Wrap_Struct(mrb,klass,type,NULL);\
(sval) = (strct *)mrb_malloc(mrb, sizeof(strct)); \
(sval) = (strct*)mrb_malloc(mrb, sizeof(strct)); \
{ static const strct zero = { 0 }; *(sval) = zero; };\
(data_obj)->data = (sval);\
} while (0)
#define RDATA(obj) ((struct RData *)(mrb_ptr(obj)))
#define RDATA(obj) ((struct RData*)(mrb_ptr(obj)))
#define DATA_PTR(d) (RDATA(d)->data)
#define DATA_TYPE(d) (RDATA(d)->type)
MRB_API void mrb_data_check_type(mrb_state *mrb, mrb_value, const mrb_data_type*);
include/mruby/endian.h
+1 -1
View File
@@ -34,7 +34,7 @@ static inline int
check_little_endian(void)
{
unsigned int n = 1;
return (*(unsigned char *)&n == 1);
return (*(unsigned char*)&n == 1);
}
# define littleendian check_little_endian()
#endif
include/mruby/khash.h
+2 -2
View File
@@ -102,8 +102,8 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
uint8_t *p = (uint8_t*)mrb_malloc_simple(mrb, sizeof(uint8_t)*sz/4+len*sz); \
if (!p) { return 1; } \
h->size = 0; \
h->keys = (khkey_t *)p; \
h->vals = kh_is_map ? (khval_t *)(p+sizeof(khkey_t)*sz) : NULL; \
h->keys = (khkey_t*)p; \
h->vals = kh_is_map ? (khval_t*)(p+sizeof(khkey_t)*sz) : NULL; \
h->ed_flags = p+len*sz; \
kh_fill_flags(h->ed_flags, 0xaa, sz/4); \
return 0; \
include/mruby/value.h
+1 -1
View File
@@ -125,7 +125,7 @@ MRB_API int mrb_msvc_snprintf(char *s, size_t n, const char *format, ...);
# define isinf(n) (!_finite(n) && !_isnan(n))
# define signbit(n) (_copysign(1.0, (n)) < 0.0)
static const unsigned int IEEE754_INFINITY_BITS_SINGLE = 0x7F800000;
# define INFINITY (*(float *)&IEEE754_INFINITY_BITS_SINGLE)
# define INFINITY (*(float*)&IEEE754_INFINITY_BITS_SINGLE)
# define NAN ((float)(INFINITY - INFINITY))
# endif
#endif
mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.h
+13 -13
View File
@@ -9,18 +9,18 @@
#include <mruby.h>
#include "mrdb.h"
int32_t mrb_debug_set_break_line(mrb_state *, mrb_debug_context *, const char *, uint16_t);
int32_t mrb_debug_set_break_method(mrb_state *, mrb_debug_context *, const char *, const char *);
int32_t mrb_debug_get_breaknum(mrb_state *, mrb_debug_context *);
int32_t mrb_debug_get_break_all(mrb_state *, mrb_debug_context *, uint32_t, mrb_debug_breakpoint bp[]);
int32_t mrb_debug_get_break(mrb_state *, mrb_debug_context *, uint32_t, mrb_debug_breakpoint *);
int32_t mrb_debug_delete_break(mrb_state *, mrb_debug_context *, uint32_t);
int32_t mrb_debug_delete_break_all(mrb_state *, mrb_debug_context *);
int32_t mrb_debug_enable_break(mrb_state *, mrb_debug_context *, uint32_t);
int32_t mrb_debug_enable_break_all(mrb_state *, mrb_debug_context *);
int32_t mrb_debug_disable_break(mrb_state *, mrb_debug_context *, uint32_t);
int32_t mrb_debug_disable_break_all(mrb_state *, mrb_debug_context *);
int32_t mrb_debug_check_breakpoint_line(mrb_state *, mrb_debug_context *, const char *, uint16_t);
int32_t mrb_debug_check_breakpoint_method(mrb_state *, mrb_debug_context *, struct RClass *, mrb_sym, mrb_bool*);
int32_t mrb_debug_set_break_line(mrb_state*, mrb_debug_context*, const char*, uint16_t);
int32_t mrb_debug_set_break_method(mrb_state*, mrb_debug_context*, const char*, const char*);
int32_t mrb_debug_get_breaknum(mrb_state*, mrb_debug_context*);
int32_t mrb_debug_get_break_all(mrb_state*, mrb_debug_context*, uint32_t, mrb_debug_breakpoint bp[]);
int32_t mrb_debug_get_break(mrb_state*, mrb_debug_context*, uint32_t, mrb_debug_breakpoint*);
int32_t mrb_debug_delete_break(mrb_state*, mrb_debug_context*, uint32_t);
int32_t mrb_debug_delete_break_all(mrb_state*, mrb_debug_context*);
int32_t mrb_debug_enable_break(mrb_state*, mrb_debug_context*, uint32_t);
int32_t mrb_debug_enable_break_all(mrb_state*, mrb_debug_context*);
int32_t mrb_debug_disable_break(mrb_state*, mrb_debug_context*, uint32_t);
int32_t mrb_debug_disable_break_all(mrb_state*, mrb_debug_context*);
int32_t mrb_debug_check_breakpoint_line(mrb_state*, mrb_debug_context*, const char*, uint16_t);
int32_t mrb_debug_check_breakpoint_method(mrb_state*, mrb_debug_context*, struct RClass*, mrb_sym, mrb_bool*);
#endif /* APIBREAK_H_ */
mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c
+1 -1
View File
@@ -200,7 +200,7 @@ mrb_debug_get_source(mrb_state *mrb, mrdb_state *mrdb, const char *srcpath, cons
break;
}
mrb_free(mrb, (void *)search_path[1]);
mrb_free(mrb, (void*)search_path[1]);
return path;
}
mrbgems/mruby-bin-debugger/tools/mrdb/apilist.h
+2 -2
View File
@@ -8,7 +8,7 @@
#include <mruby.h>
#include "mrdb.h"
int32_t mrb_debug_list(mrb_state *, mrb_debug_context *, char *, uint16_t, uint16_t);
char* mrb_debug_get_source(mrb_state *, mrdb_state *, const char *, const char *);
int32_t mrb_debug_list(mrb_state*, mrb_debug_context*, char*, uint16_t, uint16_t);
char* mrb_debug_get_source(mrb_state*, mrdb_state*, const char*, const char *);
#endif /* APILIST_H_ */
mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c
+1 -1
View File
@@ -34,7 +34,7 @@ mrdb_check_syntax(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size
mrb_value
mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t len, mrb_bool *exc, int direct_eval)
{
void (*tmp)(struct mrb_state *, const struct mrb_irep *, const mrb_code *, mrb_value *);
void (*tmp)(struct mrb_state*, const struct mrb_irep*, const mrb_code*, mrb_value*);
mrb_value ruby_code;
mrb_value s;
mrb_value v;
mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c
+2 -2
View File
@@ -42,8 +42,8 @@
#define LINENO_MAX_DIGIT 6
#define BPNO_LETTER_NUM 9
typedef int32_t (*all_command_func)(mrb_state *, mrb_debug_context *);
typedef int32_t (*select_command_func)(mrb_state *, mrb_debug_context *, uint32_t);
typedef int32_t (*all_command_func)(mrb_state*, mrb_debug_context*);
typedef int32_t (*select_command_func)(mrb_state*, mrb_debug_context*, uint32_t);
static void
print_api_common_error(int32_t error)
mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c
+1 -1
View File
@@ -350,7 +350,7 @@ check_cmd_pattern(const char *pattern, const char *cmd)
}
p = lbracket + 1;
q = (char *)cmd + (lbracket - pattern);
q = (char*)cmd + (lbracket - pattern);
for ( ; p < rbracket && *q != '\0'; p++, q++) {
if (*p != *q) {
mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
+3 -4
View File
@@ -20,7 +20,7 @@
#include "apibreak.h"
#include "apilist.h"
void mrdb_state_free(mrb_state *);
void mrdb_state_free(mrb_state*);
static mrb_debug_context *_debug_context = NULL;
static mrdb_state *_mrdb_state = NULL;
@@ -113,7 +113,7 @@ append_srcpath:
char *buf;
buflen = strlen(item) + 1;
buf = (char *)mrb_malloc(mrb, buflen);
buf = (char*)mrb_malloc(mrb, buflen);
memcpy(buf, item, buflen);
args->srcpath = buf;
}
@@ -123,8 +123,7 @@ append_srcpath:
srcpathlen = strlen(args->srcpath);
itemlen = strlen(item);
args->srcpath =
(char *)mrb_realloc(mrb, args->srcpath, srcpathlen + itemlen + 2);
args->srcpath = (char*)mrb_realloc(mrb, args->srcpath, srcpathlen + itemlen + 2);
args->srcpath[srcpathlen] = '\n';
memcpy(args->srcpath + srcpathlen + 1, item, itemlen + 1);
}
mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
+1 -1
View File
@@ -95,7 +95,7 @@ get_history_path(mrb_state *mrb)
int len = snprintf(NULL, 0, "%s/%s", home, history_file_name);
if (len >= 0) {
size_t size = len + 1;
path = (char *)mrb_malloc_simple(mrb, size);
path = (char*)mrb_malloc_simple(mrb, size);
if (path != NULL) {
int n = snprintf(path, size, "%s/%s", home, history_file_name);
if (n != len) {
mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c
+1 -1
View File
@@ -199,7 +199,7 @@ static int
partial_hook(struct mrb_parser_state *p)
{
mrbc_context *c = p->cxt;
struct mrbc_args *args = (struct mrbc_args *)c->partial_data;
struct mrbc_args *args = (struct mrbc_args*)c->partial_data;
const char *fn;
if (p->f) fclose(p->f);
mrbgems/mruby-bin-mruby/tools/mruby/mruby.c
+1 -2
View File
@@ -172,8 +172,7 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args)
cmdlinelen = strlen(args->cmdline);
itemlen = strlen(item);
args->cmdline =
(char *)mrb_realloc(mrb, args->cmdline, cmdlinelen + itemlen + 2);
args->cmdline = (char*)mrb_realloc(mrb, args->cmdline, cmdlinelen + itemlen + 2);
args->cmdline[cmdlinelen] = '\n';
memcpy(args->cmdline + cmdlinelen + 1, item, itemlen + 1);
}
mrbgems/mruby-binding/src/binding.c
+1 -1
View File
@@ -55,7 +55,7 @@ mrb_binding_extract_env(mrb_state *mrb, mrb_value binding)
}
else {
mrb_check_type(mrb, obj, MRB_TT_ENV);
return (struct REnv *)mrb_obj_ptr(obj);
return (struct REnv*)mrb_obj_ptr(obj);
}
}
mrbgems/mruby-fiber/src/fiber.c
+2 -2
View File
@@ -93,7 +93,7 @@ fiber_init(mrb_state *mrb, mrb_value self)
if (p->body.irep->nregs > slen) {
slen += p->body.irep->nregs;
}
c->stbase = (mrb_value *)mrb_malloc(mrb, slen*sizeof(mrb_value));
c->stbase = (mrb_value*)mrb_malloc(mrb, slen*sizeof(mrb_value));
c->stend = c->stbase + slen;
{
@@ -110,7 +110,7 @@ fiber_init(mrb_state *mrb, mrb_value self)
c->stbase[0] = mrb->c->ci->stack[0];
/* initialize callinfo stack */
c->cibase = (mrb_callinfo *)mrb_calloc(mrb, FIBER_CI_INIT_SIZE, sizeof(mrb_callinfo));
c->cibase = (mrb_callinfo*)mrb_calloc(mrb, FIBER_CI_INIT_SIZE, sizeof(mrb_callinfo));
c->ciend = c->cibase + FIBER_CI_INIT_SIZE;
c->ci = c->cibase;
mrbgems/mruby-io/src/file.c
+2 -2
View File
@@ -615,10 +615,10 @@ mrb_file_s_readlink(mrb_state *mrb, mrb_value klass) {
mrb_get_args(mrb, "z", &path);
tmp = mrb_locale_from_utf8(path, -1);
buf = (char *)mrb_malloc(mrb, bufsize);
buf = (char*)mrb_malloc(mrb, bufsize);
while ((rc = readlink(tmp, buf, bufsize)) == (ssize_t)bufsize && rc != -1) {
bufsize *= 2;
buf = (char *)mrb_realloc(mrb, buf, bufsize);
buf = (char*)mrb_realloc(mrb, buf, bufsize);
}
mrb_locale_free(tmp);
if (rc == -1) {
mrbgems/mruby-io/src/file_test.c
+1 -1
View File
@@ -38,7 +38,7 @@ mrb_stat0(mrb_state *mrb, mrb_value obj, struct stat *st, int do_lstat)
{
if (mrb_obj_is_kind_of(mrb, obj, mrb_class_get(mrb, "IO"))) {
struct mrb_io *fptr;
fptr = (struct mrb_io *)mrb_data_get_ptr(mrb, obj, &mrb_io_type);
fptr = (struct mrb_io*)mrb_data_get_ptr(mrb, obj, &mrb_io_type);
if (fptr && fptr->fd >= 0) {
return fstat(fptr->fd, st);
mrbgems/mruby-io/test/mruby_io_test.c
+1 -1
View File
@@ -142,7 +142,7 @@ mrb_io_test_io_setup(mrb_state *mrb, mrb_value self)
sun0.sun_family = AF_UNIX;
strncpy(sun0.sun_path, fnames[IDX_SOCKET], sizeof(sun0.sun_path)-1);
sun0.sun_path[sizeof(sun0.sun_path)-1] = 0;
if (bind(fds[IDX_SOCKET], (struct sockaddr *)&sun0, sizeof(sun0)) == -1) {
if (bind(fds[IDX_SOCKET], (struct sockaddr*)&sun0, sizeof(sun0)) == -1) {
mrb_raisef(mrb, E_RUNTIME_ERROR, "can't bind AF_UNIX socket to %s: %d",
sun0.sun_path,
errno);
mrbgems/mruby-os-memsize/src/memsize.c
+3 -3
View File
@@ -95,7 +95,7 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj)
/* Arrays that do not fit within an RArray perform a heap allocation
* storing an array of pointers to the original objects*/
size += mrb_objspace_page_slot_size();
if(len > MRB_ARY_EMBED_LEN_MAX) size += sizeof(mrb_value *) * len;
if(len > MRB_ARY_EMBED_LEN_MAX) size += sizeof(mrb_value*) * len;
break;
}
case MRB_TT_PROC: {
@@ -112,7 +112,7 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj)
#endif
break;
case MRB_TT_FIBER: {
struct RFiber* f = (struct RFiber *)mrb_ptr(obj);
struct RFiber* f = (struct RFiber*)mrb_ptr(obj);
ptrdiff_t stack_size = f->cxt->stend - f->cxt->stbase;
ptrdiff_t ci_size = f->cxt->ciend - f->cxt->cibase;
@@ -206,7 +206,7 @@ struct os_memsize_of_all_cb_data {
static int
os_memsize_of_all_cb(mrb_state *mrb, struct RBasic *obj, void *d)
{
struct os_memsize_of_all_cb_data *data = (struct os_memsize_of_all_cb_data *)d;
struct os_memsize_of_all_cb_data *data = (struct os_memsize_of_all_cb_data*)d;
switch (obj->tt) {
case MRB_TT_FREE: case MRB_TT_ENV:
case MRB_TT_BREAK: case MRB_TT_ICLASS:
mrbgems/mruby-pack/src/pack.c
+12 -12
View File
@@ -123,9 +123,9 @@ static int
unpack_char(mrb_state *mrb, const void *src, int srclen, mrb_value ary, unsigned int flags)
{
if (flags & PACK_FLAG_SIGNED)
mrb_ary_push(mrb, ary, mrb_fixnum_value(*(signed char *)src));
mrb_ary_push(mrb, ary, mrb_fixnum_value(*(signed char*)src));
else
mrb_ary_push(mrb, ary, mrb_fixnum_value(*(unsigned char *)src));
mrb_ary_push(mrb, ary, mrb_fixnum_value(*(unsigned char*)src));
return 1;
}
@@ -425,7 +425,7 @@ pack_double(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned i
{
int i;
double d;
uint8_t *buffer = (uint8_t *)&d;
uint8_t *buffer = (uint8_t*)&d;
str = str_len_ensure(mrb, str, sidx + 8);
d = mrb_float(o);
@@ -457,7 +457,7 @@ unpack_double(mrb_state *mrb, const unsigned char * src, int srclen, mrb_value a
{
int i;
double d;
uint8_t *buffer = (uint8_t *)&d;
uint8_t *buffer = (uint8_t*)&d;
if (flags & PACK_FLAG_LITTLEENDIAN) {
if (littleendian) {
@@ -488,7 +488,7 @@ pack_float(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned in
{
int i;
float f;
uint8_t *buffer = (uint8_t *)&f;
uint8_t *buffer = (uint8_t*)&f;
str = str_len_ensure(mrb, str, sidx + 4);
f = (float)mrb_float(o);
@@ -520,7 +520,7 @@ unpack_float(mrb_state *mrb, const unsigned char * src, int srclen, mrb_value ar
{
int i;
float f;
uint8_t *buffer = (uint8_t *)&f;
uint8_t *buffer = (uint8_t*)&f;
if (flags & PACK_FLAG_LITTLEENDIAN) {
if (littleendian) {
@@ -660,7 +660,7 @@ unpack_utf8(mrb_state *mrb, const unsigned char * src, int srclen, mrb_value ary
if (srclen == 0) {
return 1;
}
uv = utf8_to_uv(mrb, (const char *)src, &lenp);
uv = utf8_to_uv(mrb, (const char*)src, &lenp);
mrb_ary_push(mrb, ary, mrb_fixnum_value((mrb_int)uv));
return (int)lenp;
}
@@ -719,14 +719,14 @@ unpack_str(mrb_state *mrb, const void *src, int slen, mrb_value ary, int count,
const char *cp, *sptr;
int copylen;
sptr = (const char *)src;
sptr = (const char*)src;
if (count != -1 && count < slen) {
slen = count;
}
copylen = slen;
if (slen >= 0 && flags & PACK_FLAG_Z) { /* "Z" */
if ((cp = (const char *)memchr(sptr, '\0', slen)) != NULL) {
if ((cp = (const char*)memchr(sptr, '\0', slen)) != NULL) {
copylen = (int)(cp - sptr);
if (count == -1) {
slen = copylen + 1;
@@ -812,7 +812,7 @@ unpack_hex(mrb_state *mrb, const void *src, int slen, mrb_value ary, int count,
bshift = 0;
}
sptr = (const char *)src;
sptr = (const char*)src;
if (count == -1)
count = slen * 2;
@@ -921,7 +921,7 @@ unpack_base64(mrb_state *mrb, const void *src, int slen, mrb_value ary)
const char *sptr, *sptr0;
char *dptr, *dptr0;
sptr0 = sptr = (const char *)src;
sptr0 = sptr = (const char*)src;
dlen = slen / 4 * 3; /* an estimated value - may be shorter */
dst = mrb_str_new(mrb, NULL, dlen);
@@ -1514,7 +1514,7 @@ pack_unpack(mrb_state *mrb, mrb_value str, int single)
}
/* PACK_FLAG_COUNT2 directions */
sptr = (const unsigned char *)RSTRING_PTR(str) + srcidx;
sptr = (const unsigned char*)RSTRING_PTR(str) + srcidx;
switch (dir) {
case PACK_DIR_HEX:
srcidx += unpack_hex(mrb, sptr, srclen - srcidx, result, count, flags);
mrbgems/mruby-socket/src/socket.c
+26 -27
View File
@@ -56,24 +56,22 @@
#ifdef _WIN32
static const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt)
{
if (af == AF_INET)
{
if (af == AF_INET) {
struct sockaddr_in in = {0};
in.sin_family = AF_INET;
memcpy(&in.sin_addr, src, sizeof(struct in_addr));
getnameinfo((struct sockaddr *)&in, sizeof(struct
sockaddr_in), dst, cnt, NULL, 0, NI_NUMERICHOST);
getnameinfo((struct sockaddr*)&in, sizeof(struct sockaddr_in),
dst, cnt, NULL, 0, NI_NUMERICHOST);
return dst;
}
else if (af == AF_INET6)
{
else if (af == AF_INET6) {
struct sockaddr_in6 in = {0};
in.sin6_family = AF_INET6;
memcpy(&in.sin6_addr, src, sizeof(struct in_addr6));
getnameinfo((struct sockaddr *)&in, sizeof(struct
sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST);
getnameinfo((struct sockaddr*)&in, sizeof(struct sockaddr_in6),
dst, cnt, NULL, 0, NI_NUMERICHOST);
return dst;
}
return NULL;
@@ -195,7 +193,7 @@ mrb_addrinfo_getnameinfo(mrb_state *mrb, mrb_value self)
if (!mrb_string_p(sastr)) {
mrb_raise(mrb, E_SOCKET_ERROR, "invalid sockaddr");
}
error = getnameinfo((struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr), RSTRING_PTR(host), NI_MAXHOST, RSTRING_PTR(serv), NI_MAXSERV, (int)flags);
error = getnameinfo((struct sockaddr*)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr), RSTRING_PTR(host), NI_MAXHOST, RSTRING_PTR(serv), NI_MAXSERV, (int)flags);
if (error) {
mrb_raisef(mrb, E_SOCKET_ERROR, "getnameinfo: %s", gai_strerror(error));
}
@@ -214,12 +212,12 @@ mrb_addrinfo_unix_path(mrb_state *mrb, mrb_value self)
mrb_value sastr;
sastr = mrb_iv_get(mrb, self, MRB_IVSYM(sockaddr));
if (((struct sockaddr *)RSTRING_PTR(sastr))->sa_family != AF_UNIX)
if (((struct sockaddr*)RSTRING_PTR(sastr))->sa_family != AF_UNIX)
mrb_raise(mrb, E_SOCKET_ERROR, "need AF_UNIX address");
if (RSTRING_LEN(sastr) < (mrb_int)offsetof(struct sockaddr_un, sun_path) + 1) {
return mrb_str_new(mrb, "", 0);
} else {
return mrb_str_new_cstr(mrb, ((struct sockaddr_un *)RSTRING_PTR(sastr))->sun_path);
return mrb_str_new_cstr(mrb, ((struct sockaddr_un*)RSTRING_PTR(sastr))->sun_path);
}
}
#endif
@@ -234,11 +232,11 @@ sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen)
switch (sa->sa_family) {
case AF_INET:
afstr = "AF_INET";
port = ((struct sockaddr_in *)sa)->sin_port;
port = ((struct sockaddr_in*)sa)->sin_port;
break;
case AF_INET6:
afstr = "AF_INET6";
port = ((struct sockaddr_in6 *)sa)->sin6_port;
port = ((struct sockaddr_in6*)sa)->sin6_port;
break;
default:
mrb_raise(mrb, E_ARGUMENT_ERROR, "bad af");
@@ -272,7 +270,7 @@ socket_family(int s)
socklen_t salen;
salen = sizeof(ss);
if (getsockname(s, (struct sockaddr *)&ss, &salen) == -1)
if (getsockname(s, (struct sockaddr*)&ss, &salen) == -1)
return AF_UNSPEC;
return ss.ss_family;
}
@@ -307,7 +305,7 @@ mrb_basicsocket_getpeername(mrb_state *mrb, mrb_value self)
socklen_t salen;
salen = sizeof(ss);
if (getpeername(socket_fd(mrb, self), (struct sockaddr *)&ss, &salen) != 0)
if (getpeername(socket_fd(mrb, self), (struct sockaddr*)&ss, &salen) != 0)
mrb_sys_fail(mrb, "getpeername");
return mrb_str_new(mrb, (char*)&ss, salen);
@@ -320,7 +318,7 @@ mrb_basicsocket_getsockname(mrb_state *mrb, mrb_value self)
socklen_t salen;
salen = sizeof(ss);
if (getsockname(socket_fd(mrb, self), (struct sockaddr *)&ss, &salen) != 0)
if (getsockname(socket_fd(mrb, self), (struct sockaddr*)&ss, &salen) != 0)
mrb_sys_fail(mrb, "getsockname");
return mrb_str_new(mrb, (char*)&ss, salen);
@@ -374,7 +372,7 @@ mrb_basicsocket_recvfrom(mrb_state *mrb, mrb_value self)
buf = mrb_str_new_capa(mrb, maxlen);
socklen = sizeof(struct sockaddr_storage);
sa = mrb_str_new_capa(mrb, socklen);
n = recvfrom(socket_fd(mrb, self), RSTRING_PTR(buf), (fsize_t)maxlen, (int)flags, (struct sockaddr *)RSTRING_PTR(sa), &socklen);
n = recvfrom(socket_fd(mrb, self), RSTRING_PTR(buf), (fsize_t)maxlen, (int)flags, (struct sockaddr*)RSTRING_PTR(sa), &socklen);
if (n == -1)
mrb_sys_fail(mrb, "recvfrom");
mrb_str_resize(mrb, buf, (mrb_int)n);
@@ -533,12 +531,13 @@ mrb_ipsocket_pton(mrb_state *mrb, mrb_value klass)
if (af == AF_INET) {
struct in_addr in;
if (inet_pton(AF_INET, buf, (void *)&in.s_addr) != 1)
if (inet_pton(AF_INET, buf, (void*)&in.s_addr) != 1)
goto invalid;
return mrb_str_new(mrb, (char*)&in.s_addr, 4);
} else if (af == AF_INET6) {
}
else if (af == AF_INET6) {
struct in6_addr in6;
if (inet_pton(AF_INET6, buf, (void *)&in6.s6_addr) != 1)
if (inet_pton(AF_INET6, buf, (void*)&in6.s6_addr) != 1)
goto invalid;
return mrb_str_new(mrb, (char*)&in6.s6_addr, 16);
} else
@@ -565,12 +564,12 @@ mrb_ipsocket_recvfrom(mrb_state *mrb, mrb_value self)
buf = mrb_str_new_capa(mrb, maxlen);
socklen = sizeof(ss);
n = recvfrom(fd, RSTRING_PTR(buf), (fsize_t)maxlen, (int)flags,
(struct sockaddr *)&ss, &socklen);
(struct sockaddr*)&ss, &socklen);
if (n == -1) {
mrb_sys_fail(mrb, "recvfrom");
}
mrb_str_resize(mrb, buf, (mrb_int)n);
a = sa2addrlist(mrb, (struct sockaddr *)&ss, socklen);
a = sa2addrlist(mrb, (struct sockaddr*)&ss, socklen);
pair = mrb_ary_new_capa(mrb, 2);
mrb_ary_push(mrb, pair, buf);
mrb_ary_push(mrb, pair, a);
@@ -620,7 +619,7 @@ mrb_socket_accept2(mrb_state *mrb, mrb_value klass)
mrb_get_args(mrb, "i", &s0);
socklen = sizeof(struct sockaddr_storage);
sastr = mrb_str_new_capa(mrb, (mrb_int)socklen);
s1 = (int)accept(s0, (struct sockaddr *)RSTRING_PTR(sastr), &socklen);
s1 = (int)accept(s0, (struct sockaddr*)RSTRING_PTR(sastr), &socklen);
if (s1 == -1) {
mrb_sys_fail(mrb, "accept");
}
@@ -639,7 +638,7 @@ mrb_socket_bind(mrb_state *mrb, mrb_value klass)
mrb_int s;
mrb_get_args(mrb, "iS", &s, &sastr);
if (bind((int)s, (struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
if (bind((int)s, (struct sockaddr*)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
mrb_sys_fail(mrb, "bind");
}
return mrb_nil_value();
@@ -652,7 +651,7 @@ mrb_socket_connect(mrb_state *mrb, mrb_value klass)
mrb_int s;
mrb_get_args(mrb, "iS", &s, &sastr);
if (connect((int)s, (struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
if (connect((int)s, (struct sockaddr*)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
mrb_sys_fail(mrb, "connect");
}
return mrb_nil_value();
@@ -680,7 +679,7 @@ mrb_socket_sockaddr_family(mrb_state *mrb, mrb_value klass)
if ((size_t)RSTRING_LEN(str) < offsetof(struct sockaddr, sa_family) + sizeof(sa->sa_family)) {
mrb_raise(mrb, E_SOCKET_ERROR, "invalid sockaddr (too short)");
}
sa = (const struct sockaddr *)RSTRING_PTR(str);
sa = (const struct sockaddr*)RSTRING_PTR(str);
return mrb_fixnum_value(sa->sa_family);
}
@@ -699,7 +698,7 @@ mrb_socket_sockaddr_un(mrb_state *mrb, mrb_value klass)
mrb_raisef(mrb, E_ARGUMENT_ERROR, "too long unix socket path (max: %d bytes)", (int)sizeof(sunp->sun_path) - 1);
}
s = mrb_str_new_capa(mrb, sizeof(struct sockaddr_un));
sunp = (struct sockaddr_un *)RSTRING_PTR(s);
sunp = (struct sockaddr_un*)RSTRING_PTR(s);
#if HAVE_SA_LEN
sunp->sun_len = sizeof(struct sockaddr_un);
#endif
mrbgems/mruby-struct/src/struct.c
+1 -1
View File
@@ -128,7 +128,7 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id)
name = mrb_sym_name_len(mrb, id, &len);
if (len > ONSTACK_STRLEN_MAX) {
buf = (char *)mrb_malloc(mrb, (size_t)len+1);
buf = (char*)mrb_malloc(mrb, (size_t)len+1);
}
else {
buf = onstack;
mrbgems/mruby-test/driver.c
+1 -1
View File
@@ -172,7 +172,7 @@ str_match_p(mrb_state *mrb,
if (lbrace && rbrace) {
/* expand brace */
char *ex_pat = (char *)mrb_malloc(mrb, pat_len-2); /* expanded pattern */
char *ex_pat = (char*)mrb_malloc(mrb, pat_len-2); /* expanded pattern */
char *ex_p = ex_pat;
COPY_AND_INC(ex_p, pat, lbrace-pat);
mrbgems/mruby-time/src/time.c
+7 -7
View File
@@ -363,7 +363,7 @@ time_alloc_time(mrb_state *mrb, time_t sec, time_t usec, enum mrb_timezone timez
{
struct mrb_time *tm;
tm = (struct mrb_time *)mrb_malloc(mrb, sizeof(struct mrb_time));
tm = (struct mrb_time*)mrb_malloc(mrb, sizeof(struct mrb_time));
tm->sec = sec;
tm->usec = usec;
if (MRB_TIME_T_UINT && tm->usec < 0) {
@@ -450,7 +450,7 @@ current_mrb_time(mrb_state *mrb)
usec = tv.tv_usec;
}
#endif
tm = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm));
tm = (struct mrb_time*)mrb_malloc(mrb, sizeof(*tm));
*tm = tmzero;
tm->sec = sec; tm->usec = usec;
tm->timezone = MRB_TIMEZONE_LOCAL;
@@ -819,7 +819,7 @@ time_getutc(mrb_state *mrb, mrb_value self)
struct mrb_time *tm, *tm2;
tm = time_get_ptr(mrb, self);
tm2 = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm));
tm2 = (struct mrb_time*)mrb_malloc(mrb, sizeof(*tm));
*tm2 = *tm;
tm2->timezone = MRB_TIMEZONE_UTC;
time_update_datetime(mrb, tm2, TRUE);
@@ -834,7 +834,7 @@ time_getlocal(mrb_state *mrb, mrb_value self)
struct mrb_time *tm, *tm2;
tm = time_get_ptr(mrb, self);
tm2 = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm));
tm2 = (struct mrb_time*)mrb_malloc(mrb, sizeof(*tm));
*tm2 = *tm;
tm2->timezone = MRB_TIMEZONE_LOCAL;
time_update_datetime(mrb, tm2, TRUE);
@@ -892,13 +892,13 @@ time_init_copy(mrb_state *mrb, mrb_value copy)
if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) {
mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
}
t1 = (struct mrb_time *)DATA_PTR(copy);
t2 = (struct mrb_time *)DATA_PTR(src);
t1 = (struct mrb_time*)DATA_PTR(copy);
t2 = (struct mrb_time*)DATA_PTR(src);
if (!t2) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "uninitialized time");
}
if (!t1) {
t1 = (struct mrb_time *)mrb_malloc(mrb, sizeof(struct mrb_time));
t1 = (struct mrb_time*)mrb_malloc(mrb, sizeof(struct mrb_time));
mrb_data_init(copy, t1, &time_type);
}
*t1 = *t2;
oss-fuzz/mruby_proto_fuzzer.cpp
+1 -1
View File
@@ -18,7 +18,7 @@ int FuzzRB(const uint8_t *Data, size_t size) {
if (!mrb)
return 0;
char *code = (char *)malloc(size+1);
char *code = (char*)malloc(size+1);
if (!code)
return 0;
memcpy(code, Data, size);
src/array.c
+6 -6
View File
@@ -160,7 +160,7 @@ ary_modify(mrb_state *mrb, struct RArray *a)
p = a->as.heap.ptr;
len = a->as.heap.len * sizeof(mrb_value);
ptr = (mrb_value *)mrb_malloc(mrb, len);
ptr = (mrb_value*)mrb_malloc(mrb, len);
if (p) {
array_copy(ptr, p, a->as.heap.len);
}
@@ -183,13 +183,13 @@ static void
ary_make_shared(mrb_state *mrb, struct RArray *a)
{
if (!ARY_SHARED_P(a) && !ARY_EMBED_P(a)) {
mrb_shared_array *shared = (mrb_shared_array *)mrb_malloc(mrb, sizeof(mrb_shared_array));
mrb_shared_array *shared = (mrb_shared_array*)mrb_malloc(mrb, sizeof(mrb_shared_array));
mrb_value *ptr = a->as.heap.ptr;
mrb_int len = a->as.heap.len;
shared->refcnt = 1;
if (a->as.heap.aux.capa > len) {
a->as.heap.ptr = shared->ptr = (mrb_value *)mrb_realloc(mrb, ptr, sizeof(mrb_value)*len+1);
a->as.heap.ptr = shared->ptr = (mrb_value*)mrb_realloc(mrb, ptr, sizeof(mrb_value)*len+1);
}
else {
shared->ptr = ptr;
@@ -224,7 +224,7 @@ ary_expand_capa(mrb_state *mrb, struct RArray *a, mrb_int len)
if (ARY_EMBED_P(a)) {
mrb_value *ptr = ARY_EMBED_PTR(a);
mrb_int len = ARY_EMBED_LEN(a);
mrb_value *expanded_ptr = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*capa);
mrb_value *expanded_ptr = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value)*capa);
ARY_UNSET_EMBED_FLAG(a);
array_copy(expanded_ptr, ptr, len);
@@ -233,7 +233,7 @@ ary_expand_capa(mrb_state *mrb, struct RArray *a, mrb_int len)
a->as.heap.ptr = expanded_ptr;
}
else if (capa > a->as.heap.aux.capa) {
mrb_value *expanded_ptr = (mrb_value *)mrb_realloc(mrb, a->as.heap.ptr, sizeof(mrb_value)*capa);
mrb_value *expanded_ptr = (mrb_value*)mrb_realloc(mrb, a->as.heap.ptr, sizeof(mrb_value)*capa);
a->as.heap.aux.capa = capa;
a->as.heap.ptr = expanded_ptr;
@@ -262,7 +262,7 @@ ary_shrink_capa(mrb_state *mrb, struct RArray *a)
if (capa > a->as.heap.len && capa < a->as.heap.aux.capa) {
a->as.heap.aux.capa = capa;
a->as.heap.ptr = (mrb_value *)mrb_realloc(mrb, a->as.heap.ptr, sizeof(mrb_value)*capa);
a->as.heap.ptr = (mrb_value*)mrb_realloc(mrb, a->as.heap.ptr, sizeof(mrb_value)*capa);
}
}
src/class.c
+1 -1
View File
@@ -1836,7 +1836,7 @@ prepare_name_common(mrb_state *mrb, mrb_sym sym, const char *prefix, const char
size_t prefix_len = prefix ? strlen(prefix) : 0;
size_t suffix_len = suffix ? strlen(suffix) : 0;
size_t name_len = sym_len + prefix_len + suffix_len;
char *buf = name_len > sizeof(onstack) ? (char *)mrb_alloca(mrb, name_len) : onstack;
char *buf = name_len > sizeof(onstack) ? (char*)mrb_alloca(mrb, name_len) : onstack;
char *p = buf;
if (prefix_len > 0) {
src/debug.c
+1 -1
View File
@@ -178,7 +178,7 @@ mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep)
mrb_irep_debug_info *ret;
mrb_assert(!irep->debug_info);
ret = (mrb_irep_debug_info *)mrb_malloc(mrb, sizeof(*ret));
ret = (mrb_irep_debug_info*)mrb_malloc(mrb, sizeof(*ret));
*ret = initial;
irep->debug_info = ret;
return ret;
src/dump.c
+3 -3
View File
@@ -452,7 +452,7 @@ get_filename_table_size(mrb_state *mrb, const mrb_irep *irep, mrb_sym **fp, uint
if (find_filename_index(filenames, *lp, file->filename_sym) == -1) {
/* register filename */
*lp += 1;
*fp = filenames = (mrb_sym *)mrb_realloc(mrb, filenames, sizeof(mrb_sym) * (*lp));
*fp = filenames = (mrb_sym*)mrb_realloc(mrb, filenames, sizeof(mrb_sym) * (*lp));
filenames[*lp - 1] = file->filename_sym;
/* filename */
@@ -557,7 +557,7 @@ write_section_debug(mrb_state *mrb, const mrb_irep *irep, uint8_t *cur, mrb_sym
return MRB_DUMP_INVALID_ARGUMENT;
}
header = (struct rite_section_debug_header *)bin;
header = (struct rite_section_debug_header*)bin;
cur += sizeof(struct rite_section_debug_header);
section_size += sizeof(struct rite_section_debug_header);
@@ -728,7 +728,7 @@ lv_section_exit:
static int
write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin, uint8_t flags)
{
struct rite_binary_header *header = (struct rite_binary_header *)bin;
struct rite_binary_header *header = (struct rite_binary_header*)bin;
memcpy(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident));
memcpy(header->major_version, RITE_BINARY_MAJOR_VER, sizeof(header->major_version));
src/error.c
+1 -1
View File
@@ -540,7 +540,7 @@ mrb_argnum_error(mrb_state *mrb, mrb_int argc, int min, int max)
void mrb_core_init_printabort(void);
int
mrb_core_init_protect(mrb_state *mrb, void (*body)(mrb_state *, void *), void *opaque)
mrb_core_init_protect(mrb_state *mrb, void (*body)(mrb_state*, void*), void *opaque)
{
struct mrb_jmpbuf *prev_jmp = mrb->jmp;
struct mrb_jmpbuf c_jmp;
src/gc.c
+4 -4
View File
@@ -175,8 +175,8 @@ mrb_static_assert(MRB_GC_RED <= GC_COLOR_MASK);
/* We have removed `objects[]` from `mrb_heap_page` since it was not C++
* compatible. Using array index to get pointer after structure instead. */
/* #define objects(p) ((RVALUE *)p->objects) */
#define objects(p) ((RVALUE *)&p[1])
/* #define objects(p) ((RVALUE*)p->objects) */
#define objects(p) ((RVALUE*)&p[1])
mrb_noreturn void mrb_raise_nomemory(mrb_state *mrb);
@@ -335,7 +335,7 @@ unlink_free_heap_page(mrb_gc *gc, mrb_heap_page *page)
static void
add_heap(mrb_state *mrb, mrb_gc *gc)
{
mrb_heap_page *page = (mrb_heap_page *)mrb_calloc(mrb, 1, sizeof(mrb_heap_page) + MRB_HEAP_PAGE_SIZE * sizeof(RVALUE));
mrb_heap_page *page = (mrb_heap_page*)mrb_calloc(mrb, 1, sizeof(mrb_heap_page) + MRB_HEAP_PAGE_SIZE * sizeof(RVALUE));
RVALUE *p, *e;
struct RBasic *prev = NULL;
@@ -546,7 +546,7 @@ mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls)
gc->live++;
gc_protect(mrb, gc, p);
*(RVALUE *)p = RVALUE_zero;
*(RVALUE*)p = RVALUE_zero;
p->tt = ttype;
p->c = cls;
paint_partial_white(gc, p);
src/hash.c
+2 -2
View File
@@ -1742,8 +1742,8 @@ mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2)
if (h_size(h2) == 0) return;
h_each(h2, entry, {
h_check_modified(mrb, h2, {h_set(mrb, h1, entry->key, entry->val);});
mrb_field_write_barrier_value(mrb, (struct RBasic *)h1, entry->key);
mrb_field_write_barrier_value(mrb, (struct RBasic *)h1, entry->val);
mrb_field_write_barrier_value(mrb, (struct RBasic*)h1, entry->key);
mrb_field_write_barrier_value(mrb, (struct RBasic*)h1, entry->val);
});
}
src/load.c
+12 -12
View File
@@ -110,7 +110,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, const uint8_t *end, size_
}
else {
void *buf = mrb_malloc(mrb, data_len);
irep->iseq = (mrb_code *)buf;
irep->iseq = (mrb_code*)buf;
memcpy(buf, src, data_len);
}
src += data_len;
@@ -220,7 +220,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, const uint8_t *end, size_
if (SIZE_ERROR_MUL(irep->slen, sizeof(mrb_sym))) {
return FALSE;
}
irep->syms = syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen);
irep->syms = syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen);
for (i = 0; i < irep->slen; i++) {
snl = bin_to_uint16(src); /* symbol name length */
@@ -233,10 +233,10 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, const uint8_t *end, size_
if (src + snl > end) return FALSE;
if (flags & FLAG_SRC_MALLOC) {
syms[i] = mrb_intern(mrb, (char *)src, snl);
syms[i] = mrb_intern(mrb, (char*)src, snl);
}
else {
syms[i] = mrb_intern_static(mrb, (char *)src, snl);
syms[i] = mrb_intern_static(mrb, (char*)src, snl);
}
src += snl + 1;
mrb_gc_arena_restore(mrb, ai);
@@ -331,7 +331,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, const uint8_t *end, mrb_
uint16_t filename_idx;
if (bin > end) return MRB_DUMP_GENERAL_FAILURE;
file = (mrb_irep_debug_info_file *)mrb_calloc(mrb, 1, sizeof(*file));
file = (mrb_irep_debug_info_file*)mrb_calloc(mrb, 1, sizeof(*file));
debug->files[f_idx] = file;
file->start_pos = bin_to_uint32(bin);
@@ -352,7 +352,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, const uint8_t *end, mrb_
size_t l = sizeof(uint16_t) * (size_t)file->line_entry_count;
if (bin + l > end) return MRB_DUMP_GENERAL_FAILURE;
uint16_t *ary = (uint16_t *)mrb_malloc(mrb, l);
uint16_t *ary = (uint16_t*)mrb_malloc(mrb, l);
for (l = 0; l < file->line_entry_count; l++) {
ary[l] = bin_to_uint16(bin);
bin += sizeof(uint16_t);
@@ -427,7 +427,7 @@ read_section_debug(mrb_state *mrb, const uint8_t *start, size_t size, mrb_irep *
mrb_value filenames_obj;
bin = start;
header = (struct rite_section_debug_header *)bin;
header = (struct rite_section_debug_header*)bin;
bin += sizeof(struct rite_section_debug_header);
filenames_len = bin_to_uint16(bin);
@@ -443,10 +443,10 @@ read_section_debug(mrb_state *mrb, const uint8_t *start, size_t size, mrb_irep *
goto debug_exit;
}
if (flags & FLAG_SRC_MALLOC) {
filenames[i] = mrb_intern(mrb, (const char *)bin, (size_t)f_len);
filenames[i] = mrb_intern(mrb, (const char*)bin, (size_t)f_len);
}
else {
filenames[i] = mrb_intern_static(mrb, (const char *)bin, (size_t)f_len);
filenames[i] = mrb_intern_static(mrb, (const char*)bin, (size_t)f_len);
}
bin += f_len;
}
@@ -558,7 +558,7 @@ lv_exit:
static int
read_binary_header(const uint8_t *bin, size_t bufsize, size_t *bin_size, uint8_t *flags)
{
const struct rite_binary_header *header = (const struct rite_binary_header *)bin;
const struct rite_binary_header *header = (const struct rite_binary_header*)bin;
if (bufsize < sizeof(struct rite_binary_header)) {
return MRB_DUMP_READ_FAULT;
@@ -607,7 +607,7 @@ read_irep(mrb_state *mrb, const uint8_t *bin, size_t bufsize, uint8_t flags)
bin += sizeof(struct rite_binary_header);
bin_size -= sizeof(struct rite_binary_header);
while (bin_size > sizeof(struct rite_section_header)) {
section_header = (const struct rite_section_header *)bin;
section_header = (const struct rite_section_header*)bin;
uint32_t section_size = bin_to_uint32(section_header->section_size);
if (bin_size < section_size) return NULL;
if (memcmp(section_header->section_ident, RITE_SECTION_IREP_IDENT, sizeof(section_header->section_ident)) == 0) {
@@ -654,7 +654,7 @@ DEFINE_READ_IREP_FUNC(
static struct RProc*
mrb_proc_read_irep_buf(mrb_state *mrb, const void *buf, size_t bufsize)
{
return read_irep(mrb, (const uint8_t *)buf, bufsize, FLAG_SRC_MALLOC);
return read_irep(mrb, (const uint8_t*)buf, bufsize, FLAG_SRC_MALLOC);
}
DEFINE_READ_IREP_FUNC(
src/pool.c
+2 -2
View File
@@ -63,7 +63,7 @@ struct mrb_pool {
MRB_API mrb_pool*
mrb_pool_open(mrb_state *mrb)
{
mrb_pool *pool = (mrb_pool *)mrb_malloc_simple(mrb, sizeof(mrb_pool));
mrb_pool *pool = (mrb_pool*)mrb_malloc_simple(mrb, sizeof(mrb_pool));
if (pool) {
pool->mrb = mrb;
@@ -95,7 +95,7 @@ page_alloc(mrb_pool *pool, size_t len)
if (len < POOL_PAGE_SIZE)
len = POOL_PAGE_SIZE;
page = (struct mrb_pool_page *)mrb_malloc_simple(pool->mrb, sizeof(struct mrb_pool_page)+len);
page = (struct mrb_pool_page*)mrb_malloc_simple(pool->mrb, sizeof(struct mrb_pool_page)+len);
if (page) {
page->offset = 0;
page->len = len;
src/range.c
+1 -1
View File
@@ -70,7 +70,7 @@ static void
range_ptr_alloc_edges(mrb_state *mrb, struct RRange *r)
{
#ifndef MRB_RANGE_EMBED
r->edges = (mrb_range_edges *)mrb_malloc(mrb, sizeof(mrb_range_edges));
r->edges = (mrb_range_edges*)mrb_malloc(mrb, sizeof(mrb_range_edges));
#endif
}
src/state.c
+3 -3
View File
@@ -20,7 +20,7 @@ void mrb_init_mrbgems(mrb_state*);
void mrb_gc_init(mrb_state*, mrb_gc *gc);
void mrb_gc_destroy(mrb_state*, mrb_gc *gc);
int mrb_core_init_protect(mrb_state *mrb, void (*body)(mrb_state *, void *), void *opaque);
int mrb_core_init_protect(mrb_state *mrb, void (*body)(mrb_state*, void*), void *opaque);
static void
init_gc_and_core(mrb_state *mrb, void *opaque)
@@ -42,7 +42,7 @@ mrb_open_core(mrb_allocf f, void *ud)
mrb_state *mrb;
if (f == NULL) f = mrb_default_allocf;
mrb = (mrb_state *)(f)(NULL, NULL, sizeof(mrb_state), ud);
mrb = (mrb_state*)(f)(NULL, NULL, sizeof(mrb_state), ud);
if (mrb == NULL) return NULL;
*mrb = mrb_state_zero;
@@ -207,7 +207,7 @@ mrb_add_irep(mrb_state *mrb)
static const mrb_irep mrb_irep_zero = { 0 };
mrb_irep *irep;
irep = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep));
irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep));
*irep = mrb_irep_zero;
irep->refcnt = 1;
src/string.c
+8 -8
View File
@@ -50,7 +50,7 @@ str_init_normal_capa(mrb_state *mrb, struct RString *s,
const char *p, mrb_int len, mrb_int capa)
{
str_check_too_big(mrb, capa);
char *dst = (char *)mrb_malloc(mrb, capa + 1);
char *dst = (char*)mrb_malloc(mrb, capa + 1);
if (p) memcpy(dst, p, len);
dst[len] = '\0';
s->as.heap.ptr = dst;
@@ -80,7 +80,7 @@ str_init_embed(struct RString *s, const char *p, mrb_int len)
static struct RString*
str_init_nofree(struct RString *s, const char *p, mrb_int len)
{
s->as.heap.ptr = (char *)p;
s->as.heap.ptr = (char*)p;
s->as.heap.len = len;
s->as.heap.aux.capa = 0; /* nofree */
RSTR_SET_TYPE_FLAG(s, NOFREE);
@@ -94,7 +94,7 @@ str_init_shared(mrb_state *mrb, const struct RString *orig, struct RString *s, m
shared->refcnt++;
}
else {
shared = (mrb_shared_string *)mrb_malloc(mrb, sizeof(mrb_shared_string));
shared = (mrb_shared_string*)mrb_malloc(mrb, sizeof(mrb_shared_string));
shared->refcnt = 1;
shared->ptr = orig->as.heap.ptr;
shared->capa = orig->as.heap.aux.capa;
@@ -486,7 +486,7 @@ mrb_memsearch_qs(const unsigned char *xs, mrb_int m, const unsigned char *ys, mr
static mrb_int
mrb_memsearch(const void *x0, mrb_int m, const void *y0, mrb_int n)
{
const unsigned char *x = (const unsigned char *)x0, *y = (const unsigned char *)y0;
const unsigned char *x = (const unsigned char*)x0, *y = (const unsigned char*)y0;
if (m > n) return -1;
else if (m == n) {
@@ -496,14 +496,14 @@ mrb_memsearch(const void *x0, mrb_int m, const void *y0, mrb_int n)
return 0;
}
else if (m == 1) {
const unsigned char *ys = (const unsigned char *)memchr(y, *x, n);
const unsigned char *ys = (const unsigned char*)memchr(y, *x, n);
if (ys)
return (mrb_int)(ys - y);
else
return -1;
}
return mrb_memsearch_qs((const unsigned char *)x0, m, (const unsigned char *)y0, n);
return mrb_memsearch_qs((const unsigned char*)x0, m, (const unsigned char*)y0, n);
}
static void
@@ -523,7 +523,7 @@ str_share(mrb_state *mrb, struct RString *orig, struct RString *s)
}
else {
if (orig->as.heap.aux.capa > orig->as.heap.len) {
orig->as.heap.ptr = (char *)mrb_realloc(mrb, orig->as.heap.ptr, len+1);
orig->as.heap.ptr = (char*)mrb_realloc(mrb, orig->as.heap.ptr, len+1);
orig->as.heap.aux.capa = (mrb_ssize)len;
}
str_init_shared(mrb, orig, s, NULL);
@@ -2781,7 +2781,7 @@ mrb_str_bytes(mrb_state *mrb, mrb_value str)
{
struct RString *s = mrb_str_ptr(str);
mrb_value a = mrb_ary_new_capa(mrb, RSTR_LEN(s));
unsigned char *p = (unsigned char *)(RSTR_PTR(s)), *pend = p + RSTR_LEN(s);
unsigned char *p = (unsigned char*)(RSTR_PTR(s)), *pend = p + RSTR_LEN(s);
while (p < pend) {
mrb_ary_push(mrb, a, mrb_fixnum_value(p[0]));
src/symbol.c
+1 -1
View File
@@ -214,7 +214,7 @@ sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit)
else {
uint32_t ulen = (uint32_t)len;
size_t ilen = mrb_packed_int_len(ulen);
char *p = (char *)mrb_malloc(mrb, len+ilen+1);
char *p = (char*)mrb_malloc(mrb, len+ilen+1);
mrb_packed_int_encode(ulen, (uint8_t*)p, (uint8_t*)p+ilen);
memcpy(p+ilen, name, len);
p[ilen+len] = 0;
src/variable.c
+2 -2
View File
@@ -345,7 +345,7 @@ assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
o = mrb_obj_iv_get(mrb, c, id_outer);
if (mrb_nil_p(o)) {
if ((struct RClass *)obj == mrb->object_class) {
if ((struct RClass*)obj == mrb->object_class) {
mrb_obj_iv_set_force(mrb, c, id_classname, mrb_symbol_value(sym));
}
else {
@@ -625,7 +625,7 @@ mrb_mod_cv_get(mrb_state *mrb, struct RClass *c, mrb_sym sym)
if (cls && cls->tt == MRB_TT_SCLASS) {
mrb_value klass;
klass = mrb_obj_iv_get(mrb, (struct RObject *)cls, MRB_SYM(__attached__));
klass = mrb_obj_iv_get(mrb, (struct RObject*)cls, MRB_SYM(__attached__));
c = mrb_class_ptr(klass);
if (c->tt == MRB_TT_CLASS || c->tt == MRB_TT_MODULE) {
given = FALSE;
src/vm.c
+6 -6
View File
@@ -106,11 +106,11 @@ stack_init(mrb_state *mrb)
struct mrb_context *c = mrb->c;
/* mrb_assert(mrb->stack == NULL); */
c->stbase = (mrb_value *)mrb_calloc(mrb, STACK_INIT_SIZE, sizeof(mrb_value));
c->stbase = (mrb_value*)mrb_calloc(mrb, STACK_INIT_SIZE, sizeof(mrb_value));
c->stend = c->stbase + STACK_INIT_SIZE;
/* mrb_assert(ci == NULL); */
c->cibase = (mrb_callinfo *)mrb_calloc(mrb, CALLINFO_INIT_SIZE, sizeof(mrb_callinfo));
c->cibase = (mrb_callinfo*)mrb_calloc(mrb, CALLINFO_INIT_SIZE, sizeof(mrb_callinfo));
c->ciend = c->cibase + CALLINFO_INIT_SIZE;
c->ci = c->cibase;
c->ci->u.target_class = mrb->object_class;
@@ -174,7 +174,7 @@ stack_extend_alloc(mrb_state *mrb, mrb_int room)
size += room;
#endif
newstack = (mrb_value *)mrb_realloc(mrb, mrb->c->stbase, sizeof(mrb_value) * size);
newstack = (mrb_value*)mrb_realloc(mrb, mrb->c->stbase, sizeof(mrb_value) * size);
stack_clear(&(newstack[oldsize]), size - oldsize);
envadjust(mrb, oldbase, newstack, oldsize);
mrb->c->stbase = newstack;
@@ -351,7 +351,7 @@ cipush(mrb_state *mrb, mrb_int push_stacks, uint8_t cci, struct RClass *target_c
if (size > MRB_CALL_LEVEL_MAX) {
mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
}
c->cibase = (mrb_callinfo *)mrb_realloc(mrb, c->cibase, sizeof(mrb_callinfo)*size*2);
c->cibase = (mrb_callinfo*)mrb_realloc(mrb, c->cibase, sizeof(mrb_callinfo)*size*2);
c->ci = c->cibase + size;
c->ciend = c->cibase + size * 2;
}
@@ -384,8 +384,8 @@ mrb_env_unshare(mrb_state *mrb, struct REnv *e, mrb_bool noraise)
}
size_t live = mrb->gc.live;
mrb_value *p = (mrb_value *)mrb_malloc_simple(mrb, sizeof(mrb_value)*len);
if (live != mrb->gc.live && mrb_object_dead_p(mrb, (struct RBasic *)e)) {
mrb_value *p = (mrb_value*)mrb_malloc_simple(mrb, sizeof(mrb_value)*len);
if (live != mrb->gc.live && mrb_object_dead_p(mrb, (struct RBasic*)e)) {
// The e object is now subject to GC inside mrb_malloc_simple().
// Moreover, if NULL is returned due to mrb_malloc_simple() failure, simply ignore it.
mrb_free(mrb, p);