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


c6f14aa0e2e491b099c6468c07fb07c62ac3ff53
[m6w6/ext-psi] / src / calc / cast.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 void psi_calc_cast(token_t in_type, impl_val *in_val, token_t out_type, impl_val *out_val)
32 {
33 switch (out_type) {
34 case PSI_T_INT8:
35 switch (in_type) {
36 case PSI_T_INT8:
37 out_val->i8 = in_val->i8;
38 break;
39 case PSI_T_UINT8:
40 out_val->i8 = in_val->u8;
41 break;
42 case PSI_T_INT16:
43 out_val->i8 = in_val->i16;
44 break;
45 case PSI_T_UINT16:
46 out_val->i8 = in_val->u16;
47 break;
48 case PSI_T_INT32:
49 out_val->i8 = in_val->i32;
50 break;
51 case PSI_T_UINT32:
52 out_val->i8 = in_val->u32;
53 break;
54 case PSI_T_INT64:
55 out_val->i8 = in_val->i64;
56 break;
57 case PSI_T_UINT64:
58 out_val->i8 = in_val->u64;
59 break;
60 case PSI_T_FLOAT:
61 out_val->i8 = in_val->fval;
62 break;
63 case PSI_T_DOUBLE:
64 out_val->i8 = in_val->dval;
65 break;
66 # if HAVE_LONG_DOUBLE
67 case PSI_T_LONG_DOUBLE:
68 out_val->i8 = in_val->ldval;
69 break;
70 # endif
71
72 default:
73 assert(0);
74 break;
75 }
76 break;
77 case PSI_T_UINT8:
78 switch (in_type) {
79 case PSI_T_INT8:
80 out_val->u8 = in_val->i8;
81 break;
82 case PSI_T_UINT8:
83 out_val->u8 = in_val->u8;
84 break;
85 case PSI_T_INT16:
86 out_val->u8 = in_val->i16;
87 break;
88 case PSI_T_UINT16:
89 out_val->u8 = in_val->u16;
90 break;
91 case PSI_T_INT32:
92 out_val->u8 = in_val->i32;
93 break;
94 case PSI_T_UINT32:
95 out_val->u8 = in_val->u32;
96 break;
97 case PSI_T_INT64:
98 out_val->u8 = in_val->i64;
99 break;
100 case PSI_T_UINT64:
101 out_val->u8 = in_val->u64;
102 break;
103 case PSI_T_FLOAT:
104 out_val->u8 = in_val->fval;
105 break;
106 case PSI_T_DOUBLE:
107 out_val->u8 = in_val->dval;
108 break;
109 # if HAVE_LONG_DOUBLE
110 case PSI_T_LONG_DOUBLE:
111 out_val->u8 = in_val->ldval;
112 break;
113 # endif
114
115 default:
116 assert(0);
117 break;
118 }
119 break;
120 case PSI_T_INT16:
121 switch (in_type) {
122 case PSI_T_INT8:
123 out_val->i16 = in_val->i8;
124 break;
125 case PSI_T_UINT8:
126 out_val->i16 = in_val->u8;
127 break;
128 case PSI_T_INT16:
129 out_val->i16 = in_val->i16;
130 break;
131 case PSI_T_UINT16:
132 out_val->i16 = in_val->u16;
133 break;
134 case PSI_T_INT32:
135 out_val->i16 = in_val->i32;
136 break;
137 case PSI_T_UINT32:
138 out_val->i16 = in_val->u32;
139 break;
140 case PSI_T_INT64:
141 out_val->i16 = in_val->i64;
142 break;
143 case PSI_T_UINT64:
144 out_val->i16 = in_val->u64;
145 break;
146 case PSI_T_FLOAT:
147 out_val->i16 = in_val->fval;
148 break;
149 case PSI_T_DOUBLE:
150 out_val->i16 = in_val->dval;
151 break;
152 # if HAVE_LONG_DOUBLE
153 case PSI_T_LONG_DOUBLE:
154 out_val->i16 = in_val->ldval;
155 break;
156 # endif
157
158 default:
159 assert(0);
160 break;
161 }
162 break;
163 case PSI_T_UINT16:
164 switch (in_type) {
165 case PSI_T_INT8:
166 out_val->u16 = in_val->i8;
167 break;
168 case PSI_T_UINT8:
169 out_val->u16 = in_val->u8;
170 break;
171 case PSI_T_INT16:
172 out_val->u16 = in_val->i16;
173 break;
174 case PSI_T_UINT16:
175 out_val->u16 = in_val->u16;
176 break;
177 case PSI_T_INT32:
178 out_val->u16 = in_val->i32;
179 break;
180 case PSI_T_UINT32:
181 out_val->u16 = in_val->u32;
182 break;
183 case PSI_T_INT64:
184 out_val->u16 = in_val->i64;
185 break;
186 case PSI_T_UINT64:
187 out_val->u16 = in_val->u64;
188 break;
189 case PSI_T_FLOAT:
190 out_val->u16 = in_val->fval;
191 break;
192 case PSI_T_DOUBLE:
193 out_val->u16 = in_val->dval;
194 break;
195 # if HAVE_LONG_DOUBLE
196 case PSI_T_LONG_DOUBLE:
197 out_val->u16 = in_val->ldval;
198 break;
199 # endif
200
201 default:
202 assert(0);
203 break;
204 }
205 break;
206 case PSI_T_INT32:
207 switch (in_type) {
208 case PSI_T_INT8:
209 out_val->i32 = in_val->i8;
210 break;
211 case PSI_T_UINT8:
212 out_val->i32 = in_val->u8;
213 break;
214 case PSI_T_INT16:
215 out_val->i32 = in_val->i16;
216 break;
217 case PSI_T_UINT16:
218 out_val->i32 = in_val->u16;
219 break;
220 case PSI_T_INT32:
221 out_val->i32 = in_val->i32;
222 break;
223 case PSI_T_UINT32:
224 out_val->i32 = in_val->u32;
225 break;
226 case PSI_T_INT64:
227 out_val->i32 = in_val->i64;
228 break;
229 case PSI_T_UINT64:
230 out_val->i32 = in_val->u64;
231 break;
232 case PSI_T_FLOAT:
233 out_val->i32 = in_val->fval;
234 break;
235 case PSI_T_DOUBLE:
236 out_val->i32 = in_val->dval;
237 break;
238 # if HAVE_LONG_DOUBLE
239 case PSI_T_LONG_DOUBLE:
240 out_val->i32 = in_val->ldval;
241 break;
242 # endif
243
244 default:
245 assert(0);
246 break;
247 }
248 break;
249 case PSI_T_UINT32:
250 switch (in_type) {
251 case PSI_T_INT8:
252 out_val->u32 = in_val->i8;
253 break;
254 case PSI_T_UINT8:
255 out_val->u32 = in_val->u8;
256 break;
257 case PSI_T_INT16:
258 out_val->u32 = in_val->i16;
259 break;
260 case PSI_T_UINT16:
261 out_val->u32 = in_val->u16;
262 break;
263 case PSI_T_INT32:
264 out_val->u32 = in_val->i32;
265 break;
266 case PSI_T_UINT32:
267 out_val->u32 = in_val->u32;
268 break;
269 case PSI_T_INT64:
270 out_val->u32 = in_val->i64;
271 break;
272 case PSI_T_UINT64:
273 out_val->u32 = in_val->u64;
274 break;
275 case PSI_T_FLOAT:
276 out_val->u32 = in_val->fval;
277 break;
278 case PSI_T_DOUBLE:
279 out_val->u32 = in_val->dval;
280 break;
281 # if HAVE_LONG_DOUBLE
282 case PSI_T_LONG_DOUBLE:
283 out_val->u32 = in_val->ldval;
284 break;
285 # endif
286
287 default:
288 assert(0);
289 break;
290 }
291 break;
292 case PSI_T_INT64:
293 switch (in_type) {
294 case PSI_T_INT8:
295 out_val->i64 = in_val->i8;
296 break;
297 case PSI_T_UINT8:
298 out_val->i64 = in_val->u8;
299 break;
300 case PSI_T_INT16:
301 out_val->i64 = in_val->i16;
302 break;
303 case PSI_T_UINT16:
304 out_val->i64 = in_val->u16;
305 break;
306 case PSI_T_INT32:
307 out_val->i64 = in_val->i32;
308 break;
309 case PSI_T_UINT32:
310 out_val->i64 = in_val->u32;
311 break;
312 case PSI_T_INT64:
313 out_val->i64 = in_val->i64;
314 break;
315 case PSI_T_UINT64:
316 out_val->i64 = in_val->u64;
317 break;
318 case PSI_T_FLOAT:
319 out_val->i64 = in_val->fval;
320 break;
321 case PSI_T_DOUBLE:
322 out_val->i64 = in_val->dval;
323 break;
324 # if HAVE_LONG_DOUBLE
325 case PSI_T_LONG_DOUBLE:
326 out_val->i64 = in_val->ldval;
327 break;
328 # endif
329
330 default:
331 assert(0);
332 break;
333 }
334 break;
335 case PSI_T_UINT64:
336 switch (in_type) {
337 case PSI_T_INT8:
338 out_val->u64 = in_val->i8;
339 break;
340 case PSI_T_UINT8:
341 out_val->u64 = in_val->u8;
342 break;
343 case PSI_T_INT16:
344 out_val->u64 = in_val->i16;
345 break;
346 case PSI_T_UINT16:
347 out_val->u64 = in_val->u16;
348 break;
349 case PSI_T_INT32:
350 out_val->u64 = in_val->i32;
351 break;
352 case PSI_T_UINT32:
353 out_val->u64 = in_val->u32;
354 break;
355 case PSI_T_INT64:
356 out_val->u64 = in_val->i64;
357 break;
358 case PSI_T_UINT64:
359 out_val->u64 = in_val->u64;
360 break;
361 case PSI_T_FLOAT:
362 out_val->u64 = in_val->fval;
363 break;
364 case PSI_T_DOUBLE:
365 out_val->u64 = in_val->dval;
366 break;
367 # if HAVE_LONG_DOUBLE
368 case PSI_T_LONG_DOUBLE:
369 out_val->u64 = in_val->ldval;
370 break;
371 # endif
372
373 default:
374 assert(0);
375 break;
376 }
377 break;
378 case PSI_T_FLOAT:
379 switch (in_type) {
380 case PSI_T_INT8:
381 out_val->fval = in_val->i8;
382 break;
383 case PSI_T_UINT8:
384 out_val->fval = in_val->u8;
385 break;
386 case PSI_T_INT16:
387 out_val->fval = in_val->i16;
388 break;
389 case PSI_T_UINT16:
390 out_val->fval = in_val->u16;
391 break;
392 case PSI_T_INT32:
393 out_val->fval = in_val->i32;
394 break;
395 case PSI_T_UINT32:
396 out_val->fval = in_val->u32;
397 break;
398 case PSI_T_INT64:
399 out_val->fval = in_val->i64;
400 break;
401 case PSI_T_UINT64:
402 out_val->fval = in_val->u64;
403 break;
404 case PSI_T_FLOAT:
405 out_val->fval = in_val->fval;
406 break;
407 case PSI_T_DOUBLE:
408 out_val->fval = in_val->dval;
409 break;
410 # if HAVE_LONG_DOUBLE
411 case PSI_T_LONG_DOUBLE:
412 out_val->fval = in_val->ldval;
413 break;
414 # endif
415
416 default:
417 assert(0);
418 break;
419 }
420 break;
421 case PSI_T_DOUBLE:
422 switch (in_type) {
423 case PSI_T_INT8:
424 out_val->dval = in_val->i8;
425 break;
426 case PSI_T_UINT8:
427 out_val->dval = in_val->u8;
428 break;
429 case PSI_T_INT16:
430 out_val->dval = in_val->i16;
431 break;
432 case PSI_T_UINT16:
433 out_val->dval = in_val->u16;
434 break;
435 case PSI_T_INT32:
436 out_val->dval = in_val->i32;
437 break;
438 case PSI_T_UINT32:
439 out_val->dval = in_val->u32;
440 break;
441 case PSI_T_INT64:
442 out_val->dval = in_val->i64;
443 break;
444 case PSI_T_UINT64:
445 out_val->dval = in_val->u64;
446 break;
447 case PSI_T_FLOAT:
448 out_val->dval = in_val->fval;
449 break;
450 case PSI_T_DOUBLE:
451 out_val->dval = in_val->dval;
452 break;
453 # if HAVE_LONG_DOUBLE
454 case PSI_T_LONG_DOUBLE:
455 out_val->dval = in_val->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 (in_type) {
467 case PSI_T_INT8:
468 out_val->ldval = in_val->i8;
469 break;
470 case PSI_T_UINT8:
471 out_val->ldval = in_val->u8;
472 break;
473 case PSI_T_INT16:
474 out_val->ldval = in_val->i16;
475 break;
476 case PSI_T_UINT16:
477 out_val->ldval = in_val->u16;
478 break;
479 case PSI_T_INT32:
480 out_val->ldval = in_val->i32;
481 break;
482 case PSI_T_UINT32:
483 out_val->ldval = in_val->u32;
484 break;
485 case PSI_T_INT64:
486 out_val->ldval = in_val->i64;
487 break;
488 case PSI_T_UINT64:
489 out_val->ldval = in_val->u64;
490 break;
491 case PSI_T_FLOAT:
492 out_val->ldval = in_val->fval;
493 break;
494 case PSI_T_DOUBLE:
495 out_val->ldval = in_val->dval;
496 break;
497 # if HAVE_LONG_DOUBLE
498 case PSI_T_LONG_DOUBLE:
499 out_val->ldval = in_val->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 }
515
PHP System Interface / POSIX Standard Interface