gitlab-cbor 1.0.0

data/ext/cbor/unpacker.c

@@ -0,0 +1,787 @@
+/*
+ * CBOR for Ruby
+ *
+ * Copyright (C) 2013 Carsten Bormann
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License").
+ *
+ * Based on:
+ ***********/
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2013 Sadayuki Furuhashi
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include "unpacker.h"
+#include "rmem.h"
+#include <math.h>               /* for ldexp */
+
+/* work around https://bugs.ruby-lang.org/issues/15779 for now
+ * by limiting preallocation to about a half a Mebibyte
+ * limit is 2**n-1 (n==16) items so we can avoid a conditional
+ */
+#define SANE_PREALLOCATION_MAX 0xFFFFUL
+#define SANE_PREALLOCATE(n) (n & SANE_PREALLOCATION_MAX)
+
+#if !defined(DISABLE_RMEM) && !defined(DISABLE_UNPACKER_STACK_RMEM) && \
+        MSGPACK_UNPACKER_STACK_CAPACITY * MSGPACK_UNPACKER_STACK_SIZE <= MSGPACK_RMEM_PAGE_SIZE
+#define UNPACKER_STACK_RMEM
+#endif
+
+#ifdef UNPACKER_STACK_RMEM
+static msgpack_rmem_t s_stack_rmem;
+#endif
+
+void msgpack_unpacker_static_init()
+{
+#ifdef UNPACKER_STACK_RMEM
+    msgpack_rmem_init(&s_stack_rmem);
+#endif
+
+#ifdef COMPAT_HAVE_ENCODING
+    s_enc_utf8 = rb_utf8_encindex();
+#endif
+}
+
+void msgpack_unpacker_static_destroy()
+{
+#ifdef UNPACKER_STACK_RMEM
+    msgpack_rmem_destroy(&s_stack_rmem);
+#endif
+}
+
+#define HEAD_BYTE_REQUIRED IB_UNUSED
+
+void msgpack_unpacker_init(msgpack_unpacker_t* uk)
+{
+    memset(uk, 0, sizeof(msgpack_unpacker_t));
+
+    msgpack_buffer_init(UNPACKER_BUFFER_(uk));
+
+    uk->head_byte = HEAD_BYTE_REQUIRED;
+
+    uk->last_object = Qnil;
+    uk->reading_raw = Qnil;
+
+#ifdef UNPACKER_STACK_RMEM
+    uk->stack = msgpack_rmem_alloc(&s_stack_rmem);
+    /*memset(uk->stack, 0, MSGPACK_UNPACKER_STACK_CAPACITY);*/
+#else
+    /*uk->stack = calloc(MSGPACK_UNPACKER_STACK_CAPACITY, sizeof(msgpack_unpacker_stack_t));*/
+    uk->stack = malloc(MSGPACK_UNPACKER_STACK_CAPACITY * sizeof(msgpack_unpacker_stack_t));
+#endif
+    uk->stack_capacity = MSGPACK_UNPACKER_STACK_CAPACITY;
+}
+
+void msgpack_unpacker_destroy(msgpack_unpacker_t* uk)
+{
+#ifdef UNPACKER_STACK_RMEM
+    msgpack_rmem_free(&s_stack_rmem, uk->stack);
+#else
+    free(uk->stack);
+#endif
+
+    msgpack_buffer_destroy(UNPACKER_BUFFER_(uk));
+}
+
+void msgpack_unpacker_mark(msgpack_unpacker_t* uk)
+{
+    rb_gc_mark(uk->last_object);
+    rb_gc_mark(uk->reading_raw);
+
+    msgpack_unpacker_stack_t* s = uk->stack;
+    msgpack_unpacker_stack_t* send = uk->stack + uk->stack_depth;
+    for(; s < send; s++) {
+        rb_gc_mark(s->object);
+        rb_gc_mark(s->key);
+    }
+
+    /* See MessagePack_Buffer_wrap */
+    /* msgpack_buffer_mark(UNPACKER_BUFFER_(uk)); */
+    rb_gc_mark(uk->buffer_ref);
+}
+
+void msgpack_unpacker_reset(msgpack_unpacker_t* uk)
+{
+    msgpack_buffer_clear(UNPACKER_BUFFER_(uk));
+
+    uk->head_byte = HEAD_BYTE_REQUIRED;
+
+    /*memset(uk->stack, 0, sizeof(msgpack_unpacker_t) * uk->stack_depth);*/
+    uk->stack_depth = 0;
+
+    uk->last_object = Qnil;
+    uk->reading_raw = Qnil;
+    uk->reading_raw_remaining = 0;
+}
+
+
+/* head byte functions */
+static int read_head_byte(msgpack_unpacker_t* uk)
+{
+    int r = msgpack_buffer_read_1(UNPACKER_BUFFER_(uk));
+    if(r == -1) {
+        return PRIMITIVE_EOF;
+    }
+    return uk->head_byte = r;
+}
+
+static inline int get_head_byte(msgpack_unpacker_t* uk)
+{
+    int b = uk->head_byte;
+    if(b == HEAD_BYTE_REQUIRED) {
+        b = read_head_byte(uk);
+    }
+    return b;
+}
+
+static inline void reset_head_byte(msgpack_unpacker_t* uk)
+{
+    uk->head_byte = HEAD_BYTE_REQUIRED;
+}
+
+static inline int object_complete(msgpack_unpacker_t* uk, VALUE object)
+{
+    uk->last_object = object;
+    reset_head_byte(uk);
+    return PRIMITIVE_OBJECT_COMPLETE;
+}
+
+static inline VALUE object_string_encoding_set(VALUE str, int textflag) {
+#ifdef COMPAT_HAVE_ENCODING
+  //str_modifiable(str);
+  ENCODING_SET(str, textflag ? s_enc_utf8: s_enc_ascii8bit);
+#endif
+  return str;
+}
+
+static inline int object_complete_string(msgpack_unpacker_t* uk, VALUE str, int textflag)
+{
+  return object_complete(uk, object_string_encoding_set(str, textflag));
+}
+
+/* stack funcs */
+static inline msgpack_unpacker_stack_t* _msgpack_unpacker_stack_top(msgpack_unpacker_t* uk)
+{
+    return &uk->stack[uk->stack_depth-1];
+}
+
+static inline int _msgpack_unpacker_stack_push_tag(msgpack_unpacker_t* uk, enum stack_type_t type, size_t count, VALUE object, uint64_t tag)
+{
+    reset_head_byte(uk);
+
+    if(uk->stack_capacity - uk->stack_depth <= 0) {
+        return PRIMITIVE_STACK_TOO_DEEP;
+    }
+
+    msgpack_unpacker_stack_t* next = &uk->stack[uk->stack_depth];
+    next->count = count;
+    next->type = type;
+    next->object = object;
+    next->key = Qnil;
+    next->tag = tag;
+
+    uk->stack_depth++;
+    return PRIMITIVE_CONTAINER_START;
+}
+
+static inline int _msgpack_unpacker_stack_push(msgpack_unpacker_t* uk, enum stack_type_t type, size_t count, VALUE object)
+{
+  return _msgpack_unpacker_stack_push_tag(uk, type, count, object, 0);
+}
+
+static inline VALUE msgpack_unpacker_stack_pop(msgpack_unpacker_t* uk)
+{
+    return --uk->stack_depth;
+}
+
+static inline bool msgpack_unpacker_stack_is_empty(msgpack_unpacker_t* uk)
+{
+    return uk->stack_depth == 0;
+}
+
+#ifdef USE_CASE_RANGE
+
+#define SWITCH_RANGE_BEGIN(BYTE)     { switch(BYTE) {
+#define SWITCH_RANGE(BYTE, FROM, TO) } case FROM ... TO: {
+#define SWITCH_RANGE_DEFAULT         } default: {
+#define SWITCH_RANGE_END             } }
+
+#else
+
+#define SWITCH_RANGE_BEGIN(BYTE)     { if(0) {
+#define SWITCH_RANGE(BYTE, FROM, TO) } else if(FROM <= (BYTE) && (BYTE) <= TO) {
+#define SWITCH_RANGE_DEFAULT         } else {
+#define SWITCH_RANGE_END             } }
+
+#endif
+
+
+#define READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, n) \
+    union msgpack_buffer_cast_block_t* cb = msgpack_buffer_read_cast_block(UNPACKER_BUFFER_(uk), n); \
+    if(cb == NULL) { \
+        return PRIMITIVE_EOF; \
+    }
+
+static inline bool is_reading_map_key(msgpack_unpacker_t* uk)
+{
+    if(uk->stack_depth > 0) {
+        msgpack_unpacker_stack_t* top = _msgpack_unpacker_stack_top(uk);
+        if(top->type == STACK_TYPE_MAP_KEY || top->type == STACK_TYPE_MAP_KEY_INDEF) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static int read_raw_body_cont(msgpack_unpacker_t* uk, int textflag)
+{
+    size_t length = uk->reading_raw_remaining;
+
+    if(uk->reading_raw == Qnil) {
+        uk->reading_raw = rb_str_buf_new(SANE_PREALLOCATE(length));
+    }
+
+    do {
+        size_t n = msgpack_buffer_read_to_string(UNPACKER_BUFFER_(uk), uk->reading_raw, length);
+        if(n == 0) {
+            return PRIMITIVE_EOF;
+        }
+        /* update reading_raw_remaining everytime because
+         * msgpack_buffer_read_to_string raises IOError */
+        uk->reading_raw_remaining = length = length - n;
+    } while(length > 0);
+
+    object_complete_string(uk, uk->reading_raw, textflag);
+    uk->reading_raw = Qnil;
+    return PRIMITIVE_OBJECT_COMPLETE;
+}
+
+static inline int read_raw_body_begin(msgpack_unpacker_t* uk, int textflag)
+{
+    /* assuming uk->reading_raw == Qnil */
+    uk->textflag = textflag;
+
+    /* try optimized read */
+    size_t length = uk->reading_raw_remaining;
+    if(length <= msgpack_buffer_top_readable_size(UNPACKER_BUFFER_(uk))) {
+        /* don't use zerocopy for hash keys but get a frozen string directly
+         * because rb_hash_aset freezes keys and it causes copying */
+        bool will_freeze = is_reading_map_key(uk);
+        VALUE string;
+        bool as_symbol = will_freeze && textflag && uk->keys_as_symbols;
+        string = msgpack_buffer_read_top_as_string(UNPACKER_BUFFER_(uk), length, will_freeze, as_symbol);
+        if (as_symbol)
+          object_complete(uk, string);
+        else {
+          object_complete_string(uk, string, textflag);
+          if (will_freeze) {
+            rb_obj_freeze(string);
+          }
+        }
+
+        uk->reading_raw_remaining = 0;
+        return PRIMITIVE_OBJECT_COMPLETE;
+    }
+
+    return read_raw_body_cont(uk, textflag);
+}
+
+/* speedier version of ldexp for 11-bit numbers  */
+static inline double ldexp11(int mant, int exp) {
+#if SOMEBODY_FIXED_LDEXP
+  return ldexp(mant, exp);
+#else
+  union {
+    double d;
+    uint64_t u;
+  } u;
+  u.u = ((mant & 0x3ffULL) << 42) | ((exp + 1033ULL) << 52);
+  return u.d;
+#endif
+}
+
+#define READ_VAL(uk, ai, val)  {                \
+    int n = 1 << ((ai) & 3);                    \
+    READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, n);   \
+    switch ((ai) & 3) {                         \
+    case 0: {                                   \
+      val = cb->u8;                             \
+      break;                                    \
+    }                                           \
+    case 1: {                                   \
+      val = _msgpack_be16(cb->u16);             \
+      break;                                    \
+    }                                           \
+    case 2: {                                   \
+      val = _msgpack_be32(cb->u32);             \
+      break;                                    \
+    }                                           \
+    case 3: {                                   \
+      val = _msgpack_be64(cb->u64);             \
+      break;                                    \
+    }                                           \
+    }                                           \
+  }
+
+
+/* All the cases with an immediate value in the AI */
+#define CASE_IMM(n) case ((n*8)): case ((n*8) + 1): case ((n*8) + 2): case ((n*8) + 3): case ((n*8) + 4): case ((n*8) + 5)
+/* The case with additional information */
+#define CASE_AI(n) case ((n*8) + 6)
+/* The case with the reserved and indefinite ai values */
+#define CASE_INDEF(n) case ((n*8) + 7)
+
+static int read_primitive(msgpack_unpacker_t* uk)
+{
+    if(uk->reading_raw_remaining > 0) {
+      return read_raw_body_cont(uk, uk->textflag);
+    }
+
+    int ib = get_head_byte(uk);
+    if (ib < 0) {
+        return ib;
+    }
+
+    int ai = IB_AI(ib);
+    uint64_t val = ai;
+
+    switch (ib >> 2) {
+    CASE_IMM(MT_UNSIGNED): // Positive Fixnum
+      return object_complete(uk, INT2FIX(ai));
+    CASE_AI(MT_UNSIGNED):
+      READ_VAL(uk, ai, val);
+      return object_complete(uk, rb_ull2inum(val));
+    CASE_IMM(MT_NEGATIVE): // Negative Fixnum
+      return object_complete(uk, INT2FIX(~ai));
+    CASE_AI(MT_NEGATIVE):
+      READ_VAL(uk, ai, val);
+      return object_complete(uk,
+                             (val & 0x8000000000000000
+                              ? rb_funcall(rb_ull2inum(val), rb_intern("~"), 0)
+                              : rb_ll2inum(~val)));
+    CASE_AI(MT_BYTES): CASE_AI(MT_TEXT):
+      READ_VAL(uk, ai, val);
+    CASE_IMM(MT_BYTES): // byte string
+    CASE_IMM(MT_TEXT): // text string
+        if (val == 0) {
+          return object_complete_string(uk, rb_str_buf_new(0), ib & IB_TEXTFLAG);
+        }
+        uk->reading_raw_remaining = val; /* TODO: range checks on val here and below */
+        return read_raw_body_begin(uk, ib & IB_TEXTFLAG);
+    CASE_AI(MT_ARRAY):
+      READ_VAL(uk, ai, val);
+    CASE_IMM(MT_ARRAY): // array
+        if (val == 0) {
+            return object_complete(uk, rb_ary_new());
+        }
+        return _msgpack_unpacker_stack_push(uk, STACK_TYPE_ARRAY, val, rb_ary_new2(SANE_PREALLOCATE(val)));
+    CASE_AI(MT_MAP):
+      READ_VAL(uk, ai, val);
+    CASE_IMM(MT_MAP): // map
+        if (val == 0) {
+            return object_complete(uk, rb_hash_new());
+        }
+        return _msgpack_unpacker_stack_push(uk, STACK_TYPE_MAP_KEY, val*2, rb_hash_new());
+    CASE_AI(MT_TAG):
+      READ_VAL(uk, ai, val);
+    CASE_IMM(MT_TAG): // tag
+      return _msgpack_unpacker_stack_push_tag(uk, STACK_TYPE_TAG, 1, Qnil, val);
+    case MT_PRIM*8+5:
+        switch(ai) {
+        case VAL_NIL:  // nil
+            return object_complete(uk, Qnil);
+        case VAL_FALSE:  // false
+            return object_complete(uk, Qfalse);
+        case VAL_TRUE:  // true
+            return object_complete(uk, Qtrue);
+        }
+        /* fall through */
+    case MT_PRIM*8: case MT_PRIM*8+1: case MT_PRIM*8+2: case MT_PRIM*8+3: case MT_PRIM*8+4:
+      return object_complete(uk, rb_struct_new(rb_cCBOR_Simple, INT2FIX(val)));
+    CASE_AI(MT_PRIM):
+      READ_VAL(uk, ai, val);
+      switch (ai) {
+        case AI_2: {  // half
+          int exp = (val >> 10) & 0x1f;
+          int mant = val & 0x3ff; /* 10 bits */
+          double res;
+          if (exp == 0) res = ldexp(mant, -24);
+          else if (exp != 31) res = ldexp11(mant + 1024, exp - 25);
+          else {
+            if (mant == 0)
+              res = INFINITY;
+            else { /* NAN */
+              union {
+                uint64_t u64;
+                double d;
+              } castbuf = { (val & 0x8000) << 48 | 0x7ff0000000000000UL | (uint64_t)mant << 42 };
+              return object_complete(uk, rb_float_new(castbuf.d));
+            }
+          }
+          return object_complete(uk, rb_float_new(val & 0x8000 ? -res : res));
+        }
+        case AI_4:  // float
+            {
+              union {
+                uint32_t u32;
+                float f;
+              } castbuf = { (uint32_t)val }; /* sets Q to 1 for NAN */
+              if (castbuf.f == castbuf.f) {
+                return object_complete(uk, rb_float_new(castbuf.f));
+              } else { /* NAN */
+                uint64_t mant = val & 0x7fffff; /* 23 bits */
+                union {
+                  uint64_t u64;
+                  double d;
+                } castbuf1 = { (val & 0x80000000UL) << 32 | 0x7ff0000000000000UL | mant << 29 };
+                return object_complete(uk, rb_float_new(castbuf1.d));
+              }
+            }
+        case AI_8:  // double
+            {
+              union {
+                uint64_t u64;
+                double d;
+              } castbuf = { val };
+              return object_complete(uk, rb_float_new(castbuf.d));
+            }
+        default:
+          return object_complete(uk, rb_struct_new(rb_cCBOR_Simple, INT2FIX(val)));
+      }
+    CASE_INDEF(MT_BYTES): CASE_INDEF(MT_TEXT):           /* handle string */
+      if (ai == AI_INDEF)
+        return _msgpack_unpacker_stack_push(uk, STACK_TYPE_STRING_INDEF, ib & IB_TEXTFLAG,
+                                            object_string_encoding_set(rb_str_buf_new(0),
+                                                                       ib & IB_TEXTFLAG));
+      /* fall through */
+    CASE_INDEF(MT_ARRAY):
+      if (ai == AI_INDEF)
+        return _msgpack_unpacker_stack_push(uk, STACK_TYPE_ARRAY_INDEF, 0, rb_ary_new2(0));
+      /* fall through */
+    CASE_INDEF(MT_MAP):
+      if (ai == AI_INDEF)
+        return _msgpack_unpacker_stack_push(uk, STACK_TYPE_MAP_KEY_INDEF, 0, rb_hash_new());
+      /* fall through */
+    CASE_INDEF(MT_PRIM):
+      if (ai == AI_INDEF)
+        return PRIMITIVE_BREAK;
+      /* fall through */
+    }
+    return PRIMITIVE_INVALID_BYTE;
+}
+
+
+int msgpack_unpacker_read_container_header(msgpack_unpacker_t* uk, uint64_t* result_size, int ib)
+{
+    int b = get_head_byte(uk);
+    if(b < 0) {
+        return b;
+    }
+
+    if(ib <= b && b < (ib + AI_1)) {
+      *result_size = IB_AI(b);
+    } else if((b & ~0x3) == (ib + AI_1)) {
+      uint64_t val;
+      READ_VAL(uk, b, val);
+      *result_size = val;
+    } else {
+        return PRIMITIVE_UNEXPECTED_TYPE; /* including INDEF! */
+    }
+
+    reset_head_byte(uk);
+    return 0;
+}
+
+
+int msgpack_unpacker_read_array_header(msgpack_unpacker_t* uk, uint64_t* result_size) {
+  return msgpack_unpacker_read_container_header(uk, result_size, IB_ARRAY);
+}
+
+int msgpack_unpacker_read_map_header(msgpack_unpacker_t* uk, uint64_t* result_size) {
+  return msgpack_unpacker_read_container_header(uk, result_size, IB_MAP);
+}
+
+static VALUE msgpack_unpacker_process_tag(msgpack_unpacker_t* uk, uint64_t tag, VALUE v) {
+  VALUE res = v;
+  switch (tag) {
+  case TAG_TIME_EPOCH: {
+    return rb_funcall(rb_cTime, rb_intern("at"), 1, v);
+  }
+  case TAG_RE: {
+    /* Reconstructing a Regexp runs the decoded data through Regexp.new,
+       which the caller may not want when decoding input from an untrusted
+       source.  Only do it when the caller opts in with
+       reconstruct_from_tags: [35]; otherwise return the value as a generic
+       tagged object. */
+    if (!uk->reconstruct_regexp)
+      goto unknown_tag;
+    return rb_funcall(rb_cRegexp, rb_intern("new"), 1, v);
+  }
+  case TAG_URI: {
+    /* Likewise, building a URI from the decoded value is opt-in via
+       reconstruct_from_tags: [32]. */
+    if (!uk->reconstruct_uri)
+      goto unknown_tag;
+    if (!rb_const_defined(rb_cObject, rb_intern("URI")))
+      goto unknown_tag;
+    return rb_funcall(rb_const_get(rb_cObject, rb_intern("URI")),
+                      rb_intern("parse"), 1, v);
+  }
+  case TAG_BIGNUM_NEG:
+  case TAG_BIGNUM:
+    /* check object is a byte string */
+    if (rb_type(v) != T_STRING)
+      break;                    /* XXX: really should error out here */
+#ifdef COMPAT_HAVE_ENCODING
+    if (ENCODING_GET(v) != s_enc_ascii8bit)
+      break;                    /* XXX: really should error out here */
+#endif
+    {
+      char *sp = RSTRING_PTR(v);
+      size_t slen = RSTRING_LEN(v);
+      while (slen && *sp == 0) {
+        slen--;
+        sp++;
+      }
+
+#ifdef HAVE_RB_INTEGER_UNPACK
+
+      res = rb_integer_unpack(sp, slen, 1, 0, INTEGER_PACK_BIG_ENDIAN);
+      /* (const void *words, size_t numwords, size_t wordsize, size_t nails, int flags); */
+
+#else
+
+#ifndef CANT_DO_BIGNUMS_FAST_ON_THIS_PLATFORM
+      int ndig = (slen + SIZEOF_BDIGITS - 1)/SIZEOF_BDIGITS;
+      res = rb_big_new(ndig, 1);
+    /* compute number RSTRING_PTR(v) */
+      if (ndig) {
+        BDIGIT *ds = RBIGNUM_DIGITS(res);
+        int missbytes = ndig*SIZEOF_BDIGITS - slen; /* 0..SIZEOF_BDIGITS - 1 */
+        union {
+          char msdig_str[SIZEOF_BDIGITS];
+          BDIGIT msdig_bd;
+        } u;
+        u.msdig_bd = 0;
+        memcpy(u.msdig_str + missbytes, sp, SIZEOF_BDIGITS - missbytes);
+        ds[ndig-1] = NTOHBDIGIT(u.msdig_bd);
+        sp += SIZEOF_BDIGITS - missbytes;
+        while (--ndig > 0) {
+          memcpy(u.msdig_str, sp, SIZEOF_BDIGITS);
+          ds[ndig-1] = NTOHBDIGIT(u.msdig_bd);
+          sp += SIZEOF_BDIGITS;
+        }
+      }
+#else
+      {
+        /* This is a slow workaround only... But a working one. */
+        char *hex = ALLOC_N(char, 2 * slen + 1);
+        char *p = hex;
+        while (slen) {
+          sprintf(p, "%02x", *sp++ & 0xFF);
+          p += 2;
+          slen--;
+        }
+        *p = 0;
+        res = rb_cstr2inum(hex, 16);
+        xfree(hex);
+      }
+#endif
+#endif
+      if (tag == TAG_BIGNUM)    /* non-negative */
+#ifndef CANT_DO_BIGNUMS_FAST_ON_THIS_PLATFORM
+        return rb_big_norm(res);
+#else
+        return res;
+#endif
+      else
+        return rb_funcall(res, rb_intern("~"), 0);  /* should be rb_big_neg(), but that is static. */
+    }
+  }
+unknown_tag:
+  /* common return for unknown tags */
+  return rb_struct_new(rb_cCBOR_Tagged, rb_ull2inum(tag), v);
+}
+
+int msgpack_unpacker_read(msgpack_unpacker_t* uk, size_t target_stack_depth)
+{
+    while(true) {
+        int r = read_primitive(uk);
+        if(r < 0) {
+            return r;
+        }
+        if(r == PRIMITIVE_CONTAINER_START) {
+            continue;
+        }
+        /* PRIMITIVE_OBJECT_COMPLETE */
+
+        if(msgpack_unpacker_stack_is_empty(uk)) {
+            if (r == PRIMITIVE_BREAK)
+              return PRIMITIVE_INVALID_BYTE;
+            return PRIMITIVE_OBJECT_COMPLETE;
+        }
+
+        container_completed:
+        {
+            msgpack_unpacker_stack_t* top = _msgpack_unpacker_stack_top(uk);
+            if (top->type <= STACK_TYPE_MAP_VALUE_INDEF && r == PRIMITIVE_BREAK)
+              return PRIMITIVE_INVALID_BYTE;
+            switch(top->type) {
+            case STACK_TYPE_ARRAY:
+                rb_ary_push(top->object, uk->last_object);
+                break;
+            case STACK_TYPE_MAP_KEY:
+                top->key = uk->last_object;
+                top->type = STACK_TYPE_MAP_VALUE;
+                break;
+            case STACK_TYPE_MAP_VALUE:
+                rb_hash_aset(top->object, top->key, uk->last_object);
+                top->type = STACK_TYPE_MAP_KEY;
+                break;
+            case STACK_TYPE_TAG:
+              object_complete(uk, msgpack_unpacker_process_tag(uk, top->tag, uk->last_object));
+              goto done;
+              
+            case STACK_TYPE_ARRAY_INDEF:
+              if (r == PRIMITIVE_BREAK)
+                goto complete;
+              rb_ary_push(top->object, uk->last_object);
+              continue;
+            case STACK_TYPE_MAP_KEY_INDEF:
+              if (r == PRIMITIVE_BREAK)
+                goto complete;
+              top->key = uk->last_object;
+              top->type = STACK_TYPE_MAP_VALUE_INDEF;
+              continue;
+            case STACK_TYPE_MAP_VALUE_INDEF:
+              rb_hash_aset(top->object, top->key, uk->last_object);
+              top->type = STACK_TYPE_MAP_KEY_INDEF;
+              continue;
+            case STACK_TYPE_STRING_INDEF:
+              if (r == PRIMITIVE_BREAK) {
+                object_complete_string(uk, top->object, (int)top->count); /* use count as textflag */
+                goto done;
+              }
+              if (!RB_TYPE_P(uk->last_object, T_STRING))
+                return PRIMITIVE_INVALID_BYTE;
+#ifdef COMPAT_HAVE_ENCODING     /* XXX */
+              if (ENCODING_GET(top->object) != ENCODING_GET(uk->last_object))
+                return PRIMITIVE_INVALID_BYTE;
+#endif
+              rb_str_append(top->object, uk->last_object);
+              continue;
+            }
+            size_t count = --top->count;
+
+            if(count == 0) {
+            complete:;
+              object_complete(uk, top->object);
+            done:;
+                if(msgpack_unpacker_stack_pop(uk) <= target_stack_depth) {
+                    return PRIMITIVE_OBJECT_COMPLETE;
+                }
+                r = PRIMITIVE_OBJECT_COMPLETE;
+                goto container_completed;
+            }
+        }
+    }
+}
+
+int msgpack_unpacker_skip(msgpack_unpacker_t* uk, size_t target_stack_depth)
+{
+    while(true) {
+        int r = read_primitive(uk);
+        if(r < 0) {
+            return r;
+        }
+        if(r == PRIMITIVE_CONTAINER_START) {
+            continue;
+        }
+        /* PRIMITIVE_OBJECT_COMPLETE */
+
+        if(msgpack_unpacker_stack_is_empty(uk)) {
+            return PRIMITIVE_OBJECT_COMPLETE;
+        }
+
+        container_completed:
+        {
+            msgpack_unpacker_stack_t* top = _msgpack_unpacker_stack_top(uk);
+
+            /* this section optimized out */
+            // TODO object_complete still creates objects which should be optimized out
+            /* XXX: check INDEF! */
+
+            size_t count = --top->count;
+
+            if(count == 0) {
+                object_complete(uk, Qnil);
+                if(msgpack_unpacker_stack_pop(uk) <= target_stack_depth) {
+                    return PRIMITIVE_OBJECT_COMPLETE;
+                }
+                goto container_completed;
+            }
+        }
+    }
+}
+
+/* dead code, but keep it for comparison purposes */
+
+static enum msgpack_unpacker_object_type msgpack_unpacker_object_types_per_mt[] = {
+    TYPE_INTEGER, TYPE_INTEGER,
+    TYPE_RAW, TYPE_RAW,         /* XXX */
+    TYPE_ARRAY, TYPE_MAP,
+    TYPE_INTEGER,               /* XXX */
+    TYPE_NIL                    /* see below: */
+};
+
+static enum msgpack_unpacker_object_type msgpack_unpacker_object_types_per_ai[] = {
+  PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE,
+  PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE,
+  PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE,
+  PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE,
+  PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE,
+  TYPE_BOOLEAN, TYPE_BOOLEAN, TYPE_NIL, PRIMITIVE_INVALID_BYTE, /* XXX */
+  PRIMITIVE_INVALID_BYTE, TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT,
+  PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE, PRIMITIVE_INVALID_BYTE,
+};
+
+int msgpack_unpacker_peek_next_object_type(msgpack_unpacker_t* uk)
+{
+    int ib = get_head_byte(uk);
+    if (ib < 0) {
+        return ib;
+    }
+
+    int t = msgpack_unpacker_object_types_per_mt[IB_MT(ib)];
+    if (t == TYPE_NIL) {
+      t = msgpack_unpacker_object_types_per_ai[IB_AI(ib)];
+    }
+    return t;
+}
+
+int msgpack_unpacker_skip_nil(msgpack_unpacker_t* uk)
+{
+    int b = get_head_byte(uk);
+    if(b < 0) {
+        return b;
+    }
+    if (b == IB_NIL) {
+        return 1;
+    }
+    return 0;
+}
+