EIC code displayed by LXR master/​include/​H5encode.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-04-18 09:16:01

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * Copyright by The HDF Group.                                               *
  * All rights reserved.                                                      *
  *                                                                           *
  * This file is part of HDF5.  The full HDF5 copyright notice, including     *
  * terms governing use, modification, and redistribution, is contained in    *
  * the COPYING file, which can be found at the root of the source code       *
  * distribution tree, or in https://www.hdfgroup.org/licenses.               *
  * If you do not have access to either file, you may request a copy from     *
  * help@hdfgroup.org.                                                        *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /*
  * File-independent encode/decode routines
  */
 
 #ifndef H5encode_H
 #define H5encode_H
 
 /***********/
 /* Headers */
 /***********/
 #include "H5MMprivate.h" /* Memory management                        */
 
 /**************************/
 /* Library Private Macros */
 /**************************/
 
 /*
  * Encode and decode macros for file meta-data.
  * Currently, all file meta-data is little-endian.
  */
 
 #define INT16ENCODE(p, i)                                                                                    \
     do {                                                                                                     \
         *(p) = (uint8_t)((unsigned)(i)&0xff);                                                                \
         (p)++;                                                                                               \
         *(p) = (uint8_t)(((unsigned)(i) >> 8) & 0xff);                                                       \
         (p)++;                                                                                               \
     } while (0)
 
 #define UINT16ENCODE(p, i)                                                                                   \
     do {                                                                                                     \
         *(p) = (uint8_t)((unsigned)(i)&0xff);                                                                \
         (p)++;                                                                                               \
         *(p) = (uint8_t)(((unsigned)(i) >> 8) & 0xff);                                                       \
         (p)++;                                                                                               \
     } while (0)
 
 #define INT32ENCODE(p, i)                                                                                    \
     do {                                                                                                     \
         *(p) = (uint8_t)((uint32_t)(i)&0xff);                                                                \
         (p)++;                                                                                               \
         *(p) = (uint8_t)(((uint32_t)(i) >> 8) & 0xff);                                                       \
         (p)++;                                                                                               \
         *(p) = (uint8_t)(((uint32_t)(i) >> 16) & 0xff);                                                      \
         (p)++;                                                                                               \
         *(p) = (uint8_t)(((uint32_t)(i) >> 24) & 0xff);                                                      \
         (p)++;                                                                                               \
     } while (0)
 
 #define UINT32ENCODE(p, i)                                                                                   \
     do {                                                                                                     \
         *(p) = (uint8_t)((i)&0xff);                                                                          \
         (p)++;                                                                                               \
         *(p) = (uint8_t)(((i) >> 8) & 0xff);                                                                 \
         (p)++;                                                                                               \
         *(p) = (uint8_t)(((i) >> 16) & 0xff);                                                                \
         (p)++;                                                                                               \
         *(p) = (uint8_t)(((i) >> 24) & 0xff);                                                                \
         (p)++;                                                                                               \
     } while (0)
 
 /* Encode an unsigned integer into a variable-sized buffer */
 /* (Assumes that the high bits of the integer are zero) */
 #define ENCODE_VAR(p, typ, n, l)                                                                             \
     do {                                                                                                     \
         typ      _n = (n);                                                                                   \
         size_t   _i;                                                                                         \
         uint8_t *_p = (uint8_t *)(p);                                                                        \
                                                                                                              \
         for (_i = 0; _i < l; _i++, _n >>= 8)                                                                 \
             *_p++ = (uint8_t)(_n & 0xff);                                                                    \
         (p) = (uint8_t *)(p) + l;                                                                            \
     } while (0)
 
 /* Encode a 32-bit unsigned integer into a variable-sized buffer */
 /* (Assumes that the high bits of the integer are zero) */
 #define UINT32ENCODE_VAR(p, n, l) ENCODE_VAR(p, uint32_t, n, l)
 
 #define INT64ENCODE(p, n)                                                                                    \
     do {                                                                                                     \
         int64_t  _n = (n);                                                                                   \
         size_t   _i;                                                                                         \
         uint8_t *_p = (uint8_t *)(p);                                                                        \
                                                                                                              \
         for (_i = 0; _i < sizeof(int64_t); _i++, _n >>= 8)                                                   \
             *_p++ = (uint8_t)(_n & 0xff);                                                                    \
         for (/*void*/; _i < 8; _i++)                                                                         \
             *_p++ = (uint8_t)((n) < 0 ? 0xff : 0);                                                           \
         (p) = (uint8_t *)(p) + 8;                                                                            \
     } while (0)
 
 #define UINT64ENCODE(p, n)                                                                                   \
     do {                                                                                                     \
         uint64_t _n = (n);                                                                                   \
         size_t   _i;                                                                                         \
         uint8_t *_p = (uint8_t *)(p);                                                                        \
                                                                                                              \
         for (_i = 0; _i < sizeof(uint64_t); _i++, _n >>= 8)                                                  \
             *_p++ = (uint8_t)(_n & 0xff);                                                                    \
         for (/*void*/; _i < 8; _i++)                                                                         \
             *_p++ = 0;                                                                                       \
         (p) = (uint8_t *)(p) + 8;                                                                            \
     } while (0)
 
 /* Encode a 64-bit unsigned integer into a variable-sized buffer */
 /* (Assumes that the high bits of the integer are zero) */
 #define UINT64ENCODE_VAR(p, n, l) ENCODE_VAR(p, uint64_t, n, l)
 
 #define H5_ENCODE_UNSIGNED(p, n)                                                                             \
     do {                                                                                                     \
         HDcompile_assert(sizeof(unsigned) == sizeof(uint32_t));                                              \
         UINT32ENCODE(p, n);                                                                                  \
     } while (0)
 
 /* Assumes the endianness of uint64_t is the same as double */
 #define H5_ENCODE_DOUBLE(p, n)                                                                               \
     do {                                                                                                     \
         uint64_t _n;                                                                                         \
         size_t   _u;                                                                                         \
         uint8_t *_p = (uint8_t *)(p);                                                                        \
                                                                                                              \
         HDcompile_assert(sizeof(double) == 8);                                                               \
         HDcompile_assert(sizeof(double) == sizeof(uint64_t));                                                \
         H5MM_memcpy(&_n, &n, sizeof(double));                                                                \
         for (_u = 0; _u < sizeof(uint64_t); _u++, _n >>= 8)                                                  \
             *_p++ = (uint8_t)(_n & 0xff);                                                                    \
         (p) = (uint8_t *)(p) + 8;                                                                            \
     } while (0)
 
 /* DECODE converts little endian bytes pointed by p to integer values and store
  * it in i.  For signed values, need to do sign-extension when converting
  * the last byte which carries the sign bit.
  * The macros does not require i be of a certain byte sizes.  It just requires
  * i be big enough to hold the intended value range.  E.g. INT16DECODE works
  * correctly even if i is actually a 64bit int like in a Cray.
  */
 
 #define INT16DECODE(p, i)                                                                                    \
     do {                                                                                                     \
         (i) = (int16_t)((*(p)&0xff));                                                                        \
         (p)++;                                                                                               \
         (i) |= (int16_t)(((*(p)&0xff) << 8) | ((*(p)&0x80) ? ~0xffff : 0x0));                                \
         (p)++;                                                                                               \
     } while (0)
 
 #define UINT16DECODE(p, i)                                                                                   \
     do {                                                                                                     \
         (i) = (uint16_t)(*(p)&0xff);                                                                         \
         (p)++;                                                                                               \
         (i) |= (uint16_t)((*(p)&0xff) << 8);                                                                 \
         (p)++;                                                                                               \
     } while (0)
 
 #define INT32DECODE(p, i)                                                                                    \
     do {                                                                                                     \
         (i) = ((int32_t)(*(p)&0xff));                                                                        \
         (p)++;                                                                                               \
         (i) |= ((int32_t)(*(p)&0xff) << 8);                                                                  \
         (p)++;                                                                                               \
         (i) |= ((int32_t)(*(p)&0xff) << 16);                                                                 \
         (p)++;                                                                                               \
         (i) |= ((int32_t)(((*(p) & (unsigned)0xff) << 24) | ((*(p)&0x80) ? ~0xffffffffULL : 0x0ULL)));       \
         (p)++;                                                                                               \
     } while (0)
 
 #define UINT32DECODE(p, i)                                                                                   \
     do {                                                                                                     \
         (i) = (uint32_t)(*(p)&0xff);                                                                         \
         (p)++;                                                                                               \
         (i) |= ((uint32_t)(*(p)&0xff) << 8);                                                                 \
         (p)++;                                                                                               \
         (i) |= ((uint32_t)(*(p)&0xff) << 16);                                                                \
         (p)++;                                                                                               \
         (i) |= ((uint32_t)(*(p)&0xff) << 24);                                                                \
         (p)++;                                                                                               \
     } while (0)
 
 /* Decode a variable-sized buffer */
 /* (Assumes that the high bits of the integer will be zero) */
 #define DECODE_VAR(p, n, l)                                                                                  \
     do {                                                                                                     \
         size_t _i;                                                                                           \
                                                                                                              \
         n = 0;                                                                                               \
         (p) += l;                                                                                            \
         for (_i = 0; _i < l; _i++)                                                                           \
             n = (n << 8) | *(--p);                                                                           \
         (p) += l;                                                                                            \
     } while (0)
 
 /* Decode a variable-sized buffer into a 32-bit unsigned integer */
 /* (Assumes that the high bits of the integer will be zero) */
 #define UINT32DECODE_VAR(p, n, l) DECODE_VAR(p, n, l)
 
 #define INT64DECODE(p, n)                                                                                    \
     do {                                                                                                     \
         /* WE DON'T CHECK FOR OVERFLOW! */                                                                   \
         size_t _i;                                                                                           \
                                                                                                              \
         n = 0;                                                                                               \
         (p) += 8;                                                                                            \
         for (_i = 0; _i < sizeof(int64_t); _i++)                                                             \
             n = (int64_t)(((uint64_t)n << 8) | *(--p));                                                      \
         (p) += 8;                                                                                            \
     } while (0)
 
 #define UINT64DECODE(p, n)                                                                                   \
     do {                                                                                                     \
         /* WE DON'T CHECK FOR OVERFLOW! */                                                                   \
         size_t _i;                                                                                           \
                                                                                                              \
         n = 0;                                                                                               \
         (p) += 8;                                                                                            \
         for (_i = 0; _i < sizeof(uint64_t); _i++)                                                            \
             n = (uint64_t)(((uint64_t)n << 8) | *(--p));                                                     \
         (p) += 8;                                                                                            \
     } while (0)
 
 /* Decode a variable-sized buffer into a 64-bit unsigned integer */
 /* (Assumes that the high bits of the integer will be zero) */
 #define UINT64DECODE_VAR(p, n, l) DECODE_VAR(p, n, l)
 
 #define H5_DECODE_UNSIGNED(p, n)                                                                             \
     do {                                                                                                     \
         HDcompile_assert(sizeof(unsigned) == sizeof(uint32_t));                                              \
         UINT32DECODE(p, n);                                                                                  \
     } while (0)
 
 /* Assumes the endianness of uint64_t is the same as double */
 #define H5_DECODE_DOUBLE(p, n)                                                                               \
     do {                                                                                                     \
         uint64_t _n;                                                                                         \
         size_t   _u;                                                                                         \
                                                                                                              \
         HDcompile_assert(sizeof(double) == 8);                                                               \
         HDcompile_assert(sizeof(double) == sizeof(uint64_t));                                                \
         _n = 0;                                                                                              \
         (p) += 8;                                                                                            \
         for (_u = 0; _u < sizeof(uint64_t); _u++)                                                            \
             _n = (_n << 8) | *(--p);                                                                         \
         H5MM_memcpy(&(n), &_n, sizeof(double));                                                              \
         (p) += 8;                                                                                            \
     } while (0)
 
 /* Macros to encode/decode offset/length's for storing in the file */
 #define H5_ENCODE_LENGTH_LEN(p, l, s)                                                                        \
     do {                                                                                                     \
         switch (s) {                                                                                         \
             case 4:                                                                                          \
                 UINT32ENCODE(p, l);                                                                          \
                 break;                                                                                       \
             case 8:                                                                                          \
                 UINT64ENCODE(p, l);                                                                          \
                 break;                                                                                       \
             case 2:                                                                                          \
                 UINT16ENCODE(p, l);                                                                          \
                 break;                                                                                       \
             default:                                                                                         \
                 assert("bad sizeof size" && 0);                                                              \
         }                                                                                                    \
     } while (0)
 
 #define H5_DECODE_LENGTH_LEN(p, l, s)                                                                        \
     do {                                                                                                     \
         switch (s) {                                                                                         \
             case 4:                                                                                          \
                 UINT32DECODE(p, l);                                                                          \
                 break;                                                                                       \
             case 8:                                                                                          \
                 UINT64DECODE(p, l);                                                                          \
                 break;                                                                                       \
             case 2:                                                                                          \
                 UINT16DECODE(p, l);                                                                          \
                 break;                                                                                       \
             default:                                                                                         \
                 assert("bad sizeof size" && 0);                                                              \
         }                                                                                                    \
     } while (0)
 
 #endif /* H5encode_H */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team