filament 0.3.0 → 0.4.0

data/plugins/{02javame → 01java}/lib/filament/javame/tools/emulator.rb

@@ -1,5 +1,4 @@
 require 'filament/javame/tools'
-require 'filament/javame/tools/platform'
 
 module Filament::JavaME::Tools
   class << self

data/plugins/{02javame → 01java}/lib/filament/javame/tools/preverifier.rb

@@ -1,5 +1,3 @@
-require 'filament/javame/tools/platform'
-
 module Filament::JavaME::Tools
   class << self
     def preverify(*args, &block)

data/plugins/01java/lib/filament/javase/application.rb

@@ -0,0 +1,43 @@
+require 'filament/java/library'
+
+module Filament::JavaSE
+  class Application < Filament::Java::Library
+    attr_accessor2 :main_class
+    
+    def init
+      super
+      
+      on_init do
+        @should_package_deps = true
+        @prop_path = "#{output_dir}/app.properties"
+        @resources.include(@prop_path)
+      end
+      
+      on_define do
+        assert_tag :javase
+      
+        task :execute => :build do
+          execute
+        end
+
+        file @prop_path => output_dir do |t|
+          Filament::JavaME::Tools::write_properties(t.name) do |d|
+            collect_outputs(:append_entries).each do |h|
+              d.append_entries(h)
+            end
+            
+            collect_outputs(:custom_entries).each do |h|
+              d.custom_entries(h)
+            end
+          end
+        end
+      end
+    end
+    
+    def execute
+      Filament::Java::Tools::Execute.new(main_class) do |e|
+        e.jar = @library.jar_path
+      end
+    end
+  end
+end

data/plugins/01java/lib/filament/javase/tasks.rb

@@ -0,0 +1 @@
+require 'filament/javase/application'

data/plugins/01java/lib/init.rb

@@ -3,3 +3,19 @@ require 'filament/java/tools'
 require 'filament/plugins/java'
 
 Filament::Application::plugin(Filament::Plugins::Java)
+
+require 'pathname'
+
+require 'filament/os'
+
+require 'filament/javase/tasks'
+require 'filament/javame/tools'
+require 'filament/javame/tasks'
+
+include Filament::OS
+
+emulator = ENV['JAVAME_EMULATOR'] || :MppSdk
+Filament::JavaME::Tools::Emulator::set_type(emulator.to_sym)
+
+preverifier = ENV['JAVAME_PREVERIFIER'] || darwin? ? :MppSdk : :Wtk
+Filament::JavaME::Tools::Preverifier::set_type(preverifier.to_sym)

data/plugins/04spin/lib/filament/spin/sji.rb

@@ -5,32 +5,30 @@ require 'filament/spin/tasks/sji_task'
 module Filament::Spin
   class SJI < Filament::Target
     include Filament::Java::Mixins::Classpath
+    include Filament::SrcUtil
     
     attr_reader :srcs
     attr_accessor2 :java_gen_package
     
     def init
       @srcs = Filament::FileList2.new
-    end
-    
-    def define
-      @sji = Filament::Spin::Tasks::SJITask.new do |sji|
-        define_sji(sji)
-      end
-      
-      output :tag => :java, :output => @sji.java_files, :tasks => @sji.tasks
-      output :tag => :spin, :output => @sji.spin_files, :tasks => @sji.tasks
-      output :tag => :jad_proc do |d|
-        d.append_entries('spin.bindings' => @sji.bindings.collect {|binding| "#{binding.keys}: #{binding.values}"}.join(';'))
+
+      on_define do
+        unless @srcs.empty?
+          @sji = Filament::Spin::Tasks::SJITask.new do |sji|
+            sji.working_dir = working_dir
+            sji.srcs = srcs
+            sji.java_gen_package = @java_gen_package
+            sji.java_gen_dir = working_dir(:java_gen)
+            sji.spin_gen_dir = working_dir(:spin_gen)
+          end
+        
+          output :tag => :java, :output => @sji.java_files, :tasks => @sji.tasks
+          output :tag => :spin, :output => @sji.spin_files, :tasks => @sji.tasks
+          output :tag => :append_entries,
+                 :output => {'spin.bindings' => @sji.bindings.collect {|binding| "#{binding.keys}:#{binding.values}"}}
+        end
       end
     end
-    
-    def define_sji(sji)
-      sji.working_dir = working_dir
-      sji.srcs = srcs
-      sji.java_gen_package = @java_gen_package
-      sji.java_gen_dir = working_dir(:java_gen)
-      sji.spin_gen_dir = working_dir(:spin_gen)
-    end
   end
 end

data/plugins/04spin/lib/filament/spin/tasks/sji_task.rb

@@ -1,4 +1,3 @@
-require 'filament/javame/tasks/library_task'
 require 'spin/sji'
 require 'rake'
 
@@ -62,23 +61,25 @@ module Filament::Spin
         
         impls = []
         
-        @sji.prototypes.each do |prototype| 
-          impls << s = Spin::JavaMethodImpl.new(prototype)
-          s.java_impl_package = @java_gen_package
-          @bindings << { (prototype.anonymous? ? '' : prototype.name) => s.full_class_name }
+        @sji.spin_prototypes.each do |prototype| 
+          impls << prototype
+          prototype.java_impl_package = @java_gen_package
+          @bindings << { (prototype.anonymous? ? '' : prototype.spin_prototype) => prototype.full_class_name }
         end
-
-        @gen_spin_files = impls.collect{|impl| impl.spin_file(spin_gen_dir)}
-        @gen_java_files = impls.collect{|impl| impl.java_file(java_gen_dir)}
+        
+        impls += @sji.java_classes
+        
+        @gen_spin_files = impls.collect{|impl| impl.spin_file(spin_gen_dir) if impl.respond_to?(:spin_file)}
+        @gen_java_files = impls.collect{|impl| impl.java_file(java_gen_dir) if impl.respond_to?(:java_file)}
 
         directory spin_gen_dir
         @gen_spin_task = task spin_gen_dir => srcs do
-          impls.each{|impl| impl.write_spin(spin_gen_dir)}
+          impls.each{|impl| impl.write_spin(spin_gen_dir) if impl.respond_to?(:write_spin)}
         end
       
         directory java_gen_dir
         @gen_java_task = task java_gen_dir => srcs do
-          impls.each{|impl| impl.write_java(java_gen_dir)}
+          impls.each{|impl| impl.write_java(java_gen_dir) if impl.respond_to?(:write_java)}
         end
       end
     end

data/plugins/04spin/lib/spin/sji.rb

@@ -5,53 +5,161 @@ require 'fileutils'
 module Spin
   class SpinJavaInterface
     def initialize
-      @prototypes = {}
-      @anonymous_prototypes = []
+      @spin_prototypes = {}
+      @spin_anonymous_prototypes = []
+      @java_classes = []
     end
     
-    def prototypes
-      return @prototypes.values + @anonymous_prototypes
+    def spin_prototypes
+      return @spin_prototypes.values + @spin_anonymous_prototypes
     end
     
-    def prototype(name=nil, *args, &block)
+    def spin_prototype(name=nil, *args, &block)
       if name.nil?
-        @anonymous_prototypes << p = Prototype.new(name, *args)
+        @spin_anonymous_prototypes << p = Prototype.new(name, *args)
       else
-        p = @prototypes[name] ||= Prototype.new(name, *args)
+        p = @spin_prototypes[name] ||= Prototype.new(name, *args)
       end
 
       p.instance_eval(&block)
     end
     
+    def java_classes
+      return @java_classes
+    end
+    
+    def java_class(spin_name, java_name, *args, &block)
+      spin_prototype spin_name do
+         bind 'new' do
+           spin_doc "Creates a #{java_name} for the given Object."
+           java_method :constructor, :type => java_name, :params => ['ISpinObject']         
+         end
+      end
+
+      m = java_name.match(/(.*)\.([^.]*)$/)
+      raise "java name #{java_name} is not valid." if m.nil?
+      @java_classes << c = JavaType.new(m[1], m[2], *args)
+      
+      c.instance_eval(&block)
+    end
+    
     def load(path)
       instance_eval(Pathname.new(path).read, path)
     end
   end
   
-  class Prototype
-    attr_accessor2 :java_type, :java_imports
+  class JavaType
+    attr_accessor2 :implements, :extends
+    attr_reader :java_package, :java_class
+    
+    def initialize(java_package, java_class)
+      @java_package = java_package
+      @java_class = java_class
+      @implements = []
+      @extends = nil
+      @imports = []
+      @spin_bindings = []
+    end
+    
+    def import(*imports)
+      @imports += imports
+    end
+    
+    def method(*args, &block)
+      b = SpinBinding.new(*args)
+      b.instance_eval(&block)
+      @spin_bindings << b
+    end
+    
+    def verify
+    end
+    
+    def java_ancestors
+      c = ""
+      c << " extends #{@extends}" unless @extends.nil?
+      
+      @implements = [@implements] unless @implements.respond_to?(:to_ary)
+      
+      unless @implements.empty?
+        c << " implements " << @implements.join(', ')
+      end
+      
+      return c
+    end
+    
+    def java
+      rjava = ERB.new(java_template, 0, '%<>')      
+      return rjava.result(binding)      
+    end
     
-    attr_reader :java_bindings, :name, :package
+    def write_java(base)
+      FileUtils.mkdir_p(java_dir(base))
+      open(java_file(base), 'w') {|io| io.write(java)}
+    end
     
-    def initialize(name)
+    def java_dir(base)
+      verify
+      return "#{base}/#{java_package.gsub(/\./, '/')}"
+    end
+    
+    def java_file(base)
+      return "#{java_dir(base)}/#{java_class}.java"
+    end
+    
+    def java_template
+      return %q$ package <%=java_package%>;
+      
+      import com.software4i.spin.*;
+      import com.software4i.spin.object.*;
+      import com.software4i.spin.util.*;
+      <% for import in @imports %>
+      import <%=import%>;
+      <% end %>
+      
+      public class <%=java_class%> <%=java_ancestors%> {
+        private ISpinObject spinObject;
+        
+        public <%=java_class%>(ISpinObject spinObject) {
+          this.spinObject = spinObject;
+        }
+        
+        <% for spin_binding in @spin_bindings %>
+        <%=spin_binding.java_doc%>
+        <%=spin_binding.java_signature%> {
+          <%=spin_binding.java_code%>
+        }
+        <% end %>
+      }
+      $.gsub(/      /, '')
+    end
+  end
+  
+  class Prototype
+    attr_accessor2 :require_type, :java_type, :java_imports
+    attr_accessor :java_impl_package
+    attr_reader :java_bindings, :spin_prototype, :spin_package, :java_impl_class_name
+    
+    def initialize(spin_prototype)
       @@id ||= 0
       @id = @@id
       @@id += 1
       
-      if name.nil?
-        @name = "Anon#{@id}"
+      if spin_prototype.nil?
+        @spin_prototype = "Anon#{@id}"
         @anonymous = true
       else
-        @name = name
+        @spin_prototype = spin_prototype
         @anonymous = false
       end
         
-      @package = ''
+      @spin_package = ''
+      @require_type = :manual || :auto
       @java_bindings = []
       @java_imports = []
       @java_type = nil
+      @java_impl_class_name = "SJI#{@spin_prototype}"
     end
-    
+
     def java_import(*args)
       @java_imports += args
     end
@@ -61,31 +169,212 @@ module Spin
     end
     
     def bind(*args, &block)
-      b = JavaMethodBinding.new(*args)
-
+      b = JavaBinding.new(*args)
       b.java_type(@java_type) unless @java_type.nil?
-
       b.instance_eval(&block)
       @java_bindings << b
     end
+  
+    def verify
+      raise 'java_impl_class_name' if java_impl_class_name.nil?
+      raise 'java_impl_package must be set' if java_impl_package.nil?
+
+      raise 'bindings cannot be empty' if java_bindings.empty?
+
+      java_bindings.each {|b| b.verify}
+    end
+    
+    def full_class_name
+      return "#{java_impl_package}.#{java_impl_class_name}"
+    end
+    
+    def spin
+      verify
+      rspin = ERB.new(spin_template, 0, '%<>')
+      return rspin.result(binding)
+    end
+    
+    def java
+      verify
+      rjava = ERB.new(java_template, 0, '%<>')      
+      return rjava.result(binding)
+    end
+
+    def write_spin(base)
+      if require_type == :manual
+        FileUtils.mkdir_p(spin_dir(base))      
+        open(spin_file(base), 'w') {|io| io.write(spin)}
+      end
+    end
+      
+    def write_java(base)
+      FileUtils.mkdir_p(java_dir(base))
+      open(java_file(base), 'w') {|io| io.write(java)}
+    end
+    
+    def java_dir(base)
+      verify
+      return "#{base}/#{java_impl_package.gsub(/\./, '/')}"
+    end
+    
+    def spin_dir(base)
+      verify
+      return "#{base}/#{spin_package}"
+    end
+    
+    def java_file(base)
+      return "#{java_dir(base)}/#{java_impl_class_name}.java"
+    end
+    
+    def spin_file(base)
+      return "#{spin_dir(base)}/#{spin_prototype.downcase}.spin"
+    end
+    
+    def spin_template
+      return %q{ 
+        <% if require_type == :manual %>
+        bind(<%=spin_prototype%>, Object.new).eval(
+          <% for m in java_bindings %>
+          # <%=m.spin_doc%>
+          bind(<%=m.spin_binding%>, JavaMethod.new("<%=full_class_name%>", <%=m.id%>, <%=m.is_special_form ? 'true' : 'false'%>, <%=m.min_args%>, <%=m.max_args%>))
+          <% end %>
+        )
+        <% end %>
+      }.gsub(/^        /, '')
+    end
+    
+    def java_template
+      return %q{package <%= java_impl_package %>;
+
+        % for import in java_imports
+        import <%= import %>;
+        % end
+        import com.software4i.spike.util.lang.*;
+        import com.software4i.spin.*;
+        import com.software4i.spin.object.*;
+        import com.software4i.spin.interpreter.*;
+        import com.software4i.spin.java.*;
+        import com.software4i.spin.util.*;
+
+        public class <%=java_impl_class_name%> extends AbstractJavaMethodImpl implements IJavaMethodImpl {
+          public <%=java_impl_class_name%>() {
+            super("<%=java_type%>");
+          }
+          
+          public Object applyNative(
+              int id, 
+              ISpinObject targetSpinObject,
+              Object target, 
+              ISpinObject callerSpinObject,
+              Object caller, 
+              IList arguments) {
+
+            switch (id) {
+            <% for m in java_bindings %>
+            case <%= m.id %>:
+              return <%=m.java_impl_delegate%>(targetSpinObject, target, callerSpinObject, caller, arguments);
+            <% end %>
+            }
+
+            return nativeMissing(id);
+          }
+
+          <% if require_type == :auto %>
+          // name, specialForm, [MIN/MAX/EXACT], numArgs
+          public void createBindings() {
+          <% for m in java_bindings %>  createBinding(<%=m.id%>, "<%=m.spin_binding%>", <%=m.is_special_form ? 'true' : 'false'%>, <%=m.min_args%>, <%=m.max_args%>);
+          <% end %>
+          }
+          <% end %>
+
+          <% for m in java_bindings %>
+          /**
+          * Java implementation for spin binding <%=m.spin_binding%>
+          * <%=m.spin_doc%>
+          */
+          private Object <%=m.java_impl_delegate%>(ISpinObject targetSpinObject, 
+            Object target, ISpinObject callerSpinObject, Object caller, IList arguments) {
+            try {
+              <%= m.java_body %>
+            } catch(RuntimeException re) {
+              throw re;
+            } catch(Exception e) {
+              throw new BaseRuntimeException("unexpected exception in native method for <%=m.spin_binding%>", e);
+            }            
+          }
+          <% end %>
+        }
+      }.gsub(/^        /, '')
+    end
+  end
+    
+  class SpinBinding
+    attr_reader :java_method, :params, :spin_params, :return_type
+    
+    def initialize(java_method)
+      @java_method = java_method
+      @params = nil
+      @spin_params = nil
+      @return_type = 'Object'
+      @java_doc = []
+    end
+    
+    def spin_binding(spin_method, h=nil)
+      @spin_method = spin_method
+      @return_type = h[:returns]
+      @params = h[:params]
+      @spin_params = h[:spin_params]
+    end
+    
+    def java_doc(*doc)
+      if doc.empty?
+        d = "/**\n"
+        d << @java_doc.map{|jd| "* #{jd}"}.join("\n") << "\n"
+        d << "*/\n"
+        return d
+      else
+        @java_docs += doc
+      end
+    end
+    
+    def arguments
+      @params.map{|p| "#{p[0]} #{p[1]}"}
+    end
+    
+    def java_signature
+      return "public #{return_type} #{java_method}(#{arguments.join(', ')})"    
+    end
+    
+    def java_code
+      c = ""
+      c << "IList arguments = new VectorList();\n"
+      c << @spin_params.map{|arg| "arguments.append(#{arg});"}.join("\n") << "\n"
+      c << "spinObject.send(spinObject, Symbol.getSymbol(\"#{@spin_method}\"), arguments, spinObject);"
+      return c
+    end
   end
   
-  class JavaMethodBinding
-    attr_accessor2 :spin_method, :java_type, :java_method, :java_params, :java_return_type,
-                  :spin_doc, :java_code, :is_special_form
+  class JavaBinding
+    attr_accessor2 :spin_binding, :spin_params_eval, :java_type, :java_params, :java_return_type,
+                  :spin_doc, :java_code
                   
     attr_reader :id
     
-    def initialize(spin_method)
+    def initialize(spin_binding)
       @@id ||= -100
       @id = @@id
       @@id += -1
 
-      @spin_method = spin_method
+      @spin_binding = spin_binding
+      @spin_params_eval = nil
       @java_return_type = nil
+      @java_params = []
+      @java_binding = nil
+      @java_node = nil
       @spin_doc = ''
       @java_code = ''
       @is_special_form = false
+      @is_static = false
       @min_args = nil
       @max_args = nil
     end
@@ -94,6 +383,10 @@ module Spin
       @java_return_type.to_s == 'void'
     end
     
+    def is_special_form
+      return !@spin_params_eval.nil?
+    end
+    
     def java_impl_delegate
       return "sji_#{id.abs}"
     end
@@ -105,9 +398,31 @@ module Spin
     def max_args
       return @max_args || @java_params.length
     end
+    
+    def java_binding(name=nil, h=nil)
+      return @java_binding if name.nil?
+      @java_binding = name
+      h ||= {}
+      @java_type = h[:type] if h.key?(:type)
+      @java_node = h[:node] if h.key?(:node)
+      @is_static = h[:static] if h.key?(:static)
+      @java_params = h[:params] if h.key?(:params)
+      @java_return_type = h[:returns] if h.key?(:returns)
+    end
+    
+    def java_method(name=nil, h=nil)
+      h ||= {} unless name.nil?
+      h[:node] = :method unless h.nil?
+      return java_binding(name, h)
+    end
 
+    def java_member(name=nil, h=nil)
+      h ||= {} unless name.nil?
+      h[:node] = :member unless h.nil?
+      return java_binding(name, h)
+    end
     
-    def java_method_call
+    def java_arguments
       arguments = []
       
       java_params.each_with_index do |p, i| 
@@ -120,15 +435,38 @@ module Spin
            unbox = h[:unbox]
          end
          
-         arguments << "((#{cast_to}) arguments.elementAt(#{i}))#{unbox}"
+         arg = "arguments.elementAt(#{i})"
+         
+         
+         if not spin_params_eval.nil? and spin_params_eval[i] # defaults to false
+           arg = "callerSpinObject.evaluate(#{arg})"
+         end
+         
+         arguments << "((#{cast_to}) #{arg})#{unbox}"
       end
       
-      if java_method == :constructor
+      return arguments    
+    end
+    
+    def java_binding_call
+      unless @java_node == :member or @java_node == :method
+        raise "unknown java_node type: #{@java_node}"
+      end
+
+      if @java_binding == :constructor
         mc = "new #{java_type}"
       else
-        mc = "((#{java_type}) target).#{java_method}"
+        if @is_static
+          mc = "#{java_type}"
+        else
+          mc = "((#{java_type}) target)"
+        end
+        mc << ".#{java_binding}"
+      end
+
+      if @java_node == :method
+        mc << "(#{java_arguments.join(', ')})"
       end
-      mc << "(#{arguments.join(', ')})"
       
       h = JAVA_PRIMITIVES[java_return_type]
       if h.nil?
@@ -142,10 +480,10 @@ module Spin
       s = "#{java_code}\n"
       
       if void?
-        s << "#{java_method_call};"
+        s << "#{java_binding_call};"
         s << "return null;"
       else
-        s << "return #{java_method_call};"
+        s << "return #{java_binding_call};"
       end
       
       return s.gsub(/^/, '    ')
@@ -167,9 +505,9 @@ module Spin
     end
     
     def verify
-      raise 'spin_method must be set' if spin_method.nil?
+      raise 'spin_binding must be set' if spin_binding.nil?
       raise 'java_type must be set' if java_type.nil?
-      raise 'java_method must be set' if java_method.nil?
+      raise 'java_binding must be set' if java_binding.nil?
       raise 'id must be set' if id.nil?
     end
 
@@ -198,142 +536,5 @@ module Spin
   java_primitive 'byte', 'Byte', '.byteValue()', 'new Byte(%)'
   
   class JavaMethodImpl
-    attr_accessor :java_impl_class_name, :java_impl_package, 
-                  :java_type_name, :spin_package, :spin_prototype_name
-    attr_reader :methods, :java_imports
-    
-    def initialize(prototype)
-      @methods = []
-      @java_imports = []
-
-      @java_impl_class_name = "SJI#{prototype.name.capitalize}"
-
-      @java_type_name = prototype.java_type
-      @spin_package = prototype.package 
-      @spin_prototype_name = prototype.name
-  
-      @java_imports.push(*prototype.java_imports)
-  
-      prototype.java_bindings.each do |binding|
-        @methods << binding
-      end
-    end
-
-    def verify
-      raise 'java_impl_class_name' if java_impl_class_name.nil?
-      raise 'java_impl_package must be set' if java_impl_package.nil?
-
-      raise 'methods cannot be empty' if methods.empty?
-
-      methods.each {|method| method.verify}
-    end
-    
-    def full_class_name
-      return "#{java_impl_package}.#{java_impl_class_name}"
-    end
-    
-    def spin
-      verify
-      rspin = ERB.new(spin_template, 0, '%<>')
-      return rspin.result(binding)
-    end
-    
-    def java
-      verify
-      rjava = ERB.new(java_template, 0, '%<>')      
-      return rjava.result(binding)
-    end
-
-    def write_spin(base)
-      FileUtils.mkdir_p(spin_dir(base))
-      
-      open(spin_file(base), 'w') {|io| io.write(spin)}
-    end
-      
-    def write_java(base)
-      FileUtils.mkdir_p(java_dir(base))
-      
-      open(java_file(base), 'w') {|io| io.write(java)}
-    end
-    
-    def java_dir(base)
-      verify
-      return "#{base}/#{java_impl_package.gsub(/\./, '/')}"
-    end
-    
-    def spin_dir(base)
-      verify
-      return "#{base}/#{spin_package}"
-    end
-    
-    def java_file(base)
-      return "#{java_dir(base)}/#{java_impl_class_name}.java"
-    end
-    
-    def spin_file(base)
-      return "#{spin_dir(base)}/#{spin_prototype_name.downcase}.spin"
-    end
-    
-    def spin_template
-      return %q{
-        % for method in methods
-        # <%=method.spin_doc%>
-
-        % end
-      }.gsub(/^        /, '')
-    end
-    
-    def java_template
-      return %q{package <%= java_impl_package %>;
-
-        % for import in java_imports
-        import <%= import %>;
-        % end
-        import com.software4i.spin.object.ISpinObject;
-        import com.software4i.spin.interpreter.ISpinObjectManager;
-        import com.software4i.spin.interpreter.Interpreter;
-        import com.software4i.spin.java.AbstractJavaMethodImpl;
-        import com.software4i.spin.java.IJavaMethodImpl;
-        import com.software4i.spin.util.IList;
-
-        public class <%=java_impl_class_name%> extends AbstractJavaMethodImpl implements IJavaMethodImpl {
-          public <%=java_impl_class_name%>() {
-            super("<%=java_type_name%>");
-          }
-          
-          public Object applyNative(
-              Object target, 
-              int id, 
-              Interpreter interpreter,
-              Object caller, 
-              IList arguments) {
-
-            ISpinObjectManager manager = interpreter.getSpinObjectManager(); 
-            ISpinObject spinObject = manager.spinObjectFor(target);
-
-            switch (id) {
-            <% for m in methods %>
-            case <%= m.id %>:
-              return <%=m.java_impl_delegate%>(interpreter, target, caller, arguments);
-            <% end %>
-            }
-
-            return nativeMissing(id);
-          }
-
-          // name, specialForm, [MIN/MAX/EXACT], numArgs
-          public void createMethods() {
-          <% for m in methods %>  createMethod(<%=m.id%>, "<%=m.spin_method%>", <%=m.is_special_form ? 'true' : 'false'%>, <%=m.min_args%>, <%=m.max_args%>);
-          <% end %>
-          }
-
-          <% for m in methods %>
-          private Object <%=m.java_impl_delegate%>(Interpreter interpreter, Object target, Object caller, IList arguments) {
-            <%= m.java_body %>
-          }
-          <% end %>
-        }
-      }.gsub(/^        /, '')
-    end
   end
 end