rubycc 1.0.0

data/lib/rubycc/rmake/model.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Rubycc
+  module Rmake
+    # A make variable. The flavor decides *when* the right-hand side is expanded:
+    # a recursive (`=`) variable keeps its text verbatim and is expanded afresh
+    # on every reference, so it can see values defined later; a simple (`:=`)
+    # variable is expanded once at definition and thereafter holds a plain
+    # string. `?=` produces a recursive variable (only when the name is unset)
+    # and `+=` appends in whichever flavor the variable already has.
+    class Variable
+      attr_reader :flavor, :value
+
+      def initialize(flavor, value)
+        @flavor = flavor
+        @value = value
+      end
+
+      def simple?
+        @flavor == :simple
+      end
+
+      def recursive?
+        @flavor == :recursive
+      end
+    end
+
+    # An explicit rule as written: its target and prerequisite words and recipe
+    # lines are stored unexpanded, because make expands them against the final
+    # variable table (all mkmf assignments precede the rules that use them). A
+    # `::` rule sets +double_colon+; +order+ is the read order, used only to pick
+    # the default goal (the first non-special target seen).
+    class ExplicitRule
+      attr_reader :targets, :prerequisites, :recipe, :order
+
+      def initialize(targets:, prerequisites:, recipe:, double_colon:, order:)
+        @targets = targets
+        @prerequisites = prerequisites
+        @recipe = recipe
+        @double_colon = double_colon
+        @order = order
+      end
+
+      def double_colon?
+        @double_colon
+      end
+    end
+
+    # A double-suffix inference rule such as `.c.o:` — build a `to_suffix` file
+    # from a same-stem `from_suffix` file using +recipe+.
+    class SuffixRule
+      attr_reader :from_suffix, :to_suffix, :recipe
+
+      def initialize(from_suffix:, to_suffix:, recipe:)
+        @from_suffix = from_suffix
+        @to_suffix = to_suffix
+        @recipe = recipe
+      end
+    end
+
+    # One shell command in an execution step: its expanded text with the
+    # recipe-line prefixes already interpreted. +silent+ (`@`), +ignore_error+
+    # (`-`) and +force+ (`+`) are retained as attributes so a dumper can show
+    # them; B1 only plans, it does not run anything.
+    class Command
+      attr_reader :text, :silent, :ignore_error, :force
+
+      def initialize(text:, silent:, ignore_error:, force:)
+        @text = text
+        @silent = silent
+        @ignore_error = ignore_error
+        @force = force
+      end
+
+      def silent?
+        @silent
+      end
+
+      def ignore_error?
+        @ignore_error
+      end
+
+      def force?
+        @force
+      end
+    end
+
+    # A single node of the execution plan: the target that would be (re)built and
+    # the ordered, fully-expanded commands that would build it. +prereqs+ names
+    # the other steps that must complete before this one may start — the edges a
+    # parallel scheduler (B3 `-j`) needs. It is empty for a step with no stale
+    # step among its prerequisites, and the sequential runner ignores it entirely
+    # (the plan is already emitted in a valid dependency order).
+    class Step
+      attr_reader :target, :commands
+      attr_accessor :prereqs
+
+      def initialize(target:, commands:, prereqs: [])
+        @target = target
+        @commands = commands
+        @prereqs = prereqs
+      end
+    end
+
+    # The result of Makefile#plan: the steps in the order make would run them
+    # (prerequisites before dependents). It carries no execution logic — the
+    # recipe runner is B2.
+    class Plan
+      attr_reader :steps
+
+      def initialize(steps)
+        @steps = steps
+      end
+
+      # The command texts in execution order, one per line — the shape a
+      # `make -n` transcript takes, used by the golden tests.
+      def command_lines
+        @steps.flat_map { |step| step.commands.map(&:text) }
+      end
+
+      # A human-readable dump that, unlike #command_lines, keeps the target
+      # boundaries and the +@+/+-+/+++ prefix attributes visible.
+      def dump
+        @steps.map do |step|
+          lines = step.commands.map do |cmd|
+            flags = +""
+            flags << "@" if cmd.silent?
+            flags << "-" if cmd.ignore_error?
+            flags << "+" if cmd.force?
+            "    #{flags.empty? ? '' : "#{flags} "}#{cmd.text}"
+          end
+          (["#{step.target}:"] + lines).join("\n")
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/rubycc/rmake/parser.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "model"
+require_relative "expander"
+
+module Rubycc
+  module Rmake
+    # Turns Makefile text into the raw model — variables plus explicit rules with
+    # their recipes — that Makefile then resolves into suffix rules, phony
+    # targets, the suffix list and a dependency graph. The parser accepts only
+    # the constructs the mkmf corpus (test/fixtures/mkmf) actually emits:
+    # variable assignments in all four flavours, backslash line continuation,
+    # `#` comments, explicit rules (single and double colon, with tab recipes)
+    # and the `.c.o:`-style two-suffix inference rules. Anything it cannot place
+    # is a ParseError rather than a silent skip, so an unsupported Makefile fails
+    # loudly instead of mis-building.
+    class Parser
+      # A variable name: letters, digits and underscore, not starting with a
+      # digit. mkmf never uses dotted or otherwise exotic names, so keeping this
+      # narrow is what lets a leading-dot line (`.PHONY:`, `.c.o:`) fall through
+      # to rule handling instead of being mistaken for an assignment.
+      NAME = /[A-Za-z_][A-Za-z0-9_]*/
+
+      # An assignment is a name, optional spaces, then an operator anchored right
+      # after the name. `+=`/`?=`/`::=`/`:=` are tried before bare `=`, and all
+      # of them before a rule's `:` can match, so `all: dep` (colon then space)
+      # is never read as `:=`.
+      ASSIGN = /\A[ \t]*(#{NAME})[ \t]*(\+=|\?=|::=|:=|=)(.*)\z/
+
+      # +overrides+ are command-line variable definitions (make's `VAR=value`
+      # operands): they are seeded before parsing and win over any assignment the
+      # Makefile makes to the same name, which is make's rule that a command-line
+      # variable overrides a makefile variable. They are stored as simple
+      # (already-expanded) variables so a `:=` assignment referencing one during
+      # the parse sees the command-line value.
+      #
+      # +defaults+ are POSIX's built-in variables (currently just `MAKE`): unlike
+      # +overrides+ they are ordinary variables once seeded, so a Makefile
+      # assignment to the same name replaces them exactly as it would replace any
+      # other pre-existing value. They are seeded first so an override (or a
+      # Makefile assignment) to the same name still wins.
+      def initialize(overrides: {}, defaults: {})
+        @variables = {}
+        @rules = []
+        @order = 0
+        @current_rule = nil
+        @expander = Expander.new(@variables)
+        @overrides = overrides || {}
+        (defaults || {}).each { |name, value| @variables[name] = Variable.new(:simple, value.to_s) }
+        @overrides.each { |name, value| @variables[name] = Variable.new(:simple, value.to_s) }
+      end
+
+      attr_reader :variables, :rules
+
+      def self.parse(text, overrides: {}, defaults: {})
+        new(overrides: overrides, defaults: defaults).tap { |p| p.run(text) }
+      end
+
+      def run(text)
+        logical_lines(text).each do |content, kind, line_no|
+          if kind == :recipe
+            handle_recipe(content, line_no)
+          else
+            handle_normal(content, line_no)
+          end
+        end
+        self
+      end
+
+      private
+
+      # --- physical -> logical lines (continuation handling) ---------------
+
+      # Fold backslash-continued physical lines into logical lines, tagging each
+      # as a recipe (started with a tab) or a normal line. A continuation and the
+      # following line's leading whitespace collapse to a single space, matching
+      # make; this is exercised by the unit tests since the corpus itself has no
+      # continuations.
+      def logical_lines(text)
+        physical = text.split("\n", -1)
+        result = []
+        i = 0
+        while i < physical.length
+          raw = physical[i]
+          start_line = i + 1
+          recipe = raw.start_with?("\t")
+          buf = raw
+          while continuation?(buf)
+            buf = drop_trailing_backslash(buf)
+            i += 1
+            nxt = (physical[i] || "")
+            nxt = nxt.sub(/\A\t/, "") if recipe
+            buf = "#{buf.rstrip} #{nxt.lstrip}"
+          end
+          result << [buf, recipe ? :recipe : :normal, start_line]
+          i += 1
+        end
+        result
+      end
+
+      # A line continues when it ends with an odd number of backslashes (an even
+      # number is that many escaped literal backslashes with no continuation).
+      def continuation?(line)
+        m = line.match(/(\\+)\z/)
+        m && m[1].length.odd?
+      end
+
+      def drop_trailing_backslash(line)
+        line.sub(/\\\z/, "")
+      end
+
+      # --- normal (non-recipe) lines ---------------------------------------
+
+      def handle_normal(content, line_no)
+        stripped = strip_comment(content)
+        return if stripped.strip.empty?
+
+        if (m = ASSIGN.match(stripped))
+          @current_rule = nil
+          apply_assignment(m[1], m[2], m[3])
+        elsif stripped.include?(":")
+          parse_rule(stripped, line_no)
+        else
+          raise ParseError.new("cannot parse line: #{content.strip.inspect}", line_number: line_no)
+        end
+      end
+
+      # Strip a `#` comment. `\#` is an escaped literal hash. Recipe lines are
+      # never passed here, so `#` inside a recipe stays intact for the shell.
+      def strip_comment(line)
+        out = +""
+        i = 0
+        while i < line.length
+          c = line[i]
+          if c == "\\" && line[i + 1] == "#"
+            out << "#"
+            i += 2
+          elsif c == "#"
+            break
+          else
+            out << c
+            i += 1
+          end
+        end
+        out
+      end
+
+      def apply_assignment(name, op, rhs)
+        # A command-line override wins over every makefile assignment to the same
+        # name (make's precedence rule), so ignore the assignment entirely.
+        return if @overrides.key?(name)
+
+        # make strips leading whitespace after the operator but keeps trailing
+        # whitespace in the value (a documented make behaviour the golden tests
+        # depend on, e.g. `dldflags = ... zlib ` contributes its trailing space).
+        value = rhs.sub(/\A[ \t]+/, "")
+        case op
+        when "="
+          @variables[name] = Variable.new(:recursive, value)
+        when ":=", "::="
+          @variables[name] = Variable.new(:simple, @expander.expand(value))
+        when "?="
+          @variables[name] ||= Variable.new(:recursive, value)
+        when "+="
+          append_assignment(name, value)
+        end
+      end
+
+      def append_assignment(name, value)
+        existing = @variables[name]
+        if existing.nil?
+          @variables[name] = Variable.new(:recursive, value)
+        elsif existing.simple?
+          joined = existing.value.empty? ? @expander.expand(value) : "#{existing.value} #{@expander.expand(value)}"
+          @variables[name] = Variable.new(:simple, joined)
+        else
+          joined = existing.value.empty? ? value : "#{existing.value} #{value}"
+          @variables[name] = Variable.new(:recursive, joined)
+        end
+      end
+
+      # --- rules -----------------------------------------------------------
+
+      def parse_rule(line, _line_no)
+        idx = line.index(":")
+        target_part = line[0...idx]
+        rest = line[(idx + 1)..]
+        double_colon = rest.start_with?(":")
+        rest = rest[1..] if double_colon
+
+        # An inline recipe after `;` (target: dep ; cmd). Absent from the corpus
+        # but cheap and part of the grammar.
+        inline = nil
+        if (semi = rest.index(";"))
+          inline = rest[(semi + 1)..].sub(/\A[ \t]+/, "")
+          rest = rest[0...semi]
+        end
+
+        @order += 1
+        rule = ExplicitRule.new(
+          targets: split_words(target_part),
+          prerequisites: split_words(rest),
+          recipe: [],
+          double_colon: double_colon,
+          order: @order
+        )
+        rule.recipe << inline if inline
+        @rules << rule
+        @current_rule = rule
+      end
+
+      def handle_recipe(content, line_no)
+        raise ParseError.new("recipe line has no preceding rule", line_number: line_no) if @current_rule.nil?
+
+        # Drop only the leading recipe-marker tab; any further indentation is
+        # part of the command text (the prefix scanner ignores leading blanks).
+        @current_rule.recipe << content.sub(/\A\t/, "")
+      end
+
+      def split_words(text)
+        text.split(/[ \t]+/).reject(&:empty?)
+      end
+    end
+  end
+end

data/lib/rubycc/rmake/rmake.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# rmake — the mkmf-Makefile subset (M3 / DESIGN R5). It ships the parser, the
+# variable expander, the dependency-graph planner, the shell-less runner and the
+# CLI (exe/rmake, B6) that RubyGems drives as `$(MAKE)`. This aggregate require is
+# the entry point; it stays self-contained — depending on nothing else in
+# lib/rubycc until a tool-substituting run reaches for the Driver — so it can be
+# loaded on its own from the tests.
+require_relative "errors"
+require_relative "model"
+require_relative "expander"
+require_relative "parser"
+require_relative "makefile"
+require_relative "executor"
+require_relative "cli"