1 #include "declarations.h"
2 #include "dsl_errno.h"
3 #include "dsl_cmd.h"
4 #include "dsl_shr.h"
5 #include "dsl_post.h"
6
7
8
dsl_run_post(struct dsl_ctx * c,struct dsl_flg * f,unsigned long k)9 int dsl_run_post(struct dsl_ctx *c, struct dsl_flg *f, unsigned long k) {
10 int r;
11 unsigned long i, j;
12
13 struct dsl_cmd *s;
14
15 s = c->script;
16
17 for(i = k, j = 0, r = 0; r == 0; i++) {
18 switch(s[i].c) {
19 case DSL_COMMAND_NONE:
20 return(0);
21 case DSL_COMMAND_ABS:
22 r = dsl_run_post_abs((struct dsl_cmd_abs *) s[i].p, c);
23
24 break;
25 case DSL_COMMAND_ADD:
26 r = dsl_run_post_add((struct dsl_cmd_add *) s[i].p, c, f);
27
28 break;
29 case DSL_COMMAND_CALL:
30 j = i;
31
32 r = dsl_run_post_call((struct dsl_cmd_call *) s[i].p, c, &j);
33
34 i = j;
35
36 break;
37 case DSL_COMMAND_CMP:
38 r = dsl_run_post_cmp((struct dsl_cmd_cmp *) s[i].p, c, f);
39
40 break;
41 case DSL_COMMAND_DEC:
42 r = dsl_run_post_dec((struct dsl_cmd_dec *) s[i].p, c, f);
43
44 break;
45 case DSL_COMMAND_DIV:
46 r = dsl_run_post_div((struct dsl_cmd_div *) s[i].p, c);
47
48 break;
49 case DSL_COMMAND_END:
50 if((r = dsl_run_post_end((struct dsl_cmd_end *) s[i].p, c)) == -1) break;
51
52 return(r);
53 case DSL_COMMAND_FUNC:
54 r = dsl_run_post_func((struct dsl_cmd_func *) s[i].p, c);
55
56 break;
57 case DSL_COMMAND_INC:
58 r = dsl_run_post_inc((struct dsl_cmd_inc *) s[i].p, c, f);
59
60 break;
61 case DSL_COMMAND_LABEL:
62 r = dsl_run_post_label((struct dsl_cmd_label *) s[i].p, c);
63
64 break;
65 case DSL_COMMAND_MOD:
66 r = dsl_run_post_mod((struct dsl_cmd_mod *) s[i].p, c);
67
68 break;
69 case DSL_COMMAND_MOV:
70 r = dsl_run_post_mov((struct dsl_cmd_mov *) s[i].p, c);
71
72 break;
73 case DSL_COMMAND_MUL:
74 r = dsl_run_post_mul((struct dsl_cmd_mul *) s[i].p, c);
75
76 break;
77 case DSL_COMMAND_NEG:
78 r = dsl_run_post_neg((struct dsl_cmd_neg *) s[i].p, c, f);
79
80 break;
81 case DSL_COMMAND_POW:
82 r = dsl_run_post_pow((struct dsl_cmd_pow *) s[i].p, c);
83
84 break;
85 case DSL_COMMAND_RAND:
86 r = dsl_run_post_rand((struct dsl_cmd_rand *) s[i].p, c);
87
88 break;
89 case DSL_COMMAND_RET:
90 r = dsl_run_post_ret((struct dsl_cmd_ret *) s[i].p, c, &j);
91
92 i = j;
93
94 break;
95 case DSL_COMMAND_SUB:
96 r = dsl_run_post_sub((struct dsl_cmd_sub *) s[i].p, c, f);
97
98 break;
99 case DSL_COMMAND_XCHG:
100 r = dsl_run_post_xchg((struct dsl_cmd_xchg *) s[i].p, c);
101
102 break;
103 case DSL_COMMAND_CLALL:
104 case DSL_COMMAND_CLA:
105 case DSL_COMMAND_CLB:
106 case DSL_COMMAND_CLE:
107 case DSL_COMMAND_CLS:
108 case DSL_COMMAND_CLZ:
109 case DSL_COMMAND_STALL:
110 case DSL_COMMAND_STA:
111 case DSL_COMMAND_STB:
112 case DSL_COMMAND_STE:
113 case DSL_COMMAND_STS:
114 case DSL_COMMAND_STZ:
115 r = dsl_run_post_flag(f, s[i].c);
116
117 break;
118 case DSL_COMMAND_JA:
119 case DSL_COMMAND_JAE:
120 case DSL_COMMAND_JB:
121 case DSL_COMMAND_JBE:
122 case DSL_COMMAND_JE:
123 case DSL_COMMAND_JNE:
124 case DSL_COMMAND_JS:
125 case DSL_COMMAND_JNS:
126 case DSL_COMMAND_JZ:
127 case DSL_COMMAND_JNZ:
128 case DSL_COMMAND_JMP:
129 j = i;
130
131 r = dsl_run_post_jmp((struct dsl_cmd_jmp *) s[i].p, c, f, s[i].c, &j);
132
133 i = j;
134
135 break;
136 #if ! defined(PROG_DISABLE_EXTENDED)
137 case DSL_COMMAND_NOT:
138 case DSL_COMMAND_TEST:
139 case DSL_COMMAND_ISFINITE:
140 case DSL_COMMAND_ISINF:
141 case DSL_COMMAND_ISNAN:
142 case DSL_COMMAND_ISNORMAL:
143 case DSL_COMMAND_SIGNBIT:
144 case DSL_COMMAND_NAN:
145 case DSL_COMMAND_CEIL:
146 case DSL_COMMAND_FLOOR:
147 case DSL_COMMAND_NEARBYINT:
148 case DSL_COMMAND_RINT:
149 case DSL_COMMAND_ROUND:
150 case DSL_COMMAND_TRUNC:
151 case DSL_COMMAND_SQRT:
152 case DSL_COMMAND_CBRT:
153 case DSL_COMMAND_EXP:
154 case DSL_COMMAND_EXP2:
155 case DSL_COMMAND_EXPM1:
156 case DSL_COMMAND_LOG:
157 case DSL_COMMAND_LOG2:
158 case DSL_COMMAND_LOG10:
159 case DSL_COMMAND_LOG1P:
160 case DSL_COMMAND_LOGB:
161 case DSL_COMMAND_ILOGB:
162 case DSL_COMMAND_COS:
163 case DSL_COMMAND_COSH:
164 case DSL_COMMAND_ACOS:
165 case DSL_COMMAND_ACOSH:
166 case DSL_COMMAND_SIN:
167 case DSL_COMMAND_SINH:
168 case DSL_COMMAND_ASIN:
169 case DSL_COMMAND_ASINH:
170 case DSL_COMMAND_TAN:
171 case DSL_COMMAND_TANH:
172 case DSL_COMMAND_ATAN:
173 case DSL_COMMAND_ATANH:
174 case DSL_COMMAND_TGAMMA:
175 case DSL_COMMAND_LGAMMA:
176 case DSL_COMMAND_J0:
177 case DSL_COMMAND_J1:
178 case DSL_COMMAND_Y0:
179 case DSL_COMMAND_Y1:
180 case DSL_COMMAND_ERF:
181 case DSL_COMMAND_ERFC:
182 case DSL_COMMAND_GDENS:
183 case DSL_COMMAND_GDIST:
184 r = dsl_run_post_math2((struct dsl_cmd_math2 *) s[i].p, c, f, s[i].c);
185
186 break;
187 case DSL_COMMAND_AND:
188 case DSL_COMMAND_OR:
189 case DSL_COMMAND_XOR:
190 case DSL_COMMAND_COPYSIGN:
191 case DSL_COMMAND_NEXTAFTER:
192 case DSL_COMMAND_NEXTTOWARD:
193 case DSL_COMMAND_REMAINDER:
194 case DSL_COMMAND_DIM:
195 case DSL_COMMAND_MAX:
196 case DSL_COMMAND_MIN:
197 case DSL_COMMAND_HYPOT:
198 case DSL_COMMAND_LDEXP:
199 case DSL_COMMAND_SCALBN:
200 case DSL_COMMAND_ATAN2:
201 case DSL_COMMAND_JN:
202 case DSL_COMMAND_YN:
203 case DSL_COMMAND_GRAND:
204 r = dsl_run_post_math3((struct dsl_cmd_math3 *) s[i].p, c, f, s[i].c);
205
206 break;
207 case DSL_COMMAND_MODF:
208 case DSL_COMMAND_FREXP:
209 r = dsl_run_post_math4((struct dsl_cmd_math3 *) s[i].p, c, s[i].c);
210
211 break;
212 case DSL_COMMAND_FMA:
213 r = dsl_run_post_math5((struct dsl_cmd_math4 *) s[i].p, c, s[i].c);
214
215 break;
216 case DSL_COMMAND_CRC32:
217 r = dsl_run_post_crc32((struct dsl_cmd_crc32 *) s[i].p, c);
218
219 break;
220 case DSL_COMMAND_CRC64:
221 r = dsl_run_post_crc64((struct dsl_cmd_crc64 *) s[i].p, c);
222
223 break;
224 #endif
225 case DSL_COMMAND_DUMP:
226 r = dsl_run_post_dump((struct dsl_cmd_dump *) s[i].p, c);
227
228 break;
229 case DSL_COMMAND_STON:
230 case DSL_COMMAND_BTON:
231 case DSL_COMMAND_PTON:
232 case DSL_COMMAND_HTON:
233 case DSL_COMMAND_NTOS:
234 case DSL_COMMAND_NTOB:
235 case DSL_COMMAND_NTOP:
236 case DSL_COMMAND_NTOH:
237 r = dsl_run_post_conv((struct dsl_cmd_conv *) s[i].p, c, s[i].c);
238
239 break;
240 case DSL_COMMAND_TOI8:
241 case DSL_COMMAND_TOI16:
242 case DSL_COMMAND_TOI32:
243 case DSL_COMMAND_TOI64:
244 #if defined(__SIZEOF_INT128__)
245 case DSL_COMMAND_TOI128:
246 #endif
247 case DSL_COMMAND_TOU8:
248 case DSL_COMMAND_TOU16:
249 case DSL_COMMAND_TOU32:
250 case DSL_COMMAND_TOU64:
251 #if defined(__SIZEOF_INT128__)
252 case DSL_COMMAND_TOU128:
253 #endif
254 case DSL_COMMAND_TOCHAR:
255 case DSL_COMMAND_TOSHORT:
256 case DSL_COMMAND_TOINT:
257 case DSL_COMMAND_TOLONG:
258 case DSL_COMMAND_TOUCHAR:
259 case DSL_COMMAND_TOUSHORT:
260 case DSL_COMMAND_TOUINT:
261 case DSL_COMMAND_TOULONG:
262 case DSL_COMMAND_TOFLOAT:
263 case DSL_COMMAND_TODOUBLE:
264 r = dsl_run_post_type((struct dsl_cmd_type *) s[i].p, c, s[i].c);
265
266 break;
267 default:
268 break;
269 }
270 }
271
272 if(r != 0) (void) dsl_error_details(s[i].c, i);
273
274 return(r);
275 }
276
dsl_run_post_abs(struct dsl_cmd_abs * p,struct dsl_ctx * c)277 static int dsl_run_post_abs(struct dsl_cmd_abs *p, struct dsl_ctx *c) {
278 if(p == NULL) {
279 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
280
281 return(-1);
282 }
283
284 if(p->d == NULL) {
285 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
286 }
287
288 /* Inherit member type to cached destination variable */
289 p->d->m = p->destination.m;
290
291 (void) dsl_var_abs_number(p->d);
292
293 return(0);
294 }
295
dsl_run_post_add(struct dsl_cmd_add * p,struct dsl_ctx * c,struct dsl_flg * f)296 static int dsl_run_post_add(struct dsl_cmd_add *p, struct dsl_ctx *c, struct dsl_flg *f) {
297 struct dsl_cmd_add_param_n *n;
298 struct dsl_cmd_add_param_v *v;
299
300 if(p == NULL || p->p == NULL) {
301 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
302
303 return(-1);
304 }
305
306 if(p->d == NULL) {
307 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
308 }
309
310 /* Inherit member type to cached destination variable */
311 p->d->m = p->destination.m;
312
313 switch(p->c) {
314 case DSL_PARAM_TYPE_NUMBER:
315 n = (struct dsl_cmd_add_param_n *) p->p;
316
317 (void) dsl_var_add_number(p->d, &n->source, f, DSL_PARAM_TYPE_NUMBER);
318
319 break;
320 case DSL_PARAM_TYPE_VARIABLE:
321 v = (struct dsl_cmd_add_param_v *) p->p;
322
323 if(p->s == NULL) {
324 if((p->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
325 }
326
327 (void) dsl_var_add_variable(p->d, p->s, v->source.m, f);
328
329 break;
330 default:
331 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
332
333 return(-1);
334 }
335
336 return(0);
337 }
338
dsl_run_post_call(struct dsl_cmd_call * p,struct dsl_ctx * c,unsigned long * i)339 static int dsl_run_post_call(struct dsl_cmd_call *p, struct dsl_ctx *c, unsigned long *i) {
340 struct dsl_cmd_call_s *s;
341 struct dsl_cmd_call_v *v;
342
343 struct dsl_stack a;
344 struct dsl_str b;
345
346 if(p == NULL || p->p == NULL) {
347 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
348
349 return(-1);
350 }
351
352 switch(p->c) {
353 case DSL_PARAM_TYPE_STRING:
354 if(p->n == 0) {
355 /* Resolve call destination label and cache it */
356 s = (struct dsl_cmd_call_s *) p->p;
357
358 if((p->n = dsl_run_label_get_node_by_name(&s->target)) == 0) return(-1);
359 if((p->m = dsl_run_label_get_slot_by_name(&s->target)) == 0) return(-1);
360 }
361
362 break;
363 case DSL_PARAM_TYPE_VARIABLE:
364 v = (struct dsl_cmd_call_v *) p->p;
365
366 if(v->cache == NULL) {
367 if((v->cache = dsl_var_find_struct_by_name(&v->target, c)) == NULL) return(-1);
368 }
369
370 /* Inherit member type to cached target variable */
371 v->cache->m = v->target.m;
372
373 if(dsl_var_get_string(v->cache, &b) != 0) return(-1);
374
375 if((p->n = dsl_run_label_get_node_by_name(&b)) == 0) return(-1);
376 if((p->m = dsl_run_label_get_slot_by_name(&b)) == 0) return(-1);
377
378 break;
379 default:
380 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
381
382 return(-1);
383 }
384
385 if(dsl_run_post_call_param(p->q, c, p->m - 1) != 0) return(-1);
386
387 /* Store program counter and local variables to stack */
388 a.n = *i;
389 a.v = c->local;
390
391 if(dsl_stack_node_push(&a) != 0) return(-1);
392
393 /* Decrement 1 to execute label command needed for switching local variables */
394 *i = p->n - 1;
395
396 return(0);
397 }
398
dsl_run_post_call_param(struct dsl_cmd_call_param * q,struct dsl_ctx * c,unsigned long o)399 static int dsl_run_post_call_param(struct dsl_cmd_call_param *q, struct dsl_ctx *c, unsigned long o) {
400 unsigned long i;
401
402 struct dsl_cmd_call_param_n *n;
403 struct dsl_cmd_call_param_s *s;
404 struct dsl_cmd_call_param_b *b;
405 struct dsl_cmd_call_param_p *p;
406 struct dsl_cmd_call_param_h *h;
407 struct dsl_cmd_call_param_c *g;
408 struct dsl_cmd_call_param_m *m;
409 struct dsl_cmd_call_param_t *t;
410 struct dsl_cmd_call_param_v *v;
411
412 struct dsl_var *w;
413
414 /* If there is no defined parameters for label, leave */
415 if(q == NULL) return(0);
416
417 for(i = 0; ; i++) {
418 switch(q[i].c) {
419 case DSL_PARAM_TYPE_NONE:
420 return(0);
421 case DSL_PARAM_TYPE_NUMBER:
422 n = (struct dsl_cmd_call_param_n *) q[i].p;
423
424 if((w = dsl_run_label_get_var_by_index(o, i)) == NULL) return(-1);
425
426 (void) dsl_var_put_number(w, &n->parameter, IS_NO);
427
428 break;
429 case DSL_PARAM_TYPE_STRING:
430 s = (struct dsl_cmd_call_param_s *) q[i].p;
431
432 if((w = dsl_run_label_get_var_by_index(o, i)) == NULL) return(-1);
433
434 (void) dsl_var_put_string(w, &s->parameter);
435
436 break;
437 case DSL_PARAM_TYPE_BLOB:
438 b = (struct dsl_cmd_call_param_b *) q[i].p;
439
440 if((w = dsl_run_label_get_var_by_index(o, i)) == NULL) return(-1);
441
442 (void) dsl_var_put_blob(w, &b->parameter, b->parameter.s);
443
444 break;
445 case DSL_PARAM_TYPE_POINTER:
446 p = (struct dsl_cmd_call_param_p *) q[i].p;
447
448 if((w = dsl_run_label_get_var_by_index(o, i)) == NULL) return(-1);
449
450 (void) dsl_var_put_pointer(w, &p->parameter);
451
452 break;
453 case DSL_PARAM_TYPE_HANDLE:
454 h = (struct dsl_cmd_call_param_h *) q[i].p;
455
456 if((w = dsl_run_label_get_var_by_index(o, i)) == NULL) return(-1);
457
458 (void) dsl_var_put_handle(w, &h->parameter);
459
460 break;
461 case DSL_PARAM_TYPE_COLOR:
462 g = (struct dsl_cmd_call_param_c *) q[i].p;
463
464 if((w = dsl_run_label_get_var_by_index(o, i)) == NULL) return(-1);
465
466 (void) dsl_var_put_color(w, &g->parameter, g->m);
467
468 break;
469 case DSL_PARAM_TYPE_IMAGE:
470 m = (struct dsl_cmd_call_param_m *) q[i].p;
471
472 if((w = dsl_run_label_get_var_by_index(o, i)) == NULL) return(-1);
473
474 (void) dsl_var_put_image(w, &m->parameter, m->parameter.s, m->m);
475
476 break;
477 case DSL_PARAM_TYPE_POINT:
478 t = (struct dsl_cmd_call_param_t *) q[i].p;
479
480 if((w = dsl_run_label_get_var_by_index(o, i)) == NULL) return(-1);
481
482 (void) dsl_var_put_point(w, &t->parameter, t->m);
483
484 break;
485 case DSL_PARAM_TYPE_VARIABLE:
486 v = (struct dsl_cmd_call_param_v *) q[i].p;
487
488 if((w = dsl_run_label_get_var_by_index(o, i)) == NULL) return(-1);
489
490 if(v->cache == NULL) {
491 if((v->cache = dsl_var_find_struct_by_name(&v->parameter, c)) == NULL) return(-1);
492 }
493
494 (void) dsl_var_put_variable(w, v->cache, v->cache->c, v->parameter.m);
495
496 break;
497 default:
498 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
499
500 return(-1);
501 }
502 }
503
504 return(0);
505 }
506
dsl_run_post_cmp(struct dsl_cmd_cmp * r,struct dsl_ctx * c,struct dsl_flg * f)507 static int dsl_run_post_cmp(struct dsl_cmd_cmp *r, struct dsl_ctx *c, struct dsl_flg *f) {
508 struct dsl_cmd_cmp_param_n *n;
509 struct dsl_cmd_cmp_param_s *s;
510 struct dsl_cmd_cmp_param_b *b;
511 struct dsl_cmd_cmp_param_p *p;
512 struct dsl_cmd_cmp_param_h *h;
513 struct dsl_cmd_cmp_param_c *g;
514 struct dsl_cmd_cmp_param_m *m;
515 struct dsl_cmd_cmp_param_t *t;
516 struct dsl_cmd_cmp_param_v *v;
517
518 if(r == NULL || r->p == NULL) {
519 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
520
521 return(-1);
522 }
523
524 if(r->d == NULL) {
525 if((r->d = dsl_var_find_struct_by_name(&r->destination, c)) == NULL) return(-1);
526 }
527
528 /* Inherit member type to cached destination variable */
529 r->d->m = r->destination.m;
530
531 /* Clear condition flags to possibly be set later */
532 f->ja = f->jb = f->je = f->js = f->jz = 0;
533
534 switch(r->c) {
535 case DSL_PARAM_TYPE_NUMBER:
536 n = (struct dsl_cmd_cmp_param_n *) r->p;
537
538 (void) dsl_var_cmp_number(r->d, &n->source, f);
539
540 break;
541 case DSL_PARAM_TYPE_STRING:
542 s = (struct dsl_cmd_cmp_param_s *) r->p;
543
544 (void) dsl_var_cmp_string(r->d, &s->source, f);
545
546 break;
547 case DSL_PARAM_TYPE_BLOB:
548 b = (struct dsl_cmd_cmp_param_b *) r->p;
549
550 (void) dsl_var_cmp_blob(r->d, &b->source, f);
551
552 break;
553 case DSL_PARAM_TYPE_POINTER:
554 p = (struct dsl_cmd_cmp_param_p *) r->p;
555
556 (void) dsl_var_cmp_pointer(r->d, &p->source, f);
557
558 break;
559 case DSL_PARAM_TYPE_HANDLE:
560 h = (struct dsl_cmd_cmp_param_h *) r->p;
561
562 (void) dsl_var_cmp_handle(r->d, &h->source, f);
563
564 break;
565 case DSL_PARAM_TYPE_COLOR:
566 g = (struct dsl_cmd_cmp_param_c *) r->p;
567
568 (void) dsl_var_cmp_color(r->d, &g->source, f, g->m);
569
570 break;
571 case DSL_PARAM_TYPE_IMAGE:
572 m = (struct dsl_cmd_cmp_param_m *) r->p;
573
574 (void) dsl_var_cmp_image(r->d, &m->source, f, m->m);
575
576 break;
577 case DSL_PARAM_TYPE_POINT:
578 t = (struct dsl_cmd_cmp_param_t *) r->p;
579
580 (void) dsl_var_cmp_point(r->d, &t->source, f, t->m);
581
582 break;
583 case DSL_PARAM_TYPE_VARIABLE:
584 v = (struct dsl_cmd_cmp_param_v *) r->p;
585
586 if(r->s == NULL) {
587 if((r->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
588 }
589
590 (void) dsl_var_cmp_variable(r->d, r->s, v->source.m, f);
591
592 break;
593 default:
594 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
595
596 return(-1);
597 }
598
599 return(0);
600 }
601
dsl_run_post_dec(struct dsl_cmd_dec * p,struct dsl_ctx * c,struct dsl_flg * f)602 static int dsl_run_post_dec(struct dsl_cmd_dec *p, struct dsl_ctx *c, struct dsl_flg *f) {
603 if(p == NULL) {
604 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
605
606 return(-1);
607 }
608
609 if(p->d == NULL) {
610 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
611 }
612
613 /* Inherit member type to cached destination variable */
614 p->d->m = p->destination.m;
615
616 (void) dsl_var_dec_number(p->d, f);
617
618 return(0);
619 }
620
dsl_run_post_div(struct dsl_cmd_div * p,struct dsl_ctx * c)621 static int dsl_run_post_div(struct dsl_cmd_div *p, struct dsl_ctx *c) {
622 struct dsl_cmd_div_param_n *n;
623 struct dsl_cmd_div_param_v *v;
624
625 if(p == NULL || p->p == NULL) {
626 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
627
628 return(-1);
629 }
630
631 if(p->d == NULL) {
632 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
633 }
634
635 /* Inherit member type to cached destination variable */
636 p->d->m = p->destination.m;
637
638 switch(p->c) {
639 case DSL_PARAM_TYPE_NUMBER:
640 n = (struct dsl_cmd_div_param_n *) p->p;
641
642 (void) dsl_var_div_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
643
644 break;
645 case DSL_PARAM_TYPE_VARIABLE:
646 v = (struct dsl_cmd_div_param_v *) p->p;
647
648 if(p->s == NULL) {
649 if((p->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
650 }
651
652 (void) dsl_var_div_variable(p->d, p->s, v->source.m);
653
654 break;
655 default:
656 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
657
658 return(-1);
659 }
660
661 return(0);
662 }
663
dsl_run_post_end(struct dsl_cmd_end * p,struct dsl_ctx * c)664 static int dsl_run_post_end(struct dsl_cmd_end *p, struct dsl_ctx *c) {
665 int r;
666
667 struct dsl_cmd_end_n *n;
668 struct dsl_cmd_end_v *v;
669
670 struct dsl_num q;
671
672 /* If there is no end code, leave */
673 if(p == NULL || p->p == NULL) return(0);
674
675 switch(p->c) {
676 case DSL_PARAM_TYPE_NUMBER:
677 n = (struct dsl_cmd_end_n *) p->p;
678
679 r = (int) dsl_num_get_number(DSL_NUMBER_TYPE_CHAR, &n->code);
680
681 break;
682 case DSL_PARAM_TYPE_VARIABLE:
683 (void) memset((void *) &q, 0, sizeof(q));
684
685 v = (struct dsl_cmd_end_v *) p->p;
686
687 if(v->cache == NULL) {
688 if((v->cache = dsl_var_find_struct_by_name(&v->code, c)) == NULL) return(-1);
689 }
690
691 /* Inherit member type to cached end code variable */
692 v->cache->m = v->code.m;
693
694 if(dsl_var_get_number(v->cache, &q) != 0) return(-1);
695
696 r = (int) dsl_num_get_number(DSL_NUMBER_TYPE_CHAR, &q);
697
698 break;
699 default:
700 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
701
702 return(-1);
703 }
704
705 return(r & 0xff);
706 }
707
dsl_run_post_func(struct dsl_cmd_func * p,struct dsl_ctx * c)708 static int dsl_run_post_func(struct dsl_cmd_func *p, struct dsl_ctx *c) {
709 int r;
710
711 char *a;
712
713 struct dsl_cmd_func_s *s;
714 struct dsl_cmd_func_v *v;
715
716 struct dsl_str e;
717
718 if(p == NULL || p->a == NULL || p->b == NULL) {
719 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
720
721 return(-1);
722 }
723
724 a = NULL;
725
726 e.string.s = NULL;
727 e.charset.s = NULL;
728
729 switch(p->c) {
730 case DSL_PARAM_TYPE_STRING:
731 if(p->h == 0) {
732 s = (struct dsl_cmd_func_s *) p->a;
733
734 a = s->function.string.s;
735 }
736
737 break;
738 case DSL_PARAM_TYPE_VARIABLE:
739 v = (struct dsl_cmd_func_v *) p->a;
740
741 if(v->cache_a == NULL) {
742 if((v->cache_a = dsl_var_find_struct_by_name(&v->function, c)) == NULL) return(-1);
743 }
744
745 /* Inherit member type to cached function variable */
746 v->cache_a->m = v->function.m;
747
748 if(dsl_var_get_string(v->cache_a, &e) != 0) return(-1);
749
750 a = e.string.s;
751
752 break;
753 default:
754 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
755
756 return(-1);
757 }
758
759 switch(p->d) {
760 case DSL_PARAM_TYPE_STRING:
761 if(p->h == 0) {
762 /* Resolve function symbol and cache it */
763 s = (struct dsl_cmd_func_s *) p->b;
764
765 if((p->h = dynload_func_open(a, s->function.string.s)) == 0) return(-1);
766
767 if(dsl_run_post_func_cache(c, p->h) != 0) {
768 (void) dynload_func_close(p->h);
769
770 p->h = 0;
771
772 return(-1);
773 }
774 }
775
776 break;
777 case DSL_PARAM_TYPE_VARIABLE:
778 v = (struct dsl_cmd_func_v *) p->b;
779
780 if(v->cache_b == NULL) {
781 if((v->cache_b = dsl_var_find_struct_by_name(&v->function, c)) == NULL) return(-1);
782 }
783
784 /* Inherit member type to cached function variable */
785 v->cache_b->m = v->function.m;
786
787 if(dsl_var_get_string(v->cache_b, &e) != 0) return(-1);
788
789 if((p->h = dynload_func_open(a, e.string.s)) == 0) return(-1);
790
791 break;
792 default:
793 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
794
795 return(-1);
796 }
797
798 /* Initialize possible function parameters */
799 if(dsl_run_post_func_param(p->q, c, p->h) != 0) return(-1);
800
801 /* Call function and get possible return value */
802 (void) dynload_func_call(p->h);
803
804 r = dsl_run_post_func_ret(p, c);
805
806 /* Close function handle if it cannot be cached because function is variable */
807 if(p->c == DSL_PARAM_TYPE_VARIABLE || p->d == DSL_PARAM_TYPE_VARIABLE) {
808 (void) dynload_func_close(p->h);
809
810 p->h = 0;
811 }
812
813 return(r);
814 }
815
dsl_run_post_func_cache(struct dsl_ctx * c,unsigned int h)816 static int dsl_run_post_func_cache(struct dsl_ctx *c, unsigned int h) {
817 unsigned int *t;
818
819 size_t u;
820
821 u = sizeof(unsigned int) * (c->f_cnt + 1);
822
823 APP_REALLOC_RET_VALUE(t, c->f_cache, u, -1);
824
825 c->f_cache[c->f_cnt++] = h;
826
827 return(0);
828 }
829
dsl_run_post_func_param(struct dsl_cmd_func_param * q,struct dsl_ctx * c,unsigned int d)830 static int dsl_run_post_func_param(struct dsl_cmd_func_param *q, struct dsl_ctx *c, unsigned int d) {
831 unsigned long i;
832
833 struct dsl_cmd_func_param_n *n;
834 struct dsl_cmd_func_param_s *s;
835 struct dsl_cmd_func_param_b *b;
836 struct dsl_cmd_func_param_p *p;
837 struct dsl_cmd_func_param_h *h;
838 struct dsl_cmd_func_param_c *g;
839 struct dsl_cmd_func_param_m *m;
840 struct dsl_cmd_func_param_t *t;
841 struct dsl_cmd_func_param_v *v;
842
843 struct dsl_cmd_func_param_n p_n;
844 struct dsl_cmd_func_param_s p_s;
845 struct dsl_cmd_func_param_b p_b;
846 struct dsl_cmd_func_param_p p_p;
847 struct dsl_cmd_func_param_h p_h;
848 struct dsl_cmd_func_param_c p_g;
849 struct dsl_cmd_func_param_m p_m;
850 struct dsl_cmd_func_param_t p_t;
851
852 /* If there is no defined parameters for function, leave */
853 if(q == NULL) return(0);
854
855 for(i = 0; ; i++) {
856 switch(q[i].c) {
857 case DSL_PARAM_TYPE_NONE:
858 return(0);
859 case DSL_PARAM_TYPE_NUMBER:
860 n = (struct dsl_cmd_func_param_n *) q[i].p;
861
862 (void) dsl_run_post_func_param_number(n, d);
863
864 break;
865 case DSL_PARAM_TYPE_STRING:
866 s = (struct dsl_cmd_func_param_s *) q[i].p;
867
868 (void) dsl_run_post_func_param_string(s, d);
869
870 break;
871 case DSL_PARAM_TYPE_BLOB:
872 b = (struct dsl_cmd_func_param_b *) q[i].p;
873
874 (void) dsl_run_post_func_param_blob(b, d);
875
876 break;
877 case DSL_PARAM_TYPE_POINTER:
878 p = (struct dsl_cmd_func_param_p *) q[i].p;
879
880 (void) dsl_run_post_func_param_pointer(p, d);
881
882 break;
883 case DSL_PARAM_TYPE_HANDLE:
884 h = (struct dsl_cmd_func_param_h *) q[i].p;
885
886 (void) dsl_run_post_func_param_handle(h, d);
887
888 break;
889 case DSL_PARAM_TYPE_COLOR:
890 g = (struct dsl_cmd_func_param_c *) q[i].p;
891
892 (void) dsl_run_post_func_param_color(g, d);
893
894 break;
895 case DSL_PARAM_TYPE_IMAGE:
896 m = (struct dsl_cmd_func_param_m *) q[i].p;
897
898 (void) dsl_run_post_func_param_image(m, d);
899
900 break;
901 case DSL_PARAM_TYPE_POINT:
902 t = (struct dsl_cmd_func_param_t *) q[i].p;
903
904 (void) dsl_run_post_func_param_point(t, d);
905
906 break;
907 case DSL_PARAM_TYPE_VARIABLE:
908 v = (struct dsl_cmd_func_param_v *) q[i].p;
909
910 if(v->cache == NULL) {
911 if((v->cache = dsl_var_find_struct_by_name(&v->parameter, c)) == NULL) return(-1);
912 }
913
914 /* Inherit member type to cached parameter variable */
915 v->cache->m = v->parameter.m;
916
917 switch(v->cache->c) {
918 case DSL_PARAM_TYPE_NONE:
919 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_VARIABLE_NOT_INITIALIZED);
920
921 return(-1);
922 case DSL_PARAM_TYPE_NUMBER:
923 (void) memset((void *) &p_n, 0, sizeof(p_n));
924
925 /* Set parameter type same as source type */
926 p_n.parameter.c = v->cache->number.c;
927
928 if(dsl_var_get_number(v->cache, &p_n.parameter) != 0) return(-1);
929
930 (void) dsl_run_post_func_param_number(&p_n, d);
931
932 break;
933 case DSL_PARAM_TYPE_STRING:
934 (void) memset((void *) &p_s, 0, sizeof(p_s));
935
936 p_s.parameter.string.s = NULL;
937 p_s.parameter.charset.s = NULL;
938
939 if(dsl_var_get_string(v->cache, &p_s.parameter) != 0) return(-1);
940
941 (void) dsl_run_post_func_param_string(&p_s, d);
942
943 break;
944 case DSL_PARAM_TYPE_BLOB:
945 (void) memset((void *) &p_b, 0, sizeof(p_b));
946
947 p_b.parameter.blob.s = NULL;
948
949 if(dsl_var_get_blob(v->cache, &p_b.parameter) != 0) return(-1);
950
951 (void) dsl_run_post_func_param_blob(&p_b, d);
952
953 break;
954 case DSL_PARAM_TYPE_POINTER:
955 (void) memset((void *) &p_p, 0, sizeof(p_p));
956
957 p_p.parameter.pointer = NULL;
958
959 if(dsl_var_get_pointer(v->cache, &p_p.parameter) != 0) return(-1);
960
961 (void) dsl_run_post_func_param_pointer(&p_p, d);
962
963 break;
964 case DSL_PARAM_TYPE_HANDLE:
965 (void) memset((void *) &p_h, 0, sizeof(p_h));
966
967 if(dsl_var_get_handle(v->cache, &p_h.parameter) != 0) return(-1);
968
969 (void) dsl_run_post_func_param_handle(&p_h, d);
970
971 break;
972 case DSL_PARAM_TYPE_COLOR:
973 (void) memset((void *) &p_g, 0, sizeof(p_g));
974
975 if(dsl_var_get_color(v->cache, &p_g.parameter) != 0) return(-1);
976
977 (void) dsl_run_post_func_param_color(&p_g, d);
978
979 break;
980 case DSL_PARAM_TYPE_IMAGE:
981 (void) memset((void *) &p_m, 0, sizeof(p_m));
982
983 p_m.parameter.image.s = NULL;
984
985 if(dsl_var_get_image(v->cache, &p_m.parameter) != 0) return(-1);
986
987 (void) dsl_run_post_func_param_image(&p_m, d);
988
989 break;
990 case DSL_PARAM_TYPE_POINT:
991 (void) memset((void *) &p_t, 0, sizeof(p_t));
992
993 if(dsl_var_get_point(v->cache, &p_t.parameter) != 0) return(-1);
994
995 (void) dsl_run_post_func_param_point(&p_t, d);
996
997 break;
998 default:
999 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1000
1001 return(-1);
1002 }
1003
1004 break;
1005 default:
1006 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1007
1008 return(-1);
1009 }
1010 }
1011
1012 return(0);
1013 }
1014
dsl_run_post_func_param_number(struct dsl_cmd_func_param_n * n,unsigned int h)1015 static void dsl_run_post_func_param_number(struct dsl_cmd_func_param_n *n, unsigned int h) {
1016 unsigned int c;
1017
1018 struct dsl_num *d;
1019
1020 c = n->parameter.c;
1021 d = &n->parameter;
1022
1023 switch(c) {
1024 case DSL_NUMBER_TYPE_I8:
1025 (void) dynload_param_add_i8(h, (int8_t) dsl_num_get_number(c, d));
1026
1027 break;
1028 case DSL_NUMBER_TYPE_I16:
1029 (void) dynload_param_add_i16(h, (int16_t) dsl_num_get_number(c, d));
1030
1031 break;
1032 case DSL_NUMBER_TYPE_I32:
1033 (void) dynload_param_add_i32(h, (int32_t) dsl_num_get_number(c, d));
1034
1035 break;
1036 case DSL_NUMBER_TYPE_I64:
1037 (void) dynload_param_add_i64(h, (int64_t) dsl_num_get_number(c, d));
1038
1039 break;
1040 #if defined(__SIZEOF_INT128__)
1041 case DSL_NUMBER_TYPE_I128:
1042 (void) dynload_param_add_i128(h, (__int128_t) dsl_num_get_number(c, d));
1043
1044 break;
1045 #endif
1046 case DSL_NUMBER_TYPE_U8:
1047 (void) dynload_param_add_u8(h, (uint8_t) dsl_num_get_number(c, d));
1048
1049 break;
1050 case DSL_NUMBER_TYPE_U16:
1051 (void) dynload_param_add_u16(h, (uint16_t) dsl_num_get_number(c, d));
1052
1053 break;
1054 case DSL_NUMBER_TYPE_U32:
1055 (void) dynload_param_add_u32(h, (uint32_t) dsl_num_get_number(c, d));
1056
1057 break;
1058 case DSL_NUMBER_TYPE_U64:
1059 (void) dynload_param_add_u64(h, (uint64_t) dsl_num_get_number(c, d));
1060
1061 break;
1062 #if defined(__SIZEOF_INT128__)
1063 case DSL_NUMBER_TYPE_U128:
1064 (void) dynload_param_add_u128(h, (__uint128_t) dsl_num_get_number(c, d));
1065
1066 break;
1067 #endif
1068 case DSL_NUMBER_TYPE_CHAR:
1069 (void) dynload_param_add_char(h, (char) dsl_num_get_number(c, d));
1070
1071 break;
1072 case DSL_NUMBER_TYPE_SHORT:
1073 (void) dynload_param_add_short(h, (short) dsl_num_get_number(c, d));
1074
1075 break;
1076 case DSL_NUMBER_TYPE_INT:
1077 (void) dynload_param_add_int(h, (int) dsl_num_get_number(c, d));
1078
1079 break;
1080 case DSL_NUMBER_TYPE_LONG:
1081 (void) dynload_param_add_long(h, (long) dsl_num_get_number(c, d));
1082
1083 break;
1084 case DSL_NUMBER_TYPE_UCHAR:
1085 (void) dynload_param_add_uchar(h, (unsigned char) dsl_num_get_number(c, d));
1086
1087 break;
1088 case DSL_NUMBER_TYPE_USHORT:
1089 (void) dynload_param_add_ushort(h, (unsigned short) dsl_num_get_number(c, d));
1090
1091 break;
1092 case DSL_NUMBER_TYPE_UINT:
1093 (void) dynload_param_add_uint(h, (unsigned int) dsl_num_get_number(c, d));
1094
1095 break;
1096 case DSL_NUMBER_TYPE_ULONG:
1097 (void) dynload_param_add_ulong(h, (unsigned long) dsl_num_get_number(c, d));
1098
1099 break;
1100 case DSL_NUMBER_TYPE_FLOAT:
1101 (void) dynload_param_add_float(h, (float) dsl_num_get_number(c, d));
1102
1103 break;
1104 default:
1105 (void) dynload_param_add_double(h, dsl_num_get_number(c, d));
1106
1107 break;
1108 }
1109 }
1110
dsl_run_post_func_param_string(struct dsl_cmd_func_param_s * s,unsigned int d)1111 static void dsl_run_post_func_param_string(struct dsl_cmd_func_param_s *s, unsigned int d) {
1112 (void) dynload_param_add_string(d, (void *) s->parameter.string.s, s->parameter.string.t);
1113 }
1114
dsl_run_post_func_param_blob(struct dsl_cmd_func_param_b * b,unsigned int d)1115 static void dsl_run_post_func_param_blob(struct dsl_cmd_func_param_b *b, unsigned int d) {
1116 (void) dynload_param_add_blob(d, (void *) b->parameter.blob.s, b->parameter.blob.t);
1117 }
1118
dsl_run_post_func_param_pointer(struct dsl_cmd_func_param_p * p,unsigned int d)1119 static void dsl_run_post_func_param_pointer(struct dsl_cmd_func_param_p *p, unsigned int d) {
1120 (void) dynload_param_add_pointer(d, p->parameter.pointer);
1121 }
1122
dsl_run_post_func_param_handle(struct dsl_cmd_func_param_h * h,unsigned int d)1123 static void dsl_run_post_func_param_handle(struct dsl_cmd_func_param_h *h, unsigned int d) {
1124 (void) dynload_param_add_handle(d, h->parameter.handle);
1125 }
1126
dsl_run_post_func_param_color(struct dsl_cmd_func_param_c * g,unsigned int d)1127 static void dsl_run_post_func_param_color(struct dsl_cmd_func_param_c *g, unsigned int d) {
1128 (void) dynload_param_add_color(d, (void *) &g->parameter);
1129 }
1130
dsl_run_post_func_param_image(struct dsl_cmd_func_param_m * m,unsigned int d)1131 static void dsl_run_post_func_param_image(struct dsl_cmd_func_param_m *m, unsigned int d) {
1132 (void) dynload_param_add_image(d, (void *) &m->parameter);
1133 }
1134
dsl_run_post_func_param_point(struct dsl_cmd_func_param_t * t,unsigned int d)1135 static void dsl_run_post_func_param_point(struct dsl_cmd_func_param_t *t, unsigned int d) {
1136 (void) dynload_param_add_point(d, (void *) &t->parameter);
1137 }
1138
dsl_run_post_func_ret(struct dsl_cmd_func * q,struct dsl_ctx * c)1139 static int dsl_run_post_func_ret(struct dsl_cmd_func *q, struct dsl_ctx *c) {
1140 unsigned int a;
1141
1142 struct dsl_num n, k;
1143 struct dsl_str s;
1144 struct dsl_blb b;
1145 struct dsl_ptr p;
1146 struct dsl_hnd h;
1147
1148 struct dsl_clr *g;
1149 struct dsl_img *m;
1150 struct dsl_pnt *t;
1151
1152 if(q->v == NULL) {
1153 /* Get variable struct for return code from global variable array */
1154 if((q->v = dsl_var_get_struct_by_name(&dsl_run_post_ret_var, &c->global)) == NULL) {
1155 return(-1);
1156 }
1157 }
1158
1159 a = dynload_func_call_ret_type(q->h);
1160
1161 switch(a) {
1162 case DSL_FUNC_RET_TYPE_NONE:
1163 (void) dsl_var_put_none(q->v);
1164
1165 break;
1166 case DSL_FUNC_RET_TYPE_STRING:
1167 (void) memset((void *) &s, 0, sizeof(s));
1168
1169 if((s.string.s = (char *) dynload_func_call_ret_string(q->h)) == NULL) return(-1);
1170
1171 s.string.t = dynload_func_call_ret_size(q->h);
1172 s.string.u = 0;
1173
1174 s.charset.s = CHARSET_DEFAULT;
1175 s.charset.t = CHARSET_DEFAULT_SIZE;
1176 s.charset.u = 0;
1177
1178 (void) dsl_var_put_string(q->v, &s);
1179
1180 /* Free storage allocated by wrapper function in dynload_bind[_app].c */
1181 (void) free(s.string.s);
1182
1183 break;
1184 case DSL_FUNC_RET_TYPE_BLOB:
1185 (void) memset((void *) &b, 0, sizeof(b));
1186
1187 if((b.blob.s = (char *) dynload_func_call_ret_blob(q->h)) == NULL) return(-1);
1188
1189 b.blob.t = dynload_func_call_ret_size(q->h);
1190 b.blob.u = 0;
1191
1192 b.s = NULL;
1193
1194 (void) dsl_var_put_blob(q->v, &b, NULL);
1195
1196 /* Free storage allocated by wrapper function in dynload_bind[_app].c */
1197 (void) free(b.blob.s);
1198
1199 break;
1200 case DSL_FUNC_RET_TYPE_POINTER:
1201 (void) memset((void *) &p, 0, sizeof(p));
1202
1203 p.pointer = dynload_func_call_ret_pointer(q->h);
1204
1205 (void) dsl_var_put_pointer(q->v, &p);
1206
1207 break;
1208 case DSL_FUNC_RET_TYPE_HANDLE:
1209 (void) memset((void *) &h, 0, sizeof(h));
1210
1211 h.handle = dynload_func_call_ret_handle(q->h);
1212
1213 (void) dsl_var_put_handle(q->v, &h);
1214
1215 break;
1216 case DSL_FUNC_RET_TYPE_COLOR:
1217 g = (struct dsl_clr *) dynload_func_call_ret_color(q->h);
1218
1219 (void) dsl_var_put_color(q->v, g, DSL_MEMBER_TYPE_NONE);
1220
1221 /* Free storage allocated by wrapper function in dynload_bind[_app].c */
1222 (void) free(g);
1223
1224 break;
1225 case DSL_FUNC_RET_TYPE_IMAGE:
1226 m = (struct dsl_img *) dynload_func_call_ret_image(q->h);
1227
1228 (void) dsl_var_put_image(q->v, m, NULL, DSL_MEMBER_TYPE_NONE);
1229
1230 /* Free storage allocated by wrapper function in dynload_bind[_app].c */
1231 (void) free(m->image.s);
1232 (void) free(m);
1233
1234 break;
1235 case DSL_FUNC_RET_TYPE_POINT:
1236 t = (struct dsl_pnt *) dynload_func_call_ret_point(q->h);
1237
1238 (void) dsl_var_put_point(q->v, t, DSL_MEMBER_TYPE_NONE);
1239
1240 /* Free storage allocated by wrapper function in dynload_bind[_app].c */
1241 (void) free(t);
1242
1243 break;
1244 default:
1245 (void) memset((void *) &n, 0, sizeof(n));
1246 (void) memset((void *) &k, 0, sizeof(k));
1247
1248 k.c = a;
1249 k.number.n = dynload_func_call_ret_number(q->h);
1250
1251 n.c = a;
1252 n.number.n = dsl_num_get_number(a, &k);
1253
1254 (void) dsl_var_put_number(q->v, &n, IS_NO);
1255
1256 /* Set return variable number type as function returned */
1257 q->v->number.c = n.c;
1258
1259 break;
1260 }
1261
1262 return(0);
1263 }
1264
dsl_run_post_inc(struct dsl_cmd_inc * p,struct dsl_ctx * c,struct dsl_flg * f)1265 static int dsl_run_post_inc(struct dsl_cmd_inc *p, struct dsl_ctx *c, struct dsl_flg *f) {
1266 if(p == NULL) {
1267 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
1268
1269 return(-1);
1270 }
1271
1272 if(p->d == NULL) {
1273 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
1274 }
1275
1276 /* Inherit member type to cached destination variable */
1277 p->d->m = p->destination.m;
1278
1279 (void) dsl_var_inc_number(p->d, f);
1280
1281 return(0);
1282 }
1283
dsl_run_post_label(struct dsl_cmd_label * p,struct dsl_ctx * c)1284 static int dsl_run_post_label(struct dsl_cmd_label *p, struct dsl_ctx *c) {
1285 /* If there are no variables for this scope and namespace switch is not needed, leave */
1286 if(p == NULL || p->d == 0) return(0);
1287
1288 /* Switch namespace, get this label local variables and put them into use */
1289 if((c->local = dsl_run_label_get_vars_by_index(p->o - 1)) == NULL) return(-1);
1290
1291 return(0);
1292 }
1293
dsl_run_post_mod(struct dsl_cmd_mod * p,struct dsl_ctx * c)1294 static int dsl_run_post_mod(struct dsl_cmd_mod *p, struct dsl_ctx *c) {
1295 struct dsl_cmd_mod_param_n *n;
1296 struct dsl_cmd_mod_param_v *v;
1297
1298 if(p == NULL || p->p == NULL) {
1299 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
1300
1301 return(-1);
1302 }
1303
1304 if(p->d == NULL) {
1305 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
1306 }
1307
1308 /* Inherit member type to cached destination variable */
1309 p->d->m = p->destination.m;
1310
1311 switch(p->c) {
1312 case DSL_PARAM_TYPE_NUMBER:
1313 n = (struct dsl_cmd_mod_param_n *) p->p;
1314
1315 (void) dsl_var_mod_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
1316
1317 break;
1318 case DSL_PARAM_TYPE_VARIABLE:
1319 v = (struct dsl_cmd_mod_param_v *) p->p;
1320
1321 if(p->s == NULL) {
1322 if((p->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
1323 }
1324
1325 (void) dsl_var_mod_variable(p->d, p->s, v->source.m);
1326
1327 break;
1328 default:
1329 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1330
1331 return(-1);
1332 }
1333
1334 return(0);
1335 }
1336
dsl_run_post_mov(struct dsl_cmd_mov * r,struct dsl_ctx * c)1337 static int dsl_run_post_mov(struct dsl_cmd_mov *r, struct dsl_ctx *c) {
1338 struct dsl_cmd_mov_param_n *n;
1339 struct dsl_cmd_mov_param_s *s;
1340 struct dsl_cmd_mov_param_b *b;
1341 struct dsl_cmd_mov_param_p *p;
1342 struct dsl_cmd_mov_param_h *h;
1343 struct dsl_cmd_mov_param_c *g;
1344 struct dsl_cmd_mov_param_m *m;
1345 struct dsl_cmd_mov_param_t *t;
1346 struct dsl_cmd_mov_param_v *v;
1347
1348 if(r == NULL || r->p == NULL) {
1349 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
1350
1351 return(-1);
1352 }
1353
1354 if(r->d == NULL) {
1355 if((r->d = dsl_run_post_var_get_or_create(&r->destination, c)) == NULL) return(-1);
1356 }
1357
1358 switch(r->c) {
1359 case DSL_PARAM_TYPE_NUMBER:
1360 n = (struct dsl_cmd_mov_param_n *) r->p;
1361
1362 (void) dsl_var_put_number(r->d, &n->source, IS_YES);
1363
1364 break;
1365 case DSL_PARAM_TYPE_STRING:
1366 s = (struct dsl_cmd_mov_param_s *) r->p;
1367
1368 (void) dsl_var_put_string(r->d, &s->source);
1369
1370 break;
1371 case DSL_PARAM_TYPE_BLOB:
1372 b = (struct dsl_cmd_mov_param_b *) r->p;
1373
1374 (void) dsl_var_put_blob(r->d, &b->source, b->source.s);
1375
1376 break;
1377 case DSL_PARAM_TYPE_POINTER:
1378 p = (struct dsl_cmd_mov_param_p *) r->p;
1379
1380 (void) dsl_var_put_pointer(r->d, &p->source);
1381
1382 break;
1383 case DSL_PARAM_TYPE_HANDLE:
1384 h = (struct dsl_cmd_mov_param_h *) r->p;
1385
1386 (void) dsl_var_put_handle(r->d, &h->source);
1387
1388 break;
1389 case DSL_PARAM_TYPE_COLOR:
1390 g = (struct dsl_cmd_mov_param_c *) r->p;
1391
1392 (void) dsl_var_put_color(r->d, &g->source, g->m);
1393
1394 break;
1395 case DSL_PARAM_TYPE_IMAGE:
1396 m = (struct dsl_cmd_mov_param_m *) r->p;
1397
1398 (void) dsl_var_put_image(r->d, &m->source, m->source.s, m->m);
1399
1400 break;
1401 case DSL_PARAM_TYPE_POINT:
1402 t = (struct dsl_cmd_mov_param_t *) r->p;
1403
1404 (void) dsl_var_put_point(r->d, &t->source, t->m);
1405
1406 break;
1407 case DSL_PARAM_TYPE_VARIABLE:
1408 v = (struct dsl_cmd_mov_param_v *) r->p;
1409
1410 if(r->s == NULL) {
1411 if((r->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
1412 }
1413
1414 (void) dsl_var_put_variable(r->d, r->s, r->s->c, v->source.m);
1415
1416 break;
1417 default:
1418 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1419
1420 return(-1);
1421 }
1422
1423 return(0);
1424 }
1425
dsl_run_post_mul(struct dsl_cmd_mul * p,struct dsl_ctx * c)1426 static int dsl_run_post_mul(struct dsl_cmd_mul *p, struct dsl_ctx *c) {
1427 struct dsl_cmd_mul_param_n *n;
1428 struct dsl_cmd_mul_param_v *v;
1429
1430 if(p == NULL || p->p == NULL) {
1431 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
1432
1433 return(-1);
1434 }
1435
1436 if(p->d == NULL) {
1437 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
1438 }
1439
1440 /* Inherit member type to cached destination variable */
1441 p->d->m = p->destination.m;
1442
1443 switch(p->c) {
1444 case DSL_PARAM_TYPE_NUMBER:
1445 n = (struct dsl_cmd_mul_param_n *) p->p;
1446
1447 (void) dsl_var_mul_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
1448
1449 break;
1450 case DSL_PARAM_TYPE_VARIABLE:
1451 v = (struct dsl_cmd_mul_param_v *) p->p;
1452
1453 if(p->s == NULL) {
1454 if((p->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
1455 }
1456
1457 (void) dsl_var_mul_variable(p->d, p->s, v->source.m);
1458
1459 break;
1460 default:
1461 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1462
1463 return(-1);
1464 }
1465
1466 return(0);
1467 }
1468
dsl_run_post_neg(struct dsl_cmd_neg * p,struct dsl_ctx * c,struct dsl_flg * f)1469 static int dsl_run_post_neg(struct dsl_cmd_neg *p, struct dsl_ctx *c, struct dsl_flg *f) {
1470 if(p == NULL) {
1471 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
1472
1473 return(-1);
1474 }
1475
1476 if(p->d == NULL) {
1477 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
1478 }
1479
1480 /* Inherit member type to cached destination variable */
1481 p->d->m = p->destination.m;
1482
1483 (void) dsl_var_neg_number(p->d, f, DSL_PARAM_TYPE_NUMBER);
1484
1485 return(0);
1486 }
1487
dsl_run_post_pow(struct dsl_cmd_pow * p,struct dsl_ctx * c)1488 static int dsl_run_post_pow(struct dsl_cmd_pow *p, struct dsl_ctx *c) {
1489 struct dsl_cmd_pow_param_n *n;
1490 struct dsl_cmd_pow_param_v *v;
1491
1492 if(p == NULL || p->p == NULL) {
1493 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
1494
1495 return(-1);
1496 }
1497
1498 if(p->d == NULL) {
1499 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
1500 }
1501
1502 /* Inherit member type to cached destination variable */
1503 p->d->m = p->destination.m;
1504
1505 switch(p->c) {
1506 case DSL_PARAM_TYPE_NUMBER:
1507 n = (struct dsl_cmd_pow_param_n *) p->p;
1508
1509 (void) dsl_var_pow_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
1510
1511 break;
1512 case DSL_PARAM_TYPE_VARIABLE:
1513 v = (struct dsl_cmd_pow_param_v *) p->p;
1514
1515 if(p->s == NULL) {
1516 if((p->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
1517 }
1518
1519 (void) dsl_var_pow_variable(p->d, p->s, v->source.m);
1520
1521 break;
1522 default:
1523 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1524
1525 return(-1);
1526 }
1527
1528 return(0);
1529 }
1530
dsl_run_post_rand(struct dsl_cmd_rand * p,struct dsl_ctx * c)1531 static int dsl_run_post_rand(struct dsl_cmd_rand *p, struct dsl_ctx *c) {
1532 struct dsl_cmd_rand_param_n *n;
1533 struct dsl_cmd_rand_param_v *v;
1534
1535 if(p == NULL || p->p == NULL) {
1536 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
1537
1538 return(-1);
1539 }
1540
1541 if(p->d == NULL) {
1542 if((p->d = dsl_run_post_var_get_or_create(&p->destination, c)) == NULL) return(-1);
1543 }
1544
1545 switch(p->c) {
1546 case DSL_PARAM_TYPE_NUMBER:
1547 n = (struct dsl_cmd_rand_param_n *) p->p;
1548
1549 (void) dsl_var_rand_number(p->d, &n->limit, DSL_PARAM_TYPE_NUMBER);
1550
1551 break;
1552 case DSL_PARAM_TYPE_VARIABLE:
1553 v = (struct dsl_cmd_rand_param_v *) p->p;
1554
1555 if(p->s == NULL) {
1556 if((p->s = dsl_var_find_struct_by_name(&v->limit, c)) == NULL) return(-1);
1557 }
1558
1559 (void) dsl_var_rand_variable(p->d, p->s, v->limit.m);
1560
1561 break;
1562 default:
1563 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1564
1565 return(-1);
1566 }
1567
1568 return(0);
1569 }
1570
dsl_run_post_ret(struct dsl_cmd_ret * r,struct dsl_ctx * c,unsigned long * i)1571 static int dsl_run_post_ret(struct dsl_cmd_ret *r, struct dsl_ctx *c, unsigned long *i) {
1572 struct dsl_cmd_ret_n *n;
1573 struct dsl_cmd_ret_s *s;
1574 struct dsl_cmd_ret_b *b;
1575 struct dsl_cmd_ret_p *p;
1576 struct dsl_cmd_ret_h *h;
1577 struct dsl_cmd_ret_c *g;
1578 struct dsl_cmd_ret_m *m;
1579 struct dsl_cmd_ret_t *t;
1580 struct dsl_cmd_ret_v *v;
1581
1582 struct dsl_stack a;
1583
1584 if(r != NULL && r->p != NULL) {
1585 if(r->v == NULL) {
1586 /* Get variable struct for return code from global variable array */
1587 if((r->v = dsl_var_get_struct_by_name(&dsl_run_post_ret_var, &c->global)) == NULL) {
1588 return(-1);
1589 }
1590 }
1591
1592 switch(r->c) {
1593 case DSL_PARAM_TYPE_NUMBER:
1594 n = (struct dsl_cmd_ret_n *) r->p;
1595
1596 (void) dsl_var_put_number(r->v, &n->code, IS_NO);
1597
1598 break;
1599 case DSL_PARAM_TYPE_STRING:
1600 s = (struct dsl_cmd_ret_s *) r->p;
1601
1602 (void) dsl_var_put_string(r->v, &s->code);
1603
1604 break;
1605 case DSL_PARAM_TYPE_BLOB:
1606 b = (struct dsl_cmd_ret_b *) r->p;
1607
1608 (void) dsl_var_put_blob(r->v, &b->code, b->code.s);
1609
1610 break;
1611 case DSL_PARAM_TYPE_POINTER:
1612 p = (struct dsl_cmd_ret_p *) r->p;
1613
1614 (void) dsl_var_put_pointer(r->v, &p->code);
1615
1616 break;
1617 case DSL_PARAM_TYPE_HANDLE:
1618 h = (struct dsl_cmd_ret_h *) r->p;
1619
1620 (void) dsl_var_put_handle(r->v, &h->code);
1621
1622 break;
1623 case DSL_PARAM_TYPE_COLOR:
1624 g = (struct dsl_cmd_ret_c *) r->p;
1625
1626 (void) dsl_var_put_color(r->v, &g->code, g->m);
1627
1628 break;
1629 case DSL_PARAM_TYPE_IMAGE:
1630 m = (struct dsl_cmd_ret_m *) r->p;
1631
1632 (void) dsl_var_put_image(r->v, &m->code, m->code.s, m->m);
1633
1634 break;
1635 case DSL_PARAM_TYPE_POINT:
1636 t = (struct dsl_cmd_ret_t *) r->p;
1637
1638 (void) dsl_var_put_point(r->v, &t->code, t->m);
1639
1640 break;
1641 case DSL_PARAM_TYPE_VARIABLE:
1642 v = (struct dsl_cmd_ret_v *) r->p;
1643
1644 if(v->cache == NULL) {
1645 if((v->cache = dsl_var_find_struct_by_name(&v->code, c)) == NULL) return(-1);
1646 }
1647
1648 (void) dsl_var_put_variable(r->v, v->cache, v->cache->c, v->code.m);
1649
1650 break;
1651 default:
1652 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1653
1654 return(-1);
1655 }
1656 }
1657
1658 /* Fetch program counter and local variables from stack */
1659 if(dsl_stack_node_pop(&a) != 0) {
1660 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_STACK_EMPTY);
1661
1662 return(-1);
1663 }
1664
1665 *i = a.n;
1666
1667 c->local = a.v;
1668
1669 return(0);
1670 }
1671
dsl_run_post_sub(struct dsl_cmd_sub * p,struct dsl_ctx * c,struct dsl_flg * f)1672 static int dsl_run_post_sub(struct dsl_cmd_sub *p, struct dsl_ctx *c, struct dsl_flg *f) {
1673 struct dsl_cmd_sub_param_n *n;
1674 struct dsl_cmd_sub_param_v *v;
1675
1676 if(p == NULL || p->p == NULL) {
1677 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
1678
1679 return(-1);
1680 }
1681
1682 if(p->d == NULL) {
1683 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
1684 }
1685
1686 /* Inherit member type to cached destination variable */
1687 p->d->m = p->destination.m;
1688
1689 switch(p->c) {
1690 case DSL_PARAM_TYPE_NUMBER:
1691 n = (struct dsl_cmd_sub_param_n *) p->p;
1692
1693 (void) dsl_var_sub_number(p->d, &n->source, f, DSL_PARAM_TYPE_NUMBER);
1694
1695 break;
1696 case DSL_PARAM_TYPE_VARIABLE:
1697 v = (struct dsl_cmd_sub_param_v *) p->p;
1698
1699 if(p->s == NULL) {
1700 if((p->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
1701 }
1702
1703 (void) dsl_var_sub_variable(p->d, p->s, v->source.m, f);
1704
1705 break;
1706 default:
1707 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1708
1709 return(-1);
1710 }
1711
1712 return(0);
1713 }
1714
dsl_run_post_xchg(struct dsl_cmd_xchg * p,struct dsl_ctx * c)1715 static int dsl_run_post_xchg(struct dsl_cmd_xchg *p, struct dsl_ctx *c) {
1716 struct dsl_cmd_xchg_param_v *v;
1717
1718 if(p == NULL || p->p == NULL) {
1719 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
1720
1721 return(-1);
1722 }
1723
1724 if(p->d == NULL) {
1725 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
1726 }
1727
1728 /* Inherit member type to cached destination variable */
1729 p->d->m = p->destination.m;
1730
1731 switch(p->c) {
1732 case DSL_PARAM_TYPE_VARIABLE:
1733 v = (struct dsl_cmd_xchg_param_v *) p->p;
1734
1735 if(p->s == NULL) {
1736 if((p->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
1737 }
1738
1739 (void) dsl_var_xchg_variable(p->d, p->s, v->source.m);
1740
1741 break;
1742 default:
1743 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1744
1745 return(-1);
1746 }
1747
1748 return(0);
1749 }
1750
dsl_run_post_flag(struct dsl_flg * f,unsigned int j)1751 static int dsl_run_post_flag(struct dsl_flg *f, unsigned int j) {
1752 switch(j) {
1753 case DSL_COMMAND_CLALL:
1754 f->ja = f->jb = f->je = f->js = f->jz = 0;
1755
1756 break;
1757 case DSL_COMMAND_CLA:
1758 f->ja = 0;
1759
1760 break;
1761 case DSL_COMMAND_CLB:
1762 f->jb = 0;
1763
1764 break;
1765 case DSL_COMMAND_CLE:
1766 f->je = 0;
1767
1768 break;
1769 case DSL_COMMAND_CLS:
1770 f->js = 0;
1771
1772 break;
1773 case DSL_COMMAND_CLZ:
1774 f->jz = 0;
1775
1776 break;
1777 case DSL_COMMAND_STALL:
1778 f->ja = f->jb = f->je = f->js = f->jz = 1;
1779
1780 break;
1781 case DSL_COMMAND_STA:
1782 f->ja = 1;
1783
1784 break;
1785 case DSL_COMMAND_STB:
1786 f->jb = 1;
1787
1788 break;
1789 case DSL_COMMAND_STE:
1790 f->je = 1;
1791
1792 break;
1793 case DSL_COMMAND_STS:
1794 f->js = 1;
1795
1796 break;
1797 case DSL_COMMAND_STZ:
1798 f->jz = 1;
1799
1800 break;
1801 default:
1802 break;
1803 }
1804
1805 return(0);
1806 }
1807
dsl_run_post_jmp(struct dsl_cmd_jmp * p,struct dsl_ctx * c,struct dsl_flg * f,unsigned int j,unsigned long * i)1808 static int dsl_run_post_jmp(struct dsl_cmd_jmp *p, struct dsl_ctx *c, struct dsl_flg *f, unsigned int j, unsigned long *i) {
1809 struct dsl_cmd_jmp_s *s;
1810 struct dsl_cmd_jmp_v *v;
1811
1812 struct dsl_str b;
1813
1814 if(p == NULL || p->p == NULL) {
1815 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
1816
1817 return(-1);
1818 }
1819
1820 switch(p->c) {
1821 case DSL_PARAM_TYPE_STRING:
1822 if(p->n == 0) {
1823 /* Resolve jump destination label and cache it */
1824 s = (struct dsl_cmd_jmp_s *) p->p;
1825
1826 if((p->n = dsl_run_label_get_node_by_name(&s->destination)) == 0) return(-1);
1827 }
1828
1829 break;
1830 case DSL_PARAM_TYPE_VARIABLE:
1831 v = (struct dsl_cmd_jmp_v *) p->p;
1832
1833 if(v->cache == NULL) {
1834 if((v->cache = dsl_var_find_struct_by_name(&v->destination, c)) == NULL) return(-1);
1835 }
1836
1837 /* Inherit member type to cached destination variable */
1838 v->cache->m = v->destination.m;
1839
1840 if(dsl_var_get_string(v->cache, &b) != 0) return(-1);
1841
1842 if((p->n = dsl_run_label_get_node_by_name(&b)) == 0) return(-1);
1843
1844 break;
1845 default:
1846 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1847
1848 return(-1);
1849 }
1850
1851 switch(j) {
1852 case DSL_COMMAND_JA:
1853 if(f->ja != 0) *i = p->n;
1854
1855 break;
1856 case DSL_COMMAND_JAE:
1857 if(f->ja != 0 || f->je != 0) *i = p->n;
1858
1859 break;
1860 case DSL_COMMAND_JB:
1861 if(f->jb != 0) *i = p->n;
1862
1863 break;
1864 case DSL_COMMAND_JBE:
1865 if(f->jb != 0 || f->je != 0) *i = p->n;
1866
1867 break;
1868 case DSL_COMMAND_JE:
1869 if(f->je != 0) *i = p->n;
1870
1871 break;
1872 case DSL_COMMAND_JNE:
1873 if(f->je == 0) *i = p->n;
1874
1875 break;
1876 case DSL_COMMAND_JS:
1877 if(f->js != 0) *i = p->n;
1878
1879 break;
1880 case DSL_COMMAND_JNS:
1881 if(f->js == 0) *i = p->n;
1882
1883 break;
1884 case DSL_COMMAND_JZ:
1885 if(f->jz != 0) *i = p->n;
1886
1887 break;
1888 case DSL_COMMAND_JNZ:
1889 if(f->jz == 0) *i = p->n;
1890
1891 break;
1892 case DSL_COMMAND_JMP:
1893 *i = p->n;
1894
1895 break;
1896 default:
1897 break;
1898 }
1899
1900 return(0);
1901 }
1902 #if ! defined(PROG_DISABLE_EXTENDED)
dsl_run_post_math2(struct dsl_cmd_math2 * p,struct dsl_ctx * c,struct dsl_flg * f,unsigned int j)1903 static int dsl_run_post_math2(struct dsl_cmd_math2 *p, struct dsl_ctx *c, struct dsl_flg *f, unsigned int j) {
1904 struct dsl_cmd_math2_param_n *n;
1905 struct dsl_cmd_math2_param_v *v;
1906
1907 if(p == NULL || p->p == NULL) {
1908 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
1909
1910 return(-1);
1911 }
1912
1913 if(p->d == NULL) {
1914 if((p->d = dsl_run_post_var_get_or_create(&p->destination, c)) == NULL) return(-1);
1915 }
1916
1917 switch(p->c) {
1918 case DSL_PARAM_TYPE_NUMBER:
1919 n = (struct dsl_cmd_math2_param_n *) p->p;
1920
1921 (void) dsl_run_post_math2_n(p, n, f, j);
1922
1923 break;
1924 case DSL_PARAM_TYPE_VARIABLE:
1925 v = (struct dsl_cmd_math2_param_v *) p->p;
1926
1927 if(p->s == NULL) {
1928 if((p->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
1929 }
1930
1931 (void) dsl_run_post_math2_v(p, v, f, j);
1932
1933 break;
1934 default:
1935 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
1936
1937 return(-1);
1938 }
1939
1940 return(0);
1941 }
1942
dsl_run_post_math2_n(struct dsl_cmd_math2 * p,struct dsl_cmd_math2_param_n * n,struct dsl_flg * f,unsigned int j)1943 static void dsl_run_post_math2_n(struct dsl_cmd_math2 *p, struct dsl_cmd_math2_param_n *n, struct dsl_flg *f, unsigned int j) {
1944 switch(j) {
1945 case DSL_COMMAND_NOT:
1946 (void) dsl_var_not_number(p->d, &n->source, f, DSL_PARAM_TYPE_NUMBER);
1947
1948 break;
1949 case DSL_COMMAND_TEST:
1950 (void) dsl_var_test_number(p->d, &n->source, f);
1951
1952 break;
1953 case DSL_COMMAND_ISFINITE:
1954 (void) dsl_var_isfinite_number(p->d, &n->source, f, DSL_PARAM_TYPE_NUMBER);
1955
1956 break;
1957 case DSL_COMMAND_ISINF:
1958 (void) dsl_var_isinf_number(p->d, &n->source, f, DSL_PARAM_TYPE_NUMBER);
1959
1960 break;
1961 case DSL_COMMAND_ISNAN:
1962 (void) dsl_var_isnan_number(p->d, &n->source, f, DSL_PARAM_TYPE_NUMBER);
1963
1964 break;
1965 case DSL_COMMAND_ISNORMAL:
1966 (void) dsl_var_isnormal_number(p->d, &n->source, f, DSL_PARAM_TYPE_NUMBER);
1967
1968 break;
1969 case DSL_COMMAND_SIGNBIT:
1970 (void) dsl_var_signbit_number(p->d, &n->source, f, DSL_PARAM_TYPE_NUMBER);
1971
1972 break;
1973 case DSL_COMMAND_NAN:
1974 (void) dsl_var_nan_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
1975
1976 break;
1977 case DSL_COMMAND_CEIL:
1978 (void) dsl_var_ceil_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
1979
1980 break;
1981 case DSL_COMMAND_FLOOR:
1982 (void) dsl_var_floor_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
1983
1984 break;
1985 case DSL_COMMAND_NEARBYINT:
1986 (void) dsl_var_nearbyint_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
1987
1988 break;
1989 case DSL_COMMAND_RINT:
1990 (void) dsl_var_rint_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
1991
1992 break;
1993 case DSL_COMMAND_ROUND:
1994 (void) dsl_var_round_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
1995
1996 break;
1997 case DSL_COMMAND_TRUNC:
1998 (void) dsl_var_trunc_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
1999
2000 break;
2001 case DSL_COMMAND_SQRT:
2002 (void) dsl_var_sqrt_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2003
2004 break;
2005 case DSL_COMMAND_CBRT:
2006 (void) dsl_var_cbrt_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2007
2008 break;
2009 case DSL_COMMAND_EXP:
2010 (void) dsl_var_exp_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2011
2012 break;
2013 case DSL_COMMAND_EXP2:
2014 (void) dsl_var_exp2_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2015
2016 break;
2017 case DSL_COMMAND_EXPM1:
2018 (void) dsl_var_expm1_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2019
2020 break;
2021 case DSL_COMMAND_LOG:
2022 (void) dsl_var_log_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2023
2024 break;
2025 case DSL_COMMAND_LOG2:
2026 (void) dsl_var_log2_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2027
2028 break;
2029 case DSL_COMMAND_LOG10:
2030 (void) dsl_var_log10_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2031
2032 break;
2033 case DSL_COMMAND_LOG1P:
2034 (void) dsl_var_log1p_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2035
2036 break;
2037 case DSL_COMMAND_LOGB:
2038 (void) dsl_var_logb_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2039
2040 break;
2041 case DSL_COMMAND_ILOGB:
2042 (void) dsl_var_ilogb_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2043
2044 break;
2045 case DSL_COMMAND_COS:
2046 (void) dsl_var_cos_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2047
2048 break;
2049 case DSL_COMMAND_COSH:
2050 (void) dsl_var_cosh_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2051
2052 break;
2053 case DSL_COMMAND_ACOS:
2054 (void) dsl_var_acos_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2055
2056 break;
2057 case DSL_COMMAND_ACOSH:
2058 (void) dsl_var_acosh_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2059
2060 break;
2061 case DSL_COMMAND_SIN:
2062 (void) dsl_var_sin_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2063
2064 break;
2065 case DSL_COMMAND_SINH:
2066 (void) dsl_var_sinh_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2067
2068 break;
2069 case DSL_COMMAND_ASIN:
2070 (void) dsl_var_asin_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2071
2072 break;
2073 case DSL_COMMAND_ASINH:
2074 (void) dsl_var_asinh_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2075
2076 break;
2077 case DSL_COMMAND_TAN:
2078 (void) dsl_var_tan_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2079
2080 break;
2081 case DSL_COMMAND_TANH:
2082 (void) dsl_var_tanh_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2083
2084 break;
2085 case DSL_COMMAND_ATAN:
2086 (void) dsl_var_atan_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2087
2088 break;
2089 case DSL_COMMAND_ATANH:
2090 (void) dsl_var_atanh_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2091
2092 break;
2093 case DSL_COMMAND_TGAMMA:
2094 (void) dsl_var_tgamma_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2095
2096 break;
2097 case DSL_COMMAND_LGAMMA:
2098 (void) dsl_var_lgamma_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2099
2100 break;
2101 case DSL_COMMAND_J0:
2102 (void) dsl_var_j0_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2103
2104 break;
2105 case DSL_COMMAND_J1:
2106 (void) dsl_var_j1_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2107
2108 break;
2109 case DSL_COMMAND_Y0:
2110 (void) dsl_var_y0_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2111
2112 break;
2113 case DSL_COMMAND_Y1:
2114 (void) dsl_var_y1_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2115
2116 break;
2117 case DSL_COMMAND_ERF:
2118 (void) dsl_var_erf_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2119
2120 break;
2121 case DSL_COMMAND_ERFC:
2122 (void) dsl_var_erfc_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2123
2124 break;
2125 case DSL_COMMAND_GDENS:
2126 (void) dsl_var_gdens_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2127
2128 break;
2129 case DSL_COMMAND_GDIST:
2130 (void) dsl_var_gdist_number(p->d, &n->source, DSL_PARAM_TYPE_NUMBER);
2131
2132 break;
2133 default:
2134 break;
2135 }
2136 }
2137
dsl_run_post_math2_v(struct dsl_cmd_math2 * p,struct dsl_cmd_math2_param_v * v,struct dsl_flg * f,unsigned int j)2138 static void dsl_run_post_math2_v(struct dsl_cmd_math2 *p, struct dsl_cmd_math2_param_v *v, struct dsl_flg *f, unsigned int j) {
2139 switch(j) {
2140 case DSL_COMMAND_NOT:
2141 (void) dsl_var_not_variable(p->d, p->s, v->source.m, f);
2142
2143 break;
2144 case DSL_COMMAND_TEST:
2145 (void) dsl_var_test_variable(p->d, p->s, v->source.m, f);
2146
2147 break;
2148 case DSL_COMMAND_ISFINITE:
2149 (void) dsl_var_isfinite_variable(p->d, p->s, v->source.m, f);
2150
2151 break;
2152 case DSL_COMMAND_ISINF:
2153 (void) dsl_var_isinf_variable(p->d, p->s, v->source.m, f);
2154
2155 break;
2156 case DSL_COMMAND_ISNAN:
2157 (void) dsl_var_isnan_variable(p->d, p->s, v->source.m, f);
2158
2159 break;
2160 case DSL_COMMAND_ISNORMAL:
2161 (void) dsl_var_isnormal_variable(p->d, p->s, v->source.m, f);
2162
2163 break;
2164 case DSL_COMMAND_SIGNBIT:
2165 (void) dsl_var_signbit_variable(p->d, p->s, v->source.m, f);
2166
2167 break;
2168 case DSL_COMMAND_NAN:
2169 (void) dsl_var_nan_variable(p->d, p->s, v->source.m);
2170
2171 break;
2172 case DSL_COMMAND_CEIL:
2173 (void) dsl_var_ceil_variable(p->d, p->s, v->source.m);
2174
2175 break;
2176 case DSL_COMMAND_FLOOR:
2177 (void) dsl_var_floor_variable(p->d, p->s, v->source.m);
2178
2179 break;
2180 case DSL_COMMAND_NEARBYINT:
2181 (void) dsl_var_nearbyint_variable(p->d, p->s, v->source.m);
2182
2183 break;
2184 case DSL_COMMAND_RINT:
2185 (void) dsl_var_rint_variable(p->d, p->s, v->source.m);
2186
2187 break;
2188 case DSL_COMMAND_ROUND:
2189 (void) dsl_var_round_variable(p->d, p->s, v->source.m);
2190
2191 break;
2192 case DSL_COMMAND_TRUNC:
2193 (void) dsl_var_trunc_variable(p->d, p->s, v->source.m);
2194
2195 break;
2196 case DSL_COMMAND_SQRT:
2197 (void) dsl_var_sqrt_variable(p->d, p->s, v->source.m);
2198
2199 break;
2200 case DSL_COMMAND_CBRT:
2201 (void) dsl_var_cbrt_variable(p->d, p->s, v->source.m);
2202
2203 break;
2204 case DSL_COMMAND_EXP:
2205 (void) dsl_var_exp_variable(p->d, p->s, v->source.m);
2206
2207 break;
2208 case DSL_COMMAND_EXP2:
2209 (void) dsl_var_exp2_variable(p->d, p->s, v->source.m);
2210
2211 break;
2212 case DSL_COMMAND_EXPM1:
2213 (void) dsl_var_expm1_variable(p->d, p->s, v->source.m);
2214
2215 break;
2216 case DSL_COMMAND_LOG:
2217 (void) dsl_var_log_variable(p->d, p->s, v->source.m);
2218
2219 break;
2220 case DSL_COMMAND_LOG2:
2221 (void) dsl_var_log2_variable(p->d, p->s, v->source.m);
2222
2223 break;
2224 case DSL_COMMAND_LOG10:
2225 (void) dsl_var_log10_variable(p->d, p->s, v->source.m);
2226
2227 break;
2228 case DSL_COMMAND_LOG1P:
2229 (void) dsl_var_log1p_variable(p->d, p->s, v->source.m);
2230
2231 break;
2232 case DSL_COMMAND_LOGB:
2233 (void) dsl_var_logb_variable(p->d, p->s, v->source.m);
2234
2235 break;
2236 case DSL_COMMAND_ILOGB:
2237 (void) dsl_var_ilogb_variable(p->d, p->s, v->source.m);
2238
2239 break;
2240 case DSL_COMMAND_COS:
2241 (void) dsl_var_cos_variable(p->d, p->s, v->source.m);
2242
2243 break;
2244 case DSL_COMMAND_COSH:
2245 (void) dsl_var_cosh_variable(p->d, p->s, v->source.m);
2246
2247 break;
2248 case DSL_COMMAND_ACOS:
2249 (void) dsl_var_acos_variable(p->d, p->s, v->source.m);
2250
2251 break;
2252 case DSL_COMMAND_ACOSH:
2253 (void) dsl_var_acosh_variable(p->d, p->s, v->source.m);
2254
2255 break;
2256 case DSL_COMMAND_SIN:
2257 (void) dsl_var_sin_variable(p->d, p->s, v->source.m);
2258
2259 break;
2260 case DSL_COMMAND_SINH:
2261 (void) dsl_var_sinh_variable(p->d, p->s, v->source.m);
2262
2263 break;
2264 case DSL_COMMAND_ASIN:
2265 (void) dsl_var_asin_variable(p->d, p->s, v->source.m);
2266
2267 break;
2268 case DSL_COMMAND_ASINH:
2269 (void) dsl_var_asinh_variable(p->d, p->s, v->source.m);
2270
2271 break;
2272 case DSL_COMMAND_TAN:
2273 (void) dsl_var_tan_variable(p->d, p->s, v->source.m);
2274
2275 break;
2276 case DSL_COMMAND_TANH:
2277 (void) dsl_var_tanh_variable(p->d, p->s, v->source.m);
2278
2279 break;
2280 case DSL_COMMAND_ATAN:
2281 (void) dsl_var_atan_variable(p->d, p->s, v->source.m);
2282
2283 break;
2284 case DSL_COMMAND_ATANH:
2285 (void) dsl_var_atanh_variable(p->d, p->s, v->source.m);
2286
2287 break;
2288 case DSL_COMMAND_TGAMMA:
2289 (void) dsl_var_tgamma_variable(p->d, p->s, v->source.m);
2290
2291 break;
2292 case DSL_COMMAND_LGAMMA:
2293 (void) dsl_var_lgamma_variable(p->d, p->s, v->source.m);
2294
2295 break;
2296 case DSL_COMMAND_J0:
2297 (void) dsl_var_j0_variable(p->d, p->s, v->source.m);
2298
2299 break;
2300 case DSL_COMMAND_J1:
2301 (void) dsl_var_j1_variable(p->d, p->s, v->source.m);
2302
2303 break;
2304 case DSL_COMMAND_Y0:
2305 (void) dsl_var_y0_variable(p->d, p->s, v->source.m);
2306
2307 break;
2308 case DSL_COMMAND_Y1:
2309 (void) dsl_var_y1_variable(p->d, p->s, v->source.m);
2310
2311 break;
2312 case DSL_COMMAND_ERF:
2313 (void) dsl_var_erf_variable(p->d, p->s, v->source.m);
2314
2315 break;
2316 case DSL_COMMAND_ERFC:
2317 (void) dsl_var_erfc_variable(p->d, p->s, v->source.m);
2318
2319 break;
2320 case DSL_COMMAND_GDENS:
2321 (void) dsl_var_gdens_variable(p->d, p->s, v->source.m);
2322
2323 break;
2324 case DSL_COMMAND_GDIST:
2325 (void) dsl_var_gdist_variable(p->d, p->s, v->source.m);
2326
2327 break;
2328 default:
2329 break;
2330 }
2331 }
2332
dsl_run_post_math3(struct dsl_cmd_math3 * p,struct dsl_ctx * c,struct dsl_flg * f,unsigned int j)2333 static int dsl_run_post_math3(struct dsl_cmd_math3 *p, struct dsl_ctx *c, struct dsl_flg *f, unsigned int j) {
2334 unsigned int m_a, m_b;
2335
2336 struct dsl_cmd_math3_param_n *n;
2337 struct dsl_cmd_math3_param_v *v_a, *v_b;
2338
2339 struct dsl_var a, b;
2340
2341 if(p == NULL || p->p_a == NULL || p->p_b == NULL) {
2342 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
2343
2344 return(-1);
2345 }
2346
2347 if(p->d == NULL) {
2348 if((p->d = dsl_run_post_var_get_or_create(&p->destination, c)) == NULL) return(-1);
2349 }
2350
2351 switch(p->c_a) {
2352 case DSL_PARAM_TYPE_NUMBER:
2353 (void) memset((void *) &a, 0, sizeof(a));
2354
2355 n = (struct dsl_cmd_math3_param_n *) p->p_a;
2356
2357 a.c = DSL_PARAM_TYPE_NUMBER;
2358
2359 a.number.c = n->source.c;
2360 a.number.number.n = n->source.number.n;
2361
2362 a.number.rpn.r.string.s = NULL;
2363 a.number.rpn.r.charset.s = NULL;
2364
2365 p->s_a = &a;
2366
2367 m_a = DSL_PARAM_TYPE_NUMBER;
2368
2369 break;
2370 case DSL_PARAM_TYPE_VARIABLE:
2371 v_a = (struct dsl_cmd_math3_param_v *) p->p_a;
2372
2373 if(p->s_a == NULL) {
2374 if((p->s_a = dsl_var_find_struct_by_name(&v_a->source, c)) == NULL) return(-1);
2375 }
2376
2377 m_a = v_a->source.m;
2378
2379 break;
2380 default:
2381 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
2382
2383 return(-1);
2384 }
2385
2386 switch(p->c_b) {
2387 case DSL_PARAM_TYPE_NUMBER:
2388 (void) memset((void *) &b, 0, sizeof(b));
2389
2390 n = (struct dsl_cmd_math3_param_n *) p->p_b;
2391
2392 b.c = DSL_PARAM_TYPE_NUMBER;
2393
2394 b.number.c = n->source.c;
2395 b.number.number.n = n->source.number.n;
2396
2397 b.number.rpn.r.string.s = NULL;
2398 b.number.rpn.r.charset.s = NULL;
2399
2400 p->s_b = &b;
2401
2402 m_b = DSL_PARAM_TYPE_NUMBER;
2403
2404 break;
2405 case DSL_PARAM_TYPE_VARIABLE:
2406 v_b = (struct dsl_cmd_math3_param_v *) p->p_b;
2407
2408 if(p->s_b == NULL) {
2409 if((p->s_b = dsl_var_find_struct_by_name(&v_b->source, c)) == NULL) return(-1);
2410 }
2411
2412 m_b = v_b->source.m;
2413
2414 break;
2415 default:
2416 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
2417
2418 return(-1);
2419 }
2420
2421 switch(j) {
2422 case DSL_COMMAND_AND:
2423 (void) dsl_var_and_variable(p->d, p->s_a, p->s_b, m_a, m_b, f);
2424
2425 break;
2426 case DSL_COMMAND_OR:
2427 (void) dsl_var_or_variable(p->d, p->s_a, p->s_b, m_a, m_b, f);
2428
2429 break;
2430 case DSL_COMMAND_XOR:
2431 (void) dsl_var_xor_variable(p->d, p->s_a, p->s_b, m_a, m_b, f);
2432
2433 break;
2434 case DSL_COMMAND_COPYSIGN:
2435 (void) dsl_var_copysign_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2436
2437 break;
2438 case DSL_COMMAND_NEXTAFTER:
2439 (void) dsl_var_nextafter_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2440
2441 break;
2442 case DSL_COMMAND_NEXTTOWARD:
2443 (void) dsl_var_nexttoward_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2444
2445 break;
2446 case DSL_COMMAND_REMAINDER:
2447 (void) dsl_var_remainder_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2448
2449 break;
2450 case DSL_COMMAND_DIM:
2451 (void) dsl_var_dim_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2452
2453 break;
2454 case DSL_COMMAND_MAX:
2455 (void) dsl_var_max_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2456
2457 break;
2458 case DSL_COMMAND_MIN:
2459 (void) dsl_var_min_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2460
2461 break;
2462 case DSL_COMMAND_HYPOT:
2463 (void) dsl_var_hypot_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2464
2465 break;
2466 case DSL_COMMAND_LDEXP:
2467 (void) dsl_var_ldexp_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2468
2469 break;
2470 case DSL_COMMAND_SCALBN:
2471 (void) dsl_var_scalbn_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2472
2473 break;
2474 case DSL_COMMAND_ATAN2:
2475 (void) dsl_var_atan2_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2476
2477 break;
2478 case DSL_COMMAND_JN:
2479 (void) dsl_var_jn_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2480
2481 break;
2482 case DSL_COMMAND_YN:
2483 (void) dsl_var_yn_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2484
2485 break;
2486 case DSL_COMMAND_GRAND:
2487 (void) dsl_var_grand_variable(p->d, p->s_a, p->s_b, m_a, m_b);
2488
2489 break;
2490 default:
2491 break;
2492 }
2493
2494 return(0);
2495 }
2496
dsl_run_post_math4(struct dsl_cmd_math3 * p,struct dsl_ctx * c,unsigned int j)2497 static int dsl_run_post_math4(struct dsl_cmd_math3 *p, struct dsl_ctx *c, unsigned int j) {
2498 unsigned int m_a;
2499
2500 struct dsl_cmd_math3_param_n *n;
2501 struct dsl_cmd_math3_param_v *v_a, *v_b;
2502
2503 struct dsl_var a;
2504
2505 if(p == NULL || p->p_a == NULL || p->p_b == NULL) {
2506 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
2507
2508 return(-1);
2509 }
2510
2511 if(p->d == NULL) {
2512 if((p->d = dsl_run_post_var_get_or_create(&p->destination, c)) == NULL) return(-1);
2513 }
2514
2515 switch(p->c_a) {
2516 case DSL_PARAM_TYPE_NUMBER:
2517 (void) memset((void *) &a, 0, sizeof(a));
2518
2519 n = (struct dsl_cmd_math3_param_n *) p->p_a;
2520
2521 a.c = DSL_PARAM_TYPE_NUMBER;
2522
2523 a.number.c = n->source.c;
2524 a.number.number.n = n->source.number.n;
2525
2526 a.number.rpn.r.string.s = NULL;
2527 a.number.rpn.r.charset.s = NULL;
2528
2529 p->s_a = &a;
2530
2531 m_a = DSL_PARAM_TYPE_NUMBER;
2532
2533 break;
2534 case DSL_PARAM_TYPE_VARIABLE:
2535 v_a = (struct dsl_cmd_math3_param_v *) p->p_a;
2536
2537 if(p->s_a == NULL) {
2538 if((p->s_a = dsl_var_find_struct_by_name(&v_a->source, c)) == NULL) return(-1);
2539 }
2540
2541 m_a = v_a->source.m;
2542
2543 break;
2544 default:
2545 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
2546
2547 return(-1);
2548 }
2549
2550 if(p->s_b == NULL) {
2551 switch(p->c_b) {
2552 case DSL_PARAM_TYPE_VARIABLE:
2553 v_b = (struct dsl_cmd_math3_param_v *) p->p_b;
2554
2555 if((p->s_b = dsl_var_find_struct_by_name(&v_b->source, c)) == NULL) return(-1);
2556
2557 break;
2558 default:
2559 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
2560
2561 return(-1);
2562 }
2563 }
2564
2565 switch(j) {
2566 case DSL_COMMAND_MODF:
2567 (void) dsl_var_modf_variable(p->d, p->s_a, p->s_b, m_a);
2568
2569 break;
2570 case DSL_COMMAND_FREXP:
2571 (void) dsl_var_frexp_variable(p->d, p->s_a, p->s_b, m_a);
2572
2573 break;
2574 default:
2575 break;
2576 }
2577
2578 return(0);
2579 }
2580
dsl_run_post_math5(struct dsl_cmd_math4 * p,struct dsl_ctx * c,unsigned int j)2581 static int dsl_run_post_math5(struct dsl_cmd_math4 *p, struct dsl_ctx *c, unsigned int j) {
2582 unsigned int m_a, m_b, m_c;
2583
2584 struct dsl_cmd_math4_param_n *n;
2585 struct dsl_cmd_math4_param_v *v_a, *v_b, *v_c;
2586
2587 struct dsl_var a, b, d;
2588
2589 if(p == NULL || p->p_a == NULL || p->p_b == NULL || p->p_c == NULL) {
2590 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
2591
2592 return(-1);
2593 }
2594
2595 if(p->d == NULL) {
2596 if((p->d = dsl_run_post_var_get_or_create(&p->destination, c)) == NULL) return(-1);
2597 }
2598
2599 switch(p->c_a) {
2600 case DSL_PARAM_TYPE_NUMBER:
2601 (void) memset((void *) &a, 0, sizeof(a));
2602
2603 n = (struct dsl_cmd_math4_param_n *) p->p_a;
2604
2605 a.c = DSL_PARAM_TYPE_NUMBER;
2606
2607 a.number.c = n->source.c;
2608 a.number.number.n = n->source.number.n;
2609
2610 a.number.rpn.r.string.s = NULL;
2611 a.number.rpn.r.charset.s = NULL;
2612
2613 p->s_a = &a;
2614
2615 m_a = DSL_PARAM_TYPE_NUMBER;
2616
2617 break;
2618 case DSL_PARAM_TYPE_VARIABLE:
2619 v_a = (struct dsl_cmd_math4_param_v *) p->p_a;
2620
2621 if(p->s_a == NULL) {
2622 if((p->s_a = dsl_var_find_struct_by_name(&v_a->source, c)) == NULL) return(-1);
2623 }
2624
2625 m_a = v_a->source.m;
2626
2627 break;
2628 default:
2629 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
2630
2631 return(-1);
2632 }
2633
2634 switch(p->c_b) {
2635 case DSL_PARAM_TYPE_NUMBER:
2636 (void) memset((void *) &b, 0, sizeof(b));
2637
2638 n = (struct dsl_cmd_math4_param_n *) p->p_b;
2639
2640 b.c = DSL_PARAM_TYPE_NUMBER;
2641
2642 b.number.c = n->source.c;
2643 b.number.number.n = n->source.number.n;
2644
2645 b.number.rpn.r.string.s = NULL;
2646 b.number.rpn.r.charset.s = NULL;
2647
2648 p->s_b = &b;
2649
2650 m_b = DSL_PARAM_TYPE_NUMBER;
2651
2652 break;
2653 case DSL_PARAM_TYPE_VARIABLE:
2654 v_b = (struct dsl_cmd_math4_param_v *) p->p_b;
2655
2656 if(p->s_b == NULL) {
2657 if((p->s_b = dsl_var_find_struct_by_name(&v_b->source, c)) == NULL) return(-1);
2658 }
2659
2660 m_b = v_b->source.m;
2661
2662 break;
2663 default:
2664 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
2665
2666 return(-1);
2667 }
2668
2669 switch(p->c_c) {
2670 case DSL_PARAM_TYPE_NUMBER:
2671 (void) memset((void *) &d, 0, sizeof(d));
2672
2673 n = (struct dsl_cmd_math4_param_n *) p->p_c;
2674
2675 d.c = DSL_PARAM_TYPE_NUMBER;
2676
2677 d.number.c = n->source.c;
2678 d.number.number.n = n->source.number.n;
2679
2680 d.number.rpn.r.string.s = NULL;
2681 d.number.rpn.r.charset.s = NULL;
2682
2683 p->s_c = &d;
2684
2685 m_c = DSL_PARAM_TYPE_NUMBER;
2686
2687 break;
2688 case DSL_PARAM_TYPE_VARIABLE:
2689 v_c = (struct dsl_cmd_math4_param_v *) p->p_c;
2690
2691 if(p->s_c == NULL) {
2692 if((p->s_c = dsl_var_find_struct_by_name(&v_c->source, c)) == NULL) return(-1);
2693 }
2694
2695 m_c = v_c->source.m;
2696
2697 break;
2698 default:
2699 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
2700
2701 return(-1);
2702 }
2703
2704 switch(j) {
2705 case DSL_COMMAND_FMA:
2706 (void) dsl_var_fma_variable(p->d, p->s_a, p->s_b, p->s_c, m_a, m_b, m_c);
2707
2708 break;
2709 default:
2710 break;
2711 }
2712
2713 return(0);
2714 }
2715
dsl_run_post_crc32(struct dsl_cmd_crc32 * p,struct dsl_ctx * c)2716 static int dsl_run_post_crc32(struct dsl_cmd_crc32 *p, struct dsl_ctx *c) {
2717 struct dsl_cmd_crc32_param_n *n;
2718 struct dsl_cmd_crc32_param_s *s;
2719 struct dsl_cmd_crc32_param_b *b;
2720 struct dsl_cmd_crc32_param_p *o;
2721 struct dsl_cmd_crc32_param_h *h;
2722 struct dsl_cmd_crc32_param_c *g;
2723 struct dsl_cmd_crc32_param_m *m;
2724 struct dsl_cmd_crc32_param_t *t;
2725 struct dsl_cmd_crc32_param_v *v;
2726
2727 if(p == NULL || p->p == NULL) {
2728 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
2729
2730 return(-1);
2731 }
2732
2733 if(p->d == NULL) {
2734 if((p->d = dsl_run_post_var_get_or_create(&p->destination, c)) == NULL) return(-1);
2735 }
2736
2737 switch(p->c) {
2738 case DSL_PARAM_TYPE_NUMBER:
2739 n = (struct dsl_cmd_crc32_param_n *) p->p;
2740
2741 (void) dsl_var_crc32_number(p->d, &n->source);
2742
2743 break;
2744 case DSL_PARAM_TYPE_STRING:
2745 s = (struct dsl_cmd_crc32_param_s *) p->p;
2746
2747 (void) dsl_var_crc32_string(p->d, &s->source);
2748
2749 break;
2750 case DSL_PARAM_TYPE_BLOB:
2751 b = (struct dsl_cmd_crc32_param_b *) p->p;
2752
2753 (void) dsl_var_crc32_blob(p->d, &b->source);
2754
2755 break;
2756 case DSL_PARAM_TYPE_POINTER:
2757 o = (struct dsl_cmd_crc32_param_p *) p->p;
2758
2759 (void) dsl_var_crc32_pointer(p->d, &o->source);
2760
2761 break;
2762 case DSL_PARAM_TYPE_HANDLE:
2763 h = (struct dsl_cmd_crc32_param_h *) p->p;
2764
2765 (void) dsl_var_crc32_handle(p->d, &h->source);
2766
2767 break;
2768 case DSL_PARAM_TYPE_COLOR:
2769 g = (struct dsl_cmd_crc32_param_c *) p->p;
2770
2771 (void) dsl_var_crc32_color(p->d, &g->source, g->m);
2772
2773 break;
2774 case DSL_PARAM_TYPE_IMAGE:
2775 m = (struct dsl_cmd_crc32_param_m *) p->p;
2776
2777 (void) dsl_var_crc32_image(p->d, &m->source, m->m);
2778
2779 break;
2780 case DSL_PARAM_TYPE_POINT:
2781 t = (struct dsl_cmd_crc32_param_t *) p->p;
2782
2783 (void) dsl_var_crc32_point(p->d, &t->source, t->m);
2784
2785 break;
2786 case DSL_PARAM_TYPE_VARIABLE:
2787 v = (struct dsl_cmd_crc32_param_v *) p->p;
2788
2789 if(p->s == NULL) {
2790 if((p->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
2791 }
2792
2793 (void) dsl_var_crc32_variable(p->d, p->s, v->source.m);
2794
2795 break;
2796 default:
2797 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
2798
2799 return(-1);
2800 }
2801
2802 return(0);
2803 }
2804
dsl_run_post_crc64(struct dsl_cmd_crc64 * p,struct dsl_ctx * c)2805 static int dsl_run_post_crc64(struct dsl_cmd_crc64 *p, struct dsl_ctx *c) {
2806 struct dsl_cmd_crc64_param_n *n;
2807 struct dsl_cmd_crc64_param_s *s;
2808 struct dsl_cmd_crc64_param_b *b;
2809 struct dsl_cmd_crc64_param_p *o;
2810 struct dsl_cmd_crc64_param_h *h;
2811 struct dsl_cmd_crc64_param_c *g;
2812 struct dsl_cmd_crc64_param_m *m;
2813 struct dsl_cmd_crc64_param_t *t;
2814 struct dsl_cmd_crc64_param_v *v;
2815
2816 if(p == NULL || p->p == NULL) {
2817 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
2818
2819 return(-1);
2820 }
2821
2822 if(p->d == NULL) {
2823 if((p->d = dsl_run_post_var_get_or_create(&p->destination, c)) == NULL) return(-1);
2824 }
2825
2826 switch(p->c) {
2827 case DSL_PARAM_TYPE_NUMBER:
2828 n = (struct dsl_cmd_crc64_param_n *) p->p;
2829
2830 (void) dsl_var_crc64_number(p->d, &n->source);
2831
2832 break;
2833 case DSL_PARAM_TYPE_STRING:
2834 s = (struct dsl_cmd_crc64_param_s *) p->p;
2835
2836 (void) dsl_var_crc64_string(p->d, &s->source);
2837
2838 break;
2839 case DSL_PARAM_TYPE_BLOB:
2840 b = (struct dsl_cmd_crc64_param_b *) p->p;
2841
2842 (void) dsl_var_crc64_blob(p->d, &b->source);
2843
2844 break;
2845 case DSL_PARAM_TYPE_POINTER:
2846 o = (struct dsl_cmd_crc64_param_p *) p->p;
2847
2848 (void) dsl_var_crc64_pointer(p->d, &o->source);
2849
2850 break;
2851 case DSL_PARAM_TYPE_HANDLE:
2852 h = (struct dsl_cmd_crc64_param_h *) p->p;
2853
2854 (void) dsl_var_crc64_handle(p->d, &h->source);
2855
2856 break;
2857 case DSL_PARAM_TYPE_COLOR:
2858 g = (struct dsl_cmd_crc64_param_c *) p->p;
2859
2860 (void) dsl_var_crc64_color(p->d, &g->source, g->m);
2861
2862 break;
2863 case DSL_PARAM_TYPE_IMAGE:
2864 m = (struct dsl_cmd_crc64_param_m *) p->p;
2865
2866 (void) dsl_var_crc64_image(p->d, &m->source, m->m);
2867
2868 break;
2869 case DSL_PARAM_TYPE_POINT:
2870 t = (struct dsl_cmd_crc64_param_t *) p->p;
2871
2872 (void) dsl_var_crc64_point(p->d, &t->source, t->m);
2873
2874 break;
2875 case DSL_PARAM_TYPE_VARIABLE:
2876 v = (struct dsl_cmd_crc64_param_v *) p->p;
2877
2878 if(p->s == NULL) {
2879 if((p->s = dsl_var_find_struct_by_name(&v->source, c)) == NULL) return(-1);
2880 }
2881
2882 (void) dsl_var_crc64_variable(p->d, p->s, v->source.m);
2883
2884 break;
2885 default:
2886 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
2887
2888 return(-1);
2889 }
2890
2891 return(0);
2892 }
2893 #endif
dsl_run_post_dump(struct dsl_cmd_dump * p,struct dsl_ctx * c)2894 static int dsl_run_post_dump(struct dsl_cmd_dump *p, struct dsl_ctx *c) {
2895 if(p == NULL) {
2896 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
2897
2898 return(-1);
2899 }
2900
2901 if(p->v == NULL) {
2902 if((p->v = dsl_var_find_struct_by_name(&p->variable, c)) == NULL) return(-1);
2903 }
2904
2905 /* Inherit member type to cached variable */
2906 p->v->m = p->variable.m;
2907
2908 (void) dsl_var_dump_variable(p->v);
2909
2910 return(0);
2911 }
2912
dsl_run_post_conv(struct dsl_cmd_conv * p,struct dsl_ctx * c,unsigned int j)2913 static int dsl_run_post_conv(struct dsl_cmd_conv *p, struct dsl_ctx *c, unsigned int j) {
2914 if(p == NULL) {
2915 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
2916
2917 return(-1);
2918 }
2919
2920 if(p->d == NULL) {
2921 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
2922 }
2923
2924 /* Inherit member type to cached destination variable */
2925 p->d->m = p->destination.m;
2926
2927 switch(j) {
2928 case DSL_COMMAND_STON:
2929 (void) dsl_var_ston(p->d);
2930
2931 break;
2932 case DSL_COMMAND_BTON:
2933 (void) dsl_var_bton(p->d);
2934
2935 break;
2936 case DSL_COMMAND_PTON:
2937 (void) dsl_var_pton(p->d);
2938
2939 break;
2940 case DSL_COMMAND_HTON:
2941 (void) dsl_var_hton(p->d);
2942
2943 break;
2944 case DSL_COMMAND_NTOS:
2945 (void) dsl_var_ntos(p->d);
2946
2947 break;
2948 case DSL_COMMAND_NTOB:
2949 (void) dsl_var_ntob(p->d);
2950
2951 break;
2952 case DSL_COMMAND_NTOP:
2953 (void) dsl_var_ntop(p->d);
2954
2955 break;
2956 case DSL_COMMAND_NTOH:
2957 (void) dsl_var_ntoh(p->d);
2958
2959 break;
2960 default:
2961 break;
2962 }
2963
2964 return(0);
2965 }
2966
dsl_run_post_type(struct dsl_cmd_type * p,struct dsl_ctx * c,unsigned int j)2967 static int dsl_run_post_type(struct dsl_cmd_type *p, struct dsl_ctx *c, unsigned int j) {
2968 if(p == NULL) {
2969 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_MISSING);
2970
2971 return(-1);
2972 }
2973
2974 if(p->d == NULL) {
2975 if((p->d = dsl_var_find_struct_by_name(&p->destination, c)) == NULL) return(-1);
2976 }
2977
2978 /* Inherit member type to cached destination variable */
2979 p->d->m = p->destination.m;
2980
2981 switch(j) {
2982 case DSL_COMMAND_TOI8:
2983 (void) dsl_var_toi8(p->d);
2984
2985 break;
2986 case DSL_COMMAND_TOI16:
2987 (void) dsl_var_toi16(p->d);
2988
2989 break;
2990 case DSL_COMMAND_TOI32:
2991 (void) dsl_var_toi32(p->d);
2992
2993 break;
2994 case DSL_COMMAND_TOI64:
2995 (void) dsl_var_toi64(p->d);
2996
2997 break;
2998 #if defined(__SIZEOF_INT128__)
2999 case DSL_COMMAND_TOI128:
3000 (void) dsl_var_toi128(p->d);
3001
3002 break;
3003 #endif
3004 case DSL_COMMAND_TOU8:
3005 (void) dsl_var_tou8(p->d);
3006
3007 break;
3008 case DSL_COMMAND_TOU16:
3009 (void) dsl_var_tou16(p->d);
3010
3011 break;
3012 case DSL_COMMAND_TOU32:
3013 (void) dsl_var_tou32(p->d);
3014
3015 break;
3016 case DSL_COMMAND_TOU64:
3017 (void) dsl_var_tou64(p->d);
3018
3019 break;
3020 #if defined(__SIZEOF_INT128__)
3021 case DSL_COMMAND_TOU128:
3022 (void) dsl_var_tou128(p->d);
3023
3024 break;
3025 #endif
3026 case DSL_COMMAND_TOCHAR:
3027 (void) dsl_var_tochar(p->d);
3028
3029 break;
3030 case DSL_COMMAND_TOSHORT:
3031 (void) dsl_var_toshort(p->d);
3032
3033 break;
3034 case DSL_COMMAND_TOINT:
3035 (void) dsl_var_toint(p->d);
3036
3037 break;
3038 case DSL_COMMAND_TOLONG:
3039 (void) dsl_var_tolong(p->d);
3040
3041 break;
3042 case DSL_COMMAND_TOUCHAR:
3043 (void) dsl_var_touchar(p->d);
3044
3045 break;
3046 case DSL_COMMAND_TOUSHORT:
3047 (void) dsl_var_toushort(p->d);
3048
3049 break;
3050 case DSL_COMMAND_TOUINT:
3051 (void) dsl_var_touint(p->d);
3052
3053 break;
3054 case DSL_COMMAND_TOULONG:
3055 (void) dsl_var_toulong(p->d);
3056
3057 break;
3058 case DSL_COMMAND_TOFLOAT:
3059 (void) dsl_var_tofloat(p->d);
3060
3061 break;
3062 case DSL_COMMAND_TODOUBLE:
3063 (void) dsl_var_todouble(p->d);
3064
3065 break;
3066 default:
3067 break;
3068 }
3069
3070 return(0);
3071 }
3072
dsl_run_post_var_get_or_create(struct dsl_var * d,struct dsl_ctx * c)3073 static struct dsl_var *dsl_run_post_var_get_or_create(struct dsl_var *d, struct dsl_ctx *c) {
3074 struct dsl_var *r;
3075 struct dsl_vars *a;
3076
3077 if((r = dsl_var_find_struct_by_name(d, c)) == NULL) {
3078 /* First candidate is to create local variable */
3079 if(c->local != NULL && d->variable.string.s[0] == '_') a = c->local;
3080 else a = &c->global;
3081
3082 if(dsl_var_new(d, a) != 0) return(NULL);
3083
3084 r = dsl_var_find_struct_by_name(d, c);
3085 }
3086
3087 /* Inherit member to this variable */
3088 r->m = d->m;
3089
3090 return(r);
3091 }
3092