fOOrth 0.6.6 → 0.6.11

data/lib/fOOrth/library/procedure_library.rb

@@ -1,65 +1,69 @@
-# 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.freeze))
-  })
-
-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
-
+# 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. This may seem odd but
+  # works because any word ending in '{{' is assumed to have a procedure literal
+  # attached to it. This is handled in compiler/process/procedure.rb. This code
+  # handles compiling the procedure and pushing a reference to it on the stack.
+  # Once this is done, this word need do nothing further so is a no-op.
+  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.freeze))
+  })
+
+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

@@ -34,13 +34,18 @@ module XfOOrth
     vm.push(self.empty?)
   })
 
+  # [queue] .present? [a_boolean]
+  Queue.create_shared_method('.present?', 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|
+  Queue.create_shared_method('.clear!', TosSpec, [], &lambda {|vm|
     self.clear
   })
 

data/lib/fOOrth/library/rational_library.rb

@@ -1,90 +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); })
-
+# 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

data/lib/fOOrth/library/stack_library.rb

@@ -14,7 +14,7 @@ module XfOOrth
   })
 
   #Clear the Stack object.
-  stack.create_shared_method('.clear', TosSpec, [], &lambda {|vm|
+  stack.create_shared_method('.clear!', TosSpec, [], &lambda {|vm|
     @data.clear
   })
 
@@ -46,6 +46,11 @@ module XfOOrth
     vm.push(@data.empty?)
   })
 
+  #[stack] .present? [a_boolean]
+  stack.create_shared_method('.present?', TosSpec, [], &lambda {|vm|
+    vm.push(!@data.empty?)
+  })
+
   #[stack] .length [an_integer]
   stack.create_shared_method('.length', TosSpec, [], &lambda {|vm|
     vm.push(@data.length)

data/lib/fOOrth/library/stdio_library.rb

@@ -1,6 +1,11 @@
 # coding: utf-8
 
 #Load up some pretty printing support.
+require_relative 'formatting/nil'
+require_relative 'formatting/object'
+require_relative 'formatting/string'
+require_relative 'formatting/array'
+require_relative 'formatting/hash'
 require_relative 'formatting/columns'
 require_relative 'formatting/bullets'
 
@@ -65,7 +70,7 @@ module XfOOrth
 
   symbol = :chars_per_line
   $chars_per_line = [80]
-  SymbolMap.add_entry('$chars_per_line', :chars_per_line)
+  SymbolMap.add_entry('$chars_per_line', symbol)
   $FOORTH_GLOBALS[symbol] = GlobalVarSpec.new('$chars_per_line', symbol, [])
 
   #Show the page length.
@@ -86,24 +91,22 @@ module XfOOrth
 
   # [ l 2 3 ... n ] .pp []; pretty print the array!
   Array.create_shared_method('.pp', TosSpec, [], &lambda {|vm|
-    puts_foorth_columnized($lines_per_page[0], $chars_per_line[0])
+    puts_foorth_columns($lines_per_page[0], $chars_per_line[0])
   })
 
   # [ l 2 3 ... n ] .format_columns []; format to strings with columns.
   Array.create_shared_method('.format_columns', TosSpec, [], &lambda {|vm|
-    vm.push(foorth_columnize($lines_per_page[0], $chars_per_line[0])
-      .map {|page| page << ""}
-      .flatten[0...-1])
+    vm.push(format_foorth_columns($lines_per_page[0], $chars_per_line[0]))
   })
 
   # [ l 2 3 ... n ] .print_columns []; pretty print columns.
   Array.create_shared_method('.print_columns', TosSpec, [], &lambda {|vm|
-    puts_foorth_columnized($lines_per_page[0], $chars_per_line[0])
+    puts_foorth_columns($lines_per_page[0], $chars_per_line[0])
   })
 
   #[["1" "stuff"] ["two" stuff] .format_bullets; format to strings with bullets.
   Array.create_shared_method('.format_bullets', TosSpec, [], &lambda {|vm|
-    vm.push(foorth_bulletize($chars_per_line[0]))
+    vm.push(foorth_format_bullets($chars_per_line[0]))
   })
 
   #[["1" "stuff"] ["two" stuff] .print_bullets; pretty print bullet points.
@@ -113,7 +116,7 @@ module XfOOrth
 
   #{ "1" "stuff" -> "two" "stuff" -> } .format_bullets; format to strings with bullets.
   Hash.create_shared_method('.format_bullets', TosSpec, [], &lambda {|vm|
-    vm.push(foorth_bulletize($chars_per_line[0]))
+    vm.push(foorth_format_bullets($chars_per_line[0]))
   })
 
   #{ "1" "stuff" -> "two" "stuff" -> } .print_bullets; pretty print bullet points.

data/lib/fOOrth/library/string_library.rb

@@ -211,33 +211,48 @@ module XfOOrth
 
   # ['fgh' 'abcdefgh'] .right? [boolean]
   String.create_shared_method('.right?', TosSpec, [],
-    &lambda {|vm| vm.poke(self.end_with?(vm.peek)); })
+    &lambda {|vm| vm.poke(self.end_with?(vm.peek)) })
 
   #Other String Methods
 
   # ['cde' 'abcdefgh'] .contains? [boolean]
   String.create_shared_method('.contains?', TosSpec, [],
-    &lambda {|vm| vm.poke(self.index(vm.peek).to_foorth_b); })
+    &lambda {|vm| vm.poke(self.index(vm.peek).to_foorth_b) })
 
   # ['cde' 'abcdefgh'] .posn [position or nil]
   String.create_shared_method('.posn', TosSpec, [],
-    &lambda {|vm| vm.poke(self.index(vm.peek)); })
+    &lambda {|vm| vm.poke(self.index(vm.peek)) })
 
   # ["a"] .length [n]
   String.create_shared_method('.length', TosSpec, [],
     &lambda {|vm| vm.push(self.length); })
 
+  # ["a"] .empty? [a_boolean]
+  String.create_shared_method('.empty?', TosSpec, [],
+    &lambda {|vm| vm.push(self.empty?) })
+
+  # ["a"] .present? [a_boolean]
+  String.create_shared_method('.present?', TosSpec, [],
+    &lambda {|vm| vm.push(!self.empty?) })
+
+  # ["a"] .clear! [a_boolean]
+  StringBuffer.create_shared_method('.clear!', TosSpec, [],
+    &lambda {|vm| self.clear })
+
   # ["b", a] + ["ba"]; "ba" is a new object, distinct from "b"
   String.create_shared_method('+', NosSpec, [],
     &lambda {|vm| vm.poke((self + vm.peek.to_s).freeze) })
 
+  # ["b", a] << [error]; Bug patch. Not fully understood.
+  String.create_shared_method('<<', NosSpec, [:stub])
+
   # ["b"*, a] << ["ba"*]; "ba"* is the same object as "b"*
   StringBuffer.create_shared_method('<<', NosSpec, [],
     &lambda {|vm| vm.poke(self << vm.peek.to_s); })
 
   # ["b"*, a] >> ["ab"*]; "ab"* is the same object as "b"*
   StringBuffer.create_shared_method('>>', NosSpec, [],
-    &lambda {|vm| vm.poke(self.prepend(vm.peek.to_s)); })
+    &lambda {|vm| vm.poke(self.prepend(vm.peek.to_s)) })
 
   # ["b", n] * ["bbb..."]
   String.create_shared_method('*', NosSpec, [], &lambda {|vm|
@@ -267,7 +282,7 @@ module XfOOrth
 
   # ["stressed"] .reverse ["desserts"]
   String.create_shared_method('.reverse', TosSpec, [],
-    &lambda {|vm| vm.push(self.to_s.reverse.freeze); })
+    &lambda {|vm| vm.push(self.to_s.reverse.freeze) })
 
   # ["stressed"*] .reverse* [] #Reverse the string in place.
   StringBuffer.create_shared_method('.reverse*', TosSpec, [],
@@ -318,7 +333,7 @@ module XfOOrth
 
   # [a_string] .shell []
   String.create_shared_method('.shell', TosSpec, [], &lambda {|vm|
-    system(self)
+    system(self.chomp + "\n")
   })
 
   # [a_string] .shell_out [a_string]