dub 0.2.2 → 0.6.5

data/lib/dub/function.rb

@@ -0,0 +1,163 @@
+require 'dub/argument'
+require 'dub/entities_unescape'
+
+module Dub
+  class Function
+    include Dub::EntitiesUnescape
+    attr_reader :arguments, :prefix, :overloaded_index, :return_value, :xml, :parent
+    attr_accessor :gen, :name, :is_constructor
+
+    def initialize(parent, name, xml, prefix = '', overloaded_index = nil)
+      @parent, @name = parent, name
+      @xml, @prefix, @overloaded_index = xml, prefix, overloaded_index
+      parse_xml
+      parse_template_params
+    end
+
+    def set_as_constructor
+      @return_value = Argument.new(self, (Hpricot::XML("<type>#{name} *</type>")/''))
+      @is_constructor = true
+    end
+
+    def bind(generator)
+      @gen = generator.function_generator
+    end
+
+    def to_s
+      generator.function(self)
+    end
+
+    def generator
+      @gen || (@parent && @parent.function_generator)
+    end
+
+    def klass
+      @parent.kind_of?(Klass) ? @parent : nil
+    end
+
+    def member_method?
+      !klass.nil?
+    end
+
+    def constructor?
+      @is_constructor
+    end
+
+    def static?
+      @is_static
+    end
+
+    alias gen generator
+
+    def name=(n)
+      @name = n
+      if constructor?
+        @return_value.type = n
+      end
+    end
+
+    def call_name
+      if klass
+        static? ? "#{klass.name}::#{name}" : name
+      else
+        name
+      end
+    end
+
+    def id_name
+      @parent ? "#{@parent.id_name}.#{name}" : name
+    end
+
+    def source
+      loc = (@xml/'location').first.attributes
+      "#{loc['file'].split('/')[-3..-1].join('/')}:#{loc['line']}"
+    end
+
+    def original_signature
+      unescape "#{(@xml/'definition').innerHTML}#{(@xml/'argsstring').innerHTML}"
+    end
+
+    def has_default_arguments?
+      return @has_defaults if defined?(@has_defaults)
+      @has_defaults = !@arguments.detect {|a| a.has_default? }.nil?
+    end
+
+    def has_array_arguments?
+      return @has_array_arguments if defined?(@has_array_arguments)
+      @has_array_arguments = !@arguments.detect {|a| a.array_suffix }.nil?
+    end
+
+    def has_class_pointer_arguments?
+      return @has_class_pointer_arguments if defined?(@has_class_pointer_arguments)
+      @has_class_pointer_arguments = !@arguments.detect {|a| !a.is_native? && a.is_pointer? }.nil?
+    end
+
+    def has_complex_arguments?
+      return @has_complex_arguments if defined?(@has_complex_arguments)
+      @has_complex_arguments = !(@arguments + [@return_value]).compact.detect {|a| a.complex? }.nil?
+    end
+
+    def vararg?
+      @arguments.last && @arguments.last.vararg?
+    end
+
+    def arg_is_list(list_position, count_position)
+      @arguments[list_position ].is_list       = true
+      @arguments[count_position].is_list_count = true
+    end
+
+    def template?
+      !@template_params.nil?
+    end
+
+    def template_params
+      @template_params
+    end
+
+    def inspect
+      "#<Function #{@prefix}_#{@name}(#{@arguments.inspect[1..-2]})>"
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    # ====== these methods are alias to
+    # generator methods on this object
+
+    def method_name(overloaded_index = nil)
+      gen.method_name(self, overloaded_index)
+    end
+
+    # =================================
+
+    private
+      def parse_xml
+        @arguments = []
+
+        (@xml/'param').each_with_index do |arg, i|
+          @arguments << Argument.new(self, arg, i + 1)
+        end
+
+        raw_type = (@xml/'/type').innerHTML
+
+        if raw_type.strip == ''
+          # no return type
+        else
+          arg = Argument.new(self, (@xml/'/type'))
+          @return_value = arg unless arg.create_type =~ /void\s*$/
+        end
+
+        @is_static = @xml[:static] == 'yes'
+      end
+
+      def parse_template_params
+        template_params = (@xml/'/templateparamlist/param')
+        if !template_params.empty?
+          @template_params = template_params.map do |param|
+            (param/'/type').innerHTML.gsub(/^\s*(typename|class)\s+/,'')
+          end
+        end
+      end
+  end
+end # Namespace

data/lib/dub/function_group.rb

@@ -0,0 +1,72 @@
+module Dub
+  class FunctionGroup < Array
+    def initialize(parent, gen = nil)
+      @parent, @gen = parent, gen
+    end
+
+    def bind(generator)
+      self.gen = generator.function_generator
+    end
+
+    def generator
+      @gen || (@parent && @parent.function_generator)
+    end
+
+    def gen=(generator)
+      @gen = generator
+      @gen_members = nil
+    end
+
+    alias gen generator
+
+    def members
+      if self.generator
+        if @parent.generator
+          @gen_members ||= @parent.generator.members_list(self)
+        else
+          @gen_members ||= generator.namespace_generator.members_list(self)
+        end
+      else
+        self
+      end
+    end
+
+    def to_s
+      generator.group(self)
+    end
+
+    def method_name(overloaded_index = nil)
+      first.method_name(overloaded_index)
+    end
+
+    def map(&block)
+      list = self.class.new(@parent, @gen)
+      super(&block).each do |e|
+        list << e
+      end
+      list
+    end
+
+    def compact
+      list = self.class.new(@parent, @gen)
+      super.each do |e|
+        list << e
+      end
+      list
+    end
+
+    def overloaded_index
+      nil
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    private
+      def method_missing(method, *args)
+        first.send(method, *args)
+      end
+
+  end
+end

data/lib/dub/generator.rb

@@ -0,0 +1,15 @@
+require 'dub/function'
+
+module Dub
+  class Generator
+
+    def comment(func)
+      "/** #{func.original_signature}\n * #{func.source}\n */"
+    end
+
+    protected
+      def indent(str, indent)
+        str.gsub(/^/, ' ' * indent)
+      end
+  end # Generator
+end # Dub

data/lib/dub/group.rb

@@ -0,0 +1,24 @@
+require 'dub/namespace'
+
+module Dub
+  class Group < Namespace
+    def parse_xml
+      super
+      parse_defines
+    end
+
+    def arg_is_list(argument_pos, count_pos)
+      each do |f|
+        f.arg_is_list(argument_pos, count_pos)
+      end
+    end
+
+    def members
+      if self.generator
+        @gen_members ||= self.generator.members_list(super, @ignores)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/dub/klass.rb

@@ -0,0 +1,244 @@
+module Dub
+  module MemberExtraction
+  end
+end
+require 'dub/member_extraction'
+
+module Dub
+  class Klass
+    include MemberExtraction
+    attr_reader :name, :xml, :prefix, :constructor, :alias_names, :enums, :parent, :instanciations
+    attr_accessor :opts
+
+    def initialize(parent, name, xml, prefix = '')
+      @parent, @name, @xml, @prefix = parent, name, xml, prefix
+
+      @alias_names = []
+      @enums       = []
+      @ignores     = []
+      @instanciations = {}
+      @opts        = {}
+      parse_xml
+    end
+
+    def bind(generator)
+      self.gen = generator.class_generator
+    end
+
+    def gen=(generator)
+      @gen = generator
+      @gen_members = nil
+    end
+
+    def to_s
+      generator.klass(self)
+    end
+
+    def generator
+      @gen || (@parent && @parent.class_generator)
+    end
+
+    def function_generator
+      if generator = self.generator
+        generator.function_generator
+      else
+        nil
+      end
+    end
+
+    alias gen generator
+
+    def ignore(list)
+      list = [list].flatten
+      @ignores += list
+      @ignores.uniq!
+      @gen_members = nil
+    end
+
+    def members
+      if self.generator
+        @gen_members ||= self.generator.members_list(super, @ignores)
+      else
+        super
+      end
+    end
+
+    def <=>(other)
+      (name || "") <=> (other.name || "")
+    end
+
+    def [](name)
+      name.to_s == @name ? constructor : get_member(name.to_s)
+    end
+
+    def class_methods
+      []
+    end
+
+    def template?
+      !@template_params.nil?
+    end
+
+    def has_constants?
+      has_enums?
+    end
+
+    def has_enums?
+      !@enums.empty?
+    end
+
+    def template_params
+      @template_params
+    end
+
+    def class_with_params(template_params)
+      @instanciations[template_params]
+    end
+
+    def register_instanciation(template_params, klass)
+      @instanciations[template_params] = klass
+    end
+
+    def source
+      loc = (@xml/'location').first.attributes
+      "#{loc['file'].split('/')[-3..-1].join('/')}:#{loc['line']}"
+    end
+
+    def header
+      @opts[:header] ||= (@xml/'location').first.attributes['file'].split('/').last
+    end
+
+    def full_type
+      @parent ? "#{@parent.full_type}::#{name}" : name
+    end
+
+    def lib_name
+      @opts[:lib_name] || name
+    end
+
+    def id_name(name = self.name)
+      "#{prefix}.#{name}"
+    end
+
+    def destructor_name
+      "#{name}_destructor"
+    end
+
+    def tostring_name
+      "#{name}__tostring"
+    end
+
+    def constructor
+      if defined?(@constructor)
+        @constructor
+      else
+        self.members
+        @constructor ||= nil
+      end
+      @constructor
+    end
+
+    def names
+      [@name] + @alias_names
+    end
+
+    private
+      def parse_xml
+        parse_enums
+        parse_members
+        parse_template_params
+        parse_instanciations
+        parse_alias_names
+      end
+
+      def parse_enums
+        @enums = (@xml/"enumvalue/name").map{|e| e.innerHTML}
+      end
+
+      def parse_template_params
+        template_params = (@xml/'/templateparamlist/param')
+        if !template_params.empty?
+          @template_params = template_params.map do |param|
+            (param/'/type').innerHTML.gsub(/^\s*(typename|class)\s+/,'')
+          end
+        end
+      end
+
+      def parse_instanciations
+        (@xml/'instanciation').each do |klass|
+          name   = (klass/'name').innerHTML
+          params = (klass/'param').map do |p|
+            p.innerHTML
+          end
+
+          @instanciations[params] = @parent[name]
+        end
+      end
+
+      def parse_alias_names
+        (@xml/'aliases/name').each do |name|
+          name = name.innerHTML
+          if name.size < @name.size
+            @alias_names << @name
+            change_name(name)
+          else
+            @alias_names << name
+          end
+
+          if @parent
+            @parent.register_alias(name, self)
+          end
+        end
+      end
+
+      def make_member(name, member, overloaded_index = nil)
+        return nil unless member[:prot] == 'public'
+        if names.include?(name)
+          # keep constructors out of members list
+          if @constructor.kind_of?(FunctionGroup)
+            constr = super
+            constr.name = @name # force key name
+            constr.set_as_constructor
+            @constructor << constr
+          elsif @constructor
+            constr = super
+            constr.name = @name
+            constr.set_as_constructor
+            list = Dub::FunctionGroup.new(self)
+            list << @constructor
+            list << constr
+            @constructor = list
+          else
+            @constructor = super
+            @constructor.set_as_constructor
+            @constructor.name = @name
+          end
+          nil
+        else
+          super
+        end
+      end
+
+      def change_name(new_name)
+        @name = new_name
+        if @constructor.kind_of?(Array)
+          @constructor.each do |c|
+            c.name = new_name
+          end
+        elsif @constructor
+          @constructor.name = new_name
+        end
+      end
+
+      def method_missing(met, *args)
+        if args.empty? && @opts.has_key?(met.to_sym)
+          @opts[met.to_sym]
+        elsif args.size == 1 && met.to_s =~ /^(.+)=$/
+          @opts[$1.to_sym] = args.first
+        else
+          super
+        end
+      end
+
+  end
+end

data/lib/dub/lua/class.cpp.erb

@@ -0,0 +1,84 @@
+#include "<%= @class.header %>"
+
+#include "lua_cpp_helper.h"
+
+<% if @class.prefix %>
+using namespace <%= @class.prefix %>;
+<% end %>
+
+/* ============================ Constructors     ====================== */
+
+<%= @class.constructor %>
+
+/* ============================ Destructor       ====================== */
+
+static int <%= @class.destructor_name %>(lua_State *L) {
+  <%= @class.name %> **userdata = (<%= @class.name %>**)luaL_checkudata(L, 1, <%= @class.id_name.inspect %>);
+  if (*userdata) delete *userdata;
+  *userdata = NULL;
+  return 0;
+}
+
+/* ============================ tostring         ====================== */
+
+static int <%= @class.tostring_name %>(lua_State *L) {
+  <%= @class.name %> **userdata = (<%= @class.name %>**)luaL_checkudata(L, 1, <%= @class.id_name.inspect %>);
+  <% if @class.opts[:string_format] %>
+  lua_pushfstring(L, "<<%= @class.id_name %>: %p <%= @class.string_format %>>", *userdata, <%= @class.string_args %>);
+  <% else %>
+  lua_pushfstring(L, "<<%= @class.id_name %>: %p>", *userdata);
+  <% end %>
+  return 1;
+}
+
+/* ============================ Member Methods   ====================== */
+
+<% if @class.members; @class.members.each do |function| %>
+<%= function %>
+
+<% end; end %>
+
+
+/* ============================ Lua Registration ====================== */
+
+static const struct luaL_Reg <%= @class.name %>_member_methods[] = {
+<%= indent(method_registration, 2) %>,
+  {NULL, NULL},
+};
+
+static const struct luaL_Reg <%= @class.name %>_namespace_methods[] = {
+<%= indent(namespace_methods_registration, 2) %>,
+  {NULL, NULL},
+};
+
+<% if @class.has_constants? %>
+static const struct lua_constants_Reg <%= @class.name %>_namespace_constants[] = {
+<%= indent(constants_registration, 2) %>,
+  {NULL, NULL},
+};
+<% end %>
+
+#ifdef DUB_LUA_NO_OPEN
+int luaload_<%= @class.prefix %>_<%= @class.lib_name %>(lua_State *L) {
+#else
+extern "C" int luaopen_<%= @class.prefix %>_<%= @class.lib_name %>(lua_State *L) {
+#endif
+  // Create the metatable which will contain all the member methods
+  luaL_newmetatable(L, <%= @class.id_name.inspect %>);
+
+  // metatable.__index = metatable (find methods in the table itself)
+  lua_pushvalue(L, -1);
+  lua_setfield(L, -2, "__index");
+
+  // register member methods
+  luaL_register(L, NULL, <%= @class.name %>_member_methods);
+
+  // register class methods in a global namespace table
+  luaL_register(L, <%= @class.prefix.inspect %>, <%= @class.name %>_namespace_methods);
+
+<% if @class.has_constants? %>
+  // register class enums
+  register_constants(L, <%= (@class.id_name + '_const').inspect %>, <%= @class.name %>_namespace_constants);
+<% end %>
+	return 1;
+}

data/lib/dub/lua/class_gen.rb

@@ -0,0 +1,97 @@
+
+require 'dub/generator'
+require 'erb'
+
+module Dub
+  module Lua
+    class ClassGen < Dub::Generator
+      attr_accessor :template_path
+
+      def initialize
+        load_erb
+      end
+
+      def template_path=(template_path)
+        @template_path = template_path
+        load_erb
+      end
+
+      def klass(klass)
+        @class = klass
+        @class_template.result(binding)
+      end
+
+      def function_generator
+        Lua.function_generator
+      end
+
+      def method_registration(klass = @class)
+        member_methods = (klass.members || []).map do |method|
+          next if method.static?
+          "{%-20s, #{method.method_name(0)}}" % method.name.inspect
+        end.compact
+
+        member_methods << "{%-20s, #{klass.tostring_name}}" % "__tostring".inspect
+        member_methods << "{%-20s, #{klass.destructor_name}}" % "__gc".inspect
+
+        member_methods.join(",\n")
+      end
+
+      def namespace_methods_registration(klass = @class)
+        global_methods = klass.names.map do |name|
+          "{%-20s, #{klass.constructor.method_name(0)}}" % name.inspect
+        end
+
+        (klass.members || []).map do |method|
+          next unless method.static?
+          global_methods << "{%-20s, #{method.method_name(0)}}" % "#{klass.name}_#{method.name}".inspect
+        end
+
+        global_methods.join(",\n")
+      end
+
+      def constants_registration(klass = @class)
+        klass.enums.map do |name|
+          "{%-20s, #{klass.full_type}::#{name}}" % name.inspect
+        end.join(",\n")
+      end
+
+      def members_list(all_members, ignore_list = [])
+        list = all_members.map do |member_or_group|
+          if ignore_list.include?(member_or_group.name)
+            nil
+          elsif member_or_group.kind_of?(Array)
+            members_list(member_or_group)
+          elsif  ignore_member?(member_or_group)
+            nil
+          else
+            member_or_group
+          end
+        end
+
+        list.compact!
+        list == [] ? nil : list
+      end
+
+      def ignore_member?(member)
+        if member.name =~ /^~/           || # do not build constructor
+           member.name =~ /^operator/    || # no conversion operators
+           member.has_complex_arguments? || # no complex arguments or return values
+           member.has_array_arguments? ||
+           member.vararg? ||
+           member.original_signature =~ /void\s+\*/ # used to detect return value and parameters
+          true # ignore
+        elsif return_value = member.return_value
+          return_value.type =~ />$/    || # no complex return types
+          return_value.is_native? && member.return_value.is_pointer?
+        else
+          false # ok, do not ignore
+        end
+      end
+
+      def load_erb
+        @class_template = ::ERB.new(File.read(@template_path || File.join(File.dirname(__FILE__), 'class.cpp.erb')))
+      end
+    end
+  end
+end