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 *******************************************************************************/
30 static inline token_t
psi_calc_add(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
37 res
->i16
= v1
->i8
+ v2
->i8
;
40 res
->i16
= v1
->i8
+ v2
->u8
;
43 res
->i32
= v1
->i8
+ v2
->i16
;
46 res
->i32
= v1
->i8
+ v2
->u16
;
49 res
->i64
= v1
->i8
+ v2
->i32
;
52 res
->i64
= v1
->i8
+ v2
->u32
;
55 res
->i64
= v1
->i8
+ v2
->i64
;
58 res
->i64
= v1
->i8
+ v2
->u64
;
62 res
->i128
= v1
->i8
+ v2
->i128
;
68 res
->u128
= v1
->i8
+ v2
->u128
;
73 res
->fval
= v1
->i8
+ v2
->fval
;
76 res
->dval
= v1
->i8
+ v2
->dval
;
79 case PSI_T_LONG_DOUBLE
:
80 res
->ldval
= v1
->i8
+ v2
->ldval
;
81 return PSI_T_LONG_DOUBLE
;
92 res
->i16
= v1
->u8
+ v2
->i8
;
95 res
->u16
= v1
->u8
+ v2
->u8
;
98 res
->i32
= v1
->u8
+ v2
->i16
;
101 res
->u32
= v1
->u8
+ v2
->u16
;
104 res
->i64
= v1
->u8
+ v2
->i32
;
107 res
->u64
= v1
->u8
+ v2
->u32
;
110 res
->i64
= v1
->u8
+ v2
->i64
;
113 res
->u64
= v1
->u8
+ v2
->u64
;
117 res
->i128
= v1
->u8
+ v2
->i128
;
123 res
->u128
= v1
->u8
+ v2
->u128
;
124 return PSI_T_UINT128
;
128 res
->fval
= v1
->u8
+ v2
->fval
;
131 res
->dval
= v1
->u8
+ v2
->dval
;
133 # if HAVE_LONG_DOUBLE
134 case PSI_T_LONG_DOUBLE
:
135 res
->ldval
= v1
->u8
+ v2
->ldval
;
136 return PSI_T_LONG_DOUBLE
;
147 res
->i32
= v1
->i16
+ v2
->i8
;
150 res
->i32
= v1
->i16
+ v2
->u8
;
153 res
->i32
= v1
->i16
+ v2
->i16
;
156 res
->i32
= v1
->i16
+ v2
->u16
;
159 res
->i64
= v1
->i16
+ v2
->i32
;
162 res
->i64
= v1
->i16
+ v2
->u32
;
165 res
->i64
= v1
->i16
+ v2
->i64
;
168 res
->i64
= v1
->i16
+ v2
->u64
;
172 res
->i128
= v1
->i16
+ v2
->i128
;
178 res
->u128
= v1
->i16
+ v2
->u128
;
179 return PSI_T_UINT128
;
183 res
->fval
= v1
->i16
+ v2
->fval
;
186 res
->dval
= v1
->i16
+ v2
->dval
;
188 # if HAVE_LONG_DOUBLE
189 case PSI_T_LONG_DOUBLE
:
190 res
->ldval
= v1
->i16
+ v2
->ldval
;
191 return PSI_T_LONG_DOUBLE
;
202 res
->i32
= v1
->u16
+ v2
->i8
;
205 res
->u32
= v1
->u16
+ v2
->u8
;
208 res
->i32
= v1
->u16
+ v2
->i16
;
211 res
->u32
= v1
->u16
+ v2
->u16
;
214 res
->i64
= v1
->u16
+ v2
->i32
;
217 res
->u64
= v1
->u16
+ v2
->u32
;
220 res
->i64
= v1
->u16
+ v2
->i64
;
223 res
->u64
= v1
->u16
+ v2
->u64
;
227 res
->i128
= v1
->u16
+ v2
->i128
;
233 res
->u128
= v1
->u16
+ v2
->u128
;
234 return PSI_T_UINT128
;
238 res
->fval
= v1
->u16
+ v2
->fval
;
241 res
->dval
= v1
->u16
+ v2
->dval
;
243 # if HAVE_LONG_DOUBLE
244 case PSI_T_LONG_DOUBLE
:
245 res
->ldval
= v1
->u16
+ v2
->ldval
;
246 return PSI_T_LONG_DOUBLE
;
257 res
->i64
= v1
->i32
+ v2
->i8
;
260 res
->i64
= v1
->i32
+ v2
->u8
;
263 res
->i64
= v1
->i32
+ v2
->i16
;
266 res
->i64
= v1
->i32
+ v2
->u16
;
269 res
->i64
= v1
->i32
+ v2
->i32
;
272 res
->i64
= v1
->i32
+ v2
->u32
;
275 res
->i64
= v1
->i32
+ v2
->i64
;
278 res
->i64
= v1
->i32
+ v2
->u64
;
282 res
->i128
= v1
->i32
+ v2
->i128
;
288 res
->u128
= v1
->i32
+ v2
->u128
;
289 return PSI_T_UINT128
;
293 res
->fval
= v1
->i32
+ v2
->fval
;
296 res
->dval
= v1
->i32
+ v2
->dval
;
298 # if HAVE_LONG_DOUBLE
299 case PSI_T_LONG_DOUBLE
:
300 res
->ldval
= v1
->i32
+ v2
->ldval
;
301 return PSI_T_LONG_DOUBLE
;
312 res
->i64
= v1
->u32
+ v2
->i8
;
315 res
->u64
= v1
->u32
+ v2
->u8
;
318 res
->i64
= v1
->u32
+ v2
->i16
;
321 res
->u64
= v1
->u32
+ v2
->u16
;
324 res
->i64
= v1
->u32
+ v2
->i32
;
327 res
->u64
= v1
->u32
+ v2
->u32
;
330 res
->i64
= v1
->u32
+ v2
->i64
;
333 res
->u64
= v1
->u32
+ v2
->u64
;
337 res
->i128
= v1
->u32
+ v2
->i128
;
343 res
->u128
= v1
->u32
+ v2
->u128
;
344 return PSI_T_UINT128
;
348 res
->fval
= v1
->u32
+ v2
->fval
;
351 res
->dval
= v1
->u32
+ v2
->dval
;
353 # if HAVE_LONG_DOUBLE
354 case PSI_T_LONG_DOUBLE
:
355 res
->ldval
= v1
->u32
+ v2
->ldval
;
356 return PSI_T_LONG_DOUBLE
;
367 res
->i64
= v1
->i64
+ v2
->i8
;
370 res
->i64
= v1
->i64
+ v2
->u8
;
373 res
->i64
= v1
->i64
+ v2
->i16
;
376 res
->i64
= v1
->i64
+ v2
->u16
;
379 res
->i64
= v1
->i64
+ v2
->i32
;
382 res
->i64
= v1
->i64
+ v2
->u32
;
385 res
->i64
= v1
->i64
+ v2
->i64
;
388 res
->i64
= v1
->i64
+ v2
->u64
;
392 res
->i128
= v1
->i64
+ v2
->i128
;
398 res
->u128
= v1
->i64
+ v2
->u128
;
399 return PSI_T_UINT128
;
403 res
->fval
= v1
->i64
+ v2
->fval
;
406 res
->dval
= v1
->i64
+ v2
->dval
;
408 # if HAVE_LONG_DOUBLE
409 case PSI_T_LONG_DOUBLE
:
410 res
->ldval
= v1
->i64
+ v2
->ldval
;
411 return PSI_T_LONG_DOUBLE
;
422 res
->i64
= v1
->u64
+ v2
->i8
;
425 res
->u64
= v1
->u64
+ v2
->u8
;
428 res
->i64
= v1
->u64
+ v2
->i16
;
431 res
->u64
= v1
->u64
+ v2
->u16
;
434 res
->i64
= v1
->u64
+ v2
->i32
;
437 res
->u64
= v1
->u64
+ v2
->u32
;
440 res
->i64
= v1
->u64
+ v2
->i64
;
443 res
->u64
= v1
->u64
+ v2
->u64
;
447 res
->i128
= v1
->u64
+ v2
->i128
;
453 res
->u128
= v1
->u64
+ v2
->u128
;
454 return PSI_T_UINT128
;
458 res
->fval
= v1
->u64
+ v2
->fval
;
461 res
->dval
= v1
->u64
+ v2
->dval
;
463 # if HAVE_LONG_DOUBLE
464 case PSI_T_LONG_DOUBLE
:
465 res
->ldval
= v1
->u64
+ v2
->ldval
;
466 return PSI_T_LONG_DOUBLE
;
478 res
->i128
= v1
->i128
+ v2
->i8
;
481 res
->i128
= v1
->i128
+ v2
->u8
;
484 res
->i128
= v1
->i128
+ v2
->i16
;
487 res
->i128
= v1
->i128
+ v2
->u16
;
490 res
->i128
= v1
->i128
+ v2
->i32
;
493 res
->i128
= v1
->i128
+ v2
->u32
;
496 res
->i128
= v1
->i128
+ v2
->i64
;
499 res
->i128
= v1
->i128
+ v2
->u64
;
503 res
->i128
= v1
->i128
+ v2
->i128
;
509 res
->u128
= v1
->i128
+ v2
->u128
;
510 return PSI_T_UINT128
;
514 res
->fval
= v1
->i128
+ v2
->fval
;
517 res
->dval
= v1
->i128
+ v2
->dval
;
519 # if HAVE_LONG_DOUBLE
520 case PSI_T_LONG_DOUBLE
:
521 res
->ldval
= v1
->i128
+ v2
->ldval
;
522 return PSI_T_LONG_DOUBLE
;
536 res
->u128
= v1
->u128
+ v2
->i8
;
537 return PSI_T_UINT128
;
539 res
->u128
= v1
->u128
+ v2
->u8
;
540 return PSI_T_UINT128
;
542 res
->u128
= v1
->u128
+ v2
->i16
;
543 return PSI_T_UINT128
;
545 res
->u128
= v1
->u128
+ v2
->u16
;
546 return PSI_T_UINT128
;
548 res
->u128
= v1
->u128
+ v2
->i32
;
549 return PSI_T_UINT128
;
551 res
->u128
= v1
->u128
+ v2
->u32
;
552 return PSI_T_UINT128
;
554 res
->u128
= v1
->u128
+ v2
->i64
;
555 return PSI_T_UINT128
;
557 res
->u128
= v1
->u128
+ v2
->u64
;
558 return PSI_T_UINT128
;
561 res
->u128
= v1
->u128
+ v2
->i128
;
562 return PSI_T_UINT128
;
567 res
->u128
= v1
->u128
+ v2
->u128
;
568 return PSI_T_UINT128
;
572 res
->fval
= v1
->u128
+ v2
->fval
;
575 res
->dval
= v1
->u128
+ v2
->dval
;
577 # if HAVE_LONG_DOUBLE
578 case PSI_T_LONG_DOUBLE
:
579 res
->ldval
= v1
->u128
+ v2
->ldval
;
580 return PSI_T_LONG_DOUBLE
;
593 res
->fval
= v1
->fval
+ v2
->i8
;
596 res
->fval
= v1
->fval
+ v2
->u8
;
599 res
->fval
= v1
->fval
+ v2
->i16
;
602 res
->fval
= v1
->fval
+ v2
->u16
;
605 res
->fval
= v1
->fval
+ v2
->i32
;
608 res
->fval
= v1
->fval
+ v2
->u32
;
611 res
->fval
= v1
->fval
+ v2
->i64
;
614 res
->fval
= v1
->fval
+ v2
->u64
;
618 res
->fval
= v1
->fval
+ v2
->i128
;
624 res
->fval
= v1
->fval
+ v2
->u128
;
629 res
->fval
= v1
->fval
+ v2
->fval
;
632 res
->dval
= v1
->fval
+ v2
->dval
;
634 # if HAVE_LONG_DOUBLE
635 case PSI_T_LONG_DOUBLE
:
636 res
->ldval
= v1
->fval
+ v2
->ldval
;
637 return PSI_T_LONG_DOUBLE
;
648 res
->dval
= v1
->dval
+ v2
->i8
;
651 res
->dval
= v1
->dval
+ v2
->u8
;
654 res
->dval
= v1
->dval
+ v2
->i16
;
657 res
->dval
= v1
->dval
+ v2
->u16
;
660 res
->dval
= v1
->dval
+ v2
->i32
;
663 res
->dval
= v1
->dval
+ v2
->u32
;
666 res
->dval
= v1
->dval
+ v2
->i64
;
669 res
->dval
= v1
->dval
+ v2
->u64
;
673 res
->dval
= v1
->dval
+ v2
->i128
;
679 res
->dval
= v1
->dval
+ v2
->u128
;
684 res
->dval
= v1
->dval
+ v2
->fval
;
687 res
->dval
= v1
->dval
+ v2
->dval
;
689 # if HAVE_LONG_DOUBLE
690 case PSI_T_LONG_DOUBLE
:
691 res
->ldval
= v1
->dval
+ v2
->ldval
;
692 return PSI_T_LONG_DOUBLE
;
701 case PSI_T_LONG_DOUBLE
:
704 res
->ldval
= v1
->ldval
+ v2
->i8
;
705 return PSI_T_LONG_DOUBLE
;
707 res
->ldval
= v1
->ldval
+ v2
->u8
;
708 return PSI_T_LONG_DOUBLE
;
710 res
->ldval
= v1
->ldval
+ v2
->i16
;
711 return PSI_T_LONG_DOUBLE
;
713 res
->ldval
= v1
->ldval
+ v2
->u16
;
714 return PSI_T_LONG_DOUBLE
;
716 res
->ldval
= v1
->ldval
+ v2
->i32
;
717 return PSI_T_LONG_DOUBLE
;
719 res
->ldval
= v1
->ldval
+ v2
->u32
;
720 return PSI_T_LONG_DOUBLE
;
722 res
->ldval
= v1
->ldval
+ v2
->i64
;
723 return PSI_T_LONG_DOUBLE
;
725 res
->ldval
= v1
->ldval
+ v2
->u64
;
726 return PSI_T_LONG_DOUBLE
;
729 res
->ldval
= v1
->ldval
+ v2
->i128
;
730 return PSI_T_LONG_DOUBLE
;
735 res
->ldval
= v1
->ldval
+ v2
->u128
;
736 return PSI_T_LONG_DOUBLE
;
740 res
->ldval
= v1
->ldval
+ v2
->fval
;
741 return PSI_T_LONG_DOUBLE
;
743 res
->ldval
= v1
->ldval
+ v2
->dval
;
744 return PSI_T_LONG_DOUBLE
;
745 # if HAVE_LONG_DOUBLE
746 case PSI_T_LONG_DOUBLE
:
747 res
->ldval
= v1
->ldval
+ v2
->ldval
;
748 return PSI_T_LONG_DOUBLE
;
765 static inline token_t
psi_calc_sub(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
772 res
->i16
= v1
->i8
- v2
->i8
;
775 res
->i16
= v1
->i8
- v2
->u8
;
778 res
->i32
= v1
->i8
- v2
->i16
;
781 res
->i32
= v1
->i8
- v2
->u16
;
784 res
->i64
= v1
->i8
- v2
->i32
;
787 res
->i64
= v1
->i8
- v2
->u32
;
790 res
->i64
= v1
->i8
- v2
->i64
;
793 res
->i64
= v1
->i8
- v2
->u64
;
797 res
->i128
= v1
->i8
- v2
->i128
;
803 res
->u128
= v1
->i8
- v2
->u128
;
804 return PSI_T_UINT128
;
808 res
->fval
= v1
->i8
- v2
->fval
;
811 res
->dval
= v1
->i8
- v2
->dval
;
813 # if HAVE_LONG_DOUBLE
814 case PSI_T_LONG_DOUBLE
:
815 res
->ldval
= v1
->i8
- v2
->ldval
;
816 return PSI_T_LONG_DOUBLE
;
827 res
->i16
= v1
->u8
- v2
->i8
;
830 res
->u16
= v1
->u8
- v2
->u8
;
833 res
->i32
= v1
->u8
- v2
->i16
;
836 res
->u32
= v1
->u8
- v2
->u16
;
839 res
->i64
= v1
->u8
- v2
->i32
;
842 res
->u64
= v1
->u8
- v2
->u32
;
845 res
->i64
= v1
->u8
- v2
->i64
;
848 res
->u64
= v1
->u8
- v2
->u64
;
852 res
->i128
= v1
->u8
- v2
->i128
;
858 res
->u128
= v1
->u8
- v2
->u128
;
859 return PSI_T_UINT128
;
863 res
->fval
= v1
->u8
- v2
->fval
;
866 res
->dval
= v1
->u8
- v2
->dval
;
868 # if HAVE_LONG_DOUBLE
869 case PSI_T_LONG_DOUBLE
:
870 res
->ldval
= v1
->u8
- v2
->ldval
;
871 return PSI_T_LONG_DOUBLE
;
882 res
->i32
= v1
->i16
- v2
->i8
;
885 res
->i32
= v1
->i16
- v2
->u8
;
888 res
->i32
= v1
->i16
- v2
->i16
;
891 res
->i32
= v1
->i16
- v2
->u16
;
894 res
->i64
= v1
->i16
- v2
->i32
;
897 res
->i64
= v1
->i16
- v2
->u32
;
900 res
->i64
= v1
->i16
- v2
->i64
;
903 res
->i64
= v1
->i16
- v2
->u64
;
907 res
->i128
= v1
->i16
- v2
->i128
;
913 res
->u128
= v1
->i16
- v2
->u128
;
914 return PSI_T_UINT128
;
918 res
->fval
= v1
->i16
- v2
->fval
;
921 res
->dval
= v1
->i16
- v2
->dval
;
923 # if HAVE_LONG_DOUBLE
924 case PSI_T_LONG_DOUBLE
:
925 res
->ldval
= v1
->i16
- v2
->ldval
;
926 return PSI_T_LONG_DOUBLE
;
937 res
->i32
= v1
->u16
- v2
->i8
;
940 res
->u32
= v1
->u16
- v2
->u8
;
943 res
->i32
= v1
->u16
- v2
->i16
;
946 res
->u32
= v1
->u16
- v2
->u16
;
949 res
->i64
= v1
->u16
- v2
->i32
;
952 res
->u64
= v1
->u16
- v2
->u32
;
955 res
->i64
= v1
->u16
- v2
->i64
;
958 res
->u64
= v1
->u16
- v2
->u64
;
962 res
->i128
= v1
->u16
- v2
->i128
;
968 res
->u128
= v1
->u16
- v2
->u128
;
969 return PSI_T_UINT128
;
973 res
->fval
= v1
->u16
- v2
->fval
;
976 res
->dval
= v1
->u16
- v2
->dval
;
978 # if HAVE_LONG_DOUBLE
979 case PSI_T_LONG_DOUBLE
:
980 res
->ldval
= v1
->u16
- v2
->ldval
;
981 return PSI_T_LONG_DOUBLE
;
992 res
->i64
= v1
->i32
- v2
->i8
;
995 res
->i64
= v1
->i32
- v2
->u8
;
998 res
->i64
= v1
->i32
- v2
->i16
;
1001 res
->i64
= v1
->i32
- v2
->u16
;
1004 res
->i64
= v1
->i32
- v2
->i32
;
1007 res
->i64
= v1
->i32
- v2
->u32
;
1010 res
->i64
= v1
->i32
- v2
->i64
;
1013 res
->i64
= v1
->i32
- v2
->u64
;
1017 res
->i128
= v1
->i32
- v2
->i128
;
1018 return PSI_T_INT128
;
1023 res
->u128
= v1
->i32
- v2
->u128
;
1024 return PSI_T_UINT128
;
1028 res
->fval
= v1
->i32
- v2
->fval
;
1031 res
->dval
= v1
->i32
- v2
->dval
;
1032 return PSI_T_DOUBLE
;
1033 # if HAVE_LONG_DOUBLE
1034 case PSI_T_LONG_DOUBLE
:
1035 res
->ldval
= v1
->i32
- v2
->ldval
;
1036 return PSI_T_LONG_DOUBLE
;
1047 res
->i64
= v1
->u32
- v2
->i8
;
1050 res
->u64
= v1
->u32
- v2
->u8
;
1051 return PSI_T_UINT64
;
1053 res
->i64
= v1
->u32
- v2
->i16
;
1056 res
->u64
= v1
->u32
- v2
->u16
;
1057 return PSI_T_UINT64
;
1059 res
->i64
= v1
->u32
- v2
->i32
;
1062 res
->u64
= v1
->u32
- v2
->u32
;
1063 return PSI_T_UINT64
;
1065 res
->i64
= v1
->u32
- v2
->i64
;
1068 res
->u64
= v1
->u32
- v2
->u64
;
1069 return PSI_T_UINT64
;
1072 res
->i128
= v1
->u32
- v2
->i128
;
1073 return PSI_T_INT128
;
1078 res
->u128
= v1
->u32
- v2
->u128
;
1079 return PSI_T_UINT128
;
1083 res
->fval
= v1
->u32
- v2
->fval
;
1086 res
->dval
= v1
->u32
- v2
->dval
;
1087 return PSI_T_DOUBLE
;
1088 # if HAVE_LONG_DOUBLE
1089 case PSI_T_LONG_DOUBLE
:
1090 res
->ldval
= v1
->u32
- v2
->ldval
;
1091 return PSI_T_LONG_DOUBLE
;
1102 res
->i64
= v1
->i64
- v2
->i8
;
1105 res
->i64
= v1
->i64
- v2
->u8
;
1108 res
->i64
= v1
->i64
- v2
->i16
;
1111 res
->i64
= v1
->i64
- v2
->u16
;
1114 res
->i64
= v1
->i64
- v2
->i32
;
1117 res
->i64
= v1
->i64
- v2
->u32
;
1120 res
->i64
= v1
->i64
- v2
->i64
;
1123 res
->i64
= v1
->i64
- v2
->u64
;
1127 res
->i128
= v1
->i64
- v2
->i128
;
1128 return PSI_T_INT128
;
1133 res
->u128
= v1
->i64
- v2
->u128
;
1134 return PSI_T_UINT128
;
1138 res
->fval
= v1
->i64
- v2
->fval
;
1141 res
->dval
= v1
->i64
- v2
->dval
;
1142 return PSI_T_DOUBLE
;
1143 # if HAVE_LONG_DOUBLE
1144 case PSI_T_LONG_DOUBLE
:
1145 res
->ldval
= v1
->i64
- v2
->ldval
;
1146 return PSI_T_LONG_DOUBLE
;
1157 res
->i64
= v1
->u64
- v2
->i8
;
1160 res
->u64
= v1
->u64
- v2
->u8
;
1161 return PSI_T_UINT64
;
1163 res
->i64
= v1
->u64
- v2
->i16
;
1166 res
->u64
= v1
->u64
- v2
->u16
;
1167 return PSI_T_UINT64
;
1169 res
->i64
= v1
->u64
- v2
->i32
;
1172 res
->u64
= v1
->u64
- v2
->u32
;
1173 return PSI_T_UINT64
;
1175 res
->i64
= v1
->u64
- v2
->i64
;
1178 res
->u64
= v1
->u64
- v2
->u64
;
1179 return PSI_T_UINT64
;
1182 res
->i128
= v1
->u64
- v2
->i128
;
1183 return PSI_T_INT128
;
1188 res
->u128
= v1
->u64
- v2
->u128
;
1189 return PSI_T_UINT128
;
1193 res
->fval
= v1
->u64
- v2
->fval
;
1196 res
->dval
= v1
->u64
- v2
->dval
;
1197 return PSI_T_DOUBLE
;
1198 # if HAVE_LONG_DOUBLE
1199 case PSI_T_LONG_DOUBLE
:
1200 res
->ldval
= v1
->u64
- v2
->ldval
;
1201 return PSI_T_LONG_DOUBLE
;
1213 res
->i128
= v1
->i128
- v2
->i8
;
1214 return PSI_T_INT128
;
1216 res
->i128
= v1
->i128
- v2
->u8
;
1217 return PSI_T_INT128
;
1219 res
->i128
= v1
->i128
- v2
->i16
;
1220 return PSI_T_INT128
;
1222 res
->i128
= v1
->i128
- v2
->u16
;
1223 return PSI_T_INT128
;
1225 res
->i128
= v1
->i128
- v2
->i32
;
1226 return PSI_T_INT128
;
1228 res
->i128
= v1
->i128
- v2
->u32
;
1229 return PSI_T_INT128
;
1231 res
->i128
= v1
->i128
- v2
->i64
;
1232 return PSI_T_INT128
;
1234 res
->i128
= v1
->i128
- v2
->u64
;
1235 return PSI_T_INT128
;
1238 res
->i128
= v1
->i128
- v2
->i128
;
1239 return PSI_T_INT128
;
1244 res
->u128
= v1
->i128
- v2
->u128
;
1245 return PSI_T_UINT128
;
1249 res
->fval
= v1
->i128
- v2
->fval
;
1252 res
->dval
= v1
->i128
- v2
->dval
;
1253 return PSI_T_DOUBLE
;
1254 # if HAVE_LONG_DOUBLE
1255 case PSI_T_LONG_DOUBLE
:
1256 res
->ldval
= v1
->i128
- v2
->ldval
;
1257 return PSI_T_LONG_DOUBLE
;
1271 res
->u128
= v1
->u128
- v2
->i8
;
1272 return PSI_T_UINT128
;
1274 res
->u128
= v1
->u128
- v2
->u8
;
1275 return PSI_T_UINT128
;
1277 res
->u128
= v1
->u128
- v2
->i16
;
1278 return PSI_T_UINT128
;
1280 res
->u128
= v1
->u128
- v2
->u16
;
1281 return PSI_T_UINT128
;
1283 res
->u128
= v1
->u128
- v2
->i32
;
1284 return PSI_T_UINT128
;
1286 res
->u128
= v1
->u128
- v2
->u32
;
1287 return PSI_T_UINT128
;
1289 res
->u128
= v1
->u128
- v2
->i64
;
1290 return PSI_T_UINT128
;
1292 res
->u128
= v1
->u128
- v2
->u64
;
1293 return PSI_T_UINT128
;
1296 res
->u128
= v1
->u128
- v2
->i128
;
1297 return PSI_T_UINT128
;
1302 res
->u128
= v1
->u128
- v2
->u128
;
1303 return PSI_T_UINT128
;
1307 res
->fval
= v1
->u128
- v2
->fval
;
1310 res
->dval
= v1
->u128
- v2
->dval
;
1311 return PSI_T_DOUBLE
;
1312 # if HAVE_LONG_DOUBLE
1313 case PSI_T_LONG_DOUBLE
:
1314 res
->ldval
= v1
->u128
- v2
->ldval
;
1315 return PSI_T_LONG_DOUBLE
;
1328 res
->fval
= v1
->fval
- v2
->i8
;
1331 res
->fval
= v1
->fval
- v2
->u8
;
1334 res
->fval
= v1
->fval
- v2
->i16
;
1337 res
->fval
= v1
->fval
- v2
->u16
;
1340 res
->fval
= v1
->fval
- v2
->i32
;
1343 res
->fval
= v1
->fval
- v2
->u32
;
1346 res
->fval
= v1
->fval
- v2
->i64
;
1349 res
->fval
= v1
->fval
- v2
->u64
;
1353 res
->fval
= v1
->fval
- v2
->i128
;
1359 res
->fval
= v1
->fval
- v2
->u128
;
1364 res
->fval
= v1
->fval
- v2
->fval
;
1367 res
->dval
= v1
->fval
- v2
->dval
;
1368 return PSI_T_DOUBLE
;
1369 # if HAVE_LONG_DOUBLE
1370 case PSI_T_LONG_DOUBLE
:
1371 res
->ldval
= v1
->fval
- v2
->ldval
;
1372 return PSI_T_LONG_DOUBLE
;
1383 res
->dval
= v1
->dval
- v2
->i8
;
1384 return PSI_T_DOUBLE
;
1386 res
->dval
= v1
->dval
- v2
->u8
;
1387 return PSI_T_DOUBLE
;
1389 res
->dval
= v1
->dval
- v2
->i16
;
1390 return PSI_T_DOUBLE
;
1392 res
->dval
= v1
->dval
- v2
->u16
;
1393 return PSI_T_DOUBLE
;
1395 res
->dval
= v1
->dval
- v2
->i32
;
1396 return PSI_T_DOUBLE
;
1398 res
->dval
= v1
->dval
- v2
->u32
;
1399 return PSI_T_DOUBLE
;
1401 res
->dval
= v1
->dval
- v2
->i64
;
1402 return PSI_T_DOUBLE
;
1404 res
->dval
= v1
->dval
- v2
->u64
;
1405 return PSI_T_DOUBLE
;
1408 res
->dval
= v1
->dval
- v2
->i128
;
1409 return PSI_T_DOUBLE
;
1414 res
->dval
= v1
->dval
- v2
->u128
;
1415 return PSI_T_DOUBLE
;
1419 res
->dval
= v1
->dval
- v2
->fval
;
1420 return PSI_T_DOUBLE
;
1422 res
->dval
= v1
->dval
- v2
->dval
;
1423 return PSI_T_DOUBLE
;
1424 # if HAVE_LONG_DOUBLE
1425 case PSI_T_LONG_DOUBLE
:
1426 res
->ldval
= v1
->dval
- v2
->ldval
;
1427 return PSI_T_LONG_DOUBLE
;
1435 #if HAVE_LONG_DOUBLE
1436 case PSI_T_LONG_DOUBLE
:
1439 res
->ldval
= v1
->ldval
- v2
->i8
;
1440 return PSI_T_LONG_DOUBLE
;
1442 res
->ldval
= v1
->ldval
- v2
->u8
;
1443 return PSI_T_LONG_DOUBLE
;
1445 res
->ldval
= v1
->ldval
- v2
->i16
;
1446 return PSI_T_LONG_DOUBLE
;
1448 res
->ldval
= v1
->ldval
- v2
->u16
;
1449 return PSI_T_LONG_DOUBLE
;
1451 res
->ldval
= v1
->ldval
- v2
->i32
;
1452 return PSI_T_LONG_DOUBLE
;
1454 res
->ldval
= v1
->ldval
- v2
->u32
;
1455 return PSI_T_LONG_DOUBLE
;
1457 res
->ldval
= v1
->ldval
- v2
->i64
;
1458 return PSI_T_LONG_DOUBLE
;
1460 res
->ldval
= v1
->ldval
- v2
->u64
;
1461 return PSI_T_LONG_DOUBLE
;
1464 res
->ldval
= v1
->ldval
- v2
->i128
;
1465 return PSI_T_LONG_DOUBLE
;
1470 res
->ldval
= v1
->ldval
- v2
->u128
;
1471 return PSI_T_LONG_DOUBLE
;
1475 res
->ldval
= v1
->ldval
- v2
->fval
;
1476 return PSI_T_LONG_DOUBLE
;
1478 res
->ldval
= v1
->ldval
- v2
->dval
;
1479 return PSI_T_LONG_DOUBLE
;
1480 # if HAVE_LONG_DOUBLE
1481 case PSI_T_LONG_DOUBLE
:
1482 res
->ldval
= v1
->ldval
- v2
->ldval
;
1483 return PSI_T_LONG_DOUBLE
;
1500 static inline token_t
psi_calc_mul(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
1507 res
->i16
= v1
->i8
* v2
->i8
;
1510 res
->i16
= v1
->i8
* v2
->u8
;
1513 res
->i32
= v1
->i8
* v2
->i16
;
1516 res
->i32
= v1
->i8
* v2
->u16
;
1519 res
->i64
= v1
->i8
* v2
->i32
;
1522 res
->i64
= v1
->i8
* v2
->u32
;
1525 res
->i64
= v1
->i8
* v2
->i64
;
1528 res
->i64
= v1
->i8
* v2
->u64
;
1532 res
->i128
= v1
->i8
* v2
->i128
;
1533 return PSI_T_INT128
;
1538 res
->u128
= v1
->i8
* v2
->u128
;
1539 return PSI_T_UINT128
;
1543 res
->fval
= v1
->i8
* v2
->fval
;
1546 res
->dval
= v1
->i8
* v2
->dval
;
1547 return PSI_T_DOUBLE
;
1548 # if HAVE_LONG_DOUBLE
1549 case PSI_T_LONG_DOUBLE
:
1550 res
->ldval
= v1
->i8
* v2
->ldval
;
1551 return PSI_T_LONG_DOUBLE
;
1562 res
->i16
= v1
->u8
* v2
->i8
;
1565 res
->u16
= v1
->u8
* v2
->u8
;
1566 return PSI_T_UINT16
;
1568 res
->i32
= v1
->u8
* v2
->i16
;
1571 res
->u32
= v1
->u8
* v2
->u16
;
1572 return PSI_T_UINT32
;
1574 res
->i64
= v1
->u8
* v2
->i32
;
1577 res
->u64
= v1
->u8
* v2
->u32
;
1578 return PSI_T_UINT64
;
1580 res
->i64
= v1
->u8
* v2
->i64
;
1583 res
->u64
= v1
->u8
* v2
->u64
;
1584 return PSI_T_UINT64
;
1587 res
->i128
= v1
->u8
* v2
->i128
;
1588 return PSI_T_INT128
;
1593 res
->u128
= v1
->u8
* v2
->u128
;
1594 return PSI_T_UINT128
;
1598 res
->fval
= v1
->u8
* v2
->fval
;
1601 res
->dval
= v1
->u8
* v2
->dval
;
1602 return PSI_T_DOUBLE
;
1603 # if HAVE_LONG_DOUBLE
1604 case PSI_T_LONG_DOUBLE
:
1605 res
->ldval
= v1
->u8
* v2
->ldval
;
1606 return PSI_T_LONG_DOUBLE
;
1617 res
->i32
= v1
->i16
* v2
->i8
;
1620 res
->i32
= v1
->i16
* v2
->u8
;
1623 res
->i32
= v1
->i16
* v2
->i16
;
1626 res
->i32
= v1
->i16
* v2
->u16
;
1629 res
->i64
= v1
->i16
* v2
->i32
;
1632 res
->i64
= v1
->i16
* v2
->u32
;
1635 res
->i64
= v1
->i16
* v2
->i64
;
1638 res
->i64
= v1
->i16
* v2
->u64
;
1642 res
->i128
= v1
->i16
* v2
->i128
;
1643 return PSI_T_INT128
;
1648 res
->u128
= v1
->i16
* v2
->u128
;
1649 return PSI_T_UINT128
;
1653 res
->fval
= v1
->i16
* v2
->fval
;
1656 res
->dval
= v1
->i16
* v2
->dval
;
1657 return PSI_T_DOUBLE
;
1658 # if HAVE_LONG_DOUBLE
1659 case PSI_T_LONG_DOUBLE
:
1660 res
->ldval
= v1
->i16
* v2
->ldval
;
1661 return PSI_T_LONG_DOUBLE
;
1672 res
->i32
= v1
->u16
* v2
->i8
;
1675 res
->u32
= v1
->u16
* v2
->u8
;
1676 return PSI_T_UINT32
;
1678 res
->i32
= v1
->u16
* v2
->i16
;
1681 res
->u32
= v1
->u16
* v2
->u16
;
1682 return PSI_T_UINT32
;
1684 res
->i64
= v1
->u16
* v2
->i32
;
1687 res
->u64
= v1
->u16
* v2
->u32
;
1688 return PSI_T_UINT64
;
1690 res
->i64
= v1
->u16
* v2
->i64
;
1693 res
->u64
= v1
->u16
* v2
->u64
;
1694 return PSI_T_UINT64
;
1697 res
->i128
= v1
->u16
* v2
->i128
;
1698 return PSI_T_INT128
;
1703 res
->u128
= v1
->u16
* v2
->u128
;
1704 return PSI_T_UINT128
;
1708 res
->fval
= v1
->u16
* v2
->fval
;
1711 res
->dval
= v1
->u16
* v2
->dval
;
1712 return PSI_T_DOUBLE
;
1713 # if HAVE_LONG_DOUBLE
1714 case PSI_T_LONG_DOUBLE
:
1715 res
->ldval
= v1
->u16
* v2
->ldval
;
1716 return PSI_T_LONG_DOUBLE
;
1727 res
->i64
= v1
->i32
* v2
->i8
;
1730 res
->i64
= v1
->i32
* v2
->u8
;
1733 res
->i64
= v1
->i32
* v2
->i16
;
1736 res
->i64
= v1
->i32
* v2
->u16
;
1739 res
->i64
= v1
->i32
* v2
->i32
;
1742 res
->i64
= v1
->i32
* v2
->u32
;
1745 res
->i64
= v1
->i32
* v2
->i64
;
1748 res
->i64
= v1
->i32
* v2
->u64
;
1752 res
->i128
= v1
->i32
* v2
->i128
;
1753 return PSI_T_INT128
;
1758 res
->u128
= v1
->i32
* v2
->u128
;
1759 return PSI_T_UINT128
;
1763 res
->fval
= v1
->i32
* v2
->fval
;
1766 res
->dval
= v1
->i32
* v2
->dval
;
1767 return PSI_T_DOUBLE
;
1768 # if HAVE_LONG_DOUBLE
1769 case PSI_T_LONG_DOUBLE
:
1770 res
->ldval
= v1
->i32
* v2
->ldval
;
1771 return PSI_T_LONG_DOUBLE
;
1782 res
->i64
= v1
->u32
* v2
->i8
;
1785 res
->u64
= v1
->u32
* v2
->u8
;
1786 return PSI_T_UINT64
;
1788 res
->i64
= v1
->u32
* v2
->i16
;
1791 res
->u64
= v1
->u32
* v2
->u16
;
1792 return PSI_T_UINT64
;
1794 res
->i64
= v1
->u32
* v2
->i32
;
1797 res
->u64
= v1
->u32
* v2
->u32
;
1798 return PSI_T_UINT64
;
1800 res
->i64
= v1
->u32
* v2
->i64
;
1803 res
->u64
= v1
->u32
* v2
->u64
;
1804 return PSI_T_UINT64
;
1807 res
->i128
= v1
->u32
* v2
->i128
;
1808 return PSI_T_INT128
;
1813 res
->u128
= v1
->u32
* v2
->u128
;
1814 return PSI_T_UINT128
;
1818 res
->fval
= v1
->u32
* v2
->fval
;
1821 res
->dval
= v1
->u32
* v2
->dval
;
1822 return PSI_T_DOUBLE
;
1823 # if HAVE_LONG_DOUBLE
1824 case PSI_T_LONG_DOUBLE
:
1825 res
->ldval
= v1
->u32
* v2
->ldval
;
1826 return PSI_T_LONG_DOUBLE
;
1837 res
->i64
= v1
->i64
* v2
->i8
;
1840 res
->i64
= v1
->i64
* v2
->u8
;
1843 res
->i64
= v1
->i64
* v2
->i16
;
1846 res
->i64
= v1
->i64
* v2
->u16
;
1849 res
->i64
= v1
->i64
* v2
->i32
;
1852 res
->i64
= v1
->i64
* v2
->u32
;
1855 res
->i64
= v1
->i64
* v2
->i64
;
1858 res
->i64
= v1
->i64
* v2
->u64
;
1862 res
->i128
= v1
->i64
* v2
->i128
;
1863 return PSI_T_INT128
;
1868 res
->u128
= v1
->i64
* v2
->u128
;
1869 return PSI_T_UINT128
;
1873 res
->fval
= v1
->i64
* v2
->fval
;
1876 res
->dval
= v1
->i64
* v2
->dval
;
1877 return PSI_T_DOUBLE
;
1878 # if HAVE_LONG_DOUBLE
1879 case PSI_T_LONG_DOUBLE
:
1880 res
->ldval
= v1
->i64
* v2
->ldval
;
1881 return PSI_T_LONG_DOUBLE
;
1892 res
->i64
= v1
->u64
* v2
->i8
;
1895 res
->u64
= v1
->u64
* v2
->u8
;
1896 return PSI_T_UINT64
;
1898 res
->i64
= v1
->u64
* v2
->i16
;
1901 res
->u64
= v1
->u64
* v2
->u16
;
1902 return PSI_T_UINT64
;
1904 res
->i64
= v1
->u64
* v2
->i32
;
1907 res
->u64
= v1
->u64
* v2
->u32
;
1908 return PSI_T_UINT64
;
1910 res
->i64
= v1
->u64
* v2
->i64
;
1913 res
->u64
= v1
->u64
* v2
->u64
;
1914 return PSI_T_UINT64
;
1917 res
->i128
= v1
->u64
* v2
->i128
;
1918 return PSI_T_INT128
;
1923 res
->u128
= v1
->u64
* v2
->u128
;
1924 return PSI_T_UINT128
;
1928 res
->fval
= v1
->u64
* v2
->fval
;
1931 res
->dval
= v1
->u64
* v2
->dval
;
1932 return PSI_T_DOUBLE
;
1933 # if HAVE_LONG_DOUBLE
1934 case PSI_T_LONG_DOUBLE
:
1935 res
->ldval
= v1
->u64
* v2
->ldval
;
1936 return PSI_T_LONG_DOUBLE
;
1948 res
->i128
= v1
->i128
* v2
->i8
;
1949 return PSI_T_INT128
;
1951 res
->i128
= v1
->i128
* v2
->u8
;
1952 return PSI_T_INT128
;
1954 res
->i128
= v1
->i128
* v2
->i16
;
1955 return PSI_T_INT128
;
1957 res
->i128
= v1
->i128
* v2
->u16
;
1958 return PSI_T_INT128
;
1960 res
->i128
= v1
->i128
* v2
->i32
;
1961 return PSI_T_INT128
;
1963 res
->i128
= v1
->i128
* v2
->u32
;
1964 return PSI_T_INT128
;
1966 res
->i128
= v1
->i128
* v2
->i64
;
1967 return PSI_T_INT128
;
1969 res
->i128
= v1
->i128
* v2
->u64
;
1970 return PSI_T_INT128
;
1973 res
->i128
= v1
->i128
* v2
->i128
;
1974 return PSI_T_INT128
;
1979 res
->u128
= v1
->i128
* v2
->u128
;
1980 return PSI_T_UINT128
;
1984 res
->fval
= v1
->i128
* v2
->fval
;
1987 res
->dval
= v1
->i128
* v2
->dval
;
1988 return PSI_T_DOUBLE
;
1989 # if HAVE_LONG_DOUBLE
1990 case PSI_T_LONG_DOUBLE
:
1991 res
->ldval
= v1
->i128
* v2
->ldval
;
1992 return PSI_T_LONG_DOUBLE
;
2006 res
->u128
= v1
->u128
* v2
->i8
;
2007 return PSI_T_UINT128
;
2009 res
->u128
= v1
->u128
* v2
->u8
;
2010 return PSI_T_UINT128
;
2012 res
->u128
= v1
->u128
* v2
->i16
;
2013 return PSI_T_UINT128
;
2015 res
->u128
= v1
->u128
* v2
->u16
;
2016 return PSI_T_UINT128
;
2018 res
->u128
= v1
->u128
* v2
->i32
;
2019 return PSI_T_UINT128
;
2021 res
->u128
= v1
->u128
* v2
->u32
;
2022 return PSI_T_UINT128
;
2024 res
->u128
= v1
->u128
* v2
->i64
;
2025 return PSI_T_UINT128
;
2027 res
->u128
= v1
->u128
* v2
->u64
;
2028 return PSI_T_UINT128
;
2031 res
->u128
= v1
->u128
* v2
->i128
;
2032 return PSI_T_UINT128
;
2037 res
->u128
= v1
->u128
* v2
->u128
;
2038 return PSI_T_UINT128
;
2042 res
->fval
= v1
->u128
* v2
->fval
;
2045 res
->dval
= v1
->u128
* v2
->dval
;
2046 return PSI_T_DOUBLE
;
2047 # if HAVE_LONG_DOUBLE
2048 case PSI_T_LONG_DOUBLE
:
2049 res
->ldval
= v1
->u128
* v2
->ldval
;
2050 return PSI_T_LONG_DOUBLE
;
2063 res
->fval
= v1
->fval
* v2
->i8
;
2066 res
->fval
= v1
->fval
* v2
->u8
;
2069 res
->fval
= v1
->fval
* v2
->i16
;
2072 res
->fval
= v1
->fval
* v2
->u16
;
2075 res
->fval
= v1
->fval
* v2
->i32
;
2078 res
->fval
= v1
->fval
* v2
->u32
;
2081 res
->fval
= v1
->fval
* v2
->i64
;
2084 res
->fval
= v1
->fval
* v2
->u64
;
2088 res
->fval
= v1
->fval
* v2
->i128
;
2094 res
->fval
= v1
->fval
* v2
->u128
;
2099 res
->fval
= v1
->fval
* v2
->fval
;
2102 res
->dval
= v1
->fval
* v2
->dval
;
2103 return PSI_T_DOUBLE
;
2104 # if HAVE_LONG_DOUBLE
2105 case PSI_T_LONG_DOUBLE
:
2106 res
->ldval
= v1
->fval
* v2
->ldval
;
2107 return PSI_T_LONG_DOUBLE
;
2118 res
->dval
= v1
->dval
* v2
->i8
;
2119 return PSI_T_DOUBLE
;
2121 res
->dval
= v1
->dval
* v2
->u8
;
2122 return PSI_T_DOUBLE
;
2124 res
->dval
= v1
->dval
* v2
->i16
;
2125 return PSI_T_DOUBLE
;
2127 res
->dval
= v1
->dval
* v2
->u16
;
2128 return PSI_T_DOUBLE
;
2130 res
->dval
= v1
->dval
* v2
->i32
;
2131 return PSI_T_DOUBLE
;
2133 res
->dval
= v1
->dval
* v2
->u32
;
2134 return PSI_T_DOUBLE
;
2136 res
->dval
= v1
->dval
* v2
->i64
;
2137 return PSI_T_DOUBLE
;
2139 res
->dval
= v1
->dval
* v2
->u64
;
2140 return PSI_T_DOUBLE
;
2143 res
->dval
= v1
->dval
* v2
->i128
;
2144 return PSI_T_DOUBLE
;
2149 res
->dval
= v1
->dval
* v2
->u128
;
2150 return PSI_T_DOUBLE
;
2154 res
->dval
= v1
->dval
* v2
->fval
;
2155 return PSI_T_DOUBLE
;
2157 res
->dval
= v1
->dval
* v2
->dval
;
2158 return PSI_T_DOUBLE
;
2159 # if HAVE_LONG_DOUBLE
2160 case PSI_T_LONG_DOUBLE
:
2161 res
->ldval
= v1
->dval
* v2
->ldval
;
2162 return PSI_T_LONG_DOUBLE
;
2170 #if HAVE_LONG_DOUBLE
2171 case PSI_T_LONG_DOUBLE
:
2174 res
->ldval
= v1
->ldval
* v2
->i8
;
2175 return PSI_T_LONG_DOUBLE
;
2177 res
->ldval
= v1
->ldval
* v2
->u8
;
2178 return PSI_T_LONG_DOUBLE
;
2180 res
->ldval
= v1
->ldval
* v2
->i16
;
2181 return PSI_T_LONG_DOUBLE
;
2183 res
->ldval
= v1
->ldval
* v2
->u16
;
2184 return PSI_T_LONG_DOUBLE
;
2186 res
->ldval
= v1
->ldval
* v2
->i32
;
2187 return PSI_T_LONG_DOUBLE
;
2189 res
->ldval
= v1
->ldval
* v2
->u32
;
2190 return PSI_T_LONG_DOUBLE
;
2192 res
->ldval
= v1
->ldval
* v2
->i64
;
2193 return PSI_T_LONG_DOUBLE
;
2195 res
->ldval
= v1
->ldval
* v2
->u64
;
2196 return PSI_T_LONG_DOUBLE
;
2199 res
->ldval
= v1
->ldval
* v2
->i128
;
2200 return PSI_T_LONG_DOUBLE
;
2205 res
->ldval
= v1
->ldval
* v2
->u128
;
2206 return PSI_T_LONG_DOUBLE
;
2210 res
->ldval
= v1
->ldval
* v2
->fval
;
2211 return PSI_T_LONG_DOUBLE
;
2213 res
->ldval
= v1
->ldval
* v2
->dval
;
2214 return PSI_T_LONG_DOUBLE
;
2215 # if HAVE_LONG_DOUBLE
2216 case PSI_T_LONG_DOUBLE
:
2217 res
->ldval
= v1
->ldval
* v2
->ldval
;
2218 return PSI_T_LONG_DOUBLE
;
2235 static inline token_t
psi_calc_div(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
2242 res
->i16
= v1
->i8
/ v2
->i8
;
2245 res
->i16
= v1
->i8
/ v2
->u8
;
2248 res
->i32
= v1
->i8
/ v2
->i16
;
2251 res
->i32
= v1
->i8
/ v2
->u16
;
2254 res
->i64
= v1
->i8
/ v2
->i32
;
2257 res
->i64
= v1
->i8
/ v2
->u32
;
2260 res
->i64
= v1
->i8
/ v2
->i64
;
2263 res
->i64
= v1
->i8
/ v2
->u64
;
2267 res
->i128
= v1
->i8
/ v2
->i128
;
2268 return PSI_T_INT128
;
2273 res
->u128
= v1
->i8
/ v2
->u128
;
2274 return PSI_T_UINT128
;
2278 res
->fval
= v1
->i8
/ v2
->fval
;
2281 res
->dval
= v1
->i8
/ v2
->dval
;
2282 return PSI_T_DOUBLE
;
2283 # if HAVE_LONG_DOUBLE
2284 case PSI_T_LONG_DOUBLE
:
2285 res
->ldval
= v1
->i8
/ v2
->ldval
;
2286 return PSI_T_LONG_DOUBLE
;
2297 res
->i16
= v1
->u8
/ v2
->i8
;
2300 res
->u16
= v1
->u8
/ v2
->u8
;
2301 return PSI_T_UINT16
;
2303 res
->i32
= v1
->u8
/ v2
->i16
;
2306 res
->u32
= v1
->u8
/ v2
->u16
;
2307 return PSI_T_UINT32
;
2309 res
->i64
= v1
->u8
/ v2
->i32
;
2312 res
->u64
= v1
->u8
/ v2
->u32
;
2313 return PSI_T_UINT64
;
2315 res
->i64
= v1
->u8
/ v2
->i64
;
2318 res
->u64
= v1
->u8
/ v2
->u64
;
2319 return PSI_T_UINT64
;
2322 res
->i128
= v1
->u8
/ v2
->i128
;
2323 return PSI_T_INT128
;
2328 res
->u128
= v1
->u8
/ v2
->u128
;
2329 return PSI_T_UINT128
;
2333 res
->fval
= v1
->u8
/ v2
->fval
;
2336 res
->dval
= v1
->u8
/ v2
->dval
;
2337 return PSI_T_DOUBLE
;
2338 # if HAVE_LONG_DOUBLE
2339 case PSI_T_LONG_DOUBLE
:
2340 res
->ldval
= v1
->u8
/ v2
->ldval
;
2341 return PSI_T_LONG_DOUBLE
;
2352 res
->i32
= v1
->i16
/ v2
->i8
;
2355 res
->i32
= v1
->i16
/ v2
->u8
;
2358 res
->i32
= v1
->i16
/ v2
->i16
;
2361 res
->i32
= v1
->i16
/ v2
->u16
;
2364 res
->i64
= v1
->i16
/ v2
->i32
;
2367 res
->i64
= v1
->i16
/ v2
->u32
;
2370 res
->i64
= v1
->i16
/ v2
->i64
;
2373 res
->i64
= v1
->i16
/ v2
->u64
;
2377 res
->i128
= v1
->i16
/ v2
->i128
;
2378 return PSI_T_INT128
;
2383 res
->u128
= v1
->i16
/ v2
->u128
;
2384 return PSI_T_UINT128
;
2388 res
->fval
= v1
->i16
/ v2
->fval
;
2391 res
->dval
= v1
->i16
/ v2
->dval
;
2392 return PSI_T_DOUBLE
;
2393 # if HAVE_LONG_DOUBLE
2394 case PSI_T_LONG_DOUBLE
:
2395 res
->ldval
= v1
->i16
/ v2
->ldval
;
2396 return PSI_T_LONG_DOUBLE
;
2407 res
->i32
= v1
->u16
/ v2
->i8
;
2410 res
->u32
= v1
->u16
/ v2
->u8
;
2411 return PSI_T_UINT32
;
2413 res
->i32
= v1
->u16
/ v2
->i16
;
2416 res
->u32
= v1
->u16
/ v2
->u16
;
2417 return PSI_T_UINT32
;
2419 res
->i64
= v1
->u16
/ v2
->i32
;
2422 res
->u64
= v1
->u16
/ v2
->u32
;
2423 return PSI_T_UINT64
;
2425 res
->i64
= v1
->u16
/ v2
->i64
;
2428 res
->u64
= v1
->u16
/ v2
->u64
;
2429 return PSI_T_UINT64
;
2432 res
->i128
= v1
->u16
/ v2
->i128
;
2433 return PSI_T_INT128
;
2438 res
->u128
= v1
->u16
/ v2
->u128
;
2439 return PSI_T_UINT128
;
2443 res
->fval
= v1
->u16
/ v2
->fval
;
2446 res
->dval
= v1
->u16
/ v2
->dval
;
2447 return PSI_T_DOUBLE
;
2448 # if HAVE_LONG_DOUBLE
2449 case PSI_T_LONG_DOUBLE
:
2450 res
->ldval
= v1
->u16
/ v2
->ldval
;
2451 return PSI_T_LONG_DOUBLE
;
2462 res
->i64
= v1
->i32
/ v2
->i8
;
2465 res
->i64
= v1
->i32
/ v2
->u8
;
2468 res
->i64
= v1
->i32
/ v2
->i16
;
2471 res
->i64
= v1
->i32
/ v2
->u16
;
2474 res
->i64
= v1
->i32
/ v2
->i32
;
2477 res
->i64
= v1
->i32
/ v2
->u32
;
2480 res
->i64
= v1
->i32
/ v2
->i64
;
2483 res
->i64
= v1
->i32
/ v2
->u64
;
2487 res
->i128
= v1
->i32
/ v2
->i128
;
2488 return PSI_T_INT128
;
2493 res
->u128
= v1
->i32
/ v2
->u128
;
2494 return PSI_T_UINT128
;
2498 res
->fval
= v1
->i32
/ v2
->fval
;
2501 res
->dval
= v1
->i32
/ v2
->dval
;
2502 return PSI_T_DOUBLE
;
2503 # if HAVE_LONG_DOUBLE
2504 case PSI_T_LONG_DOUBLE
:
2505 res
->ldval
= v1
->i32
/ v2
->ldval
;
2506 return PSI_T_LONG_DOUBLE
;
2517 res
->i64
= v1
->u32
/ v2
->i8
;
2520 res
->u64
= v1
->u32
/ v2
->u8
;
2521 return PSI_T_UINT64
;
2523 res
->i64
= v1
->u32
/ v2
->i16
;
2526 res
->u64
= v1
->u32
/ v2
->u16
;
2527 return PSI_T_UINT64
;
2529 res
->i64
= v1
->u32
/ v2
->i32
;
2532 res
->u64
= v1
->u32
/ v2
->u32
;
2533 return PSI_T_UINT64
;
2535 res
->i64
= v1
->u32
/ v2
->i64
;
2538 res
->u64
= v1
->u32
/ v2
->u64
;
2539 return PSI_T_UINT64
;
2542 res
->i128
= v1
->u32
/ v2
->i128
;
2543 return PSI_T_INT128
;
2548 res
->u128
= v1
->u32
/ v2
->u128
;
2549 return PSI_T_UINT128
;
2553 res
->fval
= v1
->u32
/ v2
->fval
;
2556 res
->dval
= v1
->u32
/ v2
->dval
;
2557 return PSI_T_DOUBLE
;
2558 # if HAVE_LONG_DOUBLE
2559 case PSI_T_LONG_DOUBLE
:
2560 res
->ldval
= v1
->u32
/ v2
->ldval
;
2561 return PSI_T_LONG_DOUBLE
;
2572 res
->i64
= v1
->i64
/ v2
->i8
;
2575 res
->i64
= v1
->i64
/ v2
->u8
;
2578 res
->i64
= v1
->i64
/ v2
->i16
;
2581 res
->i64
= v1
->i64
/ v2
->u16
;
2584 res
->i64
= v1
->i64
/ v2
->i32
;
2587 res
->i64
= v1
->i64
/ v2
->u32
;
2590 res
->i64
= v1
->i64
/ v2
->i64
;
2593 res
->i64
= v1
->i64
/ v2
->u64
;
2597 res
->i128
= v1
->i64
/ v2
->i128
;
2598 return PSI_T_INT128
;
2603 res
->u128
= v1
->i64
/ v2
->u128
;
2604 return PSI_T_UINT128
;
2608 res
->fval
= v1
->i64
/ v2
->fval
;
2611 res
->dval
= v1
->i64
/ v2
->dval
;
2612 return PSI_T_DOUBLE
;
2613 # if HAVE_LONG_DOUBLE
2614 case PSI_T_LONG_DOUBLE
:
2615 res
->ldval
= v1
->i64
/ v2
->ldval
;
2616 return PSI_T_LONG_DOUBLE
;
2627 res
->i64
= v1
->u64
/ v2
->i8
;
2630 res
->u64
= v1
->u64
/ v2
->u8
;
2631 return PSI_T_UINT64
;
2633 res
->i64
= v1
->u64
/ v2
->i16
;
2636 res
->u64
= v1
->u64
/ v2
->u16
;
2637 return PSI_T_UINT64
;
2639 res
->i64
= v1
->u64
/ v2
->i32
;
2642 res
->u64
= v1
->u64
/ v2
->u32
;
2643 return PSI_T_UINT64
;
2645 res
->i64
= v1
->u64
/ v2
->i64
;
2648 res
->u64
= v1
->u64
/ v2
->u64
;
2649 return PSI_T_UINT64
;
2652 res
->i128
= v1
->u64
/ v2
->i128
;
2653 return PSI_T_INT128
;
2658 res
->u128
= v1
->u64
/ v2
->u128
;
2659 return PSI_T_UINT128
;
2663 res
->fval
= v1
->u64
/ v2
->fval
;
2666 res
->dval
= v1
->u64
/ v2
->dval
;
2667 return PSI_T_DOUBLE
;
2668 # if HAVE_LONG_DOUBLE
2669 case PSI_T_LONG_DOUBLE
:
2670 res
->ldval
= v1
->u64
/ v2
->ldval
;
2671 return PSI_T_LONG_DOUBLE
;
2683 res
->i128
= v1
->i128
/ v2
->i8
;
2684 return PSI_T_INT128
;
2686 res
->i128
= v1
->i128
/ v2
->u8
;
2687 return PSI_T_INT128
;
2689 res
->i128
= v1
->i128
/ v2
->i16
;
2690 return PSI_T_INT128
;
2692 res
->i128
= v1
->i128
/ v2
->u16
;
2693 return PSI_T_INT128
;
2695 res
->i128
= v1
->i128
/ v2
->i32
;
2696 return PSI_T_INT128
;
2698 res
->i128
= v1
->i128
/ v2
->u32
;
2699 return PSI_T_INT128
;
2701 res
->i128
= v1
->i128
/ v2
->i64
;
2702 return PSI_T_INT128
;
2704 res
->i128
= v1
->i128
/ v2
->u64
;
2705 return PSI_T_INT128
;
2708 res
->i128
= v1
->i128
/ v2
->i128
;
2709 return PSI_T_INT128
;
2714 res
->u128
= v1
->i128
/ v2
->u128
;
2715 return PSI_T_UINT128
;
2719 res
->fval
= v1
->i128
/ v2
->fval
;
2722 res
->dval
= v1
->i128
/ v2
->dval
;
2723 return PSI_T_DOUBLE
;
2724 # if HAVE_LONG_DOUBLE
2725 case PSI_T_LONG_DOUBLE
:
2726 res
->ldval
= v1
->i128
/ v2
->ldval
;
2727 return PSI_T_LONG_DOUBLE
;
2741 res
->u128
= v1
->u128
/ v2
->i8
;
2742 return PSI_T_UINT128
;
2744 res
->u128
= v1
->u128
/ v2
->u8
;
2745 return PSI_T_UINT128
;
2747 res
->u128
= v1
->u128
/ v2
->i16
;
2748 return PSI_T_UINT128
;
2750 res
->u128
= v1
->u128
/ v2
->u16
;
2751 return PSI_T_UINT128
;
2753 res
->u128
= v1
->u128
/ v2
->i32
;
2754 return PSI_T_UINT128
;
2756 res
->u128
= v1
->u128
/ v2
->u32
;
2757 return PSI_T_UINT128
;
2759 res
->u128
= v1
->u128
/ v2
->i64
;
2760 return PSI_T_UINT128
;
2762 res
->u128
= v1
->u128
/ v2
->u64
;
2763 return PSI_T_UINT128
;
2766 res
->u128
= v1
->u128
/ v2
->i128
;
2767 return PSI_T_UINT128
;
2772 res
->u128
= v1
->u128
/ v2
->u128
;
2773 return PSI_T_UINT128
;
2777 res
->fval
= v1
->u128
/ v2
->fval
;
2780 res
->dval
= v1
->u128
/ v2
->dval
;
2781 return PSI_T_DOUBLE
;
2782 # if HAVE_LONG_DOUBLE
2783 case PSI_T_LONG_DOUBLE
:
2784 res
->ldval
= v1
->u128
/ v2
->ldval
;
2785 return PSI_T_LONG_DOUBLE
;
2798 res
->fval
= v1
->fval
/ v2
->i8
;
2801 res
->fval
= v1
->fval
/ v2
->u8
;
2804 res
->fval
= v1
->fval
/ v2
->i16
;
2807 res
->fval
= v1
->fval
/ v2
->u16
;
2810 res
->fval
= v1
->fval
/ v2
->i32
;
2813 res
->fval
= v1
->fval
/ v2
->u32
;
2816 res
->fval
= v1
->fval
/ v2
->i64
;
2819 res
->fval
= v1
->fval
/ v2
->u64
;
2823 res
->fval
= v1
->fval
/ v2
->i128
;
2829 res
->fval
= v1
->fval
/ v2
->u128
;
2834 res
->fval
= v1
->fval
/ v2
->fval
;
2837 res
->dval
= v1
->fval
/ v2
->dval
;
2838 return PSI_T_DOUBLE
;
2839 # if HAVE_LONG_DOUBLE
2840 case PSI_T_LONG_DOUBLE
:
2841 res
->ldval
= v1
->fval
/ v2
->ldval
;
2842 return PSI_T_LONG_DOUBLE
;
2853 res
->dval
= v1
->dval
/ v2
->i8
;
2854 return PSI_T_DOUBLE
;
2856 res
->dval
= v1
->dval
/ v2
->u8
;
2857 return PSI_T_DOUBLE
;
2859 res
->dval
= v1
->dval
/ v2
->i16
;
2860 return PSI_T_DOUBLE
;
2862 res
->dval
= v1
->dval
/ v2
->u16
;
2863 return PSI_T_DOUBLE
;
2865 res
->dval
= v1
->dval
/ v2
->i32
;
2866 return PSI_T_DOUBLE
;
2868 res
->dval
= v1
->dval
/ v2
->u32
;
2869 return PSI_T_DOUBLE
;
2871 res
->dval
= v1
->dval
/ v2
->i64
;
2872 return PSI_T_DOUBLE
;
2874 res
->dval
= v1
->dval
/ v2
->u64
;
2875 return PSI_T_DOUBLE
;
2878 res
->dval
= v1
->dval
/ v2
->i128
;
2879 return PSI_T_DOUBLE
;
2884 res
->dval
= v1
->dval
/ v2
->u128
;
2885 return PSI_T_DOUBLE
;
2889 res
->dval
= v1
->dval
/ v2
->fval
;
2890 return PSI_T_DOUBLE
;
2892 res
->dval
= v1
->dval
/ v2
->dval
;
2893 return PSI_T_DOUBLE
;
2894 # if HAVE_LONG_DOUBLE
2895 case PSI_T_LONG_DOUBLE
:
2896 res
->ldval
= v1
->dval
/ v2
->ldval
;
2897 return PSI_T_LONG_DOUBLE
;
2905 #if HAVE_LONG_DOUBLE
2906 case PSI_T_LONG_DOUBLE
:
2909 res
->ldval
= v1
->ldval
/ v2
->i8
;
2910 return PSI_T_LONG_DOUBLE
;
2912 res
->ldval
= v1
->ldval
/ v2
->u8
;
2913 return PSI_T_LONG_DOUBLE
;
2915 res
->ldval
= v1
->ldval
/ v2
->i16
;
2916 return PSI_T_LONG_DOUBLE
;
2918 res
->ldval
= v1
->ldval
/ v2
->u16
;
2919 return PSI_T_LONG_DOUBLE
;
2921 res
->ldval
= v1
->ldval
/ v2
->i32
;
2922 return PSI_T_LONG_DOUBLE
;
2924 res
->ldval
= v1
->ldval
/ v2
->u32
;
2925 return PSI_T_LONG_DOUBLE
;
2927 res
->ldval
= v1
->ldval
/ v2
->i64
;
2928 return PSI_T_LONG_DOUBLE
;
2930 res
->ldval
= v1
->ldval
/ v2
->u64
;
2931 return PSI_T_LONG_DOUBLE
;
2934 res
->ldval
= v1
->ldval
/ v2
->i128
;
2935 return PSI_T_LONG_DOUBLE
;
2940 res
->ldval
= v1
->ldval
/ v2
->u128
;
2941 return PSI_T_LONG_DOUBLE
;
2945 res
->ldval
= v1
->ldval
/ v2
->fval
;
2946 return PSI_T_LONG_DOUBLE
;
2948 res
->ldval
= v1
->ldval
/ v2
->dval
;
2949 return PSI_T_LONG_DOUBLE
;
2950 # if HAVE_LONG_DOUBLE
2951 case PSI_T_LONG_DOUBLE
:
2952 res
->ldval
= v1
->ldval
/ v2
->ldval
;
2953 return PSI_T_LONG_DOUBLE
;
2972 static inline token_t
psi_calc_mod(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
3031 #if HAVE_LONG_DOUBLE
3032 case PSI_T_LONG_DOUBLE
:
3086 #if HAVE_LONG_DOUBLE
3087 case PSI_T_LONG_DOUBLE
:
3097 res
->i64
= i1
.i64
% i2
.i64
;