Class: Rbind::GeneratorRuby::RBindHelper

Inherits:
HelperBase
  • Object
show all
Defined in:
lib/rbind/generator_ruby.rb

Instance Attribute Summary collapse

Attributes inherited from HelperBase

#name

Instance Method Summary collapse

Methods inherited from HelperBase

#binding, #full_name

Constructor Details

#initialize(name, root, compact_namespace = true) ⇒ RBindHelper

Returns a new instance of RBindHelper.



191
192
193
194
 
# File 'lib/rbind/generator_ruby.rb', line 191

def initialize(name, root,compact_namespace=true)
    @compact_namespace = compact_namespace
    super(name,root)
end

Instance Attribute Details

#compact_namespace ⇒ Object (readonly)

Returns the value of attribute compact_namespace.



189
190
191
 
# File 'lib/rbind/generator_ruby.rb', line 189

def compact_namespace
  @compact_namespace
end

Instance Method Details

#add_accessors ⇒ Object 



227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
 
# File 'lib/rbind/generator_ruby.rb', line 227

def add_accessors
    str = ""
    @root.root.each_type do |t|
        next if t.basic_type? && !t.is_a?(RNamespace)
        str += "\n#methods for #{t.full_name}\n"
        if t.cdelete_method
            str += "attach_function :#{normalize_m t.cdelete_method},"\
            ":#{t.cdelete_method},[#{normalize_t t.full_name}],:void\n"
            str += "attach_function :#{normalize_m t.cdelete_method}_struct,"\
            ":#{t.cdelete_method},[#{normalize_t t.full_name}Struct],:void\n"
        end
        t.each_operation do |op|
            return_type = if op.constructor?
                              "#{normalize_t op.owner.full_name}"
                          else
                              if op.return_type.basic_type?
                                  ":#{normalize_bt op.return_type.csignature}"
                              else
                                  if op.return_type.extern_package_name
                                      normalize_t("::#{op.return_type.extern_package_name}::#{op.return_type.full_name}")
                                  else
                                      normalize_t op.return_type.full_name
                                  end
                              end
                          end
            args = op.cparameters.map do |p|
                if p.type.basic_type?
                    ":#{normalize_bt p.type.csignature}"
                else
                    if p.type.extern_package_name
                        normalize_t("::#{p.type.extern_package_name}::#{p.type.full_name}")
                    else
                        normalize_t p.type.full_name
                    end
                end
            end
            fct_name = normalize_m op.cname
            str += "attach_function :#{fct_name},:#{op.cname},[#{args.join(",")}],#{return_type}\n"
        end
        str+"\n"
    end
    str+"\n"
    str.gsub(/\n/,"\n        ")
end

#file_prefix ⇒ Object 



223
224
225
 
# File 'lib/rbind/generator_ruby.rb', line 223

def file_prefix
    @root.file_prefix
end

#library_name ⇒ Object 



213
214
215
 
# File 'lib/rbind/generator_ruby.rb', line 213

def library_name
    @root.library_name
end

#normalize_bt(name) ⇒ Object 



205
206
207
 
# File 'lib/rbind/generator_ruby.rb', line 205

def normalize_bt(name)
    GeneratorRuby.normalize_basic_type_name_ffi name
end

#normalize_m(name) ⇒ Object 



209
210
211
 
# File 'lib/rbind/generator_ruby.rb', line 209

def normalize_m(name)
    GeneratorRuby.normalize_method_name name
end

#normalize_t(name) ⇒ Object 



196
197
198
199
200
201
202
203
 
# File 'lib/rbind/generator_ruby.rb', line 196

def normalize_t(name)
    t = GeneratorRuby.normalize_type_name name
    if compact_namespace
        t.gsub(/^#{self.name}::/,"")
    else
        t
    end
end

#required_module_names ⇒ Object 



217
218
219
220
221
 
# File 'lib/rbind/generator_ruby.rb', line 217

def required_module_names
    @root.required_module_names.map do |name|
        "require '#{name.downcase}'\n"
    end.join
end