rubycc 1.0.0

data/lib/rubycc/pkgconf/pkgconf.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Pkgconf — the pkg-config shim (M3 / DESIGN R5, ROADMAP §6 B4): a pure-Ruby
+# .pc parser plus the narrow CLI mkmf's mkmf.rb#pkg_config actually invokes
+# ($PKGCONFIG with --exists / --modversion / --cflags[-only-*] /
+# --libs[-only-l]). It stays self-contained — depending on nothing else in
+# lib/rubycc, like rmake (M3 B1) — so exe/rubycc-pkgconf and the tests can
+# load it on its own.
+require_relative "errors"
+require_relative "model"
+require_relative "parser"
+require_relative "search_path"
+require_relative "system_path_filter"
+require_relative "resolver"
+require_relative "cli"

data/lib/rubycc/pkgconf/resolver.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module Rubycc
+  module Pkgconf
+    # Loads .pc files by name from a search path and walks their Requires
+    # chain to produce the token lists --cflags/--libs need. A module is
+    # loaded at most once per Resolver (a memoizing cache doubling as the
+    # cycle guard for a Requires loop); within a single module's own
+    # Cflags/Libs value, tokens are kept exactly as written — no de-duplication
+    # is attempted (see the Step 59 report: this cannot be measured against
+    # the real pkg-config in this environment, so the simplest order-preserving
+    # concatenation is used, which is all mkmf's pkg_config() needs).
+    class Resolver
+      def initialize(directories: SearchPath.directories)
+        @directories = directories
+        @cache = {}
+      end
+
+      # True if +name+ and its whole Requires/Requires.private chain resolve —
+      # the same thing `pkg-config --exists` has to check, since it must load
+      # every dependency's .pc file to answer the question.
+      def exists?(name)
+        cflags_tokens(name)
+        true
+      rescue PkgconfError
+        false
+      end
+
+      def load(name)
+        return @cache[name] if @cache.key?(name)
+
+        path = SearchPath.find(name, directories: @directories)
+        raise NotFoundError, "package '#{name}' not found (searched #{@directories.join(File::PATH_SEPARATOR)})" unless path
+
+        @cache[name] = Parser.parse(File.read(path), path: path)
+      end
+
+      # Own Cflags, then each public Requires recursively, then each
+      # Requires.private recursively — a private dependency's compiler flags
+      # are still needed to build against +name+, they are just not exposed to
+      # *its* dependents (that asymmetry is Requires.private's whole point).
+      def cflags_tokens(name, visited = {})
+        return [] if visited[name]
+
+        visited[name] = true
+        pkg = load(name)
+        tokens = Shellwords.split(pkg.cflags)
+        pkg.requires.each { |dep| tokens.concat(cflags_tokens(dep, visited)) }
+        pkg.requires_private.each { |dep| tokens.concat(cflags_tokens(dep, visited)) }
+        tokens
+      end
+
+      # Own Libs, then each public Requires recursively. Requires.private
+      # never contributes here — pkg-config only pulls a private dependency's
+      # Libs into the static-link case (Libs.private via --static), which
+      # mkmf's pkg_config() never requests, so it is out of scope.
+      def libs_tokens(name, visited = {})
+        return [] if visited[name]
+
+        visited[name] = true
+        pkg = load(name)
+        tokens = Shellwords.split(pkg.libs)
+        pkg.requires.each { |dep| tokens.concat(libs_tokens(dep, visited)) }
+        tokens
+      end
+    end
+  end
+end

data/lib/rubycc/pkgconf/search_path.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Rubycc
+  module Pkgconf
+    # Where a `<name>.pc` is looked up when nothing else says otherwise.
+    module SearchPath
+      # The multiarch directory comes first because that is where this
+      # environment's real .pc files actually live
+      # (/usr/lib/x86_64-linux-gnu/pkgconfig/{zlib,libffi,openssl,...}.pc —
+      # see the Step 59 report); /usr/lib/pkgconfig and /usr/share/pkgconfig
+      # are the architecture-independent locations pkg-config falls back to
+      # next on a Debian/Ubuntu multiarch system.
+      DEFAULT_DIRECTORIES = [
+        "/usr/lib/x86_64-linux-gnu/pkgconfig",
+        "/usr/lib/pkgconfig",
+        "/usr/share/pkgconfig"
+      ].freeze
+
+      # PKG_CONFIG_PATH (colon-separated, mirroring PATH) is searched before
+      # the defaults — the same precedence mkmf's own pkg_config() relies on
+      # when dir_config found a --with-*-dir libdir and set PKG_CONFIG_PATH to
+      # that libdir's pkgconfig/ subdirectory before invoking pkg-config.
+      def self.directories(env = ENV)
+        extra = (env["PKG_CONFIG_PATH"] || "").split(File::PATH_SEPARATOR).reject(&:empty?)
+        extra + DEFAULT_DIRECTORIES
+      end
+
+      # The first `<name>.pc` found across +directories+, or nil.
+      def self.find(name, directories: directories())
+        directories.each do |dir|
+          path = File.join(dir, "#{name}.pc")
+          return path if File.file?(path)
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/rubycc/pkgconf/system_path_filter.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Rubycc
+  module Pkgconf
+    # Drops the `-I<dir>`/`-L<dir>` tokens whose directory the toolchain
+    # already searches on its own. pkg-config suppresses those in its
+    # --cflags/--libs output (emitting them would let a package silently
+    # reorder the compiler's or linker's default search order), so a shim that
+    # kept them would disagree with the real tool on the most common packages
+    # of all: this environment's zlib.pc alone carries `-I/usr/include` and
+    # `-L${libdir}`.
+    #
+    # The two escape hatches are the ones the environment exposes:
+    # PKG_CONFIG_ALLOW_SYSTEM_CFLAGS / PKG_CONFIG_ALLOW_SYSTEM_LIBS turn the
+    # respective filter off, and PKG_CONFIG_SYSTEM_INCLUDE_PATH /
+    # PKG_CONFIG_SYSTEM_LIBRARY_PATH (colon-separated, mirroring PATH) replace
+    # the directory lists below.
+    class SystemPathFilter
+      # What counts as a system directory when nothing overrides it.
+      DEFAULT_INCLUDE_DIRECTORIES = ["/usr/include"].freeze
+
+      # What counts as a system library directory, in two groups.
+      #
+      # The multiarch pair is here because CI measured the real pkg-config
+      # against a Debian zlib.pc (libdir=${prefix}/lib/x86_64-linux-gnu) and
+      # found it drops the `-L` for that directory too, not just plain /usr/lib:
+      # on Debian/Ubuntu the multiarch libdir *is* a system libdir as far as
+      # pkg-config is concerned. It is applied only when the directory exists,
+      # because a multiarch libdir is a Debian/Ubuntu layout: on a host without
+      # one (Alpine, measured in CI) the real pkg-config keeps a `-L` naming it,
+      # since there it is an ordinary directory rather than one the linker
+      # already searches. Dropping it there made this shim emit `-lz` where the
+      # real tool emitted `-L/usr/lib/x86_64-linux-gnu -lz` (docs/development/STEPS.md Step
+      # 196).
+      #
+      # /usr/lib, /lib and /usr/lib64 are unconditional: they are system libdirs
+      # wherever they exist, and gating them on existence would change what this
+      # shim emits on the hosts the other measurements were taken on.
+      #
+      # The lists are deliberately kept in step with the other hardcoded
+      # "default search directory" lists in this codebase --
+      # Link::LibraryResolver::DEFAULT_SYSTEM_DIRS and
+      # SearchPath::DEFAULT_DIRECTORIES both already special-case the same
+      # multiarch path -- on the theory that a directory this shim's own linker
+      # searches by default is never worth emitting a `-L` for; that is the
+      # whole point of this filter.
+      #
+      # /usr/local/lib is deliberately *not* included even though
+      # LibraryResolver::DEFAULT_SYSTEM_DIRS lists it: the real pkg-config does
+      # not treat it as a system directory, and adding it would make this shim
+      # diverge from the measured behaviour instead of matching it.
+      MULTIARCH_LIBRARY_DIRECTORIES = [
+        "/usr/lib/x86_64-linux-gnu",
+        "/lib/x86_64-linux-gnu"
+      ].freeze
+
+      UNIVERSAL_LIBRARY_DIRECTORIES = [
+        "/usr/lib",
+        "/lib",
+        "/usr/lib64"
+      ].freeze
+
+      # The system libdirs on *this* host, in the order above.
+      def self.default_library_directories
+        MULTIARCH_LIBRARY_DIRECTORIES.select { |d| File.directory?(d) } + UNIVERSAL_LIBRARY_DIRECTORIES
+      end
+
+      # +env+ is an argument (defaulting to the process environment) for the
+      # same reason SearchPath.directories takes one: it keeps the lookup
+      # injectable from a test without mutating the global ENV.
+      def initialize(env = ENV)
+        @include_directories = directory_list(env["PKG_CONFIG_SYSTEM_INCLUDE_PATH"], DEFAULT_INCLUDE_DIRECTORIES)
+        @library_directories = directory_list(env["PKG_CONFIG_SYSTEM_LIBRARY_PATH"],
+                                             self.class.default_library_directories)
+        @keep_system_includes = set?(env["PKG_CONFIG_ALLOW_SYSTEM_CFLAGS"])
+        @keep_system_libraries = set?(env["PKG_CONFIG_ALLOW_SYSTEM_LIBS"])
+      end
+
+      # +tokens+ with the system `-I<dir>` entries removed. Every other token
+      # (`-D...`, a bare `-I`, `-l...`, ...) is passed through untouched.
+      def cflags(tokens)
+        return tokens if @keep_system_includes
+
+        reject_system(tokens, "-I", @include_directories)
+      end
+
+      # +tokens+ with the system `-L<dir>` entries removed; `-l` and the rest
+      # are passed through untouched.
+      def libs(tokens)
+        return tokens if @keep_system_libraries
+
+        reject_system(tokens, "-L", @library_directories)
+      end
+
+      private
+
+      # Only the one-token `-I/usr/include` spelling is recognized. A `.pc`
+      # that writes the directory as a separate token (`-I /usr/include`)
+      # already defeats this shim's --cflags-only-I/--cflags-only-other split,
+      # which classifies per token, so nothing here tries to pair the two up.
+      def reject_system(tokens, flag, system_directories)
+        tokens.reject do |token|
+          token.start_with?(flag) && token.length > flag.length &&
+            system_directories.include?(normalize(token[flag.length..]))
+        end
+      end
+
+      # An explicit value replaces the default outright, even when it is empty
+      # (`PKG_CONFIG_SYSTEM_INCLUDE_PATH=` then means "no directory is a
+      # system directory"); only an unset variable falls back to +defaults+.
+      def directory_list(value, defaults)
+        list = value.nil? ? defaults : value.split(File::PATH_SEPARATOR).reject(&:empty?)
+        list.map { |dir| normalize(dir) }
+      end
+
+      def set?(value)
+        !value.nil? && !value.empty?
+      end
+
+      # Compare directories as text, not as filesystem objects: repeated and
+      # trailing separators are folded away so `-I/usr/include/` matches
+      # `/usr/include`, while symlinks are deliberately left unresolved (a
+      # .pc's prefix is frequently a symlink, and resolving it would make the
+      # output depend on the state of the filesystem).
+      def normalize(dir)
+        folded = dir.gsub(%r{/{2,}}, "/")
+        folded.length > 1 ? folded.sub(%r{/\z}, "") : folded
+      end
+    end
+  end
+end

data/lib/rubycc/preprocess/constant_expression.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative "../front/ast"
+require_relative "../type"
+require_relative "../compile_error"
+
+module Rubycc
+  module Preprocess
+    # Parses the controlling constant-expression of a "#if"/"#elif" (ISO C
+    # 6.10.1) into a Front::AST the shared ConstantEvaluator can fold. It runs
+    # over an already-neutralized Front::Token stream: "defined" has been folded
+    # to 1/0, macros have been expanded, and every surviving identifier has been
+    # turned into the integer 0 (6.10.1p4), so the only leaves that reach here
+    # are integer/character constants and parentheses.
+    #
+    # The grammar admitted is exactly the integer constant-expression subset the
+    # preprocessor allows: unary "+ - ~ !", the binary arithmetic, shift,
+    # relational, equality and bitwise operators, "&&"/"||", and "?:". Cast,
+    # sizeof, comma and assignment are outside it; those spellings either arrive
+    # as a stray punctuator (comma, assignment) or, being keyword-spelled
+    # identifiers, have already collapsed to 0, and any leftover token is
+    # rejected. Rather than a method per precedence level, a single precedence
+    # table drives one climbing loop, so the whole binary grammar is one method.
+    class ConstantExpressionParser
+      # Each binary operator's binding power (higher binds tighter) and the
+      # AST::Binary op it lowers to; "&&" and "||" carry :logical markers since
+      # they build their own short-circuiting nodes rather than an AST::Binary.
+      BINARY_OPERATORS = {
+        "*" => [11, :mul], "/" => [11, :div], "%" => [11, :mod],
+        "+" => [10, :add], "-" => [10, :sub],
+        "<<" => [9, :shl], ">>" => [9, :shr],
+        "<" => [8, :lt], ">" => [8, :gt], "<=" => [8, :le], ">=" => [8, :ge],
+        "==" => [7, :eq], "!=" => [7, :ne],
+        "&" => [6, :and],
+        "^" => [5, :xor],
+        "|" => [4, :or],
+        "&&" => [3, :logical_and],
+        "||" => [2, :logical_or]
+      }.freeze
+
+      # The lowest binding power in the table ("||"); the conditional operator
+      # sits just below it, so climbing from here collects every binary operator
+      # before "?:" is considered.
+      LOGICAL_OR_PRECEDENCE = 2
+
+      # The recursion-depth ceiling, mirroring the main parser's guard: a hostile
+      # "#if (((...)))" or "#if !!!...1" would otherwise recurse until the Ruby
+      # stack overflows with a bare SystemStackError. This grammar is far lighter
+      # than the main parser's (a single precedence-climbing loop rather than a
+      # deep chain), so its stack gives out only around 2500 nested parentheses;
+      # 500 stops a pathological input after roughly 250 levels — an order of
+      # magnitude below that, and far above the trivial nesting any real
+      # controlling expression uses (well under ten).
+      MAX_NESTING_DEPTH = 500
+
+      def initialize(tokens, directive)
+        @tokens = tokens
+        @pos = 0
+        # The directive keyword ("if"/"elif"), used only to name diagnostics.
+        @directive = directive
+        # Live recursion depth, capped at MAX_NESTING_DEPTH by #with_nesting_guard.
+        @depth = 0
+      end
+
+      def parse
+        node = parse_conditional
+        unless current.eof?
+          raise_at(current, "extra tokens at end of ##{@directive} expression")
+        end
+
+        node
+      end
+
+      private
+
+      # conditional-expression: a logical-OR expression optionally followed by
+      # "? expression : conditional-expression". Right associativity falls out of
+      # recursing on the else arm. Every parenthesized sub-expression re-enters
+      # here (a "(" primary recurses back into #parse_conditional), so guarding
+      # this entry bounds the depth of nested parentheses and "?:" chains alike.
+      def parse_conditional
+        with_nesting_guard do
+          condition = parse_binary(LOGICAL_OR_PRECEDENCE)
+          if current.punct?("?")
+            question = advance
+            then_expr = parse_conditional
+            expect(":", "expected ':' in preprocessor conditional expression")
+            else_expr = parse_conditional
+            Front::AST::Conditional.new(condition: condition, then_expr: then_expr,
+                                        else_expr: else_expr, token: question)
+          else
+            condition
+          end
+        end
+      end
+
+      # Precedence climbing: parse a unary operand, then keep folding in any
+      # binary operator whose binding power meets `min_power`, recursing one
+      # level tighter on the right so equal-precedence operators associate left.
+      def parse_binary(min_power)
+        left = parse_unary
+        loop do
+          info = current.type == :punct ? BINARY_OPERATORS[current.value] : nil
+          break if info.nil? || info[0] < min_power
+
+          power, op = info
+          operator = advance
+          right = parse_binary(power + 1)
+          left = build_binary(op, left, right, operator)
+        end
+        left
+      end
+
+      def build_binary(op, left, right, token)
+        case op
+        when :logical_and
+          Front::AST::LogicalAnd.new(lhs: left, rhs: right, token: token)
+        when :logical_or
+          Front::AST::LogicalOr.new(lhs: left, rhs: right, token: token)
+        else
+          Front::AST::Binary.new(op: op, lhs: left, rhs: right, token: token)
+        end
+      end
+
+      # unary-expression: a chain of "+ - ~ !" prefixes over a primary. Unary "+"
+      # folds away; "~x" desugars to "x ^ -1", the same lowering the main parser
+      # uses so the evaluator meets a single :xor form. A prefix chain recurses
+      # here without passing through #parse_conditional, so it carries its own
+      # depth guard against a long "!!!...1"/"~~~...1" run.
+      def parse_unary
+        with_nesting_guard do
+          if current.punct?("+")
+            advance
+            parse_unary
+          elsif current.punct?("-")
+            token = advance
+            Front::AST::Unary.new(op: :neg, operand: parse_unary, token: token)
+          elsif current.punct?("!")
+            token = advance
+            Front::AST::Unary.new(op: :not, operand: parse_unary, token: token)
+          elsif current.punct?("~")
+            token = advance
+            operand = parse_unary
+            Front::AST::Binary.new(op: :xor, lhs: operand, rhs: int_literal(-1, token), token: token)
+          else
+            parse_primary
+          end
+        end
+      end
+
+      # primary-expression: an integer/character constant, or a parenthesized
+      # conditional-expression. Anything else — a leftover operator, a comma, an
+      # unmatched paren — is not valid in a preprocessor expression.
+      def parse_primary
+        token = current
+        if token.type == :num
+          advance
+          int_literal(token.value, token)
+        elsif token.punct?("(")
+          advance
+          node = parse_conditional
+          expect(")", "expected ')' in preprocessor expression")
+          node
+        else
+          raise_at(token, "token is not valid in preprocessor expressions")
+        end
+      end
+
+      # An integer leaf. The value is what the evaluator reads; the type is
+      # nominal (this subset folds every intermediate as an unbounded integer),
+      # so a single wide signed type stands in for the intmax the preprocessor
+      # nominally computes in.
+      def int_literal(value, token)
+        Front::AST::IntLit.new(value: value, token: token, type: Type::Long)
+      end
+
+      # Runs `block` one level deeper, rejecting a pathologically nested
+      # controlling expression with a located diagnostic (rather than letting it
+      # overflow the Ruby stack) once MAX_NESTING_DEPTH levels are live. The
+      # depth is decremented in an ensure so a parse error still unwinds it.
+      def with_nesting_guard
+        if @depth >= MAX_NESTING_DEPTH
+          raise_at(current, "##{@directive} expression nested too deeply")
+        end
+
+        @depth += 1
+        begin
+          yield
+        ensure
+          @depth -= 1
+        end
+      end
+
+      def current
+        @tokens[@pos]
+      end
+
+      def advance
+        token = @tokens[@pos]
+        @pos += 1 unless token.eof?
+        token
+      end
+
+      def expect(punct, message)
+        raise_at(current, message) unless current.punct?(punct)
+
+        advance
+      end
+
+      def raise_at(token, description)
+        raise CompileError.new(
+          description,
+          filename: token.filename, line: token.line, column: token.column,
+          source_line: token.source_line
+        )
+      end
+    end
+  end
+end

data/lib/rubycc/preprocess/glibc_version.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "../objfile/elf_reader"
+require_relative "../link/errors"
+require_relative "../link/library_resolver"
+
+module Rubycc
+  module Preprocess
+    # Measures the glibc minor version of the C library a compile will link
+    # against, so <features.h>'s __GLIBC__/__GLIBC_MINOR__ can describe *this*
+    # host instead of the machine the bundled headers were written on.
+    #
+    # rubycc ships one copy of the libc headers for every host (R8), so the
+    # version those headers report used to be a constant: 39, the reference
+    # platform's. On any other host that constant made version-gated header code
+    # ("#if __GLIBC_PREREQ (2, 38)") select a different branch than the host's
+    # own gcc does, and in the over-reporting direction — claiming 2.39 on a
+    # 2.34 host — the selected branch can reach for a symbol that libc does not
+    # have, which surfaces as an undefined symbol at link or dlopen time
+    # (docs/development/GAPS.md gap U). The value therefore has to be measured, and the only
+    # honest place to measure it is the C library itself: not the host's
+    # /usr/include (a distroless target has none, which is the whole reason the
+    # bundled headers exist) and not the host's gcc (rubycc must work without
+    # one).
+    #
+    # What a glibc image states about itself is the set of symbol versions it
+    # defines — GLIBC_2.2.5, GLIBC_2.3, ... GLIBC_2.39 — recorded in its
+    # .gnu.version_d table, which ELFReader reads. The highest GLIBC_2.<n> it
+    # defines is the newest interface it can satisfy, so <n> is what
+    # __GLIBC_MINOR__ has to say for a version gate to pick a branch this libc
+    # can actually back.
+    #
+    # That measure has one known way of coming out low: a glibc release that
+    # added no new symbol to libc.so.6 gets no version node of its own (2.19,
+    # 2.20, 2.21 and 2.37 are the releases where this happened), so on such a
+    # host the highest node names the previous release. The result is then
+    # conservative rather than wrong in the dangerous direction — a gate may
+    # take an older branch, never one whose symbols are missing — but it does
+    # differ from what the host's own headers say. Reading the version out of
+    # glibc's banner string instead would be exact; it is not done here because
+    # that means pattern-matching English prose in .rodata, whereas the version
+    # table is a structure the ABI defines.
+    #
+    # Which file is "the C library" is a question about the *target*, never
+    # about this host's own paths: the search runs through LibraryResolver with
+    # the target's own system directories, exactly as the `-lc` of a real link
+    # would, so a cross compile measures the cross libc and a host with no libc
+    # at all measures nothing and falls back (see .minor_for).
+    module GlibcVersion
+      # The library request that finds the C library. Deliberately the same
+      # spelling a link uses, so this reads whatever `-lc` would reach —
+      # including through the GNU-ld script glibc installs as libc.so.
+      LIBC_LIBRARY = "c"
+
+      # A version node naming a whole glibc release: "GLIBC_2.39" and kin. The
+      # three-component names ("GLIBC_2.2.5") and the non-release ones
+      # ("GLIBC_PRIVATE", "GLIBC_ABI_DT_RELR") are not releases whose minor
+      # number __GLIBC_MINOR__ could carry, so only this shape counts. The major
+      # number is pinned at 2 for the same reason __GLIBC__ is: glibc has
+      # carried it since 1997, and a 3.x would be a different ABI whose minor
+      # number this measurement should not be feeding to a 2.x header anyway.
+      # Naming glibc's own spelling here is not the hard-coded host identity
+      # test/test_platform_literals.rb guards against: this module measures
+      # glibc specifically, and a libc that spells its versions otherwise is
+      # precisely the "not measurable" case (see .minor_in).
+      RELEASE_VERSION = /\AGLIBC_2\.(\d+)\z/
+
+      class << self
+        # The measured glibc minor version for `target` (an architecture name or
+        # triple, as LibraryResolver takes), or nil when this host has no glibc
+        # to measure — no C library on the target's search path, a libc that is
+        # not glibc (musl defines no version nodes), or one this reader cannot
+        # parse. The caller decides what an unmeasurable host means; the
+        # preprocessor falls back to the value the bundled <features.h> carries.
+        #
+        # Memoized per target for the life of the process: a translation unit
+        # must not pay a 2 MB read of libc for a value that cannot change while
+        # the compiler runs (N1). nil is memoized too, so a host without a libc
+        # searches once rather than once per unit.
+        def minor_for(target)
+          cache = (@minor_for ||= {})
+          return cache[target] if cache.key?(target)
+
+          cache[target] = measure(target)
+        end
+
+        # The uncached measurement, kept separate so a caller (and the tests)
+        # can ask for a fresh reading. The first library that states a version
+        # settles it: the `-lc` resolution yields libc itself ahead of the
+        # loader it names, and a glibc loader repeats libc's versions rather
+        # than adding to them.
+        def measure(target)
+          libc_images(target).each do |path|
+            minor = minor_in(path)
+            return minor if minor
+          end
+          nil
+        end
+
+        # The highest glibc release version the shared object at `path` defines,
+        # or nil when it defines none — which is the answer for a musl libc, for
+        # a relocatable object, and for anything that is not an ELF file this
+        # reader accepts. An unreadable file is likewise "cannot measure", not
+        # an error: this runs on the way to a compile that must still happen.
+        def minor_in(path)
+          reader = ObjFile::ELFReader.read_file(path)
+          reader.version_definitions.filter_map { |v| v.name[RELEASE_VERSION, 1]&.to_i }.max
+        rescue ObjFile::ELFFormatError, SystemCallError, IOError
+          nil
+        end
+
+        # The shared objects a `-lc` link for `target` would bind against, in
+        # the order the linker sees them. A target with no C library on its
+        # search path is not an error here (a cross target whose sysroot is not
+        # installed, a musl image with no glibc): it simply cannot be measured.
+        def libc_images(target)
+          Link::LibraryResolver.resolve([LIBC_LIBRARY], target: target).needed
+        rescue Link::LinkError, SystemCallError
+          []
+        end
+      end
+    end
+  end
+end

data/lib/rubycc/preprocess/pp_token.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Rubycc
+  module Preprocess
+    # A preprocessing token (ISO C 6.4). Unlike a Front::Token it holds only the
+    # source spelling (`text`), deferring interpretation of numbers, literals and
+    # keywords to the conversion that ends translation phase 4. `type` is one of:
+    #
+    #   :identifier  an identifier or keyword spelling
+    #   :pp_number   a preprocessing number (6.4.8), broader than a C constant
+    #   :string      a string literal, quotes and escapes still verbatim
+    #   :char        a character constant, quotes and escapes still verbatim
+    #   :punct       a punctuator (including the pp-only "#" and "##")
+    #   :newline     an end-of-line marker kept so directives stay line-oriented
+    #   :other       any single character matching no other category (6.4p1)
+    #   :eof         the end of the translation unit
+    #
+    # The location fields follow the same 1-based line/column convention as
+    # Front::Token, and point at the token's first character on its physical
+    # line (a token spliced across a line continuation keeps its start line).
+    # `space_before` records whether whitespace or a comment preceded the token,
+    # which the directive layer consults to classify a macro definition.
+    # `suppress` is the token's own set of macro names it must not be re-expanded
+    # as (6.10.3.4, "painted blue"): a frozen list carried along every copy, so
+    # each token remembers the expansions it was already born from.
+    class PPToken
+      # The suppression set of a token that came straight from source and has yet
+      # to pass through any macro; shared so unpainted tokens cost no allocation.
+      NO_SUPPRESS = [].freeze
+
+      attr_reader :type, :text, :filename, :line, :column, :source_line, :space_before, :suppress
+
+      def initialize(type:, text:, filename:, line:, column:, source_line:, space_before: false,
+                     suppress: NO_SUPPRESS)
+        @type = type
+        @text = text
+        @filename = filename
+        @line = line
+        @column = column
+        @source_line = source_line
+        @space_before = space_before
+        @suppress = suppress
+      end
+
+      def newline?
+        @type == :newline
+      end
+
+      def eof?
+        @type == :eof
+      end
+
+      def punct?(str)
+        @type == :punct && @text == str
+      end
+
+      def inspect
+        "#<PPToken #{type} #{text.inspect} @#{line}:#{column}>"
+      end
+    end
+  end
+end