encode and decode classes

Author: Asmod4n

mrbgem.rake

@@ -10,6 +10,7 @@ MRuby::Gem::Specification.new('mruby-cbor') do |spec|
   spec.add_dependency 'mruby-time'
   spec.add_dependency 'mruby-string-is-utf8'
   spec.add_dependency 'mruby-native-ext-type', github: 'Asmod4n/mruby-native-ext-type', branch: 'main'
+  spec.add_dependency 'mruby-str-constantize', github: 'Asmod4n/mruby-str-constantize', branch: 'main'
   spec.add_test_dependency 'mruby-bigint'
   spec.add_test_dependency 'mruby-random'
   spec.add_test_dependency 'mruby-io'

src/mrb_cbor.c

@@ -14,6 +14,7 @@ MRB_END_DECL
 #include <mruby/variable.h>
 #include <mruby/error.h>
 #include <mruby/ned.h>
+#include <mruby/str_constantize.h>
 
 #include <stdlib.h>
 #include <stdint.h>
@@ -33,6 +34,8 @@ MRB_END_DECL
   #endif
 #endif
 
+#define CBOR_TAG_CLASS UINT32_C(49999)
+
 typedef struct {
   const uint8_t* base;
   const uint8_t* p;
@@ -627,6 +630,16 @@ decode_symbol(mrb_state *mrb, Reader* r, mrb_value src, mrb_value sharedrefs)
   return mrb_nil_value();
 }
 
+static mrb_value
+decode_class(mrb_state *mrb, Reader *r, mrb_value src, mrb_value sharedrefs)
+{
+  mrb_value v = decode_value(mrb, r, src, sharedrefs);
+  if (likely(mrb_string_p(v)))
+    return mrb_str_constantize(mrb, v);
+  mrb_raise(mrb, E_TYPE_ERROR, "invalid payload for tag 49999 (expected text string)");
+  return mrb_undef_value();
+}
+
 // ============================================================================
 // Master decode with depth protection
 // ============================================================================
@@ -673,6 +686,10 @@ decode_value(mrb_state* mrb, Reader* r, mrb_value src, mrb_value sharedrefs)
         result = decode_symbol(mrb, r, src, sharedrefs);
         goto done;
       }
+      if (mrb_integer_p(tag) && (uint64_t)mrb_integer(tag) == CBOR_TAG_CLASS) {
+        result = decode_class(mrb, r, src, sharedrefs);
+        goto done;
+      }
 
       {
         mrb_value reg   = cbor_tag_registry(mrb);
@@ -999,6 +1016,20 @@ encode_string(CborWriter* w, mrb_value str)
   cbor_writer_write(w, (const uint8_t*)p, (size_t)blen);
 }
 
+static void
+encode_class(CborWriter *w, mrb_value obj)
+{
+  mrb_state *mrb = w->mrb;
+  mrb_value name = mrb_class_path(mrb, mrb_class_ptr(obj));
+
+  if (likely(mrb_string_p(name))) {
+    encode_len(w, 6, CBOR_TAG_CLASS);
+    encode_string(w, name);
+  } else {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "cannot encode anonymous class/module");
+  }
+}
+
 static void
 encode_simple(CborWriter* w, mrb_value obj)
 {
@@ -1088,6 +1119,8 @@ encode_value(CborWriter* w, mrb_value obj)
 #ifdef MRB_USE_BIGINT
     case MRB_TT_BIGINT:  encode_bignum(w, obj); break;
 #endif
+    case MRB_TT_CLASS:
+    case MRB_TT_MODULE:  encode_class(w, obj); break;
     default: {
       mrb_value rev     = cbor_tag_rev_registry(mrb);
       mrb_value klass   = mrb_obj_value(mrb_class(mrb, obj));
@@ -1822,6 +1855,8 @@ cbor_register_tag_impl(mrb_state *mrb, mrb_value tag_v, mrb_value klass)
       mrb_raisef(mrb, E_ARGUMENT_ERROR,
         "tag %v is reserved for internal CBOR use", tag_v);
   }
+  if (unlikely(mrb_integer_p(tag_v) && (uint64_t)mrb_integer(tag_v) == CBOR_TAG_CLASS))
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "tag 49999 is reserved for internal CBOR use");
 
   {
     struct RClass *kp = mrb_class_ptr(klass);