forthic 0.1.0

data/lib/forthic/variable.rb

@@ -0,0 +1,34 @@
+# # frozen_string_literal: true
+
+module Forthic
+  class Variable
+    attr_accessor :name, :value
+
+    # @param [String] name
+    # @param [Object] value
+    def initialize(name, value = nil)
+      @name = name
+      @value = value
+    end
+
+    # @return [String]
+    def get_name
+      @name
+    end
+
+    # @param [Object] val
+    def set_value(val)
+      @value = val
+    end
+
+    # @return [Object]
+    def get_value
+      @value
+    end
+
+    # @return [Variable]
+    def dup
+      Variable.new(@name, @value)
+    end
+  end
+end

data/lib/forthic/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Forthic
+  VERSION = "0.1.0"
+end

data/lib/forthic/words/definition_word.rb

@@ -0,0 +1,40 @@
+# # frozen_string_literal: true
+
+require_relative 'word'
+require_relative '../forthic_error'
+
+module Forthic
+  class DefinitionWord < Word
+    attr_accessor :words, :cur_index
+
+    # @param [String] name
+    def initialize(name)
+      super(name)
+      @words = []
+      @cur_index = 0
+    end
+
+    # @param [Word] word
+    def add_word(word)
+      @words.push(word)
+    end
+
+    # @param [Interpreter] interp
+    def execute(interp)
+      @words.each do |word|
+        begin
+          word.execute(interp)
+        rescue => e
+          error = ForthicError.new(
+            "definition_word-29",
+            "Error executing word #{word.name}",
+            "Error in #{self.name} definition",
+            interp.get_string_location
+          )
+          error.set_caught_error(e)
+          raise error
+        end
+      end
+    end
+  end
+end

data/lib/forthic/words/end_array_word.rb

@@ -0,0 +1,28 @@
+# # frozen_string_literal: true
+
+require_relative 'word'
+require_relative '../token'
+
+module Forthic
+  class EndArrayWord < Word
+    def initialize
+      super("]")
+    end
+
+    # @param [Interpreter] interp
+    def execute(interp)
+      items = []
+      item = interp.stack_pop
+
+      # NOTE: This won't infinite loop because interp.stack_pop() will eventually fail
+      loop do
+        break if item.is_a?(Token) && item.type == TokenType::START_ARRAY
+        items.push(item)
+        item = interp.stack_pop
+      end
+
+      items.reverse!
+      interp.stack_push(items)
+    end
+  end
+end

data/lib/forthic/words/end_module_word.rb

@@ -0,0 +1,16 @@
+# # frozen_string_literal: true
+
+require_relative 'word'
+
+module Forthic
+  class EndModuleWord < Word
+    def initialize
+      super("}")
+    end
+
+    # @param [Interpreter] interp
+    def execute(interp)
+      interp.module_stack_pop
+    end
+  end
+end

data/lib/forthic/words/imported_word.rb

@@ -0,0 +1,27 @@
+# # frozen_string_literal: true
+
+require_relative 'word'
+require_relative 'module_word'
+
+module Forthic
+  class ImportedWord < Word
+    attr_accessor :module_word, :imported_module
+
+    # @param [Word] module_word
+    # @param [String] prefix
+    # @param [ModuleWord] imported_module
+    def initialize(module_word, prefix, imported_module)
+      prefix = prefix.empty? ? "" : "#{prefix}."
+      super("#{prefix}#{module_word.name}")
+      @module_word = module_word
+      @imported_module = imported_module
+    end
+
+    # @param [Interpreter] interp
+    def execute(interp)
+      interp.module_stack_push(@imported_module)
+      @module_word.execute(interp)
+      interp.module_stack_pop
+    end
+  end
+end

data/lib/forthic/words/map_word.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Forthic
+  class MapWord
+    attr_accessor :forthic, :forthic_location, :items, :flags, :depth, :num_interps, :push_error, :with_key, :cur_index, :result, :errors, :is_debugging, :processing_item, :is_done
+
+    def initialize(items, forthic, forthic_location, flags)
+      @forthic = forthic
+      @forthic_location = forthic_location
+      @items = items
+      @flags = flags
+
+      # MAP flags
+      @depth = flags[:depth] || 0
+      @num_interps = flags[:interps] || 1
+      @push_error = flags[:push_error]
+      @with_key = flags[:with_key]
+
+      @cur_index = 0
+      @result = []
+      @errors = []
+      @is_debugging = false
+      @processing_item = false
+      @is_done = false
+    end
+
+    def execute(interp)
+      normal_execute(interp)
+    end
+
+    def normal_execute(interp)
+      @is_debugging = false
+      items = @items
+      if !items || items.empty?
+        interp.stack_push(items)
+        return
+      end
+
+      @result = []
+      @errors = []
+      if @num_interps > 1
+        interp.stack_push(items)
+        interp.run("LENGTH")
+        num_items = interp.stack_pop
+        group_size = (num_items.to_f / @num_interps).ceil
+        interp.stack_push(items)
+        interp.stack_push(group_size)
+        interp.run("GROUPS-OF")
+        groups = interp.stack_pop
+
+        # Clone and load up interpreters
+        interp_runs = []
+
+        groups.each do |group|
+          new_interp = interp.dup
+          interp_run = -> { map(new_interp, group) }
+          interp_runs.push(interp_run)
+        end
+
+        # Run in parallel using threads
+        threads = interp_runs.map do |interp_run|
+          Thread.new { interp_run.call }
+        end
+        run_results = threads.map(&:value)
+
+        # Gather results
+        is_array = items.is_a?(Array)
+        array_result = []
+        object_result = {}
+        errors = []
+        run_results.each do |res|
+          if is_array
+            array_result.concat(res[0])
+          else
+            object_result.merge!(res[0])
+          end
+          errors.concat(res[1])
+        end
+        @result = is_array ? array_result : object_result
+        @errors = errors
+      else
+        map(interp, items)
+      end
+
+      # Return results
+      interp.stack_push(@result)
+      interp.stack_push(@errors) if @push_error
+    end
+
+    def map(interp, items)
+      forthic = @forthic
+      forthic_location = @forthic_location
+      self_ref = self
+
+      if !items
+        interp.stack_push(items)
+        return
+      end
+
+      # This maps the forthic over an item, storing errors if needed
+      map_value = lambda do |key, value, errors|
+        interp.stack_push(key) if self_ref.with_key
+        interp.stack_push(value)
+
+        if self_ref.push_error
+          error = nil
+          begin
+            # If this runs successfully, it would have pushed the result onto the stack
+            interp.run(forthic, forthic_location)
+          rescue => e
+            # Since this didn't run successfully, push nil onto the stack
+            interp.stack_push(nil)
+            error = e
+          end
+          errors.push(error)
+        else
+          interp.run(forthic, forthic_location)
+        end
+        interp.stack_pop
+      end
+
+      # This recursively descends a record structure
+      descend_record = lambda do |record, depth, accum, errors|
+        record.each do |k, item|
+          if depth > 0
+            if item.is_a?(Array)
+              accum[k] = []
+              descend_list.call(item, depth - 1, accum[k], errors)
+            else
+              accum[k] = {}
+              descend_record.call(item, depth - 1, accum[k], errors)
+            end
+          else
+            accum[k] = map_value.call(k, item, errors)
+          end
+        end
+        accum
+      end
+
+      # This recursively descends a list
+      descend_list = lambda do |items, depth, accum, errors|
+        items.each_with_index do |item, i|
+          if depth > 0
+            if item.is_a?(Array)
+              accum.push([])
+              descend_list.call(item, depth - 1, accum.last, errors)
+            else
+              accum.push({})
+              descend_record.call(item, depth - 1, accum.last, errors)
+            end
+          else
+            accum.push(map_value.call(i, item, errors))
+          end
+        end
+        accum
+      end
+
+      errors = []
+      result = if items.is_a?(Array)
+                 descend_list.call(items, @depth, [], errors)
+               else
+                 descend_record.call(items, @depth, {}, errors)
+               end
+      @result = result
+      @errors = errors
+      [result, errors]
+    end
+  end
+end

data/lib/forthic/words/module_memo_bang_at_word.rb

@@ -0,0 +1,22 @@
+# # frozen_string_literal: true
+
+require_relative 'word'
+require_relative 'module_memo_word'
+
+module Forthic
+  class ModuleMemoBangAtWord < Word
+    attr_accessor :memo_word
+
+    # @param [ModuleMemoWord] memo_word
+    def initialize(memo_word)
+      super("#{memo_word.name}!@")
+      @memo_word = memo_word
+    end
+
+    # @param [Interpreter] interp
+    def execute(interp)
+      @memo_word.refresh(interp)
+      interp.stack_push(@memo_word.value)
+    end
+  end
+end

data/lib/forthic/words/module_memo_bang_word.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'word'
+require_relative 'module_memo_word'
+
+module Forthic
+  class ModuleMemoBangWord < Word
+    attr_accessor :memo_word
+
+    # @param [ModuleMemoWord] memo_word
+    def initialize(memo_word)
+      super("#{memo_word.name}!")
+      @memo_word = memo_word
+    end
+
+    # @param [Interpreter] interp
+    def execute(interp)
+      @memo_word.refresh(interp)
+    end
+  end
+end

data/lib/forthic/words/module_memo_word.rb

@@ -0,0 +1,35 @@
+# # frozen_string_literal: true
+
+require_relative 'word'
+
+module Forthic
+  class ModuleMemoWord < Word
+    attr_accessor :word, :has_value, :value
+
+    # @param [Word] word
+    def initialize(word)
+      super(word.name)
+      @word = word
+      @has_value = false
+      @value = nil
+    end
+
+    # @param [Interpreter] interp
+    def refresh(interp)
+      @word.execute(interp)
+      @value = interp.stack_pop
+      @has_value = true
+    end
+
+    # @param [Interpreter] interp
+    def execute(interp)
+      refresh(interp) unless @has_value
+      interp.stack_push(@value)
+    end
+
+    def reset
+      @has_value = false
+      @value = nil
+    end
+  end
+end

data/lib/forthic/words/module_word.rb

@@ -0,0 +1,21 @@
+# # frozen_string_literal: true
+
+require_relative 'word'
+
+module Forthic
+  class ModuleWord < Word
+    attr_accessor :handler
+
+    # @param [String] name
+    # @param [Proc] handler
+    def initialize(name, handler)
+      super(name)
+      @handler = handler
+    end
+
+    # @param [Interpreter] interp
+    def execute(interp)
+      @handler.call(interp)
+    end
+  end
+end

data/lib/forthic/words/push_value_word.rb

@@ -0,0 +1,21 @@
+# # frozen_string_literal: true
+
+require_relative 'word'
+
+module Forthic
+  class PushValueWord < Word
+    attr_accessor :value
+
+    # @param [String] name
+    # @param [Object] value
+    def initialize(name, value)
+      super(name)
+      @value = value
+    end
+
+    # @param [Interpreter] interp
+    def execute(interp, _options = {})
+      interp.stack_push(@value)
+    end
+  end
+end

data/lib/forthic/words/start_module_word.rb

@@ -0,0 +1,31 @@
+# # frozen_string_literal: true
+
+require_relative 'word'
+require_relative '../forthic_module'
+
+module Forthic
+  class StartModuleWord < Word
+    # @param [Interpreter] interp
+    def execute(interp)
+      # The app module is the only module with a blank name
+      if self.name == ""
+        interp.module_stack_push(interp.get_app_module)
+        return
+      end
+
+      # If the module is used by the current module, push it onto the stack, otherwise
+      # create a new module.
+      mod = interp.cur_module.find_module(self.name)
+      unless mod
+        mod = ForthicModule.new(self.name)
+        interp.cur_module.register_module(mod.name, mod.name, mod)
+
+        # If we're at the app module, also register with interpreter
+        if interp.cur_module.name == ""
+          interp.register_module(mod)
+        end
+      end
+      interp.module_stack_push(mod)
+    end
+  end
+end

data/lib/forthic/words/word.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Forthic
+  class Word
+    attr_accessor :name, :string, :location
+
+    # @param [String] name
+    def initialize(name)
+      @name = name
+      @string = name
+      @location = nil
+    end
+
+    # @param [CodeLocation] location
+    def set_location(location)
+      @location = location
+    end
+
+    # @return [CodeLocation, nil]
+    def get_location
+      @location
+    end
+
+    # @param [Interpreter] _interp
+    # @param [Hash] _options
+    def execute(_interp, _options = {})
+      raise "Must override Word.execute"
+    end
+  end
+end

data/lib/forthic.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "forthic/version"
+
+module Forthic
+  autoload :Tokenizer, 'forthic/tokenizer'
+  autoload :CodeLocation, 'forthic/code_location'
+  autoload :Token, 'forthic/token'
+  autoload :PositionedString, 'forthic/positioned_string'
+  autoload :ForthicError, 'forthic/forthic_error'
+  autoload :Word, 'forthic/words/word'
+  autoload :PushValueWord, 'forthic/words/push_value_word'
+  autoload :DefinitionWord, 'forthic/words/definition_word'
+  autoload :ModuleMemoWord, 'forthic/words/module_memo_word'
+  autoload :ModuleMemoBangAtWord, 'forthic/words/module_memo_bang_at_word'
+  autoload :ModuleMemoBangWord, 'forthic/words/module_memo_bang_word'
+  autoload :ModuleMemoBangAtWord, 'forthic/words/module_memo_bang_at_word'
+  autoload :EndArrayWord, 'forthic/words/end_array_word'
+  autoload :StartModuleWord, 'forthic/words/start_module_word'
+  autoload :EndModuleWord, 'forthic/words/end_module_word'
+  autoload :MapWord, 'forthic/words/map_word'
+  autoload :ForthicModule, 'forthic/forthic_module'
+  autoload :GlobalModule, 'forthic/global_module'
+  autoload :Interpreter, 'forthic/interpreter'
+end

data/sig/forthic.rbs

@@ -0,0 +1,4 @@
+module Forthic
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: forthic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rino Jose
+bindir: exe
+cert_chain: []
+date: 2025-01-02 00:00:00.000000000 Z
+dependencies: []
+description: This package provides a Forthic interpreter that allows you to execute
+  Forthic code within your Ruby projects. Forthic is a stack-based programming language
+  inspired by Forth.
+email:
+- rjose@forthix.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- Guardfile
+- README.md
+- Rakefile
+- lib/forthic.rb
+- lib/forthic/code_location.rb
+- lib/forthic/forthic_error.rb
+- lib/forthic/forthic_module.rb
+- lib/forthic/global_module.rb
+- lib/forthic/interpreter.rb
+- lib/forthic/positioned_string.rb
+- lib/forthic/token.rb
+- lib/forthic/tokenizer.rb
+- lib/forthic/variable.rb
+- lib/forthic/version.rb
+- lib/forthic/words/definition_word.rb
+- lib/forthic/words/end_array_word.rb
+- lib/forthic/words/end_module_word.rb
+- lib/forthic/words/imported_word.rb
+- lib/forthic/words/map_word.rb
+- lib/forthic/words/module_memo_bang_at_word.rb
+- lib/forthic/words/module_memo_bang_word.rb
+- lib/forthic/words/module_memo_word.rb
+- lib/forthic/words/module_word.rb
+- lib/forthic/words/push_value_word.rb
+- lib/forthic/words/start_module_word.rb
+- lib/forthic/words/word.rb
+- sig/forthic.rbs
+homepage: https://github.com/linkedin/forthic
+licenses: []
+metadata:
+  homepage_uri: https://github.com/linkedin/forthic
+  source_code_uri: https://github.com/linkedin/forthic
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A Forthic interpreter that runs within Ruby.
+test_files: []