home
readme
diff
tree
note
docs
0commit 9ae022c736d2c492fe903c5f1f89c42e67f90784
1Author: lakefox <mason@lakefox.net>
2Date: Wed Apr 8 20:28:48 2026 -0600
3
4 Cleaned up some unused code
5
6diff --git a/Makefile b/Makefile
7index b3d0445..df9f26c 100755
8--- a/Makefile
9+++ b/Makefile
10@@ -1,6 +1,6 @@
11 # --- Variables ---
12-#CCFLAGS = -std=c23 -O3 -lm
13-CCFLAGS = -Wall -Wextra -std=c23 -g -O0 -fsanitize=address,undefined -fno-omit-frame-pointer -lm
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/playground/css_unit.c b/playground/css_unit.c
20index 1a15211..060142e 100644
21--- a/playground/css_unit.c
22+++ b/playground/css_unit.c
23@@ -141,7 +141,7 @@ int main() {
24 int stack_len = 0;
25 int max_register_size = 0;
26
27- char* ustr = "let(a 0) while(range(1000000 as b) (set(a (a + b)))) print(a)";
28+ char* ustr = "let(x empty(3)) ((length(x) == 3) && (capacity(x) == 3))";
29
30 get_unit(&units, &cap, &units_len, &vars, &vars_len, &vars_cap, &funcs, &funcs_len, &funcs_cap, &stack_len, &max_register_size, ustr);
31
32diff --git a/playground/unit_value.c b/playground/unit_value.c
33index 2511be7..2501860 100644
34--- a/playground/unit_value.c
35+++ b/playground/unit_value.c
36@@ -69,15 +69,18 @@ void benchmark_unit_value(char* value) {
37
38
39 // Calculate time difference in seconds
40- double total_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
41- printf("Average execution time: %.9f seconds (%f us)\n",
42- total_time / iterations,
43- (total_time / iterations) * 1000000);
44+ long long total_ns = (end.tv_sec - start.tv_sec) * 1000000000LL + (end.tv_nsec - start.tv_nsec);
45+ double avg_ns = (double)total_ns / iterations;
46+
47+ printf("Average execution time:\n");
48+ printf(" %.2f ns\n", avg_ns);
49+ printf(" %.4f us\n", avg_ns / 1000.0);
50+ printf(" %.9f s\n", avg_ns / 1e9);
51 }
52
53 void test_unit_value(char* ustr, float value) {
54 int cap = 10;
55- struct Unit *units = malloc(sizeof(struct Unit) * cap);
56+ struct Unit *units = calloc(cap, sizeof(struct Unit));
57 int units_len = 0;
58
59 int vars_cap = 0;
60@@ -139,13 +142,13 @@ int main() {
61 int vars_len = 0;
62
63 int funcs_cap = 0;
64- KeyValue *funcs = {};
65+ KeyValue *funcs = NULL;
66 int funcs_len = 0;
67
68 int stack_len = 0;
69 int max_register_size = 0;
70
71- char* ustr = "let(a 0) while(range(1000000) (set(a (a + 1)))) a";
72+ char* ustr = "1 + 1";
73
74 get_unit(&units, &cap, &units_len, &vars, &vars_len, &vars_cap, &funcs, &funcs_len, &funcs_cap, &stack_len, &max_register_size, ustr);
75
76@@ -177,7 +180,7 @@ int main() {
77
78
79 if (true) {
80- // benchmark_unit_value(ustr);
81+ benchmark_unit_value(ustr);
82
83 test_unit_value("1 + 1", 2);
84 test_unit_value("pow(10 2)", 100);
85@@ -195,7 +198,10 @@ int main() {
86 test_unit_value("let(x 10px 20px 30px) set(at(x 1) 90px) at(x 1) == 90px", 1);
87 test_unit_value("let(x 10px 20px 30px) set(at(x 1) 90px) if(at(x 1) != 90px, 1 + 1, 5 + 5)", 10);
88 test_unit_value("let(x 10px 20px 30px) set(at(x 1) 90px) if(at(x 1) == 90px, 1 + 1)", 2);
89- test_unit_value("let(x empty(3)) ((length(x) == 3) && (capacity(x) == 3))", 1);
90+ test_unit_value("let(x empty(3)) ((length(x) == 0) && (capacity(x) == 3))", 1);
91+ test_unit_value("let(x empty(3)) (length(x) == 0)", 1);
92+ test_unit_value("let(x empty(3)) (capacity(x) == 3)", 1);
93+ test_unit_value("(3 == 3) && (3 == 3)", 1);
94 test_unit_value("let(height 10) def(x (age name) (age + height * name)) x(4 x(5 x(6 x(7 8))))", 456960);
95 test_unit_value("let(height 10) def(x () (21 + 3)) x()", 24);
96 test_unit_value("let(height 10) def(x (name age) (age + height * name)) x(4 x(5 x(6 x(7 8))))", 16560);
97diff --git a/src/grim.c b/src/grim.c
98index 02823fe..95af631 100755
99--- a/src/grim.c
100+++ b/src/grim.c
101@@ -477,37 +477,30 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
102 case NUMBER:
103 // NUMBER is any untyped numbers "2". Treat as a pixel
104 case PX: {
105- registers[register_len].type = NUMBER;
106 registers[register_len++].value = unit.value;
107 break;
108 }
109 case CM: {
110- registers[register_len].type = NUMBER;
111 registers[register_len++].value = unit.value*37.8f;
112 break;
113 }
114 case MM: {
115- registers[register_len].type = NUMBER;
116 registers[register_len++].value = unit.value*3.78f;
117 break;
118 }
119 case Q: {
120- registers[register_len].type = NUMBER;
121 registers[register_len++].value = unit.value*0.94f;
122 break;
123 }
124 case IN: {
125- registers[register_len].type = NUMBER;
126 registers[register_len++].value = unit.value*96.0f;
127 break;
128 }
129 case PC: {
130- registers[register_len].type = NUMBER;
131 registers[register_len++].value = unit.value*16.0f;
132 break;
133 }
134 case PT: {
135- registers[register_len].type = NUMBER;
136 registers[register_len++].value = unit.value*1.3f;
137 break;
138 }
139@@ -522,19 +515,16 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
140 case RCH:
141 case RIC:
142 case RLH: {
143- registers[register_len].type = NUMBER;
144 registers[register_len++].value = unit.value*stack[2].value.value;
145 break;
146 }
147 case EX:
148 case REX: {
149- registers[register_len].type = NUMBER;
150 registers[register_len++].value = unit.value*(stack[2].value.value*0.5f);
151 break;
152 }
153 case CQH:
154 case VH: {
155- registers[register_len].type = NUMBER;
156 registers[register_len++].value = stack[1].value.value*(unit.value*0.01f);
157 break;
158 }
159@@ -543,35 +533,23 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
160 case CQB:
161 case PERCENT:
162 case VW: {
163- registers[register_len].type = NUMBER;
164 registers[register_len++].value = stack[0].value.value*(unit.value*0.01f);
165 break;
166 }
167 case VMAX:
168 case CQMAX: {
169- registers[register_len].type = NUMBER;
170+ registers[register_len++].value = fmaxf(unit.value*stack[0].value.value, unit.value*stack[1].value.value);
171 // 0: width
172 // 1: height
173- if (stack[0].value.value > stack[1].value.value) {
174- registers[register_len++].value = unit.value*stack[0].value.value;
175- } else {
176- registers[register_len++].value = unit.value*stack[1].value.value;
177- }
178 break;
179 }
180 case VMIN:
181 case CQMIN: {
182- registers[register_len].type = NUMBER;
183- if (stack[0].value.value < stack[1].value.value) {
184- registers[register_len++].value = unit.value*stack[0].value.value;
185- } else {
186- registers[register_len++].value = unit.value*stack[1].value.value;
187- }
188+ registers[register_len++].value = fminf(unit.value*stack[0].value.value, unit.value*stack[1].value.value);
189 break;
190 }
191 case VB:
192 case VI: {
193- registers[register_len].type = NUMBER;
194 registers[register_len++].value = unit.value*stack[0].value.value;
195 break;
196 }
197@@ -581,8 +559,6 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
198 break;
199 }
200 case MIN: {
201- registers[idx].type = NUMBER;
202-
203 for (int j = idx+1; j < register_len; j++) {
204 if (registers[idx].value > registers[j].value) {
205 registers[idx] = registers[j];
206@@ -592,8 +568,6 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
207 break;
208 }
209 case MAX: {
210- registers[idx].type = NUMBER;
211-
212 for (int j = idx+1; j < register_len; j++) {
213 if (registers[idx].value < registers[j].value) {
214 registers[idx] = registers[j];
215@@ -615,7 +589,6 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
216 // if the value is less than idx (min) then idx (return) remains the same
217 }
218
219- registers[idx].type = NUMBER;
220 register_len = idx + 1;
221 break;
222 }
223@@ -637,7 +610,6 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
224
225 }
226
227- registers[idx].type = NUMBER;
228 register_len = idx + 1;
229 break;
230 }
231@@ -647,7 +619,6 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
232 registers[idx].value = fmodf(registers[idx].value, registers[idx + 1].value);
233 }
234
235- registers[idx].type = NUMBER;
236 register_len = idx + 1;
237 break;
238 }
239@@ -657,38 +628,31 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
240 registers[idx].value = (registers[idx].value-registers[idx + 1].value)/(registers[idx + 2].value-registers[idx + 1].value);
241 }
242
243- registers[idx].type = NUMBER;
244 register_len = idx + 1;
245 break;
246 }
247 case SIN: {
248 registers[idx].value = sinf(registers[idx].value);
249- registers[idx].type = NUMBER;
250 break;
251 }
252 case COS: {
253 registers[idx].value = cosf(registers[idx].value);
254- registers[idx].type = NUMBER;
255 break;
256 }
257 case TAN: {
258 registers[idx].value = tanf(registers[idx].value);
259- registers[idx].type = NUMBER;
260 break;
261 }
262 case ASIN: {
263 registers[idx].value = asinf(registers[idx].value);
264- registers[idx].type = NUMBER;
265 break;
266 }
267 case ACOS: {
268 registers[idx].value = acosf(registers[idx].value);
269- registers[idx].type = NUMBER;
270 break;
271 }
272 case ATAN: {
273 registers[idx].value = atanf(registers[idx].value);
274- registers[idx].type = NUMBER;
275 break;
276 }
277 case ATAN2: {
278@@ -696,7 +660,6 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
279 registers[idx].value = atan2f(registers[idx].value, registers[idx + 2].value);
280 }
281
282- registers[idx].type = NUMBER;
283 register_len = idx + 1;
284 break;
285 }
286@@ -705,13 +668,11 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
287 registers[idx].value = powf(registers[idx].value, registers[idx + 1].value);
288 }
289
290- registers[idx].type = NUMBER;
291 register_len = idx + 1;
292 break;
293 }
294 case SQRT: {
295 registers[idx].value = sqrtf(registers[idx].value);
296- registers[idx].type = NUMBER;
297 break;
298 }
299 case HYPOT: {
300@@ -723,7 +684,6 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
301
302 registers[idx].value = sqrtf(v);
303
304- registers[idx].type = NUMBER;
305 register_len = idx + 1;
306 break;
307 }
308@@ -734,30 +694,19 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
309 registers[idx].value = logf(registers[idx].value);
310 }
311
312- registers[idx].type = NUMBER;
313 register_len = idx + 1;
314 break;
315 }
316 case EXP: {
317 registers[idx].value = expf(registers[idx].value);
318- registers[idx].type = NUMBER;
319 break;
320 }
321 case ABS: {
322 registers[idx].value = fabsf(registers[idx].value);
323- registers[idx].type = NUMBER;
324 break;
325 }
326 case SIGN: {
327- if (registers[idx].value > 0) {
328- registers[idx].value = 1;
329- } else if (registers[idx].value < 0) {
330- registers[idx].value = -1;
331- } else {
332- registers[idx].value = 0;
333- }
334-
335- registers[idx].type = NUMBER;
336+ registers[idx].value = (float)((registers[idx].value > 0) - (registers[idx].value < 0));
337 break;
338 }
339 case ATTR: {
340@@ -794,7 +743,6 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
341 } else if (stack[(int)unit.value].length > 1) {
342 registers[register_len++] = stack[(int)unit.value].data[0];
343 } else {
344- registers[register_len].type = NUMBER;
345 registers[register_len++].value = 0.0f;
346 }
347 }
348@@ -862,19 +810,22 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
349 stack[(int)registers[idx].value].value = registers[idx + 1];
350 } else {
351 int items = 0;
352+ int capacity = 0;
353 for (int j = idx + 1; j < register_len; j++) {
354 if (registers[j].type == FREE) {
355- items += (int)registers[j].value;
356+ capacity += (int)registers[j].value;
357+ registers[j].type = NUMBER;
358 } else {
359 items++;
360+ capacity++;
361 }
362 }
363- if (stack[(int)registers[idx].value].capacity < items || stack[(int)registers[idx].value].capacity/2 > items) {
364+ if (stack[(int)registers[idx].value].capacity < capacity || stack[(int)registers[idx].value].capacity/2 > capacity) {
365 if (stack[(int)registers[idx].value].capacity > 0) {
366 free(stack[(int)registers[idx].value].data);
367 }
368- stack[(int)registers[idx].value].data = malloc(items * sizeof(struct Unit));
369- stack[(int)registers[idx].value].capacity = items;
370+ stack[(int)registers[idx].value].data = malloc(capacity * sizeof(struct Unit));
371+ stack[(int)registers[idx].value].capacity = capacity;
372 stack[(int)registers[idx].value].length = items;
373 }
374
375@@ -883,6 +834,7 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
376 for (int j = idx+1; j < idx+(int)unit.value; j++) {
377 if (registers[j].type == FREE) {
378 offset += (int)registers[j].value - 1;
379+ registers[j].type = NUMBER;
380 } else {
381 stack[(int)registers[idx].value].data[((j-1)-idx)+offset] = registers[j];
382 }
383@@ -904,15 +856,9 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
384 // AT
385 if (stack[(int)registers[idx].value].capacity >= registers[idx+1].value) {
386 // If set(at(x 0) empty(15)) it will just place NUMBER 15
387- if (registers[idx + 2].type == FREE) {
388- registers[idx + 2].type = NUMBER;
389- }
390 stack[(int)registers[idx].value].data[(int)registers[idx + 1].value] = registers[idx + 2];
391 }
392 } else {
393- if (registers[idx + 1].type == FREE) {
394- registers[idx + 1].type = NUMBER;
395- }
396 stack[(int)registers[idx].value].value = registers[idx + 1];
397 }
398
399@@ -951,14 +897,14 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
400 break;
401 }
402 case LENGTH: {
403- registers[idx].type = NUMBER;
404- registers[idx].value = (float)stack[(int)registers[idx].value].length;
405+ int stack_idx = (int)registers[idx].value;
406+ registers[idx].value = (float)stack[stack_idx].length;
407 register_len = idx + 1;
408 break;
409 }
410 case CAPACITY: {
411- registers[idx].type = NUMBER;
412- registers[idx].value = (float)stack[(int)registers[idx].value].capacity;
413+ int stack_idx = (int)registers[idx].value;
414+ registers[idx].value = (float)stack[stack_idx].capacity;
415 register_len = idx + 1;
416 break;
417 }
418@@ -976,22 +922,18 @@ float unit_value(struct Slot stack[], int register_size, struct Unit* units, int
419 break;
420 }
421 case ADD:
422- registers[idx].type = NUMBER;
423 registers[idx].value += registers[idx+1].value;
424 register_len = idx + 1;
425 break;
426 case SUB:
427- registers[idx].type = NUMBER;
428 registers[idx].value -= registers[idx+1].value;
429 register_len = idx + 1;
430 break;
431 case DIV:
432- registers[idx].type = NUMBER;
433 registers[idx].value /= registers[idx+1].value;
434 register_len = idx + 1;
435 break;
436 case MULT:
437- registers[idx].type = NUMBER;
438 registers[idx].value *= registers[idx+1].value;
439 register_len = idx + 1;
440 break;