couchbase 1.2.0.z.beta-x86-mingw32 → 1.2.1-x86-mingw32

data/ext/couchbase_ext/timer.c

@@ -26,7 +26,7 @@ cb_timer_free(void *ptr)
     void
 cb_timer_mark(void *ptr)
 {
-    struct timer_st *timer = ptr;
+    struct cb_timer_st *timer = ptr;
     if (timer) {
         rb_gc_mark(timer->callback);
     }
@@ -36,10 +36,10 @@ cb_timer_mark(void *ptr)
 cb_timer_alloc(VALUE klass)
 {
     VALUE obj;
-    struct timer_st *timer;
+    struct cb_timer_st *timer;
 
     /* allocate new bucket struct and set it to zero */
-    obj = Data_Make_Struct(klass, struct timer_st, cb_timer_mark,
+    obj = Data_Make_Struct(klass, struct cb_timer_st, cb_timer_mark,
             cb_timer_free, timer);
     return obj;
 }
@@ -56,7 +56,7 @@ cb_timer_alloc(VALUE klass)
 cb_timer_inspect(VALUE self)
 {
     VALUE str;
-    struct timer_st *tm = DATA_PTR(self);
+    struct cb_timer_st *tm = DATA_PTR(self);
     char buf[200];
 
     str = rb_str_buf_new2("#<");
@@ -97,7 +97,7 @@ cb_timer_inspect(VALUE self)
     VALUE
 cb_timer_cancel(VALUE self)
 {
-    struct timer_st *tm = DATA_PTR(self);
+    struct cb_timer_st *tm = DATA_PTR(self);
     lcb_timer_destroy(tm->bucket->handle, tm->timer);
     return self;
 }
@@ -105,15 +105,15 @@ cb_timer_cancel(VALUE self)
     static VALUE
 trigger_timer(VALUE timer)
 {
-    struct timer_st *tm = DATA_PTR(timer);
-    return cb_proc_call(tm->callback, 1, timer);
+    struct cb_timer_st *tm = DATA_PTR(timer);
+    return cb_proc_call(tm->bucket, tm->callback, 1, timer);
 }
 
     static void
 timer_callback(lcb_timer_t timer, lcb_t instance,
         const void *cookie)
 {
-    struct timer_st *tm = (struct timer_st *)cookie;
+    struct cb_timer_st *tm = (struct cb_timer_st *)cookie;
     int error = 0;
 
     rb_protect(trigger_timer, tm->self, &error);
@@ -162,14 +162,14 @@ timer_callback(lcb_timer_t timer, lcb_t instance,
     VALUE
 cb_timer_init(int argc, VALUE *argv, VALUE self)
 {
-    struct timer_st *tm = DATA_PTR(self);
+    struct cb_timer_st *tm = DATA_PTR(self);
     VALUE bucket, opts, timeout, exc, cb;
     lcb_error_t err;
 
     rb_need_block();
     rb_scan_args(argc, argv, "21&", &bucket, &timeout, &opts, &cb);
 
-    if (CLASS_OF(bucket) != cBucket) {
+    if (CLASS_OF(bucket) != cb_cBucket) {
         rb_raise(rb_eTypeError, "wrong argument type (expected Couchbase::Bucket)");
     }
     tm->self = self;
@@ -178,7 +178,7 @@ cb_timer_init(int argc, VALUE *argv, VALUE self)
     tm->bucket = DATA_PTR(bucket);
     if (opts != Qnil) {
         Check_Type(opts, T_HASH);
-        tm->periodic = RTEST(rb_hash_aref(opts, sym_periodic));
+        tm->periodic = RTEST(rb_hash_aref(opts, cb_sym_periodic));
     }
     tm->timer = lcb_timer_create(tm->bucket->handle, tm, tm->usec,
             tm->periodic, timer_callback, &err);

data/ext/couchbase_ext/touch.c

@@ -18,39 +18,40 @@
 #include "couchbase_ext.h"
 
     void
-touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_touch_resp_t *resp)
+cb_touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_touch_resp_t *resp)
 {
-    struct context_st *ctx = (struct context_st *)cookie;
-    struct bucket_st *bucket = ctx->bucket;
+    struct cb_context_st *ctx = (struct cb_context_st *)cookie;
+    struct cb_bucket_st *bucket = ctx->bucket;
     VALUE key, *rv = ctx->rv, exc = Qnil, res;
 
     ctx->nqueries--;
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
-    strip_key_prefix(bucket, key);
+    cb_strip_key_prefix(bucket, key);
 
     if (error != LCB_KEY_ENOENT || !ctx->quiet) {
         exc = cb_check_error(error, "failed to touch value", key);
         if (exc != Qnil) {
-            rb_ivar_set(exc, id_iv_operation, sym_touch);
-            if (NIL_P(ctx->exception)) {
-                ctx->exception = cb_gc_protect(bucket, exc);
-            }
+            rb_ivar_set(exc, cb_id_iv_operation, cb_sym_touch);
+            ctx->exception = cb_gc_protect(bucket, exc);
         }
     }
 
     if (bucket->async) {    /* asynchronous */
         if (ctx->proc != Qnil) {
-            res = rb_class_new_instance(0, NULL, cResult);
-            rb_ivar_set(res, id_iv_error, exc);
-            rb_ivar_set(res, id_iv_operation, sym_touch);
-            rb_ivar_set(res, id_iv_key, key);
-            cb_proc_call(ctx->proc, 1, res);
+            res = rb_class_new_instance(0, NULL, cb_cResult);
+            rb_ivar_set(res, cb_id_iv_error, exc);
+            rb_ivar_set(res, cb_id_iv_operation, cb_sym_touch);
+            rb_ivar_set(res, cb_id_iv_key, key);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
         rb_hash_aset(*rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
     }
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
+        if (bucket->async) {
+            free(ctx);
+        }
     }
     (void)handle;
 }
@@ -123,27 +124,27 @@ touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_to
    VALUE
 cb_bucket_touch(int argc, VALUE *argv, VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    struct context_st *ctx;
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    struct cb_context_st *ctx;
     VALUE args, rv, proc, exc;
     lcb_error_t err;
-    struct params_st params;
+    struct cb_params_st params;
 
     if (bucket->handle == NULL) {
-        rb_raise(eConnectError, "closed connection");
+        rb_raise(cb_eConnectError, "closed connection");
     }
     rb_scan_args(argc, argv, "0*&", &args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    rb_funcall(args, id_flatten_bang, 0);
-    memset(&params, 0, sizeof(struct params_st));
-    params.type = cmd_touch;
+    rb_funcall(args, cb_id_flatten_bang, 0);
+    memset(&params, 0, sizeof(struct cb_params_st));
+    params.type = cb_cmd_touch;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
     ctx->proc = cb_gc_protect(bucket, proc);
     ctx->bucket = bucket;
@@ -157,12 +158,12 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule touch request", Qnil);
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
     if (bucket->async) {
-        maybe_do_loop(bucket);
+        cb_maybe_do_loop(bucket);
         return Qnil;
     } else {
         if (ctx->nqueries > 0) {
@@ -170,12 +171,14 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        xfree(ctx);
+        free(ctx);
         if (exc != Qnil) {
             rb_exc_raise(cb_gc_unprotect(bucket, exc));
         }
-        if (bucket->exception != Qnil) {
-            rb_exc_raise(bucket->exception);
+        exc = bucket->exception;
+        if (exc != Qnil) {
+            bucket->exception = Qnil;
+            rb_exc_raise(exc);
         }
         if (params.cmd.touch.num > 1) {
             return rv;  /* return as a hash {key => true, ...} */

data/ext/couchbase_ext/unlock.c

@@ -18,39 +18,40 @@
 #include "couchbase_ext.h"
 
     void
-unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_unlock_resp_t *resp)
+cb_unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_unlock_resp_t *resp)
 {
-    struct context_st *ctx = (struct context_st *)cookie;
-    struct bucket_st *bucket = ctx->bucket;
+    struct cb_context_st *ctx = (struct cb_context_st *)cookie;
+    struct cb_bucket_st *bucket = ctx->bucket;
     VALUE key, *rv = ctx->rv, exc = Qnil, res;
 
     ctx->nqueries--;
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
-    strip_key_prefix(bucket, key);
+    cb_strip_key_prefix(bucket, key);
 
     if (error != LCB_KEY_ENOENT || !ctx->quiet) {
         exc = cb_check_error(error, "failed to unlock value", key);
         if (exc != Qnil) {
-            rb_ivar_set(exc, id_iv_operation, sym_unlock);
-            if (NIL_P(ctx->exception)) {
-                ctx->exception = cb_gc_protect(bucket, exc);
-            }
+            rb_ivar_set(exc, cb_id_iv_operation, cb_sym_unlock);
+            ctx->exception = cb_gc_protect(bucket, exc);
         }
     }
 
     if (bucket->async) {    /* asynchronous */
         if (ctx->proc != Qnil) {
-            res = rb_class_new_instance(0, NULL, cResult);
-            rb_ivar_set(res, id_iv_error, exc);
-            rb_ivar_set(res, id_iv_operation, sym_unlock);
-            rb_ivar_set(res, id_iv_key, key);
-            cb_proc_call(ctx->proc, 1, res);
+            res = rb_class_new_instance(0, NULL, cb_cResult);
+            rb_ivar_set(res, cb_id_iv_error, exc);
+            rb_ivar_set(res, cb_id_iv_operation, cb_sym_unlock);
+            rb_ivar_set(res, cb_id_iv_key, key);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
         rb_hash_aset(*rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
     }
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
+        if (bucket->async) {
+            free(ctx);
+        }
     }
     (void)handle;
 }
@@ -113,27 +114,27 @@ unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_u
    VALUE
 cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    struct context_st *ctx;
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    struct cb_context_st *ctx;
     VALUE args, rv, proc, exc;
     lcb_error_t err;
-    struct params_st params;
+    struct cb_params_st params;
 
     if (bucket->handle == NULL) {
-        rb_raise(eConnectError, "closed connection");
+        rb_raise(cb_eConnectError, "closed connection");
     }
     rb_scan_args(argc, argv, "0*&", &args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    rb_funcall(args, id_flatten_bang, 0);
-    memset(&params, 0, sizeof(struct params_st));
-    params.type = cmd_unlock;
+    rb_funcall(args, cb_id_flatten_bang, 0);
+    memset(&params, 0, sizeof(struct cb_params_st));
+    params.type = cb_cmd_unlock;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
     ctx->proc = cb_gc_protect(bucket, proc);
     ctx->bucket = bucket;
@@ -147,12 +148,12 @@ cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule unlock request", Qnil);
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
     if (bucket->async) {
-        maybe_do_loop(bucket);
+        cb_maybe_do_loop(bucket);
         return Qnil;
     } else {
         if (ctx->nqueries > 0) {
@@ -160,12 +161,14 @@ cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        xfree(ctx);
+        free(ctx);
         if (exc != Qnil) {
             rb_exc_raise(cb_gc_unprotect(bucket, exc));
         }
-        if (bucket->exception != Qnil) {
-            rb_exc_raise(bucket->exception);
+        exc = bucket->exception;
+        if (exc != Qnil) {
+            bucket->exception = Qnil;
+            rb_exc_raise(exc);
         }
         if (params.cmd.unlock.num > 1) {
             return rv;  /* return as a hash {key => true, ...} */

data/ext/couchbase_ext/utils.c

@@ -18,28 +18,80 @@
 #include "couchbase_ext.h"
 
     VALUE
-cb_gc_protect(struct bucket_st *bucket, VALUE val)
+cb_gc_protect(struct cb_bucket_st *bucket, VALUE val)
 {
     rb_hash_aset(bucket->object_space, val|1, val);
     return val;
 }
 
     VALUE
-cb_gc_unprotect(struct bucket_st *bucket, VALUE val)
+cb_gc_unprotect(struct cb_bucket_st *bucket, VALUE val)
 {
-    rb_funcall(bucket->object_space, id_delete, 1, val|1);
+    rb_funcall(bucket->object_space, cb_id_delete, 1, val|1);
     return val;
 }
 
+struct proc_params_st
+{
+    struct cb_bucket_st *bucket;
+    VALUE recv;
+    ID mid;
+    int argc;
+    VALUE *argv;
+    VALUE exc;
+};
+
+    static VALUE
+do_async_error_notify(VALUE ptr)
+{
+    struct proc_params_st *p = (struct proc_params_st *)ptr;
+    return rb_funcall(p->bucket->on_error_proc, cb_id_call, 1, p->exc);
+}
+
+    void
+cb_async_error_notify(struct cb_bucket_st *bucket, VALUE exc)
+{
+    if (bucket->on_error_proc != Qnil) {
+        struct proc_params_st params;
+        int fail;
+        params.bucket = bucket;
+        params.exc = exc;
+        rb_protect(do_async_error_notify, (VALUE)&params, &fail);
+        if (fail) {
+            rb_warning("Couchbase::Bucket#on_error shouldn't raise exceptions");
+        }
+    } else {
+        if (NIL_P(bucket->exception)) {
+            bucket->exception = exc;
+        }
+    }
+}
+
+    static VALUE
+func_call_failed(VALUE ptr, VALUE exc)
+{
+    struct proc_params_st *p = (struct proc_params_st *)ptr;
+    cb_async_error_notify(p->bucket, exc);
+    return Qnil;
+}
+
+    static VALUE
+do_func_call(VALUE ptr)
+{
+    struct proc_params_st *p = (struct proc_params_st *)ptr;
+    return rb_funcall2(p->recv, p->mid, p->argc, p->argv);
+}
+
     VALUE
-cb_proc_call(VALUE recv, int argc, ...)
+cb_proc_call(struct cb_bucket_st *bucket, VALUE recv, int argc, ...)
 {
     VALUE *argv;
     va_list ar;
     int arity;
     int ii;
+    struct proc_params_st params;
 
-    arity = FIX2INT(rb_funcall(recv, id_arity, 0));
+    arity = FIX2INT(rb_funcall(recv, cb_id_arity, 0));
     if (arity < 0) {
         arity = argc;
     }
@@ -57,13 +109,20 @@ cb_proc_call(VALUE recv, int argc, ...)
     } else {
         argv = NULL;
     }
-    return rb_funcall2(recv, id_call, arity, argv);
+    params.bucket = bucket;
+    params.recv = recv;
+    params.mid = cb_id_call;
+    params.argc = arity;
+    params.argv = argv;
+    return rb_rescue2(do_func_call, (VALUE)&params,
+            func_call_failed, (VALUE)&params,
+            rb_eException, (VALUE)0);
 }
 
 VALUE
 cb_hash_delete(VALUE hash, VALUE key)
 {
-    return rb_funcall(hash, id_delete, 1, key);
+    return rb_funcall(hash, cb_id_delete, 1, key);
 }
 
 /* Helper to convert return code from libcouchbase to meaningful exception.
@@ -77,83 +136,93 @@ cb_check_error_with_status(lcb_error_t rc, const char *msg, VALUE key,
     VALUE klass, exc, str;
     char buf[300];
 
-    if (rc == LCB_SUCCESS || rc == LCB_AUTH_CONTINUE) {
+    if ((rc == LCB_SUCCESS && (status == 0 || status / 100 == 2)) ||
+            rc == LCB_AUTH_CONTINUE) {
         return Qnil;
     }
     switch (rc) {
         case LCB_AUTH_ERROR:
-            klass = eAuthError;
+            klass = cb_eAuthError;
             break;
         case LCB_DELTA_BADVAL:
-            klass = eDeltaBadvalError;
+            klass = cb_eDeltaBadvalError;
             break;
         case LCB_E2BIG:
-            klass = eTooBigError;
+            klass = cb_eTooBigError;
             break;
         case LCB_EBUSY:
-            klass = eBusyError;
+            klass = cb_eBusyError;
             break;
         case LCB_EINTERNAL:
-            klass = eInternalError;
+            klass = cb_eInternalError;
             break;
         case LCB_EINVAL:
-            klass = eInvalidError;
+            klass = cb_eInvalidError;
             break;
         case LCB_ENOMEM:
-            klass = eNoMemoryError;
+            klass = cb_eNoMemoryError;
             break;
         case LCB_ERANGE:
-            klass = eRangeError;
+            klass = cb_eRangeError;
             break;
         case LCB_ETMPFAIL:
-            klass = eTmpFailError;
+            klass = cb_eTmpFailError;
             break;
         case LCB_KEY_EEXISTS:
-            klass = eKeyExistsError;
+            klass = cb_eKeyExistsError;
             break;
         case LCB_KEY_ENOENT:
-            klass = eNotFoundError;
+            klass = cb_eNotFoundError;
             break;
-        case LCB_LIBEVENT_ERROR:
-            klass = eLibeventError;
+        case LCB_DLOPEN_FAILED:
+            klass = cb_eDlopenFailedError;
+            break;
+        case LCB_DLSYM_FAILED:
+            klass = cb_eDlsymFailedError;
             break;
         case LCB_NETWORK_ERROR:
-            klass = eNetworkError;
+            klass = cb_eNetworkError;
             break;
         case LCB_NOT_MY_VBUCKET:
-            klass = eNotMyVbucketError;
+            klass = cb_eNotMyVbucketError;
             break;
         case LCB_NOT_STORED:
-            klass = eNotStoredError;
+            klass = cb_eNotStoredError;
             break;
         case LCB_NOT_SUPPORTED:
-            klass = eNotSupportedError;
+            klass = cb_eNotSupportedError;
             break;
         case LCB_UNKNOWN_COMMAND:
-            klass = eUnknownCommandError;
+            klass = cb_eUnknownCommandError;
             break;
         case LCB_UNKNOWN_HOST:
-            klass = eUnknownHostError;
+            klass = cb_eUnknownHostError;
             break;
         case LCB_PROTOCOL_ERROR:
-            klass = eProtocolError;
+            klass = cb_eProtocolError;
             break;
         case LCB_ETIMEDOUT:
-            klass = eTimeoutError;
+            klass = cb_eTimeoutError;
             break;
         case LCB_CONNECT_ERROR:
-            klass = eConnectError;
+            klass = cb_eConnectError;
             break;
         case LCB_BUCKET_ENOENT:
-            klass = eBucketNotFoundError;
+            klass = cb_eBucketNotFoundError;
             break;
         case LCB_CLIENT_ENOMEM:
-            klass = eClientNoMemoryError;
+            klass = cb_eClientNoMemoryError;
+            break;
+        case LCB_CLIENT_ETMPFAIL:
+            klass = cb_eClientTmpFailError;
+            break;
+        case LCB_EBADHANDLE:
+            klass = cb_eBadHandleError;
             break;
         case LCB_ERROR:
             /* fall through */
         default:
-            klass = eLibcouchbaseError;
+            klass = cb_eLibcouchbaseError;
     }
 
     str = rb_str_buf_new2(msg ? msg : "");
@@ -164,6 +233,7 @@ cb_check_error_with_status(lcb_error_t rc, const char *msg, VALUE key,
     }
     if (status > 0) {
         const char *reason = NULL;
+        klass = cb_eHTTPError;
         snprintf(buf, 300, "status=\"%d\"", status);
         rb_str_buf_cat2(str, buf);
         switch (status) {
@@ -261,11 +331,11 @@ cb_check_error_with_status(lcb_error_t rc, const char *msg, VALUE key,
     snprintf(buf, 300, "error=0x%02x)", rc);
     rb_str_buf_cat2(str, buf);
     exc = rb_exc_new3(klass, str);
-    rb_ivar_set(exc, id_iv_error, INT2FIX(rc));
-    rb_ivar_set(exc, id_iv_key, key);
-    rb_ivar_set(exc, id_iv_cas, Qnil);
-    rb_ivar_set(exc, id_iv_operation, Qnil);
-    rb_ivar_set(exc, id_iv_status, status ? INT2FIX(status) : Qnil);
+    rb_ivar_set(exc, cb_id_iv_error, INT2FIX(rc));
+    rb_ivar_set(exc, cb_id_iv_key, key);
+    rb_ivar_set(exc, cb_id_iv_cas, Qnil);
+    rb_ivar_set(exc, cb_id_iv_operation, Qnil);
+    rb_ivar_set(exc, cb_id_iv_status, status ? INT2FIX(status) : Qnil);
     return exc;
 }
 
@@ -277,35 +347,35 @@ cb_check_error(lcb_error_t rc, const char *msg, VALUE key)
 
 
     uint32_t
-flags_set_format(uint32_t flags, ID format)
+cb_flags_set_format(uint32_t flags, ID format)
 {
-    flags &= ~((uint32_t)FMT_MASK); /* clear format bits */
-
-    if (format == sym_document) {
-        return flags | FMT_DOCUMENT;
-    } else if (format == sym_marshal) {
-        return flags | FMT_MARSHAL;
-    } else if (format == sym_plain) {
-        return flags | FMT_PLAIN;
+    flags &= ~((uint32_t)CB_FMT_MASK); /* clear format bits */
+
+    if (format == cb_sym_document) {
+        return flags | CB_FMT_DOCUMENT;
+    } else if (format == cb_sym_marshal) {
+        return flags | CB_FMT_MARSHAL;
+    } else if (format == cb_sym_plain) {
+        return flags | CB_FMT_PLAIN;
     }
     return flags; /* document is the default */
 }
 
     ID
-flags_get_format(uint32_t flags)
+cb_flags_get_format(uint32_t flags)
 {
-    flags &= FMT_MASK; /* select format bits */
+    flags &= CB_FMT_MASK; /* select format bits */
 
     switch (flags) {
-        case FMT_DOCUMENT:
-            return sym_document;
-        case FMT_MARSHAL:
-            return sym_marshal;
-        case FMT_PLAIN:
+        case CB_FMT_DOCUMENT:
+            return cb_sym_document;
+        case CB_FMT_MARSHAL:
+            return cb_sym_marshal;
+        case CB_FMT_PLAIN:
             /* fall through */
         default:
             /* all other formats treated as plain */
-            return sym_plain;
+            return cb_sym_plain;
     }
 }
 
@@ -314,14 +384,14 @@ flags_get_format(uint32_t flags)
 do_encode(VALUE *args)
 {
     VALUE val = args[0];
-    uint32_t flags = ((uint32_t)args[1] & FMT_MASK);
+    uint32_t flags = ((uint32_t)args[1] & CB_FMT_MASK);
 
     switch (flags) {
-        case FMT_DOCUMENT:
-            return rb_funcall(mMultiJson, id_dump, 1, val);
-        case FMT_MARSHAL:
-            return rb_funcall(mMarshal, id_dump, 1, val);
-        case FMT_PLAIN:
+        case CB_FMT_DOCUMENT:
+            return rb_funcall(cb_mMultiJson, cb_id_dump, 1, val);
+        case CB_FMT_MARSHAL:
+            return rb_funcall(cb_mMarshal, cb_id_dump, 1, val);
+        case CB_FMT_PLAIN:
             /* fall through */
         default:
             /* all other formats treated as plain */
@@ -336,22 +406,22 @@ do_decode(VALUE *args)
     VALUE force_format = args[2];
 
     if (TYPE(force_format) == T_SYMBOL) {
-        if (force_format == sym_document) {
-            return rb_funcall(mMultiJson, id_load, 1, blob);
-        } else if (force_format == sym_marshal) {
-            return rb_funcall(mMarshal, id_load, 1, blob);
-        } else { /* sym_plain and any other symbol */
+        if (force_format == cb_sym_document) {
+            return rb_funcall(cb_mMultiJson, cb_id_load, 1, blob);
+        } else if (force_format == cb_sym_marshal) {
+            return rb_funcall(cb_mMarshal, cb_id_load, 1, blob);
+        } else { /* cb_sym_plain and any other cb_symbol */
             return blob;
         }
     } else {
-        uint32_t flags = ((uint32_t)args[1] & FMT_MASK);
+        uint32_t flags = ((uint32_t)args[1] & CB_FMT_MASK);
 
         switch (flags) {
-            case FMT_DOCUMENT:
-                return rb_funcall(mMultiJson, id_load, 1, blob);
-            case FMT_MARSHAL:
-                return rb_funcall(mMarshal, id_load, 1, blob);
-            case FMT_PLAIN:
+            case CB_FMT_DOCUMENT:
+                return rb_funcall(cb_mMultiJson, cb_id_load, 1, blob);
+            case CB_FMT_MARSHAL:
+                return rb_funcall(cb_mMarshal, cb_id_load, 1, blob);
+            case CB_FMT_PLAIN:
                 /* fall through */
             default:
                 /* all other formats treated as plain */
@@ -361,29 +431,25 @@ do_decode(VALUE *args)
 }
 
     static VALUE
-coding_failed(void)
+coding_failed(VALUE unused, VALUE exc)
 {
-    return Qundef;
+    (void)unused;
+    return exc;
 }
 
     VALUE
-encode_value(VALUE val, uint32_t flags)
+cb_encode_value(VALUE val, uint32_t flags)
 {
     VALUE blob, args[2];
 
     args[0] = val;
     args[1] = (VALUE)flags;
-    /* FIXME re-raise proper exception */
     blob = rb_rescue(do_encode, (VALUE)args, coding_failed, 0);
-    /* it must be bytestring after all */
-    if (TYPE(blob) != T_STRING) {
-        return Qundef;
-    }
-    return blob;
+    return blob; /* bytestring or exception object */
 }
 
     VALUE
-decode_value(VALUE blob, uint32_t flags, VALUE force_format)
+cb_decode_value(VALUE blob, uint32_t flags, VALUE force_format)
 {
     VALUE val, args[3];
 
@@ -395,23 +461,23 @@ decode_value(VALUE blob, uint32_t flags, VALUE force_format)
     args[1] = (VALUE)flags;
     args[2] = (VALUE)force_format;
     val = rb_rescue(do_decode, (VALUE)args, coding_failed, 0);
-    return val;
+    return val; /* the value or exception object */
 }
 
     void
-strip_key_prefix(struct bucket_st *bucket, VALUE key)
+cb_strip_key_prefix(struct cb_bucket_st *bucket, VALUE key)
 {
-    if (bucket->key_prefix) {
-        rb_str_update(key, 0, RSTRING_LEN(bucket->key_prefix_val), STR_NEW_CSTR(""));
+    if (RTEST(bucket->key_prefix_val)) {
+        rb_str_update(key, 0, RSTRING_LEN(bucket->key_prefix_val), cb_vStrEmpty);
     }
 }
 
     VALUE
-unify_key(struct bucket_st *bucket, VALUE key, int apply_prefix)
+cb_unify_key(struct cb_bucket_st *bucket, VALUE key, int apply_prefix)
 {
     VALUE ret = Qnil, tmp;
 
-    if (bucket->key_prefix && apply_prefix) {
+    if (RTEST(bucket->key_prefix_val) && apply_prefix) {
         ret = rb_str_dup(bucket->key_prefix_val);
     }
     switch (TYPE(key)) {
@@ -427,7 +493,7 @@ unify_key(struct bucket_st *bucket, VALUE key, int apply_prefix)
 }
 
     void
-cb_build_headers(struct context_st *ctx, const char * const *headers)
+cb_build_headers(struct cb_context_st *ctx, const char * const *headers)
 {
     if (!ctx->headers_built) {
         VALUE key = Qnil, val;
@@ -469,3 +535,14 @@ cb_first_value_i(VALUE key, VALUE value, VALUE arg)
     (void)key;
     return ST_STOP;
 }
+
+#ifndef HAVE_RB_HASH_LOOKUP2
+    VALUE
+rb_hash_lookup2(VALUE hash, VALUE key, VALUE dflt)
+{
+    if (RTEST(rb_funcall2(hash, cb_id_has_key_p, 1, &key))) {
+        dflt = rb_hash_aref(hash, key);
+    }
+    return dflt;
+}
+#endif