git.m6w6.name Git - m6w6/ext-psi/blob - 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_INT128:
  61                         out_val->i8 = in_val->i128;
  62                         break;
  63                 case PSI_T_UINT128:
  64                         out_val->i8 = in_val->u128;
  65                         break;
  66                 case PSI_T_FLOAT:
  67                         out_val->i8 = in_val->fval;
  68                         break;
  69                 case PSI_T_DOUBLE:
  70                         out_val->i8 = in_val->dval;
  71                         break;
  72 #       if HAVE_LONG_DOUBLE
  73                 case PSI_T_LONG_DOUBLE:
  74                         out_val->i8 = in_val->ldval;
  75                         break;
  76 #       endif
  77
  78                 default:
  79                         assert(0);
  80                         break;
  81                 }
  82                 break;
  83         case PSI_T_UINT8:
  84                 switch (in_type) {
  85                 case PSI_T_INT8:
  86                         out_val->u8 = in_val->i8;
  87                         break;
  88                 case PSI_T_UINT8:
  89                         out_val->u8 = in_val->u8;
  90                         break;
  91                 case PSI_T_INT16:
  92                         out_val->u8 = in_val->i16;
  93                         break;
  94                 case PSI_T_UINT16:
  95                         out_val->u8 = in_val->u16;
  96                         break;
  97                 case PSI_T_INT32:
  98                         out_val->u8 = in_val->i32;
  99                         break;
 100                 case PSI_T_UINT32:
 101                         out_val->u8 = in_val->u32;
 102                         break;
 103                 case PSI_T_INT64:
 104                         out_val->u8 = in_val->i64;
 105                         break;
 106                 case PSI_T_UINT64:
 107                         out_val->u8 = in_val->u64;
 108                         break;
 109                 case PSI_T_INT128:
 110                         out_val->u8 = in_val->i128;
 111                         break;
 112                 case PSI_T_UINT128:
 113                         out_val->u8 = in_val->u128;
 114                         break;
 115                 case PSI_T_FLOAT:
 116                         out_val->u8 = in_val->fval;
 117                         break;
 118                 case PSI_T_DOUBLE:
 119                         out_val->u8 = in_val->dval;
 120                         break;
 121 #       if HAVE_LONG_DOUBLE
 122                 case PSI_T_LONG_DOUBLE:
 123                         out_val->u8 = in_val->ldval;
 124                         break;
 125 #       endif
 126
 127                 default:
 128                         assert(0);
 129                         break;
 130                 }
 131                 break;
 132         case PSI_T_INT16:
 133                 switch (in_type) {
 134                 case PSI_T_INT8:
 135                         out_val->i16 = in_val->i8;
 136                         break;
 137                 case PSI_T_UINT8:
 138                         out_val->i16 = in_val->u8;
 139                         break;
 140                 case PSI_T_INT16:
 141                         out_val->i16 = in_val->i16;
 142                         break;
 143                 case PSI_T_UINT16:
 144                         out_val->i16 = in_val->u16;
 145                         break;
 146                 case PSI_T_INT32:
 147                         out_val->i16 = in_val->i32;
 148                         break;
 149                 case PSI_T_UINT32:
 150                         out_val->i16 = in_val->u32;
 151                         break;
 152                 case PSI_T_INT64:
 153                         out_val->i16 = in_val->i64;
 154                         break;
 155                 case PSI_T_UINT64:
 156                         out_val->i16 = in_val->u64;
 157                         break;
 158                 case PSI_T_INT128:
 159                         out_val->i16 = in_val->i128;
 160                         break;
 161                 case PSI_T_UINT128:
 162                         out_val->i16 = in_val->u128;
 163                         break;
 164                 case PSI_T_FLOAT:
 165                         out_val->i16 = in_val->fval;
 166                         break;
 167                 case PSI_T_DOUBLE:
 168                         out_val->i16 = in_val->dval;
 169                         break;
 170 #       if HAVE_LONG_DOUBLE
 171                 case PSI_T_LONG_DOUBLE:
 172                         out_val->i16 = in_val->ldval;
 173                         break;
 174 #       endif
 175
 176                 default:
 177                         assert(0);
 178                         break;
 179                 }
 180                 break;
 181         case PSI_T_UINT16:
 182                 switch (in_type) {
 183                 case PSI_T_INT8:
 184                         out_val->u16 = in_val->i8;
 185                         break;
 186                 case PSI_T_UINT8:
 187                         out_val->u16 = in_val->u8;
 188                         break;
 189                 case PSI_T_INT16:
 190                         out_val->u16 = in_val->i16;
 191                         break;
 192                 case PSI_T_UINT16:
 193                         out_val->u16 = in_val->u16;
 194                         break;
 195                 case PSI_T_INT32:
 196                         out_val->u16 = in_val->i32;
 197                         break;
 198                 case PSI_T_UINT32:
 199                         out_val->u16 = in_val->u32;
 200                         break;
 201                 case PSI_T_INT64:
 202                         out_val->u16 = in_val->i64;
 203                         break;
 204                 case PSI_T_UINT64:
 205                         out_val->u16 = in_val->u64;
 206                         break;
 207                 case PSI_T_INT128:
 208                         out_val->u16 = in_val->i128;
 209                         break;
 210                 case PSI_T_UINT128:
 211                         out_val->u16 = in_val->u128;
 212                         break;
 213                 case PSI_T_FLOAT:
 214                         out_val->u16 = in_val->fval;
 215                         break;
 216                 case PSI_T_DOUBLE:
 217                         out_val->u16 = in_val->dval;
 218                         break;
 219 #       if HAVE_LONG_DOUBLE
 220                 case PSI_T_LONG_DOUBLE:
 221                         out_val->u16 = in_val->ldval;
 222                         break;
 223 #       endif
 224
 225                 default:
 226                         assert(0);
 227                         break;
 228                 }
 229                 break;
 230         case PSI_T_INT32:
 231                 switch (in_type) {
 232                 case PSI_T_INT8:
 233                         out_val->i32 = in_val->i8;
 234                         break;
 235                 case PSI_T_UINT8:
 236                         out_val->i32 = in_val->u8;
 237                         break;
 238                 case PSI_T_INT16:
 239                         out_val->i32 = in_val->i16;
 240                         break;
 241                 case PSI_T_UINT16:
 242                         out_val->i32 = in_val->u16;
 243                         break;
 244                 case PSI_T_INT32:
 245                         out_val->i32 = in_val->i32;
 246                         break;
 247                 case PSI_T_UINT32:
 248                         out_val->i32 = in_val->u32;
 249                         break;
 250                 case PSI_T_INT64:
 251                         out_val->i32 = in_val->i64;
 252                         break;
 253                 case PSI_T_UINT64:
 254                         out_val->i32 = in_val->u64;
 255                         break;
 256                 case PSI_T_INT128:
 257                         out_val->i32 = in_val->i128;
 258                         break;
 259                 case PSI_T_UINT128:
 260                         out_val->i32 = in_val->u128;
 261                         break;
 262                 case PSI_T_FLOAT:
 263                         out_val->i32 = in_val->fval;
 264                         break;
 265                 case PSI_T_DOUBLE:
 266                         out_val->i32 = in_val->dval;
 267                         break;
 268 #       if HAVE_LONG_DOUBLE
 269                 case PSI_T_LONG_DOUBLE:
 270                         out_val->i32 = in_val->ldval;
 271                         break;
 272 #       endif
 273
 274                 default:
 275                         assert(0);
 276                         break;
 277                 }
 278                 break;
 279         case PSI_T_UINT32:
 280                 switch (in_type) {
 281                 case PSI_T_INT8:
 282                         out_val->u32 = in_val->i8;
 283                         break;
 284                 case PSI_T_UINT8:
 285                         out_val->u32 = in_val->u8;
 286                         break;
 287                 case PSI_T_INT16:
 288                         out_val->u32 = in_val->i16;
 289                         break;
 290                 case PSI_T_UINT16:
 291                         out_val->u32 = in_val->u16;
 292                         break;
 293                 case PSI_T_INT32:
 294                         out_val->u32 = in_val->i32;
 295                         break;
 296                 case PSI_T_UINT32:
 297                         out_val->u32 = in_val->u32;
 298                         break;
 299                 case PSI_T_INT64:
 300                         out_val->u32 = in_val->i64;
 301                         break;
 302                 case PSI_T_UINT64:
 303                         out_val->u32 = in_val->u64;
 304                         break;
 305                 case PSI_T_INT128:
 306                         out_val->u32 = in_val->i128;
 307                         break;
 308                 case PSI_T_UINT128:
 309                         out_val->u32 = in_val->u128;
 310                         break;
 311                 case PSI_T_FLOAT:
 312                         out_val->u32 = in_val->fval;
 313                         break;
 314                 case PSI_T_DOUBLE:
 315                         out_val->u32 = in_val->dval;
 316                         break;
 317 #       if HAVE_LONG_DOUBLE
 318                 case PSI_T_LONG_DOUBLE:
 319                         out_val->u32 = in_val->ldval;
 320                         break;
 321 #       endif
 322
 323                 default:
 324                         assert(0);
 325                         break;
 326                 }
 327                 break;
 328         case PSI_T_INT64:
 329                 switch (in_type) {
 330                 case PSI_T_INT8:
 331                         out_val->i64 = in_val->i8;
 332                         break;
 333                 case PSI_T_UINT8:
 334                         out_val->i64 = in_val->u8;
 335                         break;
 336                 case PSI_T_INT16:
 337                         out_val->i64 = in_val->i16;
 338                         break;
 339                 case PSI_T_UINT16:
 340                         out_val->i64 = in_val->u16;
 341                         break;
 342                 case PSI_T_INT32:
 343                         out_val->i64 = in_val->i32;
 344                         break;
 345                 case PSI_T_UINT32:
 346                         out_val->i64 = in_val->u32;
 347                         break;
 348                 case PSI_T_INT64:
 349                         out_val->i64 = in_val->i64;
 350                         break;
 351                 case PSI_T_UINT64:
 352                         out_val->i64 = in_val->u64;
 353                         break;
 354                 case PSI_T_INT128:
 355                         out_val->i64 = in_val->i128;
 356                         break;
 357                 case PSI_T_UINT128:
 358                         out_val->i64 = in_val->u128;
 359                         break;
 360                 case PSI_T_FLOAT:
 361                         out_val->i64 = in_val->fval;
 362                         break;
 363                 case PSI_T_DOUBLE:
 364                         out_val->i64 = in_val->dval;
 365                         break;
 366 #       if HAVE_LONG_DOUBLE
 367                 case PSI_T_LONG_DOUBLE:
 368                         out_val->i64 = in_val->ldval;
 369                         break;
 370 #       endif
 371
 372                 default:
 373                         assert(0);
 374                         break;
 375                 }
 376                 break;
 377         case PSI_T_UINT64:
 378                 switch (in_type) {
 379                 case PSI_T_INT8:
 380                         out_val->u64 = in_val->i8;
 381                         break;
 382                 case PSI_T_UINT8:
 383                         out_val->u64 = in_val->u8;
 384                         break;
 385                 case PSI_T_INT16:
 386                         out_val->u64 = in_val->i16;
 387                         break;
 388                 case PSI_T_UINT16:
 389                         out_val->u64 = in_val->u16;
 390                         break;
 391                 case PSI_T_INT32:
 392                         out_val->u64 = in_val->i32;
 393                         break;
 394                 case PSI_T_UINT32:
 395                         out_val->u64 = in_val->u32;
 396                         break;
 397                 case PSI_T_INT64:
 398                         out_val->u64 = in_val->i64;
 399                         break;
 400                 case PSI_T_UINT64:
 401                         out_val->u64 = in_val->u64;
 402                         break;
 403                 case PSI_T_INT128:
 404                         out_val->u64 = in_val->i128;
 405                         break;
 406                 case PSI_T_UINT128:
 407                         out_val->u64 = in_val->u128;
 408                         break;
 409                 case PSI_T_FLOAT:
 410                         out_val->u64 = in_val->fval;
 411                         break;
 412                 case PSI_T_DOUBLE:
 413                         out_val->u64 = in_val->dval;
 414                         break;
 415 #       if HAVE_LONG_DOUBLE
 416                 case PSI_T_LONG_DOUBLE:
 417                         out_val->u64 = in_val->ldval;
 418                         break;
 419 #       endif
 420
 421                 default:
 422                         assert(0);
 423                         break;
 424                 }
 425                 break;
 426         case PSI_T_INT128:
 427                 switch (in_type) {
 428                 case PSI_T_INT8:
 429                         out_val->i128 = in_val->i8;
 430                         break;
 431                 case PSI_T_UINT8:
 432                         out_val->i128 = in_val->u8;
 433                         break;
 434                 case PSI_T_INT16:
 435                         out_val->i128 = in_val->i16;
 436                         break;
 437                 case PSI_T_UINT16:
 438                         out_val->i128 = in_val->u16;
 439                         break;
 440                 case PSI_T_INT32:
 441                         out_val->i128 = in_val->i32;
 442                         break;
 443                 case PSI_T_UINT32:
 444                         out_val->i128 = in_val->u32;
 445                         break;
 446                 case PSI_T_INT64:
 447                         out_val->i128 = in_val->i64;
 448                         break;
 449                 case PSI_T_UINT64:
 450                         out_val->i128 = in_val->u64;
 451                         break;
 452                 case PSI_T_INT128:
 453                         out_val->i128 = in_val->i128;
 454                         break;
 455                 case PSI_T_UINT128:
 456                         out_val->i128 = in_val->u128;
 457                         break;
 458                 case PSI_T_FLOAT:
 459                         out_val->i128 = in_val->fval;
 460                         break;
 461                 case PSI_T_DOUBLE:
 462                         out_val->i128 = in_val->dval;
 463                         break;
 464 #       if HAVE_LONG_DOUBLE
 465                 case PSI_T_LONG_DOUBLE:
 466                         out_val->i128 = in_val->ldval;
 467                         break;
 468 #       endif
 469
 470                 default:
 471                         assert(0);
 472                         break;
 473                 }
 474                 break;
 475         case PSI_T_UINT128:
 476                 switch (in_type) {
 477                 case PSI_T_INT8:
 478                         out_val->u128 = in_val->i8;
 479                         break;
 480                 case PSI_T_UINT8:
 481                         out_val->u128 = in_val->u8;
 482                         break;
 483                 case PSI_T_INT16:
 484                         out_val->u128 = in_val->i16;
 485                         break;
 486                 case PSI_T_UINT16:
 487                         out_val->u128 = in_val->u16;
 488                         break;
 489                 case PSI_T_INT32:
 490                         out_val->u128 = in_val->i32;
 491                         break;
 492                 case PSI_T_UINT32:
 493                         out_val->u128 = in_val->u32;
 494                         break;
 495                 case PSI_T_INT64:
 496                         out_val->u128 = in_val->i64;
 497                         break;
 498                 case PSI_T_UINT64:
 499                         out_val->u128 = in_val->u64;
 500                         break;
 501                 case PSI_T_INT128:
 502                         out_val->u128 = in_val->i128;
 503                         break;
 504                 case PSI_T_UINT128:
 505                         out_val->u128 = in_val->u128;
 506                         break;
 507                 case PSI_T_FLOAT:
 508                         out_val->u128 = in_val->fval;
 509                         break;
 510                 case PSI_T_DOUBLE:
 511                         out_val->u128 = in_val->dval;
 512                         break;
 513 #       if HAVE_LONG_DOUBLE
 514                 case PSI_T_LONG_DOUBLE:
 515                         out_val->u128 = in_val->ldval;
 516                         break;
 517 #       endif
 518
 519                 default:
 520                         assert(0);
 521                         break;
 522                 }
 523                 break;
 524         case PSI_T_FLOAT:
 525                 switch (in_type) {
 526                 case PSI_T_INT8:
 527                         out_val->fval = in_val->i8;
 528                         break;
 529                 case PSI_T_UINT8:
 530                         out_val->fval = in_val->u8;
 531                         break;
 532                 case PSI_T_INT16:
 533                         out_val->fval = in_val->i16;
 534                         break;
 535                 case PSI_T_UINT16:
 536                         out_val->fval = in_val->u16;
 537                         break;
 538                 case PSI_T_INT32:
 539                         out_val->fval = in_val->i32;
 540                         break;
 541                 case PSI_T_UINT32:
 542                         out_val->fval = in_val->u32;
 543                         break;
 544                 case PSI_T_INT64:
 545                         out_val->fval = in_val->i64;
 546                         break;
 547                 case PSI_T_UINT64:
 548                         out_val->fval = in_val->u64;
 549                         break;
 550                 case PSI_T_INT128:
 551                         out_val->fval = in_val->i128;
 552                         break;
 553                 case PSI_T_UINT128:
 554                         out_val->fval = in_val->u128;
 555                         break;
 556                 case PSI_T_FLOAT:
 557                         out_val->fval = in_val->fval;
 558                         break;
 559                 case PSI_T_DOUBLE:
 560                         out_val->fval = in_val->dval;
 561                         break;
 562 #       if HAVE_LONG_DOUBLE
 563                 case PSI_T_LONG_DOUBLE:
 564                         out_val->fval = in_val->ldval;
 565                         break;
 566 #       endif
 567
 568                 default:
 569                         assert(0);
 570                         break;
 571                 }
 572                 break;
 573         case PSI_T_DOUBLE:
 574                 switch (in_type) {
 575                 case PSI_T_INT8:
 576                         out_val->dval = in_val->i8;
 577                         break;
 578                 case PSI_T_UINT8:
 579                         out_val->dval = in_val->u8;
 580                         break;
 581                 case PSI_T_INT16:
 582                         out_val->dval = in_val->i16;
 583                         break;
 584                 case PSI_T_UINT16:
 585                         out_val->dval = in_val->u16;
 586                         break;
 587                 case PSI_T_INT32:
 588                         out_val->dval = in_val->i32;
 589                         break;
 590                 case PSI_T_UINT32:
 591                         out_val->dval = in_val->u32;
 592                         break;
 593                 case PSI_T_INT64:
 594                         out_val->dval = in_val->i64;
 595                         break;
 596                 case PSI_T_UINT64:
 597                         out_val->dval = in_val->u64;
 598                         break;
 599                 case PSI_T_INT128:
 600                         out_val->dval = in_val->i128;
 601                         break;
 602                 case PSI_T_UINT128:
 603                         out_val->dval = in_val->u128;
 604                         break;
 605                 case PSI_T_FLOAT:
 606                         out_val->dval = in_val->fval;
 607                         break;
 608                 case PSI_T_DOUBLE:
 609                         out_val->dval = in_val->dval;
 610                         break;
 611 #       if HAVE_LONG_DOUBLE
 612                 case PSI_T_LONG_DOUBLE:
 613                         out_val->dval = in_val->ldval;
 614                         break;
 615 #       endif
 616
 617                 default:
 618                         assert(0);
 619                         break;
 620                 }
 621                 break;
 622 #if HAVE_LONG_DOUBLE
 623         case PSI_T_LONG_DOUBLE:
 624                 switch (in_type) {
 625                 case PSI_T_INT8:
 626                         out_val->ldval = in_val->i8;
 627                         break;
 628                 case PSI_T_UINT8:
 629                         out_val->ldval = in_val->u8;
 630                         break;
 631                 case PSI_T_INT16:
 632                         out_val->ldval = in_val->i16;
 633                         break;
 634                 case PSI_T_UINT16:
 635                         out_val->ldval = in_val->u16;
 636                         break;
 637                 case PSI_T_INT32:
 638                         out_val->ldval = in_val->i32;
 639                         break;
 640                 case PSI_T_UINT32:
 641                         out_val->ldval = in_val->u32;
 642                         break;
 643                 case PSI_T_INT64:
 644                         out_val->ldval = in_val->i64;
 645                         break;
 646                 case PSI_T_UINT64:
 647                         out_val->ldval = in_val->u64;
 648                         break;
 649                 case PSI_T_INT128:
 650                         out_val->ldval = in_val->i128;
 651                         break;
 652                 case PSI_T_UINT128:
 653                         out_val->ldval = in_val->u128;
 654                         break;
 655                 case PSI_T_FLOAT:
 656                         out_val->ldval = in_val->fval;
 657                         break;
 658                 case PSI_T_DOUBLE:
 659                         out_val->ldval = in_val->dval;
 660                         break;
 661 #       if HAVE_LONG_DOUBLE
 662                 case PSI_T_LONG_DOUBLE:
 663                         out_val->ldval = in_val->ldval;
 664                         break;
 665 #       endif
 666
 667                 default:
 668                         assert(0);
 669                         break;
 670                 }
 671                 break;
 672 #endif
 673
 674         default:
 675                 assert(0);
 676                 break;
 677         }
 678 }
 679