rubycc 1.0.0

data/lib/rubycc/rmake/expander.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Rubycc
+  module Rmake
+    # Turns raw make text with `$(...)` / `${...}` / `$x` references into its
+    # expanded string. It implements exactly the reference forms the mkmf corpus
+    # uses (test/fixtures/mkmf): plain variable references, nested references,
+    # the `$(var:from=to)` substitution reference, and the automatic variables
+    # ($@, $<, $^, $*, and their D/F directory/file variants). Undefined
+    # variables expand to the empty string, matching make.
+    #
+    # Recursive (`=`) variables are stored unexpanded and expanded on every
+    # reference; simple (`:=`) variables are stored already-expanded. That split
+    # lives in the Variable value object, so the expander only has to re-expand
+    # whatever text a recursive variable holds — which is where an `A=$(B)` /
+    # `B=$(A)` cycle would otherwise recurse forever, so every variable
+    # dereference spends one unit of the depth budget below.
+    class Expander
+      # DoS fail-safe: the maximum number of nested variable dereferences during
+      # a single expansion. A reference cycle between recursive variables would
+      # recurse without bound; this cap converts that into an ExpansionError long
+      # before the Ruby stack is exhausted. Legitimate mkmf variable chains
+      # (e.g. rubyarchhdrdir -> rubyhdrdir -> includedir -> prefix) are well
+      # under a dozen deep, so the limit is generous.
+      MAX_EXPANSION_DEPTH = 200
+
+      # DoS fail-safe, part two: the depth cap above only counts how deep the
+      # call stack goes, so it says nothing about *fan-out*. A chain like
+      # `A1 = $(A0)$(A0)` / `A2 = $(A1)$(A1)` / ... stays only n levels deep
+      # while doing 2^n work, so a 30-line Makefile can wedge the parser (`:=`
+      # assignments expand at parse time, before any target is built). The two
+      # budgets below bound the total work of one top-level expansion, in the
+      # same spirit as the preprocessor's EXPANSION_TOKEN_LIMIT.
+      #
+      # Both are needed, because each misses the explosion the other catches:
+      #
+      # * MAX_EXPANSION_REFERENCES counts variable dereferences. It is the only
+      #   one that sees a fan-out whose leaves expand to nothing (`A0 =` empty
+      #   still costs 2^n dereferences while producing zero characters), and it
+      #   is also what catches a cycle that grows the call count rather than the
+      #   text.
+      # * MAX_EXPANSION_OUTPUT counts characters produced. It is the only one
+      #   that sees a blow-up driven by text size rather than reference count
+      #   (`BIG = <megabytes>` referenced a handful of times per level exhausts
+      #   memory long before the reference count is reached).
+      #
+      # Both limits are orders of magnitude above what the mkmf corpus needs:
+      # measured over the rmake test suite (test/fixtures/mkmf included), the
+      # heaviest single expansion resolves 32 references and yields ~4 KB.
+      #
+      # The reference cap is deliberately kept small rather than merely "safe":
+      # a budget is spent per top-level call, so the time it takes to reach the
+      # cap is itself the attacker's resource — a Makefile with many `:=`
+      # assignments multiplies it by the number of assignments. 100_000 still
+      # leaves ~3000x headroom over the measured 32 while tripping in well under
+      # a second.
+      MAX_EXPANSION_REFERENCES = 100_000
+      MAX_EXPANSION_OUTPUT = 4_194_304 # 4 MiB of characters
+
+      # Base characters of the automatic variables rmake recognises. Each may be
+      # written bare ($@) or parenthesised ($(@)), and the parenthesised form may
+      # carry a D/F modifier ($(@D) = directory part, $(@F) = file part).
+      AUTOMATIC_CHARS = %w[@ < ^ ? * + %].freeze
+
+      # variables:: Hash{String => Variable}
+      def initialize(variables)
+        @variables = variables
+        @references = 0
+        @output_chars = 0
+      end
+
+      # Expand +text+. +autos+ is a Hash{String => String} keyed by automatic
+      # variable base character (e.g. {"@" => "foo.o", "<" => "foo.c"}); pass nil
+      # outside a recipe, where automatic variables expand to "".
+      def expand(text, autos = nil, depth = 0)
+        # depth 0 is the entry point from outside, so one external call gets one
+        # budget; the recursive calls below all pass depth + 1 and therefore
+        # share it.
+        if depth.zero?
+          @references = 0
+          @output_chars = 0
+        end
+        guard_depth(depth)
+        out = +""
+        i = 0
+        n = text.length
+        while i < n
+          c = text[i]
+          if c == "$"
+            consumed, value = expand_reference(text, i, autos, depth)
+            @output_chars += value.length
+            guard_output
+            out << value
+            i += consumed
+          else
+            @output_chars += 1
+            guard_output
+            out << c
+            i += 1
+          end
+        end
+        out
+      end
+
+      private
+
+      def guard_depth(depth)
+        return if depth <= MAX_EXPANSION_DEPTH
+
+        raise ExpansionError,
+              "variable expansion exceeded #{MAX_EXPANSION_DEPTH} levels " \
+              "(likely a reference cycle between recursive variables)"
+      end
+
+      def guard_references
+        return if @references <= MAX_EXPANSION_REFERENCES
+
+        raise ExpansionError,
+              "variable expansion resolved more than #{MAX_EXPANSION_REFERENCES} references " \
+              "(likely a reference cycle or an exponentially expanding variable chain)"
+      end
+
+      def guard_output
+        return if @output_chars <= MAX_EXPANSION_OUTPUT
+
+        raise ExpansionError,
+              "variable expansion produced more than #{MAX_EXPANSION_OUTPUT} characters " \
+              "(likely a reference cycle or an exponentially expanding variable chain)"
+      end
+
+      # Parse one reference starting at the `$` at +i+. Returns [chars_consumed,
+      # expanded_value].
+      def expand_reference(text, i, autos, depth)
+        nxt = text[i + 1]
+        case nxt
+        when nil
+          # Trailing bare `$` — emit it literally.
+          [1, "$"]
+        when "$"
+          [2, "$"]
+        when "(", "{"
+          close = (nxt == "(" ? ")" : "}")
+          inner, len = read_balanced(text, i + 2, nxt, close)
+          [2 + len, expand_parenthesised(inner, autos, depth)]
+        else
+          # Single-character reference: $@, $<, $x ...
+          [2, resolve_name(nxt, autos, depth)]
+        end
+      end
+
+      # Read up to the matching close bracket, honouring nesting so that
+      # `$(a$(b))` is read whole. Returns [inner_without_brackets,
+      # chars_consumed_including_close]. An unterminated reference is treated as
+      # extending to end of text (make is similarly lenient).
+      def read_balanced(text, start, open, close)
+        depth = 1
+        i = start
+        n = text.length
+        while i < n
+          c = text[i]
+          if c == open
+            depth += 1
+          elsif c == close
+            depth -= 1
+            return [text[start...i], (i - start) + 1] if depth.zero?
+          end
+          i += 1
+        end
+        [text[start..], n - start]
+      end
+
+      def expand_parenthesised(inner, autos, depth)
+        # Substitution reference: $(var:from=to). Split on the first ':' and then
+        # the remainder on the first '=' so a replacement text may itself contain
+        # '=' or spaces (e.g. `$(ECHO1:0=@ echo)`).
+        if (colon = inner.index(":")) && inner.index("=", colon)
+          name = inner[0...colon]
+          from, to = inner[(colon + 1)..].split("=", 2)
+          value = resolve_name(expand(name, autos, depth + 1), autos, depth)
+          return substitute_suffix(value, expand(from, autos, depth + 1), expand(to.to_s, autos, depth + 1))
+        end
+
+        name = expand(inner, autos, depth + 1)
+        resolve_name(name, autos, depth)
+      end
+
+      # Resolve a fully-expanded variable/automatic name to its value. This is
+      # the one place every dereference passes through — the `$x` branch of
+      # #expand_reference and both branches of #expand_parenthesised call it —
+      # so the reference budget is charged here and nowhere else.
+      def resolve_name(name, autos, depth)
+        @references += 1
+        guard_references
+        auto = automatic_value(name, autos)
+        return auto unless auto.nil?
+
+        var = @variables[name]
+        return "" if var.nil?
+
+        var.simple? ? var.value : expand(var.value, autos, depth + 1)
+      end
+
+      # Returns the automatic-variable value for +name+, or nil when +name+ is
+      # not an automatic variable. Outside a recipe (+autos+ nil) the automatic
+      # variables are defined but empty, matching make.
+      def automatic_value(name, autos)
+        base = name
+        modifier = nil
+        if name.length == 2 && (name[1] == "D" || name[1] == "F") && AUTOMATIC_CHARS.include?(name[0])
+          base = name[0]
+          modifier = name[1]
+        end
+        return nil unless AUTOMATIC_CHARS.include?(base) && name.length <= 2
+
+        raw = autos ? autos.fetch(base, "") : ""
+        case modifier
+        when "D" then directory_parts(raw)
+        when "F" then file_parts(raw)
+        else raw
+        end
+      end
+
+      # make's $(var:from=to) replaces +from+ at the end of each whitespace-
+      # separated word with +to+ (equivalent to $(patsubst %from,%to,var)).
+      def substitute_suffix(value, from, to)
+        value.split(/\s+/).reject(&:empty?).map do |word|
+          word.end_with?(from) ? word[0, word.length - from.length] + to : word
+        end.join(" ")
+      end
+
+      # $(@D): directory part of each word, "." when a word has no directory,
+      # trailing slash stripped.
+      def directory_parts(value)
+        value.split(/\s+/).reject(&:empty?).map do |word|
+          slash = word.rindex("/")
+          slash.nil? ? "." : (slash.zero? ? "/" : word[0...slash])
+        end.join(" ")
+      end
+
+      # $(@F): file (basename) part of each word.
+      def file_parts(value)
+        value.split(/\s+/).reject(&:empty?).map do |word|
+          slash = word.rindex("/")
+          slash.nil? ? word : word[(slash + 1)..]
+        end.join(" ")
+      end
+    end
+  end
+end

data/lib/rubycc/rmake/makefile.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "model"
+require_relative "expander"
+require_relative "parser"
+require_relative "executor"
+
+module Rubycc
+  module Rmake
+    # The public entry point: parse Makefile text, then answer "what would make
+    # do?" for a goal as an execution Plan. It resolves the raw rules the Parser
+    # produced into a working graph — a per-target index of explicit
+    # prerequisites and recipes, the `.c.o:` suffix rules, the `.PHONY`/
+    # `.SUFFIXES` special targets and VPATH — and walks that graph in
+    # dependency order, comparing timestamps to decide which targets are stale.
+    # It only plans: recipes are expanded and their `@`/`-`/`+` prefixes
+    # interpreted, but nothing is run (the runner is B2).
+    class Makefile
+      # A target that names its own inference: `.c.o` builds `.o` from `.c`. Two
+      # dots and nothing else, which is how it stays distinct from the one-dot
+      # special targets `.PHONY` / `.SUFFIXES`.
+      SUFFIX_TARGET = /\A(\.[^.\s]+)(\.[^.\s]+)\z/
+
+      attr_reader :variables, :dir, :default_goal, :phony, :suffixes
+
+      # +overrides+ are command-line variable definitions (make's `VAR=value`
+      # operands) that take precedence over the Makefile's own assignments;
+      # +defaults+ are POSIX's built-in variables (currently just `MAKE`, seeded
+      # by CLI). Both are threaded to the Parser, which seeds them — protecting
+      # +overrides+ from any Makefile assignment, but leaving +defaults+ as
+      # ordinary variables a Makefile assignment can replace.
+      def self.parse(text, dir: ".", overrides: {}, defaults: {})
+        parsed = Parser.parse(text, overrides: overrides, defaults: defaults)
+        new(parsed.variables, parsed.rules, dir: dir)
+      end
+
+      def initialize(variables, rules, dir: ".")
+        @variables = variables
+        @dir = dir
+        @expander = Expander.new(@variables)
+        @explicit = {}       # target name => {prereqs:, recipe:, double_colon:}
+        @suffix_rules = []   # SuffixRule
+        @phony = []
+        @suffixes = []
+        @default_goal = nil
+        index_rules(rules)
+      end
+
+      # Compute the execution plan for +goal+ (the default goal when omitted),
+      # judging staleness against the filesystem as of +now+ is implicit in the
+      # file mtimes read from #dir. Returns a Plan of steps in the order make
+      # would run them.
+      def plan(goal = nil, now: Time.now)
+        @now = now
+        goal ||= @default_goal
+        raise RmakeError, "no target specified and the Makefile has no default goal" if goal.nil?
+
+        @steps = []
+        @state = {}
+        build(goal)
+        Plan.new(@steps)
+      end
+
+      # Plan +goal+ and then run it through the shell-less Executor (B2/B3). This
+      # is the "make it" entry point that pairs with #plan (the "what would make
+      # do" entry point). +dry_run+ prints the recipe lines without running them
+      # (make -n) and matches #plan's #command_lines.
+      #
+      # +tools+ turns on in-process tool substitution (B3): when truthy the
+      # recipe commands whose argv[0] is this Makefile's compiler/linker program
+      # (the first word of `$(CC)` / `$(LDSHARED)`, normally "gcc") are run by
+      # rubycc's own Driver in a forked child instead of being exec'd, so no
+      # external compiler is needed. It defaults off, leaving the B2 behaviour
+      # (every command exec'd) exactly as it was. +jobs+ is the maximum number of
+      # independent steps to build concurrently (`-j`; default 1 = sequential).
+      #
+      # Returns the Plan that was executed; raises CommandFailedError /
+      # UnsupportedRecipeError on the first failing or uninterpretable recipe line.
+      def run(goal = nil, out: $stdout, err: $stderr, dry_run: false, env: ENV, now: Time.now,
+              tools: nil, jobs: 1)
+        computed = plan(goal, now: now)
+        Executor.new(dir: @dir, out: out, err: err, dry_run: dry_run, env: env,
+                     tools: tools ? tool_programs : [], jobs: jobs).execute(computed)
+        computed
+      end
+
+      # The set of program names a `-`tools run substitutes for rubycc: the first
+      # word of `$(CC)` and of `$(LDSHARED)` (the compile and shared-link drivers
+      # mkmf emits). `$(LDSHARED)` is normally `$(CC) -shared`, so its flag words
+      # already sit inside the expanded recipe and only the leading program name
+      # is matched here; for the mkmf corpus both reduce to "gcc".
+      def tool_programs
+        [variable_value("CC"), variable_value("LDSHARED")]
+          .map { |value| value.split(/\s+/).reject(&:empty?).first }
+          .compact.uniq
+      end
+
+      # The fully-expanded value of a variable (empty string when undefined).
+      def variable_value(name)
+        @expander.expand("$(#{name})")
+      end
+
+      private
+
+      # --- turning raw rules into the working graph ------------------------
+
+      def index_rules(rules)
+        rules.each do |rule|
+          targets = expand_words(rule.targets)
+          prereqs = expand_words(rule.prerequisites)
+          targets.each { |t| classify_target(t, prereqs, rule) }
+        end
+      end
+
+      def classify_target(target, prereqs, rule)
+        case target
+        when ".PHONY"
+          @phony.concat(prereqs)
+        when ".SUFFIXES"
+          prereqs.empty? ? @suffixes.clear : @suffixes.concat(prereqs)
+        else
+          if (m = SUFFIX_TARGET.match(target)) && prereqs.empty? && !rule.recipe.empty?
+            @suffix_rules << SuffixRule.new(from_suffix: m[1], to_suffix: m[2], recipe: rule.recipe)
+          else
+            record_explicit(target, prereqs, rule)
+          end
+        end
+      end
+
+      def record_explicit(target, prereqs, rule)
+        entry = (@explicit[target] ||= { prereqs: [], recipe: nil, double_colon: rule.double_colon? })
+        entry[:prereqs].concat(prereqs)
+        # The last rule to carry a recipe wins (make's behaviour for `:` rules);
+        # prerequisite-only rules just contribute dependencies.
+        entry[:recipe] = rule.recipe unless rule.recipe.empty?
+        @default_goal ||= target
+      end
+
+      # --- dependency walk + staleness ------------------------------------
+
+      # Returns [stale?, mtime_or_nil, exposed_steps]. +stale?+ propagates upward:
+      # a prerequisite that will be rebuilt makes its dependents stale even if
+      # their own file is newer, matching make's dry-run reasoning.
+      #
+      # +exposed_steps+ is the set of step targets a parent must wait for before
+      # this target counts as ready — the dependency edges the `-j` scheduler
+      # walks. A target that is itself a step exposes just itself (its own
+      # prerequisite steps become that step's #prereqs and are hidden behind it);
+      # a target that is not a step forwards its prerequisites' exposed steps, so
+      # a phony aggregate like `all` exposes the real steps beneath it.
+      def build(target)
+        return @state[target] if @state.key?(target)
+
+        # Tentative entry breaks any dependency cycle without looping forever.
+        @state[target] = [false, file_mtime(target), []]
+        node = resolve(target)
+
+        rebuilt = false
+        newest = nil
+        dep_steps = []
+        node[:prereqs].each do |p|
+          stale, mtime, exposed = build(p)
+          rebuilt ||= stale
+          newest = newer(newest, mtime)
+          dep_steps.concat(exposed)
+        end
+
+        own = node[:mtime]
+        stale = node[:phony] || own.nil? || rebuilt || (newest && own && newest > own)
+
+        if stale && node[:recipe]
+          step = build_step(target, node)
+          step.prereqs = dep_steps.uniq
+          @steps << step
+          exposed = [target]
+        else
+          exposed = dep_steps.uniq
+        end
+
+        @state[target] = [stale, own, exposed]
+      end
+
+      # Assemble everything needed to judge and, if stale, build +target+: its
+      # prerequisites, the recipe (explicit or inferred), the automatic-variable
+      # source/stem for a suffix rule, its mtime and whether it is phony.
+      def resolve(target)
+        entry = @explicit[target]
+        prereqs = entry ? entry[:prereqs].dup : []
+        recipe = entry && entry[:recipe]
+        source = nil
+        stem = nil
+
+        if recipe.nil?
+          inferred = infer_suffix_rule(target)
+          if inferred
+            rule, source, stem = inferred
+            recipe = rule.recipe
+            prereqs += [source]
+          end
+        end
+
+        {
+          target: target,
+          prereqs: prereqs,
+          recipe: recipe,
+          source: source,
+          stem: stem,
+          mtime: file_mtime(target),
+          phony: @phony.include?(target)
+        }
+      end
+
+      # Find an inference rule for +target+: its suffix must be a known
+      # `.SUFFIXES` entry and produced by some `.X.Y:` rule whose same-stem
+      # source file exists (searched along VPATH). Returns [rule, source_name,
+      # stem] or nil. Candidate source suffixes are tried in `.SUFFIXES` order,
+      # as make does.
+      def infer_suffix_rule(target)
+        to_suffix = suffix_of(target)
+        return nil unless to_suffix && @suffixes.include?(to_suffix)
+
+        stem = target[0...(target.length - to_suffix.length)]
+        @suffixes.each do |from|
+          rule = @suffix_rules.find { |r| r.from_suffix == from && r.to_suffix == to_suffix }
+          next unless rule
+
+          resolved = resolve_prerequisite("#{stem}#{from}")
+          return [rule, resolved, stem] if resolved
+        end
+        nil
+      end
+
+      def suffix_of(name)
+        base = File.basename(name)
+        dot = base.rindex(".")
+        return nil if dot.nil? || dot.zero?
+
+        base[dot..]
+      end
+
+      # --- recipe expansion ------------------------------------------------
+
+      def build_step(target, node)
+        autos = automatic_variables(target, node)
+        commands = node[:recipe].map do |raw|
+          expanded = @expander.expand(raw, autos)
+          text, silent, ignore, force = split_prefixes(expanded)
+          Command.new(text: text, silent: silent, ignore_error: ignore, force: force)
+        end
+        Step.new(target: target, commands: commands)
+      end
+
+      def automatic_variables(target, node)
+        first = node[:source] || node[:prereqs].first || ""
+        all = node[:prereqs].join(" ")
+        {
+          "@" => target,
+          "<" => first,
+          "^" => all,
+          "+" => all,
+          "?" => all,
+          "*" => node[:stem] || strip_known_suffix(target)
+        }
+      end
+
+      def strip_known_suffix(target)
+        suffix = suffix_of(target)
+        suffix && @suffixes.include?(suffix) ? target[0...(target.length - suffix.length)] : target
+      end
+
+      # Interpret the leading recipe-line prefixes make recognises: `@` (silent),
+      # `-` (ignore errors) and `+` (run even under -n). They may appear in any
+      # order and be separated by whitespace; the remaining text is the command
+      # as make would print it under -n.
+      def split_prefixes(line)
+        silent = ignore = force = false
+        i = 0
+        loop do
+          i += 1 while i < line.length && whitespace?(line[i])
+          case line[i]
+          when "@" then silent = true
+          when "-" then ignore = true
+          when "+" then force = true
+          else break
+          end
+          i += 1
+        end
+        [line[i..] || "", silent, ignore, force]
+      end
+
+      def whitespace?(char)
+        char == " " || char == "\t"
+      end
+
+      # --- filesystem / VPATH ---------------------------------------------
+
+      def file_mtime(name)
+        located = locate(name)
+        located ? File.mtime(located[1]) : nil
+      end
+
+      # The name a prerequisite resolves to after VPATH search (what $< would
+      # hold), or nil when no such file exists anywhere on the path.
+      def resolve_prerequisite(name)
+        located = locate(name)
+        located && located[0]
+      end
+
+      # Search for +name+ as a plain path first, then along VPATH. Returns
+      # [name_to_use, full_path] or nil. A "." VPATH entry (mkmf's srcdir) leaves
+      # the name unadorned, so $< stays `parser.c` rather than `./parser.c`.
+      def locate(name)
+        direct = full_path(name)
+        return [name, direct] if File.exist?(direct)
+        return nil if absolute?(name)
+
+        vpath_dirs.each do |d|
+          candidate = (d == ".") ? name : File.join(d, name)
+          full = full_path(candidate)
+          return [candidate, full] if File.exist?(full)
+        end
+        nil
+      end
+
+      def vpath_dirs
+        @vpath_dirs ||= variable_value("VPATH").split(/[:\s]+/).reject(&:empty?)
+      end
+
+      def full_path(name)
+        absolute?(name) ? name : File.join(@dir, name)
+      end
+
+      def absolute?(name)
+        name.start_with?("/")
+      end
+
+      # --- helpers ---------------------------------------------------------
+
+      def expand_words(raw_words)
+        raw_words.flat_map { |w| @expander.expand(w).split(/[ \t]+/) }.reject(&:empty?)
+      end
+
+      def newer(a, b)
+        return b if a.nil?
+        return a if b.nil?
+
+        a > b ? a : b
+      end
+    end
+  end
+end