fOOrth 0.5.0

data/lib/fOOrth/library/stack_library.rb

@@ -0,0 +1,56 @@
+# 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.
+  stack = Object.create_foorth_subclass('Stack').new_class
+
+  #Uses the default implementation of the .new method.
+
+  #Initialize the Stack object.
+  stack.create_shared_method('.init', TosSpec, [], &lambda {|vm|
+    @data = []
+  })
+
+  #Clear the Stack object.
+  stack.create_shared_method('.clear', TosSpec, [], &lambda {|vm|
+    @data.clear
+  })
+
+  #[v stack] .push []; pushes the v onto the stack.
+  stack.create_shared_method('.push', TosSpec, [], &lambda {|vm|
+    @data << vm.pop
+  })
+
+  #[stack] .pop [v]; pops the v from the stack.
+  stack.create_shared_method('.pop', TosSpec, [], &lambda {|vm|
+    if @data.length > 0
+      vm.push(@data.pop)
+    else
+      error "F31: Stack Underflow: .pop"
+    end
+  })
+
+  #[stack] .peek [v]; sneaks a peek at the top item of the stack.
+  stack.create_shared_method('.peek', TosSpec, [], &lambda {|vm|
+    if @data.length > 0
+      vm.push(@data[-1])
+    else
+      error "F31: Stack Underflow: .peek"
+    end
+  })
+
+  #[stack] .empty? [a_boolean]
+  stack.create_shared_method('.empty?', TosSpec, [], &lambda {|vm|
+    vm.push(@data.empty?)
+  })
+
+  #[stack] .length [an_integer]
+  stack.create_shared_method('.length', TosSpec, [], &lambda {|vm|
+    vm.push(@data.length)
+  })
+
+end

data/lib/fOOrth/library/stdio_library.rb

@@ -0,0 +1,56 @@
+# coding: utf-8
+
+#* library/stdio_library.rb - The standard I/O fOOrth library.
+module XfOOrth
+
+  # Some basic console I/O words.
+  #[obj] . []; print out the object as a string.
+  Object.create_shared_method('.', TosSpec, [], &lambda {|vm|
+    self.to_foorth_s(vm)
+    print vm.pop
+  })
+
+  #Print out a string.
+  # [] ."string" []; prints out the string.
+  String.create_shared_method('."', TosSpec, [], &lambda {|vm|
+    print self
+  })
+
+  #Force a new line.
+  # [] cr []; prints a new line.
+  VirtualMachine.create_shared_method('cr', MacroSpec,
+    [:macro, "puts; "])
+
+  #Force a space.
+  # [] space []; prints a space
+  VirtualMachine.create_shared_method('space', MacroSpec,
+    [:macro, "print ' '; "])
+
+  #Force multiple spaces.
+  # [n] spaces []; prints n spaces.
+  VirtualMachine.create_shared_method('spaces', MacroSpec,
+    [:macro, "print ' ' * Integer.foorth_coerce(vm.pop()); "])
+
+  #Print out a single character.
+  #[obj] .emit []; print out the object as a character.
+  Numeric.create_shared_method('.emit', TosSpec, [],
+    &lambda {|vm| print self.to_foorth_c})
+  String.create_shared_method('.emit', TosSpec, [],
+    &lambda {|vm| print self.to_foorth_c})
+  Complex.create_shared_method('.emit', TosSpec, [:stub])
+
+  #Get a string from the console.
+  # [] accept [string]; gets a string from the console.
+  VirtualMachine.create_shared_method('accept', VmSpec, [],
+    &lambda {|vm| push(MiniReadline.readline('? ', true)); })
+
+  #Get a string from the console.
+  # [] accept"prompt" [string]; gets a string from the console.
+  VirtualMachine.create_shared_method('accept"', VmSpec, [],
+    &lambda {|vm| poke(MiniReadline.readline(peek.to_s, true)); })
+
+  #Get a string from the console.
+  # "prompt" [] .accept [string]; gets a string from the console.
+  String.create_shared_method('.accept', TosSpec, [],
+    &lambda{|vm|  vm.push(MiniReadline.readline(self, true))})
+end

data/lib/fOOrth/library/string_library.rb

@@ -0,0 +1,285 @@
+# coding: utf-8
+
+#* library/string_library.rb - String support for the fOOrth library.
+module XfOOrth
+
+  #Connect the String class to the fOOrth class system.
+  String.create_foorth_proxy
+
+  # A no operation place holder for string literals
+  VirtualMachine.create_shared_method('"', MacroSpec, [:macro, " "])
+
+  # [string] .each{{ ... }} [unspecified]
+  String.create_shared_method('.each{{', NosSpec, [], &lambda { |vm|
+    block, idx = vm.pop, 0
+    self.chars { |val| block.call(vm, val, idx); idx += 1 }
+  })
+
+  #Some comparison operators
+  # [b,a] > if b > a then [true] else [false]
+  String.create_shared_method('>', NosSpec, [],
+    &lambda {|vm| vm.poke(self > vm.peek.to_s); })
+
+  # [b,a] < if b < a then [true] else [false]
+  String.create_shared_method('<', NosSpec, [],
+    &lambda {|vm| vm.poke(self < vm.peek.to_s); })
+
+  # [b,a] >= if b >= a then [true] else [false]
+  String.create_shared_method('>=', NosSpec, [],
+    &lambda {|vm| vm.poke(self >= vm.peek.to_s); })
+
+  # [b,a] <= if b <= a then [true] else [false]
+  String.create_shared_method('<=', NosSpec, [],
+    &lambda {|vm| vm.poke(self <= vm.peek.to_s); })
+
+  # [b,a] <=> if b <=> a then [true] else [false]
+  String.create_shared_method('<=>', NosSpec, [],
+    &lambda {|vm| vm.poke(self <=> vm.peek.to_s); })
+
+
+  #Some string manipulation methods.
+  # [n a] .ljust ['a    ']; left justify
+  String.create_shared_method('.ljust', TosSpec, [],
+    &lambda {|vm| vm.poke(self.ljust(Integer.foorth_coerce(vm.peek))); })
+
+  # [n a] .cjust ['  a  ']; center justify
+  String.create_shared_method('.cjust', TosSpec, [],
+    &lambda {|vm| vm.poke(self.center(Integer.foorth_coerce(vm.peek))); })
+
+  # [n a] .rjust ['    a']; right justify
+  String.create_shared_method('.rjust', TosSpec, [],
+    &lambda {|vm| vm.poke(self.rjust(Integer.foorth_coerce(vm.peek))); })
+
+  # ["  a  "] .lstrip ["a  "]; left strip
+  String.create_shared_method('.lstrip', TosSpec, [],
+    &lambda {|vm| vm.push(self.lstrip); })
+
+  # ["  a  "] .strip ["a"]; left and right strip
+  String.create_shared_method('.strip', TosSpec, [],
+    &lambda {|vm| vm.push(self.strip); })
+
+  # ["  a  "] .rstrip ["  a"]; right strip
+  String.create_shared_method('.rstrip', TosSpec, [],
+    &lambda {|vm| vm.push(self.rstrip); })
+
+  format_action = lambda do |vm|
+    begin
+      vm.poke(vm.peek % self.in_array)
+    rescue => err
+      vm.data_stack.pop
+      error "F40: Formating error: #{err.message}."
+    end
+  end
+
+  # [object_or_array fmt_str] format ['a formatted string']
+  Object.create_shared_method('format', NosSpec, [], &format_action)
+
+  # [object_or_array] f"fmt_str" ['a formatted string']
+  Object.create_shared_method('f"', NosSpec, [], &format_action)
+
+  parse_action = lambda {|vm| vm.poke(self.sscanf(vm.peek))}
+
+  # [a_str fmt_str] parse [result_array]
+  String.create_shared_method('parse', NosSpec, [], &parse_action)
+
+  # [a_str] p"fmt_str" [result_array]
+  String.create_shared_method('p"', NosSpec, [], &parse_action)
+
+
+  #LEFT Group
+
+  # [w 'abcdefgh'] .left ['ab']         // Assumes w = 2
+  String.create_shared_method('.left', TosSpec, [],
+    &lambda {|vm| vm.poke(self[0...(Integer.foorth_coerce(vm.peek))]); })
+
+  # [w 'abcdefgh'] .-left ['cdefgh']    // Assumes w = 2
+  String.create_shared_method('.-left', TosSpec, [],
+    &lambda {|vm| vm.poke(self[(Integer.foorth_coerce(vm.peek))..-1]); })
+
+  # [w '123''abcdefgh'] .+left ['123cdefgh']    // Assumes w = 2
+  String.create_shared_method('.+left', TosSpec, [], &lambda {|vm|
+    ins = vm.pop.to_s
+    vm.poke(ins + self[(Integer.foorth_coerce(vm.peek))..-1])
+  })
+
+  # ['abc' 'abcdefgh'] .left? [boolean]
+  String.create_shared_method('.left?', TosSpec, [],
+    &lambda {|vm| vm.poke(self.start_with?(vm.peek)); })
+
+
+  #MID Group
+
+  # [n w 'abcdefgh'] .mid ['cdef']      // Assumes n = 2, w = 4
+  String.create_shared_method('.mid', TosSpec, [], &lambda {|vm|
+    width = Integer.foorth_coerce(vm.pop)
+    posn = Integer.foorth_coerce(vm.pop)
+    vm.push(self[posn...(posn+width)])
+  })
+
+  # [n w 'abcdefgh'] .-mid ['abgh']     // Assumes n = 2, w = 4
+  String.create_shared_method('.-mid', TosSpec, [], &lambda {|vm|
+    width = Integer.foorth_coerce(vm.pop)
+    posn = Integer.foorth_coerce(vm.pop)
+    vm.push(self[0...posn] + self[(posn+width)..-1])
+  })
+
+  # [n w "123" "abcdefgh"] .+mid ["ab123gh"] // Assumes n = 2, w = 4
+  String.create_shared_method('.+mid', TosSpec, [], &lambda {|vm|
+    ins = vm.pop.to_s
+    width = Integer.foorth_coerce(vm.pop)
+    posn = Integer.foorth_coerce(vm.pop)
+    vm.push(self[0...posn] + ins + self[(posn+width)..-1])
+  })
+
+  # [n 'cde' 'abcdefgh'] .mid? [true]      // Assumes n = 2
+  String.create_shared_method('.mid?', TosSpec, [], &lambda {|vm|
+    search = vm.pop.to_s
+    width  = search.length
+    posn   = Integer.foorth_coerce(vm.pop)
+    vm.push(self[posn...(posn+width)] == search)
+  })
+
+
+  #MIDLR Group
+
+  # [l r 'abcdefgh'] .midlr ['bcdefg']  // Assumes l = 1, r = 1
+  String.create_shared_method('.midlr', TosSpec, [], &lambda {|vm|
+    right = Integer.foorth_coerce(vm.pop)
+    left  = Integer.foorth_coerce(vm.pop)
+    vm.push(self[left...(0-right)])
+  })
+
+  # [l r 'abcdefgh'] .-midlr ['ah']     // Assumes l = 1, r = 1
+  String.create_shared_method('.-midlr', TosSpec, [], &lambda {|vm|
+    right = Integer.foorth_coerce(vm.pop)
+    left  = Integer.foorth_coerce(vm.pop)
+    vm.push(self[0...left] + self[((0-right))..-1])
+  })
+
+  # [l r "123" 'abcdefgh'] .+midlr ['a123h']     // Assumes l = 1, r = 1
+  String.create_shared_method('.+midlr', TosSpec, [], &lambda {|vm|
+    ins = vm.pop.to_s
+    right = Integer.foorth_coerce(vm.pop)
+    left  = Integer.foorth_coerce(vm.pop)
+    vm.push(self[0...left] + ins + self[((0-right))..-1])
+  })
+
+  #RIGHT Group
+
+  # [w 'abcdefgh'] .right ['gh']        // Assumes w = 2
+  String.create_shared_method('.right', TosSpec, [],
+    &lambda {|vm| vm.poke(self[(0-(Integer.foorth_coerce(vm.peek)))..-1]); })
+
+  # [w 'abcdefgh'] .-right ['abcdef']   // Assumes w = 2
+  String.create_shared_method('.-right', TosSpec, [],
+    &lambda {|vm| vm.poke(self[0...(0-(Integer.foorth_coerce(vm.peek)))]); })
+
+  # [w "123" 'abcdefgh'] .+right ['abcdef123']   // Assumes w = 2
+  String.create_shared_method('.+right', TosSpec, [], &lambda {|vm|
+    ins = vm.pop.to_s
+    width = Integer.foorth_coerce(vm.pop)
+    vm.push(self[0...(0-width)] + ins)
+  })
+
+  # ['fgh' 'abcdefgh'] .right? [boolean]
+  String.create_shared_method('.right?', TosSpec, [],
+    &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); })
+
+  # ['cde' 'abcdefgh'] .posn [position or nil]
+  String.create_shared_method('.posn', TosSpec, [],
+    &lambda {|vm| vm.poke(self.index(vm.peek)); })
+
+  # ["a"] .length [n]
+  String.create_shared_method('.length', TosSpec, [],
+    &lambda {|vm| vm.push(self.length); })
+
+  # ["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); })
+
+  # ["b", a] << ["ba"]; "ba" is the same object as "b"
+  String.create_shared_method('<<', NosSpec, [],
+    &lambda {|vm| vm.poke(self << vm.peek.to_s); })
+
+  # ["b", n] * ["bbb..."]
+  String.create_shared_method('*', NosSpec, [], &lambda {|vm|
+    begin
+      vm.poke(self * Integer.foorth_coerce(vm.peek))
+    rescue
+      vm.data_stack.pop
+      raise
+    end
+  })
+
+  # ["abCD"] .to_upper ["ABCD"]
+  String.create_shared_method('.to_upper', TosSpec, [],
+    &lambda {|vm| vm.push(self.upcase); })
+
+  # ["abCD"] .to_lower ["abcd"]
+  String.create_shared_method('.to_lower', TosSpec, [],
+    &lambda {|vm| vm.push(self.downcase); })
+
+  # ["stressed"] .reverse ["desserts"]
+  String.create_shared_method('.reverse', TosSpec, [],
+    &lambda {|vm| vm.push(self.reverse); })
+
+  # ["abc\\ndef\\n123"] .lines [["abc", "def", "123"]]
+  String.create_shared_method('.lines', TosSpec, [],
+    &lambda {|vm| vm.push(self.lines.to_a.collect {|line| line.chomp}) })
+
+  # ["abc def 123"] .split [["abc", "def", "123"]]
+  String.create_shared_method('.split', TosSpec, [],
+    &lambda {|vm| vm.push(self.split(' ')) })
+
+  # [file_name_string] .load [undefined]; load the file as source code.
+  String.create_shared_method('.load', TosSpec, [], &lambda {|vm|
+    if File.extname(self) == '' && !self.end_with?('.')
+      file_name = self + '.foorth'
+    else
+      file_name = self
+    end
+
+    unless File.exists?(file_name)
+      error "F50: Unable to locate file #{file_name}"
+    end
+
+    vm.process_file(file_name)
+  })
+
+  # [] .load"file_name_string" [undefined]; load the file as source code.
+  VirtualMachine.create_shared_method('load"', VmSpec, [], &lambda{|vm|
+    vm.pop.foorth_load_file(vm)
+  })
+
+  # ["a_string"] .call [unspecified]; Execute the string as source code.
+  String.create_shared_method('.call', TosSpec, [], &lambda {|vm|
+    vm.process_string(self)
+  })
+
+  # ["Error message"] .throw []; Raises an exception.
+  String.create_shared_method('.throw', TosSpec, [], &lambda {|vm|
+    raise XfOOrth::XfOOrthError, self, caller
+  })
+
+  # [] throw"Error message" []; Raises an exception.
+  VirtualMachine.create_shared_method('throw"', VmSpec, [], &lambda {|vm|
+    raise XfOOrth::XfOOrthError, vm.pop.to_s, caller
+  })
+
+  # [a_string] .shell []
+  String.create_shared_method('.shell', TosSpec, [], &lambda {|vm|
+    system(self)
+  })
+
+  # [a_string] .shell_out [a_string]
+  String.create_shared_method('.shell_out', TosSpec, [], &lambda {|vm|
+    IO.popen(self, "r") {|io| vm.push(io.read) }
+  })
+
+end

data/lib/fOOrth/library/stubs.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+
+#* library/stubs.rb - The standard fOOrth library.
+module XfOOrth
+
+  # Some comparison words.  See numeric_library.rb and string_library.rb
+  Object.create_shared_method('>',    NosSpec, [:stub])
+  Object.create_shared_method('<',    NosSpec, [:stub])
+  Object.create_shared_method('>=',   NosSpec, [:stub])
+  Object.create_shared_method('<=',   NosSpec, [:stub])
+  Object.create_shared_method('<=>',  NosSpec, [:stub])
+
+  # Some comparison with zero words.  See numeric_library.rb
+  Object.create_shared_method('0=',     TosSpec, [:stub])
+  Object.create_shared_method('0<>',    TosSpec, [:stub])
+  Object.create_shared_method('0>',     TosSpec, [:stub])
+  Object.create_shared_method('0<',     TosSpec, [:stub])
+  Object.create_shared_method('0>=',    TosSpec, [:stub])
+  Object.create_shared_method('0<=',    TosSpec, [:stub])
+  Object.create_shared_method('0<=>',   TosSpec, [:stub])
+
+  # Stubs for the stack arithmetic words. See numeric_library.rb
+  Object.create_shared_method('+',      NosSpec, [:stub])
+  Object.create_shared_method('-',      NosSpec, [:stub])
+  Object.create_shared_method('*',      NosSpec, [:stub])
+  Object.create_shared_method('**',     NosSpec, [:stub])
+  Object.create_shared_method('/',      NosSpec, [:stub])
+  Object.create_shared_method('mod',    NosSpec, [:stub])
+  Object.create_shared_method('neg',    TosSpec, [:stub])
+
+  Object.create_shared_method('1+',     TosSpec, [:stub])
+  Object.create_shared_method('1-',     TosSpec, [:stub])
+  Object.create_shared_method('2+',     TosSpec, [:stub])
+  Object.create_shared_method('2-',     TosSpec, [:stub])
+  Object.create_shared_method('2*',     TosSpec, [:stub])
+  Object.create_shared_method('2/',     TosSpec, [:stub])
+
+  Object.create_shared_method(')stubs', TosSpec, [:stub])
+
+  # Some bitwise operation stubs. See numeric_library.rb
+  Object.create_shared_method('and',    NosSpec, [:stub])
+  Object.create_shared_method('or',     NosSpec, [:stub])
+  Object.create_shared_method('xor',    NosSpec, [:stub])
+  Object.create_shared_method('com',    TosSpec, [:stub])
+  Object.create_shared_method('<<',     NosSpec, [:stub])
+  Object.create_shared_method('>>',     NosSpec, [:stub])
+
+  Object.create_shared_method('@',      TosSpec, [:stub])
+  Object.create_shared_method('!',      TosSpec, [:stub])
+
+  Object.create_shared_method('parse',     NosSpec, [:stub])
+  Object.create_shared_method('parse!',    NosSpec, [:stub])
+  Object.create_shared_method('p"',        NosSpec, [:stub])
+  Object.create_shared_method('p!"',       NosSpec, [:stub])
+
+  #Procedure literal stubs.
+  Object.create_shared_method('.each{{',        NosSpec, [:stub])
+  Object.create_shared_method('.new{{',         NosSpec, [:stub])
+  Object.create_shared_method('.map{{',         NosSpec, [:stub])
+  Object.create_shared_method('.select{{',      NosSpec, [:stub])
+  Object.create_shared_method('.open{{',        NosSpec, [:stub])
+  Object.create_shared_method('.create{{',      NosSpec, [:stub])
+  Object.create_shared_method('.append{{',      NosSpec, [:stub])
+  Object.create_shared_method('.do{{',          NosSpec, [:stub])
+  Object.create_shared_method('.default{{',     NosSpec, [:stub])
+  Object.create_shared_method('.new_default{{', NosSpec, [:stub])
+
+  #Define some "crossover" symbols.
+  SymbolMap.add_entry('.is_class?',     "foorth_is_class?".to_sym)
+  SymbolMap.add_entry('.to_s',          :to_foorth_s)
+  SymbolMap.add_entry('.strlen',        :foorth_strlen)
+  SymbolMap.add_entry('.strmax',        :foorth_strmax)
+  SymbolMap.add_entry('.strmax2',       :foorth_strmax2)
+  SymbolMap.add_entry('.pp',            :foorth_pretty)
+  SymbolMap.add_entry('.load',          :foorth_load_file)
+end