diff options
| -rw-r--r-- | Readme.mdown | 62 | ||||
| -rw-r--r-- | generate.rb | 189 | ||||
| -rw-r--r-- | rework.mdown | 62 | ||||
| -rw-r--r-- | templates.rb | 415 |
4 files changed, 565 insertions, 163 deletions
diff --git a/Readme.mdown b/Readme.mdown index bfda7ce..8ca731b 100644 --- a/Readme.mdown +++ b/Readme.mdown @@ -10,7 +10,7 @@ A binding assistant and generator for C/C++ to mruby(Under heavy WIP) ### How I plan for it to work: -1. Run the scanner which will generate a glue.json file. This json file will contain all functions(and their params) as well as all structs(and their params) +1. Run the scanner which will generate a func.json file. This json file will contain all functions(and their params) as well as all structs(and their params) 2. Create a configuration file where you can reference specific functions and how you want their bindings to be generated differently - for example, under what module or class a function should belong - if a certain param should use self instead of passing in something @@ -18,28 +18,38 @@ A binding assistant and generator for C/C++ to mruby(Under heavy WIP) - insert bindings you made yourself 3. Run the generator with the configuration file - this generates the resulting binding code -#### Todo: - -- [X] parse C files for function and struct declarations -- [X] plan for DSL for configuration file -- [ ] create generator's default output - - [X] phase 1 - bind returnless, paramless functions - - [X] phase 2 - bind standard type return functions(e.g string or int), but still paramless - - bool - - int - - float - - double - - string - - [X] phase 3 - bind standard type return or params - - [X] phase 4 - bind struct construction(returning struct objects) - - [X] returning structs - - [X] accessors for values inside structs - - [X] bind struct initializer - - [ ] phase 5 - bind remaining struct related things - - [ ] struct as params of functions - - [ ] fix structs inside of structs - - [ ] for initilization - - [ ] for accessors -- [ ] clean up code -- [ ] have generator use config DSL file to customize bindings -- [ ] do it all again for C++ +### Opinionated Bindings + +The defaults of FelBind make some assumptions on how you would like the resulting interface to look like. + +- Functions get bound to methods using snake_case and kwargs + - `SomeFunction(someValue)` => `some_function(some_value: thing)` +- Functions are defined under a module(by default `Test`) + - `Test.some_function` +- Structs are defined as classes under a module(by default `Test`) + - `Test::MyStruct` +- Functions beginning with `Set` get bound as a method with `=` + - `SetSomeFunction(value)` => `some_function = value` +- Functions beginning with `Get` get bound as a method without it + - `GetSomeFunction()` => `some_function` + +### What Currently Works: + +- Wrapping functions that return or have parameters that are of the basic C types(int, float, char \*, etc) or their pointers(int \*, float \*, etc[except char *]) +- Wrapping function that return or have parameters that are structs or their pointers +- Wrapping structs +- Giving struct objects initializers and accessers + +### What Doesn't Work: + +- Binding C functions that begin with `Set` are bound incorrectly +- Making accessors for structs that contain structs +- kwargs should follow snake_case naming conventions +- The config system +- Struct Aliases(might make this manually done) + +### What isnt currently planned to make work: + +- Functions that utilize the `* void` type +- Nested Pointers +- Functions with variable arguments diff --git a/generate.rb b/generate.rb index df84164..93545d1 100644 --- a/generate.rb +++ b/generate.rb @@ -20,7 +20,7 @@ options[:glue] ||= './glue.json' glue = JSON.parse(File.read(options[:glue])) # configuration -Tplt.treated_as_int |= ['unsigned char'] +#Template.treated_as_int |= ['unsigned char'] LibraryName = 'Test' $phase1 = {} @@ -34,8 +34,8 @@ $complete_phase3 = {} $complete_phase4 = {} $complete_phase5 = {} -result = "" -includes = %{ +$result = "" +$includes = %{ #include <raylib.h> #include <mruby.h> #include <mruby/array.h> @@ -46,8 +46,11 @@ includes = %{ #include <mruby/compile.h> #include <stdlib.h> } -defines = "" -init_body = "" + + +$defines = "" +$init_body = "" +Template.parse_struct_types(glue.last) # convert types @@ -64,22 +67,35 @@ glue.first.keys.each do |k| end end +glue.first.each do |params| + params[1].map! do |param| + rpart = param.rpartition(' ') + + if ['Texture2D'].include? rpart.first + "Texture #{rpart.last}" + elsif ['RenderTexture2D'].include? rpart.first + "RenderTexture #{rpart.last}" + else + param + end + end +end # for displaying statistics glue.first.each do |func, params| if (func.rpartition(' ').first == 'void') && (params[0] == 'void') $phase1[func] = params - elsif (Tplt.non_struct_types.include? func.rpartition(' ').first) && (params[0] == 'void') + elsif (Template.non_struct_types =~ func.rpartition(' ').first) && (params[0] == 'void') $phase2[func] = params else no_struct_param = true params.each do |param| - if !(Tplt.non_struct_types.include? param.rpartition(' ').first) + if !(Template.non_struct_types =~ param.rpartition(' ').first) no_struct_param = false break end end if no_struct_param - if Tplt.non_struct_types.include? func.rpartition(' ').first + if Template.non_struct_types =~ func.rpartition(' ').first $phase3[func] = params else $phase4[func] = params @@ -89,7 +105,6 @@ glue.first.each do |func, params| end end end - # also for display statistics def debug_mark_binding(func, params) if $phase1.include? func @@ -105,13 +120,12 @@ def debug_mark_binding(func, params) end end - $all_params = [] $bound_params = [] # generates structs, accessors, and initializers glue.last.each do |struct, params| - defines += Tplt.init_struct_wrapper(struct) - init_body += Tplt.init_class(struct, LibraryName.downcase) + $defines += Template.init_struct_wrapper(struct) + $init_body += Template.init_class(struct, LibraryName.downcase) init_vars = '' @@ -121,17 +135,17 @@ glue.last.each do |struct, params| param_datatype = rpart.first param_name = rpart.last - next unless Tplt.non_struct_types.include? param_datatype + next unless Template.non_struct_types =~ param_datatype $bound_params.push param # getter # take no params # unwrap struct # return(using correct type conversion) - body = Tplt.unwrap_struct("#{struct} *struct_#{struct.downcase}", 'self', "mrb_#{struct}_struct", struct) - body += "return #{Tplt.to_mrb(param_datatype, "struct_#{struct.downcase}->#{param_name}")};\n" - defines += Tplt.function("#{struct}_get_#{param_name}", body) - init_body += Tplt.init_function("#{struct.downcase}_class", param_name, "#{struct}_get_#{param_name}", "MRB_ARGS_NONE()") + body = Template.unwrap_struct("#{struct} *struct_#{struct.downcase}", 'self', "mrb_#{struct}_struct", struct) + body += "return #{Template.to_mrb(param_datatype, "struct_#{struct.downcase}->#{param_name}")};\n" + $defines += Template.function("#{struct}_get_#{param_name}", body) + $init_body += Template.init_function("#{struct.downcase}_class", param_name, "#{struct}_get_#{param_name}", "MRB_ARGS_NONE()") # setter # init var of correct type @@ -139,25 +153,25 @@ glue.last.each do |struct, params| # unwrap struct # set value in struct # return same value - body = Tplt.get_args({ "#{param_name}": "#{param_datatype}" }) - body += Tplt.unwrap_struct("#{struct} *struct_#{struct.downcase}", 'self', "mrb_#{struct}_struct", struct) - body += "struct_#{struct.downcase}->#{param_name} = #{param_name};\n" - body += "return #{Tplt.to_mrb(param_datatype, param_name)};\n" - defines += Tplt.function("#{struct}_set_#{param_name}", body) - init_body += Tplt.init_function("#{struct.downcase}_class", "#{param_name}=", "#{struct}_set_#{param_name}", "MRB_ARGS_REQ(1)") + body = Template.get_args({ "#{param_name}": "#{param_datatype}" }) + body += Template.unwrap_struct("#{struct} *struct_#{struct.downcase}", 'self', "mrb_#{struct}_struct", struct) + body += "struct_#{struct.downcase}->#{param_name} = #{Template::C.convention_parameter(param_name)};\n" + body += "return #{Template.to_mrb(param_datatype, Template::C.convention_parameter(param_name))};\n" + $defines += Template.function("#{struct}_set_#{param_name}", body) + $init_body += Template.init_function("#{struct.downcase}_class", "#{param_name}=", "#{struct}_set_#{param_name}", "MRB_ARGS_REQ(1)") end - # initializer + ## initializer # init the struct(using mrb to allocate) # get values # assign values to struct # wrap struct # return self body = '' - body += Tplt.get_module(LibraryName) - body += Tplt.get_class(struct, LibraryName.downcase) + body += Template.get_module(LibraryName) + body += Template.get_class(struct, LibraryName.downcase) body += "#{struct} *wrapped_value = (#{struct} *)mrb_malloc(mrb, sizeof(#{struct}));\n" #body += "*wrapped_value = {0};\n" #{func_name}(" @@ -172,8 +186,8 @@ glue.last.each do |struct, params| #init_var_body += temp + ";\n" init_array_body += "mrb_intern_lit(mrb, \"#{temp_rpart.last}\"),\n" #unwrapped_kwargs += Tplt.unwrap_kwarg(index, "#{temp_rpart.last} = #{Tplt.to_c(temp_rpart.first, "kw_values[#{index}]")};", nil, "#{temp_rpart.last} Argument Missing") - if Tplt.non_struct_types.include? temp_rpart.first - unwrapped_kwargs += Tplt.unwrap_kwarg(index, "wrapped_value->#{temp_rpart.last} = #{Tplt.to_c(temp_rpart.first, "kw_values[#{index}]")};\n") + if Template.non_struct_types =~ temp_rpart.first + unwrapped_kwargs += Template::C.unwrap_kwarg(index, "wrapped_value->#{temp_rpart.last} = #{Template.to_c(temp_rpart.first, "kw_values[#{index}]")};\n") else # this is for structs or "undetermined" types # doesnt work yet @@ -181,13 +195,13 @@ glue.last.each do |struct, params| #unwrapped_kwargs += Tplt.unwrap_kwarg(index, "wrapped_value->#{temp_rpart.last} = (#{temp_rpart.first})kw_values[#{index}];\n") end end - body += Tplt.get_kwargs(params.length, '', init_array_body) + body += Template::C.get_kwargs(params)#params.length, '', init_array_body) body += unwrapped_kwargs body += "mrb_data_init(self, wrapped_value, &mrb_#{struct}_struct);\n" body += 'return self;' - defines += Tplt.function("#{struct}_initialize", body) - init_body += Tplt.init_function("#{struct.downcase}_class", "initialize", "#{struct}_initialize", "MRB_ARGS_OPT(1)") + $defines += Template.function("#{struct}_initialize", body) + $init_body += Template.init_function("#{struct.downcase}_class", "initialize", "#{struct}_initialize", "MRB_ARGS_OPT(1)") end @@ -202,20 +216,67 @@ glue.first.each do |func, params| func_datatype = rpart.first func_name = rpart.last - # TODO: just treat longs and shorts as ints - # + # TODO make a skip detector(what functions to skip bindings) + skip = false + #puts "FUNCTION" + #puts "#{func.rpartition(' ').first}| + |#{func.rpartition(' ').last}" + params.each do |param| + #puts "#{param.rpartition(' ').first}| - |#{param.rpartition(' ').last}" + unless (Template.all_valid_types =~ param.rpartition(' ').first) || ("void" == param) + skip = true + break + end + #if param.chars.include? '*' + # unless /^char \*$/ =~ param.rpartition(' ').first + # skip = true + # break + # end + #end + end + next if skip + #next if ['SetTraceLogCallback', 'SetSaveFileTextCallback', 'SetSaveFileDataCallback', 'SetLoadFileTextCallback', 'SetLoadFileDataCallback', 'SetCameraMode', 'GetWorldToScreenEx', 'GetWorldToScreen', 'GetMouseRay', 'GetCameraMatrix', 'DrawBillboardRec', 'DrawBillboardPro', 'DrawBillboard'].include? func_name + # since void * can be anything just skip functions # (by default) that use it next if ['void *'].include? func_datatype + unless Template.all_valid_types =~ func_datatype + puts "// \"#{func_datatype}\" is not a function return datatype that can be currently autobound. From function: \"#{func_name}\"\n\n" + next + end + + body = '' + + body += Template::C.initialize_variables(params, glue.last, func_name) + + body += Template::C.get_kwargs(params) + + body += Template::C.parse_kwargs(params) + body += "\n" # formatting + + body += Template::C.initialize_return_var(func_datatype, func_name) + body += "\n" # formatting + + body += Template.format_set_method_call(func_datatype, func_name, params, Template.struct_types =~ func_datatype.gsub(/ *\*+$/,'')) + body += Template.format_return(func_datatype, func_name) + $defines += "\n//#{func}" + $defines += Template.function(func_name, body) + $init_body += Template.init_module_function(LibraryName.downcase, Template::MRuby.rubify_func_name(func_name), func_name, "MRB_ARGS_OPT(1)") + + debug_mark_binding(func, params) + #puts body + # TODO CONTINUE HERE + #puts "// --- NEXT ---" + #next +=begin # if phase 1 or 2 if (func_datatype == 'void' && params[0] == 'void') || ((Tplt.non_struct_types.include? func_datatype) && (params[0] == 'void')) body = Tplt.return_format(func, params) - #defines += 'PHASE 1\n' - defines += "\n//#{func}" - defines += Tplt.function(func_name, body) - init_body += Tplt.init_module_function(LibraryName.downcase, Tplt.rubify_func_name(func_name), func_name, "MRB_ARGS_NONE()") + #$defines += 'PHASE 1\n' + $defines += "\n//#{func}" + $defines += Tplt.function(func_name, body) + $init_body += Tplt.init_module_function(LibraryName.downcase, Tplt.rubify_func_name(func_name), func_name, "MRB_ARGS_NONE()") debug_mark_binding(func, params) else Tplt.non_struct_types.include? func_datatype # accept params @@ -272,9 +333,9 @@ glue.first.each do |func, params| body += "return mrb_obj_value(Data_Wrap_Struct(mrb, #{func_datatype.downcase}_mrb_class, &mrb_#{func_datatype}_struct, wrapped_value));" end - defines += "\n//#{func}" - defines += Tplt.function(func_name, body) - init_body += Tplt.init_module_function(LibraryName.downcase, Tplt.rubify_func_name(func_name), func_name, "MRB_ARGS_OPT(1)") # opt stuff isnt correct, need to look at this again + $defines += "\n//#{func}" + $defines += Tplt.function(func_name, body) + $init_body += Tplt.init_module_function(LibraryName.downcase, Tplt.rubify_func_name(func_name), func_name, "MRB_ARGS_OPT(1)") # opt stuff isnt correct, need to look at this again # --- #puts func debug_mark_binding(func, params) @@ -284,27 +345,45 @@ glue.first.each do |func, params| end end end +raise 'end of testing' +=end +end +$init_body.prepend(Template.define_module(LibraryName)) -init_body.prepend(Tplt.define_module(LibraryName)) - -result = %{ -#{includes} -#{defines} -#{Tplt.base(LibraryName.downcase, init_body, nil)} +$result = %{ +#{$includes} +#{$defines} +#{Template.base(LibraryName.downcase, $init_body, nil)} } -result += "//Bound Functions: #{$complete_phase1.length + $complete_phase2.length + $complete_phase3.length + $complete_phase4.length + $complete_phase5.length} / #{$phase1.length + $phase2.length + $phase3.length + $phase4.length + $phase5.length}\n//---\n" +$result += "//Bound Functions: #{$complete_phase1.length + $complete_phase2.length + $complete_phase3.length + $complete_phase4.length + $complete_phase5.length} / #{$phase1.length + $phase2.length + $phase3.length + $phase4.length + $phase5.length}\n//---\n" + +$result += "//Phase 1 Functions: #{$complete_phase1.length} / #{$phase1.length}\n" +$result += "//Phase 2 Functions: #{$complete_phase2.length} / #{$phase2.length}\n" +$result += "//Phase 3 Functions: #{$complete_phase3.length} / #{$phase3.length}\n" +$result += "//Phase 4 Functions: #{$complete_phase4.length} / #{$phase4.length}\n" +$result += "//Phase 5 Functions: #{$complete_phase5.length} / #{$phase5.length}\n" +$result += "\n" +#$result += "//Struct Accessors: #{$bound_params.length} / #{$all_params.length}\n" -result += "//Phase 1 Functions: #{$complete_phase1.length} / #{$phase1.length}\n" -result += "//Phase 2 Functions: #{$complete_phase2.length} / #{$phase2.length}\n" -result += "//Phase 3 Functions: #{$complete_phase3.length} / #{$phase3.length}\n" -result += "//Phase 4 Functions: #{$complete_phase4.length} / #{$phase4.length}\n" -result += "//Phase 5 Functions: #{$complete_phase5.length} / #{$phase5.length}\n" -result += "\n" -result += "//Struct Accessors: #{$bound_params.length} / #{$all_params.length}\n" +#pp ($phase3.keys - $complete_phase3.keys) +#puts +#pp $complete_phase3 +all_completed = $complete_phase1.keys | $complete_phase2.keys | $complete_phase3.keys | $complete_phase4.keys | $complete_phase5.keys +all = $phase1.keys | $phase2.keys | $phase3.keys | $phase4.keys | $phase5.keys + +$result += "/* Unbound:\n" +(all - all_completed).each do |unbound| + $result += "#{unbound}\n" +end +$result += "*/\n" + +($phase4.keys - $complete_phase4.keys).each do |ye| + #puts ye +end -puts result +puts $result #$phase4.reverse_each do |key, elem| # puts '---' diff --git a/rework.mdown b/rework.mdown new file mode 100644 index 0000000..60fa67e --- /dev/null +++ b/rework.mdown @@ -0,0 +1,62 @@ +# Refactoring Document + +## Types of functions +- C function wrap +- getter +- setter +- initializer + +### C function wrap +``` +static mrb_value +mrb_#{function_name}(mrb_state* mrb, mrb_value self) { + + #{initialize vars} + + #{unwrap kwarg/arg} + + #{kwargs.each do assignment} <-- this will need to unwrap structs + ^ also need to check if a default exists + + #{call method} + + #{wrap return struct} <-- only if return is new struct + #{return} +} +``` + +### Getter +``` +mrb_#{struct_name}_get_#{var}(mrb_state* mrb, mrb_value self) { + +#{unwrap struct} + +#{return value} <-- may need to wrap value if its a struct +} +``` + +### Setter +``` +mrb_#{struct_name}_set_#{var}(mrb_state* mrb, mrb_value self) { +#{initialize var} +#{get arg} +#{unwrap struct} +#{set value} +#{return the value from the struct} +} +``` + +### Initializer +``` +mrb_#{struct_name}_initialize(mrb_state* mrb, mrb_value self) { +#{initialize var} +#{unwrap kwarg/arg} + +#{kwargs.each do assignment} <-- this will need to unwrap structs +^ also need to check if a default exists + +#{initialize as mrb object} + +return self +} +``` diff --git a/templates.rb b/templates.rb index b4ca43c..1846a0e 100644 --- a/templates.rb +++ b/templates.rb @@ -1,46 +1,317 @@ -module Tplt # Template - class << self - def base(gem_name, init_body, final_body) - %{ -void -mrb_mruby_#{gem_name}_gem_init(mrb_state* mrb) { -#{init_body} -} +module Template # Template + # methods that convert something from ruby-land to c-land + module C + class << self + def to_c_function_name(function_name:) + "mrb_#{function_name}" + end -void -mrb_mruby_#{gem_name}_gem_final(mrb_state* mrb) { -#{final_body} + def to_getter_name(struct_name:, variable_name:) + "mrb_#{struct_name}_get_#{variable_name}" + end + + def to_setter_name(struct_name:, variable_name:) + "mrb_#{struct_name}_set_#{variable_name}" + end + + def to_initializer_name(struct_name:) + "mrb_#{struct_name}_initialize" + end + + def format_type(param_datatype) + if Template.treated_as_int =~ param_datatype + 'int' + elsif Template.treated_as_int_pointer =~ param_datatype + 'int' + elsif Template.treated_as_bool =~ param_datatype + 'bool' + elsif Template.treated_as_bool_pointer =~ param_datatype + 'bool' + elsif Template.treated_as_float =~ param_datatype + 'float' + elsif Template.treated_as_float_pointer =~ param_datatype + 'float' + elsif Template.treated_as_string =~ param_datatype + 'char *' + # Ignore for now + #elsif Template.treated_as_string_pointer =~ param_datatype + # 'char *' + elsif Template.struct_types =~ param_datatype + "#{param_datatype}" + elsif Template.struct_types_pointer =~ param_datatype + "#{param_datatype.gsub(/ *\*+$/,'')}" + else + nil # cannot be formated + end + end + + def convention_parameter(param) + "parameter_#{param}" + end + + def convention_return_variable(func_name) + "return_of_#{func_name}" + end + + def initialize_variables(params, structs, func_name=nil) + + result = '' + return result if params.first == 'void' + params.each do |param| + rpart = param.rpartition(' ') + format = Template::C.format_type(rpart.first) + if format + result += format + " #{'*' if Template.struct_types =~ rpart.first.gsub(/ *\*+$/,'')}#{Template::C.convention_parameter(rpart.last)};\n" + elsif !func_name.nil? + puts "// \"#{rpart.first}\" is not a parameter datatype that can be currently autobound. From function: \"#{func_name}\" and param: #{rpart.last}\n\n" + #raise + end + end + result + "\n" + end + + def initialize_return_var(func_datatype, func_name) + return '' if func_datatype == 'void' + result = '' + depointer_datatype = func_datatype.delete_suffix(' *') + if Template.struct_types =~ depointer_datatype + result += Template.get_module('Test') + result += Template.get_class(depointer_datatype, 'Test') + result += "#{depointer_datatype} *#{Template::C.convention_return_variable(func_name)} = (#{depointer_datatype} *)mrb_malloc(mrb, sizeof(#{depointer_datatype}));\n" + else + result += "#{func_datatype} #{Template::C.convention_return_variable(func_name)};\n" + end + result + end + + def get_kwargs(params) + init_array_body = '' + params.each do |param| + rpart = param.rpartition(' ') + init_array_body += "mrb_intern_lit(mrb, \"#{rpart.last}\"),\n" + end + init_array_body.delete_suffix!(",\n") + %{uint32_t kw_num = #{params.length}; +const mrb_sym kw_names[] = { +#{init_array_body} +}; +mrb_value kw_values[kw_num]; +const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; +mrb_get_args(mrb, "|:", &kwargs); + } + end + + def parse_kwargs(params) + result = '' + skipped = 0 + params.each_with_index do |param, index| + rpart = param.rpartition(' ') + if Template.struct_types =~ rpart.first + + unwrap = Template.unwrap_struct(Template::C.convention_parameter(rpart.last), "kw_values[#{index - skipped}]", "mrb_#{rpart.first}_struct", rpart.first) + + result += Template::C.unwrap_kwarg(index - skipped,unwrap) + elsif Template.non_struct_types =~ rpart.first + unwrap = "#{Template::C.convention_parameter(rpart.last)} = #{Template.to_c(rpart.first, "kw_values[#{index - skipped}]")};" + result += Template::C.unwrap_kwarg(index - skipped,unwrap) + else + skipped += 1 + next + end + end + result + end + + def unwrap_kwarg(kwarg_iter, body_if_defined, body_if_undefined = nil, no_argument_error_message = 'Missing Keyword Argument') + %{ +if (mrb_undef_p(kw_values[#{kwarg_iter}])) { +#{body_if_undefined || "mrb_load_string(mrb, \"raise ArgumentError.new \\\"#{no_argument_error_message}\\\"\");"} +} else { +#{body_if_defined} } - } + } + end + end + end + + # methods that convert something from c-land to ruby-land + module MRuby + class << self + # convert a C function name to be + # formatted like a Ruby method name + def rubify_func_name(function) + func = function.underscore + if func.start_with? 'is_' + func = func.delete_prefix('is_') + '?' + elsif func.start_with? 'set_' + func = func.delete_prefix('set_') + '=' + else + func.delete_prefix('get_') + end + func + end + + def to_c_function_name(function_name:) + rubify_func_name(function_name) + end + + def to_getter_name(struct_name:, variable_name: nil) + rubify_func_name(variable_name) + end + def to_setter_name(struct_name:, variable_name: nil) + rubify_func_name(variable_name) + '=' + end + + def to_initializer_name(struct_name: nil) + "initialize" + end + end + end + + + class << self + + # could be unsigned attr_writer :treated_as_int def treated_as_int - @treated_as_int ||= ['int', 'unsigned int', 'long', 'short'] + @treated_as_int ||= /^((un)?signed )?int$|^((un)?signed )?long$|^((un)?signed )?short$|^((un)?signed )char$/ + end + attr_writer :treated_as_int_pointer + def treated_as_int_pointer + @treated_as_int_pointer ||= /^((un)?signed )?int \*$|^((un)?signed )?long \*$|^((un)?signed )?short \*$|^((un)?signed )char \*$/ end attr_writer :treated_as_bool def treated_as_bool - @treated_as_bool ||= ['bool'] + @treated_as_bool ||= /^bool$/ + end + attr_writer :treated_as_bool_pointer + def treated_as_bool_pointer + @treated_as_bool_pointer ||= /^bool \*$/ end attr_writer :treated_as_float def treated_as_float - @treated_as_float ||= ['float', 'double'] + @treated_as_float ||= /^float$|^double$/ + end + attr_writer :treated_as_float_pointer + def treated_as_float_pointer + @treated_as_float_pointer ||= /^float \*$|^double \*$/ end attr_writer :treated_as_string def treated_as_string - @treated_as_string ||= ['char *', 'const char *'] + @treated_as_string ||= /^(const )?char \*$/ end + # Ignore for now + #attr_writer :treated_as_string_pointer + #def treated_as_string_pointer + # @treated_as_string_pointer ||= /^(const )?char \*\*$/ + #end attr_writer :treated_as_void def treated_as_void - @treated_as_void ||= ['void'] + @treated_as_void ||= /^void$/ end def non_struct_types - treated_as_int | treated_as_bool | treated_as_float | treated_as_string | treated_as_void + @non_struct_types ||= Regexp.union(treated_as_int, treated_as_bool, treated_as_float, treated_as_string, treated_as_void) + end + def non_struct_types_pointer + @non_struct_types_pointer ||= Regexp.union(treated_as_int_pointer, treated_as_bool_pointer, treated_as_float_pointer)#, treated_as_string_pointer) + end + + attr_writer :struct_types + def struct_types + if @struct_types + @struct_types + else + raise "Struct types were not parsed\nRun 'parse_struct_types' first" + end + end + attr_writer :struct_types_pointer + def struct_types_pointer + if @struct_types_pointer + @struct_types_pointer + else + raise "Struct types were not parsed\nRun 'parse_struct_types' first" + end + end + + def parse_struct_types(structs) + struct_types = structs.keys + struct_types_pointer = struct_types.map do |string| + "^#{string} \\*$" + end + struct_types.map! do |string| + "^#{string}$" + end + @struct_types_pointer = /#{struct_types_pointer.join('|')}/ + @struct_types = /#{struct_types.join('|')}/ + end + + def valid_types + @valid_types ||= Regexp.union(non_struct_types, struct_types) + end + def valid_types_pointer + @valid_types_pointer ||= Regexp.union(non_struct_types_pointer, struct_types_pointer) + end + def all_valid_types + @all_valid_types ||= Regexp.union(valid_types, valid_types_pointer) + end + + def base(gem_name, init_body, final_body) + %{ + void + mrb_mruby_#{gem_name}_gem_init(mrb_state* mrb) { + #{init_body} +} + +void +mrb_mruby_#{gem_name}_gem_final(mrb_state* mrb) { +#{final_body} +} + } + end + + def format_method_call(func_datatype, func_name, params, is_struct=false) + result = '' + #if params.first == 'void' + # result += "return #{'*' if is_struct}#{Template::C.convention_return_variable(func_name)} = " + #end + result += "#{func_name}(" + puts '//| --- |' + puts "//#{func_name}" + unless params.first == 'void' + params.each do |param| + rpart = param.rpartition(' ') + puts '//--' + puts "//#{rpart.first}" + puts "//#{Template.struct_types =~ rpart.first}" + result += "#{'*' if Template.struct_types =~ rpart.first}#{"(#{rpart.first})&" if Template.non_struct_types_pointer =~ rpart.first}#{Template::C.convention_parameter(rpart.last)}, " + end + end + result.delete_suffix(', ') + ")" + end + + def format_set_method_call(func_datatype, func_name, params, is_struct=false) + result = format_method_call(func_datatype, func_name, params, is_struct) + ";\n" + unless func_datatype == 'void' + if Template.struct_types_pointer =~ func_datatype + result = '*' + result + end + result = "#{Template::C.convention_return_variable(func_name)} = #{result}" + if is_struct + result = '*' + result + end + end + result + end + + def format_return(func_datatype, func_name) + "return #{Template.to_mrb(func_datatype, Template::C.convention_return_variable(func_name))};" end def init_module(module_name) @@ -64,11 +335,11 @@ mrb_mruby_#{gem_name}_gem_final(mrb_state* mrb) { # define under needs the C name, not the ruby name which may be confusing def init_class(class_name, define_under, is_struct_wrapper = true) %{ -struct RClass *#{class_name.downcase}_class = mrb_define_class_under(mrb, #{define_under}, \"#{class_name}\", mrb->object_class);#{ + struct RClass *#{class_name.downcase}_class = mrb_define_class_under(mrb, #{define_under}, \"#{class_name}\", mrb->object_class);#{ if is_struct_wrapper "\nMRB_SET_INSTANCE_TT(#{class_name.downcase}_class, MRB_TT_DATA);" end - } +} } end @@ -86,56 +357,35 @@ mrb_#{function_name}(mrb_state* mrb, mrb_value self) { } end - def get_kwargs(kwarg_num, init_var_body, init_array_body) - %{ -#{init_var_body} - -uint32_t kw_num = #{kwarg_num}; -const mrb_sym kw_names[] = { -#{init_array_body} -}; -mrb_value kw_values[kw_num]; -const mrb_kwargs kwargs = { kw_num, 0, kw_names, kw_values, NULL }; -mrb_get_args(mrb, "|:", &kwargs); - } - end - - def unwrap_kwarg(kwarg_iter, body_if_defined, body_if_undefined = nil, no_argument_error_message = 'Missing Keyword Argument') - %{ -if (mrb_undef_p(kw_values[#{kwarg_iter}])) { -#{body_if_undefined || "mrb_load_string(mrb, \"raise ArgumentError.new \\\"#{no_argument_error_message}\\\"\");"} -} else { -#{body_if_defined} -} - } - end - def get_args(req_arg_hash, opt_arg_hash=nil) - raise if opt_arg_hash + raise 'opt_arg_hash feature not implemented yet' if opt_arg_hash result = '' tail = '' flags = '' req_arg_hash.each do |var_name, var_datatype| - if var_datatype != 'unsigned char' - result += "#{var_datatype} #{var_name};\n" - else - result += "mrb_int #{var_name};\n" + #if var_datatype != 'unsigned char' + if Template.non_struct_types =~ var_datatype + result += "#{Template::C.format_type(var_datatype)} #{Template::C.convention_parameter(var_name)};\n" + #else + # result += "mrb_int #{var_name};\n" end - tail += ", &#{var_name}" + tail += ", &#{Template::C.convention_parameter(var_name)}" flags += datatype_to_arg_flag(var_datatype) end result += "mrb_get_args(mrb, \"#{flags}\"#{tail});\n" end def datatype_to_arg_flag(datatype) - if treated_as_int.include? datatype + if Template.treated_as_int =~ datatype 'i' - elsif treated_as_bool.include? datatype + elsif Template.treated_as_bool =~ datatype 'b' - elsif treated_as_float.include? datatype + elsif Template.treated_as_float =~ datatype 'f' - elsif treated_as_string.include? datatype + elsif Template.treated_as_string =~ datatype 'z' + elsif Template.struct_types =~ datatype + 'o' end end @@ -145,9 +395,9 @@ if (mrb_undef_p(kw_values[#{kwarg_iter}])) { def wrap_struct(var_name, target, mrb_type, type) %{ - #{var_name} = (#{type} *)DATA_PTR(#{target}); - if(#{var_name}) #{'{'} mrb_free(mrb, #{var_name}); #{'}'} -mrb_data_init(#{target}, NULL, &#{mrb_type}); + #{var_name} = (#{type} *)DATA_PTR(#{target}); + if(#{var_name}) #{'{'} mrb_free(mrb, #{var_name}); #{'}'} + mrb_data_init(#{target}, NULL, &#{mrb_type}); #{var_name} = (#{type} *)mrb_malloc(mrb, sizeof(#{type})); } end @@ -159,39 +409,40 @@ mrb_data_init(#{target}, NULL, &#{mrb_type}); # for converting mrb to C def to_c(type, variable) - if treated_as_int.include?(type) || treated_as_bool.include?(type) + if (Template.treated_as_int =~ type) || (Template.treated_as_bool =~ type) "mrb_as_int(mrb, #{variable})" - elsif treated_as_float.include? type + elsif Template.treated_as_float =~ type "mrb_as_float(mrb, #{variable})" - elsif treated_as_string.include? type + elsif Template.treated_as_string =~ type "mrb_str_to_cstr(mrb, #{variable})" end end # for converting C to mrb def to_mrb(type, variable) - if treated_as_int.include? type + if Template.treated_as_int =~ type "mrb_fixnum_value(#{variable})" - elsif treated_as_float.include? type + elsif Template.treated_as_float =~ type "mrb_float_value(mrb, #{variable})" - elsif treated_as_bool.include? type + elsif Template.treated_as_bool =~ type "mrb_bool_value(#{variable})" - elsif treated_as_string.include? type + elsif Template.treated_as_int_pointer =~ type + "mrb_fixnum_value(*#{variable})" + elsif Template.treated_as_float_pointer =~ type + "mrb_float_value(mrb, *#{variable})" + elsif Template.treated_as_bool_pointer =~ type + "mrb_bool_value(*#{variable})" + elsif Template.treated_as_string =~ type "mrb_str_new_cstr(mrb, #{variable})" - elsif treated_as_void.include? type + elsif Template.treated_as_void =~ type 'mrb_nil_value()' + elsif Template.struct_types =~ type + "mrb_obj_value(Data_Wrap_Struct(mrb, #{type.downcase}_mrb_class, &mrb_#{type}_struct, #{variable}))" + elsif Template.struct_types_pointer =~ type + "mrb_obj_value(Data_Wrap_Struct(mrb, #{type.delete_suffix(' *').downcase}_mrb_class, &mrb_#{type.delete_suffix(' *')}_struct, #{variable}))" end end - # convert a C function name to be - # formatted like a Ruby method name - def rubify_func_name(function) - func = function.underscore - if func.start_with? 'is_' - func = func.delete_prefix('is_') + '?' - end - func.delete_prefix('get_') - end # generate a return of a ruby bound C function def return_format(function, params) @@ -242,31 +493,31 @@ mrb_data_init(#{target}, NULL, &#{mrb_type}); # wrapping an existing struct to be used by ruby def init_struct_wrapper(struct, free_body = nil) %{ - #{"void mrb_helper_#{struct}_free(mrb_state*, void*);" if free_body} + #{"void mrb_helper_#{struct}_free(mrb_state*, void*);" if free_body} -static const struct mrb_data_type mrb_#{struct}_struct = { -"#{struct}", -#{ + static const struct mrb_data_type mrb_#{struct}_struct = { + "#{struct}", + #{ if free_body "mrb_helper_#{struct}_free" else "mrb_free" end } - }; - #{ + }; + #{ if free_body %{ void mrb_helper_#{struct}_free(mrb_state* mrb, void*ptr) { #{struct} *struct_data = (#{struct}*)ptr; -#{free_body} + #{free_body} mrb_free(mrb, ptr); } } end - } + } } end |