MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
fix explicit casts
+99
-87
+1
-1
include/ant.h
+1
-1
include/ant.h
···
14
14
#define STR_PROTO_LEN 9
15
15
16
16
#define ANT_STRING(s) js_mkstr(js, s, sizeof(s) - 1)
17
-
#define ANT_PTR(ptr) js_mknum((uintptr_t)(ptr))
17
+
#define ANT_PTR(ptr) js_mknum((double)(uintptr_t)(ptr))
18
18
#define ANT_COPY(buf, len, s) cpy(buf, len, s, sizeof(s) - 1)
19
19
20
20
struct js;
+9
meson.build
+9
meson.build
···
35
35
36
36
add_project_arguments(
37
37
'-D NO_EXECUTE_PERMISSION',
38
+
'-Wall',
39
+
'-Wextra',
40
+
'-Wshadow',
41
+
'-Wdouble-promotion',
42
+
'-Wformat=2',
43
+
'-Wundef',
44
+
'-Wconversion',
45
+
'-Wno-sign-conversion',
38
46
'-Wno-unused-function',
47
+
'-Wno-unused-parameter',
39
48
'-Wno-deprecated-declarations',
40
49
language: 'c')
41
50
+1
src/ant.c
+1
src/ant.c
···
57
57
_Static_assert(sizeof(double) == 8, "NaN-boxing requires 64-bit IEEE 754 doubles");
58
58
_Static_assert(sizeof(uint64_t) == 8, "NaN-boxing requires 64-bit integers");
59
59
_Static_assert(sizeof(double) == sizeof(uint64_t), "double and uint64_t must have same size");
60
+
_Static_assert(sizeof(void*) <= 8 && (sizeof(void*) < 8 || 1), "ANT_PTR: pointers must fit in 53-bit double mantissa");
60
61
61
62
#if defined(__STDC_IEC_559__) || defined(__GCC_IEC_559)
62
63
#elif defined(__FAST_MATH__)
+52
-54
src/modules/buffer.c
+52
-54
src/modules/buffer.c
···
20
20
static uint8_t *ta_arena = NULL;
21
21
static size_t ta_arena_offset = 0;
22
22
23
+
static inline ssize_t normalize_index(ssize_t idx, ssize_t len) {
24
+
if (idx < 0) idx += len;
25
+
if (idx < 0) return 0;
26
+
if (idx > len) return len;
27
+
return idx;
28
+
}
29
+
23
30
static void *ta_arena_alloc(size_t size) {
24
31
size = (size + 7) & ~7;
25
32
···
191
198
192
199
if (js_type(proto) == JS_OBJ) js_set_proto(js, obj, proto);
193
200
js_set_slot(js, obj, SLOT_BUFFER, ANT_PTR(data));
194
-
js_set(js, obj, "byteLength", js_mknum(length));
201
+
js_set(js, obj, "byteLength", js_mknum((double)length));
195
202
196
203
return obj;
197
204
}
···
208
215
ArrayBufferData *data = (ArrayBufferData *)(uintptr_t)js_getnum(data_val);
209
216
if (!data) return js_mkerr(js, "Invalid ArrayBuffer");
210
217
211
-
int begin = 0, end = data->length;
212
-
if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (int)js_getnum(args[0]);
213
-
if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (int)js_getnum(args[1]);
218
+
ssize_t len = (ssize_t)data->length;
219
+
ssize_t begin = 0, end = len;
220
+
if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (ssize_t)js_getnum(args[0]);
221
+
if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (ssize_t)js_getnum(args[1]);
214
222
215
-
if (begin < 0) begin = data->length + begin;
216
-
if (end < 0) end = data->length + end;
217
-
if (begin < 0) begin = 0;
218
-
if (end < 0) end = 0;
219
-
if (begin > (int)data->length) begin = data->length;
220
-
if (end > (int)data->length) end = data->length;
223
+
begin = normalize_index(begin, len);
224
+
end = normalize_index(end, len);
221
225
if (end < begin) end = begin;
222
226
223
-
size_t new_length = end - begin;
227
+
size_t new_length = (size_t)(end - begin);
224
228
ArrayBufferData *new_data = create_array_buffer_data(new_length);
225
229
if (!new_data) return js_mkerr(js, "Failed to allocate new ArrayBuffer");
226
230
···
231
235
232
236
if (js_type(proto) == JS_OBJ) js_set_proto(js, new_obj, proto);
233
237
js_set_slot(js, new_obj, SLOT_BUFFER, ANT_PTR(new_data));
234
-
js_set(js, new_obj, "byteLength", js_mknum(new_length));
238
+
js_set(js, new_obj, "byteLength", js_mknum((double)new_length));
235
239
236
240
return new_obj;
237
241
}
···
485
489
TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val);
486
490
if (!ta_data) return js_mkerr(js, "Invalid TypedArray");
487
491
488
-
int begin = 0, end = ta_data->length;
489
-
if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (int)js_getnum(args[0]);
490
-
if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (int)js_getnum(args[1]);
492
+
ssize_t len = (ssize_t)ta_data->length;
493
+
ssize_t begin = 0, end = len;
491
494
492
-
if (begin < 0) begin = ta_data->length + begin;
493
-
if (end < 0) end = ta_data->length + end;
494
-
if (begin < 0) begin = 0;
495
-
if (end < 0) end = 0;
496
-
if (begin > (int)ta_data->length) begin = ta_data->length;
497
-
if (end > (int)ta_data->length) end = ta_data->length;
495
+
if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (ssize_t)js_getnum(args[0]);
496
+
if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (ssize_t)js_getnum(args[1]);
497
+
498
+
begin = normalize_index(begin, len);
499
+
end = normalize_index(end, len);
498
500
if (end < begin) end = begin;
499
501
500
-
size_t new_length = end - begin;
502
+
size_t new_length = (size_t)(end - begin);
501
503
size_t element_size = get_element_size(ta_data->type);
502
504
ArrayBufferData *new_buffer = create_array_buffer_data(new_length * element_size);
503
505
if (!new_buffer) return js_mkerr(js, "Failed to allocate new buffer");
504
506
505
507
memcpy(
506
508
new_buffer->data,
507
-
ta_data->buffer->data + ta_data->byte_offset + begin * element_size,
509
+
ta_data->buffer->data + ta_data->byte_offset + (size_t)begin * element_size,
508
510
new_length * element_size
509
511
);
510
512
···
519
521
TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val);
520
522
if (!ta_data) return js_mkerr(js, "Invalid TypedArray");
521
523
522
-
int begin = 0, end = ta_data->length;
523
-
if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (int)js_getnum(args[0]);
524
-
if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (int)js_getnum(args[1]);
524
+
ssize_t len = (ssize_t)ta_data->length;
525
+
ssize_t begin = 0, end = len;
525
526
526
-
if (begin < 0) begin = ta_data->length + begin;
527
-
if (end < 0) end = ta_data->length + end;
528
-
if (begin < 0) begin = 0;
529
-
if (end < 0) end = 0;
530
-
if (begin > (int)ta_data->length) begin = ta_data->length;
531
-
if (end > (int)ta_data->length) end = ta_data->length;
527
+
if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (ssize_t)js_getnum(args[0]);
528
+
if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (ssize_t)js_getnum(args[1]);
529
+
530
+
begin = normalize_index(begin, len);
531
+
end = normalize_index(end, len);
532
532
if (end < begin) end = begin;
533
533
534
-
size_t new_length = end - begin;
534
+
size_t new_length = (size_t)(end - begin);
535
535
size_t element_size = get_element_size(ta_data->type);
536
-
size_t new_offset = ta_data->byte_offset + begin * element_size;
536
+
size_t new_offset = ta_data->byte_offset + (size_t)begin * element_size;
537
537
538
538
return create_typed_array(js, ta_data->type, ta_data->buffer, new_offset, new_length, "TypedArray");
539
539
}
···
549
549
double value = 0;
550
550
if (nargs > 0 && js_type(args[0]) == JS_NUM) value = js_getnum(args[0]);
551
551
552
-
int start = 0, end = ta_data->length;
553
-
if (nargs > 1 && js_type(args[1]) == JS_NUM) start = (int)js_getnum(args[1]);
554
-
if (nargs > 2 && js_type(args[2]) == JS_NUM) end = (int)js_getnum(args[2]);
552
+
ssize_t len = (ssize_t)ta_data->length;
553
+
ssize_t start = 0, end = len;
555
554
556
-
if (start < 0) start = ta_data->length + start;
557
-
if (end < 0) end = ta_data->length + end;
558
-
if (start < 0) start = 0;
559
-
if (end < 0) end = 0;
560
-
if (start > (int)ta_data->length) start = ta_data->length;
561
-
if (end > (int)ta_data->length) end = ta_data->length;
555
+
if (nargs > 1 && js_type(args[1]) == JS_NUM) start = (ssize_t)js_getnum(args[1]);
556
+
if (nargs > 2 && js_type(args[2]) == JS_NUM) end = (ssize_t)js_getnum(args[2]);
557
+
558
+
start = normalize_index(start, len);
559
+
end = normalize_index(end, len);
562
560
if (end < start) end = start;
563
561
564
562
uint8_t *data = ta_data->buffer->data + ta_data->byte_offset;
···
572
570
goto *dispatch[ta_data->type];
573
571
574
572
L_INT8:
575
-
for (int i = start; i < end; i++) ((int8_t*)data)[i] = (int8_t)value;
573
+
for (ssize_t i = start; i < end; i++) ((int8_t*)data)[i] = (int8_t)value;
576
574
goto L_DONE;
577
575
L_UINT8:
578
-
for (int i = start; i < end; i++) data[i] = (uint8_t)value;
576
+
for (ssize_t i = start; i < end; i++) data[i] = (uint8_t)value;
579
577
goto L_DONE;
580
578
L_INT16:
581
-
for (int i = start; i < end; i++) ((int16_t*)data)[i] = (int16_t)value;
579
+
for (ssize_t i = start; i < end; i++) ((int16_t*)data)[i] = (int16_t)value;
582
580
goto L_DONE;
583
581
L_UINT16:
584
-
for (int i = start; i < end; i++) ((uint16_t*)data)[i] = (uint16_t)value;
582
+
for (ssize_t i = start; i < end; i++) ((uint16_t*)data)[i] = (uint16_t)value;
585
583
goto L_DONE;
586
584
L_INT32:
587
-
for (int i = start; i < end; i++) ((int32_t*)data)[i] = (int32_t)value;
585
+
for (ssize_t i = start; i < end; i++) ((int32_t*)data)[i] = (int32_t)value;
588
586
goto L_DONE;
589
587
L_UINT32:
590
-
for (int i = start; i < end; i++) ((uint32_t*)data)[i] = (uint32_t)value;
588
+
for (ssize_t i = start; i < end; i++) ((uint32_t*)data)[i] = (uint32_t)value;
591
589
goto L_DONE;
592
590
L_FLOAT32:
593
-
for (int i = start; i < end; i++) ((float*)data)[i] = (float)value;
591
+
for (ssize_t i = start; i < end; i++) ((float*)data)[i] = (float)value;
594
592
goto L_DONE;
595
593
L_FLOAT64:
596
-
for (int i = start; i < end; i++) ((double*)data)[i] = value;
594
+
for (ssize_t i = start; i < end; i++) ((double*)data)[i] = value;
597
595
goto L_DONE;
598
596
L_DONE:
599
597
return this_val;
···
714
712
TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val);
715
713
if (!ta_data) return js_mkerr(js, "Invalid TypedArray");
716
714
717
-
int index = (int)js_getnum(args[0]);
715
+
ssize_t index = (ssize_t)js_getnum(args[0]);
718
716
double value = js_getnum(args[1]);
719
717
size_t length = ta_data->length;
720
718
721
-
if (index < 0) index = length + index;
719
+
if (index < 0) index = (ssize_t)length + index;
722
720
if (index < 0 || (size_t)index >= length) {
723
721
return js_mkerr(js, "Index out of bounds");
724
722
}
···
1546
1544
1547
1545
if (js_type(proto) == JS_OBJ) js_set_proto(js, obj, proto);
1548
1546
js_set_slot(js, obj, SLOT_BUFFER, ANT_PTR(data));
1549
-
js_set(js, obj, "byteLength", js_mknum(length));
1547
+
js_set(js, obj, "byteLength", js_mknum((double)length));
1550
1548
1551
1549
return obj;
1552
1550
}
+2
-2
src/modules/child_process.c
+2
-2
src/modules/child_process.c
···
269
269
270
270
if (nread < 0) {
271
271
if (nread != UV_EOF) {
272
-
jsval_t err_args[1] = { js_mkstr(cp->js, uv_strerror(nread), strlen(uv_strerror(nread))) };
272
+
jsval_t err_args[1] = { js_mkstr(cp->js, uv_strerror((int)nread), (int)strlen(uv_strerror((int)nread))) };
273
273
emit_event(cp, "error", err_args, 1);
274
274
}
275
275
cp->pending_closes++;
···
416
416
char *buf_data = malloc(data_len);
417
417
memcpy(buf_data, data, data_len);
418
418
419
-
uv_buf_t buf = uv_buf_init(buf_data, data_len);
419
+
uv_buf_t buf = uv_buf_init(buf_data, (unsigned int)data_len);
420
420
write_req->data = buf_data;
421
421
422
422
int result = uv_write(write_req, (uv_stream_t *)&cp->stdin_pipe, &buf, 1, NULL);
+4
src/modules/crypto.c
+4
src/modules/crypto.c
+1
-1
src/modules/fetch.c
+1
-1
src/modules/fetch.c
+15
-15
src/modules/fs.c
+15
-15
src/modules/fs.c
···
102
102
103
103
if (uv_req->result < 0) {
104
104
req->failed = 1;
105
-
req->error_msg = strdup(uv_strerror(uv_req->result));
105
+
req->error_msg = strdup(uv_strerror((int)uv_req->result));
106
106
req->completed = 1;
107
107
complete_request(req);
108
108
return;
···
123
123
124
124
if (uv_req->result < 0) {
125
125
req->failed = 1;
126
-
req->error_msg = strdup(uv_strerror(uv_req->result));
126
+
req->error_msg = strdup(uv_strerror((int)uv_req->result));
127
127
req->completed = 1;
128
128
complete_request(req);
129
129
return;
130
130
}
131
131
132
-
req->fd = uv_req->result;
132
+
req->fd = (int)uv_req->result;
133
133
uv_fs_req_cleanup(uv_req);
134
134
135
135
uv_fs_t stat_req;
···
162
162
return;
163
163
}
164
164
165
-
uv_buf_t buf = uv_buf_init(req->data, file_size);
165
+
uv_buf_t buf = uv_buf_init(req->data, (unsigned int)file_size);
166
166
int read_result = uv_fs_read(fs_loop, uv_req, req->fd, &buf, 1, 0, on_read_complete);
167
167
168
168
if (read_result < 0) {
···
182
182
183
183
if (uv_req->result < 0) {
184
184
req->failed = 1;
185
-
req->error_msg = strdup(uv_strerror(uv_req->result));
185
+
req->error_msg = strdup(uv_strerror((int)uv_req->result));
186
186
}
187
187
188
188
uv_fs_t close_req;
···
198
198
199
199
if (uv_req->result < 0) {
200
200
req->failed = 1;
201
-
req->error_msg = strdup(uv_strerror(uv_req->result));
201
+
req->error_msg = strdup(uv_strerror((int)uv_req->result));
202
202
req->completed = 1;
203
203
complete_request(req);
204
204
return;
205
205
}
206
206
207
-
req->fd = uv_req->result;
207
+
req->fd = (int)uv_req->result;
208
208
uv_fs_req_cleanup(uv_req);
209
209
210
-
uv_buf_t buf = uv_buf_init(req->data, req->data_len);
210
+
uv_buf_t buf = uv_buf_init(req->data, (unsigned int)req->data_len);
211
211
int write_result = uv_fs_write(fs_loop, uv_req, req->fd, &buf, 1, 0, on_write_complete);
212
212
213
213
if (write_result < 0) {
···
227
227
228
228
if (uv_req->result < 0) {
229
229
req->failed = 1;
230
-
req->error_msg = strdup(uv_strerror(uv_req->result));
230
+
req->error_msg = strdup(uv_strerror((int)uv_req->result));
231
231
}
232
232
233
233
uv_fs_req_cleanup(uv_req);
···
240
240
241
241
if (uv_req->result < 0) {
242
242
req->failed = 1;
243
-
req->error_msg = strdup(uv_strerror(uv_req->result));
243
+
req->error_msg = strdup(uv_strerror((int)uv_req->result));
244
244
}
245
245
246
246
uv_fs_req_cleanup(uv_req);
···
253
253
254
254
if (uv_req->result < 0) {
255
255
req->failed = 1;
256
-
req->error_msg = strdup(uv_strerror(uv_req->result));
256
+
req->error_msg = strdup(uv_strerror((int)uv_req->result));
257
257
}
258
258
259
259
uv_fs_req_cleanup(uv_req);
···
266
266
267
267
if (uv_req->result < 0) {
268
268
req->failed = 1;
269
-
req->error_msg = strdup(uv_strerror(uv_req->result));
269
+
req->error_msg = strdup(uv_strerror((int)uv_req->result));
270
270
req->completed = 1;
271
271
complete_request(req);
272
272
return;
···
304
304
305
305
if (uv_req->result < 0) {
306
306
req->failed = 1;
307
-
req->error_msg = strdup(uv_strerror(uv_req->result));
307
+
req->error_msg = strdup(uv_strerror((int)uv_req->result));
308
308
req->completed = 1;
309
309
complete_request(req);
310
310
return;
···
321
321
322
322
if (uv_req->result < 0) {
323
323
req->failed = 1;
324
-
req->error_msg = strdup(uv_strerror(uv_req->result));
324
+
req->error_msg = strdup(uv_strerror((int)uv_req->result));
325
325
req->completed = 1;
326
326
complete_request(req);
327
327
return;
···
824
824
(void)mode;
825
825
int result = _mkdir(path_cstr);
826
826
#else
827
-
int result = mkdir(path_cstr, mode);
827
+
int result = mkdir(path_cstr, (mode_t)mode);
828
828
#endif
829
829
free(path_cstr);
830
830
+2
-2
src/modules/io.c
+2
-2
src/modules/io.c
···
380
380
381
381
if (console_timer_count < 64) {
382
382
console_timers[console_timer_count].label = strdup(label);
383
-
console_timers[console_timer_count].start_time = uv_hrtime() / 1e6;
383
+
console_timers[console_timer_count].start_time = (double)uv_hrtime() / 1e6;
384
384
console_timer_count++;
385
385
}
386
386
···
395
395
396
396
for (int i = 0; i < console_timer_count; i++) {
397
397
if (strcmp(console_timers[i].label, label) == 0) {
398
-
double elapsed = (uv_hrtime() / 1e6) - console_timers[i].start_time;
398
+
double elapsed = ((double)uv_hrtime() / 1e6) - console_timers[i].start_time;
399
399
fprintf(stdout, "%s: %.3fms\n", label, elapsed);
400
400
free(console_timers[i].label);
401
401
for (int j = i; j < console_timer_count - 1; j++) {
+1
-1
src/modules/json.c
+1
-1
src/modules/json.c
···
168
168
case JS_NUM: {
169
169
double num = js_getnum(val);
170
170
if (isnan(num) || isinf(num)) return yyjson_mut_null(doc);
171
-
if (num == (int64_t)num) return yyjson_mut_sint(doc, (int64_t)num);
171
+
if (num == (double)(int64_t)num) return yyjson_mut_sint(doc, (int64_t)num);
172
172
return yyjson_mut_real(doc, num);
173
173
}
174
174
+2
-2
src/modules/os.c
+2
-2
src/modules/os.c
···
301
301
302
302
if (host_page_size(mach_port, &page_size) == KERN_SUCCESS &&
303
303
host_statistics64(mach_port, HOST_VM_INFO64, (host_info64_t)&vm_stats, &count) == KERN_SUCCESS) {
304
-
return js_mknum((double)vm_stats.free_count * page_size);
304
+
return js_mknum((double)vm_stats.free_count * (double)page_size);
305
305
}
306
306
return js_mknum(0);
307
307
#elif defined(__linux__)
···
375
375
len = sizeof(freq);
376
376
if (sysctlbyname("hw.cpufrequency", &freq, &len, NULL, 0) != 0)
377
377
freq = 2400000000;
378
-
double speed = freq / 1000000.0;
378
+
double speed = (double)freq / 1000000.0;
379
379
380
380
processor_cpu_load_info_data_t *load = (processor_cpu_load_info_data_t *)cpu_info;
381
381
+2
-2
src/modules/readline.c
+2
-2
src/modules/readline.c
···
258
258
const char *hist_line = rl_history_prev(&iface->history);
259
259
if (hist_line) {
260
260
strcpy(iface->line_buffer, hist_line);
261
-
iface->line_len = strlen(iface->line_buffer);
261
+
iface->line_len = (int)strlen(iface->line_buffer);
262
262
iface->line_pos = iface->line_len;
263
263
refresh_line(iface);
264
264
}
···
268
268
const char *hist_line = rl_history_next(&iface->history);
269
269
if (hist_line) {
270
270
strcpy(iface->line_buffer, hist_line);
271
-
iface->line_len = strlen(iface->line_buffer);
271
+
iface->line_len = (int)strlen(iface->line_buffer);
272
272
iface->line_pos = iface->line_len;
273
273
refresh_line(iface);
274
274
}
+5
-5
src/modules/server.c
+5
-5
src/modules/server.c
···
241
241
242
242
static int parse_http_request(const char *buffer, size_t len, http_request_t *req) {
243
243
const char *method_end = strchr(buffer, ' ');
244
-
if (!method_end || method_end - buffer >= sizeof(req->method)) return -1;
244
+
if (!method_end || (size_t)(method_end - buffer) >= sizeof(req->method)) return -1;
245
245
246
246
memcpy(req->method, buffer, method_end - buffer);
247
247
req->method[method_end - buffer] = '\0';
···
580
580
}
581
581
582
582
stream.next_in = (Bytef *)data;
583
-
stream.avail_in = data_len;
583
+
stream.avail_in = (uInt)data_len;
584
584
stream.next_out = (Bytef *)compressed;
585
-
stream.avail_out = bound;
585
+
stream.avail_out = (uInt)bound;
586
586
587
587
if (deflate(&stream, Z_FINISH) != Z_STREAM_END) {
588
588
free(compressed);
···
679
679
680
680
if (compressed) free(compressed);
681
681
682
-
write_req->buf = uv_buf_init(response, total_len);
682
+
write_req->buf = uv_buf_init(response, (unsigned int)total_len);
683
683
uv_write((uv_write_t *)write_req, client, &write_req->buf, 1, on_write);
684
684
}
685
685
···
821
821
client_t *client = (client_t *)stream->data;
822
822
823
823
if (nread < 0) {
824
-
if (nread != UV_EOF) fprintf(stderr, "Read error: %s\n", uv_strerror(nread));
824
+
if (nread != UV_EOF) fprintf(stderr, "Read error: %s\n", uv_strerror((int)nread));
825
825
uv_close((uv_handle_t *)stream, on_close);
826
826
free(buf->base);
827
827
return;
+2
-2
src/repl.c
+2
-2
src/repl.c
···
287
287
static void line_set(char *line, int *pos, int *len, const char *str, const char *prompt) {
288
288
printf("\r\033[K%s%s", prompt, str);
289
289
fflush(stdout); strcpy(line, str);
290
-
*len = strlen(line); *pos = *len;
290
+
*len = (int)strlen(line); *pos = *len;
291
291
}
292
292
293
293
static void line_backspace(char *line, int *pos, int *len) {
···
304
304
if (*len >= MAX_LINE_LENGTH - 1) return;
305
305
306
306
memmove(line + *pos + 1, line + *pos, *len - *pos + 1);
307
-
line[*pos] = c;
307
+
line[*pos] = (char)c;
308
308
(*pos)++; (*len)++;
309
309
printf("%c%s", c, line + *pos);
310
310
for (int i = 0; i < *len - *pos; i++) printf("\033[D");