ibex 0.1.0 → 0.2.0

data/gemfiles/Gemfile.lock

@@ -1,98 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    ast (2.4.3)
-    concurrent-ruby (1.3.8)
-    csv (3.3.5)
-    ffi (1.17.4)
-    ffi (1.17.4-arm64-darwin)
-    fileutils (1.8.0)
-    json (2.21.1)
-    language_server-protocol (3.17.0.6)
-    listen (3.10.0)
-      logger
-      rb-fsevent (~> 0.10, >= 0.10.3)
-      rb-inotify (~> 0.9, >= 0.9.10)
-    logger (1.7.0)
-    parser (3.3.12.0)
-      ast (~> 2.4.1)
-      racc
-    prism (1.9.0)
-    racc (1.8.1)
-    rainbow (3.1.1)
-    rb-fsevent (0.11.2)
-    rb-inotify (0.11.1)
-      ffi (~> 1.0)
-    rbs (4.0.3)
-      logger
-      prism (>= 1.6.0)
-      tsort
-    rbs-inline (0.14.0)
-      prism (>= 0.29)
-      rbs (~> 4.0)
-    securerandom (0.4.1)
-    steep (2.0.0)
-      concurrent-ruby (>= 1.1.10)
-      csv (>= 3.0.9)
-      fileutils (>= 1.1.0)
-      json (>= 2.1.0)
-      language_server-protocol (>= 3.17.0.4, < 4.0)
-      listen (~> 3.0)
-      logger (>= 1.3.0)
-      parser (>= 3.2)
-      prism (>= 0.25.0)
-      rainbow (>= 2.2.2, < 4.0)
-      rbs (~> 4.0)
-      securerandom (>= 0.1)
-      strscan (>= 1.0.0)
-      terminal-table (>= 2, < 5)
-      uri (>= 0.12.0)
-    strscan (3.1.8)
-    terminal-table (4.0.0)
-      unicode-display_width (>= 1.1.1, < 4)
-    tsort (0.2.0)
-    unicode-display_width (3.2.0)
-      unicode-emoji (~> 4.1)
-    unicode-emoji (4.2.0)
-    uri (1.1.1)
-
-PLATFORMS
-  arm64-darwin-24
-  ruby
-
-DEPENDENCIES
-  rbs (= 4.0.3)
-  rbs-inline (= 0.14.0)
-  steep (= 2.0.0)
-
-CHECKSUMS
-  ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
-  bundler (4.0.13) sha256=19f08be7f27022cf0b89f27da0b044ae075e8270a9ef44ad248a932614e1ca3b
-  concurrent-ruby (1.3.8) sha256=b2f1be836e968ccc78ccfce277ea79c72a88633f22306782c16ff23fb415d1e1
-  csv (3.3.5) sha256=6e5134ac3383ef728b7f02725d9872934f523cb40b961479f69cf3afa6c8e73f
-  ffi (1.17.4) sha256=bcd1642e06f0d16fc9e09ac6d49c3a7298b9789bcb58127302f934e437d60acf
-  ffi (1.17.4-arm64-darwin) sha256=19071aaf1419251b0a46852abf960e77330a3b334d13a4ab51d58b31a937001b
-  fileutils (1.8.0) sha256=8c6b1df54e2540bdb2f39258f08af78853aa70bad52b4d394bbc6424593c6e02
-  json (2.21.1) sha256=13a43df75d95641443f5702dff350f237164a9d811ff0f2c2800d4d980220583
-  language_server-protocol (3.17.0.6) sha256=5ef2c0c138f8267e1bc631d3328347d354f96724b0af22f2c79516120443b7f0
-  listen (3.10.0) sha256=c6e182db62143aeccc2e1960033bebe7445309c7272061979bb098d03760c9d2
-  logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
-  parser (3.3.12.0) sha256=21a6d7f755d5a24dfbdc6e6b772e4e879a52e7631a88bc5a3a134606052c9828
-  prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
-  racc (1.8.1) sha256=4a7f6929691dbec8b5209a0b373bc2614882b55fc5d2e447a21aaa691303d62f
-  rainbow (3.1.1) sha256=039491aa3a89f42efa1d6dec2fc4e62ede96eb6acd95e52f1ad581182b79bc6a
-  rb-fsevent (0.11.2) sha256=43900b972e7301d6570f64b850a5aa67833ee7d87b458ee92805d56b7318aefe
-  rb-inotify (0.11.1) sha256=a0a700441239b0ff18eb65e3866236cd78613d6b9f78fea1f9ac47a85e47be6e
-  rbs (4.0.3) sha256=5a7bf70e2628549d9a1f44eae447b2cfe55968a9c60cfff52693a4bdcc020e14
-  rbs-inline (0.14.0) sha256=eaf47b46690d63acddab1f6804c9cc205a4bc78e637cfc421a0b1239874ef51c
-  securerandom (0.4.1) sha256=cc5193d414a4341b6e225f0cb4446aceca8e50d5e1888743fac16987638ea0b1
-  steep (2.0.0) sha256=6eb0ecc09637bbb54f0a5f2cf63daea6d3208ccace64b4f1107d976333605c30
-  strscan (3.1.8) sha256=aae2db611a225559f21ffbb71765c9a4e60fd262534a9ea84f4f11c7f32f679e
-  terminal-table (4.0.0) sha256=f504793203f8251b2ea7c7068333053f0beeea26093ec9962e62ea79f94301d2
-  tsort (0.2.0) sha256=9650a793f6859a43b6641671278f79cfead60ac714148aabe4e3f0060480089f
-  unicode-display_width (3.2.0) sha256=0cdd96b5681a5949cdbc2c55e7b420facae74c4aaf9a9815eee1087cb1853c42
-  unicode-emoji (4.2.0) sha256=519e69150f75652e40bf736106cfbc8f0f73aa3fb6a65afe62fefa7f80b0f80f
-  uri (1.1.1) sha256=379fa58d27ffb1387eaada68c749d1426738bd0f654d812fcc07e7568f5c57c6
-
-BUNDLED WITH
-  4.0.13

data/lib/ibex/frontend/grammar.y

@@ -1,156 +0,0 @@
-class Ibex::Frontend::GeneratedParser < Ibex::Frontend::GeneratedParserBase
-token CLASS TOKEN PRECHIGH PRECLOW OPTIONS EXPECT START CONVERT PRAGMA RULE END
-token LEFT RIGHT NONASSOC IDENTIFIER LITERAL INTEGER ACTION USER_CODE LHS
-token SEPARATED_LIST SEPARATED_NONEMPTY_LIST
-rule
-  grammar
-    : CLASS constant_path superclass pragmas declarations RULE rules END user_code
-      { result = build_root(val[0], val[1], val[2], val[4], val[6], val[8]) }
-
-  constant_path
-    : IDENTIFIER                         { result = [val[0].value] }
-    | constant_path '::' IDENTIFIER      { result = val[0] + [val[2].value] }
-
-  superclass
-    :                                    { result = nil }
-    | '<' constant_path                  { result = val[1] }
-
-  pragmas
-    :
-    | pragmas PRAGMA IDENTIFIER
-
-  declarations
-    :                                    { result = Array.new(0) }
-    | declarations declaration           { result = val[0] + [val[1]] }
-
-  declaration
-    : token_declaration                  { result = val[0] }
-    | precedence_declaration             { result = val[0] }
-    | options_declaration                { result = val[0] }
-    | expect_declaration                 { result = val[0] }
-    | start_declaration                  { result = val[0] }
-    | convert_declaration                { result = val[0] }
-
-  token_declaration
-    : TOKEN symbols                      { result = build_tokens(val[0], val[1]) }
-
-  precedence_declaration
-    : PRECHIGH precedence_levels PRECLOW { result = build_precedence(val[0], :high_to_low, val[1]) }
-    | PRECLOW precedence_levels PRECHIGH { result = build_precedence(val[0], :low_to_high, val[1]) }
-
-  precedence_levels
-    :                                    { result = Array.new(0) }
-    | precedence_levels precedence_level { result = val[0] + [val[1]] }
-
-  precedence_level
-    : association symbols                { result = build_precedence_level(val[0], val[1]) }
-
-  association
-    : LEFT                               { result = val[0] }
-    | RIGHT                              { result = val[0] }
-    | NONASSOC                           { result = val[0] }
-
-  options_declaration
-    : OPTIONS identifiers                { result = build_options(val[0], val[1]) }
-
-  expect_declaration
-    : EXPECT INTEGER                     { result = build_expect(val[0], val[1]) }
-
-  start_declaration
-    : START grammar_symbol               { result = build_start(val[0], val[1].value) }
-
-  convert_declaration
-    : CONVERT conversions END            { result = build_convert(val[0], val[1]) }
-
-  conversions
-    :                                    { result = Array.new(0) }
-    | conversions conversion             { result = val[0] + [val[1]] }
-
-  conversion
-    : grammar_symbol LITERAL              { result = build_conversion(val[0], val[1]) }
-
-  identifiers
-    :                                    { result = Array.new(0) }
-    | identifiers IDENTIFIER              { result = val[0] + [val[1].value] }
-
-  symbols
-    :                                    { result = Array.new(0) }
-    | symbols grammar_symbol              { result = val[0] + [val[1].value] }
-
-  grammar_symbol
-    : IDENTIFIER                         { result = val[0] }
-    | LITERAL                            { result = val[0] }
-
-  rules
-    : rule_definition                    { result = [val[0]] }
-    | rules rule_definition              { result = val[0] + [val[1]] }
-
-  rule_definition
-    : LHS ':' alternatives semicolon     { result = build_rule(val[0], val[2]) }
-
-  semicolon
-    :
-    | ';'
-
-  alternatives
-    : alternative                        { result = [val[0]] }
-    | alternatives '|' alternative       { result = val[0] + [val[2]] }
-
-  alternative
-    : items precedence_override          { result = build_alternative(val[0], val[1]) }
-
-  precedence_override
-    :                                    { result = nil }
-    | '=' grammar_symbol                 { result = val[1] }
-
-  items
-    :                                    { result = Array.new(0) }
-    | items item                         { result = val[0] + [val[1]] }
-
-  item
-    : symbol_item                        { result = val[0] }
-    | ACTION                             { result = build_action(val[0]) }
-    | group_item                         { result = val[0] }
-    | separated_item                     { result = val[0] }
-
-  symbol_item
-    : grammar_symbol named_reference suffixes
-      { result = build_symbol_reference(val[0], val[1], val[2]) }
-
-  named_reference
-    :                                    { result = nil }
-    | ':' IDENTIFIER                     { result = [val[0], val[1]] }
-
-  suffixes
-    :                                    { result = Array.new(0) }
-    | suffixes '?'                       { result = val[0] + [val[1]] }
-    | suffixes '*'                       { result = val[0] + [val[1]] }
-    | suffixes '+'                       { result = val[0] + [val[1]] }
-
-  group_item
-    : '(' group_alternatives ')' suffixes
-      { result = build_group(val[0], val[1], val[3]) }
-
-  group_alternatives
-    : group_items                        { result = [val[0]] }
-    | group_alternatives '|' group_items { result = val[0] + [val[2]] }
-
-  group_items
-    :                                    { result = Array.new(0) }
-    | group_items group_item_element      { result = val[0] + [val[1]] }
-
-  group_item_element
-    : symbol_item                        { result = val[0] }
-    | group_item                         { result = val[0] }
-    | separated_item                     { result = val[0] }
-
-  separated_item
-    : SEPARATED_LIST '(' item ',' item ')'
-      { result = build_separated_list(val[0], val[2], val[4]) }
-    | SEPARATED_NONEMPTY_LIST '(' item ',' item ')'
-      { result = build_separated_list(val[0], val[2], val[4]) }
-
-  user_code
-    :                                    { result = empty_user_code }
-    | user_code USER_CODE                { result = append_user_code(val[0], val[1]) }
-end

data/lib/ibex/runtime/parser.rb

@@ -1,360 +0,0 @@
-# frozen_string_literal: true
-# rbs_inline: enabled
-
-module Ibex
-  module Runtime
-    # Parser-table shape understood by this runtime.
-    PARSER_TABLE_FORMAT_VERSION = 1 #: Integer
-
-    # Raised by the default parser error handler.
-    class ParseError < StandardError; end
-
-    # rubocop:disable Metrics/ClassLength
-
-    # Drives a table-defined LR parser without native extensions.
-    #
-    # Subclasses provide `.parser_tables`, returning `:tokens`, `:token_names`,
-    # `:actions`, `:gotos`, and `:productions`. Actions are represented by
-    # `[:shift, state]`, `[:reduce, production]`, `[:accept]`, or `[:error]`.
-    class Parser
-      EOF_TOKEN = 0 #: Integer
-      ERROR_TOKEN = 1 #: Integer
-      NO_LOOKAHEAD = Object.new.freeze #: Object
-      RECOVERY_SHIFTS = 3 #: Integer
-      empty_row = {} # @type var empty_row: Hash[Integer, untyped]
-
-      EMPTY_ROW = empty_row.freeze #: Hash[Integer, untyped]
-
-      # @rbs @yydebug: bool
-      # @rbs @yydebug_output: IO
-      # @rbs @source: (^() -> untyped)?
-      # @rbs @state_stack: Array[Integer]
-      # @rbs @value_stack: Array[untyped]
-      # @rbs @lookahead: untyped
-      # @rbs @lookahead_value: untyped
-      # @rbs @recovery_shifts: Integer
-      # @rbs @semantic_error: bool
-      # @rbs @accept_requested: bool
-      # @rbs @unknown_token_id: Integer?
-      # @rbs @unknown_token_name: String?
-
-      attr_accessor :yydebug #: bool
-      attr_writer :yydebug_output #: IO
-
-      # @rbs () -> void
-      def initialize
-        @yydebug = false
-        @yydebug_output = $stderr
-        @source = nil
-        @state_stack = []
-        @value_stack = []
-        @lookahead = NO_LOOKAHEAD
-        @lookahead_value = nil
-        @recovery_shifts = 0
-        @semantic_error = false
-        @accept_requested = false
-        @unknown_token_id = nil
-      end
-
-      # Pull tokens from `next_token` and parse them.
-      # @rbs () -> untyped
-      def do_parse
-        drive_parser(-> { next_token })
-      end
-
-      # Parse tokens yielded by `receiver.method_id`.
-      # @rbs (untyped receiver, Symbol method_id) -> untyped
-      def yyparse(receiver, method_id)
-        stream = Enumerator.new do |tokens|
-          receiver.__send__(method_id) { |token| tokens << token }
-        end
-        drive_parser(-> { stream.next })
-      end
-
-      # Override in pull parsers. Return `[token, value]`, `false`, or `nil`.
-      # @rbs () -> ([untyped, untyped] | false | nil)
-      def next_token
-        raise NotImplementedError, "(input):1:1: next_token must be implemented"
-      end
-
-      # Override to recover from syntax errors. The default always raises.
-      # @rbs (Integer token_id, untyped value, Array[untyped] value_stack) -> untyped
-      def on_error(token_id, value, _value_stack)
-        expected = expected_tokens
-        suffix = expected.empty? ? "" : "; expected #{expected.join(', ')}"
-        raise ParseError, "(input):1:1: unexpected #{token_to_str(token_id)}#{suffix} (#{value.inspect})"
-      end
-
-      # Called after an ordinary input token is shifted. Override to observe
-      # the internal token id, semantic value, and destination state.
-      # @rbs (Integer token_id, untyped value, Integer state) -> void
-      def on_shift(_token_id, _value, _state); end
-
-      # Called after a production's semantic action and goto are committed.
-      # Override to observe its id, RHS values, and semantic result.
-      # @rbs (Integer production_id, Array[untyped] values, untyped result) -> void
-      def on_reduce(_production_id, _values, _result); end
-
-      # Called after the synthetic error token enters a recovery state.
-      # The payload describes the original error before recovery popped stacks.
-      # @rbs (Integer token_id, untyped value, Array[untyped] value_stack) -> void
-      def on_error_recover(_token_id, _value, _value_stack); end
-
-      # Return a human-readable name for an internal token id.
-      # @rbs (Integer token_id) -> String
-      def token_to_str(token_id)
-        return @unknown_token_name || token_id.to_s if token_id == @unknown_token_id
-
-        parser_tables.fetch(:token_names).fetch(token_id, token_id.to_s)
-      end
-
-      # Enter error recovery from a semantic action without calling `on_error`.
-      # @rbs () -> nil
-      def yyerror
-        @semantic_error = true
-        nil
-      end
-
-      # Leave error recovery immediately.
-      # @rbs () -> nil
-      def yyerrok
-        @recovery_shifts = 0
-        nil
-      end
-
-      # Accept immediately after the current semantic action completes.
-      # @rbs () -> nil
-      def yyaccept
-        @accept_requested = true
-        nil
-      end
-
-      # Return token names accepted in the current parser state.
-      # @rbs () -> Array[String]
-      def expected_tokens
-        return [] if @state_stack.empty?
-
-        state = @state_stack.last
-        parser_tables.fetch(:token_names).keys.filter_map do |token_id|
-          action = table_lookup(parser_tables.fetch(:actions), state, token_id) || default_action(state) || [:error]
-          token_to_str(token_id) unless error_action?(action) || token_id == ERROR_TOKEN
-        end
-      end
-
-      private
-
-      # @rbs (^() -> untyped source) -> untyped
-      def drive_parser(source)
-        prepare_parse(source)
-        loop do
-          action = action_for_current_state
-          outcome = perform(action)
-          return outcome[1] if outcome[0] == :done
-        end
-      ensure
-        @source = nil
-      end
-
-      # @rbs (^() -> untyped source) -> void
-      def prepare_parse(source)
-        validate_parser_table_format!
-        @source = source
-        @state_stack = [0]
-        @value_stack = []
-        @lookahead = NO_LOOKAHEAD
-        @lookahead_value = nil
-        @recovery_shifts = 0
-        @semantic_error = false
-        @accept_requested = false
-        @unknown_token_id = nil
-        trace("start state 0")
-      end
-
-      # @rbs () -> void
-      def validate_parser_table_format!
-        tables = parser_tables
-        unless tables.key?(:format_version)
-          raise ParseError,
-                "(tables):1:1: parser tables for #{self.class} are missing :format_version; " \
-                "regenerate the parser with the installed Ibex version"
-        end
-
-        actual = tables.fetch(:format_version)
-        return if actual == PARSER_TABLE_FORMAT_VERSION
-
-        raise ParseError,
-              "(tables):1:1: unsupported parser table format version #{actual.inspect} for #{self.class}; " \
-              "runtime supports #{PARSER_TABLE_FORMAT_VERSION}; regenerate the parser with the installed Ibex version"
-      end
-
-      # @rbs () -> untyped
-      def action_for_current_state
-        read_lookahead if @lookahead.equal?(NO_LOOKAHEAD)
-        state = @state_stack.last
-        return [:error] unless parser_tables.fetch(:token_names).key?(@lookahead)
-
-        explicit = table_lookup(parser_tables.fetch(:actions), state, @lookahead)
-        return explicit if explicit
-
-        default_action(state) || [:error]
-      end
-
-      # @rbs (untyped action) -> untyped
-      def perform(action)
-        case action.first
-        when :shift then shift(action.fetch(1))
-        when :reduce then reduce(action.fetch(1))
-        when :accept then [:done, @value_stack.last]
-        when :error then recover
-        else raise ParseError, "(tables):1:1: unknown parser action #{action.inspect}"
-        end
-      end
-
-      # @rbs (Integer next_state) -> untyped
-      def shift(next_state)
-        token_id = @lookahead
-        value = @lookahead_value
-        trace("shift #{token_to_str(token_id)} -> state #{next_state}")
-        @state_stack << next_state
-        @value_stack << value
-        @lookahead = NO_LOOKAHEAD
-        @recovery_shifts -= 1 if @recovery_shifts.positive?
-        on_shift(token_id, value, next_state)
-        [:continue]
-      end
-
-      # @rbs (Integer production_id) -> untyped
-      def reduce(production_id)
-        production = parser_tables.fetch(:productions).fetch(production_id)
-        length = production.fetch(:length)
-        values = @value_stack.last(length)
-        hook_values = values.dup
-        @state_stack.pop(length)
-        @value_stack.pop(length)
-        result = reduction_value(production, values)
-        next_state = table_lookup(parser_tables.fetch(:gotos), @state_stack.last, production.fetch(:lhs))
-        raise ParseError, "(tables):1:1: missing goto for production #{production_id}" if next_state.nil?
-
-        @state_stack << next_state
-        @value_stack << result
-        trace("reduce #{production_id} (#{length}) -> state #{next_state}")
-        on_reduce(production_id, hook_values, result)
-        return [:done, result] if @accept_requested
-        return recover(report: false) if @semantic_error
-
-        [:continue]
-      end
-
-      # @rbs (Hash[Symbol, untyped] production, Array[untyped] values) -> untyped
-      def reduction_value(production, values)
-        action = production[:action]
-        return values.first unless action
-        return instance_exec(values, @value_stack.dup, &action) if action.respond_to?(:call)
-
-        __send__(action, values, @value_stack.dup)
-      end
-
-      # @rbs (?report: bool) -> untyped
-      def recover(report: true)
-        @semantic_error = false
-        if @recovery_shifts.positive?
-          return [:done, nil] if @lookahead == EOF_TOKEN
-
-          trace("discard #{token_to_str(@lookahead)} during recovery")
-          @lookahead = NO_LOOKAHEAD
-          return [:continue]
-        end
-
-        token_id = @lookahead
-        value = @lookahead_value
-        value_stack = @value_stack.dup
-        on_error(token_id, value, value_stack.dup) if report
-        return [:done, nil] unless shift_error_token
-
-        @recovery_shifts = RECOVERY_SHIFTS
-        on_error_recover(token_id, value, value_stack)
-        [:continue]
-      end
-
-      # @rbs () -> bool
-      def shift_error_token
-        loop do
-          action = table_lookup(parser_tables.fetch(:actions), @state_stack.last, ERROR_TOKEN)
-          if action&.first == :shift
-            trace("recover: shift error -> state #{action.fetch(1)}")
-            @state_stack << action.fetch(1)
-            @value_stack << nil
-            return true
-          end
-          return false if @state_stack.length == 1
-
-          trace("recover: pop state #{@state_stack.last}")
-          @state_stack.pop
-          @value_stack.pop
-        end
-      end
-
-      # @rbs () -> void
-      def read_lookahead
-        pair = read_external_token
-        if pair.nil? || pair == false
-          @lookahead = EOF_TOKEN
-          @lookahead_value = nil
-        else
-          external_token, @lookahead_value = pair
-          @lookahead = internal_token_id(external_token)
-        end
-        trace("read #{token_to_str(@lookahead)}")
-      end
-
-      # @rbs () -> untyped
-      def read_external_token
-        source = @source
-        raise ParseError, "(input):1:1: token source is not available" unless source
-
-        source.call
-      rescue StopIteration
-        false
-      end
-
-      # @rbs (untyped external_token) -> Integer
-      def internal_token_id(external_token)
-        token_id = parser_tables.fetch(:tokens)[external_token]
-        return token_id if token_id
-
-        @unknown_token_name = external_token.inspect
-        @unknown_token_id = -external_token.object_id.abs
-      end
-
-      # @rbs () -> Hash[Symbol, untyped]
-      def parser_tables
-        self.class.__send__(:parser_tables)
-      rescue NoMethodError
-        raise ParseError, "(tables):1:1: #{self.class} must define .parser_tables"
-      end
-
-      # @rbs (untyped action) -> bool
-      def error_action?(action)
-        action.nil? || action.first == :error
-      end
-
-      # @rbs (Integer state) -> untyped
-      def default_action(state)
-        parser_tables.fetch(:default_actions, EMPTY_ROW)[state]
-      end
-
-      # @rbs (untyped table, Integer row, Integer column) -> untyped
-      def table_lookup(table, row, column)
-        return table.lookup(row, column) if table.respond_to?(:lookup)
-
-        table.fetch(row, EMPTY_ROW)[column]
-      end
-
-      # @rbs (String message) -> void
-      def trace(message)
-        @yydebug_output.puts("ibex: #{message}") if @yydebug
-      end
-    end
-    # rubocop:enable Metrics/ClassLength
-  end
-end

data/lib/ibex/runtime.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "runtime/parser"
-
-module Ibex
-  module Runtime
-  end
-end