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


ac021e06a9db5dc4f80d821dcc59622a250472ac
[m6w6/ext-psi] / src / calc / basic.h
1 /*******************************************************************************
2 Copyright (c) 2016, Michael Wallner <mike@php.net>.
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
7
8 * Redistributions of source code must retain the above copyright notice,
9 this list of conditions and the following disclaimer.
10 * Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the distribution.
13
14 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
18 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *******************************************************************************/
25
26 #include "php_psi_stdinc.h"
27 #include <assert.h>
28
29 #include "token.h"
30
31 static inline token_t psi_calc_add(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
32 {
33
34 switch (t1) {
35 case PSI_T_INT8:
36 switch (t2) {
37 case PSI_T_INT8:
38 res->i16 = v1->i8 + v2->i8;
39 return PSI_T_INT16;
40 case PSI_T_UINT8:
41 res->i16 = v1->i8 + v2->u8;
42 return PSI_T_INT16;
43 case PSI_T_INT16:
44 res->i32 = v1->i8 + v2->i16;
45 return PSI_T_INT32;
46 case PSI_T_UINT16:
47 res->i32 = v1->i8 + v2->u16;
48 return PSI_T_INT32;
49 case PSI_T_INT32:
50 res->i64 = v1->i8 + v2->i32;
51 return PSI_T_INT64;
52 case PSI_T_UINT32:
53 res->i64 = v1->i8 + v2->u32;
54 return PSI_T_INT64;
55 case PSI_T_INT64:
56 res->i64 = v1->i8 + v2->i64;
57 return PSI_T_INT64;
58 case PSI_T_UINT64:
59 res->i64 = v1->i8 + v2->u64;
60 return PSI_T_INT64;
61 case PSI_T_FLOAT:
62 res->fval = v1->i8 + v2->fval;
63 return PSI_T_FLOAT;
64 case PSI_T_DOUBLE:
65 res->dval = v1->i8 + v2->dval;
66 return PSI_T_DOUBLE;
67 # if HAVE_LONG_DOUBLE
68 case PSI_T_LONG_DOUBLE:
69 res->ldval = v1->i8 + v2->ldval;
70 return PSI_T_LONG_DOUBLE;
71 # endif
72
73 default:
74 assert(0);
75 break;
76 }
77 break;
78 case PSI_T_UINT8:
79 switch (t2) {
80 case PSI_T_INT8:
81 res->i16 = v1->u8 + v2->i8;
82 return PSI_T_INT16;
83 case PSI_T_UINT8:
84 res->u16 = v1->u8 + v2->u8;
85 return PSI_T_UINT16;
86 case PSI_T_INT16:
87 res->i32 = v1->u8 + v2->i16;
88 return PSI_T_INT32;
89 case PSI_T_UINT16:
90 res->u32 = v1->u8 + v2->u16;
91 return PSI_T_UINT32;
92 case PSI_T_INT32:
93 res->i64 = v1->u8 + v2->i32;
94 return PSI_T_INT64;
95 case PSI_T_UINT32:
96 res->u64 = v1->u8 + v2->u32;
97 return PSI_T_UINT64;
98 case PSI_T_INT64:
99 res->i64 = v1->u8 + v2->i64;
100 return PSI_T_INT64;
101 case PSI_T_UINT64:
102 res->u64 = v1->u8 + v2->u64;
103 return PSI_T_UINT64;
104 case PSI_T_FLOAT:
105 res->fval = v1->u8 + v2->fval;
106 return PSI_T_FLOAT;
107 case PSI_T_DOUBLE:
108 res->dval = v1->u8 + v2->dval;
109 return PSI_T_DOUBLE;
110 # if HAVE_LONG_DOUBLE
111 case PSI_T_LONG_DOUBLE:
112 res->ldval = v1->u8 + v2->ldval;
113 return PSI_T_LONG_DOUBLE;
114 # endif
115
116 default:
117 assert(0);
118 break;
119 }
120 break;
121 case PSI_T_INT16:
122 switch (t2) {
123 case PSI_T_INT8:
124 res->i32 = v1->i16 + v2->i8;
125 return PSI_T_INT32;
126 case PSI_T_UINT8:
127 res->i32 = v1->i16 + v2->u8;
128 return PSI_T_INT32;
129 case PSI_T_INT16:
130 res->i32 = v1->i16 + v2->i16;
131 return PSI_T_INT32;
132 case PSI_T_UINT16:
133 res->i32 = v1->i16 + v2->u16;
134 return PSI_T_INT32;
135 case PSI_T_INT32:
136 res->i64 = v1->i16 + v2->i32;
137 return PSI_T_INT64;
138 case PSI_T_UINT32:
139 res->i64 = v1->i16 + v2->u32;
140 return PSI_T_INT64;
141 case PSI_T_INT64:
142 res->i64 = v1->i16 + v2->i64;
143 return PSI_T_INT64;
144 case PSI_T_UINT64:
145 res->i64 = v1->i16 + v2->u64;
146 return PSI_T_INT64;
147 case PSI_T_FLOAT:
148 res->fval = v1->i16 + v2->fval;
149 return PSI_T_FLOAT;
150 case PSI_T_DOUBLE:
151 res->dval = v1->i16 + v2->dval;
152 return PSI_T_DOUBLE;
153 # if HAVE_LONG_DOUBLE
154 case PSI_T_LONG_DOUBLE:
155 res->ldval = v1->i16 + v2->ldval;
156 return PSI_T_LONG_DOUBLE;
157 # endif
158
159 default:
160 assert(0);
161 break;
162 }
163 break;
164 case PSI_T_UINT16:
165 switch (t2) {
166 case PSI_T_INT8:
167 res->i32 = v1->u16 + v2->i8;
168 return PSI_T_INT32;
169 case PSI_T_UINT8:
170 res->u32 = v1->u16 + v2->u8;
171 return PSI_T_UINT32;
172 case PSI_T_INT16:
173 res->i32 = v1->u16 + v2->i16;
174 return PSI_T_INT32;
175 case PSI_T_UINT16:
176 res->u32 = v1->u16 + v2->u16;
177 return PSI_T_UINT32;
178 case PSI_T_INT32:
179 res->i64 = v1->u16 + v2->i32;
180 return PSI_T_INT64;
181 case PSI_T_UINT32:
182 res->u64 = v1->u16 + v2->u32;
183 return PSI_T_UINT64;
184 case PSI_T_INT64:
185 res->i64 = v1->u16 + v2->i64;
186 return PSI_T_INT64;
187 case PSI_T_UINT64:
188 res->u64 = v1->u16 + v2->u64;
189 return PSI_T_UINT64;
190 case PSI_T_FLOAT:
191 res->fval = v1->u16 + v2->fval;
192 return PSI_T_FLOAT;
193 case PSI_T_DOUBLE:
194 res->dval = v1->u16 + v2->dval;
195 return PSI_T_DOUBLE;
196 # if HAVE_LONG_DOUBLE
197 case PSI_T_LONG_DOUBLE:
198 res->ldval = v1->u16 + v2->ldval;
199 return PSI_T_LONG_DOUBLE;
200 # endif
201
202 default:
203 assert(0);
204 break;
205 }
206 break;
207 case PSI_T_INT32:
208 switch (t2) {
209 case PSI_T_INT8:
210 res->i64 = v1->i32 + v2->i8;
211 return PSI_T_INT64;
212 case PSI_T_UINT8:
213 res->i64 = v1->i32 + v2->u8;
214 return PSI_T_INT64;
215 case PSI_T_INT16:
216 res->i64 = v1->i32 + v2->i16;
217 return PSI_T_INT64;
218 case PSI_T_UINT16:
219 res->i64 = v1->i32 + v2->u16;
220 return PSI_T_INT64;
221 case PSI_T_INT32:
222 res->i64 = v1->i32 + v2->i32;
223 return PSI_T_INT64;
224 case PSI_T_UINT32:
225 res->i64 = v1->i32 + v2->u32;
226 return PSI_T_INT64;
227 case PSI_T_INT64:
228 res->i64 = v1->i32 + v2->i64;
229 return PSI_T_INT64;
230 case PSI_T_UINT64:
231 res->i64 = v1->i32 + v2->u64;
232 return PSI_T_INT64;
233 case PSI_T_FLOAT:
234 res->fval = v1->i32 + v2->fval;
235 return PSI_T_FLOAT;
236 case PSI_T_DOUBLE:
237 res->dval = v1->i32 + v2->dval;
238 return PSI_T_DOUBLE;
239 # if HAVE_LONG_DOUBLE
240 case PSI_T_LONG_DOUBLE:
241 res->ldval = v1->i32 + v2->ldval;
242 return PSI_T_LONG_DOUBLE;
243 # endif
244
245 default:
246 assert(0);
247 break;
248 }
249 break;
250 case PSI_T_UINT32:
251 switch (t2) {
252 case PSI_T_INT8:
253 res->i64 = v1->u32 + v2->i8;
254 return PSI_T_INT64;
255 case PSI_T_UINT8:
256 res->u64 = v1->u32 + v2->u8;
257 return PSI_T_UINT64;
258 case PSI_T_INT16:
259 res->i64 = v1->u32 + v2->i16;
260 return PSI_T_INT64;
261 case PSI_T_UINT16:
262 res->u64 = v1->u32 + v2->u16;
263 return PSI_T_UINT64;
264 case PSI_T_INT32:
265 res->i64 = v1->u32 + v2->i32;
266 return PSI_T_INT64;
267 case PSI_T_UINT32:
268 res->u64 = v1->u32 + v2->u32;
269 return PSI_T_UINT64;
270 case PSI_T_INT64:
271 res->i64 = v1->u32 + v2->i64;
272 return PSI_T_INT64;
273 case PSI_T_UINT64:
274 res->u64 = v1->u32 + v2->u64;
275 return PSI_T_UINT64;
276 case PSI_T_FLOAT:
277 res->fval = v1->u32 + v2->fval;
278 return PSI_T_FLOAT;
279 case PSI_T_DOUBLE:
280 res->dval = v1->u32 + v2->dval;
281 return PSI_T_DOUBLE;
282 # if HAVE_LONG_DOUBLE
283 case PSI_T_LONG_DOUBLE:
284 res->ldval = v1->u32 + v2->ldval;
285 return PSI_T_LONG_DOUBLE;
286 # endif
287
288 default:
289 assert(0);
290 break;
291 }
292 break;
293 case PSI_T_INT64:
294 switch (t2) {
295 case PSI_T_INT8:
296 res->i64 = v1->i64 + v2->i8;
297 return PSI_T_INT64;
298 case PSI_T_UINT8:
299 res->i64 = v1->i64 + v2->u8;
300 return PSI_T_INT64;
301 case PSI_T_INT16:
302 res->i64 = v1->i64 + v2->i16;
303 return PSI_T_INT64;
304 case PSI_T_UINT16:
305 res->i64 = v1->i64 + v2->u16;
306 return PSI_T_INT64;
307 case PSI_T_INT32:
308 res->i64 = v1->i64 + v2->i32;
309 return PSI_T_INT64;
310 case PSI_T_UINT32:
311 res->i64 = v1->i64 + v2->u32;
312 return PSI_T_INT64;
313 case PSI_T_INT64:
314 res->i64 = v1->i64 + v2->i64;
315 return PSI_T_INT64;
316 case PSI_T_UINT64:
317 res->i64 = v1->i64 + v2->u64;
318 return PSI_T_INT64;
319 case PSI_T_FLOAT:
320 res->fval = v1->i64 + v2->fval;
321 return PSI_T_FLOAT;
322 case PSI_T_DOUBLE:
323 res->dval = v1->i64 + v2->dval;
324 return PSI_T_DOUBLE;
325 # if HAVE_LONG_DOUBLE
326 case PSI_T_LONG_DOUBLE:
327 res->ldval = v1->i64 + v2->ldval;
328 return PSI_T_LONG_DOUBLE;
329 # endif
330
331 default:
332 assert(0);
333 break;
334 }
335 break;
336 case PSI_T_UINT64:
337 switch (t2) {
338 case PSI_T_INT8:
339 res->i64 = v1->u64 + v2->i8;
340 return PSI_T_INT64;
341 case PSI_T_UINT8:
342 res->u64 = v1->u64 + v2->u8;
343 return PSI_T_UINT64;
344 case PSI_T_INT16:
345 res->i64 = v1->u64 + v2->i16;
346 return PSI_T_INT64;
347 case PSI_T_UINT16:
348 res->u64 = v1->u64 + v2->u16;
349 return PSI_T_UINT64;
350 case PSI_T_INT32:
351 res->i64 = v1->u64 + v2->i32;
352 return PSI_T_INT64;
353 case PSI_T_UINT32:
354 res->u64 = v1->u64 + v2->u32;
355 return PSI_T_UINT64;
356 case PSI_T_INT64:
357 res->i64 = v1->u64 + v2->i64;
358 return PSI_T_INT64;
359 case PSI_T_UINT64:
360 res->u64 = v1->u64 + v2->u64;
361 return PSI_T_UINT64;
362 case PSI_T_FLOAT:
363 res->fval = v1->u64 + v2->fval;
364 return PSI_T_FLOAT;
365 case PSI_T_DOUBLE:
366 res->dval = v1->u64 + v2->dval;
367 return PSI_T_DOUBLE;
368 # if HAVE_LONG_DOUBLE
369 case PSI_T_LONG_DOUBLE:
370 res->ldval = v1->u64 + v2->ldval;
371 return PSI_T_LONG_DOUBLE;
372 # endif
373
374 default:
375 assert(0);
376 break;
377 }
378 break;
379 case PSI_T_FLOAT:
380 switch (t2) {
381 case PSI_T_INT8:
382 res->fval = v1->fval + v2->i8;
383 return PSI_T_FLOAT;
384 case PSI_T_UINT8:
385 res->fval = v1->fval + v2->u8;
386 return PSI_T_FLOAT;
387 case PSI_T_INT16:
388 res->fval = v1->fval + v2->i16;
389 return PSI_T_FLOAT;
390 case PSI_T_UINT16:
391 res->fval = v1->fval + v2->u16;
392 return PSI_T_FLOAT;
393 case PSI_T_INT32:
394 res->fval = v1->fval + v2->i32;
395 return PSI_T_FLOAT;
396 case PSI_T_UINT32:
397 res->fval = v1->fval + v2->u32;
398 return PSI_T_FLOAT;
399 case PSI_T_INT64:
400 res->fval = v1->fval + v2->i64;
401 return PSI_T_FLOAT;
402 case PSI_T_UINT64:
403 res->fval = v1->fval + v2->u64;
404 return PSI_T_FLOAT;
405 case PSI_T_FLOAT:
406 res->fval = v1->fval + v2->fval;
407 return PSI_T_FLOAT;
408 case PSI_T_DOUBLE:
409 res->dval = v1->fval + v2->dval;
410 return PSI_T_DOUBLE;
411 # if HAVE_LONG_DOUBLE
412 case PSI_T_LONG_DOUBLE:
413 res->ldval = v1->fval + v2->ldval;
414 return PSI_T_LONG_DOUBLE;
415 # endif
416
417 default:
418 assert(0);
419 break;
420 }
421 break;
422 case PSI_T_DOUBLE:
423 switch (t2) {
424 case PSI_T_INT8:
425 res->dval = v1->dval + v2->i8;
426 return PSI_T_DOUBLE;
427 case PSI_T_UINT8:
428 res->dval = v1->dval + v2->u8;
429 return PSI_T_DOUBLE;
430 case PSI_T_INT16:
431 res->dval = v1->dval + v2->i16;
432 return PSI_T_DOUBLE;
433 case PSI_T_UINT16:
434 res->dval = v1->dval + v2->u16;
435 return PSI_T_DOUBLE;
436 case PSI_T_INT32:
437 res->dval = v1->dval + v2->i32;
438 return PSI_T_DOUBLE;
439 case PSI_T_UINT32:
440 res->dval = v1->dval + v2->u32;
441 return PSI_T_DOUBLE;
442 case PSI_T_INT64:
443 res->dval = v1->dval + v2->i64;
444 return PSI_T_DOUBLE;
445 case PSI_T_UINT64:
446 res->dval = v1->dval + v2->u64;
447 return PSI_T_DOUBLE;
448 case PSI_T_FLOAT:
449 res->dval = v1->dval + v2->fval;
450 return PSI_T_DOUBLE;
451 case PSI_T_DOUBLE:
452 res->dval = v1->dval + v2->dval;
453 return PSI_T_DOUBLE;
454 # if HAVE_LONG_DOUBLE
455 case PSI_T_LONG_DOUBLE:
456 res->ldval = v1->dval + v2->ldval;
457 return PSI_T_LONG_DOUBLE;
458 # endif
459
460 default:
461 assert(0);
462 break;
463 }
464 break;
465 #if HAVE_LONG_DOUBLE
466 case PSI_T_LONG_DOUBLE:
467 switch (t2) {
468 case PSI_T_INT8:
469 res->ldval = v1->ldval + v2->i8;
470 return PSI_T_LONG_DOUBLE;
471 case PSI_T_UINT8:
472 res->ldval = v1->ldval + v2->u8;
473 return PSI_T_LONG_DOUBLE;
474 case PSI_T_INT16:
475 res->ldval = v1->ldval + v2->i16;
476 return PSI_T_LONG_DOUBLE;
477 case PSI_T_UINT16:
478 res->ldval = v1->ldval + v2->u16;
479 return PSI_T_LONG_DOUBLE;
480 case PSI_T_INT32:
481 res->ldval = v1->ldval + v2->i32;
482 return PSI_T_LONG_DOUBLE;
483 case PSI_T_UINT32:
484 res->ldval = v1->ldval + v2->u32;
485 return PSI_T_LONG_DOUBLE;
486 case PSI_T_INT64:
487 res->ldval = v1->ldval + v2->i64;
488 return PSI_T_LONG_DOUBLE;
489 case PSI_T_UINT64:
490 res->ldval = v1->ldval + v2->u64;
491 return PSI_T_LONG_DOUBLE;
492 case PSI_T_FLOAT:
493 res->ldval = v1->ldval + v2->fval;
494 return PSI_T_LONG_DOUBLE;
495 case PSI_T_DOUBLE:
496 res->ldval = v1->ldval + v2->dval;
497 return PSI_T_LONG_DOUBLE;
498 # if HAVE_LONG_DOUBLE
499 case PSI_T_LONG_DOUBLE:
500 res->ldval = v1->ldval + v2->ldval;
501 return PSI_T_LONG_DOUBLE;
502 # endif
503
504 default:
505 assert(0);
506 break;
507 }
508 break;
509 #endif
510
511 default:
512 assert(0);
513 break;
514 }
515
516 return 0;
517 }
518 static inline token_t psi_calc_sub(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
519 {
520
521 switch (t1) {
522 case PSI_T_INT8:
523 switch (t2) {
524 case PSI_T_INT8:
525 res->i16 = v1->i8 - v2->i8;
526 return PSI_T_INT16;
527 case PSI_T_UINT8:
528 res->i16 = v1->i8 - v2->u8;
529 return PSI_T_INT16;
530 case PSI_T_INT16:
531 res->i32 = v1->i8 - v2->i16;
532 return PSI_T_INT32;
533 case PSI_T_UINT16:
534 res->i32 = v1->i8 - v2->u16;
535 return PSI_T_INT32;
536 case PSI_T_INT32:
537 res->i64 = v1->i8 - v2->i32;
538 return PSI_T_INT64;
539 case PSI_T_UINT32:
540 res->i64 = v1->i8 - v2->u32;
541 return PSI_T_INT64;
542 case PSI_T_INT64:
543 res->i64 = v1->i8 - v2->i64;
544 return PSI_T_INT64;
545 case PSI_T_UINT64:
546 res->i64 = v1->i8 - v2->u64;
547 return PSI_T_INT64;
548 case PSI_T_FLOAT:
549 res->fval = v1->i8 - v2->fval;
550 return PSI_T_FLOAT;
551 case PSI_T_DOUBLE:
552 res->dval = v1->i8 - v2->dval;
553 return PSI_T_DOUBLE;
554 # if HAVE_LONG_DOUBLE
555 case PSI_T_LONG_DOUBLE:
556 res->ldval = v1->i8 - v2->ldval;
557 return PSI_T_LONG_DOUBLE;
558 # endif
559
560 default:
561 assert(0);
562 break;
563 }
564 break;
565 case PSI_T_UINT8:
566 switch (t2) {
567 case PSI_T_INT8:
568 res->i16 = v1->u8 - v2->i8;
569 return PSI_T_INT16;
570 case PSI_T_UINT8:
571 res->u16 = v1->u8 - v2->u8;
572 return PSI_T_UINT16;
573 case PSI_T_INT16:
574 res->i32 = v1->u8 - v2->i16;
575 return PSI_T_INT32;
576 case PSI_T_UINT16:
577 res->u32 = v1->u8 - v2->u16;
578 return PSI_T_UINT32;
579 case PSI_T_INT32:
580 res->i64 = v1->u8 - v2->i32;
581 return PSI_T_INT64;
582 case PSI_T_UINT32:
583 res->u64 = v1->u8 - v2->u32;
584 return PSI_T_UINT64;
585 case PSI_T_INT64:
586 res->i64 = v1->u8 - v2->i64;
587 return PSI_T_INT64;
588 case PSI_T_UINT64:
589 res->u64 = v1->u8 - v2->u64;
590 return PSI_T_UINT64;
591 case PSI_T_FLOAT:
592 res->fval = v1->u8 - v2->fval;
593 return PSI_T_FLOAT;
594 case PSI_T_DOUBLE:
595 res->dval = v1->u8 - v2->dval;
596 return PSI_T_DOUBLE;
597 # if HAVE_LONG_DOUBLE
598 case PSI_T_LONG_DOUBLE:
599 res->ldval = v1->u8 - v2->ldval;
600 return PSI_T_LONG_DOUBLE;
601 # endif
602
603 default:
604 assert(0);
605 break;
606 }
607 break;
608 case PSI_T_INT16:
609 switch (t2) {
610 case PSI_T_INT8:
611 res->i32 = v1->i16 - v2->i8;
612 return PSI_T_INT32;
613 case PSI_T_UINT8:
614 res->i32 = v1->i16 - v2->u8;
615 return PSI_T_INT32;
616 case PSI_T_INT16:
617 res->i32 = v1->i16 - v2->i16;
618 return PSI_T_INT32;
619 case PSI_T_UINT16:
620 res->i32 = v1->i16 - v2->u16;
621 return PSI_T_INT32;
622 case PSI_T_INT32:
623 res->i64 = v1->i16 - v2->i32;
624 return PSI_T_INT64;
625 case PSI_T_UINT32:
626 res->i64 = v1->i16 - v2->u32;
627 return PSI_T_INT64;
628 case PSI_T_INT64:
629 res->i64 = v1->i16 - v2->i64;
630 return PSI_T_INT64;
631 case PSI_T_UINT64:
632 res->i64 = v1->i16 - v2->u64;
633 return PSI_T_INT64;
634 case PSI_T_FLOAT:
635 res->fval = v1->i16 - v2->fval;
636 return PSI_T_FLOAT;
637 case PSI_T_DOUBLE:
638 res->dval = v1->i16 - v2->dval;
639 return PSI_T_DOUBLE;
640 # if HAVE_LONG_DOUBLE
641 case PSI_T_LONG_DOUBLE:
642 res->ldval = v1->i16 - v2->ldval;
643 return PSI_T_LONG_DOUBLE;
644 # endif
645
646 default:
647 assert(0);
648 break;
649 }
650 break;
651 case PSI_T_UINT16:
652 switch (t2) {
653 case PSI_T_INT8:
654 res->i32 = v1->u16 - v2->i8;
655 return PSI_T_INT32;
656 case PSI_T_UINT8:
657 res->u32 = v1->u16 - v2->u8;
658 return PSI_T_UINT32;
659 case PSI_T_INT16:
660 res->i32 = v1->u16 - v2->i16;
661 return PSI_T_INT32;
662 case PSI_T_UINT16:
663 res->u32 = v1->u16 - v2->u16;
664 return PSI_T_UINT32;
665 case PSI_T_INT32:
666 res->i64 = v1->u16 - v2->i32;
667 return PSI_T_INT64;
668 case PSI_T_UINT32:
669 res->u64 = v1->u16 - v2->u32;
670 return PSI_T_UINT64;
671 case PSI_T_INT64:
672 res->i64 = v1->u16 - v2->i64;
673 return PSI_T_INT64;
674 case PSI_T_UINT64:
675 res->u64 = v1->u16 - v2->u64;
676 return PSI_T_UINT64;
677 case PSI_T_FLOAT:
678 res->fval = v1->u16 - v2->fval;
679 return PSI_T_FLOAT;
680 case PSI_T_DOUBLE:
681 res->dval = v1->u16 - v2->dval;
682 return PSI_T_DOUBLE;
683 # if HAVE_LONG_DOUBLE
684 case PSI_T_LONG_DOUBLE:
685 res->ldval = v1->u16 - v2->ldval;
686 return PSI_T_LONG_DOUBLE;
687 # endif
688
689 default:
690 assert(0);
691 break;
692 }
693 break;
694 case PSI_T_INT32:
695 switch (t2) {
696 case PSI_T_INT8:
697 res->i64 = v1->i32 - v2->i8;
698 return PSI_T_INT64;
699 case PSI_T_UINT8:
700 res->i64 = v1->i32 - v2->u8;
701 return PSI_T_INT64;
702 case PSI_T_INT16:
703 res->i64 = v1->i32 - v2->i16;
704 return PSI_T_INT64;
705 case PSI_T_UINT16:
706 res->i64 = v1->i32 - v2->u16;
707 return PSI_T_INT64;
708 case PSI_T_INT32:
709 res->i64 = v1->i32 - v2->i32;
710 return PSI_T_INT64;
711 case PSI_T_UINT32:
712 res->i64 = v1->i32 - v2->u32;
713 return PSI_T_INT64;
714 case PSI_T_INT64:
715 res->i64 = v1->i32 - v2->i64;
716 return PSI_T_INT64;
717 case PSI_T_UINT64:
718 res->i64 = v1->i32 - v2->u64;
719 return PSI_T_INT64;
720 case PSI_T_FLOAT:
721 res->fval = v1->i32 - v2->fval;
722 return PSI_T_FLOAT;
723 case PSI_T_DOUBLE:
724 res->dval = v1->i32 - v2->dval;
725 return PSI_T_DOUBLE;
726 # if HAVE_LONG_DOUBLE
727 case PSI_T_LONG_DOUBLE:
728 res->ldval = v1->i32 - v2->ldval;
729 return PSI_T_LONG_DOUBLE;
730 # endif
731
732 default:
733 assert(0);
734 break;
735 }
736 break;
737 case PSI_T_UINT32:
738 switch (t2) {
739 case PSI_T_INT8:
740 res->i64 = v1->u32 - v2->i8;
741 return PSI_T_INT64;
742 case PSI_T_UINT8:
743 res->u64 = v1->u32 - v2->u8;
744 return PSI_T_UINT64;
745 case PSI_T_INT16:
746 res->i64 = v1->u32 - v2->i16;
747 return PSI_T_INT64;
748 case PSI_T_UINT16:
749 res->u64 = v1->u32 - v2->u16;
750 return PSI_T_UINT64;
751 case PSI_T_INT32:
752 res->i64 = v1->u32 - v2->i32;
753 return PSI_T_INT64;
754 case PSI_T_UINT32:
755 res->u64 = v1->u32 - v2->u32;
756 return PSI_T_UINT64;
757 case PSI_T_INT64:
758 res->i64 = v1->u32 - v2->i64;
759 return PSI_T_INT64;
760 case PSI_T_UINT64:
761 res->u64 = v1->u32 - v2->u64;
762 return PSI_T_UINT64;
763 case PSI_T_FLOAT:
764 res->fval = v1->u32 - v2->fval;
765 return PSI_T_FLOAT;
766 case PSI_T_DOUBLE:
767 res->dval = v1->u32 - v2->dval;
768 return PSI_T_DOUBLE;
769 # if HAVE_LONG_DOUBLE
770 case PSI_T_LONG_DOUBLE:
771 res->ldval = v1->u32 - v2->ldval;
772 return PSI_T_LONG_DOUBLE;
773 # endif
774
775 default:
776 assert(0);
777 break;
778 }
779 break;
780 case PSI_T_INT64:
781 switch (t2) {
782 case PSI_T_INT8:
783 res->i64 = v1->i64 - v2->i8;
784 return PSI_T_INT64;
785 case PSI_T_UINT8:
786 res->i64 = v1->i64 - v2->u8;
787 return PSI_T_INT64;
788 case PSI_T_INT16:
789 res->i64 = v1->i64 - v2->i16;
790 return PSI_T_INT64;
791 case PSI_T_UINT16:
792 res->i64 = v1->i64 - v2->u16;
793 return PSI_T_INT64;
794 case PSI_T_INT32:
795 res->i64 = v1->i64 - v2->i32;
796 return PSI_T_INT64;
797 case PSI_T_UINT32:
798 res->i64 = v1->i64 - v2->u32;
799 return PSI_T_INT64;
800 case PSI_T_INT64:
801 res->i64 = v1->i64 - v2->i64;
802 return PSI_T_INT64;
803 case PSI_T_UINT64:
804 res->i64 = v1->i64 - v2->u64;
805 return PSI_T_INT64;
806 case PSI_T_FLOAT:
807 res->fval = v1->i64 - v2->fval;
808 return PSI_T_FLOAT;
809 case PSI_T_DOUBLE:
810 res->dval = v1->i64 - v2->dval;
811 return PSI_T_DOUBLE;
812 # if HAVE_LONG_DOUBLE
813 case PSI_T_LONG_DOUBLE:
814 res->ldval = v1->i64 - v2->ldval;
815 return PSI_T_LONG_DOUBLE;
816 # endif
817
818 default:
819 assert(0);
820 break;
821 }
822 break;
823 case PSI_T_UINT64:
824 switch (t2) {
825 case PSI_T_INT8:
826 res->i64 = v1->u64 - v2->i8;
827 return PSI_T_INT64;
828 case PSI_T_UINT8:
829 res->u64 = v1->u64 - v2->u8;
830 return PSI_T_UINT64;
831 case PSI_T_INT16:
832 res->i64 = v1->u64 - v2->i16;
833 return PSI_T_INT64;
834 case PSI_T_UINT16:
835 res->u64 = v1->u64 - v2->u16;
836 return PSI_T_UINT64;
837 case PSI_T_INT32:
838 res->i64 = v1->u64 - v2->i32;
839 return PSI_T_INT64;
840 case PSI_T_UINT32:
841 res->u64 = v1->u64 - v2->u32;
842 return PSI_T_UINT64;
843 case PSI_T_INT64:
844 res->i64 = v1->u64 - v2->i64;
845 return PSI_T_INT64;
846 case PSI_T_UINT64:
847 res->u64 = v1->u64 - v2->u64;
848 return PSI_T_UINT64;
849 case PSI_T_FLOAT:
850 res->fval = v1->u64 - v2->fval;
851 return PSI_T_FLOAT;
852 case PSI_T_DOUBLE:
853 res->dval = v1->u64 - v2->dval;
854 return PSI_T_DOUBLE;
855 # if HAVE_LONG_DOUBLE
856 case PSI_T_LONG_DOUBLE:
857 res->ldval = v1->u64 - v2->ldval;
858 return PSI_T_LONG_DOUBLE;
859 # endif
860
861 default:
862 assert(0);
863 break;
864 }
865 break;
866 case PSI_T_FLOAT:
867 switch (t2) {
868 case PSI_T_INT8:
869 res->fval = v1->fval - v2->i8;
870 return PSI_T_FLOAT;
871 case PSI_T_UINT8:
872 res->fval = v1->fval - v2->u8;
873 return PSI_T_FLOAT;
874 case PSI_T_INT16:
875 res->fval = v1->fval - v2->i16;
876 return PSI_T_FLOAT;
877 case PSI_T_UINT16:
878 res->fval = v1->fval - v2->u16;
879 return PSI_T_FLOAT;
880 case PSI_T_INT32:
881 res->fval = v1->fval - v2->i32;
882 return PSI_T_FLOAT;
883 case PSI_T_UINT32:
884 res->fval = v1->fval - v2->u32;
885 return PSI_T_FLOAT;
886 case PSI_T_INT64:
887 res->fval = v1->fval - v2->i64;
888 return PSI_T_FLOAT;
889 case PSI_T_UINT64:
890 res->fval = v1->fval - v2->u64;
891 return PSI_T_FLOAT;
892 case PSI_T_FLOAT:
893 res->fval = v1->fval - v2->fval;
894 return PSI_T_FLOAT;
895 case PSI_T_DOUBLE:
896 res->dval = v1->fval - v2->dval;
897 return PSI_T_DOUBLE;
898 # if HAVE_LONG_DOUBLE
899 case PSI_T_LONG_DOUBLE:
900 res->ldval = v1->fval - v2->ldval;
901 return PSI_T_LONG_DOUBLE;
902 # endif
903
904 default:
905 assert(0);
906 break;
907 }
908 break;
909 case PSI_T_DOUBLE:
910 switch (t2) {
911 case PSI_T_INT8:
912 res->dval = v1->dval - v2->i8;
913 return PSI_T_DOUBLE;
914 case PSI_T_UINT8:
915 res->dval = v1->dval - v2->u8;
916 return PSI_T_DOUBLE;
917 case PSI_T_INT16:
918 res->dval = v1->dval - v2->i16;
919 return PSI_T_DOUBLE;
920 case PSI_T_UINT16:
921 res->dval = v1->dval - v2->u16;
922 return PSI_T_DOUBLE;
923 case PSI_T_INT32:
924 res->dval = v1->dval - v2->i32;
925 return PSI_T_DOUBLE;
926 case PSI_T_UINT32:
927 res->dval = v1->dval - v2->u32;
928 return PSI_T_DOUBLE;
929 case PSI_T_INT64:
930 res->dval = v1->dval - v2->i64;
931 return PSI_T_DOUBLE;
932 case PSI_T_UINT64:
933 res->dval = v1->dval - v2->u64;
934 return PSI_T_DOUBLE;
935 case PSI_T_FLOAT:
936 res->dval = v1->dval - v2->fval;
937 return PSI_T_DOUBLE;
938 case PSI_T_DOUBLE:
939 res->dval = v1->dval - v2->dval;
940 return PSI_T_DOUBLE;
941 # if HAVE_LONG_DOUBLE
942 case PSI_T_LONG_DOUBLE:
943 res->ldval = v1->dval - v2->ldval;
944 return PSI_T_LONG_DOUBLE;
945 # endif
946
947 default:
948 assert(0);
949 break;
950 }
951 break;
952 #if HAVE_LONG_DOUBLE
953 case PSI_T_LONG_DOUBLE:
954 switch (t2) {
955 case PSI_T_INT8:
956 res->ldval = v1->ldval - v2->i8;
957 return PSI_T_LONG_DOUBLE;
958 case PSI_T_UINT8:
959 res->ldval = v1->ldval - v2->u8;
960 return PSI_T_LONG_DOUBLE;
961 case PSI_T_INT16:
962 res->ldval = v1->ldval - v2->i16;
963 return PSI_T_LONG_DOUBLE;
964 case PSI_T_UINT16:
965 res->ldval = v1->ldval - v2->u16;
966 return PSI_T_LONG_DOUBLE;
967 case PSI_T_INT32:
968 res->ldval = v1->ldval - v2->i32;
969 return PSI_T_LONG_DOUBLE;
970 case PSI_T_UINT32:
971 res->ldval = v1->ldval - v2->u32;
972 return PSI_T_LONG_DOUBLE;
973 case PSI_T_INT64:
974 res->ldval = v1->ldval - v2->i64;
975 return PSI_T_LONG_DOUBLE;
976 case PSI_T_UINT64:
977 res->ldval = v1->ldval - v2->u64;
978 return PSI_T_LONG_DOUBLE;
979 case PSI_T_FLOAT:
980 res->ldval = v1->ldval - v2->fval;
981 return PSI_T_LONG_DOUBLE;
982 case PSI_T_DOUBLE:
983 res->ldval = v1->ldval - v2->dval;
984 return PSI_T_LONG_DOUBLE;
985 # if HAVE_LONG_DOUBLE
986 case PSI_T_LONG_DOUBLE:
987 res->ldval = v1->ldval - v2->ldval;
988 return PSI_T_LONG_DOUBLE;
989 # endif
990
991 default:
992 assert(0);
993 break;
994 }
995 break;
996 #endif
997
998 default:
999 assert(0);
1000 break;
1001 }
1002
1003 return 0;
1004 }
1005 static inline token_t psi_calc_mul(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
1006 {
1007
1008 switch (t1) {
1009 case PSI_T_INT8:
1010 switch (t2) {
1011 case PSI_T_INT8:
1012 res->i16 = v1->i8 * v2->i8;
1013 return PSI_T_INT16;
1014 case PSI_T_UINT8:
1015 res->i16 = v1->i8 * v2->u8;
1016 return PSI_T_INT16;
1017 case PSI_T_INT16:
1018 res->i32 = v1->i8 * v2->i16;
1019 return PSI_T_INT32;
1020 case PSI_T_UINT16:
1021 res->i32 = v1->i8 * v2->u16;
1022 return PSI_T_INT32;
1023 case PSI_T_INT32:
1024 res->i64 = v1->i8 * v2->i32;
1025 return PSI_T_INT64;
1026 case PSI_T_UINT32:
1027 res->i64 = v1->i8 * v2->u32;
1028 return PSI_T_INT64;
1029 case PSI_T_INT64:
1030 res->i64 = v1->i8 * v2->i64;
1031 return PSI_T_INT64;
1032 case PSI_T_UINT64:
1033 res->i64 = v1->i8 * v2->u64;
1034 return PSI_T_INT64;
1035 case PSI_T_FLOAT:
1036 res->fval = v1->i8 * v2->fval;
1037 return PSI_T_FLOAT;
1038 case PSI_T_DOUBLE:
1039 res->dval = v1->i8 * v2->dval;
1040 return PSI_T_DOUBLE;
1041 # if HAVE_LONG_DOUBLE
1042 case PSI_T_LONG_DOUBLE:
1043 res->ldval = v1->i8 * v2->ldval;
1044 return PSI_T_LONG_DOUBLE;
1045 # endif
1046
1047 default:
1048 assert(0);
1049 break;
1050 }
1051 break;
1052 case PSI_T_UINT8:
1053 switch (t2) {
1054 case PSI_T_INT8:
1055 res->i16 = v1->u8 * v2->i8;
1056 return PSI_T_INT16;
1057 case PSI_T_UINT8:
1058 res->u16 = v1->u8 * v2->u8;
1059 return PSI_T_UINT16;
1060 case PSI_T_INT16:
1061 res->i32 = v1->u8 * v2->i16;
1062 return PSI_T_INT32;
1063 case PSI_T_UINT16:
1064 res->u32 = v1->u8 * v2->u16;
1065 return PSI_T_UINT32;
1066 case PSI_T_INT32:
1067 res->i64 = v1->u8 * v2->i32;
1068 return PSI_T_INT64;
1069 case PSI_T_UINT32:
1070 res->u64 = v1->u8 * v2->u32;
1071 return PSI_T_UINT64;
1072 case PSI_T_INT64:
1073 res->i64 = v1->u8 * v2->i64;
1074 return PSI_T_INT64;
1075 case PSI_T_UINT64:
1076 res->u64 = v1->u8 * v2->u64;
1077 return PSI_T_UINT64;
1078 case PSI_T_FLOAT:
1079 res->fval = v1->u8 * v2->fval;
1080 return PSI_T_FLOAT;
1081 case PSI_T_DOUBLE:
1082 res->dval = v1->u8 * v2->dval;
1083 return PSI_T_DOUBLE;
1084 # if HAVE_LONG_DOUBLE
1085 case PSI_T_LONG_DOUBLE:
1086 res->ldval = v1->u8 * v2->ldval;
1087 return PSI_T_LONG_DOUBLE;
1088 # endif
1089
1090 default:
1091 assert(0);
1092 break;
1093 }
1094 break;
1095 case PSI_T_INT16:
1096 switch (t2) {
1097 case PSI_T_INT8:
1098 res->i32 = v1->i16 * v2->i8;
1099 return PSI_T_INT32;
1100 case PSI_T_UINT8:
1101 res->i32 = v1->i16 * v2->u8;
1102 return PSI_T_INT32;
1103 case PSI_T_INT16:
1104 res->i32 = v1->i16 * v2->i16;
1105 return PSI_T_INT32;
1106 case PSI_T_UINT16:
1107 res->i32 = v1->i16 * v2->u16;
1108 return PSI_T_INT32;
1109 case PSI_T_INT32:
1110 res->i64 = v1->i16 * v2->i32;
1111 return PSI_T_INT64;
1112 case PSI_T_UINT32:
1113 res->i64 = v1->i16 * v2->u32;
1114 return PSI_T_INT64;
1115 case PSI_T_INT64:
1116 res->i64 = v1->i16 * v2->i64;
1117 return PSI_T_INT64;
1118 case PSI_T_UINT64:
1119 res->i64 = v1->i16 * v2->u64;
1120 return PSI_T_INT64;
1121 case PSI_T_FLOAT:
1122 res->fval = v1->i16 * v2->fval;
1123 return PSI_T_FLOAT;
1124 case PSI_T_DOUBLE:
1125 res->dval = v1->i16 * v2->dval;
1126 return PSI_T_DOUBLE;
1127 # if HAVE_LONG_DOUBLE
1128 case PSI_T_LONG_DOUBLE:
1129 res->ldval = v1->i16 * v2->ldval;
1130 return PSI_T_LONG_DOUBLE;
1131 # endif
1132
1133 default:
1134 assert(0);
1135 break;
1136 }
1137 break;
1138 case PSI_T_UINT16:
1139 switch (t2) {
1140 case PSI_T_INT8:
1141 res->i32 = v1->u16 * v2->i8;
1142 return PSI_T_INT32;
1143 case PSI_T_UINT8:
1144 res->u32 = v1->u16 * v2->u8;
1145 return PSI_T_UINT32;
1146 case PSI_T_INT16:
1147 res->i32 = v1->u16 * v2->i16;
1148 return PSI_T_INT32;
1149 case PSI_T_UINT16:
1150 res->u32 = v1->u16 * v2->u16;
1151 return PSI_T_UINT32;
1152 case PSI_T_INT32:
1153 res->i64 = v1->u16 * v2->i32;
1154 return PSI_T_INT64;
1155 case PSI_T_UINT32:
1156 res->u64 = v1->u16 * v2->u32;
1157 return PSI_T_UINT64;
1158 case PSI_T_INT64:
1159 res->i64 = v1->u16 * v2->i64;
1160 return PSI_T_INT64;
1161 case PSI_T_UINT64:
1162 res->u64 = v1->u16 * v2->u64;
1163 return PSI_T_UINT64;
1164 case PSI_T_FLOAT:
1165 res->fval = v1->u16 * v2->fval;
1166 return PSI_T_FLOAT;
1167 case PSI_T_DOUBLE:
1168 res->dval = v1->u16 * v2->dval;
1169 return PSI_T_DOUBLE;
1170 # if HAVE_LONG_DOUBLE
1171 case PSI_T_LONG_DOUBLE:
1172 res->ldval = v1->u16 * v2->ldval;
1173 return PSI_T_LONG_DOUBLE;
1174 # endif
1175
1176 default:
1177 assert(0);
1178 break;
1179 }
1180 break;
1181 case PSI_T_INT32:
1182 switch (t2) {
1183 case PSI_T_INT8:
1184 res->i64 = v1->i32 * v2->i8;
1185 return PSI_T_INT64;
1186 case PSI_T_UINT8:
1187 res->i64 = v1->i32 * v2->u8;
1188 return PSI_T_INT64;
1189 case PSI_T_INT16:
1190 res->i64 = v1->i32 * v2->i16;
1191 return PSI_T_INT64;
1192 case PSI_T_UINT16:
1193 res->i64 = v1->i32 * v2->u16;
1194 return PSI_T_INT64;
1195 case PSI_T_INT32:
1196 res->i64 = v1->i32 * v2->i32;
1197 return PSI_T_INT64;
1198 case PSI_T_UINT32:
1199 res->i64 = v1->i32 * v2->u32;
1200 return PSI_T_INT64;
1201 case PSI_T_INT64:
1202 res->i64 = v1->i32 * v2->i64;
1203 return PSI_T_INT64;
1204 case PSI_T_UINT64:
1205 res->i64 = v1->i32 * v2->u64;
1206 return PSI_T_INT64;
1207 case PSI_T_FLOAT:
1208 res->fval = v1->i32 * v2->fval;
1209 return PSI_T_FLOAT;
1210 case PSI_T_DOUBLE:
1211 res->dval = v1->i32 * v2->dval;
1212 return PSI_T_DOUBLE;
1213 # if HAVE_LONG_DOUBLE
1214 case PSI_T_LONG_DOUBLE:
1215 res->ldval = v1->i32 * v2->ldval;
1216 return PSI_T_LONG_DOUBLE;
1217 # endif
1218
1219 default:
1220 assert(0);
1221 break;
1222 }
1223 break;
1224 case PSI_T_UINT32:
1225 switch (t2) {
1226 case PSI_T_INT8:
1227 res->i64 = v1->u32 * v2->i8;
1228 return PSI_T_INT64;
1229 case PSI_T_UINT8:
1230 res->u64 = v1->u32 * v2->u8;
1231 return PSI_T_UINT64;
1232 case PSI_T_INT16:
1233 res->i64 = v1->u32 * v2->i16;
1234 return PSI_T_INT64;
1235 case PSI_T_UINT16:
1236 res->u64 = v1->u32 * v2->u16;
1237 return PSI_T_UINT64;
1238 case PSI_T_INT32:
1239 res->i64 = v1->u32 * v2->i32;
1240 return PSI_T_INT64;
1241 case PSI_T_UINT32:
1242 res->u64 = v1->u32 * v2->u32;
1243 return PSI_T_UINT64;
1244 case PSI_T_INT64:
1245 res->i64 = v1->u32 * v2->i64;
1246 return PSI_T_INT64;
1247 case PSI_T_UINT64:
1248 res->u64 = v1->u32 * v2->u64;
1249 return PSI_T_UINT64;
1250 case PSI_T_FLOAT:
1251 res->fval = v1->u32 * v2->fval;
1252 return PSI_T_FLOAT;
1253 case PSI_T_DOUBLE:
1254 res->dval = v1->u32 * v2->dval;
1255 return PSI_T_DOUBLE;
1256 # if HAVE_LONG_DOUBLE
1257 case PSI_T_LONG_DOUBLE:
1258 res->ldval = v1->u32 * v2->ldval;
1259 return PSI_T_LONG_DOUBLE;
1260 # endif
1261
1262 default:
1263 assert(0);
1264 break;
1265 }
1266 break;
1267 case PSI_T_INT64:
1268 switch (t2) {
1269 case PSI_T_INT8:
1270 res->i64 = v1->i64 * v2->i8;
1271 return PSI_T_INT64;
1272 case PSI_T_UINT8:
1273 res->i64 = v1->i64 * v2->u8;
1274 return PSI_T_INT64;
1275 case PSI_T_INT16:
1276 res->i64 = v1->i64 * v2->i16;
1277 return PSI_T_INT64;
1278 case PSI_T_UINT16:
1279 res->i64 = v1->i64 * v2->u16;
1280 return PSI_T_INT64;
1281 case PSI_T_INT32:
1282 res->i64 = v1->i64 * v2->i32;
1283 return PSI_T_INT64;
1284 case PSI_T_UINT32:
1285 res->i64 = v1->i64 * v2->u32;
1286 return PSI_T_INT64;
1287 case PSI_T_INT64:
1288 res->i64 = v1->i64 * v2->i64;
1289 return PSI_T_INT64;
1290 case PSI_T_UINT64:
1291 res->i64 = v1->i64 * v2->u64;
1292 return PSI_T_INT64;
1293 case PSI_T_FLOAT:
1294 res->fval = v1->i64 * v2->fval;
1295 return PSI_T_FLOAT;
1296 case PSI_T_DOUBLE:
1297 res->dval = v1->i64 * v2->dval;
1298 return PSI_T_DOUBLE;
1299 # if HAVE_LONG_DOUBLE
1300 case PSI_T_LONG_DOUBLE:
1301 res->ldval = v1->i64 * v2->ldval;
1302 return PSI_T_LONG_DOUBLE;
1303 # endif
1304
1305 default:
1306 assert(0);
1307 break;
1308 }
1309 break;
1310 case PSI_T_UINT64:
1311 switch (t2) {
1312 case PSI_T_INT8:
1313 res->i64 = v1->u64 * v2->i8;
1314 return PSI_T_INT64;
1315 case PSI_T_UINT8:
1316 res->u64 = v1->u64 * v2->u8;
1317 return PSI_T_UINT64;
1318 case PSI_T_INT16:
1319 res->i64 = v1->u64 * v2->i16;
1320 return PSI_T_INT64;
1321 case PSI_T_UINT16:
1322 res->u64 = v1->u64 * v2->u16;
1323 return PSI_T_UINT64;
1324 case PSI_T_INT32:
1325 res->i64 = v1->u64 * v2->i32;
1326 return PSI_T_INT64;
1327 case PSI_T_UINT32:
1328 res->u64 = v1->u64 * v2->u32;
1329 return PSI_T_UINT64;
1330 case PSI_T_INT64:
1331 res->i64 = v1->u64 * v2->i64;
1332 return PSI_T_INT64;
1333 case PSI_T_UINT64:
1334 res->u64 = v1->u64 * v2->u64;
1335 return PSI_T_UINT64;
1336 case PSI_T_FLOAT:
1337 res->fval = v1->u64 * v2->fval;
1338 return PSI_T_FLOAT;
1339 case PSI_T_DOUBLE:
1340 res->dval = v1->u64 * v2->dval;
1341 return PSI_T_DOUBLE;
1342 # if HAVE_LONG_DOUBLE
1343 case PSI_T_LONG_DOUBLE:
1344 res->ldval = v1->u64 * v2->ldval;
1345 return PSI_T_LONG_DOUBLE;
1346 # endif
1347
1348 default:
1349 assert(0);
1350 break;
1351 }
1352 break;
1353 case PSI_T_FLOAT:
1354 switch (t2) {
1355 case PSI_T_INT8:
1356 res->fval = v1->fval * v2->i8;
1357 return PSI_T_FLOAT;
1358 case PSI_T_UINT8:
1359 res->fval = v1->fval * v2->u8;
1360 return PSI_T_FLOAT;
1361 case PSI_T_INT16:
1362 res->fval = v1->fval * v2->i16;
1363 return PSI_T_FLOAT;
1364 case PSI_T_UINT16:
1365 res->fval = v1->fval * v2->u16;
1366 return PSI_T_FLOAT;
1367 case PSI_T_INT32:
1368 res->fval = v1->fval * v2->i32;
1369 return PSI_T_FLOAT;
1370 case PSI_T_UINT32:
1371 res->fval = v1->fval * v2->u32;
1372 return PSI_T_FLOAT;
1373 case PSI_T_INT64:
1374 res->fval = v1->fval * v2->i64;
1375 return PSI_T_FLOAT;
1376 case PSI_T_UINT64:
1377 res->fval = v1->fval * v2->u64;
1378 return PSI_T_FLOAT;
1379 case PSI_T_FLOAT:
1380 res->fval = v1->fval * v2->fval;
1381 return PSI_T_FLOAT;
1382 case PSI_T_DOUBLE:
1383 res->dval = v1->fval * v2->dval;
1384 return PSI_T_DOUBLE;
1385 # if HAVE_LONG_DOUBLE
1386 case PSI_T_LONG_DOUBLE:
1387 res->ldval = v1->fval * v2->ldval;
1388 return PSI_T_LONG_DOUBLE;
1389 # endif
1390
1391 default:
1392 assert(0);
1393 break;
1394 }
1395 break;
1396 case PSI_T_DOUBLE:
1397 switch (t2) {
1398 case PSI_T_INT8:
1399 res->dval = v1->dval * v2->i8;
1400 return PSI_T_DOUBLE;
1401 case PSI_T_UINT8:
1402 res->dval = v1->dval * v2->u8;
1403 return PSI_T_DOUBLE;
1404 case PSI_T_INT16:
1405 res->dval = v1->dval * v2->i16;
1406 return PSI_T_DOUBLE;
1407 case PSI_T_UINT16:
1408 res->dval = v1->dval * v2->u16;
1409 return PSI_T_DOUBLE;
1410 case PSI_T_INT32:
1411 res->dval = v1->dval * v2->i32;
1412 return PSI_T_DOUBLE;
1413 case PSI_T_UINT32:
1414 res->dval = v1->dval * v2->u32;
1415 return PSI_T_DOUBLE;
1416 case PSI_T_INT64:
1417 res->dval = v1->dval * v2->i64;
1418 return PSI_T_DOUBLE;
1419 case PSI_T_UINT64:
1420 res->dval = v1->dval * v2->u64;
1421 return PSI_T_DOUBLE;
1422 case PSI_T_FLOAT:
1423 res->dval = v1->dval * v2->fval;
1424 return PSI_T_DOUBLE;
1425 case PSI_T_DOUBLE:
1426 res->dval = v1->dval * v2->dval;
1427 return PSI_T_DOUBLE;
1428 # if HAVE_LONG_DOUBLE
1429 case PSI_T_LONG_DOUBLE:
1430 res->ldval = v1->dval * v2->ldval;
1431 return PSI_T_LONG_DOUBLE;
1432 # endif
1433
1434 default:
1435 assert(0);
1436 break;
1437 }
1438 break;
1439 #if HAVE_LONG_DOUBLE
1440 case PSI_T_LONG_DOUBLE:
1441 switch (t2) {
1442 case PSI_T_INT8:
1443 res->ldval = v1->ldval * v2->i8;
1444 return PSI_T_LONG_DOUBLE;
1445 case PSI_T_UINT8:
1446 res->ldval = v1->ldval * v2->u8;
1447 return PSI_T_LONG_DOUBLE;
1448 case PSI_T_INT16:
1449 res->ldval = v1->ldval * v2->i16;
1450 return PSI_T_LONG_DOUBLE;
1451 case PSI_T_UINT16:
1452 res->ldval = v1->ldval * v2->u16;
1453 return PSI_T_LONG_DOUBLE;
1454 case PSI_T_INT32:
1455 res->ldval = v1->ldval * v2->i32;
1456 return PSI_T_LONG_DOUBLE;
1457 case PSI_T_UINT32:
1458 res->ldval = v1->ldval * v2->u32;
1459 return PSI_T_LONG_DOUBLE;
1460 case PSI_T_INT64:
1461 res->ldval = v1->ldval * v2->i64;
1462 return PSI_T_LONG_DOUBLE;
1463 case PSI_T_UINT64:
1464 res->ldval = v1->ldval * v2->u64;
1465 return PSI_T_LONG_DOUBLE;
1466 case PSI_T_FLOAT:
1467 res->ldval = v1->ldval * v2->fval;
1468 return PSI_T_LONG_DOUBLE;
1469 case PSI_T_DOUBLE:
1470 res->ldval = v1->ldval * v2->dval;
1471 return PSI_T_LONG_DOUBLE;
1472 # if HAVE_LONG_DOUBLE
1473 case PSI_T_LONG_DOUBLE:
1474 res->ldval = v1->ldval * v2->ldval;
1475 return PSI_T_LONG_DOUBLE;
1476 # endif
1477
1478 default:
1479 assert(0);
1480 break;
1481 }
1482 break;
1483 #endif
1484
1485 default:
1486 assert(0);
1487 break;
1488 }
1489
1490 return 0;
1491 }
1492 static inline token_t psi_calc_div(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
1493 {
1494
1495 switch (t1) {
1496 case PSI_T_INT8:
1497 switch (t2) {
1498 case PSI_T_INT8:
1499 res->i16 = v1->i8 / v2->i8;
1500 return PSI_T_INT16;
1501 case PSI_T_UINT8:
1502 res->i16 = v1->i8 / v2->u8;
1503 return PSI_T_INT16;
1504 case PSI_T_INT16:
1505 res->i32 = v1->i8 / v2->i16;
1506 return PSI_T_INT32;
1507 case PSI_T_UINT16:
1508 res->i32 = v1->i8 / v2->u16;
1509 return PSI_T_INT32;
1510 case PSI_T_INT32:
1511 res->i64 = v1->i8 / v2->i32;
1512 return PSI_T_INT64;
1513 case PSI_T_UINT32:
1514 res->i64 = v1->i8 / v2->u32;
1515 return PSI_T_INT64;
1516 case PSI_T_INT64:
1517 res->i64 = v1->i8 / v2->i64;
1518 return PSI_T_INT64;
1519 case PSI_T_UINT64:
1520 res->i64 = v1->i8 / v2->u64;
1521 return PSI_T_INT64;
1522 case PSI_T_FLOAT:
1523 res->fval = v1->i8 / v2->fval;
1524 return PSI_T_FLOAT;
1525 case PSI_T_DOUBLE:
1526 res->dval = v1->i8 / v2->dval;
1527 return PSI_T_DOUBLE;
1528 # if HAVE_LONG_DOUBLE
1529 case PSI_T_LONG_DOUBLE:
1530 res->ldval = v1->i8 / v2->ldval;
1531 return PSI_T_LONG_DOUBLE;
1532 # endif
1533
1534 default:
1535 assert(0);
1536 break;
1537 }
1538 break;
1539 case PSI_T_UINT8:
1540 switch (t2) {
1541 case PSI_T_INT8:
1542 res->i16 = v1->u8 / v2->i8;
1543 return PSI_T_INT16;
1544 case PSI_T_UINT8:
1545 res->u16 = v1->u8 / v2->u8;
1546 return PSI_T_UINT16;
1547 case PSI_T_INT16:
1548 res->i32 = v1->u8 / v2->i16;
1549 return PSI_T_INT32;
1550 case PSI_T_UINT16:
1551 res->u32 = v1->u8 / v2->u16;
1552 return PSI_T_UINT32;
1553 case PSI_T_INT32:
1554 res->i64 = v1->u8 / v2->i32;
1555 return PSI_T_INT64;
1556 case PSI_T_UINT32:
1557 res->u64 = v1->u8 / v2->u32;
1558 return PSI_T_UINT64;
1559 case PSI_T_INT64:
1560 res->i64 = v1->u8 / v2->i64;
1561 return PSI_T_INT64;
1562 case PSI_T_UINT64:
1563 res->u64 = v1->u8 / v2->u64;
1564 return PSI_T_UINT64;
1565 case PSI_T_FLOAT:
1566 res->fval = v1->u8 / v2->fval;
1567 return PSI_T_FLOAT;
1568 case PSI_T_DOUBLE:
1569 res->dval = v1->u8 / v2->dval;
1570 return PSI_T_DOUBLE;
1571 # if HAVE_LONG_DOUBLE
1572 case PSI_T_LONG_DOUBLE:
1573 res->ldval = v1->u8 / v2->ldval;
1574 return PSI_T_LONG_DOUBLE;
1575 # endif
1576
1577 default:
1578 assert(0);
1579 break;
1580 }
1581 break;
1582 case PSI_T_INT16:
1583 switch (t2) {
1584 case PSI_T_INT8:
1585 res->i32 = v1->i16 / v2->i8;
1586 return PSI_T_INT32;
1587 case PSI_T_UINT8:
1588 res->i32 = v1->i16 / v2->u8;
1589 return PSI_T_INT32;
1590 case PSI_T_INT16:
1591 res->i32 = v1->i16 / v2->i16;
1592 return PSI_T_INT32;
1593 case PSI_T_UINT16:
1594 res->i32 = v1->i16 / v2->u16;
1595 return PSI_T_INT32;
1596 case PSI_T_INT32:
1597 res->i64 = v1->i16 / v2->i32;
1598 return PSI_T_INT64;
1599 case PSI_T_UINT32:
1600 res->i64 = v1->i16 / v2->u32;
1601 return PSI_T_INT64;
1602 case PSI_T_INT64:
1603 res->i64 = v1->i16 / v2->i64;
1604 return PSI_T_INT64;
1605 case PSI_T_UINT64:
1606 res->i64 = v1->i16 / v2->u64;
1607 return PSI_T_INT64;
1608 case PSI_T_FLOAT:
1609 res->fval = v1->i16 / v2->fval;
1610 return PSI_T_FLOAT;
1611 case PSI_T_DOUBLE:
1612 res->dval = v1->i16 / v2->dval;
1613 return PSI_T_DOUBLE;
1614 # if HAVE_LONG_DOUBLE
1615 case PSI_T_LONG_DOUBLE:
1616 res->ldval = v1->i16 / v2->ldval;
1617 return PSI_T_LONG_DOUBLE;
1618 # endif
1619
1620 default:
1621 assert(0);
1622 break;
1623 }
1624 break;
1625 case PSI_T_UINT16:
1626 switch (t2) {
1627 case PSI_T_INT8:
1628 res->i32 = v1->u16 / v2->i8;
1629 return PSI_T_INT32;
1630 case PSI_T_UINT8:
1631 res->u32 = v1->u16 / v2->u8;
1632 return PSI_T_UINT32;
1633 case PSI_T_INT16:
1634 res->i32 = v1->u16 / v2->i16;
1635 return PSI_T_INT32;
1636 case PSI_T_UINT16:
1637 res->u32 = v1->u16 / v2->u16;
1638 return PSI_T_UINT32;
1639 case PSI_T_INT32:
1640 res->i64 = v1->u16 / v2->i32;
1641 return PSI_T_INT64;
1642 case PSI_T_UINT32:
1643 res->u64 = v1->u16 / v2->u32;
1644 return PSI_T_UINT64;
1645 case PSI_T_INT64:
1646 res->i64 = v1->u16 / v2->i64;
1647 return PSI_T_INT64;
1648 case PSI_T_UINT64:
1649 res->u64 = v1->u16 / v2->u64;
1650 return PSI_T_UINT64;
1651 case PSI_T_FLOAT:
1652 res->fval = v1->u16 / v2->fval;
1653 return PSI_T_FLOAT;
1654 case PSI_T_DOUBLE:
1655 res->dval = v1->u16 / v2->dval;
1656 return PSI_T_DOUBLE;
1657 # if HAVE_LONG_DOUBLE
1658 case PSI_T_LONG_DOUBLE:
1659 res->ldval = v1->u16 / v2->ldval;
1660 return PSI_T_LONG_DOUBLE;
1661 # endif
1662
1663 default:
1664 assert(0);
1665 break;
1666 }
1667 break;
1668 case PSI_T_INT32:
1669 switch (t2) {
1670 case PSI_T_INT8:
1671 res->i64 = v1->i32 / v2->i8;
1672 return PSI_T_INT64;
1673 case PSI_T_UINT8:
1674 res->i64 = v1->i32 / v2->u8;
1675 return PSI_T_INT64;
1676 case PSI_T_INT16:
1677 res->i64 = v1->i32 / v2->i16;
1678 return PSI_T_INT64;
1679 case PSI_T_UINT16:
1680 res->i64 = v1->i32 / v2->u16;
1681 return PSI_T_INT64;
1682 case PSI_T_INT32:
1683 res->i64 = v1->i32 / v2->i32;
1684 return PSI_T_INT64;
1685 case PSI_T_UINT32:
1686 res->i64 = v1->i32 / v2->u32;
1687 return PSI_T_INT64;
1688 case PSI_T_INT64:
1689 res->i64 = v1->i32 / v2->i64;
1690 return PSI_T_INT64;
1691 case PSI_T_UINT64:
1692 res->i64 = v1->i32 / v2->u64;
1693 return PSI_T_INT64;
1694 case PSI_T_FLOAT:
1695 res->fval = v1->i32 / v2->fval;
1696 return PSI_T_FLOAT;
1697 case PSI_T_DOUBLE:
1698 res->dval = v1->i32 / v2->dval;
1699 return PSI_T_DOUBLE;
1700 # if HAVE_LONG_DOUBLE
1701 case PSI_T_LONG_DOUBLE:
1702 res->ldval = v1->i32 / v2->ldval;
1703 return PSI_T_LONG_DOUBLE;
1704 # endif
1705
1706 default:
1707 assert(0);
1708 break;
1709 }
1710 break;
1711 case PSI_T_UINT32:
1712 switch (t2) {
1713 case PSI_T_INT8:
1714 res->i64 = v1->u32 / v2->i8;
1715 return PSI_T_INT64;
1716 case PSI_T_UINT8:
1717 res->u64 = v1->u32 / v2->u8;
1718 return PSI_T_UINT64;
1719 case PSI_T_INT16:
1720 res->i64 = v1->u32 / v2->i16;
1721 return PSI_T_INT64;
1722 case PSI_T_UINT16:
1723 res->u64 = v1->u32 / v2->u16;
1724 return PSI_T_UINT64;
1725 case PSI_T_INT32:
1726 res->i64 = v1->u32 / v2->i32;
1727 return PSI_T_INT64;
1728 case PSI_T_UINT32:
1729 res->u64 = v1->u32 / v2->u32;
1730 return PSI_T_UINT64;
1731 case PSI_T_INT64:
1732 res->i64 = v1->u32 / v2->i64;
1733 return PSI_T_INT64;
1734 case PSI_T_UINT64:
1735 res->u64 = v1->u32 / v2->u64;
1736 return PSI_T_UINT64;
1737 case PSI_T_FLOAT:
1738 res->fval = v1->u32 / v2->fval;
1739 return PSI_T_FLOAT;
1740 case PSI_T_DOUBLE:
1741 res->dval = v1->u32 / v2->dval;
1742 return PSI_T_DOUBLE;
1743 # if HAVE_LONG_DOUBLE
1744 case PSI_T_LONG_DOUBLE:
1745 res->ldval = v1->u32 / v2->ldval;
1746 return PSI_T_LONG_DOUBLE;
1747 # endif
1748
1749 default:
1750 assert(0);
1751 break;
1752 }
1753 break;
1754 case PSI_T_INT64:
1755 switch (t2) {
1756 case PSI_T_INT8:
1757 res->i64 = v1->i64 / v2->i8;
1758 return PSI_T_INT64;
1759 case PSI_T_UINT8:
1760 res->i64 = v1->i64 / v2->u8;
1761 return PSI_T_INT64;
1762 case PSI_T_INT16:
1763 res->i64 = v1->i64 / v2->i16;
1764 return PSI_T_INT64;
1765 case PSI_T_UINT16:
1766 res->i64 = v1->i64 / v2->u16;
1767 return PSI_T_INT64;
1768 case PSI_T_INT32:
1769 res->i64 = v1->i64 / v2->i32;
1770 return PSI_T_INT64;
1771 case PSI_T_UINT32:
1772 res->i64 = v1->i64 / v2->u32;
1773 return PSI_T_INT64;
1774 case PSI_T_INT64:
1775 res->i64 = v1->i64 / v2->i64;
1776 return PSI_T_INT64;
1777 case PSI_T_UINT64:
1778 res->i64 = v1->i64 / v2->u64;
1779 return PSI_T_INT64;
1780 case PSI_T_FLOAT:
1781 res->fval = v1->i64 / v2->fval;
1782 return PSI_T_FLOAT;
1783 case PSI_T_DOUBLE:
1784 res->dval = v1->i64 / v2->dval;
1785 return PSI_T_DOUBLE;
1786 # if HAVE_LONG_DOUBLE
1787 case PSI_T_LONG_DOUBLE:
1788 res->ldval = v1->i64 / v2->ldval;
1789 return PSI_T_LONG_DOUBLE;
1790 # endif
1791
1792 default:
1793 assert(0);
1794 break;
1795 }
1796 break;
1797 case PSI_T_UINT64:
1798 switch (t2) {
1799 case PSI_T_INT8:
1800 res->i64 = v1->u64 / v2->i8;
1801 return PSI_T_INT64;
1802 case PSI_T_UINT8:
1803 res->u64 = v1->u64 / v2->u8;
1804 return PSI_T_UINT64;
1805 case PSI_T_INT16:
1806 res->i64 = v1->u64 / v2->i16;
1807 return PSI_T_INT64;
1808 case PSI_T_UINT16:
1809 res->u64 = v1->u64 / v2->u16;
1810 return PSI_T_UINT64;
1811 case PSI_T_INT32:
1812 res->i64 = v1->u64 / v2->i32;
1813 return PSI_T_INT64;
1814 case PSI_T_UINT32:
1815 res->u64 = v1->u64 / v2->u32;
1816 return PSI_T_UINT64;
1817 case PSI_T_INT64:
1818 res->i64 = v1->u64 / v2->i64;
1819 return PSI_T_INT64;
1820 case PSI_T_UINT64:
1821 res->u64 = v1->u64 / v2->u64;
1822 return PSI_T_UINT64;
1823 case PSI_T_FLOAT:
1824 res->fval = v1->u64 / v2->fval;
1825 return PSI_T_FLOAT;
1826 case PSI_T_DOUBLE:
1827 res->dval = v1->u64 / v2->dval;
1828 return PSI_T_DOUBLE;
1829 # if HAVE_LONG_DOUBLE
1830 case PSI_T_LONG_DOUBLE:
1831 res->ldval = v1->u64 / v2->ldval;
1832 return PSI_T_LONG_DOUBLE;
1833 # endif
1834
1835 default:
1836 assert(0);
1837 break;
1838 }
1839 break;
1840 case PSI_T_FLOAT:
1841 switch (t2) {
1842 case PSI_T_INT8:
1843 res->fval = v1->fval / v2->i8;
1844 return PSI_T_FLOAT;
1845 case PSI_T_UINT8:
1846 res->fval = v1->fval / v2->u8;
1847 return PSI_T_FLOAT;
1848 case PSI_T_INT16:
1849 res->fval = v1->fval / v2->i16;
1850 return PSI_T_FLOAT;
1851 case PSI_T_UINT16:
1852 res->fval = v1->fval / v2->u16;
1853 return PSI_T_FLOAT;
1854 case PSI_T_INT32:
1855 res->fval = v1->fval / v2->i32;
1856 return PSI_T_FLOAT;
1857 case PSI_T_UINT32:
1858 res->fval = v1->fval / v2->u32;
1859 return PSI_T_FLOAT;
1860 case PSI_T_INT64:
1861 res->fval = v1->fval / v2->i64;
1862 return PSI_T_FLOAT;
1863 case PSI_T_UINT64:
1864 res->fval = v1->fval / v2->u64;
1865 return PSI_T_FLOAT;
1866 case PSI_T_FLOAT:
1867 res->fval = v1->fval / v2->fval;
1868 return PSI_T_FLOAT;
1869 case PSI_T_DOUBLE:
1870 res->dval = v1->fval / v2->dval;
1871 return PSI_T_DOUBLE;
1872 # if HAVE_LONG_DOUBLE
1873 case PSI_T_LONG_DOUBLE:
1874 res->ldval = v1->fval / v2->ldval;
1875 return PSI_T_LONG_DOUBLE;
1876 # endif
1877
1878 default:
1879 assert(0);
1880 break;
1881 }
1882 break;
1883 case PSI_T_DOUBLE:
1884 switch (t2) {
1885 case PSI_T_INT8:
1886 res->dval = v1->dval / v2->i8;
1887 return PSI_T_DOUBLE;
1888 case PSI_T_UINT8:
1889 res->dval = v1->dval / v2->u8;
1890 return PSI_T_DOUBLE;
1891 case PSI_T_INT16:
1892 res->dval = v1->dval / v2->i16;
1893 return PSI_T_DOUBLE;
1894 case PSI_T_UINT16:
1895 res->dval = v1->dval / v2->u16;
1896 return PSI_T_DOUBLE;
1897 case PSI_T_INT32:
1898 res->dval = v1->dval / v2->i32;
1899 return PSI_T_DOUBLE;
1900 case PSI_T_UINT32:
1901 res->dval = v1->dval / v2->u32;
1902 return PSI_T_DOUBLE;
1903 case PSI_T_INT64:
1904 res->dval = v1->dval / v2->i64;
1905 return PSI_T_DOUBLE;
1906 case PSI_T_UINT64:
1907 res->dval = v1->dval / v2->u64;
1908 return PSI_T_DOUBLE;
1909 case PSI_T_FLOAT:
1910 res->dval = v1->dval / v2->fval;
1911 return PSI_T_DOUBLE;
1912 case PSI_T_DOUBLE:
1913 res->dval = v1->dval / v2->dval;
1914 return PSI_T_DOUBLE;
1915 # if HAVE_LONG_DOUBLE
1916 case PSI_T_LONG_DOUBLE:
1917 res->ldval = v1->dval / v2->ldval;
1918 return PSI_T_LONG_DOUBLE;
1919 # endif
1920
1921 default:
1922 assert(0);
1923 break;
1924 }
1925 break;
1926 #if HAVE_LONG_DOUBLE
1927 case PSI_T_LONG_DOUBLE:
1928 switch (t2) {
1929 case PSI_T_INT8:
1930 res->ldval = v1->ldval / v2->i8;
1931 return PSI_T_LONG_DOUBLE;
1932 case PSI_T_UINT8:
1933 res->ldval = v1->ldval / v2->u8;
1934 return PSI_T_LONG_DOUBLE;
1935 case PSI_T_INT16:
1936 res->ldval = v1->ldval / v2->i16;
1937 return PSI_T_LONG_DOUBLE;
1938 case PSI_T_UINT16:
1939 res->ldval = v1->ldval / v2->u16;
1940 return PSI_T_LONG_DOUBLE;
1941 case PSI_T_INT32:
1942 res->ldval = v1->ldval / v2->i32;
1943 return PSI_T_LONG_DOUBLE;
1944 case PSI_T_UINT32:
1945 res->ldval = v1->ldval / v2->u32;
1946 return PSI_T_LONG_DOUBLE;
1947 case PSI_T_INT64:
1948 res->ldval = v1->ldval / v2->i64;
1949 return PSI_T_LONG_DOUBLE;
1950 case PSI_T_UINT64:
1951 res->ldval = v1->ldval / v2->u64;
1952 return PSI_T_LONG_DOUBLE;
1953 case PSI_T_FLOAT:
1954 res->ldval = v1->ldval / v2->fval;
1955 return PSI_T_LONG_DOUBLE;
1956 case PSI_T_DOUBLE:
1957 res->ldval = v1->ldval / v2->dval;
1958 return PSI_T_LONG_DOUBLE;
1959 # if HAVE_LONG_DOUBLE
1960 case PSI_T_LONG_DOUBLE:
1961 res->ldval = v1->ldval / v2->ldval;
1962 return PSI_T_LONG_DOUBLE;
1963 # endif
1964
1965 default:
1966 assert(0);
1967 break;
1968 }
1969 break;
1970 #endif
1971
1972 default:
1973 assert(0);
1974 break;
1975 }
1976
1977 return 0;
1978 }
1979
1980
1981 static inline token_t psi_calc_mod(token_t t1, impl_val *v1, token_t t2, impl_val *v2, impl_val *res)
1982 {
1983 impl_val i1, i2;
1984
1985 switch (t1) {
1986 case PSI_T_INT8:
1987 i1.i64 = v1->i8;
1988 break;
1989
1990 case PSI_T_UINT8:
1991 i1.i64 = v1->u8;
1992 break;
1993
1994 case PSI_T_INT16:
1995 i1.i64 = v1->i16;
1996 break;
1997
1998 case PSI_T_UINT16:
1999 i1.i64 = v1->u16;
2000 break;
2001
2002 case PSI_T_INT32:
2003 i1.i64 = v1->i32;
2004 break;
2005
2006 case PSI_T_UINT32:
2007 i1.i64 = v1->u32;
2008 break;
2009
2010 case PSI_T_INT64:
2011 i1.i64 = v1->i64;
2012 break;
2013
2014 case PSI_T_UINT64:
2015 i1.i64 = v1->u64;
2016 break;
2017
2018 case PSI_T_FLOAT:
2019 i1.i64 = v1->fval;
2020 break;
2021
2022 case PSI_T_DOUBLE:
2023 i1.i64 = v1->dval;
2024 break;
2025
2026 #if HAVE_LONG_DOUBLE
2027 case PSI_T_LONG_DOUBLE:
2028 i1.i64 = v1->ldval;
2029 break;
2030
2031 #endif
2032
2033 default:
2034 assert(0);
2035 break;
2036 }
2037
2038 switch (t2) {
2039 case PSI_T_INT8:
2040 i2.i64 = v2->i8;
2041 break;
2042 case PSI_T_UINT8:
2043 i2.i64 = v2->u8;
2044 break;
2045 case PSI_T_INT16:
2046 i2.i64 = v2->i16;
2047 break;
2048 case PSI_T_UINT16:
2049 i2.i64 = v2->u16;
2050 break;
2051 case PSI_T_INT32:
2052 i2.i64 = v2->i32;
2053 break;
2054 case PSI_T_UINT32:
2055 i2.i64 = v2->u32;
2056 break;
2057 case PSI_T_INT64:
2058 i2.i64 = v2->i64;
2059 break;
2060 case PSI_T_UINT64:
2061 i2.i64 = v2->u64;
2062 break;
2063 case PSI_T_FLOAT:
2064 i2.i64 = v2->fval;
2065 break;
2066 case PSI_T_DOUBLE:
2067 i2.i64 = v2->dval;
2068 break;
2069 #if HAVE_LONG_DOUBLE
2070 case PSI_T_LONG_DOUBLE:
2071 i2.i64 = v2->ldval;
2072 break;
2073 #endif
2074
2075 default:
2076 assert(0);
2077 break;
2078 }
2079
2080 res->i64 = i1.i64 % i2.i64;
2081 return PSI_T_INT64;
2082 }
PHP System Interface / POSIX Standard Interface