c_cpp/etc/calc/byteswap.c

   1 /*
   2  * byteswap - byte swapping routines
   3  *
   4  * Copyright (C) 1999  Landon Curt Noll
   5  *
   6  * Calc is open software; you can redistribute it and/or modify it under
   7  * the terms of the version 2.1 of the GNU Lesser General Public License
   8  * as published by the Free Software Foundation.
   9  *
  10  * Calc is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
  13  * Public License for more details.
  14  *
  15  * A copy of version 2.1 of the GNU Lesser General Public License is
  16  * distributed with calc under the filename COPYING-LGPL.  You should have
  17  * received a copy with calc; if not, write to Free Software Foundation, Inc.
  18  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * @(#) $Revision: 30.2 $
  21  * @(#) $Id: byteswap.c,v 30.2 2013/08/11 08:41:38 chongo Exp $
  22  * @(#) $Source: /usr/local/src/bin/calc/RCS/byteswap.c,v $
  23  *
  24  * Under source code control:   1995/10/11 04:44:01
  25  * File existed as early as:    1995
  26  *
  27  * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
  28  * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  29  */
  30
  31
  32 #include "cmath.h"
  33 #include "byteswap.h"
  34
  35
  36 /*
  37  * swap_b8_in_HALFs - swap 8 and if needed, 16 bits in an array of HALFs
  38  *
  39  * given:
  40  *      dest    - pointer to where the swapped src wil be put or
  41  *                NULL to allocate the storage
  42  *      src     - pointer to a HALF array to swap
  43  *      len     - length of the src HALF array
  44  *
  45  * returns:
  46  *      pointer to where the swapped src has been put
  47  */
  48 HALF *
  49 swap_b8_in_HALFs(HALF *dest, HALF *src, LEN len)
  50 {
  51         HALF *ret;
  52         LEN i;
  53
  54         /*
  55          * allocate storage if needed
  56          */
  57         if (dest == NULL) {
  58                 dest = alloc(len);
  59         }
  60         ret = dest;
  61
  62         /*
  63          * swap the array
  64          */
  65         for (i=0; i < len; ++i, ++dest, ++src) {
  66                 SWAP_B8_IN_HALF(dest, src);
  67         }
  68
  69         /*
  70          * return the result
  71          */
  72         return ret;
  73 }
  74
  75
  76 /*
  77  * swap_b8_in_ZVALUE - swap 8 and if needed, 16 bits in a ZVALUE
  78  *
  79  * given:
  80  *      dest    - pointer to where the swapped src wil be put or
  81  *                NULL to allocate the storage
  82  *      src     - pointer to a ZVALUE to swap
  83  *      all     - TRUE => swap every element, FALSE => swap only the
  84  *                multiprecision storage
  85  *
  86  * returns:
  87  *      pointer to where the swapped src has been put
  88  *
  89  * This macro will either switch to the opposite byte sex (Big Endian vs.
  90  * Little Endian) the elements of a ZVALUE.
  91  */
  92 ZVALUE *
  93 swap_b8_in_ZVALUE(ZVALUE *dest, ZVALUE *src, BOOL all)
  94 {
  95         /*
  96          * allocate storage if needed
  97          */
  98         if (dest == NULL) {
  99
 100                 /*
 101                  * allocate the storage
 102                  */
 103                 dest = malloc(sizeof(ZVALUE));
 104                 if (dest == NULL) {
 105                         math_error("swap_b8_in_ZVALUE: swap_b8_in_ZVALUE: "
 106                                     "Not enough memory");
 107                         /*NOTREACHED*/
 108                 }
 109
 110                 /*
 111                  * allocate (by forcing swap_b8_in_ZVALUE) and swap storage
 112                  */
 113                 dest->v = swap_b8_in_HALFs(NULL, src->v, src->len);
 114
 115         } else {
 116
 117                 /*
 118                  * swap storage
 119                  */
 120                 if (dest->v != NULL) {
 121                         zfree(*dest);
 122                 }
 123                 dest->v = swap_b8_in_HALFs(NULL, src->v, src->len);
 124         }
 125
 126         /*
 127          * swap or copy the rest of the ZVALUE elements
 128          */
 129         if (all) {
 130                 dest->len = (LEN)SWAP_B8_IN_LEN(&dest->len, &src->len);
 131                 dest->sign = (BOOL)SWAP_B8_IN_BOOL(&dest->sign, &src->sign);
 132         } else {
 133                 dest->len = src->len;
 134                 dest->sign = src->sign;
 135         }
 136
 137         /*
 138          * return the result
 139          */
 140         return dest;
 141 }
 142
 143
 144 /*
 145  * swap_b8_in_NUMBER - swap 8 and if needed, 16 bits in a NUMBER
 146  *
 147  * given:
 148  *      dest    - pointer to where the swapped src wil be put or
 149  *                NULL to allocate the storage
 150  *      src     - pointer to a NUMBER to swap
 151  *      all     - TRUE => swap every element, FALSE => swap only the
 152  *                multiprecision storage
 153  *
 154  * returns:
 155  *      pointer to where the swapped src has been put
 156  *
 157  * This macro will either switch to the opposite byte sex (Big Endian vs.
 158  * Little Endian) the elements of a NUMBER.
 159  */
 160 NUMBER *
 161 swap_b8_in_NUMBER(NUMBER *dest, NUMBER *src, BOOL all)
 162 {
 163         /*
 164          * allocate storage if needed
 165          */
 166         if (dest == NULL) {
 167
 168                 /*
 169                  * allocate the storage
 170                  */
 171                 dest = malloc(sizeof(NUMBER));
 172                 if (dest == NULL) {
 173                         math_error("swap_b8_in_NUMBER: Not enough memory");
 174                         /*NOTREACHED*/
 175                 }
 176
 177                 /*
 178                  * allocate (by forcing swap_b8_in_ZVALUE) and swap storage
 179                  */
 180                 dest->num = *swap_b8_in_ZVALUE(NULL, &src->num, all);
 181                 dest->den = *swap_b8_in_ZVALUE(NULL, &src->den, all);
 182
 183         } else {
 184
 185                 /*
 186                  * swap storage
 187                  */
 188                 dest->num = *swap_b8_in_ZVALUE(&dest->num, &src->num, all);
 189                 dest->den = *swap_b8_in_ZVALUE(&dest->den, &src->den, all);
 190         }
 191
 192         /*
 193          * swap or copy the rest of the NUMBER elements
 194          */
 195         if (all) {
 196                 dest->links = (long)SWAP_B8_IN_LONG(&dest->links, &src->links);
 197         } else {
 198                 dest->links = src->links;
 199         }
 200
 201         /*
 202          * return the result
 203          */
 204         return dest;
 205 }
 206
 207
 208 /*
 209  * swap_b8_in_COMPLEX - swap 8 and if needed, 16 bits in a COMPLEX
 210  *
 211  * given:
 212  *      dest    - pointer to where the swapped src wil be put or
 213  *                NULL to allocate the storage
 214  *      src     - pointer to a COMPLEX to swap
 215  *      all     - TRUE => swap every element, FALSE => swap only the
 216  *                multiprecision storage
 217  *
 218  * returns:
 219  *      pointer to where the swapped src has been put
 220  *
 221  * This macro will either switch to the opposite byte sex (Big Endian vs.
 222  * Little Endian) the elements of a COMPLEX.
 223  */
 224 COMPLEX *
 225 swap_b8_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all)
 226 {
 227         /*
 228          * allocate storage if needed
 229          */
 230         if (dest == NULL) {
 231
 232                 /*
 233                  * allocate the storage
 234                  */
 235                 dest = malloc(sizeof(COMPLEX));
 236                 if (dest == NULL) {
 237                         math_error("swap_b8_in_COMPLEX: Not enough memory");
 238                         /*NOTREACHED*/
 239                 }
 240
 241                 /*
 242                  * allocate (by forcing swap_b8_in_ZVALUE) and swap storage
 243                  */
 244                 dest->real = swap_b8_in_NUMBER(NULL, src->real, all);
 245                 dest->imag = swap_b8_in_NUMBER(NULL, src->imag, all);
 246
 247         } else {
 248
 249                 /*
 250                  * swap storage
 251                  */
 252                 dest->real = swap_b8_in_NUMBER(dest->real, src->real, all);
 253                 dest->imag = swap_b8_in_NUMBER(dest->imag, src->imag, all);
 254         }
 255
 256         /*
 257          * swap or copy the rest of the NUMBER elements
 258          */
 259         if (all) {
 260                 dest->links = (long)SWAP_B8_IN_LONG(&dest->links, &src->links);
 261         } else {
 262                 dest->links = src->links;
 263         }
 264
 265         /*
 266          * return the result
 267          */
 268         return dest;
 269 }
 270
 271
 272 /*
 273  * swap_b16_in_HALFs - swap 16 bits in an array of HALFs
 274  *
 275  * given:
 276  *      dest    - pointer to where the swapped src wil be put or
 277  *                NULL to allocate the storage
 278  *      src     - pointer to a HALF array to swap
 279  *      len     - length of the src HALF array
 280  *
 281  * returns:
 282  *      pointer to where the swapped src has been put
 283  */
 284 HALF *
 285 swap_b16_in_HALFs(HALF *dest, HALF *src, LEN len)
 286 {
 287         HALF *ret;
 288         LEN i;
 289
 290         /*
 291          * allocate storage if needed
 292          */
 293         if (dest == NULL) {
 294                 dest = alloc(len);
 295         }
 296         ret = dest;
 297
 298         /*
 299          * swap the array
 300          */
 301         for (i=0; i < len; ++i, ++dest, ++src) {
 302                 SWAP_B16_IN_HALF(dest, src);
 303         }
 304
 305         /*
 306          * return the result
 307          */
 308         return ret;
 309 }
 310
 311
 312 /*
 313  * swap_b16_in_ZVALUE - swap 16 bits in a ZVALUE
 314  *
 315  * given:
 316  *      dest    - pointer to where the swapped src wil be put or
 317  *                NULL to allocate the storage
 318  *      src     - pointer to a ZVALUE to swap
 319  *      all     - TRUE => swap every element, FALSE => swap only the
 320  *                multiprecision storage
 321  *
 322  * returns:
 323  *      pointer to where the swapped src has been put
 324  *
 325  * This macro will either switch to the opposite byte sex (Big Endian vs.
 326  * Little Endian) the elements of a ZVALUE.
 327  */
 328 ZVALUE *
 329 swap_b16_in_ZVALUE(ZVALUE *dest, ZVALUE *src, BOOL all)
 330 {
 331         /*
 332          * allocate storage if needed
 333          */
 334         if (dest == NULL) {
 335
 336                 /*
 337                  * allocate the storage
 338                  */
 339                 dest = malloc(sizeof(ZVALUE));
 340                 if (dest == NULL) {
 341                         math_error("swap_b16_in_ZVALUE: Not enough memory");
 342                         /*NOTREACHED*/
 343                 }
 344
 345                 /*
 346                  * allocate (by forcing swap_b16_in_ZVALUE) and swap storage
 347                  */
 348                 dest->v = swap_b16_in_HALFs(NULL, src->v, src->len);
 349
 350         } else {
 351
 352                 /*
 353                  * swap storage
 354                  */
 355                 if (dest->v != NULL) {
 356                         zfree(*dest);
 357                 }
 358                 dest->v = swap_b16_in_HALFs(NULL, src->v, src->len);
 359         }
 360
 361         /*
 362          * swap or copy the rest of the ZVALUE elements
 363          */
 364         if (all) {
 365                 dest->len = (LEN)SWAP_B16_IN_LEN(&dest->len, &src->len);
 366                 dest->sign = (BOOL)SWAP_B16_IN_BOOL(&dest->sign, &src->sign);
 367         } else {
 368                 dest->len = src->len;
 369                 dest->sign = src->sign;
 370         }
 371
 372         /*
 373          * return the result
 374          */
 375         return dest;
 376 }
 377
 378
 379 /*
 380  * swap_b16_in_NUMBER - swap 16 bits in a NUMBER
 381  *
 382  * given:
 383  *      dest    - pointer to where the swapped src wil be put or
 384  *                NULL to allocate the storage
 385  *      src     - pointer to a NUMBER to swap
 386  *      all     - TRUE => swap every element, FALSE => swap only the
 387  *                multiprecision storage
 388  *
 389  * returns:
 390  *      pointer to where the swapped src has been put
 391  *
 392  * This macro will either switch to the opposite byte sex (Big Endian vs.
 393  * Little Endian) the elements of a NUMBER.
 394  */
 395 NUMBER *
 396 swap_b16_in_NUMBER(NUMBER *dest, NUMBER *src, BOOL all)
 397 {
 398         /*
 399          * allocate storage if needed
 400          */
 401         if (dest == NULL) {
 402
 403                 /*
 404                  * allocate the storage
 405                  */
 406                 dest = malloc(sizeof(NUMBER));
 407                 if (dest == NULL) {
 408                         math_error("swap_b16_in_NUMBER: Not enough memory");
 409                         /*NOTREACHED*/
 410                 }
 411
 412                 /*
 413                  * allocate (by forcing swap_b16_in_ZVALUE) and swap storage
 414                  */
 415                 dest->num = *swap_b16_in_ZVALUE(NULL, &src->num, all);
 416                 dest->den = *swap_b16_in_ZVALUE(NULL, &src->den, all);
 417
 418         } else {
 419
 420                 /*
 421                  * swap storage
 422                  */
 423                 dest->num = *swap_b16_in_ZVALUE(&dest->num, &src->num, all);
 424                 dest->den = *swap_b16_in_ZVALUE(&dest->den, &src->den, all);
 425         }
 426
 427         /*
 428          * swap or copy the rest of the NUMBER elements
 429          */
 430         if (all) {
 431                 dest->links = (long)SWAP_B16_IN_LONG(&dest->links, &src->links);
 432         } else {
 433                 dest->links = src->links;
 434         }
 435
 436         /*
 437          * return the result
 438          */
 439         return dest;
 440 }
 441
 442
 443 /*
 444  * swap_b16_in_COMPLEX - swap 16 bits in a COMPLEX
 445  *
 446  * given:
 447  *      dest    - pointer to where the swapped src wil be put or
 448  *                NULL to allocate the storage
 449  *      src     - pointer to a COMPLEX to swap
 450  *      all     - TRUE => swap every element, FALSE => swap only the
 451  *                multiprecision storage
 452  *
 453  * returns:
 454  *      pointer to where the swapped src has been put
 455  *
 456  * This macro will either switch to the opposite byte sex (Big Endian vs.
 457  * Little Endian) the elements of a COMPLEX.
 458  */
 459 COMPLEX *
 460 swap_b16_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all)
 461 {
 462         /*
 463          * allocate storage if needed
 464          */
 465         if (dest == NULL) {
 466
 467                 /*
 468                  * allocate the storage
 469                  */
 470                 dest = malloc(sizeof(COMPLEX));
 471                 if (dest == NULL) {
 472                         math_error("swap_b16_in_COMPLEX: Not enough memory");
 473                         /*NOTREACHED*/
 474                 }
 475
 476                 /*
 477                  * allocate (by forcing swap_b16_in_ZVALUE) and swap storage
 478                  */
 479                 dest->real = swap_b16_in_NUMBER(NULL, src->real, all);
 480                 dest->imag = swap_b16_in_NUMBER(NULL, src->imag, all);
 481
 482         } else {
 483
 484                 /*
 485                  * swap storage
 486                  */
 487                 dest->real = swap_b16_in_NUMBER(dest->real, src->real, all);
 488                 dest->imag = swap_b16_in_NUMBER(dest->imag, src->imag, all);
 489         }
 490
 491         /*
 492          * swap or copy the rest of the NUMBER elements
 493          */
 494         if (all) {
 495                 dest->links = (long)SWAP_B16_IN_LONG(&dest->links, &src->links);
 496         } else {
 497                 dest->links = src->links;
 498         }
 499
 500         /*
 501          * return the result
 502          */
 503         return dest;
 504 }
 505
 506
 507 /*
 508  * swap_HALF_in_ZVALUE - swap HALFs in a ZVALUE
 509  *
 510  * given:
 511  *      dest    - pointer to where the swapped src wil be put or
 512  *                NULL to allocate the storage
 513  *      src     - pointer to a ZVALUE to swap
 514  *      all     - TRUE => swap every element, FALSE => swap only the
 515  *                multiprecision storage
 516  *
 517  * returns:
 518  *      pointer to where the swapped src has been put
 519  *
 520  * This macro will either switch to the opposite byte sex (Big Endian vs.
 521  * Little Endian) the elements of a ZVALUE.
 522  */
 523 ZVALUE *
 524 swap_HALF_in_ZVALUE(ZVALUE *dest, ZVALUE *src, BOOL all)
 525 {
 526         /*
 527          * allocate storage if needed
 528          */
 529         if (dest == NULL) {
 530
 531                 /*
 532                  * allocate the storage
 533                  */
 534                 dest = malloc(sizeof(ZVALUE));
 535                 if (dest == NULL) {
 536                         math_error("swap_HALF_in_ZVALUE: Not enough memory");
 537                         /*NOTREACHED*/
 538                 }
 539
 540                 /*
 541                  * copy storage because we are dealing with HALFs
 542                  */
 543                 dest->v = (HALF *) zcopyval(*src, *dest);
 544
 545         } else {
 546
 547                 /*
 548                  * copy storage because we are dealing with HALFs
 549                  */
 550                 if (dest->v != NULL) {
 551                         zfree(*dest);
 552                         dest->v = alloc(src->len);
 553                 }
 554                 zcopyval(*src, *dest);
 555         }
 556
 557         /*
 558          * swap or copy the rest of the ZVALUE elements
 559          */
 560         if (all) {
 561                 dest->len = (LEN)SWAP_HALF_IN_LEN(&dest->len, &src->len);
 562                 dest->sign = (BOOL)SWAP_HALF_IN_BOOL(&dest->sign, &src->sign);
 563         } else {
 564                 dest->len = src->len;
 565                 dest->sign = src->sign;
 566         }
 567
 568         /*
 569          * return the result
 570          */
 571         return dest;
 572 }
 573
 574
 575 /*
 576  * swap_HALF_in_NUMBER - swap HALFs in a NUMBER
 577  *
 578  * given:
 579  *      dest    - pointer to where the swapped src wil be put or
 580  *                NULL to allocate the storage
 581  *      src     - pointer to a NUMBER to swap
 582  *      all     - TRUE => swap every element, FALSE => swap only the
 583  *                multiprecision storage
 584  *
 585  * returns:
 586  *      pointer to where the swapped src has been put
 587  *
 588  * This macro will either switch to the opposite byte sex (Big Endian vs.
 589  * Little Endian) the elements of a NUMBER.
 590  */
 591 NUMBER *
 592 swap_HALF_in_NUMBER(NUMBER *dest, NUMBER *src, BOOL all)
 593 {
 594         /*
 595          * allocate storage if needed
 596          */
 597         if (dest == NULL) {
 598
 599                 /*
 600                  * allocate the storage
 601                  */
 602                 dest = malloc(sizeof(NUMBER));
 603                 if (dest == NULL) {
 604                         math_error("swap_HALF_in_NUMBER: Not enough memory");
 605                         /*NOTREACHED*/
 606                 }
 607
 608                 /*
 609                  * allocate (by forcing swap_HALF_in_ZVALUE) and swap storage
 610                  */
 611                 dest->num = *swap_HALF_in_ZVALUE(NULL, &src->num, all);
 612                 dest->den = *swap_HALF_in_ZVALUE(NULL, &src->den, all);
 613
 614         } else {
 615
 616                 /*
 617                  * swap storage
 618                  */
 619                 dest->num = *swap_HALF_in_ZVALUE(&dest->num, &src->num, all);
 620                 dest->den = *swap_HALF_in_ZVALUE(&dest->den, &src->den, all);
 621         }
 622
 623         /*
 624          * swap or copy the rest of the NUMBER elements
 625          */
 626         if (all) {
 627                 dest->links = (long)SWAP_HALF_IN_LONG(&dest->links,&src->links);
 628         } else {
 629                 dest->links = src->links;
 630         }
 631
 632         /*
 633          * return the result
 634          */
 635         return dest;
 636 }
 637
 638
 639 /*
 640  * swap_HALF_in_COMPLEX - swap HALFs in a COMPLEX
 641  *
 642  * given:
 643  *      dest    - pointer to where the swapped src wil be put or
 644  *                NULL to allocate the storage
 645  *      src     - pointer to a COMPLEX to swap
 646  *      all     - TRUE => swap every element, FALSE => swap only the
 647  *                multiprecision storage
 648  *
 649  * returns:
 650  *      pointer to where the swapped src has been put
 651  *
 652  * This macro will either switch to the opposite byte sex (Big Endian vs.
 653  * Little Endian) the elements of a COMPLEX.
 654  */
 655 COMPLEX *
 656 swap_HALF_in_COMPLEX(COMPLEX *dest, COMPLEX *src, BOOL all)
 657 {
 658         /*
 659          * allocate storage if needed
 660          */
 661         if (dest == NULL) {
 662
 663                 /*
 664                  * allocate the storage
 665                  */
 666                 dest = malloc(sizeof(COMPLEX));
 667                 if (dest == NULL) {
 668                         math_error("swap_HALF_in_COMPLEX: Not enough memory");
 669                         /*NOTREACHED*/
 670                 }
 671
 672                 /*
 673                  * allocate (by forcing swap_HALF_in_ZVALUE) and swap storage
 674                  */
 675                 dest->real = swap_HALF_in_NUMBER(NULL, src->real, all);
 676                 dest->imag = swap_HALF_in_NUMBER(NULL, src->imag, all);
 677
 678         } else {
 679
 680                 /*
 681                  * swap storage
 682                  */
 683                 dest->real = swap_HALF_in_NUMBER(dest->real, src->real, all);
 684                 dest->imag = swap_HALF_in_NUMBER(dest->imag, src->imag, all);
 685         }
 686
 687         /*
 688          * swap or copy the rest of the NUMBER elements
 689          */
 690         if (all) {
 691                 dest->links = (long)SWAP_HALF_IN_LONG(&dest->links,&src->links);
 692         } else {
 693                 dest->links = src->links;
 694         }
 695
 696         /*
 697          * return the result
 698          */
 699         return dest;
 700 }