ceph/src/jaegertracing/opentelemetry-cpp/third_party/prometheus-cpp/3rdparty/civetweb/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer.h

   1 /*
   2  *  Heap buffer representation.
   3  *
   4  *  Heap allocated user data buffer which is either:
   5  *
   6  *    1. A fixed size buffer (data follows header statically)
   7  *    2. A dynamic size buffer (data pointer follows header)
   8  *
   9  *  The data pointer for a variable size buffer of zero size may be NULL.
  10  */
  11
  12 #ifndef DUK_HBUFFER_H_INCLUDED
  13 #define DUK_HBUFFER_H_INCLUDED
  14
  15 /*
  16  *  Flags
  17  *
  18  *  Fixed buffer:     0
  19  *  Dynamic buffer:   DUK_HBUFFER_FLAG_DYNAMIC
  20  *  External buffer:  DUK_HBUFFER_FLAG_DYNAMIC | DUK_HBUFFER_FLAG_EXTERNAL
  21  */
  22
  23 #define DUK_HBUFFER_FLAG_DYNAMIC                  DUK_HEAPHDR_USER_FLAG(0)    /* buffer is behind a pointer, dynamic or external */
  24 #define DUK_HBUFFER_FLAG_EXTERNAL                 DUK_HEAPHDR_USER_FLAG(1)    /* buffer pointer is to an externally allocated buffer */
  25
  26 #define DUK_HBUFFER_HAS_DYNAMIC(x)                DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
  27 #define DUK_HBUFFER_HAS_EXTERNAL(x)               DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
  28
  29 #define DUK_HBUFFER_SET_DYNAMIC(x)                DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
  30 #define DUK_HBUFFER_SET_EXTERNAL(x)               DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
  31
  32 #define DUK_HBUFFER_CLEAR_DYNAMIC(x)              DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
  33 #define DUK_HBUFFER_CLEAR_EXTERNAL(x)             DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
  34
  35 /*
  36  *  Misc defines
  37  */
  38
  39 /* Impose a maximum buffer length for now.  Restricted artificially to
  40  * ensure resize computations or adding a heap header length won't
  41  * overflow size_t and that a signed duk_int_t can hold a buffer
  42  * length.  The limit should be synchronized with DUK_HSTRING_MAX_BYTELEN.
  43  */
  44
  45 #if defined(DUK_USE_BUFLEN16)
  46 #define DUK_HBUFFER_MAX_BYTELEN                   (0x0000ffffUL)
  47 #else
  48 /* Intentionally not 0x7fffffffUL; at least JSON code expects that
  49  * 2*len + 2 fits in 32 bits.
  50  */
  51 #define DUK_HBUFFER_MAX_BYTELEN                   (0x7ffffffeUL)
  52 #endif
  53
  54 /*
  55  *  Field access
  56  */
  57
  58 /* Get/set the current user visible size, without accounting for a dynamic
  59  * buffer's "spare" (= usable size).
  60  */
  61 #if defined(DUK_USE_BUFLEN16)
  62 /* size stored in duk_heaphdr unused flag bits */
  63 #define DUK_HBUFFER_GET_SIZE(x)     ((x)->hdr.h_flags >> 16)
  64 #define DUK_HBUFFER_SET_SIZE(x,v)   do { \
  65                 duk_size_t duk__v; \
  66                 duk__v = (v); \
  67                 DUK_ASSERT(duk__v <= 0xffffUL); \
  68                 (x)->hdr.h_flags = ((x)->hdr.h_flags & 0x0000ffffUL) | (((duk_uint32_t) duk__v) << 16); \
  69         } while (0)
  70 #define DUK_HBUFFER_ADD_SIZE(x,dv)  do { \
  71                 (x)->hdr.h_flags += ((dv) << 16); \
  72         } while (0)
  73 #define DUK_HBUFFER_SUB_SIZE(x,dv)  do { \
  74                 (x)->hdr.h_flags -= ((dv) << 16); \
  75         } while (0)
  76 #else
  77 #define DUK_HBUFFER_GET_SIZE(x)     (((duk_hbuffer *) (x))->size)
  78 #define DUK_HBUFFER_SET_SIZE(x,v)   do { \
  79                 ((duk_hbuffer *) (x))->size = (v); \
  80         } while (0)
  81 #define DUK_HBUFFER_ADD_SIZE(x,dv)  do { \
  82                 (x)->size += (dv); \
  83         } while (0)
  84 #define DUK_HBUFFER_SUB_SIZE(x,dv)  do { \
  85                 (x)->size -= (dv); \
  86         } while (0)
  87 #endif
  88
  89 #define DUK_HBUFFER_FIXED_GET_SIZE(x)       DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
  90 #define DUK_HBUFFER_FIXED_SET_SIZE(x,v)     DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x))
  91
  92 #define DUK_HBUFFER_DYNAMIC_GET_SIZE(x)     DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
  93 #define DUK_HBUFFER_DYNAMIC_SET_SIZE(x,v)   DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v))
  94 #define DUK_HBUFFER_DYNAMIC_ADD_SIZE(x,dv)  DUK_HBUFFER_ADD_SIZE((duk_hbuffer *) (x), (dv))
  95 #define DUK_HBUFFER_DYNAMIC_SUB_SIZE(x,dv)  DUK_HBUFFER_SUB_SIZE((duk_hbuffer *) (x), (dv))
  96
  97 #define DUK_HBUFFER_EXTERNAL_GET_SIZE(x)    DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
  98 #define DUK_HBUFFER_EXTERNAL_SET_SIZE(x,v)  DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v))
  99
 100 #define DUK_HBUFFER_FIXED_GET_DATA_PTR(heap,x)    ((duk_uint8_t *) (((duk_hbuffer_fixed *) (x)) + 1))
 101
 102 #if defined(DUK_USE_HEAPPTR16)
 103 #define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap,x) \
 104         ((void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, ((duk_heaphdr *) (x))->h_extra16))
 105 #define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v)     do { \
 106                 ((duk_heaphdr *) (x))->h_extra16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
 107         } while (0)
 108 #define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x)  do { \
 109                 ((duk_heaphdr *) (x))->h_extra16 = 0;  /* assume 0 <=> NULL */ \
 110         } while (0)
 111 #else
 112 #define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap,x)       ((x)->curr_alloc)
 113 #define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v)     do { \
 114                 (x)->curr_alloc = (void *) (v); \
 115         } while (0)
 116 #define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x)  do { \
 117                 (x)->curr_alloc = (void *) NULL; \
 118         } while (0)
 119 #endif
 120
 121 /* No pointer compression because pointer is potentially outside of
 122  * Duktape heap.
 123  */
 124 #if defined(DUK_USE_HEAPPTR16)
 125 #define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap,x) \
 126         ((void *) (x)->curr_alloc)
 127 #define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v)     do { \
 128                 (x)->curr_alloc = (void *) (v); \
 129         } while (0)
 130 #define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap,x)  do { \
 131                 (x)->curr_alloc = (void *) NULL; \
 132         } while (0)
 133 #else
 134 #define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap,x) \
 135         ((void *) (x)->curr_alloc)
 136 #define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v)     do { \
 137                 (x)->curr_alloc = (void *) (v); \
 138         } while (0)
 139 #define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap,x)  do { \
 140                 (x)->curr_alloc = (void *) NULL; \
 141         } while (0)
 142 #endif
 143
 144 /* Get a pointer to the current buffer contents (matching current allocation
 145  * size).  May be NULL for zero size dynamic/external buffer.
 146  */
 147 #if defined(DUK_USE_HEAPPTR16)
 148 #define DUK_HBUFFER_GET_DATA_PTR(heap,x)  ( \
 149         DUK_HBUFFER_HAS_DYNAMIC((x)) ? \
 150                 ( \
 151                         DUK_HBUFFER_HAS_EXTERNAL((x)) ? \
 152                                 DUK_HBUFFER_EXTERNAL_GET_DATA_PTR((heap), (duk_hbuffer_external *) (x)) : \
 153                                 DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) \
 154                 ) : \
 155                 DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (x)) \
 156         )
 157 #else
 158 /* Without heap pointer compression duk_hbuffer_dynamic and duk_hbuffer_external
 159  * have the same layout so checking for fixed vs. dynamic (or external) is enough.
 160  */
 161 #define DUK_HBUFFER_GET_DATA_PTR(heap,x)  ( \
 162         DUK_HBUFFER_HAS_DYNAMIC((x)) ? \
 163                 DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) : \
 164                 DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (x)) \
 165         )
 166 #endif
 167
 168 /*
 169  *  Structs
 170  */
 171
 172 /* Shared prefix for all buffer types. */
 173 struct duk_hbuffer {
 174         duk_heaphdr hdr;
 175
 176         /* It's not strictly necessary to track the current size, but
 177          * it is useful for writing robust native code.
 178          */
 179
 180         /* Current size (not counting a dynamic buffer's "spare"). */
 181 #if defined(DUK_USE_BUFLEN16)
 182         /* Stored in duk_heaphdr unused flags. */
 183 #else
 184         duk_size_t size;
 185 #endif
 186
 187         /*
 188          *  Data following the header depends on the DUK_HBUFFER_FLAG_DYNAMIC
 189          *  flag.
 190          *
 191          *  If the flag is clear (the buffer is a fixed size one), the buffer
 192          *  data follows the header directly, consisting of 'size' bytes.
 193          *
 194          *  If the flag is set, the actual buffer is allocated separately, and
 195          *  a few control fields follow the header.  Specifically:
 196          *
 197          *    - a "void *" pointing to the current allocation
 198          *    - a duk_size_t indicating the full allocated size (always >= 'size')
 199          *
 200          *  If DUK_HBUFFER_FLAG_EXTERNAL is set, the buffer has been allocated
 201          *  by user code, so that Duktape won't be able to resize it and won't
 202          *  free it.  This allows buffers to point to e.g. an externally
 203          *  allocated structure such as a frame buffer.
 204          *
 205          *  Unlike strings, no terminator byte (NUL) is guaranteed after the
 206          *  data.  This would be convenient, but would pad aligned user buffers
 207          *  unnecessarily upwards in size.  For instance, if user code requested
 208          *  a 64-byte dynamic buffer, 65 bytes would actually be allocated which
 209          *  would then potentially round upwards to perhaps 68 or 72 bytes.
 210          */
 211 };
 212
 213 /* Fixed buffer; data follows struct, with proper alignment guaranteed by
 214  * struct size.
 215  */
 216 #if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_MSVC_PRAGMA)
 217 #pragma pack(push, 8)
 218 #endif
 219 struct duk_hbuffer_fixed {
 220         /* A union is used here as a portable struct size / alignment trick:
 221          * by adding a 32-bit or a 64-bit (unused) union member, the size of
 222          * the struct is effectively forced to be a multiple of 4 or 8 bytes
 223          * (respectively) without increasing the size of the struct unless
 224          * necessary.
 225          */
 226         union {
 227                 struct {
 228                         duk_heaphdr hdr;
 229 #if defined(DUK_USE_BUFLEN16)
 230                         /* Stored in duk_heaphdr unused flags. */
 231 #else
 232                         duk_size_t size;
 233 #endif
 234                 } s;
 235 #if (DUK_USE_ALIGN_BY == 4)
 236                 duk_uint32_t dummy_for_align4;
 237 #elif (DUK_USE_ALIGN_BY == 8)
 238                 duk_double_t dummy_for_align8;
 239 #elif (DUK_USE_ALIGN_BY == 1)
 240                 /* no extra padding */
 241 #else
 242 #error invalid DUK_USE_ALIGN_BY
 243 #endif
 244         } u;
 245
 246         /*
 247          *  Data follows the struct header.  The struct size is padded by the
 248          *  compiler based on the struct members.  This guarantees that the
 249          *  buffer data will be aligned-by-4 but not necessarily aligned-by-8.
 250          *
 251          *  On platforms where alignment does not matter, the struct padding
 252          *  could be removed (if there is any).  On platforms where alignment
 253          *  by 8 is required, the struct size must be forced to be a multiple
 254          *  of 8 by some means.  Without it, some user code may break, and also
 255          *  Duktape itself breaks (e.g. the compiler stores duk_tvals in a
 256          *  dynamic buffer).
 257          */
 258 }
 259 #if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_GCC_ATTR)
 260 __attribute__ ((aligned (8)))
 261 #elif (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_CLANG_ATTR)
 262 __attribute__ ((aligned (8)))
 263 #endif
 264 ;
 265 #if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_MSVC_PRAGMA)
 266 #pragma pack(pop)
 267 #endif
 268
 269 /* Dynamic buffer with 'curr_alloc' pointing to a dynamic area allocated using
 270  * heap allocation primitives.  Also used for external buffers when low memory
 271  * options are not used.
 272  */
 273 struct duk_hbuffer_dynamic {
 274         duk_heaphdr hdr;
 275
 276 #if defined(DUK_USE_BUFLEN16)
 277         /* Stored in duk_heaphdr unused flags. */
 278 #else
 279         duk_size_t size;
 280 #endif
 281
 282 #if defined(DUK_USE_HEAPPTR16)
 283         /* Stored in duk_heaphdr h_extra16. */
 284 #else
 285         void *curr_alloc;  /* may be NULL if alloc_size == 0 */
 286 #endif
 287
 288         /*
 289          *  Allocation size for 'curr_alloc' is alloc_size.  There is no
 290          *  automatic NUL terminator for buffers (see above for rationale).
 291          *
 292          *  'curr_alloc' is explicitly allocated with heap allocation
 293          *  primitives and will thus always have alignment suitable for
 294          *  e.g. duk_tval and an IEEE double.
 295          */
 296 };
 297
 298 /* External buffer with 'curr_alloc' managed by user code and pointing to an
 299  * arbitrary address.  When heap pointer compression is not used, this struct
 300  * has the same layout as duk_hbuffer_dynamic.
 301  */
 302 struct duk_hbuffer_external {
 303         duk_heaphdr hdr;
 304
 305 #if defined(DUK_USE_BUFLEN16)
 306         /* Stored in duk_heaphdr unused flags. */
 307 #else
 308         duk_size_t size;
 309 #endif
 310
 311         /* Cannot be compressed as a heap pointer because may point to
 312          * an arbitrary address.
 313          */
 314         void *curr_alloc;  /* may be NULL if alloc_size == 0 */
 315 };
 316
 317 /*
 318  *  Prototypes
 319  */
 320
 321 DUK_INTERNAL_DECL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags, void **out_bufdata);
 322 DUK_INTERNAL_DECL void *duk_hbuffer_get_dynalloc_ptr(duk_heap *heap, void *ud);  /* indirect allocs */
 323
 324 /* dynamic buffer ops */
 325 DUK_INTERNAL_DECL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size);
 326 DUK_INTERNAL_DECL void duk_hbuffer_reset(duk_hthread *thr, duk_hbuffer_dynamic *buf);
 327
 328 #endif  /* DUK_HBUFFER_H_INCLUDED */