--- /dev/null
+/*
+ * 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 */
projects / ceph.git / blobdiff