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