1 /*******************************************************************************
2 Copyright (c) 2016, Michael Wallner <mike@php.net>.
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
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.
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 *******************************************************************************/
26 #include "php_psi_stdinc.h"
31 static inline token_t
psi_calc_add(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
38 res
->i16
= v1
->i8
+ v2
->i8
;
41 res
->i16
= v1
->i8
+ v2
->u8
;
44 res
->i32
= v1
->i8
+ v2
->i16
;
47 res
->i32
= v1
->i8
+ v2
->u16
;
50 res
->i64
= v1
->i8
+ v2
->i32
;
53 res
->i64
= v1
->i8
+ v2
->u32
;
56 res
->i64
= v1
->i8
+ v2
->i64
;
59 res
->i64
= v1
->i8
+ v2
->u64
;
62 res
->fval
= v1
->i8
+ v2
->fval
;
65 res
->dval
= v1
->i8
+ v2
->dval
;
68 case PSI_T_LONG_DOUBLE
:
69 res
->ldval
= v1
->i8
+ v2
->ldval
;
70 return PSI_T_LONG_DOUBLE
;
81 res
->i16
= v1
->u8
+ v2
->i8
;
84 res
->u16
= v1
->u8
+ v2
->u8
;
87 res
->i32
= v1
->u8
+ v2
->i16
;
90 res
->u32
= v1
->u8
+ v2
->u16
;
93 res
->i64
= v1
->u8
+ v2
->i32
;
96 res
->u64
= v1
->u8
+ v2
->u32
;
99 res
->i64
= v1
->u8
+ v2
->i64
;
102 res
->u64
= v1
->u8
+ v2
->u64
;
105 res
->fval
= v1
->u8
+ v2
->fval
;
108 res
->dval
= v1
->u8
+ v2
->dval
;
110 # if HAVE_LONG_DOUBLE
111 case PSI_T_LONG_DOUBLE
:
112 res
->ldval
= v1
->u8
+ v2
->ldval
;
113 return PSI_T_LONG_DOUBLE
;
124 res
->i32
= v1
->i16
+ v2
->i8
;
127 res
->i32
= v1
->i16
+ v2
->u8
;
130 res
->i32
= v1
->i16
+ v2
->i16
;
133 res
->i32
= v1
->i16
+ v2
->u16
;
136 res
->i64
= v1
->i16
+ v2
->i32
;
139 res
->i64
= v1
->i16
+ v2
->u32
;
142 res
->i64
= v1
->i16
+ v2
->i64
;
145 res
->i64
= v1
->i16
+ v2
->u64
;
148 res
->fval
= v1
->i16
+ v2
->fval
;
151 res
->dval
= v1
->i16
+ v2
->dval
;
153 # if HAVE_LONG_DOUBLE
154 case PSI_T_LONG_DOUBLE
:
155 res
->ldval
= v1
->i16
+ v2
->ldval
;
156 return PSI_T_LONG_DOUBLE
;
167 res
->i32
= v1
->u16
+ v2
->i8
;
170 res
->u32
= v1
->u16
+ v2
->u8
;
173 res
->i32
= v1
->u16
+ v2
->i16
;
176 res
->u32
= v1
->u16
+ v2
->u16
;
179 res
->i64
= v1
->u16
+ v2
->i32
;
182 res
->u64
= v1
->u16
+ v2
->u32
;
185 res
->i64
= v1
->u16
+ v2
->i64
;
188 res
->u64
= v1
->u16
+ v2
->u64
;
191 res
->fval
= v1
->u16
+ v2
->fval
;
194 res
->dval
= v1
->u16
+ v2
->dval
;
196 # if HAVE_LONG_DOUBLE
197 case PSI_T_LONG_DOUBLE
:
198 res
->ldval
= v1
->u16
+ v2
->ldval
;
199 return PSI_T_LONG_DOUBLE
;
210 res
->i64
= v1
->i32
+ v2
->i8
;
213 res
->i64
= v1
->i32
+ v2
->u8
;
216 res
->i64
= v1
->i32
+ v2
->i16
;
219 res
->i64
= v1
->i32
+ v2
->u16
;
222 res
->i64
= v1
->i32
+ v2
->i32
;
225 res
->i64
= v1
->i32
+ v2
->u32
;
228 res
->i64
= v1
->i32
+ v2
->i64
;
231 res
->i64
= v1
->i32
+ v2
->u64
;
234 res
->fval
= v1
->i32
+ v2
->fval
;
237 res
->dval
= v1
->i32
+ v2
->dval
;
239 # if HAVE_LONG_DOUBLE
240 case PSI_T_LONG_DOUBLE
:
241 res
->ldval
= v1
->i32
+ v2
->ldval
;
242 return PSI_T_LONG_DOUBLE
;
253 res
->i64
= v1
->u32
+ v2
->i8
;
256 res
->u64
= v1
->u32
+ v2
->u8
;
259 res
->i64
= v1
->u32
+ v2
->i16
;
262 res
->u64
= v1
->u32
+ v2
->u16
;
265 res
->i64
= v1
->u32
+ v2
->i32
;
268 res
->u64
= v1
->u32
+ v2
->u32
;
271 res
->i64
= v1
->u32
+ v2
->i64
;
274 res
->u64
= v1
->u32
+ v2
->u64
;
277 res
->fval
= v1
->u32
+ v2
->fval
;
280 res
->dval
= v1
->u32
+ v2
->dval
;
282 # if HAVE_LONG_DOUBLE
283 case PSI_T_LONG_DOUBLE
:
284 res
->ldval
= v1
->u32
+ v2
->ldval
;
285 return PSI_T_LONG_DOUBLE
;
296 res
->i64
= v1
->i64
+ v2
->i8
;
299 res
->i64
= v1
->i64
+ v2
->u8
;
302 res
->i64
= v1
->i64
+ v2
->i16
;
305 res
->i64
= v1
->i64
+ v2
->u16
;
308 res
->i64
= v1
->i64
+ v2
->i32
;
311 res
->i64
= v1
->i64
+ v2
->u32
;
314 res
->i64
= v1
->i64
+ v2
->i64
;
317 res
->i64
= v1
->i64
+ v2
->u64
;
320 res
->fval
= v1
->i64
+ v2
->fval
;
323 res
->dval
= v1
->i64
+ v2
->dval
;
325 # if HAVE_LONG_DOUBLE
326 case PSI_T_LONG_DOUBLE
:
327 res
->ldval
= v1
->i64
+ v2
->ldval
;
328 return PSI_T_LONG_DOUBLE
;
339 res
->i64
= v1
->u64
+ v2
->i8
;
342 res
->u64
= v1
->u64
+ v2
->u8
;
345 res
->i64
= v1
->u64
+ v2
->i16
;
348 res
->u64
= v1
->u64
+ v2
->u16
;
351 res
->i64
= v1
->u64
+ v2
->i32
;
354 res
->u64
= v1
->u64
+ v2
->u32
;
357 res
->i64
= v1
->u64
+ v2
->i64
;
360 res
->u64
= v1
->u64
+ v2
->u64
;
363 res
->fval
= v1
->u64
+ v2
->fval
;
366 res
->dval
= v1
->u64
+ v2
->dval
;
368 # if HAVE_LONG_DOUBLE
369 case PSI_T_LONG_DOUBLE
:
370 res
->ldval
= v1
->u64
+ v2
->ldval
;
371 return PSI_T_LONG_DOUBLE
;
382 res
->fval
= v1
->fval
+ v2
->i8
;
385 res
->fval
= v1
->fval
+ v2
->u8
;
388 res
->fval
= v1
->fval
+ v2
->i16
;
391 res
->fval
= v1
->fval
+ v2
->u16
;
394 res
->fval
= v1
->fval
+ v2
->i32
;
397 res
->fval
= v1
->fval
+ v2
->u32
;
400 res
->fval
= v1
->fval
+ v2
->i64
;
403 res
->fval
= v1
->fval
+ v2
->u64
;
406 res
->fval
= v1
->fval
+ v2
->fval
;
409 res
->dval
= v1
->fval
+ v2
->dval
;
411 # if HAVE_LONG_DOUBLE
412 case PSI_T_LONG_DOUBLE
:
413 res
->ldval
= v1
->fval
+ v2
->ldval
;
414 return PSI_T_LONG_DOUBLE
;
425 res
->dval
= v1
->dval
+ v2
->i8
;
428 res
->dval
= v1
->dval
+ v2
->u8
;
431 res
->dval
= v1
->dval
+ v2
->i16
;
434 res
->dval
= v1
->dval
+ v2
->u16
;
437 res
->dval
= v1
->dval
+ v2
->i32
;
440 res
->dval
= v1
->dval
+ v2
->u32
;
443 res
->dval
= v1
->dval
+ v2
->i64
;
446 res
->dval
= v1
->dval
+ v2
->u64
;
449 res
->dval
= v1
->dval
+ v2
->fval
;
452 res
->dval
= v1
->dval
+ v2
->dval
;
454 # if HAVE_LONG_DOUBLE
455 case PSI_T_LONG_DOUBLE
:
456 res
->ldval
= v1
->dval
+ v2
->ldval
;
457 return PSI_T_LONG_DOUBLE
;
466 case PSI_T_LONG_DOUBLE
:
469 res
->ldval
= v1
->ldval
+ v2
->i8
;
470 return PSI_T_LONG_DOUBLE
;
472 res
->ldval
= v1
->ldval
+ v2
->u8
;
473 return PSI_T_LONG_DOUBLE
;
475 res
->ldval
= v1
->ldval
+ v2
->i16
;
476 return PSI_T_LONG_DOUBLE
;
478 res
->ldval
= v1
->ldval
+ v2
->u16
;
479 return PSI_T_LONG_DOUBLE
;
481 res
->ldval
= v1
->ldval
+ v2
->i32
;
482 return PSI_T_LONG_DOUBLE
;
484 res
->ldval
= v1
->ldval
+ v2
->u32
;
485 return PSI_T_LONG_DOUBLE
;
487 res
->ldval
= v1
->ldval
+ v2
->i64
;
488 return PSI_T_LONG_DOUBLE
;
490 res
->ldval
= v1
->ldval
+ v2
->u64
;
491 return PSI_T_LONG_DOUBLE
;
493 res
->ldval
= v1
->ldval
+ v2
->fval
;
494 return PSI_T_LONG_DOUBLE
;
496 res
->ldval
= v1
->ldval
+ v2
->dval
;
497 return PSI_T_LONG_DOUBLE
;
498 # if HAVE_LONG_DOUBLE
499 case PSI_T_LONG_DOUBLE
:
500 res
->ldval
= v1
->ldval
+ v2
->ldval
;
501 return PSI_T_LONG_DOUBLE
;
518 static inline token_t
psi_calc_sub(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
525 res
->i16
= v1
->i8
- v2
->i8
;
528 res
->i16
= v1
->i8
- v2
->u8
;
531 res
->i32
= v1
->i8
- v2
->i16
;
534 res
->i32
= v1
->i8
- v2
->u16
;
537 res
->i64
= v1
->i8
- v2
->i32
;
540 res
->i64
= v1
->i8
- v2
->u32
;
543 res
->i64
= v1
->i8
- v2
->i64
;
546 res
->i64
= v1
->i8
- v2
->u64
;
549 res
->fval
= v1
->i8
- v2
->fval
;
552 res
->dval
= v1
->i8
- v2
->dval
;
554 # if HAVE_LONG_DOUBLE
555 case PSI_T_LONG_DOUBLE
:
556 res
->ldval
= v1
->i8
- v2
->ldval
;
557 return PSI_T_LONG_DOUBLE
;
568 res
->i16
= v1
->u8
- v2
->i8
;
571 res
->u16
= v1
->u8
- v2
->u8
;
574 res
->i32
= v1
->u8
- v2
->i16
;
577 res
->u32
= v1
->u8
- v2
->u16
;
580 res
->i64
= v1
->u8
- v2
->i32
;
583 res
->u64
= v1
->u8
- v2
->u32
;
586 res
->i64
= v1
->u8
- v2
->i64
;
589 res
->u64
= v1
->u8
- v2
->u64
;
592 res
->fval
= v1
->u8
- v2
->fval
;
595 res
->dval
= v1
->u8
- v2
->dval
;
597 # if HAVE_LONG_DOUBLE
598 case PSI_T_LONG_DOUBLE
:
599 res
->ldval
= v1
->u8
- v2
->ldval
;
600 return PSI_T_LONG_DOUBLE
;
611 res
->i32
= v1
->i16
- v2
->i8
;
614 res
->i32
= v1
->i16
- v2
->u8
;
617 res
->i32
= v1
->i16
- v2
->i16
;
620 res
->i32
= v1
->i16
- v2
->u16
;
623 res
->i64
= v1
->i16
- v2
->i32
;
626 res
->i64
= v1
->i16
- v2
->u32
;
629 res
->i64
= v1
->i16
- v2
->i64
;
632 res
->i64
= v1
->i16
- v2
->u64
;
635 res
->fval
= v1
->i16
- v2
->fval
;
638 res
->dval
= v1
->i16
- v2
->dval
;
640 # if HAVE_LONG_DOUBLE
641 case PSI_T_LONG_DOUBLE
:
642 res
->ldval
= v1
->i16
- v2
->ldval
;
643 return PSI_T_LONG_DOUBLE
;
654 res
->i32
= v1
->u16
- v2
->i8
;
657 res
->u32
= v1
->u16
- v2
->u8
;
660 res
->i32
= v1
->u16
- v2
->i16
;
663 res
->u32
= v1
->u16
- v2
->u16
;
666 res
->i64
= v1
->u16
- v2
->i32
;
669 res
->u64
= v1
->u16
- v2
->u32
;
672 res
->i64
= v1
->u16
- v2
->i64
;
675 res
->u64
= v1
->u16
- v2
->u64
;
678 res
->fval
= v1
->u16
- v2
->fval
;
681 res
->dval
= v1
->u16
- v2
->dval
;
683 # if HAVE_LONG_DOUBLE
684 case PSI_T_LONG_DOUBLE
:
685 res
->ldval
= v1
->u16
- v2
->ldval
;
686 return PSI_T_LONG_DOUBLE
;
697 res
->i64
= v1
->i32
- v2
->i8
;
700 res
->i64
= v1
->i32
- v2
->u8
;
703 res
->i64
= v1
->i32
- v2
->i16
;
706 res
->i64
= v1
->i32
- v2
->u16
;
709 res
->i64
= v1
->i32
- v2
->i32
;
712 res
->i64
= v1
->i32
- v2
->u32
;
715 res
->i64
= v1
->i32
- v2
->i64
;
718 res
->i64
= v1
->i32
- v2
->u64
;
721 res
->fval
= v1
->i32
- v2
->fval
;
724 res
->dval
= v1
->i32
- v2
->dval
;
726 # if HAVE_LONG_DOUBLE
727 case PSI_T_LONG_DOUBLE
:
728 res
->ldval
= v1
->i32
- v2
->ldval
;
729 return PSI_T_LONG_DOUBLE
;
740 res
->i64
= v1
->u32
- v2
->i8
;
743 res
->u64
= v1
->u32
- v2
->u8
;
746 res
->i64
= v1
->u32
- v2
->i16
;
749 res
->u64
= v1
->u32
- v2
->u16
;
752 res
->i64
= v1
->u32
- v2
->i32
;
755 res
->u64
= v1
->u32
- v2
->u32
;
758 res
->i64
= v1
->u32
- v2
->i64
;
761 res
->u64
= v1
->u32
- v2
->u64
;
764 res
->fval
= v1
->u32
- v2
->fval
;
767 res
->dval
= v1
->u32
- v2
->dval
;
769 # if HAVE_LONG_DOUBLE
770 case PSI_T_LONG_DOUBLE
:
771 res
->ldval
= v1
->u32
- v2
->ldval
;
772 return PSI_T_LONG_DOUBLE
;
783 res
->i64
= v1
->i64
- v2
->i8
;
786 res
->i64
= v1
->i64
- v2
->u8
;
789 res
->i64
= v1
->i64
- v2
->i16
;
792 res
->i64
= v1
->i64
- v2
->u16
;
795 res
->i64
= v1
->i64
- v2
->i32
;
798 res
->i64
= v1
->i64
- v2
->u32
;
801 res
->i64
= v1
->i64
- v2
->i64
;
804 res
->i64
= v1
->i64
- v2
->u64
;
807 res
->fval
= v1
->i64
- v2
->fval
;
810 res
->dval
= v1
->i64
- v2
->dval
;
812 # if HAVE_LONG_DOUBLE
813 case PSI_T_LONG_DOUBLE
:
814 res
->ldval
= v1
->i64
- v2
->ldval
;
815 return PSI_T_LONG_DOUBLE
;
826 res
->i64
= v1
->u64
- v2
->i8
;
829 res
->u64
= v1
->u64
- v2
->u8
;
832 res
->i64
= v1
->u64
- v2
->i16
;
835 res
->u64
= v1
->u64
- v2
->u16
;
838 res
->i64
= v1
->u64
- v2
->i32
;
841 res
->u64
= v1
->u64
- v2
->u32
;
844 res
->i64
= v1
->u64
- v2
->i64
;
847 res
->u64
= v1
->u64
- v2
->u64
;
850 res
->fval
= v1
->u64
- v2
->fval
;
853 res
->dval
= v1
->u64
- v2
->dval
;
855 # if HAVE_LONG_DOUBLE
856 case PSI_T_LONG_DOUBLE
:
857 res
->ldval
= v1
->u64
- v2
->ldval
;
858 return PSI_T_LONG_DOUBLE
;
869 res
->fval
= v1
->fval
- v2
->i8
;
872 res
->fval
= v1
->fval
- v2
->u8
;
875 res
->fval
= v1
->fval
- v2
->i16
;
878 res
->fval
= v1
->fval
- v2
->u16
;
881 res
->fval
= v1
->fval
- v2
->i32
;
884 res
->fval
= v1
->fval
- v2
->u32
;
887 res
->fval
= v1
->fval
- v2
->i64
;
890 res
->fval
= v1
->fval
- v2
->u64
;
893 res
->fval
= v1
->fval
- v2
->fval
;
896 res
->dval
= v1
->fval
- v2
->dval
;
898 # if HAVE_LONG_DOUBLE
899 case PSI_T_LONG_DOUBLE
:
900 res
->ldval
= v1
->fval
- v2
->ldval
;
901 return PSI_T_LONG_DOUBLE
;
912 res
->dval
= v1
->dval
- v2
->i8
;
915 res
->dval
= v1
->dval
- v2
->u8
;
918 res
->dval
= v1
->dval
- v2
->i16
;
921 res
->dval
= v1
->dval
- v2
->u16
;
924 res
->dval
= v1
->dval
- v2
->i32
;
927 res
->dval
= v1
->dval
- v2
->u32
;
930 res
->dval
= v1
->dval
- v2
->i64
;
933 res
->dval
= v1
->dval
- v2
->u64
;
936 res
->dval
= v1
->dval
- v2
->fval
;
939 res
->dval
= v1
->dval
- v2
->dval
;
941 # if HAVE_LONG_DOUBLE
942 case PSI_T_LONG_DOUBLE
:
943 res
->ldval
= v1
->dval
- v2
->ldval
;
944 return PSI_T_LONG_DOUBLE
;
953 case PSI_T_LONG_DOUBLE
:
956 res
->ldval
= v1
->ldval
- v2
->i8
;
957 return PSI_T_LONG_DOUBLE
;
959 res
->ldval
= v1
->ldval
- v2
->u8
;
960 return PSI_T_LONG_DOUBLE
;
962 res
->ldval
= v1
->ldval
- v2
->i16
;
963 return PSI_T_LONG_DOUBLE
;
965 res
->ldval
= v1
->ldval
- v2
->u16
;
966 return PSI_T_LONG_DOUBLE
;
968 res
->ldval
= v1
->ldval
- v2
->i32
;
969 return PSI_T_LONG_DOUBLE
;
971 res
->ldval
= v1
->ldval
- v2
->u32
;
972 return PSI_T_LONG_DOUBLE
;
974 res
->ldval
= v1
->ldval
- v2
->i64
;
975 return PSI_T_LONG_DOUBLE
;
977 res
->ldval
= v1
->ldval
- v2
->u64
;
978 return PSI_T_LONG_DOUBLE
;
980 res
->ldval
= v1
->ldval
- v2
->fval
;
981 return PSI_T_LONG_DOUBLE
;
983 res
->ldval
= v1
->ldval
- v2
->dval
;
984 return PSI_T_LONG_DOUBLE
;
985 # if HAVE_LONG_DOUBLE
986 case PSI_T_LONG_DOUBLE
:
987 res
->ldval
= v1
->ldval
- v2
->ldval
;
988 return PSI_T_LONG_DOUBLE
;
1005 static inline token_t
psi_calc_mul(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
1012 res
->i16
= v1
->i8
* v2
->i8
;
1015 res
->i16
= v1
->i8
* v2
->u8
;
1018 res
->i32
= v1
->i8
* v2
->i16
;
1021 res
->i32
= v1
->i8
* v2
->u16
;
1024 res
->i64
= v1
->i8
* v2
->i32
;
1027 res
->i64
= v1
->i8
* v2
->u32
;
1030 res
->i64
= v1
->i8
* v2
->i64
;
1033 res
->i64
= v1
->i8
* v2
->u64
;
1036 res
->fval
= v1
->i8
* v2
->fval
;
1039 res
->dval
= v1
->i8
* v2
->dval
;
1040 return PSI_T_DOUBLE
;
1041 # if HAVE_LONG_DOUBLE
1042 case PSI_T_LONG_DOUBLE
:
1043 res
->ldval
= v1
->i8
* v2
->ldval
;
1044 return PSI_T_LONG_DOUBLE
;
1055 res
->i16
= v1
->u8
* v2
->i8
;
1058 res
->u16
= v1
->u8
* v2
->u8
;
1059 return PSI_T_UINT16
;
1061 res
->i32
= v1
->u8
* v2
->i16
;
1064 res
->u32
= v1
->u8
* v2
->u16
;
1065 return PSI_T_UINT32
;
1067 res
->i64
= v1
->u8
* v2
->i32
;
1070 res
->u64
= v1
->u8
* v2
->u32
;
1071 return PSI_T_UINT64
;
1073 res
->i64
= v1
->u8
* v2
->i64
;
1076 res
->u64
= v1
->u8
* v2
->u64
;
1077 return PSI_T_UINT64
;
1079 res
->fval
= v1
->u8
* v2
->fval
;
1082 res
->dval
= v1
->u8
* v2
->dval
;
1083 return PSI_T_DOUBLE
;
1084 # if HAVE_LONG_DOUBLE
1085 case PSI_T_LONG_DOUBLE
:
1086 res
->ldval
= v1
->u8
* v2
->ldval
;
1087 return PSI_T_LONG_DOUBLE
;
1098 res
->i32
= v1
->i16
* v2
->i8
;
1101 res
->i32
= v1
->i16
* v2
->u8
;
1104 res
->i32
= v1
->i16
* v2
->i16
;
1107 res
->i32
= v1
->i16
* v2
->u16
;
1110 res
->i64
= v1
->i16
* v2
->i32
;
1113 res
->i64
= v1
->i16
* v2
->u32
;
1116 res
->i64
= v1
->i16
* v2
->i64
;
1119 res
->i64
= v1
->i16
* v2
->u64
;
1122 res
->fval
= v1
->i16
* v2
->fval
;
1125 res
->dval
= v1
->i16
* v2
->dval
;
1126 return PSI_T_DOUBLE
;
1127 # if HAVE_LONG_DOUBLE
1128 case PSI_T_LONG_DOUBLE
:
1129 res
->ldval
= v1
->i16
* v2
->ldval
;
1130 return PSI_T_LONG_DOUBLE
;
1141 res
->i32
= v1
->u16
* v2
->i8
;
1144 res
->u32
= v1
->u16
* v2
->u8
;
1145 return PSI_T_UINT32
;
1147 res
->i32
= v1
->u16
* v2
->i16
;
1150 res
->u32
= v1
->u16
* v2
->u16
;
1151 return PSI_T_UINT32
;
1153 res
->i64
= v1
->u16
* v2
->i32
;
1156 res
->u64
= v1
->u16
* v2
->u32
;
1157 return PSI_T_UINT64
;
1159 res
->i64
= v1
->u16
* v2
->i64
;
1162 res
->u64
= v1
->u16
* v2
->u64
;
1163 return PSI_T_UINT64
;
1165 res
->fval
= v1
->u16
* v2
->fval
;
1168 res
->dval
= v1
->u16
* v2
->dval
;
1169 return PSI_T_DOUBLE
;
1170 # if HAVE_LONG_DOUBLE
1171 case PSI_T_LONG_DOUBLE
:
1172 res
->ldval
= v1
->u16
* v2
->ldval
;
1173 return PSI_T_LONG_DOUBLE
;
1184 res
->i64
= v1
->i32
* v2
->i8
;
1187 res
->i64
= v1
->i32
* v2
->u8
;
1190 res
->i64
= v1
->i32
* v2
->i16
;
1193 res
->i64
= v1
->i32
* v2
->u16
;
1196 res
->i64
= v1
->i32
* v2
->i32
;
1199 res
->i64
= v1
->i32
* v2
->u32
;
1202 res
->i64
= v1
->i32
* v2
->i64
;
1205 res
->i64
= v1
->i32
* v2
->u64
;
1208 res
->fval
= v1
->i32
* v2
->fval
;
1211 res
->dval
= v1
->i32
* v2
->dval
;
1212 return PSI_T_DOUBLE
;
1213 # if HAVE_LONG_DOUBLE
1214 case PSI_T_LONG_DOUBLE
:
1215 res
->ldval
= v1
->i32
* v2
->ldval
;
1216 return PSI_T_LONG_DOUBLE
;
1227 res
->i64
= v1
->u32
* v2
->i8
;
1230 res
->u64
= v1
->u32
* v2
->u8
;
1231 return PSI_T_UINT64
;
1233 res
->i64
= v1
->u32
* v2
->i16
;
1236 res
->u64
= v1
->u32
* v2
->u16
;
1237 return PSI_T_UINT64
;
1239 res
->i64
= v1
->u32
* v2
->i32
;
1242 res
->u64
= v1
->u32
* v2
->u32
;
1243 return PSI_T_UINT64
;
1245 res
->i64
= v1
->u32
* v2
->i64
;
1248 res
->u64
= v1
->u32
* v2
->u64
;
1249 return PSI_T_UINT64
;
1251 res
->fval
= v1
->u32
* v2
->fval
;
1254 res
->dval
= v1
->u32
* v2
->dval
;
1255 return PSI_T_DOUBLE
;
1256 # if HAVE_LONG_DOUBLE
1257 case PSI_T_LONG_DOUBLE
:
1258 res
->ldval
= v1
->u32
* v2
->ldval
;
1259 return PSI_T_LONG_DOUBLE
;
1270 res
->i64
= v1
->i64
* v2
->i8
;
1273 res
->i64
= v1
->i64
* v2
->u8
;
1276 res
->i64
= v1
->i64
* v2
->i16
;
1279 res
->i64
= v1
->i64
* v2
->u16
;
1282 res
->i64
= v1
->i64
* v2
->i32
;
1285 res
->i64
= v1
->i64
* v2
->u32
;
1288 res
->i64
= v1
->i64
* v2
->i64
;
1291 res
->i64
= v1
->i64
* v2
->u64
;
1294 res
->fval
= v1
->i64
* v2
->fval
;
1297 res
->dval
= v1
->i64
* v2
->dval
;
1298 return PSI_T_DOUBLE
;
1299 # if HAVE_LONG_DOUBLE
1300 case PSI_T_LONG_DOUBLE
:
1301 res
->ldval
= v1
->i64
* v2
->ldval
;
1302 return PSI_T_LONG_DOUBLE
;
1313 res
->i64
= v1
->u64
* v2
->i8
;
1316 res
->u64
= v1
->u64
* v2
->u8
;
1317 return PSI_T_UINT64
;
1319 res
->i64
= v1
->u64
* v2
->i16
;
1322 res
->u64
= v1
->u64
* v2
->u16
;
1323 return PSI_T_UINT64
;
1325 res
->i64
= v1
->u64
* v2
->i32
;
1328 res
->u64
= v1
->u64
* v2
->u32
;
1329 return PSI_T_UINT64
;
1331 res
->i64
= v1
->u64
* v2
->i64
;
1334 res
->u64
= v1
->u64
* v2
->u64
;
1335 return PSI_T_UINT64
;
1337 res
->fval
= v1
->u64
* v2
->fval
;
1340 res
->dval
= v1
->u64
* v2
->dval
;
1341 return PSI_T_DOUBLE
;
1342 # if HAVE_LONG_DOUBLE
1343 case PSI_T_LONG_DOUBLE
:
1344 res
->ldval
= v1
->u64
* v2
->ldval
;
1345 return PSI_T_LONG_DOUBLE
;
1356 res
->fval
= v1
->fval
* v2
->i8
;
1359 res
->fval
= v1
->fval
* v2
->u8
;
1362 res
->fval
= v1
->fval
* v2
->i16
;
1365 res
->fval
= v1
->fval
* v2
->u16
;
1368 res
->fval
= v1
->fval
* v2
->i32
;
1371 res
->fval
= v1
->fval
* v2
->u32
;
1374 res
->fval
= v1
->fval
* v2
->i64
;
1377 res
->fval
= v1
->fval
* v2
->u64
;
1380 res
->fval
= v1
->fval
* v2
->fval
;
1383 res
->dval
= v1
->fval
* v2
->dval
;
1384 return PSI_T_DOUBLE
;
1385 # if HAVE_LONG_DOUBLE
1386 case PSI_T_LONG_DOUBLE
:
1387 res
->ldval
= v1
->fval
* v2
->ldval
;
1388 return PSI_T_LONG_DOUBLE
;
1399 res
->dval
= v1
->dval
* v2
->i8
;
1400 return PSI_T_DOUBLE
;
1402 res
->dval
= v1
->dval
* v2
->u8
;
1403 return PSI_T_DOUBLE
;
1405 res
->dval
= v1
->dval
* v2
->i16
;
1406 return PSI_T_DOUBLE
;
1408 res
->dval
= v1
->dval
* v2
->u16
;
1409 return PSI_T_DOUBLE
;
1411 res
->dval
= v1
->dval
* v2
->i32
;
1412 return PSI_T_DOUBLE
;
1414 res
->dval
= v1
->dval
* v2
->u32
;
1415 return PSI_T_DOUBLE
;
1417 res
->dval
= v1
->dval
* v2
->i64
;
1418 return PSI_T_DOUBLE
;
1420 res
->dval
= v1
->dval
* v2
->u64
;
1421 return PSI_T_DOUBLE
;
1423 res
->dval
= v1
->dval
* v2
->fval
;
1424 return PSI_T_DOUBLE
;
1426 res
->dval
= v1
->dval
* v2
->dval
;
1427 return PSI_T_DOUBLE
;
1428 # if HAVE_LONG_DOUBLE
1429 case PSI_T_LONG_DOUBLE
:
1430 res
->ldval
= v1
->dval
* v2
->ldval
;
1431 return PSI_T_LONG_DOUBLE
;
1439 #if HAVE_LONG_DOUBLE
1440 case PSI_T_LONG_DOUBLE
:
1443 res
->ldval
= v1
->ldval
* v2
->i8
;
1444 return PSI_T_LONG_DOUBLE
;
1446 res
->ldval
= v1
->ldval
* v2
->u8
;
1447 return PSI_T_LONG_DOUBLE
;
1449 res
->ldval
= v1
->ldval
* v2
->i16
;
1450 return PSI_T_LONG_DOUBLE
;
1452 res
->ldval
= v1
->ldval
* v2
->u16
;
1453 return PSI_T_LONG_DOUBLE
;
1455 res
->ldval
= v1
->ldval
* v2
->i32
;
1456 return PSI_T_LONG_DOUBLE
;
1458 res
->ldval
= v1
->ldval
* v2
->u32
;
1459 return PSI_T_LONG_DOUBLE
;
1461 res
->ldval
= v1
->ldval
* v2
->i64
;
1462 return PSI_T_LONG_DOUBLE
;
1464 res
->ldval
= v1
->ldval
* v2
->u64
;
1465 return PSI_T_LONG_DOUBLE
;
1467 res
->ldval
= v1
->ldval
* v2
->fval
;
1468 return PSI_T_LONG_DOUBLE
;
1470 res
->ldval
= v1
->ldval
* v2
->dval
;
1471 return PSI_T_LONG_DOUBLE
;
1472 # if HAVE_LONG_DOUBLE
1473 case PSI_T_LONG_DOUBLE
:
1474 res
->ldval
= v1
->ldval
* v2
->ldval
;
1475 return PSI_T_LONG_DOUBLE
;
1492 static inline token_t
psi_calc_div(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
1499 res
->i16
= v1
->i8
/ v2
->i8
;
1502 res
->i16
= v1
->i8
/ v2
->u8
;
1505 res
->i32
= v1
->i8
/ v2
->i16
;
1508 res
->i32
= v1
->i8
/ v2
->u16
;
1511 res
->i64
= v1
->i8
/ v2
->i32
;
1514 res
->i64
= v1
->i8
/ v2
->u32
;
1517 res
->i64
= v1
->i8
/ v2
->i64
;
1520 res
->i64
= v1
->i8
/ v2
->u64
;
1523 res
->fval
= v1
->i8
/ v2
->fval
;
1526 res
->dval
= v1
->i8
/ v2
->dval
;
1527 return PSI_T_DOUBLE
;
1528 # if HAVE_LONG_DOUBLE
1529 case PSI_T_LONG_DOUBLE
:
1530 res
->ldval
= v1
->i8
/ v2
->ldval
;
1531 return PSI_T_LONG_DOUBLE
;
1542 res
->i16
= v1
->u8
/ v2
->i8
;
1545 res
->u16
= v1
->u8
/ v2
->u8
;
1546 return PSI_T_UINT16
;
1548 res
->i32
= v1
->u8
/ v2
->i16
;
1551 res
->u32
= v1
->u8
/ v2
->u16
;
1552 return PSI_T_UINT32
;
1554 res
->i64
= v1
->u8
/ v2
->i32
;
1557 res
->u64
= v1
->u8
/ v2
->u32
;
1558 return PSI_T_UINT64
;
1560 res
->i64
= v1
->u8
/ v2
->i64
;
1563 res
->u64
= v1
->u8
/ v2
->u64
;
1564 return PSI_T_UINT64
;
1566 res
->fval
= v1
->u8
/ v2
->fval
;
1569 res
->dval
= v1
->u8
/ v2
->dval
;
1570 return PSI_T_DOUBLE
;
1571 # if HAVE_LONG_DOUBLE
1572 case PSI_T_LONG_DOUBLE
:
1573 res
->ldval
= v1
->u8
/ v2
->ldval
;
1574 return PSI_T_LONG_DOUBLE
;
1585 res
->i32
= v1
->i16
/ v2
->i8
;
1588 res
->i32
= v1
->i16
/ v2
->u8
;
1591 res
->i32
= v1
->i16
/ v2
->i16
;
1594 res
->i32
= v1
->i16
/ v2
->u16
;
1597 res
->i64
= v1
->i16
/ v2
->i32
;
1600 res
->i64
= v1
->i16
/ v2
->u32
;
1603 res
->i64
= v1
->i16
/ v2
->i64
;
1606 res
->i64
= v1
->i16
/ v2
->u64
;
1609 res
->fval
= v1
->i16
/ v2
->fval
;
1612 res
->dval
= v1
->i16
/ v2
->dval
;
1613 return PSI_T_DOUBLE
;
1614 # if HAVE_LONG_DOUBLE
1615 case PSI_T_LONG_DOUBLE
:
1616 res
->ldval
= v1
->i16
/ v2
->ldval
;
1617 return PSI_T_LONG_DOUBLE
;
1628 res
->i32
= v1
->u16
/ v2
->i8
;
1631 res
->u32
= v1
->u16
/ v2
->u8
;
1632 return PSI_T_UINT32
;
1634 res
->i32
= v1
->u16
/ v2
->i16
;
1637 res
->u32
= v1
->u16
/ v2
->u16
;
1638 return PSI_T_UINT32
;
1640 res
->i64
= v1
->u16
/ v2
->i32
;
1643 res
->u64
= v1
->u16
/ v2
->u32
;
1644 return PSI_T_UINT64
;
1646 res
->i64
= v1
->u16
/ v2
->i64
;
1649 res
->u64
= v1
->u16
/ v2
->u64
;
1650 return PSI_T_UINT64
;
1652 res
->fval
= v1
->u16
/ v2
->fval
;
1655 res
->dval
= v1
->u16
/ v2
->dval
;
1656 return PSI_T_DOUBLE
;
1657 # if HAVE_LONG_DOUBLE
1658 case PSI_T_LONG_DOUBLE
:
1659 res
->ldval
= v1
->u16
/ v2
->ldval
;
1660 return PSI_T_LONG_DOUBLE
;
1671 res
->i64
= v1
->i32
/ v2
->i8
;
1674 res
->i64
= v1
->i32
/ v2
->u8
;
1677 res
->i64
= v1
->i32
/ v2
->i16
;
1680 res
->i64
= v1
->i32
/ v2
->u16
;
1683 res
->i64
= v1
->i32
/ v2
->i32
;
1686 res
->i64
= v1
->i32
/ v2
->u32
;
1689 res
->i64
= v1
->i32
/ v2
->i64
;
1692 res
->i64
= v1
->i32
/ v2
->u64
;
1695 res
->fval
= v1
->i32
/ v2
->fval
;
1698 res
->dval
= v1
->i32
/ v2
->dval
;
1699 return PSI_T_DOUBLE
;
1700 # if HAVE_LONG_DOUBLE
1701 case PSI_T_LONG_DOUBLE
:
1702 res
->ldval
= v1
->i32
/ v2
->ldval
;
1703 return PSI_T_LONG_DOUBLE
;
1714 res
->i64
= v1
->u32
/ v2
->i8
;
1717 res
->u64
= v1
->u32
/ v2
->u8
;
1718 return PSI_T_UINT64
;
1720 res
->i64
= v1
->u32
/ v2
->i16
;
1723 res
->u64
= v1
->u32
/ v2
->u16
;
1724 return PSI_T_UINT64
;
1726 res
->i64
= v1
->u32
/ v2
->i32
;
1729 res
->u64
= v1
->u32
/ v2
->u32
;
1730 return PSI_T_UINT64
;
1732 res
->i64
= v1
->u32
/ v2
->i64
;
1735 res
->u64
= v1
->u32
/ v2
->u64
;
1736 return PSI_T_UINT64
;
1738 res
->fval
= v1
->u32
/ v2
->fval
;
1741 res
->dval
= v1
->u32
/ v2
->dval
;
1742 return PSI_T_DOUBLE
;
1743 # if HAVE_LONG_DOUBLE
1744 case PSI_T_LONG_DOUBLE
:
1745 res
->ldval
= v1
->u32
/ v2
->ldval
;
1746 return PSI_T_LONG_DOUBLE
;
1757 res
->i64
= v1
->i64
/ v2
->i8
;
1760 res
->i64
= v1
->i64
/ v2
->u8
;
1763 res
->i64
= v1
->i64
/ v2
->i16
;
1766 res
->i64
= v1
->i64
/ v2
->u16
;
1769 res
->i64
= v1
->i64
/ v2
->i32
;
1772 res
->i64
= v1
->i64
/ v2
->u32
;
1775 res
->i64
= v1
->i64
/ v2
->i64
;
1778 res
->i64
= v1
->i64
/ v2
->u64
;
1781 res
->fval
= v1
->i64
/ v2
->fval
;
1784 res
->dval
= v1
->i64
/ v2
->dval
;
1785 return PSI_T_DOUBLE
;
1786 # if HAVE_LONG_DOUBLE
1787 case PSI_T_LONG_DOUBLE
:
1788 res
->ldval
= v1
->i64
/ v2
->ldval
;
1789 return PSI_T_LONG_DOUBLE
;
1800 res
->i64
= v1
->u64
/ v2
->i8
;
1803 res
->u64
= v1
->u64
/ v2
->u8
;
1804 return PSI_T_UINT64
;
1806 res
->i64
= v1
->u64
/ v2
->i16
;
1809 res
->u64
= v1
->u64
/ v2
->u16
;
1810 return PSI_T_UINT64
;
1812 res
->i64
= v1
->u64
/ v2
->i32
;
1815 res
->u64
= v1
->u64
/ v2
->u32
;
1816 return PSI_T_UINT64
;
1818 res
->i64
= v1
->u64
/ v2
->i64
;
1821 res
->u64
= v1
->u64
/ v2
->u64
;
1822 return PSI_T_UINT64
;
1824 res
->fval
= v1
->u64
/ v2
->fval
;
1827 res
->dval
= v1
->u64
/ v2
->dval
;
1828 return PSI_T_DOUBLE
;
1829 # if HAVE_LONG_DOUBLE
1830 case PSI_T_LONG_DOUBLE
:
1831 res
->ldval
= v1
->u64
/ v2
->ldval
;
1832 return PSI_T_LONG_DOUBLE
;
1843 res
->fval
= v1
->fval
/ v2
->i8
;
1846 res
->fval
= v1
->fval
/ v2
->u8
;
1849 res
->fval
= v1
->fval
/ v2
->i16
;
1852 res
->fval
= v1
->fval
/ v2
->u16
;
1855 res
->fval
= v1
->fval
/ v2
->i32
;
1858 res
->fval
= v1
->fval
/ v2
->u32
;
1861 res
->fval
= v1
->fval
/ v2
->i64
;
1864 res
->fval
= v1
->fval
/ v2
->u64
;
1867 res
->fval
= v1
->fval
/ v2
->fval
;
1870 res
->dval
= v1
->fval
/ v2
->dval
;
1871 return PSI_T_DOUBLE
;
1872 # if HAVE_LONG_DOUBLE
1873 case PSI_T_LONG_DOUBLE
:
1874 res
->ldval
= v1
->fval
/ v2
->ldval
;
1875 return PSI_T_LONG_DOUBLE
;
1886 res
->dval
= v1
->dval
/ v2
->i8
;
1887 return PSI_T_DOUBLE
;
1889 res
->dval
= v1
->dval
/ v2
->u8
;
1890 return PSI_T_DOUBLE
;
1892 res
->dval
= v1
->dval
/ v2
->i16
;
1893 return PSI_T_DOUBLE
;
1895 res
->dval
= v1
->dval
/ v2
->u16
;
1896 return PSI_T_DOUBLE
;
1898 res
->dval
= v1
->dval
/ v2
->i32
;
1899 return PSI_T_DOUBLE
;
1901 res
->dval
= v1
->dval
/ v2
->u32
;
1902 return PSI_T_DOUBLE
;
1904 res
->dval
= v1
->dval
/ v2
->i64
;
1905 return PSI_T_DOUBLE
;
1907 res
->dval
= v1
->dval
/ v2
->u64
;
1908 return PSI_T_DOUBLE
;
1910 res
->dval
= v1
->dval
/ v2
->fval
;
1911 return PSI_T_DOUBLE
;
1913 res
->dval
= v1
->dval
/ v2
->dval
;
1914 return PSI_T_DOUBLE
;
1915 # if HAVE_LONG_DOUBLE
1916 case PSI_T_LONG_DOUBLE
:
1917 res
->ldval
= v1
->dval
/ v2
->ldval
;
1918 return PSI_T_LONG_DOUBLE
;
1926 #if HAVE_LONG_DOUBLE
1927 case PSI_T_LONG_DOUBLE
:
1930 res
->ldval
= v1
->ldval
/ v2
->i8
;
1931 return PSI_T_LONG_DOUBLE
;
1933 res
->ldval
= v1
->ldval
/ v2
->u8
;
1934 return PSI_T_LONG_DOUBLE
;
1936 res
->ldval
= v1
->ldval
/ v2
->i16
;
1937 return PSI_T_LONG_DOUBLE
;
1939 res
->ldval
= v1
->ldval
/ v2
->u16
;
1940 return PSI_T_LONG_DOUBLE
;
1942 res
->ldval
= v1
->ldval
/ v2
->i32
;
1943 return PSI_T_LONG_DOUBLE
;
1945 res
->ldval
= v1
->ldval
/ v2
->u32
;
1946 return PSI_T_LONG_DOUBLE
;
1948 res
->ldval
= v1
->ldval
/ v2
->i64
;
1949 return PSI_T_LONG_DOUBLE
;
1951 res
->ldval
= v1
->ldval
/ v2
->u64
;
1952 return PSI_T_LONG_DOUBLE
;
1954 res
->ldval
= v1
->ldval
/ v2
->fval
;
1955 return PSI_T_LONG_DOUBLE
;
1957 res
->ldval
= v1
->ldval
/ v2
->dval
;
1958 return PSI_T_LONG_DOUBLE
;
1959 # if HAVE_LONG_DOUBLE
1960 case PSI_T_LONG_DOUBLE
:
1961 res
->ldval
= v1
->ldval
/ v2
->ldval
;
1962 return PSI_T_LONG_DOUBLE
;
1981 static inline token_t
psi_calc_mod(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
2026 #if HAVE_LONG_DOUBLE
2027 case PSI_T_LONG_DOUBLE
:
2069 #if HAVE_LONG_DOUBLE
2070 case PSI_T_LONG_DOUBLE
:
2080 res
->i64
= i1
.i64
% i2
.i64
;