Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641
  1. #include "vm/vm.h"
  2. #include <string.h>
  3. #include <stdio.h>
  4. #include <stdarg.h>
  5. #include "vm/builtins.h"
  6. static int stdio_inited = 0;
  7. static struct l2_io_file_writer std_output;
  8. static struct l2_io_file_writer std_error;
  9. static l2_word alloc_val(struct l2_vm *vm) {
  10. size_t id = l2_bitset_set_next(&vm->valueset);
  11. if (id + 16 >= vm->valuessize) {
  12. if (id >= vm->valuessize) {
  13. if (vm->valuessize == 0) {
  14. vm->valuessize = 64;
  15. }
  16. while (id >= vm->valuessize) {
  17. vm->valuessize *= 2;
  18. }
  19. vm->values = realloc(vm->values, sizeof(*vm->values) * vm->valuessize);
  20. } else {
  21. vm->gc_scheduled = 1;
  22. }
  23. }
  24. return (l2_word)id;
  25. }
  26. static double u32s_to_double(uint32_t high, uint32_t low) {
  27. double d;
  28. uint64_t num = (uint64_t)high << 32 | (uint64_t)low;
  29. memcpy(&d, &num, sizeof(num));
  30. return d;
  31. }
  32. static void gc_mark_array(struct l2_vm *vm, struct l2_vm_value *val);
  33. static void gc_mark_namespace(struct l2_vm *vm, struct l2_vm_value *val);
  34. static void gc_mark(struct l2_vm *vm, l2_word id) {
  35. struct l2_vm_value *val = &vm->values[id];
  36. if (val->flags & L2_VAL_MARKED) {
  37. return;
  38. }
  39. val->flags |= L2_VAL_MARKED;
  40. int typ = l2_vm_value_type(val);
  41. if (typ == L2_VAL_TYPE_ARRAY) {
  42. gc_mark_array(vm, val);
  43. } else if (typ == L2_VAL_TYPE_NAMESPACE) {
  44. gc_mark_namespace(vm, val);
  45. } else if (typ == L2_VAL_TYPE_FUNCTION) {
  46. gc_mark(vm, val->func.ns);
  47. }
  48. }
  49. static void gc_mark_array(struct l2_vm *vm, struct l2_vm_value *val) {
  50. if (val->array == NULL) {
  51. return;
  52. }
  53. for (size_t i = 0; i < val->array->len; ++i) {
  54. gc_mark(vm, val->array->data[i]);
  55. }
  56. }
  57. static void gc_mark_namespace(struct l2_vm *vm, struct l2_vm_value *val) {
  58. if (val->extra.ns_parent != 0) {
  59. gc_mark(vm, val->extra.ns_parent);
  60. }
  61. if (val->ns == NULL) {
  62. return;
  63. }
  64. for (size_t i = 0; i < val->ns->size; ++i) {
  65. l2_word key = val->ns->data[i];
  66. if (key == 0 || key == ~(l2_word)0) {
  67. continue;
  68. }
  69. gc_mark(vm, val->ns->data[val->ns->size + i]);
  70. }
  71. }
  72. static void gc_free(struct l2_vm *vm, l2_word id) {
  73. struct l2_vm_value *val = &vm->values[id];
  74. l2_bitset_unset(&vm->valueset, id);
  75. // Don't need to do anything more; the next round of GC will free
  76. // whichever values were only referenced by the array
  77. int typ = l2_vm_value_type(val);
  78. if (typ == L2_VAL_TYPE_ARRAY) {
  79. free(val->array);
  80. } else if (typ == L2_VAL_TYPE_BUFFER) {
  81. free(val->buffer);
  82. } else if (typ == L2_VAL_TYPE_NAMESPACE) {
  83. free(val->ns);
  84. } else if (typ == L2_VAL_TYPE_ERROR) {
  85. free(val->error);
  86. }
  87. }
  88. static size_t gc_sweep(struct l2_vm *vm) {
  89. size_t freed = 0;
  90. for (size_t i = vm->gc_start; i < vm->valuessize; ++i) {
  91. if (!l2_bitset_get(&vm->valueset, i)) {
  92. continue;
  93. }
  94. struct l2_vm_value *val = &vm->values[i];
  95. if (!(val->flags & L2_VAL_MARKED)) {
  96. l2_bitset_unset(&vm->valueset, i);
  97. gc_free(vm, i);
  98. freed += 1;
  99. } else {
  100. val->flags &= ~L2_VAL_MARKED;
  101. }
  102. }
  103. return freed;
  104. }
  105. const char *l2_value_type_name(enum l2_value_type typ) {
  106. switch (typ) {
  107. case L2_VAL_TYPE_NONE: return "NONE";
  108. case L2_VAL_TYPE_ATOM: return "ATOM";
  109. case L2_VAL_TYPE_REAL: return "REAL";
  110. case L2_VAL_TYPE_BUFFER: return "BUFFER";
  111. case L2_VAL_TYPE_ARRAY: return "ARRAY";
  112. case L2_VAL_TYPE_NAMESPACE: return "NAMESPACE";
  113. case L2_VAL_TYPE_FUNCTION: return "FUNCTION";
  114. case L2_VAL_TYPE_CFUNCTION: return "CFUNCTION";
  115. case L2_VAL_TYPE_ERROR: return "ERROR";
  116. case L2_VAL_TYPE_CONTINUATION: return "CONTINUATION";
  117. }
  118. return "(unknown)";
  119. }
  120. void l2_vm_init(struct l2_vm *vm, l2_word *ops, size_t opcount) {
  121. if (!stdio_inited) {
  122. std_output.w.write = l2_io_file_write;
  123. std_output.f = stdout;
  124. std_error.w.write = l2_io_file_write;
  125. std_error.f = stderr;
  126. stdio_inited = 1;
  127. }
  128. vm->std_output = &std_output.w;
  129. vm->std_error = &std_error.w;
  130. vm->halted = 0;
  131. vm->gc_scheduled = 0;
  132. vm->ops = ops;
  133. vm->opcount = opcount;
  134. vm->iptr = 0;
  135. vm->sptr = 0;
  136. vm->fsptr = 0;
  137. vm->values = NULL;
  138. vm->valuessize = 0;
  139. l2_bitset_init(&vm->valueset);
  140. // It's wasteful to allocate new 'none' variables all the time,
  141. // variable ID 0 should be the only 'none' variable in the system
  142. l2_word none_id = alloc_val(vm);
  143. vm->values[none_id].flags = L2_VAL_TYPE_NONE | L2_VAL_CONST;
  144. // Need to allocate a builtins namespace
  145. l2_word builtins = alloc_val(vm);
  146. vm->values[builtins].extra.ns_parent = 0;
  147. vm->values[builtins].ns = NULL; // Will be allocated on first insert
  148. vm->values[builtins].flags = L2_VAL_TYPE_NAMESPACE;
  149. vm->fstack[vm->fsptr].ns = builtins;
  150. vm->fstack[vm->fsptr].retptr = 0;
  151. vm->fsptr += 1;
  152. // Need to allocate a root namespace
  153. l2_word root = alloc_val(vm);
  154. vm->values[root].extra.ns_parent = builtins;
  155. vm->values[root].ns = NULL;
  156. vm->values[root].flags = L2_VAL_TYPE_NAMESPACE;
  157. vm->fstack[vm->fsptr].ns = root;
  158. vm->fstack[vm->fsptr].retptr = 0;
  159. vm->fsptr += 1;
  160. // Define a C function variable for every builtin
  161. l2_word id;
  162. l2_word key = 1;
  163. #define Y(name, k) \
  164. if (strcmp(#k, "knone") == 0) { \
  165. id = 0; \
  166. l2_vm_namespace_set(&vm->values[builtins], key, id); \
  167. } else { \
  168. id = alloc_val(vm); \
  169. vm->values[id].flags = L2_VAL_TYPE_ATOM | L2_VAL_CONST; \
  170. vm->values[id].atom = key; \
  171. } \
  172. vm->k = id; \
  173. key += 1;
  174. #define X(name, f) \
  175. id = alloc_val(vm); \
  176. vm->values[id].flags = L2_VAL_TYPE_CFUNCTION | L2_VAL_CONST; \
  177. vm->values[id].cfunc = f; \
  178. l2_vm_namespace_set(&vm->values[builtins], key++, id);
  179. #include "builtins.x.h"
  180. #undef Y
  181. #undef X
  182. vm->gc_start = id + 1;
  183. }
  184. l2_word l2_vm_alloc(struct l2_vm *vm, enum l2_value_type typ, enum l2_value_flags flags) {
  185. l2_word id = alloc_val(vm);
  186. memset(&vm->values[id], 0, sizeof(vm->values[id]));
  187. vm->values[id].flags = typ | flags;
  188. return id;
  189. }
  190. l2_word l2_vm_error(struct l2_vm *vm, const char *fmt, ...) {
  191. l2_word id = alloc_val(vm);
  192. struct l2_vm_value *val = &vm->values[id];
  193. val->flags = L2_VAL_CONST | L2_VAL_TYPE_ERROR;
  194. char buf[256];
  195. va_list va;
  196. va_start(va, fmt);
  197. int n = vsnprintf(buf, sizeof(buf), fmt, va);
  198. if (n < 0) {
  199. const char *message = "Failed to generate error message!";
  200. val->error = malloc(strlen(message) + 1);
  201. strcpy(val->error, message);
  202. va_end(va);
  203. return id;
  204. } else if ((size_t)n + 1 < sizeof(buf)) {
  205. val->error = malloc(n + 1);
  206. strcpy(val->error, buf);
  207. va_end(va);
  208. return id;
  209. }
  210. val->error = malloc(n + 1);
  211. vsnprintf(val->error, n + 1, fmt, va);
  212. va_end(va);
  213. return id;
  214. }
  215. l2_word l2_vm_type_error(struct l2_vm *vm, struct l2_vm_value *val) {
  216. return l2_vm_error(vm, "Unexpected type %s", l2_value_type_name(l2_vm_value_type(val)));
  217. }
  218. void l2_vm_free(struct l2_vm *vm) {
  219. // Skip ID 0, because that's always NONE
  220. for (size_t i = 1; i < vm->valuessize; ++i) {
  221. if (!l2_bitset_get(&vm->valueset, i)) {
  222. continue;
  223. }
  224. gc_free(vm, i);
  225. }
  226. free(vm->values);
  227. l2_bitset_free(&vm->valueset);
  228. }
  229. size_t l2_vm_gc(struct l2_vm *vm) {
  230. for (l2_word sptr = 0; sptr < vm->sptr; ++sptr) {
  231. gc_mark(vm, vm->stack[sptr]);
  232. }
  233. for (l2_word fsptr = 0; fsptr < vm->fsptr; ++fsptr) {
  234. gc_mark(vm, vm->fstack[fsptr].ns);
  235. }
  236. return gc_sweep(vm);
  237. }
  238. void l2_vm_run(struct l2_vm *vm) {
  239. while (!vm->halted) {
  240. l2_vm_step(vm);
  241. }
  242. }
  243. // The 'call_func' function assumes that all relevant values have been popped off
  244. // the stack, so that the return value can be pushed to the top of the stack
  245. // straight away
  246. static void call_func(
  247. struct l2_vm *vm, l2_word func_id,
  248. l2_word argc, l2_word *argv) {
  249. l2_word stack_base = vm->sptr;
  250. struct l2_vm_value *func = &vm->values[func_id];
  251. enum l2_value_type typ = l2_vm_value_type(func);
  252. // C functions are called differently from language functions
  253. if (typ == L2_VAL_TYPE_CFUNCTION) {
  254. // Make this a while loop, because using call_func would
  255. // make the call stack depth unbounded
  256. vm->stack[vm->sptr++] = func->cfunc(vm, argc, argv);
  257. while (1) {
  258. struct l2_vm_value *val = &vm->values[vm->stack[vm->sptr - 1]];
  259. if (l2_vm_value_type(val) != L2_VAL_TYPE_CONTINUATION) {
  260. break;
  261. }
  262. l2_word cont_id = val->cont.call;
  263. struct l2_vm_value *cont = &vm->values[cont_id];
  264. l2_word new_argc;
  265. l2_word new_argv[1];
  266. if (val->cont.arg == 0) {
  267. new_argc = 0;
  268. } else {
  269. new_argc = 1;
  270. new_argv[0] = val->cont.arg;
  271. }
  272. if (l2_vm_value_type(cont) == L2_VAL_TYPE_CFUNCTION) {
  273. vm->stack[vm->sptr - 1] = cont->cfunc(vm, new_argc, new_argv);
  274. } else {
  275. vm->sptr -= 1;
  276. call_func(vm, cont_id, new_argc, new_argv);
  277. break;
  278. }
  279. }
  280. return;
  281. }
  282. // Don't interpret a non-function as a function
  283. if (typ != L2_VAL_TYPE_FUNCTION) {
  284. vm->stack[vm->sptr++] = l2_vm_error(vm, "Attempt to call non-function");
  285. return;
  286. }
  287. l2_word arr_id = alloc_val(vm);
  288. vm->values[arr_id].flags = L2_VAL_TYPE_ARRAY;
  289. vm->values[arr_id].array = malloc(
  290. sizeof(struct l2_vm_array) + sizeof(l2_word) * argc);
  291. struct l2_vm_array *arr = vm->values[arr_id].array;
  292. arr->len = argc;
  293. arr->size = argc;
  294. for (l2_word i = 0; i < argc; ++i) {
  295. arr->data[i] = argv[i];
  296. }
  297. vm->stack[vm->sptr++] = arr_id;
  298. l2_word ns_id = alloc_val(vm);
  299. func = &vm->values[func_id]; // func might be stale after alloc
  300. vm->values[ns_id].extra.ns_parent = func->func.ns;
  301. vm->values[ns_id].ns = NULL;
  302. vm->values[ns_id].flags = L2_VAL_TYPE_NAMESPACE;
  303. vm->fstack[vm->fsptr].ns = ns_id;
  304. vm->fstack[vm->fsptr].retptr = vm->iptr;
  305. vm->fstack[vm->fsptr].sptr = stack_base;
  306. vm->fsptr += 1;
  307. vm->iptr = func->func.pos;
  308. }
  309. void l2_vm_step(struct l2_vm *vm) {
  310. enum l2_opcode opcode = (enum l2_opcode)vm->ops[vm->iptr++];
  311. l2_word word;
  312. switch (opcode) {
  313. case L2_OP_NOP:
  314. break;
  315. case L2_OP_DISCARD:
  316. vm->sptr -= 1;
  317. if (l2_vm_value_type(&vm->values[vm->stack[vm->sptr]]) == L2_VAL_TYPE_ERROR) {
  318. l2_io_printf(vm->std_error, "Error: %s\n", vm->values[vm->stack[vm->sptr]].error);
  319. vm->halted = 1;
  320. }
  321. break;
  322. case L2_OP_SWAP_DISCARD:
  323. vm->stack[vm->sptr - 2] = vm->stack[vm->sptr - 1];
  324. vm->sptr -= 1;
  325. if (l2_vm_value_type(&vm->values[vm->stack[vm->sptr]]) == L2_VAL_TYPE_ERROR) {
  326. l2_io_printf(vm->std_error, "Error: %s\n", vm->values[vm->stack[vm->sptr]].error);
  327. vm->halted = 1;
  328. }
  329. break;
  330. case L2_OP_DUP:
  331. vm->stack[vm->sptr] = vm->ops[vm->sptr - 1];
  332. vm->sptr += 1;
  333. break;
  334. case L2_OP_ADD:
  335. vm->stack[vm->sptr - 2] += vm->stack[vm->sptr - 1];
  336. vm->sptr -= 1;
  337. break;
  338. case L2_OP_FUNC_CALL:
  339. {
  340. l2_word argc = vm->ops[vm->iptr++];
  341. vm->sptr -= argc;
  342. l2_word *argv = vm->stack + vm->sptr;
  343. l2_word func_id = vm->stack[--vm->sptr];
  344. call_func(vm, func_id, argc, argv);
  345. }
  346. break;
  347. case L2_OP_RJMP:
  348. vm->iptr += vm->ops[vm->iptr] + 1;
  349. break;
  350. case L2_OP_STACK_FRAME_LOOKUP:
  351. {
  352. l2_word key = vm->ops[vm->iptr++];
  353. struct l2_vm_value *ns = &vm->values[vm->fstack[vm->fsptr - 1].ns];
  354. vm->stack[vm->sptr++] = l2_vm_namespace_get(vm, ns, key);
  355. }
  356. break;
  357. case L2_OP_STACK_FRAME_SET:
  358. {
  359. l2_word key = vm->ops[vm->iptr++];
  360. l2_word val = vm->stack[vm->sptr - 1];
  361. struct l2_vm_value *ns = &vm->values[vm->fstack[vm->fsptr - 1].ns];
  362. l2_vm_namespace_set(ns, key, val);
  363. }
  364. break;
  365. case L2_OP_STACK_FRAME_REPLACE:
  366. {
  367. l2_word key = vm->ops[vm->iptr++];
  368. l2_word val = vm->stack[vm->sptr - 1];
  369. struct l2_vm_value *ns = &vm->values[vm->fstack[vm->fsptr - 1].ns];
  370. l2_vm_namespace_replace(vm, ns, key, val); // TODO: error if returns -1
  371. }
  372. break;
  373. case L2_OP_RET:
  374. {
  375. l2_word retval = vm->stack[--vm->sptr];
  376. l2_word retptr = vm->fstack[vm->fsptr - 1].retptr;
  377. l2_word sptr = vm->fstack[vm->fsptr - 1].sptr;
  378. vm->fsptr -= 1;
  379. vm->sptr = sptr;
  380. vm->stack[vm->sptr++] = retval;
  381. vm->iptr = retptr;
  382. }
  383. break;
  384. case L2_OP_ALLOC_NONE:
  385. vm->stack[vm->sptr++] = 0;
  386. break;
  387. case L2_OP_ALLOC_ATOM:
  388. word = alloc_val(vm);
  389. vm->values[word].flags = L2_VAL_TYPE_ATOM;
  390. vm->values[word].atom = vm->ops[vm->iptr++];
  391. vm->stack[vm->sptr++] = word;
  392. break;
  393. case L2_OP_ALLOC_REAL:
  394. {
  395. word = alloc_val(vm);
  396. l2_word high = vm->ops[vm->iptr++];
  397. l2_word low = vm->ops[vm->iptr++];
  398. vm->values[word].flags = L2_VAL_TYPE_REAL;
  399. vm->values[word].real = u32s_to_double(high, low);
  400. vm->stack[vm->sptr++] = word;
  401. }
  402. break;
  403. case L2_OP_ALLOC_BUFFER_STATIC:
  404. {
  405. word = alloc_val(vm);
  406. l2_word length = vm->ops[vm->iptr++];
  407. l2_word offset = vm->ops[vm->iptr++];
  408. vm->values[word].flags = L2_VAL_TYPE_BUFFER;
  409. vm->values[word].buffer = malloc(sizeof(struct l2_vm_buffer) + length);
  410. vm->values[word].buffer->len = length;
  411. memcpy(
  412. (unsigned char *)vm->values[word].buffer + sizeof(struct l2_vm_buffer),
  413. vm->ops + offset, length);
  414. vm->stack[vm->sptr] = word;
  415. vm->sptr += 1;
  416. }
  417. break;
  418. case L2_OP_ALLOC_ARRAY:
  419. {
  420. l2_word count = vm->ops[vm->iptr++];
  421. l2_word arr_id = alloc_val(vm);
  422. struct l2_vm_value *arr = &vm->values[arr_id];
  423. arr->flags = L2_VAL_TYPE_ARRAY;
  424. if (count == 0) {
  425. arr->array = NULL;
  426. vm->stack[vm->sptr++] = arr_id;
  427. break;
  428. }
  429. arr->array = malloc(sizeof(struct l2_vm_array) + count * sizeof(l2_word));
  430. arr->array->len = count;
  431. arr->array->size = count;
  432. for (l2_word i = 0; i < count; ++i) {
  433. arr->array->data[count - 1 - i] = vm->stack[--vm->sptr];
  434. }
  435. vm->stack[vm->sptr++] = arr_id;
  436. }
  437. break;
  438. case L2_OP_ALLOC_NAMESPACE:
  439. word = alloc_val(vm);
  440. vm->values[word].flags = L2_VAL_TYPE_NAMESPACE;
  441. vm->values[word].extra.ns_parent = 0;
  442. vm->values[word].ns = NULL; // Will be allocated on first insert
  443. vm->stack[vm->sptr] = word;
  444. vm->sptr += 1;
  445. break;
  446. case L2_OP_ALLOC_FUNCTION:
  447. word = alloc_val(vm);
  448. vm->values[word].flags = L2_VAL_TYPE_FUNCTION;
  449. vm->values[word].func.pos = vm->ops[vm->iptr++];
  450. vm->values[word].func.ns = vm->fstack[vm->fsptr - 1].ns;
  451. vm->stack[vm->sptr] = word;
  452. vm->sptr += 1;
  453. break;
  454. case L2_OP_NAMESPACE_SET:
  455. {
  456. l2_word key = vm->ops[vm->iptr++];
  457. l2_word val = vm->stack[vm->sptr - 1];
  458. l2_word ns = vm->stack[vm->sptr - 2];
  459. l2_vm_namespace_set(&vm->values[ns], key, val);
  460. }
  461. break;
  462. case L2_OP_NAMESPACE_LOOKUP:
  463. {
  464. l2_word key = vm->ops[vm->iptr++];
  465. l2_word ns = vm->stack[--vm->sptr];
  466. vm->stack[vm->sptr++] = l2_vm_namespace_get(vm, &vm->values[ns], key);
  467. }
  468. break;
  469. case L2_OP_ARRAY_LOOKUP:
  470. {
  471. l2_word key = vm->ops[vm->iptr++];
  472. l2_word arr = vm->stack[--vm->sptr];
  473. // TODO: Error if out of bounds or incorrect type
  474. vm->stack[vm->sptr++] = vm->values[arr].array->data[key];
  475. }
  476. break;
  477. case L2_OP_ARRAY_SET:
  478. {
  479. l2_word key = vm->ops[vm->iptr++];
  480. l2_word val = vm->stack[vm->sptr - 1];
  481. l2_word arr = vm->stack[vm->sptr - 2];
  482. // TODO: Error if out of bounds or incorrect type
  483. vm->values[arr].array->data[key] = val;
  484. }
  485. break;
  486. case L2_OP_DYNAMIC_LOOKUP:
  487. {
  488. l2_word key_id = vm->stack[--vm->sptr];
  489. l2_word container_id = vm->stack[--vm->sptr];
  490. struct l2_vm_value *key = &vm->values[key_id];
  491. struct l2_vm_value *container = &vm->values[container_id];
  492. if (
  493. l2_vm_value_type(key) == L2_VAL_TYPE_REAL &&
  494. l2_vm_value_type(container) == L2_VAL_TYPE_ARRAY) {
  495. // TODO: Error if out of bounds
  496. vm->stack[vm->sptr++] = container->array->data[(size_t)key->real];
  497. } else if (
  498. l2_vm_value_type(key) == L2_VAL_TYPE_ATOM &&
  499. l2_vm_value_type(container) == L2_VAL_TYPE_NAMESPACE) {
  500. // TODO: Error if out of bounds
  501. vm->stack[vm->sptr++] = l2_vm_namespace_get(vm, container, key->atom);
  502. } else {
  503. // TODO: error
  504. }
  505. }
  506. break;
  507. case L2_OP_DYNAMIC_SET:
  508. {
  509. l2_word val = vm->stack[--vm->sptr];
  510. l2_word key_id = vm->stack[--vm->sptr];
  511. l2_word container_id = vm->stack[--vm->sptr];
  512. vm->stack[vm->sptr++] = val;
  513. struct l2_vm_value *key = &vm->values[key_id];
  514. struct l2_vm_value *container = &vm->values[container_id];
  515. if (
  516. l2_vm_value_type(key) == L2_VAL_TYPE_REAL &&
  517. l2_vm_value_type(container) == L2_VAL_TYPE_ARRAY) {
  518. // TODO: Error if out of bounds
  519. container->array->data[(size_t)key->real] = val;
  520. } else if (
  521. l2_vm_value_type(key) == L2_VAL_TYPE_ATOM &&
  522. l2_vm_value_type(container) == L2_VAL_TYPE_NAMESPACE) {
  523. // TODO: Error if out of bounds
  524. l2_vm_namespace_set(container, key->atom, val);
  525. } else {
  526. // TODO: error
  527. }
  528. }
  529. break;
  530. case L2_OP_FUNC_CALL_INFIX:
  531. {
  532. l2_word rhs = vm->stack[--vm->sptr];
  533. l2_word func_id = vm->stack[--vm->sptr];
  534. l2_word lhs = vm->stack[--vm->sptr];
  535. l2_word argv[] = {lhs, rhs};
  536. call_func(vm, func_id, 2, argv);
  537. }
  538. break;
  539. case L2_OP_HALT:
  540. vm->halted = 1;
  541. break;
  542. }
  543. if (vm->gc_scheduled) {
  544. l2_vm_gc(vm);
  545. vm->gc_scheduled = 0;
  546. }
  547. }