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


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