rubylisp 0.2.1 → 1.0.2

data/lib/rubylisp/environment_frame.rb

@@ -2,31 +2,50 @@ module Lisp
 
   class EnvironmentFrame
 
-    attr_accessor :frame, :current_code, :previous
+    attr_accessor :frame, :current_code, :previous, :name
+    attr_reader :parent, :project_environment
     
     def self.global
-      @@global_frame ||= EnvironmentFrame.new(nil)
+      @@global_frame ||= EnvironmentFrame.new(nil, "GLOBAL")
       @@global_frame
     end
 
-    def self.extending(parent, f=nil)
+    def self.extending(parent, name, f=nil)
       f ||= parent.frame if parent && parent.has_frame?
-      self.new(parent, f)
+      e = self.new(parent, name, f)
+      TopLevelEnvironments[name] = e if parent.nil? || parent == self.global
+      e
     end
 
-    def initialize(parent, f=nil)
+    def initialize(parent, name, f=nil)
       @bindings = []
       @parent = parent
+      @name = name
       @frame = f
       @current_code = []
     end
 
+
+    def clear
+      TopLevelEnvironments[@name] = nil if TopLevelEnvironments.has_key?(@name)
+      @bindings.each {|b| b.value = nil}
+    end
+    
+
     def has_frame?
       !@frame.nil?
     end
     
     # Bindings following parent env frame pointer
 
+    def bound_names
+      @bindings.map {|b| b.symbol}
+    end
+
+    def bound_values
+      @bindings.map {|b| b.value}
+    end
+
     def is_name_bound?(str)
       if !@frame && @frame.has_slot?(Lisp:Symbol.named("#{str}:", true))
         return true
@@ -38,6 +57,11 @@ module Lisp
       return @parent.is_name_bound?(str)
     end
 
+    def name_bound_locally?(str)
+      binding = @bindings.detect {|b| b.symbol.name == str}
+      !binding.nil?
+    end
+
     def binding_for(symbol)
       binding = @bindings.detect {|b| b.symbol.name == symbol.name}
       return binding unless binding.nil?
@@ -152,8 +176,9 @@ module Lisp
         1 + @previous.depth
       end
     end
-    
+
   end
 
+  TopLevelEnvironments = {}
 
 end

data/lib/rubylisp/eof_object.rb

@@ -0,0 +1,26 @@
+module Lisp
+
+  class EofObject < Atom
+
+    def self.instance
+      @instance ||= self.new()
+    end
+
+    def initialize()
+    end
+
+    def type
+      :eof_object
+    end
+
+    def eof_object?
+      true
+    end
+
+    def to_s
+      "<EOF>"
+    end
+
+  end
+
+end

data/lib/rubylisp/exception.rb

@@ -3,81 +3,81 @@ module Lisp
   class Exception
 
     def self.register
-      Primitive.register("raise")     {|args, env| Lisp::Exception::raise_impl(args, env) }
-      Primitive.register("reraise")   {|args, env| Lisp::Exception::reraise_impl(args, env) }
-      Primitive.register("try")       {|args, env| Lisp::Exception::try_impl(args, env) }
-      Primitive.register("reraise")   {|args, env| Lisp::Exception::reraise_impl(args, env) }
-      Primitive.register("resume")    {|args, env| Lisp::Exception::resume_impl(args, env) }
-      Primitive.register("restart")   {|args, env| Lisp::Exception::restart_impl(args, env) }
+      # Primitive.register("raise")     {|args, env| Lisp::Exception::raise_impl(args, env) }
+      # Primitive.register("reraise")   {|args, env| Lisp::Exception::reraise_impl(args, env) }
+      # Primitive.register("try")       {|args, env| Lisp::Exception::try_impl(args, env) }
+      # Primitive.register("reraise")   {|args, env| Lisp::Exception::reraise_impl(args, env) }
+      # Primitive.register("resume")    {|args, env| Lisp::Exception::resume_impl(args, env) }
+      # Primitive.register("restart")   {|args, env| Lisp::Exception::restart_impl(args, env) }
     end
 
 
-    def handler_or_nil(handlers, exception_name)
-      handlers.each do |handler_pair|
-        exceptions = handler_pair.car
-        if exceptions.eq(exception_name) || (exceptions.pair? && exceptions.include?(exception_name))
-          handler_pair.cdr
-        else
-          nil
-        end
-      end
-    end
-
-    def self.do_exception(name, with_message, args, env)
-      frame = env
-      while !frame.nil?
-        handlers = frame.value_of(Symbol.named("__handlers__"))
-        unless handlers.nil?
-          handler = handler_or_nil(handlers, for: name)
-          unless handler.nil?
-            handler.apply_to_without_evaluating(args, frame)
-            break
-          end
-        end
-        frame = frame.parent
-        if frame.nil?
-          exception_message = message.empty? ? "" : ": #{message}"
-          return Lisp::Debug.process_error("Unhandled Exception: #{exception_name}#{exception_message}", env)
-        end
-      end
-    end
+    # def handler_or_nil(handlers, exception_name)
+    #   handlers.each do |handler_pair|
+    #     exceptions = handler_pair.car
+    #     if exceptions.eq(exception_name) || (exceptions.pair? && exceptions.include?(exception_name))
+    #       handler_pair.cdr
+    #     else
+    #       nil
+    #     end
+    #   end
+    # end
+
+    # def self.do_exception(name, with_message, args, env)
+    #   frame = env
+    #   while !frame.nil?
+    #     handlers = frame.value_of(Symbol.named("__handlers__"))
+    #     unless handlers.nil?
+    #       handler = handler_or_nil(handlers, for: name)
+    #       unless handler.nil?
+    #         handler.apply_to_without_evaluating(args, frame)
+    #         break
+    #       end
+    #     end
+    #     frame = frame.parent
+    #     if frame.nil?
+    #       exception_message = message.empty? ? "" : ": #{message}"
+    #       return Lisp::Debug.process_error("Unhandled Exception: #{exception_name}#{exception_message}", env)
+    #     end
+    #   end
+    # end
     
     def self.raise_impl(args, env)
-      return Lisp::Debug.process_error("'raise' requires at least one argument.", env) unless args.length > 0
-      exception_name = args.car.evaluate(env)
-      return Lisp::Debug.process_error("'raise' requires an exception name as it's first argument.", env) unless exception_name.string? || class_name.symbol?
+      # return Lisp::Debug.process_error("'raise' requires at least one argument.", env) unless args.length > 0
+      # exception_name = args.car.evaluate(env)
+      # return Lisp::Debug.process_error("'raise' requires an exception name as it's first argument.", env) unless exception_name.string? || class_name.symbol?
 
-      message = ""
-      if args.length > 1
-        message = args.cadr.evaluate(env)
-        return Lisp::Debug.process_error("The message parameter to 'raise' must be a string.", env) unless message.string?
-      end
+      # message = ""
+      # if args.length > 1
+      #   message = args.cadr.evaluate(env)
+      #   return Lisp::Debug.process_error("The message parameter to 'raise' must be a string.", env) unless message.string?
+      # end
 
-      handler_args = args.length > 2 ? Lisp::ConsCell.array_to_list(args.cdr.to_a.collect {|a| a.evaluate(env)}) : Lisp::ConsCell.new
+      # handler_args = args.length > 2 ? Lisp::ConsCell.array_to_list(args.cdr.to_a.collect {|a| a.evaluate(env)}) : Lisp::ConsCell.new
     end
   
 
     def self.try_impl(args, env)
-      raw_handlers = args.car
-      body = args.cdr
+      # raw_handlers = args.car
+      # body = args.cdr
       
-      return Lisp::Debug.process_error("Exception handlers must be a list.", env) unless raw_handlers.list?
-      return Lisp::Debug.process_error("Exception handlers must be a list of pairs.", env) unless raw_handlers.all? {|h| h.list?}
-      return Lisp::Debug.process_error("Exception clause must be a symbol/string or a list of symbol/string.", env) unless raw_handlers.all? do |h|
-        ex = h.car
-        ex.symbol? || ex.string? || (ex.list? && ex.all? {|h2| h2.symbol? || h2.string?})
-      end
+      # return Lisp::Debug.process_error("Exception handlers must be a list.", env) unless raw_handlers.list?
+      # return Lisp::Debug.process_error("Exception handlers must be a list of pairs.", env) unless raw_handlers.all? {|h| h.list?}
+      # return Lisp::Debug.process_error("Exception clause must be a symbol/string or a list of symbol/string.", env) unless raw_handlers.all? do |h|
+      #   ex = h.car
+      #   ex.symbol? || ex.string? || (ex.list? && ex.all? {|h2| h2.symbol? || h2.string?})
+      # end
       
-      array_of_handlers = raw_handlers.to_a.collect do |h|
-        ex = h.car
-        f = h.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Exception handler has to be a function.", env) unless f.function?
-        Lisp::ConsCell.cons(ex, f)
-      end
-      handlers = Lisp::ConsCell.array_to_list(array_of_handlers)
-      env.bind_locally(Symbol.named("__handlers__"), handlers)
+      # array_of_handlers = raw_handlers.to_a.collect do |h|
+      #   ex = h.car
+      #   f = h.cadr.evaluate(env)
+      # return Lisp::Debug.process_error("Exception handler has to be a function.", env) unless f.function?
+      #   Lisp::ConsCell.cons(ex, f)
+      # end
+      # handlers = Lisp::ConsCell.array_to_list(array_of_handlers)
+      # env.bind_locally(Symbol.named("__handlers__"), handlers)
       
-      body.evaluate_each(env)
+      # body.evaluate_each(env)
     end
 
 

data/lib/rubylisp/ext.rb

@@ -5,15 +5,29 @@ class NilClass
   end
   
   def false?
-    true
+    false
   end
 
   def to_s
     "()"
   end
 
+  
+  def to_ary
+    []
+  end
+
+  
+  def eqv?(other)
+    other.nil? || (other.pair? && other.empty?)
+  end
+  
   def eq?(other)
-    other.nil?
+    other.nil? || (other.pair? && other.empty?)
+  end
+  
+  def equal?(other)
+    other.nil? || (other.pair? && other.empty?)
   end
   
   def print_string
@@ -84,14 +98,25 @@ class NilClass
     true
   end
   
+  def vector?
+    false
+  end
+  
+  def environment?
+    false
+  end
+  
   def method_missing(name, *args, &block)
-    if name[0] == ?c && name[-1] == ?r && (name[1..-2].chars.all? {|e| "ad".include?(e)})
+    is_list_walk = name[0] == ?c && name[-1] == ?r && (name[1..-2].chars.all? {|e| "ad".include?(e)})
+    if is_list_walk
       nil
     else
+      #puts "nil#method_missing name: #{name} args #{args}"
+      #puts caller
       super
     end
   end
-
+  
   def primitive?
     false
   end
@@ -112,8 +137,9 @@ class NilClass
     true
   end
     
-
-  
+  def flatten
+    nil
+  end  
 end
 
 

data/lib/rubylisp/ffi_new.rb

@@ -4,14 +4,15 @@ module Lisp
 
     def initialize(name)
       @value = name
-      @klass = Object.const_get(name)
     end
 
     def apply_to(args, env)
+      @klass = Object.const_get(@value)
       NativeObject.with_value(@klass.new)
     end
 
     def apply_to_without_evaluating(args, env)
+      @klass = Object.const_get(@value)
       NativeObject.with_value(@klass.new)
     end
 

data/lib/rubylisp/ffi_send.rb

@@ -10,7 +10,9 @@ module Lisp
       apply_to_without_evaluating(Lisp::ConsCell.array_to_list(args.to_a.map {|a| a.evaluate(env)}), env)
     end
 
+    # convert a rubymotion arg to a lisp arg
     def convert_value(value)
+      #puts "convert_value(#{value.to_s})\n"
       case value.class.name
       when "Fixnum", "Float"
         Lisp::Number.with_value(value)
@@ -30,11 +32,17 @@ module Lisp
     end
 
 
+    # convert a lisp arg to a rubymotion arg
     def process_arg(a, env)
+      #puts "process_arg(#{a.to_s})"
       if a.function?
-        proc do |*args|
-          arg_list = args.empty? ? nil : Lisp::ConsCell.array_to_list(args.collect {|arg| convert_value(arg) })
-          a.apply_to(arg_list, env)
+        #puts "function arg"
+        proc do #|*args|
+          #puts "Proc argument invoked"
+          # arg_list = args.empty? ? nil : Lisp::ConsCell.array_to_list(args.collect {|arg| convert_value(arg) })
+          # puts "Applying #{@a.to_s} to #{arg_list}"
+         
+          a.apply_to(nil, env)
         end
       elsif a.list?
         a.to_a.map {|i| process_arg(i, env)}
@@ -49,6 +57,8 @@ module Lisp
       return Lisp::Debug.process_error("Send target of '#{@value}' evaluated to nil.", env) if target.nil?
       return Lisp::Debug.process_error("Target of an FFI send of '#{@value}' must be a wrapped ObjC object, was #{target}", env) unless target.object?
 
+      # puts "Sending #{@value} to #{target.to_s} with raw args #{args}"
+
       arguments = args.cdr.nil? ? [] : args.cdr.to_a.map {|a| process_arg(a, env)}      
       result = nil
       
@@ -56,11 +66,11 @@ module Lisp
         result = if arguments[-1].instance_of?(Proc)
                    target.value.send(@value, *(arguments[0..-2]), &arguments[-1])
                  else
-#                   puts "Sending #{@value} with #{arguments}"
+                   # puts "Sending #{@value} to #{target} with processed args #{arguments}"
                    target.value.send(@value, *arguments)
                  end
       rescue Exception => e
-        return Lisp::Debug.process_error("Exception sending #{@value}: #{e}", env)
+        return Lisp::Debug.process_error("Exception sending #{@value} - #{e.name}", env)
       end
 
       convert_value(result)

data/lib/rubylisp/frame.rb

@@ -2,172 +2,13 @@ module Lisp
 
   class Frame < Atom
 
-    def self.register
-      Primitive.register("make-frame", "(make-frame slot-name slot-value ... )\n\nFrames can be created using the make-frame function, passing it an alternating sequence of slot names and values:\n\n        (make-frame a: 1 b: 2)\n\nThis results in a frame with two slots, named a: and b: with values 1 and 2, respectively.") do |args, env|
-        Lisp::Frame::make_frame_impl(args, env)
-      end
-      
-      Primitive.register("has-slot?", "(has-slot? frame slot-name)\n\nThe has-slot? function is used to query whether a frame contains (directly or in an ancestor) the particular slot.") do |args, env|
-        Lisp::Frame::has_slot_impl(args, env)
-      end
-      
-      Primitive.register("get-slot", "(get-slot _frame_ _slot-name_)\n\nThe get-slot function is used to retrieve values from frame slots") do |args, env|
-        Lisp::Frame::get_slot_impl(args, env)
-      end
-      
-      Primitive.register("get-slot-if", "(get-slot-if frame slot-name)\n\nThe same as above, except that if a matching slot is not found, nil is returned instead of raising an error.") do |args, env|
-        Lisp::Frame::get_slot_if_impl(args, env)
-      end
-      
-      Primitive.register("remove-slot!", "(remove-slot! frame slot-name)\n\nThe remove-slot! function is used to function is used to remove a slot from a frame. It only removes slots from the frame itself. not any of it's parents. remove-slot! return #t if the slot was removed, #f otherwise.") do |args, env|
-        Lisp::Frame::remove_slot_impl(args, env)
-      end
-      
-      Primitive.register("set-slot!", "(set-slot! frame slot-name new-value)\n\nThe set-slot! function is used to change values in frame slots") do |args, env|
-        Lisp::Frame::set_slot_impl(args, env)
-      end
-      
-      Primitive.register("send", "(send frame slot-name arg...)\n\nSend the message slot-name to frame, passing along the arg collection. The result is what is returned by the code in that slot.") do |args, env|
-        Lisp::Frame::send_impl(args, env)
-      end
-      
-      Primitive.register("send-super", "**(send-super slot-name arg...)\n\nLike send, but sends to the first parent that has the named slot. send-super can only be used from within a frame.") do |args, env|
-        Lisp::Frame::send_super_impl(args, env)
-      end
-      
-      Primitive.register("clone", "(clone frame)\n\nFrames represent things. For example, you could use a frame that looks like {x: 1 y: 10} to represent a point. A system that would use point frames will typically need many independant points. The approach to this is to create a prototypical point data frame, and use the clone function to create individual, independant frames.") do |args, env|
-        Lisp::Frame::clone_impl(args, env)
-      end
-      
-      Primitive.register("keys", "(keys frame)\n\nReturn a list of the keys in the frame.") do |args, env|
-        Lisp::Frame::keys_impl(args, env)
-      end
-      
-    end
-
-
-    def self.make_frame_impl(args, env)
-      c = args
-      m = {}
-      while !c.nil?
-        k = c.car
-        return Lisp::Debug.process_error("Slot names must be a symbol, found a {k.type}.", env) unless k.symbol?
-        return Lisp::Debug.process_error("Slot names must end in a colon, found '#{k}'.", env) unless k.naked?
-        v = c.cadr.evaluate(env)
-        m[k] = v
-        c = c.cddr
-      end
-
-      Lisp::Frame.with_map(m)
-    end
-
-
-    def self.has_slot_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      key = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Frame key must be a symbol but was #{key.type}.", env) unless key.symbol?
-      return Lisp::TRUE if frame.has_slot?(key)
-      Lisp::FALSE
-    end
-
-    
-    def self.get_slot_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      key = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Frame key (#{key.to_s}) must be a symbol but was #{key.type}.", env) unless key.symbol?
-      return Lisp::Debug.process_error("Frame key (#{key.to_s}) must name an existing slot.", env) unless frame.has_slot?(key)
-      frame.get(key)
-    end
-
-    
-    def self.get_slot_if_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      key = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Frame key (#{key.to_s}) must be a symbol but was #{key.type}.", env) unless key.symbol?
-      frame.get(key)
-    end
-
-    
-    def self.remove_slot_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      key = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Frame key (#{key.to_s}) must be a symbol but was #{key.type}.", env) unless key.symbol?
-      return Lisp::TRUE if frame.remove(key)
-      Lisp::FALSE
-    end
-
-    
-    def self.set_slot_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      key = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Frame key (#{key.to_s}) must be a symbol but was #{key.type}.", env) unless key.symbol?
-      value = args.caddr.evaluate(env)
-      frame.at_put(key, value)
-    end
-    
-
-    def self.send_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      selector = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Selector must be a symbol but was #{selector.type}.", env) unless selector.symbol?
-      return Lisp::Debug.process_error("Message sent must name an existing slot in the receiver.", env) unless frame.has_slot?(selector)
-      func = frame.get(selector)
-      return Lisp::Debug.process_error("Message sent must select a function slot but was #{func.type}.", env) unless func.function?
-      params = args.cddr
-      frame_env = Lisp::EnvironmentFrame.extending(env, frame)
-      frame_env.bind_locally(Symbol.named("self"), frame)
-      func.apply_to(params, frame_env)
-    end
-
-    def self.get_super_function(selector, env)
-      f = env.frame
-      return nil if f.nil?
-      f.parents.each do |p|
-        func = p.get(selector)
-        return func unless func.nil?
-      end
-      nil
-    end
-    
-    def self.send_super_impl(args, env)
-      return Lisp::Debug.process_error("super can only be used within the context of a frame.", env) unless env.frame
-      selector = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Selector must be a symbol but was #{selector.type}.", env) unless selector.symbol?
-      func = get_super_function(selector, env)
-      return Lisp::Debug.process_error("Message sent must select a function slot but was #{func.type}.", env) unless func && func.function?
-      params = args.cdr
-      frame_env = Lisp::EnvironmentFrame.extending(env, env.frame)
-      frame_env.bind_locally(Symbol.named("self"), env.frame)
-      func.apply_to(params, frame_env)
-    end
-
-    
-    def self.clone_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      frame.clone
-    end
-
-
-    def self.keys_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      ConsCell.array_to_list(frame.value.keys)
-    end
-
-
     def self.with_map(m)
       self.new(m)
     end
 
-    def initialize(m=nil)
-      @value = m || {}
+    def initialize(m = {})
+      @value = m
+      self
     end
 
 
@@ -285,11 +126,11 @@ module Lisp
       nil
     end
 
-    def eq?(other)
+    def equal?(other)
       return false unless other.frame?
       return false unless @value.length == other.value.length
       @value.each do |k, v|
-        return false unless Lisp::Equivalence.equal_check(other.value[k], v).value
+        return false unless other.value[k].equal?(v)
       end
       true
     end

data/lib/rubylisp/function.rb

@@ -2,7 +2,7 @@ module Lisp
 
   class Function < Atom
 
-    attr_reader :doc, :arity, :name
+    attr_reader :doc, :arity, :name, :env, :body
     
     def compute_required_argument_count(args)
       a = args
@@ -37,10 +37,11 @@ module Lisp
       if @var_args
         return Lisp::Debug.process_error("#{@name} expected at least #{@arity} parameters, received #{parameters.length}.", env) if parameters.length < @arity
       else
+        puts "#{@name} #{@arguments.print_string} #{@body.print_string}" unless parameters.length == @arity
+        puts caller unless parameters.length == @arity
         return Lisp::Debug.process_error("#{@name} expected #{@arity} parameters, received #{parameters.length}.", env) unless parameters.length == @arity        
       end
-      
-      local_env = EnvironmentFrame.extending(@env, env.frame)
+      local_env = EnvironmentFrame.extending(@env, @name, env.frame)
       local_env.previous = env
       self_sym = Symbol.named("self")
       if env.frame

data/lib/rubylisp/macro.rb

@@ -2,7 +2,7 @@ module Lisp
 
   class Macro < Atom
 
-    attr_reader :doc
+    attr_reader :name, :doc, :body
     
     def compute_required_argument_count(args)
       a = args
@@ -20,6 +20,7 @@ module Lisp
     end
     
     def initialize(name, arguments, doc, body, env)
+      #puts "Macro#initialize #{name} #{arguments.to_a}"
       sig = ([name] << arguments.to_a).flatten
       @doc = "(#{(sig.collect {|e| e.to_s}).join(" ")})"
       @name = name
@@ -33,14 +34,12 @@ module Lisp
 
     def expand(parameters, env, should_eval)
       if @var_args
-        return Lisp::Debug.process_error("#{@name} expected at least
-                                ##{@required_argument_count} parameters, received #{parameters.length}.", env) if parameters.length < @required_argument_count
+        return Lisp::Debug.process_error("#{@name} expected at least #{@required_argument_count} parameters, received #{parameters.length}.", env) if parameters.length < @required_argument_count
       else
-        return Lisp::Debug.process_error("#{@name} expected
-                                ##{@required_argument_count} parameters, received #{parameters.length}.", env) unless parameters.length == @required_argument_count        
+        return Lisp::Debug.process_error("#{@name} expected #{@required_argument_count} parameters, received #{parameters.length}.", env) unless parameters.length == @required_argument_count        
       end
       
-      local_env = EnvironmentFrame.extending(@env, env.frame)
+      local_env = EnvironmentFrame.extending(@env, @name, env.frame)
       self_sym = Symbol.named("self")
       if env.frame
         local_env.bind_locally(self_sym, env.frame)
@@ -63,8 +62,14 @@ module Lisp
         accumulating_arg = arg if arg.symbol?
       end
       local_env.bind_locally(accumulating_arg, Lisp::ConsCell.array_to_list(accumulated_params)) if accumulating_arg
+
+      #puts "expanding #{@name}"
+      #puts "     #{@body.print_string}"
       
-      @body.evaluate(local_env)
+      result = @body.evaluate(local_env)
+
+      #puts "     #{result.print_string}"
+      result
     end
     
     def internal_apply_to(parameters, env, should_eval)
@@ -91,7 +96,7 @@ module Lisp
     def type
       :macro
     end
-
+    
   end
 
 end