rubyx/lib/risc/builder.rb

module Risc

  # A Builder is used to generate code, either by using it's api, or dsl
  #
  # The code is added to the method_compiler.
  #
  # Basically this allows to express many Risc instructions with extremely readable code.
  # example:
  #  space << Parfait.object_space # load constant
  #  message[:receiver] << space  #make current message's (r0) receiver the space
  # See http://ruby-x.org/rubyx/builder.html for details
  #
  class Builder

    attr_reader :built , :compiler , :names

    # pass a compiler, to which instruction are added (usually)
    # call build with a block to build
    def initialize(compiler, for_source)
      raise "no compiler" unless compiler
      raise "no source" unless for_source
      @compiler = compiler
      @source = for_source
      @source_used = false
      @names = {}
    end

    # make the magic: convert incoming names into registers that have the
    # type set according to the name (using infer_type)
    # names are stored, so subsequent calls use the same register
    def method_missing(name , *args)
      return super if args.length != 0
      name = name.to_s
      return @names[name] if @names.has_key?(name)
      if name == "message"
        return Risc.message_reg.set_builder(self)
      end
      if name.index("label")
        reg = Risc.label( @source , "#{name}_#{object_id}")
        @source_used = true
      else
        last_char = name[-1]
        name = name[0 ... -1]
        if last_char == "!" or last_char == "?"
          if @names.has_key?(name)
            return @names[name] if last_char == "?"
            raise "Name exists (#{@names.keys})before creating it #{name}#{last_char}"
          end
        else
          raise "Must create (with ! or ?) before using #{name}#{last_char}"
        end
        type = infer_type(name )
        reg = @compiler.use_reg( type.object_class.name ).set_builder(self)
      end
      @names[name] = reg
      reg
    end

    # Infer the type from a symbol. In the simplest case the symbol is the class name.
    # But in building, sometimes variations are needed, so next_message or caller work
    # too (and both return "Message")
    # A general "_reg"/"_obj"/"_const" or "_tmp" at the end of the name will be removed
    # An error is raised if the symbol/object can not be inferred
    def infer_type( name )
      as_string = name.to_s
      parts = as_string.split("_")
      if( ["reg" , "obj" , "tmp" , "self" , "const", "1" , "2"].include?( parts.last ) )
        parts.pop
        as_string = parts.join("_")
      end
      as_string = "word" if as_string == "name"
      as_string = "message" if as_string == "next_message"
      as_string = "message" if as_string == "caller"
      sym = as_string.camelise.to_sym
      clazz = Parfait.object_space.get_class_by_name(sym)
      raise "Not implemented/found object #{name}:#{sym}" unless clazz
      return clazz.instance_type
    end

    def if_zero( label )
      @source_used = true
      add_code Risc::IsZero.new(@source , label)
    end
    def if_not_zero( label )
      @source_used = true
      add_code Risc::IsNotZero.new(@source , label)
    end
    def if_minus( label )
      @source_used = true
      add_code Risc::IsMinus.new(@source , label)
    end
    def branch( label )
      @source_used = true
      add_code Risc::Branch.new(@source, label)
    end

    # To avoid many an if, it can be handy to swap variable names.
    # But since the names in the builder are not variables, we need this method.
    # As it says, swap the two names around. Names must exist
    def swap_names(left , right)
      left , right = left.to_s , right.to_s
      l = @names[left]
      r = @names[right]
      raise "No such name #{left}" unless l
      raise "No such name #{right}" unless r
      @names[left] = r
      @names[right] = l
    end

    # Reset the names stored by the builder. The names are sort of variables names
    # that can be used in the build block due to method_missing magic.
    #
    # But just as the compiler has reset_regs, the builder has this reset button, to
    # start fresh. Quite crude for now, and only used in allocate_int
    #
    # Compiler regs are reset as well
    def reset_names
      @names = {}
      compiler.reset_regs
    end

    # Build code using dsl (see __init__ or MessageSetup for examples).
    # Names (that ruby would resolve to a variable/method) are converted
    # to registers. << means assignment and [] is supported both on
    # L and R values (but only one at a time). R values may also be constants.
    #
    # Basically this allows to create LoadConstant, RegToSlot, SlotToReg and
    # Transfer instructions with extremely readable code.
    # example:
    #  space << Parfait.object_space # load constant
    #  message[:receiver] << space  #make current message's (r0) receiver the space
    #
    # build result is added to compiler directly
    #
    def build(&block)
      instance_eval(&block)
    end

    # add code straight to the compiler
    def add_code(ins)
      @compiler.add_code(ins)
      return ins
    end

    # for some methods that return an integer it is beneficial to pre allocate the
    # integer and store it in the return value. That is what this function does.
    #
    # Those (builtin) methods, mostly syscall wrappers then go on to do this and that
    # clobbering registers and so the allocate and even move would be difficult.
    # We sidestep all that by pre-allocating.
    def prepare_int_return
      integer_tmp = allocate_int
      reset_names
      build do
        message[:return_value] << integer_tmp
      end
    end

    # allocate int fetches a new int, for sure. It is a builder method, rather than
    # an inbuilt one, to avoid call overhead for 99.9%
    # The factories allocate in 1k, so only when that runs out do we really need a call.
    # Note:
    #   Unfortunately (or so me thinks), this creates code bloat, as the calling is
    #   included in 100%, but only needed in 0.1. Risc-level Blocks or Macros may be needed.
    #   as the calling in (the same) 40-50 instructions for every basic int op.
    #
    # The method
    # - grabs a Integer instance from the Integer factory
    # - checks for nil and calls (get_more) for more if needed
    # - returns the RiscValue (Register) where the object is found
    #
    # The implicit condition is that the method is called at the entry of a method.
    # It uses a fair few registers and resets all at the end. The returned object
    # will always be in r1, because the method resets, and all others will be clobbered.
    #
    # Return RegisterValue(:r1) that will be named integer_tmp
    def allocate_int
      compiler.reset_regs
      integer = self.integer!
      build do
        factory! << Parfait.object_space.get_factory_for(:Integer)
        integer << factory[:next_object]
        object! << Parfait.object_space.nil_object
        object - integer
        if_not_zero cont_label
        integer_2! << factory[:reserve]
        factory[:next_object] << integer_2
        call_get_more
        integer << factory[:next_object]
        add_code cont_label
        integer_2 << integer[:next_integer]
        factory[:next_object] << integer_2
      end
      reset_names
      integer_tmp!
    end

    # Call_get_more calls the method get_more on the factory (see there).
    # From the callers perspective the method ensures there is a next_object.
    #
    # Calling is three step process
    # - setting up the next message
    # - moving receiver (factory) and arguments (none)
    # - issuing the call
    # These steps shadow the SlotMachineInstructions MessageSetup, ArgumentTransfer and SimpleCall
    def call_get_more
      factory = Parfait.object_space.get_factory_for( :Integer )
      calling = factory.get_type.get_method( :get_more )
      calling = Parfait.object_space.get_method!(:Space,:main) #until we actually parse Factory
      raise "no main defined" unless calling
      SlotMachine::MessageSetup.new( calling ).build_with( self )
      self.build do
        factory_reg! << factory
        message[:receiver] << factory_reg
      end
      SlotMachine::SimpleCall.new(calling).to_risc(compiler)
    end

  end

end