MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
add Float16Array
+129
-67
+2
include/modules/buffer.h
+2
include/modules/buffer.h
···
22
22
TYPED_ARRAY_UINT16,
23
23
TYPED_ARRAY_INT32,
24
24
TYPED_ARRAY_UINT32,
25
+
TYPED_ARRAY_FLOAT16,
25
26
TYPED_ARRAY_FLOAT32,
26
27
TYPED_ARRAY_FLOAT64,
27
28
TYPED_ARRAY_BIGINT64,
···
50
51
51
52
ArrayBufferData *create_array_buffer_data(size_t length);
52
53
ant_value_t create_arraybuffer_obj(ant_t *js, ArrayBufferData *buffer);
54
+
const char *buffer_typedarray_type_name(TypedArrayType type);
53
55
54
56
ant_value_t create_typed_array(
55
57
ant_t *js, TypedArrayType type, ArrayBufferData *buffer,
+3
include/utils.h
+3
include/utils.h
···
14
14
extern const char *const module_resolve_extensions[];
15
15
uint64_t hash_key(const char *key, size_t len);
16
16
17
+
double half_to_double(uint16_t bits16);
18
+
uint16_t double_to_half(double value);
19
+
17
20
char hex_char(int v);
18
21
char *resolve_js_file(const char *filename);
19
22
+6
-7
src/ant.c
+6
-7
src/ant.c
···
1130
1130
if (vtype(ta_slot) == T_TYPEDARRAY) {
1131
1131
TypedArrayData *ta = (TypedArrayData *)vdata(ta_slot);
1132
1132
if (ta && ta->buffer) {
1133
-
static const char *ta_type_names[] = {
1134
-
"Int8Array", "Uint8Array", "Uint8ClampedArray",
1135
-
"Int16Array", "Uint16Array", "Int32Array", "Uint32Array",
1136
-
"Float32Array", "Float64Array", "BigInt64Array", "BigUint64Array"
1137
-
};
1138
-
1139
1133
const char *type_name = NULL;
1140
1134
size_t type_len = 0;
1141
1135
···
1145
1139
type_name = "Buffer";
1146
1140
type_len = 6;
1147
1141
} else if (ta->type <= TYPED_ARRAY_BIGUINT64) {
1148
-
type_name = ta_type_names[ta->type];
1142
+
type_name = buffer_typedarray_type_name(ta->type);
1149
1143
type_len = strlen(type_name);
1150
1144
} else {
1151
1145
type_name = "TypedArray";
···
1180
1174
break;
1181
1175
case TYPED_ARRAY_UINT32:
1182
1176
n += (size_t) snprintf(buf + n, REMAIN(n, len), "%u", ((uint32_t*)data)[i]);
1177
+
break;
1178
+
case TYPED_ARRAY_FLOAT16:
1179
+
n += (size_t) snprintf(
1180
+
buf + n, REMAIN(n, len), "%g", half_to_double(((uint16_t*)data)[i])
1181
+
);
1183
1182
break;
1184
1183
case TYPED_ARRAY_FLOAT32:
1185
1184
n += (size_t) snprintf(buf + n, REMAIN(n, len), "%g", (double)((float*)data)[i]);
+50
-28
src/modules/buffer.c
+50
-28
src/modules/buffer.c
···
11
11
#endif
12
12
13
13
#include "ant.h"
14
+
#include "utils.h"
14
15
#include "errors.h"
15
16
#include "base64.h"
16
17
#include "internal.h"
17
-
#include "silver/engine.h"
18
18
#include "runtime.h"
19
19
#include "descriptors.h"
20
20
21
+
#include "silver/engine.h"
21
22
#include "modules/buffer.h"
22
23
#include "modules/symbol.h"
23
24
···
94
95
case TYPED_ARRAY_UINT16: value = (double)((uint16_t *)data)[idx]; break;
95
96
case TYPED_ARRAY_INT32: value = (double)((int32_t *)data)[idx]; break;
96
97
case TYPED_ARRAY_UINT32: value = (double)((uint32_t *)data)[idx]; break;
98
+
case TYPED_ARRAY_FLOAT16: value = half_to_double(((uint16_t *)data)[idx]); break;
97
99
case TYPED_ARRAY_FLOAT32: value = (double)((float *)data)[idx]; break;
98
100
case TYPED_ARRAY_FLOAT64: value = ((double *)data)[idx]; break;
99
101
default: return false;
···
277
279
static size_t get_element_size(TypedArrayType type) {
278
280
static const void *dispatch[] = {
279
281
&&L_1, &&L_1, &&L_1, &&L_2, &&L_2,
280
-
&&L_4, &&L_4, &&L_4, &&L_8, &&L_8, &&L_8
282
+
&&L_4, &&L_4, &&L_2, &&L_4, &&L_8, &&L_8, &&L_8
281
283
};
282
284
283
285
if (type > TYPED_ARRAY_BIGUINT64) goto L_1;
···
289
291
L_8: return 8;
290
292
}
291
293
292
-
static const char *typedarray_type_name(TypedArrayType type) {
293
-
switch (type) {
294
-
case TYPED_ARRAY_INT8: return "Int8Array";
295
-
case TYPED_ARRAY_UINT8: return "Uint8Array";
296
-
case TYPED_ARRAY_UINT8_CLAMPED: return "Uint8ClampedArray";
297
-
case TYPED_ARRAY_INT16: return "Int16Array";
298
-
case TYPED_ARRAY_UINT16: return "Uint16Array";
299
-
case TYPED_ARRAY_INT32: return "Int32Array";
300
-
case TYPED_ARRAY_UINT32: return "Uint32Array";
301
-
case TYPED_ARRAY_FLOAT32: return "Float32Array";
302
-
case TYPED_ARRAY_FLOAT64: return "Float64Array";
303
-
case TYPED_ARRAY_BIGINT64: return "BigInt64Array";
304
-
case TYPED_ARRAY_BIGUINT64: return "BigUint64Array";
305
-
default: return "Uint8Array";
306
-
}}
294
+
const char *buffer_typedarray_type_name(TypedArrayType type) {
295
+
static const char *const names[] = {
296
+
"Int8Array",
297
+
"Uint8Array",
298
+
"Uint8ClampedArray",
299
+
"Int16Array",
300
+
"Uint16Array",
301
+
"Int32Array",
302
+
"Uint32Array",
303
+
"Float16Array",
304
+
"Float32Array",
305
+
"Float64Array",
306
+
"BigInt64Array",
307
+
"BigUint64Array",
308
+
};
309
+
310
+
int i = (int)type;
311
+
if (i < 0 || i >= (int)(sizeof(names) / sizeof(names[0]))) return "Uint8Array";
312
+
return names[i];
313
+
}
307
314
308
315
static ant_value_t create_typed_array_like(
309
316
ant_t *js,
···
316
323
ant_value_t ab_obj = create_arraybuffer_obj(js, buffer);
317
324
ant_value_t out = create_typed_array_with_buffer(
318
325
js,type, buffer, byte_offset,
319
-
length, typedarray_type_name(type), ab_obj
326
+
length, buffer_typedarray_type_name(type), ab_obj
320
327
);
321
328
322
329
if (is_err(out)) return out;
···
470
477
471
478
static const void *dispatch[] = {
472
479
&&L_INT8, &&L_UINT8, &&L_UINT8, &&L_INT16, &&L_UINT16,
473
-
&&L_INT32, &&L_UINT32, &&L_FLOAT32, &&L_FLOAT64, &&L_UNDEF, &&L_UNDEF
480
+
&&L_INT32, &&L_UINT32, &&L_FLOAT16, &&L_FLOAT32, &&L_FLOAT64, &&L_UNDEF, &&L_UNDEF
474
481
};
475
482
476
483
if (ta_data->type > TYPED_ARRAY_BIGUINT64) goto L_UNDEF;
···
482
489
L_UINT16: value = (double)((uint16_t*)data)[index]; goto L_DONE;
483
490
L_INT32: value = (double)((int32_t*)data)[index]; goto L_DONE;
484
491
L_UINT32: value = (double)((uint32_t*)data)[index]; goto L_DONE;
492
+
L_FLOAT16: value = half_to_double(((uint16_t*)data)[index]); goto L_DONE;
485
493
L_FLOAT32: value = (double)((float*)data)[index]; goto L_DONE;
486
494
L_FLOAT64: value = ((double*)data)[index]; goto L_DONE;
487
495
L_UNDEF: return js_mkundef();
···
508
516
509
517
static const void *dispatch[] = {
510
518
&&S_INT8, &&S_UINT8, &&S_UINT8, &&S_INT16, &&S_UINT16,
511
-
&&S_INT32, &&S_UINT32, &&S_FLOAT32, &&S_FLOAT64, &&S_FAIL, &&S_FAIL
519
+
&&S_INT32, &&S_UINT32, &&S_FLOAT16, &&S_FLOAT32, &&S_FLOAT64, &&S_FAIL, &&S_FAIL
512
520
};
513
521
514
522
if (ta_data->type > TYPED_ARRAY_BIGUINT64) goto S_FAIL;
···
520
528
S_UINT16: ((uint16_t*)data)[index] = (uint16_t)num_val; goto S_DONE;
521
529
S_INT32: ((int32_t*)data)[index] = (int32_t)num_val; goto S_DONE;
522
530
S_UINT32: ((uint32_t*)data)[index] = (uint32_t)num_val; goto S_DONE;
531
+
S_FLOAT16: ((uint16_t*)data)[index] = double_to_half(num_val); goto S_DONE;
523
532
S_FLOAT32: ((float*)data)[index] = (float)num_val; goto S_DONE;
524
533
S_FLOAT64: ((double*)data)[index] = num_val; goto S_DONE;
525
534
S_FAIL: return false;
···
532
541
533
542
static const void *dispatch[] = {
534
543
&&R_INT8, &&R_UINT8, &&R_UINT8, &&R_INT16, &&R_UINT16,
535
-
&&R_INT32, &&R_UINT32, &&R_FLOAT32, &&R_FLOAT64, &&R_FAIL, &&R_FAIL
544
+
&&R_INT32, &&R_UINT32, &&R_FLOAT16, &&R_FLOAT32, &&R_FLOAT64, &&R_FAIL, &&R_FAIL
536
545
};
537
546
538
547
if (ta_data->type > TYPED_ARRAY_BIGUINT64) goto R_FAIL;
···
544
553
R_UINT16: *out = (double)((uint16_t *)data)[index]; return true;
545
554
R_INT32: *out = (double)((int32_t *)data)[index]; return true;
546
555
R_UINT32: *out = (double)((uint32_t *)data)[index]; return true;
556
+
R_FLOAT16: *out = half_to_double(((uint16_t *)data)[index]); return true;
547
557
R_FLOAT32: *out = (double)((float *)data)[index]; return true;
548
558
R_FLOAT64: *out = ((double *)data)[index]; return true;
549
559
R_FAIL: return false;
···
555
565
556
566
static const void *dispatch[] = {
557
567
&&W_INT8, &&W_UINT8, &&W_UINT8, &&W_INT16, &&W_UINT16,
558
-
&&W_INT32, &&W_UINT32, &&W_FLOAT32, &&W_FLOAT64, &&W_FAIL, &&W_FAIL
568
+
&&W_INT32, &&W_UINT32, &&W_FLOAT16, &&W_FLOAT32, &&W_FLOAT64, &&W_FAIL, &&W_FAIL
559
569
};
560
570
561
571
if (ta_data->type > TYPED_ARRAY_BIGUINT64) goto W_FAIL;
···
567
577
W_UINT16: ((uint16_t *)data)[index] = (uint16_t)value; return true;
568
578
W_INT32: ((int32_t *)data)[index] = (int32_t)value; return true;
569
579
W_UINT32: ((uint32_t *)data)[index] = (uint32_t)value; return true;
580
+
W_FLOAT16: ((uint16_t *)data)[index] = double_to_half(value); return true;
570
581
W_FLOAT32: ((float *)data)[index] = (float)value; return true;
571
582
W_FLOAT64: ((double *)data)[index] = value; return true;
572
583
W_FAIL: return false;
···
739
750
740
751
static const void *write_dispatch[] = {
741
752
&&W_INT8, &&W_UINT8, &&W_UINT8, &&W_INT16, &&W_UINT16,
742
-
&&W_INT32, &&W_UINT32, &&W_FLOAT32, &&W_FLOAT64, &&W_DONE, &&W_DONE
753
+
&&W_INT32, &&W_UINT32, &&W_FLOAT16, &&W_FLOAT32, &&W_FLOAT64, &&W_DONE, &&W_DONE
743
754
};
744
755
745
756
for (size_t i = 0; i < length; i++) {
···
753
764
double val = vtype(elem) == T_NUM
754
765
? js_getnum(elem)
755
766
: js_to_number(js, elem);
756
-
767
+
757
768
if (type > TYPED_ARRAY_BIGUINT64) goto W_DONE;
758
769
goto *write_dispatch[type];
759
770
···
763
774
W_UINT16: ((uint16_t*)data)[i] = (uint16_t)val; goto W_NEXT;
764
775
W_INT32: ((int32_t*)data)[i] = (int32_t)val; goto W_NEXT;
765
776
W_UINT32: ((uint32_t*)data)[i] = (uint32_t)val; goto W_NEXT;
777
+
W_FLOAT16: ((uint16_t*)data)[i] = double_to_half(val); goto W_NEXT;
766
778
W_FLOAT32: ((float*)data)[i] = (float)val; goto W_NEXT;
767
779
W_FLOAT64: ((double*)data)[i] = val; goto W_NEXT;
768
780
W_NEXT:;
···
805
817
case TYPED_ARRAY_UINT16: value = (double)((uint16_t*)data)[index]; break;
806
818
case TYPED_ARRAY_INT32: value = (double)((int32_t*)data)[index]; break;
807
819
case TYPED_ARRAY_UINT32: value = (double)((uint32_t*)data)[index]; break;
820
+
case TYPED_ARRAY_FLOAT16: value = half_to_double(((uint16_t*)data)[index]); break;
808
821
case TYPED_ARRAY_FLOAT32: value = (double)((float*)data)[index]; break;
809
822
case TYPED_ARRAY_FLOAT64: value = ((double*)data)[index]; break;
810
823
default: return js_mkundef();
···
901
914
902
915
static const void *dispatch[] = {
903
916
&&L_INT8, &&L_UINT8, &&L_UINT8, &&L_INT16, &&L_UINT16,
904
-
&&L_INT32, &&L_UINT32, &&L_FLOAT32, &&L_FLOAT64, &&L_DONE, &&L_DONE
917
+
&&L_INT32, &&L_UINT32, &&L_FLOAT16, &&L_FLOAT32, &&L_FLOAT64, &&L_DONE, &&L_DONE
905
918
};
906
919
907
920
if (ta_data->type > TYPED_ARRAY_BIGUINT64) goto L_DONE;
···
924
937
goto L_DONE;
925
938
L_UINT32:
926
939
for (ssize_t i = start; i < end; i++) ((uint32_t*)data)[i] = (uint32_t)value;
940
+
goto L_DONE;
941
+
L_FLOAT16:
942
+
for (ssize_t i = start; i < end; i++) ((uint16_t*)data)[i] = double_to_half(value);
927
943
goto L_DONE;
928
944
L_FLOAT32:
929
945
for (ssize_t i = start; i < end; i++) ((float*)data)[i] = (float)value;
···
1104
1120
1105
1121
static const void *read_dispatch[] = {
1106
1122
&&R_INT8, &&R_UINT8, &&R_UINT8, &&R_INT16, &&R_UINT16,
1107
-
&&R_INT32, &&R_UINT32, &&R_FLOAT32, &&R_FLOAT64, &&R_DONE, &&R_DONE
1123
+
&&R_INT32, &&R_UINT32, &&R_FLOAT16, &&R_FLOAT32, &&R_FLOAT64, &&R_DONE, &&R_DONE
1108
1124
};
1109
1125
1110
1126
if (ta_data->type > TYPED_ARRAY_BIGUINT64) goto R_DONE;
···
1116
1132
R_UINT16: a_val = (double)((uint16_t*)data)[j-1]; b_val = (double)((uint16_t*)data)[j]; goto R_COMPARE;
1117
1133
R_INT32: a_val = (double)((int32_t*)data)[j-1]; b_val = (double)((int32_t*)data)[j]; goto R_COMPARE;
1118
1134
R_UINT32: a_val = (double)((uint32_t*)data)[j-1]; b_val = (double)((uint32_t*)data)[j]; goto R_COMPARE;
1135
+
R_FLOAT16: a_val = half_to_double(((uint16_t*)data)[j-1]); b_val = half_to_double(((uint16_t*)data)[j]); goto R_COMPARE;
1119
1136
R_FLOAT32: a_val = (double)((float*)data)[j-1]; b_val = (double)((float*)data)[j]; goto R_COMPARE;
1120
1137
R_FLOAT64: a_val = ((double*)data)[j-1]; b_val = ((double*)data)[j]; goto R_COMPARE;
1121
1138
R_DONE: goto SORT_DONE;
···
1133
1150
1134
1151
static const void *swap_dispatch[] = {
1135
1152
&&S_INT8, &&S_UINT8, &&S_UINT8, &&S_INT16, &&S_UINT16,
1136
-
&&S_INT32, &&S_UINT32, &&S_FLOAT32, &&S_FLOAT64, &&S_DONE, &&S_DONE
1153
+
&&S_INT32, &&S_UINT32, &&S_FLOAT16, &&S_FLOAT32, &&S_FLOAT64, &&S_DONE, &&S_DONE
1137
1154
};
1138
1155
1139
1156
if (ta_data->type > TYPED_ARRAY_BIGUINT64) goto S_DONE;
···
1145
1162
S_UINT16: { uint16_t tmp = ((uint16_t*)data)[j-1]; ((uint16_t*)data)[j-1] = ((uint16_t*)data)[j]; ((uint16_t*)data)[j] = tmp; goto S_DONE; }
1146
1163
S_INT32: { int32_t tmp = ((int32_t*)data)[j-1]; ((int32_t*)data)[j-1] = ((int32_t*)data)[j]; ((int32_t*)data)[j] = tmp; goto S_DONE; }
1147
1164
S_UINT32: { uint32_t tmp = ((uint32_t*)data)[j-1]; ((uint32_t*)data)[j-1] = ((uint32_t*)data)[j]; ((uint32_t*)data)[j] = tmp; goto S_DONE; }
1165
+
S_FLOAT16: { uint16_t tmp = ((uint16_t*)data)[j-1]; ((uint16_t*)data)[j-1] = ((uint16_t*)data)[j]; ((uint16_t*)data)[j] = tmp; goto S_DONE; }
1148
1166
S_FLOAT32: { float tmp = ((float*)data)[j-1]; ((float*)data)[j-1] = ((float*)data)[j]; ((float*)data)[j] = tmp; goto S_DONE; }
1149
1167
S_FLOAT64: { double tmp = ((double*)data)[j-1]; ((double*)data)[j-1] = ((double*)data)[j]; ((double*)data)[j] = tmp; goto S_DONE; }
1150
1168
S_DONE:;
···
1184
1202
1185
1203
static const void *dispatch[] = {
1186
1204
&&W_INT8, &&W_UINT8, &&W_UINT8, &&W_INT16, &&W_UINT16,
1187
-
&&W_INT32, &&W_UINT32, &&W_FLOAT32, &&W_FLOAT64, &&W_DONE, &&W_DONE
1205
+
&&W_INT32, &&W_UINT32, &&W_FLOAT16, &&W_FLOAT32, &&W_FLOAT64, &&W_DONE, &&W_DONE
1188
1206
};
1189
1207
1190
1208
if (ta_data->type > TYPED_ARRAY_BIGUINT64) goto W_DONE;
···
1196
1214
W_UINT16: ((uint16_t*)data)[index] = (uint16_t)value; goto W_DONE;
1197
1215
W_INT32: ((int32_t*)data)[index] = (int32_t)value; goto W_DONE;
1198
1216
W_UINT32: ((uint32_t*)data)[index] = (uint32_t)value; goto W_DONE;
1217
+
W_FLOAT16: ((uint16_t*)data)[index] = double_to_half(value); goto W_DONE;
1199
1218
W_FLOAT32: ((float*)data)[index] = (float)value; goto W_DONE;
1200
1219
W_FLOAT64: ((double*)data)[index] = value; goto W_DONE;
1201
1220
W_DONE:
···
1221
1240
DEFINE_TYPEDARRAY_CONSTRUCTOR(Uint16Array, TYPED_ARRAY_UINT16)
1222
1241
DEFINE_TYPEDARRAY_CONSTRUCTOR(Int32Array, TYPED_ARRAY_INT32)
1223
1242
DEFINE_TYPEDARRAY_CONSTRUCTOR(Uint32Array, TYPED_ARRAY_UINT32)
1243
+
DEFINE_TYPEDARRAY_CONSTRUCTOR(Float16Array, TYPED_ARRAY_FLOAT16)
1224
1244
DEFINE_TYPEDARRAY_CONSTRUCTOR(Float32Array, TYPED_ARRAY_FLOAT32)
1225
1245
DEFINE_TYPEDARRAY_CONSTRUCTOR(Float64Array, TYPED_ARRAY_FLOAT64)
1226
1246
DEFINE_TYPEDARRAY_CONSTRUCTOR(BigInt64Array, TYPED_ARRAY_BIGINT64)
···
1806
1826
case TYPED_ARRAY_UINT16: written = snprintf(buf + pos, cap - pos, "%u", ((uint16_t*)data)[i]); break;
1807
1827
case TYPED_ARRAY_INT32: written = snprintf(buf + pos, cap - pos, "%d", ((int32_t*)data)[i]); break;
1808
1828
case TYPED_ARRAY_UINT32: written = snprintf(buf + pos, cap - pos, "%u", ((uint32_t*)data)[i]); break;
1829
+
case TYPED_ARRAY_FLOAT16: written = snprintf(buf + pos, cap - pos, "%g", half_to_double(((uint16_t*)data)[i])); break;
1809
1830
case TYPED_ARRAY_FLOAT32: written = snprintf(buf + pos, cap - pos, "%g", (double)((float*)data)[i]); break;
1810
1831
case TYPED_ARRAY_FLOAT64: written = snprintf(buf + pos, cap - pos, "%g", ((double*)data)[i]); break;
1811
1832
case TYPED_ARRAY_BIGINT64: written = snprintf(buf + pos, cap - pos, "%lld", ((long long*)data)[i]); break;
···
2178
2199
SETUP_TYPEDARRAY(Uint16Array);
2179
2200
SETUP_TYPEDARRAY(Int32Array);
2180
2201
SETUP_TYPEDARRAY(Uint32Array);
2202
+
SETUP_TYPEDARRAY(Float16Array);
2181
2203
SETUP_TYPEDARRAY(Float32Array);
2182
2204
SETUP_TYPEDARRAY(Float64Array);
2183
2205
SETUP_TYPEDARRAY(BigInt64Array);
+1
-18
src/modules/napi.c
+1
-18
src/modules/napi.c
···
290
290
return true;
291
291
}
292
292
293
-
static const char *napi_typed_array_name(TypedArrayType t) {
294
-
switch (t) {
295
-
case TYPED_ARRAY_INT8: return "Int8Array";
296
-
case TYPED_ARRAY_UINT8: return "Uint8Array";
297
-
case TYPED_ARRAY_UINT8_CLAMPED: return "Uint8ClampedArray";
298
-
case TYPED_ARRAY_INT16: return "Int16Array";
299
-
case TYPED_ARRAY_UINT16: return "Uint16Array";
300
-
case TYPED_ARRAY_INT32: return "Int32Array";
301
-
case TYPED_ARRAY_UINT32: return "Uint32Array";
302
-
case TYPED_ARRAY_FLOAT32: return "Float32Array";
303
-
case TYPED_ARRAY_FLOAT64: return "Float64Array";
304
-
case TYPED_ARRAY_BIGINT64: return "BigInt64Array";
305
-
case TYPED_ARRAY_BIGUINT64: return "BigUint64Array";
306
-
default: return "Uint8Array";
307
-
}
308
-
}
309
-
310
293
static bool napi_to_ant_typedarray_type(
311
294
napi_typedarray_type in,
312
295
TypedArrayType *out
···
1049
1032
ab,
1050
1033
byte_offset,
1051
1034
length,
1052
-
napi_typed_array_name(ta_type),
1035
+
buffer_typedarray_type_name(ta_type),
1053
1036
(ant_value_t)arraybuffer
1054
1037
);
1055
1038
+1
-14
src/modules/structured-clone.c
+1
-14
src/modules/structured-clone.c
···
49
49
}
50
50
}
51
51
52
-
static const char *sc_ta_type_name(TypedArrayType type) {
53
-
static const char *names[] = {
54
-
"Int8Array", "Uint8Array", "Uint8ClampedArray",
55
-
"Int16Array", "Uint16Array",
56
-
"Int32Array", "Uint32Array",
57
-
"Float32Array", "Float64Array",
58
-
"BigInt64Array", "BigUint64Array"
59
-
};
60
-
int i = (int)type;
61
-
if (i < 0 || i > 10) return "Uint8Array";
62
-
return names[i];
63
-
}
64
-
65
52
static ant_value_t sc_clone_typed_array(
66
53
ant_t *js, ant_value_t key, TypedArrayData *ta_data, sc_entry_t **seen
67
54
) {
···
80
67
81
68
ant_value_t clone = create_typed_array(
82
69
js, ta_data->type, new_buf, 0,
83
-
ta_data->length, sc_ta_type_name(ta_data->type)
70
+
ta_data->length, buffer_typedarray_type_name(ta_data->type)
84
71
);
85
72
86
73
sc_add(seen, key, clone);
+66
src/utils.c
+66
src/utils.c
···
46
46
return hash;
47
47
}
48
48
49
+
double half_to_double(uint16_t bits16) {
50
+
uint32_t sign = ((uint32_t)bits16 & 0x8000u) << 16;
51
+
uint32_t exp = ((uint32_t)bits16 >> 10) & 0x1fu;
52
+
uint32_t mant = (uint32_t)bits16 & 0x03ffu;
53
+
54
+
uint32_t bits32 = 0;
55
+
float out = 0.0f;
56
+
57
+
if (exp == 0) {
58
+
if (mant == 0) {
59
+
bits32 = sign;
60
+
} else {
61
+
uint32_t exp32 = 113;
62
+
while ((mant & 0x0400u) == 0) {
63
+
mant <<= 1;
64
+
exp32--;
65
+
}
66
+
mant &= 0x03ffu;
67
+
bits32 = sign | (exp32 << 23) | (mant << 13);
68
+
}}
69
+
70
+
else if (exp == 0x1fu) bits32 = sign | 0x7f800000u | (mant << 13);
71
+
else bits32 = sign | ((exp + 112u) << 23) | (mant << 13);
72
+
73
+
memcpy(&out, &bits32, sizeof(out));
74
+
return (double)out;
75
+
}
76
+
77
+
uint16_t double_to_half(double value) {
78
+
float input = (float)value;
79
+
80
+
uint32_t bits32 = 0;
81
+
uint32_t sign = 0;
82
+
uint32_t exp = 0;
83
+
uint32_t mant = 0;
84
+
int32_t exp16 = 0;
85
+
uint16_t out = 0;
86
+
87
+
memcpy(&bits32, &input, sizeof(bits32));
88
+
sign = (bits32 >> 16) & 0x8000u;
89
+
exp = (bits32 >> 23) & 0xffu;
90
+
mant = bits32 & 0x007fffffu;
91
+
92
+
if (exp == 0xffu) {
93
+
if (mant != 0) return (uint16_t)(sign | 0x7e00u);
94
+
return (uint16_t)(sign | 0x7c00u);
95
+
}
96
+
97
+
exp16 = (int32_t)exp - 127 + 15;
98
+
if (exp16 >= 0x1f) return (uint16_t)(sign | 0x7c00u);
99
+
100
+
if (exp16 <= 0) {
101
+
if (exp16 < -10) return (uint16_t)sign;
102
+
mant |= 0x00800000u;
103
+
uint32_t shift = (uint32_t)(14 - exp16);
104
+
uint16_t sub = (uint16_t)(mant >> shift);
105
+
if ((mant >> (shift - 1)) & 1u) sub++;
106
+
return (uint16_t)(sign | sub);
107
+
}
108
+
109
+
out = (uint16_t)(sign | ((uint32_t)exp16 << 10) | (mant >> 13));
110
+
if (mant & 0x00001000u) out++;
111
+
112
+
return out;
113
+
}
114
+
49
115
int is_typescript_file(const char *filename) {
50
116
if (filename == NULL) return 0;
51
117
size_t len = strlen(filename);