forthic 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4e71f6368dc2bcc817f0095a389740a6676005ab8ddb862cdef02f0e0910d09d
+  data.tar.gz: b408177ce893d5353aa00ce2a73698005c07e22e3d68a8ec6cade6032887a591
+SHA512:
+  metadata.gz: 2ffd692800bdf839d25a106c79bea485addaeabb7d2eafd5366a9d034927a642fed7b4ecb498e5f081016f5079077d3a4db4ba96eae113a8ce547024b4164736
+  data.tar.gz: b4ab0aec5f7b788873bbbc71761f5382f565864057101125919338c24453bdccdedbcf26f281dc5c46dee4a16fc7824a08516a52c9c318af91ab0f932a329f42

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-12-27
+
+- Initial release

data/Guardfile

@@ -0,0 +1,42 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exist?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+
+  # with Minitest::Spec
+  # watch(%r{^spec/(.*)_spec\.rb$})
+  # watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+
+  # Rails 4
+  # watch(%r{^app/(.+)\.rb$})                               { |m| "test/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/application_controller\.rb$}) { 'test/controllers' }
+  # watch(%r{^app/controllers/(.+)_controller\.rb$})        { |m| "test/integration/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)_mailer/.+})                    { |m| "test/mailers/#{m[1]}_mailer_test.rb" }
+  # watch(%r{^lib/(.+)\.rb$})                               { |m| "test/lib/#{m[1]}_test.rb" }
+  # watch(%r{^test/.+_test\.rb$})
+  # watch(%r{^test/test_helper\.rb$}) { 'test' }
+
+  # Rails < 4
+  # watch(%r{^app/controllers/(.*)\.rb$}) { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r{^app/helpers/(.*)\.rb$})     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r{^app/models/(.*)\.rb$})      { |m| "test/unit/#{m[1]}_test.rb" }
+end

data/README.md

@@ -0,0 +1,37 @@
+# Forthic
+
+A Forthic interpreter that runs within Ruby.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add forthic
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install forthic
+```
+
+## Usage
+
+Here's a basic example of how to use the Forthic interpreter:
+
+```ruby
+require 'forthic'
+
+interp = Forthic::Interpreter.new
+interp.run("[1 2 3] '8 *' MAP")
+puts interp.stack_pop
+
+# Output:
+#
+# [ 8, 16, 24 ]
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/linkedin/forthic.

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "standard/rake"
+
+task default: %i[test standard]
+
+task :guard do
+  sh "bundle exec guard"
+end

data/lib/forthic/code_location.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Forthic
+  class CodeLocation
+    attr_accessor :screen_name, :line, :column, :start_pos, :end_pos
+
+    # @param [String] screen_name
+    # @param [Integer] line
+    # @param [Integer] column
+    # @param [Integer] start_pos
+    # @param [Integer] end_pos
+    def initialize(screen_name: "<ad-hoc>", line: 1, column: 1, start_pos: 0, end_pos: 0)
+      @screen_name = screen_name
+      @line = line
+      @column = column
+      @start_pos = start_pos
+      @end_pos = end_pos
+    end
+  end
+end

data/lib/forthic/forthic_error.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Forthic
+  class ForthicError < StandardError
+    attr_accessor :error_key, :title, :description, :location, :caught_error
+
+    # @param [String] error_key
+    # @param [String] title
+    # @param [String] description
+    # @param [CodeLocation, nil] location
+    def initialize(error_key, title, description, location = nil)
+      @error_key = error_key
+      @title = title
+      @description = description
+      @location = location
+      @caught_error = nil
+      puts "ForthicError: #{error_key}, #{title}, #{description}, #{location}"
+    end
+
+    # @param [ForthicError] error
+    def set_caught_error(error)
+      @caught_error = error
+    end
+
+    # @return [String]
+    def get_title
+      @title
+    end
+
+    # @return [String]
+    def get_description
+      @description
+    end
+
+    # @return [Array<ForthicError>]
+    def get_error_stack
+      max_depth = 100
+      cur_error = self
+      result = [cur_error]
+
+      max_depth.times do
+        break unless cur_error.caught_error
+
+        result << cur_error.caught_error
+        cur_error = cur_error.caught_error
+      end
+
+      result.reverse
+    end
+  end
+end

data/lib/forthic/forthic_module.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative 'words/word'
+require_relative 'words/module_word'
+require_relative 'words/module_memo_word'
+require_relative 'words/module_memo_bang_word'
+require_relative 'words/module_memo_bang_at_word'
+require_relative 'words/imported_word'
+require_relative 'variable'
+
+module Forthic
+  class ForthicModule
+    attr_accessor :words, :exportable, :variables, :modules, :module_prefixes, :required_modules, :name, :forthic_code, :module_id
+
+    # @param [String] name
+    # @param [Interpreter, nil] interp
+    # @param [String] forthic_code
+    def initialize(name, interp = nil, forthic_code = "")
+      @words = []
+      @exportable = []
+      @variables = {}
+      @modules = {}
+      @module_prefixes = {}
+      @required_modules = []
+      @name = name
+      @forthic_code = forthic_code
+      @module_id = "#{name}-#{rand(1_000_000)}"
+    end
+
+    # @return [ForthicModule]
+    def dup
+      result = ForthicModule.new(@name, @interp, @forthic_code)
+      result.words = @words.dup
+      result.exportable = @exportable.dup
+      @variables.each { |key, var| result.variables[key] = var.dup }
+      @modules.each { |key, mod| result.modules[key] = mod }
+      result.required_modules = @required_modules.dup
+      result.forthic_code = @forthic_code
+      result
+    end
+
+    # @param [String] prefix
+    # @param [ForthicModule] mod
+    def require_module(prefix, mod)
+      @required_modules << { prefix: prefix, module: mod }
+    end
+
+    # @param [String] name
+    # @return [ForthicModule, nil]
+    def find_module(name)
+      @modules[name]
+    end
+
+    # @param [String] word_name
+    # @param [Proc] word_func
+    def add_module_word(word_name, word_func)
+      add_exportable_word(ModuleWord.new(word_name, word_func))
+    end
+
+    # @param [Word] word
+    def add_word(word)
+      @words << word
+    end
+
+    # @param [Word] word
+    # @return [ModuleMemoWord]
+    def add_memo_words(word)
+      memo_word = ModuleMemoWord.new(word)
+      @words << memo_word
+      @words << ModuleMemoBangWord.new(memo_word)
+      @words << ModuleMemoBangAtWord.new(memo_word)
+      memo_word
+    end
+
+    # @param [Array<String>] names
+    def add_exportable(names)
+      @exportable.concat(names)
+    end
+
+    # @return [Array<Word>]
+    def exportable_words
+      @words.select { |word| @exportable.include?(word.name) }
+    end
+
+    # @param [Word] word
+    def add_exportable_word(word)
+      @words << word
+      @exportable << word.name
+    end
+
+    # @param [String] name
+    # @param [Object, nil] value
+    def add_variable(name, value = nil)
+      @variables[name] ||= Variable.new(name, value)
+    end
+
+    # @param [Interpreter] interp
+    def initialize_modules(interp)
+      @required_modules.each do |rec|
+        import_module(rec[:prefix], rec[:module], interp)
+      end
+    end
+
+    # @param [String] module_name
+    # @param [String] prefix
+    # @param [ForthicModule] mod
+    def register_module(module_name, prefix, mod)
+      @modules[module_name] = mod
+      @module_prefixes[module_name] ||= Set.new
+      @module_prefixes[module_name] << prefix
+    end
+
+    # @param [String] prefix
+    # @param [ForthicModule] mod
+    # @param [Interpreter] interp
+    def import_module(prefix, mod, interp)
+      new_module = mod.dup
+      new_module.initialize_modules(interp)
+
+      new_module.exportable_words.each do |word|
+        add_word(ImportedWord.new(word, prefix, new_module))
+      end
+      register_module(mod.name, prefix, new_module)
+    end
+
+    # @param [String] name
+    # @return [Word, nil]
+    def find_word(name)
+      find_dictionary_word(name) || find_variable(name)
+    end
+
+    # @param [String] word_name
+    # @return [Word, nil]
+    def find_dictionary_word(word_name)
+      @words.reverse.find { |w| w.name == word_name }
+    end
+
+    # @param [String] varname
+    # @return [PushValueWord, nil]
+    def find_variable(varname)
+      var_result = @variables[varname]
+      var_result ? PushValueWord.new(varname, var_result) : nil
+    end
+  end
+end