ceedling 1.1.10 → 1.2.0

data/examples/wondrous_forest/test/TestCalibration.c

@@ -0,0 +1,39 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
+/* Partials pattern: TEST_PARTIAL_PRIVATE_MODULE_AT
+ * Two sensors each carry their own Calibration module, so the module name alone
+ * names two files. Each directive adds the directory that tells them apart, and
+ * each Partial carries only its own module's private clamp. */
+
+#include "unity.h"
+#include "ceedling.h"
+
+#include TEST_PARTIAL_PRIVATE_MODULE_AT(sensors/soil, Calibration)
+#include TEST_PARTIAL_PRIVATE_MODULE_AT(sensors/light, Calibration)
+
+void setUp(void) {}
+void tearDown(void) {}
+
+/* Each clamp has its own ceiling, so the same input gives each module a
+ * different answer. A Partial built from the wrong module would still compile
+ * and link -- it would simply return the other sensor's value. */
+void test_SoilClampCeilingIsSaturationPercentage(void)
+{
+  TEST_ASSERT_EQUAL_INT(100, Soil__Clamp(150));
+}
+
+void test_LightClampCeilingIsAdcFullScale(void)
+{
+  TEST_ASSERT_EQUAL_INT(150, Light__Clamp(150));
+}
+
+void test_ClampsPassThroughValuesWithinTheirOwnRange(void)
+{
+  TEST_ASSERT_EQUAL_INT(42, Soil__Clamp(42));
+  TEST_ASSERT_EQUAL_INT(42, Light__Clamp(42));
+}

data/lib/ceedling/batchinator.rb

@@ -5,6 +5,16 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
+# Batchinator is Ceedling's one chokepoint for parallel work. Every worker
+# thread the build spins up, for compiling or for running tests, passes
+# through here. Keeping that in one small file makes the parallel handling
+# easy to find and easy to reason about, instead of scattered thread-pool
+# code wherever a build step happens to need parallelism.
+#
+# Actually running things in parallel is handled by the `parallel` gem.
+# Batchinator's job is just the Ceedling-specific parts on top: picking a
+# worker count from project configuration, and reporting timing.
+
 require 'benchmark'
 require 'parallel'
 
@@ -12,12 +22,8 @@ class Batchinator
 
   constructor :configurator, :loginator, :reportinator
 
-  def setup
-    @queue = Queue.new
-  end
-
   # Neaten up a build step with progress message and some scope encapsulation
-  def build_step(msg, heading: true, &block)
+  def build_step(msg, heading: true)
     if heading
       msg = @reportinator.generate_heading( @loginator.decorate( msg, LogLabels::RUN ) )
     else # Progress message
@@ -29,15 +35,42 @@ class Batchinator
     yield # Execute build step block
   end
 
-  # Parallelize work to be done:
-  #  - Enqueue things (thread-safe)
-  #  - Spin up a number of worker threads within constraints of project file config and amount of work
-  #  - Each worker thread consumes one item from queue and runs the block against its details
-  #  - When the queue is empty, the worker threads wind down
+  # Run a block once per item in `things`, spread across worker threads.
+  #
+  # `workload:` picks how many worker threads to use. Compiling and running
+  # tests are configured with independent thread counts (`:project ↳
+  # :compile_threads` and `:project ↳ :test_threads`), since the two
+  # workloads have different performance characteristics and a project may
+  # want to tune them separately. `workload:` says which of the two
+  # settings applies to this call.
+  #
+  # `things:` is whatever collection of work items needs processing. It can
+  # be a plain Array (`job_block` receives one item, e.g. `|object|`) or a
+  # Hash (`job_block` receives a key/value pair, e.g. `|name, testable|`).
+  # Both work through the same `|key, value|` block signature below because
+  # of two ordinary Ruby behaviors, not anything Batchinator does itself:
+  # the `parallel` gem converts any `things` collection to an Array of
+  # items first, and Ruby auto-splats a 2-element Array item (a Hash pair)
+  # into two block parameters. A plain Array item just becomes `key`, with
+  # `value` left `nil`.
+  #
+  # Thread safety is the caller's responsibility, not Batchinator's.
+  # `job_block` runs concurrently on multiple threads. If it reads or
+  # writes anything shared across those calls (a counter, an entry in a
+  # shared results object), that access needs its own synchronization,
+  # typically a `Mutex` the caller owns and passes in via closure. Nothing
+  # about calling `exec` makes shared state safe on its own.
+  #
+  # If `job_block` raises, already-running items keep running to
+  # completion. No new items start once an exception has been seen. Once
+  # every thread is done, the first exception raised is re-raised here, in
+  # the calling thread. This is the `parallel` gem's own default behavior
+  # for thread-based work, not something Batchinator changes.
   def exec(workload:, things:, &job_block)
 
     batch_results = []
     sum_elapsed = 0.0
+    start_times = {}
 
     all_elapsed = Benchmark.realtime do
       # Determine number of worker threads to run
@@ -48,20 +81,46 @@ class Batchinator
       when :test
         workers = @configurator.project_test_threads
       else
-        raise NameError.new("Unrecognized batch workload type: #{workload}")
+        # Explicit ::ArgumentError, not the bare name: this class mixes in
+        # the `constructor` gem's Constructor module, which defines its own
+        # Constructor::ArgumentError ahead of the real one in this class's
+        # ancestor chain. A bare ArgumentError reference here would silently
+        # resolve to that one instead, which expects an Array and not a
+        # String and breaks accordingly.
+        raise ::ArgumentError.new("Unrecognized batch workload type: #{workload}")
       end
 
-      # Perform the actual parallelized work and collect the results and timing
-      batch_results = Parallel.map(things, in_threads: workers) do |key, value| 
-        this_results = ''
-        this_elapsed = Benchmark.realtime { this_results = job_block.call(key, value) }
-        [this_results, this_elapsed]
-      end
-
-      # Separate the elapsed time and results
-      if batch_results.size > 0
-        batch_results, batch_elapsed = batch_results.transpose
-        sum_elapsed = batch_elapsed.sum()
+      if workers <= 1
+        # `parallel`'s in_threads: mode always spawns a real Thread, even for
+        # a pool of size 1 -- pure overhead when there's no concurrency to be
+        # had, and it also hides all of this call's real work from sampling
+        # profilers that (like stackprof's :wall mode) only sample the
+        # calling thread. At workers <= 1 there's never more than one item in
+        # flight, so running things.to_a sequentially in the calling thread
+        # is observably identical to the threaded path: same start:/finish:-
+        # equivalent timing bookkeeping below, same per-item return values in
+        # input order, and the same "no new items start once an exception has
+        # been seen" contract falls out for free (an exception on item N
+        # simply stops the each_with_index loop before item N+1 runs).
+        batch_results = things.to_a.each_with_index.map do |item, index|
+          start_times[index] = Time.now
+          result = yield( item )
+          sum_elapsed += (Time.now - start_times[index])
+          result
+        end
+      else
+        # Perform the actual parallelized work. Per-item timing rides along on
+        # the `parallel` gem's own start:/finish: callbacks instead of wrapping
+        # each job block call in a separate Benchmark.realtime -- the gem calls
+        # these under its own internal mutex, so summing into sum_elapsed here
+        # needs no synchronization of our own. batch_results ends up as the job
+        # block's own per-item return values, nothing wrapped around them.
+        batch_results = Parallel.map(
+          things,
+          in_threads: workers,
+          start:  ->(_item, index) { start_times[index] = Time.now },
+          finish: ->(_item, index, _result) { sum_elapsed += (Time.now - start_times[index]) }
+        ) { |key, value| yield(key, value) }
       end
     end
 

data/lib/ceedling/c_extractor/README.md

@@ -0,0 +1,61 @@
+# The C Extractor
+
+This subsystem turns raw C source text into structured data. It finds every function, variable, type, and directive a file contains. It does this without a real C compiler.
+
+## Where This Leads
+
+Ceedling's Partials feature is the one consumer of this subsystem. Partials pulls selected functions out of a module's real source and header. To do that safely, it needs to know exactly where each function begins and ends. It needs the same precision for variables and type definitions. This subsystem supplies that precision.
+
+## Scanning Text with StringScanner
+
+Most of this subsystem is built on Ruby's `StringScanner`. A reader who has never used `StringScanner` should think of it as a cursor sitting inside a string. The cursor starts at position zero. Each call asks the cursor a question about the text right in front of it, and most calls also move the cursor forward.
+
+The main call is `scan(pattern)`. It tries to match a pattern starting exactly at the cursor. If the pattern matches, the cursor moves past the match and the matched text is returned. If the pattern does not match at that exact spot, nothing happens and the cursor stays put. This is very different from an ordinary regex search, which looks anywhere in a string for a match. `StringScanner` only ever looks right where the cursor already is.
+
+A few other calls round out the toolkit. `check(pattern)` asks whether a pattern would match at the cursor, without moving it. This is a peek. `peek(n)` looks at the next `n` characters without consuming them. `getch` consumes exactly one character and returns it. `skip(pattern)` behaves like `scan`, but throws away the matched text and just reports how many characters it covered.
+
+Together these calls let the c_extractor classes behave like a small hand-written parser. Some of the work happens one character at a time. Some of it happens in regex-sized bites. Both styles share the same cursor, so they compose naturally.
+
+## A Shared Toolkit for Common Maneuvers
+
+`CExtractorCodeText` holds the scanning moves every other class in this subsystem needs. None of these methods own a scanner. Each one is handed a scanner already sitting at the right spot, and each one moves that scanner forward.
+
+The most important method is `collect_balanced`. It is given an open character and a matching close character, such as `{` and `}`. The scanner must already be sitting on the open character. `collect_balanced` walks forward, counting how deep it is inside nested pairs. It stops the moment the count returns to zero, at the matching close character. Along the way it treats anything inside a string or character literal as inert text, so a stray `}` inside a quoted string can never be mistaken for the end of the group. It also replaces any comment it passes through with a single space, so a brace hiding inside a comment cannot confuse the count either. This one method is what lets the subsystem find the true end of a function body, no matter how deeply that body nests loops, conditionals, or braced initializers.
+
+Other methods in this toolkit skip a string or character literal safely, honoring backslash escapes so an escaped quote does not end the literal early. Others skip whitespace and comments, skip runs of stray semicolons, and strip away compiler-specific syntax such as `__attribute__((...))` or `__declspec(...)`. These extensions are stripped because they can otherwise be mistaken for part of a function's parameter list or a variable's declaration.
+
+## Recognizing Functions
+
+`CExtractorFunctions` finds function declarations and function definitions. A declaration is a bare prototype ending in a semicolon. A definition carries a full body in braces.
+
+The extractor walks forward from a candidate starting point, tracking how deep it is inside parentheses. It also watches for a few signs that what it is looking at is not actually a function. A leading `(*name)` pattern signals a function-pointer variable, not a function. A `[` appearing before any `(` signals an array variable. An `=` appearing outside any parentheses signals a variable with an initializer. Once these possibilities are ruled out, the extractor knows it has found a genuine function signature.
+
+For a definition, the extractor calls on `collect_balanced` to pull the complete function body, including every nested brace inside it. For a declaration, it confirms the signature is immediately followed by a semicolon. Either way, the function's name is pulled out with a small regex, and any leading `static` or `inline` keywords are split off separately so a caller can ask about visibility without re-parsing the signature.
+
+## Recognizing Variables
+
+`CExtractorDeclarations` finds variable declarations. This is a harder problem than it first appears, because a single C statement can declare more than one variable at once, as in `int a, b;`.
+
+The extractor tracks three independent counts at the same time: parentheses, square brackets, and braces. Parentheses matter for function-pointer variables. Square brackets matter for arrays. Braces matter for initializer lists, such as `int values[] = {1, 2, 3};`. The extractor only considers the declaration finished when all three counts return to zero at a semicolon.
+
+Once the raw declaration text is captured, it is split at any top-level commas into one record per variable. Each variable's name, base type, array suffix, and any decorating keywords are then pulled out with straightforward regex matching against the now-isolated text.
+
+## Recognizing Types and Directives
+
+`CExtractorDefinitions` finds two kinds of type-level content. The first is a `typedef` statement, tracked from the `typedef` keyword through to its closing semicolon, watching only for balanced braces since a struct or union body can sit inside it. The second is a standalone `struct`, `enum`, or `union` definition, such as `struct Foo { ... };`. This extractor is careful to tell a type definition apart from a variable declared using an inline struct body, such as `struct Foo { ... } var;`. It does this by looking past the closing brace for a semicolon. If a semicolon follows directly, it is a type definition. If a variable name appears instead, the extractor backs off entirely and lets the variable extractor handle it.
+
+`CExtractorPreprocessing` finds preprocessor directives such as `#define`, correctly following a backslash-newline so a directive spanning several physical lines is still read as one logical line. It also finds C11 and C23 `static_assert` statements. Separately, and outside the main scanning loop described below, it offers the ability to find every call to a specific named macro anywhere in a body of text and to parse out that call's arguments. This capability is used directly by Ceedling's Partials feature to read its own configuration macros (documented in `partials/`).
+
+## Assembling One Module's Worth of Content
+
+`CExtractor` is the class other code actually calls. It reads a file, or an in-memory string, and produces one combined result describing everything of interest inside it.
+
+Internally it works through the source from beginning to end. At each position, it tries each of the recognizers described above, in a fixed order: preprocessor directives, typedefs, static assertions, aggregate type definitions, function definitions, function declarations, and finally plain variable declarations. The first recognizer that succeeds wins, and the recognizers are ordered by the uniqueness of the features they extract. This helps ensure that features that could be confused for one another are kept distinct. Scanning for another features resumes at the position immediately following the previous feature. If nothing recognizes the text at a given position, scanning stops there, and whatever has been gathered so far is returned.
+
+Rather than reading an entire file into memory at once, `CExtractor` reads in modest chunks, growing its working buffer only as needed until a recognizer succeeds or the end of the file is reached. This keeps memory use reasonable even for a very large source file. A safety ceiling on how large that buffer is allowed to grow guards against a genuinely malformed or unbounded input.
+
+## What Comes Back
+
+Every extraction produces a `CModule`. A `CModule` groups its findings by kind: function definitions, function declarations, variable declarations, macro definitions, type definitions, and aggregate definitions. Each of these is itself a small data record. A function definition, for instance, carries its name, its signature, its body, the combined text of signature and body together, and the line number where it began in the original source.
+
+A `CModule` also keeps one further list, called its element sequence. This list holds every item found, of every kind, in the exact order they appeared in the source file. The grouped lists are convenient when a caller wants only functions or only variables. The element sequence exists for the times a caller needs to know the true original ordering across every kind of content at once, such as when reconstructing a file that mixes types, functions, and variables together in a meaningful sequence. Two `CModule`s, such as the results of extracting a header and its matching source file, can also be merged into one `CModule`, with the first module's items placed ahead of the second's.

data/lib/ceedling/c_extractor/c_extractor.rb

@@ -18,7 +18,7 @@ class CExtractor
   include CExtractorConstants
   include CExtractorTypes
 
-  constructor :c_extractor_code_text, :c_extractor_functions, :c_extractor_declarations, :c_extractor_preprocessing, :c_extractor_definitions, :configurator, :loginator
+  constructor :c_extractor_code_text, :c_extractor_functions, :c_extractor_declarations, :c_extractor_preprocessing, :c_extractor_definitions, :configurator, :loginator, :file_wrapper
 
   attr_writer :chunk_size, :max_buffer_length
 
@@ -45,7 +45,7 @@ class CExtractor
   #   CeedlingException: If file cannot be opened (permissions, doesn't exist, etc.)
   def from_file(filepath)
     begin
-      File.open(filepath, 'r') do |file|
+      @file_wrapper.open(filepath, 'r') do |file|
         return extract_contents( file, filepath )
       end
     rescue => ex
@@ -105,6 +105,7 @@ class CExtractor
     macro_definitions     = []
     type_definitions      = []
     aggregate_definitions = []
+    macro_invocations     = []
     sequence              = []
     cumulative_newlines   = 0
 
@@ -181,6 +182,35 @@ class CExtractor
         next
       end
 
+      # A bare, top-level, semicolon-less macro invocation (e.g. an x-macro call that
+      # expands to a full function definition once the macro itself is applied) has no
+      # leading '#', no trailing ';', and no trailing '{' -- directives-only
+      # preprocessing never expands it, so it reaches every extractor below as literal,
+      # unexpanded text. Tried here, before the signature-scanning extractors, because
+      # those scan forward for their own terminating '{'/';' with no check that what
+      # they started scanning actually looks like a signature -- given this shape
+      # immediately followed by an unrelated typedef, aggregate, or real function, they
+      # will happily treat that construct's own opening brace as if it belonged to this
+      # invocation, silently discarding the real content it swallows. Catching the
+      # invocation here, before any of that can happen, protects every construct that
+      # can follow it, not only variable declarations (the narrower, original shape).
+      invocation, invocation_start = extract_next_feature(
+        io:         io,
+        max_length: @max_buffer_length,
+        extractor:  @preprocessing.method(:try_extract_bare_macro_invocation)
+      )
+      if invocation
+        # try_extract_bare_macro_invocation already returns a full CStatement (matching
+        # the function extractors' own convention of returning a complete object, not a
+        # bare string for the dispatch loop to wrap) -- only line_num is set here.
+        line_num, cumulative_newlines =
+          _compute_line_info(io, call_start, invocation_start, cumulative_newlines)
+        invocation.line_num = line_num
+        macro_invocations << invocation
+        sequence << invocation
+        next
+      end
+
       # Extract a function definition (most unique non-preprocessor feature)
       func, func_start = extract_next_feature(
         io: io,
@@ -240,6 +270,7 @@ class CExtractor
       macro_definitions:     macro_definitions,
       type_definitions:      type_definitions,
       aggregate_definitions: aggregate_definitions,
+      macro_invocations:     macro_invocations,
       element_sequence:      sequence
     )
   ensure

data/lib/ceedling/c_extractor/c_extractor_code_text.rb

@@ -12,6 +12,22 @@ class CExtractorCodeText
 
   include CExtractorConstants
 
+  # Bare (no-argument-list) keywords strip_compiler_extensions strips verbatim:
+  # MSVC calling conventions, inline hints, and C11 specifier keywords. Built
+  # once into a single alternation regex rather than tried one keyword at a
+  # time, since this check runs at every scanner position -- one shared regex
+  # avoids rebuilding and re-running many small ones on every character
+  # scanned. `\b` on both ends keeps a short keyword from matching as a mere
+  # prefix of a longer identifier that happens to start the same way (e.g.
+  # matching "__cdecl" inside "__cdeclFoo"); listing keywords in any order is
+  # safe even where one prefixes another (__inline vs. __inline__), since a
+  # match that fails its own trailing \b simply falls through to try the next
+  # alternative at that same position.
+  BARE_STRIP_KEYWORDS = (
+    MSVC_CALLING_CONVENTIONS + ['__forceinline', '__inline__', '__inline'] + C11_SPECIFIER_KEYWORDS
+  ).freeze unless const_defined?(:BARE_STRIP_KEYWORDS, false)
+  BARE_STRIP_REGEX = /\b(?:#{BARE_STRIP_KEYWORDS.map { |kw| Regexp.escape(kw) }.join('|')})\b/.freeze unless const_defined?(:BARE_STRIP_REGEX, false)
+
   # Collect the full text of a balanced delimiter pair starting AT open_char.
   # Nested pairs, string literals (verbatim), and comments (replaced with a
   # single space) are handled correctly.
@@ -242,10 +258,6 @@ class CExtractorCodeText
     scanner = StringScanner.new(text)
     result  = +""
 
-    bare_strip = MSVC_CALLING_CONVENTIONS +
-                 ['__forceinline', '__inline__', '__inline'] +
-                 C11_SPECIFIER_KEYWORDS
-
     until scanner.eos?
       # __word__(…) — any double-underscore attribute form including __attribute__((…))
       if scanner.check(/__\w+__\s*\(/)
@@ -264,13 +276,9 @@ class CExtractorCodeText
       end
 
       # Whitelisted bare keywords (calling conventions, inline hints, C11 specifiers)
-      stripped = bare_strip.any? do |kw|
-        if scanner.check(/#{Regexp.escape(kw)}\b/)
-          scanner.skip(/#{Regexp.escape(kw)}/)
-          true
-        end
+      if scanner.scan(BARE_STRIP_REGEX)
+        next
       end
-      next if stripped
 
       result << scanner.getch
     end

data/lib/ceedling/c_extractor/c_extractor_constants.rb

@@ -7,29 +7,29 @@
 
 module CExtractorConstants
   # 16 KB -- enough for most functions
-  DEFAULT_CHUNK_SIZE = (16 * 1024)
+  DEFAULT_CHUNK_SIZE = (16 * 1024) unless const_defined?(:DEFAULT_CHUNK_SIZE, false)
 
   # 5 MB mega-length safety limit
-  DEFAULT_MAX_FUNCTION_LENGTH = (5 * 1024 * 1024)
+  DEFAULT_MAX_FUNCTION_LENGTH = (5 * 1024 * 1024) unless const_defined?(:DEFAULT_MAX_FUNCTION_LENGTH, false)
 
   # C function decorators that indicate private (file-local) visibility
-  PRIVATE_KEYWORDS = ['static', 'inline', '__inline', '__inline__', '__forceinline'].freeze
+  PRIVATE_KEYWORDS = ['static', 'inline', '__inline', '__inline__', '__forceinline'].freeze unless const_defined?(:PRIVATE_KEYWORDS, false)
 
   # MSVC calling-convention keywords (appear between return type and function name)
-  MSVC_CALLING_CONVENTIONS = ['__cdecl', '__stdcall', '__fastcall', '__thiscall', '__vectorcall'].freeze
+  MSVC_CALLING_CONVENTIONS = ['__cdecl', '__stdcall', '__fastcall', '__thiscall', '__vectorcall'].freeze unless const_defined?(:MSVC_CALLING_CONVENTIONS, false)
 
   # C11/C23 bare specifier keywords (no argument list)
-  C11_SPECIFIER_KEYWORDS = ['_Noreturn', '_Thread_local', '_Atomic', '_Bool', '_Complex', '_Imaginary'].freeze
+  C11_SPECIFIER_KEYWORDS = ['_Noreturn', '_Thread_local', '_Atomic', '_Bool', '_Complex', '_Imaginary'].freeze unless const_defined?(:C11_SPECIFIER_KEYWORDS, false)
 
   # Common type keywords that are part of return type, not decorators
-  TYPE_KEYWORDS = ['unsigned', 'signed', 'long', 'short', 'struct', 'union', 'enum'].freeze
+  TYPE_KEYWORDS = ['unsigned', 'signed', 'long', 'short', 'struct', 'union', 'enum'].freeze unless const_defined?(:TYPE_KEYWORDS, false)
 
   # C type qualifiers
-  TYPE_QUALIFIER_KEYWORDS = ['const', 'volatile', 'restrict'].freeze
+  TYPE_QUALIFIER_KEYWORDS = ['const', 'volatile', 'restrict'].freeze unless const_defined?(:TYPE_QUALIFIER_KEYWORDS, false)
 
   # C function modifier keywords
-  MODIFIER_KEYWORDS = (['extern'] + TYPE_QUALIFIER_KEYWORDS).freeze
+  MODIFIER_KEYWORDS = (['extern'] + TYPE_QUALIFIER_KEYWORDS).freeze unless const_defined?(:MODIFIER_KEYWORDS, false)
 
   # Keywords stripped when producing clean `declaration` / `signature_stripped` fields
-  DECORATOR_KEYWORDS = (PRIVATE_KEYWORDS + TYPE_QUALIFIER_KEYWORDS + ['extern']).freeze
-end
+  DECORATOR_KEYWORDS = (PRIVATE_KEYWORDS + TYPE_QUALIFIER_KEYWORDS + ['extern']).freeze unless const_defined?(:DECORATOR_KEYWORDS, false)
+end

data/lib/ceedling/c_extractor/c_extractor_declarations.rb

@@ -97,18 +97,16 @@ class CExtractorDeclarations
         string_char = char
         scanner.getch
       when '/'
-        # Handle comments
-        if scanner.peek(2) =~ %r{^(/[/*])}
-          if scanner.peek(2) == '//'
-            # Line comment -- skip to end of line
-            scanner.scan_until(/\n/) || scanner.terminate
-          elsif scanner.peek(2) == '/*'
-            # Block comment -- skip to closing */
-            scanner.pos += 2
-            scanner.scan_until(%r{\*/})
-          else
-            scanner.getch
-          end
+        # Handle comments -- peek(2) starting with '/' is only ever exactly '//' or '/*'
+        # when it's a comment opener at all; anything else (a lone '/' or '/' followed by
+        # some other character) falls through to the plain-character else below.
+        if scanner.peek(2) == '//'
+          # Line comment -- skip to end of line
+          scanner.scan_until(/\n/) || scanner.terminate
+        elsif scanner.peek(2) == '/*'
+          # Block comment -- skip to closing */
+          scanner.pos += 2
+          scanner.scan_until(%r{\*/})
         else
           scanner.getch
         end
@@ -163,7 +161,7 @@ class CExtractorDeclarations
           # Can end with: word character, ], ), }, or " (for string initializers)
           # `/m` flag: declaration may span multiple lines (e.g. a multiline brace
           # initializer), so '.' must match embedded newlines too
-          if declaration =~ /\w+.*[\w\]\)\}"']\s*;$/m
+          if declaration.match?(/\w+.*[\w\]\)\}"']\s*;$/m)
             return [true, expand_and_parse(declaration)]
           else
             scanner.pos = start_pos
@@ -383,7 +381,9 @@ class CExtractorDeclarations
   # Returns the complete subscript string (e.g., "[8]", "[M][N]") or "" for scalars.
   def extract_array_suffix(clean_text)
     text = clean_text.sub(/\s*;\s*$/, '').sub(/\s*=.*/, '')
-    return '' if text =~ /\(\s*\*/                       # function pointer -- no array suffix
+    # `match?` leaves $~ alone, which is safe because the line below sets it
+    # with its own match before reading $1.
+    return '' if text.match?(/\(\s*\*/)                    # function pointer -- no array suffix
     text =~ /\w+(\s*(?:\[[^\]]*\])+)\s*$/ ? $1.strip : ''
   end
 

data/lib/ceedling/c_extractor/c_extractor_functions.rb

@@ -37,20 +37,14 @@ class CExtractorFunctions
   def try_extract_function_definition(scanner, filepath)
     start_pos = scanner.pos
 
-    # Look for function signature
+    # Look for function signature. extract_function_signature only ever returns
+    # non-nil for :definition mode by matching the '{' case in its own scan loop, and
+    # that case never consumes the brace -- the scanner is always left positioned
+    # exactly on the real '{' here, so there's no separate deadspace-skip/brace-check
+    # step to perform first.
     signature = extract_function_signature(scanner, :definition)
     return [false, CFunctionDefinition.new] unless signature
-    
-    @code_text.skip_deadspace(scanner)
 
-    unless scanner.peek(1) == '{'
-      return [false, CFunctionDefinition.new(
-        name: extract_function_name(signature),
-        signature: signature,
-        filepath: filepath
-      )]
-    end
-    
     # Extract function body
     success, braced_body = @code_text.extract_balanced_braces(scanner)
     unless success
@@ -159,7 +153,10 @@ class CExtractorFunctions
         string_char = char
         scanner.getch
       when '/'
-        if scanner.peek(2) =~ %r{^(/[/*])}
+        # Hottest comparison in the extractor -- reached for every '/' in the
+        # source. `start_with?` avoids compiling and running a regex here. The
+        # original anchored pattern matched exactly these two character pairs.
+        if scanner.peek(2).start_with?('//', '/*')
           @code_text.skip_comment(scanner)
         else
           scanner.getch
@@ -225,7 +222,7 @@ class CExtractorFunctions
           # Check if this looks like a function declaration
           # Pattern: ends with identifier followed by (...) and semicolon
           # NOT: contains (*identifier) pattern (function pointer variable)
-          if cleaned =~ /\(\s*\*\s*[a-zA-Z_][a-zA-Z0-9_]*\s*\)/
+          if cleaned.match?(/\(\s*\*\s*[a-zA-Z_][a-zA-Z0-9_]*\s*\)/)
             # This is a function pointer variable, not a function declaration
             scanner.pos = start_pos
             return nil

data/lib/ceedling/c_extractor/c_extractor_preprocessing.rb

@@ -5,6 +5,8 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
+require 'ceedling/c_extractor/c_extractor_types'
+
 class CExtractorPreprocessing
 
   # Directive type symbols for use with filter_directive()
@@ -12,6 +14,81 @@ class CExtractorPreprocessing
 
   constructor :c_extractor_code_text
 
+  # Compiler-extension attribute forms (CExtractorCodeText#strip_compiler_extensions'
+  # own `__word__(...)`/`__declspec(...)` shapes) are indistinguishable from a bare
+  # invocation by identifier-plus-parens shape alone -- e.g. `__declspec(dllexport)
+  # void foo(int x) {...}` -- but they're a function signature's own leading
+  # decoration, always followed by more of that same signature, never a construct in
+  # their own right. Excluded in try_extract_bare_macro_invocation below so that method
+  # never steals them out from under the signature-scanning extractors it exists to run
+  # ahead of.
+  COMPILER_EXTENSION_IDENTIFIER = /\A(?:__\w+__|__declspec)\z/
+
+  # A bare, top-level, semicolon-less macro invocation (an x-macro call expanding to a
+  # full function definition once the macro itself is applied) has no leading '#', no
+  # trailing ';', and no trailing '{' -- real compilable C at file/statement scope
+  # never has IDENTIFIER(balanced-args) followed by anything else, so this shape only
+  # exists pre-macro-expansion. A trailing ';' (an ordinary call-as-statement) or '{'
+  # (a real function definition) are both explicitly NOT this shape and are left for
+  # the extractors that already handle those correctly.
+  #
+  # One accepted, pre-existing limitation, not introduced here: a K&R-style old-style
+  # function definition (`foo(a,b)\nint a; int b;\n{...}`) also matches this shape and
+  # would be misclassified -- but it already falls through to the same broken
+  # catch-all this method exists to intercept, so this swaps one already-wrong output
+  # for a different one, for a construct essentially extinct in Ceedling's actual
+  # (modern embedded C) audience. Not worth the real declaration-grammar knowledge
+  # this hand-rolled scanner doesn't have.
+  #
+  # @param scanner [StringScanner] positioned at a potential macro invocation
+  # @return [Array(Boolean, CExtractorTypes::CStatement|nil)]
+  def try_extract_bare_macro_invocation(scanner)
+    start_pos = scanner.pos
+
+    return [false, nil] unless scanner.scan(/[A-Za-z_]\w*/)
+    if scanner.matched.match?(COMPILER_EXTENSION_IDENTIFIER)
+      scanner.pos = start_pos
+      return [false, nil]
+    end
+
+    @c_extractor_code_text.skip_deadspace(scanner)
+    unless scanner.peek(1) == '('
+      scanner.pos = start_pos
+      return [false, nil]
+    end
+
+    success, _args = @c_extractor_code_text.collect_balanced(scanner, '(', ')')
+    unless success
+      scanner.pos = start_pos
+      return [false, nil]
+    end
+
+    # Peek past trailing deadspace without consuming it as part of this element --
+    # only the invocation itself belongs to this element's own text span.
+    after_invocation = scanner.pos
+    @c_extractor_code_text.skip_deadspace(scanner)
+    # A mid-buffer eos? here is ambiguous -- it may only mean this chunk ran out, not
+    # that the real file has ended. Fail (not succeed) so extract_next_feature's own
+    # buffer-growth-and-retry sees more input before this method decides, exactly like
+    # collect_balanced/try_extract_static_assert already do at their own boundaries. A
+    # genuine, whole-file EOF right after the invocation is legitimate and handled the
+    # same way every other feature type's own unterminated-trailing-content case is
+    # (see CExtractor#extract_contents' final break) -- no special-casing needed here.
+    if scanner.eos?
+      scanner.pos = start_pos
+      return [false, nil]
+    end
+    next_char = scanner.peek(1)
+    scanner.pos = after_invocation
+
+    if next_char == ';' || next_char == '{'
+      scanner.pos = start_pos
+      return [false, nil]
+    end
+
+    [true, CExtractorTypes::CStatement.new(text: scanner.string[start_pos...scanner.pos])]
+  end
+
   # Scan `scanner` for calls to any macro in `macro_names` and return them as a
   # flat Array of cleaned strings in order of appearance. Each string is the full
   # macro call with its argument list on a single line, runs of whitespace