duktape-1.8.0/src-separate/duk_hbufferobject.h

Go to the documentation of this file.

/*
 *  Heap Buffer object representation.  Used for all Buffer variants.
 */
 
#ifndef DUK_HBUFFEROBJECT_H_INCLUDED
#define DUK_HBUFFEROBJECT_H_INCLUDED
 
/* All element accessors are host endian now (driven by TypedArray spec). */
#define DUK_HBUFFEROBJECT_ELEM_UINT8           0
#define DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED    1
#define DUK_HBUFFEROBJECT_ELEM_INT8            2
#define DUK_HBUFFEROBJECT_ELEM_UINT16          3
#define DUK_HBUFFEROBJECT_ELEM_INT16           4
#define DUK_HBUFFEROBJECT_ELEM_UINT32          5
#define DUK_HBUFFEROBJECT_ELEM_INT32           6
#define DUK_HBUFFEROBJECT_ELEM_FLOAT32         7
#define DUK_HBUFFEROBJECT_ELEM_FLOAT64         8
#define DUK_HBUFFEROBJECT_ELEM_MAX             8
 
#define DUK_ASSERT_HBUFFEROBJECT_VALID(h) do { \
        DUK_ASSERT((h) != NULL); \
        DUK_ASSERT((h)->shift <= 3); \
        DUK_ASSERT((h)->elem_type <= DUK_HBUFFEROBJECT_ELEM_MAX); \
        DUK_ASSERT(((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8) || \
                   ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) || \
                   ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT8) || \
                   ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT16) || \
                   ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT16) || \
                   ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT32) || \
                   ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT32) || \
                   ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT32) || \
                   ((h)->shift == 3 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT64)); \
        DUK_ASSERT((h)->is_view == 0 || (h)->is_view == 1); \
        DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) (h))); \
        if ((h)->buf == NULL) { \
            DUK_ASSERT((h)->offset == 0); \
            DUK_ASSERT((h)->length == 0); \
        } else { \
            /* No assertions for offset or length; in particular, \
             * it's OK for length to be longer than underlying \
             * buffer.  Just ensure they don't wrap when added. \
             */ \
            DUK_ASSERT((h)->offset + (h)->length >= (h)->offset); \
        } \
    } while (0)
 
/* Get the current data pointer (caller must ensure buf != NULL) as a
 * duk_uint8_t ptr.
 */
#define DUK_HBUFFEROBJECT_GET_SLICE_BASE(heap,h) \
    (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \
    (((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR((heap), (h)->buf)) + (h)->offset))
 
/* True if slice is full, i.e. offset is zero and length covers the entire
 * buffer.  This status may change independently of the duk_hbufferobject if
 * the underlying buffer is dynamic and changes without the hbufferobject
 * being changed.
 */
#define DUK_HBUFFEROBJECT_FULL_SLICE(h) \
    (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \
    ((h)->offset == 0 && (h)->length == DUK_HBUFFER_GET_SIZE((h)->buf)))
 
/* Validate that the whole slice [0,length[ is contained in the underlying
 * buffer.  Caller must ensure 'buf' != NULL.
 */
#define DUK_HBUFFEROBJECT_VALID_SLICE(h) \
    (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \
    ((h)->offset + (h)->length <= DUK_HBUFFER_GET_SIZE((h)->buf)))
 
/* Validate byte read/write for virtual 'offset', i.e. check that the
 * offset, taking into account h->offset, is within the underlying
 * buffer size.  This is a safety check which is needed to ensure
 * that even a misconfigured duk_hbufferobject never causes memory
 * unsafe behavior (e.g. if an underlying dynamic buffer changes
 * after being setup).  Caller must ensure 'buf' != NULL.
 */
#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_INCL(h,off) \
    (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \
    ((h)->offset + (off) < DUK_HBUFFER_GET_SIZE((h)->buf)))
 
#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h,off) \
    (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \
    ((h)->offset + (off) <= DUK_HBUFFER_GET_SIZE((h)->buf)))
 
/* Clamp an input byte length (already assumed to be within the nominal
 * duk_hbufferobject 'length') to the current dynamic buffer limits to
 * yield a byte length limit that's safe for memory accesses.  This value
 * can be invalidated by any side effect because it may trigger a user
 * callback that resizes the underlying buffer.
 */
#define DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h,len) \
    (DUK_ASSERT_EXPR((h) != NULL), \
    duk_hbufferobject_clamp_bytelength((h), (len)))
 
struct duk_hbufferobject {
    /* Shared object part. */
    duk_hobject obj;
 
    /* Underlying buffer (refcounted), may be NULL. */
    duk_hbuffer *buf;
 
    /* Slice and accessor information.
     *
     * Because the underlying buffer may be dynamic, these may be
     * invalidated by the buffer being modified so that both offset
     * and length should be validated before every access.  Behavior
     * when the underlying buffer has changed doesn't need to be clean:
     * virtual 'length' doesn't need to be affected, reads can return
     * zero/NaN, and writes can be ignored.
     *
     * Note that a data pointer cannot be precomputed because 'buf' may
     * be dynamic and its pointer unstable.
     */
 
    duk_uint_t offset;       /* byte offset to buf */
    duk_uint_t length;       /* byte index limit for element access, exclusive */
    duk_uint8_t shift;       /* element size shift:
                              *   0 = u8/i8
                              *   1 = u16/i16
                              *   2 = u32/i32/float
                              *   3 = double
                              */
    duk_uint8_t elem_type;   /* element type */
    duk_uint8_t is_view;
};
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
DUK_INTERNAL_DECL duk_uint_t duk_hbufferobject_clamp_bytelength(duk_hbufferobject *h_bufobj, duk_uint_t len);
#endif
DUK_INTERNAL_DECL void duk_hbufferobject_push_validated_read(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size);
DUK_INTERNAL_DECL void duk_hbufferobject_validated_write(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size);
 
#endif  /* DUK_HBUFFEROBJECT_H_INCLUDED */