wruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e868c3c2d079107e665b0de7bb170c4ba9c68b69b505364eabc5435060083c20
+  data.tar.gz: 192c37b854e25974f1da3dd3ed451827982eb9ef4f87789d3b96673859ca70b8
+SHA512:
+  metadata.gz: 4c9c383325bea8bbb76fb4b9c08dc02c4da95cf60ef3b90e24cacd5663ac0d2a304dbeaa02bf10f74bf0429f6bae543aae3d66de649e8ce79fca0afde55544a1
+  data.tar.gz: 4f712a63f78ecb3bd88adaf8bc32804ba92b8382c8fac90a52b37898b406af68c248e678cd9d4e1605e1516583a3a25ae618e201c732f91b30fa723759a28bb5

data/lib/wruby/format_error.rb

@@ -0,0 +1,5 @@
+module WRuby
+    class FormatError < StandardError
+        
+    end
+end

data/lib/wruby/metadata.rb

@@ -0,0 +1,154 @@
+require "wruby/format_error"
+module WRuby
+    class MetaData
+        class UnrecognizedTypeError < StandardError
+            def initialize(name)
+                super("Unrecognized type: #{name}")
+            end
+        end
+
+
+        def self.parse(data)
+            me = self.new
+            data["includes"].each {|f| add_header(f)}
+            data["typedefs"].each do |name, wrappings|
+                aliased = wrappings.key?("alias")
+                wrapped = wrappings.key?("wrap")
+                unwrapped = wrappings.key?("unwrap")
+                unless aliased || wrapped || unwrapped 
+                    raise FormatError, "Type with no deifnition: #{name}"
+                end
+                if aliased && (wrapped || unwrapped)
+                    raise FormatError, "Ambiguous type definition: #{name}"
+                end
+                if wrapped ^ unwrapped
+                    raise FormatError, "Incomplete type definition: #{name}"
+                end
+
+                if aliased
+                    register_alias(name, wrappings["alias"])
+                elsif wrapped || unwrapped
+                    register_wrapping(name, wrappings["wrap"], wrappings["unwrap"])
+                end
+            end
+            data["wrapped_classes"].each {|name| register_class(name)}
+        end
+
+        def initialize
+            @headers = []
+            @types = {}
+            @aliases = {}
+            @aliases.default_proc = proc {|h, k| k}
+
+            @classes = {}
+        end
+
+        attr_reader :headers, :classes
+
+        def add_header(file_name)
+            @headers << file_name unless @headers.include?(file_name)
+        end
+        
+        def register_class(class_name)
+            return unless @classes.key?(class_name)
+            @classes[class_name] << Class.new do
+                def alloc 
+                    "#{class_name}_alloc"
+                end
+                def ctype
+                    "#{class_name}_type"
+                end
+            end
+        end
+
+        def register_alias(alias_name, type)
+            @aliases[alias_name.to_s] = type.to_s
+        end
+
+        def register_wrapping(type, wrapping, unwrapping)
+            @types[type.to_s] = {wrap: wrapping, unwrap: unwrapping}
+        end
+
+        def wrap(code, type)
+            raise UnrecognizedTypeError.new(type) unless @types.key?(type) || @aliases.key?(type)
+            resolved_type = @aliases[type.to_s]
+            @types[resolved_type.to_s][:wrap].gsub(/\bthis\b/, code)
+        end
+
+        def unwrap(code, type)
+            raise UnrecognizedTypeError.new(type) unless @types.key?(type) || @aliases.key?(type)
+            resolved_type = @aliases[type.to_s]
+            @types[resolved_type.to_s][:unwrap].gsub(/\bthis\b/, code)
+        end
+
+        def alias_valid?(type)
+            @aliases.key?(type) && @types.key?(@aliases[type])
+        end
+
+        def has_type?(type)
+            @types.key?(type) || alias_valid?(type)
+        end
+
+        def each_class(&block)
+            return to_enum(__method__) unless block_given?
+            @wrapped_classes.each(&block)
+        end
+
+        private
+        def self.register_default_wrappings
+            # Basic integer types
+            register_wrapping("char", "INT2NUM(this)", "NUM2CHR(this)")
+            register_wrapping("short", "INT2NUM(this)", "NUM2SHORT(this)")
+            register_wrapping("int", "INT2NUM(this)", "NUM2INT(this)")
+            register_wrapping("long", "LONG2NUM(this)", "NUM2LONG(this)")
+            register_wrapping("long long", "LL2NUM(this)", "NUM2LL(this)")
+            # Basic unsigned integer types
+            register_wrapping("unsigned char", "UINT2NUM(this)", "NUM2UCHR(this)")
+            register_wrapping("unsigned short", "UINT2NUM(this)", "NUM2USHORT(this)")
+            register_wrapping("unsigned int", "UINT2NUM(this)", "NUM2UINT(this)")
+            register_wrapping("unsigned long", "ULONG2NUM(this)", "NUM2ULONG(this)")
+            register_wrapping("unsigned long long", "ULL2NUM(this)", "NUM2ULL(this)")
+            # unsigned abbreviations
+            register_alias("uchar", "unsigned char")
+            register_alias("ushort", "unsigned short")
+            register_alias("uint", "unsigned int") 
+            register_alias("ulong", "unsigned long") 
+            register_alias("long ulong", "unsigned long long") # This one is weird, but it makes more sense than ulong long
+
+            # Fixed integer types
+            register_wrapping("int8_t", "INT2NUM(this)", "(int8_t)NUM2CHR(this)")
+            register_wrapping("int16_t", "INT2NUM(this)", "(int16_t)NUM2SHORT(this)")
+            register_wrapping("int32_t", "INT2NUM(this)", "(int32_t)NUM2INT(this)")
+            register_wrapping("int64_t", "LONG2NUM(this)", "(int64_t)NUM2LONG(this)")
+            register_wrapping("uint8_t", "UINT2NUM(this)", "(int8_t)NUM2UINT(this)")
+            register_wrapping("uint16_t", "UINT2NUM(this)", "(int16_t)NUM2UINT(this)")
+            register_wrapping("uint32_t", "UINT2NUM(this)", "(int32_t)NUM2UINT(this)")
+            register_wrapping("uint64_t", "ULONG2NUM(this)", "(int64_t)NUM2ULONG(this)")
+            register_alias("int8", "int8_t")
+            register_alias("int16", "int16_t")
+            register_alias("int32", "int32_t")
+            register_alias("int64", "int64_t")
+            register_alias("uint8", "uint8_t")
+            register_alias("uint16", "uint16_t")
+            register_alias("uint32", "uint32_t")
+            register_alias("uint64", "uint64_t")
+
+            # Floating-point types
+            register_wrapping("float", "DBL2NUM(this)", "(float)NUM2DBL(this)")
+            register_wrapping("double", "DBL2NUM(this)", "NUM2DBL(this)")
+            # Fixed-size floating-point aliases
+            register_alias("float32", "float")
+            register_alias("float64", "double")
+
+            # Boolean type
+            register_wrapping("bool", "(this ? QTrue : QFalse)", "RTEST(this)")
+
+            # String types
+            # C-style strings
+            register_wrapping("char*", "rb_str_new_cstr(this)", "StringValueCStr(this)")
+            register_alias("cstring", "char*")
+            register_alias("cstr", "char*")
+            # Non-C-style strings are not handled here, as it's more complex than a simple inline
+        end
+    end
+end

data/lib/wruby/util/hash.rb

@@ -0,0 +1,11 @@
+require "wruby/format_error"
+module WRuby::Util
+    module RequireHash
+        def require(key, failure_message = "")
+            raise WRuby::FormatError, failure_message unless self.key?(key)
+            self[key]
+        end
+    end
+end
+
+Hash.prepend(WRuby::Util::RequireHash)

data/lib/wruby/util/normalize.rb

@@ -0,0 +1,9 @@
+module WRuby
+    def self.rubify_name(name)
+        case name 
+        when /\?/ then "is_#{name[...(name.size - 1)]}"
+        when /!/ then name[...(name.size - 1)]
+        else name
+        end
+    end
+end

data/lib/wruby/util/type_wrap.rb

@@ -0,0 +1,94 @@
+module WRuby
+    @@types = {}
+    @@aliases = {}
+    @@aliases.default_proc = proc {|h, k| k}
+
+    class UnrecognizedTypeError < StandardError
+        def initialize(name)
+            super("Unrecognized type: #{name}")
+        end
+    end
+
+    def self.register_alias(alias_name, type)
+        @@aliases[alias_name.to_s] = type.to_s
+    end
+
+    def self.register_wrapping(type, wrapping, unwrapping)
+        @@types[type.to_s] = {wrap: wrapping, unwrap: unwrapping}
+    end
+
+    def self.wrap(code, type)
+        raise UnrecognizedTypeError.new(type) unless @@types.key?(type) || @@aliases.key?(type)
+        resolved_type = @@aliases[type.to_s]
+        @@types[resolved_type.to_s][:wrap].gsub(/\bthis\b/, code)
+    end
+
+    def self.unwrap(code, type)
+        raise UnrecognizedTypeError.new(type) unless @@types.key?(type) || @@aliases.key?(type)
+        resolved_type = @@aliases[type.to_s]
+        @@types[resolved_type.to_s][:unwrap].gsub(/\bthis\b/, code)
+    end
+
+    def self.allocator_for(name)
+        "#{name}_alloc"
+    end
+
+    def self.native_name_for(name)
+        "#{name}_type"
+    end
+
+    # Basic integer types
+    register_wrapping("char", "INT2NUM(this)", "NUM2CHR(this)")
+    register_wrapping("short", "INT2NUM(this)", "NUM2SHORT(this)")
+    register_wrapping("int", "INT2NUM(this)", "NUM2INT(this)")
+    register_wrapping("long", "LONG2NUM(this)", "NUM2LONG(this)")
+    register_wrapping("long long", "LL2NUM(this)", "NUM2LL(this)")
+    # Basic unsigned integer types
+    register_wrapping("unsigned char", "UINT2NUM(this)", "NUM2UCHR(this)")
+    register_wrapping("unsigned short", "UINT2NUM(this)", "NUM2USHORT(this)")
+    register_wrapping("unsigned int", "UINT2NUM(this)", "NUM2UINT(this)")
+    register_wrapping("unsigned long", "ULONG2NUM(this)", "NUM2ULONG(this)")
+    register_wrapping("unsigned long long", "ULL2NUM(this)", "NUM2ULL(this)")
+    # unsigned abbreviations
+    register_alias("uchar", "unsigned char")
+    register_alias("ushort", "unsigned short")
+    register_alias("uint", "unsigned int") 
+    register_alias("ulong", "unsigned long") 
+    register_alias("long ulong", "unsigned long long") # This one is weird, but it makes more sense than ulong long
+
+    # Fixed integer types
+    register_wrapping("int8_t", "INT2NUM(this)", "(int8_t)NUM2CHR(this)")
+    register_wrapping("int16_t", "INT2NUM(this)", "(int16_t)NUM2SHORT(this)")
+    register_wrapping("int32_t", "INT2NUM(this)", "(int32_t)NUM2INT(this)")
+    register_wrapping("int64_t", "LONG2NUM(this)", "(int64_t)NUM2LONG(this)")
+    register_wrapping("uint8_t", "UINT2NUM(this)", "(int8_t)NUM2UINT(this)")
+    register_wrapping("uint16_t", "UINT2NUM(this)", "(int16_t)NUM2UINT(this)")
+    register_wrapping("uint32_t", "UINT2NUM(this)", "(int32_t)NUM2UINT(this)")
+    register_wrapping("uint64_t", "ULONG2NUM(this)", "(int64_t)NUM2ULONG(this)")
+    register_alias("int8", "int8_t")
+    register_alias("int16", "int16_t")
+    register_alias("int32", "int32_t")
+    register_alias("int64", "int64_t")
+    register_alias("uint8", "uint8_t")
+    register_alias("uint16", "uint16_t")
+    register_alias("uint32", "uint32_t")
+    register_alias("uint64", "uint64_t")
+
+    # Floating-point types
+    register_wrapping("float", "DBL2NUM(this)", "(float)NUM2DBL(this)")
+    register_wrapping("double", "DBL2NUM(this)", "NUM2DBL(this)")
+    # Fixed-size floating-point aliases
+    register_alias("float32", "float")
+    register_alias("float64", "double")
+
+    # Boolean type
+    register_wrapping("bool", "(this ? QTrue : QFalse)", "RTEST(this)")
+
+    # String types
+    # C-style strings
+    register_wrapping("char*", "rb_str_new_cstr(this)", "StringValueCStr(this)")
+    register_alias("cstring", "char*")
+    register_alias("cstr", "char*")
+    # Non-C-style strings are not handled here, as it's more complex than a simple inline
+
+end

data/lib/wruby.old/lib/method_definition.rb

@@ -0,0 +1,118 @@
+require "wruby/util/hash"
+require "wruby/parameter_definition"
+require "wruby/return_definition"
+require "wruby/util/normalize"
+module WRuby
+    class MethodDefinition
+
+        attr_reader :name, :parameters, :return, :method_type, :wrapper, :wrapped_function, :definition, :alias
+
+        def initialize(data)
+            @name = data.require("name", "Method definition missing name")
+            @parameters = data.require("parameters", "Method \'#{data["name"]}' missing 'parameters' field")
+            @parameters.map!{|e| ParameterDefinition.new(e)} unless @parameters.nil?
+            @return = data.require("return", "Method \'#{data["name"]}' missing 'return' field")
+            @return = ReturnDefinition.new(@return) unless @return.nil?
+            @method_type = data.require("method_type", "Method \'#{data["name"]}' missing 'method_type' field")
+            raise FormatError, "method_type '#{@method_type}' unsupported" unless ["constructor", "method", "module", "singleton"].include?(@method_type)
+            @wrapper = data.key? "wrapped_function"
+            if @wrapper
+                @wrapped_function = data.require("wrapped_function", "Method \'#{data["name"]}' missing wrapped_function")
+            else
+                @definition = data.require("definition", "Method \'#{data["name"]}' missing definition")
+            end
+            @alias = data["alias"]
+        end
+
+        def param_count(include_out = false)
+            return -1 if optional_params?
+            @parameters.filter{|p| include_out || !p.out?}.count
+        end
+
+        def optional_params?
+            @parameters.any?{|p| p.optional?}
+        end
+
+        def out_params
+            @parameters.filter{|p| p.out?}
+        end
+
+        def aliased?
+            !@alias.nil?
+        end
+
+        def qualified_name(klass_name)
+            "#{klass_name}#{(module? || singleton?) ? "_m" : ""}_#{WRuby::normalize_ruby_name(name)}"
+        end
+
+        def render(klass_spec)
+            "#{render_signature(klass_spec.qualified_name)} + {#{render_body(klass_spec)}}"
+        end
+
+        def render_signature(klass_name)
+            param_list = @parameters.filter{|p| !p.out?}.map do |param|
+                "VALUE #{param.name}"
+            end.join(", ")
+            "VALUE #{qualified_name(klass_name)}(VALUE self#{", #{param_list}" unless param_list.empty?})"
+        end
+
+        def render_body(klass_spec)
+            if method?
+                render_method
+            elsif module?
+                render_module_function
+            elsif singleton?
+                render_singleton_function
+            elsif constructor?
+                render_constructor
+            end
+        end
+
+        def singleton?
+            @method_type == "singleton"
+        end
+
+        def module?
+            @method_type == "module"
+        end
+
+        def method?
+            @method_type == "method"
+        end
+
+        def constructor?
+            @method_type == "constructor"
+        end
+            
+
+        private
+        def render_method(klass_spec)
+            ""
+        end
+
+        def render_module_function(klass_spec)
+            ""
+        end
+
+        def render_singleton_function(klass_spec)
+            ""
+        end
+
+        def render_constructor(klass_spec)
+            ""
+        end
+
+        def declare_out_variables
+            out_params.map do |p|
+                "#{p.type} #{p.name};\n"
+            end
+        end
+
+        def get_self(klass_spec)
+<<-SELF
+#{klass_spec.underlying_type}* that;
+TypedData_Get_Struct(self, #{klass_spec.underlying_type}, &#{klass_spec.type_name}, that);
+SELF
+        end
+    end
+end

data/lib/wruby.old/lib/module_definition.rb

@@ -0,0 +1,46 @@
+require "wruby/util/hash"
+require "wruby/method_definition"
+module WRuby
+    class ModuleDefinition
+        attr_reader :name
+        def initialize(data) 
+            @name = data.require("name", "Module definition requires a name")
+            @methods = data["methods"]
+            @methods&.map!{|e| MethodDefinition.new(e)}
+            @free_method = data["free"]
+        end
+
+        def render_methods
+            @methods.map do |m|
+                m.render_signature(qualified_name)
+            end.join("\n\n")
+        end
+
+        def qualified_name
+            return "m#{@name}"
+        end
+
+        def render_definitions(module_name)
+            module_def = "VALUE #{qualified_name} = rb_define_module"
+            module_def += module_name.nil? ? "(" : "_under(#{module_name}, "
+            module_def += "\"#{@name}\");\n"
+
+            definitions = @methods.map do |m|
+                rb_method = case m.method_type 
+                when "singleton"
+                    "rb_define_singleton_method"
+                else
+                    "rb_define_method"
+                end
+                rb_method += "(#{qualified_name}, \"#{m.name}\", #{m.qualified_name(qualified_name)}, #{m.param_count});"
+                if m.aliased? && m.method_type != "singleton"
+                    rb_method += "\nrb_define_alias(#{qualified_name}, \"#{m.alias}\", \"#{m.name}\""
+                end
+
+                rb_method;
+            end.join("\n")
+
+            module_def + definitions
+        end
+    end
+end

data/lib/wruby.old/lib/parameter_definition.rb

@@ -0,0 +1,23 @@
+require "wruby/util/hash"
+module WRuby
+    class ParameterDefinition
+        attr_accessor :name, :type, :default
+
+        def initialize(data) 
+            @name = data.require("name", "Parameter definition missing name")
+            raise FormatError, "Parameter cannot be named 'self'" if @name == "self"
+            @type = data.require("type", "Parameter #{@name} missing its type")
+            @default = data["default"]
+            @optional = data["optional"] || !!@default
+            @out_param = !!data["out"]
+        end
+
+        def out?
+            @out_param
+        end
+
+        def optional?
+            @optional
+        end
+    end
+end

data/lib/wruby.old/lib/return_definition.rb

@@ -0,0 +1,14 @@
+require "wruby/util/hash"
+module WRuby
+    class ReturnDefinition
+        attr_accessor :type, :base_type
+
+        def initialize(data)
+            @type = data
+        end
+        
+        def uses_typedef?
+            instance_variable_defined?("@base_type")
+        end
+    end
+end

data/lib/wruby.old/lib/structure_definition.rb

@@ -0,0 +1,110 @@
+require "wruby/util/hash"
+require "wruby/method_definition"
+module WRuby
+    class StructureDefinition
+        attr_reader :name
+        def initialize(data) 
+            @type = data.require("type", "Structure definition requires a type (module or class)")
+            @name = data.require("name", "Structure definition requires a name")
+            @methods = data["methods"]
+            @methods.map!{|e| MethodDefinition.new(e)} unless @methods.nil?
+            @parent = data["parent"]
+            @underlying_type = data.require("basetype", "Class requires an underlying type") if @type == "class" 
+            @free_function = data["free"]
+            raise FormatError, "Modules do not require freeing" if @free_method && @type == "module"
+        end
+
+        def render_methods
+            @methods.map do |m|
+                m.render(self)
+            end.join("\n\n")
+        end
+        
+        def qualified_name
+            case @type
+            when "class" then "c#{name}"
+            when "module" then "m#{name}"
+            end 
+        end
+
+        def camel_case(_name = @name)
+            _name.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+            gsub(/([a-z\d])([A-Z])/,'\1_\2').
+            downcase
+        end
+        
+        def render_definitions(module_name)
+            
+            module_def = "VALUE #{qualified_name} = rb_define_#{@type}"
+            module_def += module_name.nil? ? "(" : "_under(#{module_name}, "
+            module_def += "\"#{@name}\""
+            module_def += case @type
+            when "class" then ", #{@parent || "rb_cObject"}"
+            when "module" then ""
+            end + ");\n"
+
+            definitions = @methods.map do |m|
+                rb_method = case m.method_type 
+                when "singleton"
+                    "rb_define_singleton_method"
+                when "method", "constructor"
+                    "rb_define_method"
+                when "module"
+                    "rb_define_module_function"
+                end
+                rb_method += "(#{qualified_name}, \"#{m.name}\", #{m.qualified_name(qualified_name)}, #{m.param_count});"
+                if m.aliased? && !m.singleton?
+                    rb_method += "\nrb_define_alias(#{qualified_name}, \"#{m.alias}\", \"#{m.name}\");"
+                end
+
+                rb_method;
+            end.join("\n")
+
+            module_def + definitions
+        end
+
+        def render_free
+            free_func = "void #{camel_case}_free(void* data) {\n"
+            free_func +="    #{@underlying_type}* self = (#{@underlying_type}*)data;\n"
+            if @free_function
+                free_func += if @free_function.start_with?(".")
+                    "    self->~#{@underlying_type}();\n"
+                else
+                    "    #{@free_function}(self);\n"
+                end
+            end
+            free_func += "    free(self);\n}\n"
+                
+        end
+
+        def render_size
+<<-SIZE
+size_t #{camel_case}_size(const void*) {
+    return sizeof(#{@underlying_type});
+}
+SIZE
+        end
+
+        def type_name
+            "#{camel_case}_type"
+        end
+
+        def render_type(namespace = "")
+<<-DEF
+const rb_data_type_t #{type_name}} = {
+    .wrap_struct_name = "#{namespace}_#{@name}",
+    .function = {
+        .dmark = NULL,
+        .dfree = #{camel_case}_free,
+        .dsize = #{camel_case}_size,
+    },
+    .parent = #{@parent ? "&#{camel_case(@parent)}_type" : "NULL"},
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+DEF
+        end
+
+        
+    end
+end

data/lib/wruby.old/lib/util/hash.rb

@@ -0,0 +1,11 @@
+require "wruby/format_error"
+module WRuby::Util
+    module RequireHash
+        def require(key, failure_message = "")
+            raise WRuby::FormatError, failure_message unless self.key?(key)
+            self[key]
+        end
+    end
+end
+
+Hash.prepend(WRuby::Util::RequireHash)

data/lib/wruby.old/lib/util/normalize.rb

@@ -0,0 +1,9 @@
+module WRuby
+    def self.rubify_name(name)
+        case name 
+        when /\?/ then "is_#{name[...(name.size - 1)]}"
+        when /!/ then name[...(name.size - 1)]
+        else name
+        end
+    end
+end

data/lib/wruby.old/lib/util/type_matchup.rb

@@ -0,0 +1,13 @@
+module WRuby
+    def self.generalize_type(type_name)
+        case type_name
+        when /u.*64/ then "ulong"
+        when /64/ then "long"
+        when /^uint/ then "uint"
+        when /^int/  then "int"
+        when /char\*/ then "string"
+        when "float" then "double"
+        else type_name
+        end
+    end
+end

data/lib/wruby.old/lib/util/type_wrap.rb

@@ -0,0 +1,77 @@
+module WRuby
+    @@types = {}
+    @@aliases = {}
+    @@aliases.default_proc = proc {|h, k| k}
+
+    class UnrecognizedTypeError < StandardError
+        def initialize(name)
+            super("Unrecognized type: #{name}")
+        end
+    end
+
+    def self.register_alias(alias_name, type)
+        @@aliases[alias_name.to_s] = type.to_s
+    end
+
+    def self.register_wrapping(type, wrapping, unwrapping)
+        @@types[type.to_s] = {wrap: wrapping, unwrap: unwrapping}
+    end
+
+    def self.wrap(name, type)
+        raise UnrecognizedTypeError.new(type) unless @@types.key?(type) || @@aliases.key?(type)
+        @@types[type.to_s][:wrap].gsub(/\wthis\w/, name)
+    end
+
+    def self.unwrap(name, type)
+        raise UnrecognizedTypeError.new(type) unless @@types.key?(type) || @@aliases.key?(type)
+        resolved_name = @@aliases[type.to_s]
+        @@types[resolved_name.to_s][:unwrap].gsub(/\wthis\w/, name)
+    end
+
+    # Basic integer types
+    register_wrapping("char", "INT2NUM(this)", "NUM2CHR(this)")
+    register_wrapping("short", "INT2NUM(this)", "NUM2SHORT(this)")
+    register_wrapping("int", "INT2NUM(this)", "NUM2INT(this)")
+    register_wrapping("long", "LONG2NUM(this)", "NUM2LONG(this)")
+    register_wrapping("long long", "LL2NUM(this)", "NUM2LL(this)")
+    # Basic unsigned integer types
+    register_wrapping("unsigned char", "UINT2NUM(this)", "NUM2UCHR(this)")
+    register_wrapping("unsigned short", "UINT2NUM(this)", "NUM2USHORT(this)")
+    register_wrapping("unsigned int", "UINT2NUM(this)", "NUM2UINT(this)")
+    register_wrapping("unsigned long", "ULONG2NUM(this)", "NUM2ULONG(this)")
+    register_wrapping("unsigned long long", "ULL2NUM(this)", "NUM2ULL(this)")
+    # unsigned abbreviations
+    register_alias("uchar", "unsigned char")
+    register_alias("ushort", "unsigned short")
+    register_alias("uint", "unsigned int") 
+    register_alias("ulong", "unsigned long") 
+    register_alias("long ulong", "unsigned long long") # This one is weird, but it makes more sense than ulong long
+
+    # Fixed integer types
+    register_wrapping("int8_t", "INT2NUM(this)", "(int8_t)NUM2CHR(this)")
+    register_wrapping("int16_t", "INT2NUM(this)", "(int16_t)NUM2SHORT(this)")
+    register_wrapping("int32_t", "INT2NUM(this)", "(int32_t)NUM2INT(this)")
+    register_wrapping("int64_t", "LONG2NUM(this)", "(int64_t)NUM2LONG(this)")
+    register_wrapping("uint8_t", "UINT2NUM(this)", "(int8_t)NUM2UINT(this)")
+    register_wrapping("uint16_t", "UINT2NUM(this)", "(int16_t)NUM2UINT(this)")
+    register_wrapping("uint32_t", "UINT2NUM(this)", "(int32_t)NUM2UINT(this)")
+    register_wrapping("uint64_t", "ULONG2NUM(this)", "(int64_t)NUM2ULONG(this)")
+
+    # Floating-point types
+    register_wrapping("float", "DBL2NUM(this)", "(float)NUM2DBL(this)")
+    register_wrapping("double", "DBL2NUM(this)", "NUM2DBL(this)")
+    # Fixed-size floating-point aliases
+    register_alias("float32", "float")
+    register_alias("float64", "double")
+
+    # Boolean type
+    register_wrapping("bool", "(this ? QTrue : QFalse)", "RTEST(this)")
+
+    # String types
+    # C-style strings
+    register_wrapping("char*", "rb_str_new_cstr(this)", "StringValueCStr(this)")
+    register_alias("cstring", "char*")
+    register_alias("cstr", "char*")
+    # Non-C-style strings are not handled here, as it's more complex than a simple inline
+
+end

data/lib/wruby.old/wruby.rb

@@ -0,0 +1,38 @@
+require "psych"
+
+require "wruby/structure_definition"
+require "wruby/module_definition"
+require "wruby/format_error"
+
+module WRuby
+    def self.parse(source)
+        data = Psych.load_stream(source)
+        raise FormatError, "Specification too short" if data.size < 2
+        data[1..].map do |d|
+            StructureDefinition.new(d)
+        end.unshift(data[0])
+    end
+
+    def self.parse_file(file) 
+        parse(File.read(file))
+    end
+
+    def self.render_functions(spec)
+        spec[1..].map do |mspec|
+            mspec.render_methods
+        end
+    end
+
+    def self.render_ruby_definitions(spec)
+        spec[1..].map.with_index do |mspec, i|
+            parent = nil
+            parent = spec[i].qualified_name unless i == 0
+            mspec.render_definitions(parent)
+        end
+
+    end
+
+    def self.render(spec)
+
+    end
+end

data/lib/wruby.rb

@@ -0,0 +1,3 @@
+module WRuby
+
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: wruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kellen Watt
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-11-27 00:00:00.000000000 Z
+dependencies: []
+description: Generates code for C/C++ code based on YAML sepcifications.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/wruby.old/lib/method_definition.rb
+- lib/wruby.old/lib/module_definition.rb
+- lib/wruby.old/lib/parameter_definition.rb
+- lib/wruby.old/lib/return_definition.rb
+- lib/wruby.old/lib/structure_definition.rb
+- lib/wruby.old/lib/util/hash.rb
+- lib/wruby.old/lib/util/normalize.rb
+- lib/wruby.old/lib/util/type_matchup.rb
+- lib/wruby.old/lib/util/type_wrap.rb
+- lib/wruby.old/wruby.rb
+- lib/wruby.rb
+- lib/wruby/format_error.rb
+- lib/wruby/metadata.rb
+- lib/wruby/util/hash.rb
+- lib/wruby/util/normalize.rb
+- lib/wruby/util/type_wrap.rb
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Name reservation for a future project
+test_files: []