fOOrth 0.5.0

data/lib/fOOrth/library/bundle_library.rb

@@ -0,0 +1,112 @@
+# coding: utf-8
+
+#* library/bundle_library.rb - The fOOrth Bundle class library.
+module XfOOrth
+
+  #Define the Bundle class.
+  Object.create_foorth_subclass('Bundle').new_class
+
+  #The fOOrth Bundle class. A bundle contains multiple fibers.
+  class XfOOrth_Bundle
+
+    #Build up the bundle instance
+    def initialize(fibers=[])
+      @fibers = fibers.in_array.map {|f| f.to_foorth_fiber}
+      @current = 0
+    rescue NoMethodError
+      error "F70: A bundle may only contain procedures, fibers, or bundles."
+    end
+
+    #Add the fibers to this bundle.
+    def add_fibers(fibers)
+      fibers.in_array.each {|f| @fibers << f.to_foorth_fiber}
+    rescue NoMethodError
+      error "F70: A bundle may only contain procedures, fibers, or bundles."
+    end
+
+    #Return this bundle as a fiber.
+    def to_foorth_fiber
+      self
+    end
+
+    #What is the status of this bundle?
+    def status
+      @fibers.empty? ? "dead" : "alive"
+    end
+
+    #how many fibers in this bundle?
+    def length
+      @fibers.length
+    end
+
+    #Let the fiber run for one step
+    def step(vm)
+      if @current < @fibers.length
+        if @fibers[@current].step(vm)
+          @current += 1
+        else
+          @fibers.delete_at(@current)
+        end
+      end
+
+      @current = 0 unless @current < @fibers.length
+      !@fibers.empty?
+    end
+
+    #Run the fiber bundle constantly until done.
+    def run(vm)
+      while step(vm); end
+    end
+  end
+
+  # [a_bundle] .to_fiber [a_bundle] ; Bundles are compatible with fibers!
+  XfOOrth_Bundle.create_shared_method('.to_fiber', TosSpec, [], &lambda {|vm|
+    vm.push(self)
+  })
+
+  #[a_bundle] .to_bundle [a_bundle]; Bundles are compatible with bundles too!
+  XfOOrth_Bundle.create_shared_method('.to_bundle', TosSpec, [], &lambda{|vm|
+    vm.push(self)
+  })
+
+  #[an_array_of_procs_fibers_or_bundles] .to_bundle [a_bundle]
+  Array.create_shared_method('.to_bundle', TosSpec, [], &lambda{|vm|
+    vm.push(XfOOrth_Bundle.new(self))
+  })
+
+  #[a_proc] .to_bundle [a_bundle]
+  Proc.create_shared_method('.to_bundle', TosSpec, [], &lambda{|vm|
+    vm.push(XfOOrth_Bundle.new(self))
+  })
+
+  # [a_proc_fiber_or_bundle a_bundle] .add [] ; Add to the bundle.
+  XfOOrth_Bundle.create_shared_method('.add', TosSpec, [], &lambda {|vm|
+    self.add_fibers(vm.pop)
+  })
+
+  #[a_bundle] .step []; Do a single step on the bundle.
+  XfOOrth_Bundle.create_shared_method('.step', TosSpec, [], &lambda{|vm|
+    step(vm)
+  })
+
+  #[a_bundle] .run []; Run the bundle until all of its fibers are done.
+  XfOOrth_Bundle.create_shared_method('.run', TosSpec, [], &lambda{|vm|
+    run(vm)
+  })
+
+  # [a_bundle] .alive? [a_boolean]; Does the bundle still have fibers in it?
+  XfOOrth_Bundle.create_shared_method('.alive?', TosSpec, [], &lambda {|vm|
+    vm.push(!@fibers.empty?)
+  })
+
+  # [a_bundle] .status [a_string]; Does the bundle still have fibers in it?
+  XfOOrth_Bundle.create_shared_method('.status', TosSpec, [], &lambda {|vm|
+    vm.push(status)
+  })
+
+  # [a_bundle] .length [a_count]; How many fibers does the bundle have?
+  XfOOrth_Bundle.create_shared_method('.length', TosSpec, [], &lambda {|vm|
+    vm.push(self.length)
+  })
+
+end

data/lib/fOOrth/library/class_library.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+#* library/class_library.rb - The fOOrth Class class library.
+module XfOOrth
+
+  #Create a new instance of this class of objects.
+  # [{optional args for .init}  a_class] .new [an_instance]
+  Class.create_shared_method('.new', TosSpec, [],
+    &lambda {|vm| vm.push(self.create_foorth_instance(vm)); })
+
+  #Get the class as a string.
+  # [cls] .to_s ["cls as a string"]
+  Class.create_shared_method('.to_s', TosSpec, [], &lambda {|vm|
+    vm.push(self.foorth_name || "AnonymousClass<#{self.object_id}>")
+  })
+
+  #The .parent_class method. Retrieves the parent class of a class.
+  # [a_class] .parent_class [parent_class or nil]
+  Class.create_shared_method('.parent_class', TosSpec, [], &lambda {|vm|
+    #Ugly hack. Sorry :-(
+    if self == Object
+      vm.push(nil)
+    elsif (self == Class) || self < Exception
+      vm.push(Object)
+    else
+      vm.push(self.superclass)
+    end
+  })
+
+  #The .is_class? method. Is the object a class object?
+  # [obj] .is_class? [boolean]
+  Object.create_shared_method('.is_class?', TosSpec, [],
+    &lambda {|vm| vm.push(false)})
+
+  Class.create_shared_method('.is_class?', TosSpec, [],
+    &lambda {|vm| vm.push(true)})
+
+  #Create a new subclass of an existing class.
+  # [a_class] .subclass: <ClassName> []; Create subclass of a_class <ClassName>
+  VirtualMachine.create_shared_method('.subclass:', VmSpec, [:immediate], &lambda {|vm|
+    name = vm.parser.get_word()
+
+    if execute_mode?
+      target = vm.pop
+      error "F13: The target of .subclass: must be a class" unless target.is_a?(Class)
+      target.create_foorth_subclass(name)
+    else
+      buffer = "vm.process_string(#{".subclass: #{name} ".inspect}); "
+      dbg_puts "  Append=#{buffer}"
+      @buffer << buffer
+    end
+  })
+
+  #Create a new subclass of the Object class.
+  # [] class: <ClassName> []; Create subclass of Object <ClassName>
+  VirtualMachine.create_shared_method('class:', VmSpec, [:immediate], &lambda {|vm|
+    name = vm.parser.get_word()
+
+    if execute_mode?
+      Object.create_foorth_subclass(name)
+    else
+      buffer = "vm.process_string(#{"class: #{name} ".inspect}); "
+      dbg_puts "  Append=#{buffer}"
+      @buffer << buffer
+    end
+  })
+
+  #Check that an object is of the correct class.
+  #[an_object a_class] .check [an_object or nil]
+  Class.create_shared_method('.check', TosSpec, [], &lambda {|vm|
+    object = vm.pop
+    vm.push(object.class <= self ? object : nil)
+  })
+
+  #Check that an object is of the correct class.
+  #[an_object a_class] .check! [an_object or error]
+  Class.create_shared_method('.check!', TosSpec, [], &lambda {|vm|
+    object = vm.pop
+
+    unless object.class <= self
+      error "F42: A #{object.foorth_name} is not compatible with a #{self.foorth_name}. "
+    end
+
+    vm.push(object)
+  })
+
+end
+
+
+

data/lib/fOOrth/library/clone_library.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+
+#* library/clone_library.rb - The fOOrth data cloning library.
+module XfOOrth
+
+  #Add an explicit mapping for .clone_exclude so that it is accessible to Ruby.
+  SymbolMap.add_entry('.clone_exclude', :foorth_exclude)
+
+  # [a] copy [a, a']
+  VirtualMachine.create_shared_method('copy', MacroSpec,
+    [:macro, "vm.push(vm.peek.safe_clone); "])
+
+  # [a] .copy [a']
+  Object.create_shared_method('.copy', TosSpec, [],
+    &lambda {|vm| vm.push(self.safe_clone); })
+
+  # [a] clone [a, a']
+  VirtualMachine.create_shared_method('clone', MacroSpec,
+    [:macro, "vm.push(vm.peek.full_clone); "])
+
+  # [a] .clone [a']
+  Object.create_shared_method('.clone', TosSpec, [],
+    &lambda {|vm| vm.push(self.full_clone); })
+
+  # [] .clone_exclude [[exclusion_list]]
+  Object.create_shared_method('.clone_exclude', TosSpec, [],
+    &lambda {|vm| vm.push([]); })
+
+end
+
+#* Runtime clone library support in Object.
+class Object
+
+  # The full clone data member clone exclusion control
+  def full_clone_exclude
+    vm = Thread.current[:vm]
+    self.foorth_exclude(vm)
+
+    vm.pop.map do |entry|
+      if (sym = XfOOrth::SymbolMap.map(entry))
+        ("@" + sym.to_s).to_sym
+      else
+        entry
+      end
+    end
+  end
+
+end
+
+#* Runtime clone library support in Array.
+class Array
+
+  # The full clone data member clone exclusion control
+  def full_clone_exclude
+    vm = Thread.current[:vm]
+    self.foorth_exclude(vm)
+    vm.pop
+  end
+
+end
+
+#* Runtime clone library support in Hash.
+class Hash
+
+  # The full clone data member clone exclusion control
+  def full_clone_exclude
+    vm = Thread.current[:vm]
+    self.foorth_exclude(vm)
+    vm.pop
+  end
+
+end

data/lib/fOOrth/library/command_library.rb

@@ -0,0 +1,205 @@
+# coding: utf-8
+
+#* library/command_library.rb - The utility command fOOrth library.
+module XfOOrth
+
+  #The quit out of fOOrth method.
+  VirtualMachine.create_shared_method(')quit', MacroSpec,
+    [:macro, "raise ForceExit; "])
+
+  #Execute a command to the shell.
+  VirtualMachine.create_shared_method(')"', MacroSpec,
+    [:macro, "system(vm.pop()); "])
+
+  #Enter debug mode. Warning! This is really verbose!
+  VirtualMachine.create_shared_method(')debug', MacroSpec,
+    [:macro, "vm.debug = true; "])
+
+  #Leave debug mode.
+  VirtualMachine.create_shared_method(')nodebug', MacroSpec,
+    [:macro, "vm.debug = false; "])
+
+  #Enter show stack mode.
+  VirtualMachine.create_shared_method(')show', MacroSpec,
+    [:macro, "vm.show_stack = true; "])
+
+  #Leave show stack mode.
+  VirtualMachine.create_shared_method(')noshow', MacroSpec,
+    [:macro, "vm.show_stack = false; "])
+
+  #Dump the context.
+  VirtualMachine.create_shared_method(')context', VmSpec, [],
+    &lambda {|vm| vm.context.debug_dump(vm) })
+
+  #Dump the context right NOW!.
+  VirtualMachine.create_shared_method(')context!', VmSpec, [:immediate],
+    &lambda {|vm| vm.context.debug_dump(vm) })
+
+  #Dump the virtual machine.
+  VirtualMachine.create_shared_method(')vm', VmSpec, [],
+    &lambda {|vm| vm.debug_dump })
+
+  #Dump the virtual machine right NOW!
+  VirtualMachine.create_shared_method(')vm!', VmSpec, [:immediate],
+    &lambda {|vm| vm.debug_dump })
+
+  #Map a symbol entry
+  VirtualMachine.create_shared_method(')map"', VmSpec, [], &lambda {|vm|
+    str = vm.pop.to_s
+    puts "#{str} => #{(SymbolMap.map(str).to_s)}"
+  })
+
+  #Unmap a symbol entry
+  VirtualMachine.create_shared_method(')unmap"', VmSpec, [], &lambda {|vm|
+    str = vm.pop.to_s
+    puts "#{str} <= #{(SymbolMap.unmap(str.to_sym).to_s)}"
+  })
+
+  #Start an Interactive RuBy session (IRB)
+  VirtualMachine.create_shared_method(')irb', VmSpec, [], &lambda {|vm|
+    require 'irb'
+    require 'irb/completion'
+
+    puts
+    puts "Starting an IRB console for fOOrth."
+    puts "Enter quit to return to fOOrth."
+    puts
+
+    ARGV.clear
+    IRB.start
+  })
+
+  #Start a Pry session (IRB)
+  VirtualMachine.create_shared_method(')pry', VmSpec, [], &lambda {|vm|
+    require 'pry'
+
+    puts
+    puts "Starting an PRY console for fOOrth."
+    puts "Enter quit to return to fOOrth."
+    puts
+
+    ARGV.clear
+    Pry.start
+  })
+
+  #Get the VM timer start time.
+  VirtualMachine.create_shared_method(')start', VmSpec, [], &lambda {|vm|
+    puts "Start time is #{vm.start_time}"
+  })
+
+  #Reset the VM timer start time.
+  VirtualMachine.create_shared_method(')restart', VmSpec, [], &lambda {|vm|
+    puts "Start time reset to #{(vm.start_time = Time.now)}"
+  })
+
+  #Display the elapsed time.
+  VirtualMachine.create_shared_method(')elapsed', VmSpec, [], &lambda {|vm|
+    puts "Elapsed time is #{Time.now - vm.start_time} seconds"
+  })
+
+  #What time is it now?
+  VirtualMachine.create_shared_method(')time', VmSpec, [], &lambda {|vm|
+    puts "It is now: #{Time.now.strftime(TimeFormat)}"
+  })
+
+  #Load the file as source code.
+  VirtualMachine.create_shared_method(')load"', VmSpec, [], &lambda {|vm|
+    start_time = Time.now
+    file_name = vm.pop.to_s
+
+    if File.extname(file_name) == ''
+      file_name = file_name + '.foorth'
+    end
+
+    if File.exists?(file_name)
+      puts "Loading file: #{file_name}"
+    else
+      error "F50: Unable to locate file #{file_name}"
+    end
+
+    vm.process_file(file_name)
+
+    puts "Completed in #{Time.now - start_time} seconds"
+  })
+
+  #Display the current fOOrth language version.
+  VirtualMachine.create_shared_method(')version', MacroSpec,
+    [:macro, 'puts "fOOrth language system version = #{XfOOrth::VERSION}"; '])
+
+  #Dump the SymbolMap entries.
+  VirtualMachine.create_shared_method(')entries', VmSpec, [], &lambda {|vm|
+    entries = SymbolMap.forward_map.keys.sort
+    puts 'Symbol Map Entries = '
+    entries.foorth_pretty(vm)
+    puts
+  })
+
+  #List the methods defined for this object.
+  Object.create_shared_method(')methods', TosSpec, [], &lambda {|vm|
+    if self.foorth_has_exclusive?
+      puts 'Exclusive Methods = '
+      self.foorth_exclusive.extract_method_names.sort.foorth_pretty(vm)
+    end
+
+    puts "#{self.class.foorth_name} Shared Methods = "
+    self.class.foorth_shared.extract_method_names.sort.foorth_pretty(vm)
+  })
+
+  #List the methods defined for this class.
+  Class.create_shared_method(')methods', TosSpec, [], &lambda {|vm|
+    if self.foorth_has_exclusive?
+      puts "#{self.foorth_name} Class Methods = "
+      self.foorth_exclusive.extract_method_names.sort.foorth_pretty(vm)
+    end
+
+    puts "#{self.foorth_name} Shared Methods = "
+    self.foorth_shared.extract_method_names.sort.foorth_pretty(vm)
+  })
+
+  #List the stubs defined for this class.
+  Class.create_shared_method(')stubs', TosSpec, [], &lambda {|vm|
+    if self.foorth_has_exclusive?
+      puts "#{self.foorth_name} Class Stubs = "
+      self.foorth_exclusive.extract_method_names(:stubs).sort.foorth_pretty(vm)
+    end
+
+    puts "#{self.foorth_name} Shared Stubs = "
+    self.foorth_shared.extract_method_names(:stubs).sort.foorth_pretty(vm)
+  })
+
+
+  #List the classes defined in fOOrth.
+  VirtualMachine.create_shared_method(')classes', VmSpec, [], &lambda {|vm|
+    $FOORTH_GLOBALS.values.
+      select {|entry| entry.has_tag?(:class)}.
+      collect {|spec| spec.new_class.foorth_name}.
+      sort.
+      foorth_pretty(vm)
+  })
+
+  #List the globals defined in fOOrth.
+  VirtualMachine.create_shared_method(')globals', VmSpec, [], &lambda {|vm|
+    $FOORTH_GLOBALS.keys.
+      select {|key| !($FOORTH_GLOBALS[key].has_tag?(:class))}.
+      collect {|key| "#{XfOOrth::SymbolMap.unmap(key)} (#{key.to_s})"}.
+      foorth_pretty(vm)
+  })
+
+  #List the virtual machine methods
+  #List the methods defined for this object.
+  VirtualMachine.create_shared_method(')words', VmSpec, [], &lambda {|vm|
+    if vm.foorth_has_exclusive?
+      puts 'Exclusive Methods = '
+      vm.foorth_exclusive.extract_method_names.sort.foorth_pretty(vm)
+    end
+
+    puts "#{vm.class.foorth_name} Shared Methods = "
+    vm.class.foorth_shared.extract_method_names.sort.foorth_pretty(vm)
+  })
+
+  VirtualMachine.create_shared_method(')threads', VmSpec, [], &lambda {|vm|
+    Thread.list.
+      collect {|thrd| "#{thrd} vm = <#{thrd[:vm].name}>" }.
+      foorth_pretty(vm)
+  })
+end