rubycc 1.0.0 → 1.1.0

data/lib/rubycc/preprocess/preprocessor.rb

@@ -245,7 +245,8 @@ module Rubycc
       # The identifiers __has_builtin (6.10.1) answers true for: exactly the
       # builtins rubycc's front end actually recognizes — the varargs intrinsics,
       # the branch-prediction hint, the stack allocator, offsetof, the
-      # constant/choose folds, the count-leading/trailing-zero scans, the
+      # constant/choose folds, the count-leading/trailing-zero scans and the
+      # set-bit count (each in its plain, "l" and "ll" spelling), the
       # unreachable hint, memcpy, the three overflow-checked arithmetic forms,
       # the nine __atomic_* forms and the ten legacy __sync_* forms. Every other
       # builtin query is false, so a header that guards a fallback behind
@@ -255,7 +256,10 @@ module Rubycc
       KNOWN_BUILTINS = %w[__builtin_va_start __builtin_va_arg __builtin_va_end __builtin_va_copy
                           __builtin_expect __builtin_alloca __builtin_offsetof
                           __builtin_constant_p __builtin_choose_expr
-                          __builtin_ctz __builtin_ctzll __builtin_clz __builtin_clzll
+                          __builtin_ctz __builtin_ctzl __builtin_ctzll
+                          __builtin_clz __builtin_clzl __builtin_clzll
+                          __builtin_popcount __builtin_popcountl
+                          __builtin_popcountll
                           __builtin_unreachable __builtin_memcpy
                           __builtin_add_overflow __builtin_sub_overflow
                           __builtin_mul_overflow
@@ -353,7 +357,19 @@ module Rubycc
         "__ATOMIC_ACQUIRE" => "2",
         "__ATOMIC_RELEASE" => "3",
         "__ATOMIC_ACQ_REL" => "4",
-        "__ATOMIC_SEQ_CST" => "5"
+        "__ATOMIC_SEQ_CST" => "5",
+        # Byte order: the __ORDER_*__ enumerators are gcc's fixed values for
+        # the classic 4321/1234/3412 encodings (independent of target), while
+        # __BYTE_ORDER__ and __FLOAT_WORD_ORDER__ carry gcc's verbatim
+        # replacement text — a reference to __ORDER_LITTLE_ENDIAN__, not the
+        # number itself — so a #if re-expands it just like gcc does. Both
+        # x86-64 and aarch64 are little-endian, so no per-target branch here;
+        # values are `gcc -dM -E </dev/null` on both, 2026-08-25.
+        "__ORDER_LITTLE_ENDIAN__" => "1234",
+        "__ORDER_BIG_ENDIAN__" => "4321",
+        "__ORDER_PDP_ENDIAN__" => "3412",
+        "__BYTE_ORDER__" => "__ORDER_LITTLE_ENDIAN__",
+        "__FLOAT_WORD_ORDER__" => "__ORDER_LITTLE_ENDIAN__"
       }.freeze
 
       # The libc this host's C library is: "musl" or "glibc" (see LIBCS). Read
@@ -508,9 +524,19 @@ module Rubycc
       # <stdarg.h> or a libc header resolves with no explicit -I; the driver's
       # -nostdinc passes it false to search only the caller's directories.
       def preprocess(source, filename:, include_paths: [], defines: [], system_includes: true)
+        # The directory a relative path is completed against (see
+        # #absolute_path). It comes from the process, so it is held as bytes,
+        # and it is read per run rather than once, since a caller driving
+        # several translation units may chdir between them.
+        @working_directory = Dir.pwd.b
         system_paths = system_includes ? default_system_include_paths : []
-        @system_include_paths = system_paths.map { |path| File.expand_path(path) }
-        @include_paths = include_paths + system_paths
+        @system_include_paths = system_paths.map { |path| absolute_path(path) }
+        # Bytes (lib/rubycc.rb): the only spot where a caller's -I (already
+        # bytes) and the bundled/libc directories (process-derived, so not)
+        # merge before joining with a header name, itself bytes.
+        @include_paths = (include_paths + system_paths).map do |path|
+          path.encoding == Encoding::BINARY ? path : path.b
+        end
         # #resolve_include's cache keys a resolved path off @include_paths (and,
         # for quote includes, the includer's directory), so it must start empty
         # every run rather than survive across calls with a different search path.
@@ -670,6 +696,7 @@ module Rubycc
         when "undef"        then handle_undef(name, body)
         when "line"         then handle_line(name, body)
         when "error"        then handle_error(hash, body)
+        when "warning"      then handle_warning(hash, body)
         when "pragma"       then handle_pragma(body, filename)
         else
           raise_at(name, "invalid preprocessing directive '##{name.text}'")
@@ -1033,7 +1060,7 @@ module Rubycc
       def process_include(hash, name, path, output)
         # A header that asked for "#pragma once" is read at most once per unit; a
         # later #include resolving to the same file is silently skipped (6.10.6).
-        return if @pragma_once.key?(File.expand_path(path))
+        return if @pragma_once.key?(absolute_path(path))
 
         # A guarded header whose guard macro is currently defined would emit
         # nothing and change nothing — skip its walk entirely (see @guard_cache).
@@ -1237,7 +1264,7 @@ module Rubycc
       # resolution beside its includer) has no "here" to resume past, so gcc
       # falls back to plain #include semantics for it, which this does too.
       def resolve_include_next(kind, name, includer, hash)
-        origin = @include_origin[File.expand_path(includer)]
+        origin = @include_origin[absolute_path(includer)]
         return resolve_include(kind, name, includer, hash) unless origin
 
         index, path = search_include_paths(name, origin + 1)
@@ -1260,11 +1287,27 @@ module Rubycc
       end
 
       def record_include_origin(path, index)
-        @include_origin[File.expand_path(path)] = index
+        @include_origin[absolute_path(path)] = index
+      end
+
+      # A path in the absolute form that serves as a file's identity here: the
+      # key of the "#pragma once" set and of the #include_next origin map, and
+      # the spelling the system-header test compares against. Both halves are
+      # bytes (lib/rubycc.rb) — the path itself, which reaches this class from a
+      # `-I` operand or a header name, and the base a relative one is completed
+      # against, which File.expand_path would otherwise take from the process
+      # itself and then refuse to splice a byte path onto.
+      def absolute_path(path)
+        path = path.b unless path.encoding == Encoding::BINARY
+        File.expand_path(path, @working_directory)
       end
 
+      # A header is read as bytes, never as text in the process's locale:
+      # File.read would tag the result with Encoding.default_external, and under
+      # a locale of "C" that is US-ASCII, which makes the first byte past 0x7F
+      # in the file an ArgumentError instead of a comment (see Scanner).
       def read_source(path, name, hash)
-        File.read(path)
+        File.binread(path)
       rescue SystemCallError
         raise_at(hash, "#{name}: No such file or directory")
       end
@@ -1324,8 +1367,8 @@ module Rubycc
       end
 
       # GCC diagnoses a conflicting redefinition from a system header as a
-      # warning, not a preprocessing error. Rubycc has no warning stream, so
-      # keep the header's later definition and continue; this is required by
+      # warning, not a preprocessing error. Rubycc reports nothing for it and
+      # keeps the header's later definition, continuing; this is required by
       # libffi, whose target header changes FFI_GO_CLOSURES after fiddle's local
       # compatibility header intentionally set it to zero. User-source
       # conflicts retain the strict diagnostic above.
@@ -1333,7 +1376,7 @@ module Rubycc
         filename = name.filename.to_s
         return false if filename.empty? || filename.start_with?("<")
 
-        path = File.expand_path(filename)
+        path = absolute_path(filename)
         @system_include_paths.any? { |root| path == root || path.start_with?("#{root}/") }
       end
 
@@ -1460,13 +1503,29 @@ module Rubycc
         one.zip(other).all? { |a, b| a.type == b.type && a.text == b.text }
       end
 
-      # --- #error ----------------------------------------------------------------
+      # --- #error / #warning -----------------------------------------------------
 
       def handle_error(hash, body)
-        # The message is the directive's tokens spelled out and single-spaced; it
-        # is never macro-expanded (matching gcc).
+        raise_at(hash, directive_message(body, "error"))
+      end
+
+      # "#warning" (C23 6.10.2p2, long a GNU extension): the same message, on the
+      # channel that reports and returns. The translation unit keeps going and
+      # the compile still succeeds, which is the whole point — a portability
+      # header announcing "unrecognized compiler" must not be the thing that
+      # kills the build.
+      def handle_warning(hash, body)
+        warn_at(hash, directive_message(body, "warning"))
+      end
+
+      # The text a #error / #warning reports: the directive's tokens spelled out
+      # and single-spaced, never macro-expanded (matching gcc), with the
+      # directive's own name standing in when it carried no message. Quoting is
+      # not required of the message and nothing is stripped from it, so
+      # `#warning foo bar` and `#warning "foo bar"` each report what they spell.
+      def directive_message(body, name)
         message = body.map(&:text).join(" ")
-        raise_at(hash, message.empty? ? "#error" : message)
+        message.empty? ? "##{name}" : message
       end
 
       # --- #line -----------------------------------------------------------------
@@ -1527,7 +1586,7 @@ module Rubycc
         first = body[0]
         return unless first&.type == :identifier && first.text == "once"
 
-        @pragma_once[File.expand_path(filename)] = true
+        @pragma_once[absolute_path(filename)] = true
       end
 
       # --- macro expansion -------------------------------------------------------
@@ -1667,10 +1726,10 @@ module Rubycc
           return
         end
 
-        raw, commas = collect_arguments(tok, queue)
+        raw, commas, close = collect_arguments(tok, queue)
         raw = match_arity(tok, macro, raw)
         invocation = Invocation.new(raw, commas, Array.new(raw.length))
-        queue.unshift(*substitute(tok, macro, invocation))
+        queue.unshift(*substitute(tok, macro, invocation, close))
       end
 
       # Whether the next non-newline token waiting in `queue` opens an argument
@@ -1685,9 +1744,12 @@ module Rubycc
       # confirmed by #call_follows?, then tokens up to the matching ")", split on
       # top-level commas. Nested parentheses are balanced so a comma or ")" inside
       # them belongs to an argument, and a newline is inter-token space that is
-      # dropped. Returns [arguments, commas]: the argument token lists and the
+      # dropped. Returns [arguments, commas, close]: the argument token lists, the
       # separating comma tokens themselves (kept so #__VA_ARGS__ can reproduce the
-      # exact spelling). Running out of tokens is an unterminated invocation.
+      # exact spelling), and the closing ")" token itself -- #expand_function_macro
+      # passes it on to #paint, whose hide-set intersection (6.10.3.4) needs the
+      # ")"'s own painting, not just its text. Running out of tokens is an
+      # unterminated invocation.
       def collect_arguments(tok, queue)
         queue.shift while queue.first&.newline?
         queue.shift # the "("
@@ -1703,7 +1765,7 @@ module Rubycc
             next
           elsif depth.zero? && token.punct?(")")
             arguments << current
-            return [arguments, commas]
+            return [arguments, commas, token]
           elsif depth.zero? && token.punct?(",")
             arguments << current
             commas << token
@@ -1755,15 +1817,18 @@ module Rubycc
 
       # Builds a macro's substitution by walking its replacement list once
       # (6.10.3). `invocation` carries a function-like call's arguments, or is nil
-      # for an object-like macro. "#" stringizes the following parameter's raw
-      # argument; "##" pastes the token to its left onto the operand to its right;
-      # a plain parameter becomes its pre-expanded argument, unless it abuts a
-      # "##", where the raw argument is used instead (6.10.3.1p1); every other
-      # token is a literal relocated to the use site and painted with the macro's
-      # name. `span` tracks how many tokens the token just placed contributed, so
-      # a following "##" knows its left operand (0 marks a placemarker).
-      def substitute(tok, macro, invocation)
-        painted = paint(tok)
+      # for an object-like macro. `close` is the ")" token that closed a
+      # function-like call's argument list (nil for an object-like macro, which
+      # has none); #paint needs it for the hide-set intersection rule. "#"
+      # stringizes the following parameter's raw argument; "##" pastes the token
+      # to its left onto the operand to its right; a plain parameter becomes its
+      # pre-expanded argument, unless it abuts a "##", where the raw argument is
+      # used instead (6.10.3.1p1); every other token is a literal relocated to the
+      # use site and painted with the macro's name. `span` tracks how many tokens
+      # the token just placed contributed, so a following "##" knows its left
+      # operand (0 marks a placemarker).
+      def substitute(tok, macro, invocation, close = nil)
+        painted = paint(tok, close)
         rep = macro.replacement
         result = []
         span = 0
@@ -1791,7 +1856,40 @@ module Rubycc
             index += 1
           end
         end
-        result
+        # hsadd(HS, OS), the last step of Prosser's subst (6.10.3.4p2): every
+        # token this call produces, argument-derived ones included, gains this
+        # call's paint. An argument keeps whatever painting it arrived with, but
+        # a macro name passed as an argument is unpainted against *this* call --
+        # it never passed through this replacement list -- and without this it
+        # would sit at the end of the substitution able to meet a "(" from the
+        # surrounding tokens and open a call the standard does not allow
+        # ("#define f(x) x" / "f(f)(1)" reads as "f(1)", not "1").
+        #
+        # Non-identifiers are painted too, because a ")" among them is read by
+        # #paint as one end of a later call: a ")" that lost this paint would
+        # empty the hide-set intersection and stop halting a self-referential or
+        # mutually recursive expansion. relocate and its kin already stamp
+        # exactly `painted`, so only argument-sourced tokens really gain here.
+        result.map! { |t| add_paint(t, painted) }
+      end
+
+      # A copy of `token` with `painted` added to its suppress set, or `token`
+      # itself when that would add nothing. The identity test comes first because
+      # it settles the common case in one comparison: relocate and kin stamp the
+      # very array `painted`, and a substitution is mostly their output, so the
+      # per-name scan is only paid for tokens that came from an argument. Union,
+      # not replacement: the token may carry a history of its own that still has
+      # to hold.
+      def add_paint(token, painted)
+        return token if token.suppress.equal?(painted)
+        return token if painted.all? { |name| token.suppress.include?(name) }
+
+        PPToken.new(
+          type: token.type, text: token.text,
+          filename: token.filename, line: token.line, column: token.column,
+          source_line: token.source_line, space_before: token.space_before,
+          suppress: (token.suppress | painted).freeze
+        )
       end
 
       # The tokens a plain (non-operator) replacement element expands to: a
@@ -1972,11 +2070,27 @@ module Rubycc
         )
       end
 
-      # The painting a token produced by expanding `tok` carries: `tok`'s own
-      # suppression set plus the macro name now being expanded, frozen so the
-      # shared list is never mutated by a later token's painting.
-      def paint(tok)
-        (tok.suppress + [tok.text]).freeze
+      # The painting a token produced by expanding `tok` carries: the names it
+      # must not expand into again, plus the macro name now being expanded,
+      # frozen so the shared list is never mutated by a later token's painting.
+      # `close` is the ")" that closed a call, or nil for an object-like macro,
+      # which has no call to close and so keeps `tok`'s own set entire.
+      #
+      # A call carries over only the names suppressed for *both* its name and
+      # its ")" -- the hide-set intersection of 6.10.3.4. The two sets differ
+      # only when the call was stitched together out of tokens with different
+      # histories: a name produced by an expansion (painted against it) reaching
+      # across to a ")" spelled in the source (painted against nothing). Taking
+      # the union there would leak an enclosing expansion's paint into a call it
+      # never wrote, which is what stalled c-testsuite 00201, where a "##" paste
+      # forms the macro name and the source supplies its argument list. Where
+      # name and ")" descend from the same replacement -- the ordinary case, and
+      # what a self-referential or mutually recursive macro produces -- the two
+      # sets are equal, so the intersection changes nothing and the recursion
+      # guard stands.
+      def paint(tok, close)
+        hidden = close ? (tok.suppress & close.suppress) : tok.suppress
+        (hidden + [tok.text]).freeze
       end
 
       def comma_token(site, suppress)
@@ -2006,6 +2120,16 @@ module Rubycc
         )
       end
 
+      # As #raise_at, but on the non-fatal channel: the message is written to the
+      # diagnostic stream in the same format and preprocessing continues.
+      def warn_at(pp, description)
+        Diagnostics.warn(
+          description,
+          filename: pp.filename, line: pp.line, column: pp.column,
+          source_line: pp.source_line
+        )
+      end
+
       # As #raise_at, but for a Front::Token (produced during #if evaluation)
       # rather than a preprocessing token; both expose the same location fields.
       def raise_at_front(token, description)

data/lib/rubycc/preprocess/scanner.rb

@@ -24,6 +24,20 @@ module Rubycc
     # the following physical line (see #sync). Positions are byte offsets
     # (StringScanner's native unit); columns are converted back to character
     # counts only when a token is actually made, and only for non-ASCII source.
+    #
+    # The unit of the whole scan is the *byte*: a C source file is a sequence of
+    # bytes (5.1.1.2), not text in whatever encoding the process's locale
+    # happens to name, and every construct this scanner recognizes is spelled in
+    # the basic character set. Anything else — a UTF-8 comment, a string literal
+    # holding non-ASCII bytes, a file that is not valid UTF-8 at all — only has
+    # to be carried through, and bytes carry it. #initialize therefore re-tags
+    # its input as ASCII-8BIT. That is what makes the compiler independent of
+    # Encoding.default_external: reading a header with File.read under a locale
+    # of "C" yields a US-ASCII string, and the first regexp or #split over it
+    # raises ArgumentError on the first byte past 0x7F (the bundled stddef.h has
+    # three, in a comment). Callers that read files hand bytes over already
+    # (File.binread); an embedder passing a String gets it re-tagged here, so no
+    # entry point can smuggle a locale-dependent encoding past this point.
     class Scanner
       # Two- and one-character punctuators gain the preprocessor-only "##" and
       # "#" over the shared punctuator tables; the three-character set is unchanged.
@@ -68,8 +82,27 @@ module Rubycc
       WIDE_CHAR_RE = /L'(?:[^'\\\n]|\\[^\n])*(?:'|\\)?/
       WIDE_STRING_RE = /L"(?:[^"\\\n]|\\[^\n])*(?:"|\\)?/
 
+      # One character that matched no token class above (6.4p1). "Character",
+      # not "byte": a lead byte takes the continuation bytes that follow it, so
+      # a stray multibyte character stays one token spanning one column. Byte
+      # tokens would break the rule that a token's spelling starts at its
+      # reported column — a caret would point at the character and the message
+      # would name a third of it — and would report one error per byte. A byte
+      # that is not UTF-8 at all (a lone continuation byte, or a lead byte with
+      # nothing after it) is a token of its own, which keeps the scan total for
+      # input that is not UTF-8. Tagged /n because the scanned text is bytes.
+      OTHER_RE = /[\xC0-\xFF][\x80-\xBF]*|./n
+
+      # UTF-8 continuation bytes (0b10xxxxxx): the bytes #column_at does not
+      # count, so that a multibyte character spans one column. Spelled as a byte
+      # range over an ASCII-8BIT string, which is what the scanned text is.
+      CONTINUATION_BYTES = "\x80-\xBF".b.freeze
+
       def initialize(source, filename:)
         @filename = filename
+        # The scan is over bytes, so anything handed over as text is re-tagged
+        # here — never transcoded (see the class comment).
+        source = source.b unless source.encoding == Encoding::BINARY
         # -1 keeps a trailing empty field so line numbers map 1:1 to entries.
         @lines = source.split("\n", -1)
         splice(source)
@@ -127,7 +160,7 @@ module Rubycc
           @spliced = source
           return
         end
-        spliced = +""
+        spliced = +"".b
         pos = 0
         while (idx = source.index("\\\n", pos))
           spliced << source[pos...idx]
@@ -166,17 +199,38 @@ module Rubycc
       end
 
       # The 1-based column of byte offset `pos`, counted in characters from the
-      # current physical line's start. Byte arithmetic serves ASCII source
-      # directly; non-ASCII source has to count characters, and must count them
-      # *incrementally*: measuring the whole @line_start..pos span per token
-      # costs O(line length) each time, so a single long line of L tokens costs
-      # O(L^2) — and one non-ASCII byte anywhere in the file (a comment in
-      # Japanese, a UTF-8 BOM) is enough to switch @ascii_only off for all of
-      # it. Tokens are located left to right, so keeping the last (byte offset,
-      # column) pair as a cursor and counting only the span since then makes a
-      # line cost O(line length) in total. Should a caller ever ask for an
-      # offset behind the cursor, the count restarts from the line start, so the
-      # answer stays right even if that monotonicity is lost.
+      # current physical line's start. A "character" here is a byte that is not
+      # a UTF-8 continuation byte: the scanned text is bytes, so the count
+      # cannot be delegated to String#length, and this rule gives the character
+      # count exactly for well-formed UTF-8 (the only multibyte encoding a
+      # caret-and-column diagnostic can hope to line up on a terminal) while
+      # staying defined — one column per byte that can begin a character — for
+      # input that is not UTF-8 at all. It is also decomposable, which the
+      # incremental cursor below needs: the count over a span is the sum over
+      # its parts however the span is cut, even mid-character.
+      #
+      # A rule that looked at the byte before — "count a
+      # continuation byte unless a lead byte precedes it" — would be more
+      # accurate on malformed input and would lose exactly that: a span cut
+      # between a lead byte and its continuation would be counted one way by
+      # the first half and another by the second, and the running total below
+      # would drift. The price is paid where the input is not UTF-8 anyway: a
+      # lone continuation byte counts as nothing, so two of them report the same
+      # column and the rest of that line is reported as many columns short (the
+      # answer is pinned in test/test_source_encoding.rb rather than left to be
+      # discovered).
+      #
+      # Byte arithmetic serves ASCII source directly; non-ASCII source has to
+      # count characters, and must count them *incrementally*: measuring the
+      # whole @line_start..pos span per token costs O(line length) each time, so
+      # a single long line of L tokens costs O(L^2) — and one non-ASCII byte
+      # anywhere in the file (a comment in Japanese, a UTF-8 BOM) is enough to
+      # switch @ascii_only off for all of it. Tokens are located left to right,
+      # so keeping the last (byte offset, column) pair as a cursor and counting
+      # only the span since then makes a line cost O(line length) in total.
+      # Should a caller ever ask for an offset behind the cursor, the count
+      # restarts from the line start, so the answer stays right even if that
+      # monotonicity is lost.
       def column_at(pos)
         return pos - @line_start + 1 if @ascii_only
 
@@ -185,7 +239,8 @@ module Rubycc
           @column_chars = 0
         end
         if pos > @column_pos
-          @column_chars += @spliced.byteslice(@column_pos, pos - @column_pos).length
+          span = @spliced.byteslice(@column_pos, pos - @column_pos)
+          @column_chars += span.bytesize - span.count(CONTINUATION_BYTES)
           @column_pos = pos
         end
         @column_chars + 1
@@ -255,7 +310,7 @@ module Rubycc
           # :other token (6.4p1), deferring the decision of whether it is an
           # error to a later phase.
           type = :other
-          text = ss.getch
+          text = ss.scan(OTHER_RE)
         end
         make_token(type, text, line, column, space_before)
       end

data/lib/rubycc/preprocess/token_converter.rb

@@ -55,7 +55,7 @@ module Rubycc
             tokens << front_token(pp, :punct, pp.text)
             index += 1
           when :other
-            raise_at(pp, "unexpected character #{pp.text.inspect}")
+            raise_at(pp, "unexpected character #{spelling_of(pp.text)}")
           end
         end
         tokens
@@ -145,6 +145,16 @@ module Rubycc
         )
       end
 
+      # How an :other token is named in its diagnostic. The scanner works on
+      # bytes, so the token's text is bytes; a well-formed UTF-8 character is
+      # re-tagged so the message shows the character the author typed rather
+      # than the escapes of its encoding, and anything else stays bytes and is
+      # shown escaped (there is no reading of it to offer).
+      def spelling_of(text)
+        utf8 = text.dup.force_encoding(Encoding::UTF_8)
+        (utf8.valid_encoding? ? utf8 : text).inspect
+      end
+
       def raise_at(pp, description)
         raise CompileError.new(
           description,

data/lib/rubycc/rmake/cli.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+require "rbconfig"
+
 require_relative "errors"
+require_relative "../command_line"
 require_relative "makefile"
 
 module Rubycc
@@ -41,15 +44,22 @@ module Rubycc
       end
 
       def run(argv)
-        options = parse_argv(argv)
+        # The command line crosses into rmake here, so it is re-tagged as bytes
+        # (lib/rubycc.rb): every goal and `VAR=value` operand is matched against
+        # words of the Makefile, which the Parser hands over as bytes. The array
+        # is rebuilt rather than mutated, since an in-process caller owns the one
+        # it passes.
+        options = parse_argv(argv.map { |arg| arg.encoding == Encoding::BINARY ? arg : arg.b })
 
-        makefile_path = File.expand_path(options[:file] || DEFAULT_MAKEFILE, @dir)
+        makefile_path = File.expand_path(options[:file] || DEFAULT_MAKEFILE, dir_bytes)
         unless File.file?(makefile_path)
           @err.puts("rmake: #{options[:file] || DEFAULT_MAKEFILE}: No such file")
           return 2
         end
 
-        mk = Makefile.parse(File.read(makefile_path), dir: @dir, overrides: options[:overrides],
+        # Bytes: a Makefile carries comments (and occasionally a path) in
+        # whatever encoding its author used.
+        mk = Makefile.parse(File.binread(makefile_path), dir: @dir, overrides: options[:overrides],
                              defaults: { "MAKE" => make_default })
         goals = options[:targets].empty? ? [nil] : options[:targets]
         # Tool substitution is always on: rmake is rubycc's build CLI, so the
@@ -113,6 +123,15 @@ module Rubycc
         { overrides: overrides, targets: targets, jobs: [jobs, 1].max, file: file }
       end
 
+      # A relative -f operand is completed against #dir, which came from the
+      # process (Dir.pwd, or the caller's own string) rather than from bytes, so
+      # the base is re-tagged too: File.expand_path joins the two, and a byte
+      # operand under a non-ASCII working directory is exactly the join Ruby
+      # refuses when their tags differ.
+      def dir_bytes
+        @dir_bytes ||= @dir.encoding == Encoding::BINARY ? @dir : @dir.b
+      end
+
       def processor_count
         require "etc"
         Etc.nprocessors
@@ -129,6 +148,14 @@ module Rubycc
       # bare "make" that would hand the recursive build to a host GNU make (or
       # fail outright) instead of rubycc.
       #
+      # The path is prefixed with the running interpreter and both words are
+      # quoted (a path may contain a space), the same shape the rubygems_plugin
+      # and the mkmf shim use: rmake's own `#!/usr/bin/env ruby`
+      # line cannot be resolved on a host with no /usr/bin/env (DESIGN R5), so a
+      # recursive invocation has to name the interpreter itself — and naming
+      # *this* interpreter also keeps the recursive build on the Ruby the
+      # top-level one is running under.
+      #
       # `ENV["MAKE"]` is honoured first because RubyGems' rubygems_plugin sets it
       # to rmake before invoking `$(MAKE)` at the top level, and that value must
       # propagate unchanged into any recipe this run itself expands.
@@ -136,7 +163,8 @@ module Rubycc
         env_make = ENV["MAKE"]
         return env_make if env_make && !env_make.empty?
 
-        File.expand_path($PROGRAM_NAME)
+        [RbConfig.ruby, File.expand_path($PROGRAM_NAME)]
+          .map { |word| CommandLine.quote(word) }.join(" ")
       end
     end
   end