projects / m6w6 / ext-psi / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
build administrativa
[m6w6/ext-psi] / src / calc / cast.h
1 /*******************************************************************************
2 Copyright (c) 2016, Michael Wallner <mike@php.net>.
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
7
8 * Redistributions of source code must retain the above copyright notice,
9 this list of conditions and the following disclaimer.
10 * Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the distribution.
13
14 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
18 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *******************************************************************************/
25
26 #include <assert.h>
27
28 #include "token.h"
29
30 static inline void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_type, impl_val *out_val)
31 {
32 switch (out_type) {
33 case PSI_T_INT8:
34 switch (in_type) {
35 case PSI_T_INT8:
36 out_val->i8 = in_val->i8;
37 break;
38 case PSI_T_UINT8:
39 out_val->i8 = in_val->u8;
40 break;
41 case PSI_T_INT16:
42 out_val->i8 = in_val->i16;
43 break;
44 case PSI_T_UINT16:
45 out_val->i8 = in_val->u16;
46 break;
47 case PSI_T_INT32:
48 out_val->i8 = in_val->i32;
49 break;
50 case PSI_T_UINT32:
51 out_val->i8 = in_val->u32;
52 break;
53 case PSI_T_INT64:
54 out_val->i8 = in_val->i64;
55 break;
56 case PSI_T_UINT64:
57 out_val->i8 = in_val->u64;
58 break;
59 # if HAVE_INT128
60 case PSI_T_INT128:
61 out_val->i8 = in_val->i128;
62 break;
63 # endif
64
65 # if HAVE_UINT128
66 case PSI_T_UINT128:
67 out_val->i8 = in_val->u128;
68 break;
69 # endif
70
71 case PSI_T_FLOAT:
72 out_val->i8 = in_val->fval;
73 break;
74 case PSI_T_DOUBLE:
75 out_val->i8 = in_val->dval;
76 break;
77 # if HAVE_LONG_DOUBLE
78 case PSI_T_LONG_DOUBLE:
79 out_val->i8 = in_val->ldval;
80 break;
81 # endif
82
83 default:
84 assert(0);
85 break;
86 }
87 break;
88 case PSI_T_UINT8:
89 switch (in_type) {
90 case PSI_T_INT8:
91 out_val->u8 = in_val->i8;
92 break;
93 case PSI_T_UINT8:
94 out_val->u8 = in_val->u8;
95 break;
96 case PSI_T_INT16:
97 out_val->u8 = in_val->i16;
98 break;
99 case PSI_T_UINT16:
100 out_val->u8 = in_val->u16;
101 break;
102 case PSI_T_INT32:
103 out_val->u8 = in_val->i32;
104 break;
105 case PSI_T_UINT32:
106 out_val->u8 = in_val->u32;
107 break;
108 case PSI_T_INT64:
109 out_val->u8 = in_val->i64;
110 break;
111 case PSI_T_UINT64:
112 out_val->u8 = in_val->u64;
113 break;
114 # if HAVE_INT128
115 case PSI_T_INT128:
116 out_val->u8 = in_val->i128;
117 break;
118 # endif
119
120 # if HAVE_UINT128
121 case PSI_T_UINT128:
122 out_val->u8 = in_val->u128;
123 break;
124 # endif
125
126 case PSI_T_FLOAT:
127 out_val->u8 = in_val->fval;
128 break;
129 case PSI_T_DOUBLE:
130 out_val->u8 = in_val->dval;
131 break;
132 # if HAVE_LONG_DOUBLE
133 case PSI_T_LONG_DOUBLE:
134 out_val->u8 = in_val->ldval;
135 break;
136 # endif
137
138 default:
139 assert(0);
140 break;
141 }
142 break;
143 case PSI_T_INT16:
144 switch (in_type) {
145 case PSI_T_INT8:
146 out_val->i16 = in_val->i8;
147 break;
148 case PSI_T_UINT8:
149 out_val->i16 = in_val->u8;
150 break;
151 case PSI_T_INT16:
152 out_val->i16 = in_val->i16;
153 break;
154 case PSI_T_UINT16:
155 out_val->i16 = in_val->u16;
156 break;
157 case PSI_T_INT32:
158 out_val->i16 = in_val->i32;
159 break;
160 case PSI_T_UINT32:
161 out_val->i16 = in_val->u32;
162 break;
163 case PSI_T_INT64:
164 out_val->i16 = in_val->i64;
165 break;
166 case PSI_T_UINT64:
167 out_val->i16 = in_val->u64;
168 break;
169 # if HAVE_INT128
170 case PSI_T_INT128:
171 out_val->i16 = in_val->i128;
172 break;
173 # endif
174
175 # if HAVE_UINT128
176 case PSI_T_UINT128:
177 out_val->i16 = in_val->u128;
178 break;
179 # endif
180
181 case PSI_T_FLOAT:
182 out_val->i16 = in_val->fval;
183 break;
184 case PSI_T_DOUBLE:
185 out_val->i16 = in_val->dval;
186 break;
187 # if HAVE_LONG_DOUBLE
188 case PSI_T_LONG_DOUBLE:
189 out_val->i16 = in_val->ldval;
190 break;
191 # endif
192
193 default:
194 assert(0);
195 break;
196 }
197 break;
198 case PSI_T_UINT16:
199 switch (in_type) {
200 case PSI_T_INT8:
201 out_val->u16 = in_val->i8;
202 break;
203 case PSI_T_UINT8:
204 out_val->u16 = in_val->u8;
205 break;
206 case PSI_T_INT16:
207 out_val->u16 = in_val->i16;
208 break;
209 case PSI_T_UINT16:
210 out_val->u16 = in_val->u16;
211 break;
212 case PSI_T_INT32:
213 out_val->u16 = in_val->i32;
214 break;
215 case PSI_T_UINT32:
216 out_val->u16 = in_val->u32;
217 break;
218 case PSI_T_INT64:
219 out_val->u16 = in_val->i64;
220 break;
221 case PSI_T_UINT64:
222 out_val->u16 = in_val->u64;
223 break;
224 # if HAVE_INT128
225 case PSI_T_INT128:
226 out_val->u16 = in_val->i128;
227 break;
228 # endif
229
230 # if HAVE_UINT128
231 case PSI_T_UINT128:
232 out_val->u16 = in_val->u128;
233 break;
234 # endif
235
236 case PSI_T_FLOAT:
237 out_val->u16 = in_val->fval;
238 break;
239 case PSI_T_DOUBLE:
240 out_val->u16 = in_val->dval;
241 break;
242 # if HAVE_LONG_DOUBLE
243 case PSI_T_LONG_DOUBLE:
244 out_val->u16 = in_val->ldval;
245 break;
246 # endif
247
248 default:
249 assert(0);
250 break;
251 }
252 break;
253 case PSI_T_INT32:
254 switch (in_type) {
255 case PSI_T_INT8:
256 out_val->i32 = in_val->i8;
257 break;
258 case PSI_T_UINT8:
259 out_val->i32 = in_val->u8;
260 break;
261 case PSI_T_INT16:
262 out_val->i32 = in_val->i16;
263 break;
264 case PSI_T_UINT16:
265 out_val->i32 = in_val->u16;
266 break;
267 case PSI_T_INT32:
268 out_val->i32 = in_val->i32;
269 break;
270 case PSI_T_UINT32:
271 out_val->i32 = in_val->u32;
272 break;
273 case PSI_T_INT64:
274 out_val->i32 = in_val->i64;
275 break;
276 case PSI_T_UINT64:
277 out_val->i32 = in_val->u64;
278 break;
279 # if HAVE_INT128
280 case PSI_T_INT128:
281 out_val->i32 = in_val->i128;
282 break;
283 # endif
284
285 # if HAVE_UINT128
286 case PSI_T_UINT128:
287 out_val->i32 = in_val->u128;
288 break;
289 # endif
290
291 case PSI_T_FLOAT:
292 out_val->i32 = in_val->fval;
293 break;
294 case PSI_T_DOUBLE:
295 out_val->i32 = in_val->dval;
296 break;
297 # if HAVE_LONG_DOUBLE
298 case PSI_T_LONG_DOUBLE:
299 out_val->i32 = in_val->ldval;
300 break;
301 # endif
302
303 default:
304 assert(0);
305 break;
306 }
307 break;
308 case PSI_T_UINT32:
309 switch (in_type) {
310 case PSI_T_INT8:
311 out_val->u32 = in_val->i8;
312 break;
313 case PSI_T_UINT8:
314 out_val->u32 = in_val->u8;
315 break;
316 case PSI_T_INT16:
317 out_val->u32 = in_val->i16;
318 break;
319 case PSI_T_UINT16:
320 out_val->u32 = in_val->u16;
321 break;
322 case PSI_T_INT32:
323 out_val->u32 = in_val->i32;
324 break;
325 case PSI_T_UINT32:
326 out_val->u32 = in_val->u32;
327 break;
328 case PSI_T_INT64:
329 out_val->u32 = in_val->i64;
330 break;
331 case PSI_T_UINT64:
332 out_val->u32 = in_val->u64;
333 break;
334 # if HAVE_INT128
335 case PSI_T_INT128:
336 out_val->u32 = in_val->i128;
337 break;
338 # endif
339
340 # if HAVE_UINT128
341 case PSI_T_UINT128:
342 out_val->u32 = in_val->u128;
343 break;
344 # endif
345
346 case PSI_T_FLOAT:
347 out_val->u32 = in_val->fval;
348 break;
349 case PSI_T_DOUBLE:
350 out_val->u32 = in_val->dval;
351 break;
352 # if HAVE_LONG_DOUBLE
353 case PSI_T_LONG_DOUBLE:
354 out_val->u32 = in_val->ldval;
355 break;
356 # endif
357
358 default:
359 assert(0);
360 break;
361 }
362 break;
363 case PSI_T_INT64:
364 switch (in_type) {
365 case PSI_T_INT8:
366 out_val->i64 = in_val->i8;
367 break;
368 case PSI_T_UINT8:
369 out_val->i64 = in_val->u8;
370 break;
371 case PSI_T_INT16:
372 out_val->i64 = in_val->i16;
373 break;
374 case PSI_T_UINT16:
375 out_val->i64 = in_val->u16;
376 break;
377 case PSI_T_INT32:
378 out_val->i64 = in_val->i32;
379 break;
380 case PSI_T_UINT32:
381 out_val->i64 = in_val->u32;
382 break;
383 case PSI_T_INT64:
384 out_val->i64 = in_val->i64;
385 break;
386 case PSI_T_UINT64:
387 out_val->i64 = in_val->u64;
388 break;
389 # if HAVE_INT128
390 case PSI_T_INT128:
391 out_val->i64 = in_val->i128;
392 break;
393 # endif
394
395 # if HAVE_UINT128
396 case PSI_T_UINT128:
397 out_val->i64 = in_val->u128;
398 break;
399 # endif
400
401 case PSI_T_FLOAT:
402 out_val->i64 = in_val->fval;
403 break;
404 case PSI_T_DOUBLE:
405 out_val->i64 = in_val->dval;
406 break;
407 # if HAVE_LONG_DOUBLE
408 case PSI_T_LONG_DOUBLE:
409 out_val->i64 = in_val->ldval;
410 break;
411 # endif
412
413 default:
414 assert(0);
415 break;
416 }
417 break;
418 case PSI_T_UINT64:
419 switch (in_type) {
420 case PSI_T_INT8:
421 out_val->u64 = in_val->i8;
422 break;
423 case PSI_T_UINT8:
424 out_val->u64 = in_val->u8;
425 break;
426 case PSI_T_INT16:
427 out_val->u64 = in_val->i16;
428 break;
429 case PSI_T_UINT16:
430 out_val->u64 = in_val->u16;
431 break;
432 case PSI_T_INT32:
433 out_val->u64 = in_val->i32;
434 break;
435 case PSI_T_UINT32:
436 out_val->u64 = in_val->u32;
437 break;
438 case PSI_T_INT64:
439 out_val->u64 = in_val->i64;
440 break;
441 case PSI_T_UINT64:
442 out_val->u64 = in_val->u64;
443 break;
444 # if HAVE_INT128
445 case PSI_T_INT128:
446 out_val->u64 = in_val->i128;
447 break;
448 # endif
449
450 # if HAVE_UINT128
451 case PSI_T_UINT128:
452 out_val->u64 = in_val->u128;
453 break;
454 # endif
455
456 case PSI_T_FLOAT:
457 out_val->u64 = in_val->fval;
458 break;
459 case PSI_T_DOUBLE:
460 out_val->u64 = in_val->dval;
461 break;
462 # if HAVE_LONG_DOUBLE
463 case PSI_T_LONG_DOUBLE:
464 out_val->u64 = in_val->ldval;
465 break;
466 # endif
467
468 default:
469 assert(0);
470 break;
471 }
472 break;
473 #if HAVE_INT128
474 case PSI_T_INT128:
475 switch (in_type) {
476 case PSI_T_INT8:
477 out_val->i128 = in_val->i8;
478 break;
479 case PSI_T_UINT8:
480 out_val->i128 = in_val->u8;
481 break;
482 case PSI_T_INT16:
483 out_val->i128 = in_val->i16;
484 break;
485 case PSI_T_UINT16:
486 out_val->i128 = in_val->u16;
487 break;
488 case PSI_T_INT32:
489 out_val->i128 = in_val->i32;
490 break;
491 case PSI_T_UINT32:
492 out_val->i128 = in_val->u32;
493 break;
494 case PSI_T_INT64:
495 out_val->i128 = in_val->i64;
496 break;
497 case PSI_T_UINT64:
498 out_val->i128 = in_val->u64;
499 break;
500 # if HAVE_INT128
501 case PSI_T_INT128:
502 out_val->i128 = in_val->i128;
503 break;
504 # endif
505
506 # if HAVE_UINT128
507 case PSI_T_UINT128:
508 out_val->i128 = in_val->u128;
509 break;
510 # endif
511
512 case PSI_T_FLOAT:
513 out_val->i128 = in_val->fval;
514 break;
515 case PSI_T_DOUBLE:
516 out_val->i128 = in_val->dval;
517 break;
518 # if HAVE_LONG_DOUBLE
519 case PSI_T_LONG_DOUBLE:
520 out_val->i128 = in_val->ldval;
521 break;
522 # endif
523
524 default:
525 assert(0);
526 break;
527 }
528 break;
529 #endif
530
531 #if HAVE_UINT128
532 case PSI_T_UINT128:
533 switch (in_type) {
534 case PSI_T_INT8:
535 out_val->u128 = in_val->i8;
536 break;
537 case PSI_T_UINT8:
538 out_val->u128 = in_val->u8;
539 break;
540 case PSI_T_INT16:
541 out_val->u128 = in_val->i16;
542 break;
543 case PSI_T_UINT16:
544 out_val->u128 = in_val->u16;
545 break;
546 case PSI_T_INT32:
547 out_val->u128 = in_val->i32;
548 break;
549 case PSI_T_UINT32:
550 out_val->u128 = in_val->u32;
551 break;
552 case PSI_T_INT64:
553 out_val->u128 = in_val->i64;
554 break;
555 case PSI_T_UINT64:
556 out_val->u128 = in_val->u64;
557 break;
558 # if HAVE_INT128
559 case PSI_T_INT128:
560 out_val->u128 = in_val->i128;
561 break;
562 # endif
563
564 # if HAVE_UINT128
565 case PSI_T_UINT128:
566 out_val->u128 = in_val->u128;
567 break;
568 # endif
569
570 case PSI_T_FLOAT:
571 out_val->u128 = in_val->fval;
572 break;
573 case PSI_T_DOUBLE:
574 out_val->u128 = in_val->dval;
575 break;
576 # if HAVE_LONG_DOUBLE
577 case PSI_T_LONG_DOUBLE:
578 out_val->u128 = in_val->ldval;
579 break;
580 # endif
581
582 default:
583 assert(0);
584 break;
585 }
586 break;
587 #endif
588
589 case PSI_T_FLOAT:
590 switch (in_type) {
591 case PSI_T_INT8:
592 out_val->fval = in_val->i8;
593 break;
594 case PSI_T_UINT8:
595 out_val->fval = in_val->u8;
596 break;
597 case PSI_T_INT16:
598 out_val->fval = in_val->i16;
599 break;
600 case PSI_T_UINT16:
601 out_val->fval = in_val->u16;
602 break;
603 case PSI_T_INT32:
604 out_val->fval = in_val->i32;
605 break;
606 case PSI_T_UINT32:
607 out_val->fval = in_val->u32;
608 break;
609 case PSI_T_INT64:
610 out_val->fval = in_val->i64;
611 break;
612 case PSI_T_UINT64:
613 out_val->fval = in_val->u64;
614 break;
615 # if HAVE_INT128
616 case PSI_T_INT128:
617 out_val->fval = in_val->i128;
618 break;
619 # endif
620
621 # if HAVE_UINT128
622 case PSI_T_UINT128:
623 out_val->fval = in_val->u128;
624 break;
625 # endif
626
627 case PSI_T_FLOAT:
628 out_val->fval = in_val->fval;
629 break;
630 case PSI_T_DOUBLE:
631 out_val->fval = in_val->dval;
632 break;
633 # if HAVE_LONG_DOUBLE
634 case PSI_T_LONG_DOUBLE:
635 out_val->fval = in_val->ldval;
636 break;
637 # endif
638
639 default:
640 assert(0);
641 break;
642 }
643 break;
644 case PSI_T_DOUBLE:
645 switch (in_type) {
646 case PSI_T_INT8:
647 out_val->dval = in_val->i8;
648 break;
649 case PSI_T_UINT8:
650 out_val->dval = in_val->u8;
651 break;
652 case PSI_T_INT16:
653 out_val->dval = in_val->i16;
654 break;
655 case PSI_T_UINT16:
656 out_val->dval = in_val->u16;
657 break;
658 case PSI_T_INT32:
659 out_val->dval = in_val->i32;
660 break;
661 case PSI_T_UINT32:
662 out_val->dval = in_val->u32;
663 break;
664 case PSI_T_INT64:
665 out_val->dval = in_val->i64;
666 break;
667 case PSI_T_UINT64:
668 out_val->dval = in_val->u64;
669 break;
670 # if HAVE_INT128
671 case PSI_T_INT128:
672 out_val->dval = in_val->i128;
673 break;
674 # endif
675
676 # if HAVE_UINT128
677 case PSI_T_UINT128:
678 out_val->dval = in_val->u128;
679 break;
680 # endif
681
682 case PSI_T_FLOAT:
683 out_val->dval = in_val->fval;
684 break;
685 case PSI_T_DOUBLE:
686 out_val->dval = in_val->dval;
687 break;
688 # if HAVE_LONG_DOUBLE
689 case PSI_T_LONG_DOUBLE:
690 out_val->dval = in_val->ldval;
691 break;
692 # endif
693
694 default:
695 assert(0);
696 break;
697 }
698 break;
699 #if HAVE_LONG_DOUBLE
700 case PSI_T_LONG_DOUBLE:
701 switch (in_type) {
702 case PSI_T_INT8:
703 out_val->ldval = in_val->i8;
704 break;
705 case PSI_T_UINT8:
706 out_val->ldval = in_val->u8;
707 break;
708 case PSI_T_INT16:
709 out_val->ldval = in_val->i16;
710 break;
711 case PSI_T_UINT16:
712 out_val->ldval = in_val->u16;
713 break;
714 case PSI_T_INT32:
715 out_val->ldval = in_val->i32;
716 break;
717 case PSI_T_UINT32:
718 out_val->ldval = in_val->u32;
719 break;
720 case PSI_T_INT64:
721 out_val->ldval = in_val->i64;
722 break;
723 case PSI_T_UINT64:
724 out_val->ldval = in_val->u64;
725 break;
726 # if HAVE_INT128
727 case PSI_T_INT128:
728 out_val->ldval = in_val->i128;
729 break;
730 # endif
731
732 # if HAVE_UINT128
733 case PSI_T_UINT128:
734 out_val->ldval = in_val->u128;
735 break;
736 # endif
737
738 case PSI_T_FLOAT:
739 out_val->ldval = in_val->fval;
740 break;
741 case PSI_T_DOUBLE:
742 out_val->ldval = in_val->dval;
743 break;
744 # if HAVE_LONG_DOUBLE
745 case PSI_T_LONG_DOUBLE:
746 out_val->ldval = in_val->ldval;
747 break;
748 # endif
749
750 default:
751 assert(0);
752 break;
753 }
754 break;
755 #endif
756
757 default:
758 assert(0);
759 break;
760 }
761 }
762
PHP System Interface / POSIX Standard Interface