home
readme
diff
tree
note
docs
0commit 4ea9dca8a0764b68a61599b21e625b852c01bdb5
1Author: lakefox <mason@lakefox.net>
2Date: Wed Mar 18 20:11:38 2026 -0600
3
4 Fixed some issues working on full testing
5
6diff --git a/Makefile b/Makefile
7index a1e11cb..6050f75 100755
8--- a/Makefile
9+++ b/Makefile
10@@ -1,6 +1,6 @@
11 # --- Variables ---
12-#CCFLAGS = -std=c23 -O3
13-CCFLAGS = -Wall -Wextra -std=c23 -g -O0 -fsanitize=address,undefined -fno-omit-frame-pointer
14+#CCFLAGS = -std=c23 -O3 -lm
15+CCFLAGS = -Wall -Wextra -std=c23 -g -O0 -fsanitize=address,undefined -fno-omit-frame-pointer -lm
16 CC = clang
17
18 .PHONY: all clean all_tests
19diff --git a/accounts b/accounts
20deleted file mode 100644
21index a639064..0000000
22--- a/accounts
23+++ /dev/null
24@@ -1,2 +0,0 @@
25-# Replace with your actual SIP details
26-<sip:lakefox@localhost>;medianat=ice
27diff --git a/include/grim.h b/include/grim.h
28index 3cb8510..69756a2 100755
29--- a/include/grim.h
30+++ b/include/grim.h
31@@ -127,6 +127,7 @@ struct Slot {
32 struct Unit* data;
33 int length;
34 int capacity;
35+ struct Unit value;
36 };
37
38 typedef struct {
39@@ -199,6 +200,8 @@ void ADD_CLASS(Node* n, char* value);
40
41 void get_unit(struct Unit** units, int* cap, int* units_len, char** vars, int* vars_len, int* vars_cap, int* stack_len, int* max_register_size, char* value);
42
43-float unit_value(struct Slot stack[], int stack_size, int register_size, struct Unit* units, int units_len);
44+float unit_value(struct Slot stack[], int stack_size, int register_size, struct Unit* gnits, int units_len);
45+
46+void ADD_STACK_VALUE(struct Slot stack[], int index, struct Unit* units, int units_len);
47
48 #endif // NODE_H
49diff --git a/playground/unit_value.c b/playground/unit_value.c
50index f86853e..251b03c 100644
51--- a/playground/unit_value.c
52+++ b/playground/unit_value.c
53@@ -13,13 +13,52 @@ void benchmark_unit_value(char* value) {
54
55 int iterations = 10000;
56
57+ int cap = 10;
58+ struct Unit *units = malloc(sizeof(struct Unit) * cap);
59+ int units_len = 0;
60+
61+ int vars_cap = 0;
62+ char **vars = NULL;
63+ int vars_len = 0;
64+
65+ int stack_len = 4;
66+ int max_register_size = 0;
67+
68+ get_unit(&units, &cap, &units_len, &vars, &vars_len, &vars_cap, &stack_len, &max_register_size, value);
69+
70+ if (stack_len < 1) {
71+ stack_len = 1;
72+ }
73+
74+ struct Slot stack[stack_len];
75+ memset(stack, 0, sizeof(stack));
76+
77+ ADD_STACK_VALUE(&stack, 0, (struct Unit[]){{NUMBER, 1920}}, 1);
78+ ADD_STACK_VALUE(&stack, 1, (struct Unit[]){{NUMBER, 1080}}, 1);
79+ ADD_STACK_VALUE(&stack, 2, (struct Unit[]){{NUMBER, 16}}, 1);
80+ ADD_STACK_VALUE(&stack, 3, (struct Unit[]){{NUMBER, 192}}, 1);
81+
82+ double v;
83+
84 // Get start time
85 clock_gettime(CLOCK_MONOTONIC, &start);
86
87+ for (int i = 0; i < iterations; i++) {
88+ v += (double)unit_value(&stack, stack_len, max_register_size, units, units_len);
89+ }
90
91 // Get end time
92 clock_gettime(CLOCK_MONOTONIC, &end);
93
94+ printf("Benchmark Collector: %f\n", v);
95+
96+ free(units);
97+ free(vars);
98+ for (int i = 0; i < stack_len; i++) {
99+ free(stack[i].data);
100+ }
101+
102+
103 // Calculate time difference in seconds
104 double total_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
105 printf("Average execution time: %.9f seconds (%f us)\n",
106@@ -27,7 +66,46 @@ void benchmark_unit_value(char* value) {
107 (total_time / iterations) * 1000000);
108 }
109
110-void test_unit_value(char* ustr, struct Unit* known_units, int known_units_len, int stack_size, int known_register_size) {
111+void test_unit_value(char* ustr, float value) {
112+ int cap = 10;
113+ struct Unit *units = malloc(sizeof(struct Unit) * cap);
114+ int units_len = 0;
115+
116+ int vars_cap = 0;
117+ char **vars = NULL;
118+ int vars_len = 0;
119+
120+ int stack_len = 4;
121+ int max_register_size = 0;
122+
123+ get_unit(&units, &cap, &units_len, &vars, &vars_len, &vars_cap, &stack_len, &max_register_size, ustr);
124+
125+ if (stack_len < 1) {
126+ stack_len = 1;
127+ }
128+
129+ struct Slot stack[stack_len];
130+ memset(stack, 0, sizeof(stack));
131+
132+ ADD_STACK_VALUE(&stack, 0, (struct Unit[]){{NUMBER, 1920}}, 1);
133+ ADD_STACK_VALUE(&stack, 1, (struct Unit[]){{NUMBER, 1080}}, 1);
134+ ADD_STACK_VALUE(&stack, 2, (struct Unit[]){{NUMBER, 16}}, 1);
135+ ADD_STACK_VALUE(&stack, 3, (struct Unit[]){{NUMBER, 192}}, 1);
136+
137+ float v = unit_value(&stack, stack_len, max_register_size, units, units_len);
138+
139+ if (v != value) {
140+ printf("FAILED test \"%s\" with value: %f (Expected: %f)\n", ustr, v, value);
141+ } else {
142+ printf("PASSED test \"%s\"\n", ustr);
143+ }
144+
145+ free(units);
146+ free(vars);
147+ for (int i = 0; i < stack_len; i++) {
148+ free(stack[i].data);
149+ }
150+
151 }
152
153 int main() {
154@@ -42,16 +120,26 @@ int main() {
155 int stack_len = 0;
156 int max_register_size = 0;
157
158- char* ustr = "max(10 1)";
159+ char* ustr = "let(x 10px 20px 30px) set(at(x 1) 90px) if(at(x 1) != 90px, 1 + 1, 5 + 5)";
160
161 get_unit(&units, &cap, &units_len, &vars, &vars_len, &vars_cap, &stack_len, &max_register_size, ustr);
162
163 printf("Stack Size: %d Registers: %d Unit Length: %d\n", stack_len, max_register_size, units_len);
164
165- struct Slot stack[stack_len || 1];
166+ if (stack_len < 1) {
167+ stack_len = 1;
168+ }
169+
170+ struct Slot stack[stack_len];
171+ memset(stack, 0, sizeof(stack));
172
173 float v = unit_value(&stack, stack_len, max_register_size, units, units_len);
174
175+ for (int i = 0; i < stack_len; i++) {
176+ free(stack[i].data);
177+ }
178+
179+
180 printf("Value: %f\n", v);
181
182 free(units);
183@@ -60,5 +148,23 @@ int main() {
184 if (true) {
185 //benchmark_unit_value(ustr);
186
187+ test_unit_value("1 + 1", 2);
188+ test_unit_value("pow(10 2)", 100);
189+ test_unit_value("let(x 10) pow(x 2)", 100);
190+ test_unit_value("let(x 10) set(x (x * 15)) pow(x 2)", 22500);
191+ test_unit_value("10 == 10", 1);
192+ test_unit_value("10 != 10", 0);
193+ test_unit_value("true and 10", 1);
194+ test_unit_value("true or not 10", 1);
195+ test_unit_value("calc(10px + 100vw)", 1930);
196+ test_unit_value("(let(x 10px) set(x 30px) (let(x 50px)) x == 30)", 1);
197+ test_unit_value("(let(x 10px 20px 30px) length(x) == 3)", 1);
198+ test_unit_value("(let(x 10px 20px 30px) capacity(x) == 3)", 1);
199+ test_unit_value("min(1 10) + 10 == 11", 1);
200+ test_unit_value("let(x 10px 20px 30px) set(at(x 1) 90px) at(x 1) == 90px", 1);
201+ test_unit_value("let(x 10px 20px 30px) set(at(x 1) 90px) if(at(x 1) != 90px, 1 + 1, 5 + 5)", 5);
202+ test_unit_value("let(x 10px 20px 30px) set(at(x 1) 90px) if(at(x 1) == 90px, 1 + 1)", 1);
203+
204+ // cases for all rel units and every function
205 }
206 }
207diff --git a/src/grim.c b/src/grim.c
208index 93b92fd..89aab68 100755
209--- a/src/grim.c
210+++ b/src/grim.c
211@@ -434,17 +434,50 @@ std::vector<std::string> parseNodeParts(Node* node) {
212 // HEAP: [width, height, em, dpi]
213 // HEAP LAYOUT: VAR
214
215+void ADD_STACK_VALUE(struct Slot stack[], int index, struct Unit* units, int units_len) {
216+ if (units_len == 1) {
217+ stack[index].length = 1;
218+ stack[index].capacity = 0;
219+ stack[index].value = units[0];
220+ } else {
221+ if (stack[index].capacity < units_len || stack[index].capacity/2 > units_len) {
222+ if (stack[index].capacity > 0) {
223+ free(stack[index].data);
224+ }
225+ stack[index].data = malloc(units_len * sizeof(struct Unit));
226+ stack[index].capacity = units_len;
227+ }
228+
229+ stack[index].length = 0;
230+
231+ for (int j = 0; j < units_len; j++) {
232+ if (units[j].type != FREE) {
233+ stack[index].length++;
234+ stack[index].data[j] = units[j];
235+ }
236+ }
237+ }
238+}
239+
240 float unit_value(struct Slot stack[], int stack_size, int register_size, struct Unit* units, int units_len) {
241 struct Unit registers[register_size];
242 int register_len = 0;
243
244 for (int i = 0; i < units_len; i++) {
245- printf("%d\n", i);
246 struct Unit unit = units[i];
247 UnitType type = unit.type;
248
249- int idx = (register_len-unit.value) || 0;
250- printf("IDX: %d Reg Len: %d Unit: %f\n", idx, register_len, unit.value);
251+ int idx = (register_len-(int)unit.value);
252+ if (idx < 0) idx = 0;
253+
254+/*
255+ printf("############ Frame: %d ##############\n", i);
256+ printf("IDX: %d UV: %f\n", idx, unit.value);
257+
258+ for (int j = 0; j < register_len; j++) {
259+ printf("R%d: %f\n", j, registers[j].value);
260+ }
261+*/
262
263 switch (type) {
264 // DEG, TURN are not length values but are treated as generic units (PX)
265@@ -499,19 +532,19 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
266 case RIC:
267 case RLH: {
268 registers[register_len].type = NUMBER;
269- registers[register_len++].value = unit.value*stack[2].data[0].value;
270+ registers[register_len++].value = unit.value*stack[2].value.value;
271 break;
272 }
273 case EX:
274 case REX: {
275 registers[register_len].type = NUMBER;
276- registers[register_len++].value = unit.value*(stack[2].data[0].value*0.5f);
277+ registers[register_len++].value = unit.value*(stack[2].value.value*0.5f);
278 break;
279 }
280 case CQH:
281 case VH: {
282 registers[register_len].type = NUMBER;
283- registers[register_len++].value = stack[1].data[0].value*(unit.value*0.01f);
284+ registers[register_len++].value = stack[1].value.value*(unit.value*0.01f);
285 break;
286 }
287 case CQW:
288@@ -520,7 +553,7 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
289 case PERCENT:
290 case VW: {
291 registers[register_len].type = NUMBER;
292- registers[register_len++].value = stack[0].data[0].value*(unit.value*0.01f);
293+ registers[register_len++].value = stack[0].value.value*(unit.value*0.01f);
294 break;
295 }
296 case VMAX:
297@@ -528,35 +561,32 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
298 registers[register_len].type = NUMBER;
299 // 0: width
300 // 1: height
301- if (stack[0].data[0].value > stack[1].data[0].value) {
302- registers[register_len++].value = unit.value*stack[0].data[0].value;
303+ if (stack[0].value.value > stack[1].value.value) {
304+ registers[register_len++].value = unit.value*stack[0].value.value;
305 } else {
306- registers[register_len++].value = unit.value*stack[1].data[0].value;
307+ registers[register_len++].value = unit.value*stack[1].value.value;
308 }
309 break;
310 }
311 case VMIN:
312 case CQMIN: {
313 registers[register_len].type = NUMBER;
314- if (stack[0].data[0].value < stack[1].data[0].value) {
315- registers[register_len++].value = unit.value*stack[0].data[0].value;
316+ if (stack[0].value.value < stack[1].value.value) {
317+ registers[register_len++].value = unit.value*stack[0].value.value;
318 } else {
319- registers[register_len++].value = unit.value*stack[1].data[0].value;
320+ registers[register_len++].value = unit.value*stack[1].value.value;
321 }
322 break;
323 }
324 case VB:
325 case VI: {
326 registers[register_len].type = NUMBER;
327- registers[register_len++].value = unit.value*stack[0].data[0].value;
328+ registers[register_len++].value = unit.value*stack[0].value.value;
329 break;
330 }
331 case CALC:
332 case GROUP: {
333- // Take the last computed value in the group and move it to the front
334- registers[idx] = registers[register_len];
335-
336- register_len = idx-(int)unit.value;
337+ // This literally does nothing because all values work towards the left side of the registers
338 break;
339 }
340 case MIN: {
341@@ -567,7 +597,7 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
342 registers[idx] = registers[j];
343 }
344 }
345- register_len = idx;
346+ register_len = idx + 1;
347 break;
348 }
349 case MAX: {
350@@ -578,7 +608,7 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
351 registers[idx] = registers[j];
352 }
353 }
354- register_len = idx;
355+ register_len = idx + 1;
356 break;
357 }
358 case CLAMP: {
359@@ -595,7 +625,7 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
360 }
361
362 registers[idx].type = NUMBER;
363- register_len = idx;
364+ register_len = idx + 1;
365 break;
366 }
367 case ROUND: {
368@@ -617,7 +647,7 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
369 }
370
371 registers[idx].type = NUMBER;
372- register_len = idx;
373+ register_len = idx + 1;
374 break;
375 }
376 case REMD:
377@@ -627,7 +657,7 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
378 }
379
380 registers[idx].type = NUMBER;
381- register_len = idx;
382+ register_len = idx + 1;
383 break;
384 }
385 case PROGRESS: {
386@@ -637,7 +667,7 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
387 }
388
389 registers[idx].type = NUMBER;
390- register_len = idx;
391+ register_len = idx + 1;
392 break;
393 }
394 case SIN: {
395@@ -676,16 +706,16 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
396 }
397
398 registers[idx].type = NUMBER;
399- register_len = idx;
400+ register_len = idx + 1;
401 break;
402 }
403 case POW: {
404 if (unit.value == 2) {
405- registers[idx].value = powf(registers[idx].value, registers[idx + 2].value);
406+ registers[idx].value = powf(registers[idx].value, registers[idx + 1].value);
407 }
408
409 registers[idx].type = NUMBER;
410- register_len = idx;
411+ register_len = idx + 1;
412 break;
413 }
414 case SQRT: {
415@@ -703,7 +733,7 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
416 registers[idx].value = sqrtf(v);
417
418 registers[idx].type = NUMBER;
419- register_len = idx;
420+ register_len = idx + 1;
421 break;
422 }
423 case LOG: {
424@@ -714,7 +744,7 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
425 }
426
427 registers[idx].type = NUMBER;
428- register_len = idx;
429+ register_len = idx + 1;
430 break;
431 }
432 case EXP: {
433@@ -750,7 +780,7 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
434 if (unit.value > 1) {
435 registers[idx].type = registers[idx + 1].type;
436 }
437- register_len = idx;
438+ register_len = idx + 1;
439 break;
440 }
441 case TYPE: {
442@@ -762,14 +792,16 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
443 registers[idx] = registers[idx + 1];
444 }
445 }
446- register_len = idx;
447+ register_len = idx + 1;
448 break;
449 }
450 case VAR: {
451- if (registers[idx].type == VAR) {
452- if (registers[idx].value > -1) {
453- if (stack[(int)registers[idx].value].length > 0) {
454- registers[register_len++] = stack[(int)registers[idx].value].data[0];
455+ if (unit.type == VAR) {
456+ if (unit.value > -1) {
457+ if (stack[(int)unit.value].length == 1) {
458+ registers[register_len++] = stack[(int)unit.value].value;
459+ } else if (stack[(int)unit.value].length > 1) {
460+ registers[register_len++] = stack[(int)unit.value].data[0];
461 } else {
462 registers[register_len++].type = NUMBER;
463 registers[register_len++].value = 0.0f;
464@@ -785,7 +817,28 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
465
466 }
467 case PRINT: {
468- printf("> %f", registers[idx].value);
469+ printf("> ");
470+ for (int j = idx; j < idx+(int)unit.value; j++) {
471+ if (registers[j].type == CHAR) {
472+ printf("%c", (char)registers[j].value);
473+ } else if (registers[j].type == BOOL) {
474+ if (registers[j].value == 0) {
475+ printf("false ");
476+ } else {
477+ printf("true ");
478+ }
479+ } else if (registers[j].type == HEX) {
480+ uint32_t u32;
481+ char hex[11];
482+ memcpy(&u32, ®isters[j].value, sizeof(u32));
483+ sprintf(hex, "0x%08x", u32);
484+ printf("%s ", hex);
485+ } else {
486+ printf("%f ", registers[j].value);
487+ }
488+ }
489+ printf("\n");
490+ register_len = idx;
491 break;
492 }
493 case JUMP: {
494@@ -809,42 +862,64 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
495 break;
496 }
497 case LET: {
498- if (stack[(int)registers[idx].value].capacity < unit.value || stack[(int)registers[idx].value].capacity/2 > unit.value) {
499- free(stack[(int)registers[idx].value].data);
500- stack[(int)registers[idx].value].data = malloc(unit.value * sizeof(struct Unit));
501- stack[(int)registers[idx].value].capacity = unit.value;
502- }
503+ if (registers[idx].value > -1) {
504+ if (unit.value == 2) {
505+ stack[(int)registers[idx].value].length = 1;
506+ stack[(int)registers[idx].value].capacity = 0;
507+ stack[(int)registers[idx].value].value = registers[idx + 1];
508+ } else {
509+ if (stack[(int)registers[idx].value].capacity < unit.value || stack[(int)registers[idx].value].capacity/2 > unit.value) {
510+ if (stack[(int)registers[idx].value].capacity > 0) {
511+ free(stack[(int)registers[idx].value].data);
512+ }
513+ stack[(int)registers[idx].value].data = malloc(unit.value * sizeof(struct Unit));
514+ stack[(int)registers[idx].value].capacity = unit.value - 1; // This includes the var def
515+ }
516
517- stack[(int)registers[idx].value].length = 0;
518+ stack[(int)registers[idx].value].length = 0;
519
520- for (int j = idx; j < idx+unit.value; j++) {
521- if (registers[j].type != FREE) {
522- stack[(int)registers[idx].value].length++;
523- stack[(int)registers[idx].value].data[j-idx] = registers[j];
524+ for (int j = idx+1; j < idx+(int)unit.value; j++) {
525+ if (registers[j].type != FREE) {
526+ stack[(int)registers[idx].value].length++;
527+ stack[(int)registers[idx].value].data[(j-1)-idx] = registers[j];
528+ }
529+ }
530 }
531 }
532 register_len = idx;
533 break;
534 }
535 case SET: {
536- if (unit.value == 3) {
537- // AT
538- if (stack[(int)registers[idx].value].capacity >= registers[idx+1].value) {
539- stack[(int)registers[idx].value].data[(int)registers[idx + 1].value] = registers[idx + 2];
540+ if (registers[idx].value > -1) {
541+ if (unit.value == 3) {
542+ if (stack[(int)registers[idx].value].length == 1) {
543+ if (stack[(int)registers[idx].value].capacity > 0) {
544+ free(stack[(int)registers[idx].value].data);
545+ }
546+ stack[(int)registers[idx].value].data = malloc((int)registers[idx + 1].value * sizeof(struct Unit));
547+ stack[(int)registers[idx].value].capacity = (int)registers[idx + 1].value;
548+ stack[(int)registers[idx].value].data[0] = stack[(int)registers[idx].value].value; // Add the prevous value
549+ }
550+ // AT
551+ if (stack[(int)registers[idx].value].capacity >= registers[idx+1].value) {
552+ stack[(int)registers[idx].value].data[(int)registers[idx + 1].value] = registers[idx + 2];
553+ }
554+ } else {
555+ stack[(int)registers[idx].value].value = registers[idx + 1];
556 }
557- } else {
558- stack[(int)registers[idx].value].data[0] = registers[idx + 1];
559 }
560
561 register_len = idx;
562 break;
563 }
564 case AT: {
565- if (stack[(int)registers[idx].value].length > registers[idx+1].value) {
566- registers[idx] = stack[(int)registers[idx].value].data[(int)registers[idx+1].value];
567+ if (registers[idx].value > -1) {
568+ if (stack[(int)registers[idx].value].length > registers[idx+1].value) {
569+ registers[idx] = stack[(int)registers[idx].value].data[(int)registers[idx+1].value];
570+ }
571 }
572
573- register_len = idx;
574+ register_len = idx + 1;
575 break;
576 }
577 case APPEND: {
578@@ -865,85 +940,83 @@ float unit_value(struct Slot stack[], int stack_size, int register_size, struct
579 case LENGTH: {
580 registers[idx].type = NUMBER;
581 registers[idx].value = (float)stack[(int)registers[idx].value].length;
582- register_len = idx;
583+ register_len = idx + 1;
584 break;
585 }
586 case CAPACITY: {
587 registers[idx].type = NUMBER;
588 registers[idx].value = (float)stack[(int)registers[idx].value].capacity;
589- register_len = idx;
590+ register_len = idx + 1;
591 break;
592 }
593 case ADD:
594 registers[idx].type = NUMBER;
595 registers[idx].value += registers[idx+1].value;
596- register_len = idx;
597- printf("ADD: %f, IDX: %f\n", registers[idx], idx);
598+ register_len = idx + 1;
599 break;
600 case SUB:
601 registers[idx].type = NUMBER;
602 registers[idx].value -= registers[idx+1].value;
603- register_len = idx;
604+ register_len = idx + 1;
605 break;
606 case DIV:
607 registers[idx].type = NUMBER;
608 registers[idx].value /= registers[idx+1].value;
609- register_len = idx;
610+ register_len = idx + 1;
611 break;
612 case MULT:
613 registers[idx].type = NUMBER;
614 registers[idx].value *= registers[idx+1].value;
615- register_len = idx;
616+ register_len = idx + 1;
617 break;
618 case LT:
619 registers[idx].type = BOOL;
620 registers[idx].value = registers[idx].value < registers[idx + 1].value;
621- register_len = idx;
622+ register_len = idx + 1;
623 break;
624 case GT:
625 registers[idx].type = BOOL;
626 registers[idx].value = registers[idx].value > registers[idx + 1].value;
627- register_len = idx;
628+ register_len = idx + 1;
629 break;
630 case LE:
631 registers[idx].type = BOOL;
632 registers[idx].value = registers[idx].value <= registers[idx + 1].value;
633- register_len = idx;
634+ register_len = idx + 1;
635 break;
636 case GE:
637 registers[idx].type = BOOL;
638 registers[idx].value = registers[idx].value >= registers[idx + 1].value;
639- register_len = idx;
640+ register_len = idx + 1;
641 break;
642 case EQ:
643 registers[idx].type = BOOL;
644 registers[idx].value = registers[idx].value == registers[idx + 1].value;
645- register_len = idx;
646+ register_len = idx + 1;
647 break;
648 case AND:
649 registers[idx].type = BOOL;
650 registers[idx].value = registers[idx].value && registers[idx + 1].value;
651- register_len = idx;
652+ register_len = idx + 1;
653 break;
654 case OR:
655 registers[idx].type = BOOL;
656 registers[idx].value = registers[idx].value || registers[idx + 1].value;
657- register_len = idx;
658+ register_len = idx + 1;
659 break;
660 case NOT:
661 registers[idx].type = BOOL;
662 registers[idx].value = !registers[idx].value;
663- register_len = idx;
664+ register_len = idx + 1;
665 break;
666 default:
667 registers[register_len++] = unit;
668+ break;
669 }
670- }
671
672- for (int i = 0; i < stack_size; i++) {
673- free(stack[i].data);
674+
675 }
676-
677+
678 return registers[0].value;
679 }
680 /*
681diff --git a/src/parser.c b/src/parser.c
682index eef3bee..7b534d6 100755
683--- a/src/parser.c
684+++ b/src/parser.c
685@@ -134,7 +134,7 @@ void get_unit(struct Unit** units, int* cap, int* units_len, char** vars, int* v
686 if (inQuotes && v == quoteType) {
687 bool hasOP = false;
688 struct Unit op;
689- if ((*units_len) > 1 && (*units)[(*units_len)-1].type >= OP_START) {
690+ if ((*units_len) > 1 && (*units)[(*units_len)-1].type >= OP_START && (*units)[(*units_len)-1].value != 2) {
691 hasOP = true;
692 op.type = (*units)[(*units_len)-1].type;
693 op.value = 2;
694@@ -229,7 +229,7 @@ void get_unit(struct Unit** units, int* cap, int* units_len, char** vars, int* v
695
696 bool hasOP = false; // We need to move operators to the back so we save it here and add it at the end
697 struct Unit op;
698- if ((*units_len) > 1 && (*units)[(*units_len)-1].type >= OP_START) {
699+ if ((*units_len) > 1 && (*units)[(*units_len)-1].type >= OP_START && (*units)[(*units_len)-1].value != 2) {
700 hasOP = true;
701 op.type = (*units)[(*units_len)-1].type;
702 op.value = 2;
703@@ -299,7 +299,7 @@ void get_unit(struct Unit** units, int* cap, int* units_len, char** vars, int* v
704 if (placeholder.type == SET) {
705 if (indexes[0] - 1 > 0 && (*units)[indexes[0] - 1].type == AT) {
706 placeholder.value = (placeholder.value - 1) + (*units)[indexes[0] - 1].value;
707- memmove((*units) + (*units_len-reg_count) + indexes[0] - 1, (*units) + (*units_len-reg_count) + indexes[0], *units_len * sizeof(struct Unit));
708+ memmove((*units) + (indexes[0] - 1), (*units) + indexes[0], (*units_len - indexes[0]) * sizeof(struct Unit));
709 *units_len -= 1;
710 }
711 }
712@@ -309,6 +309,8 @@ void get_unit(struct Unit** units, int* cap, int* units_len, char** vars, int* v
713 // Turn VARS to PTR's if the calling function needs the address not the value
714 if (placeholder.type == LET ||
715 placeholder.type == SET ||
716+ placeholder.type == LENGTH ||
717+ placeholder.type == CAPACITY ||
718 placeholder.type == AT) {
719 (*units)[before_count].type = PTR;
720 }
721@@ -321,9 +323,9 @@ void get_unit(struct Unit** units, int* cap, int* units_len, char** vars, int* v
722 *units = realloc(*units, sizeof(struct Unit) * (*cap * 2));
723 }
724
725- memmove((*units) + (*units_len-reg_count) + indexes[0], (*units) + (*units_len-reg_count) + indexes[0] - 1, *units_len * sizeof(struct Unit));
726+ memmove((*units) + indexes[0], (*units) + indexes[0] - 1, (*units_len - indexes[0]) * sizeof(struct Unit));
727 (*units)[indexes[0]].type = IF;
728- (*units)[indexes[0]].value = reg_count -indexes[0] + 1;
729+ (*units)[indexes[0]].value = reg_count - indexes[0] + 1;
730 } else if (child_count == 3) {
731 // if else
732 // Move back 1 and add a jump at the end of the conditional logic
733@@ -331,11 +333,11 @@ void get_unit(struct Unit** units, int* cap, int* units_len, char** vars, int* v
734 *units = realloc(*units, sizeof(struct Unit) * (*cap * 2));
735 }
736
737- memmove((*units) + (*units_len-reg_count) + indexes[1], (*units) + (*units_len-reg_count) + indexes[1] - 1, *units_len * sizeof(struct Unit));
738+ memmove((*units) + indexes[1], (*units) + indexes[1] - 1, (*units_len - indexes[1]) * sizeof(struct Unit));
739 (*units)[indexes[1]].type = IF;
740 (*units)[indexes[1]].value = (indexes[0] - indexes[1]) + 2; // Add one for the jump and one for the if
741
742- memmove((*units) + (*units_len-reg_count) + indexes[0], (*units) + (*units_len-reg_count) + indexes[0] - 1, *units_len * sizeof(struct Unit));
743+ memmove((*units) + indexes[0] + 1, (*units) + indexes[0], ((indexes[0] - indexes[1]) + 1) * sizeof(struct Unit));
744 (*units)[indexes[0] + 1].type = JUMP;
745 (*units)[indexes[0] + 1].value = (*units_len-indexes[0]);
746
747@@ -483,7 +485,7 @@ void get_unit(struct Unit** units, int* cap, int* units_len, char** vars, int* v
748 }
749 }
750
751- if ((*units_len) > 1 && (*units)[(*units_len)-1].type >= OP_START) {
752+ if ((*units_len) > 1 && (*units)[(*units_len)-1].type >= OP_START && (*units)[(*units_len)-1].value != 2) {
753 struct Unit u = (*units)[(*units_len)-1];
754 u.value = 2;
755 (*units_len) -= 1;