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
;
63 res
->i128
= v1
->i8
+ v2
->i128
;
69 res
->u128
= v1
->i8
+ v2
->u128
;
74 res
->fval
= v1
->i8
+ v2
->fval
;
77 res
->dval
= v1
->i8
+ v2
->dval
;
80 case PSI_T_LONG_DOUBLE
:
81 res
->ldval
= v1
->i8
+ v2
->ldval
;
82 return PSI_T_LONG_DOUBLE
;
93 res
->i16
= v1
->u8
+ v2
->i8
;
96 res
->u16
= v1
->u8
+ v2
->u8
;
99 res
->i32
= v1
->u8
+ v2
->i16
;
102 res
->u32
= v1
->u8
+ v2
->u16
;
105 res
->i64
= v1
->u8
+ v2
->i32
;
108 res
->u64
= v1
->u8
+ v2
->u32
;
111 res
->i64
= v1
->u8
+ v2
->i64
;
114 res
->u64
= v1
->u8
+ v2
->u64
;
118 res
->i128
= v1
->u8
+ v2
->i128
;
124 res
->u128
= v1
->u8
+ v2
->u128
;
125 return PSI_T_UINT128
;
129 res
->fval
= v1
->u8
+ v2
->fval
;
132 res
->dval
= v1
->u8
+ v2
->dval
;
134 # if HAVE_LONG_DOUBLE
135 case PSI_T_LONG_DOUBLE
:
136 res
->ldval
= v1
->u8
+ v2
->ldval
;
137 return PSI_T_LONG_DOUBLE
;
148 res
->i32
= v1
->i16
+ v2
->i8
;
151 res
->i32
= v1
->i16
+ v2
->u8
;
154 res
->i32
= v1
->i16
+ v2
->i16
;
157 res
->i32
= v1
->i16
+ v2
->u16
;
160 res
->i64
= v1
->i16
+ v2
->i32
;
163 res
->i64
= v1
->i16
+ v2
->u32
;
166 res
->i64
= v1
->i16
+ v2
->i64
;
169 res
->i64
= v1
->i16
+ v2
->u64
;
173 res
->i128
= v1
->i16
+ v2
->i128
;
179 res
->u128
= v1
->i16
+ v2
->u128
;
180 return PSI_T_UINT128
;
184 res
->fval
= v1
->i16
+ v2
->fval
;
187 res
->dval
= v1
->i16
+ v2
->dval
;
189 # if HAVE_LONG_DOUBLE
190 case PSI_T_LONG_DOUBLE
:
191 res
->ldval
= v1
->i16
+ v2
->ldval
;
192 return PSI_T_LONG_DOUBLE
;
203 res
->i32
= v1
->u16
+ v2
->i8
;
206 res
->u32
= v1
->u16
+ v2
->u8
;
209 res
->i32
= v1
->u16
+ v2
->i16
;
212 res
->u32
= v1
->u16
+ v2
->u16
;
215 res
->i64
= v1
->u16
+ v2
->i32
;
218 res
->u64
= v1
->u16
+ v2
->u32
;
221 res
->i64
= v1
->u16
+ v2
->i64
;
224 res
->u64
= v1
->u16
+ v2
->u64
;
228 res
->i128
= v1
->u16
+ v2
->i128
;
234 res
->u128
= v1
->u16
+ v2
->u128
;
235 return PSI_T_UINT128
;
239 res
->fval
= v1
->u16
+ v2
->fval
;
242 res
->dval
= v1
->u16
+ v2
->dval
;
244 # if HAVE_LONG_DOUBLE
245 case PSI_T_LONG_DOUBLE
:
246 res
->ldval
= v1
->u16
+ v2
->ldval
;
247 return PSI_T_LONG_DOUBLE
;
258 res
->i64
= v1
->i32
+ v2
->i8
;
261 res
->i64
= v1
->i32
+ v2
->u8
;
264 res
->i64
= v1
->i32
+ v2
->i16
;
267 res
->i64
= v1
->i32
+ v2
->u16
;
270 res
->i64
= v1
->i32
+ v2
->i32
;
273 res
->i64
= v1
->i32
+ v2
->u32
;
276 res
->i64
= v1
->i32
+ v2
->i64
;
279 res
->i64
= v1
->i32
+ v2
->u64
;
283 res
->i128
= v1
->i32
+ v2
->i128
;
289 res
->u128
= v1
->i32
+ v2
->u128
;
290 return PSI_T_UINT128
;
294 res
->fval
= v1
->i32
+ v2
->fval
;
297 res
->dval
= v1
->i32
+ v2
->dval
;
299 # if HAVE_LONG_DOUBLE
300 case PSI_T_LONG_DOUBLE
:
301 res
->ldval
= v1
->i32
+ v2
->ldval
;
302 return PSI_T_LONG_DOUBLE
;
313 res
->i64
= v1
->u32
+ v2
->i8
;
316 res
->u64
= v1
->u32
+ v2
->u8
;
319 res
->i64
= v1
->u32
+ v2
->i16
;
322 res
->u64
= v1
->u32
+ v2
->u16
;
325 res
->i64
= v1
->u32
+ v2
->i32
;
328 res
->u64
= v1
->u32
+ v2
->u32
;
331 res
->i64
= v1
->u32
+ v2
->i64
;
334 res
->u64
= v1
->u32
+ v2
->u64
;
338 res
->i128
= v1
->u32
+ v2
->i128
;
344 res
->u128
= v1
->u32
+ v2
->u128
;
345 return PSI_T_UINT128
;
349 res
->fval
= v1
->u32
+ v2
->fval
;
352 res
->dval
= v1
->u32
+ v2
->dval
;
354 # if HAVE_LONG_DOUBLE
355 case PSI_T_LONG_DOUBLE
:
356 res
->ldval
= v1
->u32
+ v2
->ldval
;
357 return PSI_T_LONG_DOUBLE
;
368 res
->i64
= v1
->i64
+ v2
->i8
;
371 res
->i64
= v1
->i64
+ v2
->u8
;
374 res
->i64
= v1
->i64
+ v2
->i16
;
377 res
->i64
= v1
->i64
+ v2
->u16
;
380 res
->i64
= v1
->i64
+ v2
->i32
;
383 res
->i64
= v1
->i64
+ v2
->u32
;
386 res
->i64
= v1
->i64
+ v2
->i64
;
389 res
->i64
= v1
->i64
+ v2
->u64
;
393 res
->i128
= v1
->i64
+ v2
->i128
;
399 res
->u128
= v1
->i64
+ v2
->u128
;
400 return PSI_T_UINT128
;
404 res
->fval
= v1
->i64
+ v2
->fval
;
407 res
->dval
= v1
->i64
+ v2
->dval
;
409 # if HAVE_LONG_DOUBLE
410 case PSI_T_LONG_DOUBLE
:
411 res
->ldval
= v1
->i64
+ v2
->ldval
;
412 return PSI_T_LONG_DOUBLE
;
423 res
->i64
= v1
->u64
+ v2
->i8
;
426 res
->u64
= v1
->u64
+ v2
->u8
;
429 res
->i64
= v1
->u64
+ v2
->i16
;
432 res
->u64
= v1
->u64
+ v2
->u16
;
435 res
->i64
= v1
->u64
+ v2
->i32
;
438 res
->u64
= v1
->u64
+ v2
->u32
;
441 res
->i64
= v1
->u64
+ v2
->i64
;
444 res
->u64
= v1
->u64
+ v2
->u64
;
448 res
->i128
= v1
->u64
+ v2
->i128
;
454 res
->u128
= v1
->u64
+ v2
->u128
;
455 return PSI_T_UINT128
;
459 res
->fval
= v1
->u64
+ v2
->fval
;
462 res
->dval
= v1
->u64
+ v2
->dval
;
464 # if HAVE_LONG_DOUBLE
465 case PSI_T_LONG_DOUBLE
:
466 res
->ldval
= v1
->u64
+ v2
->ldval
;
467 return PSI_T_LONG_DOUBLE
;
479 res
->i128
= v1
->i128
+ v2
->i8
;
482 res
->i128
= v1
->i128
+ v2
->u8
;
485 res
->i128
= v1
->i128
+ v2
->i16
;
488 res
->i128
= v1
->i128
+ v2
->u16
;
491 res
->i128
= v1
->i128
+ v2
->i32
;
494 res
->i128
= v1
->i128
+ v2
->u32
;
497 res
->i128
= v1
->i128
+ v2
->i64
;
500 res
->i128
= v1
->i128
+ v2
->u64
;
504 res
->i128
= v1
->i128
+ v2
->i128
;
510 res
->u128
= v1
->i128
+ v2
->u128
;
511 return PSI_T_UINT128
;
515 res
->fval
= v1
->i128
+ v2
->fval
;
518 res
->dval
= v1
->i128
+ v2
->dval
;
520 # if HAVE_LONG_DOUBLE
521 case PSI_T_LONG_DOUBLE
:
522 res
->ldval
= v1
->i128
+ v2
->ldval
;
523 return PSI_T_LONG_DOUBLE
;
537 res
->u128
= v1
->u128
+ v2
->i8
;
538 return PSI_T_UINT128
;
540 res
->u128
= v1
->u128
+ v2
->u8
;
541 return PSI_T_UINT128
;
543 res
->u128
= v1
->u128
+ v2
->i16
;
544 return PSI_T_UINT128
;
546 res
->u128
= v1
->u128
+ v2
->u16
;
547 return PSI_T_UINT128
;
549 res
->u128
= v1
->u128
+ v2
->i32
;
550 return PSI_T_UINT128
;
552 res
->u128
= v1
->u128
+ v2
->u32
;
553 return PSI_T_UINT128
;
555 res
->u128
= v1
->u128
+ v2
->i64
;
556 return PSI_T_UINT128
;
558 res
->u128
= v1
->u128
+ v2
->u64
;
559 return PSI_T_UINT128
;
562 res
->u128
= v1
->u128
+ v2
->i128
;
563 return PSI_T_UINT128
;
568 res
->u128
= v1
->u128
+ v2
->u128
;
569 return PSI_T_UINT128
;
573 res
->fval
= v1
->u128
+ v2
->fval
;
576 res
->dval
= v1
->u128
+ v2
->dval
;
578 # if HAVE_LONG_DOUBLE
579 case PSI_T_LONG_DOUBLE
:
580 res
->ldval
= v1
->u128
+ v2
->ldval
;
581 return PSI_T_LONG_DOUBLE
;
594 res
->fval
= v1
->fval
+ v2
->i8
;
597 res
->fval
= v1
->fval
+ v2
->u8
;
600 res
->fval
= v1
->fval
+ v2
->i16
;
603 res
->fval
= v1
->fval
+ v2
->u16
;
606 res
->fval
= v1
->fval
+ v2
->i32
;
609 res
->fval
= v1
->fval
+ v2
->u32
;
612 res
->fval
= v1
->fval
+ v2
->i64
;
615 res
->fval
= v1
->fval
+ v2
->u64
;
619 res
->fval
= v1
->fval
+ v2
->i128
;
625 res
->fval
= v1
->fval
+ v2
->u128
;
630 res
->fval
= v1
->fval
+ v2
->fval
;
633 res
->dval
= v1
->fval
+ v2
->dval
;
635 # if HAVE_LONG_DOUBLE
636 case PSI_T_LONG_DOUBLE
:
637 res
->ldval
= v1
->fval
+ v2
->ldval
;
638 return PSI_T_LONG_DOUBLE
;
649 res
->dval
= v1
->dval
+ v2
->i8
;
652 res
->dval
= v1
->dval
+ v2
->u8
;
655 res
->dval
= v1
->dval
+ v2
->i16
;
658 res
->dval
= v1
->dval
+ v2
->u16
;
661 res
->dval
= v1
->dval
+ v2
->i32
;
664 res
->dval
= v1
->dval
+ v2
->u32
;
667 res
->dval
= v1
->dval
+ v2
->i64
;
670 res
->dval
= v1
->dval
+ v2
->u64
;
674 res
->dval
= v1
->dval
+ v2
->i128
;
680 res
->dval
= v1
->dval
+ v2
->u128
;
685 res
->dval
= v1
->dval
+ v2
->fval
;
688 res
->dval
= v1
->dval
+ v2
->dval
;
690 # if HAVE_LONG_DOUBLE
691 case PSI_T_LONG_DOUBLE
:
692 res
->ldval
= v1
->dval
+ v2
->ldval
;
693 return PSI_T_LONG_DOUBLE
;
702 case PSI_T_LONG_DOUBLE
:
705 res
->ldval
= v1
->ldval
+ v2
->i8
;
706 return PSI_T_LONG_DOUBLE
;
708 res
->ldval
= v1
->ldval
+ v2
->u8
;
709 return PSI_T_LONG_DOUBLE
;
711 res
->ldval
= v1
->ldval
+ v2
->i16
;
712 return PSI_T_LONG_DOUBLE
;
714 res
->ldval
= v1
->ldval
+ v2
->u16
;
715 return PSI_T_LONG_DOUBLE
;
717 res
->ldval
= v1
->ldval
+ v2
->i32
;
718 return PSI_T_LONG_DOUBLE
;
720 res
->ldval
= v1
->ldval
+ v2
->u32
;
721 return PSI_T_LONG_DOUBLE
;
723 res
->ldval
= v1
->ldval
+ v2
->i64
;
724 return PSI_T_LONG_DOUBLE
;
726 res
->ldval
= v1
->ldval
+ v2
->u64
;
727 return PSI_T_LONG_DOUBLE
;
730 res
->ldval
= v1
->ldval
+ v2
->i128
;
731 return PSI_T_LONG_DOUBLE
;
736 res
->ldval
= v1
->ldval
+ v2
->u128
;
737 return PSI_T_LONG_DOUBLE
;
741 res
->ldval
= v1
->ldval
+ v2
->fval
;
742 return PSI_T_LONG_DOUBLE
;
744 res
->ldval
= v1
->ldval
+ v2
->dval
;
745 return PSI_T_LONG_DOUBLE
;
746 # if HAVE_LONG_DOUBLE
747 case PSI_T_LONG_DOUBLE
:
748 res
->ldval
= v1
->ldval
+ v2
->ldval
;
749 return PSI_T_LONG_DOUBLE
;
766 static inline token_t
psi_calc_sub(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
773 res
->i16
= v1
->i8
- v2
->i8
;
776 res
->i16
= v1
->i8
- v2
->u8
;
779 res
->i32
= v1
->i8
- v2
->i16
;
782 res
->i32
= v1
->i8
- v2
->u16
;
785 res
->i64
= v1
->i8
- v2
->i32
;
788 res
->i64
= v1
->i8
- v2
->u32
;
791 res
->i64
= v1
->i8
- v2
->i64
;
794 res
->i64
= v1
->i8
- v2
->u64
;
798 res
->i128
= v1
->i8
- v2
->i128
;
804 res
->u128
= v1
->i8
- v2
->u128
;
805 return PSI_T_UINT128
;
809 res
->fval
= v1
->i8
- v2
->fval
;
812 res
->dval
= v1
->i8
- v2
->dval
;
814 # if HAVE_LONG_DOUBLE
815 case PSI_T_LONG_DOUBLE
:
816 res
->ldval
= v1
->i8
- v2
->ldval
;
817 return PSI_T_LONG_DOUBLE
;
828 res
->i16
= v1
->u8
- v2
->i8
;
831 res
->u16
= v1
->u8
- v2
->u8
;
834 res
->i32
= v1
->u8
- v2
->i16
;
837 res
->u32
= v1
->u8
- v2
->u16
;
840 res
->i64
= v1
->u8
- v2
->i32
;
843 res
->u64
= v1
->u8
- v2
->u32
;
846 res
->i64
= v1
->u8
- v2
->i64
;
849 res
->u64
= v1
->u8
- v2
->u64
;
853 res
->i128
= v1
->u8
- v2
->i128
;
859 res
->u128
= v1
->u8
- v2
->u128
;
860 return PSI_T_UINT128
;
864 res
->fval
= v1
->u8
- v2
->fval
;
867 res
->dval
= v1
->u8
- v2
->dval
;
869 # if HAVE_LONG_DOUBLE
870 case PSI_T_LONG_DOUBLE
:
871 res
->ldval
= v1
->u8
- v2
->ldval
;
872 return PSI_T_LONG_DOUBLE
;
883 res
->i32
= v1
->i16
- v2
->i8
;
886 res
->i32
= v1
->i16
- v2
->u8
;
889 res
->i32
= v1
->i16
- v2
->i16
;
892 res
->i32
= v1
->i16
- v2
->u16
;
895 res
->i64
= v1
->i16
- v2
->i32
;
898 res
->i64
= v1
->i16
- v2
->u32
;
901 res
->i64
= v1
->i16
- v2
->i64
;
904 res
->i64
= v1
->i16
- v2
->u64
;
908 res
->i128
= v1
->i16
- v2
->i128
;
914 res
->u128
= v1
->i16
- v2
->u128
;
915 return PSI_T_UINT128
;
919 res
->fval
= v1
->i16
- v2
->fval
;
922 res
->dval
= v1
->i16
- v2
->dval
;
924 # if HAVE_LONG_DOUBLE
925 case PSI_T_LONG_DOUBLE
:
926 res
->ldval
= v1
->i16
- v2
->ldval
;
927 return PSI_T_LONG_DOUBLE
;
938 res
->i32
= v1
->u16
- v2
->i8
;
941 res
->u32
= v1
->u16
- v2
->u8
;
944 res
->i32
= v1
->u16
- v2
->i16
;
947 res
->u32
= v1
->u16
- v2
->u16
;
950 res
->i64
= v1
->u16
- v2
->i32
;
953 res
->u64
= v1
->u16
- v2
->u32
;
956 res
->i64
= v1
->u16
- v2
->i64
;
959 res
->u64
= v1
->u16
- v2
->u64
;
963 res
->i128
= v1
->u16
- v2
->i128
;
969 res
->u128
= v1
->u16
- v2
->u128
;
970 return PSI_T_UINT128
;
974 res
->fval
= v1
->u16
- v2
->fval
;
977 res
->dval
= v1
->u16
- v2
->dval
;
979 # if HAVE_LONG_DOUBLE
980 case PSI_T_LONG_DOUBLE
:
981 res
->ldval
= v1
->u16
- v2
->ldval
;
982 return PSI_T_LONG_DOUBLE
;
993 res
->i64
= v1
->i32
- v2
->i8
;
996 res
->i64
= v1
->i32
- v2
->u8
;
999 res
->i64
= v1
->i32
- v2
->i16
;
1002 res
->i64
= v1
->i32
- v2
->u16
;
1005 res
->i64
= v1
->i32
- v2
->i32
;
1008 res
->i64
= v1
->i32
- v2
->u32
;
1011 res
->i64
= v1
->i32
- v2
->i64
;
1014 res
->i64
= v1
->i32
- v2
->u64
;
1018 res
->i128
= v1
->i32
- v2
->i128
;
1019 return PSI_T_INT128
;
1024 res
->u128
= v1
->i32
- v2
->u128
;
1025 return PSI_T_UINT128
;
1029 res
->fval
= v1
->i32
- v2
->fval
;
1032 res
->dval
= v1
->i32
- v2
->dval
;
1033 return PSI_T_DOUBLE
;
1034 # if HAVE_LONG_DOUBLE
1035 case PSI_T_LONG_DOUBLE
:
1036 res
->ldval
= v1
->i32
- v2
->ldval
;
1037 return PSI_T_LONG_DOUBLE
;
1048 res
->i64
= v1
->u32
- v2
->i8
;
1051 res
->u64
= v1
->u32
- v2
->u8
;
1052 return PSI_T_UINT64
;
1054 res
->i64
= v1
->u32
- v2
->i16
;
1057 res
->u64
= v1
->u32
- v2
->u16
;
1058 return PSI_T_UINT64
;
1060 res
->i64
= v1
->u32
- v2
->i32
;
1063 res
->u64
= v1
->u32
- v2
->u32
;
1064 return PSI_T_UINT64
;
1066 res
->i64
= v1
->u32
- v2
->i64
;
1069 res
->u64
= v1
->u32
- v2
->u64
;
1070 return PSI_T_UINT64
;
1073 res
->i128
= v1
->u32
- v2
->i128
;
1074 return PSI_T_INT128
;
1079 res
->u128
= v1
->u32
- v2
->u128
;
1080 return PSI_T_UINT128
;
1084 res
->fval
= v1
->u32
- v2
->fval
;
1087 res
->dval
= v1
->u32
- v2
->dval
;
1088 return PSI_T_DOUBLE
;
1089 # if HAVE_LONG_DOUBLE
1090 case PSI_T_LONG_DOUBLE
:
1091 res
->ldval
= v1
->u32
- v2
->ldval
;
1092 return PSI_T_LONG_DOUBLE
;
1103 res
->i64
= v1
->i64
- v2
->i8
;
1106 res
->i64
= v1
->i64
- v2
->u8
;
1109 res
->i64
= v1
->i64
- v2
->i16
;
1112 res
->i64
= v1
->i64
- v2
->u16
;
1115 res
->i64
= v1
->i64
- v2
->i32
;
1118 res
->i64
= v1
->i64
- v2
->u32
;
1121 res
->i64
= v1
->i64
- v2
->i64
;
1124 res
->i64
= v1
->i64
- v2
->u64
;
1128 res
->i128
= v1
->i64
- v2
->i128
;
1129 return PSI_T_INT128
;
1134 res
->u128
= v1
->i64
- v2
->u128
;
1135 return PSI_T_UINT128
;
1139 res
->fval
= v1
->i64
- v2
->fval
;
1142 res
->dval
= v1
->i64
- v2
->dval
;
1143 return PSI_T_DOUBLE
;
1144 # if HAVE_LONG_DOUBLE
1145 case PSI_T_LONG_DOUBLE
:
1146 res
->ldval
= v1
->i64
- v2
->ldval
;
1147 return PSI_T_LONG_DOUBLE
;
1158 res
->i64
= v1
->u64
- v2
->i8
;
1161 res
->u64
= v1
->u64
- v2
->u8
;
1162 return PSI_T_UINT64
;
1164 res
->i64
= v1
->u64
- v2
->i16
;
1167 res
->u64
= v1
->u64
- v2
->u16
;
1168 return PSI_T_UINT64
;
1170 res
->i64
= v1
->u64
- v2
->i32
;
1173 res
->u64
= v1
->u64
- v2
->u32
;
1174 return PSI_T_UINT64
;
1176 res
->i64
= v1
->u64
- v2
->i64
;
1179 res
->u64
= v1
->u64
- v2
->u64
;
1180 return PSI_T_UINT64
;
1183 res
->i128
= v1
->u64
- v2
->i128
;
1184 return PSI_T_INT128
;
1189 res
->u128
= v1
->u64
- v2
->u128
;
1190 return PSI_T_UINT128
;
1194 res
->fval
= v1
->u64
- v2
->fval
;
1197 res
->dval
= v1
->u64
- v2
->dval
;
1198 return PSI_T_DOUBLE
;
1199 # if HAVE_LONG_DOUBLE
1200 case PSI_T_LONG_DOUBLE
:
1201 res
->ldval
= v1
->u64
- v2
->ldval
;
1202 return PSI_T_LONG_DOUBLE
;
1214 res
->i128
= v1
->i128
- v2
->i8
;
1215 return PSI_T_INT128
;
1217 res
->i128
= v1
->i128
- v2
->u8
;
1218 return PSI_T_INT128
;
1220 res
->i128
= v1
->i128
- v2
->i16
;
1221 return PSI_T_INT128
;
1223 res
->i128
= v1
->i128
- v2
->u16
;
1224 return PSI_T_INT128
;
1226 res
->i128
= v1
->i128
- v2
->i32
;
1227 return PSI_T_INT128
;
1229 res
->i128
= v1
->i128
- v2
->u32
;
1230 return PSI_T_INT128
;
1232 res
->i128
= v1
->i128
- v2
->i64
;
1233 return PSI_T_INT128
;
1235 res
->i128
= v1
->i128
- v2
->u64
;
1236 return PSI_T_INT128
;
1239 res
->i128
= v1
->i128
- v2
->i128
;
1240 return PSI_T_INT128
;
1245 res
->u128
= v1
->i128
- v2
->u128
;
1246 return PSI_T_UINT128
;
1250 res
->fval
= v1
->i128
- v2
->fval
;
1253 res
->dval
= v1
->i128
- v2
->dval
;
1254 return PSI_T_DOUBLE
;
1255 # if HAVE_LONG_DOUBLE
1256 case PSI_T_LONG_DOUBLE
:
1257 res
->ldval
= v1
->i128
- v2
->ldval
;
1258 return PSI_T_LONG_DOUBLE
;
1272 res
->u128
= v1
->u128
- v2
->i8
;
1273 return PSI_T_UINT128
;
1275 res
->u128
= v1
->u128
- v2
->u8
;
1276 return PSI_T_UINT128
;
1278 res
->u128
= v1
->u128
- v2
->i16
;
1279 return PSI_T_UINT128
;
1281 res
->u128
= v1
->u128
- v2
->u16
;
1282 return PSI_T_UINT128
;
1284 res
->u128
= v1
->u128
- v2
->i32
;
1285 return PSI_T_UINT128
;
1287 res
->u128
= v1
->u128
- v2
->u32
;
1288 return PSI_T_UINT128
;
1290 res
->u128
= v1
->u128
- v2
->i64
;
1291 return PSI_T_UINT128
;
1293 res
->u128
= v1
->u128
- v2
->u64
;
1294 return PSI_T_UINT128
;
1297 res
->u128
= v1
->u128
- v2
->i128
;
1298 return PSI_T_UINT128
;
1303 res
->u128
= v1
->u128
- v2
->u128
;
1304 return PSI_T_UINT128
;
1308 res
->fval
= v1
->u128
- v2
->fval
;
1311 res
->dval
= v1
->u128
- v2
->dval
;
1312 return PSI_T_DOUBLE
;
1313 # if HAVE_LONG_DOUBLE
1314 case PSI_T_LONG_DOUBLE
:
1315 res
->ldval
= v1
->u128
- v2
->ldval
;
1316 return PSI_T_LONG_DOUBLE
;
1329 res
->fval
= v1
->fval
- v2
->i8
;
1332 res
->fval
= v1
->fval
- v2
->u8
;
1335 res
->fval
= v1
->fval
- v2
->i16
;
1338 res
->fval
= v1
->fval
- v2
->u16
;
1341 res
->fval
= v1
->fval
- v2
->i32
;
1344 res
->fval
= v1
->fval
- v2
->u32
;
1347 res
->fval
= v1
->fval
- v2
->i64
;
1350 res
->fval
= v1
->fval
- v2
->u64
;
1354 res
->fval
= v1
->fval
- v2
->i128
;
1360 res
->fval
= v1
->fval
- v2
->u128
;
1365 res
->fval
= v1
->fval
- v2
->fval
;
1368 res
->dval
= v1
->fval
- v2
->dval
;
1369 return PSI_T_DOUBLE
;
1370 # if HAVE_LONG_DOUBLE
1371 case PSI_T_LONG_DOUBLE
:
1372 res
->ldval
= v1
->fval
- v2
->ldval
;
1373 return PSI_T_LONG_DOUBLE
;
1384 res
->dval
= v1
->dval
- v2
->i8
;
1385 return PSI_T_DOUBLE
;
1387 res
->dval
= v1
->dval
- v2
->u8
;
1388 return PSI_T_DOUBLE
;
1390 res
->dval
= v1
->dval
- v2
->i16
;
1391 return PSI_T_DOUBLE
;
1393 res
->dval
= v1
->dval
- v2
->u16
;
1394 return PSI_T_DOUBLE
;
1396 res
->dval
= v1
->dval
- v2
->i32
;
1397 return PSI_T_DOUBLE
;
1399 res
->dval
= v1
->dval
- v2
->u32
;
1400 return PSI_T_DOUBLE
;
1402 res
->dval
= v1
->dval
- v2
->i64
;
1403 return PSI_T_DOUBLE
;
1405 res
->dval
= v1
->dval
- v2
->u64
;
1406 return PSI_T_DOUBLE
;
1409 res
->dval
= v1
->dval
- v2
->i128
;
1410 return PSI_T_DOUBLE
;
1415 res
->dval
= v1
->dval
- v2
->u128
;
1416 return PSI_T_DOUBLE
;
1420 res
->dval
= v1
->dval
- v2
->fval
;
1421 return PSI_T_DOUBLE
;
1423 res
->dval
= v1
->dval
- v2
->dval
;
1424 return PSI_T_DOUBLE
;
1425 # if HAVE_LONG_DOUBLE
1426 case PSI_T_LONG_DOUBLE
:
1427 res
->ldval
= v1
->dval
- v2
->ldval
;
1428 return PSI_T_LONG_DOUBLE
;
1436 #if HAVE_LONG_DOUBLE
1437 case PSI_T_LONG_DOUBLE
:
1440 res
->ldval
= v1
->ldval
- v2
->i8
;
1441 return PSI_T_LONG_DOUBLE
;
1443 res
->ldval
= v1
->ldval
- v2
->u8
;
1444 return PSI_T_LONG_DOUBLE
;
1446 res
->ldval
= v1
->ldval
- v2
->i16
;
1447 return PSI_T_LONG_DOUBLE
;
1449 res
->ldval
= v1
->ldval
- v2
->u16
;
1450 return PSI_T_LONG_DOUBLE
;
1452 res
->ldval
= v1
->ldval
- v2
->i32
;
1453 return PSI_T_LONG_DOUBLE
;
1455 res
->ldval
= v1
->ldval
- v2
->u32
;
1456 return PSI_T_LONG_DOUBLE
;
1458 res
->ldval
= v1
->ldval
- v2
->i64
;
1459 return PSI_T_LONG_DOUBLE
;
1461 res
->ldval
= v1
->ldval
- v2
->u64
;
1462 return PSI_T_LONG_DOUBLE
;
1465 res
->ldval
= v1
->ldval
- v2
->i128
;
1466 return PSI_T_LONG_DOUBLE
;
1471 res
->ldval
= v1
->ldval
- v2
->u128
;
1472 return PSI_T_LONG_DOUBLE
;
1476 res
->ldval
= v1
->ldval
- v2
->fval
;
1477 return PSI_T_LONG_DOUBLE
;
1479 res
->ldval
= v1
->ldval
- v2
->dval
;
1480 return PSI_T_LONG_DOUBLE
;
1481 # if HAVE_LONG_DOUBLE
1482 case PSI_T_LONG_DOUBLE
:
1483 res
->ldval
= v1
->ldval
- v2
->ldval
;
1484 return PSI_T_LONG_DOUBLE
;
1501 static inline token_t
psi_calc_mul(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
1508 res
->i16
= v1
->i8
* v2
->i8
;
1511 res
->i16
= v1
->i8
* v2
->u8
;
1514 res
->i32
= v1
->i8
* v2
->i16
;
1517 res
->i32
= v1
->i8
* v2
->u16
;
1520 res
->i64
= v1
->i8
* v2
->i32
;
1523 res
->i64
= v1
->i8
* v2
->u32
;
1526 res
->i64
= v1
->i8
* v2
->i64
;
1529 res
->i64
= v1
->i8
* v2
->u64
;
1533 res
->i128
= v1
->i8
* v2
->i128
;
1534 return PSI_T_INT128
;
1539 res
->u128
= v1
->i8
* v2
->u128
;
1540 return PSI_T_UINT128
;
1544 res
->fval
= v1
->i8
* v2
->fval
;
1547 res
->dval
= v1
->i8
* v2
->dval
;
1548 return PSI_T_DOUBLE
;
1549 # if HAVE_LONG_DOUBLE
1550 case PSI_T_LONG_DOUBLE
:
1551 res
->ldval
= v1
->i8
* v2
->ldval
;
1552 return PSI_T_LONG_DOUBLE
;
1563 res
->i16
= v1
->u8
* v2
->i8
;
1566 res
->u16
= v1
->u8
* v2
->u8
;
1567 return PSI_T_UINT16
;
1569 res
->i32
= v1
->u8
* v2
->i16
;
1572 res
->u32
= v1
->u8
* v2
->u16
;
1573 return PSI_T_UINT32
;
1575 res
->i64
= v1
->u8
* v2
->i32
;
1578 res
->u64
= v1
->u8
* v2
->u32
;
1579 return PSI_T_UINT64
;
1581 res
->i64
= v1
->u8
* v2
->i64
;
1584 res
->u64
= v1
->u8
* v2
->u64
;
1585 return PSI_T_UINT64
;
1588 res
->i128
= v1
->u8
* v2
->i128
;
1589 return PSI_T_INT128
;
1594 res
->u128
= v1
->u8
* v2
->u128
;
1595 return PSI_T_UINT128
;
1599 res
->fval
= v1
->u8
* v2
->fval
;
1602 res
->dval
= v1
->u8
* v2
->dval
;
1603 return PSI_T_DOUBLE
;
1604 # if HAVE_LONG_DOUBLE
1605 case PSI_T_LONG_DOUBLE
:
1606 res
->ldval
= v1
->u8
* v2
->ldval
;
1607 return PSI_T_LONG_DOUBLE
;
1618 res
->i32
= v1
->i16
* v2
->i8
;
1621 res
->i32
= v1
->i16
* v2
->u8
;
1624 res
->i32
= v1
->i16
* v2
->i16
;
1627 res
->i32
= v1
->i16
* v2
->u16
;
1630 res
->i64
= v1
->i16
* v2
->i32
;
1633 res
->i64
= v1
->i16
* v2
->u32
;
1636 res
->i64
= v1
->i16
* v2
->i64
;
1639 res
->i64
= v1
->i16
* v2
->u64
;
1643 res
->i128
= v1
->i16
* v2
->i128
;
1644 return PSI_T_INT128
;
1649 res
->u128
= v1
->i16
* v2
->u128
;
1650 return PSI_T_UINT128
;
1654 res
->fval
= v1
->i16
* v2
->fval
;
1657 res
->dval
= v1
->i16
* v2
->dval
;
1658 return PSI_T_DOUBLE
;
1659 # if HAVE_LONG_DOUBLE
1660 case PSI_T_LONG_DOUBLE
:
1661 res
->ldval
= v1
->i16
* v2
->ldval
;
1662 return PSI_T_LONG_DOUBLE
;
1673 res
->i32
= v1
->u16
* v2
->i8
;
1676 res
->u32
= v1
->u16
* v2
->u8
;
1677 return PSI_T_UINT32
;
1679 res
->i32
= v1
->u16
* v2
->i16
;
1682 res
->u32
= v1
->u16
* v2
->u16
;
1683 return PSI_T_UINT32
;
1685 res
->i64
= v1
->u16
* v2
->i32
;
1688 res
->u64
= v1
->u16
* v2
->u32
;
1689 return PSI_T_UINT64
;
1691 res
->i64
= v1
->u16
* v2
->i64
;
1694 res
->u64
= v1
->u16
* v2
->u64
;
1695 return PSI_T_UINT64
;
1698 res
->i128
= v1
->u16
* v2
->i128
;
1699 return PSI_T_INT128
;
1704 res
->u128
= v1
->u16
* v2
->u128
;
1705 return PSI_T_UINT128
;
1709 res
->fval
= v1
->u16
* v2
->fval
;
1712 res
->dval
= v1
->u16
* v2
->dval
;
1713 return PSI_T_DOUBLE
;
1714 # if HAVE_LONG_DOUBLE
1715 case PSI_T_LONG_DOUBLE
:
1716 res
->ldval
= v1
->u16
* v2
->ldval
;
1717 return PSI_T_LONG_DOUBLE
;
1728 res
->i64
= v1
->i32
* v2
->i8
;
1731 res
->i64
= v1
->i32
* v2
->u8
;
1734 res
->i64
= v1
->i32
* v2
->i16
;
1737 res
->i64
= v1
->i32
* v2
->u16
;
1740 res
->i64
= v1
->i32
* v2
->i32
;
1743 res
->i64
= v1
->i32
* v2
->u32
;
1746 res
->i64
= v1
->i32
* v2
->i64
;
1749 res
->i64
= v1
->i32
* v2
->u64
;
1753 res
->i128
= v1
->i32
* v2
->i128
;
1754 return PSI_T_INT128
;
1759 res
->u128
= v1
->i32
* v2
->u128
;
1760 return PSI_T_UINT128
;
1764 res
->fval
= v1
->i32
* v2
->fval
;
1767 res
->dval
= v1
->i32
* v2
->dval
;
1768 return PSI_T_DOUBLE
;
1769 # if HAVE_LONG_DOUBLE
1770 case PSI_T_LONG_DOUBLE
:
1771 res
->ldval
= v1
->i32
* v2
->ldval
;
1772 return PSI_T_LONG_DOUBLE
;
1783 res
->i64
= v1
->u32
* v2
->i8
;
1786 res
->u64
= v1
->u32
* v2
->u8
;
1787 return PSI_T_UINT64
;
1789 res
->i64
= v1
->u32
* v2
->i16
;
1792 res
->u64
= v1
->u32
* v2
->u16
;
1793 return PSI_T_UINT64
;
1795 res
->i64
= v1
->u32
* v2
->i32
;
1798 res
->u64
= v1
->u32
* v2
->u32
;
1799 return PSI_T_UINT64
;
1801 res
->i64
= v1
->u32
* v2
->i64
;
1804 res
->u64
= v1
->u32
* v2
->u64
;
1805 return PSI_T_UINT64
;
1808 res
->i128
= v1
->u32
* v2
->i128
;
1809 return PSI_T_INT128
;
1814 res
->u128
= v1
->u32
* v2
->u128
;
1815 return PSI_T_UINT128
;
1819 res
->fval
= v1
->u32
* v2
->fval
;
1822 res
->dval
= v1
->u32
* v2
->dval
;
1823 return PSI_T_DOUBLE
;
1824 # if HAVE_LONG_DOUBLE
1825 case PSI_T_LONG_DOUBLE
:
1826 res
->ldval
= v1
->u32
* v2
->ldval
;
1827 return PSI_T_LONG_DOUBLE
;
1838 res
->i64
= v1
->i64
* v2
->i8
;
1841 res
->i64
= v1
->i64
* v2
->u8
;
1844 res
->i64
= v1
->i64
* v2
->i16
;
1847 res
->i64
= v1
->i64
* v2
->u16
;
1850 res
->i64
= v1
->i64
* v2
->i32
;
1853 res
->i64
= v1
->i64
* v2
->u32
;
1856 res
->i64
= v1
->i64
* v2
->i64
;
1859 res
->i64
= v1
->i64
* v2
->u64
;
1863 res
->i128
= v1
->i64
* v2
->i128
;
1864 return PSI_T_INT128
;
1869 res
->u128
= v1
->i64
* v2
->u128
;
1870 return PSI_T_UINT128
;
1874 res
->fval
= v1
->i64
* v2
->fval
;
1877 res
->dval
= v1
->i64
* v2
->dval
;
1878 return PSI_T_DOUBLE
;
1879 # if HAVE_LONG_DOUBLE
1880 case PSI_T_LONG_DOUBLE
:
1881 res
->ldval
= v1
->i64
* v2
->ldval
;
1882 return PSI_T_LONG_DOUBLE
;
1893 res
->i64
= v1
->u64
* v2
->i8
;
1896 res
->u64
= v1
->u64
* v2
->u8
;
1897 return PSI_T_UINT64
;
1899 res
->i64
= v1
->u64
* v2
->i16
;
1902 res
->u64
= v1
->u64
* v2
->u16
;
1903 return PSI_T_UINT64
;
1905 res
->i64
= v1
->u64
* v2
->i32
;
1908 res
->u64
= v1
->u64
* v2
->u32
;
1909 return PSI_T_UINT64
;
1911 res
->i64
= v1
->u64
* v2
->i64
;
1914 res
->u64
= v1
->u64
* v2
->u64
;
1915 return PSI_T_UINT64
;
1918 res
->i128
= v1
->u64
* v2
->i128
;
1919 return PSI_T_INT128
;
1924 res
->u128
= v1
->u64
* v2
->u128
;
1925 return PSI_T_UINT128
;
1929 res
->fval
= v1
->u64
* v2
->fval
;
1932 res
->dval
= v1
->u64
* v2
->dval
;
1933 return PSI_T_DOUBLE
;
1934 # if HAVE_LONG_DOUBLE
1935 case PSI_T_LONG_DOUBLE
:
1936 res
->ldval
= v1
->u64
* v2
->ldval
;
1937 return PSI_T_LONG_DOUBLE
;
1949 res
->i128
= v1
->i128
* v2
->i8
;
1950 return PSI_T_INT128
;
1952 res
->i128
= v1
->i128
* v2
->u8
;
1953 return PSI_T_INT128
;
1955 res
->i128
= v1
->i128
* v2
->i16
;
1956 return PSI_T_INT128
;
1958 res
->i128
= v1
->i128
* v2
->u16
;
1959 return PSI_T_INT128
;
1961 res
->i128
= v1
->i128
* v2
->i32
;
1962 return PSI_T_INT128
;
1964 res
->i128
= v1
->i128
* v2
->u32
;
1965 return PSI_T_INT128
;
1967 res
->i128
= v1
->i128
* v2
->i64
;
1968 return PSI_T_INT128
;
1970 res
->i128
= v1
->i128
* v2
->u64
;
1971 return PSI_T_INT128
;
1974 res
->i128
= v1
->i128
* v2
->i128
;
1975 return PSI_T_INT128
;
1980 res
->u128
= v1
->i128
* v2
->u128
;
1981 return PSI_T_UINT128
;
1985 res
->fval
= v1
->i128
* v2
->fval
;
1988 res
->dval
= v1
->i128
* v2
->dval
;
1989 return PSI_T_DOUBLE
;
1990 # if HAVE_LONG_DOUBLE
1991 case PSI_T_LONG_DOUBLE
:
1992 res
->ldval
= v1
->i128
* v2
->ldval
;
1993 return PSI_T_LONG_DOUBLE
;
2007 res
->u128
= v1
->u128
* v2
->i8
;
2008 return PSI_T_UINT128
;
2010 res
->u128
= v1
->u128
* v2
->u8
;
2011 return PSI_T_UINT128
;
2013 res
->u128
= v1
->u128
* v2
->i16
;
2014 return PSI_T_UINT128
;
2016 res
->u128
= v1
->u128
* v2
->u16
;
2017 return PSI_T_UINT128
;
2019 res
->u128
= v1
->u128
* v2
->i32
;
2020 return PSI_T_UINT128
;
2022 res
->u128
= v1
->u128
* v2
->u32
;
2023 return PSI_T_UINT128
;
2025 res
->u128
= v1
->u128
* v2
->i64
;
2026 return PSI_T_UINT128
;
2028 res
->u128
= v1
->u128
* v2
->u64
;
2029 return PSI_T_UINT128
;
2032 res
->u128
= v1
->u128
* v2
->i128
;
2033 return PSI_T_UINT128
;
2038 res
->u128
= v1
->u128
* v2
->u128
;
2039 return PSI_T_UINT128
;
2043 res
->fval
= v1
->u128
* v2
->fval
;
2046 res
->dval
= v1
->u128
* v2
->dval
;
2047 return PSI_T_DOUBLE
;
2048 # if HAVE_LONG_DOUBLE
2049 case PSI_T_LONG_DOUBLE
:
2050 res
->ldval
= v1
->u128
* v2
->ldval
;
2051 return PSI_T_LONG_DOUBLE
;
2064 res
->fval
= v1
->fval
* v2
->i8
;
2067 res
->fval
= v1
->fval
* v2
->u8
;
2070 res
->fval
= v1
->fval
* v2
->i16
;
2073 res
->fval
= v1
->fval
* v2
->u16
;
2076 res
->fval
= v1
->fval
* v2
->i32
;
2079 res
->fval
= v1
->fval
* v2
->u32
;
2082 res
->fval
= v1
->fval
* v2
->i64
;
2085 res
->fval
= v1
->fval
* v2
->u64
;
2089 res
->fval
= v1
->fval
* v2
->i128
;
2095 res
->fval
= v1
->fval
* v2
->u128
;
2100 res
->fval
= v1
->fval
* v2
->fval
;
2103 res
->dval
= v1
->fval
* v2
->dval
;
2104 return PSI_T_DOUBLE
;
2105 # if HAVE_LONG_DOUBLE
2106 case PSI_T_LONG_DOUBLE
:
2107 res
->ldval
= v1
->fval
* v2
->ldval
;
2108 return PSI_T_LONG_DOUBLE
;
2119 res
->dval
= v1
->dval
* v2
->i8
;
2120 return PSI_T_DOUBLE
;
2122 res
->dval
= v1
->dval
* v2
->u8
;
2123 return PSI_T_DOUBLE
;
2125 res
->dval
= v1
->dval
* v2
->i16
;
2126 return PSI_T_DOUBLE
;
2128 res
->dval
= v1
->dval
* v2
->u16
;
2129 return PSI_T_DOUBLE
;
2131 res
->dval
= v1
->dval
* v2
->i32
;
2132 return PSI_T_DOUBLE
;
2134 res
->dval
= v1
->dval
* v2
->u32
;
2135 return PSI_T_DOUBLE
;
2137 res
->dval
= v1
->dval
* v2
->i64
;
2138 return PSI_T_DOUBLE
;
2140 res
->dval
= v1
->dval
* v2
->u64
;
2141 return PSI_T_DOUBLE
;
2144 res
->dval
= v1
->dval
* v2
->i128
;
2145 return PSI_T_DOUBLE
;
2150 res
->dval
= v1
->dval
* v2
->u128
;
2151 return PSI_T_DOUBLE
;
2155 res
->dval
= v1
->dval
* v2
->fval
;
2156 return PSI_T_DOUBLE
;
2158 res
->dval
= v1
->dval
* v2
->dval
;
2159 return PSI_T_DOUBLE
;
2160 # if HAVE_LONG_DOUBLE
2161 case PSI_T_LONG_DOUBLE
:
2162 res
->ldval
= v1
->dval
* v2
->ldval
;
2163 return PSI_T_LONG_DOUBLE
;
2171 #if HAVE_LONG_DOUBLE
2172 case PSI_T_LONG_DOUBLE
:
2175 res
->ldval
= v1
->ldval
* v2
->i8
;
2176 return PSI_T_LONG_DOUBLE
;
2178 res
->ldval
= v1
->ldval
* v2
->u8
;
2179 return PSI_T_LONG_DOUBLE
;
2181 res
->ldval
= v1
->ldval
* v2
->i16
;
2182 return PSI_T_LONG_DOUBLE
;
2184 res
->ldval
= v1
->ldval
* v2
->u16
;
2185 return PSI_T_LONG_DOUBLE
;
2187 res
->ldval
= v1
->ldval
* v2
->i32
;
2188 return PSI_T_LONG_DOUBLE
;
2190 res
->ldval
= v1
->ldval
* v2
->u32
;
2191 return PSI_T_LONG_DOUBLE
;
2193 res
->ldval
= v1
->ldval
* v2
->i64
;
2194 return PSI_T_LONG_DOUBLE
;
2196 res
->ldval
= v1
->ldval
* v2
->u64
;
2197 return PSI_T_LONG_DOUBLE
;
2200 res
->ldval
= v1
->ldval
* v2
->i128
;
2201 return PSI_T_LONG_DOUBLE
;
2206 res
->ldval
= v1
->ldval
* v2
->u128
;
2207 return PSI_T_LONG_DOUBLE
;
2211 res
->ldval
= v1
->ldval
* v2
->fval
;
2212 return PSI_T_LONG_DOUBLE
;
2214 res
->ldval
= v1
->ldval
* v2
->dval
;
2215 return PSI_T_LONG_DOUBLE
;
2216 # if HAVE_LONG_DOUBLE
2217 case PSI_T_LONG_DOUBLE
:
2218 res
->ldval
= v1
->ldval
* v2
->ldval
;
2219 return PSI_T_LONG_DOUBLE
;
2236 static inline token_t
psi_calc_div(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
2243 res
->i16
= v1
->i8
/ v2
->i8
;
2246 res
->i16
= v1
->i8
/ v2
->u8
;
2249 res
->i32
= v1
->i8
/ v2
->i16
;
2252 res
->i32
= v1
->i8
/ v2
->u16
;
2255 res
->i64
= v1
->i8
/ v2
->i32
;
2258 res
->i64
= v1
->i8
/ v2
->u32
;
2261 res
->i64
= v1
->i8
/ v2
->i64
;
2264 res
->i64
= v1
->i8
/ v2
->u64
;
2268 res
->i128
= v1
->i8
/ v2
->i128
;
2269 return PSI_T_INT128
;
2274 res
->u128
= v1
->i8
/ v2
->u128
;
2275 return PSI_T_UINT128
;
2279 res
->fval
= v1
->i8
/ v2
->fval
;
2282 res
->dval
= v1
->i8
/ v2
->dval
;
2283 return PSI_T_DOUBLE
;
2284 # if HAVE_LONG_DOUBLE
2285 case PSI_T_LONG_DOUBLE
:
2286 res
->ldval
= v1
->i8
/ v2
->ldval
;
2287 return PSI_T_LONG_DOUBLE
;
2298 res
->i16
= v1
->u8
/ v2
->i8
;
2301 res
->u16
= v1
->u8
/ v2
->u8
;
2302 return PSI_T_UINT16
;
2304 res
->i32
= v1
->u8
/ v2
->i16
;
2307 res
->u32
= v1
->u8
/ v2
->u16
;
2308 return PSI_T_UINT32
;
2310 res
->i64
= v1
->u8
/ v2
->i32
;
2313 res
->u64
= v1
->u8
/ v2
->u32
;
2314 return PSI_T_UINT64
;
2316 res
->i64
= v1
->u8
/ v2
->i64
;
2319 res
->u64
= v1
->u8
/ v2
->u64
;
2320 return PSI_T_UINT64
;
2323 res
->i128
= v1
->u8
/ v2
->i128
;
2324 return PSI_T_INT128
;
2329 res
->u128
= v1
->u8
/ v2
->u128
;
2330 return PSI_T_UINT128
;
2334 res
->fval
= v1
->u8
/ v2
->fval
;
2337 res
->dval
= v1
->u8
/ v2
->dval
;
2338 return PSI_T_DOUBLE
;
2339 # if HAVE_LONG_DOUBLE
2340 case PSI_T_LONG_DOUBLE
:
2341 res
->ldval
= v1
->u8
/ v2
->ldval
;
2342 return PSI_T_LONG_DOUBLE
;
2353 res
->i32
= v1
->i16
/ v2
->i8
;
2356 res
->i32
= v1
->i16
/ v2
->u8
;
2359 res
->i32
= v1
->i16
/ v2
->i16
;
2362 res
->i32
= v1
->i16
/ v2
->u16
;
2365 res
->i64
= v1
->i16
/ v2
->i32
;
2368 res
->i64
= v1
->i16
/ v2
->u32
;
2371 res
->i64
= v1
->i16
/ v2
->i64
;
2374 res
->i64
= v1
->i16
/ v2
->u64
;
2378 res
->i128
= v1
->i16
/ v2
->i128
;
2379 return PSI_T_INT128
;
2384 res
->u128
= v1
->i16
/ v2
->u128
;
2385 return PSI_T_UINT128
;
2389 res
->fval
= v1
->i16
/ v2
->fval
;
2392 res
->dval
= v1
->i16
/ v2
->dval
;
2393 return PSI_T_DOUBLE
;
2394 # if HAVE_LONG_DOUBLE
2395 case PSI_T_LONG_DOUBLE
:
2396 res
->ldval
= v1
->i16
/ v2
->ldval
;
2397 return PSI_T_LONG_DOUBLE
;
2408 res
->i32
= v1
->u16
/ v2
->i8
;
2411 res
->u32
= v1
->u16
/ v2
->u8
;
2412 return PSI_T_UINT32
;
2414 res
->i32
= v1
->u16
/ v2
->i16
;
2417 res
->u32
= v1
->u16
/ v2
->u16
;
2418 return PSI_T_UINT32
;
2420 res
->i64
= v1
->u16
/ v2
->i32
;
2423 res
->u64
= v1
->u16
/ v2
->u32
;
2424 return PSI_T_UINT64
;
2426 res
->i64
= v1
->u16
/ v2
->i64
;
2429 res
->u64
= v1
->u16
/ v2
->u64
;
2430 return PSI_T_UINT64
;
2433 res
->i128
= v1
->u16
/ v2
->i128
;
2434 return PSI_T_INT128
;
2439 res
->u128
= v1
->u16
/ v2
->u128
;
2440 return PSI_T_UINT128
;
2444 res
->fval
= v1
->u16
/ v2
->fval
;
2447 res
->dval
= v1
->u16
/ v2
->dval
;
2448 return PSI_T_DOUBLE
;
2449 # if HAVE_LONG_DOUBLE
2450 case PSI_T_LONG_DOUBLE
:
2451 res
->ldval
= v1
->u16
/ v2
->ldval
;
2452 return PSI_T_LONG_DOUBLE
;
2463 res
->i64
= v1
->i32
/ v2
->i8
;
2466 res
->i64
= v1
->i32
/ v2
->u8
;
2469 res
->i64
= v1
->i32
/ v2
->i16
;
2472 res
->i64
= v1
->i32
/ v2
->u16
;
2475 res
->i64
= v1
->i32
/ v2
->i32
;
2478 res
->i64
= v1
->i32
/ v2
->u32
;
2481 res
->i64
= v1
->i32
/ v2
->i64
;
2484 res
->i64
= v1
->i32
/ v2
->u64
;
2488 res
->i128
= v1
->i32
/ v2
->i128
;
2489 return PSI_T_INT128
;
2494 res
->u128
= v1
->i32
/ v2
->u128
;
2495 return PSI_T_UINT128
;
2499 res
->fval
= v1
->i32
/ v2
->fval
;
2502 res
->dval
= v1
->i32
/ v2
->dval
;
2503 return PSI_T_DOUBLE
;
2504 # if HAVE_LONG_DOUBLE
2505 case PSI_T_LONG_DOUBLE
:
2506 res
->ldval
= v1
->i32
/ v2
->ldval
;
2507 return PSI_T_LONG_DOUBLE
;
2518 res
->i64
= v1
->u32
/ v2
->i8
;
2521 res
->u64
= v1
->u32
/ v2
->u8
;
2522 return PSI_T_UINT64
;
2524 res
->i64
= v1
->u32
/ v2
->i16
;
2527 res
->u64
= v1
->u32
/ v2
->u16
;
2528 return PSI_T_UINT64
;
2530 res
->i64
= v1
->u32
/ v2
->i32
;
2533 res
->u64
= v1
->u32
/ v2
->u32
;
2534 return PSI_T_UINT64
;
2536 res
->i64
= v1
->u32
/ v2
->i64
;
2539 res
->u64
= v1
->u32
/ v2
->u64
;
2540 return PSI_T_UINT64
;
2543 res
->i128
= v1
->u32
/ v2
->i128
;
2544 return PSI_T_INT128
;
2549 res
->u128
= v1
->u32
/ v2
->u128
;
2550 return PSI_T_UINT128
;
2554 res
->fval
= v1
->u32
/ v2
->fval
;
2557 res
->dval
= v1
->u32
/ v2
->dval
;
2558 return PSI_T_DOUBLE
;
2559 # if HAVE_LONG_DOUBLE
2560 case PSI_T_LONG_DOUBLE
:
2561 res
->ldval
= v1
->u32
/ v2
->ldval
;
2562 return PSI_T_LONG_DOUBLE
;
2573 res
->i64
= v1
->i64
/ v2
->i8
;
2576 res
->i64
= v1
->i64
/ v2
->u8
;
2579 res
->i64
= v1
->i64
/ v2
->i16
;
2582 res
->i64
= v1
->i64
/ v2
->u16
;
2585 res
->i64
= v1
->i64
/ v2
->i32
;
2588 res
->i64
= v1
->i64
/ v2
->u32
;
2591 res
->i64
= v1
->i64
/ v2
->i64
;
2594 res
->i64
= v1
->i64
/ v2
->u64
;
2598 res
->i128
= v1
->i64
/ v2
->i128
;
2599 return PSI_T_INT128
;
2604 res
->u128
= v1
->i64
/ v2
->u128
;
2605 return PSI_T_UINT128
;
2609 res
->fval
= v1
->i64
/ v2
->fval
;
2612 res
->dval
= v1
->i64
/ v2
->dval
;
2613 return PSI_T_DOUBLE
;
2614 # if HAVE_LONG_DOUBLE
2615 case PSI_T_LONG_DOUBLE
:
2616 res
->ldval
= v1
->i64
/ v2
->ldval
;
2617 return PSI_T_LONG_DOUBLE
;
2628 res
->i64
= v1
->u64
/ v2
->i8
;
2631 res
->u64
= v1
->u64
/ v2
->u8
;
2632 return PSI_T_UINT64
;
2634 res
->i64
= v1
->u64
/ v2
->i16
;
2637 res
->u64
= v1
->u64
/ v2
->u16
;
2638 return PSI_T_UINT64
;
2640 res
->i64
= v1
->u64
/ v2
->i32
;
2643 res
->u64
= v1
->u64
/ v2
->u32
;
2644 return PSI_T_UINT64
;
2646 res
->i64
= v1
->u64
/ v2
->i64
;
2649 res
->u64
= v1
->u64
/ v2
->u64
;
2650 return PSI_T_UINT64
;
2653 res
->i128
= v1
->u64
/ v2
->i128
;
2654 return PSI_T_INT128
;
2659 res
->u128
= v1
->u64
/ v2
->u128
;
2660 return PSI_T_UINT128
;
2664 res
->fval
= v1
->u64
/ v2
->fval
;
2667 res
->dval
= v1
->u64
/ v2
->dval
;
2668 return PSI_T_DOUBLE
;
2669 # if HAVE_LONG_DOUBLE
2670 case PSI_T_LONG_DOUBLE
:
2671 res
->ldval
= v1
->u64
/ v2
->ldval
;
2672 return PSI_T_LONG_DOUBLE
;
2684 res
->i128
= v1
->i128
/ v2
->i8
;
2685 return PSI_T_INT128
;
2687 res
->i128
= v1
->i128
/ v2
->u8
;
2688 return PSI_T_INT128
;
2690 res
->i128
= v1
->i128
/ v2
->i16
;
2691 return PSI_T_INT128
;
2693 res
->i128
= v1
->i128
/ v2
->u16
;
2694 return PSI_T_INT128
;
2696 res
->i128
= v1
->i128
/ v2
->i32
;
2697 return PSI_T_INT128
;
2699 res
->i128
= v1
->i128
/ v2
->u32
;
2700 return PSI_T_INT128
;
2702 res
->i128
= v1
->i128
/ v2
->i64
;
2703 return PSI_T_INT128
;
2705 res
->i128
= v1
->i128
/ v2
->u64
;
2706 return PSI_T_INT128
;
2709 res
->i128
= v1
->i128
/ v2
->i128
;
2710 return PSI_T_INT128
;
2715 res
->u128
= v1
->i128
/ v2
->u128
;
2716 return PSI_T_UINT128
;
2720 res
->fval
= v1
->i128
/ v2
->fval
;
2723 res
->dval
= v1
->i128
/ v2
->dval
;
2724 return PSI_T_DOUBLE
;
2725 # if HAVE_LONG_DOUBLE
2726 case PSI_T_LONG_DOUBLE
:
2727 res
->ldval
= v1
->i128
/ v2
->ldval
;
2728 return PSI_T_LONG_DOUBLE
;
2742 res
->u128
= v1
->u128
/ v2
->i8
;
2743 return PSI_T_UINT128
;
2745 res
->u128
= v1
->u128
/ v2
->u8
;
2746 return PSI_T_UINT128
;
2748 res
->u128
= v1
->u128
/ v2
->i16
;
2749 return PSI_T_UINT128
;
2751 res
->u128
= v1
->u128
/ v2
->u16
;
2752 return PSI_T_UINT128
;
2754 res
->u128
= v1
->u128
/ v2
->i32
;
2755 return PSI_T_UINT128
;
2757 res
->u128
= v1
->u128
/ v2
->u32
;
2758 return PSI_T_UINT128
;
2760 res
->u128
= v1
->u128
/ v2
->i64
;
2761 return PSI_T_UINT128
;
2763 res
->u128
= v1
->u128
/ v2
->u64
;
2764 return PSI_T_UINT128
;
2767 res
->u128
= v1
->u128
/ v2
->i128
;
2768 return PSI_T_UINT128
;
2773 res
->u128
= v1
->u128
/ v2
->u128
;
2774 return PSI_T_UINT128
;
2778 res
->fval
= v1
->u128
/ v2
->fval
;
2781 res
->dval
= v1
->u128
/ v2
->dval
;
2782 return PSI_T_DOUBLE
;
2783 # if HAVE_LONG_DOUBLE
2784 case PSI_T_LONG_DOUBLE
:
2785 res
->ldval
= v1
->u128
/ v2
->ldval
;
2786 return PSI_T_LONG_DOUBLE
;
2799 res
->fval
= v1
->fval
/ v2
->i8
;
2802 res
->fval
= v1
->fval
/ v2
->u8
;
2805 res
->fval
= v1
->fval
/ v2
->i16
;
2808 res
->fval
= v1
->fval
/ v2
->u16
;
2811 res
->fval
= v1
->fval
/ v2
->i32
;
2814 res
->fval
= v1
->fval
/ v2
->u32
;
2817 res
->fval
= v1
->fval
/ v2
->i64
;
2820 res
->fval
= v1
->fval
/ v2
->u64
;
2824 res
->fval
= v1
->fval
/ v2
->i128
;
2830 res
->fval
= v1
->fval
/ v2
->u128
;
2835 res
->fval
= v1
->fval
/ v2
->fval
;
2838 res
->dval
= v1
->fval
/ v2
->dval
;
2839 return PSI_T_DOUBLE
;
2840 # if HAVE_LONG_DOUBLE
2841 case PSI_T_LONG_DOUBLE
:
2842 res
->ldval
= v1
->fval
/ v2
->ldval
;
2843 return PSI_T_LONG_DOUBLE
;
2854 res
->dval
= v1
->dval
/ v2
->i8
;
2855 return PSI_T_DOUBLE
;
2857 res
->dval
= v1
->dval
/ v2
->u8
;
2858 return PSI_T_DOUBLE
;
2860 res
->dval
= v1
->dval
/ v2
->i16
;
2861 return PSI_T_DOUBLE
;
2863 res
->dval
= v1
->dval
/ v2
->u16
;
2864 return PSI_T_DOUBLE
;
2866 res
->dval
= v1
->dval
/ v2
->i32
;
2867 return PSI_T_DOUBLE
;
2869 res
->dval
= v1
->dval
/ v2
->u32
;
2870 return PSI_T_DOUBLE
;
2872 res
->dval
= v1
->dval
/ v2
->i64
;
2873 return PSI_T_DOUBLE
;
2875 res
->dval
= v1
->dval
/ v2
->u64
;
2876 return PSI_T_DOUBLE
;
2879 res
->dval
= v1
->dval
/ v2
->i128
;
2880 return PSI_T_DOUBLE
;
2885 res
->dval
= v1
->dval
/ v2
->u128
;
2886 return PSI_T_DOUBLE
;
2890 res
->dval
= v1
->dval
/ v2
->fval
;
2891 return PSI_T_DOUBLE
;
2893 res
->dval
= v1
->dval
/ v2
->dval
;
2894 return PSI_T_DOUBLE
;
2895 # if HAVE_LONG_DOUBLE
2896 case PSI_T_LONG_DOUBLE
:
2897 res
->ldval
= v1
->dval
/ v2
->ldval
;
2898 return PSI_T_LONG_DOUBLE
;
2906 #if HAVE_LONG_DOUBLE
2907 case PSI_T_LONG_DOUBLE
:
2910 res
->ldval
= v1
->ldval
/ v2
->i8
;
2911 return PSI_T_LONG_DOUBLE
;
2913 res
->ldval
= v1
->ldval
/ v2
->u8
;
2914 return PSI_T_LONG_DOUBLE
;
2916 res
->ldval
= v1
->ldval
/ v2
->i16
;
2917 return PSI_T_LONG_DOUBLE
;
2919 res
->ldval
= v1
->ldval
/ v2
->u16
;
2920 return PSI_T_LONG_DOUBLE
;
2922 res
->ldval
= v1
->ldval
/ v2
->i32
;
2923 return PSI_T_LONG_DOUBLE
;
2925 res
->ldval
= v1
->ldval
/ v2
->u32
;
2926 return PSI_T_LONG_DOUBLE
;
2928 res
->ldval
= v1
->ldval
/ v2
->i64
;
2929 return PSI_T_LONG_DOUBLE
;
2931 res
->ldval
= v1
->ldval
/ v2
->u64
;
2932 return PSI_T_LONG_DOUBLE
;
2935 res
->ldval
= v1
->ldval
/ v2
->i128
;
2936 return PSI_T_LONG_DOUBLE
;
2941 res
->ldval
= v1
->ldval
/ v2
->u128
;
2942 return PSI_T_LONG_DOUBLE
;
2946 res
->ldval
= v1
->ldval
/ v2
->fval
;
2947 return PSI_T_LONG_DOUBLE
;
2949 res
->ldval
= v1
->ldval
/ v2
->dval
;
2950 return PSI_T_LONG_DOUBLE
;
2951 # if HAVE_LONG_DOUBLE
2952 case PSI_T_LONG_DOUBLE
:
2953 res
->ldval
= v1
->ldval
/ v2
->ldval
;
2954 return PSI_T_LONG_DOUBLE
;
2973 static inline token_t
psi_calc_mod(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
3032 #if HAVE_LONG_DOUBLE
3033 case PSI_T_LONG_DOUBLE
:
3087 #if HAVE_LONG_DOUBLE
3088 case PSI_T_LONG_DOUBLE
:
3098 res
->i64
= i1
.i64
% i2
.i64
;