postsvg 0.1.0 → 0.3.0

data/lib/postsvg/source/ast_builder.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Source
+    # Walks a token stream from the Lexer and produces a typed
+    # Model::Program. Procedures, arrays, and dictionaries are kept as
+    # Model literal nodes; operators are constructed via the
+    # Model::Operators registry.
+    class AstBuilder
+      attr_reader :tokens, :stack, :body, :header, :dict_stack, :recursion_depth
+
+      MAX_PROC_DEPTH = 64
+
+      def initialize(tokens)
+        @tokens = tokens
+        @stack = OperandStack.new
+        @body = []
+        @dict_stack = [{}] # global dictionary
+        @header = Model::Program::Header.new
+        @recursion_depth = 0
+      end
+
+      def self.build(tokens)
+        new(tokens).build
+      end
+
+      def build
+        Model::Operators.load_all!
+        consume_until(tokens.length)
+        Model::Program.new(header: @header, body: @body)
+      end
+
+      private
+
+      def consume_until(end_index, terminators: [], depth: 0)
+        raise RecursionLimitError, "procedure depth exceeded #{MAX_PROC_DEPTH}" if depth > MAX_PROC_DEPTH
+
+        i = 0
+        collected = []
+        while i < end_index
+          token = tokens[i]
+          break if terminators.include?(token&.type)
+
+          i += consume_token(token, collected)
+        end
+        collected
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+      def consume_token(token, collected)
+        case token.type
+        when :number
+          node = build_number(token)
+          @stack.push(node)
+          append_statement(node, collected)
+          1
+        when :string
+          node = Model::Literals::StringLiteral.new(token.value)
+          @stack.push(node)
+          append_statement(node, collected)
+          1
+        when :hexstring
+          node = Model::Literals::HexLiteral.new(token.value)
+          @stack.push(node)
+          append_statement(node, collected)
+          1
+        when :name
+          node = Model::Literals::Name.new(token.value, literal: token.literal || false)
+          @stack.push(node)
+          append_statement(node, collected)
+          1
+        when :proc_open
+          consume_procedure(after: token_position(token), collected: collected)
+        when :array_open
+          consume_array(after: token_position(token), collected: collected)
+        when :dict_open
+          consume_dict(after: token_position(token), collected: collected)
+        when :dsc
+          apply_dsc(token)
+          1
+        when :operator
+          consume_operator(token, collected)
+        else
+          1
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+      # Push a literal onto both the parse stack and the program body.
+      # The body is what the visitor walks; the stack is what operator
+      # factories pop from.
+      def append_statement(node, collected)
+        @body << node
+        collected << node
+      end
+
+      def token_position(token)
+        [token.line, token.column]
+      end
+
+      def build_number(token)
+        raw = token.value
+        value =
+          if raw =~ /\A[-+]?\d+\z/
+            raw.to_i
+          elsif raw =~ /\A[-+]?\d+\.\d+\z/ || raw =~ /\A[-+]?(\.\d+|\d+\.)\z/
+            raw.to_f
+          elsif raw =~ /\A[-+]?(\d+\.?\d*|\.\d+)[eE][-+]?\d+\z/
+            raw.to_f
+          else
+            raw.to_f
+          end
+        Model::Literals::Number.new(value)
+      end
+
+      # Consume a procedure body. Returns the number of tokens consumed
+      # (including the closing brace). The Procedure value is pushed
+      # onto the stack AND recorded as a statement on the program body
+      # so the renderer can visit it standalone.
+      def consume_procedure(after:, collected:)
+        start_index = find_index(after)
+        body_tokens, end_index = match_braces(start_index + 1)
+        body_nodes = sub_build(body_tokens)
+        procedure = Model::Literals::Procedure.new(body_nodes)
+        @stack.push(procedure)
+        append_statement(procedure, collected)
+        end_index - start_index + 1
+      end
+
+      def consume_array(after:, collected:)
+        start_index = find_index(after)
+        body_tokens, end_index = match_until(start_index + 1, :array_close, :array_open)
+        body_nodes = sub_build(body_tokens)
+        array = Model::Literals::ArrayLiteral.new(body_nodes.select { |n| literal?(n) })
+        @stack.push(array)
+        append_statement(array, collected)
+        end_index - start_index + 1
+      end
+
+      def consume_dict(after:, collected:)
+        start_index = find_index(after)
+        body_tokens, end_index = match_until(start_index + 1, :dict_close, :dict_open)
+        entries = {}
+        pending_key = nil
+        sub_nodes = sub_build(body_tokens)
+        sub_nodes.each do |node|
+          if node.is_a?(Model::Literals::Name) && node.literal?
+            pending_key = node.value
+          elsif pending_key
+            entries[pending_key] = node
+            pending_key = nil
+          end
+        end
+        dict = Model::Literals::Dictionary.new(entries)
+        @stack.push(dict)
+        collected << dict
+        end_index - start_index + 1
+      end
+
+      def literal?(node)
+        node.is_a?(Model::Literals::Number) ||
+          node.is_a?(Model::Literals::Name) ||
+          node.is_a?(Model::Literals::StringLiteral) ||
+          node.is_a?(Model::Literals::HexLiteral) ||
+          node.is_a?(Model::Literals::ArrayLiteral) ||
+          node.is_a?(Model::Literals::Procedure) ||
+          node.is_a?(Model::Literals::Dictionary)
+      end
+
+      def sub_build(sub_tokens)
+        # Build a temporary AstBuilder over a sub-token-stream and
+        # harvest its body. The temp builder shares no state with the
+        # outer one.
+        return [] if sub_tokens.empty?
+
+        program = AstBuilder.new(sub_tokens).build
+        program.body
+      end
+
+      def find_index(line_col)
+        line, col = line_col
+        tokens.each_with_index do |tok, idx|
+          return idx if tok.line == line && tok.column == col
+        end
+        tokens.length
+      end
+
+      def match_braces(start_index)
+        depth = 1
+        i = start_index
+        while i < tokens.length
+          tok = tokens[i]
+          if tok.type == :proc_open
+            depth += 1
+          elsif tok.type == :proc_close
+            depth -= 1
+            return [tokens[start_index...i], i] if depth.zero?
+          end
+          i += 1
+        end
+        raise SyntaxError, "unbalanced procedure braces"
+      end
+
+      def match_until(start_index, close_type, open_type)
+        depth = 1
+        i = start_index
+        while i < tokens.length
+          tok = tokens[i]
+          if tok.type == open_type
+            depth += 1
+          elsif tok.type == close_type
+            depth -= 1
+            return [tokens[start_index...i], i] if depth.zero?
+          end
+          i += 1
+        end
+        raise SyntaxError, "unbalanced #{close_type}"
+      end
+
+      def consume_operator(token, collected)
+        keyword = token.value
+
+        # Resolve user-defined names to InvokeProcedure.
+        if (proc_value = lookup_user_definition(keyword))
+          if proc_value.is_a?(Model::Literals::Procedure)
+            inv = Model::InvokeProcedure.new(name: keyword, procedure: proc_value)
+            @body << inv
+            collected << inv
+            return 1
+          end
+        end
+
+        operator_class = Model::Operators[keyword]
+        unless operator_class
+          unknown = Model::UnknownOperator.new(keyword: keyword)
+          @body << unknown
+          collected << unknown
+          return 1
+        end
+
+        operator = operator_class.from_operands(@stack)
+        return 1 if operator.nil?
+
+        # Reflect the runtime stack shape: push a +Computed+ sentinel
+        # for each value the operator would have produced at runtime.
+        # This lets chained operators (findfont ... scalefont, add +
+        # mul, etc.) parse cleanly even though their intermediate
+        # results aren't yet known.
+        operator.class.produces.to_i.times do
+          @stack.push(Model::Computed.new(operator_keyword: keyword))
+        end
+
+        @body << operator
+        collected << operator
+        apply_side_effects(operator)
+        1
+      end
+
+      # When a `def` operator is constructed, capture the binding into
+      # the active dictionary so subsequent operator tokens can resolve
+      # to InvokeProcedure.
+      def apply_side_effects(operator)
+        case operator
+        when Model::Operators::Dictionary::Def
+          @dict_stack.last[operator.key.to_s.sub(/\A\//, "")] = operator.value
+        end
+      end
+
+      def lookup_user_definition(name)
+        @dict_stack.reverse_each do |dict|
+          return dict[name] if dict.key?(name)
+        end
+        nil
+      end
+
+      def apply_dsc(token)
+        text = token.value.strip
+        case text
+        when /\ABoundingBox:\s*(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\z/
+          @header = @header.with(bounding_box: [
+            ::Regexp.last_match(1).to_f, ::Regexp.last_match(2).to_f,
+            ::Regexp.last_match(3).to_f, ::Regexp.last_match(4).to_f,
+          ])
+        when /\AHiResBoundingBox:\s*(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\z/
+          @header = @header.with(hires_bounding_box: [
+            ::Regexp.last_match(1).to_f, ::Regexp.last_match(2).to_f,
+            ::Regexp.last_match(3).to_f, ::Regexp.last_match(4).to_f,
+          ])
+        when /\ATitle:\s*(.+)\z/
+          @header = @header.with(title: ::Regexp.last_match(1))
+        when /\ACreator:\s*(.+)\z/
+          @header = @header.with(creator: ::Regexp.last_match(1))
+        when /\ACreationDate:\s*(.+)\z/
+          @header = @header.with(creation_date: ::Regexp.last_match(1))
+        when /\APages:\s*(\d+)\s+(\d+)\z/
+          @header = @header.with(page_count: ::Regexp.last_match(1).to_i,
+                                 pages: ::Regexp.last_match(2).to_i)
+        when /\ALanguageLevel:\s*(\d+)\z/
+          @header = @header.with(language_level: ::Regexp.last_match(1).to_i)
+        when /\AEOF/, /\AEndComments/
+          nil
+        else
+          @header = @header.with(custom: @header.custom.merge(text => true))
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/source/lexer.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Source
+    # Comment-aware PS lexer.
+    #
+    # Distinguishes +#+ line comments from +%+ inside string literals,
+    # captures DSC comments (lines beginning with +%%+), and tags every
+    # token with its source position (line, column).
+    #
+    # The legacy Tokenizer stripped comments with a global
+    # +gsub(/%[^\n\r]*/, " ")+ before lexing, which corrupted +%+ chars
+    # inside string literals. This implementation walks the source as a
+    # state machine so +%+ inside (...) or <...> survives.
+    class Lexer
+      attr_reader :source, :position, :line, :column
+
+      def initialize(source)
+        @source = source.to_s
+        @position = 0
+        @line = 1
+        @column = 1
+        @tokens = []
+        @state = :top
+      end
+
+      def tokenize
+        until eos?
+          case @state
+          when :top        then scan_top
+          when :string     then scan_string_body
+          when :hexstring  then scan_hexstring_body
+          when :comment    then scan_comment_body
+          when :dsc        then scan_dsc_body
+          end
+        end
+        @tokens.freeze
+      end
+
+      def self.tokenize(source)
+        new(source).tokenize
+      end
+
+      private
+
+      def eos? = @position >= @source.bytesize
+
+      def peek(offset = 0)
+        @source.getbyte(@position + offset)
+      end
+
+      def advance
+        byte = @source.getbyte(@position)
+        @position += 1
+        if byte == 10 # \n
+          @line += 1
+          @column = 1
+        else
+          @column += 1
+        end
+        byte
+      end
+
+      def scan_top
+        skip_whitespace and return
+        byte = peek
+        return if byte.nil?
+
+        char = byte.chr
+
+        case char
+        when "%"        then start_dsc_or_comment
+        when "("        then start_string
+        when "<"
+          if peek(1) == 60 # <<
+            advance
+            advance
+            emit(:dict_open, "<<")
+          else
+            start_hexstring
+          end
+        when ">"        then maybe_close_dict
+        when "{"        then advance and emit(:proc_open, "{")
+        when "}"        then advance and emit(:proc_close, "}")
+        when "["        then advance and emit(:array_open, "[")
+        when "]"        then advance and emit(:array_close, "]")
+        when "/", "\\"
+          start_name_with_slash(char)
+        else
+          scan_word_or_number
+        end
+      end
+
+      def skip_whitespace
+        consumed = false
+        until eos?
+          byte = peek
+          break unless whitespace_byte?(byte)
+
+          advance
+          consumed = true
+        end
+        consumed
+      end
+
+      def whitespace_byte?(byte)
+        byte && [32, 9, 10, 13, 12, 11, 0].include?(byte)
+      end
+
+      def start_dsc_or_comment
+        advance # consume first %
+        if peek == 37 # second %
+          advance # consume second %
+          @state = :dsc
+        else
+          @state = :comment
+        end
+      end
+
+      def scan_dsc_body
+        start_pos = @position
+        start_line = @line
+        start_col = @column
+        until eos? || @source.getbyte(@position) == 10
+          advance
+        end
+        text = @source.byteslice(start_pos, @position - start_pos)
+        @tokens << Model::Token.new(:dsc, text.chomp, line: start_line, column: start_col)
+        @state = :top
+      end
+
+      def scan_comment_body
+        until eos? || @source.getbyte(@position) == 10
+          advance
+        end
+        @state = :top
+      end
+
+      def start_string
+        start_line = @line
+        start_col = @column
+        advance # consume (
+        @string_start = { line: start_line, column: start_col, bytes: +"" }
+        @string_depth = 1
+        @state = :string
+      end
+
+      def scan_string_body
+        until eos?
+          byte = @source.getbyte(@position)
+          case byte
+          when 92 # backslash
+            advance
+            handle_escape
+          when 40 # (
+            advance
+            @string_depth += 1
+            @string_start[:bytes] << "("
+          when 41 # )
+            advance
+            @string_depth -= 1
+            if @string_depth.zero?
+              emit_string
+              return
+            end
+            @string_start[:bytes] << ")"
+          else
+            advance
+            @string_start[:bytes] << byte.chr
+          end
+        end
+        raise LexError.new("unterminated string literal",
+                           source_position: [@string_start[:line], @string_start[:column]])
+      end
+
+      def handle_escape
+        byte = peek
+        return if byte.nil?
+
+        char = byte.chr
+        replacement =
+          case char
+          when "n"  then "\n"
+          when "r"  then "\r"
+          when "t"  then "\t"
+          when "b"  then "\b"
+          when "f"  then "\f"
+          when "\\" then "\\"
+          when "("  then "("
+          when ")"  then ")"
+          when "0".."7"
+            consume_octal_escape
+          else
+            char
+          end
+        if replacement.is_a?(String)
+          advance
+          @string_start[:bytes] << replacement
+        end
+      end
+
+      def consume_octal_escape
+        digits = +""
+        3.times do
+          byte = peek
+          break unless byte && (byte >= 48 && byte <= 55) # 0..7
+
+          digits << byte.chr
+          advance
+        end
+        code = digits.to_i(8) & 0xFF
+        @string_start[:bytes] << code.chr
+        nil
+      end
+
+      def emit_string
+        @tokens << Model::Token.new(:string, @string_start[:bytes],
+                                    line: @string_start[:line], column: @string_start[:column])
+        @string_start = nil
+        @state = :top
+      end
+
+      def start_hexstring
+        start_line = @line
+        start_col = @column
+        advance # consume <
+        @hex_start = { line: start_line, column: start_col, bytes: +"" }
+        @state = :hexstring
+      end
+
+      def scan_hexstring_body
+        until eos?
+          byte = @source.getbyte(@position)
+          case byte
+          when 62 # >
+            advance
+            emit_hexstring
+            return
+          when 32, 9, 10, 13, 12
+            advance
+          else
+            advance
+            @hex_start[:bytes] << byte.chr
+          end
+        end
+        raise LexError.new("unterminated hex string literal",
+                           source_position: [@hex_start[:line], @hex_start[:column]])
+      end
+
+      def emit_hexstring
+        hex = @hex_start[:bytes].delete("^0-9a-fA-F")
+        @tokens << Model::Token.new(:hexstring, hex,
+                                    line: @hex_start[:line], column: @hex_start[:column])
+        @hex_start = nil
+        @state = :top
+      end
+
+      def maybe_close_dict
+        if peek(1) == 62 # >>
+          advance
+          advance
+          emit(:dict_close, ">>")
+        else
+          # Lone '>' is not a valid token in PS; skip and warn via token.
+          advance
+        end
+      end
+
+      def start_name_with_slash(prefix)
+        start_line = @line
+        start_col = @column
+        advance
+        bytes = +""
+        until eos?
+          byte = peek
+          break if byte.nil? || whitespace_byte?(byte) || delimiter_byte?(byte)
+
+          bytes << byte.chr
+          advance
+        end
+        @tokens << Model::Token.new(:name, bytes, line: start_line, column: start_col, literal: true)
+      end
+
+      def delimiter_byte?(byte)
+        return false unless byte
+
+        char = byte.chr
+        "%()<>{}/[]".include?(char)
+      end
+
+      def scan_word_or_number
+        start_line = @line
+        start_col = @column
+        bytes = +""
+        until eos?
+          byte = peek
+          break if byte.nil? || whitespace_byte?(byte) || delimiter_byte?(byte)
+
+          bytes << byte.chr
+          advance
+        end
+        emit_word(bytes, start_line, start_col)
+      end
+
+      def emit_word(bytes, line, col)
+        type =
+          if NUMBER_RE.match?(bytes)
+            :number
+          else
+            :operator
+          end
+        @tokens << Model::Token.new(type, bytes, line: line, column: col)
+      end
+
+      NUMBER_RE = /\A[-+]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][-+]?\d+)?\z/.freeze
+
+      def emit(type, value)
+        @tokens << Model::Token.new(type, value, line: @line, column: @column)
+      end
+    end
+  end
+end

data/lib/postsvg/source/operand_stack.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Source
+    # Parse-time operand stack. Wraps an Array with type-aware pops.
+    class OperandStack
+      def initialize
+        @items = []
+      end
+
+      def push(value)
+        @items.push(value)
+        self
+      end
+      alias << push
+
+      def pop
+        return Model::Computed.new(operator_keyword: "(missing)") if @items.empty?
+
+        @items.pop
+      end
+
+      def pop_number(default_on_empty: nil)
+        return default_on_empty if @items.empty? && !default_on_empty.nil?
+
+        value = pop
+        return value.to_f if value.is_a?(Model::Literals::Number)
+        return value.to_f if value.is_a?(Numeric)
+
+        # Parse-time fallback: a Name (e.g. /x defined via def) or a
+        # Computed sentinel (e.g. result of an arithmetic op) cannot
+        # be evaluated to a number yet. Return 0 so the operator
+        # instance can be built; the visitor will re-resolve at
+        # runtime if the program is executed.
+        0.0
+      end
+
+      def peek(offset = 0)
+        @items[-1 - offset]
+      end
+
+      def length
+        @items.length
+      end
+
+      def empty?
+        @items.empty?
+      end
+
+      def to_a
+        @items.dup
+      end
+    end
+  end
+end

data/lib/postsvg/source.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # Source-reading layer: PS source text -> Model::Program.
+  #
+  # Lexer produces an array of Model::Token; AstBuilder walks tokens and
+  # emits a typed Model::Program. Errors are raised as Postsvg::LexError
+  # and Postsvg::SyntaxError respectively.
+  module Source
+    autoload :Lexer, "postsvg/source/lexer"
+    autoload :AstBuilder, "postsvg/source/ast_builder"
+    autoload :OperandStack, "postsvg/source/operand_stack"
+
+    module_function
+
+    # One-shot convenience: PS source -> Model::Program.
+    def parse(source)
+      AstBuilder.build(Lexer.tokenize(source))
+    end
+  end
+end