fOOrth 0.5.0

data/lib/fOOrth/compiler/process/generate.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+#* compiler/process/generate.rb - Generate the Ruby object code.
+module XfOOrth
+
+  #* compiler/process/generate.rb - Generate the Ruby object code.
+  class VirtualMachine
+
+    #Finally generate some code!
+    #<br>Parameters:
+    #* token - The token to receive the generated code.
+    #* word  - The text of the word.
+    def generate_code(token, word)
+      if (spec = @context.map(word))
+        token.add(spec.builds, spec.tags)
+      elsif (value = word.to_foorth_n)
+        token.add("vm.push(#{value.foorth_embed}); ", [:numeric])
+      else
+        error "F10: ?#{word}?"
+      end
+    end
+
+  end
+end

data/lib/fOOrth/compiler/process/get_token.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+#* compiler/process/get_token.rb - Get a complete language element.
+module XfOOrth
+
+  #* compiler/process/get_token.rb - Get a complete language element.
+  class VirtualMachine
+
+    #Get the next token structure from the source code or nil if none
+    #can be found.
+    #<br>Returns
+    #* A Token structure or nil.
+    def get_token
+      return nil unless (word = parser.get_word)
+
+      token = Token.new
+      string_parms(token, word) || procedure_parms(token, word)
+      generate_code(token, word)
+      token
+    end
+
+  end
+end

data/lib/fOOrth/compiler/process/procedure.rb

@@ -0,0 +1,55 @@
+# coding: utf-8
+
+#* compiler/process/procedure.rb - Get an embedded procedure literal.
+module XfOOrth
+
+  #* compiler/process/procedure.rb - Get an embedded procedure literal.
+  class VirtualMachine
+
+    private
+
+    #Process optional string parameters.
+    #<br>Parameters:
+    #* token - The token to receive the generated code.
+    #* word  - The text of the word.
+    def procedure_parms(token, word)
+      if word.end_with?('{{')
+        token.add(get_procedure_literal, [:procedure])
+      end
+    end
+
+    #Extract a procedure literal from the source code.
+    def get_procedure_literal
+      save, @buffer  = @buffer, ""
+      open_procedure_literal
+
+      begin
+        token = get_procedure_token
+        due_token(token)
+      end until token.has_tag?(:end)
+
+      close_procedure_literal
+      (result, @buffer = @buffer, save)[0]
+    end
+
+    #Handle the opening of a procedure literal.
+    def open_procedure_literal
+      suspend_execute_mode("vm.push(lambda {|vm, val=nil, idx=nil| ", :procedure)
+      context.create_local_method('v',  MacroSpec, [:macro, "vm.push(val); "])
+      context.create_local_method('x',  MacroSpec, [:macro, "vm.push(idx); "])
+      context.create_local_method('}}', MacroSpec, [:macro, :end,     "}); "])
+    end
+
+    #Handle the closing of a procedure literal.
+    def close_procedure_literal
+      unnest_mode(nil, [:procedure])
+    end
+
+    #Get a token for the procedure literal.
+    def get_procedure_token
+      error "F12: Error, Invalid nesting." unless (token = get_token)
+      token
+    end
+
+  end
+end

data/lib/fOOrth/compiler/process/string.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+#* compiler/process/string.rb - Get an embedded string literal.
+module XfOOrth
+
+  #* compiler/process/string.rb - Get an embedded string literal.
+  class VirtualMachine
+
+    #Process optional string parameters.
+    #<br>Parameters:
+    #* token - The token to receive the generated code.
+    #* word  - The text of the word.
+    def string_parms(token, word)
+      if word.end_with?('"')
+        token.add("vm.push(#{parser.get_string.foorth_embed}); ")
+      end
+    end
+
+  end
+end

data/lib/fOOrth/compiler/source.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+
+require_relative 'source/read_point'
+
+#* compiler/source.rb - The abstract source class shared by many code sources.
+module XfOOrth
+
+  #The Source class used to contain code common to most sources.
+  class AbstractSource
+    include ReadPoint
+
+    #Initialize the abstract base class.
+    def initialize
+      reset_read_point
+      @eof = false
+    end
+
+    #Close the source.
+    def close
+      @eoln = true
+      @eof = true
+    end
+
+    #Get the next character of input data
+    #<br>Returns:
+    #* The next character or nil if none are available.
+    def get
+      return nil if @eof
+
+      read do
+        begin
+          @read_step.next.rstrip
+        rescue StopIteration
+          @eof = true
+          nil
+        end
+      end
+    end
+
+    #Has the source reached the end of the available data?
+    #<br>Returns:
+    #* True if the end is reached else false.
+    def eof?
+      @eof
+    end
+  end
+end
+
+require_relative 'source/string_source'
+require_relative 'source/file_source'
+require_relative 'source/console'

data/lib/fOOrth/compiler/source/console.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+
+#* compiler/console.rb - The fOOrth console support file.
+module XfOOrth
+
+  #The console class enables the use of the command line console as a source
+  #for fOOrth commands and source code. The readline facility is used to enable
+  #editing and command history and retrieval.
+  class Console
+    include ReadPoint
+
+    #Initialize a new console command source.
+    def initialize
+      reset_read_point
+
+      auto_src = lambda { SymbolMap.forward_map.keys.sort  }
+
+      @edit = MiniReadline::Readline.new(history: true,
+                                         auto_complete: true,
+                                         auto_source: MiniReadline::ArraySource,
+                                         array_src: auto_src,
+                                         eoi_detect: true)
+    end
+
+    alias close reset_read_point
+    alias flush reset_read_point
+
+    #Get the next character of command text from the user.
+    #<br>Returns
+    #* The next character of user input as a string.
+    def get
+      read do
+        @edit.readline(prompt: prompt).rstrip
+      end
+    end
+
+    #Has the scanning of the text reached the end of input?
+    #<br>Returns
+    #* Always returns false.
+    def eof?
+      false
+    end
+
+    #Build the command prompt for the user based on the state
+    #of the virtual machine.
+    #<br>Returns
+    #* A prompt string.
+    #<br> Endemic Code Smells
+    #* :reek:FeatureEnvy
+    def prompt
+      vm = Thread.current[:vm]
+      puts
+
+      if vm.show_stack
+        vm.data_stack.to_foorth_s(vm)
+        puts vm.pop
+      end
+
+      '>' * vm.context.depth + '"' * vm.quotes
+    end
+
+    #What is the source of this text?
+    def source_name
+      "The console."
+    end
+
+    alias :file_name :source_name
+
+  end
+end

data/lib/fOOrth/compiler/source/file_source.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+#* compiler/file_source.rb - Uses a file as a source of fOOrth source code.
+module XfOOrth
+
+  #The FileSource class used to extract fOOrth source code
+  #from a string.
+  class FileSource < AbstractSource
+
+    #Initialize from a file name.
+    #<br>Parameters:
+    #* name - The name of the file with the fOOrth source code.
+    def initialize(name)
+      @name      = name
+      @file      = File.new(name, "r")
+      @read_step = @file.each_line
+      super()
+    end
+
+    #Close the file
+    def close
+      @file.close
+      super()
+    end
+
+    #What is the source of this text?
+    def source_name
+      "A file: #{@name}"
+    end
+
+    #Get the name of the file
+    def file_name
+      File.absolute_path(@name)
+    end
+  end
+
+end

data/lib/fOOrth/compiler/source/read_point.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+#* compiler/read_point.rb - A module used to read source code text from a buffer.
+module XfOOrth
+
+  #This module is used to facilitate the reading
+  #of source code text from a buffer.
+  module ReadPoint
+    #Get the current line of text being read.
+    attr_reader :read_buffer
+
+    #Reset the read point to the initial conditions. Namely,
+    #no text in the buffer and not at end of line,
+    def reset_read_point
+      @read_point = nil
+      @eoln = false
+    end
+
+    #Read the next character of data from the source. If there
+    #is nothing to read, call the block to get some more data to
+    #work with.
+    #<br>Parameters
+    #* block - A block of code that retrieves the next line of
+    #  source code to be processed.
+    def read(&block)
+      unless @read_point
+        return nil unless (@read_buffer = block.call)
+        @read_point = @read_buffer.each_char
+      end
+
+      begin
+        result, @eoln = @read_point.next, false
+      rescue StopIteration
+        result, @read_point, @eoln = ' ', nil, true
+      end
+
+      result
+    end
+
+    #Is the read point at the end of line?
+    def eoln?
+      @eoln
+    end
+  end
+
+end

data/lib/fOOrth/compiler/source/string_source.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+#* compiler/string_source.rb - Uses a string as a source of fOOrth source code.
+module XfOOrth
+
+  #The StringSource class used to extract fOOrth source code
+  #from a string.
+  class StringSource < AbstractSource
+
+    #Initialize from a string.
+    #<br>Parameters:
+    #* string - A string of fOOrth source code.
+    def initialize(string)
+      @string_list = string.split("\n")
+      @read_step   = @string_list.each
+      super()
+    end
+
+    #What is the source of this text?
+    def source_name
+      "A string."
+    end
+
+    alias :file_name :source_name
+
+  end
+
+end

data/lib/fOOrth/compiler/token.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+#* compiler/token.rb - A little bit of object code compiled from the source.
+module XfOOrth
+
+  #A class used to hold vital info extracted from the source code.
+  class Token
+
+    #The code fragment in this token.
+    attr_reader :code
+
+    #Set up an empty token
+    def initialize
+      @code = ''
+      @tags = []
+    end
+
+    #Append some text/tags to the code_fragment.
+    def add(text, tags=nil)
+      @code << text
+      @tags.concat(tags).uniq! if tags
+      self
+    end
+
+    #Does this token have the specified tag?
+    def has_tag?(value)
+      @tags.include?(value)
+    end
+
+    #As a string for debugging.
+    def to_s
+      "Tags=#{@tags.inspect} Code=#{@code.inspect}"
+    end
+
+  end
+
+end

data/lib/fOOrth/compiler/word_specs.rb

@@ -0,0 +1,178 @@
+# coding: utf-8
+
+#* compiler/word_specs.rb - The classes that support the specification of the
+#  compile and run-time behaviors of fOOrth definitions of all sorts.
+module XfOOrth
+
+  #The abstract base class for all of the different sorts of word specs.
+  class AbstractWordSpec
+
+    #The compile-time text inserted into the buffer.
+    attr_reader :builds
+
+    #The run-time action; The block that gets linked to the method's symbol.
+    attr_reader :does
+
+    #The attributes tagged to this specification.
+    attr_reader :tags
+
+    #Set up the method spec.
+    #<br>Parameters:
+    #* name - The string that maps to the symbol.
+    #* symbol - The symbol that the name maps to.
+    #* tags - A an array of tags.
+    #<br>These may include:
+    #* :immediate - The word is executed, even in compile modes.
+    #* :macro - Identifies the spec as a macro spec to assist debugging.
+    #* :stub - The word is a place holder in the hierarchy.
+    #<br>Endemic Code Smells
+    #* :reek:ControlParameter -- false positive
+    def initialize(name, symbol, tags=[], &block)
+      @tags = tags
+      @does = block || get_stub_action(name, symbol)
+      build_builds_string(name, symbol)
+    end
+
+    #Get the default action if none is specified.
+    def get_stub_action(name, symbol)
+      lambda do |*_any|
+        error "F20: A #{self.foorth_name} does not understand #{name} (#{symbol.inspect})."
+      end
+    end
+
+    #Look up an tag of interest.
+    def has_tag?(tag)
+      @tags.include?(tag)
+    end
+
+  end
+
+  #A class used to specify the compile of VM words.
+  class VmSpec < AbstractWordSpec
+    #Generate the Ruby code for this method.
+    #<br>Parameters:
+    #* _name - The string that maps to the symbol. Unused
+    #* symbol - The symbol that the name maps to.
+    def build_builds_string(_name, symbol)
+      @builds = "vm.#{symbol}(vm); "
+    end
+  end
+
+  #A class used to specify the compile of public methods of a class or object.
+  class TosSpec < AbstractWordSpec
+    #Generate the Ruby code for this method.
+    #<br>Parameters:
+    #* _name - The string that maps to the symbol. Unused
+    #* symbol - The symbol that the name maps to.
+    def build_builds_string(_name, symbol)
+      @builds = "vm.pop.#{symbol}(vm); "
+    end
+  end
+
+  #A class used to specify the compile of private methods of a class or object.
+  class SelfSpec < AbstractWordSpec
+    #Generate the Ruby code for this method.
+    #<br>Parameters:
+    #* _name - The string that maps to the symbol. Unused
+    #* symbol - The symbol that the name maps to.
+    def build_builds_string(_name, symbol)
+      @builds = "self.#{symbol}(vm); "
+    end
+  end
+
+  #A class used to specify the compile of dyadic operators.
+  class NosSpec < AbstractWordSpec
+    #Generate the Ruby code for this dyadic operator.
+    #<br>Parameters:
+    #* _name - The string that maps to the symbol. Unused
+    #* symbol - The symbol that the name maps to.
+    def build_builds_string(_name, symbol)
+      @builds = "vm.swap_pop.#{symbol}(vm); "
+    end
+
+    #Get the default action if none is specified.
+    def get_stub_action(name, symbol)
+      lambda do |vm|
+        #NOS methods can leave an extra bit of mess on the stack which must
+        #be cleaned up at this time or it will cause further problems.
+        vm.data_stack.pop
+
+        error "F20: A #{self.foorth_name} does not understand #{name} (#{symbol.inspect})."
+      end
+    end
+
+  end
+
+  #A class used to specify the compile of fOOrth classes.
+  class ClassSpec < AbstractWordSpec
+    #Generate the Ruby code for this fOOrth class.
+    #<br>Parameters:
+    #* \new_class - The string that maps to the symbol.
+    #* _symbol - The symbol that the name maps to. Unused
+    def build_builds_string(new_class, _symbol)
+      @new_class = new_class
+      @builds = "vm.push(#{new_class.name}); "
+    end
+
+    #Give read access to the class for testing.
+    attr_reader :new_class
+  end
+
+  #A class used to specify the compile of fOOrth instances variables.
+  class InstanceVarSpec < AbstractWordSpec
+    #Generate the Ruby code for this fOOrth variable.
+    #<br>Parameters:
+    #* _name - The string that maps to the symbol.  Unused
+    #* symbol - The symbol that the name maps to.
+    def build_builds_string(_name, symbol)
+      @builds = "vm.push(#{'@'+(symbol.to_s)}); "
+    end
+  end
+
+  #A class used to specify the compile of fOOrth thread variables.
+  class ThreadVarSpec < AbstractWordSpec
+    #Generate the Ruby code for this fOOrth variable.
+    #<br>Parameters:
+    #* _name - The string that maps to the symbol.  Unused
+    #* symbol - The symbol that the name maps to.
+    def build_builds_string(_name, symbol)
+      @builds = "vm.push(vm.data[#{symbol.inspect}]); "
+    end
+  end
+
+  #A class used to specify the compile of fOOrth global variables.
+  class GlobalVarSpec < AbstractWordSpec
+    #Generate the Ruby code for this fOOrth variable.
+    #<br>Parameters:
+    #* _name - The string that maps to the symbol.  Unused
+    #* symbol - The symbol that the name maps to.
+    def build_builds_string(_name, symbol)
+      @builds = "vm.push(#{'$' + symbol.to_s}); "
+    end
+  end
+
+  #A class used to specify the compile of fOOrth variable.
+  class LocalSpec < AbstractWordSpec
+    #Generate the Ruby code for this fOOrth variable.
+    #<br>Parameters:
+    #* _name  - The string that maps to the symbol. Unused
+    #* symbol - The symbol that the name maps to.
+    def build_builds_string(_name, symbol)
+      @builds = "vm.context[#{symbol.inspect}].does.call(vm); "
+    end
+  end
+
+  #A class used to specify the compile of fOOrth macros.
+  class MacroSpec < AbstractWordSpec
+    #Generate the Ruby code for this macro.
+    #<br>Parameters:
+    #* _name - The string that maps to the symbol. Unused
+    #* _symbol - The symbol that the name maps to. Unused
+    #<br>Note:
+    #* The last entry in the tags array is expected to be a string
+    #  with the text of the command macro.
+    def build_builds_string(_name, _symbol)
+      @builds = @tags.pop
+    end
+  end
+end