back to method_compiler

it is what it is

lib/mom/instruction/instruction.rb

@@ -18,7 +18,7 @@ module Mom
     # In other words Mom is the higher abstraction and so mom instructions convert
     # to many (1-10) risc instructions
     #
-    # The argument that is passed is a RiscCompiler, which has the method and some
+    # The argument that is passed is a MethodCompiler, which has the method and some
     # state about registers used. (also provides helpers to generate risc instructions)
     def to_risc(compiler)
       raise self.class.name + "_todo"

lib/parfait/vool_method.rb

@@ -36,7 +36,7 @@ module Parfait
     def compile_to_risc(for_type)
       typed_method = create_typed_method(for_type)
       head = source.to_mom( typed_method )
-      compiler = Risc::RiscCompiler.new( typed_method )
+      compiler = Risc::MethodCompiler.new( typed_method )
       compiler.add_mom(head)
       head # return for testing
     end

lib/risc.rb

@@ -25,7 +25,7 @@ require_relative "risc/platform"
 require "parfait"
 require_relative "risc/parfait_adapter"
 require_relative "risc/machine"
-require_relative "risc/risc_compiler"
+require_relative "risc/method_compiler"
 
 class Fixnum
   def fits_u8?

lib/risc/builder.rb

@@ -236,7 +236,7 @@ module Risc
     end
   end
 
-  # A CompilerBuilder adds the generated code to the RiscCompiler.
+  # A CompilerBuilder adds the generated code to the MethodCompiler.
   #
   class CompilerBuilder < Builder
     # add code straight to the compiler

lib/risc/builtin/compile_helper.rb

@@ -6,7 +6,7 @@ module Risc
       def compiler_for( clazz_name , method_name , arguments , locals = {})
         frame = Parfait::NamedList.type_for( locals )
         args = Parfait::NamedList.type_for( arguments )
-        RiscCompiler.compiler_for_class(clazz_name , method_name , args, frame )
+        MethodCompiler.compiler_for_class(clazz_name , method_name , args, frame )
       end
 
     end

lib/risc/builtin/object.rb

@@ -46,7 +46,7 @@ module Risc
         # it isn't really a function, ie it is jumped to (not called), exits and may not return
         # so it is responsible for initial setup
         def __init__ context
-          compiler = RiscCompiler.compiler_for_class(:Object,:__init__ ,
+          compiler = MethodCompiler.compiler_for_class(:Object,:__init__ ,
                             Parfait::NamedList.type_for({}) , Parfait::NamedList.type_for({}))
           builder = compiler.compiler_builder(compiler.method)
           builder.build do

lib/risc/method_compiler.rb

@@ -1,10 +1,10 @@
 module Risc
 
-  # RiscCompiler (old name) is used to generate risc instructions for methods
+  # MethodCompiler (old name) is used to generate risc instructions for methods
   # and to instantiate the methods correctly. Most of the init is typed layer stuff,
   # but there is some logic too.
 
-  class RiscCompiler
+  class MethodCompiler
 
     def initialize( method )
       @regs = []