hx_cbor 2021.8.20

data/ext/cbor/buffer_class.h

@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+#ifndef MSGPACK_RUBY_BUFFER_CLASS_H__
+#define MSGPACK_RUBY_BUFFER_CLASS_H__
+
+#include "buffer.h"
+
+extern VALUE cMessagePack_Buffer;
+
+void MessagePack_Buffer_module_init(VALUE mMessagePack);
+
+VALUE MessagePack_Buffer_wrap(msgpack_buffer_t* b, VALUE owner);
+
+void MessagePack_Buffer_initialize(msgpack_buffer_t* b, VALUE io, VALUE options);
+
+#endif
+

data/ext/cbor/cbor.h

@@ -0,0 +1,69 @@
+#ifndef CBOR_RUBY_BUFFER_H__
+#define CBOR_RUBY_BUFFER_H__
+
+/* The 8 major types */
+#define MT_UNSIGNED 0
+#define MT_NEGATIVE 1
+#define MT_BYTES 2
+#define MT_TEXT 3
+#define MT_ARRAY 4
+#define MT_MAP 5
+#define MT_TAG 6
+#define MT_PRIM 7
+
+/* The initial bytes resulting from those */
+#define IB_UNSIGNED (MT_UNSIGNED << 5)
+#define IB_NEGATIVE (MT_NEGATIVE << 5)
+#define IB_BYTES (MT_BYTES << 5)
+#define IB_TEXT (MT_TEXT << 5)
+#define IB_ARRAY (MT_ARRAY << 5)
+#define IB_MAP (MT_MAP << 5)
+#define IB_TAG (MT_TAG << 5)
+#define IB_PRIM (MT_PRIM << 5)
+
+#define IB_NEGFLAG (IB_NEGATIVE - IB_UNSIGNED)
+#define IB_NEGFLAG_AS_BIT(ib) ((ib) >> 5)
+#define IB_TEXTFLAG (IB_TEXT - IB_BYTES)
+
+#define IB_AI(ib) ((ib) & 0x1F)
+#define IB_MT(ib) ((ib) >> 5)
+
+/* Tag numbers handled by this implementation */
+#define TAG_TIME_EPOCH 1
+#define TAG_BIGNUM 2
+#define TAG_BIGNUM_NEG 3
+#define TAG_URI 32
+#define TAG_RE 35
+
+/* Initial bytes of those tag numbers */
+#define IB_TIME_EPOCH (IB_TAG + TAG_TIME_EPOCH)
+#define IB_BIGNUM (IB_TAG + TAG_BIGNUM)
+#define IB_BIGNUM_NEG (IB_TAG + TAG_BIGNUM_NEG)
+/* TAG_URI and TAG_RE are non-immediate tags */
+
+/* Simple values handled by this implementation */
+#define VAL_NIL 22
+#define VAL_FALSE 20
+#define VAL_TRUE 21
+
+/* Initial bytes of those simple values */
+#define IB_NIL (IB_PRIM + VAL_NIL)
+#define IB_FALSE (IB_PRIM + VAL_FALSE)
+#define IB_TRUE (IB_PRIM + VAL_TRUE)
+
+/* AI values with more data in head */
+#define AI_1 24
+#define AI_2 25
+#define AI_4 26
+#define AI_8 27
+#define AI_INDEF 31
+#define IB_BREAK (IB_PRIM + AI_INDEF)
+/* For  */
+#define IB_UNUSED (IB_TAG + AI_INDEF)
+
+/* Floating point initial bytes */
+#define IB_FLOAT2 (IB_PRIM + AI_2)
+#define IB_FLOAT4 (IB_PRIM + AI_4)
+#define IB_FLOAT8 (IB_PRIM + AI_8)
+
+#endif

data/ext/cbor/compat.h

@@ -0,0 +1,147 @@
+/*
+ * 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.
+ */
+#ifndef MSGPACK_RUBY_COMPAT_H__
+#define MSGPACK_RUBY_COMPAT_H__
+
+#include "ruby.h"
+
+#if defined(HAVE_RUBY_ST_H)
+#  include "ruby/st.h"  /* ruby hash on Ruby 1.9 */
+#elif defined(HAVE_ST_H)
+#  include "st.h"       /* ruby hash on Ruby 1.8 */
+#endif
+
+
+/*
+ * COMPAT_HAVE_ENCODING
+ */
+#ifdef HAVE_RUBY_ENCODING_H
+#  include "ruby/encoding.h"
+#  define COMPAT_HAVE_ENCODING
+#endif
+
+#if defined(__MACRUBY__)  /* MacRuby */
+#  undef COMPAT_HAVE_ENCODING
+#endif
+
+
+/*
+ * define STR_DUP_LIKELY_DOES_COPY
+ * check rb_str_dup actually copies the string or not
+ */
+#if defined(RUBY_VM) && defined(FL_ALL) && defined(FL_USER1) && defined(FL_USER3)  /* MRI 1.9 */
+#  define STR_DUP_LIKELY_DOES_COPY(str) FL_ALL(str, FL_USER1|FL_USER3)  /* same as STR_ASSOC_P(str) */
+
+#elif defined(FL_TEST) && defined(ELTS_SHARED)  /* MRI 1.8 */
+#  define STR_DUP_LIKELY_DOES_COPY(str) (!FL_TEST(str, ELTS_SHARED))
+
+//#elif defined(RUBINIUS) || defined(JRUBY)  /* Rubinius and JRuby */
+#else
+#  define STR_DUP_LIKELY_DOES_COPY(str) (1)
+
+#endif
+
+
+/*
+ * SIZET2NUM
+ */
+#ifndef SIZET2NUM   /* MRI 1.8 */
+#  define SIZET2NUM(v) ULL2NUM(v)
+#endif
+
+
+/*
+ * rb_errinfo()
+ */
+#if defined(RUBY_VM)  /* MRI 1.9 */
+#  define COMPAT_RERAISE rb_exc_raise(rb_errinfo())
+
+#elif defined(JRUBY)  /* JRuby */
+#  define COMPAT_RERAISE rb_exc_raise(rb_gv_get("$!"))
+
+#else  /* MRI 1.8 and Rubinius */
+#  define COMPAT_RERAISE rb_exc_raise(ruby_errinfo)
+#endif
+
+
+/*
+ * RBIGNUM_POSITIVE_P
+ */
+#ifndef RBIGNUM_POSITIVE_P
+#  if defined(RUBINIUS)  /* Rubinius <= v1.2.3 */
+#    define RBIGNUM_POSITIVE_P(b) (rb_funcall(b, rb_intern(">="), 1, INT2FIX(0)) == Qtrue)
+
+#  elif defined(JRUBY)  /* JRuby */
+#    define RBIGNUM_POSITIVE_P(b) (rb_funcall(b, rb_intern(">="), 1, INT2FIX(0)) == Qtrue)
+#    define rb_big2ull(b) rb_num2ull(b)
+     /*#define rb_big2ll(b) rb_num2ll(b)*/
+
+#  else  /* MRI 1.8 */
+#    define RBIGNUM_POSITIVE_P(b) (RBIGNUM(b)->sign)
+#  endif
+#endif
+
+
+#ifndef HAVE_RB_INTEGER_UNPACK
+
+/* More MRI 1.8 */
+#ifndef RBIGNUM_LEN
+  #define RBIGNUM_LEN(b)        (RBIGNUM(b)->len)
+#endif
+#ifndef RBIGNUM_DIGITS
+  #ifndef RBIGNUM
+    #define CANT_DO_BIGNUMS_FAST_ON_THIS_PLATFORM
+  #endif
+  #define RBIGNUM_DIGITS(b)     (RBIGNUM(b)->digits)
+#endif
+#ifndef HAVE_RB_BIG_NEW
+/* not really worth fixing any more... */
+    #define CANT_DO_BIGNUMS_FAST_ON_THIS_PLATFORM
+/* gross 1.8.7 hack thanks to Mathieu Bouchard <matju@artengine.ca> */
+#define rb_big_new(len, sign) rb_funcall(INT2FIX(1),rb_intern("<<"),1,INT2FIX(len > 0 ? ((len) * SIZEOF_BDIGITS * 8) - 1 : 0));
+#endif
+
+#endif
+
+#ifndef RB_TYPE_P
+  #define RB_TYPE_P(obj, type) (TYPE(obj) == (type))
+#endif
+
+/*
+ * RSTRING_PTR, RSTRING_LEN
+ */
+#ifndef RSTRING_PTR  /* MRI 1.8.5 */
+#  define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+#ifndef RSTRING_LEN  /* MRI 1.8.5 */
+#  define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+
+#endif
+

data/ext/cbor/core_ext.c

@@ -0,0 +1,201 @@
+/*
+ * 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 "core_ext.h"
+#include "packer.h"
+#include "packer_class.h"
+
+static inline VALUE delegete_to_pack(int argc, VALUE* argv, VALUE self)
+{
+    if(argc == 0) {
+        return MessagePack_pack(1, &self);
+    } else if(argc == 1) {
+        /* write to io */
+        VALUE argv2[2];
+        argv2[0] = self;
+        argv2[1] = argv[0];
+        return MessagePack_pack(2, argv2);
+    } else {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
+    }
+}
+
+#define ENSURE_PACKER(argc, argv, packer, pk) \
+    if(argc != 1 || rb_class_of(argv[0]) != cMessagePack_Packer) { \
+        return delegete_to_pack(argc, argv, self); \
+    } \
+    VALUE packer = argv[0]; \
+    msgpack_packer_t *pk; \
+    Data_Get_Struct(packer, msgpack_packer_t, pk);
+
+static VALUE NilClass_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_nil(pk);
+    return packer;
+}
+
+static VALUE TrueClass_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_true(pk);
+    return packer;
+}
+
+static VALUE FalseClass_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_false(pk);
+    return packer;
+}
+
+#ifdef RUBY_INTEGER_UNIFICATION
+
+static VALUE Integer_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+  ENSURE_PACKER(argc, argv, packer, pk);
+  if (FIXNUM_P(self))
+    msgpack_packer_write_fixnum_value(pk, self);
+  else
+    msgpack_packer_write_bignum_value(pk, self);
+  return packer;
+}
+
+#else
+
+static VALUE Fixnum_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_fixnum_value(pk, self);
+    return packer;
+}
+
+static VALUE Bignum_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_bignum_value(pk, self);
+    return packer;
+}
+
+#endif
+
+static VALUE Float_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_float_value(pk, self);
+    return packer;
+}
+
+static VALUE String_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_string_value(pk, self);
+    return packer;
+}
+
+static VALUE Array_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_array_value(pk, self);
+    return packer;
+}
+
+static VALUE Hash_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_hash_value(pk, self);
+    return packer;
+}
+
+static VALUE Symbol_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_symbol_value(pk, self);
+    return packer;
+}
+
+static VALUE Simple_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_simple_value(pk, self);
+    return packer;
+}
+
+static VALUE Tagged_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_tagged_value(pk, self);
+    return packer;
+}
+
+static VALUE Regexp_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_processed_value(pk, self, rb_intern("source"), TAG_RE);
+    return packer;
+}
+
+static VALUE URI_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_processed_value(pk, self, rb_intern("to_s"), TAG_URI);
+    return packer;
+}
+
+static VALUE Time_to_msgpack(int argc, VALUE* argv, VALUE self)
+{
+    ENSURE_PACKER(argc, argv, packer, pk);
+    msgpack_packer_write_processed_value(pk, self, rb_intern("to_i"), TAG_TIME_EPOCH);
+    return packer;
+}
+
+void MessagePack_core_ext_module_init()
+{
+    rb_define_method(rb_cNilClass,   "to_cbor", NilClass_to_msgpack, -1);
+    rb_define_method(rb_cTrueClass,  "to_cbor", TrueClass_to_msgpack, -1);
+    rb_define_method(rb_cFalseClass, "to_cbor", FalseClass_to_msgpack, -1);
+#ifdef RUBY_INTEGER_UNIFICATION
+    rb_define_method(rb_cInteger, "to_cbor", Integer_to_msgpack, -1);
+#else
+    rb_define_method(rb_cFixnum, "to_cbor", Fixnum_to_msgpack, -1);
+    rb_define_method(rb_cBignum, "to_cbor", Bignum_to_msgpack, -1);
+#endif
+    rb_define_method(rb_cFloat,  "to_cbor", Float_to_msgpack, -1);
+    rb_define_method(rb_cString, "to_cbor", String_to_msgpack, -1);
+    rb_define_method(rb_cArray,  "to_cbor", Array_to_msgpack, -1);
+    rb_define_method(rb_cHash,   "to_cbor", Hash_to_msgpack, -1);
+    rb_define_method(rb_cSymbol, "to_cbor", Symbol_to_msgpack, -1);
+    rb_define_method(rb_cTime,   "to_cbor", Time_to_msgpack, -1);
+    rb_define_method(rb_cRegexp,   "to_cbor", Regexp_to_msgpack, -1);
+    if (rb_const_defined(rb_cObject, rb_intern("URI"))) {
+      rb_define_method(rb_const_get(rb_cObject, rb_intern("URI")),
+                       "to_cbor", URI_to_msgpack, -1);
+    }
+    rb_define_method(rb_cCBOR_Simple,   "to_cbor", Simple_to_msgpack, -1);
+    rb_define_method(rb_cCBOR_Tagged,   "to_cbor", Tagged_to_msgpack, -1);
+}
+