rubycc 1.0.0 → 1.1.0

data/lib/rubycc/rmake/executor.rb

@@ -2,6 +2,9 @@
 
 require "fileutils"
 require_relative "errors"
+require_relative "tool_command"
+require_relative "../command_line"
+require_relative "../shell"
 
 module Rubycc
   module Rmake
@@ -23,50 +26,61 @@ module Rubycc
     # directly with an argv array; the runner never builds a shell command string.
     #
     # B3 adds two things on top of that. First, in-process tool substitution: when
-    # a set of program names is passed as +tools+, a command whose argv[0] is one
-    # of them (the first word of `$(CC)`/`$(LDSHARED)`) is not exec'd but run by
-    # rubycc's own Driver — inside a forked child, so a compiler crash cannot take
-    # rmake down and the Driver's per-invocation state stays isolated. Second, a
-    # `-j` scheduler that forks independent stale steps up to +jobs+ at a time,
+    # +tools+ carries the argv prefixes of `$(CC)`/`$(LDSHARED)` (which may be two
+    # words or more — the mkmf shim writes `<ruby> <path>/exe/rubycc`), a command
+    # whose argv begins with one of them is not exec'd but run by rubycc's own
+    # Driver — inside a forked child, so a compiler crash cannot take rmake down
+    # and the Driver's per-invocation state stays isolated. Second, a `-j`
+    # scheduler that forks independent stale steps up to +jobs+ at a time,
     # honouring the plan's dependency edges and buffering each worker's output to
     # flush it whole when the step finishes (make -O's un-interleaved output).
     class Executor
       # The utilities reimplemented in-process, keyed by the command's basename so
       # that `/usr/bin/mkdir` and `mkdir` resolve to the same builtin. `:` is
       # make's $(NULLCMD); `exit` is how mkmf's `TOUCH = exit >` stamps a
-      # timestamp file (the `>` creates it, `exit` succeeds).
-      BUILTINS = %w[cd rm mkdir rmdir cp install echo touch true : exit].freeze
+      # timestamp file (the `>` creates it, `exit` succeeds). `test` and its
+      # other spelling `[` (escaped here only because %w[] counts brackets) are
+      # builtins for the same reason as the rest: coreutils is not in the
+      # minimal target environment, so falling back to /usr/bin/test would make
+      # a recipe's result depend on what happens to be installed.
+      BUILTINS = %w[cd rm mkdir rmdir cp install echo touch true : exit test \[].freeze
 
       # Per-recipe-line mutable state: the working directory a `cd` in the same
-      # line has moved to, and the reason string of the most recent failure (used
-      # to enrich CommandFailedError). Each recipe line starts from the Makefile's
-      # base directory afresh, matching make running every line in its own shell.
+      # line has moved to, the shell variables assignments in the same line have
+      # set, and the reason string of the most recent failure (used to enrich
+      # CommandFailedError). Each recipe line starts from the Makefile's base
+      # directory with no variables, matching make running every line in its own
+      # shell — a `list=` in one line must not be visible in the next.
       class LineState
         attr_accessor :cwd, :failure_reason
+        attr_reader :variables
 
         def initialize(cwd)
           @cwd = cwd
+          @variables = {}
           @failure_reason = nil
         end
       end
 
-      # One redirection parsed off a command: which stream (:stdout/:stderr),
-      # whether it truncates or appends, and the target path (relative to the
-      # command's cwd).
-      Redirection = Struct.new(:stream, :mode, :path)
-
-      # One simple command: leading `VAR=value` assignments, the argv words and
-      # the redirections that apply to it.
-      SimpleCommand = Struct.new(:assignments, :argv, :redirections)
+      # The parsed shapes come from the shared splitter (Rubycc::CommandLine),
+      # which rmake and the mkmf shim both use; they are named here too so the
+      # runner reads as it did when it owned the parser.
+      Redirection = CommandLine::Redirection
+      SimpleCommand = CommandLine::SimpleCommand
 
       def initialize(dir:, out: $stdout, err: $stderr, dry_run: false, env: ENV,
                      tools: [], jobs: 1)
-        @dir = File.expand_path(dir)
+        # Kept as bytes: everything joined onto it later — a recipe's file names,
+        # a `cd` operand — comes from the Makefile, which Parser hands over as
+        # bytes.
+        @dir = File.expand_path(dir).b
         @out = out
         @err = err
         @dry_run = dry_run
         @env = env
-        @tools = Array(tools)
+        # Each tool is an argv prefix (the words that name the program). A bare
+        # string is accepted as the one-word prefix it describes.
+        @tools = Array(tools).map { |tool| Array(tool) }
         @jobs = [jobs.to_i, 1].max
         # In sequential mode a substituted tool is fork-isolated for its own sake;
         # a parallel worker is already a forked step child, so it runs the Driver
@@ -111,201 +125,32 @@ module Rubycc
         @out.puts(command.text) if @dry_run || !command.silent?
       end
 
-      # Interpret a recipe line as an and-or list: simple commands joined by
-      # `&&` (run next only after success), `||` (run next only after failure)
-      # and `;` (always run next). A single left-to-right status carries the
-      # result, exactly as an sh and-or list evaluates. Returns the final success.
+      # Interpret a recipe line with Rubycc::Shell — the connectors (`&&`, `||`,
+      # `;`), the compound commands (`for`, `if`, `{ }`) and the shell variables
+      # — and run each simple command it hands back here. The split is on
+      # purpose: Shell knows shell syntax and nothing about make, this runner
+      # knows the builtins, the substituted tools and the redirections and
+      # nothing about syntax. The variables live in +state+, so they last for
+      # this line only, and expansion falls back to the environment the spawned
+      # commands will themselves see, so `$PATH` means one thing per recipe.
       def run_and_or_list(target, text, state)
-        commands = parse_line(target, text)
-        success = true
-        commands.each do |connector, cmd|
-          run = case connector
-                when :first, :semi then true
-                when :and then success
-                when :or then !success
-                end
-          success = run_simple(target, cmd, state, text) if run
-        end
-        success
-      end
-
-      # --- lexing ----------------------------------------------------------
-
-      # Characters after which a backslash inside double quotes keeps its
-      # special meaning (POSIX quote removal, XCU 2.2 / 2.2.3): only these five
-      # make the backslash consume — and remove itself along with — the next
-      # character; before a newline both vanish (line continuation). Before any
-      # other character the backslash inside double quotes is left in the word
-      # verbatim: `"a\b"` stays `a\b`, while `"a\"b"` becomes `a"b`. Verified
-      # against /bin/sh (dash).
-      DQUOTE_BACKSLASH_SPECIAL = ["$", "`", '"', "\\", "\n"].freeze
-
-      # Split a recipe line into tokens: :word (quote-stripped), the connectors
-      # :and/:or/:semi and :redirect markers. Single quotes protect everything
-      # verbatim — backslash has no special meaning inside them. Double quotes
-      # strip a backslash only before `$`/`` ` ``/`"`/`\`/newline
-      # (DQUOTE_BACKSLASH_SPECIAL); elsewhere the backslash stays in the word.
-      # Outside any quote, a backslash preserves the literal value of the
-      # following character and disappears itself, except before a newline
-      # where both vanish (line continuation) — this is POSIX quote removal,
-      # verified against /bin/sh. mkmf relies on the outside-quotes rule: it
-      # writes `-DSYSCONFDIR=\"...\"` expecting the shell to unescape the
-      # backslash-quotes into a literal `"` in the word. Genuinely unhandled
-      # shell syntax (pipe, background, substitution, subshell) stops the run.
-      def tokenize(target, text)
-        tokens = []
-        word = nil
-        i = 0
-        n = text.length
-        while i < n
-          c = text[i]
-          case c
-          when "'"
-            close = text.index(c, i + 1)
-            unsupported!("unterminated quote", target, text) if close.nil?
-            word = (word || +"") + text[(i + 1)...close]
-            i = close + 1
-          when '"'
-            segment, i = scan_double_quoted(target, text, i)
-            word = (word || +"") + segment
-          when "\\"
-            nxt = text[i + 1]
-            if nxt.nil?
-              # A lone trailing backslash with nothing to escape is kept
-              # literally (verified against /bin/sh).
-              word = (word || +"") + c
-              i += 1
-            elsif nxt == "\n"
-              i += 2 # line continuation: backslash and newline both vanish
-            else
-              word = (word || +"") + nxt
-              i += 2
-            end
-          when " ", "\t"
-            tokens << [:word, word] if word
-            word = nil
-            i += 1
-          when "&"
-            tokens << [:word, word] if word
-            word = nil
-            unsupported!("background '&'", target, text) unless text[i + 1] == "&"
-            tokens << [:and]
-            i += 2
-          when "|"
-            tokens << [:word, word] if word
-            word = nil
-            unsupported!("pipe '|'", target, text) unless text[i + 1] == "|"
-            tokens << [:or]
-            i += 2
-          when ";"
-            tokens << [:word, word] if word
-            word = nil
-            tokens << [:semi]
-            i += 1
-          when ">"
-            tokens << [:word, word] if word
-            word = nil
-            if text[i + 1] == ">"
-              tokens << [:redirect, :stdout, :append]
-              i += 2
-            else
-              tokens << [:redirect, :stdout, :truncate]
-              i += 1
-            end
-          when "<", "`", "(", ")"
-            unsupported!("shell metacharacter '#{c}'", target, text)
-          else
-            if word.nil? && (c == "1" || c == "2") && text[i + 1] == ">"
-              stream = c == "2" ? :stderr : :stdout
-              if text[i + 2] == ">"
-                tokens << [:redirect, stream, :append]
-                i += 3
-              else
-                tokens << [:redirect, stream, :truncate]
-                i += 2
-              end
-            else
-              word = (word || +"") + c
-              i += 1
-            end
-          end
-        end
-        tokens << [:word, word] if word
-        tokens
-      end
-
-      # Scan a double-quoted segment starting at +i+ (text[i] == '"'). Applies
-      # the backslash-removal rule that is special to double quotes (see
-      # DQUOTE_BACKSLASH_SPECIAL) and returns [content, index_after_closing_quote].
-      def scan_double_quoted(target, text, i)
-        n = text.length
-        j = i + 1
-        buf = +""
-        loop do
-          unsupported!("unterminated quote", target, text) if j >= n
-
-          c = text[j]
-          if c == '"'
-            j += 1
-            break
-          elsif c == "\\" && j + 1 < n && DQUOTE_BACKSLASH_SPECIAL.include?(text[j + 1])
-            nxt = text[j + 1]
-            buf << nxt unless nxt == "\n" # backslash-newline vanishes entirely
-            j += 2
-          else
-            buf << c
-            j += 1
-          end
+        shell = Shell.new(variables: state.variables, environment: @env) do |cmd|
+          run_simple(target, cmd, state, text)
         end
-        [buf, j]
+        shell.run(text)
+      rescue CommandLine::UnsupportedSyntaxError => e
+        unsupported!(e.construct, target, text)
       end
 
       # --- parsing ---------------------------------------------------------
 
-      # Turn the token stream into [[connector, SimpleCommand], ...]. A leading
-      # run of `VAR=value` words become that command's environment; a redirect
-      # marker consumes the following word as its target path.
-      def parse_line(target, text)
-        tokens = tokenize(target, text)
-        commands = []
-        connector = :first
-        assignments = []
-        argv = []
-        redirections = []
-        i = 0
-
-        flush = lambda do
-          unless assignments.empty? && argv.empty? && redirections.empty?
-            commands << [connector, SimpleCommand.new(assignments, argv, redirections)]
-          end
-          assignments = []
-          argv = []
-          redirections = []
-        end
-
-        while i < tokens.length
-          tok = tokens[i]
-          case tok[0]
-          when :word
-            w = tok[1]
-            if argv.empty? && w =~ /\A[A-Za-z_][A-Za-z0-9_]*=/
-              assignments << w
-            else
-              argv << w
-            end
-          when :and, :or, :semi
-            flush.call
-            connector = tok[0]
-          when :redirect
-            nxt = tokens[i + 1]
-            unsupported!("redirection without a target", target, text) if nxt.nil? || nxt[0] != :word
-            redirections << Redirection.new(tok[1], tok[2], nxt[1])
-            i += 1
-          end
-          i += 1
-        end
-        flush.call
-        commands
+      # Split a recipe line into words and connectors with the shared splitter.
+      # Kept as a method of the runner because a failure has to name the target
+      # whose recipe was at fault, which only the runner knows.
+      def tokenize(target, text)
+        CommandLine.tokenize(text)
+      rescue CommandLine::UnsupportedSyntaxError => e
+        unsupported!(e.construct, target, text)
       end
 
       # --- running a simple command ---------------------------------------
@@ -319,31 +164,36 @@ module Rubycc
         name = File.basename(argv[0])
         if BUILTINS.include?(name)
           run_builtin(target, name, argv, cmd, state, text)
-        elsif tool?(argv[0])
-          run_tool(argv, cmd, state)
+        elsif (driver_argv = tool_arguments(argv))
+          run_tool(driver_argv, cmd, state)
         else
           run_external(target, argv, cmd, state)
         end
       end
 
-      # Whether argv[0] names one of the substituted tool programs (matched by the
-      # word as written and by its basename, so both `gcc` and `/usr/bin/gcc`
-      # resolve). Empty when substitution is off, which keeps the default path
-      # (exec every unknown command) untouched.
-      def tool?(arg0)
-        return false if @tools.empty?
+      # The arguments to hand rubycc's Driver when +argv+ runs one of the
+      # substituted tools, or nil when it does not (in which case the command is
+      # run as an ordinary external process). A tool is matched by its whole argv
+      # prefix — the words `$(CC)`/`$(LDSHARED)` expand to, which for the mkmf
+      # shim's `<ruby> <path>/exe/rubycc` is two of them — and exactly those words
+      # are dropped, so what reaches the Driver is what the recipe added. The
+      # longest matching prefix wins, since a longer one describes the command
+      # more completely. With substitution off (@tools empty) nothing matches,
+      # which keeps the default path (exec every unknown command) untouched.
+      def tool_arguments(argv)
+        return nil if @tools.empty?
 
-        @tools.include?(arg0) || @tools.include?(File.basename(arg0))
+        prefix = @tools.select { |candidate| ToolCommand.match?(argv, candidate) }.max_by(&:length)
+        prefix && argv.drop(prefix.length)
       end
 
       # Run a substituted compiler/linker command through rubycc's Driver, which
-      # takes the gcc-style argv minus its program word. The compile line and the
-      # `-shared` link line map through the same Driver entry point (it selects
-      # its mode from the flags), so the two need no special-casing here. Sequential
-      # runs fork for crash isolation; a parallel worker is already isolated and
-      # runs the Driver in-process.
-      def run_tool(argv, cmd, state)
-        driver_argv = argv.drop(1)
+      # takes the gcc-style argv minus the words that named the program (see
+      # #tool_arguments). The compile line and the `-shared` link line map through
+      # the same Driver entry point (it selects its mode from the flags), so the
+      # two need no special-casing here. Sequential runs fork for crash isolation;
+      # a parallel worker is already isolated and runs the Driver in-process.
+      def run_tool(driver_argv, cmd, state)
         ok, reason = @isolate_tool ? fork_driver(driver_argv, state.cwd, cmd) \
                                    : inline_driver(driver_argv, state.cwd, cmd)
         state.failure_reason = reason unless ok
@@ -400,7 +250,20 @@ module Rubycc
           options[:out] = out_io if out_io
           options[:err] = err_io if err_io
           begin
-            pid = Process.spawn(env_overrides(cmd.assignments), *argv, options)
+            # `[argv[0], argv[0]]` (program plus argv0) rather than a bare
+            # `argv[0]` is load-bearing. Given a lone command string, Process
+            # .spawn decides for itself whether to involve /bin/sh, and it
+            # routes a shell reserved word there: measured on Ruby 3.4.5,
+            # "for", "do", "done", "if", "then", "elif", "else", "fi", "case",
+            # "esac", "while", "until", "in", "time", "!", "{", "}", "[[" and
+            # "]]" all reach the shell, while an ordinary name execs directly
+            # and raises ENOENT. A recipe fragment that happens to be one such
+            # word would then behave one way where a shell is installed and
+            # another where it is not -- the outcome DESIGN R5 and this module
+            # exist to rule out (see the file banner). The array form takes the
+            # decision away: it always execs. Commands of two words or more
+            # already did.
+            pid = Process.spawn(env_overrides(cmd.assignments), [argv[0], argv[0]], *argv[1..], options)
             _, status = Process.waitpid2(pid)
             state.failure_reason = "exited with status #{status.exitstatus}" unless status.success?
             status.success?
@@ -609,6 +472,7 @@ module Rubycc
           when "install" then builtin_install(target, argv, state, text)
           when "echo" then builtin_echo(argv, out)
           when "touch" then builtin_touch(argv, state)
+          when "test", "[" then builtin_test(target, argv, state, text)
           when "true", ":", "exit" then true
           else
             # BUILTINS listed it but no branch handles it — a programming error.
@@ -785,6 +649,73 @@ module Rubycc
         true
       end
 
+      # `test EXPR` / `[ EXPR ]` — the conditional Automake's install rules ask
+      # every file about (`test -f $p`, `test -z "$list2"`). It is a builtin
+      # rather than /usr/bin/test for the reason the whole runner exists: the
+      # minimal target environment has no coreutils, and a recipe must not
+      # succeed only where they happen to be installed. Only the primaries those
+      # recipes use are implemented; anything else is refused rather than
+      # guessed, since a wrong answer here silently takes the wrong branch.
+      # A false condition is an ordinary status, not an error, so it records no
+      # failure reason.
+      def builtin_test(target, argv, state, text)
+        args = argv.drop(1)
+        if File.basename(argv[0]) == "["
+          unsupported!("`[` without a closing `]`", target, text) unless args.last == "]"
+
+          args = args[0...-1]
+        end
+        test_expression(target, args, state, text)
+      end
+
+      # Evaluate a test expression by its argument count, which is how POSIX
+      # defines it (XCU test): no arguments is false, one argument is true when
+      # the string is not empty, two are a unary primary, three a binary one,
+      # and a leading `!` negates whichever of those follows.
+      def test_expression(target, args, state, text)
+        return !test_expression(target, args.drop(1), state, text) if args.first == "!"
+
+        case args.length
+        when 0 then false
+        when 1 then !args[0].empty?
+        when 2 then test_unary(target, args[0], args[1], state, text)
+        when 3 then test_binary(target, args, text)
+        else unsupported!("test expression #{args.inspect}", target, text)
+        end
+      end
+
+      # The file and string primaries. `-r` asks the kernel rather than reading
+      # the mode bits, so it answers for the user rmake is actually running as.
+      def test_unary(target, op, operand, state, text)
+        case op
+        when "-n" then !operand.empty?
+        when "-z" then operand.empty?
+        else
+          # The rest ask about a file, resolved against this line's cwd like
+          # every other operand a builtin takes.
+          path = absolute(operand, state.cwd)
+          case op
+          when "-f" then File.file?(path)
+          when "-d" then File.directory?(path)
+          when "-e" then File.exist?(path)
+          when "-r" then File.readable?(path)
+          when "-s" then File.exist?(path) && File.size(path).positive?
+          else unsupported!("test primary '#{op}'", target, text)
+          end
+        end
+      end
+
+      # String comparison. The arithmetic and file-age primaries (`-eq`, `-nt`,
+      # ...) are refused: no recipe rmake has to run uses one.
+      def test_binary(target, args, text)
+        left, op, right = args
+        case op
+        when "=" then left == right
+        when "!=" then left != right
+        else unsupported!("test operator '#{op}'", target, text)
+        end
+      end
+
       # `touch FILE...` — create each file or update its timestamp.
       def builtin_touch(argv, state)
         argv.drop(1).reject { |a| a.start_with?("-") }.each do |f|

data/lib/rubycc/rmake/makefile.rb

@@ -5,6 +5,7 @@ require_relative "model"
 require_relative "expander"
 require_relative "parser"
 require_relative "executor"
+require_relative "tool_command"
 
 module Rubycc
   module Rmake
@@ -51,9 +52,15 @@ module Rubycc
       # 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.
+      #
+      # +goal+ comes from the process (a command-line target), while the names it
+      # has to match — the rule targets, .PHONY, the default goal — are words of
+      # the Makefile, which Parser hands over as bytes. A goal spelled in another
+      # encoding matches no explicit rule at all once it holds a non-ASCII byte,
+      # so it is re-tagged here rather than silently planning nothing.
       def plan(goal = nil, now: Time.now)
         @now = now
-        goal ||= @default_goal
+        goal = goal ? goal.b : @default_goal
         raise RmakeError, "no target specified and the Makefile has no default goal" if goal.nil?
 
         @steps = []
@@ -68,8 +75,8 @@ module Rubycc
       # (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
+      # recipe commands that run this Makefile's compiler/linker — the ones whose
+      # argv begins with the words of `$(CC)` / `$(LDSHARED)` — 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
@@ -81,19 +88,28 @@ module Rubycc
               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)
+                     tools: tools ? tool_prefixes : [], 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
+      # The commands a `-`tools run substitutes for rubycc, each as the argv
+      # prefix that names the program: the words of `$(CC)` and of `$(LDSHARED)`
+      # (the compile and shared-link drivers mkmf emits), with trailing option
+      # words trimmed off. `LDSHARED` is normally `$(CC) -shared`, so both
+      # collapse to the same prefix and the `-shared` stays in the recipe where
+      # the Driver reads it; a plain gcc Makefile gives ["gcc"].
+      #
+      # A prefix rather than a program name because the words that name the
+      # program are not always one: the mkmf shim writes `CC = <ruby>
+      # <path>/exe/rubycc`, launching the executable through the running
+      # interpreter rather than through its `#!/usr/bin/env ruby` line. Matching
+      # the whole prefix is what keeps `ruby -Ilib <script>` or `jruby <script>`
+      # from handing the script path to the Driver as a compiler argument
+      # (ToolCommand).
+      def tool_prefixes
         [variable_value("CC"), variable_value("LDSHARED")]
-          .map { |value| value.split(/\s+/).reject(&:empty?).first }
-          .compact.uniq
+          .map { |value| ToolCommand.prefix(value) }
+          .reject(&:empty?).uniq
       end
 
       # The fully-expanded value of a variable (empty string when undefined).
@@ -327,8 +343,14 @@ module Rubycc
         @vpath_dirs ||= variable_value("VPATH").split(/[:\s]+/).reject(&:empty?)
       end
 
+      # +name+ is a word of the Makefile (bytes) while #dir came from the process
+      # (ARGV or Dir.pwd), so the join is done in bytes.
       def full_path(name)
-        absolute?(name) ? name : File.join(@dir, name)
+        absolute?(name) ? name : File.join(dir_bytes, name)
+      end
+
+      def dir_bytes
+        @dir_bytes ||= @dir.b
       end
 
       def absolute?(name)

data/lib/rubycc/rmake/parser.rb

@@ -47,8 +47,11 @@ module Rubycc
         @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) }
+        # Seeded values arrive from the process (a `VAR=value` operand, the
+        # built-in MAKE) and are expanded into the Makefile's own byte text, so
+        # they are taken as bytes here.
+        (defaults || {}).each { |name, value| @variables[name] = Variable.new(:simple, value.to_s.b) }
+        @overrides.each { |name, value| @variables[name] = Variable.new(:simple, value.to_s.b) }
       end
 
       attr_reader :variables, :rules
@@ -57,7 +60,10 @@ module Rubycc
         new(overrides: overrides, defaults: defaults).tap { |p| p.run(text) }
       end
 
+      # Bytes in (lib/rubycc.rb): the Makefile grammar is spelled in ASCII, and
+      # comments and recipe text are carried through.
       def run(text)
+        text = text.b unless text.encoding == Encoding::BINARY
         logical_lines(text).each do |content, kind, line_no|
           if kind == :recipe
             handle_recipe(content, line_no)

data/lib/rubycc/rmake/rmake.rb

@@ -10,6 +10,7 @@ require_relative "errors"
 require_relative "model"
 require_relative "expander"
 require_relative "parser"
+require_relative "tool_command"
 require_relative "makefile"
 require_relative "executor"
 require_relative "cli"