Rewrite statically mentioned symbols to point to pre-created objects.

Author: vidarh

compile_pragma.rb

@@ -5,21 +5,18 @@
 #
 
 class Compiler
-  #
-  # FIXME: We could go one better with this, and generate the
-  # objects "raw". Will revisit that once I see if it is worth it.
-  #
-  def output_integer_list(scope)
-    @integers.each do |i|
-      compile_assign(scope, int_name(i), [:call, :__int, i])
+
+  def output_symbol_list(scope)
+    @symbols.each do |s|
+      compile_assign(scope, symbol_name(s), [:call, :__get_symbol, s])
     end
     Value.new([:global, :nil])
   end
 
   def compile___compiler_internal scope, type, *args
     case type
-    when :integer_list
-      return output_integer_list(scope)
+    when :symbol_list
+      return output_symbol_list(scope)
     end
 
     error("Unknown pragma: #{type}")

compiler.rb

@@ -46,7 +46,7 @@ class Compiler
                    :lt, :le, :gt, :ge,:saveregs, :and, :or,
                    :preturn, :proc, :stackframe, :deref, :include,
                    :protected, :array, :splat, :mod, :or_assign, :break, :next,
-                   :__compiler_internal # See `compile_pragma.rb`
+                   :__compiler_internal, # See `compile_pragma.rb`
                   ]
 
   Keywords = @@keywords

lib/core/symbol.rb

@@ -109,3 +109,5 @@ def self.__get_symbol(name)
 end
 
 %s(defun __get_symbol (name) (callm Symbol __get_symbol ((__get_string name))))
+
+%s(__compiler_internal symbol_list)

transform.rb

@@ -106,6 +106,8 @@ def rewrite_strconst(exp)
   end
 
 
+  def symbol_name(v)
+    s = "__S_#{clean_method_name(v)}"
   def int_name(v)
     if v < 0
       # FIXME: @bug #{-v} causes error, because it tries to call Fixnum#- with single argument
@@ -143,7 +145,35 @@ def rewrite_integer_constant(exp)
     end
   end
 
+  # Rewrite a symbol constant outside %s() to
+  # %s(sexp __[num]) and output a list later
+  def rewrite_symbol_constant(exp)
+    @symbols = Set[]
+    exp.depth_first do |e|
+      next :skip if e[0] == :sexp
+      is_call = e[0] == :call || e[0] == :callm
+      # FIXME: e seems to get aliased by v
+      ex = e
+      e.each_with_index do |v,i|
+        name = v.to_s
+        if v.is_a?(Symbol) && name[0] == ?:
+          #STDERR.puts v.inspect
+          if !@symbols.member?(v)
+            @symbols << name[1..-1]
+          end
+          ex[i] = E[:sexp, symbol_name(name[1..-1])]
+
+          # FIXME: This is a horrible workaround to deal with a parser
+          # inconsistency that leaves calls with a single argument with
+          # the argument "bare" if it's not an array, which breaks with
+          # this rewrite.
+          ex[i] = E[ex[i]] if is_call && i > 1
+        end
+      end
+    end
+  end
 
+  
   # Rewrite operators that should be treated as method calls
   # so that e.g. (+ 1 2) is turned into (callm 1 + 2)
   #
@@ -619,6 +649,7 @@ def preprocess exp
     rewrite_range(exp)
     rewrite_strconst(exp)
     rewrite_integer_constant(exp)
+    rewrite_symbol_constant(exp)
     rewrite_operators(exp)
     rewrite_yield(exp)
     rewrite_let_env(exp)