projects / m6w6 / ext-psi / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
ifdef HAVE_INT128
[m6w6/ext-psi] / src / calc / basic.h
1 /*******************************************************************************
2 Copyright (c) 2016, Michael Wallner <mike@php.net>.
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
7
8 * Redistributions of source code must retain the above copyright notice,
9 this list of conditions and the following disclaimer.
10 * Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the distribution.
13
14 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
18 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *******************************************************************************/
25
26 #include "php_psi_stdinc.h"
27 #include <assert.h>
28
29 #include "token.h"
30
31 static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
32 {
33
34 switch (t1) {
35 case PSI_T_INT8:
36 switch (t2) {
37 case PSI_T_INT8:
38 res->i16 = v1->i8 + v2->i8;
39 return PSI_T_INT16;
40 case PSI_T_UINT8:
41 res->i16 = v1->i8 + v2->u8;
42 return PSI_T_INT16;
43 case PSI_T_INT16:
44 res->i32 = v1->i8 + v2->i16;
45 return PSI_T_INT32;
46 case PSI_T_UINT16:
47 res->i32 = v1->i8 + v2->u16;
48 return PSI_T_INT32;
49 case PSI_T_INT32:
50 res->i64 = v1->i8 + v2->i32;
51 return PSI_T_INT64;
52 case PSI_T_UINT32:
53 res->i64 = v1->i8 + v2->u32;
54 return PSI_T_INT64;
55 case PSI_T_INT64:
56 res->i64 = v1->i8 + v2->i64;
57 return PSI_T_INT64;
58 case PSI_T_UINT64:
59 res->i64 = v1->i8 + v2->u64;
60 return PSI_T_INT64;
61 # if HAVE_INT128
62 case PSI_T_INT128:
63 res->i128 = v1->i8 + v2->i128;
64 return PSI_T_INT128;
65 # endif
66
67 # if HAVE_UINT128
68 case PSI_T_UINT128:
69 res->u128 = v1->i8 + v2->u128;
70 return PSI_T_UINT128;
71 # endif
72
73 case PSI_T_FLOAT:
74 res->fval = v1->i8 + v2->fval;
75 return PSI_T_FLOAT;
76 case PSI_T_DOUBLE:
77 res->dval = v1->i8 + v2->dval;
78 return PSI_T_DOUBLE;
79 # if HAVE_LONG_DOUBLE
80 case PSI_T_LONG_DOUBLE:
81 res->ldval = v1->i8 + v2->ldval;
82 return PSI_T_LONG_DOUBLE;
83 # endif
84
85 default:
86 assert(0);
87 break;
88 }
89 break;
90 case PSI_T_UINT8:
91 switch (t2) {
92 case PSI_T_INT8:
93 res->i16 = v1->u8 + v2->i8;
94 return PSI_T_INT16;
95 case PSI_T_UINT8:
96 res->u16 = v1->u8 + v2->u8;
97 return PSI_T_UINT16;
98 case PSI_T_INT16:
99 res->i32 = v1->u8 + v2->i16;
100 return PSI_T_INT32;
101 case PSI_T_UINT16:
102 res->u32 = v1->u8 + v2->u16;
103 return PSI_T_UINT32;
104 case PSI_T_INT32:
105 res->i64 = v1->u8 + v2->i32;
106 return PSI_T_INT64;
107 case PSI_T_UINT32:
108 res->u64 = v1->u8 + v2->u32;
109 return PSI_T_UINT64;
110 case PSI_T_INT64:
111 res->i64 = v1->u8 + v2->i64;
112 return PSI_T_INT64;
113 case PSI_T_UINT64:
114 res->u64 = v1->u8 + v2->u64;
115 return PSI_T_UINT64;
116 # if HAVE_INT128
117 case PSI_T_INT128:
118 res->i128 = v1->u8 + v2->i128;
119 return PSI_T_INT128;
120 # endif
121
122 # if HAVE_UINT128
123 case PSI_T_UINT128:
124 res->u128 = v1->u8 + v2->u128;
125 return PSI_T_UINT128;
126 # endif
127
128 case PSI_T_FLOAT:
129 res->fval = v1->u8 + v2->fval;
130 return PSI_T_FLOAT;
131 case PSI_T_DOUBLE:
132 res->dval = v1->u8 + v2->dval;
133 return PSI_T_DOUBLE;
134 # if HAVE_LONG_DOUBLE
135 case PSI_T_LONG_DOUBLE:
136 res->ldval = v1->u8 + v2->ldval;
137 return PSI_T_LONG_DOUBLE;
138 # endif
139
140 default:
141 assert(0);
142 break;
143 }
144 break;
145 case PSI_T_INT16:
146 switch (t2) {
147 case PSI_T_INT8:
148 res->i32 = v1->i16 + v2->i8;
149 return PSI_T_INT32;
150 case PSI_T_UINT8:
151 res->i32 = v1->i16 + v2->u8;
152 return PSI_T_INT32;
153 case PSI_T_INT16:
154 res->i32 = v1->i16 + v2->i16;
155 return PSI_T_INT32;
156 case PSI_T_UINT16:
157 res->i32 = v1->i16 + v2->u16;
158 return PSI_T_INT32;
159 case PSI_T_INT32:
160 res->i64 = v1->i16 + v2->i32;
161 return PSI_T_INT64;
162 case PSI_T_UINT32:
163 res->i64 = v1->i16 + v2->u32;
164 return PSI_T_INT64;
165 case PSI_T_INT64:
166 res->i64 = v1->i16 + v2->i64;
167 return PSI_T_INT64;
168 case PSI_T_UINT64:
169 res->i64 = v1->i16 + v2->u64;
170 return PSI_T_INT64;
171 # if HAVE_INT128
172 case PSI_T_INT128:
173 res->i128 = v1->i16 + v2->i128;
174 return PSI_T_INT128;
175 # endif
176
177 # if HAVE_UINT128
178 case PSI_T_UINT128:
179 res->u128 = v1->i16 + v2->u128;
180 return PSI_T_UINT128;
181 # endif
182
183 case PSI_T_FLOAT:
184 res->fval = v1->i16 + v2->fval;
185 return PSI_T_FLOAT;
186 case PSI_T_DOUBLE:
187 res->dval = v1->i16 + v2->dval;
188 return PSI_T_DOUBLE;
189 # if HAVE_LONG_DOUBLE
190 case PSI_T_LONG_DOUBLE:
191 res->ldval = v1->i16 + v2->ldval;
192 return PSI_T_LONG_DOUBLE;
193 # endif
194
195 default:
196 assert(0);
197 break;
198 }
199 break;
200 case PSI_T_UINT16:
201 switch (t2) {
202 case PSI_T_INT8:
203 res->i32 = v1->u16 + v2->i8;
204 return PSI_T_INT32;
205 case PSI_T_UINT8:
206 res->u32 = v1->u16 + v2->u8;
207 return PSI_T_UINT32;
208 case PSI_T_INT16:
209 res->i32 = v1->u16 + v2->i16;
210 return PSI_T_INT32;
211 case PSI_T_UINT16:
212 res->u32 = v1->u16 + v2->u16;
213 return PSI_T_UINT32;
214 case PSI_T_INT32:
215 res->i64 = v1->u16 + v2->i32;
216 return PSI_T_INT64;
217 case PSI_T_UINT32:
218 res->u64 = v1->u16 + v2->u32;
219 return PSI_T_UINT64;
220 case PSI_T_INT64:
221 res->i64 = v1->u16 + v2->i64;
222 return PSI_T_INT64;
223 case PSI_T_UINT64:
224 res->u64 = v1->u16 + v2->u64;
225 return PSI_T_UINT64;
226 # if HAVE_INT128
227 case PSI_T_INT128:
228 res->i128 = v1->u16 + v2->i128;
229 return PSI_T_INT128;
230 # endif
231
232 # if HAVE_UINT128
233 case PSI_T_UINT128:
234 res->u128 = v1->u16 + v2->u128;
235 return PSI_T_UINT128;
236 # endif
237
238 case PSI_T_FLOAT:
239 res->fval = v1->u16 + v2->fval;
240 return PSI_T_FLOAT;
241 case PSI_T_DOUBLE:
242 res->dval = v1->u16 + v2->dval;
243 return PSI_T_DOUBLE;
244 # if HAVE_LONG_DOUBLE
245 case PSI_T_LONG_DOUBLE:
246 res->ldval = v1->u16 + v2->ldval;
247 return PSI_T_LONG_DOUBLE;
248 # endif
249
250 default:
251 assert(0);
252 break;
253 }
254 break;
255 case PSI_T_INT32:
256 switch (t2) {
257 case PSI_T_INT8:
258 res->i64 = v1->i32 + v2->i8;
259 return PSI_T_INT64;
260 case PSI_T_UINT8:
261 res->i64 = v1->i32 + v2->u8;
262 return PSI_T_INT64;
263 case PSI_T_INT16:
264 res->i64 = v1->i32 + v2->i16;
265 return PSI_T_INT64;
266 case PSI_T_UINT16:
267 res->i64 = v1->i32 + v2->u16;
268 return PSI_T_INT64;
269 case PSI_T_INT32:
270 res->i64 = v1->i32 + v2->i32;
271 return PSI_T_INT64;
272 case PSI_T_UINT32:
273 res->i64 = v1->i32 + v2->u32;
274 return PSI_T_INT64;
275 case PSI_T_INT64:
276 res->i64 = v1->i32 + v2->i64;
277 return PSI_T_INT64;
278 case PSI_T_UINT64:
279 res->i64 = v1->i32 + v2->u64;
280 return PSI_T_INT64;
281 # if HAVE_INT128
282 case PSI_T_INT128:
283 res->i128 = v1->i32 + v2->i128;
284 return PSI_T_INT128;
285 # endif
286
287 # if HAVE_UINT128
288 case PSI_T_UINT128:
289 res->u128 = v1->i32 + v2->u128;
290 return PSI_T_UINT128;
291 # endif
292
293 case PSI_T_FLOAT:
294 res->fval = v1->i32 + v2->fval;
295 return PSI_T_FLOAT;
296 case PSI_T_DOUBLE:
297 res->dval = v1->i32 + v2->dval;
298 return PSI_T_DOUBLE;
299 # if HAVE_LONG_DOUBLE
300 case PSI_T_LONG_DOUBLE:
301 res->ldval = v1->i32 + v2->ldval;
302 return PSI_T_LONG_DOUBLE;
303 # endif
304
305 default:
306 assert(0);
307 break;
308 }
309 break;
310 case PSI_T_UINT32:
311 switch (t2) {
312 case PSI_T_INT8:
313 res->i64 = v1->u32 + v2->i8;
314 return PSI_T_INT64;
315 case PSI_T_UINT8:
316 res->u64 = v1->u32 + v2->u8;
317 return PSI_T_UINT64;
318 case PSI_T_INT16:
319 res->i64 = v1->u32 + v2->i16;
320 return PSI_T_INT64;
321 case PSI_T_UINT16:
322 res->u64 = v1->u32 + v2->u16;
323 return PSI_T_UINT64;
324 case PSI_T_INT32:
325 res->i64 = v1->u32 + v2->i32;
326 return PSI_T_INT64;
327 case PSI_T_UINT32:
328 res->u64 = v1->u32 + v2->u32;
329 return PSI_T_UINT64;
330 case PSI_T_INT64:
331 res->i64 = v1->u32 + v2->i64;
332 return PSI_T_INT64;
333 case PSI_T_UINT64:
334 res->u64 = v1->u32 + v2->u64;
335 return PSI_T_UINT64;
336 # if HAVE_INT128
337 case PSI_T_INT128:
338 res->i128 = v1->u32 + v2->i128;
339 return PSI_T_INT128;
340 # endif
341
342 # if HAVE_UINT128
343 case PSI_T_UINT128:
344 res->u128 = v1->u32 + v2->u128;
345 return PSI_T_UINT128;
346 # endif
347
348 case PSI_T_FLOAT:
349 res->fval = v1->u32 + v2->fval;
350 return PSI_T_FLOAT;
351 case PSI_T_DOUBLE:
352 res->dval = v1->u32 + v2->dval;
353 return PSI_T_DOUBLE;
354 # if HAVE_LONG_DOUBLE
355 case PSI_T_LONG_DOUBLE:
356 res->ldval = v1->u32 + v2->ldval;
357 return PSI_T_LONG_DOUBLE;
358 # endif
359
360 default:
361 assert(0);
362 break;
363 }
364 break;
365 case PSI_T_INT64:
366 switch (t2) {
367 case PSI_T_INT8:
368 res->i64 = v1->i64 + v2->i8;
369 return PSI_T_INT64;
370 case PSI_T_UINT8:
371 res->i64 = v1->i64 + v2->u8;
372 return PSI_T_INT64;
373 case PSI_T_INT16:
374 res->i64 = v1->i64 + v2->i16;
375 return PSI_T_INT64;
376 case PSI_T_UINT16:
377 res->i64 = v1->i64 + v2->u16;
378 return PSI_T_INT64;
379 case PSI_T_INT32:
380 res->i64 = v1->i64 + v2->i32;
381 return PSI_T_INT64;
382 case PSI_T_UINT32:
383 res->i64 = v1->i64 + v2->u32;
384 return PSI_T_INT64;
385 case PSI_T_INT64:
386 res->i64 = v1->i64 + v2->i64;
387 return PSI_T_INT64;
388 case PSI_T_UINT64:
389 res->i64 = v1->i64 + v2->u64;
390 return PSI_T_INT64;
391 # if HAVE_INT128
392 case PSI_T_INT128:
393 res->i128 = v1->i64 + v2->i128;
394 return PSI_T_INT128;
395 # endif
396
397 # if HAVE_UINT128
398 case PSI_T_UINT128:
399 res->u128 = v1->i64 + v2->u128;
400 return PSI_T_UINT128;
401 # endif
402
403 case PSI_T_FLOAT:
404 res->fval = v1->i64 + v2->fval;
405 return PSI_T_FLOAT;
406 case PSI_T_DOUBLE:
407 res->dval = v1->i64 + v2->dval;
408 return PSI_T_DOUBLE;
409 # if HAVE_LONG_DOUBLE
410 case PSI_T_LONG_DOUBLE:
411 res->ldval = v1->i64 + v2->ldval;
412 return PSI_T_LONG_DOUBLE;
413 # endif
414
415 default:
416 assert(0);
417 break;
418 }
419 break;
420 case PSI_T_UINT64:
421 switch (t2) {
422 case PSI_T_INT8:
423 res->i64 = v1->u64 + v2->i8;
424 return PSI_T_INT64;
425 case PSI_T_UINT8:
426 res->u64 = v1->u64 + v2->u8;
427 return PSI_T_UINT64;
428 case PSI_T_INT16:
429 res->i64 = v1->u64 + v2->i16;
430 return PSI_T_INT64;
431 case PSI_T_UINT16:
432 res->u64 = v1->u64 + v2->u16;
433 return PSI_T_UINT64;
434 case PSI_T_INT32:
435 res->i64 = v1->u64 + v2->i32;
436 return PSI_T_INT64;
437 case PSI_T_UINT32:
438 res->u64 = v1->u64 + v2->u32;
439 return PSI_T_UINT64;
440 case PSI_T_INT64:
441 res->i64 = v1->u64 + v2->i64;
442 return PSI_T_INT64;
443 case PSI_T_UINT64:
444 res->u64 = v1->u64 + v2->u64;
445 return PSI_T_UINT64;
446 # if HAVE_INT128
447 case PSI_T_INT128:
448 res->i128 = v1->u64 + v2->i128;
449 return PSI_T_INT128;
450 # endif
451
452 # if HAVE_UINT128
453 case PSI_T_UINT128:
454 res->u128 = v1->u64 + v2->u128;
455 return PSI_T_UINT128;
456 # endif
457
458 case PSI_T_FLOAT:
459 res->fval = v1->u64 + v2->fval;
460 return PSI_T_FLOAT;
461 case PSI_T_DOUBLE:
462 res->dval = v1->u64 + v2->dval;
463 return PSI_T_DOUBLE;
464 # if HAVE_LONG_DOUBLE
465 case PSI_T_LONG_DOUBLE:
466 res->ldval = v1->u64 + v2->ldval;
467 return PSI_T_LONG_DOUBLE;
468 # endif
469
470 default:
471 assert(0);
472 break;
473 }
474 break;
475 #if HAVE_INT128
476 case PSI_T_INT128:
477 switch (t2) {
478 case PSI_T_INT8:
479 res->i128 = v1->i128 + v2->i8;
480 return PSI_T_INT128;
481 case PSI_T_UINT8:
482 res->i128 = v1->i128 + v2->u8;
483 return PSI_T_INT128;
484 case PSI_T_INT16:
485 res->i128 = v1->i128 + v2->i16;
486 return PSI_T_INT128;
487 case PSI_T_UINT16:
488 res->i128 = v1->i128 + v2->u16;
489 return PSI_T_INT128;
490 case PSI_T_INT32:
491 res->i128 = v1->i128 + v2->i32;
492 return PSI_T_INT128;
493 case PSI_T_UINT32:
494 res->i128 = v1->i128 + v2->u32;
495 return PSI_T_INT128;
496 case PSI_T_INT64:
497 res->i128 = v1->i128 + v2->i64;
498 return PSI_T_INT128;
499 case PSI_T_UINT64:
500 res->i128 = v1->i128 + v2->u64;
501 return PSI_T_INT128;
502 # if HAVE_INT128
503 case PSI_T_INT128:
504 res->i128 = v1->i128 + v2->i128;
505 return PSI_T_INT128;
506 # endif
507
508 # if HAVE_UINT128
509 case PSI_T_UINT128:
510 res->u128 = v1->i128 + v2->u128;
511 return PSI_T_UINT128;
512 # endif
513
514 case PSI_T_FLOAT:
515 res->fval = v1->i128 + v2->fval;
516 return PSI_T_FLOAT;
517 case PSI_T_DOUBLE:
518 res->dval = v1->i128 + v2->dval;
519 return PSI_T_DOUBLE;
520 # if HAVE_LONG_DOUBLE
521 case PSI_T_LONG_DOUBLE:
522 res->ldval = v1->i128 + v2->ldval;
523 return PSI_T_LONG_DOUBLE;
524 # endif
525
526 default:
527 assert(0);
528 break;
529 }
530 break;
531 #endif
532
533 #if HAVE_UINT128
534 case PSI_T_UINT128:
535 switch (t2) {
536 case PSI_T_INT8:
537 res->u128 = v1->u128 + v2->i8;
538 return PSI_T_UINT128;
539 case PSI_T_UINT8:
540 res->u128 = v1->u128 + v2->u8;
541 return PSI_T_UINT128;
542 case PSI_T_INT16:
543 res->u128 = v1->u128 + v2->i16;
544 return PSI_T_UINT128;
545 case PSI_T_UINT16:
546 res->u128 = v1->u128 + v2->u16;
547 return PSI_T_UINT128;
548 case PSI_T_INT32:
549 res->u128 = v1->u128 + v2->i32;
550 return PSI_T_UINT128;
551 case PSI_T_UINT32:
552 res->u128 = v1->u128 + v2->u32;
553 return PSI_T_UINT128;
554 case PSI_T_INT64:
555 res->u128 = v1->u128 + v2->i64;
556 return PSI_T_UINT128;
557 case PSI_T_UINT64:
558 res->u128 = v1->u128 + v2->u64;
559 return PSI_T_UINT128;
560 # if HAVE_INT128
561 case PSI_T_INT128:
562 res->u128 = v1->u128 + v2->i128;
563 return PSI_T_UINT128;
564 # endif
565
566 # if HAVE_UINT128
567 case PSI_T_UINT128:
568 res->u128 = v1->u128 + v2->u128;
569 return PSI_T_UINT128;
570 # endif
571
572 case PSI_T_FLOAT:
573 res->fval = v1->u128 + v2->fval;
574 return PSI_T_FLOAT;
575 case PSI_T_DOUBLE:
576 res->dval = v1->u128 + v2->dval;
577 return PSI_T_DOUBLE;
578 # if HAVE_LONG_DOUBLE
579 case PSI_T_LONG_DOUBLE:
580 res->ldval = v1->u128 + v2->ldval;
581 return PSI_T_LONG_DOUBLE;
582 # endif
583
584 default:
585 assert(0);
586 break;
587 }
588 break;
589 #endif
590
591 case PSI_T_FLOAT:
592 switch (t2) {
593 case PSI_T_INT8:
594 res->fval = v1->fval + v2->i8;
595 return PSI_T_FLOAT;
596 case PSI_T_UINT8:
597 res->fval = v1->fval + v2->u8;
598 return PSI_T_FLOAT;
599 case PSI_T_INT16:
600 res->fval = v1->fval + v2->i16;
601 return PSI_T_FLOAT;
602 case PSI_T_UINT16:
603 res->fval = v1->fval + v2->u16;
604 return PSI_T_FLOAT;
605 case PSI_T_INT32:
606 res->fval = v1->fval + v2->i32;
607 return PSI_T_FLOAT;
608 case PSI_T_UINT32:
609 res->fval = v1->fval + v2->u32;
610 return PSI_T_FLOAT;
611 case PSI_T_INT64:
612 res->fval = v1->fval + v2->i64;
613 return PSI_T_FLOAT;
614 case PSI_T_UINT64:
615 res->fval = v1->fval + v2->u64;
616 return PSI_T_FLOAT;
617 # if HAVE_INT128
618 case PSI_T_INT128:
619 res->fval = v1->fval + v2->i128;
620 return PSI_T_FLOAT;
621 # endif
622
623 # if HAVE_UINT128
624 case PSI_T_UINT128:
625 res->fval = v1->fval + v2->u128;
626 return PSI_T_FLOAT;
627 # endif
628
629 case PSI_T_FLOAT:
630 res->fval = v1->fval + v2->fval;
631 return PSI_T_FLOAT;
632 case PSI_T_DOUBLE:
633 res->dval = v1->fval + v2->dval;
634 return PSI_T_DOUBLE;
635 # if HAVE_LONG_DOUBLE
636 case PSI_T_LONG_DOUBLE:
637 res->ldval = v1->fval + v2->ldval;
638 return PSI_T_LONG_DOUBLE;
639 # endif
640
641 default:
642 assert(0);
643 break;
644 }
645 break;
646 case PSI_T_DOUBLE:
647 switch (t2) {
648 case PSI_T_INT8:
649 res->dval = v1->dval + v2->i8;
650 return PSI_T_DOUBLE;
651 case PSI_T_UINT8:
652 res->dval = v1->dval + v2->u8;
653 return PSI_T_DOUBLE;
654 case PSI_T_INT16:
655 res->dval = v1->dval + v2->i16;
656 return PSI_T_DOUBLE;
657 case PSI_T_UINT16:
658 res->dval = v1->dval + v2->u16;
659 return PSI_T_DOUBLE;
660 case PSI_T_INT32:
661 res->dval = v1->dval + v2->i32;
662 return PSI_T_DOUBLE;
663 case PSI_T_UINT32:
664 res->dval = v1->dval + v2->u32;
665 return PSI_T_DOUBLE;
666 case PSI_T_INT64:
667 res->dval = v1->dval + v2->i64;
668 return PSI_T_DOUBLE;
669 case PSI_T_UINT64:
670 res->dval = v1->dval + v2->u64;
671 return PSI_T_DOUBLE;
672 # if HAVE_INT128
673 case PSI_T_INT128:
674 res->dval = v1->dval + v2->i128;
675 return PSI_T_DOUBLE;
676 # endif
677
678 # if HAVE_UINT128
679 case PSI_T_UINT128:
680 res->dval = v1->dval + v2->u128;
681 return PSI_T_DOUBLE;
682 # endif
683
684 case PSI_T_FLOAT:
685 res->dval = v1->dval + v2->fval;
686 return PSI_T_DOUBLE;
687 case PSI_T_DOUBLE:
688 res->dval = v1->dval + v2->dval;
689 return PSI_T_DOUBLE;
690 # if HAVE_LONG_DOUBLE
691 case PSI_T_LONG_DOUBLE:
692 res->ldval = v1->dval + v2->ldval;
693 return PSI_T_LONG_DOUBLE;
694 # endif
695
696 default:
697 assert(0);
698 break;
699 }
700 break;
701 #if HAVE_LONG_DOUBLE
702 case PSI_T_LONG_DOUBLE:
703 switch (t2) {
704 case PSI_T_INT8:
705 res->ldval = v1->ldval + v2->i8;
706 return PSI_T_LONG_DOUBLE;
707 case PSI_T_UINT8:
708 res->ldval = v1->ldval + v2->u8;
709 return PSI_T_LONG_DOUBLE;
710 case PSI_T_INT16:
711 res->ldval = v1->ldval + v2->i16;
712 return PSI_T_LONG_DOUBLE;
713 case PSI_T_UINT16:
714 res->ldval = v1->ldval + v2->u16;
715 return PSI_T_LONG_DOUBLE;
716 case PSI_T_INT32:
717 res->ldval = v1->ldval + v2->i32;
718 return PSI_T_LONG_DOUBLE;
719 case PSI_T_UINT32:
720 res->ldval = v1->ldval + v2->u32;
721 return PSI_T_LONG_DOUBLE;
722 case PSI_T_INT64:
723 res->ldval = v1->ldval + v2->i64;
724 return PSI_T_LONG_DOUBLE;
725 case PSI_T_UINT64:
726 res->ldval = v1->ldval + v2->u64;
727 return PSI_T_LONG_DOUBLE;
728 # if HAVE_INT128
729 case PSI_T_INT128:
730 res->ldval = v1->ldval + v2->i128;
731 return PSI_T_LONG_DOUBLE;
732 # endif
733
734 # if HAVE_UINT128
735 case PSI_T_UINT128:
736 res->ldval = v1->ldval + v2->u128;
737 return PSI_T_LONG_DOUBLE;
738 # endif
739
740 case PSI_T_FLOAT:
741 res->ldval = v1->ldval + v2->fval;
742 return PSI_T_LONG_DOUBLE;
743 case PSI_T_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;
750 # endif
751
752 default:
753 assert(0);
754 break;
755 }
756 break;
757 #endif
758
759 default:
760 assert(0);
761 break;
762 }
763
764 return 0;
765 }
766 static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
767 {
768
769 switch (t1) {
770 case PSI_T_INT8:
771 switch (t2) {
772 case PSI_T_INT8:
773 res->i16 = v1->i8 - v2->i8;
774 return PSI_T_INT16;
775 case PSI_T_UINT8:
776 res->i16 = v1->i8 - v2->u8;
777 return PSI_T_INT16;
778 case PSI_T_INT16:
779 res->i32 = v1->i8 - v2->i16;
780 return PSI_T_INT32;
781 case PSI_T_UINT16:
782 res->i32 = v1->i8 - v2->u16;
783 return PSI_T_INT32;
784 case PSI_T_INT32:
785 res->i64 = v1->i8 - v2->i32;
786 return PSI_T_INT64;
787 case PSI_T_UINT32:
788 res->i64 = v1->i8 - v2->u32;
789 return PSI_T_INT64;
790 case PSI_T_INT64:
791 res->i64 = v1->i8 - v2->i64;
792 return PSI_T_INT64;
793 case PSI_T_UINT64:
794 res->i64 = v1->i8 - v2->u64;
795 return PSI_T_INT64;
796 # if HAVE_INT128
797 case PSI_T_INT128:
798 res->i128 = v1->i8 - v2->i128;
799 return PSI_T_INT128;
800 # endif
801
802 # if HAVE_UINT128
803 case PSI_T_UINT128:
804 res->u128 = v1->i8 - v2->u128;
805 return PSI_T_UINT128;
806 # endif
807
808 case PSI_T_FLOAT:
809 res->fval = v1->i8 - v2->fval;
810 return PSI_T_FLOAT;
811 case PSI_T_DOUBLE:
812 res->dval = v1->i8 - v2->dval;
813 return PSI_T_DOUBLE;
814 # if HAVE_LONG_DOUBLE
815 case PSI_T_LONG_DOUBLE:
816 res->ldval = v1->i8 - v2->ldval;
817 return PSI_T_LONG_DOUBLE;
818 # endif
819
820 default:
821 assert(0);
822 break;
823 }
824 break;
825 case PSI_T_UINT8:
826 switch (t2) {
827 case PSI_T_INT8:
828 res->i16 = v1->u8 - v2->i8;
829 return PSI_T_INT16;
830 case PSI_T_UINT8:
831 res->u16 = v1->u8 - v2->u8;
832 return PSI_T_UINT16;
833 case PSI_T_INT16:
834 res->i32 = v1->u8 - v2->i16;
835 return PSI_T_INT32;
836 case PSI_T_UINT16:
837 res->u32 = v1->u8 - v2->u16;
838 return PSI_T_UINT32;
839 case PSI_T_INT32:
840 res->i64 = v1->u8 - v2->i32;
841 return PSI_T_INT64;
842 case PSI_T_UINT32:
843 res->u64 = v1->u8 - v2->u32;
844 return PSI_T_UINT64;
845 case PSI_T_INT64:
846 res->i64 = v1->u8 - v2->i64;
847 return PSI_T_INT64;
848 case PSI_T_UINT64:
849 res->u64 = v1->u8 - v2->u64;
850 return PSI_T_UINT64;
851 # if HAVE_INT128
852 case PSI_T_INT128:
853 res->i128 = v1->u8 - v2->i128;
854 return PSI_T_INT128;
855 # endif
856
857 # if HAVE_UINT128
858 case PSI_T_UINT128:
859 res->u128 = v1->u8 - v2->u128;
860 return PSI_T_UINT128;
861 # endif
862
863 case PSI_T_FLOAT:
864 res->fval = v1->u8 - v2->fval;
865 return PSI_T_FLOAT;
866 case PSI_T_DOUBLE:
867 res->dval = v1->u8 - v2->dval;
868 return PSI_T_DOUBLE;
869 # if HAVE_LONG_DOUBLE
870 case PSI_T_LONG_DOUBLE:
871 res->ldval = v1->u8 - v2->ldval;
872 return PSI_T_LONG_DOUBLE;
873 # endif
874
875 default:
876 assert(0);
877 break;
878 }
879 break;
880 case PSI_T_INT16:
881 switch (t2) {
882 case PSI_T_INT8:
883 res->i32 = v1->i16 - v2->i8;
884 return PSI_T_INT32;
885 case PSI_T_UINT8:
886 res->i32 = v1->i16 - v2->u8;
887 return PSI_T_INT32;
888 case PSI_T_INT16:
889 res->i32 = v1->i16 - v2->i16;
890 return PSI_T_INT32;
891 case PSI_T_UINT16:
892 res->i32 = v1->i16 - v2->u16;
893 return PSI_T_INT32;
894 case PSI_T_INT32:
895 res->i64 = v1->i16 - v2->i32;
896 return PSI_T_INT64;
897 case PSI_T_UINT32:
898 res->i64 = v1->i16 - v2->u32;
899 return PSI_T_INT64;
900 case PSI_T_INT64:
901 res->i64 = v1->i16 - v2->i64;
902 return PSI_T_INT64;
903 case PSI_T_UINT64:
904 res->i64 = v1->i16 - v2->u64;
905 return PSI_T_INT64;
906 # if HAVE_INT128
907 case PSI_T_INT128:
908 res->i128 = v1->i16 - v2->i128;
909 return PSI_T_INT128;
910 # endif
911
912 # if HAVE_UINT128
913 case PSI_T_UINT128:
914 res->u128 = v1->i16 - v2->u128;
915 return PSI_T_UINT128;
916 # endif
917
918 case PSI_T_FLOAT:
919 res->fval = v1->i16 - v2->fval;
920 return PSI_T_FLOAT;
921 case PSI_T_DOUBLE:
922 res->dval = v1->i16 - v2->dval;
923 return PSI_T_DOUBLE;
924 # if HAVE_LONG_DOUBLE
925 case PSI_T_LONG_DOUBLE:
926 res->ldval = v1->i16 - v2->ldval;
927 return PSI_T_LONG_DOUBLE;
928 # endif
929
930 default:
931 assert(0);
932 break;
933 }
934 break;
935 case PSI_T_UINT16:
936 switch (t2) {
937 case PSI_T_INT8:
938 res->i32 = v1->u16 - v2->i8;
939 return PSI_T_INT32;
940 case PSI_T_UINT8:
941 res->u32 = v1->u16 - v2->u8;
942 return PSI_T_UINT32;
943 case PSI_T_INT16:
944 res->i32 = v1->u16 - v2->i16;
945 return PSI_T_INT32;
946 case PSI_T_UINT16:
947 res->u32 = v1->u16 - v2->u16;
948 return PSI_T_UINT32;
949 case PSI_T_INT32:
950 res->i64 = v1->u16 - v2->i32;
951 return PSI_T_INT64;
952 case PSI_T_UINT32:
953 res->u64 = v1->u16 - v2->u32;
954 return PSI_T_UINT64;
955 case PSI_T_INT64:
956 res->i64 = v1->u16 - v2->i64;
957 return PSI_T_INT64;
958 case PSI_T_UINT64:
959 res->u64 = v1->u16 - v2->u64;
960 return PSI_T_UINT64;
961 # if HAVE_INT128
962 case PSI_T_INT128:
963 res->i128 = v1->u16 - v2->i128;
964 return PSI_T_INT128;
965 # endif
966
967 # if HAVE_UINT128
968 case PSI_T_UINT128:
969 res->u128 = v1->u16 - v2->u128;
970 return PSI_T_UINT128;
971 # endif
972
973 case PSI_T_FLOAT:
974 res->fval = v1->u16 - v2->fval;
975 return PSI_T_FLOAT;
976 case PSI_T_DOUBLE:
977 res->dval = v1->u16 - v2->dval;
978 return PSI_T_DOUBLE;
979 # if HAVE_LONG_DOUBLE
980 case PSI_T_LONG_DOUBLE:
981 res->ldval = v1->u16 - v2->ldval;
982 return PSI_T_LONG_DOUBLE;
983 # endif
984
985 default:
986 assert(0);
987 break;
988 }
989 break;
990 case PSI_T_INT32:
991 switch (t2) {
992 case PSI_T_INT8:
993 res->i64 = v1->i32 - v2->i8;
994 return PSI_T_INT64;
995 case PSI_T_UINT8:
996 res->i64 = v1->i32 - v2->u8;
997 return PSI_T_INT64;
998 case PSI_T_INT16:
999 res->i64 = v1->i32 - v2->i16;
1000 return PSI_T_INT64;
1001 case PSI_T_UINT16:
1002 res->i64 = v1->i32 - v2->u16;
1003 return PSI_T_INT64;
1004 case PSI_T_INT32:
1005 res->i64 = v1->i32 - v2->i32;
1006 return PSI_T_INT64;
1007 case PSI_T_UINT32:
1008 res->i64 = v1->i32 - v2->u32;
1009 return PSI_T_INT64;
1010 case PSI_T_INT64:
1011 res->i64 = v1->i32 - v2->i64;
1012 return PSI_T_INT64;
1013 case PSI_T_UINT64:
1014 res->i64 = v1->i32 - v2->u64;
1015 return PSI_T_INT64;
1016 # if HAVE_INT128
1017 case PSI_T_INT128:
1018 res->i128 = v1->i32 - v2->i128;
1019 return PSI_T_INT128;
1020 # endif
1021
1022 # if HAVE_UINT128
1023 case PSI_T_UINT128:
1024 res->u128 = v1->i32 - v2->u128;
1025 return PSI_T_UINT128;
1026 # endif
1027
1028 case PSI_T_FLOAT:
1029 res->fval = v1->i32 - v2->fval;
1030 return PSI_T_FLOAT;
1031 case PSI_T_DOUBLE:
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;
1038 # endif
1039
1040 default:
1041 assert(0);
1042 break;
1043 }
1044 break;
1045 case PSI_T_UINT32:
1046 switch (t2) {
1047 case PSI_T_INT8:
1048 res->i64 = v1->u32 - v2->i8;
1049 return PSI_T_INT64;
1050 case PSI_T_UINT8:
1051 res->u64 = v1->u32 - v2->u8;
1052 return PSI_T_UINT64;
1053 case PSI_T_INT16:
1054 res->i64 = v1->u32 - v2->i16;
1055 return PSI_T_INT64;
1056 case PSI_T_UINT16:
1057 res->u64 = v1->u32 - v2->u16;
1058 return PSI_T_UINT64;
1059 case PSI_T_INT32:
1060 res->i64 = v1->u32 - v2->i32;
1061 return PSI_T_INT64;
1062 case PSI_T_UINT32:
1063 res->u64 = v1->u32 - v2->u32;
1064 return PSI_T_UINT64;
1065 case PSI_T_INT64:
1066 res->i64 = v1->u32 - v2->i64;
1067 return PSI_T_INT64;
1068 case PSI_T_UINT64:
1069 res->u64 = v1->u32 - v2->u64;
1070 return PSI_T_UINT64;
1071 # if HAVE_INT128
1072 case PSI_T_INT128:
1073 res->i128 = v1->u32 - v2->i128;
1074 return PSI_T_INT128;
1075 # endif
1076
1077 # if HAVE_UINT128
1078 case PSI_T_UINT128:
1079 res->u128 = v1->u32 - v2->u128;
1080 return PSI_T_UINT128;
1081 # endif
1082
1083 case PSI_T_FLOAT:
1084 res->fval = v1->u32 - v2->fval;
1085 return PSI_T_FLOAT;
1086 case PSI_T_DOUBLE:
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;
1093 # endif
1094
1095 default:
1096 assert(0);
1097 break;
1098 }
1099 break;
1100 case PSI_T_INT64:
1101 switch (t2) {
1102 case PSI_T_INT8:
1103 res->i64 = v1->i64 - v2->i8;
1104 return PSI_T_INT64;
1105 case PSI_T_UINT8:
1106 res->i64 = v1->i64 - v2->u8;
1107 return PSI_T_INT64;
1108 case PSI_T_INT16:
1109 res->i64 = v1->i64 - v2->i16;
1110 return PSI_T_INT64;
1111 case PSI_T_UINT16:
1112 res->i64 = v1->i64 - v2->u16;
1113 return PSI_T_INT64;
1114 case PSI_T_INT32:
1115 res->i64 = v1->i64 - v2->i32;
1116 return PSI_T_INT64;
1117 case PSI_T_UINT32:
1118 res->i64 = v1->i64 - v2->u32;
1119 return PSI_T_INT64;
1120 case PSI_T_INT64:
1121 res->i64 = v1->i64 - v2->i64;
1122 return PSI_T_INT64;
1123 case PSI_T_UINT64:
1124 res->i64 = v1->i64 - v2->u64;
1125 return PSI_T_INT64;
1126 # if HAVE_INT128
1127 case PSI_T_INT128:
1128 res->i128 = v1->i64 - v2->i128;
1129 return PSI_T_INT128;
1130 # endif
1131
1132 # if HAVE_UINT128
1133 case PSI_T_UINT128:
1134 res->u128 = v1->i64 - v2->u128;
1135 return PSI_T_UINT128;
1136 # endif
1137
1138 case PSI_T_FLOAT:
1139 res->fval = v1->i64 - v2->fval;
1140 return PSI_T_FLOAT;
1141 case PSI_T_DOUBLE:
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;
1148 # endif
1149
1150 default:
1151 assert(0);
1152 break;
1153 }
1154 break;
1155 case PSI_T_UINT64:
1156 switch (t2) {
1157 case PSI_T_INT8:
1158 res->i64 = v1->u64 - v2->i8;
1159 return PSI_T_INT64;
1160 case PSI_T_UINT8:
1161 res->u64 = v1->u64 - v2->u8;
1162 return PSI_T_UINT64;
1163 case PSI_T_INT16:
1164 res->i64 = v1->u64 - v2->i16;
1165 return PSI_T_INT64;
1166 case PSI_T_UINT16:
1167 res->u64 = v1->u64 - v2->u16;
1168 return PSI_T_UINT64;
1169 case PSI_T_INT32:
1170 res->i64 = v1->u64 - v2->i32;
1171 return PSI_T_INT64;
1172 case PSI_T_UINT32:
1173 res->u64 = v1->u64 - v2->u32;
1174 return PSI_T_UINT64;
1175 case PSI_T_INT64:
1176 res->i64 = v1->u64 - v2->i64;
1177 return PSI_T_INT64;
1178 case PSI_T_UINT64:
1179 res->u64 = v1->u64 - v2->u64;
1180 return PSI_T_UINT64;
1181 # if HAVE_INT128
1182 case PSI_T_INT128:
1183 res->i128 = v1->u64 - v2->i128;
1184 return PSI_T_INT128;
1185 # endif
1186
1187 # if HAVE_UINT128
1188 case PSI_T_UINT128:
1189 res->u128 = v1->u64 - v2->u128;
1190 return PSI_T_UINT128;
1191 # endif
1192
1193 case PSI_T_FLOAT:
1194 res->fval = v1->u64 - v2->fval;
1195 return PSI_T_FLOAT;
1196 case PSI_T_DOUBLE:
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;
1203 # endif
1204
1205 default:
1206 assert(0);
1207 break;
1208 }
1209 break;
1210 #if HAVE_INT128
1211 case PSI_T_INT128:
1212 switch (t2) {
1213 case PSI_T_INT8:
1214 res->i128 = v1->i128 - v2->i8;
1215 return PSI_T_INT128;
1216 case PSI_T_UINT8:
1217 res->i128 = v1->i128 - v2->u8;
1218 return PSI_T_INT128;
1219 case PSI_T_INT16:
1220 res->i128 = v1->i128 - v2->i16;
1221 return PSI_T_INT128;
1222 case PSI_T_UINT16:
1223 res->i128 = v1->i128 - v2->u16;
1224 return PSI_T_INT128;
1225 case PSI_T_INT32:
1226 res->i128 = v1->i128 - v2->i32;
1227 return PSI_T_INT128;
1228 case PSI_T_UINT32:
1229 res->i128 = v1->i128 - v2->u32;
1230 return PSI_T_INT128;
1231 case PSI_T_INT64:
1232 res->i128 = v1->i128 - v2->i64;
1233 return PSI_T_INT128;
1234 case PSI_T_UINT64:
1235 res->i128 = v1->i128 - v2->u64;
1236 return PSI_T_INT128;
1237 # if HAVE_INT128
1238 case PSI_T_INT128:
1239 res->i128 = v1->i128 - v2->i128;
1240 return PSI_T_INT128;
1241 # endif
1242
1243 # if HAVE_UINT128
1244 case PSI_T_UINT128:
1245 res->u128 = v1->i128 - v2->u128;
1246 return PSI_T_UINT128;
1247 # endif
1248
1249 case PSI_T_FLOAT:
1250 res->fval = v1->i128 - v2->fval;
1251 return PSI_T_FLOAT;
1252 case PSI_T_DOUBLE:
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;
1259 # endif
1260
1261 default:
1262 assert(0);
1263 break;
1264 }
1265 break;
1266 #endif
1267
1268 #if HAVE_UINT128
1269 case PSI_T_UINT128:
1270 switch (t2) {
1271 case PSI_T_INT8:
1272 res->u128 = v1->u128 - v2->i8;
1273 return PSI_T_UINT128;
1274 case PSI_T_UINT8:
1275 res->u128 = v1->u128 - v2->u8;
1276 return PSI_T_UINT128;
1277 case PSI_T_INT16:
1278 res->u128 = v1->u128 - v2->i16;
1279 return PSI_T_UINT128;
1280 case PSI_T_UINT16:
1281 res->u128 = v1->u128 - v2->u16;
1282 return PSI_T_UINT128;
1283 case PSI_T_INT32:
1284 res->u128 = v1->u128 - v2->i32;
1285 return PSI_T_UINT128;
1286 case PSI_T_UINT32:
1287 res->u128 = v1->u128 - v2->u32;
1288 return PSI_T_UINT128;
1289 case PSI_T_INT64:
1290 res->u128 = v1->u128 - v2->i64;
1291 return PSI_T_UINT128;
1292 case PSI_T_UINT64:
1293 res->u128 = v1->u128 - v2->u64;
1294 return PSI_T_UINT128;
1295 # if HAVE_INT128
1296 case PSI_T_INT128:
1297 res->u128 = v1->u128 - v2->i128;
1298 return PSI_T_UINT128;
1299 # endif
1300
1301 # if HAVE_UINT128
1302 case PSI_T_UINT128:
1303 res->u128 = v1->u128 - v2->u128;
1304 return PSI_T_UINT128;
1305 # endif
1306
1307 case PSI_T_FLOAT:
1308 res->fval = v1->u128 - v2->fval;
1309 return PSI_T_FLOAT;
1310 case PSI_T_DOUBLE:
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;
1317 # endif
1318
1319 default:
1320 assert(0);
1321 break;
1322 }
1323 break;
1324 #endif
1325
1326 case PSI_T_FLOAT:
1327 switch (t2) {
1328 case PSI_T_INT8:
1329 res->fval = v1->fval - v2->i8;
1330 return PSI_T_FLOAT;
1331 case PSI_T_UINT8:
1332 res->fval = v1->fval - v2->u8;
1333 return PSI_T_FLOAT;
1334 case PSI_T_INT16:
1335 res->fval = v1->fval - v2->i16;
1336 return PSI_T_FLOAT;
1337 case PSI_T_UINT16:
1338 res->fval = v1->fval - v2->u16;
1339 return PSI_T_FLOAT;
1340 case PSI_T_INT32:
1341 res->fval = v1->fval - v2->i32;
1342 return PSI_T_FLOAT;
1343 case PSI_T_UINT32:
1344 res->fval = v1->fval - v2->u32;
1345 return PSI_T_FLOAT;
1346 case PSI_T_INT64:
1347 res->fval = v1->fval - v2->i64;
1348 return PSI_T_FLOAT;
1349 case PSI_T_UINT64:
1350 res->fval = v1->fval - v2->u64;
1351 return PSI_T_FLOAT;
1352 # if HAVE_INT128
1353 case PSI_T_INT128:
1354 res->fval = v1->fval - v2->i128;
1355 return PSI_T_FLOAT;
1356 # endif
1357
1358 # if HAVE_UINT128
1359 case PSI_T_UINT128:
1360 res->fval = v1->fval - v2->u128;
1361 return PSI_T_FLOAT;
1362 # endif
1363
1364 case PSI_T_FLOAT:
1365 res->fval = v1->fval - v2->fval;
1366 return PSI_T_FLOAT;
1367 case PSI_T_DOUBLE:
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;
1374 # endif
1375
1376 default:
1377 assert(0);
1378 break;
1379 }
1380 break;
1381 case PSI_T_DOUBLE:
1382 switch (t2) {
1383 case PSI_T_INT8:
1384 res->dval = v1->dval - v2->i8;
1385 return PSI_T_DOUBLE;
1386 case PSI_T_UINT8:
1387 res->dval = v1->dval - v2->u8;
1388 return PSI_T_DOUBLE;
1389 case PSI_T_INT16:
1390 res->dval = v1->dval - v2->i16;
1391 return PSI_T_DOUBLE;
1392 case PSI_T_UINT16:
1393 res->dval = v1->dval - v2->u16;
1394 return PSI_T_DOUBLE;
1395 case PSI_T_INT32:
1396 res->dval = v1->dval - v2->i32;
1397 return PSI_T_DOUBLE;
1398 case PSI_T_UINT32:
1399 res->dval = v1->dval - v2->u32;
1400 return PSI_T_DOUBLE;
1401 case PSI_T_INT64:
1402 res->dval = v1->dval - v2->i64;
1403 return PSI_T_DOUBLE;
1404 case PSI_T_UINT64:
1405 res->dval = v1->dval - v2->u64;
1406 return PSI_T_DOUBLE;
1407 # if HAVE_INT128
1408 case PSI_T_INT128:
1409 res->dval = v1->dval - v2->i128;
1410 return PSI_T_DOUBLE;
1411 # endif
1412
1413 # if HAVE_UINT128
1414 case PSI_T_UINT128:
1415 res->dval = v1->dval - v2->u128;
1416 return PSI_T_DOUBLE;
1417 # endif
1418
1419 case PSI_T_FLOAT:
1420 res->dval = v1->dval - v2->fval;
1421 return PSI_T_DOUBLE;
1422 case 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;
1429 # endif
1430
1431 default:
1432 assert(0);
1433 break;
1434 }
1435 break;
1436 #if HAVE_LONG_DOUBLE
1437 case PSI_T_LONG_DOUBLE:
1438 switch (t2) {
1439 case PSI_T_INT8:
1440 res->ldval = v1->ldval - v2->i8;
1441 return PSI_T_LONG_DOUBLE;
1442 case PSI_T_UINT8:
1443 res->ldval = v1->ldval - v2->u8;
1444 return PSI_T_LONG_DOUBLE;
1445 case PSI_T_INT16:
1446 res->ldval = v1->ldval - v2->i16;
1447 return PSI_T_LONG_DOUBLE;
1448 case PSI_T_UINT16:
1449 res->ldval = v1->ldval - v2->u16;
1450 return PSI_T_LONG_DOUBLE;
1451 case PSI_T_INT32:
1452 res->ldval = v1->ldval - v2->i32;
1453 return PSI_T_LONG_DOUBLE;
1454 case PSI_T_UINT32:
1455 res->ldval = v1->ldval - v2->u32;
1456 return PSI_T_LONG_DOUBLE;
1457 case PSI_T_INT64:
1458 res->ldval = v1->ldval - v2->i64;
1459 return PSI_T_LONG_DOUBLE;
1460 case PSI_T_UINT64:
1461 res->ldval = v1->ldval - v2->u64;
1462 return PSI_T_LONG_DOUBLE;
1463 # if HAVE_INT128
1464 case PSI_T_INT128:
1465 res->ldval = v1->ldval - v2->i128;
1466 return PSI_T_LONG_DOUBLE;
1467 # endif
1468
1469 # if HAVE_UINT128
1470 case PSI_T_UINT128:
1471 res->ldval = v1->ldval - v2->u128;
1472 return PSI_T_LONG_DOUBLE;
1473 # endif
1474
1475 case PSI_T_FLOAT:
1476 res->ldval = v1->ldval - v2->fval;
1477 return PSI_T_LONG_DOUBLE;
1478 case PSI_T_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;
1485 # endif
1486
1487 default:
1488 assert(0);
1489 break;
1490 }
1491 break;
1492 #endif
1493
1494 default:
1495 assert(0);
1496 break;
1497 }
1498
1499 return 0;
1500 }
1501 static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
1502 {
1503
1504 switch (t1) {
1505 case PSI_T_INT8:
1506 switch (t2) {
1507 case PSI_T_INT8:
1508 res->i16 = v1->i8 * v2->i8;
1509 return PSI_T_INT16;
1510 case PSI_T_UINT8:
1511 res->i16 = v1->i8 * v2->u8;
1512 return PSI_T_INT16;
1513 case PSI_T_INT16:
1514 res->i32 = v1->i8 * v2->i16;
1515 return PSI_T_INT32;
1516 case PSI_T_UINT16:
1517 res->i32 = v1->i8 * v2->u16;
1518 return PSI_T_INT32;
1519 case PSI_T_INT32:
1520 res->i64 = v1->i8 * v2->i32;
1521 return PSI_T_INT64;
1522 case PSI_T_UINT32:
1523 res->i64 = v1->i8 * v2->u32;
1524 return PSI_T_INT64;
1525 case PSI_T_INT64:
1526 res->i64 = v1->i8 * v2->i64;
1527 return PSI_T_INT64;
1528 case PSI_T_UINT64:
1529 res->i64 = v1->i8 * v2->u64;
1530 return PSI_T_INT64;
1531 # if HAVE_INT128
1532 case PSI_T_INT128:
1533 res->i128 = v1->i8 * v2->i128;
1534 return PSI_T_INT128;
1535 # endif
1536
1537 # if HAVE_UINT128
1538 case PSI_T_UINT128:
1539 res->u128 = v1->i8 * v2->u128;
1540 return PSI_T_UINT128;
1541 # endif
1542
1543 case PSI_T_FLOAT:
1544 res->fval = v1->i8 * v2->fval;
1545 return PSI_T_FLOAT;
1546 case PSI_T_DOUBLE:
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;
1553 # endif
1554
1555 default:
1556 assert(0);
1557 break;
1558 }
1559 break;
1560 case PSI_T_UINT8:
1561 switch (t2) {
1562 case PSI_T_INT8:
1563 res->i16 = v1->u8 * v2->i8;
1564 return PSI_T_INT16;
1565 case PSI_T_UINT8:
1566 res->u16 = v1->u8 * v2->u8;
1567 return PSI_T_UINT16;
1568 case PSI_T_INT16:
1569 res->i32 = v1->u8 * v2->i16;
1570 return PSI_T_INT32;
1571 case PSI_T_UINT16:
1572 res->u32 = v1->u8 * v2->u16;
1573 return PSI_T_UINT32;
1574 case PSI_T_INT32:
1575 res->i64 = v1->u8 * v2->i32;
1576 return PSI_T_INT64;
1577 case PSI_T_UINT32:
1578 res->u64 = v1->u8 * v2->u32;
1579 return PSI_T_UINT64;
1580 case PSI_T_INT64:
1581 res->i64 = v1->u8 * v2->i64;
1582 return PSI_T_INT64;
1583 case PSI_T_UINT64:
1584 res->u64 = v1->u8 * v2->u64;
1585 return PSI_T_UINT64;
1586 # if HAVE_INT128
1587 case PSI_T_INT128:
1588 res->i128 = v1->u8 * v2->i128;
1589 return PSI_T_INT128;
1590 # endif
1591
1592 # if HAVE_UINT128
1593 case PSI_T_UINT128:
1594 res->u128 = v1->u8 * v2->u128;
1595 return PSI_T_UINT128;
1596 # endif
1597
1598 case PSI_T_FLOAT:
1599 res->fval = v1->u8 * v2->fval;
1600 return PSI_T_FLOAT;
1601 case PSI_T_DOUBLE:
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;
1608 # endif
1609
1610 default:
1611 assert(0);
1612 break;
1613 }
1614 break;
1615 case PSI_T_INT16:
1616 switch (t2) {
1617 case PSI_T_INT8:
1618 res->i32 = v1->i16 * v2->i8;
1619 return PSI_T_INT32;
1620 case PSI_T_UINT8:
1621 res->i32 = v1->i16 * v2->u8;
1622 return PSI_T_INT32;
1623 case PSI_T_INT16:
1624 res->i32 = v1->i16 * v2->i16;
1625 return PSI_T_INT32;
1626 case PSI_T_UINT16:
1627 res->i32 = v1->i16 * v2->u16;
1628 return PSI_T_INT32;
1629 case PSI_T_INT32:
1630 res->i64 = v1->i16 * v2->i32;
1631 return PSI_T_INT64;
1632 case PSI_T_UINT32:
1633 res->i64 = v1->i16 * v2->u32;
1634 return PSI_T_INT64;
1635 case PSI_T_INT64:
1636 res->i64 = v1->i16 * v2->i64;
1637 return PSI_T_INT64;
1638 case PSI_T_UINT64:
1639 res->i64 = v1->i16 * v2->u64;
1640 return PSI_T_INT64;
1641 # if HAVE_INT128
1642 case PSI_T_INT128:
1643 res->i128 = v1->i16 * v2->i128;
1644 return PSI_T_INT128;
1645 # endif
1646
1647 # if HAVE_UINT128
1648 case PSI_T_UINT128:
1649 res->u128 = v1->i16 * v2->u128;
1650 return PSI_T_UINT128;
1651 # endif
1652
1653 case PSI_T_FLOAT:
1654 res->fval = v1->i16 * v2->fval;
1655 return PSI_T_FLOAT;
1656 case PSI_T_DOUBLE:
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;
1663 # endif
1664
1665 default:
1666 assert(0);
1667 break;
1668 }
1669 break;
1670 case PSI_T_UINT16:
1671 switch (t2) {
1672 case PSI_T_INT8:
1673 res->i32 = v1->u16 * v2->i8;
1674 return PSI_T_INT32;
1675 case PSI_T_UINT8:
1676 res->u32 = v1->u16 * v2->u8;
1677 return PSI_T_UINT32;
1678 case PSI_T_INT16:
1679 res->i32 = v1->u16 * v2->i16;
1680 return PSI_T_INT32;
1681 case PSI_T_UINT16:
1682 res->u32 = v1->u16 * v2->u16;
1683 return PSI_T_UINT32;
1684 case PSI_T_INT32:
1685 res->i64 = v1->u16 * v2->i32;
1686 return PSI_T_INT64;
1687 case PSI_T_UINT32:
1688 res->u64 = v1->u16 * v2->u32;
1689 return PSI_T_UINT64;
1690 case PSI_T_INT64:
1691 res->i64 = v1->u16 * v2->i64;
1692 return PSI_T_INT64;
1693 case PSI_T_UINT64:
1694 res->u64 = v1->u16 * v2->u64;
1695 return PSI_T_UINT64;
1696 # if HAVE_INT128
1697 case PSI_T_INT128:
1698 res->i128 = v1->u16 * v2->i128;
1699 return PSI_T_INT128;
1700 # endif
1701
1702 # if HAVE_UINT128
1703 case PSI_T_UINT128:
1704 res->u128 = v1->u16 * v2->u128;
1705 return PSI_T_UINT128;
1706 # endif
1707
1708 case PSI_T_FLOAT:
1709 res->fval = v1->u16 * v2->fval;
1710 return PSI_T_FLOAT;
1711 case PSI_T_DOUBLE:
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;
1718 # endif
1719
1720 default:
1721 assert(0);
1722 break;
1723 }
1724 break;
1725 case PSI_T_INT32:
1726 switch (t2) {
1727 case PSI_T_INT8:
1728 res->i64 = v1->i32 * v2->i8;
1729 return PSI_T_INT64;
1730 case PSI_T_UINT8:
1731 res->i64 = v1->i32 * v2->u8;
1732 return PSI_T_INT64;
1733 case PSI_T_INT16:
1734 res->i64 = v1->i32 * v2->i16;
1735 return PSI_T_INT64;
1736 case PSI_T_UINT16:
1737 res->i64 = v1->i32 * v2->u16;
1738 return PSI_T_INT64;
1739 case PSI_T_INT32:
1740 res->i64 = v1->i32 * v2->i32;
1741 return PSI_T_INT64;
1742 case PSI_T_UINT32:
1743 res->i64 = v1->i32 * v2->u32;
1744 return PSI_T_INT64;
1745 case PSI_T_INT64:
1746 res->i64 = v1->i32 * v2->i64;
1747 return PSI_T_INT64;
1748 case PSI_T_UINT64:
1749 res->i64 = v1->i32 * v2->u64;
1750 return PSI_T_INT64;
1751 # if HAVE_INT128
1752 case PSI_T_INT128:
1753 res->i128 = v1->i32 * v2->i128;
1754 return PSI_T_INT128;
1755 # endif
1756
1757 # if HAVE_UINT128
1758 case PSI_T_UINT128:
1759 res->u128 = v1->i32 * v2->u128;
1760 return PSI_T_UINT128;
1761 # endif
1762
1763 case PSI_T_FLOAT:
1764 res->fval = v1->i32 * v2->fval;
1765 return PSI_T_FLOAT;
1766 case PSI_T_DOUBLE:
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;
1773 # endif
1774
1775 default:
1776 assert(0);
1777 break;
1778 }
1779 break;
1780 case PSI_T_UINT32:
1781 switch (t2) {
1782 case PSI_T_INT8:
1783 res->i64 = v1->u32 * v2->i8;
1784 return PSI_T_INT64;
1785 case PSI_T_UINT8:
1786 res->u64 = v1->u32 * v2->u8;
1787 return PSI_T_UINT64;
1788 case PSI_T_INT16:
1789 res->i64 = v1->u32 * v2->i16;
1790 return PSI_T_INT64;
1791 case PSI_T_UINT16:
1792 res->u64 = v1->u32 * v2->u16;
1793 return PSI_T_UINT64;
1794 case PSI_T_INT32:
1795 res->i64 = v1->u32 * v2->i32;
1796 return PSI_T_INT64;
1797 case PSI_T_UINT32:
1798 res->u64 = v1->u32 * v2->u32;
1799 return PSI_T_UINT64;
1800 case PSI_T_INT64:
1801 res->i64 = v1->u32 * v2->i64;
1802 return PSI_T_INT64;
1803 case PSI_T_UINT64:
1804 res->u64 = v1->u32 * v2->u64;
1805 return PSI_T_UINT64;
1806 # if HAVE_INT128
1807 case PSI_T_INT128:
1808 res->i128 = v1->u32 * v2->i128;
1809 return PSI_T_INT128;
1810 # endif
1811
1812 # if HAVE_UINT128
1813 case PSI_T_UINT128:
1814 res->u128 = v1->u32 * v2->u128;
1815 return PSI_T_UINT128;
1816 # endif
1817
1818 case PSI_T_FLOAT:
1819 res->fval = v1->u32 * v2->fval;
1820 return PSI_T_FLOAT;
1821 case PSI_T_DOUBLE:
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;
1828 # endif
1829
1830 default:
1831 assert(0);
1832 break;
1833 }
1834 break;
1835 case PSI_T_INT64:
1836 switch (t2) {
1837 case PSI_T_INT8:
1838 res->i64 = v1->i64 * v2->i8;
1839 return PSI_T_INT64;
1840 case PSI_T_UINT8:
1841 res->i64 = v1->i64 * v2->u8;
1842 return PSI_T_INT64;
1843 case PSI_T_INT16:
1844 res->i64 = v1->i64 * v2->i16;
1845 return PSI_T_INT64;
1846 case PSI_T_UINT16:
1847 res->i64 = v1->i64 * v2->u16;
1848 return PSI_T_INT64;
1849 case PSI_T_INT32:
1850 res->i64 = v1->i64 * v2->i32;
1851 return PSI_T_INT64;
1852 case PSI_T_UINT32:
1853 res->i64 = v1->i64 * v2->u32;
1854 return PSI_T_INT64;
1855 case PSI_T_INT64:
1856 res->i64 = v1->i64 * v2->i64;
1857 return PSI_T_INT64;
1858 case PSI_T_UINT64:
1859 res->i64 = v1->i64 * v2->u64;
1860 return PSI_T_INT64;
1861 # if HAVE_INT128
1862 case PSI_T_INT128:
1863 res->i128 = v1->i64 * v2->i128;
1864 return PSI_T_INT128;
1865 # endif
1866
1867 # if HAVE_UINT128
1868 case PSI_T_UINT128:
1869 res->u128 = v1->i64 * v2->u128;
1870 return PSI_T_UINT128;
1871 # endif
1872
1873 case PSI_T_FLOAT:
1874 res->fval = v1->i64 * v2->fval;
1875 return PSI_T_FLOAT;
1876 case PSI_T_DOUBLE:
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;
1883 # endif
1884
1885 default:
1886 assert(0);
1887 break;
1888 }
1889 break;
1890 case PSI_T_UINT64:
1891 switch (t2) {
1892 case PSI_T_INT8:
1893 res->i64 = v1->u64 * v2->i8;
1894 return PSI_T_INT64;
1895 case PSI_T_UINT8:
1896 res->u64 = v1->u64 * v2->u8;
1897 return PSI_T_UINT64;
1898 case PSI_T_INT16:
1899 res->i64 = v1->u64 * v2->i16;
1900 return PSI_T_INT64;
1901 case PSI_T_UINT16:
1902 res->u64 = v1->u64 * v2->u16;
1903 return PSI_T_UINT64;
1904 case PSI_T_INT32:
1905 res->i64 = v1->u64 * v2->i32;
1906 return PSI_T_INT64;
1907 case PSI_T_UINT32:
1908 res->u64 = v1->u64 * v2->u32;
1909 return PSI_T_UINT64;
1910 case PSI_T_INT64:
1911 res->i64 = v1->u64 * v2->i64;
1912 return PSI_T_INT64;
1913 case PSI_T_UINT64:
1914 res->u64 = v1->u64 * v2->u64;
1915 return PSI_T_UINT64;
1916 # if HAVE_INT128
1917 case PSI_T_INT128:
1918 res->i128 = v1->u64 * v2->i128;
1919 return PSI_T_INT128;
1920 # endif
1921
1922 # if HAVE_UINT128
1923 case PSI_T_UINT128:
1924 res->u128 = v1->u64 * v2->u128;
1925 return PSI_T_UINT128;
1926 # endif
1927
1928 case PSI_T_FLOAT:
1929 res->fval = v1->u64 * v2->fval;
1930 return PSI_T_FLOAT;
1931 case PSI_T_DOUBLE:
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;
1938 # endif
1939
1940 default:
1941 assert(0);
1942 break;
1943 }
1944 break;
1945 #if HAVE_INT128
1946 case PSI_T_INT128:
1947 switch (t2) {
1948 case PSI_T_INT8:
1949 res->i128 = v1->i128 * v2->i8;
1950 return PSI_T_INT128;
1951 case PSI_T_UINT8:
1952 res->i128 = v1->i128 * v2->u8;
1953 return PSI_T_INT128;
1954 case PSI_T_INT16:
1955 res->i128 = v1->i128 * v2->i16;
1956 return PSI_T_INT128;
1957 case PSI_T_UINT16:
1958 res->i128 = v1->i128 * v2->u16;
1959 return PSI_T_INT128;
1960 case PSI_T_INT32:
1961 res->i128 = v1->i128 * v2->i32;
1962 return PSI_T_INT128;
1963 case PSI_T_UINT32:
1964 res->i128 = v1->i128 * v2->u32;
1965 return PSI_T_INT128;
1966 case PSI_T_INT64:
1967 res->i128 = v1->i128 * v2->i64;
1968 return PSI_T_INT128;
1969 case PSI_T_UINT64:
1970 res->i128 = v1->i128 * v2->u64;
1971 return PSI_T_INT128;
1972 # if HAVE_INT128
1973 case PSI_T_INT128:
1974 res->i128 = v1->i128 * v2->i128;
1975 return PSI_T_INT128;
1976 # endif
1977
1978 # if HAVE_UINT128
1979 case PSI_T_UINT128:
1980 res->u128 = v1->i128 * v2->u128;
1981 return PSI_T_UINT128;
1982 # endif
1983
1984 case PSI_T_FLOAT:
1985 res->fval = v1->i128 * v2->fval;
1986 return PSI_T_FLOAT;
1987 case PSI_T_DOUBLE:
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;
1994 # endif
1995
1996 default:
1997 assert(0);
1998 break;
1999 }
2000 break;
2001 #endif
2002
2003 #if HAVE_UINT128
2004 case PSI_T_UINT128:
2005 switch (t2) {
2006 case PSI_T_INT8:
2007 res->u128 = v1->u128 * v2->i8;
2008 return PSI_T_UINT128;
2009 case PSI_T_UINT8:
2010 res->u128 = v1->u128 * v2->u8;
2011 return PSI_T_UINT128;
2012 case PSI_T_INT16:
2013 res->u128 = v1->u128 * v2->i16;
2014 return PSI_T_UINT128;
2015 case PSI_T_UINT16:
2016 res->u128 = v1->u128 * v2->u16;
2017 return PSI_T_UINT128;
2018 case PSI_T_INT32:
2019 res->u128 = v1->u128 * v2->i32;
2020 return PSI_T_UINT128;
2021 case PSI_T_UINT32:
2022 res->u128 = v1->u128 * v2->u32;
2023 return PSI_T_UINT128;
2024 case PSI_T_INT64:
2025 res->u128 = v1->u128 * v2->i64;
2026 return PSI_T_UINT128;
2027 case PSI_T_UINT64:
2028 res->u128 = v1->u128 * v2->u64;
2029 return PSI_T_UINT128;
2030 # if HAVE_INT128
2031 case PSI_T_INT128:
2032 res->u128 = v1->u128 * v2->i128;
2033 return PSI_T_UINT128;
2034 # endif
2035
2036 # if HAVE_UINT128
2037 case PSI_T_UINT128:
2038 res->u128 = v1->u128 * v2->u128;
2039 return PSI_T_UINT128;
2040 # endif
2041
2042 case PSI_T_FLOAT:
2043 res->fval = v1->u128 * v2->fval;
2044 return PSI_T_FLOAT;
2045 case PSI_T_DOUBLE:
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;
2052 # endif
2053
2054 default:
2055 assert(0);
2056 break;
2057 }
2058 break;
2059 #endif
2060
2061 case PSI_T_FLOAT:
2062 switch (t2) {
2063 case PSI_T_INT8:
2064 res->fval = v1->fval * v2->i8;
2065 return PSI_T_FLOAT;
2066 case PSI_T_UINT8:
2067 res->fval = v1->fval * v2->u8;
2068 return PSI_T_FLOAT;
2069 case PSI_T_INT16:
2070 res->fval = v1->fval * v2->i16;
2071 return PSI_T_FLOAT;
2072 case PSI_T_UINT16:
2073 res->fval = v1->fval * v2->u16;
2074 return PSI_T_FLOAT;
2075 case PSI_T_INT32:
2076 res->fval = v1->fval * v2->i32;
2077 return PSI_T_FLOAT;
2078 case PSI_T_UINT32:
2079 res->fval = v1->fval * v2->u32;
2080 return PSI_T_FLOAT;
2081 case PSI_T_INT64:
2082 res->fval = v1->fval * v2->i64;
2083 return PSI_T_FLOAT;
2084 case PSI_T_UINT64:
2085 res->fval = v1->fval * v2->u64;
2086 return PSI_T_FLOAT;
2087 # if HAVE_INT128
2088 case PSI_T_INT128:
2089 res->fval = v1->fval * v2->i128;
2090 return PSI_T_FLOAT;
2091 # endif
2092
2093 # if HAVE_UINT128
2094 case PSI_T_UINT128:
2095 res->fval = v1->fval * v2->u128;
2096 return PSI_T_FLOAT;
2097 # endif
2098
2099 case PSI_T_FLOAT:
2100 res->fval = v1->fval * v2->fval;
2101 return PSI_T_FLOAT;
2102 case PSI_T_DOUBLE:
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;
2109 # endif
2110
2111 default:
2112 assert(0);
2113 break;
2114 }
2115 break;
2116 case PSI_T_DOUBLE:
2117 switch (t2) {
2118 case PSI_T_INT8:
2119 res->dval = v1->dval * v2->i8;
2120 return PSI_T_DOUBLE;
2121 case PSI_T_UINT8:
2122 res->dval = v1->dval * v2->u8;
2123 return PSI_T_DOUBLE;
2124 case PSI_T_INT16:
2125 res->dval = v1->dval * v2->i16;
2126 return PSI_T_DOUBLE;
2127 case PSI_T_UINT16:
2128 res->dval = v1->dval * v2->u16;
2129 return PSI_T_DOUBLE;
2130 case PSI_T_INT32:
2131 res->dval = v1->dval * v2->i32;
2132 return PSI_T_DOUBLE;
2133 case PSI_T_UINT32:
2134 res->dval = v1->dval * v2->u32;
2135 return PSI_T_DOUBLE;
2136 case PSI_T_INT64:
2137 res->dval = v1->dval * v2->i64;
2138 return PSI_T_DOUBLE;
2139 case PSI_T_UINT64:
2140 res->dval = v1->dval * v2->u64;
2141 return PSI_T_DOUBLE;
2142 # if HAVE_INT128
2143 case PSI_T_INT128:
2144 res->dval = v1->dval * v2->i128;
2145 return PSI_T_DOUBLE;
2146 # endif
2147
2148 # if HAVE_UINT128
2149 case PSI_T_UINT128:
2150 res->dval = v1->dval * v2->u128;
2151 return PSI_T_DOUBLE;
2152 # endif
2153
2154 case PSI_T_FLOAT:
2155 res->dval = v1->dval * v2->fval;
2156 return PSI_T_DOUBLE;
2157 case 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;
2164 # endif
2165
2166 default:
2167 assert(0);
2168 break;
2169 }
2170 break;
2171 #if HAVE_LONG_DOUBLE
2172 case PSI_T_LONG_DOUBLE:
2173 switch (t2) {
2174 case PSI_T_INT8:
2175 res->ldval = v1->ldval * v2->i8;
2176 return PSI_T_LONG_DOUBLE;
2177 case PSI_T_UINT8:
2178 res->ldval = v1->ldval * v2->u8;
2179 return PSI_T_LONG_DOUBLE;
2180 case PSI_T_INT16:
2181 res->ldval = v1->ldval * v2->i16;
2182 return PSI_T_LONG_DOUBLE;
2183 case PSI_T_UINT16:
2184 res->ldval = v1->ldval * v2->u16;
2185 return PSI_T_LONG_DOUBLE;
2186 case PSI_T_INT32:
2187 res->ldval = v1->ldval * v2->i32;
2188 return PSI_T_LONG_DOUBLE;
2189 case PSI_T_UINT32:
2190 res->ldval = v1->ldval * v2->u32;
2191 return PSI_T_LONG_DOUBLE;
2192 case PSI_T_INT64:
2193 res->ldval = v1->ldval * v2->i64;
2194 return PSI_T_LONG_DOUBLE;
2195 case PSI_T_UINT64:
2196 res->ldval = v1->ldval * v2->u64;
2197 return PSI_T_LONG_DOUBLE;
2198 # if HAVE_INT128
2199 case PSI_T_INT128:
2200 res->ldval = v1->ldval * v2->i128;
2201 return PSI_T_LONG_DOUBLE;
2202 # endif
2203
2204 # if HAVE_UINT128
2205 case PSI_T_UINT128:
2206 res->ldval = v1->ldval * v2->u128;
2207 return PSI_T_LONG_DOUBLE;
2208 # endif
2209
2210 case PSI_T_FLOAT:
2211 res->ldval = v1->ldval * v2->fval;
2212 return PSI_T_LONG_DOUBLE;
2213 case PSI_T_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;
2220 # endif
2221
2222 default:
2223 assert(0);
2224 break;
2225 }
2226 break;
2227 #endif
2228
2229 default:
2230 assert(0);
2231 break;
2232 }
2233
2234 return 0;
2235 }
2236 static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
2237 {
2238
2239 switch (t1) {
2240 case PSI_T_INT8:
2241 switch (t2) {
2242 case PSI_T_INT8:
2243 res->i16 = v1->i8 / v2->i8;
2244 return PSI_T_INT16;
2245 case PSI_T_UINT8:
2246 res->i16 = v1->i8 / v2->u8;
2247 return PSI_T_INT16;
2248 case PSI_T_INT16:
2249 res->i32 = v1->i8 / v2->i16;
2250 return PSI_T_INT32;
2251 case PSI_T_UINT16:
2252 res->i32 = v1->i8 / v2->u16;
2253 return PSI_T_INT32;
2254 case PSI_T_INT32:
2255 res->i64 = v1->i8 / v2->i32;
2256 return PSI_T_INT64;
2257 case PSI_T_UINT32:
2258 res->i64 = v1->i8 / v2->u32;
2259 return PSI_T_INT64;
2260 case PSI_T_INT64:
2261 res->i64 = v1->i8 / v2->i64;
2262 return PSI_T_INT64;
2263 case PSI_T_UINT64:
2264 res->i64 = v1->i8 / v2->u64;
2265 return PSI_T_INT64;
2266 # if HAVE_INT128
2267 case PSI_T_INT128:
2268 res->i128 = v1->i8 / v2->i128;
2269 return PSI_T_INT128;
2270 # endif
2271
2272 # if HAVE_UINT128
2273 case PSI_T_UINT128:
2274 res->u128 = v1->i8 / v2->u128;
2275 return PSI_T_UINT128;
2276 # endif
2277
2278 case PSI_T_FLOAT:
2279 res->fval = v1->i8 / v2->fval;
2280 return PSI_T_FLOAT;
2281 case PSI_T_DOUBLE:
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;
2288 # endif
2289
2290 default:
2291 assert(0);
2292 break;
2293 }
2294 break;
2295 case PSI_T_UINT8:
2296 switch (t2) {
2297 case PSI_T_INT8:
2298 res->i16 = v1->u8 / v2->i8;
2299 return PSI_T_INT16;
2300 case PSI_T_UINT8:
2301 res->u16 = v1->u8 / v2->u8;
2302 return PSI_T_UINT16;
2303 case PSI_T_INT16:
2304 res->i32 = v1->u8 / v2->i16;
2305 return PSI_T_INT32;
2306 case PSI_T_UINT16:
2307 res->u32 = v1->u8 / v2->u16;
2308 return PSI_T_UINT32;
2309 case PSI_T_INT32:
2310 res->i64 = v1->u8 / v2->i32;
2311 return PSI_T_INT64;
2312 case PSI_T_UINT32:
2313 res->u64 = v1->u8 / v2->u32;
2314 return PSI_T_UINT64;
2315 case PSI_T_INT64:
2316 res->i64 = v1->u8 / v2->i64;
2317 return PSI_T_INT64;
2318 case PSI_T_UINT64:
2319 res->u64 = v1->u8 / v2->u64;
2320 return PSI_T_UINT64;
2321 # if HAVE_INT128
2322 case PSI_T_INT128:
2323 res->i128 = v1->u8 / v2->i128;
2324 return PSI_T_INT128;
2325 # endif
2326
2327 # if HAVE_UINT128
2328 case PSI_T_UINT128:
2329 res->u128 = v1->u8 / v2->u128;
2330 return PSI_T_UINT128;
2331 # endif
2332
2333 case PSI_T_FLOAT:
2334 res->fval = v1->u8 / v2->fval;
2335 return PSI_T_FLOAT;
2336 case PSI_T_DOUBLE:
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;
2343 # endif
2344
2345 default:
2346 assert(0);
2347 break;
2348 }
2349 break;
2350 case PSI_T_INT16:
2351 switch (t2) {
2352 case PSI_T_INT8:
2353 res->i32 = v1->i16 / v2->i8;
2354 return PSI_T_INT32;
2355 case PSI_T_UINT8:
2356 res->i32 = v1->i16 / v2->u8;
2357 return PSI_T_INT32;
2358 case PSI_T_INT16:
2359 res->i32 = v1->i16 / v2->i16;
2360 return PSI_T_INT32;
2361 case PSI_T_UINT16:
2362 res->i32 = v1->i16 / v2->u16;
2363 return PSI_T_INT32;
2364 case PSI_T_INT32:
2365 res->i64 = v1->i16 / v2->i32;
2366 return PSI_T_INT64;
2367 case PSI_T_UINT32:
2368 res->i64 = v1->i16 / v2->u32;
2369 return PSI_T_INT64;
2370 case PSI_T_INT64:
2371 res->i64 = v1->i16 / v2->i64;
2372 return PSI_T_INT64;
2373 case PSI_T_UINT64:
2374 res->i64 = v1->i16 / v2->u64;
2375 return PSI_T_INT64;
2376 # if HAVE_INT128
2377 case PSI_T_INT128:
2378 res->i128 = v1->i16 / v2->i128;
2379 return PSI_T_INT128;
2380 # endif
2381
2382 # if HAVE_UINT128
2383 case PSI_T_UINT128:
2384 res->u128 = v1->i16 / v2->u128;
2385 return PSI_T_UINT128;
2386 # endif
2387
2388 case PSI_T_FLOAT:
2389 res->fval = v1->i16 / v2->fval;
2390 return PSI_T_FLOAT;
2391 case PSI_T_DOUBLE:
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;
2398 # endif
2399
2400 default:
2401 assert(0);
2402 break;
2403 }
2404 break;
2405 case PSI_T_UINT16:
2406 switch (t2) {
2407 case PSI_T_INT8:
2408 res->i32 = v1->u16 / v2->i8;
2409 return PSI_T_INT32;
2410 case PSI_T_UINT8:
2411 res->u32 = v1->u16 / v2->u8;
2412 return PSI_T_UINT32;
2413 case PSI_T_INT16:
2414 res->i32 = v1->u16 / v2->i16;
2415 return PSI_T_INT32;
2416 case PSI_T_UINT16:
2417 res->u32 = v1->u16 / v2->u16;
2418 return PSI_T_UINT32;
2419 case PSI_T_INT32:
2420 res->i64 = v1->u16 / v2->i32;
2421 return PSI_T_INT64;
2422 case PSI_T_UINT32:
2423 res->u64 = v1->u16 / v2->u32;
2424 return PSI_T_UINT64;
2425 case PSI_T_INT64:
2426 res->i64 = v1->u16 / v2->i64;
2427 return PSI_T_INT64;
2428 case PSI_T_UINT64:
2429 res->u64 = v1->u16 / v2->u64;
2430 return PSI_T_UINT64;
2431 # if HAVE_INT128
2432 case PSI_T_INT128:
2433 res->i128 = v1->u16 / v2->i128;
2434 return PSI_T_INT128;
2435 # endif
2436
2437 # if HAVE_UINT128
2438 case PSI_T_UINT128:
2439 res->u128 = v1->u16 / v2->u128;
2440 return PSI_T_UINT128;
2441 # endif
2442
2443 case PSI_T_FLOAT:
2444 res->fval = v1->u16 / v2->fval;
2445 return PSI_T_FLOAT;
2446 case PSI_T_DOUBLE:
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;
2453 # endif
2454
2455 default:
2456 assert(0);
2457 break;
2458 }
2459 break;
2460 case PSI_T_INT32:
2461 switch (t2) {
2462 case PSI_T_INT8:
2463 res->i64 = v1->i32 / v2->i8;
2464 return PSI_T_INT64;
2465 case PSI_T_UINT8:
2466 res->i64 = v1->i32 / v2->u8;
2467 return PSI_T_INT64;
2468 case PSI_T_INT16:
2469 res->i64 = v1->i32 / v2->i16;
2470 return PSI_T_INT64;
2471 case PSI_T_UINT16:
2472 res->i64 = v1->i32 / v2->u16;
2473 return PSI_T_INT64;
2474 case PSI_T_INT32:
2475 res->i64 = v1->i32 / v2->i32;
2476 return PSI_T_INT64;
2477 case PSI_T_UINT32:
2478 res->i64 = v1->i32 / v2->u32;
2479 return PSI_T_INT64;
2480 case PSI_T_INT64:
2481 res->i64 = v1->i32 / v2->i64;
2482 return PSI_T_INT64;
2483 case PSI_T_UINT64:
2484 res->i64 = v1->i32 / v2->u64;
2485 return PSI_T_INT64;
2486 # if HAVE_INT128
2487 case PSI_T_INT128:
2488 res->i128 = v1->i32 / v2->i128;
2489 return PSI_T_INT128;
2490 # endif
2491
2492 # if HAVE_UINT128
2493 case PSI_T_UINT128:
2494 res->u128 = v1->i32 / v2->u128;
2495 return PSI_T_UINT128;
2496 # endif
2497
2498 case PSI_T_FLOAT:
2499 res->fval = v1->i32 / v2->fval;
2500 return PSI_T_FLOAT;
2501 case PSI_T_DOUBLE:
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;
2508 # endif
2509
2510 default:
2511 assert(0);
2512 break;
2513 }
2514 break;
2515 case PSI_T_UINT32:
2516 switch (t2) {
2517 case PSI_T_INT8:
2518 res->i64 = v1->u32 / v2->i8;
2519 return PSI_T_INT64;
2520 case PSI_T_UINT8:
2521 res->u64 = v1->u32 / v2->u8;
2522 return PSI_T_UINT64;
2523 case PSI_T_INT16:
2524 res->i64 = v1->u32 / v2->i16;
2525 return PSI_T_INT64;
2526 case PSI_T_UINT16:
2527 res->u64 = v1->u32 / v2->u16;
2528 return PSI_T_UINT64;
2529 case PSI_T_INT32:
2530 res->i64 = v1->u32 / v2->i32;
2531 return PSI_T_INT64;
2532 case PSI_T_UINT32:
2533 res->u64 = v1->u32 / v2->u32;
2534 return PSI_T_UINT64;
2535 case PSI_T_INT64:
2536 res->i64 = v1->u32 / v2->i64;
2537 return PSI_T_INT64;
2538 case PSI_T_UINT64:
2539 res->u64 = v1->u32 / v2->u64;
2540 return PSI_T_UINT64;
2541 # if HAVE_INT128
2542 case PSI_T_INT128:
2543 res->i128 = v1->u32 / v2->i128;
2544 return PSI_T_INT128;
2545 # endif
2546
2547 # if HAVE_UINT128
2548 case PSI_T_UINT128:
2549 res->u128 = v1->u32 / v2->u128;
2550 return PSI_T_UINT128;
2551 # endif
2552
2553 case PSI_T_FLOAT:
2554 res->fval = v1->u32 / v2->fval;
2555 return PSI_T_FLOAT;
2556 case PSI_T_DOUBLE:
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;
2563 # endif
2564
2565 default:
2566 assert(0);
2567 break;
2568 }
2569 break;
2570 case PSI_T_INT64:
2571 switch (t2) {
2572 case PSI_T_INT8:
2573 res->i64 = v1->i64 / v2->i8;
2574 return PSI_T_INT64;
2575 case PSI_T_UINT8:
2576 res->i64 = v1->i64 / v2->u8;
2577 return PSI_T_INT64;
2578 case PSI_T_INT16:
2579 res->i64 = v1->i64 / v2->i16;
2580 return PSI_T_INT64;
2581 case PSI_T_UINT16:
2582 res->i64 = v1->i64 / v2->u16;
2583 return PSI_T_INT64;
2584 case PSI_T_INT32:
2585 res->i64 = v1->i64 / v2->i32;
2586 return PSI_T_INT64;
2587 case PSI_T_UINT32:
2588 res->i64 = v1->i64 / v2->u32;
2589 return PSI_T_INT64;
2590 case PSI_T_INT64:
2591 res->i64 = v1->i64 / v2->i64;
2592 return PSI_T_INT64;
2593 case PSI_T_UINT64:
2594 res->i64 = v1->i64 / v2->u64;
2595 return PSI_T_INT64;
2596 # if HAVE_INT128
2597 case PSI_T_INT128:
2598 res->i128 = v1->i64 / v2->i128;
2599 return PSI_T_INT128;
2600 # endif
2601
2602 # if HAVE_UINT128
2603 case PSI_T_UINT128:
2604 res->u128 = v1->i64 / v2->u128;
2605 return PSI_T_UINT128;
2606 # endif
2607
2608 case PSI_T_FLOAT:
2609 res->fval = v1->i64 / v2->fval;
2610 return PSI_T_FLOAT;
2611 case PSI_T_DOUBLE:
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;
2618 # endif
2619
2620 default:
2621 assert(0);
2622 break;
2623 }
2624 break;
2625 case PSI_T_UINT64:
2626 switch (t2) {
2627 case PSI_T_INT8:
2628 res->i64 = v1->u64 / v2->i8;
2629 return PSI_T_INT64;
2630 case PSI_T_UINT8:
2631 res->u64 = v1->u64 / v2->u8;
2632 return PSI_T_UINT64;
2633 case PSI_T_INT16:
2634 res->i64 = v1->u64 / v2->i16;
2635 return PSI_T_INT64;
2636 case PSI_T_UINT16:
2637 res->u64 = v1->u64 / v2->u16;
2638 return PSI_T_UINT64;
2639 case PSI_T_INT32:
2640 res->i64 = v1->u64 / v2->i32;
2641 return PSI_T_INT64;
2642 case PSI_T_UINT32:
2643 res->u64 = v1->u64 / v2->u32;
2644 return PSI_T_UINT64;
2645 case PSI_T_INT64:
2646 res->i64 = v1->u64 / v2->i64;
2647 return PSI_T_INT64;
2648 case PSI_T_UINT64:
2649 res->u64 = v1->u64 / v2->u64;
2650 return PSI_T_UINT64;
2651 # if HAVE_INT128
2652 case PSI_T_INT128:
2653 res->i128 = v1->u64 / v2->i128;
2654 return PSI_T_INT128;
2655 # endif
2656
2657 # if HAVE_UINT128
2658 case PSI_T_UINT128:
2659 res->u128 = v1->u64 / v2->u128;
2660 return PSI_T_UINT128;
2661 # endif
2662
2663 case PSI_T_FLOAT:
2664 res->fval = v1->u64 / v2->fval;
2665 return PSI_T_FLOAT;
2666 case PSI_T_DOUBLE:
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;
2673 # endif
2674
2675 default:
2676 assert(0);
2677 break;
2678 }
2679 break;
2680 #if HAVE_INT128
2681 case PSI_T_INT128:
2682 switch (t2) {
2683 case PSI_T_INT8:
2684 res->i128 = v1->i128 / v2->i8;
2685 return PSI_T_INT128;
2686 case PSI_T_UINT8:
2687 res->i128 = v1->i128 / v2->u8;
2688 return PSI_T_INT128;
2689 case PSI_T_INT16:
2690 res->i128 = v1->i128 / v2->i16;
2691 return PSI_T_INT128;
2692 case PSI_T_UINT16:
2693 res->i128 = v1->i128 / v2->u16;
2694 return PSI_T_INT128;
2695 case PSI_T_INT32:
2696 res->i128 = v1->i128 / v2->i32;
2697 return PSI_T_INT128;
2698 case PSI_T_UINT32:
2699 res->i128 = v1->i128 / v2->u32;
2700 return PSI_T_INT128;
2701 case PSI_T_INT64:
2702 res->i128 = v1->i128 / v2->i64;
2703 return PSI_T_INT128;
2704 case PSI_T_UINT64:
2705 res->i128 = v1->i128 / v2->u64;
2706 return PSI_T_INT128;
2707 # if HAVE_INT128
2708 case PSI_T_INT128:
2709 res->i128 = v1->i128 / v2->i128;
2710 return PSI_T_INT128;
2711 # endif
2712
2713 # if HAVE_UINT128
2714 case PSI_T_UINT128:
2715 res->u128 = v1->i128 / v2->u128;
2716 return PSI_T_UINT128;
2717 # endif
2718
2719 case PSI_T_FLOAT:
2720 res->fval = v1->i128 / v2->fval;
2721 return PSI_T_FLOAT;
2722 case PSI_T_DOUBLE:
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;
2729 # endif
2730
2731 default:
2732 assert(0);
2733 break;
2734 }
2735 break;
2736 #endif
2737
2738 #if HAVE_UINT128
2739 case PSI_T_UINT128:
2740 switch (t2) {
2741 case PSI_T_INT8:
2742 res->u128 = v1->u128 / v2->i8;
2743 return PSI_T_UINT128;
2744 case PSI_T_UINT8:
2745 res->u128 = v1->u128 / v2->u8;
2746 return PSI_T_UINT128;
2747 case PSI_T_INT16:
2748 res->u128 = v1->u128 / v2->i16;
2749 return PSI_T_UINT128;
2750 case PSI_T_UINT16:
2751 res->u128 = v1->u128 / v2->u16;
2752 return PSI_T_UINT128;
2753 case PSI_T_INT32:
2754 res->u128 = v1->u128 / v2->i32;
2755 return PSI_T_UINT128;
2756 case PSI_T_UINT32:
2757 res->u128 = v1->u128 / v2->u32;
2758 return PSI_T_UINT128;
2759 case PSI_T_INT64:
2760 res->u128 = v1->u128 / v2->i64;
2761 return PSI_T_UINT128;
2762 case PSI_T_UINT64:
2763 res->u128 = v1->u128 / v2->u64;
2764 return PSI_T_UINT128;
2765 # if HAVE_INT128
2766 case PSI_T_INT128:
2767 res->u128 = v1->u128 / v2->i128;
2768 return PSI_T_UINT128;
2769 # endif
2770
2771 # if HAVE_UINT128
2772 case PSI_T_UINT128:
2773 res->u128 = v1->u128 / v2->u128;
2774 return PSI_T_UINT128;
2775 # endif
2776
2777 case PSI_T_FLOAT:
2778 res->fval = v1->u128 / v2->fval;
2779 return PSI_T_FLOAT;
2780 case PSI_T_DOUBLE:
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;
2787 # endif
2788
2789 default:
2790 assert(0);
2791 break;
2792 }
2793 break;
2794 #endif
2795
2796 case PSI_T_FLOAT:
2797 switch (t2) {
2798 case PSI_T_INT8:
2799 res->fval = v1->fval / v2->i8;
2800 return PSI_T_FLOAT;
2801 case PSI_T_UINT8:
2802 res->fval = v1->fval / v2->u8;
2803 return PSI_T_FLOAT;
2804 case PSI_T_INT16:
2805 res->fval = v1->fval / v2->i16;
2806 return PSI_T_FLOAT;
2807 case PSI_T_UINT16:
2808 res->fval = v1->fval / v2->u16;
2809 return PSI_T_FLOAT;
2810 case PSI_T_INT32:
2811 res->fval = v1->fval / v2->i32;
2812 return PSI_T_FLOAT;
2813 case PSI_T_UINT32:
2814 res->fval = v1->fval / v2->u32;
2815 return PSI_T_FLOAT;
2816 case PSI_T_INT64:
2817 res->fval = v1->fval / v2->i64;
2818 return PSI_T_FLOAT;
2819 case PSI_T_UINT64:
2820 res->fval = v1->fval / v2->u64;
2821 return PSI_T_FLOAT;
2822 # if HAVE_INT128
2823 case PSI_T_INT128:
2824 res->fval = v1->fval / v2->i128;
2825 return PSI_T_FLOAT;
2826 # endif
2827
2828 # if HAVE_UINT128
2829 case PSI_T_UINT128:
2830 res->fval = v1->fval / v2->u128;
2831 return PSI_T_FLOAT;
2832 # endif
2833
2834 case PSI_T_FLOAT:
2835 res->fval = v1->fval / v2->fval;
2836 return PSI_T_FLOAT;
2837 case PSI_T_DOUBLE:
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;
2844 # endif
2845
2846 default:
2847 assert(0);
2848 break;
2849 }
2850 break;
2851 case PSI_T_DOUBLE:
2852 switch (t2) {
2853 case PSI_T_INT8:
2854 res->dval = v1->dval / v2->i8;
2855 return PSI_T_DOUBLE;
2856 case PSI_T_UINT8:
2857 res->dval = v1->dval / v2->u8;
2858 return PSI_T_DOUBLE;
2859 case PSI_T_INT16:
2860 res->dval = v1->dval / v2->i16;
2861 return PSI_T_DOUBLE;
2862 case PSI_T_UINT16:
2863 res->dval = v1->dval / v2->u16;
2864 return PSI_T_DOUBLE;
2865 case PSI_T_INT32:
2866 res->dval = v1->dval / v2->i32;
2867 return PSI_T_DOUBLE;
2868 case PSI_T_UINT32:
2869 res->dval = v1->dval / v2->u32;
2870 return PSI_T_DOUBLE;
2871 case PSI_T_INT64:
2872 res->dval = v1->dval / v2->i64;
2873 return PSI_T_DOUBLE;
2874 case PSI_T_UINT64:
2875 res->dval = v1->dval / v2->u64;
2876 return PSI_T_DOUBLE;
2877 # if HAVE_INT128
2878 case PSI_T_INT128:
2879 res->dval = v1->dval / v2->i128;
2880 return PSI_T_DOUBLE;
2881 # endif
2882
2883 # if HAVE_UINT128
2884 case PSI_T_UINT128:
2885 res->dval = v1->dval / v2->u128;
2886 return PSI_T_DOUBLE;
2887 # endif
2888
2889 case PSI_T_FLOAT:
2890 res->dval = v1->dval / v2->fval;
2891 return PSI_T_DOUBLE;
2892 case 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;
2899 # endif
2900
2901 default:
2902 assert(0);
2903 break;
2904 }
2905 break;
2906 #if HAVE_LONG_DOUBLE
2907 case PSI_T_LONG_DOUBLE:
2908 switch (t2) {
2909 case PSI_T_INT8:
2910 res->ldval = v1->ldval / v2->i8;
2911 return PSI_T_LONG_DOUBLE;
2912 case PSI_T_UINT8:
2913 res->ldval = v1->ldval / v2->u8;
2914 return PSI_T_LONG_DOUBLE;
2915 case PSI_T_INT16:
2916 res->ldval = v1->ldval / v2->i16;
2917 return PSI_T_LONG_DOUBLE;
2918 case PSI_T_UINT16:
2919 res->ldval = v1->ldval / v2->u16;
2920 return PSI_T_LONG_DOUBLE;
2921 case PSI_T_INT32:
2922 res->ldval = v1->ldval / v2->i32;
2923 return PSI_T_LONG_DOUBLE;
2924 case PSI_T_UINT32:
2925 res->ldval = v1->ldval / v2->u32;
2926 return PSI_T_LONG_DOUBLE;
2927 case PSI_T_INT64:
2928 res->ldval = v1->ldval / v2->i64;
2929 return PSI_T_LONG_DOUBLE;
2930 case PSI_T_UINT64:
2931 res->ldval = v1->ldval / v2->u64;
2932 return PSI_T_LONG_DOUBLE;
2933 # if HAVE_INT128
2934 case PSI_T_INT128:
2935 res->ldval = v1->ldval / v2->i128;
2936 return PSI_T_LONG_DOUBLE;
2937 # endif
2938
2939 # if HAVE_UINT128
2940 case PSI_T_UINT128:
2941 res->ldval = v1->ldval / v2->u128;
2942 return PSI_T_LONG_DOUBLE;
2943 # endif
2944
2945 case PSI_T_FLOAT:
2946 res->ldval = v1->ldval / v2->fval;
2947 return PSI_T_LONG_DOUBLE;
2948 case PSI_T_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;
2955 # endif
2956
2957 default:
2958 assert(0);
2959 break;
2960 }
2961 break;
2962 #endif
2963
2964 default:
2965 assert(0);
2966 break;
2967 }
2968
2969 return 0;
2970 }
2971
2972
2973 static inline token_t psi_calc_mod(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
2974 {
2975 impl_val i1, i2;
2976
2977 switch (t1) {
2978 case PSI_T_INT8:
2979 i1.i64 = v1->i8;
2980 break;
2981
2982 case PSI_T_UINT8:
2983 i1.i64 = v1->u8;
2984 break;
2985
2986 case PSI_T_INT16:
2987 i1.i64 = v1->i16;
2988 break;
2989
2990 case PSI_T_UINT16:
2991 i1.i64 = v1->u16;
2992 break;
2993
2994 case PSI_T_INT32:
2995 i1.i64 = v1->i32;
2996 break;
2997
2998 case PSI_T_UINT32:
2999 i1.i64 = v1->u32;
3000 break;
3001
3002 case PSI_T_INT64:
3003 i1.i64 = v1->i64;
3004 break;
3005
3006 case PSI_T_UINT64:
3007 i1.i64 = v1->u64;
3008 break;
3009
3010 #if HAVE_INT128
3011 case PSI_T_INT128:
3012 i1.i64 = v1->i128;
3013 break;
3014
3015 #endif
3016
3017 #if HAVE_UINT128
3018 case PSI_T_UINT128:
3019 i1.i64 = v1->u128;
3020 break;
3021
3022 #endif
3023
3024 case PSI_T_FLOAT:
3025 i1.i64 = v1->fval;
3026 break;
3027
3028 case PSI_T_DOUBLE:
3029 i1.i64 = v1->dval;
3030 break;
3031
3032 #if HAVE_LONG_DOUBLE
3033 case PSI_T_LONG_DOUBLE:
3034 i1.i64 = v1->ldval;
3035 break;
3036
3037 #endif
3038
3039 default:
3040 assert(0);
3041 break;
3042 }
3043
3044 switch (t2) {
3045 case PSI_T_INT8:
3046 i2.i64 = v2->i8;
3047 break;
3048 case PSI_T_UINT8:
3049 i2.i64 = v2->u8;
3050 break;
3051 case PSI_T_INT16:
3052 i2.i64 = v2->i16;
3053 break;
3054 case PSI_T_UINT16:
3055 i2.i64 = v2->u16;
3056 break;
3057 case PSI_T_INT32:
3058 i2.i64 = v2->i32;
3059 break;
3060 case PSI_T_UINT32:
3061 i2.i64 = v2->u32;
3062 break;
3063 case PSI_T_INT64:
3064 i2.i64 = v2->i64;
3065 break;
3066 case PSI_T_UINT64:
3067 i2.i64 = v2->u64;
3068 break;
3069 #if HAVE_INT128
3070 case PSI_T_INT128:
3071 i2.i64 = v2->i128;
3072 break;
3073 #endif
3074
3075 #if HAVE_UINT128
3076 case PSI_T_UINT128:
3077 i2.i64 = v2->u128;
3078 break;
3079 #endif
3080
3081 case PSI_T_FLOAT:
3082 i2.i64 = v2->fval;
3083 break;
3084 case PSI_T_DOUBLE:
3085 i2.i64 = v2->dval;
3086 break;
3087 #if HAVE_LONG_DOUBLE
3088 case PSI_T_LONG_DOUBLE:
3089 i2.i64 = v2->ldval;
3090 break;
3091 #endif
3092
3093 default:
3094 assert(0);
3095 break;
3096 }
3097
3098 res->i64 = i1.i64 % i2.i64;
3099 return PSI_T_INT64;
3100 }
PHP System Interface / POSIX Standard Interface