rubber-generate 0.0.5

data/README.md

@@ -0,0 +1,58 @@
+Rubber C Binder v0.0.5
+Template language for generating Ruby bindings for C libraries
+by Geoff Youngs <g@intersect-uk.co.uk>
+
+Introduction
+~~~~~~~~~~~~
+A simple ruby-style bindings generator for Ruby.  It allows bindings to 
+be laid out in a Ruby style, documentation to be included inline and 
+explicit type casts within C code.  It's somewhere between SWIG and pyrex.
+
+It also allows features extconf.rb creation, including checks for headers,
+pkg-config etc.  The modules it creates currently depend on Ruby/GTK, but
+it is planned to remove this dependency unless they genuinely require Ruby/GTK.
+
+Other features include custom named type-maps, pre/post code inclusion within
+functions and some rudimentary understanding of C code.
+
+
+Dependencies
+~~~~~~~~~~~~
+Ruby 1.8
+  Doesn't require any modules which aren't in the Ruby 1.8.0 distribution.
+Ruby 1.6
+  Has not been tested.  Requires at least the StringScanner (C version) and
+  StringIO modules. (See raa.ruby-lang.org for 'strscan' and 'stringio')
+
+
+Example
+~~~~~~~
+Sample file:
+  vte/vte.cr
+
+Usage:
+  $ ruby rubber.rb vte.cr
+
+Which should generate
+  vte.c      <- Source code for extension
+  vte.rd     <- RD documentation from vte.cr
+  extconf.rb <- Config script
+
+Running extconf.rb should then allow installation of the extension as normal.
+
+
+Installation
+~~~~~~~~~~~~
+There is currently no installation.  Rubber will automatically look for it's
+libraries in the normal path or in the directory where the 'real' rubber script
+resides.  (So the rubber.rb can be symlinked from where you unpacked it to
+a directory in your path).
+
+When rubber matures then it will come with a proper install.rb setup.
+
+
+Credits
+~~~~~~~
+Rubber was created by Geoff Youngs
+
+Contributors: Vincent Isambart

data/bin/rubber-generate

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+if FileTest.symlink?(__FILE__)
+  file = File::readlink(__FILE__)
+else
+  file = __FILE__
+end
+
+require 'rbconfig'
+require 'ftools'
+
+dir = File::dirname(file)
+$:.unshift(dir)
+#puts dir
+require 'strscan'
+#require 'rubygems'
+#require_gem 'rubber'
+require 'rubber/codegen'
+require 'rubber/mkextconf'
+require 'rubber/scanner'
+require 'rubber/types'
+require 'rubber/autord'
+
+
+args = ARGV.select { |i| i[0] != ?- }
+switches = ARGV.select { |i| i[0] == ?- }
+(args.size > 0 && args || Dir.glob('*.cr')).each { |file|
+
+  file = File.expand_path(file)
+  File.mkpath(Config::CONFIG['sitearch'])
+  Dir.chdir(Config::CONFIG['sitearch']) do
+
+	  
+	  scanner = Rubber::CRScanner.new(file)
+	  scanner.scan(nil)
+	 
+	  out = File.open(scanner.ext + ".c", 'w')
+	  doc = File.open(scanner.ext + ".rd", 'w')
+	  
+	  extconf = File.open('extconf.rb', 'w')
+	  Rubber.generate_extconf(scanner, extconf)
+	  Rubber.generate_c_source(scanner, out)
+	  Rubber.generate_rd(scanner, doc)
+	  
+	  
+	  doc.close
+	  out.close
+	  extconf.close
+	  
+	  system('ruby','extconf.rb') if switches.include?('--configure')
+	  system('make') if switches.include?("--build")
+  end
+}
+#out.close

data/lib/rubber/autord.rb

@@ -0,0 +1,10 @@
+module Rubber
+  def self.generate_rd(scanner, io)
+    if scanner.doc
+      io.write(scanner.doc + "\n\n")
+    end
+    scanner.stack.first.classes.each { |c|
+      c.doc_rd(io)
+    }
+  end
+end

data/lib/rubber/codegen.rb

@@ -0,0 +1,131 @@
+require 'rubber/struct'
+module Rubber
+def generate_c_source(scanner, io)
+  mod = scanner.stack.first # Pseudo root module for file
+  if scanner.options.gnu
+  	io.puts "#define _GNU_SOURCE 1"
+  end
+  io.puts "/* Includes */"
+  io.puts "#include <ruby.h>"
+  io.puts "#include <stdlib.h>"
+  io.puts "#include <stdio.h>"
+  io.puts "#include <string.h>"
+  if scanner.incs
+    scanner.incs.each { |i| io.puts "#include #{i.inspect}"}
+  end
+  io.puts "\n/* Setup types */"
+  io.puts "/* Try not to clash with other definitions of bool... */"
+  io.puts "typedef int rubber_bool;"
+  io.puts "#define bool rubber_bool"
+  io.puts "\n/* Prototypes */"
+  io.puts '#include "rbglib.h"' if scanner.options.glib?
+  
+if scanner.options.glib? and scanner.options.gtk?
+  io.write <<-EOI
+#include "rbgtk.h"
+
+#if defined(G_PLATFORM_WIN32) && !defined(RUBY_GTK2_STATIC_COMPILATION)
+#  ifdef RUBY_GTK2_COMPILATION
+#    define RUBY_GTK2_VAR __declspec(dllexport)
+#  else
+#    define RUBY_GTK2_VAR extern __declspec(dllimport)
+#  endif
+#else
+#  define RUBY_GTK2_VAR extern
+#endif
+
+RUBY_GTK2_VAR VALUE mGtk;
+RUBY_GTK2_VAR VALUE mGdk;
+
+#define RBGTK_INITIALIZE(obj,gtkobj)\
+ (rbgtk_initialize_gtkobject(obj, GTK_OBJECT(gtkobj)))
+EOI
+end
+
+
+  mod.classes.each { |c|
+    c.declare(io)
+  }
+  if scanner.raw
+    io.puts("\n/* Inline C code */")
+    io.write(scanner.raw)
+  end
+  io.puts "\n/* Code */"
+  mod.classes.each { |c|
+    c.code(io)
+  }
+  io.puts "/* Init */"
+  io.puts "void"
+  io.puts "Init_#{scanner.ext}(void)"
+  io.puts "{"
+  io.puts scanner.pre_init_code if scanner.pre_init_code
+    mod.classes.each { |c|
+      c.register(io)
+    }
+  io.puts scanner.post_init_code if scanner.post_init_code
+  io.puts "}"
+  
+end
+module_function :generate_c_source
+
+module RegisterChildren
+	attr_reader :child_names
+	def register_children(io)
+	    @child_names = {}
+	    contents.each { |f| 
+    		f.register(io, @child_names.has_key?(f.name)) 
+		if @child_names.has_key?(f.name)
+			puts "#{self.cname} has duplicate definitiion of #{f.name}"
+		else
+    		@child_names[f.name]= f 
+		end
+	    }
+	    if respond_to?(:register_aliases)
+	    	register_aliases(io)
+	    end
+	end
+	def cname
+		if parent && parent.child_names && parent.child_names[name] && parent.child_names[name] != self
+			parent.child_names[name].cname 
+		else
+			default_cname()
+		end
+	end
+end
+
+
+class C_RootModule
+  define_members({:classes => []}, {:methods => []}, {:functions => []}, {:constants => []}, {:includes => []})
+  attr_reader :child_names
+  def cname
+  	p "RootModule cName req'd.", caller
+  	nil
+  end
+end
+
+require 'rubber/codegen/module'
+require 'rubber/codegen/class'
+require 'rubber/codegen/param'
+require 'rubber/codegen/function'
+
+# Constants
+require 'rubber/codegen/string'
+require 'rubber/codegen/integer'
+require 'rubber/codegen/float'
+
+# Special
+require 'rubber/codegen/struct'
+require 'rubber/codegen/enum'
+require 'rubber/codegen/flags'
+# needs int derivative
+require 'rubber/codegen/genum'
+require 'rubber/codegen/gflags'
+require 'rubber/codegen/gboxed'
+require 'rubber/codegen/ginterface'
+require 'rubber/codegen/gobject'
+
+# Utils
+require 'rubber/codegen/gcrefpool'
+
+
+end # m Rubber

data/lib/rubber/codegen/class.rb

@@ -0,0 +1,79 @@
+require 'rubber/codegen/module'
+
+module Rubber
+
+class C_Class < C_Module
+  define_members :name, :superclass, :methods, :functions, :constants, :ctype, {:classes => []}, :includes, :parent
+  attr_accessor :pre_func, :post_func, :doc, :pre_only, :pre_except, :post_only, :post_except
+  attr_reader :child_names
+
+  def fullname()
+    if parent and parent.respond_to?(:fullname)
+      "#{parent.fullname}::#{name}"
+    else
+      name
+    end
+  end
+  def doc_rd(io)
+    id = fullname()
+    id += " < #{superclass}" if superclass
+    depth = (fullname.gsub(/[^:]/,'').size >> 1)
+    io.puts "=#{'=' * depth} class #{id}"
+    io.puts @doc if @doc
+    contents.each { |f| f.doc_rd(io) }
+  end
+  def get_root(); is_root? ? self : parent.get_root; end
+  def is_root?()
+    not parent.respond_to?(:fullname)
+  end
+  def code(io)
+    contents .each { |f| f.code(io) }
+  end
+  def declare(io)
+    io.puts "static VALUE #{cname};";
+    contents .each { |f| f.declare(io) }
+  end
+  def register(io, already_defined=false)
+    if parent.child_names && parent.child_names[name]
+      	io.puts "  c#{name} = #{cname};"
+    else
+	    if parent and parent.cname
+	      io.puts "  #{cname} = rb_define_class_under(#{parent.cname}, #{name.inspect}, #{Rubber::find_class(superclass) || 'rb_cObject'});"
+	    else
+	      io.puts "  #{cname} = rb_define_class(#{name.inspect}, #{Rubber::find_class(superclass) || 'rb_cObject'});"
+	    end
+    end
+    register_children(io)
+  end
+  include RegisterChildren
+  def default_cname
+    "c"+name
+  end
+  def check_wrap_ok(io, fn, where)
+    case where
+    when :pre
+	  code   = @pre_func
+	  only   = @pre_only
+	  except = @pre_except
+	when :post
+	  code   = @post_func
+	  only   = @post_only
+	  except = @post_except
+	end
+	if code && ! fn.singleton
+		return if only && ! only.empty? && ! only.include?(fn.name)
+		return if except && except.include?(fn.name)
+		io.puts code
+	end
+  end
+  def pre_func(io, func)
+    #io.puts @pre_func unless @pre_func.nil? or func.singleton
+	check_wrap_ok(io, func, :pre)
+  end
+  def post_func(io, func)
+    #io.puts @post_func unless @post_func.nil? or func.singleton
+	check_wrap_ok(io, func, :post)
+  end
+end
+
+end # Rubber

data/lib/rubber/codegen/enum.rb

@@ -0,0 +1,231 @@
+module Rubber
+
+class C_Enum
+  define_members :name, :args, :parent
+  attr_reader :child_names
+  @@declared_base = false
+  @@declared_register = false
+  def init()
+    ($custom_maps[name] ||= {})["VALUE"] = "enum_#{name}_to_ruby((%%))"
+    ($custom_maps["VALUE"] ||= {})[name] = "enum_ruby_to_#{name}((%%))"
+    STDERR.puts "Auto-adding custom map for #{name}"
+    @splits = strip_prefixes(args)
+    @strip = args.first.length - @splits.first.length
+  end
+  def code(io)
+  end
+  def declare(io)
+    io.puts "static VALUE #{cname};"
+    unless @@declared_base
+    	@@declared_base = true
+    	io.puts "
+
+static VALUE enumBaseClass;
+
+typedef struct {
+	int value;
+	char *name;
+	char *fullname;
+} EnumData;
+
+static VALUE make_enum_value(VALUE klass, int value, char *name, char *fullname)
+{
+	EnumData *data = NULL;
+	
+	data = ALLOC(EnumData);
+	data->value = value;
+	data->name = name;
+	data->fullname = fullname;
+	
+	return Data_Wrap_Struct(klass, NULL, free, data);
+}
+static int value_to_int(VALUE value, VALUE klass)
+{
+	switch (TYPE(value))
+	{
+	case T_FIXNUM:
+	case T_FLOAT:
+		return NUM2INT(value);
+	break;
+	case T_DATA:
+		if (rb_obj_is_kind_of(value, enumBaseClass))
+		{
+			EnumData *data = NULL;
+			
+			if ((klass != Qnil) && (!rb_obj_is_kind_of(value, klass)))
+			{
+				rb_raise(rb_eTypeError, \"Wrong type of enum  %s (%s required)\", rb_obj_classname(value), rb_class2name(klass));
+			}
+			
+			Data_Get_Struct(value, EnumData, data);
+			return data->value;
+		}
+	break;
+	}
+	return 0;
+	
+}
+
+static VALUE rubber_enum_inspect(VALUE value)
+{
+	EnumData *data = NULL;
+	volatile VALUE str = rb_str_new(\"#<\", 2);
+	char number[16] = \"\"; 
+	
+	Data_Get_Struct(value, EnumData, data);
+	
+	rb_str_cat2(str, rb_obj_classname(value));
+	rb_str_cat2(str, \" - \");
+	rb_str_cat2(str, data->name);
+	rb_str_cat2(str, \"(\");
+	sprintf(number, \"%i\", data->value);
+	rb_str_cat2(str, number);
+	rb_str_cat2(str, \")>\");
+	
+	return str;
+}
+
+static VALUE rubber_enum_to_s(VALUE value)
+{
+	EnumData *data = NULL;
+	
+	Data_Get_Struct(value, EnumData, data);
+	
+	return rb_str_new2(data->fullname);
+}
+static VALUE rubber_enum_name(VALUE value)
+{
+	EnumData *data = NULL;
+	
+	Data_Get_Struct(value, EnumData, data);
+	
+	return rb_str_new2(data->name);
+}
+
+static VALUE rubber_enum_cmp(VALUE value, VALUE other)
+{
+	VALUE a,b;
+	a = rb_funcall(value, rb_intern(\"to_i\"), 0);
+	b = rb_funcall(other, rb_intern(\"to_i\"), 0);
+	return rb_num_coerce_cmp(a, b);
+}
+
+static VALUE rubber_enum_to_i(VALUE value)
+{
+	EnumData *data = NULL;
+	
+	Data_Get_Struct(value, EnumData, data);
+	
+	return INT2FIX(data->value);
+}
+
+static VALUE rubber_enum_coerce(VALUE value, VALUE other)
+{
+	EnumData *data = NULL;
+	
+	Data_Get_Struct(value, EnumData, data);
+	
+	switch(TYPE(other))
+	{
+	case T_FIXNUM:
+	case T_BIGNUM:
+		return INT2FIX(data->value);
+	case T_FLOAT:
+		return rb_float_new(data->value);
+	default:
+		return Qnil;
+	}
+}
+
+"
+    end
+    args.each do |arg|
+      io.puts "static VALUE #{default_cname}_#{arg} = Qnil;"
+    end    
+    io.puts "typedef int #{name};
+#ifdef __GNUC__
+// No point in declaring these unless we're using GCC
+// They're ahead of any code that uses them anyway.
+static VALUE enum_#{name}_to_ruby(int value)
+__attribute__ ((unused))
+;
+static int enum_ruby_to_#{name}(VALUE val)
+__attribute__ ((unused))
+;
+#endif
+
+"
+    io.puts "static VALUE enum_#{name}_to_ruby(int value) { switch(value) {"
+    args.each do |arg|
+      io.puts "    case #{arg}: return #{default_cname}_#{arg};"
+    end    
+    io.puts "}; return Qnil; }"
+    io.puts "static int enum_ruby_to_#{name}(VALUE val) { return value_to_int(val, #{cname}); }"
+  end
+  include RegisterChildren
+  def default_cname
+    "enum"+name
+  end
+  def doc_rd(io)
+    depth = (fullname.gsub(/[^:]/,'').size >> 1)
+    io.puts "=#{'=' * depth} enum #{fullname}"
+  end
+  def get_root(); is_root? ? self : parent.get_root; end; def is_root?()
+    not parent.respond_to?(:fullname)
+  end
+  def fullname()
+    if parent and parent.respond_to?(:fullname)
+      "#{parent.fullname}::#{name}"
+    else
+      name
+    end
+  end
+  def same_prefix(arr)
+    for i in arr
+      return false if arr.first.first != i.first
+    end
+    return true
+  end
+  def strip_prefixes(arr)
+    splits = arr.collect { |i| i.strip.split(/_/) }
+    while (same_prefix(splits))
+      splits.each { |i| i.shift }
+    end
+    splits.collect!{|i| i.join('_') }
+    splits
+  end
+  def get_root(); is_root? ? self : parent.get_root; end; 
+  def is_root?()
+    not parent.respond_to?(:fullname)
+  end
+  def register(io, already_defined=false)
+    unless @@declared_register
+    	@@declared_register = true
+      io.puts "  enumBaseClass = rb_define_class(\"Enum\", rb_cObject);"
+      io.puts '    rb_define_method(enumBaseClass, "inspect", rubber_enum_inspect, 0);'
+      io.puts '    rb_define_method(enumBaseClass, "to_i", rubber_enum_to_i, 0);'
+      io.puts '    rb_define_method(enumBaseClass, "coerce", rubber_enum_coerce, 1);'
+      io.puts '    rb_define_method(enumBaseClass, "to_s", rubber_enum_to_s, 0);'
+      io.puts '    rb_define_method(enumBaseClass, "to_str", rubber_enum_to_s, 0);'
+      io.puts '    rb_define_method(enumBaseClass, "fullname", rubber_enum_to_s, 0);'
+      io.puts '    rb_define_method(enumBaseClass, "name", rubber_enum_name, 0);'
+      io.puts '    rb_define_method(enumBaseClass, "<=>", rubber_enum_cmp, 0);'
+      io.puts '    '
+    end
+    if parent
+      io.puts "  #{cname} = rb_define_class_under(#{parent.cname}, #{name.inspect}, enumBaseClass);"
+    else
+      io.puts "  #{cname} = rb_define_class(#{name.inspect}, enumBaseClass);"
+    end
+    
+    args.each do |arg|
+      uniq = arg[@strip..-1]
+      uniq.sub!(/\A[^a-zA-Z]/,'')
+      io.puts "    #{default_cname}_#{arg} = make_enum_value(#{cname}, #{arg}, #{uniq.downcase.gsub(/_/,'-').inspect}, #{arg.inspect});"
+      io.puts "    rb_obj_freeze(#{default_cname}_#{arg});"
+      io.puts "    rb_define_const(#{cname}, #{uniq.upcase.inspect}, #{default_cname}_#{arg});"
+    end
+  end
+end
+
+end # Rubber