projects / m6w6 / ext-psi / blob
? search:


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