fOOrth 0.5.0

data/lib/fOOrth/library/compile_library.rb

@@ -0,0 +1,181 @@
+# coding: utf-8
+
+#* library/compile_library.rb - The compile support fOOrth library.
+module XfOOrth
+
+  # COLON =======================================
+
+  #The classic colon definition that creates a word in the Virtual Machine class.
+  # [] : <name> <stuff omitted> ; []; creates <name> on the VirtualMachine
+  VirtualMachine.create_shared_method(':', VmSpec, [:immediate],  &lambda {|vm|
+    if execute_mode?
+      target = VirtualMachine
+      name   = vm.parser.get_word()
+      type   = VmSpec
+      XfOOrth.validate_type(vm, type, name)
+
+      begin_compile_mode(':', vm: vm, &lambda {|vm, src, tags|
+        vm.dbg_puts "#{name} => #{src}"
+        target.create_shared_method(name, type, tags, &eval(src))
+      })
+
+      XfOOrth.add_common_compiler_locals(vm, ':')
+    else
+      delayed_compile_mode(':')
+    end
+  })
+
+  # BANG COLON ==================================
+
+  #A special colon definition that creates an immediate word in the
+  #Virtual Machine class.
+  # [] !: <name> <stuff omitted> ; []; creates <name> on the VirtualMachine
+  VirtualMachine.create_shared_method('!:', VmSpec, [:immediate],  &lambda {|vm|
+    if execute_mode?
+      target = VirtualMachine
+      name   = vm.parser.get_word()
+      type   = VmSpec
+      XfOOrth.validate_type(vm, type, name)
+
+      begin_compile_mode('!:', vm: vm, tags: [:immediate], &lambda {|vm, src, tags|
+        vm.dbg_puts "(!) #{name} => #{src}"
+        target.create_shared_method(name, type, tags, &eval(src))
+      })
+
+      XfOOrth.add_common_compiler_locals(vm, '!:')
+    else
+      delayed_compile_mode('!:')
+    end
+  })
+
+
+  # DOT COLON ===================================
+
+  # [a_class] .: <name> <stuff omitted> ; []; creates <name> on a_class
+  VirtualMachine.create_shared_method('.:', VmSpec, [:immediate],  &lambda {|vm|
+    if execute_mode?
+      target = vm.pop
+      error "F13: The target of .: must be a class" unless target.is_a?(Class)
+
+      name   = vm.parser.get_word()
+      type   = XfOOrth.name_to_type(name)
+      XfOOrth.validate_type(vm, type, name)
+      XfOOrth.validate_string_method(type, target, name)
+
+      begin_compile_mode('.:', cls: target, &lambda {|vm, src, tags|
+        vm.dbg_puts "#{target.foorth_name} #{name} => #{src}"
+        target.create_shared_method(name, type, tags, &eval(src))
+      })
+
+      XfOOrth.add_common_compiler_locals(vm, '.:')
+    else
+      delayed_compile_mode('.:')
+    end
+  })
+
+
+  # DOT COLON COLON =============================
+
+  # [an_object] .:: <name> <stuff omitted> ; []; creates <name> on an_object
+  VirtualMachine.create_shared_method('.::', VmSpec, [:immediate],  &lambda {|vm|
+    if execute_mode?
+      target = vm.pop
+      name   = vm.parser.get_word()
+      type   = XfOOrth.name_to_type(name)
+      XfOOrth.validate_type(vm, type, name)
+      XfOOrth.validate_string_method(type, target.class, name)
+
+      begin_compile_mode('.::', obj: target, &lambda {|vm, src, tags|
+        vm.dbg_puts "#{target.foorth_name} #{name} => #{src}"
+        target.create_exclusive_method(name, type, tags, &eval(src))
+      })
+
+      XfOOrth.add_common_compiler_locals(vm, '.::')
+    else
+      delayed_compile_mode('.::')
+    end
+  })
+
+
+  # COMMON LOCAL DEFNS ==========================
+
+  #Set up the common local defns.
+  #<br>Parameters:
+  #* vm - The current virtual machine instance.
+  #* ctrl - A list of valid start controls.
+  #<br>Endemic Code Smells
+  #* :reek:TooManyStatements
+  def self.add_common_compiler_locals(vm, ctrl)
+    context = vm.context
+
+    #Support for local variables.
+    context.create_local_method('var:', LocalSpec, [:immediate], &Local_Var_Action)
+    context.create_local_method('val:', LocalSpec, [:immediate], &Local_Val_Action)
+
+    #Support for instance variables.
+    context.create_local_method('var@:', LocalSpec, [:immediate], &Inst_Var_Action)
+    context.create_local_method('val@:', LocalSpec, [:immediate], &Inst_Val_Action)
+
+    #Support for super methods.
+    context.create_local_method('super', LocalSpec, [:immediate],
+      &lambda {|vm| vm << 'super(vm); ' })
+
+    #The standard end-compile adapter word: ';' semi-colon.
+    context.create_local_method(';', LocalSpec, [:immediate],
+      &lambda {|vm| vm.end_compile_mode([ctrl]) })
+  end
+
+  #Determine the type of method being created. This only applies to non-vm
+  #methods as vm methods are all of type VmSpec.
+  #<br>Parameters
+  #*name - The name of the method to be created.
+  #<Returns>
+  #* The class of the spec to be used for this method.
+  def self.name_to_type(name)
+    case name[0]
+    when '.'
+      TosSpec
+
+    when '~'
+      SelfSpec
+
+    when /[0-9A-Z$@#]/
+      error "F10: Invalid name for a method: #{name}"
+
+    else
+      NosSpec
+    end
+  end
+
+  #Compare the new method's spec against the specs of other methods of the
+  #same name. If no specs exist, create one on Object if the new spec is not
+  #a virtual machine spec.
+  #<br>Parameters
+  #*vm - The current virtual machine.
+  #*type - The class of the method to be created.
+  #*name - The name of the method to be created.
+  def self.validate_type(vm, type, name)
+    if (spec = vm.context.map(name))
+      if spec.class != type
+        error "F90: Spec type mismatch #{spec.foorth_name} vs #{type.foorth_name}"
+      end
+    else
+      Object.create_shared_method(name, type, [:stub]) unless type == VmSpec
+    end
+
+  end
+
+  #Check for the case where a string method is created on another class.
+  #<br>Parameters
+  #*type - The class of the method to be created.
+  #*target - The object that is to receive this method.
+  #*name - The name of the method to be created.
+  #<br>Endemic Code Smells
+  #* :reek:ControlParameter -- false positive
+  def self.validate_string_method(type, target, name)
+    if type == TosSpec && name[-1] == '"' && target != String
+      error "F13: Creating a string method #{name} on a #{target.foorth_name}"
+    end
+  end
+
+end

data/lib/fOOrth/library/complex_library.rb

@@ -0,0 +1,81 @@
+# coding: utf-8
+
+#* library/complex_library.rb - Numeric support for the fOOrth library.
+module XfOOrth
+
+  #Connect the Complex class to the fOOrth class system.
+  Complex.create_foorth_proxy
+
+  #Some complex stubs.
+  Complex.create_shared_method('mod',    NosSpec, [:stub])
+  Complex.create_shared_method('.ceil',  TosSpec, [:stub])
+  Complex.create_shared_method('.floor', TosSpec, [:stub])
+  Complex.create_shared_method('.round', TosSpec, [:stub])
+  Complex.create_shared_method('<',      NosSpec, [:stub])
+  Complex.create_shared_method('>',      NosSpec, [:stub])
+  Complex.create_shared_method('<=',     NosSpec, [:stub])
+  Complex.create_shared_method('>=',     NosSpec, [:stub])
+  Complex.create_shared_method('<=>',    NosSpec, [:stub])
+
+
+  #Some conversion words.
+  # [a b] complex [a+bi]
+  VirtualMachine.create_shared_method('complex', VmSpec, [], &lambda {|vm|
+    real,imag = popm(2)
+
+    begin
+      push(Complex(real,imag));
+    rescue
+      error "F40: Cannot coerce a #{real.foorth_name}, #{imag.foorth_name} to a Complex"
+    end
+  })
+
+  # [a+bi] .split [a b]
+  Complex.create_shared_method('.split', TosSpec, [],
+    &lambda {|vm| vm.push(self.real); vm.push(self.imaginary); })
+
+  # [a] .to_x [compleX or nil]
+  Object.create_shared_method('.to_x', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Complex(self))
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  # [a] .to_x! [compleX]
+  Object.create_shared_method('.to_x!', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Complex(self))
+    rescue
+      error "F40: Cannot coerce a #{self.foorth_name} to a Complex"
+    end
+  })
+
+  # [a+bi] .imaginary [b]
+  Numeric.create_shared_method('.imaginary', TosSpec, [],
+    &lambda {|vm| vm.push(self.imaginary); })
+
+  # [a+bi] .real [a]
+  Numeric.create_shared_method('.real', TosSpec, [],
+    &lambda {|vm| vm.push(self.real); })
+
+  # [a+bi] .angle [atan2(b,a) or 0]
+  Numeric.create_shared_method('.angle', TosSpec, [],
+    &lambda {|vm| vm.push(self.angle); })
+
+  # [a+bi] .magnitude [sqrt(a**2 + b**2)]
+  Numeric.create_shared_method('.magnitude', TosSpec, [],
+    &lambda {|vm| vm.push(self.magnitude); })
+
+  # [a+bi] .conjugate [a-bi]
+  # Complex convicts that behave well are allowed .conjugate visits.
+  Numeric.create_shared_method('.conjugate', TosSpec, [],
+    &lambda {|vm| vm.push(self.conjugate); })
+
+  # [a+bi] .polar [magnitude angle]
+  # Convert a complex number to polar format
+  Numeric.create_shared_method('.polar', TosSpec, [],
+    &lambda {|vm| vm.pushm(self.polar); })
+
+end

data/lib/fOOrth/library/ctrl_struct_library.rb

@@ -0,0 +1,116 @@
+# coding: utf-8
+
+#* library/ctrl_struct_library.rb - The control structures fOOrth library.
+module XfOOrth
+
+  # [boolean] if (boolean true code) else (boolean false code) then
+  VirtualMachine.create_shared_method('if', VmSpec, [:immediate], &lambda {|vm|
+    suspend_execute_mode('if vm.pop? then ', :if)
+
+    context.create_local_method('else', LocalSpec, [:immediate], &lambda {|vm|
+      check_deferred_mode('else ', [:if])
+      vm.context.remove_local_method('else')
+    })
+
+    context.create_local_method('then', LocalSpec, [:immediate],
+      &lambda {|vm| resume_execute_mode('end; ', [:if]) })
+  })
+
+  # [unspecified] switch ... end [unspecified]
+  VirtualMachine.create_shared_method('switch', VmSpec, [:immediate], &lambda {|vm|
+    suspend_execute_mode('loop do; ', :switch)
+
+    context.create_local_method('break', LocalSpec, [:immediate],
+      &lambda {|vm| vm << 'break; ' })
+
+    context.create_local_method('?break', LocalSpec, [:immediate],
+      &lambda {|vm| vm << 'break if vm.pop?; ' })
+
+    context.create_local_method('end', LocalSpec, [:immediate],
+      &lambda {|vm| resume_execute_mode('break; end; ', [:switch]) })
+  })
+
+  # Looping constructs for fOOrth.
+  VirtualMachine.create_shared_method('begin', VmSpec, [:immediate], &lambda {|vm|
+    suspend_execute_mode('begin ', :begin)
+
+    context.create_local_method('while', LocalSpec, [:immediate],
+      &lambda {|vm| check_deferred_mode('break unless vm.pop?; ', [:begin]) })
+
+    context.create_local_method('until', LocalSpec, [:immediate],
+      &lambda {|vm| resume_execute_mode('end until vm.pop?; ', [:begin]) })
+
+    context.create_local_method('again', LocalSpec, [:immediate],
+      &lambda {|vm| resume_execute_mode('end until false; ', [:begin]) })
+
+    context.create_local_method('repeat', LocalSpec, [:immediate],
+      &lambda {|vm| resume_execute_mode('end until false; ', [:begin]) })
+  })
+
+  # Support for the sanitized do loop constructs!
+  VirtualMachine.create_shared_method('do', VmSpec, [:immediate], &lambda {|vm|
+    jvar =  context[:jloop].to_s
+    suspend_execute_mode("vm.vm_do(#{jvar}) {|iloop, jloop| ", :do)
+    context[:jloop] = 'iloop'
+
+    context.create_local_method('i', MacroSpec,
+      [:macro, 'vm.push(iloop[0]); '])
+
+    context.create_local_method('j', MacroSpec,
+      [:macro, 'vm.push(jloop[0]); '])
+
+    context.create_local_method('-i', MacroSpec,
+      [:macro, 'vm.push(iloop[2] - iloop[0]); '])
+
+    context.create_local_method('-j', MacroSpec,
+      [:macro, 'vm.push(jloop[2] - jloop[0]); '])
+
+    context.create_local_method('loop', LocalSpec, [:immediate],
+      &lambda {|vm| resume_execute_mode('iloop[0] += 1}; ', [:do]) })
+
+    context.create_local_method('+loop', LocalSpec, [:immediate],
+      &lambda {|vm| resume_execute_mode('iloop[0] += vm.vm_do_increment}; ', [:do]) })
+  })
+
+  #Support for the try ... catch ... finally ... end construct.
+  VirtualMachine.create_shared_method('try', VmSpec, [:immediate], &lambda {|vm|
+    suspend_execute_mode('begin; ', :try_block)
+
+    SymbolMap.add_entry('error') #Make sure an entry for 'error' exists.
+    SymbolMap.add_entry('?"')    #Make sure an entry for '?"' exists.
+
+    context.create_local_method('catch', LocalSpec, [:immediate], &lambda {|vm|
+      check_deferred_mode('rescue StandardError, SignalException => error; ', [:try_block])
+
+      vm.context.create_local_method('?"', LocalSpec, [:immediate], &lambda {|vm|
+        str = vm.pop
+        vm << "vm.push(error.foorth_match(#{str.foorth_embed})); "
+      })
+
+      vm.context.create_local_method('error', LocalSpec, [:immediate], &lambda {|vm|
+        vm << 'vm.push(error.foorth_message); '
+      })
+
+      vm.context.create_local_method('bounce', LocalSpec, [:immediate], &lambda {|vm|
+        vm << 'raise; '
+      })
+
+      vm.context.remove_local_method('catch')
+    })
+
+    context.create_local_method('finally', LocalSpec, [:immediate], &lambda {|vm|
+      check_deferred_mode('ensure; ', [:try_block])
+
+      vm.context.remove_local_method('catch')
+      vm.context.remove_local_method('finally')
+      vm.context.remove_local_method('?"')
+      vm.context.remove_local_method('error')
+      vm.context.remove_local_method('bounce')
+    })
+
+    vm.context.create_local_method('end', LocalSpec, [:immediate], &lambda {|vm|
+      vm.resume_execute_mode('end; ', [:try_block])
+    })
+  })
+
+end

data/lib/fOOrth/library/data_ref_library.rb

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+#* library/data_ref_library.rb - The data references (variables) fOOrth library.
+module XfOOrth
+
+  #The lambda used to define local variables. fOOrth language definition is:
+  # [n] var: lv [], lv = [n]
+  Local_Var_Action = lambda {|vm|
+    name   = vm.parser.get_word()
+    error "F10: Invalid var name #{name}" unless /^[a-z][a-z0-9_]*$/ =~ name
+    symbol = XfOOrth::SymbolMap.add_entry(name)
+    vm << "#{symbol} = [vm.pop]; "
+
+    #Add a local defn for the local variable.
+    vm.context.create_local_method(name, LocalSpec, [:immediate],
+      &lambda {|vm| vm << "vm.push(#{symbol}); "} )
+  }
+
+  #The lambda used to define local values. fOOrth language definition is:
+  # [n] val: lv [], lv = n
+  Local_Val_Action = lambda {|vm|
+    name   = vm.parser.get_word()
+    error "F10: Invalid val name #{name}" unless /^[a-z][a-z0-9_]*$/ =~ name
+    symbol = XfOOrth::SymbolMap.add_entry(name)
+    vm << "#{symbol} = vm.pop; "
+
+    #Add a local defn for the local variable.
+    vm.context.create_local_method(name, LocalSpec, [:immediate],
+      &lambda {|vm| vm << "vm.push(#{symbol}); "} )
+  }
+
+  #The lambda used to define instance variables. fOOrth language definition is:
+  # [n] var@: @iv [], @iv = [n]
+  Inst_Var_Action = lambda { |vm|
+    name   = vm.parser.get_word()
+    error "F10: Invalid var name #{name}" unless /^@[a-z][a-z0-9_]*$/ =~ name
+    symbol = XfOOrth::SymbolMap.add_entry(name)
+    vm << "#{'@'+(symbol.to_s)} = [vm.pop]; "
+
+    #Add a defn for the instance variable.
+    vm.context.recvr.create_shared_method(name, InstanceVarSpec, [])
+  }
+
+  #The lambda used to define instance values. fOOrth language definition is:
+  # [n] val@: @iv [], @iv = n
+  Inst_Val_Action = lambda { |vm|
+    name   = vm.parser.get_word()
+    error "F10: Invalid val name #{name}" unless /^@[a-z][a-z0-9_]*$/ =~ name
+    symbol = XfOOrth::SymbolMap.add_entry(name)
+    vm << "#{'@'+(symbol.to_s)} = vm.pop; "
+
+    #Add a defn for the instance variable.
+    vm.context.recvr.create_shared_method(name, InstanceVarSpec, [])
+  }
+
+  # Thread Variables
+  # [n] var#: #tv [], Thread.current[#tv] = [n]
+  VirtualMachine.create_shared_method('var#:', VmSpec, [], &lambda {|vm|
+    name   = vm.parser.get_word()
+    error "F10: Invalid var name #{name}" unless /^#[a-z][a-z0-9_]*$/ =~ name
+    symbol = XfOOrth::SymbolMap.add_entry(name)
+    @data[symbol] = [vm.pop]
+
+    vm.create_exclusive_method(name, ThreadVarSpec, [])
+  })
+
+  # Thread values.
+  # [n] val#: #tv [], Thread.current[#tv] = n
+  VirtualMachine.create_shared_method('val#:', VmSpec, [], &lambda {|vm|
+    name   = vm.parser.get_word()
+    error "F10: Invalid val name #{name}" unless /^#[a-z][a-z0-9_]*$/ =~ name
+    symbol = XfOOrth::SymbolMap.add_entry(name)
+    @data[symbol] = vm.pop
+
+    vm.create_exclusive_method(name, ThreadVarSpec, [])
+  })
+
+  # Global Variables
+  # [n] var$: $gv [], $gv = [n]
+  VirtualMachine.create_shared_method('var$:', VmSpec, [], &lambda {|vm|
+    name   = vm.parser.get_word()
+    error "F10: Invalid var name #{name}" unless /^\$[a-z][a-z0-9_]*$/ =~ name
+    symbol = XfOOrth::SymbolMap.add_entry(name)
+    eval "#{'$' + symbol.to_s} = [vm.pop]"
+
+    $FOORTH_GLOBALS[symbol] = GlobalVarSpec.new(name, symbol, [])
+  })
+
+  # Global Values
+  # [n] val$: $gv [], $gv = n
+  VirtualMachine.create_shared_method('val$:', VmSpec, [], &lambda {|vm|
+    name   = vm.parser.get_word()
+    error "F10: Invalid val name #{name}" unless /^\$[a-z][a-z0-9_]*$/ =~ name
+    symbol = XfOOrth::SymbolMap.add_entry(name)
+    eval "#{'$' + symbol.to_s} = vm.pop"
+
+    $FOORTH_GLOBALS[symbol] = GlobalVarSpec.new(name, symbol, [])
+  })
+
+end