1 #include "declarations.h"
2 #include "dsl_errno.h"
3 #include "dsl_cmd.h"
4 #include "dsl_shr.h"
5 #include "dsl_variable.h"
6
7 #include "config.mach"
8
9
10
dsl_var_new(struct dsl_var * s,struct dsl_vars * d)11 int dsl_var_new(struct dsl_var *s, struct dsl_vars *d) {
12 size_t u;
13
14 struct dsl_var *a;
15 struct dsl_var **t;
16
17 /* Check if variable is already defined in this scope */
18 if(dsl_var_new_exists(s, d->v, d->c) != 0) return(-1);
19
20 /* Allocate slot for variable */
21 u = sizeof(struct dsl_var *) * (d->c + 1);
22
23 if((t = realloc(d->v, u)) == NULL) {
24 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_GENERAL_ALLOC);
25
26 return(-1);
27 }
28
29 d->v = t;
30
31 u = sizeof(struct dsl_var);
32
33 if((d->v[d->c] = malloc(u)) == NULL) {
34 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_GENERAL_ALLOC);
35
36 return(-1);
37 }
38
39 (void) memset((void *) d->v[d->c], 0, u);
40
41 ++d->c;
42
43 /* Store variable name for later use */
44 if(dsl_str_copy(&d->v[d->c - 1]->variable, &s->variable) != 0) {
45 (void) free(d->v[d->c - 1]);
46
47 d->v[d->c - 1] = NULL;
48
49 return(-1);
50 }
51
52 a = d->v[d->c - 1];
53
54 a->number.rpn.r.string.s = NULL;
55 a->number.rpn.r.charset.s = NULL;
56
57 a->number.rpn.c = IS_NO;
58 a->number.rpn.d = 0.0;
59
60 a->string.string.s = NULL;
61 a->string.charset.s = NULL;
62
63 a->blob.blob.s = NULL;
64
65 a->pointer.pointer = NULL;
66
67 a->image.image.s = NULL;
68
69 /* Initialize variable content */
70 switch(s->c) {
71 case DSL_PARAM_TYPE_NONE:
72 (void) dsl_var_put_none(a);
73
74 break;
75 case DSL_PARAM_TYPE_NUMBER:
76 (void) dsl_var_put_number(a, &s->number, IS_NO);
77
78 break;
79 case DSL_PARAM_TYPE_STRING:
80 (void) dsl_var_put_string(a, &s->string);
81
82 break;
83 case DSL_PARAM_TYPE_BLOB:
84 (void) dsl_var_put_blob(a, &s->blob, s->blob.s);
85
86 break;
87 case DSL_PARAM_TYPE_POINTER:
88 (void) dsl_var_put_pointer(a, &s->pointer);
89
90 break;
91 case DSL_PARAM_TYPE_HANDLE:
92 (void) dsl_var_put_handle(a, &s->handle);
93
94 break;
95 case DSL_PARAM_TYPE_COLOR:
96 (void) dsl_var_put_color(a, &s->color, s->m);
97
98 break;
99 case DSL_PARAM_TYPE_IMAGE:
100 (void) dsl_var_put_image(a, &s->image, s->image.s, s->m);
101
102 break;
103 case DSL_PARAM_TYPE_POINT:
104 (void) dsl_var_put_point(a, &s->point, s->m);
105
106 break;
107 case DSL_PARAM_TYPE_VARIABLE:
108 (void) dsl_var_put_variable(a, s, s->c, s->m);
109
110 break;
111 default:
112 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
113
114 return(-1);
115 }
116
117 /* Initialize numeral type if not initialized already */
118 if(a->number.c == DSL_PARAM_TYPE_NONE) a->number.c = DSL_NUMBER_TYPE_DEFAULT;
119
120 return(0);
121 }
122
dsl_var_new_exists(struct dsl_var * s,struct dsl_var ** d,unsigned long c)123 static int dsl_var_new_exists(struct dsl_var *s, struct dsl_var **d, unsigned long c) {
124 unsigned long i;
125
126 char *p;
127
128 size_t t;
129
130 p = s->variable.string.s;
131 t = s->variable.string.t;
132
133 for(i = 0; i < c; i++) {
134 if(d[i] == NULL) continue;
135 if(t != d[i]->variable.string.t) continue;
136 if(memcmp((const void *) d[i]->variable.string.s, (const void *) p, t) == 0) {
137 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_VARIABLE_DEFINED_ALREADY);
138
139 return(-1);
140 }
141 }
142
143 return(0);
144 }
145
dsl_var_free(struct dsl_var * v)146 void dsl_var_free(struct dsl_var *v) {
147 (void) dsl_str_free(&v->variable);
148 (void) dsl_str_free(&v->string);
149 (void) dsl_blob_free(&v->blob);
150 (void) dsl_image_free(&v->image);
151
152 (void) free(v);
153 }
154
dsl_var_get_number(struct dsl_var * v,struct dsl_num * n)155 int dsl_var_get_number(struct dsl_var *v, struct dsl_num *n) {
156 switch(v->c) {
157 case DSL_PARAM_TYPE_NONE:
158 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_VARIABLE_NOT_INITIALIZED);
159
160 break;
161 case DSL_PARAM_TYPE_NUMBER:
162 /* We dont set number type because destination variable type needs to be preserved */
163 n->number.n = dsl_num_get_number(v->number.c, &v->number);
164
165 return(0);
166 case DSL_PARAM_TYPE_STRING:
167 case DSL_PARAM_TYPE_BLOB:
168 case DSL_PARAM_TYPE_POINTER:
169 case DSL_PARAM_TYPE_HANDLE:
170 case DSL_PARAM_TYPE_COLOR:
171 case DSL_PARAM_TYPE_IMAGE:
172 case DSL_PARAM_TYPE_POINT:
173 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
174
175 break;
176 default:
177 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
178
179 break;
180 }
181
182 return(-1);
183 }
184
dsl_var_get_string(struct dsl_var * v,struct dsl_str * s)185 int dsl_var_get_string(struct dsl_var *v, struct dsl_str *s) {
186 switch(v->c) {
187 case DSL_PARAM_TYPE_NONE:
188 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_VARIABLE_NOT_INITIALIZED);
189
190 break;
191 case DSL_PARAM_TYPE_STRING:
192 /* String copy is not needed, as caller is expected to consume string immediately */
193 s->string.s = v->string.string.s;
194 s->string.t = v->string.string.t;
195 s->string.u = v->string.string.u;
196
197 s->charset.s = v->string.charset.s;
198 s->charset.t = v->string.charset.t;
199 s->charset.u = v->string.charset.u;
200
201 return(0);
202 case DSL_PARAM_TYPE_BLOB:
203 case DSL_PARAM_TYPE_NUMBER:
204 case DSL_PARAM_TYPE_POINTER:
205 case DSL_PARAM_TYPE_HANDLE:
206 case DSL_PARAM_TYPE_COLOR:
207 case DSL_PARAM_TYPE_IMAGE:
208 case DSL_PARAM_TYPE_POINT:
209 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
210
211 break;
212 default:
213 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
214
215 break;
216 }
217
218 return(-1);
219 }
220
dsl_var_get_blob(struct dsl_var * v,struct dsl_blb * b)221 int dsl_var_get_blob(struct dsl_var *v, struct dsl_blb *b) {
222 switch(v->c) {
223 case DSL_PARAM_TYPE_NONE:
224 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_VARIABLE_NOT_INITIALIZED);
225
226 break;
227 case DSL_PARAM_TYPE_BLOB:
228 /* Blob copy is not needed, as caller is expected to consume blob immediately */
229 b->blob.s = v->blob.blob.s;
230 b->blob.t = v->blob.blob.t;
231 b->blob.u = v->blob.blob.u;
232
233 b->s = v->blob.s;
234
235 return(0);
236 case DSL_PARAM_TYPE_NUMBER:
237 case DSL_PARAM_TYPE_STRING:
238 case DSL_PARAM_TYPE_POINTER:
239 case DSL_PARAM_TYPE_HANDLE:
240 case DSL_PARAM_TYPE_COLOR:
241 case DSL_PARAM_TYPE_IMAGE:
242 case DSL_PARAM_TYPE_POINT:
243 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
244
245 break;
246 default:
247 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
248
249 break;
250 }
251
252 return(-1);
253 }
254
dsl_var_get_pointer(struct dsl_var * v,struct dsl_ptr * p)255 int dsl_var_get_pointer(struct dsl_var *v, struct dsl_ptr *p) {
256 switch(v->c) {
257 case DSL_PARAM_TYPE_NONE:
258 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_VARIABLE_NOT_INITIALIZED);
259
260 break;
261 case DSL_PARAM_TYPE_POINTER:
262 p->pointer = v->pointer.pointer;
263
264 return(0);
265 case DSL_PARAM_TYPE_NUMBER:
266 case DSL_PARAM_TYPE_STRING:
267 case DSL_PARAM_TYPE_BLOB:
268 case DSL_PARAM_TYPE_HANDLE:
269 case DSL_PARAM_TYPE_COLOR:
270 case DSL_PARAM_TYPE_IMAGE:
271 case DSL_PARAM_TYPE_POINT:
272 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
273
274 break;
275 default:
276 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
277
278 break;
279 }
280
281 return(-1);
282 }
283
dsl_var_get_handle(struct dsl_var * v,struct dsl_hnd * h)284 int dsl_var_get_handle(struct dsl_var *v, struct dsl_hnd *h) {
285 switch(v->c) {
286 case DSL_PARAM_TYPE_NONE:
287 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_VARIABLE_NOT_INITIALIZED);
288
289 break;
290 case DSL_PARAM_TYPE_HANDLE:
291 h->handle = v->handle.handle;
292
293 return(0);
294 case DSL_PARAM_TYPE_NUMBER:
295 case DSL_PARAM_TYPE_STRING:
296 case DSL_PARAM_TYPE_BLOB:
297 case DSL_PARAM_TYPE_POINTER:
298 case DSL_PARAM_TYPE_COLOR:
299 case DSL_PARAM_TYPE_IMAGE:
300 case DSL_PARAM_TYPE_POINT:
301 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
302
303 break;
304 default:
305 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
306
307 break;
308 }
309
310 return(-1);
311 }
312
dsl_var_get_color(struct dsl_var * v,struct dsl_clr * c)313 int dsl_var_get_color(struct dsl_var *v, struct dsl_clr *c) {
314 switch(v->c) {
315 case DSL_PARAM_TYPE_NONE:
316 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_VARIABLE_NOT_INITIALIZED);
317
318 break;
319 case DSL_PARAM_TYPE_COLOR:
320 return(dsl_var_get_color_op(v, c));
321 case DSL_PARAM_TYPE_NUMBER:
322 case DSL_PARAM_TYPE_STRING:
323 case DSL_PARAM_TYPE_BLOB:
324 case DSL_PARAM_TYPE_POINTER:
325 case DSL_PARAM_TYPE_HANDLE:
326 case DSL_PARAM_TYPE_IMAGE:
327 case DSL_PARAM_TYPE_POINT:
328 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
329
330 break;
331 default:
332 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
333
334 break;
335 }
336
337 return(-1);
338 }
339
dsl_var_get_color_op(struct dsl_var * v,struct dsl_clr * c)340 static int dsl_var_get_color_op(struct dsl_var *v, struct dsl_clr *c) {
341 switch(v->m) {
342 case DSL_MEMBER_TYPE_NONE:
343 c->color.pixel.p = v->color.color.pixel.p;
344
345 break;
346 case DSL_MEMBER_TYPE_RED:
347 c->color.pixel.r = v->color.color.pixel.r;
348
349 break;
350 case DSL_MEMBER_TYPE_GREEN:
351 c->color.pixel.g = v->color.color.pixel.g;
352
353 break;
354 case DSL_MEMBER_TYPE_BLUE:
355 c->color.pixel.b = v->color.color.pixel.b;
356
357 break;
358 case DSL_MEMBER_TYPE_ALPHA:
359 c->color.pixel.a = v->color.color.pixel.a;
360
361 break;
362 default:
363 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
364
365 return(-1);
366 }
367
368 return(0);
369 }
370
dsl_var_get_image(struct dsl_var * v,struct dsl_img * m)371 int dsl_var_get_image(struct dsl_var *v, struct dsl_img *m) {
372 switch(v->c) {
373 case DSL_PARAM_TYPE_NONE:
374 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_VARIABLE_NOT_INITIALIZED);
375
376 break;
377 case DSL_PARAM_TYPE_IMAGE:
378 return(dsl_var_get_image_op(v, m));
379 case DSL_PARAM_TYPE_NUMBER:
380 case DSL_PARAM_TYPE_STRING:
381 case DSL_PARAM_TYPE_BLOB:
382 case DSL_PARAM_TYPE_POINTER:
383 case DSL_PARAM_TYPE_HANDLE:
384 case DSL_PARAM_TYPE_COLOR:
385 case DSL_PARAM_TYPE_POINT:
386 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
387
388 break;
389 default:
390 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
391
392 break;
393 }
394
395 return(-1);
396 }
397
dsl_var_get_image_op(struct dsl_var * v,struct dsl_img * m)398 static int dsl_var_get_image_op(struct dsl_var *v, struct dsl_img *m) {
399 switch(v->m) {
400 case DSL_MEMBER_TYPE_NONE:
401 m->image.w = v->image.image.w;
402 m->image.h = v->image.image.h;
403 m->image.s = v->image.image.s;
404
405 m->s = v->image.s;
406
407 break;
408 case DSL_MEMBER_TYPE_WIDTH:
409 m->image.w = v->image.image.w;
410
411 break;
412 case DSL_MEMBER_TYPE_HEIGHT:
413 m->image.h = v->image.image.h;
414
415 break;
416 default:
417 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
418
419 return(-1);
420 }
421
422 return(0);
423 }
424
dsl_var_get_point(struct dsl_var * v,struct dsl_pnt * t)425 int dsl_var_get_point(struct dsl_var *v, struct dsl_pnt *t) {
426 switch(v->c) {
427 case DSL_PARAM_TYPE_NONE:
428 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_VARIABLE_NOT_INITIALIZED);
429
430 break;
431 case DSL_PARAM_TYPE_POINT:
432 return(dsl_var_get_point_op(v, t));
433 case DSL_PARAM_TYPE_NUMBER:
434 case DSL_PARAM_TYPE_STRING:
435 case DSL_PARAM_TYPE_BLOB:
436 case DSL_PARAM_TYPE_POINTER:
437 case DSL_PARAM_TYPE_HANDLE:
438 case DSL_PARAM_TYPE_COLOR:
439 case DSL_PARAM_TYPE_IMAGE:
440 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
441
442 break;
443 default:
444 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_UNKNOWN);
445
446 break;
447 }
448
449 return(-1);
450 }
451
dsl_var_get_point_op(struct dsl_var * v,struct dsl_pnt * t)452 static int dsl_var_get_point_op(struct dsl_var *v, struct dsl_pnt *t) {
453 switch(v->m) {
454 case DSL_MEMBER_TYPE_NONE:
455 t->point.x = v->point.point.x;
456 t->point.y = v->point.point.y;
457 t->point.z = v->point.point.z;
458
459 break;
460 case DSL_MEMBER_TYPE_X:
461 t->point.x = v->point.point.x;
462
463 break;
464 case DSL_MEMBER_TYPE_Y:
465 t->point.y = v->point.point.y;
466
467 break;
468 case DSL_MEMBER_TYPE_Z:
469 t->point.z = v->point.point.z;
470
471 break;
472 default:
473 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
474
475 return(-1);
476 }
477
478 return(0);
479 }
480
dsl_var_abs_number(struct dsl_var * v)481 void dsl_var_abs_number(struct dsl_var *v) {
482 double a;
483
484 a = dsl_num_get_number(v->number.c, &v->number);
485
486 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
487
488 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ABS);
489 }
490
dsl_var_dec_number(struct dsl_var * v,struct dsl_flg * f)491 void dsl_var_dec_number(struct dsl_var *v, struct dsl_flg *f) {
492 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
493
494 (void) dsl_var_src_number(v, 1.0, 0.0, 0.0, NULL, DSL_COMMAND_SUB);
495
496 (void) dsl_var_num_flag_s(&v->number, f);
497 (void) dsl_var_num_flag_z(&v->number, f);
498 }
499
dsl_var_inc_number(struct dsl_var * v,struct dsl_flg * f)500 void dsl_var_inc_number(struct dsl_var *v, struct dsl_flg *f) {
501 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
502
503 (void) dsl_var_src_number(v, 1.0, 0.0, 0.0, NULL, DSL_COMMAND_ADD);
504
505 (void) dsl_var_num_flag_s(&v->number, f);
506 (void) dsl_var_num_flag_z(&v->number, f);
507 }
508
dsl_var_add_number(struct dsl_var * v,struct dsl_num * n,struct dsl_flg * f,unsigned int c)509 void dsl_var_add_number(struct dsl_var *v, struct dsl_num *n, struct dsl_flg *f, unsigned int c) {
510 double a;
511
512 a = dsl_num_get_number(n->c, n);
513
514 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
515
516 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ADD);
517
518 (void) dsl_var_num_flag_s(&v->number, f);
519 (void) dsl_var_num_flag_z(&v->number, f);
520 }
521
dsl_var_add_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m,struct dsl_flg * f)522 void dsl_var_add_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m, struct dsl_flg *f) {
523 struct dsl_num n;
524
525 switch(d->c) {
526 case DSL_PARAM_TYPE_NUMBER:
527 (void) dsl_var_add_number(v, &d->number, f, DSL_PARAM_TYPE_NUMBER);
528
529 break;
530 case DSL_PARAM_TYPE_COLOR:
531 (void) dsl_var_dst_color(d, m, &n);
532 (void) dsl_var_add_number(v, &n, f, DSL_PARAM_TYPE_COLOR);
533
534 break;
535 case DSL_PARAM_TYPE_IMAGE:
536 (void) dsl_var_dst_image(d, m, &n);
537 (void) dsl_var_add_number(v, &n, f, DSL_PARAM_TYPE_IMAGE);
538
539 break;
540 case DSL_PARAM_TYPE_POINT:
541 (void) dsl_var_dst_point(d, m, &n);
542 (void) dsl_var_add_number(v, &n, f, DSL_PARAM_TYPE_POINT);
543
544 break;
545 default:
546 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
547
548 return;
549 }
550 }
551
dsl_var_sub_number(struct dsl_var * v,struct dsl_num * n,struct dsl_flg * f,unsigned int c)552 void dsl_var_sub_number(struct dsl_var *v, struct dsl_num *n, struct dsl_flg *f, unsigned int c) {
553 double a;
554
555 a = dsl_num_get_number(n->c, n);
556
557 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
558
559 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_SUB);
560
561 (void) dsl_var_num_flag_s(&v->number, f);
562 (void) dsl_var_num_flag_z(&v->number, f);
563 }
564
dsl_var_sub_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m,struct dsl_flg * f)565 void dsl_var_sub_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m, struct dsl_flg *f) {
566 struct dsl_num n;
567
568 switch(d->c) {
569 case DSL_PARAM_TYPE_NUMBER:
570 (void) dsl_var_sub_number(v, &d->number, f, DSL_PARAM_TYPE_NUMBER);
571
572 break;
573 case DSL_PARAM_TYPE_COLOR:
574 (void) dsl_var_dst_color(d, m, &n);
575 (void) dsl_var_sub_number(v, &n, f, DSL_PARAM_TYPE_COLOR);
576
577 break;
578 case DSL_PARAM_TYPE_IMAGE:
579 (void) dsl_var_dst_image(d, m, &n);
580 (void) dsl_var_sub_number(v, &n, f, DSL_PARAM_TYPE_IMAGE);
581
582 break;
583 case DSL_PARAM_TYPE_POINT:
584 (void) dsl_var_dst_point(d, m, &n);
585 (void) dsl_var_sub_number(v, &n, f, DSL_PARAM_TYPE_POINT);
586
587 break;
588 default:
589 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
590
591 return;
592 }
593 }
594
dsl_var_div_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)595 void dsl_var_div_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
596 double a;
597
598 a = dsl_num_get_number(n->c, n);
599
600 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
601
602 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_DIV);
603 }
604
dsl_var_div_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)605 void dsl_var_div_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
606 struct dsl_num n;
607
608 switch(d->c) {
609 case DSL_PARAM_TYPE_NUMBER:
610 (void) dsl_var_div_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
611
612 break;
613 case DSL_PARAM_TYPE_COLOR:
614 (void) dsl_var_dst_color(d, m, &n);
615 (void) dsl_var_div_number(v, &n, DSL_PARAM_TYPE_COLOR);
616
617 break;
618 case DSL_PARAM_TYPE_IMAGE:
619 (void) dsl_var_dst_image(d, m, &n);
620 (void) dsl_var_div_number(v, &n, DSL_PARAM_TYPE_IMAGE);
621
622 break;
623 case DSL_PARAM_TYPE_POINT:
624 (void) dsl_var_dst_point(d, m, &n);
625 (void) dsl_var_div_number(v, &n, DSL_PARAM_TYPE_POINT);
626
627 break;
628 default:
629 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
630
631 return;
632 }
633 }
634
dsl_var_mul_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)635 void dsl_var_mul_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
636 double a;
637
638 a = dsl_num_get_number(n->c, n);
639
640 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
641
642 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_MUL);
643 }
644
dsl_var_mul_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)645 void dsl_var_mul_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
646 struct dsl_num n;
647
648 switch(d->c) {
649 case DSL_PARAM_TYPE_NUMBER:
650 (void) dsl_var_mul_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
651
652 break;
653 case DSL_PARAM_TYPE_COLOR:
654 (void) dsl_var_dst_color(d, m, &n);
655 (void) dsl_var_mul_number(v, &n, DSL_PARAM_TYPE_COLOR);
656
657 break;
658 case DSL_PARAM_TYPE_IMAGE:
659 (void) dsl_var_dst_image(d, m, &n);
660 (void) dsl_var_mul_number(v, &n, DSL_PARAM_TYPE_IMAGE);
661
662 break;
663 case DSL_PARAM_TYPE_POINT:
664 (void) dsl_var_dst_point(d, m, &n);
665 (void) dsl_var_mul_number(v, &n, DSL_PARAM_TYPE_POINT);
666
667 break;
668 default:
669 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
670
671 return;
672 }
673 }
674
dsl_var_mod_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)675 void dsl_var_mod_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
676 double a;
677
678 a = dsl_num_get_number(n->c, n);
679
680 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
681
682 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_MOD);
683 }
684
dsl_var_mod_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)685 void dsl_var_mod_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
686 struct dsl_num n;
687
688 switch(d->c) {
689 case DSL_PARAM_TYPE_NUMBER:
690 (void) dsl_var_mod_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
691
692 break;
693 case DSL_PARAM_TYPE_COLOR:
694 (void) dsl_var_dst_color(d, m, &n);
695 (void) dsl_var_mod_number(v, &n, DSL_PARAM_TYPE_COLOR);
696
697 break;
698 case DSL_PARAM_TYPE_IMAGE:
699 (void) dsl_var_dst_image(d, m, &n);
700 (void) dsl_var_mod_number(v, &n, DSL_PARAM_TYPE_IMAGE);
701
702 break;
703 case DSL_PARAM_TYPE_POINT:
704 (void) dsl_var_dst_point(d, m, &n);
705 (void) dsl_var_mod_number(v, &n, DSL_PARAM_TYPE_POINT);
706
707 break;
708 default:
709 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
710
711 return;
712 }
713 }
714
dsl_var_pow_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)715 void dsl_var_pow_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
716 double a;
717
718 a = dsl_num_get_number(n->c, n);
719
720 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
721
722 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_POW);
723 }
724
dsl_var_pow_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)725 void dsl_var_pow_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
726 struct dsl_num n;
727
728 switch(d->c) {
729 case DSL_PARAM_TYPE_NUMBER:
730 (void) dsl_var_pow_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
731
732 break;
733 case DSL_PARAM_TYPE_COLOR:
734 (void) dsl_var_dst_color(d, m, &n);
735 (void) dsl_var_pow_number(v, &n, DSL_PARAM_TYPE_COLOR);
736
737 break;
738 case DSL_PARAM_TYPE_IMAGE:
739 (void) dsl_var_dst_image(d, m, &n);
740 (void) dsl_var_pow_number(v, &n, DSL_PARAM_TYPE_IMAGE);
741
742 break;
743 case DSL_PARAM_TYPE_POINT:
744 (void) dsl_var_dst_point(d, m, &n);
745 (void) dsl_var_pow_number(v, &n, DSL_PARAM_TYPE_POINT);
746
747 break;
748 default:
749 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
750
751 return;
752 }
753 }
754
dsl_var_neg_number(struct dsl_var * v,struct dsl_flg * f,unsigned int c)755 void dsl_var_neg_number(struct dsl_var *v, struct dsl_flg *f, unsigned int c) {
756 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
757
758 (void) dsl_var_src_number(v, -1.0, 0.0, 0.0, NULL, DSL_COMMAND_MUL);
759
760 (void) dsl_var_num_flag_s(&v->number, f);
761 (void) dsl_var_num_flag_z(&v->number, f);
762 }
763
dsl_var_cmp_number(struct dsl_var * v,struct dsl_num * n,struct dsl_flg * f)764 void dsl_var_cmp_number(struct dsl_var *v, struct dsl_num *n, struct dsl_flg *f) {
765 double a, b;
766
767 a = dsl_num_get_number(n->c, n);
768
769 switch(v->c) {
770 case DSL_PARAM_TYPE_NUMBER:
771 b = dsl_num_get_number(v->number.c, &v->number);
772
773 break;
774 case DSL_PARAM_TYPE_COLOR:
775 b = dsl_var_cmp_color_op(&v->color, v->m);
776
777 break;
778 case DSL_PARAM_TYPE_IMAGE:
779 b = dsl_var_cmp_image_op(&v->image, v->m);
780
781 break;
782 case DSL_PARAM_TYPE_POINT:
783 b = dsl_var_cmp_point_op(&v->point, v->m);
784
785 break;
786 default:
787 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
788
789 return;
790 }
791
792 (void) dsl_var_cmp_op(a, b, f);
793 }
794
dsl_var_cmp_string(struct dsl_var * v,struct dsl_str * s,struct dsl_flg * f)795 void dsl_var_cmp_string(struct dsl_var *v, struct dsl_str *s, struct dsl_flg *f) {
796 (void) dsl_var_cmp_op((double) s->string.t, (double) v->string.string.t, f);
797 }
798
dsl_var_cmp_blob(struct dsl_var * v,struct dsl_blb * b,struct dsl_flg * f)799 void dsl_var_cmp_blob(struct dsl_var *v, struct dsl_blb *b, struct dsl_flg *f) {
800 (void) dsl_var_cmp_op((double) b->blob.t, (double) v->blob.blob.t, f);
801 }
802
dsl_var_cmp_pointer(struct dsl_var * v,struct dsl_ptr * p,struct dsl_flg * f)803 void dsl_var_cmp_pointer(struct dsl_var *v, struct dsl_ptr *p, struct dsl_flg *f) {
804 unsigned long a, b;
805
806 a = (unsigned long) p->pointer;
807 b = (unsigned long) v->pointer.pointer;
808
809 (void) dsl_var_cmp_op((double) a, (double) b, f);
810 }
811
dsl_var_cmp_handle(struct dsl_var * v,struct dsl_hnd * h,struct dsl_flg * f)812 void dsl_var_cmp_handle(struct dsl_var *v, struct dsl_hnd *h, struct dsl_flg *f) {
813 (void) dsl_var_cmp_op((double) h->handle, (double) v->handle.handle, f);
814 }
815
dsl_var_cmp_color(struct dsl_var * v,struct dsl_clr * c,struct dsl_flg * f,unsigned int m)816 void dsl_var_cmp_color(struct dsl_var *v, struct dsl_clr *c, struct dsl_flg *f, unsigned int m) {
817 double a, b;
818
819 a = dsl_var_cmp_color_op(c, m);
820 b = dsl_var_cmp_color_op(&v->color, v->m);
821
822 (void) dsl_var_cmp_op(a, b, f);
823 }
824
dsl_var_cmp_color_op(struct dsl_clr * c,unsigned int m)825 static double dsl_var_cmp_color_op(struct dsl_clr *c, unsigned int m) {
826 double r;
827
828 switch(m) {
829 case DSL_MEMBER_TYPE_NONE:
830 r = (double) c->color.pixel.p;
831
832 break;
833 default:
834 r = (double) dsl_var_put_color_it(c, 0, m);
835
836 break;
837 }
838
839 return(r);
840 }
841
dsl_var_cmp_image(struct dsl_var * v,struct dsl_img * i,struct dsl_flg * f,unsigned int m)842 void dsl_var_cmp_image(struct dsl_var *v, struct dsl_img *i, struct dsl_flg *f, unsigned int m) {
843 double a, b;
844
845 a = dsl_var_cmp_image_op(i, m);
846 b = dsl_var_cmp_image_op(&v->image, v->m);
847
848 (void) dsl_var_cmp_op(a, b, f);
849 }
850
dsl_var_cmp_image_op(struct dsl_img * i,unsigned int m)851 static double dsl_var_cmp_image_op(struct dsl_img *i, unsigned int m) {
852 double r;
853
854 size_t t;
855
856 switch(m) {
857 case DSL_MEMBER_TYPE_NONE:
858 t = i->image.w * i->image.h * sizeof(struct pixel_rgba_8);
859
860 r = (double) crc32_calc((unsigned char *) i->image.s, t);
861
862 break;
863 default:
864 r = (double) dsl_var_put_image_it(i, 0, m);
865
866 break;
867 }
868
869 return(r);
870 }
871
dsl_var_cmp_point(struct dsl_var * v,struct dsl_pnt * t,struct dsl_flg * f,unsigned int m)872 void dsl_var_cmp_point(struct dsl_var *v, struct dsl_pnt *t, struct dsl_flg *f, unsigned int m) {
873 double a, b;
874
875 a = dsl_var_put_point_it(t, dsl_var_cmp_point_op(t, m), m);
876 b = dsl_var_put_point_it(&v->point, dsl_var_cmp_point_op(&v->point, v->m), v->m);
877
878 (void) dsl_var_cmp_op(a, b, f);
879 }
880
dsl_var_cmp_point_op(struct dsl_pnt * t,unsigned int m)881 static double dsl_var_cmp_point_op(struct dsl_pnt *t, unsigned int m) {
882 double r;
883
884 switch(m) {
885 case DSL_MEMBER_TYPE_NONE:
886 r = coords_mag_3d(&t->point) * coords_position_to_angle(&t->point);
887
888 break;
889 default:
890 r = dsl_var_put_point_it(t, 0.0, m);
891
892 break;
893 }
894
895 return(r);
896 }
897
dsl_var_cmp_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m,struct dsl_flg * f)898 void dsl_var_cmp_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m, struct dsl_flg *f) {
899 switch(d->c) {
900 case DSL_PARAM_TYPE_NUMBER:
901 (void) dsl_var_cmp_number(v, &d->number, f);
902
903 break;
904 case DSL_PARAM_TYPE_STRING:
905 (void) dsl_var_cmp_string(v, &d->string, f);
906
907 break;
908 case DSL_PARAM_TYPE_BLOB:
909 (void) dsl_var_cmp_blob(v, &d->blob, f);
910
911 break;
912 case DSL_PARAM_TYPE_POINTER:
913 (void) dsl_var_cmp_pointer(v, &d->pointer, f);
914
915 break;
916 case DSL_PARAM_TYPE_HANDLE:
917 (void) dsl_var_cmp_handle(v, &d->handle, f);
918
919 break;
920 case DSL_PARAM_TYPE_COLOR:
921 (void) dsl_var_cmp_color(v, &d->color, f, m);
922
923 break;
924 case DSL_PARAM_TYPE_IMAGE:
925 (void) dsl_var_cmp_image(v, &d->image, f, m);
926
927 break;
928 case DSL_PARAM_TYPE_POINT:
929 (void) dsl_var_cmp_point(v, &d->point, f, m);
930
931 break;
932 default:
933 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
934
935 break;
936 }
937 }
938
dsl_var_cmp_op(double d,double e,struct dsl_flg * f)939 static void dsl_var_cmp_op(double d, double e, struct dsl_flg *f) {
940 if(fabs(d - e) < CONST_FLOAT_EQUALS) {
941 f->je = 1;
942 f->jz = 1;
943 }
944 else if(d > e) {
945 f->jb = 1;
946 f->js = 1;
947 }
948 else f->ja = 1;
949 }
950
dsl_var_rand_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)951 void dsl_var_rand_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
952 double a;
953
954 a = dsl_num_get_number(DSL_NUMBER_TYPE_UINT, n);
955
956 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
957
958 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_RAND);
959 }
960
dsl_var_rand_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)961 void dsl_var_rand_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
962 struct dsl_num n;
963
964 switch(d->c) {
965 case DSL_PARAM_TYPE_NUMBER:
966 (void) dsl_var_rand_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
967
968 break;
969 case DSL_PARAM_TYPE_COLOR:
970 (void) dsl_var_dst_color(d, m, &n);
971 (void) dsl_var_rand_number(v, &n, DSL_PARAM_TYPE_COLOR);
972
973 break;
974 case DSL_PARAM_TYPE_IMAGE:
975 (void) dsl_var_dst_image(d, m, &n);
976 (void) dsl_var_rand_number(v, &n, DSL_PARAM_TYPE_IMAGE);
977
978 break;
979 case DSL_PARAM_TYPE_POINT:
980 (void) dsl_var_dst_point(d, m, &n);
981 (void) dsl_var_rand_number(v, &n, DSL_PARAM_TYPE_POINT);
982
983 break;
984 default:
985 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
986
987 return;
988 }
989 }
990
dsl_var_xchg_variable(struct dsl_var * v,struct dsl_var * d,__UNUSED__ unsigned int m)991 void dsl_var_xchg_variable(struct dsl_var *v, struct dsl_var *d, __UNUSED__ unsigned int m) {
992 struct dsl_var t;
993
994 (void) memcpy((void *) &t, (const void *) d, sizeof(struct dsl_var));
995 (void) memcpy((void *) d, (const void *) v, sizeof(struct dsl_var));
996 (void) memcpy((void *) v, (const void *) &t, sizeof(struct dsl_var));
997 }
998 #if ! defined(PROG_DISABLE_EXTENDED)
dsl_var_and_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,struct dsl_flg * f,unsigned int c)999 void dsl_var_and_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, struct dsl_flg *f, unsigned int c) {
1000 double a, b;
1001
1002 a = dsl_num_get_number(n_a->c, n_a);
1003 b = dsl_num_get_number(n_b->c, n_b);
1004
1005 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1006
1007 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_AND);
1008
1009 (void) dsl_var_num_flag_s(&v->number, f);
1010 (void) dsl_var_num_flag_z(&v->number, f);
1011 }
1012
dsl_var_and_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b,struct dsl_flg * f)1013 void dsl_var_and_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b, struct dsl_flg *f) {
1014 struct dsl_num n_a, n_b;
1015
1016 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
1017
1018 switch(d_b->c) {
1019 case DSL_PARAM_TYPE_NUMBER:
1020 (void) dsl_var_and_number(v, &n_a, &d_b->number, f, DSL_PARAM_TYPE_NUMBER);
1021
1022 break;
1023 case DSL_PARAM_TYPE_COLOR:
1024 (void) dsl_var_dst_color(d_b, m_b, &n_b);
1025 (void) dsl_var_and_number(v, &n_a, &n_b, f, DSL_PARAM_TYPE_COLOR);
1026
1027 break;
1028 case DSL_PARAM_TYPE_IMAGE:
1029 (void) dsl_var_dst_image(d_b, m_b, &n_b);
1030 (void) dsl_var_and_number(v, &n_a, &n_b, f, DSL_PARAM_TYPE_IMAGE);
1031
1032 break;
1033 case DSL_PARAM_TYPE_POINT:
1034 (void) dsl_var_dst_point(d_b, m_b, &n_b);
1035 (void) dsl_var_and_number(v, &n_a, &n_b, f, DSL_PARAM_TYPE_POINT);
1036
1037 break;
1038 default:
1039 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1040
1041 return;
1042 }
1043 }
1044
dsl_var_or_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,struct dsl_flg * f,unsigned int c)1045 void dsl_var_or_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, struct dsl_flg *f, unsigned int c) {
1046 double a, b;
1047
1048 a = dsl_num_get_number(n_a->c, n_a);
1049 b = dsl_num_get_number(n_b->c, n_b);
1050
1051 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1052
1053 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_OR);
1054
1055 (void) dsl_var_num_flag_s(&v->number, f);
1056 (void) dsl_var_num_flag_z(&v->number, f);
1057 }
1058
dsl_var_or_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b,struct dsl_flg * f)1059 void dsl_var_or_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b, struct dsl_flg *f) {
1060 struct dsl_num n_a, n_b;
1061
1062 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
1063
1064 switch(d_b->c) {
1065 case DSL_PARAM_TYPE_NUMBER:
1066 (void) dsl_var_or_number(v, &n_a, &d_b->number, f, DSL_PARAM_TYPE_NUMBER);
1067
1068 break;
1069 case DSL_PARAM_TYPE_COLOR:
1070 (void) dsl_var_dst_color(d_b, m_b, &n_b);
1071 (void) dsl_var_or_number(v, &n_a, &n_b, f, DSL_PARAM_TYPE_COLOR);
1072
1073 break;
1074 case DSL_PARAM_TYPE_IMAGE:
1075 (void) dsl_var_dst_image(d_b, m_b, &n_b);
1076 (void) dsl_var_or_number(v, &n_a, &n_b, f, DSL_PARAM_TYPE_IMAGE);
1077
1078 break;
1079 case DSL_PARAM_TYPE_POINT:
1080 (void) dsl_var_dst_point(d_b, m_b, &n_b);
1081 (void) dsl_var_or_number(v, &n_a, &n_b, f, DSL_PARAM_TYPE_POINT);
1082
1083 break;
1084 default:
1085 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1086
1087 return;
1088 }
1089 }
1090
dsl_var_xor_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,struct dsl_flg * f,unsigned int c)1091 void dsl_var_xor_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, struct dsl_flg *f, unsigned int c) {
1092 double a, b;
1093
1094 a = dsl_num_get_number(n_a->c, n_a);
1095 b = dsl_num_get_number(n_b->c, n_b);
1096
1097 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1098
1099 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_XOR);
1100
1101 (void) dsl_var_num_flag_s(&v->number, f);
1102 (void) dsl_var_num_flag_z(&v->number, f);
1103 }
1104
dsl_var_xor_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b,struct dsl_flg * f)1105 void dsl_var_xor_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b, struct dsl_flg *f) {
1106 struct dsl_num n_a, n_b;
1107
1108 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
1109
1110 switch(d_b->c) {
1111 case DSL_PARAM_TYPE_NUMBER:
1112 (void) dsl_var_xor_number(v, &n_a, &d_b->number, f, DSL_PARAM_TYPE_NUMBER);
1113
1114 break;
1115 case DSL_PARAM_TYPE_COLOR:
1116 (void) dsl_var_dst_color(d_b, m_b, &n_b);
1117 (void) dsl_var_xor_number(v, &n_a, &n_b, f, DSL_PARAM_TYPE_COLOR);
1118
1119 break;
1120 case DSL_PARAM_TYPE_IMAGE:
1121 (void) dsl_var_dst_image(d_b, m_b, &n_b);
1122 (void) dsl_var_xor_number(v, &n_a, &n_b, f, DSL_PARAM_TYPE_IMAGE);
1123
1124 break;
1125 case DSL_PARAM_TYPE_POINT:
1126 (void) dsl_var_dst_point(d_b, m_b, &n_b);
1127 (void) dsl_var_xor_number(v, &n_a, &n_b, f, DSL_PARAM_TYPE_POINT);
1128
1129 break;
1130 default:
1131 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1132
1133 return;
1134 }
1135 }
1136
dsl_var_not_number(struct dsl_var * v,struct dsl_num * n,struct dsl_flg * f,unsigned int c)1137 void dsl_var_not_number(struct dsl_var *v, struct dsl_num *n, struct dsl_flg *f, unsigned int c) {
1138 double a;
1139
1140 a = dsl_num_get_number(n->c, n);
1141
1142 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1143
1144 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_NOT);
1145
1146 (void) dsl_var_num_flag_s(&v->number, f);
1147 (void) dsl_var_num_flag_z(&v->number, f);
1148 }
1149
dsl_var_not_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m,struct dsl_flg * f)1150 void dsl_var_not_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m, struct dsl_flg *f) {
1151 struct dsl_num n;
1152
1153 switch(d->c) {
1154 case DSL_PARAM_TYPE_NUMBER:
1155 (void) dsl_var_not_number(v, &d->number, f, DSL_PARAM_TYPE_NUMBER);
1156
1157 break;
1158 case DSL_PARAM_TYPE_COLOR:
1159 (void) dsl_var_dst_color(d, m, &n);
1160 (void) dsl_var_not_number(v, &n, f, DSL_PARAM_TYPE_COLOR);
1161
1162 break;
1163 case DSL_PARAM_TYPE_IMAGE:
1164 (void) dsl_var_dst_image(d, m, &n);
1165 (void) dsl_var_not_number(v, &n, f, DSL_PARAM_TYPE_IMAGE);
1166
1167 break;
1168 case DSL_PARAM_TYPE_POINT:
1169 (void) dsl_var_dst_point(d, m, &n);
1170 (void) dsl_var_not_number(v, &n, f, DSL_PARAM_TYPE_POINT);
1171
1172 break;
1173 default:
1174 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1175
1176 return;
1177 }
1178 }
1179
dsl_var_test_number(struct dsl_var * v,struct dsl_num * n,struct dsl_flg * f)1180 void dsl_var_test_number(struct dsl_var *v, struct dsl_num *n, struct dsl_flg *f) {
1181 double a, b;
1182
1183 struct dsl_var t;
1184
1185 (void) memcpy((void *) &t, (const void *) v, sizeof(t));
1186
1187 a = dsl_num_get_number(n->c, n);
1188 b = dsl_num_get_number(v->number.c, &v->number);
1189
1190 (void) dsl_var_src_number(&t, a, b, 0.0, NULL, DSL_COMMAND_AND);
1191
1192 (void) dsl_var_num_flag_s(&t.number, f);
1193 (void) dsl_var_num_flag_z(&t.number, f);
1194 }
1195
dsl_var_test_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m,struct dsl_flg * f)1196 void dsl_var_test_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m, struct dsl_flg *f) {
1197 struct dsl_num n;
1198
1199 switch(d->c) {
1200 case DSL_PARAM_TYPE_NUMBER:
1201 (void) dsl_var_test_number(v, &d->number, f);
1202
1203 break;
1204 case DSL_PARAM_TYPE_COLOR:
1205 (void) dsl_var_dst_color(d, m, &n);
1206 (void) dsl_var_test_number(v, &n, f);
1207
1208 break;
1209 case DSL_PARAM_TYPE_IMAGE:
1210 (void) dsl_var_dst_image(d, m, &n);
1211 (void) dsl_var_test_number(v, &n, f);
1212
1213 break;
1214 case DSL_PARAM_TYPE_POINT:
1215 (void) dsl_var_dst_point(d, m, &n);
1216 (void) dsl_var_test_number(v, &n, f);
1217
1218 break;
1219 default:
1220 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1221
1222 return;
1223 }
1224 }
1225
dsl_var_isfinite_number(struct dsl_var * v,struct dsl_num * n,struct dsl_flg * f,unsigned int c)1226 void dsl_var_isfinite_number(struct dsl_var *v, struct dsl_num *n, struct dsl_flg *f, unsigned int c) {
1227 double a;
1228
1229 a = dsl_num_get_number(n->c, n);
1230
1231 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1232
1233 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ISFINITE);
1234
1235 (void) dsl_var_num_flag_s(&v->number, f);
1236 (void) dsl_var_num_flag_z(&v->number, f);
1237 }
1238
dsl_var_isfinite_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m,struct dsl_flg * f)1239 void dsl_var_isfinite_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m, struct dsl_flg *f) {
1240 struct dsl_num n;
1241
1242 switch(d->c) {
1243 case DSL_PARAM_TYPE_NUMBER:
1244 (void) dsl_var_isfinite_number(v, &d->number, f, DSL_PARAM_TYPE_NUMBER);
1245
1246 break;
1247 case DSL_PARAM_TYPE_COLOR:
1248 (void) dsl_var_dst_color(d, m, &n);
1249 (void) dsl_var_isfinite_number(v, &n, f, DSL_PARAM_TYPE_COLOR);
1250
1251 break;
1252 case DSL_PARAM_TYPE_IMAGE:
1253 (void) dsl_var_dst_image(d, m, &n);
1254 (void) dsl_var_isfinite_number(v, &n, f, DSL_PARAM_TYPE_IMAGE);
1255
1256 break;
1257 case DSL_PARAM_TYPE_POINT:
1258 (void) dsl_var_dst_point(d, m, &n);
1259 (void) dsl_var_isfinite_number(v, &n, f, DSL_PARAM_TYPE_POINT);
1260
1261 break;
1262 default:
1263 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1264
1265 return;
1266 }
1267 }
1268
dsl_var_isinf_number(struct dsl_var * v,struct dsl_num * n,struct dsl_flg * f,unsigned int c)1269 void dsl_var_isinf_number(struct dsl_var *v, struct dsl_num *n, struct dsl_flg *f, unsigned int c) {
1270 double a;
1271
1272 a = dsl_num_get_number(n->c, n);
1273
1274 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1275
1276 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ISINF);
1277
1278 (void) dsl_var_num_flag_s(&v->number, f);
1279 (void) dsl_var_num_flag_z(&v->number, f);
1280 }
1281
dsl_var_isinf_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m,struct dsl_flg * f)1282 void dsl_var_isinf_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m, struct dsl_flg *f) {
1283 struct dsl_num n;
1284
1285 switch(d->c) {
1286 case DSL_PARAM_TYPE_NUMBER:
1287 (void) dsl_var_isinf_number(v, &d->number, f, DSL_PARAM_TYPE_NUMBER);
1288
1289 break;
1290 case DSL_PARAM_TYPE_COLOR:
1291 (void) dsl_var_dst_color(d, m, &n);
1292 (void) dsl_var_isinf_number(v, &n, f, DSL_PARAM_TYPE_COLOR);
1293
1294 break;
1295 case DSL_PARAM_TYPE_IMAGE:
1296 (void) dsl_var_dst_image(d, m, &n);
1297 (void) dsl_var_isinf_number(v, &n, f, DSL_PARAM_TYPE_IMAGE);
1298
1299 break;
1300 case DSL_PARAM_TYPE_POINT:
1301 (void) dsl_var_dst_point(d, m, &n);
1302 (void) dsl_var_isinf_number(v, &n, f, DSL_PARAM_TYPE_POINT);
1303
1304 break;
1305 default:
1306 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1307
1308 return;
1309 }
1310 }
1311
dsl_var_isnan_number(struct dsl_var * v,struct dsl_num * n,struct dsl_flg * f,unsigned int c)1312 void dsl_var_isnan_number(struct dsl_var *v, struct dsl_num *n, struct dsl_flg *f, unsigned int c) {
1313 double a;
1314
1315 a = dsl_num_get_number(n->c, n);
1316
1317 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1318
1319 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ISNAN);
1320
1321 (void) dsl_var_num_flag_s(&v->number, f);
1322 (void) dsl_var_num_flag_z(&v->number, f);
1323 }
1324
dsl_var_isnan_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m,struct dsl_flg * f)1325 void dsl_var_isnan_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m, struct dsl_flg *f) {
1326 struct dsl_num n;
1327
1328 switch(d->c) {
1329 case DSL_PARAM_TYPE_NUMBER:
1330 (void) dsl_var_isnan_number(v, &d->number, f, DSL_PARAM_TYPE_NUMBER);
1331
1332 break;
1333 case DSL_PARAM_TYPE_COLOR:
1334 (void) dsl_var_dst_color(d, m, &n);
1335 (void) dsl_var_isnan_number(v, &n, f, DSL_PARAM_TYPE_COLOR);
1336
1337 break;
1338 case DSL_PARAM_TYPE_IMAGE:
1339 (void) dsl_var_dst_image(d, m, &n);
1340 (void) dsl_var_isnan_number(v, &n, f, DSL_PARAM_TYPE_IMAGE);
1341
1342 break;
1343 case DSL_PARAM_TYPE_POINT:
1344 (void) dsl_var_dst_point(d, m, &n);
1345 (void) dsl_var_isnan_number(v, &n, f, DSL_PARAM_TYPE_POINT);
1346
1347 break;
1348 default:
1349 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1350
1351 return;
1352 }
1353 }
1354
dsl_var_isnormal_number(struct dsl_var * v,struct dsl_num * n,struct dsl_flg * f,unsigned int c)1355 void dsl_var_isnormal_number(struct dsl_var *v, struct dsl_num *n, struct dsl_flg *f, unsigned int c) {
1356 double a;
1357
1358 a = dsl_num_get_number(n->c, n);
1359
1360 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1361
1362 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ISNORMAL);
1363
1364 (void) dsl_var_num_flag_s(&v->number, f);
1365 (void) dsl_var_num_flag_z(&v->number, f);
1366 }
1367
dsl_var_isnormal_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m,struct dsl_flg * f)1368 void dsl_var_isnormal_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m, struct dsl_flg *f) {
1369 struct dsl_num n;
1370
1371 switch(d->c) {
1372 case DSL_PARAM_TYPE_NUMBER:
1373 (void) dsl_var_isnormal_number(v, &d->number, f, DSL_PARAM_TYPE_NUMBER);
1374
1375 break;
1376 case DSL_PARAM_TYPE_COLOR:
1377 (void) dsl_var_dst_color(d, m, &n);
1378 (void) dsl_var_isnormal_number(v, &n, f, DSL_PARAM_TYPE_COLOR);
1379
1380 break;
1381 case DSL_PARAM_TYPE_IMAGE:
1382 (void) dsl_var_dst_image(d, m, &n);
1383 (void) dsl_var_isnormal_number(v, &n, f, DSL_PARAM_TYPE_IMAGE);
1384
1385 break;
1386 case DSL_PARAM_TYPE_POINT:
1387 (void) dsl_var_dst_point(d, m, &n);
1388 (void) dsl_var_isnormal_number(v, &n, f, DSL_PARAM_TYPE_POINT);
1389
1390 break;
1391 default:
1392 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1393
1394 return;
1395 }
1396 }
1397
dsl_var_signbit_number(struct dsl_var * v,struct dsl_num * n,struct dsl_flg * f,unsigned int c)1398 void dsl_var_signbit_number(struct dsl_var *v, struct dsl_num *n, struct dsl_flg *f, unsigned int c) {
1399 double a;
1400
1401 a = dsl_num_get_number(n->c, n);
1402
1403 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1404
1405 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_SIGNBIT);
1406
1407 (void) dsl_var_num_flag_s(&v->number, f);
1408 (void) dsl_var_num_flag_z(&v->number, f);
1409 }
1410
dsl_var_signbit_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m,struct dsl_flg * f)1411 void dsl_var_signbit_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m, struct dsl_flg *f) {
1412 struct dsl_num n;
1413
1414 switch(d->c) {
1415 case DSL_PARAM_TYPE_NUMBER:
1416 (void) dsl_var_signbit_number(v, &d->number, f, DSL_PARAM_TYPE_NUMBER);
1417
1418 break;
1419 case DSL_PARAM_TYPE_COLOR:
1420 (void) dsl_var_dst_color(d, m, &n);
1421 (void) dsl_var_signbit_number(v, &n, f, DSL_PARAM_TYPE_COLOR);
1422
1423 break;
1424 case DSL_PARAM_TYPE_IMAGE:
1425 (void) dsl_var_dst_image(d, m, &n);
1426 (void) dsl_var_signbit_number(v, &n, f, DSL_PARAM_TYPE_IMAGE);
1427
1428 break;
1429 case DSL_PARAM_TYPE_POINT:
1430 (void) dsl_var_dst_point(d, m, &n);
1431 (void) dsl_var_signbit_number(v, &n, f, DSL_PARAM_TYPE_POINT);
1432
1433 break;
1434 default:
1435 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1436
1437 return;
1438 }
1439 }
1440
dsl_var_nan_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1441 void dsl_var_nan_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1442 double a;
1443
1444 a = dsl_num_get_number(n->c, n);
1445
1446 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1447
1448 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_NAN);
1449 }
1450
dsl_var_nan_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1451 void dsl_var_nan_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1452 struct dsl_num n;
1453
1454 switch(d->c) {
1455 case DSL_PARAM_TYPE_NUMBER:
1456 (void) dsl_var_nan_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1457
1458 break;
1459 case DSL_PARAM_TYPE_COLOR:
1460 (void) dsl_var_dst_color(d, m, &n);
1461 (void) dsl_var_nan_number(v, &n, DSL_PARAM_TYPE_COLOR);
1462
1463 break;
1464 case DSL_PARAM_TYPE_IMAGE:
1465 (void) dsl_var_dst_image(d, m, &n);
1466 (void) dsl_var_nan_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1467
1468 break;
1469 case DSL_PARAM_TYPE_POINT:
1470 (void) dsl_var_dst_point(d, m, &n);
1471 (void) dsl_var_nan_number(v, &n, DSL_PARAM_TYPE_POINT);
1472
1473 break;
1474 default:
1475 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1476
1477 return;
1478 }
1479 }
1480
dsl_var_ceil_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1481 void dsl_var_ceil_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1482 double a;
1483
1484 a = dsl_num_get_number(n->c, n);
1485
1486 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1487
1488 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_CEIL);
1489 }
1490
dsl_var_ceil_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1491 void dsl_var_ceil_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1492 struct dsl_num n;
1493
1494 switch(d->c) {
1495 case DSL_PARAM_TYPE_NUMBER:
1496 (void) dsl_var_ceil_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1497
1498 break;
1499 case DSL_PARAM_TYPE_COLOR:
1500 (void) dsl_var_dst_color(d, m, &n);
1501 (void) dsl_var_ceil_number(v, &n, DSL_PARAM_TYPE_COLOR);
1502
1503 break;
1504 case DSL_PARAM_TYPE_IMAGE:
1505 (void) dsl_var_dst_image(d, m, &n);
1506 (void) dsl_var_ceil_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1507
1508 break;
1509 case DSL_PARAM_TYPE_POINT:
1510 (void) dsl_var_dst_point(d, m, &n);
1511 (void) dsl_var_ceil_number(v, &n, DSL_PARAM_TYPE_POINT);
1512
1513 break;
1514 default:
1515 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1516
1517 return;
1518 }
1519 }
1520
dsl_var_floor_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1521 void dsl_var_floor_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1522 double a;
1523
1524 a = dsl_num_get_number(n->c, n);
1525
1526 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1527
1528 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_FLOOR);
1529 }
1530
dsl_var_floor_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1531 void dsl_var_floor_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1532 struct dsl_num n;
1533
1534 switch(d->c) {
1535 case DSL_PARAM_TYPE_NUMBER:
1536 (void) dsl_var_floor_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1537
1538 break;
1539 case DSL_PARAM_TYPE_COLOR:
1540 (void) dsl_var_dst_color(d, m, &n);
1541 (void) dsl_var_floor_number(v, &n, DSL_PARAM_TYPE_COLOR);
1542
1543 break;
1544 case DSL_PARAM_TYPE_IMAGE:
1545 (void) dsl_var_dst_image(d, m, &n);
1546 (void) dsl_var_floor_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1547
1548 break;
1549 case DSL_PARAM_TYPE_POINT:
1550 (void) dsl_var_dst_point(d, m, &n);
1551 (void) dsl_var_floor_number(v, &n, DSL_PARAM_TYPE_POINT);
1552
1553 break;
1554 default:
1555 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1556
1557 return;
1558 }
1559 }
1560
dsl_var_nearbyint_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1561 void dsl_var_nearbyint_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1562 double a;
1563
1564 a = dsl_num_get_number(n->c, n);
1565
1566 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1567
1568 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_NEARBYINT);
1569 }
1570
dsl_var_nearbyint_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1571 void dsl_var_nearbyint_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1572 struct dsl_num n;
1573
1574 switch(d->c) {
1575 case DSL_PARAM_TYPE_NUMBER:
1576 (void) dsl_var_nearbyint_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1577
1578 break;
1579 case DSL_PARAM_TYPE_COLOR:
1580 (void) dsl_var_dst_color(d, m, &n);
1581 (void) dsl_var_nearbyint_number(v, &n, DSL_PARAM_TYPE_COLOR);
1582
1583 break;
1584 case DSL_PARAM_TYPE_IMAGE:
1585 (void) dsl_var_dst_image(d, m, &n);
1586 (void) dsl_var_nearbyint_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1587
1588 break;
1589 case DSL_PARAM_TYPE_POINT:
1590 (void) dsl_var_dst_point(d, m, &n);
1591 (void) dsl_var_nearbyint_number(v, &n, DSL_PARAM_TYPE_POINT);
1592
1593 break;
1594 default:
1595 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1596
1597 return;
1598 }
1599 }
1600
dsl_var_rint_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1601 void dsl_var_rint_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1602 double a;
1603
1604 a = dsl_num_get_number(n->c, n);
1605
1606 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1607
1608 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_RINT);
1609 }
1610
dsl_var_rint_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1611 void dsl_var_rint_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1612 struct dsl_num n;
1613
1614 switch(d->c) {
1615 case DSL_PARAM_TYPE_NUMBER:
1616 (void) dsl_var_rint_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1617
1618 break;
1619 case DSL_PARAM_TYPE_COLOR:
1620 (void) dsl_var_dst_color(d, m, &n);
1621 (void) dsl_var_rint_number(v, &n, DSL_PARAM_TYPE_COLOR);
1622
1623 break;
1624 case DSL_PARAM_TYPE_IMAGE:
1625 (void) dsl_var_dst_image(d, m, &n);
1626 (void) dsl_var_rint_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1627
1628 break;
1629 case DSL_PARAM_TYPE_POINT:
1630 (void) dsl_var_dst_point(d, m, &n);
1631 (void) dsl_var_rint_number(v, &n, DSL_PARAM_TYPE_POINT);
1632
1633 break;
1634 default:
1635 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1636
1637 return;
1638 }
1639 }
1640
dsl_var_round_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1641 void dsl_var_round_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1642 double a;
1643
1644 a = dsl_num_get_number(n->c, n);
1645
1646 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1647
1648 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ROUND);
1649 }
1650
dsl_var_round_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1651 void dsl_var_round_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1652 struct dsl_num n;
1653
1654 switch(d->c) {
1655 case DSL_PARAM_TYPE_NUMBER:
1656 (void) dsl_var_round_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1657
1658 break;
1659 case DSL_PARAM_TYPE_COLOR:
1660 (void) dsl_var_dst_color(d, m, &n);
1661 (void) dsl_var_round_number(v, &n, DSL_PARAM_TYPE_COLOR);
1662
1663 break;
1664 case DSL_PARAM_TYPE_IMAGE:
1665 (void) dsl_var_dst_image(d, m, &n);
1666 (void) dsl_var_round_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1667
1668 break;
1669 case DSL_PARAM_TYPE_POINT:
1670 (void) dsl_var_dst_point(d, m, &n);
1671 (void) dsl_var_round_number(v, &n, DSL_PARAM_TYPE_POINT);
1672
1673 break;
1674 default:
1675 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1676
1677 return;
1678 }
1679 }
1680
dsl_var_trunc_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1681 void dsl_var_trunc_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1682 double a;
1683
1684 a = dsl_num_get_number(n->c, n);
1685
1686 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1687
1688 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_TRUNC);
1689 }
1690
dsl_var_trunc_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1691 void dsl_var_trunc_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1692 struct dsl_num n;
1693
1694 switch(d->c) {
1695 case DSL_PARAM_TYPE_NUMBER:
1696 (void) dsl_var_trunc_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1697
1698 break;
1699 case DSL_PARAM_TYPE_COLOR:
1700 (void) dsl_var_dst_color(d, m, &n);
1701 (void) dsl_var_trunc_number(v, &n, DSL_PARAM_TYPE_COLOR);
1702
1703 break;
1704 case DSL_PARAM_TYPE_IMAGE:
1705 (void) dsl_var_dst_image(d, m, &n);
1706 (void) dsl_var_trunc_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1707
1708 break;
1709 case DSL_PARAM_TYPE_POINT:
1710 (void) dsl_var_dst_point(d, m, &n);
1711 (void) dsl_var_trunc_number(v, &n, DSL_PARAM_TYPE_POINT);
1712
1713 break;
1714 default:
1715 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1716
1717 return;
1718 }
1719 }
1720
dsl_var_sqrt_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1721 void dsl_var_sqrt_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1722 double a;
1723
1724 a = dsl_num_get_number(n->c, n);
1725
1726 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1727
1728 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_SQRT);
1729 }
1730
dsl_var_sqrt_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1731 void dsl_var_sqrt_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1732 struct dsl_num n;
1733
1734 switch(d->c) {
1735 case DSL_PARAM_TYPE_NUMBER:
1736 (void) dsl_var_sqrt_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1737
1738 break;
1739 case DSL_PARAM_TYPE_COLOR:
1740 (void) dsl_var_dst_color(d, m, &n);
1741 (void) dsl_var_sqrt_number(v, &n, DSL_PARAM_TYPE_COLOR);
1742
1743 break;
1744 case DSL_PARAM_TYPE_IMAGE:
1745 (void) dsl_var_dst_image(d, m, &n);
1746 (void) dsl_var_sqrt_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1747
1748 break;
1749 case DSL_PARAM_TYPE_POINT:
1750 (void) dsl_var_dst_point(d, m, &n);
1751 (void) dsl_var_sqrt_number(v, &n, DSL_PARAM_TYPE_POINT);
1752
1753 break;
1754 default:
1755 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1756
1757 return;
1758 }
1759 }
1760
dsl_var_cbrt_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1761 void dsl_var_cbrt_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1762 double a;
1763
1764 a = dsl_num_get_number(n->c, n);
1765
1766 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1767
1768 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_CBRT);
1769 }
1770
dsl_var_cbrt_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1771 void dsl_var_cbrt_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1772 struct dsl_num n;
1773
1774 switch(d->c) {
1775 case DSL_PARAM_TYPE_NUMBER:
1776 (void) dsl_var_cbrt_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1777
1778 break;
1779 case DSL_PARAM_TYPE_COLOR:
1780 (void) dsl_var_dst_color(d, m, &n);
1781 (void) dsl_var_cbrt_number(v, &n, DSL_PARAM_TYPE_COLOR);
1782
1783 break;
1784 case DSL_PARAM_TYPE_IMAGE:
1785 (void) dsl_var_dst_image(d, m, &n);
1786 (void) dsl_var_cbrt_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1787
1788 break;
1789 case DSL_PARAM_TYPE_POINT:
1790 (void) dsl_var_dst_point(d, m, &n);
1791 (void) dsl_var_cbrt_number(v, &n, DSL_PARAM_TYPE_POINT);
1792
1793 break;
1794 default:
1795 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1796
1797 return;
1798 }
1799 }
1800
dsl_var_exp_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1801 void dsl_var_exp_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1802 double a;
1803
1804 a = dsl_num_get_number(n->c, n);
1805
1806 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1807
1808 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_EXP);
1809 }
1810
dsl_var_exp_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1811 void dsl_var_exp_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1812 struct dsl_num n;
1813
1814 switch(d->c) {
1815 case DSL_PARAM_TYPE_NUMBER:
1816 (void) dsl_var_exp_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1817
1818 break;
1819 case DSL_PARAM_TYPE_COLOR:
1820 (void) dsl_var_dst_color(d, m, &n);
1821 (void) dsl_var_exp_number(v, &n, DSL_PARAM_TYPE_COLOR);
1822
1823 break;
1824 case DSL_PARAM_TYPE_IMAGE:
1825 (void) dsl_var_dst_image(d, m, &n);
1826 (void) dsl_var_exp_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1827
1828 break;
1829 case DSL_PARAM_TYPE_POINT:
1830 (void) dsl_var_dst_point(d, m, &n);
1831 (void) dsl_var_exp_number(v, &n, DSL_PARAM_TYPE_POINT);
1832
1833 break;
1834 default:
1835 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1836
1837 return;
1838 }
1839 }
1840
dsl_var_exp2_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1841 void dsl_var_exp2_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1842 double a;
1843
1844 a = dsl_num_get_number(n->c, n);
1845
1846 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1847
1848 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_EXP2);
1849 }
1850
dsl_var_exp2_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1851 void dsl_var_exp2_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1852 struct dsl_num n;
1853
1854 switch(d->c) {
1855 case DSL_PARAM_TYPE_NUMBER:
1856 (void) dsl_var_exp2_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1857
1858 break;
1859 case DSL_PARAM_TYPE_COLOR:
1860 (void) dsl_var_dst_color(d, m, &n);
1861 (void) dsl_var_exp2_number(v, &n, DSL_PARAM_TYPE_COLOR);
1862
1863 break;
1864 case DSL_PARAM_TYPE_IMAGE:
1865 (void) dsl_var_dst_image(d, m, &n);
1866 (void) dsl_var_exp2_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1867
1868 break;
1869 case DSL_PARAM_TYPE_POINT:
1870 (void) dsl_var_dst_point(d, m, &n);
1871 (void) dsl_var_exp2_number(v, &n, DSL_PARAM_TYPE_POINT);
1872
1873 break;
1874 default:
1875 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1876
1877 return;
1878 }
1879 }
1880
dsl_var_expm1_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1881 void dsl_var_expm1_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1882 double a;
1883
1884 a = dsl_num_get_number(n->c, n);
1885
1886 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1887
1888 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_EXPM1);
1889 }
1890
dsl_var_expm1_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1891 void dsl_var_expm1_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1892 struct dsl_num n;
1893
1894 switch(d->c) {
1895 case DSL_PARAM_TYPE_NUMBER:
1896 (void) dsl_var_expm1_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1897
1898 break;
1899 case DSL_PARAM_TYPE_COLOR:
1900 (void) dsl_var_dst_color(d, m, &n);
1901 (void) dsl_var_expm1_number(v, &n, DSL_PARAM_TYPE_COLOR);
1902
1903 break;
1904 case DSL_PARAM_TYPE_IMAGE:
1905 (void) dsl_var_dst_image(d, m, &n);
1906 (void) dsl_var_expm1_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1907
1908 break;
1909 case DSL_PARAM_TYPE_POINT:
1910 (void) dsl_var_dst_point(d, m, &n);
1911 (void) dsl_var_expm1_number(v, &n, DSL_PARAM_TYPE_POINT);
1912
1913 break;
1914 default:
1915 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1916
1917 return;
1918 }
1919 }
1920
dsl_var_log_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1921 void dsl_var_log_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1922 double a;
1923
1924 a = dsl_num_get_number(n->c, n);
1925
1926 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1927
1928 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_LOG);
1929 }
1930
dsl_var_log_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1931 void dsl_var_log_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1932 struct dsl_num n;
1933
1934 switch(d->c) {
1935 case DSL_PARAM_TYPE_NUMBER:
1936 (void) dsl_var_log_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1937
1938 break;
1939 case DSL_PARAM_TYPE_COLOR:
1940 (void) dsl_var_dst_color(d, m, &n);
1941 (void) dsl_var_log_number(v, &n, DSL_PARAM_TYPE_COLOR);
1942
1943 break;
1944 case DSL_PARAM_TYPE_IMAGE:
1945 (void) dsl_var_dst_image(d, m, &n);
1946 (void) dsl_var_log_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1947
1948 break;
1949 case DSL_PARAM_TYPE_POINT:
1950 (void) dsl_var_dst_point(d, m, &n);
1951 (void) dsl_var_log_number(v, &n, DSL_PARAM_TYPE_POINT);
1952
1953 break;
1954 default:
1955 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1956
1957 return;
1958 }
1959 }
1960
dsl_var_log2_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)1961 void dsl_var_log2_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
1962 double a;
1963
1964 a = dsl_num_get_number(n->c, n);
1965
1966 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
1967
1968 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_LOG2);
1969 }
1970
dsl_var_log2_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)1971 void dsl_var_log2_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
1972 struct dsl_num n;
1973
1974 switch(d->c) {
1975 case DSL_PARAM_TYPE_NUMBER:
1976 (void) dsl_var_log2_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
1977
1978 break;
1979 case DSL_PARAM_TYPE_COLOR:
1980 (void) dsl_var_dst_color(d, m, &n);
1981 (void) dsl_var_log2_number(v, &n, DSL_PARAM_TYPE_COLOR);
1982
1983 break;
1984 case DSL_PARAM_TYPE_IMAGE:
1985 (void) dsl_var_dst_image(d, m, &n);
1986 (void) dsl_var_log2_number(v, &n, DSL_PARAM_TYPE_IMAGE);
1987
1988 break;
1989 case DSL_PARAM_TYPE_POINT:
1990 (void) dsl_var_dst_point(d, m, &n);
1991 (void) dsl_var_log2_number(v, &n, DSL_PARAM_TYPE_POINT);
1992
1993 break;
1994 default:
1995 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
1996
1997 return;
1998 }
1999 }
2000
dsl_var_log10_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2001 void dsl_var_log10_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2002 double a;
2003
2004 a = dsl_num_get_number(n->c, n);
2005
2006 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2007
2008 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_LOG10);
2009 }
2010
dsl_var_log10_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2011 void dsl_var_log10_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2012 struct dsl_num n;
2013
2014 switch(d->c) {
2015 case DSL_PARAM_TYPE_NUMBER:
2016 (void) dsl_var_log10_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2017
2018 break;
2019 case DSL_PARAM_TYPE_COLOR:
2020 (void) dsl_var_dst_color(d, m, &n);
2021 (void) dsl_var_log10_number(v, &n, DSL_PARAM_TYPE_COLOR);
2022
2023 break;
2024 case DSL_PARAM_TYPE_IMAGE:
2025 (void) dsl_var_dst_image(d, m, &n);
2026 (void) dsl_var_log10_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2027
2028 break;
2029 case DSL_PARAM_TYPE_POINT:
2030 (void) dsl_var_dst_point(d, m, &n);
2031 (void) dsl_var_log10_number(v, &n, DSL_PARAM_TYPE_POINT);
2032
2033 break;
2034 default:
2035 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2036
2037 return;
2038 }
2039 }
2040
dsl_var_log1p_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2041 void dsl_var_log1p_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2042 double a;
2043
2044 a = dsl_num_get_number(n->c, n);
2045
2046 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2047
2048 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_LOG1P);
2049 }
2050
dsl_var_log1p_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2051 void dsl_var_log1p_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2052 struct dsl_num n;
2053
2054 switch(d->c) {
2055 case DSL_PARAM_TYPE_NUMBER:
2056 (void) dsl_var_log1p_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2057
2058 break;
2059 case DSL_PARAM_TYPE_COLOR:
2060 (void) dsl_var_dst_color(d, m, &n);
2061 (void) dsl_var_log1p_number(v, &n, DSL_PARAM_TYPE_COLOR);
2062
2063 break;
2064 case DSL_PARAM_TYPE_IMAGE:
2065 (void) dsl_var_dst_image(d, m, &n);
2066 (void) dsl_var_log1p_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2067
2068 break;
2069 case DSL_PARAM_TYPE_POINT:
2070 (void) dsl_var_dst_point(d, m, &n);
2071 (void) dsl_var_log1p_number(v, &n, DSL_PARAM_TYPE_POINT);
2072
2073 break;
2074 default:
2075 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2076
2077 return;
2078 }
2079 }
2080
dsl_var_logb_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2081 void dsl_var_logb_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2082 double a;
2083
2084 a = dsl_num_get_number(n->c, n);
2085
2086 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2087
2088 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_LOGB);
2089 }
2090
dsl_var_logb_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2091 void dsl_var_logb_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2092 struct dsl_num n;
2093
2094 switch(d->c) {
2095 case DSL_PARAM_TYPE_NUMBER:
2096 (void) dsl_var_logb_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2097
2098 break;
2099 case DSL_PARAM_TYPE_COLOR:
2100 (void) dsl_var_dst_color(d, m, &n);
2101 (void) dsl_var_logb_number(v, &n, DSL_PARAM_TYPE_COLOR);
2102
2103 break;
2104 case DSL_PARAM_TYPE_IMAGE:
2105 (void) dsl_var_dst_image(d, m, &n);
2106 (void) dsl_var_logb_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2107
2108 break;
2109 case DSL_PARAM_TYPE_POINT:
2110 (void) dsl_var_dst_point(d, m, &n);
2111 (void) dsl_var_logb_number(v, &n, DSL_PARAM_TYPE_POINT);
2112
2113 break;
2114 default:
2115 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2116
2117 return;
2118 }
2119 }
2120
dsl_var_ilogb_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2121 void dsl_var_ilogb_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2122 double a;
2123
2124 a = dsl_num_get_number(n->c, n);
2125
2126 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2127
2128 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ILOGB);
2129 }
2130
dsl_var_ilogb_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2131 void dsl_var_ilogb_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2132 struct dsl_num n;
2133
2134 switch(d->c) {
2135 case DSL_PARAM_TYPE_NUMBER:
2136 (void) dsl_var_ilogb_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2137
2138 break;
2139 case DSL_PARAM_TYPE_COLOR:
2140 (void) dsl_var_dst_color(d, m, &n);
2141 (void) dsl_var_ilogb_number(v, &n, DSL_PARAM_TYPE_COLOR);
2142
2143 break;
2144 case DSL_PARAM_TYPE_IMAGE:
2145 (void) dsl_var_dst_image(d, m, &n);
2146 (void) dsl_var_ilogb_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2147
2148 break;
2149 case DSL_PARAM_TYPE_POINT:
2150 (void) dsl_var_dst_point(d, m, &n);
2151 (void) dsl_var_ilogb_number(v, &n, DSL_PARAM_TYPE_POINT);
2152
2153 break;
2154 default:
2155 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2156
2157 return;
2158 }
2159 }
2160
dsl_var_cos_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2161 void dsl_var_cos_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2162 double a;
2163
2164 a = dsl_num_get_number(n->c, n);
2165
2166 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2167
2168 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_COS);
2169 }
2170
dsl_var_cos_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2171 void dsl_var_cos_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2172 struct dsl_num n;
2173
2174 switch(d->c) {
2175 case DSL_PARAM_TYPE_NUMBER:
2176 (void) dsl_var_cos_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2177
2178 break;
2179 case DSL_PARAM_TYPE_COLOR:
2180 (void) dsl_var_dst_color(d, m, &n);
2181 (void) dsl_var_cos_number(v, &n, DSL_PARAM_TYPE_COLOR);
2182
2183 break;
2184 case DSL_PARAM_TYPE_IMAGE:
2185 (void) dsl_var_dst_image(d, m, &n);
2186 (void) dsl_var_cos_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2187
2188 break;
2189 case DSL_PARAM_TYPE_POINT:
2190 (void) dsl_var_dst_point(d, m, &n);
2191 (void) dsl_var_cos_number(v, &n, DSL_PARAM_TYPE_POINT);
2192
2193 break;
2194 default:
2195 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2196
2197 return;
2198 }
2199 }
2200
dsl_var_cosh_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2201 void dsl_var_cosh_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2202 double a;
2203
2204 a = dsl_num_get_number(n->c, n);
2205
2206 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2207
2208 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_COSH);
2209 }
2210
dsl_var_cosh_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2211 void dsl_var_cosh_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2212 struct dsl_num n;
2213
2214 switch(d->c) {
2215 case DSL_PARAM_TYPE_NUMBER:
2216 (void) dsl_var_cosh_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2217
2218 break;
2219 case DSL_PARAM_TYPE_COLOR:
2220 (void) dsl_var_dst_color(d, m, &n);
2221 (void) dsl_var_cosh_number(v, &n, DSL_PARAM_TYPE_COLOR);
2222
2223 break;
2224 case DSL_PARAM_TYPE_IMAGE:
2225 (void) dsl_var_dst_image(d, m, &n);
2226 (void) dsl_var_cosh_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2227
2228 break;
2229 case DSL_PARAM_TYPE_POINT:
2230 (void) dsl_var_dst_point(d, m, &n);
2231 (void) dsl_var_cosh_number(v, &n, DSL_PARAM_TYPE_POINT);
2232
2233 break;
2234 default:
2235 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2236
2237 return;
2238 }
2239 }
2240
dsl_var_acos_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2241 void dsl_var_acos_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2242 double a;
2243
2244 a = dsl_num_get_number(n->c, n);
2245
2246 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2247
2248 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ACOS);
2249 }
2250
dsl_var_acos_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2251 void dsl_var_acos_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2252 struct dsl_num n;
2253
2254 switch(d->c) {
2255 case DSL_PARAM_TYPE_NUMBER:
2256 (void) dsl_var_acos_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2257
2258 break;
2259 case DSL_PARAM_TYPE_COLOR:
2260 (void) dsl_var_dst_color(d, m, &n);
2261 (void) dsl_var_acos_number(v, &n, DSL_PARAM_TYPE_COLOR);
2262
2263 break;
2264 case DSL_PARAM_TYPE_IMAGE:
2265 (void) dsl_var_dst_image(d, m, &n);
2266 (void) dsl_var_acos_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2267
2268 break;
2269 case DSL_PARAM_TYPE_POINT:
2270 (void) dsl_var_dst_point(d, m, &n);
2271 (void) dsl_var_acos_number(v, &n, DSL_PARAM_TYPE_POINT);
2272
2273 break;
2274 default:
2275 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2276
2277 return;
2278 }
2279 }
2280
dsl_var_acosh_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2281 void dsl_var_acosh_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2282 double a;
2283
2284 a = dsl_num_get_number(n->c, n);
2285
2286 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2287
2288 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ACOSH);
2289 }
2290
dsl_var_acosh_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2291 void dsl_var_acosh_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2292 struct dsl_num n;
2293
2294 switch(d->c) {
2295 case DSL_PARAM_TYPE_NUMBER:
2296 (void) dsl_var_acosh_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2297
2298 break;
2299 case DSL_PARAM_TYPE_COLOR:
2300 (void) dsl_var_dst_color(d, m, &n);
2301 (void) dsl_var_acosh_number(v, &n, DSL_PARAM_TYPE_COLOR);
2302
2303 break;
2304 case DSL_PARAM_TYPE_IMAGE:
2305 (void) dsl_var_dst_image(d, m, &n);
2306 (void) dsl_var_acosh_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2307
2308 break;
2309 case DSL_PARAM_TYPE_POINT:
2310 (void) dsl_var_dst_point(d, m, &n);
2311 (void) dsl_var_acosh_number(v, &n, DSL_PARAM_TYPE_POINT);
2312
2313 break;
2314 default:
2315 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2316
2317 return;
2318 }
2319 }
2320
dsl_var_sin_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2321 void dsl_var_sin_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2322 double a;
2323
2324 a = dsl_num_get_number(n->c, n);
2325
2326 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2327
2328 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_SIN);
2329 }
2330
dsl_var_sin_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2331 void dsl_var_sin_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2332 struct dsl_num n;
2333
2334 switch(d->c) {
2335 case DSL_PARAM_TYPE_NUMBER:
2336 (void) dsl_var_sin_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2337
2338 break;
2339 case DSL_PARAM_TYPE_COLOR:
2340 (void) dsl_var_dst_color(d, m, &n);
2341 (void) dsl_var_sin_number(v, &n, DSL_PARAM_TYPE_COLOR);
2342
2343 break;
2344 case DSL_PARAM_TYPE_IMAGE:
2345 (void) dsl_var_dst_image(d, m, &n);
2346 (void) dsl_var_sin_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2347
2348 break;
2349 case DSL_PARAM_TYPE_POINT:
2350 (void) dsl_var_dst_point(d, m, &n);
2351 (void) dsl_var_sin_number(v, &n, DSL_PARAM_TYPE_POINT);
2352
2353 break;
2354 default:
2355 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2356
2357 return;
2358 }
2359 }
2360
dsl_var_sinh_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2361 void dsl_var_sinh_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2362 double a;
2363
2364 a = dsl_num_get_number(n->c, n);
2365
2366 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2367
2368 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_SINH);
2369 }
2370
dsl_var_sinh_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2371 void dsl_var_sinh_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2372 struct dsl_num n;
2373
2374 switch(d->c) {
2375 case DSL_PARAM_TYPE_NUMBER:
2376 (void) dsl_var_sinh_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2377
2378 break;
2379 case DSL_PARAM_TYPE_COLOR:
2380 (void) dsl_var_dst_color(d, m, &n);
2381 (void) dsl_var_sinh_number(v, &n, DSL_PARAM_TYPE_COLOR);
2382
2383 break;
2384 case DSL_PARAM_TYPE_IMAGE:
2385 (void) dsl_var_dst_image(d, m, &n);
2386 (void) dsl_var_sinh_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2387
2388 break;
2389 case DSL_PARAM_TYPE_POINT:
2390 (void) dsl_var_dst_point(d, m, &n);
2391 (void) dsl_var_sinh_number(v, &n, DSL_PARAM_TYPE_POINT);
2392
2393 break;
2394 default:
2395 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2396
2397 return;
2398 }
2399 }
2400
dsl_var_asin_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2401 void dsl_var_asin_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2402 double a;
2403
2404 a = dsl_num_get_number(n->c, n);
2405
2406 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2407
2408 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ASIN);
2409 }
2410
dsl_var_asin_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2411 void dsl_var_asin_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2412 struct dsl_num n;
2413
2414 switch(d->c) {
2415 case DSL_PARAM_TYPE_NUMBER:
2416 (void) dsl_var_asin_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2417
2418 break;
2419 case DSL_PARAM_TYPE_COLOR:
2420 (void) dsl_var_dst_color(d, m, &n);
2421 (void) dsl_var_asin_number(v, &n, DSL_PARAM_TYPE_COLOR);
2422
2423 break;
2424 case DSL_PARAM_TYPE_IMAGE:
2425 (void) dsl_var_dst_image(d, m, &n);
2426 (void) dsl_var_asin_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2427
2428 break;
2429 case DSL_PARAM_TYPE_POINT:
2430 (void) dsl_var_dst_point(d, m, &n);
2431 (void) dsl_var_asin_number(v, &n, DSL_PARAM_TYPE_POINT);
2432
2433 break;
2434 default:
2435 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2436
2437 return;
2438 }
2439 }
2440
dsl_var_asinh_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2441 void dsl_var_asinh_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2442 double a;
2443
2444 a = dsl_num_get_number(n->c, n);
2445
2446 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2447
2448 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ASINH);
2449 }
2450
dsl_var_asinh_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2451 void dsl_var_asinh_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2452 struct dsl_num n;
2453
2454 switch(d->c) {
2455 case DSL_PARAM_TYPE_NUMBER:
2456 (void) dsl_var_asinh_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2457
2458 break;
2459 case DSL_PARAM_TYPE_COLOR:
2460 (void) dsl_var_dst_color(d, m, &n);
2461 (void) dsl_var_asinh_number(v, &n, DSL_PARAM_TYPE_COLOR);
2462
2463 break;
2464 case DSL_PARAM_TYPE_IMAGE:
2465 (void) dsl_var_dst_image(d, m, &n);
2466 (void) dsl_var_asinh_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2467
2468 break;
2469 case DSL_PARAM_TYPE_POINT:
2470 (void) dsl_var_dst_point(d, m, &n);
2471 (void) dsl_var_asinh_number(v, &n, DSL_PARAM_TYPE_POINT);
2472
2473 break;
2474 default:
2475 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2476
2477 return;
2478 }
2479 }
2480
dsl_var_tan_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2481 void dsl_var_tan_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2482 double a;
2483
2484 a = dsl_num_get_number(n->c, n);
2485
2486 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2487
2488 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_TAN);
2489 }
2490
dsl_var_tan_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2491 void dsl_var_tan_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2492 struct dsl_num n;
2493
2494 switch(d->c) {
2495 case DSL_PARAM_TYPE_NUMBER:
2496 (void) dsl_var_tan_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2497
2498 break;
2499 case DSL_PARAM_TYPE_COLOR:
2500 (void) dsl_var_dst_color(d, m, &n);
2501 (void) dsl_var_tan_number(v, &n, DSL_PARAM_TYPE_COLOR);
2502
2503 break;
2504 case DSL_PARAM_TYPE_IMAGE:
2505 (void) dsl_var_dst_image(d, m, &n);
2506 (void) dsl_var_tan_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2507
2508 break;
2509 case DSL_PARAM_TYPE_POINT:
2510 (void) dsl_var_dst_point(d, m, &n);
2511 (void) dsl_var_tan_number(v, &n, DSL_PARAM_TYPE_POINT);
2512
2513 break;
2514 default:
2515 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2516
2517 return;
2518 }
2519 }
2520
dsl_var_tanh_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2521 void dsl_var_tanh_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2522 double a;
2523
2524 a = dsl_num_get_number(n->c, n);
2525
2526 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2527
2528 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_TANH);
2529 }
2530
dsl_var_tanh_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2531 void dsl_var_tanh_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2532 struct dsl_num n;
2533
2534 switch(d->c) {
2535 case DSL_PARAM_TYPE_NUMBER:
2536 (void) dsl_var_tanh_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2537
2538 break;
2539 case DSL_PARAM_TYPE_COLOR:
2540 (void) dsl_var_dst_color(d, m, &n);
2541 (void) dsl_var_tanh_number(v, &n, DSL_PARAM_TYPE_COLOR);
2542
2543 break;
2544 case DSL_PARAM_TYPE_IMAGE:
2545 (void) dsl_var_dst_image(d, m, &n);
2546 (void) dsl_var_tanh_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2547
2548 break;
2549 case DSL_PARAM_TYPE_POINT:
2550 (void) dsl_var_dst_point(d, m, &n);
2551 (void) dsl_var_tanh_number(v, &n, DSL_PARAM_TYPE_POINT);
2552
2553 break;
2554 default:
2555 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2556
2557 return;
2558 }
2559 }
2560
dsl_var_atan_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2561 void dsl_var_atan_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2562 double a;
2563
2564 a = dsl_num_get_number(n->c, n);
2565
2566 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2567
2568 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ATAN);
2569 }
2570
dsl_var_atan_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2571 void dsl_var_atan_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2572 struct dsl_num n;
2573
2574 switch(d->c) {
2575 case DSL_PARAM_TYPE_NUMBER:
2576 (void) dsl_var_atan_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2577
2578 break;
2579 case DSL_PARAM_TYPE_COLOR:
2580 (void) dsl_var_dst_color(d, m, &n);
2581 (void) dsl_var_atan_number(v, &n, DSL_PARAM_TYPE_COLOR);
2582
2583 break;
2584 case DSL_PARAM_TYPE_IMAGE:
2585 (void) dsl_var_dst_image(d, m, &n);
2586 (void) dsl_var_atan_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2587
2588 break;
2589 case DSL_PARAM_TYPE_POINT:
2590 (void) dsl_var_dst_point(d, m, &n);
2591 (void) dsl_var_atan_number(v, &n, DSL_PARAM_TYPE_POINT);
2592
2593 break;
2594 default:
2595 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2596
2597 return;
2598 }
2599 }
2600
dsl_var_atanh_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2601 void dsl_var_atanh_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2602 double a;
2603
2604 a = dsl_num_get_number(n->c, n);
2605
2606 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2607
2608 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ATANH);
2609 }
2610
dsl_var_atanh_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2611 void dsl_var_atanh_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2612 struct dsl_num n;
2613
2614 switch(d->c) {
2615 case DSL_PARAM_TYPE_NUMBER:
2616 (void) dsl_var_atanh_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2617
2618 break;
2619 case DSL_PARAM_TYPE_COLOR:
2620 (void) dsl_var_dst_color(d, m, &n);
2621 (void) dsl_var_atanh_number(v, &n, DSL_PARAM_TYPE_COLOR);
2622
2623 break;
2624 case DSL_PARAM_TYPE_IMAGE:
2625 (void) dsl_var_dst_image(d, m, &n);
2626 (void) dsl_var_atanh_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2627
2628 break;
2629 case DSL_PARAM_TYPE_POINT:
2630 (void) dsl_var_dst_point(d, m, &n);
2631 (void) dsl_var_atanh_number(v, &n, DSL_PARAM_TYPE_POINT);
2632
2633 break;
2634 default:
2635 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2636
2637 return;
2638 }
2639 }
2640
dsl_var_tgamma_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2641 void dsl_var_tgamma_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2642 double a;
2643
2644 a = dsl_num_get_number(n->c, n);
2645
2646 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2647
2648 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_TGAMMA);
2649 }
2650
dsl_var_tgamma_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2651 void dsl_var_tgamma_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2652 struct dsl_num n;
2653
2654 switch(d->c) {
2655 case DSL_PARAM_TYPE_NUMBER:
2656 (void) dsl_var_tgamma_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2657
2658 break;
2659 case DSL_PARAM_TYPE_COLOR:
2660 (void) dsl_var_dst_color(d, m, &n);
2661 (void) dsl_var_tgamma_number(v, &n, DSL_PARAM_TYPE_COLOR);
2662
2663 break;
2664 case DSL_PARAM_TYPE_IMAGE:
2665 (void) dsl_var_dst_image(d, m, &n);
2666 (void) dsl_var_tgamma_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2667
2668 break;
2669 case DSL_PARAM_TYPE_POINT:
2670 (void) dsl_var_dst_point(d, m, &n);
2671 (void) dsl_var_tgamma_number(v, &n, DSL_PARAM_TYPE_POINT);
2672
2673 break;
2674 default:
2675 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2676
2677 return;
2678 }
2679 }
2680
dsl_var_lgamma_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2681 void dsl_var_lgamma_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2682 double a;
2683
2684 a = dsl_num_get_number(n->c, n);
2685
2686 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2687
2688 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_LGAMMA);
2689 }
2690
dsl_var_lgamma_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2691 void dsl_var_lgamma_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2692 struct dsl_num n;
2693
2694 switch(d->c) {
2695 case DSL_PARAM_TYPE_NUMBER:
2696 (void) dsl_var_lgamma_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2697
2698 break;
2699 case DSL_PARAM_TYPE_COLOR:
2700 (void) dsl_var_dst_color(d, m, &n);
2701 (void) dsl_var_lgamma_number(v, &n, DSL_PARAM_TYPE_COLOR);
2702
2703 break;
2704 case DSL_PARAM_TYPE_IMAGE:
2705 (void) dsl_var_dst_image(d, m, &n);
2706 (void) dsl_var_lgamma_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2707
2708 break;
2709 case DSL_PARAM_TYPE_POINT:
2710 (void) dsl_var_dst_point(d, m, &n);
2711 (void) dsl_var_lgamma_number(v, &n, DSL_PARAM_TYPE_POINT);
2712
2713 break;
2714 default:
2715 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2716
2717 return;
2718 }
2719 }
2720
dsl_var_j0_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2721 void dsl_var_j0_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2722 double a;
2723
2724 a = dsl_num_get_number(n->c, n);
2725
2726 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2727
2728 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_J0);
2729 }
2730
dsl_var_j0_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2731 void dsl_var_j0_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2732 struct dsl_num n;
2733
2734 switch(d->c) {
2735 case DSL_PARAM_TYPE_NUMBER:
2736 (void) dsl_var_j0_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2737
2738 break;
2739 case DSL_PARAM_TYPE_COLOR:
2740 (void) dsl_var_dst_color(d, m, &n);
2741 (void) dsl_var_j0_number(v, &n, DSL_PARAM_TYPE_COLOR);
2742
2743 break;
2744 case DSL_PARAM_TYPE_IMAGE:
2745 (void) dsl_var_dst_image(d, m, &n);
2746 (void) dsl_var_j0_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2747
2748 break;
2749 case DSL_PARAM_TYPE_POINT:
2750 (void) dsl_var_dst_point(d, m, &n);
2751 (void) dsl_var_j0_number(v, &n, DSL_PARAM_TYPE_POINT);
2752
2753 break;
2754 default:
2755 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2756
2757 return;
2758 }
2759 }
2760
dsl_var_j1_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2761 void dsl_var_j1_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2762 double a;
2763
2764 a = dsl_num_get_number(n->c, n);
2765
2766 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2767
2768 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_J1);
2769 }
2770
dsl_var_j1_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2771 void dsl_var_j1_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2772 struct dsl_num n;
2773
2774 switch(d->c) {
2775 case DSL_PARAM_TYPE_NUMBER:
2776 (void) dsl_var_j1_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2777
2778 break;
2779 case DSL_PARAM_TYPE_COLOR:
2780 (void) dsl_var_dst_color(d, m, &n);
2781 (void) dsl_var_j1_number(v, &n, DSL_PARAM_TYPE_COLOR);
2782
2783 break;
2784 case DSL_PARAM_TYPE_IMAGE:
2785 (void) dsl_var_dst_image(d, m, &n);
2786 (void) dsl_var_j1_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2787
2788 break;
2789 case DSL_PARAM_TYPE_POINT:
2790 (void) dsl_var_dst_point(d, m, &n);
2791 (void) dsl_var_j1_number(v, &n, DSL_PARAM_TYPE_POINT);
2792
2793 break;
2794 default:
2795 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2796
2797 return;
2798 }
2799 }
2800
dsl_var_y0_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2801 void dsl_var_y0_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2802 double a;
2803
2804 a = dsl_num_get_number(n->c, n);
2805
2806 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2807
2808 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_Y0);
2809 }
2810
dsl_var_y0_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2811 void dsl_var_y0_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2812 struct dsl_num n;
2813
2814 switch(d->c) {
2815 case DSL_PARAM_TYPE_NUMBER:
2816 (void) dsl_var_y0_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2817
2818 break;
2819 case DSL_PARAM_TYPE_COLOR:
2820 (void) dsl_var_dst_color(d, m, &n);
2821 (void) dsl_var_y0_number(v, &n, DSL_PARAM_TYPE_COLOR);
2822
2823 break;
2824 case DSL_PARAM_TYPE_IMAGE:
2825 (void) dsl_var_dst_image(d, m, &n);
2826 (void) dsl_var_y0_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2827
2828 break;
2829 case DSL_PARAM_TYPE_POINT:
2830 (void) dsl_var_dst_point(d, m, &n);
2831 (void) dsl_var_y0_number(v, &n, DSL_PARAM_TYPE_POINT);
2832
2833 break;
2834 default:
2835 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2836
2837 return;
2838 }
2839 }
2840
dsl_var_y1_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2841 void dsl_var_y1_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2842 double a;
2843
2844 a = dsl_num_get_number(n->c, n);
2845
2846 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2847
2848 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_Y1);
2849 }
2850
dsl_var_y1_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2851 void dsl_var_y1_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2852 struct dsl_num n;
2853
2854 switch(d->c) {
2855 case DSL_PARAM_TYPE_NUMBER:
2856 (void) dsl_var_y1_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2857
2858 break;
2859 case DSL_PARAM_TYPE_COLOR:
2860 (void) dsl_var_dst_color(d, m, &n);
2861 (void) dsl_var_y1_number(v, &n, DSL_PARAM_TYPE_COLOR);
2862
2863 break;
2864 case DSL_PARAM_TYPE_IMAGE:
2865 (void) dsl_var_dst_image(d, m, &n);
2866 (void) dsl_var_y1_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2867
2868 break;
2869 case DSL_PARAM_TYPE_POINT:
2870 (void) dsl_var_dst_point(d, m, &n);
2871 (void) dsl_var_y1_number(v, &n, DSL_PARAM_TYPE_POINT);
2872
2873 break;
2874 default:
2875 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2876
2877 return;
2878 }
2879 }
2880
dsl_var_erf_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2881 void dsl_var_erf_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2882 double a;
2883
2884 a = dsl_num_get_number(n->c, n);
2885
2886 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2887
2888 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ERF);
2889 }
2890
dsl_var_erf_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2891 void dsl_var_erf_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2892 struct dsl_num n;
2893
2894 switch(d->c) {
2895 case DSL_PARAM_TYPE_NUMBER:
2896 (void) dsl_var_erf_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2897
2898 break;
2899 case DSL_PARAM_TYPE_COLOR:
2900 (void) dsl_var_dst_color(d, m, &n);
2901 (void) dsl_var_erf_number(v, &n, DSL_PARAM_TYPE_COLOR);
2902
2903 break;
2904 case DSL_PARAM_TYPE_IMAGE:
2905 (void) dsl_var_dst_image(d, m, &n);
2906 (void) dsl_var_erf_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2907
2908 break;
2909 case DSL_PARAM_TYPE_POINT:
2910 (void) dsl_var_dst_point(d, m, &n);
2911 (void) dsl_var_erf_number(v, &n, DSL_PARAM_TYPE_POINT);
2912
2913 break;
2914 default:
2915 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2916
2917 return;
2918 }
2919 }
2920
dsl_var_erfc_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2921 void dsl_var_erfc_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2922 double a;
2923
2924 a = dsl_num_get_number(n->c, n);
2925
2926 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2927
2928 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_ERFC);
2929 }
2930
dsl_var_erfc_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2931 void dsl_var_erfc_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2932 struct dsl_num n;
2933
2934 switch(d->c) {
2935 case DSL_PARAM_TYPE_NUMBER:
2936 (void) dsl_var_erfc_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2937
2938 break;
2939 case DSL_PARAM_TYPE_COLOR:
2940 (void) dsl_var_dst_color(d, m, &n);
2941 (void) dsl_var_erfc_number(v, &n, DSL_PARAM_TYPE_COLOR);
2942
2943 break;
2944 case DSL_PARAM_TYPE_IMAGE:
2945 (void) dsl_var_dst_image(d, m, &n);
2946 (void) dsl_var_erfc_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2947
2948 break;
2949 case DSL_PARAM_TYPE_POINT:
2950 (void) dsl_var_dst_point(d, m, &n);
2951 (void) dsl_var_erfc_number(v, &n, DSL_PARAM_TYPE_POINT);
2952
2953 break;
2954 default:
2955 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2956
2957 return;
2958 }
2959 }
2960
dsl_var_gdens_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)2961 void dsl_var_gdens_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
2962 double a;
2963
2964 a = dsl_num_get_number(n->c, n);
2965
2966 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
2967
2968 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_GDENS);
2969 }
2970
dsl_var_gdens_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)2971 void dsl_var_gdens_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
2972 struct dsl_num n;
2973
2974 switch(d->c) {
2975 case DSL_PARAM_TYPE_NUMBER:
2976 (void) dsl_var_gdens_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
2977
2978 break;
2979 case DSL_PARAM_TYPE_COLOR:
2980 (void) dsl_var_dst_color(d, m, &n);
2981 (void) dsl_var_gdens_number(v, &n, DSL_PARAM_TYPE_COLOR);
2982
2983 break;
2984 case DSL_PARAM_TYPE_IMAGE:
2985 (void) dsl_var_dst_image(d, m, &n);
2986 (void) dsl_var_gdens_number(v, &n, DSL_PARAM_TYPE_IMAGE);
2987
2988 break;
2989 case DSL_PARAM_TYPE_POINT:
2990 (void) dsl_var_dst_point(d, m, &n);
2991 (void) dsl_var_gdens_number(v, &n, DSL_PARAM_TYPE_POINT);
2992
2993 break;
2994 default:
2995 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
2996
2997 return;
2998 }
2999 }
3000
dsl_var_gdist_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)3001 void dsl_var_gdist_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
3002 double a;
3003
3004 a = dsl_num_get_number(n->c, n);
3005
3006 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3007
3008 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_GDIST);
3009 }
3010
dsl_var_gdist_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)3011 void dsl_var_gdist_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
3012 struct dsl_num n;
3013
3014 switch(d->c) {
3015 case DSL_PARAM_TYPE_NUMBER:
3016 (void) dsl_var_gdist_number(v, &d->number, DSL_PARAM_TYPE_NUMBER);
3017
3018 break;
3019 case DSL_PARAM_TYPE_COLOR:
3020 (void) dsl_var_dst_color(d, m, &n);
3021 (void) dsl_var_gdist_number(v, &n, DSL_PARAM_TYPE_COLOR);
3022
3023 break;
3024 case DSL_PARAM_TYPE_IMAGE:
3025 (void) dsl_var_dst_image(d, m, &n);
3026 (void) dsl_var_gdist_number(v, &n, DSL_PARAM_TYPE_IMAGE);
3027
3028 break;
3029 case DSL_PARAM_TYPE_POINT:
3030 (void) dsl_var_dst_point(d, m, &n);
3031 (void) dsl_var_gdist_number(v, &n, DSL_PARAM_TYPE_POINT);
3032
3033 break;
3034 default:
3035 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3036
3037 return;
3038 }
3039 }
3040
dsl_var_copysign_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3041 void dsl_var_copysign_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3042 double a, b;
3043
3044 a = dsl_num_get_number(n_a->c, n_a);
3045 b = dsl_num_get_number(n_b->c, n_b);
3046
3047 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3048
3049 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_COPYSIGN);
3050 }
3051
dsl_var_copysign_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3052 void dsl_var_copysign_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3053 struct dsl_num n_a, n_b;
3054
3055 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3056
3057 switch(d_b->c) {
3058 case DSL_PARAM_TYPE_NUMBER:
3059 (void) dsl_var_copysign_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3060
3061 break;
3062 case DSL_PARAM_TYPE_COLOR:
3063 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3064 (void) dsl_var_copysign_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3065
3066 break;
3067 case DSL_PARAM_TYPE_IMAGE:
3068 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3069 (void) dsl_var_copysign_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3070
3071 break;
3072 case DSL_PARAM_TYPE_POINT:
3073 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3074 (void) dsl_var_copysign_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3075
3076 break;
3077 default:
3078 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3079
3080 return;
3081 }
3082 }
3083
dsl_var_nextafter_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3084 void dsl_var_nextafter_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3085 double a, b;
3086
3087 a = dsl_num_get_number(n_a->c, n_a);
3088 b = dsl_num_get_number(n_b->c, n_b);
3089
3090 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3091
3092 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_NEXTAFTER);
3093 }
3094
dsl_var_nextafter_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3095 void dsl_var_nextafter_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3096 struct dsl_num n_a, n_b;
3097
3098 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3099
3100 switch(d_b->c) {
3101 case DSL_PARAM_TYPE_NUMBER:
3102 (void) dsl_var_nextafter_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3103
3104 break;
3105 case DSL_PARAM_TYPE_COLOR:
3106 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3107 (void) dsl_var_nextafter_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3108
3109 break;
3110 case DSL_PARAM_TYPE_IMAGE:
3111 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3112 (void) dsl_var_nextafter_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3113
3114 break;
3115 case DSL_PARAM_TYPE_POINT:
3116 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3117 (void) dsl_var_nextafter_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3118
3119 break;
3120 default:
3121 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3122
3123 return;
3124 }
3125 }
3126
dsl_var_nexttoward_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3127 void dsl_var_nexttoward_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3128 double a, b;
3129
3130 a = dsl_num_get_number(n_a->c, n_a);
3131 b = dsl_num_get_number(n_b->c, n_b);
3132
3133 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3134
3135 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_NEXTTOWARD);
3136 }
3137
dsl_var_nexttoward_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3138 void dsl_var_nexttoward_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3139 struct dsl_num n_a, n_b;
3140
3141 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3142
3143 switch(d_b->c) {
3144 case DSL_PARAM_TYPE_NUMBER:
3145 (void) dsl_var_nexttoward_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3146
3147 break;
3148 case DSL_PARAM_TYPE_COLOR:
3149 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3150 (void) dsl_var_nexttoward_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3151
3152 break;
3153 case DSL_PARAM_TYPE_IMAGE:
3154 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3155 (void) dsl_var_nexttoward_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3156
3157 break;
3158 case DSL_PARAM_TYPE_POINT:
3159 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3160 (void) dsl_var_nexttoward_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3161
3162 break;
3163 default:
3164 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3165
3166 return;
3167 }
3168 }
3169
dsl_var_remainder_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3170 void dsl_var_remainder_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3171 double a, b;
3172
3173 a = dsl_num_get_number(n_a->c, n_a);
3174 b = dsl_num_get_number(n_b->c, n_b);
3175
3176 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3177
3178 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_REMAINDER);
3179 }
3180
dsl_var_remainder_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3181 void dsl_var_remainder_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3182 struct dsl_num n_a, n_b;
3183
3184 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3185
3186 switch(d_b->c) {
3187 case DSL_PARAM_TYPE_NUMBER:
3188 (void) dsl_var_remainder_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3189
3190 break;
3191 case DSL_PARAM_TYPE_COLOR:
3192 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3193 (void) dsl_var_remainder_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3194
3195 break;
3196 case DSL_PARAM_TYPE_IMAGE:
3197 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3198 (void) dsl_var_remainder_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3199
3200 break;
3201 case DSL_PARAM_TYPE_POINT:
3202 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3203 (void) dsl_var_remainder_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3204
3205 break;
3206 default:
3207 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3208
3209 return;
3210 }
3211 }
3212
dsl_var_dim_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3213 void dsl_var_dim_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3214 double a, b;
3215
3216 a = dsl_num_get_number(n_a->c, n_a);
3217 b = dsl_num_get_number(n_b->c, n_b);
3218
3219 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3220
3221 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_DIM);
3222 }
3223
dsl_var_dim_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3224 void dsl_var_dim_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3225 struct dsl_num n_a, n_b;
3226
3227 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3228
3229 switch(d_b->c) {
3230 case DSL_PARAM_TYPE_NUMBER:
3231 (void) dsl_var_dim_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3232
3233 break;
3234 case DSL_PARAM_TYPE_COLOR:
3235 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3236 (void) dsl_var_dim_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3237
3238 break;
3239 case DSL_PARAM_TYPE_IMAGE:
3240 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3241 (void) dsl_var_dim_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3242
3243 break;
3244 case DSL_PARAM_TYPE_POINT:
3245 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3246 (void) dsl_var_dim_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3247
3248 break;
3249 default:
3250 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3251
3252 return;
3253 }
3254 }
3255
dsl_var_max_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3256 void dsl_var_max_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3257 double a, b;
3258
3259 a = dsl_num_get_number(n_a->c, n_a);
3260 b = dsl_num_get_number(n_b->c, n_b);
3261
3262 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3263
3264 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_MAX);
3265 }
3266
dsl_var_max_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3267 void dsl_var_max_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3268 struct dsl_num n_a, n_b;
3269
3270 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3271
3272 switch(d_b->c) {
3273 case DSL_PARAM_TYPE_NUMBER:
3274 (void) dsl_var_max_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3275
3276 break;
3277 case DSL_PARAM_TYPE_COLOR:
3278 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3279 (void) dsl_var_max_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3280
3281 break;
3282 case DSL_PARAM_TYPE_IMAGE:
3283 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3284 (void) dsl_var_max_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3285
3286 break;
3287 case DSL_PARAM_TYPE_POINT:
3288 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3289 (void) dsl_var_max_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3290
3291 break;
3292 default:
3293 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3294
3295 return;
3296 }
3297 }
3298
dsl_var_min_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3299 void dsl_var_min_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3300 double a, b;
3301
3302 a = dsl_num_get_number(n_a->c, n_a);
3303 b = dsl_num_get_number(n_b->c, n_b);
3304
3305 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3306
3307 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_MIN);
3308 }
3309
dsl_var_min_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3310 void dsl_var_min_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3311 struct dsl_num n_a, n_b;
3312
3313 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3314
3315 switch(d_b->c) {
3316 case DSL_PARAM_TYPE_NUMBER:
3317 (void) dsl_var_min_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3318
3319 break;
3320 case DSL_PARAM_TYPE_COLOR:
3321 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3322 (void) dsl_var_min_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3323
3324 break;
3325 case DSL_PARAM_TYPE_IMAGE:
3326 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3327 (void) dsl_var_min_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3328
3329 break;
3330 case DSL_PARAM_TYPE_POINT:
3331 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3332 (void) dsl_var_min_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3333
3334 break;
3335 default:
3336 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3337
3338 return;
3339 }
3340 }
3341
dsl_var_hypot_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3342 void dsl_var_hypot_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3343 double a, b;
3344
3345 a = dsl_num_get_number(n_a->c, n_a);
3346 b = dsl_num_get_number(n_b->c, n_b);
3347
3348 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3349
3350 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_HYPOT);
3351 }
3352
dsl_var_hypot_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3353 void dsl_var_hypot_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3354 struct dsl_num n_a, n_b;
3355
3356 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3357
3358 switch(d_b->c) {
3359 case DSL_PARAM_TYPE_NUMBER:
3360 (void) dsl_var_hypot_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3361
3362 break;
3363 case DSL_PARAM_TYPE_COLOR:
3364 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3365 (void) dsl_var_hypot_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3366
3367 break;
3368 case DSL_PARAM_TYPE_IMAGE:
3369 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3370 (void) dsl_var_hypot_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3371
3372 break;
3373 case DSL_PARAM_TYPE_POINT:
3374 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3375 (void) dsl_var_hypot_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3376
3377 break;
3378 default:
3379 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3380
3381 return;
3382 }
3383 }
3384
dsl_var_ldexp_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3385 void dsl_var_ldexp_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3386 double a, b;
3387
3388 a = dsl_num_get_number(n_a->c, n_a);
3389 b = dsl_num_get_number(DSL_NUMBER_TYPE_INT, n_b);
3390
3391 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3392
3393 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_LDEXP);
3394 }
3395
dsl_var_ldexp_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3396 void dsl_var_ldexp_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3397 struct dsl_num n_a, n_b;
3398
3399 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3400
3401 switch(d_b->c) {
3402 case DSL_PARAM_TYPE_NUMBER:
3403 (void) dsl_var_ldexp_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3404
3405 break;
3406 case DSL_PARAM_TYPE_COLOR:
3407 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3408 (void) dsl_var_ldexp_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3409
3410 break;
3411 case DSL_PARAM_TYPE_IMAGE:
3412 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3413 (void) dsl_var_ldexp_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3414
3415 break;
3416 case DSL_PARAM_TYPE_POINT:
3417 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3418 (void) dsl_var_ldexp_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3419
3420 break;
3421 default:
3422 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3423
3424 return;
3425 }
3426 }
3427
dsl_var_scalbn_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3428 void dsl_var_scalbn_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3429 double a, b;
3430
3431 a = dsl_num_get_number(n_a->c, n_a);
3432 b = dsl_num_get_number(DSL_NUMBER_TYPE_INT, n_b);
3433
3434 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3435
3436 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_SCALBN);
3437 }
3438
dsl_var_scalbn_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3439 void dsl_var_scalbn_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3440 struct dsl_num n_a, n_b;
3441
3442 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3443
3444 switch(d_b->c) {
3445 case DSL_PARAM_TYPE_NUMBER:
3446 (void) dsl_var_scalbn_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3447
3448 break;
3449 case DSL_PARAM_TYPE_COLOR:
3450 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3451 (void) dsl_var_scalbn_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3452
3453 break;
3454 case DSL_PARAM_TYPE_IMAGE:
3455 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3456 (void) dsl_var_scalbn_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3457
3458 break;
3459 case DSL_PARAM_TYPE_POINT:
3460 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3461 (void) dsl_var_scalbn_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3462
3463 break;
3464 default:
3465 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3466
3467 return;
3468 }
3469 }
3470
dsl_var_atan2_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3471 void dsl_var_atan2_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3472 double a, b;
3473
3474 a = dsl_num_get_number(n_a->c, n_a);
3475 b = dsl_num_get_number(n_b->c, n_b);
3476
3477 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3478
3479 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_ATAN2);
3480 }
3481
dsl_var_atan2_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3482 void dsl_var_atan2_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3483 struct dsl_num n_a, n_b;
3484
3485 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3486
3487 switch(d_b->c) {
3488 case DSL_PARAM_TYPE_NUMBER:
3489 (void) dsl_var_atan2_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3490
3491 break;
3492 case DSL_PARAM_TYPE_COLOR:
3493 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3494 (void) dsl_var_atan2_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3495
3496 break;
3497 case DSL_PARAM_TYPE_IMAGE:
3498 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3499 (void) dsl_var_atan2_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3500
3501 break;
3502 case DSL_PARAM_TYPE_POINT:
3503 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3504 (void) dsl_var_atan2_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3505
3506 break;
3507 default:
3508 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3509
3510 return;
3511 }
3512 }
3513
dsl_var_jn_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3514 void dsl_var_jn_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3515 double a, b;
3516
3517 a = dsl_num_get_number(DSL_NUMBER_TYPE_INT, n_a);
3518 b = dsl_num_get_number(n_b->c, n_b);
3519
3520 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3521
3522 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_JN);
3523 }
3524
dsl_var_jn_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3525 void dsl_var_jn_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3526 struct dsl_num n_a, n_b;
3527
3528 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3529
3530 switch(d_b->c) {
3531 case DSL_PARAM_TYPE_NUMBER:
3532 (void) dsl_var_jn_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3533
3534 break;
3535 case DSL_PARAM_TYPE_COLOR:
3536 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3537 (void) dsl_var_jn_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3538
3539 break;
3540 case DSL_PARAM_TYPE_IMAGE:
3541 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3542 (void) dsl_var_jn_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3543
3544 break;
3545 case DSL_PARAM_TYPE_POINT:
3546 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3547 (void) dsl_var_jn_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3548
3549 break;
3550 default:
3551 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3552
3553 return;
3554 }
3555 }
3556
dsl_var_yn_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3557 void dsl_var_yn_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3558 double a, b;
3559
3560 a = dsl_num_get_number(DSL_NUMBER_TYPE_INT, n_a);
3561 b = dsl_num_get_number(n_b->c, n_b);
3562
3563 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3564
3565 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_YN);
3566 }
3567
dsl_var_yn_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3568 void dsl_var_yn_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3569 struct dsl_num n_a, n_b;
3570
3571 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3572
3573 switch(d_b->c) {
3574 case DSL_PARAM_TYPE_NUMBER:
3575 (void) dsl_var_yn_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3576
3577 break;
3578 case DSL_PARAM_TYPE_COLOR:
3579 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3580 (void) dsl_var_yn_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3581
3582 break;
3583 case DSL_PARAM_TYPE_IMAGE:
3584 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3585 (void) dsl_var_yn_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3586
3587 break;
3588 case DSL_PARAM_TYPE_POINT:
3589 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3590 (void) dsl_var_yn_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3591
3592 break;
3593 default:
3594 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3595
3596 return;
3597 }
3598 }
3599
dsl_var_grand_number(struct dsl_var * v,struct dsl_num * n_a,struct dsl_num * n_b,unsigned int c)3600 void dsl_var_grand_number(struct dsl_var *v, struct dsl_num *n_a, struct dsl_num *n_b, unsigned int c) {
3601 double a, b;
3602
3603 a = dsl_num_get_number(n_a->c, n_a);
3604 b = dsl_num_get_number(n_b->c, n_b);
3605
3606 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3607
3608 (void) dsl_var_src_number(v, a, b, 0.0, NULL, DSL_COMMAND_GRAND);
3609 }
3610
dsl_var_grand_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,unsigned int m_a,unsigned int m_b)3611 void dsl_var_grand_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, unsigned int m_a, unsigned int m_b) {
3612 struct dsl_num n_a, n_b;
3613
3614 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3615
3616 switch(d_b->c) {
3617 case DSL_PARAM_TYPE_NUMBER:
3618 (void) dsl_var_grand_number(v, &n_a, &d_b->number, DSL_PARAM_TYPE_NUMBER);
3619
3620 break;
3621 case DSL_PARAM_TYPE_COLOR:
3622 (void) dsl_var_dst_color(d_b, m_b, &n_b);
3623 (void) dsl_var_grand_number(v, &n_a, &n_b, DSL_PARAM_TYPE_COLOR);
3624
3625 break;
3626 case DSL_PARAM_TYPE_IMAGE:
3627 (void) dsl_var_dst_image(d_b, m_b, &n_b);
3628 (void) dsl_var_grand_number(v, &n_a, &n_b, DSL_PARAM_TYPE_IMAGE);
3629
3630 break;
3631 case DSL_PARAM_TYPE_POINT:
3632 (void) dsl_var_dst_point(d_b, m_b, &n_b);
3633 (void) dsl_var_grand_number(v, &n_a, &n_b, DSL_PARAM_TYPE_POINT);
3634
3635 break;
3636 default:
3637 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3638
3639 return;
3640 }
3641 }
3642
dsl_var_math3_variable_op(struct dsl_var * v,struct dsl_num * n,unsigned int m)3643 static void dsl_var_math3_variable_op(struct dsl_var *v, struct dsl_num *n, unsigned int m) {
3644 switch(v->c) {
3645 case DSL_PARAM_TYPE_NUMBER:
3646 (void) memset((void *) n, 0, sizeof(struct dsl_num));
3647
3648 n->rpn.r.string.s = NULL;
3649 n->rpn.r.charset.s = NULL;
3650
3651 n->c = v->number.c;
3652 n->number.n = dsl_num_get_number(v->number.c, &v->number);
3653
3654 break;
3655 case DSL_PARAM_TYPE_COLOR:
3656 (void) dsl_var_dst_color(v, m, n);
3657
3658 break;
3659 case DSL_PARAM_TYPE_IMAGE:
3660 (void) dsl_var_dst_image(v, m, n);
3661
3662 break;
3663 case DSL_PARAM_TYPE_POINT:
3664 (void) dsl_var_dst_point(v, m, n);
3665
3666 break;
3667 default:
3668 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3669
3670 return;
3671 }
3672 }
3673
dsl_var_modf_number(struct dsl_var * v,struct dsl_num * n,struct dsl_var * r,unsigned int c)3674 void dsl_var_modf_number(struct dsl_var *v, struct dsl_num *n, struct dsl_var *r, unsigned int c) {
3675 double a;
3676
3677 a = dsl_num_get_number(n->c, n);
3678
3679 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3680
3681 (void) dsl_var_src_number(v, a, 0.0, 0.0, r, DSL_COMMAND_MODF);
3682 }
3683
dsl_var_modf_variable(struct dsl_var * v,struct dsl_var * d,struct dsl_var * r,unsigned int m)3684 void dsl_var_modf_variable(struct dsl_var *v, struct dsl_var *d, struct dsl_var *r, unsigned int m) {
3685 struct dsl_num n;
3686
3687 switch(d->c) {
3688 case DSL_PARAM_TYPE_NUMBER:
3689 (void) dsl_var_modf_number(v, &d->number, r, DSL_PARAM_TYPE_NUMBER);
3690
3691 break;
3692 case DSL_PARAM_TYPE_COLOR:
3693 (void) dsl_var_dst_color(d, m, &n);
3694 (void) dsl_var_modf_number(v, &n, r, DSL_PARAM_TYPE_COLOR);
3695
3696 break;
3697 case DSL_PARAM_TYPE_IMAGE:
3698 (void) dsl_var_dst_image(d, m, &n);
3699 (void) dsl_var_modf_number(v, &n, r, DSL_PARAM_TYPE_IMAGE);
3700
3701 break;
3702 case DSL_PARAM_TYPE_POINT:
3703 (void) dsl_var_dst_point(d, m, &n);
3704 (void) dsl_var_modf_number(v, &n, r, DSL_PARAM_TYPE_POINT);
3705
3706 break;
3707 default:
3708 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3709
3710 return;
3711 }
3712 }
3713
dsl_var_frexp_number(struct dsl_var * v,struct dsl_num * n,struct dsl_var * r,unsigned int c)3714 void dsl_var_frexp_number(struct dsl_var *v, struct dsl_num *n, struct dsl_var *r, unsigned int c) {
3715 double a;
3716
3717 a = dsl_num_get_number(n->c, n);
3718
3719 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3720
3721 (void) dsl_var_src_number(v, a, 0.0, 0.0, r, DSL_COMMAND_FREXP);
3722 }
3723
dsl_var_frexp_variable(struct dsl_var * v,struct dsl_var * d,struct dsl_var * r,unsigned int m)3724 void dsl_var_frexp_variable(struct dsl_var *v, struct dsl_var *d, struct dsl_var *r, unsigned int m) {
3725 struct dsl_num n;
3726
3727 switch(d->c) {
3728 case DSL_PARAM_TYPE_NUMBER:
3729 (void) dsl_var_frexp_number(v, &d->number, r, DSL_PARAM_TYPE_NUMBER);
3730
3731 break;
3732 case DSL_PARAM_TYPE_COLOR:
3733 (void) dsl_var_dst_color(d, m, &n);
3734 (void) dsl_var_frexp_number(v, &n, r, DSL_PARAM_TYPE_COLOR);
3735
3736 break;
3737 case DSL_PARAM_TYPE_IMAGE:
3738 (void) dsl_var_dst_image(d, m, &n);
3739 (void) dsl_var_frexp_number(v, &n, r, DSL_PARAM_TYPE_IMAGE);
3740
3741 break;
3742 case DSL_PARAM_TYPE_POINT:
3743 (void) dsl_var_dst_point(d, m, &n);
3744 (void) dsl_var_frexp_number(v, &n, r, DSL_PARAM_TYPE_POINT);
3745
3746 break;
3747 default:
3748 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3749
3750 return;
3751 }
3752 }
3753
dsl_var_fma_number(struct dsl_var * v,struct dsl_num * d_a,struct dsl_num * d_b,struct dsl_num * d_c,unsigned int c)3754 void dsl_var_fma_number(struct dsl_var *v, struct dsl_num *d_a, struct dsl_num *d_b, struct dsl_num *d_c, unsigned int c) {
3755 double a, b, d;
3756
3757 a = dsl_num_get_number(d_a->c, d_a);
3758 b = dsl_num_get_number(d_b->c, d_b);
3759 d = dsl_num_get_number(d_c->c, d_c);
3760
3761 if(v->c == DSL_PARAM_TYPE_NONE) v->c = c;
3762
3763 (void) dsl_var_src_number(v, a, b, d, NULL, DSL_COMMAND_FMA);
3764 }
3765
dsl_var_fma_variable(struct dsl_var * v,struct dsl_var * d_a,struct dsl_var * d_b,struct dsl_var * d_c,unsigned int m_a,unsigned int m_b,unsigned int m_c)3766 void dsl_var_fma_variable(struct dsl_var *v, struct dsl_var *d_a, struct dsl_var *d_b, struct dsl_var *d_c, unsigned int m_a, unsigned int m_b, unsigned int m_c) {
3767 struct dsl_num n_a, n_b, n_c;
3768
3769 (void) dsl_var_math3_variable_op(d_a, &n_a, m_a);
3770 (void) dsl_var_math3_variable_op(d_b, &n_b, m_b);
3771
3772 switch(d_c->c) {
3773 case DSL_PARAM_TYPE_NUMBER:
3774 (void) dsl_var_fma_number(v, &n_a, &n_b, &d_c->number, DSL_PARAM_TYPE_NUMBER);
3775
3776 break;
3777 case DSL_PARAM_TYPE_COLOR:
3778 (void) dsl_var_dst_color(d_c, m_c, &n_c);
3779 (void) dsl_var_fma_number(v, &n_a, &n_b, &n_c, DSL_PARAM_TYPE_COLOR);
3780
3781 break;
3782 case DSL_PARAM_TYPE_IMAGE:
3783 (void) dsl_var_dst_image(d_c, m_c, &n_c);
3784 (void) dsl_var_fma_number(v, &n_a, &n_b, &n_c, DSL_PARAM_TYPE_IMAGE);
3785
3786 break;
3787 case DSL_PARAM_TYPE_POINT:
3788 (void) dsl_var_dst_point(d_c, m_c, &n_c);
3789 (void) dsl_var_fma_number(v, &n_a, &n_b, &n_c, DSL_PARAM_TYPE_POINT);
3790
3791 break;
3792 default:
3793 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3794
3795 return;
3796 }
3797 }
3798
dsl_var_crc32_number(struct dsl_var * v,struct dsl_num * n)3799 void dsl_var_crc32_number(struct dsl_var *v, struct dsl_num *n) {
3800 v->number.number.n = (double) crc32_calc((unsigned char *) &n->number.n, sizeof(n->number.n));
3801
3802 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3803 }
3804
dsl_var_crc32_string(struct dsl_var * v,struct dsl_str * s)3805 void dsl_var_crc32_string(struct dsl_var *v, struct dsl_str *s) {
3806 v->number.number.n = (double) crc32_calc((unsigned char *) s->string.s, s->string.t);
3807
3808 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3809 }
3810
dsl_var_crc32_blob(struct dsl_var * v,struct dsl_blb * b)3811 void dsl_var_crc32_blob(struct dsl_var *v, struct dsl_blb *b) {
3812 v->number.number.n = (double) crc32_calc((unsigned char *) b->blob.s, b->blob.t);
3813
3814 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3815 }
3816
dsl_var_crc32_pointer(struct dsl_var * v,struct dsl_ptr * p)3817 void dsl_var_crc32_pointer(struct dsl_var *v, struct dsl_ptr *p) {
3818 v->number.number.n = (double) crc32_calc((unsigned char *) &p->pointer, sizeof(p->pointer));
3819
3820 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3821 }
3822
dsl_var_crc32_handle(struct dsl_var * v,struct dsl_hnd * h)3823 void dsl_var_crc32_handle(struct dsl_var *v, struct dsl_hnd *h) {
3824 v->number.number.n = (double) crc32_calc((unsigned char *) &h->handle, sizeof(h->handle));
3825
3826 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3827 }
3828
dsl_var_crc32_color(struct dsl_var * v,struct dsl_clr * c,unsigned int m)3829 void dsl_var_crc32_color(struct dsl_var *v, struct dsl_clr *c, unsigned int m) {
3830 double a;
3831
3832 a = dsl_var_cmp_color_op(c, m);
3833
3834 v->number.number.n = (double) crc32_calc((unsigned char *) &a, sizeof(a));
3835
3836 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3837 }
3838
dsl_var_crc32_image(struct dsl_var * v,struct dsl_img * i,unsigned int m)3839 void dsl_var_crc32_image(struct dsl_var *v, struct dsl_img *i, unsigned int m) {
3840 double a;
3841
3842 a = dsl_var_cmp_image_op(i, m);
3843
3844 v->number.number.n = (double) crc32_calc((unsigned char *) &a, sizeof(a));
3845
3846 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3847 }
3848
dsl_var_crc32_point(struct dsl_var * v,struct dsl_pnt * t,unsigned int m)3849 void dsl_var_crc32_point(struct dsl_var *v, struct dsl_pnt *t, unsigned int m) {
3850 double a;
3851
3852 a = dsl_var_cmp_point_op(t, m);
3853
3854 v->number.number.n = (double) crc32_calc((unsigned char *) &a, sizeof(a));
3855
3856 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3857 }
3858
dsl_var_crc32_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)3859 void dsl_var_crc32_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
3860 switch(d->c) {
3861 case DSL_PARAM_TYPE_NUMBER:
3862 (void) dsl_var_crc32_number(v, &d->number);
3863
3864 break;
3865 case DSL_PARAM_TYPE_STRING:
3866 (void) dsl_var_crc32_string(v, &d->string);
3867
3868 break;
3869 case DSL_PARAM_TYPE_BLOB:
3870 (void) dsl_var_crc32_blob(v, &d->blob);
3871
3872 break;
3873 case DSL_PARAM_TYPE_POINTER:
3874 (void) dsl_var_crc32_pointer(v, &d->pointer);
3875
3876 break;
3877 case DSL_PARAM_TYPE_HANDLE:
3878 (void) dsl_var_crc32_handle(v, &d->handle);
3879
3880 break;
3881 case DSL_PARAM_TYPE_COLOR:
3882 (void) dsl_var_crc32_color(v, &d->color, m);
3883
3884 break;
3885 case DSL_PARAM_TYPE_IMAGE:
3886 (void) dsl_var_crc32_image(v, &d->image, m);
3887
3888 break;
3889 case DSL_PARAM_TYPE_POINT:
3890 (void) dsl_var_crc32_point(v, &d->point, m);
3891
3892 break;
3893 default:
3894 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3895
3896 break;
3897 }
3898 }
3899
dsl_var_crc64_number(struct dsl_var * v,struct dsl_num * n)3900 void dsl_var_crc64_number(struct dsl_var *v, struct dsl_num *n) {
3901 v->number.number.n = (double) crc64_calc((unsigned char *) &n->number.n, sizeof(n->number.n));
3902
3903 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3904 }
3905
dsl_var_crc64_string(struct dsl_var * v,struct dsl_str * s)3906 void dsl_var_crc64_string(struct dsl_var *v, struct dsl_str *s) {
3907 v->number.number.n = (double) crc64_calc((unsigned char *) s->string.s, s->string.t);
3908
3909 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3910 }
3911
dsl_var_crc64_blob(struct dsl_var * v,struct dsl_blb * b)3912 void dsl_var_crc64_blob(struct dsl_var *v, struct dsl_blb *b) {
3913 v->number.number.n = (double) crc64_calc((unsigned char *) b->blob.s, b->blob.t);
3914
3915 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3916 }
3917
dsl_var_crc64_pointer(struct dsl_var * v,struct dsl_ptr * p)3918 void dsl_var_crc64_pointer(struct dsl_var *v, struct dsl_ptr *p) {
3919 v->number.number.n = (double) crc64_calc((unsigned char *) &p->pointer, sizeof(p->pointer));
3920
3921 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3922 }
3923
dsl_var_crc64_handle(struct dsl_var * v,struct dsl_hnd * h)3924 void dsl_var_crc64_handle(struct dsl_var *v, struct dsl_hnd *h) {
3925 v->number.number.n = (double) crc64_calc((unsigned char *) &h->handle, sizeof(h->handle));
3926
3927 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3928 }
3929
dsl_var_crc64_color(struct dsl_var * v,struct dsl_clr * c,unsigned int m)3930 void dsl_var_crc64_color(struct dsl_var *v, struct dsl_clr *c, unsigned int m) {
3931 double a;
3932
3933 a = dsl_var_cmp_color_op(c, m);
3934
3935 v->number.number.n = (double) crc64_calc((unsigned char *) &a, sizeof(a));
3936
3937 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3938 }
3939
dsl_var_crc64_image(struct dsl_var * v,struct dsl_img * i,unsigned int m)3940 void dsl_var_crc64_image(struct dsl_var *v, struct dsl_img *i, unsigned int m) {
3941 double a;
3942
3943 a = dsl_var_cmp_image_op(i, m);
3944
3945 v->number.number.n = (double) crc64_calc((unsigned char *) &a, sizeof(a));
3946
3947 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3948 }
3949
dsl_var_crc64_point(struct dsl_var * v,struct dsl_pnt * t,unsigned int m)3950 void dsl_var_crc64_point(struct dsl_var *v, struct dsl_pnt *t, unsigned int m) {
3951 double a;
3952
3953 a = dsl_var_cmp_point_op(t, m);
3954
3955 v->number.number.n = (double) crc64_calc((unsigned char *) &a, sizeof(a));
3956
3957 if(v->c == DSL_PARAM_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
3958 }
3959
dsl_var_crc64_variable(struct dsl_var * v,struct dsl_var * d,unsigned int m)3960 void dsl_var_crc64_variable(struct dsl_var *v, struct dsl_var *d, unsigned int m) {
3961 switch(d->c) {
3962 case DSL_PARAM_TYPE_NUMBER:
3963 (void) dsl_var_crc64_number(v, &d->number);
3964
3965 break;
3966 case DSL_PARAM_TYPE_STRING:
3967 (void) dsl_var_crc64_string(v, &d->string);
3968
3969 break;
3970 case DSL_PARAM_TYPE_BLOB:
3971 (void) dsl_var_crc64_blob(v, &d->blob);
3972
3973 break;
3974 case DSL_PARAM_TYPE_POINTER:
3975 (void) dsl_var_crc64_pointer(v, &d->pointer);
3976
3977 break;
3978 case DSL_PARAM_TYPE_HANDLE:
3979 (void) dsl_var_crc64_handle(v, &d->handle);
3980
3981 break;
3982 case DSL_PARAM_TYPE_COLOR:
3983 (void) dsl_var_crc64_color(v, &d->color, m);
3984
3985 break;
3986 case DSL_PARAM_TYPE_IMAGE:
3987 (void) dsl_var_crc64_image(v, &d->image, m);
3988
3989 break;
3990 case DSL_PARAM_TYPE_POINT:
3991 (void) dsl_var_crc64_point(v, &d->point, m);
3992
3993 break;
3994 default:
3995 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
3996
3997 break;
3998 }
3999 }
4000 #endif
dsl_var_dump_variable(struct dsl_var * v)4001 void dsl_var_dump_variable(struct dsl_var *v) {
4002 unsigned char *s;
4003
4004 size_t i;
4005
4006 (void) fprintf(stdout, _("%s is "), v->variable.string.s);
4007
4008 switch(v->c) {
4009 case DSL_PARAM_TYPE_NUMBER:
4010 if(v->number.rpn.r.string.s != NULL) {
4011 (void) fprintf(
4012 stdout,
4013 _("rpn (%s) \"%s\""),
4014 v->number.rpn.r.charset.s, v->number.rpn.r.string.s
4015 );
4016
4017 if(v->number.rpn.c != IS_NO) (void) fprintf(stdout, _(", cacheable"));
4018
4019 (void) fprintf(stdout, " (");
4020 }
4021 else (void) fprintf(stdout, _("number ("));
4022
4023 switch(v->number.c) {
4024 case DSL_NUMBER_TYPE_I8:
4025 (void) fprintf(stdout, "int8");
4026
4027 break;
4028 case DSL_NUMBER_TYPE_I16:
4029 (void) fprintf(stdout, "int16");
4030
4031 break;
4032 case DSL_NUMBER_TYPE_I32:
4033 (void) fprintf(stdout, "int32");
4034
4035 break;
4036 case DSL_NUMBER_TYPE_I64:
4037 (void) fprintf(stdout, "int64");
4038
4039 break;
4040 case DSL_NUMBER_TYPE_I128:
4041 (void) fprintf(stdout, "int128");
4042
4043 break;
4044 case DSL_NUMBER_TYPE_U8:
4045 (void) fprintf(stdout, "uint8");
4046
4047 break;
4048 case DSL_NUMBER_TYPE_U16:
4049 (void) fprintf(stdout, "uint16");
4050
4051 break;
4052 case DSL_NUMBER_TYPE_U32:
4053 (void) fprintf(stdout, "uint32");
4054
4055 break;
4056 case DSL_NUMBER_TYPE_U64:
4057 (void) fprintf(stdout, "uint64");
4058
4059 break;
4060 case DSL_NUMBER_TYPE_U128:
4061 (void) fprintf(stdout, "uint128");
4062
4063 break;
4064 case DSL_NUMBER_TYPE_CHAR:
4065 (void) fprintf(stdout, "char");
4066
4067 break;
4068 case DSL_NUMBER_TYPE_SHORT:
4069 (void) fprintf(stdout, "short");
4070
4071 break;
4072 case DSL_NUMBER_TYPE_INT:
4073 (void) fprintf(stdout, "int");
4074
4075 break;
4076 case DSL_NUMBER_TYPE_LONG:
4077 (void) fprintf(stdout, "long");
4078
4079 break;
4080 case DSL_NUMBER_TYPE_UCHAR:
4081 (void) fprintf(stdout, "uchar");
4082
4083 break;
4084 case DSL_NUMBER_TYPE_USHORT:
4085 (void) fprintf(stdout, "ushort");
4086
4087 break;
4088 case DSL_NUMBER_TYPE_UINT:
4089 (void) fprintf(stdout, "uint");
4090
4091 break;
4092 case DSL_NUMBER_TYPE_ULONG:
4093 (void) fprintf(stdout, "ulong");
4094
4095 break;
4096 case DSL_NUMBER_TYPE_FLOAT:
4097 (void) fprintf(stdout, "float");
4098
4099 break;
4100 case DSL_NUMBER_TYPE_DOUBLE:
4101 (void) fprintf(stdout, "double");
4102
4103 break;
4104 default:
4105 (void) fprintf(stdout, _("unknown"));
4106
4107 break;
4108 }
4109
4110 (void) fprintf(stdout, ") " DEFAULT_VAR_FORMAT, v->number.number.n);
4111
4112 break;
4113 case DSL_PARAM_TYPE_STRING:
4114 if(v->string.string.t == 0 || v->string.string.s == NULL) {
4115 (void) fprintf(stdout, _("empty string"));
4116
4117 break;
4118 }
4119
4120 (void) fprintf(stdout, _("string (%s) \"%s\""), v->string.charset.s, v->string.string.s);
4121
4122 break;
4123 case DSL_PARAM_TYPE_BLOB:
4124 if(v->blob.blob.t == 0 || v->blob.blob.s == NULL) {
4125 (void) fprintf(stdout, _("empty blob"));
4126
4127 if(v->blob.s != NULL) (void) fprintf(stdout, " (%s)", v->blob.s);
4128
4129 break;
4130 }
4131
4132 (void) fprintf(stdout, _("blob (%lu bytes) "), (unsigned long) v->blob.blob.t);
4133
4134 s = (unsigned char *) v->blob.blob.s;
4135
4136 for(i = 0; i < v->blob.blob.t; i++) {
4137 (void) fprintf(stdout, "0x%.2x ", s[i]);
4138
4139 if(i >= 8) {
4140 if(v->blob.blob.t > i) (void) fprintf(stdout, "...");
4141
4142 break;
4143 }
4144 }
4145
4146 break;
4147 case DSL_PARAM_TYPE_POINTER:
4148 (void) fprintf(stdout, _("pointer %p"), v->pointer.pointer);
4149
4150 break;
4151 case DSL_PARAM_TYPE_HANDLE:
4152 (void) fprintf(stdout, _("handle %u"), v->handle.handle);
4153
4154 break;
4155 case DSL_PARAM_TYPE_COLOR:
4156 switch(v->m) {
4157 case DSL_MEMBER_TYPE_NONE:
4158 (void) fprintf(stdout, _("color (8bpp rgba) 0x%.8x"), v->color.color.pixel.p);
4159
4160 break;
4161 case DSL_MEMBER_TYPE_RED:
4162 (void) fprintf(stdout, _("color (8bpp rgba:r) 0x%.2x"), v->color.color.pixel.r);
4163
4164 break;
4165 case DSL_MEMBER_TYPE_GREEN:
4166 (void) fprintf(stdout, _("color (8bpp rgba:g) 0x%.2x"), v->color.color.pixel.g);
4167
4168 break;
4169 case DSL_MEMBER_TYPE_BLUE:
4170 (void) fprintf(stdout, _("color (8bpp rgba:b) 0x%.2x"), v->color.color.pixel.b);
4171
4172 break;
4173 case DSL_MEMBER_TYPE_ALPHA:
4174 (void) fprintf(stdout, _("color (8bpp rgba:a) 0x%.2x"), v->color.color.pixel.a);
4175
4176 break;
4177 case DSL_MEMBER_TYPE_BRIGHTNESS:
4178 (void) fprintf(
4179 stdout,
4180 _("color (8bpp rgba:brightness) 0x%.2x"),
4181 (uint8_t) roundf(color_rgba_brightness(&v->color.color))
4182 );
4183
4184 break;
4185 default:
4186 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
4187
4188 return;
4189 }
4190
4191 break;
4192 case DSL_PARAM_TYPE_IMAGE:
4193 switch(v->m) {
4194 case DSL_MEMBER_TYPE_NONE:
4195 (void) fprintf(
4196 stdout,
4197 _("image (8bpp rgba) %u x %u"),
4198 v->image.image.w, v->image.image.h
4199 );
4200
4201 break;
4202 case DSL_MEMBER_TYPE_WIDTH:
4203 (void) fprintf(stdout, _("image (8bpp rgba:w) %u"), v->image.image.w);
4204
4205 break;
4206 case DSL_MEMBER_TYPE_HEIGHT:
4207 (void) fprintf(stdout, _("image (8bpp rgba:h) %u"), v->image.image.h);
4208
4209 break;
4210 default:
4211 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
4212
4213 return;
4214 }
4215
4216 if(v->image.s != NULL) (void) fprintf(stdout, " (%s)", v->image.s);
4217
4218 break;
4219 case DSL_PARAM_TYPE_POINT:
4220 switch(v->m) {
4221 case DSL_MEMBER_TYPE_NONE:
4222 (void) fprintf(
4223 stdout,
4224 _("point (xyz) " DEFAULT_VAR_FORMAT " " DEFAULT_VAR_FORMAT " " DEFAULT_VAR_FORMAT),
4225 v->point.point.x, v->point.point.y, v->point.point.z
4226 );
4227
4228 break;
4229 case DSL_MEMBER_TYPE_X:
4230 (void) fprintf(
4231 stdout,
4232 _("point (xyz:x) " DEFAULT_VAR_FORMAT),
4233 v->point.point.x
4234 );
4235
4236 break;
4237 case DSL_MEMBER_TYPE_Y:
4238 (void) fprintf(
4239 stdout,
4240 _("point (xyz:y) " DEFAULT_VAR_FORMAT),
4241 v->point.point.y
4242 );
4243
4244 break;
4245 case DSL_MEMBER_TYPE_Z:
4246 (void) fprintf(
4247 stdout,
4248 _("point (xyz:z) " DEFAULT_VAR_FORMAT),
4249 v->point.point.z
4250 );
4251
4252 break;
4253 case DSL_MEMBER_TYPE_ANGLE_XY:
4254 (void) fprintf(
4255 stdout,
4256 _("point (xyz:angle_xy) " DEFAULT_VAR_FORMAT),
4257 coords_position_to_angle(&v->point.point)
4258 );
4259
4260 break;
4261 case DSL_MEMBER_TYPE_MAG_XY:
4262 (void) fprintf(
4263 stdout,
4264 _("point (xyz:mag_xy) " DEFAULT_VAR_FORMAT),
4265 coords_mag_2d(&v->point.point)
4266 );
4267
4268 break;
4269 case DSL_MEMBER_TYPE_MAG_XYZ:
4270 (void) fprintf(
4271 stdout,
4272 _("point (xyz:mag_xyz) " DEFAULT_VAR_FORMAT),
4273 coords_mag_3d(&v->point.point)
4274 );
4275
4276 break;
4277 default:
4278 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
4279
4280 return;
4281 }
4282
4283 break;
4284 default:
4285 (void) fprintf(stdout, _("unknown"));
4286
4287 break;
4288 }
4289
4290 (void) fprintf(stdout, "%c", CONFIG_LINE_FEED);
4291 }
4292
dsl_var_ston(struct dsl_var * v)4293 void dsl_var_ston(struct dsl_var *v) {
4294 int e;
4295
4296 if(v->string.string.s != NULL) {
4297 e = 0;
4298
4299 v->number.c = DSL_NUMBER_TYPE_DEFAULT;
4300 v->number.number.n = dsl_str_get_number(&v->string, &e);
4301 }
4302
4303 v->c = DSL_PARAM_TYPE_NUMBER;
4304 }
4305
dsl_var_bton(struct dsl_var * v)4306 void dsl_var_bton(struct dsl_var *v) {
4307 (void) dsl_var_ston(v);
4308 }
4309
dsl_var_pton(struct dsl_var * v)4310 void dsl_var_pton(struct dsl_var *v) {
4311 unsigned long n;
4312
4313 n = (unsigned long) v->pointer.pointer;
4314
4315 v->number.c = DSL_NUMBER_TYPE_DEFAULT;
4316 v->number.number.n = (double) n;
4317
4318 v->c = DSL_PARAM_TYPE_NUMBER;
4319 }
4320
dsl_var_hton(struct dsl_var * v)4321 void dsl_var_hton(struct dsl_var *v) {
4322 v->number.c = DSL_NUMBER_TYPE_DEFAULT;
4323 v->number.number.n = (double) v->handle.handle;
4324
4325 v->c = DSL_PARAM_TYPE_NUMBER;
4326 }
4327
dsl_var_ntos(struct dsl_var * v)4328 void dsl_var_ntos(struct dsl_var *v) {
4329 size_t t;
4330
4331 struct dsl_str p;
4332
4333 p.string.s = NULL;
4334 p.charset.s = NULL;
4335
4336 t = CONFIG_LINE_LENGTH;
4337
4338 if((p.string.s = dsl_var_conv_op(t)) != NULL) {
4339 if((p.charset.s = dsl_var_conv_op(t)) != NULL) {
4340 p.string.t = (size_t) snprintf(
4341 p.string.s,
4342 t,
4343 DEFAULT_VAR_FORMAT,
4344 dsl_num_get_number(v->number.c, &v->number)
4345 );
4346
4347 p.charset.t = (size_t) snprintf(p.charset.s, t, CHARSET_DEFAULT);
4348
4349 (void) dsl_str_copy(&v->string, &p);
4350 }
4351 }
4352
4353 if(p.string.s != NULL) (void) free(p.string.s);
4354 if(p.charset.s != NULL) (void) free(p.charset.s);
4355
4356 v->c = DSL_PARAM_TYPE_STRING;
4357 }
4358
dsl_var_ntob(struct dsl_var * v)4359 void dsl_var_ntob(struct dsl_var *v) {
4360 size_t t;
4361
4362 struct dsl_blb p;
4363
4364 t = CONFIG_LINE_LENGTH;
4365
4366 if((p.blob.s = dsl_var_conv_op(t)) != NULL) {
4367 p.blob.t = (size_t) snprintf(p.blob.s, t, DEFAULT_VAR_FORMAT, v->number.number.n);
4368
4369 (void) dsl_blob_copy(&v->blob, &p);
4370 }
4371
4372 if(p.blob.s != NULL) (void) free(p.blob.s);
4373
4374 v->c = DSL_PARAM_TYPE_BLOB;
4375 }
4376
dsl_var_ntop(struct dsl_var * v)4377 void dsl_var_ntop(struct dsl_var *v) {
4378 unsigned long n;
4379
4380 n = (unsigned long) dsl_num_get_number(DSL_NUMBER_TYPE_ULONG, &v->number);
4381
4382 v->pointer.pointer = (void *) n;
4383
4384 v->c = DSL_PARAM_TYPE_POINTER;
4385 }
4386
dsl_var_ntoh(struct dsl_var * v)4387 void dsl_var_ntoh(struct dsl_var *v) {
4388 unsigned int h;
4389
4390 h = (unsigned int) dsl_num_get_number(DSL_NUMBER_TYPE_UINT, &v->number);
4391
4392 v->handle.handle = h;
4393
4394 v->c = DSL_PARAM_TYPE_HANDLE;
4395 }
4396
dsl_var_conv_op(size_t t)4397 static char *dsl_var_conv_op(size_t t) {
4398 char *r;
4399
4400 if((r = malloc(t)) == NULL) {
4401 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_GENERAL_ALLOC);
4402
4403 return(NULL);
4404 }
4405
4406 return(r);
4407 }
4408
dsl_var_toi8(struct dsl_var * v)4409 void dsl_var_toi8(struct dsl_var *v) {
4410 v->number.c = DSL_NUMBER_TYPE_I8;
4411 }
4412
dsl_var_toi16(struct dsl_var * v)4413 void dsl_var_toi16(struct dsl_var *v) {
4414 v->number.c = DSL_NUMBER_TYPE_I16;
4415 }
4416
dsl_var_toi32(struct dsl_var * v)4417 void dsl_var_toi32(struct dsl_var *v) {
4418 v->number.c = DSL_NUMBER_TYPE_I32;
4419 }
4420
dsl_var_toi64(struct dsl_var * v)4421 void dsl_var_toi64(struct dsl_var *v) {
4422 v->number.c = DSL_NUMBER_TYPE_I64;
4423 }
4424
dsl_var_toi128(struct dsl_var * v)4425 void dsl_var_toi128(struct dsl_var *v) {
4426 v->number.c = DSL_NUMBER_TYPE_I128;
4427 }
4428
dsl_var_tou8(struct dsl_var * v)4429 void dsl_var_tou8(struct dsl_var *v) {
4430 v->number.c = DSL_NUMBER_TYPE_U8;
4431 }
4432
dsl_var_tou16(struct dsl_var * v)4433 void dsl_var_tou16(struct dsl_var *v) {
4434 v->number.c = DSL_NUMBER_TYPE_U16;
4435 }
4436
dsl_var_tou32(struct dsl_var * v)4437 void dsl_var_tou32(struct dsl_var *v) {
4438 v->number.c = DSL_NUMBER_TYPE_U32;
4439 }
4440
dsl_var_tou64(struct dsl_var * v)4441 void dsl_var_tou64(struct dsl_var *v) {
4442 v->number.c = DSL_NUMBER_TYPE_U64;
4443 }
4444
dsl_var_tou128(struct dsl_var * v)4445 void dsl_var_tou128(struct dsl_var *v) {
4446 v->number.c = DSL_NUMBER_TYPE_U128;
4447 }
4448
dsl_var_tochar(struct dsl_var * v)4449 void dsl_var_tochar(struct dsl_var *v) {
4450 v->number.c = DSL_NUMBER_TYPE_CHAR;
4451 }
4452
dsl_var_toshort(struct dsl_var * v)4453 void dsl_var_toshort(struct dsl_var *v) {
4454 v->number.c = DSL_NUMBER_TYPE_SHORT;
4455 }
4456
dsl_var_toint(struct dsl_var * v)4457 void dsl_var_toint(struct dsl_var *v) {
4458 v->number.c = DSL_NUMBER_TYPE_INT;
4459 }
4460
dsl_var_tolong(struct dsl_var * v)4461 void dsl_var_tolong(struct dsl_var *v) {
4462 v->number.c = DSL_NUMBER_TYPE_LONG;
4463 }
4464
dsl_var_touchar(struct dsl_var * v)4465 void dsl_var_touchar(struct dsl_var *v) {
4466 v->number.c = DSL_NUMBER_TYPE_UCHAR;
4467 }
4468
dsl_var_toushort(struct dsl_var * v)4469 void dsl_var_toushort(struct dsl_var *v) {
4470 v->number.c = DSL_NUMBER_TYPE_USHORT;
4471 }
4472
dsl_var_touint(struct dsl_var * v)4473 void dsl_var_touint(struct dsl_var *v) {
4474 v->number.c = DSL_NUMBER_TYPE_UINT;
4475 }
4476
dsl_var_toulong(struct dsl_var * v)4477 void dsl_var_toulong(struct dsl_var *v) {
4478 v->number.c = DSL_NUMBER_TYPE_ULONG;
4479 }
4480
dsl_var_tofloat(struct dsl_var * v)4481 void dsl_var_tofloat(struct dsl_var *v) {
4482 v->number.c = DSL_NUMBER_TYPE_FLOAT;
4483 }
4484
dsl_var_todouble(struct dsl_var * v)4485 void dsl_var_todouble(struct dsl_var *v) {
4486 v->number.c = DSL_NUMBER_TYPE_DOUBLE;
4487 }
4488
dsl_var_src_number(struct dsl_var * v,double p1,double p2,double p3,struct dsl_var * v1,unsigned int m)4489 static void dsl_var_src_number(struct dsl_var *v, double p1, double p2, double p3, struct dsl_var *v1, unsigned int m) {
4490 double a, b, c, d;
4491
4492 switch(v->c) {
4493 case DSL_PARAM_TYPE_NUMBER:
4494 (void) dsl_var_src_number_op(v, &v->number.number.n, p1, p2, p3, v1, m);
4495
4496 break;
4497 case DSL_PARAM_TYPE_COLOR:
4498 switch(v->m) {
4499 case DSL_MEMBER_TYPE_NONE:
4500 a = (double) v->color.color.pixel.r;
4501 b = (double) v->color.color.pixel.g;
4502 c = (double) v->color.color.pixel.b;
4503 d = (double) v->color.color.pixel.a;
4504
4505 (void) dsl_var_src_number_op(v, &a, p1, p2, p3, v1, m);
4506 (void) dsl_var_src_number_op(v, &b, p1, p2, p3, v1, m);
4507 (void) dsl_var_src_number_op(v, &c, p1, p2, p3, v1, m);
4508 (void) dsl_var_src_number_op(v, &d, p1, p2, p3, v1, m);
4509
4510 if(a < 0.0) a = 0.0;
4511 else if(a > 255.0) a = 255.0;
4512
4513 if(b < 0.0) b = 0.0;
4514 else if(b > 255.0) b = 255.0;
4515
4516 if(c < 0.0) c = 0.0;
4517 else if(c > 255.0) c = 255.0;
4518
4519 if(d < 0.0) d = 0.0;
4520 else if(d > 255.0) d = 255.0;
4521
4522 v->color.color.pixel.r = (uint8_t) round(a);
4523 v->color.color.pixel.g = (uint8_t) round(b);
4524 v->color.color.pixel.b = (uint8_t) round(c);
4525 v->color.color.pixel.a = (uint8_t) round(d);
4526
4527 break;
4528 case DSL_MEMBER_TYPE_RED:
4529 a = (double) v->color.color.pixel.r;
4530
4531 (void) dsl_var_src_number_op(v, &a, p1, p2, p3, v1, m);
4532
4533 if(a < 0.0) a = 0.0;
4534 else if(a > 255.0) a = 255.0;
4535
4536 v->color.color.pixel.r = (uint8_t) round(a);
4537
4538 break;
4539 case DSL_MEMBER_TYPE_GREEN:
4540 a = (double) v->color.color.pixel.g;
4541
4542 (void) dsl_var_src_number_op(v, &a, p1, p2, p3, v1, m);
4543
4544 if(a < 0.0) a = 0.0;
4545 else if(a > 255.0) a = 255.0;
4546
4547 v->color.color.pixel.g = (uint8_t) round(a);
4548
4549 break;
4550 case DSL_MEMBER_TYPE_BLUE:
4551 a = (double) v->color.color.pixel.b;
4552
4553 (void) dsl_var_src_number_op(v, &a, p1, p2, p3, v1, m);
4554
4555 if(a < 0.0) a = 0.0;
4556 else if(a > 255.0) a = 255.0;
4557
4558 v->color.color.pixel.b = (uint8_t) round(a);
4559
4560 break;
4561 case DSL_MEMBER_TYPE_ALPHA:
4562 a = (double) v->color.color.pixel.a;
4563
4564 (void) dsl_var_src_number_op(v, &a, p1, p2, p3, v1, m);
4565
4566 if(a < 0.0) a = 0.0;
4567 else if(a > 255.0) a = 255.0;
4568
4569 v->color.color.pixel.a = (uint8_t) round(a);
4570
4571 break;
4572 default:
4573 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
4574
4575 return;
4576 }
4577
4578 break;
4579 case DSL_PARAM_TYPE_IMAGE:
4580 switch(v->m) {
4581 case DSL_MEMBER_TYPE_NONE:
4582 a = (double) v->image.image.w;
4583 b = (double) v->image.image.h;
4584
4585 (void) dsl_var_src_number_op(v, &a, p1, p2, p3, v1, m);
4586 (void) dsl_var_src_number_op(v, &b, p1, p2, p3, v1, m);
4587
4588 v->image.image.w = (unsigned int) round(a);
4589 v->image.image.h = (unsigned int) round(b);
4590
4591 break;
4592 case DSL_MEMBER_TYPE_WIDTH:
4593 a = (double) v->image.image.w;
4594
4595 (void) dsl_var_src_number_op(v, &a, p1, p2, p3, v1, m);
4596
4597 v->image.image.w = (unsigned int) round(a);
4598
4599 break;
4600 case DSL_MEMBER_TYPE_HEIGHT:
4601 a = (double) v->image.image.h;
4602
4603 (void) dsl_var_src_number_op(v, &a, p1, p2, p3, v1, m);
4604
4605 v->image.image.h = (unsigned int) round(a);
4606
4607 break;
4608 default:
4609 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
4610
4611 return;
4612 }
4613
4614 break;
4615 case DSL_PARAM_TYPE_POINT:
4616 switch(v->m) {
4617 case DSL_MEMBER_TYPE_NONE:
4618 (void) dsl_var_src_number_op(v, &v->point.point.x, p1, p2, p3, v1, m);
4619 (void) dsl_var_src_number_op(v, &v->point.point.y, p1, p2, p3, v1, m);
4620 (void) dsl_var_src_number_op(v, &v->point.point.z, p1, p2, p3, v1, m);
4621
4622 break;
4623 case DSL_MEMBER_TYPE_X:
4624 (void) dsl_var_src_number_op(v, &v->point.point.x, p1, p2, p3, v1, m);
4625
4626 break;
4627 case DSL_MEMBER_TYPE_Y:
4628 (void) dsl_var_src_number_op(v, &v->point.point.y, p1, p2, p3, v1, m);
4629
4630 break;
4631 case DSL_MEMBER_TYPE_Z:
4632 (void) dsl_var_src_number_op(v, &v->point.point.z, p1, p2, p3, v1, m);
4633
4634 break;
4635 case DSL_MEMBER_TYPE_ANGLE_XY:
4636 a = coords_position_to_angle(&v->point.point);
4637 d = coords_mag_2d(&v->point.point);
4638
4639 (void) dsl_var_src_number_op(v, &a, p1, p2, p3, v1, m);
4640
4641 (void) coords_angle_distance_to_position(a, d, &v->point.point);
4642
4643 break;
4644 case DSL_MEMBER_TYPE_MAG_XY:
4645 a = coords_position_to_angle(&v->point.point);
4646 d = coords_mag_2d(&v->point.point);
4647
4648 (void) dsl_var_src_number_op(v, &d, p1, p2, p3, v1, m);
4649
4650 (void) coords_angle_distance_to_position(a, d, &v->point.point);
4651
4652 break;
4653 case DSL_MEMBER_TYPE_MAG_XYZ:
4654 a = coords_position_to_angle(&v->point.point);
4655 d = coords_mag_3d(&v->point.point);
4656
4657 (void) dsl_var_src_number_op(v, &d, p1, p2, p3, v1, m);
4658
4659 (void) coords_angle_distance_to_position(a, d, &v->point.point);
4660
4661 break;
4662 default:
4663 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
4664
4665 return;
4666 }
4667
4668 break;
4669 default:
4670 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
4671
4672 return;
4673 }
4674 }
4675
dsl_var_src_number_op(struct dsl_var * v,double * r,double p1,double p2,double p3,struct dsl_var * v1,unsigned int m)4676 static void dsl_var_src_number_op(struct dsl_var *v, double *r, double p1, double p2, double p3, struct dsl_var *v1, unsigned int m) {
4677 #if ! defined(PROG_DISABLE_EXTENDED)
4678 int e;
4679
4680 uint64_t o, p;
4681
4682 struct dsl_var a;
4683 struct dsl_num b;
4684 #else
4685 (void) p2;
4686 (void) p3;
4687 (void) v1;
4688 #endif
4689 switch(m) {
4690 case DSL_COMMAND_ABS:
4691 *(r) = fabs(p1);
4692
4693 break;
4694 case DSL_COMMAND_ADD:
4695 *(r) += p1;
4696
4697 break;
4698 case DSL_COMMAND_DIV:
4699 *(r) /= p1;
4700
4701 break;
4702 case DSL_COMMAND_MOD:
4703 *(r) = fmod(dsl_num_get_number(v->number.c, &v->number), p1);
4704
4705 break;
4706 case DSL_COMMAND_MOV:
4707 *(r) = p1;
4708
4709 break;
4710 case DSL_COMMAND_MUL:
4711 *(r) *= p1;
4712
4713 break;
4714 case DSL_COMMAND_POW:
4715 *(r) = pow(dsl_num_get_number(v->number.c, &v->number), p1);
4716
4717 break;
4718 case DSL_COMMAND_RAND:
4719 *(r) = (double) maths_rand((unsigned int) round(p1));
4720
4721 break;
4722 case DSL_COMMAND_SUB:
4723 *(r) -= p1;
4724
4725 break;
4726 #if ! defined(PROG_DISABLE_EXTENDED)
4727 case DSL_COMMAND_AND:
4728 o = (uint64_t) round(p1);
4729 p = (uint64_t) round(p2);
4730
4731 o &= p;
4732
4733 *(r) = (double) o;
4734
4735 break;
4736 case DSL_COMMAND_OR:
4737 o = (uint64_t) round(p1);
4738 p = (uint64_t) round(p2);
4739
4740 o |= p;
4741
4742 *(r) = (double) o;
4743
4744 break;
4745 case DSL_COMMAND_XOR:
4746 o = (uint64_t) round(p1);
4747 p = (uint64_t) round(p2);
4748
4749 o ^= p;
4750
4751 *(r) = (double) o;
4752
4753 break;
4754 case DSL_COMMAND_NOT:
4755 o = (uint64_t) round(p1);
4756
4757 o = ~o;
4758
4759 *(r) = (double) o;
4760
4761 break;
4762 case DSL_COMMAND_ISFINITE:
4763 #if defined(isfinite) || defined(HAVE_ISFINITE)
4764 *(r) = (double) isfinite(p1);
4765 #else
4766 LOGWARN(
4767 ERROR_FATAL, SUBSYSTEM,
4768 _("Mandatory isfinite() function call is not supported by this implementation (%s)"),
4769 CONFIG_MACH
4770 );
4771 #endif
4772 break;
4773 case DSL_COMMAND_ISINF:
4774 #if defined(isinf) || defined(HAVE_ISINF)
4775 *(r) = (double) isinf(p1);
4776 #else
4777 LOGWARN(
4778 ERROR_FATAL, SUBSYSTEM,
4779 _("Mandatory isinf() function call is not supported by this implementation (%s)"),
4780 CONFIG_MACH
4781 );
4782 #endif
4783 break;
4784 case DSL_COMMAND_ISNAN:
4785 *(r) = (double) isnan(p1);
4786
4787 break;
4788 case DSL_COMMAND_ISNORMAL:
4789 #if defined(isnormal) || defined(HAVE_ISNORMAL)
4790 *(r) = (double) isnormal(p1);
4791 #else
4792 LOGWARN(
4793 ERROR_FATAL, SUBSYSTEM,
4794 _("Mandatory isnormal() function call is not supported by this implementation (%s)"),
4795 CONFIG_MACH
4796 );
4797 #endif
4798 break;
4799 case DSL_COMMAND_SIGNBIT:
4800 #if defined(signbit) || defined(HAVE_SIGNBIT)
4801 *(r) = (double) signbit(p1);
4802 #else
4803 LOGWARN(
4804 ERROR_FATAL, SUBSYSTEM,
4805 _("Mandatory signbit() function call is not supported by this implementation (%s)"),
4806 CONFIG_MACH
4807 );
4808 #endif
4809 break;
4810 case DSL_COMMAND_COPYSIGN:
4811 *(r) = copysign(p1, p2);
4812
4813 break;
4814 case DSL_COMMAND_NEXTAFTER:
4815 #if defined(HAVE_NEXTAFTER)
4816 *(r) = nextafter(p1, p2);
4817 #else
4818 LOGWARN(
4819 ERROR_FATAL, SUBSYSTEM,
4820 _("Mandatory nextafter() function call is not supported by this implementation (%s)"),
4821 CONFIG_MACH
4822 );
4823 #endif
4824 break;
4825 case DSL_COMMAND_NEXTTOWARD:
4826 #if defined(HAVE_NEXTTOWARD)
4827 *(r) = nexttoward(p1, (long double) p2);
4828 #else
4829 LOGWARN(
4830 ERROR_FATAL, SUBSYSTEM,
4831 _("Mandatory nexttoward() function call is not supported by this implementation (%s)"),
4832 CONFIG_MACH
4833 );
4834 #endif
4835 break;
4836 case DSL_COMMAND_NAN:
4837 #if defined(HAVE_NAN)
4838 (void) memset((void *) &a, 0, sizeof(a));
4839
4840 a.string.string.s = NULL;
4841 a.string.charset.s = NULL;
4842
4843 a.number.c = DSL_NUMBER_TYPE_DEFAULT;
4844 a.number.number.n = p1;
4845
4846 a.number.rpn.r.string.s = NULL;
4847 a.number.rpn.r.charset.s = NULL;
4848
4849 (void) dsl_var_ntos(&a);
4850
4851 *(r) = nan((const char *) a.string.string.s);
4852
4853 if(a.string.string.s != NULL) (void) free(a.string.string.s);
4854 if(a.string.charset.s != NULL) (void) free(a.string.charset.s);
4855 #else
4856 (void) a;
4857
4858 LOGWARN(
4859 ERROR_FATAL, SUBSYSTEM,
4860 _("Mandatory nan() function call is not supported by this implementation (%s)"),
4861 CONFIG_MACH
4862 );
4863 #endif
4864 break;
4865 case DSL_COMMAND_CEIL:
4866 *(r) = ceil(p1);
4867
4868 break;
4869 case DSL_COMMAND_FLOOR:
4870 *(r) = floor(p1);
4871
4872 break;
4873 case DSL_COMMAND_NEARBYINT:
4874 #if defined(HAVE_NEARBYINT)
4875 *(r) = nearbyint(p1);
4876 #else
4877 LOGWARN(
4878 ERROR_FATAL, SUBSYSTEM,
4879 _("Mandatory nearbyint() function call is not supported by this implementation (%s)"),
4880 CONFIG_MACH
4881 );
4882 #endif
4883 break;
4884 case DSL_COMMAND_RINT:
4885 *(r) = rint(p1);
4886
4887 break;
4888 case DSL_COMMAND_ROUND:
4889 *(r) = round(p1);
4890
4891 break;
4892 case DSL_COMMAND_TRUNC:
4893 #if defined(HAVE_TRUNC)
4894 *(r) = trunc(p1);
4895 #else
4896 LOGWARN(
4897 ERROR_FATAL, SUBSYSTEM,
4898 _("Mandatory trunc() function call is not supported by this implementation (%s)"),
4899 CONFIG_MACH
4900 );
4901 #endif
4902 break;
4903 case DSL_COMMAND_REMAINDER:
4904 #if defined(HAVE_REMAINDER)
4905 *(r) = remainder(p1, p2);
4906 #else
4907 LOGWARN(
4908 ERROR_FATAL, SUBSYSTEM,
4909 _("Mandatory remainder() function call is not supported by this implementation (%s)"),
4910 CONFIG_MACH
4911 );
4912 #endif
4913 break;
4914 case DSL_COMMAND_DIM:
4915 #if defined(HAVE_FDIM)
4916 *(r) = fdim(p1, p2);
4917 #else
4918 LOGWARN(
4919 ERROR_FATAL, SUBSYSTEM,
4920 _("Mandatory fdim() function call is not supported by this implementation (%s)"),
4921 CONFIG_MACH
4922 );
4923 #endif
4924 break;
4925 case DSL_COMMAND_MAX:
4926 #if defined(HAVE_FMAX)
4927 *(r) = fmax(p1, p2);
4928 #else
4929 if(isnan(p1)) {
4930 *(r) = p2;
4931 }
4932 else if(isnan(p2)) {
4933 *(r) = p1;
4934 }
4935 else {
4936 *(r) = p1 > p2 ? p1 : p2;
4937 }
4938 #endif
4939 break;
4940 case DSL_COMMAND_MIN:
4941 #if defined(HAVE_FMIN)
4942 *(r) = fmin(p1, p2);
4943 #else
4944 if(isnan(p1)) {
4945 *(r) = p2;
4946 }
4947 else if(isnan(p2)) {
4948 *(r) = p1;
4949 }
4950 else {
4951 *(r) = p1 < p2 ? p1 : p2;
4952 }
4953 #endif
4954 break;
4955 case DSL_COMMAND_FMA:
4956 #if defined(HAVE_FMA)
4957 *(r) = fma(p1, p2, p3);
4958 #else
4959 (void) p3;
4960
4961 LOGWARN(
4962 ERROR_FATAL, SUBSYSTEM,
4963 _("Mandatory fma() function call is not supported by this implementation (%s)"),
4964 CONFIG_MACH
4965 );
4966 #endif
4967 break;
4968 case DSL_COMMAND_SQRT:
4969 *(r) = sqrt(p1);
4970
4971 break;
4972 case DSL_COMMAND_CBRT:
4973 *(r) = cbrt(p1);
4974
4975 break;
4976 case DSL_COMMAND_HYPOT:
4977 *(r) = hypot(p1, p2);
4978
4979 break;
4980 case DSL_COMMAND_EXP:
4981 *(r) = exp(p1);
4982
4983 break;
4984 case DSL_COMMAND_EXP2:
4985 #if defined(HAVE_EXP2)
4986 *(r) = exp2(p1);
4987 #else
4988 LOGWARN(
4989 ERROR_FATAL, SUBSYSTEM,
4990 _("Mandatory exp2() function call is not supported by this implementation (%s)"),
4991 CONFIG_MACH
4992 );
4993 #endif
4994 break;
4995 case DSL_COMMAND_EXPM1:
4996 *(r) = expm1(p1);
4997
4998 break;
4999 case DSL_COMMAND_LOG:
5000 *(r) = log(p1);
5001
5002 break;
5003 case DSL_COMMAND_LOG2:
5004 #if defined(HAVE_LOG2)
5005 *(r) = log2(p1);
5006 #else
5007 LOGWARN(
5008 ERROR_FATAL, SUBSYSTEM,
5009 _("Mandatory log2() function call is not supported by this implementation (%s)"),
5010 CONFIG_MACH
5011 );
5012 #endif
5013 break;
5014 case DSL_COMMAND_LOG10:
5015 *(r) = log10(p1);
5016
5017 break;
5018 case DSL_COMMAND_LOG1P:
5019 *(r) = log1p(p1);
5020
5021 break;
5022 case DSL_COMMAND_LOGB:
5023 *(r) = logb(p1);
5024
5025 break;
5026 case DSL_COMMAND_ILOGB:
5027 #if defined(HAVE_ILOGB)
5028 *(r) = (double) ilogb(p1);
5029 #else
5030 LOGWARN(
5031 ERROR_FATAL, SUBSYSTEM,
5032 _("Mandatory ilogb() function call is not supported by this implementation (%s)"),
5033 CONFIG_MACH
5034 );
5035 #endif
5036 break;
5037 case DSL_COMMAND_MODF:
5038 (void) memset((void *) &b, 0, sizeof(b));
5039
5040 b.rpn.r.string.s = NULL;
5041 b.rpn.r.charset.s = NULL;
5042
5043 *(r) = modf(p1, &b.number.n);
5044
5045 b.c = DSL_NUMBER_TYPE_DEFAULT;
5046
5047 (void) dsl_var_put_number(v1, &b, IS_NO);
5048
5049 break;
5050 case DSL_COMMAND_FREXP:
5051 (void) memset((void *) &b, 0, sizeof(b));
5052
5053 b.rpn.r.string.s = NULL;
5054 b.rpn.r.charset.s = NULL;
5055
5056 *(r) = frexp(p1, &e);
5057
5058 b.c = DSL_NUMBER_TYPE_INT;
5059 b.number.n = (double) e;
5060
5061 (void) dsl_var_put_number(v1, &b, IS_NO);
5062
5063 break;
5064 case DSL_COMMAND_LDEXP:
5065 *(r) = ldexp(p1, (int) p2);
5066
5067 break;
5068 case DSL_COMMAND_SCALBN:
5069 #if defined(HAVE_SCALBN)
5070 *(r) = scalbn(p1, (int) p2);
5071 #else
5072 LOGWARN(
5073 ERROR_FATAL, SUBSYSTEM,
5074 _("Mandatory scalbn() function call is not supported by this implementation (%s)"),
5075 CONFIG_MACH
5076 );
5077 #endif
5078 break;
5079 case DSL_COMMAND_COS:
5080 *(r) = cos(p1);
5081
5082 break;
5083 case DSL_COMMAND_COSH:
5084 *(r) = cosh(p1);
5085
5086 break;
5087 case DSL_COMMAND_ACOS:
5088 *(r) = acos(p1);
5089
5090 break;
5091 case DSL_COMMAND_ACOSH:
5092 *(r) = acosh(p1);
5093
5094 break;
5095 case DSL_COMMAND_SIN:
5096 *(r) = sin(p1);
5097
5098 break;
5099 case DSL_COMMAND_SINH:
5100 *(r) = sinh(p1);
5101
5102 break;
5103 case DSL_COMMAND_ASIN:
5104 *(r) = asin(p1);
5105
5106 break;
5107 case DSL_COMMAND_ASINH:
5108 *(r) = asinh(p1);
5109
5110 break;
5111 case DSL_COMMAND_TAN:
5112 *(r) = tan(p1);
5113
5114 break;
5115 case DSL_COMMAND_TANH:
5116 *(r) = tanh(p1);
5117
5118 break;
5119 case DSL_COMMAND_ATAN:
5120 *(r) = atan(p1);
5121
5122 break;
5123 case DSL_COMMAND_ATANH:
5124 *(r) = atanh(p1);
5125
5126 break;
5127 case DSL_COMMAND_ATAN2:
5128 *(r) = atan2(p1, p2);
5129
5130 break;
5131 case DSL_COMMAND_TGAMMA:
5132 #if defined(HAVE_TGAMMA)
5133 *(r) = tgamma(p1);
5134 #else
5135 LOGWARN(
5136 ERROR_FATAL, SUBSYSTEM,
5137 _("Mandatory tgamma() function call is not supported by this implementation (%s)"),
5138 CONFIG_MACH
5139 );
5140 #endif
5141 break;
5142 case DSL_COMMAND_LGAMMA:
5143 #if defined(HAVE_LGAMMA)
5144 *(r) = lgamma(p1);
5145 #else
5146 LOGWARN(
5147 ERROR_FATAL, SUBSYSTEM,
5148 _("Mandatory lgamma() function call is not supported by this implementation (%s)"),
5149 CONFIG_MACH
5150 );
5151 #endif
5152 break;
5153 case DSL_COMMAND_J0:
5154 *(r) = j0(p1);
5155
5156 break;
5157 case DSL_COMMAND_J1:
5158 *(r) = j1(p1);
5159
5160 break;
5161 case DSL_COMMAND_JN:
5162 *(r) = jn((int) p1, p2);
5163
5164 break;
5165 case DSL_COMMAND_Y0:
5166 *(r) = y0(p1);
5167
5168 break;
5169 case DSL_COMMAND_Y1:
5170 *(r) = y1(p1);
5171
5172 break;
5173 case DSL_COMMAND_YN:
5174 *(r) = yn((int) p1, p2);
5175
5176 break;
5177 case DSL_COMMAND_ERF:
5178 *(r) = erf(p1);
5179
5180 break;
5181 case DSL_COMMAND_ERFC:
5182 *(r) = erfc(p1);
5183
5184 break;
5185 case DSL_COMMAND_GDENS:
5186 *(r) = maths_gaussian_dens(p1);
5187
5188 break;
5189 case DSL_COMMAND_GDIST:
5190 *(r) = maths_gaussian_dist(p1);
5191
5192 break;
5193 case DSL_COMMAND_GRAND:
5194 *(r) = maths_gaussian_rand(p1, p2);
5195
5196 break;
5197 #endif
5198 default:
5199 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
5200
5201 return;
5202 }
5203 }
5204
dsl_var_num_flag_s(struct dsl_num * n,struct dsl_flg * f)5205 static void dsl_var_num_flag_s(struct dsl_num *n, struct dsl_flg *f) {
5206 if(n->number.n < 0.0) f->js = 1;
5207 else f->js = 0;
5208 }
5209
dsl_var_num_flag_z(struct dsl_num * n,struct dsl_flg * f)5210 static void dsl_var_num_flag_z(struct dsl_num *n, struct dsl_flg *f) {
5211 if(fabs(n->number.n - 0.0) < CONST_FLOAT_EQUALS) f->jz = 1;
5212 else f->jz = 0;
5213 }
5214
dsl_var_put_none(struct dsl_var * v)5215 void dsl_var_put_none(struct dsl_var *v) {
5216 v->c = DSL_PARAM_TYPE_NONE;
5217 }
5218
dsl_var_put_number(struct dsl_var * v,struct dsl_num * n,unsigned int c)5219 void dsl_var_put_number(struct dsl_var *v, struct dsl_num *n, unsigned int c) {
5220 double a;
5221
5222 a = dsl_num_get_number(n->c, n);
5223
5224 /* Set variable type only if variable member type was not set */
5225 if(v->m == DSL_MEMBER_TYPE_NONE) v->c = DSL_PARAM_TYPE_NUMBER;
5226
5227 (void) dsl_var_src_number(v, a, 0.0, 0.0, NULL, DSL_COMMAND_MOV);
5228
5229 /* Set number type only if destination variable type needs not to be preserved */
5230 if(c != IS_NO) v->number.c = n->c;
5231 }
5232
dsl_var_put_string(struct dsl_var * v,struct dsl_str * s)5233 void dsl_var_put_string(struct dsl_var *v, struct dsl_str *s) {
5234 (void) dsl_str_copy(&v->string, s);
5235
5236 v->c = DSL_PARAM_TYPE_STRING;
5237 }
5238
dsl_var_put_blob(struct dsl_var * v,struct dsl_blb * b,char * s)5239 void dsl_var_put_blob(struct dsl_var *v, struct dsl_blb *b, char *s) {
5240 unsigned int f;
5241
5242 void *c;
5243
5244 size_t t;
5245
5246 struct dsl_blb d;
5247
5248 if(s != NULL) {
5249 if((f = files_open(s, 0, FILE_MODE_READ)) == 0) return;
5250 if((t = files_get_file_size(f)) != 0) {
5251 if(files_read(f, t) == 0) {
5252 if((c = files_get_content(f)) != NULL) {
5253 d.blob.s = (char *) c;
5254 d.blob.t = t;
5255
5256 (void) dsl_blob_copy(&v->blob, &d);
5257
5258 /* Dont try to read this blob again */
5259 b->s = NULL;
5260 }
5261 }
5262 }
5263
5264 (void) files_close(f);
5265 }
5266 else (void) dsl_blob_copy(&v->blob, b);
5267
5268 v->c = DSL_PARAM_TYPE_BLOB;
5269 }
5270
dsl_var_put_pointer(struct dsl_var * v,struct dsl_ptr * p)5271 void dsl_var_put_pointer(struct dsl_var *v, struct dsl_ptr *p) {
5272 if(p != NULL) v->pointer.pointer = p->pointer;
5273
5274 v->c = DSL_PARAM_TYPE_POINTER;
5275 }
5276
dsl_var_put_handle(struct dsl_var * v,struct dsl_hnd * h)5277 void dsl_var_put_handle(struct dsl_var *v, struct dsl_hnd *h) {
5278 v->handle.handle = h->handle;
5279
5280 v->c = DSL_PARAM_TYPE_HANDLE;
5281 }
5282
dsl_var_put_color(struct dsl_var * v,struct dsl_clr * c,unsigned int m)5283 void dsl_var_put_color(struct dsl_var *v, struct dsl_clr *c, unsigned int m) {
5284 if(c != NULL) (void) dsl_var_put_color_op(v, c, m);
5285 }
5286
dsl_var_put_color_op(struct dsl_var * v,struct dsl_clr * c,unsigned int m)5287 static void dsl_var_put_color_op(struct dsl_var *v, struct dsl_clr *c, unsigned int m) {
5288 switch(v->m) {
5289 case DSL_MEMBER_TYPE_NONE:
5290 v->color.color.pixel.r = dsl_var_put_color_it(c, c->color.pixel.r, m);
5291 v->color.color.pixel.g = dsl_var_put_color_it(c, c->color.pixel.g, m);
5292 v->color.color.pixel.b = dsl_var_put_color_it(c, c->color.pixel.b, m);
5293 v->color.color.pixel.a = dsl_var_put_color_it(c, c->color.pixel.a, m);
5294
5295 break;
5296 case DSL_MEMBER_TYPE_RED:
5297 v->color.color.pixel.r = dsl_var_put_color_it(c, c->color.pixel.r, m);
5298
5299 break;
5300 case DSL_MEMBER_TYPE_GREEN:
5301 v->color.color.pixel.g = dsl_var_put_color_it(c, c->color.pixel.g, m);
5302
5303 break;
5304 case DSL_MEMBER_TYPE_BLUE:
5305 v->color.color.pixel.b = dsl_var_put_color_it(c, c->color.pixel.b, m);
5306
5307 break;
5308 case DSL_MEMBER_TYPE_ALPHA:
5309 v->color.color.pixel.a = dsl_var_put_color_it(c, c->color.pixel.a, m);
5310
5311 break;
5312 default:
5313 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
5314
5315 return;
5316 }
5317
5318 v->c = DSL_PARAM_TYPE_COLOR;
5319 }
5320
dsl_var_put_color_it(struct dsl_clr * c,uint8_t r,unsigned int m)5321 static uint8_t dsl_var_put_color_it(struct dsl_clr *c, uint8_t r, unsigned int m) {
5322 switch(m) {
5323 case DSL_MEMBER_TYPE_NONE:
5324 return(r);
5325 case DSL_MEMBER_TYPE_RED:
5326 return(c->color.pixel.r);
5327 case DSL_MEMBER_TYPE_GREEN:
5328 return(c->color.pixel.g);
5329 case DSL_MEMBER_TYPE_BLUE:
5330 return(c->color.pixel.b);
5331 case DSL_MEMBER_TYPE_ALPHA:
5332 return(c->color.pixel.a);
5333 case DSL_MEMBER_TYPE_BRIGHTNESS:
5334 return((uint8_t) roundf(color_rgba_brightness(&c->color)));
5335 default:
5336 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
5337
5338 break;
5339 }
5340
5341 return(r);
5342 }
5343
dsl_var_dst_color(struct dsl_var * d,unsigned int m,struct dsl_num * n)5344 static void dsl_var_dst_color(struct dsl_var *d, unsigned int m, struct dsl_num *n) {
5345 (void) memset((void *) n, 0, sizeof(struct dsl_num));
5346
5347 n->c = DSL_NUMBER_TYPE_DEFAULT;
5348
5349 n->rpn.r.string.s = NULL;
5350 n->rpn.r.charset.s = NULL;
5351
5352 switch(m) {
5353 case DSL_MEMBER_TYPE_RED:
5354 n->number.n = (double) d->color.color.pixel.r;
5355
5356 break;
5357 case DSL_MEMBER_TYPE_GREEN:
5358 n->number.n = (double) d->color.color.pixel.g;
5359
5360 break;
5361 case DSL_MEMBER_TYPE_BLUE:
5362 n->number.n = (double) d->color.color.pixel.b;
5363
5364 break;
5365 case DSL_MEMBER_TYPE_ALPHA:
5366 n->number.n = (double) d->color.color.pixel.a;
5367
5368 break;
5369 case DSL_MEMBER_TYPE_BRIGHTNESS:
5370 n->number.n = (double) color_rgba_brightness(&d->color.color);
5371
5372 break;
5373 default:
5374 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
5375
5376 return;
5377 }
5378 }
5379
dsl_var_put_image(struct dsl_var * v,struct dsl_img * i,char * s,unsigned int m)5380 void dsl_var_put_image(struct dsl_var *v, struct dsl_img *i, char *s, unsigned int m) {
5381 if(i != NULL) (void) dsl_var_put_image_op(v, i, s, m);
5382 }
5383
dsl_var_put_image_op(struct dsl_var * v,struct dsl_img * i,char * s,unsigned int m)5384 static void dsl_var_put_image_op(struct dsl_var *v, struct dsl_img *i, char *s, unsigned int m) {
5385 struct t_img *r;
5386 struct dsl_img d;
5387
5388 switch(v->m) {
5389 case DSL_MEMBER_TYPE_NONE:
5390 if(s != NULL) {
5391 (void) memset((void *) &d, 0, sizeof(d));
5392
5393 if((r = image_read(s, 0)) == NULL) return;
5394
5395 d.image.w = (unsigned int) r->w;
5396 d.image.h = (unsigned int) r->h;
5397
5398 d.image.s = r->p;
5399
5400 d.s = NULL;
5401
5402 (void) dsl_image_copy(&v->image, &d);
5403
5404 (void) image_free(r);
5405
5406 /* Dont try to read this image again */
5407 i->s = NULL;
5408 }
5409 else (void) dsl_image_copy(&v->image, i);
5410
5411 break;
5412 case DSL_MEMBER_TYPE_WIDTH:
5413 v->image.image.w = dsl_var_put_image_it(i, i->image.w, m);
5414
5415 break;
5416 case DSL_MEMBER_TYPE_HEIGHT:
5417 v->image.image.h = dsl_var_put_image_it(i, i->image.h, m);
5418
5419 break;
5420 default:
5421 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
5422
5423 return;
5424 }
5425
5426 v->c = DSL_PARAM_TYPE_IMAGE;
5427 }
5428
dsl_var_put_image_it(struct dsl_img * i,unsigned int r,unsigned int m)5429 static unsigned int dsl_var_put_image_it(struct dsl_img *i, unsigned int r, unsigned int m) {
5430 switch(m) {
5431 case DSL_MEMBER_TYPE_NONE:
5432 return(r);
5433 case DSL_MEMBER_TYPE_WIDTH:
5434 return(i->image.w);
5435 case DSL_MEMBER_TYPE_HEIGHT:
5436 return(i->image.h);
5437 default:
5438 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
5439
5440 break;
5441 }
5442
5443 return(r);
5444 }
5445
dsl_var_dst_image(struct dsl_var * d,unsigned int m,struct dsl_num * n)5446 static void dsl_var_dst_image(struct dsl_var *d, unsigned int m, struct dsl_num *n) {
5447 (void) memset((void *) n, 0, sizeof(struct dsl_num));
5448
5449 n->c = DSL_NUMBER_TYPE_DEFAULT;
5450
5451 n->rpn.r.string.s = NULL;
5452 n->rpn.r.charset.s = NULL;
5453
5454 switch(m) {
5455 case DSL_MEMBER_TYPE_WIDTH:
5456 n->number.n = (double) d->image.image.w;
5457
5458 break;
5459 case DSL_MEMBER_TYPE_HEIGHT:
5460 n->number.n = (double) d->image.image.h;
5461
5462 break;
5463 default:
5464 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
5465
5466 return;
5467 }
5468 }
5469
dsl_var_put_point(struct dsl_var * v,struct dsl_pnt * t,unsigned int m)5470 void dsl_var_put_point(struct dsl_var *v, struct dsl_pnt *t, unsigned int m) {
5471 if(t != NULL) (void) dsl_var_put_point_op(v, t, m);
5472 }
5473
dsl_var_put_point_op(struct dsl_var * v,struct dsl_pnt * t,unsigned int m)5474 static void dsl_var_put_point_op(struct dsl_var *v, struct dsl_pnt *t, unsigned int m) {
5475 double a, d;
5476
5477 switch(v->m) {
5478 case DSL_MEMBER_TYPE_NONE:
5479 v->point.point.x = dsl_var_put_point_it(t, t->point.x, m);
5480 v->point.point.y = dsl_var_put_point_it(t, t->point.y, m);
5481 v->point.point.z = dsl_var_put_point_it(t, t->point.z, m);
5482
5483 break;
5484 case DSL_MEMBER_TYPE_X:
5485 v->point.point.x = dsl_var_put_point_it(t, t->point.x, m);
5486
5487 break;
5488 case DSL_MEMBER_TYPE_Y:
5489 v->point.point.y = dsl_var_put_point_it(t, t->point.y, m);
5490
5491 break;
5492 case DSL_MEMBER_TYPE_Z:
5493 v->point.point.z = dsl_var_put_point_it(t, t->point.z, m);
5494
5495 break;
5496 case DSL_MEMBER_TYPE_ANGLE_XY:
5497 a = coords_position_to_angle(&t->point);
5498 d = coords_mag_2d(&v->point.point);
5499
5500 (void) coords_angle_distance_to_position(a, d, &v->point.point);
5501
5502 break;
5503 case DSL_MEMBER_TYPE_MAG_XY:
5504 a = coords_position_to_angle(&v->point.point);
5505 d = coords_mag_2d(&t->point);
5506
5507 (void) coords_angle_distance_to_position(a, d, &v->point.point);
5508
5509 break;
5510 case DSL_MEMBER_TYPE_MAG_XYZ:
5511 a = coords_position_to_angle(&v->point.point);
5512 d = coords_mag_3d(&t->point);
5513
5514 (void) coords_angle_distance_to_position(a, d, &v->point.point);
5515
5516 break;
5517 default:
5518 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
5519
5520 return;
5521 }
5522
5523 v->c = DSL_PARAM_TYPE_POINT;
5524 }
5525
dsl_var_put_point_it(struct dsl_pnt * t,double r,unsigned int m)5526 static double dsl_var_put_point_it(struct dsl_pnt *t, double r, unsigned int m) {
5527 switch(m) {
5528 case DSL_MEMBER_TYPE_NONE:
5529 return(r);
5530 case DSL_MEMBER_TYPE_X:
5531 return(t->point.x);
5532 case DSL_MEMBER_TYPE_Y:
5533 return(t->point.y);
5534 case DSL_MEMBER_TYPE_Z:
5535 return(t->point.z);
5536 case DSL_MEMBER_TYPE_ANGLE_XY:
5537 return(coords_position_to_angle(&t->point));
5538 case DSL_MEMBER_TYPE_MAG_XY:
5539 return(coords_mag_2d(&t->point));
5540 case DSL_MEMBER_TYPE_MAG_XYZ:
5541 return(coords_mag_3d(&t->point));
5542 default:
5543 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
5544
5545 break;
5546 }
5547
5548 return(r);
5549 }
5550
dsl_var_dst_point(struct dsl_var * d,unsigned int m,struct dsl_num * n)5551 static void dsl_var_dst_point(struct dsl_var *d, unsigned int m, struct dsl_num *n) {
5552 (void) memset((void *) n, 0, sizeof(struct dsl_num));
5553
5554 n->c = DSL_NUMBER_TYPE_DEFAULT;
5555
5556 n->rpn.r.string.s = NULL;
5557 n->rpn.r.charset.s = NULL;
5558
5559 switch(m) {
5560 case DSL_MEMBER_TYPE_X:
5561 n->number.n = d->point.point.x;
5562
5563 break;
5564 case DSL_MEMBER_TYPE_Y:
5565 n->number.n = d->point.point.y;
5566
5567 break;
5568 case DSL_MEMBER_TYPE_Z:
5569 n->number.n = d->point.point.z;
5570
5571 break;
5572 case DSL_MEMBER_TYPE_ANGLE_XY:
5573 n->number.n = coords_position_to_angle(&d->point.point);
5574
5575 break;
5576 case DSL_MEMBER_TYPE_MAG_XY:
5577 n->number.n = coords_mag_2d(&d->point.point);
5578
5579 break;
5580 case DSL_MEMBER_TYPE_MAG_XYZ:
5581 n->number.n = coords_mag_3d(&d->point.point);
5582
5583 break;
5584 default:
5585 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
5586
5587 return;
5588 }
5589 }
5590
dsl_var_put_variable(struct dsl_var * v,struct dsl_var * s,unsigned int c,unsigned int m)5591 void dsl_var_put_variable(struct dsl_var *v, struct dsl_var *s, unsigned int c, unsigned int m) {
5592 switch(c) {
5593 case DSL_PARAM_TYPE_NONE:
5594 (void) dsl_var_put_none(v);
5595
5596 break;
5597 case DSL_PARAM_TYPE_NUMBER:
5598 (void) dsl_var_put_number(v, &s->number, IS_NO);
5599
5600 break;
5601 case DSL_PARAM_TYPE_STRING:
5602 (void) dsl_var_put_string(v, &s->string);
5603
5604 break;
5605 case DSL_PARAM_TYPE_BLOB:
5606 (void) dsl_var_put_blob(v, &s->blob, NULL);
5607
5608 break;
5609 case DSL_PARAM_TYPE_POINTER:
5610 (void) dsl_var_put_pointer(v, &s->pointer);
5611
5612 break;
5613 case DSL_PARAM_TYPE_HANDLE:
5614 (void) dsl_var_put_handle(v, &s->handle);
5615
5616 break;
5617 case DSL_PARAM_TYPE_COLOR:
5618 (void) dsl_var_put_color(v, &s->color, m);
5619
5620 break;
5621 case DSL_PARAM_TYPE_IMAGE:
5622 (void) dsl_var_put_image(v, &s->image, NULL, m);
5623
5624 break;
5625 case DSL_PARAM_TYPE_POINT:
5626 (void) dsl_var_put_point(v, &s->point, m);
5627
5628 break;
5629 default:
5630 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_PARAM_TYPE_INCOMPATIBLE);
5631
5632 break;
5633 }
5634 }
5635
dsl_var_get_struct_by_name(struct dsl_str * s,struct dsl_vars * v)5636 struct dsl_var *dsl_var_get_struct_by_name(struct dsl_str *s, struct dsl_vars *v) {
5637 unsigned long i;
5638
5639 char *p;
5640
5641 size_t t;
5642
5643 p = s->string.s;
5644 t = s->string.t;
5645
5646 for(i = 0; i < v->c; i++) {
5647 if(t != v->v[i]->variable.string.t) continue;
5648 if(memcmp((const void *) p, (const void *) v->v[i]->variable.string.s, t) == 0) {
5649 return(v->v[i]);
5650 }
5651 }
5652
5653 (void) dsl_error_set(ERROR_SLIGHT, DSL_ERROR_VARIABLE_NOT_DEFINED);
5654
5655 return(NULL);
5656 }
5657
dsl_var_find_struct_by_name(struct dsl_var * v,struct dsl_ctx * c)5658 struct dsl_var *dsl_var_find_struct_by_name(struct dsl_var *v, struct dsl_ctx *c) {
5659 struct dsl_var *r;
5660
5661 r = NULL;
5662
5663 if(c->local != NULL) {
5664 /* Try to find variable from local array first */
5665 r = dsl_var_get_struct_by_name(&v->variable, c->local);
5666
5667 (void) dsl_error_set(ERROR_NOERROR, DSL_ERROR_NONE);
5668 }
5669
5670 if(r == NULL) {
5671 /* Variable was not in local array, try global then */
5672 r = dsl_var_get_struct_by_name(&v->variable, &c->global);
5673 }
5674
5675 return(r);
5676 }
5677