fOOrth 0.5.0

data/lib/fOOrth/library/object_library.rb

@@ -0,0 +1,80 @@
+# coding: utf-8
+
+#* library/object_library.rb - The fOOrth Object class library.
+module XfOOrth
+
+  #The .class method. This allows the class of any object to be determined.
+  # [obj] .class [class_of(obj)]
+  Object.create_shared_method('.class', TosSpec, [],
+    &lambda {|vm| vm.push(self.class)})
+
+  # Some basic "constant" value words.
+  #The self method.
+  # [] self [self]
+  VirtualMachine.create_shared_method('self', MacroSpec, [:macro, "vm.push(self); "])
+
+  #Get the name of an object or class.
+  # [obj] .with{{ ... }} [] Execute the block with self set to obj
+  Object.create_shared_method('.with{{', NosSpec, [], &lambda {|vm|
+    block = vm.pop
+    self.instance_exec(vm, nil, nil, &block)
+  })
+
+  #Get the name of an object or class.
+  # [obj] .name ["name of obj"]
+  Object.create_shared_method('.name', TosSpec, [],
+    &lambda {|vm| vm.push(self.foorth_name)})
+
+  #Get the object as a string.
+  # [obj] .to_s ["obj as a string"]
+  Object.create_shared_method('.to_s', TosSpec, [],
+    &lambda {|vm| vm.push(self.to_s)})
+
+  #Get the length of the object as a string.
+  # [obj] .strlen [n]; the length of the object's to_s string
+  Object.create_shared_method('.strlen', TosSpec, [],
+    &lambda {|vm| self.to_foorth_s(vm); vm.poke(vm.peek.length)})
+
+  # Some comparison words.
+  # [b,a] = if b == a then [true] else [false]
+  Object.create_shared_method('=', NosSpec, [],
+    &lambda {|vm| vm.poke(self == vm.peek); })
+
+  # [b,a] <> if b != a then [true] else [false]
+  Object.create_shared_method('<>', NosSpec, [],
+    &lambda {|vm| vm.poke(self != vm.peek); })
+
+
+  # Some identity comparison words.
+  # [b,a] identical? if b.object_id == a.object_id then [true] else [false]
+  Object.create_shared_method('identical?', NosSpec, [],
+    &lambda {|vm| vm.poke(self.object_id == vm.peek.object_id); })
+
+  # [b,a] distinct? if b.object_id != a.object_id then [true] else [false]
+  Object.create_shared_method('distinct?', NosSpec, [],
+    &lambda {|vm| vm.poke(self.object_id != vm.peek.object_id); })
+
+
+  # [b,a] max [max(b,a)]
+  Object.create_shared_method('max', NosSpec, [], &lambda {|vm|
+    begin
+      other = vm.peek
+      vm.poke((self > self.foorth_coerce(other)) ? self : other)
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+  # [b,a] min [min(b,a)]
+  Object.create_shared_method('min', NosSpec, [], &lambda {|vm|
+    begin
+      other = vm.peek
+      vm.poke((self < self.foorth_coerce(other)) ? self : other)
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+end

data/lib/fOOrth/library/other_value_types_library.rb

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+#* library/other_value_types_library.rb - Support for true, false, and nil in
+#  the fOOrth library.
+module XfOOrth
+
+  # Connect the TrueClass class to the fOOrth class system.
+  TrueClass.create_foorth_proxy('True')
+
+  # [] true [true]
+  VirtualMachine.create_shared_method('true', MacroSpec, [:macro, "vm.push(true); "])
+
+  #Connect the FalseClass class to the fOOrth class system.
+  FalseClass.create_foorth_proxy('False')
+
+  # [] false [false]
+  VirtualMachine.create_shared_method('false', MacroSpec, [:macro, "vm.push(false); "])
+
+  # Connect the NilClass class to the fOOrth class system.
+  NilClass.create_foorth_proxy('Nil')
+
+  # [] nil [nil]
+  VirtualMachine.create_shared_method('nil', MacroSpec, [:macro, "vm.push(nil); "])
+
+
+  # Some boolean operation words.
+
+  # [b,a] && [b&a]
+  Object.create_shared_method('&&', TosSpec, [],
+    &lambda {|vm| vm.poke(vm.peek?); })
+  FalseClass.create_shared_method('&&', TosSpec, [],
+    &lambda {|vm| vm.poke(false); })
+  NilClass.create_shared_method('&&', TosSpec, [],
+    &lambda {|vm| vm.poke(false); })
+
+  # [b,a] || [b|a]
+  Object.create_shared_method('||', TosSpec, [],
+    &lambda {|vm| vm.poke(true); })
+  FalseClass.create_shared_method('||', TosSpec, [],
+    &lambda {|vm| vm.poke(vm.peek?); })
+  NilClass.create_shared_method('||', TosSpec, [],
+    &lambda {|vm| vm.poke(vm.peek?); })
+
+  # [b,a] ^^ [b^a]
+  Object.create_shared_method('^^', TosSpec, [],
+    &lambda {|vm| vm.poke(!vm.peek?); })
+  FalseClass.create_shared_method('^^', TosSpec, [],
+    &lambda {|vm| vm.poke(vm.peek?); })
+  NilClass.create_shared_method('^^', TosSpec, [],
+    &lambda {|vm| vm.poke(vm.peek?); })
+
+  # [a] not [!a]
+  Object.create_shared_method('not', TosSpec, [],
+    &lambda {|vm| vm.push(false); })
+  FalseClass.create_shared_method('not', TosSpec, [],
+    &lambda {|vm| vm.push(true); })
+  NilClass.create_shared_method('not', TosSpec, [],
+    &lambda {|vm| vm.push(true); })
+
+
+  # Some nil operation words
+
+  # [a] =nil [true/false]
+  Object.create_shared_method('nil=', TosSpec, [],
+    &lambda {|vm| vm.push(false); })
+  NilClass.create_shared_method('nil=', TosSpec, [],
+    &lambda {|vm| vm.push(true); })
+
+  # [a] <>nil [true/false]
+  Object.create_shared_method('nil<>', TosSpec, [],
+    &lambda {|vm| vm.push(true); })
+  NilClass.create_shared_method('nil<>', TosSpec, [],
+    &lambda {|vm| vm.push(false); })
+
+
+  # Special Float values.
+
+  # [] epsilon [Float::EPSILON]
+  VirtualMachine.create_shared_method('epsilon', MacroSpec, [:macro, "vm.push(Float::EPSILON); "])
+
+  # [] infinity [Float::INFINITY]
+  VirtualMachine.create_shared_method('infinity', MacroSpec, [:macro, "vm.push(Float::INFINITY); "])
+
+  # [] -infinity [-Float::INFINITY]
+  VirtualMachine.create_shared_method('-infinity', MacroSpec, [:macro, "vm.push(-Float::INFINITY); "])
+
+  # [] max_float [Float::MAX]
+  VirtualMachine.create_shared_method('max_float', MacroSpec, [:macro, "vm.push(Float::MAX); "])
+
+  # [] min_float [Float::MIN]
+  VirtualMachine.create_shared_method('min_float', MacroSpec, [:macro, "vm.push(Float::MIN); "])
+
+  # [] nan [Float::NAN]
+  VirtualMachine.create_shared_method('nan', MacroSpec, [:macro, "vm.push(Float::NAN); "])
+
+end

data/lib/fOOrth/library/out_stream_library.rb

@@ -0,0 +1,146 @@
+# coding: utf-8
+
+#* library/in_stream_library.rb - The fOOrth InStream class library.
+module XfOOrth
+
+  out_stream = Object.create_foorth_subclass('OutStream').new_class
+
+  #* The fOOrth InStream file input mini-class.
+  class XfOOrth_OutStream
+
+    #The file used to perform the actual input operations.
+    attr_reader :file
+
+    #Set up the OutStream for the given file name.
+    #<br>Parameters
+    #* file_name - The name of the file.
+    #* file_mode - The mode to use opening the file. Either 'w' or 'a'
+    def initialize(file_name, file_mode)
+      @file = File.new(file_name, file_mode)
+    rescue
+      error "F51: Unable to open the file #{file_name} for writing."
+    end
+
+  end
+
+  #The .new method is stubbed out.
+  out_stream.create_exclusive_method('.new', TosSpec, [:stub])
+
+  # ["file_name" OutStream] .create [an_outstream]
+  out_stream.create_exclusive_method('.create', TosSpec, [], &lambda {|vm|
+    file_name = vm.pop.to_s
+    vm.push(XfOOrth_OutStream.new(file_name, 'w'))
+  })
+
+  # ["file_name" OutStream] .create{{ ... }} []
+  out_stream.create_exclusive_method('.create{{', TosSpec, [], &lambda {|vm|
+    block = vm.pop
+    file_name = vm.pop.to_s
+    out_stream = XfOOrth_OutStream.new(file_name, 'w')
+
+    begin
+      out_stream.instance_exec(vm, nil, nil, &block)
+    ensure
+      out_stream.file.close
+    end
+  })
+
+  # ["file_name" OutStream] .append{{ ... }} []
+  out_stream.create_exclusive_method('.append{{', TosSpec, [], &lambda {|vm|
+    block = vm.pop
+    file_name = vm.pop.to_s
+    out_stream = XfOOrth_OutStream.new(file_name, 'a')
+
+    begin
+      out_stream.instance_exec(vm, nil, nil, &block)
+    ensure
+      out_stream.file.close
+    end
+  })
+
+  # ["file_name" OutStream] .append [an_outstream]
+  out_stream.create_exclusive_method('.append', TosSpec, [], &lambda {|vm|
+    file_name = vm.pop.to_s
+    vm.push(XfOOrth_OutStream.new(file_name, 'a'))
+  })
+
+  # [an_outstream] .close []
+  out_stream.create_shared_method('.close', TosSpec, [], &lambda {|vm|
+    file.close
+  })
+
+  #[obj an_outstream] . []; print out the object as a string to the OutStream instance.
+  out_stream.create_shared_method('.', TosSpec, [],
+    &lambda {|vm| file << vm.pop})
+
+  #{self = an_outstream} [obj] ~ []; print out the object as a string to the OutStream self.
+  out_stream.create_shared_method('~', SelfSpec, [],
+    &lambda {|vm| file << vm.pop})
+
+  #{self = an_outstream} [] ~"a string" []; print out the string to the OutStream self.
+  out_stream.create_shared_method('~"', SelfSpec, [],
+    &lambda {|vm| file << vm.pop })
+
+
+  #[obj an_outstream] .emit []; print out a character to the OutStream.
+  out_stream.create_shared_method('.emit', TosSpec, [],
+    &lambda {|vm| file << vm.pop.to_foorth_c})
+
+  #{self = an_outstream} [obj] ~emit []; print out a character to the OutStream self.
+  out_stream.create_shared_method('~emit', SelfSpec, [],
+    &lambda {|vm| file << vm.pop.to_foorth_c})
+
+
+  #[an_outstream] .cr []; print out a newline to the OutStream instance.
+  out_stream.create_shared_method('.cr', TosSpec, [],
+    &lambda {|vm| file << "\n"})
+
+  #{self = an_outstream} [] ~cr []; print out a newline to the OutStream self.
+  out_stream.create_shared_method('~cr', SelfSpec, [],
+    &lambda {|vm| file << "\n"})
+
+
+  #[an_outstream] .space []; print out a space to the OutStream instance.
+  out_stream.create_shared_method('.space', TosSpec, [],
+    &lambda {|vm| file << " "})
+
+  #{self = an_outstream} [] ~space []; print out a space to the OutStream self.
+  out_stream.create_shared_method('~space', SelfSpec, [],
+    &lambda {|vm| file << " "})
+
+
+  #[count an_outstream] .spaces []; print out spaces to the OutStream instance.
+  out_stream.create_shared_method('.spaces', TosSpec, [],
+    &lambda {|vm| file << " " * Integer.foorth_coerce(vm.pop())})
+
+  #{self = an_outstream} [count] ~spaces []; print out spaces to the OutStream self.
+  out_stream.create_shared_method('~spaces', SelfSpec, [],
+    &lambda {|vm| file << " " * Integer.foorth_coerce(vm.pop())})
+
+  # [text_array "file_name" OutStream] .put_all []; Write the array to file_name
+  out_stream.create_exclusive_method('.put_all', TosSpec, [], &lambda {|vm|
+    file_name = vm.pop.to_s
+    file_source = vm.pop
+    out_stream = XfOOrth_OutStream.new(file_name, 'w')
+
+    begin
+      file_source.each {|line| out_stream.file.puts(line) }
+    ensure
+      out_stream.file.close
+    end
+  })
+
+  # [text_array "file_name" OutStream] .append_all []; Append the array to file_name
+  out_stream.create_exclusive_method('.append_all', TosSpec, [], &lambda {|vm|
+    file_name = vm.pop.to_s
+    file_source = vm.pop
+    out_stream = XfOOrth_OutStream.new(file_name, 'a')
+
+    begin
+      file_source.each {|line| out_stream.file.puts(line) }
+    ensure
+      out_stream.file.close
+    end
+  })
+
+end

data/lib/fOOrth/library/procedure_library.rb

@@ -0,0 +1,65 @@
+# coding: utf-8
+
+#* library/procedure_library.rb - Proc support for the fOOrth library.
+module XfOOrth
+
+  #Connect the Proc class to the fOOrth class system.
+  Proc.create_foorth_proxy('Procedure')
+
+  # A no operation place holder for procedure literals
+  VirtualMachine.create_shared_method('{{', MacroSpec, [:macro, " "])
+
+  # [procedure] .call [unspecified]
+  Proc.create_shared_method('.call', TosSpec, [],
+    &lambda {|vm| self.call(vm); })
+
+  # [owner procedure] .call_with [unspecified]
+  Proc.create_shared_method('.call_with', TosSpec, [],
+    &lambda {|vm| vm.pop.instance_exec(vm, &self); })
+
+  # [v procedure] .call_v [unspecified]
+  Proc.create_shared_method('.call_v', TosSpec, [],
+    &lambda {|vm| value = vm.pop; self.call(vm, value); })
+
+  # [x procedure] .call_x [unspecified]
+  Proc.create_shared_method('.call_x', TosSpec, [],
+    &lambda {|vm| index = vm.pop; self.call(vm, nil, index); })
+
+  # [v x procedure] .call_vx [unspecified]
+  Proc.create_shared_method('.call_vx', TosSpec, [],
+    &lambda {|vm| value, index = vm.popm(2); self.call(vm, value, index); })
+
+  # [procedure] .start [a_thread]
+  Proc.create_shared_method('.start', TosSpec, [], &lambda {|vm|
+    vm.push(self.do_thread_start(vm, '-'))
+  })
+
+  # [name procedure] .start_named [a_thread]
+  Proc.create_shared_method('.start_named', TosSpec, [], &lambda {|vm|
+    vm.push(self.do_thread_start(vm, vm.pop.to_s))
+  })
+
+end
+
+#A helper method in the Proc class for fOOrth threads.
+class Proc
+  #Do the mechanics of starting a thread.
+  def do_thread_start(vm, vm_name)
+    block, interlock = self, Queue.new
+
+    result = Thread.new(vm.foorth_copy(vm_name)) do |vm_copy|
+
+      begin
+        self.foorth_init(vm_copy.compiler_reset.connect_vm_to_thread)
+      ensure
+        interlock.push(:ready)
+      end
+
+      vm_copy.instance_exec(vm_copy, &block)
+    end
+
+    interlock.pop
+    result
+  end
+end
+

data/lib/fOOrth/library/queue_library.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+require 'thread'
+
+#* library/queue_library.rb - The Queue support fOOrth library.
+module XfOOrth
+
+  #Connect the Queue class to the fOOrth class system.
+  Queue.create_foorth_proxy("Queue")
+
+  #Uses the default implementation of the .new method.
+
+  # [v queue] .push []; v is pushed onto the queue
+  Queue.create_shared_method('.push', TosSpec, [], &lambda {|vm|
+    self.push(vm.pop)
+  })
+
+  # [queue] .pop [v]; v is popped from the queue
+  Queue.create_shared_method('.pop', TosSpec, [], &lambda {|vm|
+    if self.length > 0
+      vm.push(self.pop)
+    else
+      error "F31: Queue Underflow: .pop"
+    end
+  })
+
+  # [queue] .pend [v]; v is popped from the queue, will pend for data.
+  Queue.create_shared_method('.pend', TosSpec, [], &lambda {|vm|
+    vm.push(self.pop)
+  })
+
+  # [queue] .empty? [a_boolean]
+  Queue.create_shared_method('.empty?', TosSpec, [], &lambda {|vm|
+    vm.push(self.empty?)
+  })
+
+  # [queue] .length [an_integer]
+  Queue.create_shared_method('.length', TosSpec, [], &lambda {|vm|
+    vm.push(self.length)
+  })
+
+  # [queue] .clear []
+  Queue.create_shared_method('.clear', TosSpec, [], &lambda {|vm|
+    self.clear
+  })
+
+end

data/lib/fOOrth/library/rational_library.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+#* library/rational_library.rb - Numeric support for the fOOrth library.
+module XfOOrth
+
+  #Connect the Rational class to the fOOrth class system.
+  Rational.create_foorth_proxy
+
+  # Some conversion words.
+  # [n d] rational [n/d]
+  VirtualMachine.create_shared_method('rational', VmSpec, [], &lambda {|vm|
+    num,den = popm(2)
+
+    begin
+      push(Rational(num.to_foorth_r, den.to_foorth_r))
+    rescue
+      push(nil)
+    end
+  })
+
+  # Some conversion words.
+  # [n d] rational! [n/d]
+  VirtualMachine.create_shared_method('rational!', VmSpec, [], &lambda {|vm|
+    num,den = popm(2)
+
+    begin
+      push(Rational(num.to_foorth_r, den.to_foorth_r))
+    rescue
+      error "F40: Cannot coerce a #{num.foorth_name}, #{den.foorth_name} to a Rational"
+    end
+  })
+
+  # [err_limit float] .rationalize_to [rational]
+  Numeric.create_shared_method('.rationalize_to', TosSpec, [], &lambda {|vm|
+    err_limit = Float.foorth_coerce(vm.pop)
+
+    vm.push(self.rationalize(err_limit))
+  })
+
+  Complex.create_shared_method('.rationalize_to', TosSpec, [:stub])
+
+  # [rational] .split [numerator, denominator]
+  Rational.create_shared_method('.split', TosSpec, [],
+    &lambda {|vm| vm.push(self.numerator); vm.push(self.denominator); })
+
+  # [a] .to_r [n/d]
+  Object.create_shared_method('.to_r', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Rational(self))
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  # [a] .to_r! [n/d]
+  Object.create_shared_method('.to_r!', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(Rational(self))
+    rescue
+      error "F40: Cannot convert a #{self.foorth_name} to a Rational instance"
+    end
+  })
+
+  # [a_float] .to_r [n/d]
+  Float.create_shared_method('.to_r', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(self.rationalize)
+    rescue
+      vm.push(nil)
+    end
+  })
+
+  # [a_float] .to_r! [n/d]
+  Float.create_shared_method('.to_r!', TosSpec, [], &lambda {|vm|
+    begin
+      vm.push(self.rationalize)
+    rescue
+      error "F40: Cannot convert a #{self.foorth_name} to a Rational instance"
+    end
+  })
+
+  # [n/d] .numerator [n]
+  Numeric.create_shared_method('.numerator', TosSpec, [],
+    &lambda {|vm| vm.push(self.numerator); })
+
+  # [n/d] .denominator [d]
+  Numeric.create_shared_method('.denominator', TosSpec, [],
+    &lambda {|vm| vm.push(self.denominator); })
+
+end