projects / m6w6 / ext-psi / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
travis: update
[m6w6/ext-psi] / src / calc / cmp.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_cmp_eq(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
31 {
32 switch (t1) {
33 case PSI_T_INT8:
34 switch (t2) {
35 case PSI_T_INT8:
36 res->u8 = v1->i8 == v2->i8;
37 break;
38 case PSI_T_UINT8:
39 res->u8 = v1->i8 == v2->u8;
40 break;
41 case PSI_T_INT16:
42 res->u8 = v1->i8 == v2->i16;
43 break;
44 case PSI_T_UINT16:
45 res->u8 = v1->i8 == v2->u16;
46 break;
47 case PSI_T_INT32:
48 res->u8 = v1->i8 == v2->i32;
49 break;
50 case PSI_T_UINT32:
51 res->u8 = v1->i8 == v2->u32;
52 break;
53 case PSI_T_INT64:
54 res->u8 = v1->i8 == v2->i64;
55 break;
56 case PSI_T_UINT64:
57 res->u8 = v1->i8 == v2->u64;
58 break;
59 # if HAVE_INT128
60 case PSI_T_INT128:
61 res->u8 = v1->i8 == v2->i128;
62 break;
63 # endif
64
65 # if HAVE_UINT128
66 case PSI_T_UINT128:
67 res->u8 = v1->i8 == v2->u128;
68 break;
69 # endif
70
71 case PSI_T_FLOAT:
72 res->u8 = v1->i8 == v2->fval;
73 break;
74 case PSI_T_DOUBLE:
75 res->u8 = v1->i8 == v2->dval;
76 break;
77 # if HAVE_LONG_DOUBLE
78 case PSI_T_LONG_DOUBLE:
79 res->u8 = v1->i8 == v2->ldval;
80 break;
81 # endif
82
83 default:
84 assert(0);
85 break;
86 }
87 break;
88 case PSI_T_UINT8:
89 switch (t2) {
90 case PSI_T_INT8:
91 res->u8 = v1->u8 == v2->i8;
92 break;
93 case PSI_T_UINT8:
94 res->u8 = v1->u8 == v2->u8;
95 break;
96 case PSI_T_INT16:
97 res->u8 = v1->u8 == v2->i16;
98 break;
99 case PSI_T_UINT16:
100 res->u8 = v1->u8 == v2->u16;
101 break;
102 case PSI_T_INT32:
103 res->u8 = v1->u8 == v2->i32;
104 break;
105 case PSI_T_UINT32:
106 res->u8 = v1->u8 == v2->u32;
107 break;
108 case PSI_T_INT64:
109 res->u8 = v1->u8 == v2->i64;
110 break;
111 case PSI_T_UINT64:
112 res->u8 = v1->u8 == v2->u64;
113 break;
114 # if HAVE_INT128
115 case PSI_T_INT128:
116 res->u8 = v1->u8 == v2->i128;
117 break;
118 # endif
119
120 # if HAVE_UINT128
121 case PSI_T_UINT128:
122 res->u8 = v1->u8 == v2->u128;
123 break;
124 # endif
125
126 case PSI_T_FLOAT:
127 res->u8 = v1->u8 == v2->fval;
128 break;
129 case PSI_T_DOUBLE:
130 res->u8 = v1->u8 == v2->dval;
131 break;
132 # if HAVE_LONG_DOUBLE
133 case PSI_T_LONG_DOUBLE:
134 res->u8 = v1->u8 == v2->ldval;
135 break;
136 # endif
137
138 default:
139 assert(0);
140 break;
141 }
142 break;
143 case PSI_T_INT16:
144 switch (t2) {
145 case PSI_T_INT8:
146 res->u8 = v1->i16 == v2->i8;
147 break;
148 case PSI_T_UINT8:
149 res->u8 = v1->i16 == v2->u8;
150 break;
151 case PSI_T_INT16:
152 res->u8 = v1->i16 == v2->i16;
153 break;
154 case PSI_T_UINT16:
155 res->u8 = v1->i16 == v2->u16;
156 break;
157 case PSI_T_INT32:
158 res->u8 = v1->i16 == v2->i32;
159 break;
160 case PSI_T_UINT32:
161 res->u8 = v1->i16 == v2->u32;
162 break;
163 case PSI_T_INT64:
164 res->u8 = v1->i16 == v2->i64;
165 break;
166 case PSI_T_UINT64:
167 res->u8 = v1->i16 == v2->u64;
168 break;
169 # if HAVE_INT128
170 case PSI_T_INT128:
171 res->u8 = v1->i16 == v2->i128;
172 break;
173 # endif
174
175 # if HAVE_UINT128
176 case PSI_T_UINT128:
177 res->u8 = v1->i16 == v2->u128;
178 break;
179 # endif
180
181 case PSI_T_FLOAT:
182 res->u8 = v1->i16 == v2->fval;
183 break;
184 case PSI_T_DOUBLE:
185 res->u8 = v1->i16 == v2->dval;
186 break;
187 # if HAVE_LONG_DOUBLE
188 case PSI_T_LONG_DOUBLE:
189 res->u8 = v1->i16 == v2->ldval;
190 break;
191 # endif
192
193 default:
194 assert(0);
195 break;
196 }
197 break;
198 case PSI_T_UINT16:
199 switch (t2) {
200 case PSI_T_INT8:
201 res->u8 = v1->u16 == v2->i8;
202 break;
203 case PSI_T_UINT8:
204 res->u8 = v1->u16 == v2->u8;
205 break;
206 case PSI_T_INT16:
207 res->u8 = v1->u16 == v2->i16;
208 break;
209 case PSI_T_UINT16:
210 res->u8 = v1->u16 == v2->u16;
211 break;
212 case PSI_T_INT32:
213 res->u8 = v1->u16 == v2->i32;
214 break;
215 case PSI_T_UINT32:
216 res->u8 = v1->u16 == v2->u32;
217 break;
218 case PSI_T_INT64:
219 res->u8 = v1->u16 == v2->i64;
220 break;
221 case PSI_T_UINT64:
222 res->u8 = v1->u16 == v2->u64;
223 break;
224 # if HAVE_INT128
225 case PSI_T_INT128:
226 res->u8 = v1->u16 == v2->i128;
227 break;
228 # endif
229
230 # if HAVE_UINT128
231 case PSI_T_UINT128:
232 res->u8 = v1->u16 == v2->u128;
233 break;
234 # endif
235
236 case PSI_T_FLOAT:
237 res->u8 = v1->u16 == v2->fval;
238 break;
239 case PSI_T_DOUBLE:
240 res->u8 = v1->u16 == v2->dval;
241 break;
242 # if HAVE_LONG_DOUBLE
243 case PSI_T_LONG_DOUBLE:
244 res->u8 = v1->u16 == v2->ldval;
245 break;
246 # endif
247
248 default:
249 assert(0);
250 break;
251 }
252 break;
253 case PSI_T_INT32:
254 switch (t2) {
255 case PSI_T_INT8:
256 res->u8 = v1->i32 == v2->i8;
257 break;
258 case PSI_T_UINT8:
259 res->u8 = v1->i32 == v2->u8;
260 break;
261 case PSI_T_INT16:
262 res->u8 = v1->i32 == v2->i16;
263 break;
264 case PSI_T_UINT16:
265 res->u8 = v1->i32 == v2->u16;
266 break;
267 case PSI_T_INT32:
268 res->u8 = v1->i32 == v2->i32;
269 break;
270 case PSI_T_UINT32:
271 res->u8 = v1->i32 == v2->u32;
272 break;
273 case PSI_T_INT64:
274 res->u8 = v1->i32 == v2->i64;
275 break;
276 case PSI_T_UINT64:
277 res->u8 = v1->i32 == v2->u64;
278 break;
279 # if HAVE_INT128
280 case PSI_T_INT128:
281 res->u8 = v1->i32 == v2->i128;
282 break;
283 # endif
284
285 # if HAVE_UINT128
286 case PSI_T_UINT128:
287 res->u8 = v1->i32 == v2->u128;
288 break;
289 # endif
290
291 case PSI_T_FLOAT:
292 res->u8 = v1->i32 == v2->fval;
293 break;
294 case PSI_T_DOUBLE:
295 res->u8 = v1->i32 == v2->dval;
296 break;
297 # if HAVE_LONG_DOUBLE
298 case PSI_T_LONG_DOUBLE:
299 res->u8 = v1->i32 == v2->ldval;
300 break;
301 # endif
302
303 default:
304 assert(0);
305 break;
306 }
307 break;
308 case PSI_T_UINT32:
309 switch (t2) {
310 case PSI_T_INT8:
311 res->u8 = v1->u32 == v2->i8;
312 break;
313 case PSI_T_UINT8:
314 res->u8 = v1->u32 == v2->u8;
315 break;
316 case PSI_T_INT16:
317 res->u8 = v1->u32 == v2->i16;
318 break;
319 case PSI_T_UINT16:
320 res->u8 = v1->u32 == v2->u16;
321 break;
322 case PSI_T_INT32:
323 res->u8 = v1->u32 == v2->i32;
324 break;
325 case PSI_T_UINT32:
326 res->u8 = v1->u32 == v2->u32;
327 break;
328 case PSI_T_INT64:
329 res->u8 = v1->u32 == v2->i64;
330 break;
331 case PSI_T_UINT64:
332 res->u8 = v1->u32 == v2->u64;
333 break;
334 # if HAVE_INT128
335 case PSI_T_INT128:
336 res->u8 = v1->u32 == v2->i128;
337 break;
338 # endif
339
340 # if HAVE_UINT128
341 case PSI_T_UINT128:
342 res->u8 = v1->u32 == v2->u128;
343 break;
344 # endif
345
346 case PSI_T_FLOAT:
347 res->u8 = v1->u32 == v2->fval;
348 break;
349 case PSI_T_DOUBLE:
350 res->u8 = v1->u32 == v2->dval;
351 break;
352 # if HAVE_LONG_DOUBLE
353 case PSI_T_LONG_DOUBLE:
354 res->u8 = v1->u32 == v2->ldval;
355 break;
356 # endif
357
358 default:
359 assert(0);
360 break;
361 }
362 break;
363 case PSI_T_INT64:
364 switch (t2) {
365 case PSI_T_INT8:
366 res->u8 = v1->i64 == v2->i8;
367 break;
368 case PSI_T_UINT8:
369 res->u8 = v1->i64 == v2->u8;
370 break;
371 case PSI_T_INT16:
372 res->u8 = v1->i64 == v2->i16;
373 break;
374 case PSI_T_UINT16:
375 res->u8 = v1->i64 == v2->u16;
376 break;
377 case PSI_T_INT32:
378 res->u8 = v1->i64 == v2->i32;
379 break;
380 case PSI_T_UINT32:
381 res->u8 = v1->i64 == v2->u32;
382 break;
383 case PSI_T_INT64:
384 res->u8 = v1->i64 == v2->i64;
385 break;
386 case PSI_T_UINT64:
387 res->u8 = v1->i64 == v2->u64;
388 break;
389 # if HAVE_INT128
390 case PSI_T_INT128:
391 res->u8 = v1->i64 == v2->i128;
392 break;
393 # endif
394
395 # if HAVE_UINT128
396 case PSI_T_UINT128:
397 res->u8 = v1->i64 == v2->u128;
398 break;
399 # endif
400
401 case PSI_T_FLOAT:
402 res->u8 = v1->i64 == v2->fval;
403 break;
404 case PSI_T_DOUBLE:
405 res->u8 = v1->i64 == v2->dval;
406 break;
407 # if HAVE_LONG_DOUBLE
408 case PSI_T_LONG_DOUBLE:
409 res->u8 = v1->i64 == v2->ldval;
410 break;
411 # endif
412
413 default:
414 assert(0);
415 break;
416 }
417 break;
418 case PSI_T_UINT64:
419 switch (t2) {
420 case PSI_T_INT8:
421 res->u8 = v1->u64 == v2->i8;
422 break;
423 case PSI_T_UINT8:
424 res->u8 = v1->u64 == v2->u8;
425 break;
426 case PSI_T_INT16:
427 res->u8 = v1->u64 == v2->i16;
428 break;
429 case PSI_T_UINT16:
430 res->u8 = v1->u64 == v2->u16;
431 break;
432 case PSI_T_INT32:
433 res->u8 = v1->u64 == v2->i32;
434 break;
435 case PSI_T_UINT32:
436 res->u8 = v1->u64 == v2->u32;
437 break;
438 case PSI_T_INT64:
439 res->u8 = v1->u64 == v2->i64;
440 break;
441 case PSI_T_UINT64:
442 res->u8 = v1->u64 == v2->u64;
443 break;
444 # if HAVE_INT128
445 case PSI_T_INT128:
446 res->u8 = v1->u64 == v2->i128;
447 break;
448 # endif
449
450 # if HAVE_UINT128
451 case PSI_T_UINT128:
452 res->u8 = v1->u64 == v2->u128;
453 break;
454 # endif
455
456 case PSI_T_FLOAT:
457 res->u8 = v1->u64 == v2->fval;
458 break;
459 case PSI_T_DOUBLE:
460 res->u8 = v1->u64 == v2->dval;
461 break;
462 # if HAVE_LONG_DOUBLE
463 case PSI_T_LONG_DOUBLE:
464 res->u8 = v1->u64 == v2->ldval;
465 break;
466 # endif
467
468 default:
469 assert(0);
470 break;
471 }
472 break;
473 #if HAVE_INT128
474 case PSI_T_INT128:
475 switch (t2) {
476 case PSI_T_INT8:
477 res->u8 = v1->i128 == v2->i8;
478 break;
479 case PSI_T_UINT8:
480 res->u8 = v1->i128 == v2->u8;
481 break;
482 case PSI_T_INT16:
483 res->u8 = v1->i128 == v2->i16;
484 break;
485 case PSI_T_UINT16:
486 res->u8 = v1->i128 == v2->u16;
487 break;
488 case PSI_T_INT32:
489 res->u8 = v1->i128 == v2->i32;
490 break;
491 case PSI_T_UINT32:
492 res->u8 = v1->i128 == v2->u32;
493 break;
494 case PSI_T_INT64:
495 res->u8 = v1->i128 == v2->i64;
496 break;
497 case PSI_T_UINT64:
498 res->u8 = v1->i128 == v2->u64;
499 break;
500 # if HAVE_INT128
501 case PSI_T_INT128:
502 res->u8 = v1->i128 == v2->i128;
503 break;
504 # endif
505
506 # if HAVE_UINT128
507 case PSI_T_UINT128:
508 res->u8 = v1->i128 == v2->u128;
509 break;
510 # endif
511
512 case PSI_T_FLOAT:
513 res->u8 = v1->i128 == v2->fval;
514 break;
515 case PSI_T_DOUBLE:
516 res->u8 = v1->i128 == v2->dval;
517 break;
518 # if HAVE_LONG_DOUBLE
519 case PSI_T_LONG_DOUBLE:
520 res->u8 = v1->i128 == v2->ldval;
521 break;
522 # endif
523
524 default:
525 assert(0);
526 break;
527 }
528 break;
529 #endif
530
531 #if HAVE_UINT128
532 case PSI_T_UINT128:
533 switch (t2) {
534 case PSI_T_INT8:
535 res->u8 = v1->u128 == v2->i8;
536 break;
537 case PSI_T_UINT8:
538 res->u8 = v1->u128 == v2->u8;
539 break;
540 case PSI_T_INT16:
541 res->u8 = v1->u128 == v2->i16;
542 break;
543 case PSI_T_UINT16:
544 res->u8 = v1->u128 == v2->u16;
545 break;
546 case PSI_T_INT32:
547 res->u8 = v1->u128 == v2->i32;
548 break;
549 case PSI_T_UINT32:
550 res->u8 = v1->u128 == v2->u32;
551 break;
552 case PSI_T_INT64:
553 res->u8 = v1->u128 == v2->i64;
554 break;
555 case PSI_T_UINT64:
556 res->u8 = v1->u128 == v2->u64;
557 break;
558 # if HAVE_INT128
559 case PSI_T_INT128:
560 res->u8 = v1->u128 == v2->i128;
561 break;
562 # endif
563
564 # if HAVE_UINT128
565 case PSI_T_UINT128:
566 res->u8 = v1->u128 == v2->u128;
567 break;
568 # endif
569
570 case PSI_T_FLOAT:
571 res->u8 = v1->u128 == v2->fval;
572 break;
573 case PSI_T_DOUBLE:
574 res->u8 = v1->u128 == v2->dval;
575 break;
576 # if HAVE_LONG_DOUBLE
577 case PSI_T_LONG_DOUBLE:
578 res->u8 = v1->u128 == v2->ldval;
579 break;
580 # endif
581
582 default:
583 assert(0);
584 break;
585 }
586 break;
587 #endif
588
589 case PSI_T_FLOAT:
590 switch (t2) {
591 case PSI_T_INT8:
592 res->u8 = v1->fval == v2->i8;
593 break;
594 case PSI_T_UINT8:
595 res->u8 = v1->fval == v2->u8;
596 break;
597 case PSI_T_INT16:
598 res->u8 = v1->fval == v2->i16;
599 break;
600 case PSI_T_UINT16:
601 res->u8 = v1->fval == v2->u16;
602 break;
603 case PSI_T_INT32:
604 res->u8 = v1->fval == v2->i32;
605 break;
606 case PSI_T_UINT32:
607 res->u8 = v1->fval == v2->u32;
608 break;
609 case PSI_T_INT64:
610 res->u8 = v1->fval == v2->i64;
611 break;
612 case PSI_T_UINT64:
613 res->u8 = v1->fval == v2->u64;
614 break;
615 # if HAVE_INT128
616 case PSI_T_INT128:
617 res->u8 = v1->fval == v2->i128;
618 break;
619 # endif
620
621 # if HAVE_UINT128
622 case PSI_T_UINT128:
623 res->u8 = v1->fval == v2->u128;
624 break;
625 # endif
626
627 case PSI_T_FLOAT:
628 res->u8 = v1->fval == v2->fval;
629 break;
630 case PSI_T_DOUBLE:
631 res->u8 = v1->fval == v2->dval;
632 break;
633 # if HAVE_LONG_DOUBLE
634 case PSI_T_LONG_DOUBLE:
635 res->u8 = v1->fval == v2->ldval;
636 break;
637 # endif
638
639 default:
640 assert(0);
641 break;
642 }
643 break;
644 case PSI_T_DOUBLE:
645 switch (t2) {
646 case PSI_T_INT8:
647 res->u8 = v1->dval == v2->i8;
648 break;
649 case PSI_T_UINT8:
650 res->u8 = v1->dval == v2->u8;
651 break;
652 case PSI_T_INT16:
653 res->u8 = v1->dval == v2->i16;
654 break;
655 case PSI_T_UINT16:
656 res->u8 = v1->dval == v2->u16;
657 break;
658 case PSI_T_INT32:
659 res->u8 = v1->dval == v2->i32;
660 break;
661 case PSI_T_UINT32:
662 res->u8 = v1->dval == v2->u32;
663 break;
664 case PSI_T_INT64:
665 res->u8 = v1->dval == v2->i64;
666 break;
667 case PSI_T_UINT64:
668 res->u8 = v1->dval == v2->u64;
669 break;
670 # if HAVE_INT128
671 case PSI_T_INT128:
672 res->u8 = v1->dval == v2->i128;
673 break;
674 # endif
675
676 # if HAVE_UINT128
677 case PSI_T_UINT128:
678 res->u8 = v1->dval == v2->u128;
679 break;
680 # endif
681
682 case PSI_T_FLOAT:
683 res->u8 = v1->dval == v2->fval;
684 break;
685 case PSI_T_DOUBLE:
686 res->u8 = v1->dval == v2->dval;
687 break;
688 # if HAVE_LONG_DOUBLE
689 case PSI_T_LONG_DOUBLE:
690 res->u8 = v1->dval == v2->ldval;
691 break;
692 # endif
693
694 default:
695 assert(0);
696 break;
697 }
698 break;
699 #if HAVE_LONG_DOUBLE
700 case PSI_T_LONG_DOUBLE:
701 switch (t2) {
702 case PSI_T_INT8:
703 res->u8 = v1->ldval == v2->i8;
704 break;
705 case PSI_T_UINT8:
706 res->u8 = v1->ldval == v2->u8;
707 break;
708 case PSI_T_INT16:
709 res->u8 = v1->ldval == v2->i16;
710 break;
711 case PSI_T_UINT16:
712 res->u8 = v1->ldval == v2->u16;
713 break;
714 case PSI_T_INT32:
715 res->u8 = v1->ldval == v2->i32;
716 break;
717 case PSI_T_UINT32:
718 res->u8 = v1->ldval == v2->u32;
719 break;
720 case PSI_T_INT64:
721 res->u8 = v1->ldval == v2->i64;
722 break;
723 case PSI_T_UINT64:
724 res->u8 = v1->ldval == v2->u64;
725 break;
726 # if HAVE_INT128
727 case PSI_T_INT128:
728 res->u8 = v1->ldval == v2->i128;
729 break;
730 # endif
731
732 # if HAVE_UINT128
733 case PSI_T_UINT128:
734 res->u8 = v1->ldval == v2->u128;
735 break;
736 # endif
737
738 case PSI_T_FLOAT:
739 res->u8 = v1->ldval == v2->fval;
740 break;
741 case PSI_T_DOUBLE:
742 res->u8 = v1->ldval == v2->dval;
743 break;
744 # if HAVE_LONG_DOUBLE
745 case PSI_T_LONG_DOUBLE:
746 res->u8 = v1->ldval == v2->ldval;
747 break;
748 # endif
749
750 default:
751 assert(0);
752 break;
753 }
754 break;
755 #endif
756
757 default:
758 assert(0);
759 break;
760 }
761 return PSI_T_UINT8;
762 }
763
764 static inline token_t psi_calc_cmp_ne(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
765 {
766 switch (t1) {
767 case PSI_T_INT8:
768 switch (t2) {
769 case PSI_T_INT8:
770 res->u8 = v1->i8 != v2->i8;
771 break;
772 case PSI_T_UINT8:
773 res->u8 = v1->i8 != v2->u8;
774 break;
775 case PSI_T_INT16:
776 res->u8 = v1->i8 != v2->i16;
777 break;
778 case PSI_T_UINT16:
779 res->u8 = v1->i8 != v2->u16;
780 break;
781 case PSI_T_INT32:
782 res->u8 = v1->i8 != v2->i32;
783 break;
784 case PSI_T_UINT32:
785 res->u8 = v1->i8 != v2->u32;
786 break;
787 case PSI_T_INT64:
788 res->u8 = v1->i8 != v2->i64;
789 break;
790 case PSI_T_UINT64:
791 res->u8 = v1->i8 != v2->u64;
792 break;
793 # if HAVE_INT128
794 case PSI_T_INT128:
795 res->u8 = v1->i8 != v2->i128;
796 break;
797 # endif
798
799 # if HAVE_UINT128
800 case PSI_T_UINT128:
801 res->u8 = v1->i8 != v2->u128;
802 break;
803 # endif
804
805 case PSI_T_FLOAT:
806 res->u8 = v1->i8 != v2->fval;
807 break;
808 case PSI_T_DOUBLE:
809 res->u8 = v1->i8 != v2->dval;
810 break;
811 # if HAVE_LONG_DOUBLE
812 case PSI_T_LONG_DOUBLE:
813 res->u8 = v1->i8 != v2->ldval;
814 break;
815 # endif
816
817 default:
818 assert(0);
819 break;
820 }
821 break;
822 case PSI_T_UINT8:
823 switch (t2) {
824 case PSI_T_INT8:
825 res->u8 = v1->u8 != v2->i8;
826 break;
827 case PSI_T_UINT8:
828 res->u8 = v1->u8 != v2->u8;
829 break;
830 case PSI_T_INT16:
831 res->u8 = v1->u8 != v2->i16;
832 break;
833 case PSI_T_UINT16:
834 res->u8 = v1->u8 != v2->u16;
835 break;
836 case PSI_T_INT32:
837 res->u8 = v1->u8 != v2->i32;
838 break;
839 case PSI_T_UINT32:
840 res->u8 = v1->u8 != v2->u32;
841 break;
842 case PSI_T_INT64:
843 res->u8 = v1->u8 != v2->i64;
844 break;
845 case PSI_T_UINT64:
846 res->u8 = v1->u8 != v2->u64;
847 break;
848 # if HAVE_INT128
849 case PSI_T_INT128:
850 res->u8 = v1->u8 != v2->i128;
851 break;
852 # endif
853
854 # if HAVE_UINT128
855 case PSI_T_UINT128:
856 res->u8 = v1->u8 != v2->u128;
857 break;
858 # endif
859
860 case PSI_T_FLOAT:
861 res->u8 = v1->u8 != v2->fval;
862 break;
863 case PSI_T_DOUBLE:
864 res->u8 = v1->u8 != v2->dval;
865 break;
866 # if HAVE_LONG_DOUBLE
867 case PSI_T_LONG_DOUBLE:
868 res->u8 = v1->u8 != v2->ldval;
869 break;
870 # endif
871
872 default:
873 assert(0);
874 break;
875 }
876 break;
877 case PSI_T_INT16:
878 switch (t2) {
879 case PSI_T_INT8:
880 res->u8 = v1->i16 != v2->i8;
881 break;
882 case PSI_T_UINT8:
883 res->u8 = v1->i16 != v2->u8;
884 break;
885 case PSI_T_INT16:
886 res->u8 = v1->i16 != v2->i16;
887 break;
888 case PSI_T_UINT16:
889 res->u8 = v1->i16 != v2->u16;
890 break;
891 case PSI_T_INT32:
892 res->u8 = v1->i16 != v2->i32;
893 break;
894 case PSI_T_UINT32:
895 res->u8 = v1->i16 != v2->u32;
896 break;
897 case PSI_T_INT64:
898 res->u8 = v1->i16 != v2->i64;
899 break;
900 case PSI_T_UINT64:
901 res->u8 = v1->i16 != v2->u64;
902 break;
903 # if HAVE_INT128
904 case PSI_T_INT128:
905 res->u8 = v1->i16 != v2->i128;
906 break;
907 # endif
908
909 # if HAVE_UINT128
910 case PSI_T_UINT128:
911 res->u8 = v1->i16 != v2->u128;
912 break;
913 # endif
914
915 case PSI_T_FLOAT:
916 res->u8 = v1->i16 != v2->fval;
917 break;
918 case PSI_T_DOUBLE:
919 res->u8 = v1->i16 != v2->dval;
920 break;
921 # if HAVE_LONG_DOUBLE
922 case PSI_T_LONG_DOUBLE:
923 res->u8 = v1->i16 != v2->ldval;
924 break;
925 # endif
926
927 default:
928 assert(0);
929 break;
930 }
931 break;
932 case PSI_T_UINT16:
933 switch (t2) {
934 case PSI_T_INT8:
935 res->u8 = v1->u16 != v2->i8;
936 break;
937 case PSI_T_UINT8:
938 res->u8 = v1->u16 != v2->u8;
939 break;
940 case PSI_T_INT16:
941 res->u8 = v1->u16 != v2->i16;
942 break;
943 case PSI_T_UINT16:
944 res->u8 = v1->u16 != v2->u16;
945 break;
946 case PSI_T_INT32:
947 res->u8 = v1->u16 != v2->i32;
948 break;
949 case PSI_T_UINT32:
950 res->u8 = v1->u16 != v2->u32;
951 break;
952 case PSI_T_INT64:
953 res->u8 = v1->u16 != v2->i64;
954 break;
955 case PSI_T_UINT64:
956 res->u8 = v1->u16 != v2->u64;
957 break;
958 # if HAVE_INT128
959 case PSI_T_INT128:
960 res->u8 = v1->u16 != v2->i128;
961 break;
962 # endif
963
964 # if HAVE_UINT128
965 case PSI_T_UINT128:
966 res->u8 = v1->u16 != v2->u128;
967 break;
968 # endif
969
970 case PSI_T_FLOAT:
971 res->u8 = v1->u16 != v2->fval;
972 break;
973 case PSI_T_DOUBLE:
974 res->u8 = v1->u16 != v2->dval;
975 break;
976 # if HAVE_LONG_DOUBLE
977 case PSI_T_LONG_DOUBLE:
978 res->u8 = v1->u16 != v2->ldval;
979 break;
980 # endif
981
982 default:
983 assert(0);
984 break;
985 }
986 break;
987 case PSI_T_INT32:
988 switch (t2) {
989 case PSI_T_INT8:
990 res->u8 = v1->i32 != v2->i8;
991 break;
992 case PSI_T_UINT8:
993 res->u8 = v1->i32 != v2->u8;
994 break;
995 case PSI_T_INT16:
996 res->u8 = v1->i32 != v2->i16;
997 break;
998 case PSI_T_UINT16:
999 res->u8 = v1->i32 != v2->u16;
1000 break;
1001 case PSI_T_INT32:
1002 res->u8 = v1->i32 != v2->i32;
1003 break;
1004 case PSI_T_UINT32:
1005 res->u8 = v1->i32 != v2->u32;
1006 break;
1007 case PSI_T_INT64:
1008 res->u8 = v1->i32 != v2->i64;
1009 break;
1010 case PSI_T_UINT64:
1011 res->u8 = v1->i32 != v2->u64;
1012 break;
1013 # if HAVE_INT128
1014 case PSI_T_INT128:
1015 res->u8 = v1->i32 != v2->i128;
1016 break;
1017 # endif
1018
1019 # if HAVE_UINT128
1020 case PSI_T_UINT128:
1021 res->u8 = v1->i32 != v2->u128;
1022 break;
1023 # endif
1024
1025 case PSI_T_FLOAT:
1026 res->u8 = v1->i32 != v2->fval;
1027 break;
1028 case PSI_T_DOUBLE:
1029 res->u8 = v1->i32 != v2->dval;
1030 break;
1031 # if HAVE_LONG_DOUBLE
1032 case PSI_T_LONG_DOUBLE:
1033 res->u8 = v1->i32 != v2->ldval;
1034 break;
1035 # endif
1036
1037 default:
1038 assert(0);
1039 break;
1040 }
1041 break;
1042 case PSI_T_UINT32:
1043 switch (t2) {
1044 case PSI_T_INT8:
1045 res->u8 = v1->u32 != v2->i8;
1046 break;
1047 case PSI_T_UINT8:
1048 res->u8 = v1->u32 != v2->u8;
1049 break;
1050 case PSI_T_INT16:
1051 res->u8 = v1->u32 != v2->i16;
1052 break;
1053 case PSI_T_UINT16:
1054 res->u8 = v1->u32 != v2->u16;
1055 break;
1056 case PSI_T_INT32:
1057 res->u8 = v1->u32 != v2->i32;
1058 break;
1059 case PSI_T_UINT32:
1060 res->u8 = v1->u32 != v2->u32;
1061 break;
1062 case PSI_T_INT64:
1063 res->u8 = v1->u32 != v2->i64;
1064 break;
1065 case PSI_T_UINT64:
1066 res->u8 = v1->u32 != v2->u64;
1067 break;
1068 # if HAVE_INT128
1069 case PSI_T_INT128:
1070 res->u8 = v1->u32 != v2->i128;
1071 break;
1072 # endif
1073
1074 # if HAVE_UINT128
1075 case PSI_T_UINT128:
1076 res->u8 = v1->u32 != v2->u128;
1077 break;
1078 # endif
1079
1080 case PSI_T_FLOAT:
1081 res->u8 = v1->u32 != v2->fval;
1082 break;
1083 case PSI_T_DOUBLE:
1084 res->u8 = v1->u32 != v2->dval;
1085 break;
1086 # if HAVE_LONG_DOUBLE
1087 case PSI_T_LONG_DOUBLE:
1088 res->u8 = v1->u32 != v2->ldval;
1089 break;
1090 # endif
1091
1092 default:
1093 assert(0);
1094 break;
1095 }
1096 break;
1097 case PSI_T_INT64:
1098 switch (t2) {
1099 case PSI_T_INT8:
1100 res->u8 = v1->i64 != v2->i8;
1101 break;
1102 case PSI_T_UINT8:
1103 res->u8 = v1->i64 != v2->u8;
1104 break;
1105 case PSI_T_INT16:
1106 res->u8 = v1->i64 != v2->i16;
1107 break;
1108 case PSI_T_UINT16:
1109 res->u8 = v1->i64 != v2->u16;
1110 break;
1111 case PSI_T_INT32:
1112 res->u8 = v1->i64 != v2->i32;
1113 break;
1114 case PSI_T_UINT32:
1115 res->u8 = v1->i64 != v2->u32;
1116 break;
1117 case PSI_T_INT64:
1118 res->u8 = v1->i64 != v2->i64;
1119 break;
1120 case PSI_T_UINT64:
1121 res->u8 = v1->i64 != v2->u64;
1122 break;
1123 # if HAVE_INT128
1124 case PSI_T_INT128:
1125 res->u8 = v1->i64 != v2->i128;
1126 break;
1127 # endif
1128
1129 # if HAVE_UINT128
1130 case PSI_T_UINT128:
1131 res->u8 = v1->i64 != v2->u128;
1132 break;
1133 # endif
1134
1135 case PSI_T_FLOAT:
1136 res->u8 = v1->i64 != v2->fval;
1137 break;
1138 case PSI_T_DOUBLE:
1139 res->u8 = v1->i64 != v2->dval;
1140 break;
1141 # if HAVE_LONG_DOUBLE
1142 case PSI_T_LONG_DOUBLE:
1143 res->u8 = v1->i64 != v2->ldval;
1144 break;
1145 # endif
1146
1147 default:
1148 assert(0);
1149 break;
1150 }
1151 break;
1152 case PSI_T_UINT64:
1153 switch (t2) {
1154 case PSI_T_INT8:
1155 res->u8 = v1->u64 != v2->i8;
1156 break;
1157 case PSI_T_UINT8:
1158 res->u8 = v1->u64 != v2->u8;
1159 break;
1160 case PSI_T_INT16:
1161 res->u8 = v1->u64 != v2->i16;
1162 break;
1163 case PSI_T_UINT16:
1164 res->u8 = v1->u64 != v2->u16;
1165 break;
1166 case PSI_T_INT32:
1167 res->u8 = v1->u64 != v2->i32;
1168 break;
1169 case PSI_T_UINT32:
1170 res->u8 = v1->u64 != v2->u32;
1171 break;
1172 case PSI_T_INT64:
1173 res->u8 = v1->u64 != v2->i64;
1174 break;
1175 case PSI_T_UINT64:
1176 res->u8 = v1->u64 != v2->u64;
1177 break;
1178 # if HAVE_INT128
1179 case PSI_T_INT128:
1180 res->u8 = v1->u64 != v2->i128;
1181 break;
1182 # endif
1183
1184 # if HAVE_UINT128
1185 case PSI_T_UINT128:
1186 res->u8 = v1->u64 != v2->u128;
1187 break;
1188 # endif
1189
1190 case PSI_T_FLOAT:
1191 res->u8 = v1->u64 != v2->fval;
1192 break;
1193 case PSI_T_DOUBLE:
1194 res->u8 = v1->u64 != v2->dval;
1195 break;
1196 # if HAVE_LONG_DOUBLE
1197 case PSI_T_LONG_DOUBLE:
1198 res->u8 = v1->u64 != v2->ldval;
1199 break;
1200 # endif
1201
1202 default:
1203 assert(0);
1204 break;
1205 }
1206 break;
1207 #if HAVE_INT128
1208 case PSI_T_INT128:
1209 switch (t2) {
1210 case PSI_T_INT8:
1211 res->u8 = v1->i128 != v2->i8;
1212 break;
1213 case PSI_T_UINT8:
1214 res->u8 = v1->i128 != v2->u8;
1215 break;
1216 case PSI_T_INT16:
1217 res->u8 = v1->i128 != v2->i16;
1218 break;
1219 case PSI_T_UINT16:
1220 res->u8 = v1->i128 != v2->u16;
1221 break;
1222 case PSI_T_INT32:
1223 res->u8 = v1->i128 != v2->i32;
1224 break;
1225 case PSI_T_UINT32:
1226 res->u8 = v1->i128 != v2->u32;
1227 break;
1228 case PSI_T_INT64:
1229 res->u8 = v1->i128 != v2->i64;
1230 break;
1231 case PSI_T_UINT64:
1232 res->u8 = v1->i128 != v2->u64;
1233 break;
1234 # if HAVE_INT128
1235 case PSI_T_INT128:
1236 res->u8 = v1->i128 != v2->i128;
1237 break;
1238 # endif
1239
1240 # if HAVE_UINT128
1241 case PSI_T_UINT128:
1242 res->u8 = v1->i128 != v2->u128;
1243 break;
1244 # endif
1245
1246 case PSI_T_FLOAT:
1247 res->u8 = v1->i128 != v2->fval;
1248 break;
1249 case PSI_T_DOUBLE:
1250 res->u8 = v1->i128 != v2->dval;
1251 break;
1252 # if HAVE_LONG_DOUBLE
1253 case PSI_T_LONG_DOUBLE:
1254 res->u8 = v1->i128 != v2->ldval;
1255 break;
1256 # endif
1257
1258 default:
1259 assert(0);
1260 break;
1261 }
1262 break;
1263 #endif
1264
1265 #if HAVE_UINT128
1266 case PSI_T_UINT128:
1267 switch (t2) {
1268 case PSI_T_INT8:
1269 res->u8 = v1->u128 != v2->i8;
1270 break;
1271 case PSI_T_UINT8:
1272 res->u8 = v1->u128 != v2->u8;
1273 break;
1274 case PSI_T_INT16:
1275 res->u8 = v1->u128 != v2->i16;
1276 break;
1277 case PSI_T_UINT16:
1278 res->u8 = v1->u128 != v2->u16;
1279 break;
1280 case PSI_T_INT32:
1281 res->u8 = v1->u128 != v2->i32;
1282 break;
1283 case PSI_T_UINT32:
1284 res->u8 = v1->u128 != v2->u32;
1285 break;
1286 case PSI_T_INT64:
1287 res->u8 = v1->u128 != v2->i64;
1288 break;
1289 case PSI_T_UINT64:
1290 res->u8 = v1->u128 != v2->u64;
1291 break;
1292 # if HAVE_INT128
1293 case PSI_T_INT128:
1294 res->u8 = v1->u128 != v2->i128;
1295 break;
1296 # endif
1297
1298 # if HAVE_UINT128
1299 case PSI_T_UINT128:
1300 res->u8 = v1->u128 != v2->u128;
1301 break;
1302 # endif
1303
1304 case PSI_T_FLOAT:
1305 res->u8 = v1->u128 != v2->fval;
1306 break;
1307 case PSI_T_DOUBLE:
1308 res->u8 = v1->u128 != v2->dval;
1309 break;
1310 # if HAVE_LONG_DOUBLE
1311 case PSI_T_LONG_DOUBLE:
1312 res->u8 = v1->u128 != v2->ldval;
1313 break;
1314 # endif
1315
1316 default:
1317 assert(0);
1318 break;
1319 }
1320 break;
1321 #endif
1322
1323 case PSI_T_FLOAT:
1324 switch (t2) {
1325 case PSI_T_INT8:
1326 res->u8 = v1->fval != v2->i8;
1327 break;
1328 case PSI_T_UINT8:
1329 res->u8 = v1->fval != v2->u8;
1330 break;
1331 case PSI_T_INT16:
1332 res->u8 = v1->fval != v2->i16;
1333 break;
1334 case PSI_T_UINT16:
1335 res->u8 = v1->fval != v2->u16;
1336 break;
1337 case PSI_T_INT32:
1338 res->u8 = v1->fval != v2->i32;
1339 break;
1340 case PSI_T_UINT32:
1341 res->u8 = v1->fval != v2->u32;
1342 break;
1343 case PSI_T_INT64:
1344 res->u8 = v1->fval != v2->i64;
1345 break;
1346 case PSI_T_UINT64:
1347 res->u8 = v1->fval != v2->u64;
1348 break;
1349 # if HAVE_INT128
1350 case PSI_T_INT128:
1351 res->u8 = v1->fval != v2->i128;
1352 break;
1353 # endif
1354
1355 # if HAVE_UINT128
1356 case PSI_T_UINT128:
1357 res->u8 = v1->fval != v2->u128;
1358 break;
1359 # endif
1360
1361 case PSI_T_FLOAT:
1362 res->u8 = v1->fval != v2->fval;
1363 break;
1364 case PSI_T_DOUBLE:
1365 res->u8 = v1->fval != v2->dval;
1366 break;
1367 # if HAVE_LONG_DOUBLE
1368 case PSI_T_LONG_DOUBLE:
1369 res->u8 = v1->fval != v2->ldval;
1370 break;
1371 # endif
1372
1373 default:
1374 assert(0);
1375 break;
1376 }
1377 break;
1378 case PSI_T_DOUBLE:
1379 switch (t2) {
1380 case PSI_T_INT8:
1381 res->u8 = v1->dval != v2->i8;
1382 break;
1383 case PSI_T_UINT8:
1384 res->u8 = v1->dval != v2->u8;
1385 break;
1386 case PSI_T_INT16:
1387 res->u8 = v1->dval != v2->i16;
1388 break;
1389 case PSI_T_UINT16:
1390 res->u8 = v1->dval != v2->u16;
1391 break;
1392 case PSI_T_INT32:
1393 res->u8 = v1->dval != v2->i32;
1394 break;
1395 case PSI_T_UINT32:
1396 res->u8 = v1->dval != v2->u32;
1397 break;
1398 case PSI_T_INT64:
1399 res->u8 = v1->dval != v2->i64;
1400 break;
1401 case PSI_T_UINT64:
1402 res->u8 = v1->dval != v2->u64;
1403 break;
1404 # if HAVE_INT128
1405 case PSI_T_INT128:
1406 res->u8 = v1->dval != v2->i128;
1407 break;
1408 # endif
1409
1410 # if HAVE_UINT128
1411 case PSI_T_UINT128:
1412 res->u8 = v1->dval != v2->u128;
1413 break;
1414 # endif
1415
1416 case PSI_T_FLOAT:
1417 res->u8 = v1->dval != v2->fval;
1418 break;
1419 case PSI_T_DOUBLE:
1420 res->u8 = v1->dval != v2->dval;
1421 break;
1422 # if HAVE_LONG_DOUBLE
1423 case PSI_T_LONG_DOUBLE:
1424 res->u8 = v1->dval != v2->ldval;
1425 break;
1426 # endif
1427
1428 default:
1429 assert(0);
1430 break;
1431 }
1432 break;
1433 #if HAVE_LONG_DOUBLE
1434 case PSI_T_LONG_DOUBLE:
1435 switch (t2) {
1436 case PSI_T_INT8:
1437 res->u8 = v1->ldval != v2->i8;
1438 break;
1439 case PSI_T_UINT8:
1440 res->u8 = v1->ldval != v2->u8;
1441 break;
1442 case PSI_T_INT16:
1443 res->u8 = v1->ldval != v2->i16;
1444 break;
1445 case PSI_T_UINT16:
1446 res->u8 = v1->ldval != v2->u16;
1447 break;
1448 case PSI_T_INT32:
1449 res->u8 = v1->ldval != v2->i32;
1450 break;
1451 case PSI_T_UINT32:
1452 res->u8 = v1->ldval != v2->u32;
1453 break;
1454 case PSI_T_INT64:
1455 res->u8 = v1->ldval != v2->i64;
1456 break;
1457 case PSI_T_UINT64:
1458 res->u8 = v1->ldval != v2->u64;
1459 break;
1460 # if HAVE_INT128
1461 case PSI_T_INT128:
1462 res->u8 = v1->ldval != v2->i128;
1463 break;
1464 # endif
1465
1466 # if HAVE_UINT128
1467 case PSI_T_UINT128:
1468 res->u8 = v1->ldval != v2->u128;
1469 break;
1470 # endif
1471
1472 case PSI_T_FLOAT:
1473 res->u8 = v1->ldval != v2->fval;
1474 break;
1475 case PSI_T_DOUBLE:
1476 res->u8 = v1->ldval != v2->dval;
1477 break;
1478 # if HAVE_LONG_DOUBLE
1479 case PSI_T_LONG_DOUBLE:
1480 res->u8 = v1->ldval != v2->ldval;
1481 break;
1482 # endif
1483
1484 default:
1485 assert(0);
1486 break;
1487 }
1488 break;
1489 #endif
1490
1491 default:
1492 assert(0);
1493 break;
1494 }
1495 return PSI_T_UINT8;
1496 }
1497
1498 static inline token_t psi_calc_cmp_lt(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
1499 {
1500 switch (t1) {
1501 case PSI_T_INT8:
1502 switch (t2) {
1503 case PSI_T_INT8:
1504 res->u8 = v1->i8 < v2->i8;
1505 break;
1506 case PSI_T_UINT8:
1507 res->u8 = v1->i8 < v2->u8;
1508 break;
1509 case PSI_T_INT16:
1510 res->u8 = v1->i8 < v2->i16;
1511 break;
1512 case PSI_T_UINT16:
1513 res->u8 = v1->i8 < v2->u16;
1514 break;
1515 case PSI_T_INT32:
1516 res->u8 = v1->i8 < v2->i32;
1517 break;
1518 case PSI_T_UINT32:
1519 res->u8 = v1->i8 < v2->u32;
1520 break;
1521 case PSI_T_INT64:
1522 res->u8 = v1->i8 < v2->i64;
1523 break;
1524 case PSI_T_UINT64:
1525 res->u8 = v1->i8 < v2->u64;
1526 break;
1527 # if HAVE_INT128
1528 case PSI_T_INT128:
1529 res->u8 = v1->i8 < v2->i128;
1530 break;
1531 # endif
1532
1533 # if HAVE_UINT128
1534 case PSI_T_UINT128:
1535 res->u8 = v1->i8 < v2->u128;
1536 break;
1537 # endif
1538
1539 case PSI_T_FLOAT:
1540 res->u8 = v1->i8 < v2->fval;
1541 break;
1542 case PSI_T_DOUBLE:
1543 res->u8 = v1->i8 < v2->dval;
1544 break;
1545 # if HAVE_LONG_DOUBLE
1546 case PSI_T_LONG_DOUBLE:
1547 res->u8 = v1->i8 < v2->ldval;
1548 break;
1549 # endif
1550
1551 default:
1552 assert(0);
1553 break;
1554 }
1555 break;
1556 case PSI_T_UINT8:
1557 switch (t2) {
1558 case PSI_T_INT8:
1559 res->u8 = v1->u8 < v2->i8;
1560 break;
1561 case PSI_T_UINT8:
1562 res->u8 = v1->u8 < v2->u8;
1563 break;
1564 case PSI_T_INT16:
1565 res->u8 = v1->u8 < v2->i16;
1566 break;
1567 case PSI_T_UINT16:
1568 res->u8 = v1->u8 < v2->u16;
1569 break;
1570 case PSI_T_INT32:
1571 res->u8 = v1->u8 < v2->i32;
1572 break;
1573 case PSI_T_UINT32:
1574 res->u8 = v1->u8 < v2->u32;
1575 break;
1576 case PSI_T_INT64:
1577 res->u8 = v1->u8 < v2->i64;
1578 break;
1579 case PSI_T_UINT64:
1580 res->u8 = v1->u8 < v2->u64;
1581 break;
1582 # if HAVE_INT128
1583 case PSI_T_INT128:
1584 res->u8 = v1->u8 < v2->i128;
1585 break;
1586 # endif
1587
1588 # if HAVE_UINT128
1589 case PSI_T_UINT128:
1590 res->u8 = v1->u8 < v2->u128;
1591 break;
1592 # endif
1593
1594 case PSI_T_FLOAT:
1595 res->u8 = v1->u8 < v2->fval;
1596 break;
1597 case PSI_T_DOUBLE:
1598 res->u8 = v1->u8 < v2->dval;
1599 break;
1600 # if HAVE_LONG_DOUBLE
1601 case PSI_T_LONG_DOUBLE:
1602 res->u8 = v1->u8 < v2->ldval;
1603 break;
1604 # endif
1605
1606 default:
1607 assert(0);
1608 break;
1609 }
1610 break;
1611 case PSI_T_INT16:
1612 switch (t2) {
1613 case PSI_T_INT8:
1614 res->u8 = v1->i16 < v2->i8;
1615 break;
1616 case PSI_T_UINT8:
1617 res->u8 = v1->i16 < v2->u8;
1618 break;
1619 case PSI_T_INT16:
1620 res->u8 = v1->i16 < v2->i16;
1621 break;
1622 case PSI_T_UINT16:
1623 res->u8 = v1->i16 < v2->u16;
1624 break;
1625 case PSI_T_INT32:
1626 res->u8 = v1->i16 < v2->i32;
1627 break;
1628 case PSI_T_UINT32:
1629 res->u8 = v1->i16 < v2->u32;
1630 break;
1631 case PSI_T_INT64:
1632 res->u8 = v1->i16 < v2->i64;
1633 break;
1634 case PSI_T_UINT64:
1635 res->u8 = v1->i16 < v2->u64;
1636 break;
1637 # if HAVE_INT128
1638 case PSI_T_INT128:
1639 res->u8 = v1->i16 < v2->i128;
1640 break;
1641 # endif
1642
1643 # if HAVE_UINT128
1644 case PSI_T_UINT128:
1645 res->u8 = v1->i16 < v2->u128;
1646 break;
1647 # endif
1648
1649 case PSI_T_FLOAT:
1650 res->u8 = v1->i16 < v2->fval;
1651 break;
1652 case PSI_T_DOUBLE:
1653 res->u8 = v1->i16 < v2->dval;
1654 break;
1655 # if HAVE_LONG_DOUBLE
1656 case PSI_T_LONG_DOUBLE:
1657 res->u8 = v1->i16 < v2->ldval;
1658 break;
1659 # endif
1660
1661 default:
1662 assert(0);
1663 break;
1664 }
1665 break;
1666 case PSI_T_UINT16:
1667 switch (t2) {
1668 case PSI_T_INT8:
1669 res->u8 = v1->u16 < v2->i8;
1670 break;
1671 case PSI_T_UINT8:
1672 res->u8 = v1->u16 < v2->u8;
1673 break;
1674 case PSI_T_INT16:
1675 res->u8 = v1->u16 < v2->i16;
1676 break;
1677 case PSI_T_UINT16:
1678 res->u8 = v1->u16 < v2->u16;
1679 break;
1680 case PSI_T_INT32:
1681 res->u8 = v1->u16 < v2->i32;
1682 break;
1683 case PSI_T_UINT32:
1684 res->u8 = v1->u16 < v2->u32;
1685 break;
1686 case PSI_T_INT64:
1687 res->u8 = v1->u16 < v2->i64;
1688 break;
1689 case PSI_T_UINT64:
1690 res->u8 = v1->u16 < v2->u64;
1691 break;
1692 # if HAVE_INT128
1693 case PSI_T_INT128:
1694 res->u8 = v1->u16 < v2->i128;
1695 break;
1696 # endif
1697
1698 # if HAVE_UINT128
1699 case PSI_T_UINT128:
1700 res->u8 = v1->u16 < v2->u128;
1701 break;
1702 # endif
1703
1704 case PSI_T_FLOAT:
1705 res->u8 = v1->u16 < v2->fval;
1706 break;
1707 case PSI_T_DOUBLE:
1708 res->u8 = v1->u16 < v2->dval;
1709 break;
1710 # if HAVE_LONG_DOUBLE
1711 case PSI_T_LONG_DOUBLE:
1712 res->u8 = v1->u16 < v2->ldval;
1713 break;
1714 # endif
1715
1716 default:
1717 assert(0);
1718 break;
1719 }
1720 break;
1721 case PSI_T_INT32:
1722 switch (t2) {
1723 case PSI_T_INT8:
1724 res->u8 = v1->i32 < v2->i8;
1725 break;
1726 case PSI_T_UINT8:
1727 res->u8 = v1->i32 < v2->u8;
1728 break;
1729 case PSI_T_INT16:
1730 res->u8 = v1->i32 < v2->i16;
1731 break;
1732 case PSI_T_UINT16:
1733 res->u8 = v1->i32 < v2->u16;
1734 break;
1735 case PSI_T_INT32:
1736 res->u8 = v1->i32 < v2->i32;
1737 break;
1738 case PSI_T_UINT32:
1739 res->u8 = v1->i32 < v2->u32;
1740 break;
1741 case PSI_T_INT64:
1742 res->u8 = v1->i32 < v2->i64;
1743 break;
1744 case PSI_T_UINT64:
1745 res->u8 = v1->i32 < v2->u64;
1746 break;
1747 # if HAVE_INT128
1748 case PSI_T_INT128:
1749 res->u8 = v1->i32 < v2->i128;
1750 break;
1751 # endif
1752
1753 # if HAVE_UINT128
1754 case PSI_T_UINT128:
1755 res->u8 = v1->i32 < v2->u128;
1756 break;
1757 # endif
1758
1759 case PSI_T_FLOAT:
1760 res->u8 = v1->i32 < v2->fval;
1761 break;
1762 case PSI_T_DOUBLE:
1763 res->u8 = v1->i32 < v2->dval;
1764 break;
1765 # if HAVE_LONG_DOUBLE
1766 case PSI_T_LONG_DOUBLE:
1767 res->u8 = v1->i32 < v2->ldval;
1768 break;
1769 # endif
1770
1771 default:
1772 assert(0);
1773 break;
1774 }
1775 break;
1776 case PSI_T_UINT32:
1777 switch (t2) {
1778 case PSI_T_INT8:
1779 res->u8 = v1->u32 < v2->i8;
1780 break;
1781 case PSI_T_UINT8:
1782 res->u8 = v1->u32 < v2->u8;
1783 break;
1784 case PSI_T_INT16:
1785 res->u8 = v1->u32 < v2->i16;
1786 break;
1787 case PSI_T_UINT16:
1788 res->u8 = v1->u32 < v2->u16;
1789 break;
1790 case PSI_T_INT32:
1791 res->u8 = v1->u32 < v2->i32;
1792 break;
1793 case PSI_T_UINT32:
1794 res->u8 = v1->u32 < v2->u32;
1795 break;
1796 case PSI_T_INT64:
1797 res->u8 = v1->u32 < v2->i64;
1798 break;
1799 case PSI_T_UINT64:
1800 res->u8 = v1->u32 < v2->u64;
1801 break;
1802 # if HAVE_INT128
1803 case PSI_T_INT128:
1804 res->u8 = v1->u32 < v2->i128;
1805 break;
1806 # endif
1807
1808 # if HAVE_UINT128
1809 case PSI_T_UINT128:
1810 res->u8 = v1->u32 < v2->u128;
1811 break;
1812 # endif
1813
1814 case PSI_T_FLOAT:
1815 res->u8 = v1->u32 < v2->fval;
1816 break;
1817 case PSI_T_DOUBLE:
1818 res->u8 = v1->u32 < v2->dval;
1819 break;
1820 # if HAVE_LONG_DOUBLE
1821 case PSI_T_LONG_DOUBLE:
1822 res->u8 = v1->u32 < v2->ldval;
1823 break;
1824 # endif
1825
1826 default:
1827 assert(0);
1828 break;
1829 }
1830 break;
1831 case PSI_T_INT64:
1832 switch (t2) {
1833 case PSI_T_INT8:
1834 res->u8 = v1->i64 < v2->i8;
1835 break;
1836 case PSI_T_UINT8:
1837 res->u8 = v1->i64 < v2->u8;
1838 break;
1839 case PSI_T_INT16:
1840 res->u8 = v1->i64 < v2->i16;
1841 break;
1842 case PSI_T_UINT16:
1843 res->u8 = v1->i64 < v2->u16;
1844 break;
1845 case PSI_T_INT32:
1846 res->u8 = v1->i64 < v2->i32;
1847 break;
1848 case PSI_T_UINT32:
1849 res->u8 = v1->i64 < v2->u32;
1850 break;
1851 case PSI_T_INT64:
1852 res->u8 = v1->i64 < v2->i64;
1853 break;
1854 case PSI_T_UINT64:
1855 res->u8 = v1->i64 < v2->u64;
1856 break;
1857 # if HAVE_INT128
1858 case PSI_T_INT128:
1859 res->u8 = v1->i64 < v2->i128;
1860 break;
1861 # endif
1862
1863 # if HAVE_UINT128
1864 case PSI_T_UINT128:
1865 res->u8 = v1->i64 < v2->u128;
1866 break;
1867 # endif
1868
1869 case PSI_T_FLOAT:
1870 res->u8 = v1->i64 < v2->fval;
1871 break;
1872 case PSI_T_DOUBLE:
1873 res->u8 = v1->i64 < v2->dval;
1874 break;
1875 # if HAVE_LONG_DOUBLE
1876 case PSI_T_LONG_DOUBLE:
1877 res->u8 = v1->i64 < v2->ldval;
1878 break;
1879 # endif
1880
1881 default:
1882 assert(0);
1883 break;
1884 }
1885 break;
1886 case PSI_T_UINT64:
1887 switch (t2) {
1888 case PSI_T_INT8:
1889 res->u8 = v1->u64 < v2->i8;
1890 break;
1891 case PSI_T_UINT8:
1892 res->u8 = v1->u64 < v2->u8;
1893 break;
1894 case PSI_T_INT16:
1895 res->u8 = v1->u64 < v2->i16;
1896 break;
1897 case PSI_T_UINT16:
1898 res->u8 = v1->u64 < v2->u16;
1899 break;
1900 case PSI_T_INT32:
1901 res->u8 = v1->u64 < v2->i32;
1902 break;
1903 case PSI_T_UINT32:
1904 res->u8 = v1->u64 < v2->u32;
1905 break;
1906 case PSI_T_INT64:
1907 res->u8 = v1->u64 < v2->i64;
1908 break;
1909 case PSI_T_UINT64:
1910 res->u8 = v1->u64 < v2->u64;
1911 break;
1912 # if HAVE_INT128
1913 case PSI_T_INT128:
1914 res->u8 = v1->u64 < v2->i128;
1915 break;
1916 # endif
1917
1918 # if HAVE_UINT128
1919 case PSI_T_UINT128:
1920 res->u8 = v1->u64 < v2->u128;
1921 break;
1922 # endif
1923
1924 case PSI_T_FLOAT:
1925 res->u8 = v1->u64 < v2->fval;
1926 break;
1927 case PSI_T_DOUBLE:
1928 res->u8 = v1->u64 < v2->dval;
1929 break;
1930 # if HAVE_LONG_DOUBLE
1931 case PSI_T_LONG_DOUBLE:
1932 res->u8 = v1->u64 < v2->ldval;
1933 break;
1934 # endif
1935
1936 default:
1937 assert(0);
1938 break;
1939 }
1940 break;
1941 #if HAVE_INT128
1942 case PSI_T_INT128:
1943 switch (t2) {
1944 case PSI_T_INT8:
1945 res->u8 = v1->i128 < v2->i8;
1946 break;
1947 case PSI_T_UINT8:
1948 res->u8 = v1->i128 < v2->u8;
1949 break;
1950 case PSI_T_INT16:
1951 res->u8 = v1->i128 < v2->i16;
1952 break;
1953 case PSI_T_UINT16:
1954 res->u8 = v1->i128 < v2->u16;
1955 break;
1956 case PSI_T_INT32:
1957 res->u8 = v1->i128 < v2->i32;
1958 break;
1959 case PSI_T_UINT32:
1960 res->u8 = v1->i128 < v2->u32;
1961 break;
1962 case PSI_T_INT64:
1963 res->u8 = v1->i128 < v2->i64;
1964 break;
1965 case PSI_T_UINT64:
1966 res->u8 = v1->i128 < v2->u64;
1967 break;
1968 # if HAVE_INT128
1969 case PSI_T_INT128:
1970 res->u8 = v1->i128 < v2->i128;
1971 break;
1972 # endif
1973
1974 # if HAVE_UINT128
1975 case PSI_T_UINT128:
1976 res->u8 = v1->i128 < v2->u128;
1977 break;
1978 # endif
1979
1980 case PSI_T_FLOAT:
1981 res->u8 = v1->i128 < v2->fval;
1982 break;
1983 case PSI_T_DOUBLE:
1984 res->u8 = v1->i128 < v2->dval;
1985 break;
1986 # if HAVE_LONG_DOUBLE
1987 case PSI_T_LONG_DOUBLE:
1988 res->u8 = v1->i128 < v2->ldval;
1989 break;
1990 # endif
1991
1992 default:
1993 assert(0);
1994 break;
1995 }
1996 break;
1997 #endif
1998
1999 #if HAVE_UINT128
2000 case PSI_T_UINT128:
2001 switch (t2) {
2002 case PSI_T_INT8:
2003 res->u8 = v1->u128 < v2->i8;
2004 break;
2005 case PSI_T_UINT8:
2006 res->u8 = v1->u128 < v2->u8;
2007 break;
2008 case PSI_T_INT16:
2009 res->u8 = v1->u128 < v2->i16;
2010 break;
2011 case PSI_T_UINT16:
2012 res->u8 = v1->u128 < v2->u16;
2013 break;
2014 case PSI_T_INT32:
2015 res->u8 = v1->u128 < v2->i32;
2016 break;
2017 case PSI_T_UINT32:
2018 res->u8 = v1->u128 < v2->u32;
2019 break;
2020 case PSI_T_INT64:
2021 res->u8 = v1->u128 < v2->i64;
2022 break;
2023 case PSI_T_UINT64:
2024 res->u8 = v1->u128 < v2->u64;
2025 break;
2026 # if HAVE_INT128
2027 case PSI_T_INT128:
2028 res->u8 = v1->u128 < v2->i128;
2029 break;
2030 # endif
2031
2032 # if HAVE_UINT128
2033 case PSI_T_UINT128:
2034 res->u8 = v1->u128 < v2->u128;
2035 break;
2036 # endif
2037
2038 case PSI_T_FLOAT:
2039 res->u8 = v1->u128 < v2->fval;
2040 break;
2041 case PSI_T_DOUBLE:
2042 res->u8 = v1->u128 < v2->dval;
2043 break;
2044 # if HAVE_LONG_DOUBLE
2045 case PSI_T_LONG_DOUBLE:
2046 res->u8 = v1->u128 < v2->ldval;
2047 break;
2048 # endif
2049
2050 default:
2051 assert(0);
2052 break;
2053 }
2054 break;
2055 #endif
2056
2057 case PSI_T_FLOAT:
2058 switch (t2) {
2059 case PSI_T_INT8:
2060 res->u8 = v1->fval < v2->i8;
2061 break;
2062 case PSI_T_UINT8:
2063 res->u8 = v1->fval < v2->u8;
2064 break;
2065 case PSI_T_INT16:
2066 res->u8 = v1->fval < v2->i16;
2067 break;
2068 case PSI_T_UINT16:
2069 res->u8 = v1->fval < v2->u16;
2070 break;
2071 case PSI_T_INT32:
2072 res->u8 = v1->fval < v2->i32;
2073 break;
2074 case PSI_T_UINT32:
2075 res->u8 = v1->fval < v2->u32;
2076 break;
2077 case PSI_T_INT64:
2078 res->u8 = v1->fval < v2->i64;
2079 break;
2080 case PSI_T_UINT64:
2081 res->u8 = v1->fval < v2->u64;
2082 break;
2083 # if HAVE_INT128
2084 case PSI_T_INT128:
2085 res->u8 = v1->fval < v2->i128;
2086 break;
2087 # endif
2088
2089 # if HAVE_UINT128
2090 case PSI_T_UINT128:
2091 res->u8 = v1->fval < v2->u128;
2092 break;
2093 # endif
2094
2095 case PSI_T_FLOAT:
2096 res->u8 = v1->fval < v2->fval;
2097 break;
2098 case PSI_T_DOUBLE:
2099 res->u8 = v1->fval < v2->dval;
2100 break;
2101 # if HAVE_LONG_DOUBLE
2102 case PSI_T_LONG_DOUBLE:
2103 res->u8 = v1->fval < v2->ldval;
2104 break;
2105 # endif
2106
2107 default:
2108 assert(0);
2109 break;
2110 }
2111 break;
2112 case PSI_T_DOUBLE:
2113 switch (t2) {
2114 case PSI_T_INT8:
2115 res->u8 = v1->dval < v2->i8;
2116 break;
2117 case PSI_T_UINT8:
2118 res->u8 = v1->dval < v2->u8;
2119 break;
2120 case PSI_T_INT16:
2121 res->u8 = v1->dval < v2->i16;
2122 break;
2123 case PSI_T_UINT16:
2124 res->u8 = v1->dval < v2->u16;
2125 break;
2126 case PSI_T_INT32:
2127 res->u8 = v1->dval < v2->i32;
2128 break;
2129 case PSI_T_UINT32:
2130 res->u8 = v1->dval < v2->u32;
2131 break;
2132 case PSI_T_INT64:
2133 res->u8 = v1->dval < v2->i64;
2134 break;
2135 case PSI_T_UINT64:
2136 res->u8 = v1->dval < v2->u64;
2137 break;
2138 # if HAVE_INT128
2139 case PSI_T_INT128:
2140 res->u8 = v1->dval < v2->i128;
2141 break;
2142 # endif
2143
2144 # if HAVE_UINT128
2145 case PSI_T_UINT128:
2146 res->u8 = v1->dval < v2->u128;
2147 break;
2148 # endif
2149
2150 case PSI_T_FLOAT:
2151 res->u8 = v1->dval < v2->fval;
2152 break;
2153 case PSI_T_DOUBLE:
2154 res->u8 = v1->dval < v2->dval;
2155 break;
2156 # if HAVE_LONG_DOUBLE
2157 case PSI_T_LONG_DOUBLE:
2158 res->u8 = v1->dval < v2->ldval;
2159 break;
2160 # endif
2161
2162 default:
2163 assert(0);
2164 break;
2165 }
2166 break;
2167 #if HAVE_LONG_DOUBLE
2168 case PSI_T_LONG_DOUBLE:
2169 switch (t2) {
2170 case PSI_T_INT8:
2171 res->u8 = v1->ldval < v2->i8;
2172 break;
2173 case PSI_T_UINT8:
2174 res->u8 = v1->ldval < v2->u8;
2175 break;
2176 case PSI_T_INT16:
2177 res->u8 = v1->ldval < v2->i16;
2178 break;
2179 case PSI_T_UINT16:
2180 res->u8 = v1->ldval < v2->u16;
2181 break;
2182 case PSI_T_INT32:
2183 res->u8 = v1->ldval < v2->i32;
2184 break;
2185 case PSI_T_UINT32:
2186 res->u8 = v1->ldval < v2->u32;
2187 break;
2188 case PSI_T_INT64:
2189 res->u8 = v1->ldval < v2->i64;
2190 break;
2191 case PSI_T_UINT64:
2192 res->u8 = v1->ldval < v2->u64;
2193 break;
2194 # if HAVE_INT128
2195 case PSI_T_INT128:
2196 res->u8 = v1->ldval < v2->i128;
2197 break;
2198 # endif
2199
2200 # if HAVE_UINT128
2201 case PSI_T_UINT128:
2202 res->u8 = v1->ldval < v2->u128;
2203 break;
2204 # endif
2205
2206 case PSI_T_FLOAT:
2207 res->u8 = v1->ldval < v2->fval;
2208 break;
2209 case PSI_T_DOUBLE:
2210 res->u8 = v1->ldval < v2->dval;
2211 break;
2212 # if HAVE_LONG_DOUBLE
2213 case PSI_T_LONG_DOUBLE:
2214 res->u8 = v1->ldval < v2->ldval;
2215 break;
2216 # endif
2217
2218 default:
2219 assert(0);
2220 break;
2221 }
2222 break;
2223 #endif
2224
2225 default:
2226 assert(0);
2227 break;
2228 }
2229 return PSI_T_UINT8;
2230 }
2231
2232 static inline token_t psi_calc_cmp_gt(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
2233 {
2234 switch (t1) {
2235 case PSI_T_INT8:
2236 switch (t2) {
2237 case PSI_T_INT8:
2238 res->u8 = v1->i8 > v2->i8;
2239 break;
2240 case PSI_T_UINT8:
2241 res->u8 = v1->i8 > v2->u8;
2242 break;
2243 case PSI_T_INT16:
2244 res->u8 = v1->i8 > v2->i16;
2245 break;
2246 case PSI_T_UINT16:
2247 res->u8 = v1->i8 > v2->u16;
2248 break;
2249 case PSI_T_INT32:
2250 res->u8 = v1->i8 > v2->i32;
2251 break;
2252 case PSI_T_UINT32:
2253 res->u8 = v1->i8 > v2->u32;
2254 break;
2255 case PSI_T_INT64:
2256 res->u8 = v1->i8 > v2->i64;
2257 break;
2258 case PSI_T_UINT64:
2259 res->u8 = v1->i8 > v2->u64;
2260 break;
2261 # if HAVE_INT128
2262 case PSI_T_INT128:
2263 res->u8 = v1->i8 > v2->i128;
2264 break;
2265 # endif
2266
2267 # if HAVE_UINT128
2268 case PSI_T_UINT128:
2269 res->u8 = v1->i8 > v2->u128;
2270 break;
2271 # endif
2272
2273 case PSI_T_FLOAT:
2274 res->u8 = v1->i8 > v2->fval;
2275 break;
2276 case PSI_T_DOUBLE:
2277 res->u8 = v1->i8 > v2->dval;
2278 break;
2279 # if HAVE_LONG_DOUBLE
2280 case PSI_T_LONG_DOUBLE:
2281 res->u8 = v1->i8 > v2->ldval;
2282 break;
2283 # endif
2284
2285 default:
2286 assert(0);
2287 break;
2288 }
2289 break;
2290 case PSI_T_UINT8:
2291 switch (t2) {
2292 case PSI_T_INT8:
2293 res->u8 = v1->u8 > v2->i8;
2294 break;
2295 case PSI_T_UINT8:
2296 res->u8 = v1->u8 > v2->u8;
2297 break;
2298 case PSI_T_INT16:
2299 res->u8 = v1->u8 > v2->i16;
2300 break;
2301 case PSI_T_UINT16:
2302 res->u8 = v1->u8 > v2->u16;
2303 break;
2304 case PSI_T_INT32:
2305 res->u8 = v1->u8 > v2->i32;
2306 break;
2307 case PSI_T_UINT32:
2308 res->u8 = v1->u8 > v2->u32;
2309 break;
2310 case PSI_T_INT64:
2311 res->u8 = v1->u8 > v2->i64;
2312 break;
2313 case PSI_T_UINT64:
2314 res->u8 = v1->u8 > v2->u64;
2315 break;
2316 # if HAVE_INT128
2317 case PSI_T_INT128:
2318 res->u8 = v1->u8 > v2->i128;
2319 break;
2320 # endif
2321
2322 # if HAVE_UINT128
2323 case PSI_T_UINT128:
2324 res->u8 = v1->u8 > v2->u128;
2325 break;
2326 # endif
2327
2328 case PSI_T_FLOAT:
2329 res->u8 = v1->u8 > v2->fval;
2330 break;
2331 case PSI_T_DOUBLE:
2332 res->u8 = v1->u8 > v2->dval;
2333 break;
2334 # if HAVE_LONG_DOUBLE
2335 case PSI_T_LONG_DOUBLE:
2336 res->u8 = v1->u8 > v2->ldval;
2337 break;
2338 # endif
2339
2340 default:
2341 assert(0);
2342 break;
2343 }
2344 break;
2345 case PSI_T_INT16:
2346 switch (t2) {
2347 case PSI_T_INT8:
2348 res->u8 = v1->i16 > v2->i8;
2349 break;
2350 case PSI_T_UINT8:
2351 res->u8 = v1->i16 > v2->u8;
2352 break;
2353 case PSI_T_INT16:
2354 res->u8 = v1->i16 > v2->i16;
2355 break;
2356 case PSI_T_UINT16:
2357 res->u8 = v1->i16 > v2->u16;
2358 break;
2359 case PSI_T_INT32:
2360 res->u8 = v1->i16 > v2->i32;
2361 break;
2362 case PSI_T_UINT32:
2363 res->u8 = v1->i16 > v2->u32;
2364 break;
2365 case PSI_T_INT64:
2366 res->u8 = v1->i16 > v2->i64;
2367 break;
2368 case PSI_T_UINT64:
2369 res->u8 = v1->i16 > v2->u64;
2370 break;
2371 # if HAVE_INT128
2372 case PSI_T_INT128:
2373 res->u8 = v1->i16 > v2->i128;
2374 break;
2375 # endif
2376
2377 # if HAVE_UINT128
2378 case PSI_T_UINT128:
2379 res->u8 = v1->i16 > v2->u128;
2380 break;
2381 # endif
2382
2383 case PSI_T_FLOAT:
2384 res->u8 = v1->i16 > v2->fval;
2385 break;
2386 case PSI_T_DOUBLE:
2387 res->u8 = v1->i16 > v2->dval;
2388 break;
2389 # if HAVE_LONG_DOUBLE
2390 case PSI_T_LONG_DOUBLE:
2391 res->u8 = v1->i16 > v2->ldval;
2392 break;
2393 # endif
2394
2395 default:
2396 assert(0);
2397 break;
2398 }
2399 break;
2400 case PSI_T_UINT16:
2401 switch (t2) {
2402 case PSI_T_INT8:
2403 res->u8 = v1->u16 > v2->i8;
2404 break;
2405 case PSI_T_UINT8:
2406 res->u8 = v1->u16 > v2->u8;
2407 break;
2408 case PSI_T_INT16:
2409 res->u8 = v1->u16 > v2->i16;
2410 break;
2411 case PSI_T_UINT16:
2412 res->u8 = v1->u16 > v2->u16;
2413 break;
2414 case PSI_T_INT32:
2415 res->u8 = v1->u16 > v2->i32;
2416 break;
2417 case PSI_T_UINT32:
2418 res->u8 = v1->u16 > v2->u32;
2419 break;
2420 case PSI_T_INT64:
2421 res->u8 = v1->u16 > v2->i64;
2422 break;
2423 case PSI_T_UINT64:
2424 res->u8 = v1->u16 > v2->u64;
2425 break;
2426 # if HAVE_INT128
2427 case PSI_T_INT128:
2428 res->u8 = v1->u16 > v2->i128;
2429 break;
2430 # endif
2431
2432 # if HAVE_UINT128
2433 case PSI_T_UINT128:
2434 res->u8 = v1->u16 > v2->u128;
2435 break;
2436 # endif
2437
2438 case PSI_T_FLOAT:
2439 res->u8 = v1->u16 > v2->fval;
2440 break;
2441 case PSI_T_DOUBLE:
2442 res->u8 = v1->u16 > v2->dval;
2443 break;
2444 # if HAVE_LONG_DOUBLE
2445 case PSI_T_LONG_DOUBLE:
2446 res->u8 = v1->u16 > v2->ldval;
2447 break;
2448 # endif
2449
2450 default:
2451 assert(0);
2452 break;
2453 }
2454 break;
2455 case PSI_T_INT32:
2456 switch (t2) {
2457 case PSI_T_INT8:
2458 res->u8 = v1->i32 > v2->i8;
2459 break;
2460 case PSI_T_UINT8:
2461 res->u8 = v1->i32 > v2->u8;
2462 break;
2463 case PSI_T_INT16:
2464 res->u8 = v1->i32 > v2->i16;
2465 break;
2466 case PSI_T_UINT16:
2467 res->u8 = v1->i32 > v2->u16;
2468 break;
2469 case PSI_T_INT32:
2470 res->u8 = v1->i32 > v2->i32;
2471 break;
2472 case PSI_T_UINT32:
2473 res->u8 = v1->i32 > v2->u32;
2474 break;
2475 case PSI_T_INT64:
2476 res->u8 = v1->i32 > v2->i64;
2477 break;
2478 case PSI_T_UINT64:
2479 res->u8 = v1->i32 > v2->u64;
2480 break;
2481 # if HAVE_INT128
2482 case PSI_T_INT128:
2483 res->u8 = v1->i32 > v2->i128;
2484 break;
2485 # endif
2486
2487 # if HAVE_UINT128
2488 case PSI_T_UINT128:
2489 res->u8 = v1->i32 > v2->u128;
2490 break;
2491 # endif
2492
2493 case PSI_T_FLOAT:
2494 res->u8 = v1->i32 > v2->fval;
2495 break;
2496 case PSI_T_DOUBLE:
2497 res->u8 = v1->i32 > v2->dval;
2498 break;
2499 # if HAVE_LONG_DOUBLE
2500 case PSI_T_LONG_DOUBLE:
2501 res->u8 = v1->i32 > v2->ldval;
2502 break;
2503 # endif
2504
2505 default:
2506 assert(0);
2507 break;
2508 }
2509 break;
2510 case PSI_T_UINT32:
2511 switch (t2) {
2512 case PSI_T_INT8:
2513 res->u8 = v1->u32 > v2->i8;
2514 break;
2515 case PSI_T_UINT8:
2516 res->u8 = v1->u32 > v2->u8;
2517 break;
2518 case PSI_T_INT16:
2519 res->u8 = v1->u32 > v2->i16;
2520 break;
2521 case PSI_T_UINT16:
2522 res->u8 = v1->u32 > v2->u16;
2523 break;
2524 case PSI_T_INT32:
2525 res->u8 = v1->u32 > v2->i32;
2526 break;
2527 case PSI_T_UINT32:
2528 res->u8 = v1->u32 > v2->u32;
2529 break;
2530 case PSI_T_INT64:
2531 res->u8 = v1->u32 > v2->i64;
2532 break;
2533 case PSI_T_UINT64:
2534 res->u8 = v1->u32 > v2->u64;
2535 break;
2536 # if HAVE_INT128
2537 case PSI_T_INT128:
2538 res->u8 = v1->u32 > v2->i128;
2539 break;
2540 # endif
2541
2542 # if HAVE_UINT128
2543 case PSI_T_UINT128:
2544 res->u8 = v1->u32 > v2->u128;
2545 break;
2546 # endif
2547
2548 case PSI_T_FLOAT:
2549 res->u8 = v1->u32 > v2->fval;
2550 break;
2551 case PSI_T_DOUBLE:
2552 res->u8 = v1->u32 > v2->dval;
2553 break;
2554 # if HAVE_LONG_DOUBLE
2555 case PSI_T_LONG_DOUBLE:
2556 res->u8 = v1->u32 > v2->ldval;
2557 break;
2558 # endif
2559
2560 default:
2561 assert(0);
2562 break;
2563 }
2564 break;
2565 case PSI_T_INT64:
2566 switch (t2) {
2567 case PSI_T_INT8:
2568 res->u8 = v1->i64 > v2->i8;
2569 break;
2570 case PSI_T_UINT8:
2571 res->u8 = v1->i64 > v2->u8;
2572 break;
2573 case PSI_T_INT16:
2574 res->u8 = v1->i64 > v2->i16;
2575 break;
2576 case PSI_T_UINT16:
2577 res->u8 = v1->i64 > v2->u16;
2578 break;
2579 case PSI_T_INT32:
2580 res->u8 = v1->i64 > v2->i32;
2581 break;
2582 case PSI_T_UINT32:
2583 res->u8 = v1->i64 > v2->u32;
2584 break;
2585 case PSI_T_INT64:
2586 res->u8 = v1->i64 > v2->i64;
2587 break;
2588 case PSI_T_UINT64:
2589 res->u8 = v1->i64 > v2->u64;
2590 break;
2591 # if HAVE_INT128
2592 case PSI_T_INT128:
2593 res->u8 = v1->i64 > v2->i128;
2594 break;
2595 # endif
2596
2597 # if HAVE_UINT128
2598 case PSI_T_UINT128:
2599 res->u8 = v1->i64 > v2->u128;
2600 break;
2601 # endif
2602
2603 case PSI_T_FLOAT:
2604 res->u8 = v1->i64 > v2->fval;
2605 break;
2606 case PSI_T_DOUBLE:
2607 res->u8 = v1->i64 > v2->dval;
2608 break;
2609 # if HAVE_LONG_DOUBLE
2610 case PSI_T_LONG_DOUBLE:
2611 res->u8 = v1->i64 > v2->ldval;
2612 break;
2613 # endif
2614
2615 default:
2616 assert(0);
2617 break;
2618 }
2619 break;
2620 case PSI_T_UINT64:
2621 switch (t2) {
2622 case PSI_T_INT8:
2623 res->u8 = v1->u64 > v2->i8;
2624 break;
2625 case PSI_T_UINT8:
2626 res->u8 = v1->u64 > v2->u8;
2627 break;
2628 case PSI_T_INT16:
2629 res->u8 = v1->u64 > v2->i16;
2630 break;
2631 case PSI_T_UINT16:
2632 res->u8 = v1->u64 > v2->u16;
2633 break;
2634 case PSI_T_INT32:
2635 res->u8 = v1->u64 > v2->i32;
2636 break;
2637 case PSI_T_UINT32:
2638 res->u8 = v1->u64 > v2->u32;
2639 break;
2640 case PSI_T_INT64:
2641 res->u8 = v1->u64 > v2->i64;
2642 break;
2643 case PSI_T_UINT64:
2644 res->u8 = v1->u64 > v2->u64;
2645 break;
2646 # if HAVE_INT128
2647 case PSI_T_INT128:
2648 res->u8 = v1->u64 > v2->i128;
2649 break;
2650 # endif
2651
2652 # if HAVE_UINT128
2653 case PSI_T_UINT128:
2654 res->u8 = v1->u64 > v2->u128;
2655 break;
2656 # endif
2657
2658 case PSI_T_FLOAT:
2659 res->u8 = v1->u64 > v2->fval;
2660 break;
2661 case PSI_T_DOUBLE:
2662 res->u8 = v1->u64 > v2->dval;
2663 break;
2664 # if HAVE_LONG_DOUBLE
2665 case PSI_T_LONG_DOUBLE:
2666 res->u8 = v1->u64 > v2->ldval;
2667 break;
2668 # endif
2669
2670 default:
2671 assert(0);
2672 break;
2673 }
2674 break;
2675 #if HAVE_INT128
2676 case PSI_T_INT128:
2677 switch (t2) {
2678 case PSI_T_INT8:
2679 res->u8 = v1->i128 > v2->i8;
2680 break;
2681 case PSI_T_UINT8:
2682 res->u8 = v1->i128 > v2->u8;
2683 break;
2684 case PSI_T_INT16:
2685 res->u8 = v1->i128 > v2->i16;
2686 break;
2687 case PSI_T_UINT16:
2688 res->u8 = v1->i128 > v2->u16;
2689 break;
2690 case PSI_T_INT32:
2691 res->u8 = v1->i128 > v2->i32;
2692 break;
2693 case PSI_T_UINT32:
2694 res->u8 = v1->i128 > v2->u32;
2695 break;
2696 case PSI_T_INT64:
2697 res->u8 = v1->i128 > v2->i64;
2698 break;
2699 case PSI_T_UINT64:
2700 res->u8 = v1->i128 > v2->u64;
2701 break;
2702 # if HAVE_INT128
2703 case PSI_T_INT128:
2704 res->u8 = v1->i128 > v2->i128;
2705 break;
2706 # endif
2707
2708 # if HAVE_UINT128
2709 case PSI_T_UINT128:
2710 res->u8 = v1->i128 > v2->u128;
2711 break;
2712 # endif
2713
2714 case PSI_T_FLOAT:
2715 res->u8 = v1->i128 > v2->fval;
2716 break;
2717 case PSI_T_DOUBLE:
2718 res->u8 = v1->i128 > v2->dval;
2719 break;
2720 # if HAVE_LONG_DOUBLE
2721 case PSI_T_LONG_DOUBLE:
2722 res->u8 = v1->i128 > v2->ldval;
2723 break;
2724 # endif
2725
2726 default:
2727 assert(0);
2728 break;
2729 }
2730 break;
2731 #endif
2732
2733 #if HAVE_UINT128
2734 case PSI_T_UINT128:
2735 switch (t2) {
2736 case PSI_T_INT8:
2737 res->u8 = v1->u128 > v2->i8;
2738 break;
2739 case PSI_T_UINT8:
2740 res->u8 = v1->u128 > v2->u8;
2741 break;
2742 case PSI_T_INT16:
2743 res->u8 = v1->u128 > v2->i16;
2744 break;
2745 case PSI_T_UINT16:
2746 res->u8 = v1->u128 > v2->u16;
2747 break;
2748 case PSI_T_INT32:
2749 res->u8 = v1->u128 > v2->i32;
2750 break;
2751 case PSI_T_UINT32:
2752 res->u8 = v1->u128 > v2->u32;
2753 break;
2754 case PSI_T_INT64:
2755 res->u8 = v1->u128 > v2->i64;
2756 break;
2757 case PSI_T_UINT64:
2758 res->u8 = v1->u128 > v2->u64;
2759 break;
2760 # if HAVE_INT128
2761 case PSI_T_INT128:
2762 res->u8 = v1->u128 > v2->i128;
2763 break;
2764 # endif
2765
2766 # if HAVE_UINT128
2767 case PSI_T_UINT128:
2768 res->u8 = v1->u128 > v2->u128;
2769 break;
2770 # endif
2771
2772 case PSI_T_FLOAT:
2773 res->u8 = v1->u128 > v2->fval;
2774 break;
2775 case PSI_T_DOUBLE:
2776 res->u8 = v1->u128 > v2->dval;
2777 break;
2778 # if HAVE_LONG_DOUBLE
2779 case PSI_T_LONG_DOUBLE:
2780 res->u8 = v1->u128 > v2->ldval;
2781 break;
2782 # endif
2783
2784 default:
2785 assert(0);
2786 break;
2787 }
2788 break;
2789 #endif
2790
2791 case PSI_T_FLOAT:
2792 switch (t2) {
2793 case PSI_T_INT8:
2794 res->u8 = v1->fval > v2->i8;
2795 break;
2796 case PSI_T_UINT8:
2797 res->u8 = v1->fval > v2->u8;
2798 break;
2799 case PSI_T_INT16:
2800 res->u8 = v1->fval > v2->i16;
2801 break;
2802 case PSI_T_UINT16:
2803 res->u8 = v1->fval > v2->u16;
2804 break;
2805 case PSI_T_INT32:
2806 res->u8 = v1->fval > v2->i32;
2807 break;
2808 case PSI_T_UINT32:
2809 res->u8 = v1->fval > v2->u32;
2810 break;
2811 case PSI_T_INT64:
2812 res->u8 = v1->fval > v2->i64;
2813 break;
2814 case PSI_T_UINT64:
2815 res->u8 = v1->fval > v2->u64;
2816 break;
2817 # if HAVE_INT128
2818 case PSI_T_INT128:
2819 res->u8 = v1->fval > v2->i128;
2820 break;
2821 # endif
2822
2823 # if HAVE_UINT128
2824 case PSI_T_UINT128:
2825 res->u8 = v1->fval > v2->u128;
2826 break;
2827 # endif
2828
2829 case PSI_T_FLOAT:
2830 res->u8 = v1->fval > v2->fval;
2831 break;
2832 case PSI_T_DOUBLE:
2833 res->u8 = v1->fval > v2->dval;
2834 break;
2835 # if HAVE_LONG_DOUBLE
2836 case PSI_T_LONG_DOUBLE:
2837 res->u8 = v1->fval > v2->ldval;
2838 break;
2839 # endif
2840
2841 default:
2842 assert(0);
2843 break;
2844 }
2845 break;
2846 case PSI_T_DOUBLE:
2847 switch (t2) {
2848 case PSI_T_INT8:
2849 res->u8 = v1->dval > v2->i8;
2850 break;
2851 case PSI_T_UINT8:
2852 res->u8 = v1->dval > v2->u8;
2853 break;
2854 case PSI_T_INT16:
2855 res->u8 = v1->dval > v2->i16;
2856 break;
2857 case PSI_T_UINT16:
2858 res->u8 = v1->dval > v2->u16;
2859 break;
2860 case PSI_T_INT32:
2861 res->u8 = v1->dval > v2->i32;
2862 break;
2863 case PSI_T_UINT32:
2864 res->u8 = v1->dval > v2->u32;
2865 break;
2866 case PSI_T_INT64:
2867 res->u8 = v1->dval > v2->i64;
2868 break;
2869 case PSI_T_UINT64:
2870 res->u8 = v1->dval > v2->u64;
2871 break;
2872 # if HAVE_INT128
2873 case PSI_T_INT128:
2874 res->u8 = v1->dval > v2->i128;
2875 break;
2876 # endif
2877
2878 # if HAVE_UINT128
2879 case PSI_T_UINT128:
2880 res->u8 = v1->dval > v2->u128;
2881 break;
2882 # endif
2883
2884 case PSI_T_FLOAT:
2885 res->u8 = v1->dval > v2->fval;
2886 break;
2887 case PSI_T_DOUBLE:
2888 res->u8 = v1->dval > v2->dval;
2889 break;
2890 # if HAVE_LONG_DOUBLE
2891 case PSI_T_LONG_DOUBLE:
2892 res->u8 = v1->dval > v2->ldval;
2893 break;
2894 # endif
2895
2896 default:
2897 assert(0);
2898 break;
2899 }
2900 break;
2901 #if HAVE_LONG_DOUBLE
2902 case PSI_T_LONG_DOUBLE:
2903 switch (t2) {
2904 case PSI_T_INT8:
2905 res->u8 = v1->ldval > v2->i8;
2906 break;
2907 case PSI_T_UINT8:
2908 res->u8 = v1->ldval > v2->u8;
2909 break;
2910 case PSI_T_INT16:
2911 res->u8 = v1->ldval > v2->i16;
2912 break;
2913 case PSI_T_UINT16:
2914 res->u8 = v1->ldval > v2->u16;
2915 break;
2916 case PSI_T_INT32:
2917 res->u8 = v1->ldval > v2->i32;
2918 break;
2919 case PSI_T_UINT32:
2920 res->u8 = v1->ldval > v2->u32;
2921 break;
2922 case PSI_T_INT64:
2923 res->u8 = v1->ldval > v2->i64;
2924 break;
2925 case PSI_T_UINT64:
2926 res->u8 = v1->ldval > v2->u64;
2927 break;
2928 # if HAVE_INT128
2929 case PSI_T_INT128:
2930 res->u8 = v1->ldval > v2->i128;
2931 break;
2932 # endif
2933
2934 # if HAVE_UINT128
2935 case PSI_T_UINT128:
2936 res->u8 = v1->ldval > v2->u128;
2937 break;
2938 # endif
2939
2940 case PSI_T_FLOAT:
2941 res->u8 = v1->ldval > v2->fval;
2942 break;
2943 case PSI_T_DOUBLE:
2944 res->u8 = v1->ldval > v2->dval;
2945 break;
2946 # if HAVE_LONG_DOUBLE
2947 case PSI_T_LONG_DOUBLE:
2948 res->u8 = v1->ldval > v2->ldval;
2949 break;
2950 # endif
2951
2952 default:
2953 assert(0);
2954 break;
2955 }
2956 break;
2957 #endif
2958
2959 default:
2960 assert(0);
2961 break;
2962 }
2963 return PSI_T_UINT8;
2964 }
2965
2966 static inline token_t psi_calc_cmp_le(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
2967 {
2968 switch (t1) {
2969 case PSI_T_INT8:
2970 switch (t2) {
2971 case PSI_T_INT8:
2972 res->u8 = v1->i8 <= v2->i8;
2973 break;
2974 case PSI_T_UINT8:
2975 res->u8 = v1->i8 <= v2->u8;
2976 break;
2977 case PSI_T_INT16:
2978 res->u8 = v1->i8 <= v2->i16;
2979 break;
2980 case PSI_T_UINT16:
2981 res->u8 = v1->i8 <= v2->u16;
2982 break;
2983 case PSI_T_INT32:
2984 res->u8 = v1->i8 <= v2->i32;
2985 break;
2986 case PSI_T_UINT32:
2987 res->u8 = v1->i8 <= v2->u32;
2988 break;
2989 case PSI_T_INT64:
2990 res->u8 = v1->i8 <= v2->i64;
2991 break;
2992 case PSI_T_UINT64:
2993 res->u8 = v1->i8 <= v2->u64;
2994 break;
2995 # if HAVE_INT128
2996 case PSI_T_INT128:
2997 res->u8 = v1->i8 <= v2->i128;
2998 break;
2999 # endif
3000
3001 # if HAVE_UINT128
3002 case PSI_T_UINT128:
3003 res->u8 = v1->i8 <= v2->u128;
3004 break;
3005 # endif
3006
3007 case PSI_T_FLOAT:
3008 res->u8 = v1->i8 <= v2->fval;
3009 break;
3010 case PSI_T_DOUBLE:
3011 res->u8 = v1->i8 <= v2->dval;
3012 break;
3013 # if HAVE_LONG_DOUBLE
3014 case PSI_T_LONG_DOUBLE:
3015 res->u8 = v1->i8 <= v2->ldval;
3016 break;
3017 # endif
3018
3019 default:
3020 assert(0);
3021 break;
3022 }
3023 break;
3024 case PSI_T_UINT8:
3025 switch (t2) {
3026 case PSI_T_INT8:
3027 res->u8 = v1->u8 <= v2->i8;
3028 break;
3029 case PSI_T_UINT8:
3030 res->u8 = v1->u8 <= v2->u8;
3031 break;
3032 case PSI_T_INT16:
3033 res->u8 = v1->u8 <= v2->i16;
3034 break;
3035 case PSI_T_UINT16:
3036 res->u8 = v1->u8 <= v2->u16;
3037 break;
3038 case PSI_T_INT32:
3039 res->u8 = v1->u8 <= v2->i32;
3040 break;
3041 case PSI_T_UINT32:
3042 res->u8 = v1->u8 <= v2->u32;
3043 break;
3044 case PSI_T_INT64:
3045 res->u8 = v1->u8 <= v2->i64;
3046 break;
3047 case PSI_T_UINT64:
3048 res->u8 = v1->u8 <= v2->u64;
3049 break;
3050 # if HAVE_INT128
3051 case PSI_T_INT128:
3052 res->u8 = v1->u8 <= v2->i128;
3053 break;
3054 # endif
3055
3056 # if HAVE_UINT128
3057 case PSI_T_UINT128:
3058 res->u8 = v1->u8 <= v2->u128;
3059 break;
3060 # endif
3061
3062 case PSI_T_FLOAT:
3063 res->u8 = v1->u8 <= v2->fval;
3064 break;
3065 case PSI_T_DOUBLE:
3066 res->u8 = v1->u8 <= v2->dval;
3067 break;
3068 # if HAVE_LONG_DOUBLE
3069 case PSI_T_LONG_DOUBLE:
3070 res->u8 = v1->u8 <= v2->ldval;
3071 break;
3072 # endif
3073
3074 default:
3075 assert(0);
3076 break;
3077 }
3078 break;
3079 case PSI_T_INT16:
3080 switch (t2) {
3081 case PSI_T_INT8:
3082 res->u8 = v1->i16 <= v2->i8;
3083 break;
3084 case PSI_T_UINT8:
3085 res->u8 = v1->i16 <= v2->u8;
3086 break;
3087 case PSI_T_INT16:
3088 res->u8 = v1->i16 <= v2->i16;
3089 break;
3090 case PSI_T_UINT16:
3091 res->u8 = v1->i16 <= v2->u16;
3092 break;
3093 case PSI_T_INT32:
3094 res->u8 = v1->i16 <= v2->i32;
3095 break;
3096 case PSI_T_UINT32:
3097 res->u8 = v1->i16 <= v2->u32;
3098 break;
3099 case PSI_T_INT64:
3100 res->u8 = v1->i16 <= v2->i64;
3101 break;
3102 case PSI_T_UINT64:
3103 res->u8 = v1->i16 <= v2->u64;
3104 break;
3105 # if HAVE_INT128
3106 case PSI_T_INT128:
3107 res->u8 = v1->i16 <= v2->i128;
3108 break;
3109 # endif
3110
3111 # if HAVE_UINT128
3112 case PSI_T_UINT128:
3113 res->u8 = v1->i16 <= v2->u128;
3114 break;
3115 # endif
3116
3117 case PSI_T_FLOAT:
3118 res->u8 = v1->i16 <= v2->fval;
3119 break;
3120 case PSI_T_DOUBLE:
3121 res->u8 = v1->i16 <= v2->dval;
3122 break;
3123 # if HAVE_LONG_DOUBLE
3124 case PSI_T_LONG_DOUBLE:
3125 res->u8 = v1->i16 <= v2->ldval;
3126 break;
3127 # endif
3128
3129 default:
3130 assert(0);
3131 break;
3132 }
3133 break;
3134 case PSI_T_UINT16:
3135 switch (t2) {
3136 case PSI_T_INT8:
3137 res->u8 = v1->u16 <= v2->i8;
3138 break;
3139 case PSI_T_UINT8:
3140 res->u8 = v1->u16 <= v2->u8;
3141 break;
3142 case PSI_T_INT16:
3143 res->u8 = v1->u16 <= v2->i16;
3144 break;
3145 case PSI_T_UINT16:
3146 res->u8 = v1->u16 <= v2->u16;
3147 break;
3148 case PSI_T_INT32:
3149 res->u8 = v1->u16 <= v2->i32;
3150 break;
3151 case PSI_T_UINT32:
3152 res->u8 = v1->u16 <= v2->u32;
3153 break;
3154 case PSI_T_INT64:
3155 res->u8 = v1->u16 <= v2->i64;
3156 break;
3157 case PSI_T_UINT64:
3158 res->u8 = v1->u16 <= v2->u64;
3159 break;
3160 # if HAVE_INT128
3161 case PSI_T_INT128:
3162 res->u8 = v1->u16 <= v2->i128;
3163 break;
3164 # endif
3165
3166 # if HAVE_UINT128
3167 case PSI_T_UINT128:
3168 res->u8 = v1->u16 <= v2->u128;
3169 break;
3170 # endif
3171
3172 case PSI_T_FLOAT:
3173 res->u8 = v1->u16 <= v2->fval;
3174 break;
3175 case PSI_T_DOUBLE:
3176 res->u8 = v1->u16 <= v2->dval;
3177 break;
3178 # if HAVE_LONG_DOUBLE
3179 case PSI_T_LONG_DOUBLE:
3180 res->u8 = v1->u16 <= v2->ldval;
3181 break;
3182 # endif
3183
3184 default:
3185 assert(0);
3186 break;
3187 }
3188 break;
3189 case PSI_T_INT32:
3190 switch (t2) {
3191 case PSI_T_INT8:
3192 res->u8 = v1->i32 <= v2->i8;
3193 break;
3194 case PSI_T_UINT8:
3195 res->u8 = v1->i32 <= v2->u8;
3196 break;
3197 case PSI_T_INT16:
3198 res->u8 = v1->i32 <= v2->i16;
3199 break;
3200 case PSI_T_UINT16:
3201 res->u8 = v1->i32 <= v2->u16;
3202 break;
3203 case PSI_T_INT32:
3204 res->u8 = v1->i32 <= v2->i32;
3205 break;
3206 case PSI_T_UINT32:
3207 res->u8 = v1->i32 <= v2->u32;
3208 break;
3209 case PSI_T_INT64:
3210 res->u8 = v1->i32 <= v2->i64;
3211 break;
3212 case PSI_T_UINT64:
3213 res->u8 = v1->i32 <= v2->u64;
3214 break;
3215 # if HAVE_INT128
3216 case PSI_T_INT128:
3217 res->u8 = v1->i32 <= v2->i128;
3218 break;
3219 # endif
3220
3221 # if HAVE_UINT128
3222 case PSI_T_UINT128:
3223 res->u8 = v1->i32 <= v2->u128;
3224 break;
3225 # endif
3226
3227 case PSI_T_FLOAT:
3228 res->u8 = v1->i32 <= v2->fval;
3229 break;
3230 case PSI_T_DOUBLE:
3231 res->u8 = v1->i32 <= v2->dval;
3232 break;
3233 # if HAVE_LONG_DOUBLE
3234 case PSI_T_LONG_DOUBLE:
3235 res->u8 = v1->i32 <= v2->ldval;
3236 break;
3237 # endif
3238
3239 default:
3240 assert(0);
3241 break;
3242 }
3243 break;
3244 case PSI_T_UINT32:
3245 switch (t2) {
3246 case PSI_T_INT8:
3247 res->u8 = v1->u32 <= v2->i8;
3248 break;
3249 case PSI_T_UINT8:
3250 res->u8 = v1->u32 <= v2->u8;
3251 break;
3252 case PSI_T_INT16:
3253 res->u8 = v1->u32 <= v2->i16;
3254 break;
3255 case PSI_T_UINT16:
3256 res->u8 = v1->u32 <= v2->u16;
3257 break;
3258 case PSI_T_INT32:
3259 res->u8 = v1->u32 <= v2->i32;
3260 break;
3261 case PSI_T_UINT32:
3262 res->u8 = v1->u32 <= v2->u32;
3263 break;
3264 case PSI_T_INT64:
3265 res->u8 = v1->u32 <= v2->i64;
3266 break;
3267 case PSI_T_UINT64:
3268 res->u8 = v1->u32 <= v2->u64;
3269 break;
3270 # if HAVE_INT128
3271 case PSI_T_INT128:
3272 res->u8 = v1->u32 <= v2->i128;
3273 break;
3274 # endif
3275
3276 # if HAVE_UINT128
3277 case PSI_T_UINT128:
3278 res->u8 = v1->u32 <= v2->u128;
3279 break;
3280 # endif
3281
3282 case PSI_T_FLOAT:
3283 res->u8 = v1->u32 <= v2->fval;
3284 break;
3285 case PSI_T_DOUBLE:
3286 res->u8 = v1->u32 <= v2->dval;
3287 break;
3288 # if HAVE_LONG_DOUBLE
3289 case PSI_T_LONG_DOUBLE:
3290 res->u8 = v1->u32 <= v2->ldval;
3291 break;
3292 # endif
3293
3294 default:
3295 assert(0);
3296 break;
3297 }
3298 break;
3299 case PSI_T_INT64:
3300 switch (t2) {
3301 case PSI_T_INT8:
3302 res->u8 = v1->i64 <= v2->i8;
3303 break;
3304 case PSI_T_UINT8:
3305 res->u8 = v1->i64 <= v2->u8;
3306 break;
3307 case PSI_T_INT16:
3308 res->u8 = v1->i64 <= v2->i16;
3309 break;
3310 case PSI_T_UINT16:
3311 res->u8 = v1->i64 <= v2->u16;
3312 break;
3313 case PSI_T_INT32:
3314 res->u8 = v1->i64 <= v2->i32;
3315 break;
3316 case PSI_T_UINT32:
3317 res->u8 = v1->i64 <= v2->u32;
3318 break;
3319 case PSI_T_INT64:
3320 res->u8 = v1->i64 <= v2->i64;
3321 break;
3322 case PSI_T_UINT64:
3323 res->u8 = v1->i64 <= v2->u64;
3324 break;
3325 # if HAVE_INT128
3326 case PSI_T_INT128:
3327 res->u8 = v1->i64 <= v2->i128;
3328 break;
3329 # endif
3330
3331 # if HAVE_UINT128
3332 case PSI_T_UINT128:
3333 res->u8 = v1->i64 <= v2->u128;
3334 break;
3335 # endif
3336
3337 case PSI_T_FLOAT:
3338 res->u8 = v1->i64 <= v2->fval;
3339 break;
3340 case PSI_T_DOUBLE:
3341 res->u8 = v1->i64 <= v2->dval;
3342 break;
3343 # if HAVE_LONG_DOUBLE
3344 case PSI_T_LONG_DOUBLE:
3345 res->u8 = v1->i64 <= v2->ldval;
3346 break;
3347 # endif
3348
3349 default:
3350 assert(0);
3351 break;
3352 }
3353 break;
3354 case PSI_T_UINT64:
3355 switch (t2) {
3356 case PSI_T_INT8:
3357 res->u8 = v1->u64 <= v2->i8;
3358 break;
3359 case PSI_T_UINT8:
3360 res->u8 = v1->u64 <= v2->u8;
3361 break;
3362 case PSI_T_INT16:
3363 res->u8 = v1->u64 <= v2->i16;
3364 break;
3365 case PSI_T_UINT16:
3366 res->u8 = v1->u64 <= v2->u16;
3367 break;
3368 case PSI_T_INT32:
3369 res->u8 = v1->u64 <= v2->i32;
3370 break;
3371 case PSI_T_UINT32:
3372 res->u8 = v1->u64 <= v2->u32;
3373 break;
3374 case PSI_T_INT64:
3375 res->u8 = v1->u64 <= v2->i64;
3376 break;
3377 case PSI_T_UINT64:
3378 res->u8 = v1->u64 <= v2->u64;
3379 break;
3380 # if HAVE_INT128
3381 case PSI_T_INT128:
3382 res->u8 = v1->u64 <= v2->i128;
3383 break;
3384 # endif
3385
3386 # if HAVE_UINT128
3387 case PSI_T_UINT128:
3388 res->u8 = v1->u64 <= v2->u128;
3389 break;
3390 # endif
3391
3392 case PSI_T_FLOAT:
3393 res->u8 = v1->u64 <= v2->fval;
3394 break;
3395 case PSI_T_DOUBLE:
3396 res->u8 = v1->u64 <= v2->dval;
3397 break;
3398 # if HAVE_LONG_DOUBLE
3399 case PSI_T_LONG_DOUBLE:
3400 res->u8 = v1->u64 <= v2->ldval;
3401 break;
3402 # endif
3403
3404 default:
3405 assert(0);
3406 break;
3407 }
3408 break;
3409 #if HAVE_INT128
3410 case PSI_T_INT128:
3411 switch (t2) {
3412 case PSI_T_INT8:
3413 res->u8 = v1->i128 <= v2->i8;
3414 break;
3415 case PSI_T_UINT8:
3416 res->u8 = v1->i128 <= v2->u8;
3417 break;
3418 case PSI_T_INT16:
3419 res->u8 = v1->i128 <= v2->i16;
3420 break;
3421 case PSI_T_UINT16:
3422 res->u8 = v1->i128 <= v2->u16;
3423 break;
3424 case PSI_T_INT32:
3425 res->u8 = v1->i128 <= v2->i32;
3426 break;
3427 case PSI_T_UINT32:
3428 res->u8 = v1->i128 <= v2->u32;
3429 break;
3430 case PSI_T_INT64:
3431 res->u8 = v1->i128 <= v2->i64;
3432 break;
3433 case PSI_T_UINT64:
3434 res->u8 = v1->i128 <= v2->u64;
3435 break;
3436 # if HAVE_INT128
3437 case PSI_T_INT128:
3438 res->u8 = v1->i128 <= v2->i128;
3439 break;
3440 # endif
3441
3442 # if HAVE_UINT128
3443 case PSI_T_UINT128:
3444 res->u8 = v1->i128 <= v2->u128;
3445 break;
3446 # endif
3447
3448 case PSI_T_FLOAT:
3449 res->u8 = v1->i128 <= v2->fval;
3450 break;
3451 case PSI_T_DOUBLE:
3452 res->u8 = v1->i128 <= v2->dval;
3453 break;
3454 # if HAVE_LONG_DOUBLE
3455 case PSI_T_LONG_DOUBLE:
3456 res->u8 = v1->i128 <= v2->ldval;
3457 break;
3458 # endif
3459
3460 default:
3461 assert(0);
3462 break;
3463 }
3464 break;
3465 #endif
3466
3467 #if HAVE_UINT128
3468 case PSI_T_UINT128:
3469 switch (t2) {
3470 case PSI_T_INT8:
3471 res->u8 = v1->u128 <= v2->i8;
3472 break;
3473 case PSI_T_UINT8:
3474 res->u8 = v1->u128 <= v2->u8;
3475 break;
3476 case PSI_T_INT16:
3477 res->u8 = v1->u128 <= v2->i16;
3478 break;
3479 case PSI_T_UINT16:
3480 res->u8 = v1->u128 <= v2->u16;
3481 break;
3482 case PSI_T_INT32:
3483 res->u8 = v1->u128 <= v2->i32;
3484 break;
3485 case PSI_T_UINT32:
3486 res->u8 = v1->u128 <= v2->u32;
3487 break;
3488 case PSI_T_INT64:
3489 res->u8 = v1->u128 <= v2->i64;
3490 break;
3491 case PSI_T_UINT64:
3492 res->u8 = v1->u128 <= v2->u64;
3493 break;
3494 # if HAVE_INT128
3495 case PSI_T_INT128:
3496 res->u8 = v1->u128 <= v2->i128;
3497 break;
3498 # endif
3499
3500 # if HAVE_UINT128
3501 case PSI_T_UINT128:
3502 res->u8 = v1->u128 <= v2->u128;
3503 break;
3504 # endif
3505
3506 case PSI_T_FLOAT:
3507 res->u8 = v1->u128 <= v2->fval;
3508 break;
3509 case PSI_T_DOUBLE:
3510 res->u8 = v1->u128 <= v2->dval;
3511 break;
3512 # if HAVE_LONG_DOUBLE
3513 case PSI_T_LONG_DOUBLE:
3514 res->u8 = v1->u128 <= v2->ldval;
3515 break;
3516 # endif
3517
3518 default:
3519 assert(0);
3520 break;
3521 }
3522 break;
3523 #endif
3524
3525 case PSI_T_FLOAT:
3526 switch (t2) {
3527 case PSI_T_INT8:
3528 res->u8 = v1->fval <= v2->i8;
3529 break;
3530 case PSI_T_UINT8:
3531 res->u8 = v1->fval <= v2->u8;
3532 break;
3533 case PSI_T_INT16:
3534 res->u8 = v1->fval <= v2->i16;
3535 break;
3536 case PSI_T_UINT16:
3537 res->u8 = v1->fval <= v2->u16;
3538 break;
3539 case PSI_T_INT32:
3540 res->u8 = v1->fval <= v2->i32;
3541 break;
3542 case PSI_T_UINT32:
3543 res->u8 = v1->fval <= v2->u32;
3544 break;
3545 case PSI_T_INT64:
3546 res->u8 = v1->fval <= v2->i64;
3547 break;
3548 case PSI_T_UINT64:
3549 res->u8 = v1->fval <= v2->u64;
3550 break;
3551 # if HAVE_INT128
3552 case PSI_T_INT128:
3553 res->u8 = v1->fval <= v2->i128;
3554 break;
3555 # endif
3556
3557 # if HAVE_UINT128
3558 case PSI_T_UINT128:
3559 res->u8 = v1->fval <= v2->u128;
3560 break;
3561 # endif
3562
3563 case PSI_T_FLOAT:
3564 res->u8 = v1->fval <= v2->fval;
3565 break;
3566 case PSI_T_DOUBLE:
3567 res->u8 = v1->fval <= v2->dval;
3568 break;
3569 # if HAVE_LONG_DOUBLE
3570 case PSI_T_LONG_DOUBLE:
3571 res->u8 = v1->fval <= v2->ldval;
3572 break;
3573 # endif
3574
3575 default:
3576 assert(0);
3577 break;
3578 }
3579 break;
3580 case PSI_T_DOUBLE:
3581 switch (t2) {
3582 case PSI_T_INT8:
3583 res->u8 = v1->dval <= v2->i8;
3584 break;
3585 case PSI_T_UINT8:
3586 res->u8 = v1->dval <= v2->u8;
3587 break;
3588 case PSI_T_INT16:
3589 res->u8 = v1->dval <= v2->i16;
3590 break;
3591 case PSI_T_UINT16:
3592 res->u8 = v1->dval <= v2->u16;
3593 break;
3594 case PSI_T_INT32:
3595 res->u8 = v1->dval <= v2->i32;
3596 break;
3597 case PSI_T_UINT32:
3598 res->u8 = v1->dval <= v2->u32;
3599 break;
3600 case PSI_T_INT64:
3601 res->u8 = v1->dval <= v2->i64;
3602 break;
3603 case PSI_T_UINT64:
3604 res->u8 = v1->dval <= v2->u64;
3605 break;
3606 # if HAVE_INT128
3607 case PSI_T_INT128:
3608 res->u8 = v1->dval <= v2->i128;
3609 break;
3610 # endif
3611
3612 # if HAVE_UINT128
3613 case PSI_T_UINT128:
3614 res->u8 = v1->dval <= v2->u128;
3615 break;
3616 # endif
3617
3618 case PSI_T_FLOAT:
3619 res->u8 = v1->dval <= v2->fval;
3620 break;
3621 case PSI_T_DOUBLE:
3622 res->u8 = v1->dval <= v2->dval;
3623 break;
3624 # if HAVE_LONG_DOUBLE
3625 case PSI_T_LONG_DOUBLE:
3626 res->u8 = v1->dval <= v2->ldval;
3627 break;
3628 # endif
3629
3630 default:
3631 assert(0);
3632 break;
3633 }
3634 break;
3635 #if HAVE_LONG_DOUBLE
3636 case PSI_T_LONG_DOUBLE:
3637 switch (t2) {
3638 case PSI_T_INT8:
3639 res->u8 = v1->ldval <= v2->i8;
3640 break;
3641 case PSI_T_UINT8:
3642 res->u8 = v1->ldval <= v2->u8;
3643 break;
3644 case PSI_T_INT16:
3645 res->u8 = v1->ldval <= v2->i16;
3646 break;
3647 case PSI_T_UINT16:
3648 res->u8 = v1->ldval <= v2->u16;
3649 break;
3650 case PSI_T_INT32:
3651 res->u8 = v1->ldval <= v2->i32;
3652 break;
3653 case PSI_T_UINT32:
3654 res->u8 = v1->ldval <= v2->u32;
3655 break;
3656 case PSI_T_INT64:
3657 res->u8 = v1->ldval <= v2->i64;
3658 break;
3659 case PSI_T_UINT64:
3660 res->u8 = v1->ldval <= v2->u64;
3661 break;
3662 # if HAVE_INT128
3663 case PSI_T_INT128:
3664 res->u8 = v1->ldval <= v2->i128;
3665 break;
3666 # endif
3667
3668 # if HAVE_UINT128
3669 case PSI_T_UINT128:
3670 res->u8 = v1->ldval <= v2->u128;
3671 break;
3672 # endif
3673
3674 case PSI_T_FLOAT:
3675 res->u8 = v1->ldval <= v2->fval;
3676 break;
3677 case PSI_T_DOUBLE:
3678 res->u8 = v1->ldval <= v2->dval;
3679 break;
3680 # if HAVE_LONG_DOUBLE
3681 case PSI_T_LONG_DOUBLE:
3682 res->u8 = v1->ldval <= v2->ldval;
3683 break;
3684 # endif
3685
3686 default:
3687 assert(0);
3688 break;
3689 }
3690 break;
3691 #endif
3692
3693 default:
3694 assert(0);
3695 break;
3696 }
3697 return PSI_T_UINT8;
3698 }
3699
3700 static inline token_t psi_calc_cmp_ge(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
3701 {
3702 switch (t1) {
3703 case PSI_T_INT8:
3704 switch (t2) {
3705 case PSI_T_INT8:
3706 res->u8 = v1->i8 >= v2->i8;
3707 break;
3708 case PSI_T_UINT8:
3709 res->u8 = v1->i8 >= v2->u8;
3710 break;
3711 case PSI_T_INT16:
3712 res->u8 = v1->i8 >= v2->i16;
3713 break;
3714 case PSI_T_UINT16:
3715 res->u8 = v1->i8 >= v2->u16;
3716 break;
3717 case PSI_T_INT32:
3718 res->u8 = v1->i8 >= v2->i32;
3719 break;
3720 case PSI_T_UINT32:
3721 res->u8 = v1->i8 >= v2->u32;
3722 break;
3723 case PSI_T_INT64:
3724 res->u8 = v1->i8 >= v2->i64;
3725 break;
3726 case PSI_T_UINT64:
3727 res->u8 = v1->i8 >= v2->u64;
3728 break;
3729 # if HAVE_INT128
3730 case PSI_T_INT128:
3731 res->u8 = v1->i8 >= v2->i128;
3732 break;
3733 # endif
3734
3735 # if HAVE_UINT128
3736 case PSI_T_UINT128:
3737 res->u8 = v1->i8 >= v2->u128;
3738 break;
3739 # endif
3740
3741 case PSI_T_FLOAT:
3742 res->u8 = v1->i8 >= v2->fval;
3743 break;
3744 case PSI_T_DOUBLE:
3745 res->u8 = v1->i8 >= v2->dval;
3746 break;
3747 # if HAVE_LONG_DOUBLE
3748 case PSI_T_LONG_DOUBLE:
3749 res->u8 = v1->i8 >= v2->ldval;
3750 break;
3751 # endif
3752
3753 default:
3754 assert(0);
3755 break;
3756 }
3757 break;
3758 case PSI_T_UINT8:
3759 switch (t2) {
3760 case PSI_T_INT8:
3761 res->u8 = v1->u8 >= v2->i8;
3762 break;
3763 case PSI_T_UINT8:
3764 res->u8 = v1->u8 >= v2->u8;
3765 break;
3766 case PSI_T_INT16:
3767 res->u8 = v1->u8 >= v2->i16;
3768 break;
3769 case PSI_T_UINT16:
3770 res->u8 = v1->u8 >= v2->u16;
3771 break;
3772 case PSI_T_INT32:
3773 res->u8 = v1->u8 >= v2->i32;
3774 break;
3775 case PSI_T_UINT32:
3776 res->u8 = v1->u8 >= v2->u32;
3777 break;
3778 case PSI_T_INT64:
3779 res->u8 = v1->u8 >= v2->i64;
3780 break;
3781 case PSI_T_UINT64:
3782 res->u8 = v1->u8 >= v2->u64;
3783 break;
3784 # if HAVE_INT128
3785 case PSI_T_INT128:
3786 res->u8 = v1->u8 >= v2->i128;
3787 break;
3788 # endif
3789
3790 # if HAVE_UINT128
3791 case PSI_T_UINT128:
3792 res->u8 = v1->u8 >= v2->u128;
3793 break;
3794 # endif
3795
3796 case PSI_T_FLOAT:
3797 res->u8 = v1->u8 >= v2->fval;
3798 break;
3799 case PSI_T_DOUBLE:
3800 res->u8 = v1->u8 >= v2->dval;
3801 break;
3802 # if HAVE_LONG_DOUBLE
3803 case PSI_T_LONG_DOUBLE:
3804 res->u8 = v1->u8 >= v2->ldval;
3805 break;
3806 # endif
3807
3808 default:
3809 assert(0);
3810 break;
3811 }
3812 break;
3813 case PSI_T_INT16:
3814 switch (t2) {
3815 case PSI_T_INT8:
3816 res->u8 = v1->i16 >= v2->i8;
3817 break;
3818 case PSI_T_UINT8:
3819 res->u8 = v1->i16 >= v2->u8;
3820 break;
3821 case PSI_T_INT16:
3822 res->u8 = v1->i16 >= v2->i16;
3823 break;
3824 case PSI_T_UINT16:
3825 res->u8 = v1->i16 >= v2->u16;
3826 break;
3827 case PSI_T_INT32:
3828 res->u8 = v1->i16 >= v2->i32;
3829 break;
3830 case PSI_T_UINT32:
3831 res->u8 = v1->i16 >= v2->u32;
3832 break;
3833 case PSI_T_INT64:
3834 res->u8 = v1->i16 >= v2->i64;
3835 break;
3836 case PSI_T_UINT64:
3837 res->u8 = v1->i16 >= v2->u64;
3838 break;
3839 # if HAVE_INT128
3840 case PSI_T_INT128:
3841 res->u8 = v1->i16 >= v2->i128;
3842 break;
3843 # endif
3844
3845 # if HAVE_UINT128
3846 case PSI_T_UINT128:
3847 res->u8 = v1->i16 >= v2->u128;
3848 break;
3849 # endif
3850
3851 case PSI_T_FLOAT:
3852 res->u8 = v1->i16 >= v2->fval;
3853 break;
3854 case PSI_T_DOUBLE:
3855 res->u8 = v1->i16 >= v2->dval;
3856 break;
3857 # if HAVE_LONG_DOUBLE
3858 case PSI_T_LONG_DOUBLE:
3859 res->u8 = v1->i16 >= v2->ldval;
3860 break;
3861 # endif
3862
3863 default:
3864 assert(0);
3865 break;
3866 }
3867 break;
3868 case PSI_T_UINT16:
3869 switch (t2) {
3870 case PSI_T_INT8:
3871 res->u8 = v1->u16 >= v2->i8;
3872 break;
3873 case PSI_T_UINT8:
3874 res->u8 = v1->u16 >= v2->u8;
3875 break;
3876 case PSI_T_INT16:
3877 res->u8 = v1->u16 >= v2->i16;
3878 break;
3879 case PSI_T_UINT16:
3880 res->u8 = v1->u16 >= v2->u16;
3881 break;
3882 case PSI_T_INT32:
3883 res->u8 = v1->u16 >= v2->i32;
3884 break;
3885 case PSI_T_UINT32:
3886 res->u8 = v1->u16 >= v2->u32;
3887 break;
3888 case PSI_T_INT64:
3889 res->u8 = v1->u16 >= v2->i64;
3890 break;
3891 case PSI_T_UINT64:
3892 res->u8 = v1->u16 >= v2->u64;
3893 break;
3894 # if HAVE_INT128
3895 case PSI_T_INT128:
3896 res->u8 = v1->u16 >= v2->i128;
3897 break;
3898 # endif
3899
3900 # if HAVE_UINT128
3901 case PSI_T_UINT128:
3902 res->u8 = v1->u16 >= v2->u128;
3903 break;
3904 # endif
3905
3906 case PSI_T_FLOAT:
3907 res->u8 = v1->u16 >= v2->fval;
3908 break;
3909 case PSI_T_DOUBLE:
3910 res->u8 = v1->u16 >= v2->dval;
3911 break;
3912 # if HAVE_LONG_DOUBLE
3913 case PSI_T_LONG_DOUBLE:
3914 res->u8 = v1->u16 >= v2->ldval;
3915 break;
3916 # endif
3917
3918 default:
3919 assert(0);
3920 break;
3921 }
3922 break;
3923 case PSI_T_INT32:
3924 switch (t2) {
3925 case PSI_T_INT8:
3926 res->u8 = v1->i32 >= v2->i8;
3927 break;
3928 case PSI_T_UINT8:
3929 res->u8 = v1->i32 >= v2->u8;
3930 break;
3931 case PSI_T_INT16:
3932 res->u8 = v1->i32 >= v2->i16;
3933 break;
3934 case PSI_T_UINT16:
3935 res->u8 = v1->i32 >= v2->u16;
3936 break;
3937 case PSI_T_INT32:
3938 res->u8 = v1->i32 >= v2->i32;
3939 break;
3940 case PSI_T_UINT32:
3941 res->u8 = v1->i32 >= v2->u32;
3942 break;
3943 case PSI_T_INT64:
3944 res->u8 = v1->i32 >= v2->i64;
3945 break;
3946 case PSI_T_UINT64:
3947 res->u8 = v1->i32 >= v2->u64;
3948 break;
3949 # if HAVE_INT128
3950 case PSI_T_INT128:
3951 res->u8 = v1->i32 >= v2->i128;
3952 break;
3953 # endif
3954
3955 # if HAVE_UINT128
3956 case PSI_T_UINT128:
3957 res->u8 = v1->i32 >= v2->u128;
3958 break;
3959 # endif
3960
3961 case PSI_T_FLOAT:
3962 res->u8 = v1->i32 >= v2->fval;
3963 break;
3964 case PSI_T_DOUBLE:
3965 res->u8 = v1->i32 >= v2->dval;
3966 break;
3967 # if HAVE_LONG_DOUBLE
3968 case PSI_T_LONG_DOUBLE:
3969 res->u8 = v1->i32 >= v2->ldval;
3970 break;
3971 # endif
3972
3973 default:
3974 assert(0);
3975 break;
3976 }
3977 break;
3978 case PSI_T_UINT32:
3979 switch (t2) {
3980 case PSI_T_INT8:
3981 res->u8 = v1->u32 >= v2->i8;
3982 break;
3983 case PSI_T_UINT8:
3984 res->u8 = v1->u32 >= v2->u8;
3985 break;
3986 case PSI_T_INT16:
3987 res->u8 = v1->u32 >= v2->i16;
3988 break;
3989 case PSI_T_UINT16:
3990 res->u8 = v1->u32 >= v2->u16;
3991 break;
3992 case PSI_T_INT32:
3993 res->u8 = v1->u32 >= v2->i32;
3994 break;
3995 case PSI_T_UINT32:
3996 res->u8 = v1->u32 >= v2->u32;
3997 break;
3998 case PSI_T_INT64:
3999 res->u8 = v1->u32 >= v2->i64;
4000 break;
4001 case PSI_T_UINT64:
4002 res->u8 = v1->u32 >= v2->u64;
4003 break;
4004 # if HAVE_INT128
4005 case PSI_T_INT128:
4006 res->u8 = v1->u32 >= v2->i128;
4007 break;
4008 # endif
4009
4010 # if HAVE_UINT128
4011 case PSI_T_UINT128:
4012 res->u8 = v1->u32 >= v2->u128;
4013 break;
4014 # endif
4015
4016 case PSI_T_FLOAT:
4017 res->u8 = v1->u32 >= v2->fval;
4018 break;
4019 case PSI_T_DOUBLE:
4020 res->u8 = v1->u32 >= v2->dval;
4021 break;
4022 # if HAVE_LONG_DOUBLE
4023 case PSI_T_LONG_DOUBLE:
4024 res->u8 = v1->u32 >= v2->ldval;
4025 break;
4026 # endif
4027
4028 default:
4029 assert(0);
4030 break;
4031 }
4032 break;
4033 case PSI_T_INT64:
4034 switch (t2) {
4035 case PSI_T_INT8:
4036 res->u8 = v1->i64 >= v2->i8;
4037 break;
4038 case PSI_T_UINT8:
4039 res->u8 = v1->i64 >= v2->u8;
4040 break;
4041 case PSI_T_INT16:
4042 res->u8 = v1->i64 >= v2->i16;
4043 break;
4044 case PSI_T_UINT16:
4045 res->u8 = v1->i64 >= v2->u16;
4046 break;
4047 case PSI_T_INT32:
4048 res->u8 = v1->i64 >= v2->i32;
4049 break;
4050 case PSI_T_UINT32:
4051 res->u8 = v1->i64 >= v2->u32;
4052 break;
4053 case PSI_T_INT64:
4054 res->u8 = v1->i64 >= v2->i64;
4055 break;
4056 case PSI_T_UINT64:
4057 res->u8 = v1->i64 >= v2->u64;
4058 break;
4059 # if HAVE_INT128
4060 case PSI_T_INT128:
4061 res->u8 = v1->i64 >= v2->i128;
4062 break;
4063 # endif
4064
4065 # if HAVE_UINT128
4066 case PSI_T_UINT128:
4067 res->u8 = v1->i64 >= v2->u128;
4068 break;
4069 # endif
4070
4071 case PSI_T_FLOAT:
4072 res->u8 = v1->i64 >= v2->fval;
4073 break;
4074 case PSI_T_DOUBLE:
4075 res->u8 = v1->i64 >= v2->dval;
4076 break;
4077 # if HAVE_LONG_DOUBLE
4078 case PSI_T_LONG_DOUBLE:
4079 res->u8 = v1->i64 >= v2->ldval;
4080 break;
4081 # endif
4082
4083 default:
4084 assert(0);
4085 break;
4086 }
4087 break;
4088 case PSI_T_UINT64:
4089 switch (t2) {
4090 case PSI_T_INT8:
4091 res->u8 = v1->u64 >= v2->i8;
4092 break;
4093 case PSI_T_UINT8:
4094 res->u8 = v1->u64 >= v2->u8;
4095 break;
4096 case PSI_T_INT16:
4097 res->u8 = v1->u64 >= v2->i16;
4098 break;
4099 case PSI_T_UINT16:
4100 res->u8 = v1->u64 >= v2->u16;
4101 break;
4102 case PSI_T_INT32:
4103 res->u8 = v1->u64 >= v2->i32;
4104 break;
4105 case PSI_T_UINT32:
4106 res->u8 = v1->u64 >= v2->u32;
4107 break;
4108 case PSI_T_INT64:
4109 res->u8 = v1->u64 >= v2->i64;
4110 break;
4111 case PSI_T_UINT64:
4112 res->u8 = v1->u64 >= v2->u64;
4113 break;
4114 # if HAVE_INT128
4115 case PSI_T_INT128:
4116 res->u8 = v1->u64 >= v2->i128;
4117 break;
4118 # endif
4119
4120 # if HAVE_UINT128
4121 case PSI_T_UINT128:
4122 res->u8 = v1->u64 >= v2->u128;
4123 break;
4124 # endif
4125
4126 case PSI_T_FLOAT:
4127 res->u8 = v1->u64 >= v2->fval;
4128 break;
4129 case PSI_T_DOUBLE:
4130 res->u8 = v1->u64 >= v2->dval;
4131 break;
4132 # if HAVE_LONG_DOUBLE
4133 case PSI_T_LONG_DOUBLE:
4134 res->u8 = v1->u64 >= v2->ldval;
4135 break;
4136 # endif
4137
4138 default:
4139 assert(0);
4140 break;
4141 }
4142 break;
4143 #if HAVE_INT128
4144 case PSI_T_INT128:
4145 switch (t2) {
4146 case PSI_T_INT8:
4147 res->u8 = v1->i128 >= v2->i8;
4148 break;
4149 case PSI_T_UINT8:
4150 res->u8 = v1->i128 >= v2->u8;
4151 break;
4152 case PSI_T_INT16:
4153 res->u8 = v1->i128 >= v2->i16;
4154 break;
4155 case PSI_T_UINT16:
4156 res->u8 = v1->i128 >= v2->u16;
4157 break;
4158 case PSI_T_INT32:
4159 res->u8 = v1->i128 >= v2->i32;
4160 break;
4161 case PSI_T_UINT32:
4162 res->u8 = v1->i128 >= v2->u32;
4163 break;
4164 case PSI_T_INT64:
4165 res->u8 = v1->i128 >= v2->i64;
4166 break;
4167 case PSI_T_UINT64:
4168 res->u8 = v1->i128 >= v2->u64;
4169 break;
4170 # if HAVE_INT128
4171 case PSI_T_INT128:
4172 res->u8 = v1->i128 >= v2->i128;
4173 break;
4174 # endif
4175
4176 # if HAVE_UINT128
4177 case PSI_T_UINT128:
4178 res->u8 = v1->i128 >= v2->u128;
4179 break;
4180 # endif
4181
4182 case PSI_T_FLOAT:
4183 res->u8 = v1->i128 >= v2->fval;
4184 break;
4185 case PSI_T_DOUBLE:
4186 res->u8 = v1->i128 >= v2->dval;
4187 break;
4188 # if HAVE_LONG_DOUBLE
4189 case PSI_T_LONG_DOUBLE:
4190 res->u8 = v1->i128 >= v2->ldval;
4191 break;
4192 # endif
4193
4194 default:
4195 assert(0);
4196 break;
4197 }
4198 break;
4199 #endif
4200
4201 #if HAVE_UINT128
4202 case PSI_T_UINT128:
4203 switch (t2) {
4204 case PSI_T_INT8:
4205 res->u8 = v1->u128 >= v2->i8;
4206 break;
4207 case PSI_T_UINT8:
4208 res->u8 = v1->u128 >= v2->u8;
4209 break;
4210 case PSI_T_INT16:
4211 res->u8 = v1->u128 >= v2->i16;
4212 break;
4213 case PSI_T_UINT16:
4214 res->u8 = v1->u128 >= v2->u16;
4215 break;
4216 case PSI_T_INT32:
4217 res->u8 = v1->u128 >= v2->i32;
4218 break;
4219 case PSI_T_UINT32:
4220 res->u8 = v1->u128 >= v2->u32;
4221 break;
4222 case PSI_T_INT64:
4223 res->u8 = v1->u128 >= v2->i64;
4224 break;
4225 case PSI_T_UINT64:
4226 res->u8 = v1->u128 >= v2->u64;
4227 break;
4228 # if HAVE_INT128
4229 case PSI_T_INT128:
4230 res->u8 = v1->u128 >= v2->i128;
4231 break;
4232 # endif
4233
4234 # if HAVE_UINT128
4235 case PSI_T_UINT128:
4236 res->u8 = v1->u128 >= v2->u128;
4237 break;
4238 # endif
4239
4240 case PSI_T_FLOAT:
4241 res->u8 = v1->u128 >= v2->fval;
4242 break;
4243 case PSI_T_DOUBLE:
4244 res->u8 = v1->u128 >= v2->dval;
4245 break;
4246 # if HAVE_LONG_DOUBLE
4247 case PSI_T_LONG_DOUBLE:
4248 res->u8 = v1->u128 >= v2->ldval;
4249 break;
4250 # endif
4251
4252 default:
4253 assert(0);
4254 break;
4255 }
4256 break;
4257 #endif
4258
4259 case PSI_T_FLOAT:
4260 switch (t2) {
4261 case PSI_T_INT8:
4262 res->u8 = v1->fval >= v2->i8;
4263 break;
4264 case PSI_T_UINT8:
4265 res->u8 = v1->fval >= v2->u8;
4266 break;
4267 case PSI_T_INT16:
4268 res->u8 = v1->fval >= v2->i16;
4269 break;
4270 case PSI_T_UINT16:
4271 res->u8 = v1->fval >= v2->u16;
4272 break;
4273 case PSI_T_INT32:
4274 res->u8 = v1->fval >= v2->i32;
4275 break;
4276 case PSI_T_UINT32:
4277 res->u8 = v1->fval >= v2->u32;
4278 break;
4279 case PSI_T_INT64:
4280 res->u8 = v1->fval >= v2->i64;
4281 break;
4282 case PSI_T_UINT64:
4283 res->u8 = v1->fval >= v2->u64;
4284 break;
4285 # if HAVE_INT128
4286 case PSI_T_INT128:
4287 res->u8 = v1->fval >= v2->i128;
4288 break;
4289 # endif
4290
4291 # if HAVE_UINT128
4292 case PSI_T_UINT128:
4293 res->u8 = v1->fval >= v2->u128;
4294 break;
4295 # endif
4296
4297 case PSI_T_FLOAT:
4298 res->u8 = v1->fval >= v2->fval;
4299 break;
4300 case PSI_T_DOUBLE:
4301 res->u8 = v1->fval >= v2->dval;
4302 break;
4303 # if HAVE_LONG_DOUBLE
4304 case PSI_T_LONG_DOUBLE:
4305 res->u8 = v1->fval >= v2->ldval;
4306 break;
4307 # endif
4308
4309 default:
4310 assert(0);
4311 break;
4312 }
4313 break;
4314 case PSI_T_DOUBLE:
4315 switch (t2) {
4316 case PSI_T_INT8:
4317 res->u8 = v1->dval >= v2->i8;
4318 break;
4319 case PSI_T_UINT8:
4320 res->u8 = v1->dval >= v2->u8;
4321 break;
4322 case PSI_T_INT16:
4323 res->u8 = v1->dval >= v2->i16;
4324 break;
4325 case PSI_T_UINT16:
4326 res->u8 = v1->dval >= v2->u16;
4327 break;
4328 case PSI_T_INT32:
4329 res->u8 = v1->dval >= v2->i32;
4330 break;
4331 case PSI_T_UINT32:
4332 res->u8 = v1->dval >= v2->u32;
4333 break;
4334 case PSI_T_INT64:
4335 res->u8 = v1->dval >= v2->i64;
4336 break;
4337 case PSI_T_UINT64:
4338 res->u8 = v1->dval >= v2->u64;
4339 break;
4340 # if HAVE_INT128
4341 case PSI_T_INT128:
4342 res->u8 = v1->dval >= v2->i128;
4343 break;
4344 # endif
4345
4346 # if HAVE_UINT128
4347 case PSI_T_UINT128:
4348 res->u8 = v1->dval >= v2->u128;
4349 break;
4350 # endif
4351
4352 case PSI_T_FLOAT:
4353 res->u8 = v1->dval >= v2->fval;
4354 break;
4355 case PSI_T_DOUBLE:
4356 res->u8 = v1->dval >= v2->dval;
4357 break;
4358 # if HAVE_LONG_DOUBLE
4359 case PSI_T_LONG_DOUBLE:
4360 res->u8 = v1->dval >= v2->ldval;
4361 break;
4362 # endif
4363
4364 default:
4365 assert(0);
4366 break;
4367 }
4368 break;
4369 #if HAVE_LONG_DOUBLE
4370 case PSI_T_LONG_DOUBLE:
4371 switch (t2) {
4372 case PSI_T_INT8:
4373 res->u8 = v1->ldval >= v2->i8;
4374 break;
4375 case PSI_T_UINT8:
4376 res->u8 = v1->ldval >= v2->u8;
4377 break;
4378 case PSI_T_INT16:
4379 res->u8 = v1->ldval >= v2->i16;
4380 break;
4381 case PSI_T_UINT16:
4382 res->u8 = v1->ldval >= v2->u16;
4383 break;
4384 case PSI_T_INT32:
4385 res->u8 = v1->ldval >= v2->i32;
4386 break;
4387 case PSI_T_UINT32:
4388 res->u8 = v1->ldval >= v2->u32;
4389 break;
4390 case PSI_T_INT64:
4391 res->u8 = v1->ldval >= v2->i64;
4392 break;
4393 case PSI_T_UINT64:
4394 res->u8 = v1->ldval >= v2->u64;
4395 break;
4396 # if HAVE_INT128
4397 case PSI_T_INT128:
4398 res->u8 = v1->ldval >= v2->i128;
4399 break;
4400 # endif
4401
4402 # if HAVE_UINT128
4403 case PSI_T_UINT128:
4404 res->u8 = v1->ldval >= v2->u128;
4405 break;
4406 # endif
4407
4408 case PSI_T_FLOAT:
4409 res->u8 = v1->ldval >= v2->fval;
4410 break;
4411 case PSI_T_DOUBLE:
4412 res->u8 = v1->ldval >= v2->dval;
4413 break;
4414 # if HAVE_LONG_DOUBLE
4415 case PSI_T_LONG_DOUBLE:
4416 res->u8 = v1->ldval >= v2->ldval;
4417 break;
4418 # endif
4419
4420 default:
4421 assert(0);
4422 break;
4423 }
4424 break;
4425 #endif
4426
4427 default:
4428 assert(0);
4429 break;
4430 }
4431 return PSI_T_UINT8;
4432 }
PHP System Interface / POSIX Standard Interface