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
->i128
= v1
->i8
+ v2
->i128
;
65 res
->u128
= v1
->i8
+ v2
->u128
;
68 res
->fval
= v1
->i8
+ v2
->fval
;
71 res
->dval
= v1
->i8
+ v2
->dval
;
74 case PSI_T_LONG_DOUBLE
:
75 res
->ldval
= v1
->i8
+ v2
->ldval
;
76 return PSI_T_LONG_DOUBLE
;
87 res
->i16
= v1
->u8
+ v2
->i8
;
90 res
->u16
= v1
->u8
+ v2
->u8
;
93 res
->i32
= v1
->u8
+ v2
->i16
;
96 res
->u32
= v1
->u8
+ v2
->u16
;
99 res
->i64
= v1
->u8
+ v2
->i32
;
102 res
->u64
= v1
->u8
+ v2
->u32
;
105 res
->i64
= v1
->u8
+ v2
->i64
;
108 res
->u64
= v1
->u8
+ v2
->u64
;
111 res
->i128
= v1
->u8
+ v2
->i128
;
114 res
->u128
= v1
->u8
+ v2
->u128
;
115 return PSI_T_UINT128
;
117 res
->fval
= v1
->u8
+ v2
->fval
;
120 res
->dval
= v1
->u8
+ v2
->dval
;
122 # if HAVE_LONG_DOUBLE
123 case PSI_T_LONG_DOUBLE
:
124 res
->ldval
= v1
->u8
+ v2
->ldval
;
125 return PSI_T_LONG_DOUBLE
;
136 res
->i32
= v1
->i16
+ v2
->i8
;
139 res
->i32
= v1
->i16
+ v2
->u8
;
142 res
->i32
= v1
->i16
+ v2
->i16
;
145 res
->i32
= v1
->i16
+ v2
->u16
;
148 res
->i64
= v1
->i16
+ v2
->i32
;
151 res
->i64
= v1
->i16
+ v2
->u32
;
154 res
->i64
= v1
->i16
+ v2
->i64
;
157 res
->i64
= v1
->i16
+ v2
->u64
;
160 res
->i128
= v1
->i16
+ v2
->i128
;
163 res
->u128
= v1
->i16
+ v2
->u128
;
164 return PSI_T_UINT128
;
166 res
->fval
= v1
->i16
+ v2
->fval
;
169 res
->dval
= v1
->i16
+ v2
->dval
;
171 # if HAVE_LONG_DOUBLE
172 case PSI_T_LONG_DOUBLE
:
173 res
->ldval
= v1
->i16
+ v2
->ldval
;
174 return PSI_T_LONG_DOUBLE
;
185 res
->i32
= v1
->u16
+ v2
->i8
;
188 res
->u32
= v1
->u16
+ v2
->u8
;
191 res
->i32
= v1
->u16
+ v2
->i16
;
194 res
->u32
= v1
->u16
+ v2
->u16
;
197 res
->i64
= v1
->u16
+ v2
->i32
;
200 res
->u64
= v1
->u16
+ v2
->u32
;
203 res
->i64
= v1
->u16
+ v2
->i64
;
206 res
->u64
= v1
->u16
+ v2
->u64
;
209 res
->i128
= v1
->u16
+ v2
->i128
;
212 res
->u128
= v1
->u16
+ v2
->u128
;
213 return PSI_T_UINT128
;
215 res
->fval
= v1
->u16
+ v2
->fval
;
218 res
->dval
= v1
->u16
+ v2
->dval
;
220 # if HAVE_LONG_DOUBLE
221 case PSI_T_LONG_DOUBLE
:
222 res
->ldval
= v1
->u16
+ v2
->ldval
;
223 return PSI_T_LONG_DOUBLE
;
234 res
->i64
= v1
->i32
+ v2
->i8
;
237 res
->i64
= v1
->i32
+ v2
->u8
;
240 res
->i64
= v1
->i32
+ v2
->i16
;
243 res
->i64
= v1
->i32
+ v2
->u16
;
246 res
->i64
= v1
->i32
+ v2
->i32
;
249 res
->i64
= v1
->i32
+ v2
->u32
;
252 res
->i64
= v1
->i32
+ v2
->i64
;
255 res
->i64
= v1
->i32
+ v2
->u64
;
258 res
->i128
= v1
->i32
+ v2
->i128
;
261 res
->u128
= v1
->i32
+ v2
->u128
;
262 return PSI_T_UINT128
;
264 res
->fval
= v1
->i32
+ v2
->fval
;
267 res
->dval
= v1
->i32
+ v2
->dval
;
269 # if HAVE_LONG_DOUBLE
270 case PSI_T_LONG_DOUBLE
:
271 res
->ldval
= v1
->i32
+ v2
->ldval
;
272 return PSI_T_LONG_DOUBLE
;
283 res
->i64
= v1
->u32
+ v2
->i8
;
286 res
->u64
= v1
->u32
+ v2
->u8
;
289 res
->i64
= v1
->u32
+ v2
->i16
;
292 res
->u64
= v1
->u32
+ v2
->u16
;
295 res
->i64
= v1
->u32
+ v2
->i32
;
298 res
->u64
= v1
->u32
+ v2
->u32
;
301 res
->i64
= v1
->u32
+ v2
->i64
;
304 res
->u64
= v1
->u32
+ v2
->u64
;
307 res
->i128
= v1
->u32
+ v2
->i128
;
310 res
->u128
= v1
->u32
+ v2
->u128
;
311 return PSI_T_UINT128
;
313 res
->fval
= v1
->u32
+ v2
->fval
;
316 res
->dval
= v1
->u32
+ v2
->dval
;
318 # if HAVE_LONG_DOUBLE
319 case PSI_T_LONG_DOUBLE
:
320 res
->ldval
= v1
->u32
+ v2
->ldval
;
321 return PSI_T_LONG_DOUBLE
;
332 res
->i64
= v1
->i64
+ v2
->i8
;
335 res
->i64
= v1
->i64
+ v2
->u8
;
338 res
->i64
= v1
->i64
+ v2
->i16
;
341 res
->i64
= v1
->i64
+ v2
->u16
;
344 res
->i64
= v1
->i64
+ v2
->i32
;
347 res
->i64
= v1
->i64
+ v2
->u32
;
350 res
->i64
= v1
->i64
+ v2
->i64
;
353 res
->i64
= v1
->i64
+ v2
->u64
;
356 res
->i128
= v1
->i64
+ v2
->i128
;
359 res
->u128
= v1
->i64
+ v2
->u128
;
360 return PSI_T_UINT128
;
362 res
->fval
= v1
->i64
+ v2
->fval
;
365 res
->dval
= v1
->i64
+ v2
->dval
;
367 # if HAVE_LONG_DOUBLE
368 case PSI_T_LONG_DOUBLE
:
369 res
->ldval
= v1
->i64
+ v2
->ldval
;
370 return PSI_T_LONG_DOUBLE
;
381 res
->i64
= v1
->u64
+ v2
->i8
;
384 res
->u64
= v1
->u64
+ v2
->u8
;
387 res
->i64
= v1
->u64
+ v2
->i16
;
390 res
->u64
= v1
->u64
+ v2
->u16
;
393 res
->i64
= v1
->u64
+ v2
->i32
;
396 res
->u64
= v1
->u64
+ v2
->u32
;
399 res
->i64
= v1
->u64
+ v2
->i64
;
402 res
->u64
= v1
->u64
+ v2
->u64
;
405 res
->i128
= v1
->u64
+ v2
->i128
;
408 res
->u128
= v1
->u64
+ v2
->u128
;
409 return PSI_T_UINT128
;
411 res
->fval
= v1
->u64
+ v2
->fval
;
414 res
->dval
= v1
->u64
+ v2
->dval
;
416 # if HAVE_LONG_DOUBLE
417 case PSI_T_LONG_DOUBLE
:
418 res
->ldval
= v1
->u64
+ v2
->ldval
;
419 return PSI_T_LONG_DOUBLE
;
430 res
->i128
= v1
->i128
+ v2
->i8
;
433 res
->i128
= v1
->i128
+ v2
->u8
;
436 res
->i128
= v1
->i128
+ v2
->i16
;
439 res
->i128
= v1
->i128
+ v2
->u16
;
442 res
->i128
= v1
->i128
+ v2
->i32
;
445 res
->i128
= v1
->i128
+ v2
->u32
;
448 res
->i128
= v1
->i128
+ v2
->i64
;
451 res
->i128
= v1
->i128
+ v2
->u64
;
454 res
->i128
= v1
->i128
+ v2
->i128
;
457 res
->u128
= v1
->i128
+ v2
->u128
;
458 return PSI_T_UINT128
;
460 res
->fval
= v1
->i128
+ v2
->fval
;
463 res
->dval
= v1
->i128
+ v2
->dval
;
465 # if HAVE_LONG_DOUBLE
466 case PSI_T_LONG_DOUBLE
:
467 res
->ldval
= v1
->i128
+ v2
->ldval
;
468 return PSI_T_LONG_DOUBLE
;
479 res
->u128
= v1
->u128
+ v2
->i8
;
480 return PSI_T_UINT128
;
482 res
->u128
= v1
->u128
+ v2
->u8
;
483 return PSI_T_UINT128
;
485 res
->u128
= v1
->u128
+ v2
->i16
;
486 return PSI_T_UINT128
;
488 res
->u128
= v1
->u128
+ v2
->u16
;
489 return PSI_T_UINT128
;
491 res
->u128
= v1
->u128
+ v2
->i32
;
492 return PSI_T_UINT128
;
494 res
->u128
= v1
->u128
+ v2
->u32
;
495 return PSI_T_UINT128
;
497 res
->u128
= v1
->u128
+ v2
->i64
;
498 return PSI_T_UINT128
;
500 res
->u128
= v1
->u128
+ v2
->u64
;
501 return PSI_T_UINT128
;
503 res
->u128
= v1
->u128
+ v2
->i128
;
504 return PSI_T_UINT128
;
506 res
->u128
= v1
->u128
+ v2
->u128
;
507 return PSI_T_UINT128
;
509 res
->fval
= v1
->u128
+ v2
->fval
;
512 res
->dval
= v1
->u128
+ v2
->dval
;
514 # if HAVE_LONG_DOUBLE
515 case PSI_T_LONG_DOUBLE
:
516 res
->ldval
= v1
->u128
+ v2
->ldval
;
517 return PSI_T_LONG_DOUBLE
;
528 res
->fval
= v1
->fval
+ v2
->i8
;
531 res
->fval
= v1
->fval
+ v2
->u8
;
534 res
->fval
= v1
->fval
+ v2
->i16
;
537 res
->fval
= v1
->fval
+ v2
->u16
;
540 res
->fval
= v1
->fval
+ v2
->i32
;
543 res
->fval
= v1
->fval
+ v2
->u32
;
546 res
->fval
= v1
->fval
+ v2
->i64
;
549 res
->fval
= v1
->fval
+ v2
->u64
;
552 res
->fval
= v1
->fval
+ v2
->i128
;
555 res
->fval
= v1
->fval
+ v2
->u128
;
558 res
->fval
= v1
->fval
+ v2
->fval
;
561 res
->dval
= v1
->fval
+ v2
->dval
;
563 # if HAVE_LONG_DOUBLE
564 case PSI_T_LONG_DOUBLE
:
565 res
->ldval
= v1
->fval
+ v2
->ldval
;
566 return PSI_T_LONG_DOUBLE
;
577 res
->dval
= v1
->dval
+ v2
->i8
;
580 res
->dval
= v1
->dval
+ v2
->u8
;
583 res
->dval
= v1
->dval
+ v2
->i16
;
586 res
->dval
= v1
->dval
+ v2
->u16
;
589 res
->dval
= v1
->dval
+ v2
->i32
;
592 res
->dval
= v1
->dval
+ v2
->u32
;
595 res
->dval
= v1
->dval
+ v2
->i64
;
598 res
->dval
= v1
->dval
+ v2
->u64
;
601 res
->dval
= v1
->dval
+ v2
->i128
;
604 res
->dval
= v1
->dval
+ v2
->u128
;
607 res
->dval
= v1
->dval
+ v2
->fval
;
610 res
->dval
= v1
->dval
+ v2
->dval
;
612 # if HAVE_LONG_DOUBLE
613 case PSI_T_LONG_DOUBLE
:
614 res
->ldval
= v1
->dval
+ v2
->ldval
;
615 return PSI_T_LONG_DOUBLE
;
624 case PSI_T_LONG_DOUBLE
:
627 res
->ldval
= v1
->ldval
+ v2
->i8
;
628 return PSI_T_LONG_DOUBLE
;
630 res
->ldval
= v1
->ldval
+ v2
->u8
;
631 return PSI_T_LONG_DOUBLE
;
633 res
->ldval
= v1
->ldval
+ v2
->i16
;
634 return PSI_T_LONG_DOUBLE
;
636 res
->ldval
= v1
->ldval
+ v2
->u16
;
637 return PSI_T_LONG_DOUBLE
;
639 res
->ldval
= v1
->ldval
+ v2
->i32
;
640 return PSI_T_LONG_DOUBLE
;
642 res
->ldval
= v1
->ldval
+ v2
->u32
;
643 return PSI_T_LONG_DOUBLE
;
645 res
->ldval
= v1
->ldval
+ v2
->i64
;
646 return PSI_T_LONG_DOUBLE
;
648 res
->ldval
= v1
->ldval
+ v2
->u64
;
649 return PSI_T_LONG_DOUBLE
;
651 res
->ldval
= v1
->ldval
+ v2
->i128
;
652 return PSI_T_LONG_DOUBLE
;
654 res
->ldval
= v1
->ldval
+ v2
->u128
;
655 return PSI_T_LONG_DOUBLE
;
657 res
->ldval
= v1
->ldval
+ v2
->fval
;
658 return PSI_T_LONG_DOUBLE
;
660 res
->ldval
= v1
->ldval
+ v2
->dval
;
661 return PSI_T_LONG_DOUBLE
;
662 # if HAVE_LONG_DOUBLE
663 case PSI_T_LONG_DOUBLE
:
664 res
->ldval
= v1
->ldval
+ v2
->ldval
;
665 return PSI_T_LONG_DOUBLE
;
682 static inline token_t
psi_calc_sub(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
689 res
->i16
= v1
->i8
- v2
->i8
;
692 res
->i16
= v1
->i8
- v2
->u8
;
695 res
->i32
= v1
->i8
- v2
->i16
;
698 res
->i32
= v1
->i8
- v2
->u16
;
701 res
->i64
= v1
->i8
- v2
->i32
;
704 res
->i64
= v1
->i8
- v2
->u32
;
707 res
->i64
= v1
->i8
- v2
->i64
;
710 res
->i64
= v1
->i8
- v2
->u64
;
713 res
->i128
= v1
->i8
- v2
->i128
;
716 res
->u128
= v1
->i8
- v2
->u128
;
717 return PSI_T_UINT128
;
719 res
->fval
= v1
->i8
- v2
->fval
;
722 res
->dval
= v1
->i8
- v2
->dval
;
724 # if HAVE_LONG_DOUBLE
725 case PSI_T_LONG_DOUBLE
:
726 res
->ldval
= v1
->i8
- v2
->ldval
;
727 return PSI_T_LONG_DOUBLE
;
738 res
->i16
= v1
->u8
- v2
->i8
;
741 res
->u16
= v1
->u8
- v2
->u8
;
744 res
->i32
= v1
->u8
- v2
->i16
;
747 res
->u32
= v1
->u8
- v2
->u16
;
750 res
->i64
= v1
->u8
- v2
->i32
;
753 res
->u64
= v1
->u8
- v2
->u32
;
756 res
->i64
= v1
->u8
- v2
->i64
;
759 res
->u64
= v1
->u8
- v2
->u64
;
762 res
->i128
= v1
->u8
- v2
->i128
;
765 res
->u128
= v1
->u8
- v2
->u128
;
766 return PSI_T_UINT128
;
768 res
->fval
= v1
->u8
- v2
->fval
;
771 res
->dval
= v1
->u8
- v2
->dval
;
773 # if HAVE_LONG_DOUBLE
774 case PSI_T_LONG_DOUBLE
:
775 res
->ldval
= v1
->u8
- v2
->ldval
;
776 return PSI_T_LONG_DOUBLE
;
787 res
->i32
= v1
->i16
- v2
->i8
;
790 res
->i32
= v1
->i16
- v2
->u8
;
793 res
->i32
= v1
->i16
- v2
->i16
;
796 res
->i32
= v1
->i16
- v2
->u16
;
799 res
->i64
= v1
->i16
- v2
->i32
;
802 res
->i64
= v1
->i16
- v2
->u32
;
805 res
->i64
= v1
->i16
- v2
->i64
;
808 res
->i64
= v1
->i16
- v2
->u64
;
811 res
->i128
= v1
->i16
- v2
->i128
;
814 res
->u128
= v1
->i16
- v2
->u128
;
815 return PSI_T_UINT128
;
817 res
->fval
= v1
->i16
- v2
->fval
;
820 res
->dval
= v1
->i16
- v2
->dval
;
822 # if HAVE_LONG_DOUBLE
823 case PSI_T_LONG_DOUBLE
:
824 res
->ldval
= v1
->i16
- v2
->ldval
;
825 return PSI_T_LONG_DOUBLE
;
836 res
->i32
= v1
->u16
- v2
->i8
;
839 res
->u32
= v1
->u16
- v2
->u8
;
842 res
->i32
= v1
->u16
- v2
->i16
;
845 res
->u32
= v1
->u16
- v2
->u16
;
848 res
->i64
= v1
->u16
- v2
->i32
;
851 res
->u64
= v1
->u16
- v2
->u32
;
854 res
->i64
= v1
->u16
- v2
->i64
;
857 res
->u64
= v1
->u16
- v2
->u64
;
860 res
->i128
= v1
->u16
- v2
->i128
;
863 res
->u128
= v1
->u16
- v2
->u128
;
864 return PSI_T_UINT128
;
866 res
->fval
= v1
->u16
- v2
->fval
;
869 res
->dval
= v1
->u16
- v2
->dval
;
871 # if HAVE_LONG_DOUBLE
872 case PSI_T_LONG_DOUBLE
:
873 res
->ldval
= v1
->u16
- v2
->ldval
;
874 return PSI_T_LONG_DOUBLE
;
885 res
->i64
= v1
->i32
- v2
->i8
;
888 res
->i64
= v1
->i32
- v2
->u8
;
891 res
->i64
= v1
->i32
- v2
->i16
;
894 res
->i64
= v1
->i32
- v2
->u16
;
897 res
->i64
= v1
->i32
- v2
->i32
;
900 res
->i64
= v1
->i32
- v2
->u32
;
903 res
->i64
= v1
->i32
- v2
->i64
;
906 res
->i64
= v1
->i32
- v2
->u64
;
909 res
->i128
= v1
->i32
- v2
->i128
;
912 res
->u128
= v1
->i32
- v2
->u128
;
913 return PSI_T_UINT128
;
915 res
->fval
= v1
->i32
- v2
->fval
;
918 res
->dval
= v1
->i32
- v2
->dval
;
920 # if HAVE_LONG_DOUBLE
921 case PSI_T_LONG_DOUBLE
:
922 res
->ldval
= v1
->i32
- v2
->ldval
;
923 return PSI_T_LONG_DOUBLE
;
934 res
->i64
= v1
->u32
- v2
->i8
;
937 res
->u64
= v1
->u32
- v2
->u8
;
940 res
->i64
= v1
->u32
- v2
->i16
;
943 res
->u64
= v1
->u32
- v2
->u16
;
946 res
->i64
= v1
->u32
- v2
->i32
;
949 res
->u64
= v1
->u32
- v2
->u32
;
952 res
->i64
= v1
->u32
- v2
->i64
;
955 res
->u64
= v1
->u32
- v2
->u64
;
958 res
->i128
= v1
->u32
- v2
->i128
;
961 res
->u128
= v1
->u32
- v2
->u128
;
962 return PSI_T_UINT128
;
964 res
->fval
= v1
->u32
- v2
->fval
;
967 res
->dval
= v1
->u32
- v2
->dval
;
969 # if HAVE_LONG_DOUBLE
970 case PSI_T_LONG_DOUBLE
:
971 res
->ldval
= v1
->u32
- v2
->ldval
;
972 return PSI_T_LONG_DOUBLE
;
983 res
->i64
= v1
->i64
- v2
->i8
;
986 res
->i64
= v1
->i64
- v2
->u8
;
989 res
->i64
= v1
->i64
- v2
->i16
;
992 res
->i64
= v1
->i64
- v2
->u16
;
995 res
->i64
= v1
->i64
- v2
->i32
;
998 res
->i64
= v1
->i64
- v2
->u32
;
1001 res
->i64
= v1
->i64
- v2
->i64
;
1004 res
->i64
= v1
->i64
- v2
->u64
;
1007 res
->i128
= v1
->i64
- v2
->i128
;
1008 return PSI_T_INT128
;
1010 res
->u128
= v1
->i64
- v2
->u128
;
1011 return PSI_T_UINT128
;
1013 res
->fval
= v1
->i64
- v2
->fval
;
1016 res
->dval
= v1
->i64
- v2
->dval
;
1017 return PSI_T_DOUBLE
;
1018 # if HAVE_LONG_DOUBLE
1019 case PSI_T_LONG_DOUBLE
:
1020 res
->ldval
= v1
->i64
- v2
->ldval
;
1021 return PSI_T_LONG_DOUBLE
;
1032 res
->i64
= v1
->u64
- v2
->i8
;
1035 res
->u64
= v1
->u64
- v2
->u8
;
1036 return PSI_T_UINT64
;
1038 res
->i64
= v1
->u64
- v2
->i16
;
1041 res
->u64
= v1
->u64
- v2
->u16
;
1042 return PSI_T_UINT64
;
1044 res
->i64
= v1
->u64
- v2
->i32
;
1047 res
->u64
= v1
->u64
- v2
->u32
;
1048 return PSI_T_UINT64
;
1050 res
->i64
= v1
->u64
- v2
->i64
;
1053 res
->u64
= v1
->u64
- v2
->u64
;
1054 return PSI_T_UINT64
;
1056 res
->i128
= v1
->u64
- v2
->i128
;
1057 return PSI_T_INT128
;
1059 res
->u128
= v1
->u64
- v2
->u128
;
1060 return PSI_T_UINT128
;
1062 res
->fval
= v1
->u64
- v2
->fval
;
1065 res
->dval
= v1
->u64
- v2
->dval
;
1066 return PSI_T_DOUBLE
;
1067 # if HAVE_LONG_DOUBLE
1068 case PSI_T_LONG_DOUBLE
:
1069 res
->ldval
= v1
->u64
- v2
->ldval
;
1070 return PSI_T_LONG_DOUBLE
;
1081 res
->i128
= v1
->i128
- v2
->i8
;
1082 return PSI_T_INT128
;
1084 res
->i128
= v1
->i128
- v2
->u8
;
1085 return PSI_T_INT128
;
1087 res
->i128
= v1
->i128
- v2
->i16
;
1088 return PSI_T_INT128
;
1090 res
->i128
= v1
->i128
- v2
->u16
;
1091 return PSI_T_INT128
;
1093 res
->i128
= v1
->i128
- v2
->i32
;
1094 return PSI_T_INT128
;
1096 res
->i128
= v1
->i128
- v2
->u32
;
1097 return PSI_T_INT128
;
1099 res
->i128
= v1
->i128
- v2
->i64
;
1100 return PSI_T_INT128
;
1102 res
->i128
= v1
->i128
- v2
->u64
;
1103 return PSI_T_INT128
;
1105 res
->i128
= v1
->i128
- v2
->i128
;
1106 return PSI_T_INT128
;
1108 res
->u128
= v1
->i128
- v2
->u128
;
1109 return PSI_T_UINT128
;
1111 res
->fval
= v1
->i128
- v2
->fval
;
1114 res
->dval
= v1
->i128
- v2
->dval
;
1115 return PSI_T_DOUBLE
;
1116 # if HAVE_LONG_DOUBLE
1117 case PSI_T_LONG_DOUBLE
:
1118 res
->ldval
= v1
->i128
- v2
->ldval
;
1119 return PSI_T_LONG_DOUBLE
;
1130 res
->u128
= v1
->u128
- v2
->i8
;
1131 return PSI_T_UINT128
;
1133 res
->u128
= v1
->u128
- v2
->u8
;
1134 return PSI_T_UINT128
;
1136 res
->u128
= v1
->u128
- v2
->i16
;
1137 return PSI_T_UINT128
;
1139 res
->u128
= v1
->u128
- v2
->u16
;
1140 return PSI_T_UINT128
;
1142 res
->u128
= v1
->u128
- v2
->i32
;
1143 return PSI_T_UINT128
;
1145 res
->u128
= v1
->u128
- v2
->u32
;
1146 return PSI_T_UINT128
;
1148 res
->u128
= v1
->u128
- v2
->i64
;
1149 return PSI_T_UINT128
;
1151 res
->u128
= v1
->u128
- v2
->u64
;
1152 return PSI_T_UINT128
;
1154 res
->u128
= v1
->u128
- v2
->i128
;
1155 return PSI_T_UINT128
;
1157 res
->u128
= v1
->u128
- v2
->u128
;
1158 return PSI_T_UINT128
;
1160 res
->fval
= v1
->u128
- v2
->fval
;
1163 res
->dval
= v1
->u128
- v2
->dval
;
1164 return PSI_T_DOUBLE
;
1165 # if HAVE_LONG_DOUBLE
1166 case PSI_T_LONG_DOUBLE
:
1167 res
->ldval
= v1
->u128
- v2
->ldval
;
1168 return PSI_T_LONG_DOUBLE
;
1179 res
->fval
= v1
->fval
- v2
->i8
;
1182 res
->fval
= v1
->fval
- v2
->u8
;
1185 res
->fval
= v1
->fval
- v2
->i16
;
1188 res
->fval
= v1
->fval
- v2
->u16
;
1191 res
->fval
= v1
->fval
- v2
->i32
;
1194 res
->fval
= v1
->fval
- v2
->u32
;
1197 res
->fval
= v1
->fval
- v2
->i64
;
1200 res
->fval
= v1
->fval
- v2
->u64
;
1203 res
->fval
= v1
->fval
- v2
->i128
;
1206 res
->fval
= v1
->fval
- v2
->u128
;
1209 res
->fval
= v1
->fval
- v2
->fval
;
1212 res
->dval
= v1
->fval
- v2
->dval
;
1213 return PSI_T_DOUBLE
;
1214 # if HAVE_LONG_DOUBLE
1215 case PSI_T_LONG_DOUBLE
:
1216 res
->ldval
= v1
->fval
- v2
->ldval
;
1217 return PSI_T_LONG_DOUBLE
;
1228 res
->dval
= v1
->dval
- v2
->i8
;
1229 return PSI_T_DOUBLE
;
1231 res
->dval
= v1
->dval
- v2
->u8
;
1232 return PSI_T_DOUBLE
;
1234 res
->dval
= v1
->dval
- v2
->i16
;
1235 return PSI_T_DOUBLE
;
1237 res
->dval
= v1
->dval
- v2
->u16
;
1238 return PSI_T_DOUBLE
;
1240 res
->dval
= v1
->dval
- v2
->i32
;
1241 return PSI_T_DOUBLE
;
1243 res
->dval
= v1
->dval
- v2
->u32
;
1244 return PSI_T_DOUBLE
;
1246 res
->dval
= v1
->dval
- v2
->i64
;
1247 return PSI_T_DOUBLE
;
1249 res
->dval
= v1
->dval
- v2
->u64
;
1250 return PSI_T_DOUBLE
;
1252 res
->dval
= v1
->dval
- v2
->i128
;
1253 return PSI_T_DOUBLE
;
1255 res
->dval
= v1
->dval
- v2
->u128
;
1256 return PSI_T_DOUBLE
;
1258 res
->dval
= v1
->dval
- v2
->fval
;
1259 return PSI_T_DOUBLE
;
1261 res
->dval
= v1
->dval
- v2
->dval
;
1262 return PSI_T_DOUBLE
;
1263 # if HAVE_LONG_DOUBLE
1264 case PSI_T_LONG_DOUBLE
:
1265 res
->ldval
= v1
->dval
- v2
->ldval
;
1266 return PSI_T_LONG_DOUBLE
;
1274 #if HAVE_LONG_DOUBLE
1275 case PSI_T_LONG_DOUBLE
:
1278 res
->ldval
= v1
->ldval
- v2
->i8
;
1279 return PSI_T_LONG_DOUBLE
;
1281 res
->ldval
= v1
->ldval
- v2
->u8
;
1282 return PSI_T_LONG_DOUBLE
;
1284 res
->ldval
= v1
->ldval
- v2
->i16
;
1285 return PSI_T_LONG_DOUBLE
;
1287 res
->ldval
= v1
->ldval
- v2
->u16
;
1288 return PSI_T_LONG_DOUBLE
;
1290 res
->ldval
= v1
->ldval
- v2
->i32
;
1291 return PSI_T_LONG_DOUBLE
;
1293 res
->ldval
= v1
->ldval
- v2
->u32
;
1294 return PSI_T_LONG_DOUBLE
;
1296 res
->ldval
= v1
->ldval
- v2
->i64
;
1297 return PSI_T_LONG_DOUBLE
;
1299 res
->ldval
= v1
->ldval
- v2
->u64
;
1300 return PSI_T_LONG_DOUBLE
;
1302 res
->ldval
= v1
->ldval
- v2
->i128
;
1303 return PSI_T_LONG_DOUBLE
;
1305 res
->ldval
= v1
->ldval
- v2
->u128
;
1306 return PSI_T_LONG_DOUBLE
;
1308 res
->ldval
= v1
->ldval
- v2
->fval
;
1309 return PSI_T_LONG_DOUBLE
;
1311 res
->ldval
= v1
->ldval
- v2
->dval
;
1312 return PSI_T_LONG_DOUBLE
;
1313 # if HAVE_LONG_DOUBLE
1314 case PSI_T_LONG_DOUBLE
:
1315 res
->ldval
= v1
->ldval
- v2
->ldval
;
1316 return PSI_T_LONG_DOUBLE
;
1333 static inline token_t
psi_calc_mul(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
1340 res
->i16
= v1
->i8
* v2
->i8
;
1343 res
->i16
= v1
->i8
* v2
->u8
;
1346 res
->i32
= v1
->i8
* v2
->i16
;
1349 res
->i32
= v1
->i8
* v2
->u16
;
1352 res
->i64
= v1
->i8
* v2
->i32
;
1355 res
->i64
= v1
->i8
* v2
->u32
;
1358 res
->i64
= v1
->i8
* v2
->i64
;
1361 res
->i64
= v1
->i8
* v2
->u64
;
1364 res
->i128
= v1
->i8
* v2
->i128
;
1365 return PSI_T_INT128
;
1367 res
->u128
= v1
->i8
* v2
->u128
;
1368 return PSI_T_UINT128
;
1370 res
->fval
= v1
->i8
* v2
->fval
;
1373 res
->dval
= v1
->i8
* v2
->dval
;
1374 return PSI_T_DOUBLE
;
1375 # if HAVE_LONG_DOUBLE
1376 case PSI_T_LONG_DOUBLE
:
1377 res
->ldval
= v1
->i8
* v2
->ldval
;
1378 return PSI_T_LONG_DOUBLE
;
1389 res
->i16
= v1
->u8
* v2
->i8
;
1392 res
->u16
= v1
->u8
* v2
->u8
;
1393 return PSI_T_UINT16
;
1395 res
->i32
= v1
->u8
* v2
->i16
;
1398 res
->u32
= v1
->u8
* v2
->u16
;
1399 return PSI_T_UINT32
;
1401 res
->i64
= v1
->u8
* v2
->i32
;
1404 res
->u64
= v1
->u8
* v2
->u32
;
1405 return PSI_T_UINT64
;
1407 res
->i64
= v1
->u8
* v2
->i64
;
1410 res
->u64
= v1
->u8
* v2
->u64
;
1411 return PSI_T_UINT64
;
1413 res
->i128
= v1
->u8
* v2
->i128
;
1414 return PSI_T_INT128
;
1416 res
->u128
= v1
->u8
* v2
->u128
;
1417 return PSI_T_UINT128
;
1419 res
->fval
= v1
->u8
* v2
->fval
;
1422 res
->dval
= v1
->u8
* v2
->dval
;
1423 return PSI_T_DOUBLE
;
1424 # if HAVE_LONG_DOUBLE
1425 case PSI_T_LONG_DOUBLE
:
1426 res
->ldval
= v1
->u8
* v2
->ldval
;
1427 return PSI_T_LONG_DOUBLE
;
1438 res
->i32
= v1
->i16
* v2
->i8
;
1441 res
->i32
= v1
->i16
* v2
->u8
;
1444 res
->i32
= v1
->i16
* v2
->i16
;
1447 res
->i32
= v1
->i16
* v2
->u16
;
1450 res
->i64
= v1
->i16
* v2
->i32
;
1453 res
->i64
= v1
->i16
* v2
->u32
;
1456 res
->i64
= v1
->i16
* v2
->i64
;
1459 res
->i64
= v1
->i16
* v2
->u64
;
1462 res
->i128
= v1
->i16
* v2
->i128
;
1463 return PSI_T_INT128
;
1465 res
->u128
= v1
->i16
* v2
->u128
;
1466 return PSI_T_UINT128
;
1468 res
->fval
= v1
->i16
* v2
->fval
;
1471 res
->dval
= v1
->i16
* v2
->dval
;
1472 return PSI_T_DOUBLE
;
1473 # if HAVE_LONG_DOUBLE
1474 case PSI_T_LONG_DOUBLE
:
1475 res
->ldval
= v1
->i16
* v2
->ldval
;
1476 return PSI_T_LONG_DOUBLE
;
1487 res
->i32
= v1
->u16
* v2
->i8
;
1490 res
->u32
= v1
->u16
* v2
->u8
;
1491 return PSI_T_UINT32
;
1493 res
->i32
= v1
->u16
* v2
->i16
;
1496 res
->u32
= v1
->u16
* v2
->u16
;
1497 return PSI_T_UINT32
;
1499 res
->i64
= v1
->u16
* v2
->i32
;
1502 res
->u64
= v1
->u16
* v2
->u32
;
1503 return PSI_T_UINT64
;
1505 res
->i64
= v1
->u16
* v2
->i64
;
1508 res
->u64
= v1
->u16
* v2
->u64
;
1509 return PSI_T_UINT64
;
1511 res
->i128
= v1
->u16
* v2
->i128
;
1512 return PSI_T_INT128
;
1514 res
->u128
= v1
->u16
* v2
->u128
;
1515 return PSI_T_UINT128
;
1517 res
->fval
= v1
->u16
* v2
->fval
;
1520 res
->dval
= v1
->u16
* v2
->dval
;
1521 return PSI_T_DOUBLE
;
1522 # if HAVE_LONG_DOUBLE
1523 case PSI_T_LONG_DOUBLE
:
1524 res
->ldval
= v1
->u16
* v2
->ldval
;
1525 return PSI_T_LONG_DOUBLE
;
1536 res
->i64
= v1
->i32
* v2
->i8
;
1539 res
->i64
= v1
->i32
* v2
->u8
;
1542 res
->i64
= v1
->i32
* v2
->i16
;
1545 res
->i64
= v1
->i32
* v2
->u16
;
1548 res
->i64
= v1
->i32
* v2
->i32
;
1551 res
->i64
= v1
->i32
* v2
->u32
;
1554 res
->i64
= v1
->i32
* v2
->i64
;
1557 res
->i64
= v1
->i32
* v2
->u64
;
1560 res
->i128
= v1
->i32
* v2
->i128
;
1561 return PSI_T_INT128
;
1563 res
->u128
= v1
->i32
* v2
->u128
;
1564 return PSI_T_UINT128
;
1566 res
->fval
= v1
->i32
* v2
->fval
;
1569 res
->dval
= v1
->i32
* v2
->dval
;
1570 return PSI_T_DOUBLE
;
1571 # if HAVE_LONG_DOUBLE
1572 case PSI_T_LONG_DOUBLE
:
1573 res
->ldval
= v1
->i32
* v2
->ldval
;
1574 return PSI_T_LONG_DOUBLE
;
1585 res
->i64
= v1
->u32
* v2
->i8
;
1588 res
->u64
= v1
->u32
* v2
->u8
;
1589 return PSI_T_UINT64
;
1591 res
->i64
= v1
->u32
* v2
->i16
;
1594 res
->u64
= v1
->u32
* v2
->u16
;
1595 return PSI_T_UINT64
;
1597 res
->i64
= v1
->u32
* v2
->i32
;
1600 res
->u64
= v1
->u32
* v2
->u32
;
1601 return PSI_T_UINT64
;
1603 res
->i64
= v1
->u32
* v2
->i64
;
1606 res
->u64
= v1
->u32
* v2
->u64
;
1607 return PSI_T_UINT64
;
1609 res
->i128
= v1
->u32
* v2
->i128
;
1610 return PSI_T_INT128
;
1612 res
->u128
= v1
->u32
* v2
->u128
;
1613 return PSI_T_UINT128
;
1615 res
->fval
= v1
->u32
* v2
->fval
;
1618 res
->dval
= v1
->u32
* v2
->dval
;
1619 return PSI_T_DOUBLE
;
1620 # if HAVE_LONG_DOUBLE
1621 case PSI_T_LONG_DOUBLE
:
1622 res
->ldval
= v1
->u32
* v2
->ldval
;
1623 return PSI_T_LONG_DOUBLE
;
1634 res
->i64
= v1
->i64
* v2
->i8
;
1637 res
->i64
= v1
->i64
* v2
->u8
;
1640 res
->i64
= v1
->i64
* v2
->i16
;
1643 res
->i64
= v1
->i64
* v2
->u16
;
1646 res
->i64
= v1
->i64
* v2
->i32
;
1649 res
->i64
= v1
->i64
* v2
->u32
;
1652 res
->i64
= v1
->i64
* v2
->i64
;
1655 res
->i64
= v1
->i64
* v2
->u64
;
1658 res
->i128
= v1
->i64
* v2
->i128
;
1659 return PSI_T_INT128
;
1661 res
->u128
= v1
->i64
* v2
->u128
;
1662 return PSI_T_UINT128
;
1664 res
->fval
= v1
->i64
* v2
->fval
;
1667 res
->dval
= v1
->i64
* v2
->dval
;
1668 return PSI_T_DOUBLE
;
1669 # if HAVE_LONG_DOUBLE
1670 case PSI_T_LONG_DOUBLE
:
1671 res
->ldval
= v1
->i64
* v2
->ldval
;
1672 return PSI_T_LONG_DOUBLE
;
1683 res
->i64
= v1
->u64
* v2
->i8
;
1686 res
->u64
= v1
->u64
* v2
->u8
;
1687 return PSI_T_UINT64
;
1689 res
->i64
= v1
->u64
* v2
->i16
;
1692 res
->u64
= v1
->u64
* v2
->u16
;
1693 return PSI_T_UINT64
;
1695 res
->i64
= v1
->u64
* v2
->i32
;
1698 res
->u64
= v1
->u64
* v2
->u32
;
1699 return PSI_T_UINT64
;
1701 res
->i64
= v1
->u64
* v2
->i64
;
1704 res
->u64
= v1
->u64
* v2
->u64
;
1705 return PSI_T_UINT64
;
1707 res
->i128
= v1
->u64
* v2
->i128
;
1708 return PSI_T_INT128
;
1710 res
->u128
= v1
->u64
* v2
->u128
;
1711 return PSI_T_UINT128
;
1713 res
->fval
= v1
->u64
* v2
->fval
;
1716 res
->dval
= v1
->u64
* v2
->dval
;
1717 return PSI_T_DOUBLE
;
1718 # if HAVE_LONG_DOUBLE
1719 case PSI_T_LONG_DOUBLE
:
1720 res
->ldval
= v1
->u64
* v2
->ldval
;
1721 return PSI_T_LONG_DOUBLE
;
1732 res
->i128
= v1
->i128
* v2
->i8
;
1733 return PSI_T_INT128
;
1735 res
->i128
= v1
->i128
* v2
->u8
;
1736 return PSI_T_INT128
;
1738 res
->i128
= v1
->i128
* v2
->i16
;
1739 return PSI_T_INT128
;
1741 res
->i128
= v1
->i128
* v2
->u16
;
1742 return PSI_T_INT128
;
1744 res
->i128
= v1
->i128
* v2
->i32
;
1745 return PSI_T_INT128
;
1747 res
->i128
= v1
->i128
* v2
->u32
;
1748 return PSI_T_INT128
;
1750 res
->i128
= v1
->i128
* v2
->i64
;
1751 return PSI_T_INT128
;
1753 res
->i128
= v1
->i128
* v2
->u64
;
1754 return PSI_T_INT128
;
1756 res
->i128
= v1
->i128
* v2
->i128
;
1757 return PSI_T_INT128
;
1759 res
->u128
= v1
->i128
* v2
->u128
;
1760 return PSI_T_UINT128
;
1762 res
->fval
= v1
->i128
* v2
->fval
;
1765 res
->dval
= v1
->i128
* v2
->dval
;
1766 return PSI_T_DOUBLE
;
1767 # if HAVE_LONG_DOUBLE
1768 case PSI_T_LONG_DOUBLE
:
1769 res
->ldval
= v1
->i128
* v2
->ldval
;
1770 return PSI_T_LONG_DOUBLE
;
1781 res
->u128
= v1
->u128
* v2
->i8
;
1782 return PSI_T_UINT128
;
1784 res
->u128
= v1
->u128
* v2
->u8
;
1785 return PSI_T_UINT128
;
1787 res
->u128
= v1
->u128
* v2
->i16
;
1788 return PSI_T_UINT128
;
1790 res
->u128
= v1
->u128
* v2
->u16
;
1791 return PSI_T_UINT128
;
1793 res
->u128
= v1
->u128
* v2
->i32
;
1794 return PSI_T_UINT128
;
1796 res
->u128
= v1
->u128
* v2
->u32
;
1797 return PSI_T_UINT128
;
1799 res
->u128
= v1
->u128
* v2
->i64
;
1800 return PSI_T_UINT128
;
1802 res
->u128
= v1
->u128
* v2
->u64
;
1803 return PSI_T_UINT128
;
1805 res
->u128
= v1
->u128
* v2
->i128
;
1806 return PSI_T_UINT128
;
1808 res
->u128
= v1
->u128
* v2
->u128
;
1809 return PSI_T_UINT128
;
1811 res
->fval
= v1
->u128
* v2
->fval
;
1814 res
->dval
= v1
->u128
* v2
->dval
;
1815 return PSI_T_DOUBLE
;
1816 # if HAVE_LONG_DOUBLE
1817 case PSI_T_LONG_DOUBLE
:
1818 res
->ldval
= v1
->u128
* v2
->ldval
;
1819 return PSI_T_LONG_DOUBLE
;
1830 res
->fval
= v1
->fval
* v2
->i8
;
1833 res
->fval
= v1
->fval
* v2
->u8
;
1836 res
->fval
= v1
->fval
* v2
->i16
;
1839 res
->fval
= v1
->fval
* v2
->u16
;
1842 res
->fval
= v1
->fval
* v2
->i32
;
1845 res
->fval
= v1
->fval
* v2
->u32
;
1848 res
->fval
= v1
->fval
* v2
->i64
;
1851 res
->fval
= v1
->fval
* v2
->u64
;
1854 res
->fval
= v1
->fval
* v2
->i128
;
1857 res
->fval
= v1
->fval
* v2
->u128
;
1860 res
->fval
= v1
->fval
* v2
->fval
;
1863 res
->dval
= v1
->fval
* v2
->dval
;
1864 return PSI_T_DOUBLE
;
1865 # if HAVE_LONG_DOUBLE
1866 case PSI_T_LONG_DOUBLE
:
1867 res
->ldval
= v1
->fval
* v2
->ldval
;
1868 return PSI_T_LONG_DOUBLE
;
1879 res
->dval
= v1
->dval
* v2
->i8
;
1880 return PSI_T_DOUBLE
;
1882 res
->dval
= v1
->dval
* v2
->u8
;
1883 return PSI_T_DOUBLE
;
1885 res
->dval
= v1
->dval
* v2
->i16
;
1886 return PSI_T_DOUBLE
;
1888 res
->dval
= v1
->dval
* v2
->u16
;
1889 return PSI_T_DOUBLE
;
1891 res
->dval
= v1
->dval
* v2
->i32
;
1892 return PSI_T_DOUBLE
;
1894 res
->dval
= v1
->dval
* v2
->u32
;
1895 return PSI_T_DOUBLE
;
1897 res
->dval
= v1
->dval
* v2
->i64
;
1898 return PSI_T_DOUBLE
;
1900 res
->dval
= v1
->dval
* v2
->u64
;
1901 return PSI_T_DOUBLE
;
1903 res
->dval
= v1
->dval
* v2
->i128
;
1904 return PSI_T_DOUBLE
;
1906 res
->dval
= v1
->dval
* v2
->u128
;
1907 return PSI_T_DOUBLE
;
1909 res
->dval
= v1
->dval
* v2
->fval
;
1910 return PSI_T_DOUBLE
;
1912 res
->dval
= v1
->dval
* v2
->dval
;
1913 return PSI_T_DOUBLE
;
1914 # if HAVE_LONG_DOUBLE
1915 case PSI_T_LONG_DOUBLE
:
1916 res
->ldval
= v1
->dval
* v2
->ldval
;
1917 return PSI_T_LONG_DOUBLE
;
1925 #if HAVE_LONG_DOUBLE
1926 case PSI_T_LONG_DOUBLE
:
1929 res
->ldval
= v1
->ldval
* v2
->i8
;
1930 return PSI_T_LONG_DOUBLE
;
1932 res
->ldval
= v1
->ldval
* v2
->u8
;
1933 return PSI_T_LONG_DOUBLE
;
1935 res
->ldval
= v1
->ldval
* v2
->i16
;
1936 return PSI_T_LONG_DOUBLE
;
1938 res
->ldval
= v1
->ldval
* v2
->u16
;
1939 return PSI_T_LONG_DOUBLE
;
1941 res
->ldval
= v1
->ldval
* v2
->i32
;
1942 return PSI_T_LONG_DOUBLE
;
1944 res
->ldval
= v1
->ldval
* v2
->u32
;
1945 return PSI_T_LONG_DOUBLE
;
1947 res
->ldval
= v1
->ldval
* v2
->i64
;
1948 return PSI_T_LONG_DOUBLE
;
1950 res
->ldval
= v1
->ldval
* v2
->u64
;
1951 return PSI_T_LONG_DOUBLE
;
1953 res
->ldval
= v1
->ldval
* v2
->i128
;
1954 return PSI_T_LONG_DOUBLE
;
1956 res
->ldval
= v1
->ldval
* v2
->u128
;
1957 return PSI_T_LONG_DOUBLE
;
1959 res
->ldval
= v1
->ldval
* v2
->fval
;
1960 return PSI_T_LONG_DOUBLE
;
1962 res
->ldval
= v1
->ldval
* v2
->dval
;
1963 return PSI_T_LONG_DOUBLE
;
1964 # if HAVE_LONG_DOUBLE
1965 case PSI_T_LONG_DOUBLE
:
1966 res
->ldval
= v1
->ldval
* v2
->ldval
;
1967 return PSI_T_LONG_DOUBLE
;
1984 static inline token_t
psi_calc_div(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
1991 res
->i16
= v1
->i8
/ v2
->i8
;
1994 res
->i16
= v1
->i8
/ v2
->u8
;
1997 res
->i32
= v1
->i8
/ v2
->i16
;
2000 res
->i32
= v1
->i8
/ v2
->u16
;
2003 res
->i64
= v1
->i8
/ v2
->i32
;
2006 res
->i64
= v1
->i8
/ v2
->u32
;
2009 res
->i64
= v1
->i8
/ v2
->i64
;
2012 res
->i64
= v1
->i8
/ v2
->u64
;
2015 res
->i128
= v1
->i8
/ v2
->i128
;
2016 return PSI_T_INT128
;
2018 res
->u128
= v1
->i8
/ v2
->u128
;
2019 return PSI_T_UINT128
;
2021 res
->fval
= v1
->i8
/ v2
->fval
;
2024 res
->dval
= v1
->i8
/ v2
->dval
;
2025 return PSI_T_DOUBLE
;
2026 # if HAVE_LONG_DOUBLE
2027 case PSI_T_LONG_DOUBLE
:
2028 res
->ldval
= v1
->i8
/ v2
->ldval
;
2029 return PSI_T_LONG_DOUBLE
;
2040 res
->i16
= v1
->u8
/ v2
->i8
;
2043 res
->u16
= v1
->u8
/ v2
->u8
;
2044 return PSI_T_UINT16
;
2046 res
->i32
= v1
->u8
/ v2
->i16
;
2049 res
->u32
= v1
->u8
/ v2
->u16
;
2050 return PSI_T_UINT32
;
2052 res
->i64
= v1
->u8
/ v2
->i32
;
2055 res
->u64
= v1
->u8
/ v2
->u32
;
2056 return PSI_T_UINT64
;
2058 res
->i64
= v1
->u8
/ v2
->i64
;
2061 res
->u64
= v1
->u8
/ v2
->u64
;
2062 return PSI_T_UINT64
;
2064 res
->i128
= v1
->u8
/ v2
->i128
;
2065 return PSI_T_INT128
;
2067 res
->u128
= v1
->u8
/ v2
->u128
;
2068 return PSI_T_UINT128
;
2070 res
->fval
= v1
->u8
/ v2
->fval
;
2073 res
->dval
= v1
->u8
/ v2
->dval
;
2074 return PSI_T_DOUBLE
;
2075 # if HAVE_LONG_DOUBLE
2076 case PSI_T_LONG_DOUBLE
:
2077 res
->ldval
= v1
->u8
/ v2
->ldval
;
2078 return PSI_T_LONG_DOUBLE
;
2089 res
->i32
= v1
->i16
/ v2
->i8
;
2092 res
->i32
= v1
->i16
/ v2
->u8
;
2095 res
->i32
= v1
->i16
/ v2
->i16
;
2098 res
->i32
= v1
->i16
/ v2
->u16
;
2101 res
->i64
= v1
->i16
/ v2
->i32
;
2104 res
->i64
= v1
->i16
/ v2
->u32
;
2107 res
->i64
= v1
->i16
/ v2
->i64
;
2110 res
->i64
= v1
->i16
/ v2
->u64
;
2113 res
->i128
= v1
->i16
/ v2
->i128
;
2114 return PSI_T_INT128
;
2116 res
->u128
= v1
->i16
/ v2
->u128
;
2117 return PSI_T_UINT128
;
2119 res
->fval
= v1
->i16
/ v2
->fval
;
2122 res
->dval
= v1
->i16
/ v2
->dval
;
2123 return PSI_T_DOUBLE
;
2124 # if HAVE_LONG_DOUBLE
2125 case PSI_T_LONG_DOUBLE
:
2126 res
->ldval
= v1
->i16
/ v2
->ldval
;
2127 return PSI_T_LONG_DOUBLE
;
2138 res
->i32
= v1
->u16
/ v2
->i8
;
2141 res
->u32
= v1
->u16
/ v2
->u8
;
2142 return PSI_T_UINT32
;
2144 res
->i32
= v1
->u16
/ v2
->i16
;
2147 res
->u32
= v1
->u16
/ v2
->u16
;
2148 return PSI_T_UINT32
;
2150 res
->i64
= v1
->u16
/ v2
->i32
;
2153 res
->u64
= v1
->u16
/ v2
->u32
;
2154 return PSI_T_UINT64
;
2156 res
->i64
= v1
->u16
/ v2
->i64
;
2159 res
->u64
= v1
->u16
/ v2
->u64
;
2160 return PSI_T_UINT64
;
2162 res
->i128
= v1
->u16
/ v2
->i128
;
2163 return PSI_T_INT128
;
2165 res
->u128
= v1
->u16
/ v2
->u128
;
2166 return PSI_T_UINT128
;
2168 res
->fval
= v1
->u16
/ v2
->fval
;
2171 res
->dval
= v1
->u16
/ v2
->dval
;
2172 return PSI_T_DOUBLE
;
2173 # if HAVE_LONG_DOUBLE
2174 case PSI_T_LONG_DOUBLE
:
2175 res
->ldval
= v1
->u16
/ v2
->ldval
;
2176 return PSI_T_LONG_DOUBLE
;
2187 res
->i64
= v1
->i32
/ v2
->i8
;
2190 res
->i64
= v1
->i32
/ v2
->u8
;
2193 res
->i64
= v1
->i32
/ v2
->i16
;
2196 res
->i64
= v1
->i32
/ v2
->u16
;
2199 res
->i64
= v1
->i32
/ v2
->i32
;
2202 res
->i64
= v1
->i32
/ v2
->u32
;
2205 res
->i64
= v1
->i32
/ v2
->i64
;
2208 res
->i64
= v1
->i32
/ v2
->u64
;
2211 res
->i128
= v1
->i32
/ v2
->i128
;
2212 return PSI_T_INT128
;
2214 res
->u128
= v1
->i32
/ v2
->u128
;
2215 return PSI_T_UINT128
;
2217 res
->fval
= v1
->i32
/ v2
->fval
;
2220 res
->dval
= v1
->i32
/ v2
->dval
;
2221 return PSI_T_DOUBLE
;
2222 # if HAVE_LONG_DOUBLE
2223 case PSI_T_LONG_DOUBLE
:
2224 res
->ldval
= v1
->i32
/ v2
->ldval
;
2225 return PSI_T_LONG_DOUBLE
;
2236 res
->i64
= v1
->u32
/ v2
->i8
;
2239 res
->u64
= v1
->u32
/ v2
->u8
;
2240 return PSI_T_UINT64
;
2242 res
->i64
= v1
->u32
/ v2
->i16
;
2245 res
->u64
= v1
->u32
/ v2
->u16
;
2246 return PSI_T_UINT64
;
2248 res
->i64
= v1
->u32
/ v2
->i32
;
2251 res
->u64
= v1
->u32
/ v2
->u32
;
2252 return PSI_T_UINT64
;
2254 res
->i64
= v1
->u32
/ v2
->i64
;
2257 res
->u64
= v1
->u32
/ v2
->u64
;
2258 return PSI_T_UINT64
;
2260 res
->i128
= v1
->u32
/ v2
->i128
;
2261 return PSI_T_INT128
;
2263 res
->u128
= v1
->u32
/ v2
->u128
;
2264 return PSI_T_UINT128
;
2266 res
->fval
= v1
->u32
/ v2
->fval
;
2269 res
->dval
= v1
->u32
/ v2
->dval
;
2270 return PSI_T_DOUBLE
;
2271 # if HAVE_LONG_DOUBLE
2272 case PSI_T_LONG_DOUBLE
:
2273 res
->ldval
= v1
->u32
/ v2
->ldval
;
2274 return PSI_T_LONG_DOUBLE
;
2285 res
->i64
= v1
->i64
/ v2
->i8
;
2288 res
->i64
= v1
->i64
/ v2
->u8
;
2291 res
->i64
= v1
->i64
/ v2
->i16
;
2294 res
->i64
= v1
->i64
/ v2
->u16
;
2297 res
->i64
= v1
->i64
/ v2
->i32
;
2300 res
->i64
= v1
->i64
/ v2
->u32
;
2303 res
->i64
= v1
->i64
/ v2
->i64
;
2306 res
->i64
= v1
->i64
/ v2
->u64
;
2309 res
->i128
= v1
->i64
/ v2
->i128
;
2310 return PSI_T_INT128
;
2312 res
->u128
= v1
->i64
/ v2
->u128
;
2313 return PSI_T_UINT128
;
2315 res
->fval
= v1
->i64
/ v2
->fval
;
2318 res
->dval
= v1
->i64
/ v2
->dval
;
2319 return PSI_T_DOUBLE
;
2320 # if HAVE_LONG_DOUBLE
2321 case PSI_T_LONG_DOUBLE
:
2322 res
->ldval
= v1
->i64
/ v2
->ldval
;
2323 return PSI_T_LONG_DOUBLE
;
2334 res
->i64
= v1
->u64
/ v2
->i8
;
2337 res
->u64
= v1
->u64
/ v2
->u8
;
2338 return PSI_T_UINT64
;
2340 res
->i64
= v1
->u64
/ v2
->i16
;
2343 res
->u64
= v1
->u64
/ v2
->u16
;
2344 return PSI_T_UINT64
;
2346 res
->i64
= v1
->u64
/ v2
->i32
;
2349 res
->u64
= v1
->u64
/ v2
->u32
;
2350 return PSI_T_UINT64
;
2352 res
->i64
= v1
->u64
/ v2
->i64
;
2355 res
->u64
= v1
->u64
/ v2
->u64
;
2356 return PSI_T_UINT64
;
2358 res
->i128
= v1
->u64
/ v2
->i128
;
2359 return PSI_T_INT128
;
2361 res
->u128
= v1
->u64
/ v2
->u128
;
2362 return PSI_T_UINT128
;
2364 res
->fval
= v1
->u64
/ v2
->fval
;
2367 res
->dval
= v1
->u64
/ v2
->dval
;
2368 return PSI_T_DOUBLE
;
2369 # if HAVE_LONG_DOUBLE
2370 case PSI_T_LONG_DOUBLE
:
2371 res
->ldval
= v1
->u64
/ v2
->ldval
;
2372 return PSI_T_LONG_DOUBLE
;
2383 res
->i128
= v1
->i128
/ v2
->i8
;
2384 return PSI_T_INT128
;
2386 res
->i128
= v1
->i128
/ v2
->u8
;
2387 return PSI_T_INT128
;
2389 res
->i128
= v1
->i128
/ v2
->i16
;
2390 return PSI_T_INT128
;
2392 res
->i128
= v1
->i128
/ v2
->u16
;
2393 return PSI_T_INT128
;
2395 res
->i128
= v1
->i128
/ v2
->i32
;
2396 return PSI_T_INT128
;
2398 res
->i128
= v1
->i128
/ v2
->u32
;
2399 return PSI_T_INT128
;
2401 res
->i128
= v1
->i128
/ v2
->i64
;
2402 return PSI_T_INT128
;
2404 res
->i128
= v1
->i128
/ v2
->u64
;
2405 return PSI_T_INT128
;
2407 res
->i128
= v1
->i128
/ v2
->i128
;
2408 return PSI_T_INT128
;
2410 res
->u128
= v1
->i128
/ v2
->u128
;
2411 return PSI_T_UINT128
;
2413 res
->fval
= v1
->i128
/ v2
->fval
;
2416 res
->dval
= v1
->i128
/ v2
->dval
;
2417 return PSI_T_DOUBLE
;
2418 # if HAVE_LONG_DOUBLE
2419 case PSI_T_LONG_DOUBLE
:
2420 res
->ldval
= v1
->i128
/ v2
->ldval
;
2421 return PSI_T_LONG_DOUBLE
;
2432 res
->u128
= v1
->u128
/ v2
->i8
;
2433 return PSI_T_UINT128
;
2435 res
->u128
= v1
->u128
/ v2
->u8
;
2436 return PSI_T_UINT128
;
2438 res
->u128
= v1
->u128
/ v2
->i16
;
2439 return PSI_T_UINT128
;
2441 res
->u128
= v1
->u128
/ v2
->u16
;
2442 return PSI_T_UINT128
;
2444 res
->u128
= v1
->u128
/ v2
->i32
;
2445 return PSI_T_UINT128
;
2447 res
->u128
= v1
->u128
/ v2
->u32
;
2448 return PSI_T_UINT128
;
2450 res
->u128
= v1
->u128
/ v2
->i64
;
2451 return PSI_T_UINT128
;
2453 res
->u128
= v1
->u128
/ v2
->u64
;
2454 return PSI_T_UINT128
;
2456 res
->u128
= v1
->u128
/ v2
->i128
;
2457 return PSI_T_UINT128
;
2459 res
->u128
= v1
->u128
/ v2
->u128
;
2460 return PSI_T_UINT128
;
2462 res
->fval
= v1
->u128
/ v2
->fval
;
2465 res
->dval
= v1
->u128
/ v2
->dval
;
2466 return PSI_T_DOUBLE
;
2467 # if HAVE_LONG_DOUBLE
2468 case PSI_T_LONG_DOUBLE
:
2469 res
->ldval
= v1
->u128
/ v2
->ldval
;
2470 return PSI_T_LONG_DOUBLE
;
2481 res
->fval
= v1
->fval
/ v2
->i8
;
2484 res
->fval
= v1
->fval
/ v2
->u8
;
2487 res
->fval
= v1
->fval
/ v2
->i16
;
2490 res
->fval
= v1
->fval
/ v2
->u16
;
2493 res
->fval
= v1
->fval
/ v2
->i32
;
2496 res
->fval
= v1
->fval
/ v2
->u32
;
2499 res
->fval
= v1
->fval
/ v2
->i64
;
2502 res
->fval
= v1
->fval
/ v2
->u64
;
2505 res
->fval
= v1
->fval
/ v2
->i128
;
2508 res
->fval
= v1
->fval
/ v2
->u128
;
2511 res
->fval
= v1
->fval
/ v2
->fval
;
2514 res
->dval
= v1
->fval
/ v2
->dval
;
2515 return PSI_T_DOUBLE
;
2516 # if HAVE_LONG_DOUBLE
2517 case PSI_T_LONG_DOUBLE
:
2518 res
->ldval
= v1
->fval
/ v2
->ldval
;
2519 return PSI_T_LONG_DOUBLE
;
2530 res
->dval
= v1
->dval
/ v2
->i8
;
2531 return PSI_T_DOUBLE
;
2533 res
->dval
= v1
->dval
/ v2
->u8
;
2534 return PSI_T_DOUBLE
;
2536 res
->dval
= v1
->dval
/ v2
->i16
;
2537 return PSI_T_DOUBLE
;
2539 res
->dval
= v1
->dval
/ v2
->u16
;
2540 return PSI_T_DOUBLE
;
2542 res
->dval
= v1
->dval
/ v2
->i32
;
2543 return PSI_T_DOUBLE
;
2545 res
->dval
= v1
->dval
/ v2
->u32
;
2546 return PSI_T_DOUBLE
;
2548 res
->dval
= v1
->dval
/ v2
->i64
;
2549 return PSI_T_DOUBLE
;
2551 res
->dval
= v1
->dval
/ v2
->u64
;
2552 return PSI_T_DOUBLE
;
2554 res
->dval
= v1
->dval
/ v2
->i128
;
2555 return PSI_T_DOUBLE
;
2557 res
->dval
= v1
->dval
/ v2
->u128
;
2558 return PSI_T_DOUBLE
;
2560 res
->dval
= v1
->dval
/ v2
->fval
;
2561 return PSI_T_DOUBLE
;
2563 res
->dval
= v1
->dval
/ v2
->dval
;
2564 return PSI_T_DOUBLE
;
2565 # if HAVE_LONG_DOUBLE
2566 case PSI_T_LONG_DOUBLE
:
2567 res
->ldval
= v1
->dval
/ v2
->ldval
;
2568 return PSI_T_LONG_DOUBLE
;
2576 #if HAVE_LONG_DOUBLE
2577 case PSI_T_LONG_DOUBLE
:
2580 res
->ldval
= v1
->ldval
/ v2
->i8
;
2581 return PSI_T_LONG_DOUBLE
;
2583 res
->ldval
= v1
->ldval
/ v2
->u8
;
2584 return PSI_T_LONG_DOUBLE
;
2586 res
->ldval
= v1
->ldval
/ v2
->i16
;
2587 return PSI_T_LONG_DOUBLE
;
2589 res
->ldval
= v1
->ldval
/ v2
->u16
;
2590 return PSI_T_LONG_DOUBLE
;
2592 res
->ldval
= v1
->ldval
/ v2
->i32
;
2593 return PSI_T_LONG_DOUBLE
;
2595 res
->ldval
= v1
->ldval
/ v2
->u32
;
2596 return PSI_T_LONG_DOUBLE
;
2598 res
->ldval
= v1
->ldval
/ v2
->i64
;
2599 return PSI_T_LONG_DOUBLE
;
2601 res
->ldval
= v1
->ldval
/ v2
->u64
;
2602 return PSI_T_LONG_DOUBLE
;
2604 res
->ldval
= v1
->ldval
/ v2
->i128
;
2605 return PSI_T_LONG_DOUBLE
;
2607 res
->ldval
= v1
->ldval
/ v2
->u128
;
2608 return PSI_T_LONG_DOUBLE
;
2610 res
->ldval
= v1
->ldval
/ v2
->fval
;
2611 return PSI_T_LONG_DOUBLE
;
2613 res
->ldval
= v1
->ldval
/ v2
->dval
;
2614 return PSI_T_LONG_DOUBLE
;
2615 # if HAVE_LONG_DOUBLE
2616 case PSI_T_LONG_DOUBLE
:
2617 res
->ldval
= v1
->ldval
/ v2
->ldval
;
2618 return PSI_T_LONG_DOUBLE
;
2637 static inline token_t
psi_calc_mod(token_t t1
, impl_val
*v1
, token_t t2
, impl_val
*v2
, impl_val
*res
)
2690 #if HAVE_LONG_DOUBLE
2691 case PSI_T_LONG_DOUBLE
:
2739 #if HAVE_LONG_DOUBLE
2740 case PSI_T_LONG_DOUBLE
:
2750 res
->i64
= i1
.i64
% i2
.i64
;