mirrors/janet
1
0
Fork 0
mirror of https://github.com/janet-lang/janet synced 2025-08-08 23:13:48 +00:00
Code Issues 1 Releases Wiki Activity

fix C source format

Browse Source
This commit is contained in:
J.-F. Cap 2019-02-23 17:13:43 +01:00
parent 0cc6c6ff33
commit 2becebce92
5 changed files with 238 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/core/abstract.c
View File

@ -28,7 +28,7 @@
/* Create new userdata */ /* Create new userdata */
void *janet_abstract(const JanetAbstractType *atype, size_t size) { void *janet_abstract(const JanetAbstractType *atype, size_t size) {
JanetAbstractHead *header = janet_gcalloc(JANET_MEMORY_ABSTRACT, JanetAbstractHead *header = janet_gcalloc(JANET_MEMORY_ABSTRACT,
sizeof(JanetAbstractHead) + size); sizeof(JanetAbstractHead) + size);
header->size = size; header->size = size;
header->type = atype; header->type = atype;
return (void *) & (header->data); return (void *) & (header->data);

124
src/core/marsh.c
View File

@ -289,24 +289,24 @@ static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags) {
} }
void janet_marshal_int(JanetMarshalContext *ctx,int32_t value) { void janet_marshal_int(JanetMarshalContext *ctx, int32_t value) {
MarshalState *st =(MarshalState *)(ctx->m_state); MarshalState *st = (MarshalState *)(ctx->m_state);
pushint(st,value); pushint(st, value);
}; };
void janet_marshal_byte(JanetMarshalContext *ctx,uint8_t value) { void janet_marshal_byte(JanetMarshalContext *ctx, uint8_t value) {
MarshalState *st =(MarshalState *)(ctx->m_state); MarshalState *st = (MarshalState *)(ctx->m_state);
pushbyte(st,value); pushbyte(st, value);
}; };
void janet_marshal_bytes(JanetMarshalContext *ctx,const uint8_t *bytes, int32_t len) { void janet_marshal_bytes(JanetMarshalContext *ctx, const uint8_t *bytes, int32_t len) {
MarshalState *st =(MarshalState *)(ctx->m_state); MarshalState *st = (MarshalState *)(ctx->m_state);
pushbytes(st,bytes,len); pushbytes(st, bytes, len);
} }
void janet_marshal_janet(JanetMarshalContext *ctx,Janet x) { void janet_marshal_janet(JanetMarshalContext *ctx, Janet x) {
MarshalState *st =(MarshalState *)(ctx->m_state); MarshalState *st = (MarshalState *)(ctx->m_state);
marshal_one(st,x,ctx->flags + 1); marshal_one(st, x, ctx->flags + 1);
} }
#define MARK_SEEN() \ #define MARK_SEEN() \
@ -314,18 +314,18 @@ void janet_marshal_janet(JanetMarshalContext *ctx,Janet x) {
static int marshal_one_abstract(MarshalState *st, Janet x, int flags) { static int marshal_one_abstract(MarshalState *st, Janet x, int flags) {
const JanetAbstractType *at = janet_abstract_type(janet_unwrap_abstract(x)); const JanetAbstractType *at = janet_abstract_type(janet_unwrap_abstract(x));
const JanetAbstractTypeInfo *info = janet_get_abstract_type_info_byname(at->name); const JanetAbstractTypeInfo *info = janet_get_abstract_type_info_byname(at->name);
if (! info) return 1 ; /* unregistered type skip marshalling*/ if (! info) return 1 ; /* unregistered type skip marshalling*/
if (info->marshal) { if (info->marshal) {
MARK_SEEN(); MARK_SEEN();
JanetMarshalContext context={st,NULL,flags,NULL}; JanetMarshalContext context = {st, NULL, flags, NULL};
pushbyte(st, LB_ABSTRACT); pushbyte(st, LB_ABSTRACT);
pushint(st,info->tag); pushint(st, info->tag);
info->marshal(janet_unwrap_abstract(x),&context); info->marshal(janet_unwrap_abstract(x), &context);
return 1; return 1;
} }
return 0; return 0;
} }
@ -488,12 +488,12 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
} }
goto done; goto done;
case JANET_ABSTRACT: { case JANET_ABSTRACT: {
if (marshal_one_abstract(st,x,flags)) { if (marshal_one_abstract(st, x, flags)) {
goto done; goto done;
} else { } else {
goto noregval; goto noregval;
} }
} }
case JANET_CFUNCTION: case JANET_CFUNCTION:
goto noregval; goto noregval;
case JANET_FUNCTION: { case JANET_FUNCTION: {
@ -957,50 +957,50 @@ error:
} }
void janet_unmarshal_int(JanetMarshalContext *ctx,int32_t* i) { void janet_unmarshal_int(JanetMarshalContext *ctx, int32_t *i) {
UnmarshalState *st =(UnmarshalState *)(ctx->u_state); UnmarshalState *st = (UnmarshalState *)(ctx->u_state);
*i=readint(st,&(ctx->data)); *i = readint(st, &(ctx->data));
}; };
void janet_unmarshal_uint(JanetMarshalContext *ctx,uint32_t* i) { void janet_unmarshal_uint(JanetMarshalContext *ctx, uint32_t *i) {
UnmarshalState *st =(UnmarshalState *)(ctx->u_state); UnmarshalState *st = (UnmarshalState *)(ctx->u_state);
*i=(uint32_t)readint(st,&(ctx->data)); *i = (uint32_t)readint(st, &(ctx->data));
}; };
void janet_unmarshal_size(JanetMarshalContext *ctx,size_t* i) { void janet_unmarshal_size(JanetMarshalContext *ctx, size_t *i) {
UnmarshalState *st =(UnmarshalState *)(ctx->u_state); UnmarshalState *st = (UnmarshalState *)(ctx->u_state);
*i=(size_t)readint(st,&(ctx->data)); *i = (size_t)readint(st, &(ctx->data));
}; };
void janet_unmarshal_byte(JanetMarshalContext *ctx,uint8_t* b) { void janet_unmarshal_byte(JanetMarshalContext *ctx, uint8_t *b) {
*b=*(ctx->data++); *b = *(ctx->data++);
}; };
void janet_unmarshal_bytes(JanetMarshalContext *ctx,uint8_t *dest, int32_t len) { void janet_unmarshal_bytes(JanetMarshalContext *ctx, uint8_t *dest, int32_t len) {
memcpy(dest,ctx->data,len); memcpy(dest, ctx->data, len);
ctx->data+=len; ctx->data += len;
} }
void janet_unmarshal_janet(JanetMarshalContext *ctx,Janet *out) { void janet_unmarshal_janet(JanetMarshalContext *ctx, Janet *out) {
UnmarshalState *st =(UnmarshalState *)(ctx->u_state); UnmarshalState *st = (UnmarshalState *)(ctx->u_state);
ctx->data=unmarshal_one(st,ctx->data,out,ctx->flags); ctx->data = unmarshal_one(st, ctx->data, out, ctx->flags);
} }
static const uint8_t *unmarshal_one_abstract(UnmarshalState *st, const uint8_t *data, Janet *out, int flags) { static const uint8_t *unmarshal_one_abstract(UnmarshalState *st, const uint8_t *data, Janet *out, int flags) {
uint32_t tag=readint(st,&data); uint32_t tag = readint(st, &data);
const JanetAbstractTypeInfo *info = janet_get_abstract_type_info(tag); const JanetAbstractTypeInfo *info = janet_get_abstract_type_info(tag);
if (info==NULL) goto error; if (info == NULL) goto error;
if (info->unmarshal) { if (info->unmarshal) {
void *p = janet_abstract(info->at,info->size); void *p = janet_abstract(info->at, info->size);
JanetMarshalContext context={NULL,st,flags,data}; JanetMarshalContext context = {NULL, st, flags, data};
info->unmarshal(p,&context); info->unmarshal(p, &context);
*out=janet_wrap_abstract(p); *out = janet_wrap_abstract(p);
return data; return data;
} }
return 0; return 0;
error: error:
longjmp(st->err, UMR_INVALID_ABSTRACT); longjmp(st->err, UMR_INVALID_ABSTRACT);
return NULL; return NULL;
} }
@ -1123,9 +1123,9 @@ static const uint8_t *unmarshal_one(
return data; return data;
} }
case LB_ABSTRACT: { case LB_ABSTRACT: {
data++; data++;
return unmarshal_one_abstract(st,data,out,flags); return unmarshal_one_abstract(st, data, out, flags);
} }
case LB_REFERENCE: case LB_REFERENCE:
case LB_ARRAY: case LB_ARRAY:
case LB_TUPLE: case LB_TUPLE:

220
src/core/typedarray.c
View File

@ -120,31 +120,31 @@ static int ta_buffer_gc(void *p, size_t s) {
} }
static void ta_buffer_marshal(void *p, JanetMarshalContext *ctx) { static void ta_buffer_marshal(void *p, JanetMarshalContext *ctx) {
TA_Buffer *buf = (TA_Buffer *)p; TA_Buffer *buf = (TA_Buffer *)p;
janet_marshal_int(ctx,buf->size); janet_marshal_int(ctx, buf->size);
janet_marshal_int(ctx,buf->flags); janet_marshal_int(ctx, buf->flags);
janet_marshal_bytes(ctx,buf->data,buf->size); janet_marshal_bytes(ctx, buf->data, buf->size);
} }
static void ta_buffer_unmarshal(void *p, JanetMarshalContext *ctx) { static void ta_buffer_unmarshal(void *p, JanetMarshalContext *ctx) {
TA_Buffer *buf = (TA_Buffer *)p; TA_Buffer *buf = (TA_Buffer *)p;
uint32_t size; uint32_t size;
janet_unmarshal_uint(ctx,&size); janet_unmarshal_uint(ctx, &size);
ta_buffer_init(buf,size); // warning if indianess <> platform ?? ta_buffer_init(buf, size); // warning if indianess <> platform ??
janet_unmarshal_uint(ctx,&(buf->flags)); janet_unmarshal_uint(ctx, &(buf->flags));
janet_unmarshal_bytes(ctx,buf->data,buf->size); janet_unmarshal_bytes(ctx, buf->data, buf->size);
} }
static const JanetAbstractType ta_buffer_type={"ta/buffer", ta_buffer_gc, NULL, NULL, NULL}; static const JanetAbstractType ta_buffer_type = {"ta/buffer", ta_buffer_gc, NULL, NULL, NULL};
static const JanetAbstractTypeInfo ta_buffer_typeinfo={ static const JanetAbstractTypeInfo ta_buffer_typeinfo = {
&ta_buffer_type, &ta_buffer_type,
sizeof(TA_Buffer), sizeof(TA_Buffer),
1000, 1000,
0, 0,
ta_buffer_marshal, ta_buffer_marshal,
ta_buffer_unmarshal, ta_buffer_unmarshal,
}; };
@ -165,27 +165,27 @@ static int ta_mark(void *p, size_t s) {
} }
static void ta_view_marshal(void *p, JanetMarshalContext *ctx) { static void ta_view_marshal(void *p, JanetMarshalContext *ctx) {
TA_View *view = (TA_View *)p; TA_View *view = (TA_View *)p;
size_t offset = (view->buffer->data - (uint8_t *)(view->data)); size_t offset = (view->buffer->data - (uint8_t *)(view->data));
janet_marshal_int(ctx,view->size); janet_marshal_int(ctx, view->size);
janet_marshal_int(ctx,view->stride); janet_marshal_int(ctx, view->stride);
janet_marshal_int(ctx,view->type); janet_marshal_int(ctx, view->type);
janet_marshal_int(ctx,offset); janet_marshal_int(ctx, offset);
janet_marshal_janet(ctx,janet_wrap_abstract(view->buffer)); janet_marshal_janet(ctx, janet_wrap_abstract(view->buffer));
} }
static void ta_view_unmarshal(void *p, JanetMarshalContext *ctx) { static void ta_view_unmarshal(void *p, JanetMarshalContext *ctx) {
TA_View *view = (TA_View *)p; TA_View *view = (TA_View *)p;
size_t offset; size_t offset;
Janet buffer; Janet buffer;
janet_unmarshal_size(ctx,&(view->size)); janet_unmarshal_size(ctx, &(view->size));
janet_unmarshal_size(ctx,&(view->stride)); janet_unmarshal_size(ctx, &(view->stride));
janet_unmarshal_uint(ctx,&(view->type)); janet_unmarshal_uint(ctx, &(view->type));
janet_unmarshal_size(ctx,&offset); janet_unmarshal_size(ctx, &offset);
janet_unmarshal_janet(ctx,&buffer); janet_unmarshal_janet(ctx, &buffer);
view->buffer=(TA_Buffer *)janet_unwrap_abstract(buffer); view->buffer = (TA_Buffer *)janet_unwrap_abstract(buffer);
view->data=view->buffer->data+offset; view->data = view->buffer->data + offset;
} }
@ -282,16 +282,16 @@ BUILD_TYPE(float64)
#define VIEW_ABSTRACT_INFO_INIT(type,salt) {&ta_view_##type##_t,sizeof(TA_View),salt,0,ta_view_marshal,ta_view_unmarshal} #define VIEW_ABSTRACT_INFO_INIT(type,salt) {&ta_view_##type##_t,sizeof(TA_View),salt,0,ta_view_marshal,ta_view_unmarshal}
static const JanetAbstractTypeInfo ta_array_types[] = { static const JanetAbstractTypeInfo ta_array_types[] = {
VIEW_ABSTRACT_INFO_INIT(uint8,1001), VIEW_ABSTRACT_INFO_INIT(uint8, 1001),
VIEW_ABSTRACT_INFO_INIT(int8,1002), VIEW_ABSTRACT_INFO_INIT(int8, 1002),
VIEW_ABSTRACT_INFO_INIT(uint16,1003), VIEW_ABSTRACT_INFO_INIT(uint16, 1003),
VIEW_ABSTRACT_INFO_INIT(int16,1004), VIEW_ABSTRACT_INFO_INIT(int16, 1004),
VIEW_ABSTRACT_INFO_INIT(uint32,1005), VIEW_ABSTRACT_INFO_INIT(uint32, 1005),
VIEW_ABSTRACT_INFO_INIT(int32,1006), VIEW_ABSTRACT_INFO_INIT(int32, 1006),
VIEW_ABSTRACT_INFO_INIT(uint64,1007), VIEW_ABSTRACT_INFO_INIT(uint64, 1007),
VIEW_ABSTRACT_INFO_INIT(int64,1008), VIEW_ABSTRACT_INFO_INIT(int64, 1008),
VIEW_ABSTRACT_INFO_INIT(float32,1009), VIEW_ABSTRACT_INFO_INIT(float32, 1009),
VIEW_ABSTRACT_INFO_INIT(float64,1010), VIEW_ABSTRACT_INFO_INIT(float64, 1010),
}; };
static int is_ta_type(Janet x) { static int is_ta_type(Janet x) {
@ -328,7 +328,7 @@ static Janet cfun_typed_array_new(int32_t argc, Janet *argv) {
stride *= view->stride; stride *= view->stride;
buffer = view->buffer; buffer = view->buffer;
} else { } else {
buffer = (TA_Buffer *)janet_getabstract(argv, 4,&ta_buffer_type); buffer = (TA_Buffer *)janet_getabstract(argv, 4, &ta_buffer_type);
} }
} }
TA_View *view = janet_abstract(ta_array_types[type].at, sizeof(TA_View)); TA_View *view = janet_abstract(ta_array_types[type].at, sizeof(TA_View));
@ -367,7 +367,7 @@ static Janet cfun_typed_array_size(int32_t argc, Janet *argv) {
TA_View *view = (TA_View *)janet_unwrap_abstract(argv[0]); TA_View *view = (TA_View *)janet_unwrap_abstract(argv[0]);
return janet_wrap_number(view->size); return janet_wrap_number(view->size);
} }
TA_Buffer *buf = (TA_Buffer *)janet_getabstract(argv, 0,&ta_buffer_type); TA_Buffer *buf = (TA_Buffer *)janet_getabstract(argv, 0, &ta_buffer_type);
return janet_wrap_number(buf->size); return janet_wrap_number(buf->size);
} }
@ -389,23 +389,23 @@ static Janet cfun_typed_array_properties(int32_t argc, Janet *argv) {
/* TODO for test it's not the good place for this function */ /* TODO for test it's not the good place for this function */
static Janet cfun_abstract_properties(int32_t argc, Janet *argv) { static Janet cfun_abstract_properties(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
JanetAbstractTypeInfo * info; JanetAbstractTypeInfo *info;
if (janet_checktype(argv[0],JANET_KEYWORD)) { if (janet_checktype(argv[0], JANET_KEYWORD)) {
const uint8_t *keyw = janet_unwrap_keyword(argv[0]); const uint8_t *keyw = janet_unwrap_keyword(argv[0]);
info=janet_get_abstract_type_info_byname((const char*)keyw); info = janet_get_abstract_type_info_byname((const char *)keyw);
} else { } else {
uint32_t tag = (uint32_t)janet_getinteger(argv, 0); uint32_t tag = (uint32_t)janet_getinteger(argv, 0);
info=janet_get_abstract_type_info(tag); info = janet_get_abstract_type_info(tag);
} }
if (info==NULL) { if (info == NULL) {
return janet_wrap_nil(); return janet_wrap_nil();
} }
JanetKV *props = janet_struct_begin(5); JanetKV *props = janet_struct_begin(5);
janet_struct_put(props, janet_ckeywordv("tag"), janet_wrap_number(info->tag)); janet_struct_put(props, janet_ckeywordv("tag"), janet_wrap_number(info->tag));
janet_struct_put(props, janet_ckeywordv("salt"), janet_wrap_number(info->salt)); janet_struct_put(props, janet_ckeywordv("salt"), janet_wrap_number(info->salt));
janet_struct_put(props, janet_ckeywordv("name"), janet_ckeywordv(info->at->name)); janet_struct_put(props, janet_ckeywordv("name"), janet_ckeywordv(info->at->name));
janet_struct_put(props, janet_ckeywordv("size"), janet_wrap_number(info->size)); janet_struct_put(props, janet_ckeywordv("size"), janet_wrap_number(info->size));
janet_struct_put(props, janet_ckeywordv("marshal"), janet_wrap_boolean((info->marshal !=NULL) && (info->unmarshal!=NULL))); janet_struct_put(props, janet_ckeywordv("marshal"), janet_wrap_boolean((info->marshal != NULL) && (info->unmarshal != NULL)));
return janet_wrap_struct(janet_struct_end(props)); return janet_wrap_struct(janet_struct_end(props));
} }
@ -413,30 +413,29 @@ static Janet cfun_abstract_properties(int32_t argc, Janet *argv) {
static Janet cfun_typed_array_copy_bytes(int32_t argc, Janet *argv) { static Janet cfun_typed_array_copy_bytes(int32_t argc, Janet *argv) {
janet_arity(argc, 4, 5); janet_arity(argc, 4, 5);
if (is_ta_type(argv[0]) && is_ta_type(argv[2])) { if (is_ta_type(argv[0]) && is_ta_type(argv[2])) {
TA_View *src = (TA_View *)janet_unwrap_abstract(argv[0]); TA_View *src = (TA_View *)janet_unwrap_abstract(argv[0]);
size_t index_src=(size_t)janet_getinteger(argv, 1); size_t index_src = (size_t)janet_getinteger(argv, 1);
TA_View *dst = (TA_View *)janet_unwrap_abstract(argv[2]); TA_View *dst = (TA_View *)janet_unwrap_abstract(argv[2]);
size_t index_dst=(size_t)janet_getinteger(argv, 3); size_t index_dst = (size_t)janet_getinteger(argv, 3);
size_t count=(argc == 5)? (size_t)janet_getinteger(argv, 4) : 1; size_t count = (argc == 5) ? (size_t)janet_getinteger(argv, 4) : 1;
size_t src_atom_size=ta_type_sizes[src->type]; size_t src_atom_size = ta_type_sizes[src->type];
size_t dst_atom_size=ta_type_sizes[dst->type]; size_t dst_atom_size = ta_type_sizes[dst->type];
size_t step_src=src->stride*src_atom_size; size_t step_src = src->stride * src_atom_size;
size_t step_dst=dst->stride*dst_atom_size; size_t step_dst = dst->stride * dst_atom_size;
size_t pos_src=((uint8_t *)(src->data) - src->buffer->data)+(index_src*step_src); size_t pos_src = ((uint8_t *)(src->data) - src->buffer->data) + (index_src * step_src);
size_t pos_dst=((uint8_t *)(dst->data) - dst->buffer->data)+(index_dst*step_dst); size_t pos_dst = ((uint8_t *)(dst->data) - dst->buffer->data) + (index_dst * step_dst);
uint8_t * ps=src->buffer->data+pos_src,* pd=dst->buffer->data+pos_dst; uint8_t *ps = src->buffer->data + pos_src, * pd = dst->buffer->data + pos_dst;
if ((pos_dst+(count-1)*step_dst+src_atom_size <= dst->buffer->size) && if ((pos_dst + (count - 1)*step_dst + src_atom_size <= dst->buffer->size) &&
(pos_src+(count-1)*step_src+src_atom_size <= src->buffer->size)) { (pos_src + (count - 1)*step_src + src_atom_size <= src->buffer->size)) {
for (size_t i=0;i<count;i++) { for (size_t i = 0; i < count; i++) {
memmove(pd,ps,src_atom_size); memmove(pd, ps, src_atom_size);
pd+=step_dst; pd += step_dst;
ps+=step_src; ps += step_src;
} }
} } else
else janet_panic("typed array copy out of bound");
janet_panic("typed array copy out of bound");
} else { } else {
janet_panic("expected typed array"); janet_panic("expected typed array");
} }
return janet_wrap_nil(); return janet_wrap_nil();
} }
@ -444,33 +443,32 @@ static Janet cfun_typed_array_copy_bytes(int32_t argc, Janet *argv) {
static Janet cfun_typed_array_swap_bytes(int32_t argc, Janet *argv) { static Janet cfun_typed_array_swap_bytes(int32_t argc, Janet *argv) {
janet_arity(argc, 4, 5); janet_arity(argc, 4, 5);
if (is_ta_type(argv[0]) && is_ta_type(argv[2])) { if (is_ta_type(argv[0]) && is_ta_type(argv[2])) {
TA_View *src = (TA_View *)janet_unwrap_abstract(argv[0]); TA_View *src = (TA_View *)janet_unwrap_abstract(argv[0]);
size_t index_src=(size_t)janet_getinteger(argv, 1); size_t index_src = (size_t)janet_getinteger(argv, 1);
TA_View *dst = (TA_View *)janet_unwrap_abstract(argv[2]); TA_View *dst = (TA_View *)janet_unwrap_abstract(argv[2]);
size_t index_dst=(size_t)janet_getinteger(argv, 3); size_t index_dst = (size_t)janet_getinteger(argv, 3);
size_t count=(argc == 5)? (size_t)janet_getinteger(argv, 4) : 1; size_t count = (argc == 5) ? (size_t)janet_getinteger(argv, 4) : 1;
size_t src_atom_size=ta_type_sizes[src->type]; size_t src_atom_size = ta_type_sizes[src->type];
size_t dst_atom_size=ta_type_sizes[dst->type]; size_t dst_atom_size = ta_type_sizes[dst->type];
size_t step_src=src->stride*src_atom_size; size_t step_src = src->stride * src_atom_size;
size_t step_dst=dst->stride*dst_atom_size; size_t step_dst = dst->stride * dst_atom_size;
size_t pos_src=((uint8_t *)(src->data) - src->buffer->data)+(index_src*step_src); size_t pos_src = ((uint8_t *)(src->data) - src->buffer->data) + (index_src * step_src);
size_t pos_dst=((uint8_t *)(dst->data) - dst->buffer->data)+(index_dst*step_dst); size_t pos_dst = ((uint8_t *)(dst->data) - dst->buffer->data) + (index_dst * step_dst);
uint8_t * ps=src->buffer->data+pos_src,* pd=dst->buffer->data+pos_dst; uint8_t *ps = src->buffer->data + pos_src, * pd = dst->buffer->data + pos_dst;
uint8_t temp[TA_ATOM_MAXSIZE]; uint8_t temp[TA_ATOM_MAXSIZE];
if ((pos_dst+(count-1)*step_dst+src_atom_size <= dst->buffer->size) && if ((pos_dst + (count - 1)*step_dst + src_atom_size <= dst->buffer->size) &&
(pos_src+(count-1)*step_src+src_atom_size <= src->buffer->size)) { (pos_src + (count - 1)*step_src + src_atom_size <= src->buffer->size)) {
for (size_t i=0;i<count;i++) { for (size_t i = 0; i < count; i++) {
memcpy(temp,ps,src_atom_size); memcpy(temp, ps, src_atom_size);
memcpy(ps,pd,src_atom_size); memcpy(ps, pd, src_atom_size);
memcpy(pd,temp,src_atom_size); memcpy(pd, temp, src_atom_size);
pd+=step_dst; pd += step_dst;
ps+=step_src; ps += step_src;
} }
} } else
else janet_panic("typed array swap out of bound");
janet_panic("typed array swap out of bound");
} else { } else {
janet_panic("expected typed array"); janet_panic("expected typed array");
} }
return janet_wrap_nil(); return janet_wrap_nil();
} }
@ -503,16 +501,16 @@ static const JanetReg ta_cfuns[] = {
JDOC("(tarray/copy-bytes src sindex dst dindex [count=1])\n\n" JDOC("(tarray/copy-bytes src sindex dst dindex [count=1])\n\n"
"copy count elements of src array from index sindex \n" "copy count elements of src array from index sindex \n"
"to dst array at position dindex \n" "to dst array at position dindex \n"
"memory can overlap" "memory can overlap"
) )
}, },
{ {
"tarray/swap-bytes", cfun_typed_array_swap_bytes, "tarray/swap-bytes", cfun_typed_array_swap_bytes,
JDOC("(tarray/swap-bytes src sindex dst dindex [count=1])\n\n" JDOC("(tarray/swap-bytes src sindex dst dindex [count=1])\n\n"
"swap count elements between src array from index sindex \n" "swap count elements between src array from index sindex \n"
"and dst array at position dindex \n" "and dst array at position dindex \n"
"memory can overlap" "memory can overlap"
) )
}, },
{ {
"abstract/properties", cfun_abstract_properties, "abstract/properties", cfun_abstract_properties,
@ -530,7 +528,7 @@ static const JanetReg ta_cfuns[] = {
void janet_lib_typed_array(JanetTable *env) { void janet_lib_typed_array(JanetTable *env) {
janet_core_cfuns(env, NULL, ta_cfuns); janet_core_cfuns(env, NULL, ta_cfuns);
janet_register_abstract_type(&ta_buffer_typeinfo); janet_register_abstract_type(&ta_buffer_typeinfo);
for (size_t i=0;i<TA_COUNT_TYPES;i++) { for (size_t i = 0; i < TA_COUNT_TYPES; i++) {
janet_register_abstract_type(ta_array_types + i); janet_register_abstract_type(ta_array_types + i);
} }
} }

76
src/core/util.c
View File

@ -288,51 +288,51 @@ void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns)
static const JanetAbstractType type_info = {"core/type_info", NULL, NULL, NULL, NULL}; static const JanetAbstractType type_info = {"core/type_info", NULL, NULL, NULL, NULL};
static uint32_t janet_abstract_type_gentag(const char * name,uint32_t salt) { static uint32_t janet_abstract_type_gentag(const char *name, uint32_t salt) {
/* something smarter should propably done here ? */ /* something smarter should propably done here ? */
int32_t len = strlen(name); int32_t len = strlen(name);
const char *end = name + len; const char *end = name + len;
uint32_t hash = 5381+salt; uint32_t hash = 5381 + salt;
while (name < end) while (name < end)
hash = (hash << 5) + hash + *name++; hash = (hash << 5) + hash + *name++;
return (int32_t) hash; return (int32_t) hash;
} }
void janet_register_abstract_type(const JanetAbstractTypeInfo * info) { void janet_register_abstract_type(const JanetAbstractTypeInfo *info) {
JanetAbstractTypeInfo * abstract =(JanetAbstractTypeInfo *)janet_abstract(&type_info,sizeof(JanetAbstractTypeInfo)); JanetAbstractTypeInfo *abstract = (JanetAbstractTypeInfo *)janet_abstract(&type_info, sizeof(JanetAbstractTypeInfo));
memcpy(abstract,info,sizeof(JanetAbstractTypeInfo)); memcpy(abstract, info, sizeof(JanetAbstractTypeInfo));
abstract->tag=janet_abstract_type_gentag(info->at->name,info->salt); abstract->tag = janet_abstract_type_gentag(info->at->name, info->salt);
if (!(janet_checktype(janet_table_get(janet_vm_registry,janet_wrap_number(abstract->tag)),JANET_NIL)) || if (!(janet_checktype(janet_table_get(janet_vm_registry, janet_wrap_number(abstract->tag)), JANET_NIL)) ||
!(janet_checktype(janet_table_get(janet_vm_registry,janet_ckeywordv(abstract->at->name)),JANET_NIL))) { !(janet_checktype(janet_table_get(janet_vm_registry, janet_ckeywordv(abstract->at->name)), JANET_NIL))) {
janet_panic("Register abstract type fail, a type with same name or tag exist"); janet_panic("Register abstract type fail, a type with same name or tag exist");
} }
janet_table_put(janet_vm_registry,janet_wrap_number(abstract->tag), janet_wrap_abstract(abstract)); janet_table_put(janet_vm_registry, janet_wrap_number(abstract->tag), janet_wrap_abstract(abstract));
janet_table_put(janet_vm_registry,janet_ckeywordv(abstract->at->name), janet_wrap_abstract(abstract)); janet_table_put(janet_vm_registry, janet_ckeywordv(abstract->at->name), janet_wrap_abstract(abstract));
} }
JanetAbstractTypeInfo * janet_get_abstract_type_info(uint32_t tag) { JanetAbstractTypeInfo *janet_get_abstract_type_info(uint32_t tag) {
Janet info=janet_table_get(janet_vm_registry,janet_wrap_number(tag)); Janet info = janet_table_get(janet_vm_registry, janet_wrap_number(tag));
if (janet_checktype(info, JANET_NIL)) { if (janet_checktype(info, JANET_NIL)) {
return NULL; return NULL;
} }
if (!janet_checktype(info, JANET_ABSTRACT) || (janet_abstract_type(janet_unwrap_abstract(info)) != &type_info)) { if (!janet_checktype(info, JANET_ABSTRACT) || (janet_abstract_type(janet_unwrap_abstract(info)) != &type_info)) {
janet_panic("expected type_info"); janet_panic("expected type_info");
} }
JanetAbstractTypeInfo * type_info = (JanetAbstractTypeInfo *)janet_unwrap_abstract(info); JanetAbstractTypeInfo *type_info = (JanetAbstractTypeInfo *)janet_unwrap_abstract(info);
return type_info; return type_info;
} }
JanetAbstractTypeInfo * janet_get_abstract_type_info_byname(const char * name) { JanetAbstractTypeInfo *janet_get_abstract_type_info_byname(const char *name) {
Janet info=janet_table_get(janet_vm_registry,janet_ckeywordv(name)); Janet info = janet_table_get(janet_vm_registry, janet_ckeywordv(name));
if (janet_checktype(info, JANET_NIL)) { if (janet_checktype(info, JANET_NIL)) {
return NULL; return NULL;
} }
if (!janet_checktype(info, JANET_ABSTRACT) || (janet_abstract_type(janet_unwrap_abstract(info)) != &type_info)) { if (!janet_checktype(info, JANET_ABSTRACT) || (janet_abstract_type(janet_unwrap_abstract(info)) != &type_info)) {
janet_panic("expected type_info"); janet_panic("expected type_info");
} }
JanetAbstractTypeInfo * type_info = (JanetAbstractTypeInfo *)janet_unwrap_abstract(info); JanetAbstractTypeInfo *type_info = (JanetAbstractTypeInfo *)janet_unwrap_abstract(info);
return type_info; return type_info;
} }

46
src/include/janet.h
View File

@ -1244,37 +1244,37 @@ JANET_API int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t lengt
JANET_API int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which); JANET_API int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which);
typedef struct { typedef struct {
void * m_state; /* void* to not expose MarshalState ?*/ void *m_state; /* void* to not expose MarshalState ?*/
void * u_state; void *u_state;
int flags; int flags;
const uint8_t * data; const uint8_t *data;
} JanetMarshalContext; } JanetMarshalContext;
JANET_API void janet_marshal_int(JanetMarshalContext *ctx,int32_t value); JANET_API void janet_marshal_int(JanetMarshalContext *ctx, int32_t value);
JANET_API void janet_marshal_byte(JanetMarshalContext *ctx,uint8_t value); JANET_API void janet_marshal_byte(JanetMarshalContext *ctx, uint8_t value);
JANET_API void janet_marshal_bytes(JanetMarshalContext *ctx,const uint8_t *bytes, int32_t len); JANET_API void janet_marshal_bytes(JanetMarshalContext *ctx, const uint8_t *bytes, int32_t len);
JANET_API void janet_marshal_janet(JanetMarshalContext *ctx,Janet x); JANET_API void janet_marshal_janet(JanetMarshalContext *ctx, Janet x);
JANET_API void janet_unmarshal_int(JanetMarshalContext *ctx,int32_t* i); JANET_API void janet_unmarshal_int(JanetMarshalContext *ctx, int32_t *i);
JANET_API void janet_unmarshal_uint(JanetMarshalContext *ctx,uint32_t* i); JANET_API void janet_unmarshal_uint(JanetMarshalContext *ctx, uint32_t *i);
JANET_API void janet_unmarshal_size(JanetMarshalContext *ctx,size_t * i); JANET_API void janet_unmarshal_size(JanetMarshalContext *ctx, size_t *i);
JANET_API void janet_unmarshal_byte(JanetMarshalContext *ctx,uint8_t* b); JANET_API void janet_unmarshal_byte(JanetMarshalContext *ctx, uint8_t *b);
JANET_API void janet_unmarshal_bytes(JanetMarshalContext *ctx,uint8_t *dest, int32_t len); JANET_API void janet_unmarshal_bytes(JanetMarshalContext *ctx, uint8_t *dest, int32_t len);
JANET_API void janet_unmarshal_janet(JanetMarshalContext *ctx,Janet *out); JANET_API void janet_unmarshal_janet(JanetMarshalContext *ctx, Janet *out);
typedef struct { typedef struct {
const JanetAbstractType *at; const JanetAbstractType *at;
size_t size; /* abstract type size */ size_t size; /* abstract type size */
const uint32_t salt; /* salt */ const uint32_t salt; /* salt */
uint32_t tag; /* unique tag computed by janet (hash of name and salt) */ uint32_t tag; /* unique tag computed by janet (hash of name and salt) */
void (* marshal)(void *p,JanetMarshalContext *ctx); void (* marshal)(void *p, JanetMarshalContext *ctx);
void (* unmarshal)(void *p,JanetMarshalContext *ctx); void (* unmarshal)(void *p, JanetMarshalContext *ctx);
} JanetAbstractTypeInfo; } JanetAbstractTypeInfo;
JANET_API void janet_register_abstract_type(const JanetAbstractTypeInfo * info); JANET_API void janet_register_abstract_type(const JanetAbstractTypeInfo *info);
JANET_API JanetAbstractTypeInfo * janet_get_abstract_type_info(uint32_t tag); JANET_API JanetAbstractTypeInfo *janet_get_abstract_type_info(uint32_t tag);
JANET_API JanetAbstractTypeInfo * janet_get_abstract_type_info_byname(const char * name); JANET_API JanetAbstractTypeInfo *janet_get_abstract_type_info_byname(const char *name);