ibex 0.1.0 → 0.3.0

data/schema/table-simulation-v1.schema.json

@@ -0,0 +1,70 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/ydah/ibex/main/schema/table-simulation-v1.schema.json",
+  "title": "Ibex table simulation v1",
+  "type": "object",
+  "required": [
+    "ibex_table_simulation",
+    "schema_version",
+    "grammar_digest",
+    "algorithm",
+    "tokens",
+    "status",
+    "steps"
+  ],
+  "properties": {
+    "ibex_table_simulation": { "const": "table-simulation" },
+    "schema_version": { "const": 1 },
+    "grammar_digest": {
+      "type": "string",
+      "pattern": "^sha256:[0-9a-f]{64}$"
+    },
+    "algorithm": { "enum": ["slr", "lalr1", "ielr1", "lr1"] },
+    "tokens": {
+      "type": "array",
+      "items": { "type": "string" },
+      "maxItems": 100000
+    },
+    "status": { "enum": ["accepted", "error"] },
+    "steps": {
+      "type": "array",
+      "maxItems": 100000,
+      "items": { "$ref": "#/$defs/step" }
+    }
+  },
+  "additionalProperties": false,
+  "$defs": {
+    "step": {
+      "type": "object",
+      "required": [
+        "sequence",
+        "state",
+        "token_id",
+        "token",
+        "action",
+        "action_source",
+        "production_id",
+        "lhs",
+        "rhs_length",
+        "target_state",
+        "stack_depth_before",
+        "stack_depth_after"
+      ],
+      "properties": {
+        "sequence": { "type": "integer", "minimum": 1 },
+        "state": { "type": "integer", "minimum": 0 },
+        "token_id": { "type": "integer", "minimum": 0 },
+        "token": { "type": "string" },
+        "action": { "enum": ["shift", "reduce", "accept", "error"] },
+        "action_source": { "enum": ["explicit", "default", "implicit"] },
+        "production_id": { "type": ["integer", "null"], "minimum": 0 },
+        "lhs": { "type": ["string", "null"] },
+        "rhs_length": { "type": ["integer", "null"], "minimum": 0 },
+        "target_state": { "type": ["integer", "null"], "minimum": 0 },
+        "stack_depth_before": { "type": "integer", "minimum": 1 },
+        "stack_depth_after": { "type": "integer", "minimum": 1 }
+      },
+      "additionalProperties": false
+    }
+  }
+}

data/schema/verification-report-v1.schema.json

@@ -0,0 +1,222 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/ydah/ibex/main/schema/verification-report-v1.schema.json",
+  "title": "Ibex scoped generation verification report version 1",
+  "type": "object",
+  "required": [
+    "ibex_report",
+    "schema_version",
+    "checker",
+    "profile",
+    "bounds",
+    "input",
+    "ir",
+    "table",
+    "outcome",
+    "excluded_trust",
+    "evidence_digest"
+  ],
+  "properties": {
+    "ibex_report": { "const": "scoped_verification" },
+    "schema_version": { "const": 1 },
+    "checker": { "$ref": "#/$defs/checker" },
+    "profile": { "enum": ["default", "strict"] },
+    "bounds": { "$ref": "#/$defs/bounds" },
+    "input": { "$ref": "#/$defs/input" },
+    "ir": { "$ref": "#/$defs/ir" },
+    "table": { "$ref": "#/$defs/table" },
+    "outcome": { "$ref": "#/$defs/outcome" },
+    "excluded_trust": {
+      "const": [
+        "source_to_ir",
+        "table_semantic_derivation",
+        "generated_wrapper",
+        "semantic_actions",
+        "lexer_actions",
+        "runtime",
+        "application_hooks",
+        "grammar_unambiguity"
+      ]
+    },
+    "evidence_digest": { "$ref": "#/$defs/digest" }
+  },
+  "additionalProperties": false,
+  "$defs": {
+    "digest": {
+      "type": "string",
+      "pattern": "^sha256:[0-9a-f]{64}$"
+    },
+    "checker": {
+      "type": "object",
+      "required": ["name", "version"],
+      "properties": {
+        "name": { "const": "ibex.verify" },
+        "version": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "bounds": {
+      "type": "object",
+      "required": ["max_states", "max_items"],
+      "properties": {
+        "max_states": { "type": "integer", "minimum": 1 },
+        "max_items": { "type": "integer", "minimum": 1 }
+      },
+      "additionalProperties": false
+    },
+    "input_file": {
+      "type": "object",
+      "required": ["logical_path", "sha256", "bytesize"],
+      "properties": {
+        "logical_path": {
+          "type": "string",
+          "pattern": "^input/[0-9]{4}/(?!(?:\\.|\\.\\.)$)[^/\\\\\\u0000-\\u001f\\u007f]+$(?![\\s\\S])"
+        },
+        "sha256": { "$ref": "#/$defs/digest" },
+        "bytesize": { "type": "integer", "minimum": 0 }
+      },
+      "additionalProperties": false
+    },
+    "input": {
+      "type": "object",
+      "required": ["digest", "files"],
+      "properties": {
+        "digest": { "$ref": "#/$defs/digest" },
+        "files": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 10000,
+          "items": { "$ref": "#/$defs/input_file" }
+        }
+      },
+      "additionalProperties": false
+    },
+    "grammar_ir": {
+      "type": "object",
+      "required": ["schema_version", "digest"],
+      "properties": {
+        "schema_version": { "type": "integer", "minimum": 1 },
+        "digest": { "$ref": "#/$defs/digest" }
+      },
+      "additionalProperties": false
+    },
+    "automaton_ir": {
+      "type": "object",
+      "required": ["schema_version", "algorithm", "digest"],
+      "properties": {
+        "schema_version": { "type": "integer", "minimum": 1 },
+        "algorithm": { "enum": ["slr", "lalr1", "ielr1", "lr1"] },
+        "digest": { "$ref": "#/$defs/digest" }
+      },
+      "additionalProperties": false
+    },
+    "ir": {
+      "type": "object",
+      "description": "Digests of Automaton IR rebuilt with source-logical-v1 location identities; raw diagnostic paths are not hashed in this scope.",
+      "required": ["identity_scope", "grammar", "automaton"],
+      "properties": {
+        "identity_scope": { "const": "source-logical-v1" },
+        "grammar": { "$ref": "#/$defs/grammar_ir" },
+        "automaton": { "$ref": "#/$defs/automaton_ir" }
+      },
+      "additionalProperties": false
+    },
+    "table": {
+      "type": "object",
+      "required": [
+        "logical_path",
+        "artifact_type",
+        "schema_version",
+        "representation",
+        "artifact_digest",
+        "payload_digest"
+      ],
+      "properties": {
+        "logical_path": {
+          "type": "string",
+          "pattern": "^table/(?!(?:\\.|\\.\\.)$)[^/\\\\\\u0000-\\u001f\\u007f]+$(?![\\s\\S])"
+        },
+        "artifact_type": { "const": "ibex.parser-table" },
+        "schema_version": { "const": 1 },
+        "representation": { "enum": ["plain", "compact"] },
+        "artifact_digest": { "$ref": "#/$defs/digest" },
+        "payload_digest": { "$ref": "#/$defs/digest" }
+      },
+      "additionalProperties": false
+    },
+    "checks": {
+      "type": "array",
+      "items": { "enum": ["V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8", "V9"] },
+      "uniqueItems": true
+    },
+    "violation": {
+      "type": "object",
+      "required": ["id", "location", "message"],
+      "properties": {
+        "id": { "enum": ["V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8", "V9"] },
+        "location": { "type": "string" },
+        "message": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "exhaustion": {
+      "type": "object",
+      "required": ["kind", "message"],
+      "properties": {
+        "kind": { "const": "reference_collection_budget" },
+        "message": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "outcome": {
+      "type": "object",
+      "required": ["status", "requested_checks", "executed_checks", "violations", "exhaustion"],
+      "properties": {
+        "status": { "enum": ["pass", "violations", "exhausted"] },
+        "requested_checks": { "$ref": "#/$defs/checks" },
+        "executed_checks": { "$ref": "#/$defs/checks" },
+        "violations": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/violation" }
+        },
+        "exhaustion": {
+          "oneOf": [
+            { "type": "null" },
+            { "$ref": "#/$defs/exhaustion" }
+          ]
+        }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "status": { "const": "pass" } } },
+          "then": {
+            "properties": {
+              "violations": { "maxItems": 0 },
+              "exhaustion": { "type": "null" }
+            }
+          }
+        },
+        {
+          "if": { "properties": { "status": { "const": "violations" } } },
+          "then": {
+            "properties": {
+              "violations": { "minItems": 1 },
+              "exhaustion": { "type": "null" }
+            }
+          }
+        },
+        {
+          "if": { "properties": { "status": { "const": "exhausted" } } },
+          "then": {
+            "properties": {
+              "executed_checks": { "maxItems": 0 },
+              "violations": { "maxItems": 0 },
+              "exhaustion": { "$ref": "#/$defs/exhaustion" }
+            }
+          }
+        }
+      ],
+      "additionalProperties": false
+    }
+  }
+}

data/schema/verify-v1.schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/ydah/ibex/main/schema/verify-v1.schema.json",
+  "title": "Ibex independent verification report v1",
+  "type": "object",
+  "required": ["ibex_report", "schema_version", "result", "strict", "bounds", "violations"],
+  "properties": {
+    "ibex_report": { "const": "verify" },
+    "schema_version": { "const": 1 },
+    "algorithm": { "enum": ["slr", "lalr1", "ielr1", "lr1"] },
+    "strict": { "type": "boolean" },
+    "checks": {
+      "type": "array",
+        "items": { "enum": ["V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8", "V9"] },
+      "uniqueItems": true
+    },
+    "bounds": {
+      "type": "object",
+      "required": ["max_states", "max_items"],
+      "properties": {
+        "max_states": { "type": "integer", "minimum": 1 },
+        "max_items": { "type": "integer", "minimum": 1 }
+      },
+      "additionalProperties": false
+    },
+    "result": { "enum": ["valid", "invalid", "budget_exhausted"] },
+    "violations": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "location", "message"],
+        "properties": {
+          "id": { "enum": ["V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8", "V9"] },
+          "location": { "type": "string" },
+          "message": { "type": "string" }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}

data/sig/ibex/analysis/digraph.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/ibex/analysis/digraph.rb with RBS::Inline
+
+module Ibex
+  module Analysis
+    # Computes the transitive bit-set closure used by the LR lookahead
+    # algorithms.  The implementation is iterative so a large grammar cannot
+    # exhaust Ruby's call stack merely because its dependency graph is deep.
+    module Digraph
+      # @rbs (Array[Integer] initial, Array[Array[Integer]] edges) -> Array[Integer]
+      def self?.closure: (Array[Integer] initial, Array[Array[Integer]] edges) -> Array[Integer]
+
+      # @rbs (Array[Array[Integer]] edges) -> Array[Array[Integer]]
+      def self?.strongly_connected_components: (Array[Array[Integer]] edges) -> Array[Array[Integer]]
+
+      # @rbs (Array[Array[Integer]]) -> Array[Integer]
+      def self?.topological_order: (Array[Array[Integer]]) -> Array[Integer]
+    end
+  end
+end

data/sig/ibex/artifact_set.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/ibex/artifact_set.rb with RBS::Inline
+
+module Ibex
+  # One fully rendered file in a parser generation.
+  class Artifact
+    attr_reader kind: Symbol
+
+    attr_reader path: String
+
+    attr_reader content: String
+
+    attr_reader mode: Integer?
+
+    # @rbs (kind: Symbol, path: String, content: String, ?mode: Integer?) -> void
+    def initialize: (kind: Symbol, path: String, content: String, ?mode: Integer?) -> void
+  end
+
+  # A generation's rendered outputs before any target is changed.
+  class ArtifactSet
+    include Enumerable[Artifact]
+
+    # @rbs () -> void
+    def initialize: () -> void
+
+    # @rbs (kind: Symbol, path: String, content: String, ?mode: Integer?) -> Artifact
+    def add: (kind: Symbol, path: String, content: String, ?mode: Integer?) -> Artifact
+
+    def each: () -> Enumerator[Artifact, ArtifactSet]
+            | () { (Artifact) -> void } -> ArtifactSet
+
+    # @rbs () -> Array[Artifact]
+    def to_a: () -> Array[Artifact]
+
+    # @rbs () -> bool
+    def empty?: () -> bool
+  end
+end

data/sig/ibex/bison_import/importer.rbs

@@ -0,0 +1,140 @@
+# Generated from lib/ibex/bison_import/importer.rb with RBS::Inline
+
+module Ibex
+  module BisonImport
+    # Converts Bison declarations and productions into analysis-only Ibex
+    # source without parsing or executing C.
+    # rubocop:disable Metrics/ClassLength -- declaration and rule recovery share one positioned directive report.
+    class Importer
+      type alternative = { items: Array[String], precedence: String? }
+
+      type rule = { lhs: String, alternatives: Array[alternative] }
+
+      DEFAULT_MAX_BYTES: Integer
+
+      DEFAULT_MAX_TOKENS: Integer
+
+      DEFAULT_MAX_RULES: Integer
+
+      DEFAULT_MAX_ACTIONS: Integer
+
+      # @rbs (String source, file: String, ?class_name: String?, ?max_bytes: Integer,
+      #   ?max_tokens: Integer, ?max_rules: Integer, ?max_actions: Integer) -> void
+      def initialize: (String source, file: String, ?class_name: String?, ?max_bytes: Integer, ?max_tokens: Integer, ?max_rules: Integer, ?max_actions: Integer) -> void
+
+      # @rbs () -> Result
+      def run: () -> Result
+
+      private
+
+      # @rbs () -> void
+      def validate_source: () -> void
+
+      # @rbs () -> [String, String, Integer]
+      def split_sections: () -> [ String, String, Integer ]
+
+      # @rbs (String source) -> void
+      def parse_declarations: (String source) -> void
+
+      # @rbs (String source) -> Array[{ name: String, detail: String, line: Integer, column: Integer }]
+      def declaration_chunks: (String source) -> Array[{ name: String, detail: String, line: Integer, column: Integer }]
+
+      # @rbs (String detail) -> void
+      def parse_token_declaration: (String detail) -> void
+
+      # @rbs (String association, String detail) -> void
+      def parse_precedence: (String association, String detail) -> void
+
+      # @rbs (String detail) -> void
+      def parse_start: (String detail) -> void
+
+      # @rbs (Array[Tokenizer::Token] tokens) -> Array[rule]
+      def parse_rules: (Array[Tokenizer::Token] tokens) -> Array[rule]
+
+      # @rbs (Array[Tokenizer::Token] tokens) -> void
+      def register_nonterminals: (Array[Tokenizer::Token] tokens) -> void
+
+      # @rbs (Array[Tokenizer::Token] tokens, Integer cursor) -> [Integer, Integer]?
+      def next_lhs: (Array[Tokenizer::Token] tokens, Integer cursor) -> [ Integer, Integer ]?
+
+      # Bison permits a named reference between an LHS and its colon:
+      # `expression[result]: ...`.
+      # @rbs (Array[Tokenizer::Token] tokens, Integer cursor) -> [Integer, Integer]?
+      def lhs_definition_at: (Array[Tokenizer::Token] tokens, Integer cursor) -> [ Integer, Integer ]?
+
+      # @rbs (Array[Tokenizer::Token] tokens, Integer cursor) -> [Array[alternative], Integer]
+      def parse_alternatives: (Array[Tokenizer::Token] tokens, Integer cursor) -> [ Array[alternative], Integer ]
+
+      # @rbs (Array[Tokenizer::Token] tokens, Integer cursor, alternative alternative) -> Integer
+      def consume_rule_directive: (Array[Tokenizer::Token] tokens, Integer cursor, alternative alternative) -> Integer
+
+      # @rbs (Tokenizer::Token token) -> String
+      def render_symbol: (Tokenizer::Token token) -> String
+
+      # @rbs (Tokenizer::Token token) -> String
+      def render_action: (Tokenizer::Token token) -> String
+
+      # @rbs (String code) -> String
+      def transform_action: (String code) -> String
+
+      # @rbs (Array[rule] rules) -> String
+      def render_source: (Array[rule] rules) -> String
+
+      # @rbs () -> String
+      def structural_status: () -> String
+
+      # @rbs (Array[String] lines) -> void
+      def render_precedence: (Array[String] lines) -> void
+
+      # @rbs (Array[String] lines, rule rule) -> void
+      def render_rule: (Array[String] lines, rule rule) -> void
+
+      # @rbs (String name, Integer line, Integer column, String detail) -> void
+      def record_directive: (String name, Integer line, Integer column, String detail) -> void
+
+      # @rbs (String detail) -> Array[String]
+      def declaration_atoms: (String detail) -> Array[String]
+
+      # @rbs (String source) -> String
+      def strip_declaration_comments: (String source) -> String
+
+      # @rbs (String value) -> bool
+      def identifier_atom?: (String value) -> bool
+
+      # @rbs (String value) -> bool
+      def literal_atom?: (String value) -> bool
+
+      # @rbs (String value) -> String
+      def sanitize_symbol: (String value) -> String
+
+      # @rbs (String value) -> String
+      def terminal_name: (String value) -> String
+
+      # All imported nonterminals receive a lowercase namespace. This avoids
+      # Ibex's terminal-by-case convention and declaration keyword collisions.
+      # @rbs (String value) -> String
+      def nonterminal_name: (String value) -> String
+
+      # @rbs () -> String
+      def resolved_class_name: () -> String
+
+      # @rbs (String value) -> String
+      def sanitize_class_name: (String value) -> String
+
+      # @rbs (String value) -> Integer?
+      def first_integer: (String value) -> Integer?
+
+      # @rbs (Integer count) -> void
+      def check_rule_budget: (Integer count) -> void
+
+      # @rbs (Integer count, Tokenizer::Token token) -> void
+      def check_action_budget: (Integer count, Tokenizer::Token token) -> void
+
+      # @rbs (Integer value, Symbol name) -> Integer
+      def positive_limit: (Integer value, Symbol name) -> Integer
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def bounds: () -> Hash[Symbol, Integer]
+    end
+  end
+end

data/sig/ibex/bison_import/tokenizer.rbs

@@ -0,0 +1,91 @@
+# Generated from lib/ibex/bison_import/tokenizer.rb with RBS::Inline
+
+module Ibex
+  module BisonImport
+    # Iterative scanner for the punctuation needed to recover Bison rules.
+    class Tokenizer
+      # One structural token with a byte-oriented source position.
+      class Token
+        attr_reader type: Symbol
+
+        attr_reader value: String
+
+        attr_reader line: Integer
+
+        attr_reader column: Integer
+
+        # @rbs (type: Symbol, value: String, line: Integer, column: Integer) -> void
+        def initialize: (type: Symbol, value: String, line: Integer, column: Integer) -> void
+      end
+
+      IDENTIFIER_START: Regexp
+
+      IDENTIFIER_CONTINUE: Regexp
+
+      # @rbs (String source, start_line: Integer, max_tokens: Integer) -> void
+      def initialize: (String source, start_line: Integer, max_tokens: Integer) -> void
+
+      # @rbs () -> Array[Token]
+      def tokenize: () -> Array[Token]
+
+      private
+
+      # @rbs () -> Token
+      def scan_token: () -> Token
+
+      # @rbs () -> void
+      def skip_ignored: () -> void
+
+      # @rbs () -> String
+      def scan_identifier: () -> String
+
+      # @rbs () -> String
+      def scan_directive: () -> String
+
+      # @rbs (Integer quote) -> String
+      def scan_quoted: (Integer quote) -> String
+
+      # @rbs () -> String
+      def scan_action: () -> String
+
+      # @rbs (Integer? byte) -> bool
+      def skip_action_opaque?: (Integer? byte) -> bool
+
+      # @rbs (Integer opener, Integer closer) -> String
+      def scan_delimited: (Integer opener, Integer closer) -> String
+
+      # @rbs () -> void
+      def skip_block_comment: () -> void
+
+      # @rbs () -> void
+      def skip_line: () -> void
+
+      # @rbs (String value) -> Symbol
+      def punctuation_type: (String value) -> Symbol
+
+      # @rbs (Integer? byte) -> bool
+      def identifier_start?: (Integer? byte) -> bool
+
+      # @rbs (Integer? byte) -> bool
+      def identifier_continue?: (Integer? byte) -> bool
+
+      # @rbs (Integer? byte) -> bool
+      def whitespace?: (Integer? byte) -> bool
+
+      # @rbs (Integer count) -> void
+      def check_token_budget: (Integer count) -> void
+
+      # @rbs () -> Integer?
+      def current_byte: () -> Integer?
+
+      # @rbs () -> Integer?
+      def peek_byte: () -> Integer?
+
+      # @rbs () -> bool
+      def eof?: () -> bool
+
+      # @rbs () -> void
+      def advance: () -> void
+    end
+  end
+end