fOOrth 0.5.0

data/lib/fOOrth/library/sync_bundle_library.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+
+#* library/sync_bundle_library.rb - The fOOrth SyncBundle class library.
+module XfOOrth
+
+  #Define the SyncBundle class.
+  XfOOrth_Bundle.create_foorth_subclass('SyncBundle').new_class
+
+  #The fOOrth Synchronized Bundle class. A bundle contains multiple fibers.
+  class XfOOrth_SyncBundle < XfOOrth_Bundle
+
+    #Build up the synchronized bundle instance
+    def initialize(fibers=[])
+      @sync = Mutex.new
+      super(fibers)
+    end
+
+    #Add the fibers to this bundle.
+    def add_fibers(fibers)
+      @sync.synchronize{super(fibers)}
+    end
+
+    #What is the status of this bundle?
+    def status
+      @sync.synchronize{super}
+    end
+
+    #how many fibers in this bundle?
+    def length
+      @sync.synchronize{super}
+    end
+
+    #Let the fiber run for one step
+    def step(vm)
+      @sync.synchronize{super(vm)}
+    end
+
+  end
+
+  #[an_array_of_procs_fibers_or_bundles] .to_bundle [a_sync_bundle]
+  Array.create_shared_method('.to_sync_bundle', TosSpec, [], &lambda{|vm|
+    vm.push(XfOOrth_SyncBundle.new(self))
+  })
+
+  #[a_proc] .to_bundle [a_bundle]
+  Proc.create_shared_method('.to_sync_bundle', TosSpec, [], &lambda{|vm|
+    vm.push(XfOOrth_SyncBundle.new(self))
+  })
+
+end

data/lib/fOOrth/library/thread_library.rb

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+#* library/thread_library.rb - The thread support fOOrth library.
+module XfOOrth
+
+  #Connect the Thread class to the fOOrth class system.
+  Thread.create_foorth_proxy
+
+  #Class Methods
+
+  Thread.create_exclusive_method('.new', TosSpec, [:stub])
+
+  # [name Thread]  .new{{ ... }} [a_thread]
+  Thread.create_exclusive_method('.new{{', NosSpec, [], &lambda {|vm|
+    block = vm.pop
+    name  = vm.pop.to_s
+    vm.push(block.do_thread_start(vm, name))
+  })
+
+  # [Thread] .current [the current thread]
+  Thread.create_exclusive_method('.current', TosSpec, [], &lambda {|vm|
+    vm.push(Thread.current)
+  })
+
+  # [Thread] .main [the main thread]
+  Thread.create_exclusive_method('.main', TosSpec, [], &lambda {|vm|
+    vm.push(Thread.main)
+  })
+
+  # [Thread] .list [[threads]]
+  Thread.create_exclusive_method('.list', TosSpec, [], &lambda {|vm|
+    vm.push(Thread.list)
+  })
+
+  #Instance Methods
+  # [a thread] .vm [the vm of the thread or nil]
+  Thread.create_shared_method('.vm', TosSpec, [], &lambda {|vm|
+    vm.push(self[:vm])
+  })
+
+  #Pause the current thread.
+  VirtualMachine.create_shared_method('pause', MacroSpec,
+    [:macro, 'Thread.pass; '])
+
+  #Put the current thread to sleep for the specified number of seconds.
+  Numeric.create_shared_method('.sleep', TosSpec, [], &lambda {|vm|
+    sleep(Float.foorth_coerce(self))
+  })
+
+  #Wait for a thread to finish.
+  #[a_thread] .join []
+  Thread.create_shared_method('.join', TosSpec, [], &lambda {|vm|
+    self.join
+  })
+
+  #Is the thread sill alive?
+  #[a_thread] .alive? [a_boolean]
+  Thread.create_shared_method('.alive?', TosSpec, [], &lambda {|vm|
+    vm.push(self.alive?)
+  })
+
+  #What is the status of this thread?
+  #[a_thread] .status ["a_status_string"]
+  Thread.create_shared_method('.status', TosSpec, [], &lambda {|vm|
+    vm.push(self.status || 'dead')
+  })
+
+  #Terminate the given thread.
+  Thread.create_shared_method('.exit', TosSpec, [], &lambda {|vm|
+    self.exit
+  })
+
+end

data/lib/fOOrth/library/time_library.rb

@@ -0,0 +1,302 @@
+# coding: utf-8
+
+require 'time' # Get extended time support.
+
+#* library/time_library.rb - The time support fOOrth library.
+module XfOOrth
+
+  #Connect the Time class to the fOOrth class system
+  Time.create_foorth_proxy
+
+  #Class Methods
+
+  #Stub out .new
+  Time.create_exclusive_method('.new', TosSpec, [:stub])
+
+  # [] now [Time.now]
+  VirtualMachine.create_shared_method('now', MacroSpec,
+    [:macro, "vm.push(Time.now); "])
+
+  VirtualMachine.create_shared_method('local_offset', MacroSpec,
+    [:macro, "vm.push(Time.now.utc_offset); "])
+
+
+  #Instance Methods
+
+  #Helper Methods .to_t and .to_t!
+
+  #[object] .to_t [a_time]
+  Numeric.create_shared_method('.to_t', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Time.at(self))
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  Numeric.create_shared_method('.to_t!', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Time.at(self))
+    rescue
+      error "F40: Cannot convert #{self.to_s} to a Time instance"
+    end
+  })
+
+  Complex.create_shared_method('.to_t',  TosSpec, [:stub])
+  Complex.create_shared_method('.to_t!', TosSpec, [:stub])
+
+  String.create_shared_method('.to_t', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Time.parse(self))
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  String.create_shared_method('.to_t!', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Time.parse(self))
+    rescue
+      error "F40: Cannot convert \"#{self.to_s}\" to a Time instance"
+    end
+  })
+
+  Time.create_shared_method('.to_t', TosSpec, [], &lambda {|vm|
+    vm.push(self.clone)
+  })
+
+  Time.create_shared_method('.to_t!', TosSpec, [], &lambda {|vm|
+    vm.push(self.clone)
+  })
+
+  Array.create_shared_method('.to_t', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Time.new(*self))
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  Array.create_shared_method('.to_t!', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Time.new(*self))
+    rescue
+      error "F40: Cannot convert #{self.to_s} to a Time instance"
+    end
+  })
+
+
+  #Turn a Time value into an Array
+
+  #[time] .to_a [string]
+  Time.create_shared_method('.to_a', TosSpec, [], &lambda {|vm|
+    vm.push([self.year,
+             self.month,
+             self.day,
+             self.hour,
+             self.min,
+             self.sec + self.subsec.to_f,
+             self.utc_offset])
+  })
+
+
+  #Methods to access various attributes of a Time object.
+
+  Time.create_shared_method('.year', TosSpec, [], &lambda {|vm|
+    vm.push(self.year)
+  })
+
+  Time.create_shared_method('.month', TosSpec, [], &lambda {|vm|
+    vm.push(self.month)
+  })
+
+  Time.create_shared_method('.day', TosSpec, [], &lambda {|vm|
+    vm.push(self.day)
+  })
+
+  Time.create_shared_method('.hour', TosSpec, [], &lambda {|vm|
+    vm.push(self.hour)
+  })
+
+  Time.create_shared_method('.minute', TosSpec, [], &lambda {|vm|
+    vm.push(self.min)
+  })
+
+  Time.create_shared_method('.second', TosSpec, [], &lambda {|vm|
+    vm.push(self.sec)
+  })
+
+  Time.create_shared_method('.fraction', TosSpec, [], &lambda {|vm|
+    vm.push(self.subsec.to_f)
+  })
+
+  Time.create_shared_method('.sec_frac', TosSpec, [], &lambda {|vm|
+    vm.push(self.sec + self.subsec.to_f)
+  })
+
+  Time.create_shared_method('.offset', TosSpec, [], &lambda {|vm|
+    vm.push(self.utc_offset)
+  })
+
+
+  #Time zone control
+
+  #[a_time] .utc? [a boolean]
+  Time.create_shared_method('.utc?', TosSpec, [], &lambda {|vm|
+    vm.push(self.utc_offset == 0)
+  })
+
+  #[a_time] .as_utc [a_time]
+  Time.create_shared_method('.as_utc', TosSpec, [], &lambda {|vm|
+    vm.push(self.clone.localtime(0))
+  })
+
+  #[a_time] .as_local [a_time]
+  Time.create_shared_method('.as_local', TosSpec, [], &lambda {|vm|
+    vm.push(self.clone.localtime)
+  })
+
+  #[offset a_time] .as_zone [a_time]
+  Time.create_shared_method('.as_zone', TosSpec, [], &lambda {|vm|
+    offset = Integer.foorth_coerce(vm.pop)
+    vm.push(self.clone.localtime(offset))
+  })
+
+
+  #Turn Time values to/from strings
+
+  #[a_time] .time_s [string]
+  Time.create_shared_method('.time_s', TosSpec, [], &lambda {|vm|
+    vm.push(self.asctime)
+  })
+
+  format_action = lambda {|vm|
+    begin
+      vm.poke(self.strftime(vm.peek));
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  }
+
+  # [a_time a_string] format [a_string]
+  Time.create_shared_method('format', NosSpec, [], &format_action)
+
+  # [a_time] f"string" [a_string]
+  Time.create_shared_method('f"', NosSpec, [], &format_action)
+
+  parse_action = lambda do |vm|
+    fmt = vm.pop
+    src = vm.pop
+
+    begin
+      vm.push(Time.strptime(src, fmt));
+    rescue
+      vm.push(nil)
+    end
+  end
+
+  # [a_string Time a_string] parse [a_time or nil]
+  Time.create_exclusive_method('parse', NosSpec, [], &parse_action)
+
+  # [a_string Time] p"string" [a_time or nil]
+  Time.create_exclusive_method('p"', NosSpec, [], &parse_action)
+
+  parse_bang_action = lambda do |vm|
+    fmt = vm.pop
+    src = vm.pop
+
+    begin
+      vm.push(Time.strptime(src, fmt));
+    rescue
+      error "F40: Cannot parse \"#{src.to_s}\" into a Time instance"
+    end
+  end
+
+  # [a_string Time a_string] parse [a_time or nil]
+  Time.create_exclusive_method('parse!', NosSpec, [], &parse_bang_action)
+
+  # [a_string Time] p"str" [a_time or nil]
+  Time.create_exclusive_method('p!"', NosSpec, [], &parse_bang_action)
+
+
+  #Time comparison operations
+
+  Time.create_shared_method('>', NosSpec, [], &lambda {|vm|
+    begin
+      vm.poke(self.to_f > Float.foorth_coerce(vm.peek))
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+  Time.create_shared_method('>=', NosSpec, [], &lambda {|vm|
+    begin
+      vm.poke(self.to_f >= Float.foorth_coerce(vm.peek))
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+  Time.create_shared_method('<', NosSpec, [], &lambda {|vm|
+    begin
+      vm.poke(self.to_f < Float.foorth_coerce(vm.peek))
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+  Time.create_shared_method('<=', NosSpec, [], &lambda {|vm|
+    begin
+      vm.poke(self.to_f <= Float.foorth_coerce(vm.peek))
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+  Time.create_shared_method('<=>', NosSpec, [], &lambda {|vm|
+    begin
+      vm.poke(self.to_f <=> Float.foorth_coerce(vm.peek))
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+  #Temporal mathematics, no Tardis required.
+
+  #[a_time a_float] + [a_time]
+  Time.create_shared_method('+', NosSpec, [], &lambda {|vm|
+    begin
+      other = vm.peek
+      vm.poke(self + other.to_foorth_r)
+    rescue TypeError
+      vm.data_stack.pop
+      error "F40: Unable to add a Time instance and a #{other.foorth_name}"
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+  #[a_time a_float] - [a_time]
+  #[a_time a_time]  - [a_float]
+  Time.create_shared_method('-', NosSpec, [], &lambda {|vm|
+    begin
+      other = vm.peek
+      result = self - (other.is_a?(Time) ? other : other.to_foorth_r)
+      vm.poke(result.is_a?(Time) ? result : Duration.new(result.rationalize))
+    rescue TypeError
+      vm.data_stack.pop
+      error "F40: Unable to subtract a Time instance and a #{other.foorth_name}"
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+end

data/lib/fOOrth/library/vm_library.rb

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+#* library/class_library.rb - The fOOrth Class class library.
+module XfOOrth
+
+  #Get the VM as a string.
+  # [vm] .to_s ["vm as a string"]
+  VirtualMachine.create_shared_method('.to_s', TosSpec, [],
+    &lambda {|vm| vm.push(self.foorth_name)})
+
+  #Create a macro to get at the current virtual machine instance.
+  # [] vm [the_current_vm]
+  VirtualMachine.create_shared_method('vm', MacroSpec,
+    [:macro, "vm.push(vm); "])
+
+  # [vm] .vm_name ['name']
+  VirtualMachine.create_shared_method('.vm_name', TosSpec, [],
+    &lambda {|vm| vm.push(self.name); })
+
+  # [vm] .dump []
+  VirtualMachine.create_shared_method('.dump', TosSpec, [],
+    &lambda {|vm| self.debug_dump; })
+
+  # Some stack manipulation words.
+  # [a] drop []
+  VirtualMachine.create_shared_method('drop', MacroSpec,
+    [:macro, "vm.pop(); "])
+
+  # [a, b] 2drop []
+  VirtualMachine.create_shared_method('2drop', MacroSpec,
+    [:macro, "vm.popm(2); "])
+
+  # Some stack manipulation words.
+  # [unspecified] clear [];
+  VirtualMachine.create_shared_method('clear', VmSpec, [], &lambda {|vm|
+    vm.data_stack.clear
+  })
+
+  # [a] dup [a, a]
+  VirtualMachine.create_shared_method('dup', MacroSpec,
+    [:macro, "vm.push(vm.peek()); "])
+
+  # [a, b] 2dup [a, b, a, b]
+  VirtualMachine.create_shared_method('2dup', MacroSpec,
+    [:macro, "vm.push(vm.peek(2)); vm.push(vm.peek(2));"])
+
+  # [a] ?dup if a is true then [a,a] else [a]
+  VirtualMachine.create_shared_method('?dup', VmSpec, [],
+    &lambda {|vm| if peek?() then push(peek()); end; })
+
+  # [b,a] swap [a,b]
+  VirtualMachine.create_shared_method('swap', VmSpec, [],
+    &lambda {|vm| vb,va = popm(2); push(va); push(vb); })
+
+  # [c,b,a] rot [b,a,c]
+  VirtualMachine.create_shared_method('rot', VmSpec, [],
+    &lambda {|vm| vc,vb,va = popm(3); push(vb); push(va); push(vc); })
+
+  # [b,a] over [b,a,b]
+  VirtualMachine.create_shared_method('over', MacroSpec,
+    [:macro, "vm.push(vm.peek(2)); "])
+
+  # [di,..d2,d1,i] pick [di,..d2,d1,di]
+  VirtualMachine.create_shared_method('pick', MacroSpec,
+    [:macro, "vm.push(vm.peek(Integer.foorth_coerce(vm.pop()))); "])
+
+  # [b,a] nip [a]
+  VirtualMachine.create_shared_method('nip', MacroSpec,
+    [:macro, "vm.swap_pop(); "])
+
+  # [b,a] tuck [a,b,a]
+  VirtualMachine.create_shared_method('tuck', VmSpec, [],
+    &lambda {|vm| vb,va = popm(2); push(va); push(vb); push(va); })
+
+  #Get the VM timer start time.
+  #[] .start [start_time]
+  VirtualMachine.create_shared_method('.start_time', TosSpec, [], &lambda {|vm|
+    vm.push(vm.start_time)
+  })
+
+  #Reset the VM timer start time.
+  #[] .restart []
+  VirtualMachine.create_shared_method('.restart_timer', TosSpec, [], &lambda {|vm|
+    vm.start_time = Time.now
+  })
+
+  #Get the elapsed time.
+  #[] .elapsed [elapsed_time_in_seconds]
+  VirtualMachine.create_shared_method('.elapsed_time', TosSpec, [], &lambda {|vm|
+    vm.push(Time.now - vm.start_time)
+  })
+
+  #Get the name of the code source.
+  #[] _FILE_ [a_string]
+  VirtualMachine.create_shared_method('_FILE_', VmSpec, [:immediate], &lambda{|vm|
+    file_name = @parser.source.file_name
+
+    if execute_mode?
+      vm.push(file_name)
+    else
+      vm << "vm.push(#{file_name.inspect})"
+    end
+  })
+
+end