forthic 0.1.0

data/lib/forthic/interpreter.rb

@@ -0,0 +1,328 @@
+# frozen_string_literal: true
+
+require_relative 'forthic_error'
+require_relative 'tokenizer'
+require_relative 'token'
+require_relative 'code_location'
+require_relative 'positioned_string'
+require_relative 'words/word'
+require_relative 'words/push_value_word'
+require_relative 'words/start_module_word'
+require_relative 'words/end_module_word'
+require_relative 'words/end_array_word'
+require_relative 'words/definition_word'
+require_relative 'global_module'
+
+module Forthic
+  class Interpreter
+    attr_accessor :stack, :global_module, :app_module, :module_stack, :registered_modules,
+                  :is_compiling, :should_stop, :is_memo_definition, :cur_definition,
+                  :screens, :default_module_flags, :module_flags, :string_location,
+                  :word_counts, :is_profiling, :start_profile_time, :timestamps
+
+    def initialize
+      @stack = []
+      @registered_modules = {}
+      @is_compiling = false
+      @should_stop = false
+      @is_memo_definition = false
+      @cur_definition = nil
+      @screens = {}
+      @default_module_flags = {}
+      @module_flags = {}
+      @string_location = nil
+
+      @global_module = GlobalModule.new(self)
+      @app_module = ForthicModule.new("", self)
+      @module_stack = [@app_module]
+
+      @word_counts = {}
+      @is_profiling = false
+      @start_profile_time = nil
+      @timestamps = []
+    end
+
+    def halt
+      @should_stop = true
+    end
+
+    # @return [ForthicModule]
+    def get_app_module
+      @app_module
+    end
+
+    # @return [CodeLocation, nil]
+    def get_string_location
+      @string_location
+    end
+
+    # @param [String] module_id
+    # @param [Hash] flags
+    def set_flags(module_id, flags)
+      @default_module_flags[module_id] = flags
+      @module_flags[module_id] = flags
+    end
+
+    # @param [String] module_id
+    # @return [Hash]
+    def get_flags(module_id)
+      module_flags = @module_flags[module_id] || {}
+      result = module_flags.dup
+      @module_flags[module_id] = @default_module_flags[module_id].dup
+      result
+    end
+
+    # @param [String] module_id
+    # @param [Hash] flags
+    def modify_flags(module_id, flags)
+      module_flags = @module_flags[module_id] || {}
+      @module_flags[module_id] = module_flags.merge(flags)
+    end
+
+    def reset
+      @stack = []
+      @app_module.variables = {}
+      @module_stack = [@app_module]
+      @is_compiling = false
+      @is_memo_definition = false
+      @cur_definition = nil
+      @string_location = nil
+    end
+
+    # @param [String] screen_name
+    # @return [String]
+    def get_screen_forthic(screen_name)
+      screen = @screens[screen_name]
+      raise ForthicError.new("interpreter-199", "Unable to find screen \"#{screen_name}\"", "Hmmm...something went wrong. Please file a ticket if this continues to happen") unless screen
+      screen
+    end
+
+    # @param [String] string
+    # @param [CodeLocation, nil] reference_location
+    # @return [Boolean]
+    def run(string, reference_location = nil)
+      tokenizer = Tokenizer.new(string, reference_location)
+      run_with_tokenizer(tokenizer)
+    end
+
+    # @param [Tokenizer] tokenizer
+    # @return [Boolean]
+    def run_with_tokenizer(tokenizer)
+      token = nil
+      loop do
+        token = tokenizer.next_token
+        handle_token(token)
+        break if token.type == TokenType::EOS || @should_stop
+        next if [TokenType::START_DEF, TokenType::END_DEF, TokenType::COMMENT].include?(token.type) || @is_compiling
+      end
+      true
+    # rescue => e
+    #   error = ForthicError.new("interpreter-213", "Ran into an error executing this '#{token.string}'", "If there is an unknown error in the stack details, please file a ticket so we can resolve it.", token.location)
+    #   error.set_caught_error(e)
+    #   raise error
+    end
+
+    # @return [ForthicModule]
+    def cur_module
+      @module_stack.last
+    end
+
+    # @param [String] name
+    # @return [ForthicModule]
+    def find_module(name)
+      result = @registered_modules[name]
+      raise ForthicError.new("interpreter-236", "Couldn't find '#{name}' module", "This is most likely a typo in your Forthic code. Please check to see if '#{name}' is properly spelled and that you have permission to access it") unless result
+      result
+    end
+
+    # @param [Object] val
+    def stack_push(val)
+      @stack.push(val)
+    end
+
+    # @return [Object]
+    def stack_pop
+      raise ForthicError.new("interpreter-251", "Stack underflow", "This happens when we expect something to be on the stack, but it's empty. This is caused by a logical error in the Forthic and can be resolved through debugging.") if @stack.empty?
+      result = @stack.pop
+      @string_location = result.is_a?(PositionedString) ? result.location : nil
+      result.is_a?(PositionedString) ? result.value_of : result
+    end
+
+    # @param [ForthicModule] mod
+    def module_stack_push(mod)
+      @module_stack.push(mod)
+    end
+
+    def module_stack_pop
+      @module_stack.pop
+    end
+
+    # @param [ForthicModule] mod
+    def register_module(mod)
+      @registered_modules[mod.name] = mod
+    end
+
+    # @param [ForthicModule] mod
+    def run_module_code(mod)
+      module_stack_push(mod)
+      run(mod.forthic_code)
+      module_stack_pop
+    rescue => e
+      error = ForthicError.new("interpreter-278", "Something went wrong when running the module #{mod.name}", "TODO: File a ticket")
+      error.set_caught_error(e)
+      raise error
+    end
+
+    # @param [String] name
+    # @return [Word, nil]
+    def find_word(name)
+      result = nil
+      @module_stack.reverse_each do |m|
+        result = m.find_word(name)
+        break if result
+      end
+      result ||= @global_module.find_word(name)
+      result
+    end
+
+    def start_profiling
+      @is_profiling = true
+      @timestamps = []
+      @start_profile_time = Time.now
+      add_timestamp("START")
+      @word_counts = {}
+    end
+
+    # @param [Word] word
+    def count_word(word)
+      return unless @is_profiling
+      @word_counts[word.name] ||= 0
+      @word_counts[word.name] += 1
+    end
+
+    def stop_profiling
+      add_timestamp("END")
+      @is_profiling = false
+    end
+
+    # @param [String] label
+    def add_timestamp(label)
+      return unless @is_profiling
+      timestamp = { label: label, time_ms: (Time.now - @start_profile_time) * 1000 }
+      @timestamps.push(timestamp)
+    end
+
+    # @return [Array<Hash>]
+    def word_histogram
+      @word_counts.map { |name, count| { word: name, count: count } }.sort_by { |item| -item[:count] }
+    end
+
+    # @return [Array<Hash>]
+    def profile_timestamps
+      @timestamps
+    end
+
+    # @param [Token] token
+    def handle_token(token)
+      case token.type
+      when TokenType::STRING then handle_string_token(token)
+      when TokenType::COMMENT then handle_comment_token(token)
+      when TokenType::START_ARRAY then handle_start_array_token(token)
+      when TokenType::END_ARRAY then handle_end_array_token(token)
+      when TokenType::START_MODULE then handle_start_module_token(token)
+      when TokenType::END_MODULE then handle_end_module_token(token)
+      when TokenType::START_DEF then handle_start_definition_token(token)
+      when TokenType::START_MEMO then handle_start_memo_token(token)
+      when TokenType::END_DEF then handle_end_definition_token(token)
+      when TokenType::WORD then handle_word_token(token)
+      when TokenType::EOS then return
+      else
+        raise ForthicError.new("interpreter-362", "Hmmm...the interpreter doesn't know what to make of '#{token.string}'", "This is most likely caused by a typo in the Forthic code and can be resolved by debugging.", token.location)
+      end
+    end
+
+    # @param [Token] token
+    def handle_string_token(token)
+      value = PositionedString.new(token.string, token.location)
+      handle_word(PushValueWord.new("<string>", value))
+    end
+
+    # @param [Token] token
+    def handle_start_module_token(token)
+      word = StartModuleWord.new(token.string)
+      @cur_definition.add_word(word) if @is_compiling
+      count_word(word)
+      word.execute(self)
+    end
+
+    # @param [Token] _token
+    def handle_end_module_token(_token)
+      word = EndModuleWord.new
+      @cur_definition.add_word(word) if @is_compiling
+      count_word(word)
+      word.execute(self)
+    end
+
+    # @param [Token] token
+    def handle_start_array_token(token)
+      handle_word(PushValueWord.new("<start_array_token>", token))
+    end
+
+    # @param [Token] _token
+    def handle_end_array_token(_token)
+      handle_word(EndArrayWord.new)
+    end
+
+    # @param [Token] _token
+    def handle_comment_token(_token)
+      # Handle comment token (no-op)
+    end
+
+    # @param [Token] token
+    def handle_start_definition_token(token)
+      raise ForthicError.new("interpreter-407", "A definition was started while an existing definition was not ended", "This is probably caused by a missing semicolon. To resolve, ensure that all word definitions end with semicolons.", token.location) if @is_compiling
+      @cur_definition = DefinitionWord.new(token.string)
+      @is_compiling = true
+      @is_memo_definition = false
+    end
+
+    # @param [Token] token
+    def handle_start_memo_token(token)
+      raise ForthicError.new("interpreter-420", "A memo definition was started while an existing definition was not ended", "This is probably caused by a missing semicolon. To resolve, ensure that all word definitions end with semicolons.", token.location) if @is_compiling
+      @cur_definition = DefinitionWord.new(token.string)
+      @is_compiling = true
+      @is_memo_definition = true
+    end
+
+    # @param [Token] token
+    def handle_end_definition_token(token)
+      raise ForthicError.new("interpreter-433", "A definition was ended when one hadn't been started yet", "This is probably caused by an extra semicolon. To resolve, ensure that there are no spurious semicolons in the Forthic code.", token.location) unless @is_compiling
+      raise ForthicError.new("interpreter-440", "Cannot finish definition because there is no current definition", "Please file a ticket", token.location) unless @cur_definition
+      if @is_memo_definition
+        cur_module.add_memo_words(@cur_definition)
+      else
+        cur_module.add_word(@cur_definition)
+      end
+      @is_compiling = false
+    end
+
+    # @param [Token] token
+    def handle_word_token(token)
+      word = find_word(token.string)
+      raise ForthicError.new("interpreter-458", "Could not find word: #{token.string}", "Check to see if you have a typo in your word or the definition of that word", token.location) unless word
+      handle_word(word, token.location)
+    end
+
+    # @param [Word] word
+    # @param [CodeLocation, nil] location
+    def handle_word(word, location = nil)
+      if @is_compiling
+        word.set_location(location)
+        @cur_definition.add_word(word)
+      else
+        count_word(word)
+        word.execute(self)
+      end
+    end
+  end
+end

data/lib/forthic/positioned_string.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Forthic
+  class PositionedString
+    attr_accessor :string, :location
+
+    # @string [String] the string value
+    # @location [CodeLocation] the location of the string in the code
+    def initialize(string, location)
+      @string = string
+      @location = location
+    end
+
+    # @return [String]
+    def value_of
+      @string
+    end
+  end
+end

data/lib/forthic/token.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Forthic
+  module TokenType
+    STRING = 1
+    COMMENT = 2
+    START_ARRAY = 3
+    END_ARRAY = 4
+    START_MODULE = 5
+    END_MODULE = 6
+    START_DEF = 7
+    END_DEF = 8
+    START_MEMO = 9
+    WORD = 10
+    EOS = 11
+  end
+end
+
+
+module Forthic
+  class Token
+    attr_reader :type, :value, :location
+
+    # @param [TokenType] type
+    # @param [String] value
+    # @param [CodeLocation] location
+    def initialize(type, value, location)
+      @type = type
+      @value = value
+      @location = location
+    end
+
+    # @return [String]
+    def string
+      @value
+    end
+  end
+end

data/lib/forthic/tokenizer.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+module Forthic
+  class Tokenizer
+    attr_accessor :reference_location, :line, :column, :input_string, :input_pos,
+                  :whitespace, :quote_chars, :token_start_pos, :token_end_pos,
+                  :token_line, :token_column, :token_string
+
+    # @param [String] string
+    # @param [CodeLocation, nil] reference_location
+    def initialize(string, reference_location = nil)
+      reference_location ||= CodeLocation.new(screen_name: "<ad-hoc>")
+      @reference_location = reference_location
+      @line = reference_location.line
+      @column = reference_location.column
+      @input_string = unescape_string(string)
+      @input_pos = 0
+      @whitespace = [" ", "\t", "\n", "\r", "(", ")", ","]
+      @quote_chars = ['"', "'"]
+
+      # Token info
+      @token_start_pos = 0
+      @token_end_pos = 0
+      @token_line = 0
+      @token_column = 0
+      @token_string = ""
+    end
+
+    # @return [Token]
+    def next_token
+      clear_token_string
+      transition_from_START
+    end
+
+    # @param [String] string
+    # @return [String]
+    def unescape_string(string)
+      string
+    end
+
+    def clear_token_string
+      @token_string = ""
+    end
+
+    def note_start_token
+      @token_start_pos = @input_pos + @reference_location.start_pos
+      @token_line = @line
+      @token_column = @column
+    end
+
+    # @param [String] char
+    # @return [Boolean]
+    def is_whitespace(char)
+      @whitespace.include?(char)
+    end
+
+    # @param [String] char
+    # @return [Boolean]
+    def is_quote(char)
+      @quote_chars.include?(char)
+    end
+
+    # @param [Integer] index
+    # @param [String] char
+    # @return [Boolean]
+    def is_triple_quote(index, char)
+      return false unless is_quote(char)
+      return false if index + 2 >= @input_string.length
+      @input_string[index + 1] == char && @input_string[index + 2] == char
+    end
+
+    # @param [Integer] index
+    # @return [Boolean]
+    def is_start_memo(index)
+      return false if index + 1 >= @input_string.length
+      @input_string[index] == "@" && @input_string[index + 1] == ":"
+    end
+
+    # @param [Integer] num_chars
+    def advance_position(num_chars)
+      if num_chars >= 0
+        num_chars.times do
+          if @input_string[@input_pos] == "\n"
+            @line += 1
+            @column = 1
+          else
+            @column += 1
+          end
+          @input_pos += 1
+        end
+      else
+        (-num_chars).times do
+          @input_pos -= 1
+          raise Forthic::Error, "Invalid position" if @input_pos < 0 || @column < 0
+          if @input_string[@input_pos] == "\n"
+            @line -= 1
+            @column = 1
+          else
+            @column -= 1
+          end
+        end
+      end
+    end
+
+    # @return [CodeLocation]
+    def get_token_location
+      CodeLocation.new(
+        screen_name: @reference_location.screen_name,
+        line: @token_line,
+        column: @token_column,
+        start_pos: @token_start_pos,
+        end_pos: @token_start_pos + @token_string.length
+      )
+    end
+
+    # @return [Token]
+    def transition_from_START
+      while @input_pos < @input_string.length
+        char = @input_string[@input_pos]
+        note_start_token
+        advance_position(1)
+
+        next if is_whitespace(char)
+        case char
+        when "#"
+          return transition_from_COMMENT
+        when ":"
+          return transition_from_START_DEFINITION
+        when ";"
+          @token_string = char
+          return Token.new(TokenType::END_DEF, char, get_token_location)
+        when "["
+          @token_string = char
+          return Token.new(TokenType::START_ARRAY, char, get_token_location)
+        when "]"
+          @token_string = char
+          return Token.new(TokenType::END_ARRAY, char, get_token_location)
+        when "{"
+          return transition_from_GATHER_MODULE
+        when "}"
+          @token_string = char
+          return Token.new(TokenType::END_MODULE, char, get_token_location)
+        else
+          if is_start_memo(@input_pos - 1)
+            advance_position(1)
+            return transition_from_START_MEMO
+          elsif is_triple_quote(@input_pos - 1, char)
+            advance_position(2)
+            return transition_from_GATHER_TRIPLE_QUOTE_STRING(char)
+          elsif is_quote(char)
+            return transition_from_GATHER_STRING(char)
+          else
+            advance_position(-1)
+            return transition_from_GATHER_WORD
+          end
+        end
+      end
+      Token.new(TokenType::EOS, "", get_token_location)
+    end
+
+    # @return [Token]
+    def transition_from_COMMENT
+      note_start_token
+      while @input_pos < @input_string.length
+        char = @input_string[@input_pos]
+        @token_string += char
+        advance_position(1)
+        break if char == "\n"
+      end
+      Token.new(TokenType::COMMENT, @token_string, get_token_location)
+    end
+
+    # @return [Token]
+    def transition_from_START_DEFINITION
+      while @input_pos < @input_string.length
+        char = @input_string[@input_pos]
+        advance_position(1)
+        next if is_whitespace(char)
+        if is_quote(char)
+          raise Forthic::Error, "Definition names can't have quotes in them"
+        else
+          advance_position(-1)
+          return transition_from_GATHER_DEFINITION_NAME
+        end
+      end
+      raise Forthic::Error, "Got EOS in START_DEFINITION"
+    end
+
+    # @return [Token]
+    def transition_from_START_MEMO
+      while @input_pos < @input_string.length
+        char = @input_string[@input_pos]
+        advance_position(1)
+        next if is_whitespace(char)
+        if is_quote(char)
+          raise Forthic::Error, "Definitions shouldn't have quotes in them"
+        else
+          advance_position(-1)
+          return transition_from_GATHER_MEMO_NAME
+        end
+      end
+      raise Forthic::Error, "Got EOS in START_MEMO"
+    end
+
+    def gather_definition_name
+      while @input_pos < @input_string.length
+        char = @input_string[@input_pos]
+        advance_position(1)
+        break if is_whitespace(char)
+        if is_quote(char)
+          raise Forthic::Error, "Definition names can't have quotes in them"
+        elsif ["[", "]", "{", "}"].include?(char)
+          raise Forthic::Error, "Definitions can't have '#{char}' in them"
+        else
+          @token_string += char
+        end
+      end
+    end
+
+    # @return [Token]
+    def transition_from_GATHER_DEFINITION_NAME
+      note_start_token
+      gather_definition_name
+      Token.new(TokenType::START_DEF, @token_string, get_token_location)
+    end
+
+    # @return [Token]
+    def transition_from_GATHER_MEMO_NAME
+      note_start_token
+      gather_definition_name
+      Token.new(TokenType::START_MEMO, @token_string, get_token_location)
+    end
+
+    # @return [Token]
+    def transition_from_GATHER_MODULE
+      note_start_token
+      while @input_pos < @input_string.length
+        char = @input_string[@input_pos]
+        advance_position(1)
+        break if is_whitespace(char)
+        if char == "}"
+          advance_position(-1)
+          break
+        else
+          @token_string += char
+        end
+      end
+      Token.new(TokenType::START_MODULE, @token_string, get_token_location)
+    end
+
+    # @param [String] delim
+    # @return [Token]
+    def transition_from_GATHER_TRIPLE_QUOTE_STRING(delim)
+      note_start_token
+      string_delimiter = delim
+
+      while @input_pos < @input_string.length
+        char = @input_string[@input_pos]
+        if char == string_delimiter && is_triple_quote(@input_pos, char)
+          advance_position(3)
+          return Token.new(TokenType::STRING, @token_string, get_token_location)
+        else
+          advance_position(1)
+          @token_string += char
+        end
+      end
+      raise Forthic::Error, "Unterminated string: #{delim * 3}#{@token_string}"
+    end
+
+    # @param [String] delim
+    # @return [Token]
+    def transition_from_GATHER_STRING(delim)
+      note_start_token
+      string_delimiter = delim
+
+      while @input_pos < @input_string.length
+        char = @input_string[@input_pos]
+        advance_position(1)
+        if char == string_delimiter
+          return Token.new(TokenType::STRING, @token_string, get_token_location)
+        else
+          @token_string += char
+        end
+      end
+      raise Forthic::Error, "Unterminated string: #{delim}#{@token_string}"
+    end
+
+    # @return [Token]
+    def transition_from_GATHER_WORD
+      note_start_token
+      while @input_pos < @input_string.length
+        char = @input_string[@input_pos]
+        advance_position(1)
+        break if is_whitespace(char)
+        if [";", "[", "]", "{", "}", "#"].include?(char)
+          advance_position(-1)
+          break
+        else
+          @token_string += char
+        end
+      end
+      Token.new(TokenType::WORD, @token_string, get_token_location)
+    end
+  end
+end