home *** CD-ROM | disk | FTP | other *** search
/ ftp.cs.arizona.edu / ftp.cs.arizona.edu.tar / ftp.cs.arizona.edu / icon / historic / v941.tgz / icon.v941src.tar / icon.v941src / ipl / cfuncs / pack.c < prev    next >
C/C++ Source or Header  |  2000-07-29  |  7KB  |  262 lines
  1. /*
  2. ############################################################################
  3. #
  4. #    File:     pack.c
  5. #
  6. #    Subject:  Functions to pack and unpack binary data
  7. #
  8. #    Author:   Gregg M. Townsend
  9. #
  10. #    Date:     November 17, 1997
  11. #
  12. ############################################################################
  13. #
  14. #   This file is in the public domain.
  15. #
  16. ############################################################################
  17. #
  18. #  s := pack(value, flags, width)
  19. #  x := unpack(string, flags)
  20. # 
  21. #  Flag characters are as follows:
  22. # 
  23. #     l -- little-endian [default]
  24. #     b -- big-endian
  25. #     n -- host platform's native packing order
  26. # 
  27. #     i -- integer [default]
  28. #     u -- unsigned integer
  29. #     r -- real (host platform's native float or double format)
  30. # 
  31. #  The default width is 4.
  32. # 
  33. #  Integer values must fit in a standard Icon integer (not large integer).
  34. #  Consequently, a word-sized value cannot have the high bit set if unsigned.
  35. #  Floating values can only be converted to/from a string width matching
  36. #  sizeof(float) or sizeof(double).
  37. # 
  38. #  Size/type combinations that can't be handled produce errors.
  39. #  Valid combinations produce failure if the value overflows.
  40. # 
  41. #  Some of this code assumes a twos-complement architecture with 8-bit bytes.
  42. #
  43. ############################################################################
  44. #
  45. #  Requires:  Dynamic loading
  46. #
  47. ############################################################################
  48. */
  49.  
  50. #include "icall.h"
  51. #include <string.h>
  52.  
  53. #define F_LTL 0x100    /* little-endian */
  54. #define F_BIG 0x200    /* big-endian */
  55. #define F_REV 0x400    /* internal flag: reversal needed */
  56.  
  57. #define F_INT 1        /* integer */
  58. #define F_UNS 2        /* unsigned integer */
  59. #define F_REAL 4    /* real */
  60.  
  61. #define DEF_WIDTH 4    /* default width */
  62. #define MAX_WIDTH 256    /* maximum width */
  63.  
  64. static unsigned long testval = 1;
  65. #define LNATIVE (*(char*)&testval)    /* true if machine is little-endian */
  66.  
  67. static int flags(char *s, int n);
  68. static void *memrev(void *s1, void *s2, size_t n);
  69.  
  70. /*
  71.  * pack(value, flags, width)
  72.  */
  73. int pack(int argc, descriptor argv[])    /*: pack integer into bytes */
  74.    {
  75.    int f, i, n, x;
  76.    long v;
  77.    unsigned char *s, obuf[MAX_WIDTH];
  78.    union { float f; double d; unsigned char buf[MAX_WIDTH]; } u;
  79.  
  80.    /*
  81.     * check arguments
  82.     */
  83.    if (argc == 0)
  84.       Error(102);            /* no value given */
  85.  
  86.    if (argc > 1) {
  87.       ArgString(2);
  88.       if ((f = flags(StringAddr(argv[2]), StringLen(argv[2]))) == 0)
  89.          ArgError(2, 205);        /* illegal flag string */
  90.       }
  91.    else 
  92.       f = flags("", 0);
  93.  
  94.    if (argc > 2) {
  95.       ArgInteger(3);
  96.       n = IntegerVal(argv[3]);
  97.       if (n < 0 || n > MAX_WIDTH)
  98.          ArgError(3, 205);        /* too long to handle */
  99.       }
  100.    else
  101.       n = DEF_WIDTH;
  102.  
  103.    if (f & F_REAL) {
  104.  
  105.       /*
  106.        * pack real value
  107.        */
  108.       ArgReal(1);
  109.       if (n == sizeof(double))
  110.          u.d = RealVal(argv[1]);
  111.       else if (n == sizeof(float))
  112.          u.f = RealVal(argv[1]);
  113.       else
  114.          ArgError(3, 205);        /* illegal length for real value */
  115.  
  116.       if (f & F_REV)
  117.          RetStringN(memrev(obuf, u.buf, n), n);
  118.       else
  119.          RetStringN((char *)u.buf, n);
  120.       } 
  121.  
  122.    /*
  123.     * pack integer value
  124.     */
  125.    ArgInteger(1);
  126.    v = IntegerVal(argv[1]);        /* value */
  127.  
  128.    if (v >= 0)
  129.       x = 0;                /* sign extension byte */
  130.    else if (f & F_UNS)
  131.       Fail;                /* invalid unsigned value */
  132.    else
  133.       x = (unsigned char) -1;
  134.  
  135.    for (s = obuf, i = 0; i < sizeof(long); i++)  {
  136.       *s++ = v & 0xFF;            /* save in little-endian fashion */
  137.       v = ((unsigned long)v) >> 8;
  138.       }
  139.    while (i++ < n)
  140.       *s++ = x;                /* extend if > sizeof(long) */
  141.  
  142.    for (i = n; i < sizeof(long); i++)    /* check that all bits did fit */
  143.       if (obuf[i] != x)
  144.          Fail;                /* overflow */
  145.  
  146.    if (f & F_BIG)
  147.       RetStringN(memrev(u.buf, obuf, n), n);
  148.    else
  149.       RetStringN((char *)obuf, n);
  150.    }
  151.  
  152. /*
  153.  * unpack(string, flags)
  154.  */
  155. int unpack(int argc, descriptor argv[])    /*: unpack integer from bytes */
  156.    {
  157.    int f, i, n, x;
  158.    long v;
  159.    unsigned char *s;
  160.    union { float f; double d; unsigned char buf[MAX_WIDTH]; } u;
  161.  
  162.    /*
  163.     * check arguments
  164.     */
  165.    ArgString(1);
  166.    s = (unsigned char *)StringAddr(argv[1]);
  167.    n = StringLen(argv[1]);
  168.    if (n > MAX_WIDTH)
  169.       ArgError(1, 205);            /* too long to handle */
  170.  
  171.    if (argc > 1) {
  172.       ArgString(2);
  173.       if ((f = flags(StringAddr(argv[2]), StringLen(argv[2]))) == 0)
  174.          ArgError(2, 205);        /* illegal flag string */
  175.       }
  176.    else 
  177.       f = flags("", 0);
  178.  
  179.    if (f & F_REAL) {
  180.       /*
  181.        * unpack real value
  182.        */
  183.       if (f & F_REV)
  184.          memrev(u.buf, s, n);
  185.       else
  186.          memcpy(u.buf, s, n);
  187.  
  188.       if (n == sizeof(double))
  189.          RetReal(u.d);
  190.       else if (n == sizeof(float))
  191.          RetReal(u.f);
  192.       else
  193.          ArgError(1, 205);        /* illegal length for real value */
  194.       }
  195.  
  196.    /*
  197.     * unpack integer value 
  198.     */
  199.    if (f & F_BIG)
  200.       s = memrev(u.buf, s, n);        /* put in little-endian order */
  201.    for (v = i = 0; i < n && i < sizeof(long); i++)
  202.       v |= *s++ << (8 * i);        /* pack into a long */
  203.  
  204.    if (v >= 0)
  205.       x = 0;                /* sign extension byte */
  206.    else if (f & F_UNS)
  207.       Fail;                /* value overflows as unsigned */
  208.    else
  209.       x = (unsigned char) -1;
  210.  
  211.    for (; i < n; i++)            /* check bytes beyond sizeof(long) */
  212.       if (*s++ != x)
  213.          Fail;                /* value overflows a long */
  214.  
  215.    RetInteger(v);            /* return value */
  216.    }
  217.  
  218.  
  219. /*
  220.  * flags(addr, len) -- interpret flag string, return 0 if error
  221.  */
  222. static int flags(char *s, int n)
  223.    {
  224.    int f = 0;
  225.  
  226.    while (n--) switch(*s++) {
  227.       case 'l':  f |= F_LTL;                break;
  228.       case 'b':  f |= F_BIG;                break;
  229.       case 'n':  f |= (LNATIVE ? F_LTL : F_BIG);     break;
  230.       case 'i':  f |= F_INT;                break;
  231.       case 'u':  f |= F_UNS + F_INT;            break;
  232.       case 'r':  f |= F_REAL;                break;
  233.       default:     return 0;
  234.       }
  235.  
  236.    if (((f & F_LTL) && (f & F_BIG)) | ((f & F_INT) && (f & F_REAL)))
  237.       return 0;                /* illegal conflict */
  238.  
  239.    if (!(f & F_BIG))
  240.       f |= F_LTL;            /* default packing is little-endian */
  241.    if (!(f & F_REAL))
  242.       f |= F_INT;            /* default type is integer */
  243.  
  244.    if (f & (LNATIVE ? F_BIG : F_LTL))
  245.       f |= F_REV;            /* set flag if non-native mode */
  246.  
  247.    return f;
  248.    }
  249.  
  250.  
  251. /*
  252.  * memrev(s1, s2, n) -- copy reversal of s2 into s1, returning s1
  253.  */
  254. static void *memrev(void *s1, void *s2, size_t n)
  255.    {
  256.    unsigned char *c1 = s1;
  257.    unsigned char *c2 = (unsigned char *)s2 + n;
  258.    while (n-- > 0)
  259.       *c1++ = *--c2;
  260.    return s1;
  261.    }
  262.