fOOrth 0.5.0

data/integration/vm_lib_tests.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+require_relative '../lib/fOOrth'
+require_relative 'support/foorth_testing'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the standard fOOrth library.
+class VMLibraryTester < Minitest::Test
+
+  include XfOOrthTestExtensions
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_that_the_VM_class_and_instance_are_available
+    foorth_equal("VirtualMachine", [XfOOrth::VirtualMachine])
+
+    vm = Thread.current[:vm]
+    foorth_equal("vm", [vm])
+
+  end
+
+  def test_for_the_vm_as_string
+    foorth_equal("vm .to_s", ['VirtualMachine instance <Main>'])
+    foorth_output('vm .'   ,  'VirtualMachine instance <Main>')
+  end
+
+  def test_for_the_vm_name
+    foorth_equal("vm .vm_name", ['Main'])
+  end
+
+  def test_for_stack_clear
+    foorth_equal('3 4 5 6 clear', [])
+  end
+
+end

data/lib/fOOrth.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+# The fOOrth Language System implemented via a Ruby gem.
+
+require 'safe_clone'
+require 'full_clone'
+require 'in_array'
+require 'format_engine'
+require 'ruby_sscanf'
+require 'English'
+
+require 'pp'
+
+$no_alias_read_line_module = true
+require 'mini_readline'
+
+require_relative 'fOOrth/version'
+require_relative 'fOOrth/debug'
+require_relative 'fOOrth/monkey_patch'
+require_relative 'fOOrth/symbol_map'
+require_relative 'fOOrth/interpreter'
+require_relative 'fOOrth/compiler'
+require_relative 'fOOrth/initialize'
+require_relative 'fOOrth/core'
+
+unless $exclude_fOOrth_library
+  require_relative 'fOOrth/library'
+  require_relative 'fOOrth/main'
+end
+
+#\XfOOrth - the module name space of the fOOrth language system.
+#* fOOrth.rb - The root file that gathers up all the system's parts.
+module XfOOrth
+
+  #The version of this module.
+  #<br>Returns
+  #* A version string; <major>.<minor>.<step>
+  def self.version
+    VERSION
+  end
+
+  #The virtual machine is the heart of the fOOrth language system that is
+  #used to facilitate the stack oriented processing of data and language
+  #elements.
+  #* fOOrth.rb - Version info lives here.
+  class VirtualMachine
+
+    #Get the version string for this virtual machine.
+    #<br>Endemic Code Smells
+    #* :reek:UtilityFunction
+    def version
+      XfOOrth.version
+    end
+  end
+
+end
+

data/lib/fOOrth/compiler.rb

@@ -0,0 +1,78 @@
+# coding: utf-8
+
+require_relative 'compiler/source'
+require_relative 'compiler/parser'
+require_relative 'compiler/token'
+require_relative 'compiler/modes'
+require_relative 'compiler/word_specs'
+require_relative 'compiler/context'
+require_relative 'compiler/process'
+
+#* compiler.rb - The compiler portion of the fOOrth language system.
+module XfOOrth
+
+  #* compiler.rb - The compiler service of the virtual machine.
+  class VirtualMachine
+
+    #The current system console object. Gets the current console object
+    #only creating one if somebody asks for one.
+    #<br>Note
+    #* This is to be the sole occurrence of @_private_console
+    def console
+      @_private_console ||= Console.new
+    end
+
+    #The current compiler parser.
+    attr_reader :parser
+
+    #The current execution/compile context.
+    attr_reader :context
+
+    #The level of quote nesting.
+    attr_accessor :quotes
+
+    #Is a force compile in effect?
+    attr_accessor :force
+
+    #Return the compiler to a known state.
+    def compiler_reset
+      @buffer = nil
+      @parser = nil
+      @quotes = 0
+      @force  = false
+      @context = Context.new(nil, vm: self, mode: :execute)
+      self
+    end
+
+    #Append text to the compile buffer.
+    def <<(text)
+      dbg_puts "  Append=#{text.inspect}"
+      @buffer << text
+    end
+
+    #Execute code from the interactive console.
+    def process_console
+      process(console)
+    ensure
+      console.flush
+    end
+
+    #Execute a string of code.
+    def process_string(str)
+      process(StringSource.new(str))
+    end
+
+    #Execute a file of code.
+    def process_file(name)
+      source = FileSource.new(name)
+
+      begin
+        process(source)
+      ensure
+        source.close
+      end
+    end
+
+  end
+
+end

data/lib/fOOrth/compiler/context.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+
+require_relative 'context/map_name'
+require_relative 'context/tags'
+require_relative 'context/locals'
+
+#* compiler/context.rb - The compile progress context manager of the fOOrth
+#  language system.
+module XfOOrth
+
+  #A class for the management of global, hierarchical, and nested compile time contexts.
+  #* compiler/context.rb - \Context constructor, tag support, and local defs.
+  class Context
+
+    #The previous context object that this one builds on. Set to nil if there
+    #is none.
+    attr_reader :previous
+
+    #Setup an instance of compiler context.
+    #<br>Parameters:
+    #* previous - The previous context object or nil if there is none.
+    #* data - A hash of context data.
+    def initialize(previous, data={})
+      @previous, @data = previous, data
+    end
+
+    #How many levels of nested context are there?
+    def depth
+      1 + (previous ? previous.depth : 0)
+    end
+
+    #Is the current nesting level what is expected?
+    #<br>Parameters
+    #* expected_depth - the expected nesting depth.
+    #<br>Notes
+    #* Raises an error (F12) on incorrect nesting.
+    def check_depth(expected_depth)
+      if expected_depth - self.depth != 0
+        error "F12: Error, Invalid control/structure nesting."
+      end
+    end
+
+    #Get the currently define method receiver
+    def recvr
+      self[:obj] || self[:cls] || self[:vm] || error("F90: No message receiver.")
+    end
+
+  end
+end

data/lib/fOOrth/compiler/context/locals.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+#* compiler/context/locals.rb - Support local methods in context.
+module XfOOrth
+
+  #* compiler/context/locals.rb - Support local methods in context.
+  class Context
+
+    #Create a local method on this context.
+    #<br>Parameters:
+    #* name - The name of the method to create.
+    #* spec_class - The specification class to use.
+    #* options - An array of options.
+    #* block - A block to associate with the name.
+    #<br>Returns
+    #* The spec created for the shared method.
+    def create_local_method(name, spec_class, options, &block)
+      sym = SymbolMap.add_entry(name)
+      self[sym] = spec_class.new(name, sym, options, &block)
+    end
+
+    #Remove a local method on this context.
+    #<br>Parameters:
+    #* The name of the method to remove.
+    def remove_local_method(name)
+      if (sym = SymbolMap.map(name))
+        @data.delete(sym)
+      else
+        error "F90: Unable to remove local method #{name}"
+      end
+    end
+
+  end
+end

data/lib/fOOrth/compiler/context/map_name.rb

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+#* compiler/context/map_name.rb - The fOOrth language mapping of names in a context.
+module XfOOrth
+
+  #* compiler/context/map_name.rb - The fOOrth language mapping of names in a context.
+  class Context
+
+    #Map a name to a specification.
+    #<br>Parameters:
+    #* name - The string to be mapped.
+    #<br>Returns:
+    #* The specification that corresponds to the name or nil if none found.
+    def map(name)
+      if (@symbol = SymbolMap.map(@name = name))
+        do_map_name
+      end
+    end
+
+    #Private methods follow.
+    private
+
+    #Do a search of dictionaries based on the syntax of the name.
+    def do_map_name
+      self[@symbol]              ||
+      case @name[0]
+      when '.'
+        do_object_class_map      ||
+        do_vm_target_map         ||
+        TosSpec.new(@name, @symbol, [:temp])
+
+      when '~'
+        do_class_target_map      ||
+        do_object_target_map     ||
+        do_vm_target_map         ||
+        SelfSpec.new(@name, @symbol, [:temp])
+
+      when '@'
+        do_class_target_map      ||
+        do_object_target_map     ||
+        do_vm_target_map         ||
+        spec_error
+
+      when '$'
+        do_global_target_map     ||
+        spec_error
+
+      when '#'
+        do_vm_target_map         ||
+        spec_error
+
+      else
+        do_object_class_map      ||
+        do_vm_target_map         ||
+        do_global_target_map     ||
+        spec_error
+      end
+
+    end
+
+    #Do a search of the Object class for the item.
+    def do_object_class_map
+      Object.map_foorth_shared(@symbol)
+    end
+
+    #Do a search of the :cls tag if it is specified.
+    def do_class_target_map
+      (tc = self[:cls]) && tc.map_foorth_shared(@symbol)
+    end
+
+    #Do a search of the :obj tag if it is specified.
+    def do_object_target_map
+      (to = self[:obj]) && to.map_foorth_exclusive(@symbol)
+    end
+
+    #Do a search of the :vm tag if it is specified.
+    def do_vm_target_map
+      (vm = self[:vm])  && vm.map_foorth_exclusive(@symbol)
+    end
+
+    #Do a search of the globals.
+    def do_global_target_map
+      $FOORTH_GLOBALS[@symbol]
+    end
+
+    #Error: Unable to find a specification.
+    def spec_error
+      error "F11: ?#{@name}?"
+    end
+
+  end
+end

data/lib/fOOrth/compiler/context/tags.rb

@@ -0,0 +1,48 @@
+# coding: utf-8
+
+#* compiler/context/tags.rb - Support tags in context.
+module XfOOrth
+
+  #* compiler/context/tags.rb - Support tags in context.
+  class Context
+
+    #Retrieve the data value currently in effect.
+    def [](index)
+      @data[index] || (previous && previous[index])
+    end
+
+    #Set a data value.
+    def []=(index,value)
+      @data[index] = value
+    end
+
+    #Get the compile tags in effect.
+    def tags
+      @data[:tags] || []
+    end
+
+    #Merge in a hash of tag data.
+    def merge(new_data)
+      @data.merge!(new_data)
+    end
+
+    #Validate a current data value.
+    #<br>Parameters:
+    #* symbol - The symbol of the value to be tested.
+    #* expect - An array of valid values.
+    #<br>Note:
+    #* Throws a XfOOrthError if the value is not valid.
+    #* To check for no value, use [nil] for expect.
+    #* Returns true to facilitate testing only.
+    def check_set(symbol, expect)
+      current = self[symbol]
+
+      unless expect.include?(current)
+        error "F10: Found a #{current.inspect}, excpected #{expect}"
+      end
+
+      true
+    end
+
+  end
+end

data/lib/fOOrth/compiler/modes.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+require_relative 'modes/compiled'
+require_relative 'modes/suspend'
+require_relative 'modes/delayed'
+require_relative 'modes/deferred'
+require_relative 'modes/nested'
+
+#* compiler/modes.rb - The control of the various compiler modes.
+module XfOOrth
+  #* modes.rb - The control of the various compiler modes.
+  class VirtualMachine
+
+    #Depending on the mode, process the text source code.
+    #<br>Parameters:
+    #* text - Some text to be executed or deferred.
+    def process_text(text)
+      if execute_mode?
+        dbg_puts "  Code=#{text.inspect}"
+        @context.recvr.instance_exec(self, &eval("lambda {|vm| #{text} }"))
+      else
+        self << text
+      end
+    end
+
+    #Check to see if the virtual machine is in execute mode.
+    def execute_mode?
+      @context[:mode] == :execute
+    end
+
+  end
+end

data/lib/fOOrth/compiler/modes/compiled.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+#* compiler/modes/compiled.rb - The compiled system mode.
+module XfOOrth
+  #* compiler/modes/compiled.rb - The control of the compiled system mode.
+  class VirtualMachine
+
+    #Start compiling a fOOrth definition. This is used to get things going
+    #by the various compiling words like ':', '::', ':::', etc.
+    #<br>Parameters:
+    #* ctrl - The control symbol that started the compilation.
+    #* action - A block to be executed when the compilation is done.
+    #<br>Note:
+    #* Adds a nested context level to be un-nested at a later point.
+    def begin_compile_mode(ctrl, defs={}, &action)
+      dbg_puts "  begin_compile_mode"
+      @context.check_set(:mode, [:execute])
+      @context = Context.new(@context, mode: :compile, ctrl: ctrl, action: action)
+      @context.merge(defs)
+      @buffer = ''
+    end
+
+    #Finish compiling a fOOrth definition. This is used to wrap things up,
+    #mostly by the semi-colon ';' word.
+    #<br>Parameters:
+    #* ctrls - an array of the allowed set of control values.
+    #<br>Returns:
+    #* The value of the action block.
+    #<br>Note:
+    #* Un-nests a context level.
+    def end_compile_mode(ctrls)
+      @context.check_set(:ctrl, ctrls)
+      source, @buffer = "lambda {|vm| #{@buffer} }", nil
+      result = instance_exec(self, source, @context.tags, &@context[:action])
+      @context = @context.previous
+      dbg_puts "  end_compile_mode"
+      result
+    end
+
+  end
+end