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