dub 0.2.2 → 1.0.0

data/lib/dub/klass.rb

@@ -0,0 +1,338 @@
+require 'yaml'
+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, :ancestors, :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
+      list = super(@ignores)
+      if self.generator
+        list = @gen_members ||= self.generator.members_list(list.reject {|m| m.constructor?})
+      end
+      # Copy members from super classes
+      superclasses = (@opts[:super] || '').split(',').map(&:strip)
+      @super_members ||= superclasses.map do |id_name|
+        if id_name =~ /([^\.])\.(.*)/
+          namespace = Dub::Namespace.find($1)
+          class_name = $2
+        else
+          namespace = self.parent
+          class_name = id_name
+        end
+        if x = namespace[class_name]
+          x.members
+        else
+          Dub.logger.warn "Could not find superclass '#{id_name}'"
+          nil
+        end
+      end.compact.flatten
+      (list + @super_members).sort do |a,b|
+        a.name <=> b.name
+      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
+
+    # Special or no destructor: class construction
+    # and method calls are treated differently because
+    # the object can be destroyed out of Lua (and Lua
+    # should call a special method on garbage collection).
+    def custom_destructor?
+      @opts[:destructor]
+    end
+
+    # Use a static method as constructor.
+    def custom_constructor?
+      @opts[:constructor]
+    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 is_deleted_name
+      "#{name}_deleted"
+    end
+
+    def tostring_name
+      "#{name}__tostring"
+    end
+
+    def constructor
+      if custom_constructor?
+        # Using a static member built with member list
+        return nil
+      end
+
+      if defined?(@constructor)
+        @constructor
+      else
+        self.members
+        @constructor ||= nil
+      end
+      @constructor
+    end
+
+    def names
+      [@name] + @alias_names
+    end
+
+    # Uses the bind declaration to read function bodies from a yml file:
+    # @dub bind: Foo.yml
+    def custom_bind(lang)
+      if !@bind_hash then
+        if file = @opts[:bind] then
+          header = (@xml/'location').first[:file]
+          path = header.split('/')
+          path.pop
+          path = (path + [file]).join('/')
+          if File.exist?(path) then
+            data = File.read(path)
+            @bind_hash = YAML::load(data)
+          else
+            @bind_hash = {}
+            Dub.logger.warn "Missing binding file '#{path}'"
+          end
+        else
+          @bind_hash = {}
+        end
+      end
+      @bind_hash[lang] ||= {}
+    end
+
+    private
+      def parse_xml
+        parse_opts_hash
+        parse_ancestors
+        parse_enums
+        parse_members
+        parse_template_params
+        parse_instanciations
+        parse_alias_names
+      end
+
+      def parse_opts_hash
+        if hash = Dub::OptsParser.extract_hash(@xml)
+          if hash.kind_of?(Hash)
+            if ignore = hash[:ignore]
+              self.ignore(ignore.split(',').map(&:strip))
+            end
+            @opts.merge!(hash)
+          else
+            raise "Could not parse @dub parameters #{hash.inspect}"
+          end
+        end
+      end
+
+      def parse_enums
+        @enums = (@xml/"enumvalue/name").map{|e| e.innerHTML}
+      end
+
+      def parse_ancestors
+        @ancestors = (@xml/'inheritancegraph'/'label').map{|a| a.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, xml)
+        member = super
+        return nil unless member
+
+        if names.include?(name)
+          member.name = @name # force key name
+          member.set_as_constructor
+
+          # special handling of constructors
+          if @constructor.kind_of?(FunctionGroup)
+            @constructor << member
+          elsif @constructor
+            list = Dub::FunctionGroup.new(self)
+            list << @constructor
+            list << member
+            @constructor = list
+          else
+            @constructor = member
+          end
+        end
+
+        member
+      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
+
+      def ignore_member?(member)
+        if custom_destructor?
+          if member.name == opts[:destructor] || member.name == 'set_userdata_ptr'
+            return true
+          end
+        end
+        if custom_constructor?
+          if member.constructor?
+            return true
+          end
+        end
+        super
+      end
+
+  end
+end

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

@@ -0,0 +1,114 @@
+#include "<%= @class.header %>"
+
+#include "lua_cpp_helper.h"
+
+<%# We need this to serialize superclass members properly %>
+<% Lua.function_generator.klass = @class %>
+
+<% if @class.prefix %>
+using namespace <%= @class.prefix %>;
+<% end %>
+
+/* ============================ Constructors     ====================== */
+
+<%= @class.constructor %>
+
+<% if @class.opts[:destructor] == '' %>
+// Destructor disabled for this class
+<% else %>
+/* ============================ Destructor       ====================== */
+
+static int <%= @class.destructor_name %>(lua_State *L) {
+  <%= @class.name %> **userdata = (<%= @class.name %>**)dubL_checksdata_n(L, 1, <%= @class.id_name.inspect %>);
+
+  <% if @class.custom_destructor? %>
+  // custom destructor
+  if (*userdata) (*userdata)-><%= @class.opts[:destructor] %>();
+  <% else %>
+  if (*userdata) delete *userdata;
+  <% end %>
+  *userdata = NULL;
+  return 0;
+}
+<% end %>
+
+<% if @class.custom_destructor? %>
+
+// test if class is deleted
+static int <%= @class.is_deleted_name %>(lua_State *L) {
+  <%= @class.name %> **userdata = (<%= @class.name %>**)dubL_checksdata_n(L, 1, <%= @class.id_name.inspect %>);
+  lua_pushboolean(L, *userdata == NULL);
+  return 1;
+}
+<% end %>
+/* ============================ tostring         ====================== */
+
+static int <%= @class.tostring_name %>(lua_State *L) {
+  <%= @class.name %> **userdata = (<%= @class.name %>**)dubL_checksdata_n(L, 1, <%= @class.id_name.inspect %>);
+  <% if @class.custom_destructor? %>
+  if (!*userdata) {
+    lua_pushstring(L, "<<%= @class.id_name %>: NULL>");
+    return 1;
+  }
+  <% end %>
+  <% 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);
+  // save meta-table in <%= @class.prefix %>.<%= @class.name %>_
+  register_mt(L, <%= @class.prefix.inspect %>, <%= @class.name.inspect %>);
+
+  // 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,96 @@
+
+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
+        if klass.opts[:destructor] != ''
+          member_methods << "{%-20s, #{klass.destructor_name}}" % "__gc".inspect
+        end
+        if klass.custom_destructor?
+          member_methods << "{%-20s, #{klass.is_deleted_name}}" % "deleted".inspect
+        end
+
+        member_methods.join(",\n")
+      end
+
+      def namespace_methods_registration(klass = @class)
+        if custom_ctor = klass.opts[:constructor]
+          ctor = klass[custom_ctor.to_sym]
+          raise "#{klass.name} custom constructor '#{custom_ctor}' not found !" unless ctor
+          raise "#{klass.name} custom constructor '#{custom_ctor}' not a static function !" unless ctor.static?
+
+          global_methods = klass.names.map do |name|
+            "{%-20s, #{ctor.method_name(0)}}" % name.inspect
+          end
+        else
+          global_methods = klass.names.map do |name|
+            "{%-20s, #{(klass[klass.opts[:constructor]] || klass.constructor).method_name(0)}}" % name.inspect
+          end
+        end
+
+        (klass.members || []).map do |method|
+          next unless method.static?
+          next if method.name == custom_ctor
+          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)
+        all_members
+        #list = all_members.map do |member_or_group|
+        #  if 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 load_erb
+        @class_template = ::ERB.new(File.read(@template_path || File.join(File.dirname(__FILE__), 'class.cpp.erb')))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+<%= comment(@function) %>
+<%= signature(@function) %> {
+<% if @function.throws? -%>
+  try {
+<%= indent(body(@function, 'dub'), 4) %>
+  } catch (std::exception &e) {
+    lua_pushfstring(L, "<%= @function.name %>: %s", e.what());
+  } catch (...) {
+    lua_pushfstring(L, "<%= @function.name %>: Unknown exception");
+  }
+  return lua_error(L);
+<% else -%>
+<%= indent(body(@function, 'lua'), 2) %>
+<% end -%>
+}