fOOrth 0.5.0

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

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+#* compiler/modes/deferred.rb - The control of the deferred compiler mode.
+module XfOOrth
+  #* compiler/modes/deferred.rb - The control of the deferred compiler mode.
+  class VirtualMachine
+
+    #Enter a mode where execution is deferred. If currently in :execute mode,
+    #enter :deferred mode else the mode is unchanged. This is used by words
+    #that need to group words together to work like if, do, and begin.
+    #<br>Parameters:
+    #* text - Some text to append to the buffer before proceeding.
+    #* ctrl - The control symbol that started the deferral.
+    #<br>Note:
+    #* Adds a nested context level to be un-nested at a later point.
+    def suspend_execute_mode(text, ctrl)
+      dbg_puts "  suspend_execute_mode"
+      @context = Context.new(@context, ctrl: ctrl)
+
+      if execute_mode?
+        @context[:mode] = :deferred
+        @buffer = ''
+      end
+
+      self << text
+    end
+
+    #Verify the deferred execution state. This are used by words that work
+    #within a word grouping like else or while.
+    #<br>Parameters:
+    #* text - Some text to append to the buffer before bundling it up.
+    #* ctrls - An array of control symbols that could have started the deferral.
+    def check_deferred_mode(text, ctrls)
+      @context.check_set(:ctrl, ctrls)
+      self << text
+    end
+
+    #If execution was previously deferred, resume the previous mode. This is
+    #used in words that close off a block action like then, loop, or repeat.
+    #<br>Parameters:
+    #* text - Some text to append to the buffer before bundling it up.
+    #* ctrls - An array of control symbols that could have started the deferral.
+    #<br>Note:
+    #* Un-nests a context level.
+    def resume_execute_mode(text, ctrls)
+      dbg_puts "  resume_execute_mode"
+      check_deferred_mode(text, ctrls)
+      @context = @context.previous
+
+      if @context[:mode] == :execute
+        source, @buffer = "lambda {|vm| #{@buffer} }", nil
+        instance_exec(self, &eval(source))
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+#* compiler/modes/delayed.rb - The delayed compile system mode.
+module XfOOrth
+  #* compiler/modes/delayed.rb - The delayed compile system mode.
+  class VirtualMachine
+
+    #Enter a delayed compile mode in which compilation is delayed till a
+    #later time.
+    def delayed_compile_mode(start)
+      dbg_puts "  begin_delayed_compile_mode"
+
+      buffer = do_delayed_compile_mode(start)
+
+      dbg_puts "  Append=#{buffer}"
+      @buffer << buffer
+      dbg_puts "  end_delayed_compile_mode"
+    end
+
+    #The worker bee for delayed_compile_mode.
+    #<br>Endemic Code Smells
+    #* :reek:FeatureEnvy -- false positive
+    def do_delayed_compile_mode(start)
+      buffer, depth = start + ' ', 1
+
+      while depth > 0
+        if (word = parser.get_word_or_string)
+          buffer << word + ' '
+          depth += 1 if [':', '!:', '.:', '.::'].include?(word)
+          depth -= 1 if word == ';'
+        else
+          error "F12: Error, Invalid compile nesting."
+        end
+      end
+
+      "vm.process_string(#{buffer.foorth_embed}); "
+    end
+
+  end
+end

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

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+#* compiler/modes/nested.rb - The control of the nested compiler modes.
+module XfOOrth
+  #* compiler/modes/nested.rb - The control of the nested compiler modes.
+  class VirtualMachine
+
+    #Enter a nested context without altering the current mode.
+    #<br>Parameters:
+    #* text - Some text to append associated with the nested state.
+    #* ctrl - The control symbol that started the nested context.
+    #<br>Note:
+    #* Adds a nested context level to be un-nested at a later point.
+    def nest_mode(text, ctrl)
+      dbg_puts "  nest_context"
+      @context = Context.new(@context, ctrl: ctrl)
+      process_text(text)
+    end
+
+    #Leave a nested context without altering the current mode.
+    #<br>Parameters:
+    #* text - Some text to append associated with the nested state.
+    #* ctrls - An array of control symbols that could have started the nest.
+    #<br>Note:
+    #* Removes a nested context level.
+    def unnest_mode(text, ctrls)
+      dbg_puts "  unnest_context"
+      @context.check_set(:ctrl, ctrls)
+      @context = @context.previous
+      process_text(text) if text
+    end
+
+  end
+end

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

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+#* compiler/modes/suspend.rb - The ability to suspend compile mode.
+module XfOOrth
+  #* compiler/modes/suspend.rb - The ability to suspend compile mode.
+  class VirtualMachine
+
+    #While compiling, suspend compiling so that some code may be executed.
+    #<br>Parameters:
+    #* ctrl - The control symbol that suspended the compilation.
+    #<br>Note:
+    #* Adds a nested context level to be un-nested at a later point.
+    def suspend_compile_mode(ctrl)
+      dbg_puts "  suspend_compile_mode"
+      @context.check_set(:mode, [:compile])
+      @context = Context.new(@context, mode: :execute, ctrl: ctrl)
+    end
+
+    #While compiling and compiling is suspended, resume normal compiling.
+    #<br>Parameters:
+    #* ctrls - An array of control symbols that could have
+    #  suspended the compilation.
+    #<br>Note:
+    #* Un-nests a context level.
+    def resume_compile_mode(ctrls)
+      dbg_puts "  resume_compile_mode"
+      @context.check_set(:ctrl, ctrls)
+      @context = @context.previous
+    end
+
+  end
+end

data/lib/fOOrth/compiler/parser.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+require_relative 'parser/get_string'
+require_relative 'parser/skip'
+require_relative 'parser/normal'
+require_relative 'parser/special'
+
+#* compiler/parser.rb - Parse source code from a code source.
+module XfOOrth
+
+  #* parser.rb - Parse source code from a code source.
+  class Parser
+
+    #The source of the text to be parsed.
+    attr_reader :source
+
+    #Initialize this parser.
+    #<br>Parameters
+    #* source - The source of the text to be parsed.
+    def initialize(source)
+      @source = source
+    end
+
+  end
+
+end

data/lib/fOOrth/compiler/parser/get_string.rb

@@ -0,0 +1,71 @@
+# coding: utf-8
+
+#* compiler/parser/get_string.rb - Extract string literals from code source.
+module XfOOrth
+
+  #* compiler/parser/get_string.rb - Extract string literals from code source.
+  class Parser
+
+    #Get the balance of a string from the source code source.
+    def get_string
+      vm = Thread.current[:vm]
+      vm.quotes, done, result = 1, false, ''
+
+      begin
+        next_char = @source.get
+
+        if next_char == "\\"
+          break if process_backslash(result)
+        elsif next_char == '"' || @source.eoln?
+          vm.quotes, done = 0, true
+        elsif next_char >= ' '
+          result << next_char
+        end
+      end until done
+
+      result
+    end
+
+    #Process a backlash character found with a string in the source text.
+    def process_backslash(buffer)
+      next_char = @source.get
+
+      if next_char == ' ' && @source.eoln?
+        next_char = skip_white_space_or_to_eoln
+        return true if ['"', ' '].include?(next_char)
+      elsif next_char == 'n'
+        next_char = "\n"
+      elsif next_char == 'x'
+        next_char = process_8_bit
+      elsif next_char == 'u'
+        next_char = process_16_bit
+      elsif next_char != "\\" && next_char != '"'
+        error "F10: Invalid string literal value: '\\#{next_char}'"
+      end
+
+      buffer << next_char
+      false
+    end
+
+    #Process an 8 bit hex character constant.
+    def process_8_bit
+      hex = process_hex_character + process_hex_character
+      eval("\"\\x#{hex}\"")
+    end
+
+    #Process a 16 bit hex character constant.
+    def process_16_bit
+      hex = process_hex_character + process_hex_character +
+            process_hex_character + process_hex_character
+      eval("\"\\u#{hex}\"")
+    end
+
+    #Get a hex character from the input stream.
+    def process_hex_character
+      next_char = @source.get
+      error "F10: Invalid hex character: '#{next_char}'" unless /\h/ =~ next_char
+
+      next_char
+    end
+  end
+end

data/lib/fOOrth/compiler/parser/normal.rb

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+#* compiler/parser/normal.rb - Parse source code when not in quote mode.
+module XfOOrth
+
+  #* compiler/parser/normal.rb - Parse source code when not in quote mode.
+  class Parser
+
+    #Get the next forth word from the source code source. This method
+    #recognizes and skips over comments in the source code.
+    #<br>Returns:
+    #* A string with the next non-comment language element or nil if none
+    #  could be found.
+    def get_word
+      loop do
+        return nil unless (word = get_word_raw)
+
+        if word == '('
+          skip_over_comment
+        elsif word == '//'
+          skip_to_eoln
+        else
+          return word
+        end
+      end
+    end
+
+    #Get the next forth word from the source code source. Recognizes, but
+    #does not process comments in the source code.
+    #<br>Returns:
+    #* A string with the next language element or nil if none could be found.
+    def get_word_raw
+      #Skip white space.
+      return nil unless (next_char = skip_white_space)
+
+      #Gather the word token.
+      word = ''
+
+      begin
+        word << next_char
+
+        #Check for the three special cases.
+        break if ['(', '//'].include?(word) || (next_char == '"')
+
+        next_char = @source.get
+      end while next_char && next_char > ' '
+
+      word
+    end
+
+  end
+
+end

data/lib/fOOrth/compiler/parser/skip.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+
+#* compiler/parser/skip.rb - Skip over stuff in the source code.
+module XfOOrth
+
+  #* compiler/parser/skip.rb - Skip over stuff in the source code.
+  class Parser
+
+    #Skip over any white space.
+    #<br>Returns:
+    #* The first non-white space character or nil if none were found.
+    def skip_white_space
+      begin
+        return nil unless (next_char = @source.get)
+      end while next_char <= ' '
+
+      next_char
+    end
+
+    #Skip over a portion of the source text until end of line detected.
+    #<br>Returns:
+    #* true
+    def skip_to_eoln
+      @source.get until @source.eoln?
+      true
+    end
+
+    #Skip over a portion of the source text until a ')' detected.
+    #<br>Returns:
+    #* true
+    #<br>Note:
+    #* Raises an XfOOrthError exception on an unterminated comment.
+    def skip_over_comment
+      until @source.eoln?
+        return true if @source.get == ')'
+      end
+
+      error "F10: Unbalanced comment detected."
+    end
+
+    #Skip till a non-white space or an end of line
+    def skip_white_space_or_to_eoln
+      while (next_char = @source.get)
+        return next_char if (next_char > ' ') || @source.eoln?
+      end
+    end
+
+  end
+
+end

data/lib/fOOrth/compiler/parser/special.rb

@@ -0,0 +1,42 @@
+# coding: utf-8
+
+#* compiler/parser/special.rb - Parse source code in special quoted mode.
+module XfOOrth
+
+  #* compiler/parser/special.rb - Parse source code in special quoted mode.
+  class Parser
+
+    #Get the next forth word and any embedded string data. This is used to
+    #support the quoted compiler mode.
+    #<br>Returns:
+    #* A string with the next non-comment language element or nil if none
+    #  could be found.
+    #<br>Endemic Code Smells
+    #*  :reek:TooManyStatements
+    def get_word_or_string
+      return nil unless (word = get_word)
+
+      if word[-1] == '"'
+        vm = Thread.current[:vm]
+        vm.quotes, skip, done = 1, false, false
+
+        until done
+          return nil unless (next_char = @source.get)
+          word << next_char
+
+          if skip
+            skip = false
+          elsif next_char == '"'
+            vm.quotes, done = 0, true
+          else
+            skip = (next_char == '\\')
+          end
+        end
+      end
+
+      word
+    end
+
+  end
+
+end

data/lib/fOOrth/compiler/process.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+require_relative 'process/get_token'
+require_relative 'process/string'
+require_relative 'process/procedure'
+require_relative 'process/generate'
+
+#* compiler/process.rb - Process source code from a code source.
+module XfOOrth
+
+  #* compiler/process.rb - Process source code from a code source.
+  class VirtualMachine
+
+    private
+
+    #Process the source code provided by the source parameter.
+    #<br>Parameters:
+    #* source - A source object. Typically a Console, StringSource or FileSource.
+    def process(source)
+      save, @parser, start_depth = @parser, Parser.new(source), @context.depth
+      due_process
+      @context.check_depth(start_depth)
+      @parser = save
+    end
+
+    #The actual work of processing source code.
+    def due_process
+      while (token = get_token)
+        due_token(token)
+      end
+    end
+
+    #Finally, process the taken.
+    def due_token(token)
+      dbg_puts token.to_s
+      code = token.code
+
+      if execute_mode? || ((token.has_tag?(:immediate)) && (!@force))
+        @context.recvr.instance_exec(self, &eval("lambda {|vm| #{code} }"))
+      else
+        @buffer << code
+        @force = false
+      end
+    end
+
+  end
+end