ceedling 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8aabde4baeef95fad89e87cf3bd6226ffa3f10df9e54708270c82f237f3efe49
-  data.tar.gz: '08693e70f80deab8cb70f11677291f368a159df04b35f7a8d9fec8025522063a'
+  metadata.gz: d8c20196572fb2d9730237fb04f7ab5d18869180b185e14649d1212669b1fd3f
+  data.tar.gz: b363d61a395c3a788fbe4566196d2ce6f6c49e5a8b00423f49c4df3fc2e3f2e1
 SHA512:
-  metadata.gz: ab5f32d7896199850b29f6328c9e3fbaea63c0f5bf3dff665434ee0bd488992f971b18afd1bcf194e5c6f2ca66636cd72e38ab26fed3e74904cb374094f9c2b7
-  data.tar.gz: fab7cf5fe911d2dbc24bdb16add93551bfe8d9b7a668b888735ccfe199d04431707d5e01ec2d5ce345ee518db9b8f34376e16b92788ba1780e2ed20b8a32832c
+  metadata.gz: 1c30b50264e5a459a19c0fca20b57fdc1e2e3cc6282b504f5789c2cec47fd9dc11d49cd05c5ecb8e09c47c6e1bb9b7029d74ce7714249abc9e00456ead5d1002
+  data.tar.gz: a83eddeb44b9049e361f94ef0280809f157f304c96631ef75ee7341302a34faed50ed4e616d1744e220dccad496872e0c2282b8f7d5e6c4c1e58c5be28fddf32

data/GIT_COMMIT_SHA

@@ -1 +1 @@
-049a9d7
+e44173e

data/README.md

@@ -1,7 +1,7 @@
 Ceedling ![CI](https://github.com/ThrowTheSwitch/Ceedling/workflows/CI/badge.svg)
 ========
 
-**Ceedling 1.1.3** is the latest and greatest.
+**Ceedling 1.1.4** is the latest and greatest.
 
 See [_Release Notes_][release-notes], [_Changelog_](docs/Changelog.md), 
 [_Breaking Changes_][breaking-changes], and [_Known Issues_][known-issues].

data/assets/fake_crash_test_fixture.rb

@@ -0,0 +1,14 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Deliberately ignores the real test executable path it's given and never runs it --
+# simulates a custom :test_fixture wrapper whose own crash-detection machinery (e.g. a
+# sanitizer's halt_on_error) kills the process before Unity ever gets to print its
+# summary. Exists to reproduce issue #1198 without needing a real sanitizer toolchain:
+# a diagnostic backtrace retry left at its default configuration runs the real
+# executable directly instead, unaffected by this fixture, and legitimately passes.
+exit 1

data/assets/partial_all_module.h

@@ -0,0 +1,11 @@
+#ifndef PARTIAL_ALL_MODULE_H
+#define PARTIAL_ALL_MODULE_H
+
+void PartialAllModule_Init(int value);
+
+static inline int PartialAllModule_DoubleValue(int value)
+{
+  return value * 2;
+}
+
+#endif

data/assets/run_with_ubsan.rb

@@ -0,0 +1,15 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Enables UBSan's halt-on-error, then execs the real test executable in this script's
+# own place rather than as a child process -- this process's PID becomes the test
+# executable's PID, so the real Process::Status Ceedling observes is the test
+# executable's own. Regression fixture for issue #1198: a diagnostic backtrace retry
+# runs through a separate, unwrapped default tool that never sees this setting, so it
+# can legitimately recover from the same undefined behavior instead of halting on it.
+ENV['UBSAN_OPTIONS'] = 'halt_on_error=1'
+exec(*ARGV)

data/assets/same_dir_pairing_module.c

@@ -0,0 +1,4 @@
+#include "same_dir_pairing_module_func.h"
+
+void SameDirPairingModuleInit(void) {
+}

data/assets/same_dir_pairing_module.h

@@ -0,0 +1,8 @@
+#ifndef SAME_DIR_PAIRING_MODULE_H
+#define SAME_DIR_PAIRING_MODULE_H
+
+typedef struct {
+  int value;
+} same_dir_pairing_module_t;
+
+#endif

data/assets/same_dir_pairing_module_func.h

@@ -0,0 +1,6 @@
+#ifndef SAME_DIR_PAIRING_MODULE_FUNC_H
+#define SAME_DIR_PAIRING_MODULE_FUNC_H
+
+void SameDirPairingModuleInit(void);
+
+#endif

data/assets/same_dir_pairing_other.c

@@ -0,0 +1,4 @@
+#include "same_dir_pairing_other.h"
+
+void SameDirPairingOtherThing(void) {
+}

data/assets/same_dir_pairing_other.h

@@ -0,0 +1,8 @@
+#ifndef SAME_DIR_PAIRING_OTHER_H
+#define SAME_DIR_PAIRING_OTHER_H
+
+#include "same_dir_pairing_module.h"
+
+void SameDirPairingOtherThing(void);
+
+#endif

data/assets/test_example_file_ub_shift_overflow.c

@@ -0,0 +1,22 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
+#include <stdint.h>
+
+#include "unity.h"
+
+void setUp(void) {}
+void tearDown(void) {}
+
+/* Left-shifting a value past its type's bit width is undefined behavior --
+   UBSan's -fsanitize=undefined flags it at runtime without a real crash
+   occurring at the OS level. */
+void test_shift_overflow(void) {
+  volatile uint8_t value = 128;
+  volatile uint32_t result = value << 24;
+  (void)result;
+}

data/assets/test_partial_all_module.c

@@ -0,0 +1,16 @@
+#include "unity.h"
+#include "ceedling.h"
+
+#include MOCK_PARTIAL_ALL_MODULE(partial_all_module)
+
+void setUp(void) {}
+void tearDown(void) {}
+
+void test_all_module_should_mock_both_a_plain_prototype_and_a_static_inline_function(void)
+{
+  PartialAllModule_Init_Expect(3);
+  PartialAllModule_Init(3);
+
+  PartialAllModule_DoubleValue_ExpectAndReturn(3, 6);
+  TEST_ASSERT_EQUAL_INT(6, PartialAllModule_DoubleValue(3));
+}

data/assets/test_same_dir_pairing.c

@@ -0,0 +1,23 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
+// `same_dir_pairing_other.h` transitively includes `same_dir_pairing_module.h` (types
+// only), which shares a filename stem with `same_dir_pairing_module.c` -- the same
+// source file that implements the differently-named header mocked below. Auto
+// source-pairing must not pull that real source file into this build alongside its mock.
+
+#include "unity.h"
+#include "mock_same_dir_pairing_module_func.h"
+#include "same_dir_pairing_other.h"
+
+void setUp(void) {}
+void tearDown(void) {}
+
+void test_SameDirPairingOtherThing_should_not_explode(void) {
+  SameDirPairingOtherThing();
+  TEST_PASS();
+}

data/docs/Changelog.md

@@ -1,4 +1,4 @@
-# 🌱 Ceedling Changelog
+p# 🌱 Ceedling Changelog
 
 This format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
@@ -10,6 +10,24 @@ This changelog is complemented by three other documents:
 
 ---
 
+# [1.1.4] — 2026-08-13
+
+## 💪 Fixed
+
+- [#1198](https://github.com/ThrowTheSwitch/Ceedling/issues/1198) Fixed a crash that could go unnoticed. If a test crashed but `:use_backtrace`'s diagnostic retry ran cleanly instead of reproducing the crash, Ceedling trusted that clean retry over the real crash and reported the test as passing, with a successful exit code.
+- [#1197](https://github.com/ThrowTheSwitch/Ceedling/issues/1197) Fixed edge case of includes extraction where header files in the same directory as a file being preprocessed were erroneously discovered as depth 0 `#include`s in the preprocessed file. The cause is a quirk of GCC search path defaults. The impact was greatest on certain test file organizations.
+
+### Partials
+
+- [#1203](https://github.com/ThrowTheSwitch/Ceedling/issues/1203) Fixed `MOCK_PARTIAL_ALL_MODULE()` (and `MOCK_PARTIAL_PUBLIC_MODULE()`/`MOCK_PARTIAL_PRIVATE_MODULE()`) silently omitting a function from the mock interface in certain cases where no function body could be found in the module.
+- [#1189](https://github.com/ThrowTheSwitch/Ceedling/issues/1189)/[#1187](https://github.com/ThrowTheSwitch/Ceedling/issues/1187) Fixed `const`/`volatile`/`restrict` qualifiers stripped from a Partial's generated `extern` declaration and definition for a promoted variable.
+- Fixed C variable extraction discarding a pointer's own qualifier (e.g. the second `const` in `const uint8_t* const ptr;`) whenever the same qualifier keyword also led the declaration.
+- [#1190](https://github.com/ThrowTheSwitch/Ceedling/issues/1190)/[#1187](https://github.com/ThrowTheSwitch/Ceedling/issues/1187) Fixed a module's typedefs and aggregate (struct/enum/union) definitions being generated into both its Test Partial and Mock Partial headers, causing a redefinition error when a test file uses both for the same module. Such content is now generated once into a shared header with unique include guard that both Partial headers, in turn, include.
+- [#1188](https://github.com/ThrowTheSwitch/Ceedling/issues/1188)/[#1187](https://github.com/ThrowTheSwitch/Ceedling/issues/1187) Fixed a long C declaration silently vanishing from a Partial (and everything textually after it in the same file) once it exceeded an internal, fixed sized buffer length. Refactored to rely on a different dynamically resized buffer with a configurable size ceiling (new `:partials` ↳ `:max_extraction_length`). C feature extraction now raises a clear error if the limit is exceeded.
+- [#1194](https://github.com/ThrowTheSwitch/Ceedling/issues/1194) Fixed generated Partials stripping directory components from system include directives (e.g. `<sys/stat.h>` becoming `<stat.h>`).
+
+---
+
 # [1.1.3] — 2026-08-06
 
 ## 💪 Fixed
@@ -18,6 +36,8 @@ This changelog is complemented by three other documents:
 - Ensure compilation symbols needed for Partials are injected when `:preprocess` defines are configured.
 - Fixed use of Thor’s Actions#directory to ensure a single options hash.
 
+---
+
 # [1.1.2] — 2026-07-27
 
 ## 💪 Fixed

data/docs/mkdocs/configuration/reference/index.md

@@ -26,6 +26,13 @@ All top-level keys of the Ceedling project configuration file, each on its own p
 
     Assembly file support for test suite builds.
 
+-   :material-book-open-variant: **[`:partials` — Partials Settings][ref-partials]**
+
+    ---
+
+    Bound how large a single C construct may grow during extraction before
+    Partial generation fails outright rather than searching indefinitely.
+
 -   :material-book-open-variant: **[`:release_build` — Release Build Settings][ref-release-build]**
 
     ---
@@ -150,6 +157,7 @@ All top-level keys of the Ceedling project configuration file, each on its own p
 [ref-project]:       project.md
 [ref-mixins]:        mixins.md
 [ref-test-build]:    test-build.md
+[ref-partials]:      partials.md
 [ref-release-build]: release-build.md
 [ref-paths]:         paths.md
 [ref-files]:         files.md

data/docs/mkdocs/configuration/reference/partials.md

@@ -0,0 +1,38 @@
+# `:partials`
+
+**Configuring C feature extraction for Partials**
+
+## Example `:partials` YAML
+
+```yaml
+:partials:
+  # Ceiling of 1000 character blocks for buffer growth
+  # 8000 = a max buffer growth to 8,000,000 characters
+  :max_extraction_length: 8000
+```
+
+## `:max_extraction_length`
+
+Notes:
+- The default should be sufficient for nearly all test builds. Modification should only be necessary on error.
+- This configuration option is only available in Ceedling 1.1.4+.
+
+Building a Partial requires Ceedling to extract each C construct — a
+variable declaration, a function, a macro, and so on — from your source
+files one at a time. Extraction reads a construct into a growing buffer
+until it finds that construct's natural end (a terminating `;`, a closing
+`}`, etc.). This setting bounds how large that buffer may grow before
+extraction fails outright, rather than continuing to search indefinitely
+into whatever else follows in the file.
+
+The value is a multiplier of 1000 characters, not a raw character count —
+`8000` means 8,000,000 characters. It must be a whole number no smaller
+than `10` (10,000 characters).
+
+Raise this value if Ceedling reports an extraction failure for a
+legitimately large single construct in your codebase — a sizable generated
+lookup table, for instance. There's ordinarily no reason to lower it.
+
+**Default**: 5000 (5,000,000 characters)
+
+<br/><br/>

data/examples/wondrous_forest/src/LightSensor.c

@@ -9,8 +9,9 @@
 #include "LightSensor.h"
 #include "SensorHal.h"
 
-static uint32 s_lux_value;
-static uint32 s_nighttime_threshold_lux;
+static uint32       s_lux_value;
+static uint32       s_nighttime_threshold_lux;
+static LightLevel_t s_light_level;
 
 /* Full-scale 4095 counts = 100 000 lux. */
 PRIVATE uint32 LightSensor__ConvertRawToLux(uint16 raw_counts)
@@ -23,10 +24,20 @@ PRIVATE_INLINE bool LightSensor__IsNighttime(uint32 lux)
     return lux < s_nighttime_threshold_lux;
 }
 
+/* Three-way classification of a lux reading, coarser than the raw value itself
+ * and handy for display or logging without exposing the underlying threshold math. */
+PRIVATE LightLevel_t LightSensor__ClassifyLux(uint32 lux)
+{
+    if (lux < 50u)   { return LIGHT_LEVEL_DARK; }
+    if (lux < 5000u) { return LIGHT_LEVEL_DIM; }
+    return LIGHT_LEVEL_BRIGHT;
+}
+
 void LightSensor_Init(uint32 nighttime_threshold_lux)
 {
     s_lux_value               = 0u;
     s_nighttime_threshold_lux = nighttime_threshold_lux;
+    s_light_level             = LIGHT_LEVEL_DARK;
     SensorHal_StartConversion(SENSOR_CHANNEL_LIGHT);
 }
 
@@ -34,8 +45,9 @@ bool LightSensor_Sample(void)
 {
     if (!SensorHal_IsChannelReady(SENSOR_CHANNEL_LIGHT)) { return false; }
 
-    uint16 raw  = SensorHal_ReadChannel(SENSOR_CHANNEL_LIGHT);
-    s_lux_value = LightSensor__ConvertRawToLux(raw);
+    uint16 raw    = SensorHal_ReadChannel(SENSOR_CHANNEL_LIGHT);
+    s_lux_value   = LightSensor__ConvertRawToLux(raw);
+    s_light_level = LightSensor__ClassifyLux(s_lux_value);
     SensorHal_StartConversion(SENSOR_CHANNEL_LIGHT);
     return true;
 }
@@ -49,3 +61,8 @@ bool LightSensor_IsNighttime(void)
 {
     return LightSensor__IsNighttime(s_lux_value);
 }
+
+LightLevel_t LightSensor_GetLightLevel(void)
+{
+    return s_light_level;
+}

data/examples/wondrous_forest/src/LightSensor.h

@@ -10,9 +10,17 @@
 
 #include "Types.h"
 
-void   LightSensor_Init(uint32 nighttime_threshold_lux);
-bool   LightSensor_Sample(void);
-uint32 LightSensor_GetLux(void);
-bool   LightSensor_IsNighttime(void);
+typedef enum
+{
+    LIGHT_LEVEL_DARK   = 0,
+    LIGHT_LEVEL_DIM    = 1,
+    LIGHT_LEVEL_BRIGHT = 2
+} LightLevel_t;
+
+void         LightSensor_Init(uint32 nighttime_threshold_lux);
+bool         LightSensor_Sample(void);
+uint32       LightSensor_GetLux(void);
+bool         LightSensor_IsNighttime(void);
+LightLevel_t LightSensor_GetLightLevel(void);
 
 #endif /* LIGHT_SENSOR_H */

data/examples/wondrous_forest/test/TestLightSensor.c

@@ -6,10 +6,13 @@
 ========================================================================= */
 
 /* Partials pattern: TEST_PARTIAL_PUBLIC_MODULE + MOCK_PARTIAL_PRIVATE_MODULE
- * Tests the public interface (LightSensor_Sample, GetLux, IsNighttime)
- * while mocking the private helpers LightSensor__ConvertRawToLux() and
- * LightSensor__IsNighttime(). SensorHal is mocked traditionally.
- * This demonstrates testing public behavior while isolating private logic. */
+ * Tests the public interface (LightSensor_Sample, GetLux, IsNighttime,
+ * GetLightLevel) while mocking the private helpers LightSensor__ConvertRawToLux(),
+ * LightSensor__IsNighttime(), and LightSensor__ClassifyLux(). SensorHal is mocked
+ * traditionally. This demonstrates testing public behavior while isolating private
+ * logic. LightSensor.h's LightLevel_t enum is needed by both a tested public
+ * function's return type and a mocked private function's return type, so this
+ * module also exercises a type shared between the generated test and mock headers. */
 
 #include "unity.h"
 #include "ceedling.h"
@@ -48,6 +51,7 @@ void test_Sample_CallsConvertHelperAndStoresResult(void)
     SensorHal_IsChannelReady_ExpectAndReturn(SENSOR_CHANNEL_LIGHT, true);
     SensorHal_ReadChannel_ExpectAndReturn(SENSOR_CHANNEL_LIGHT, 2000u);
     LightSensor__ConvertRawToLux_ExpectAndReturn(2000u, 48840u);
+    LightSensor__ClassifyLux_ExpectAndReturn(48840u, LIGHT_LEVEL_BRIGHT);
     SensorHal_StartConversion_Expect(SENSOR_CHANNEL_LIGHT);
 
     TEST_ASSERT_TRUE(LightSensor_Sample());
@@ -59,6 +63,7 @@ void test_IsNighttime_ReturnsTrueWhenPrivateHelperReturnsTrue(void)
     SensorHal_IsChannelReady_ExpectAndReturn(SENSOR_CHANNEL_LIGHT, true);
     SensorHal_ReadChannel_ExpectAndReturn(SENSOR_CHANNEL_LIGHT, 10u);
     LightSensor__ConvertRawToLux_ExpectAndReturn(10u, 244u);
+    LightSensor__ClassifyLux_ExpectAndReturn(244u, LIGHT_LEVEL_DIM);
     SensorHal_StartConversion_Expect(SENSOR_CHANNEL_LIGHT);
     LightSensor_Sample();
 
@@ -71,9 +76,34 @@ void test_IsNighttime_ReturnsFalseWhenPrivateHelperReturnsFalse(void)
     SensorHal_IsChannelReady_ExpectAndReturn(SENSOR_CHANNEL_LIGHT, true);
     SensorHal_ReadChannel_ExpectAndReturn(SENSOR_CHANNEL_LIGHT, 3000u);
     LightSensor__ConvertRawToLux_ExpectAndReturn(3000u, 73260u);
+    LightSensor__ClassifyLux_ExpectAndReturn(73260u, LIGHT_LEVEL_BRIGHT);
     SensorHal_StartConversion_Expect(SENSOR_CHANNEL_LIGHT);
     LightSensor_Sample();
 
     LightSensor__IsNighttime_ExpectAndReturn(73260u, false);
     TEST_ASSERT_FALSE(LightSensor_IsNighttime());
 }
+
+void test_Sample_ClassifiesLuxAsDark(void)
+{
+    SensorHal_IsChannelReady_ExpectAndReturn(SENSOR_CHANNEL_LIGHT, true);
+    SensorHal_ReadChannel_ExpectAndReturn(SENSOR_CHANNEL_LIGHT, 1u);
+    LightSensor__ConvertRawToLux_ExpectAndReturn(1u, 20u);
+    LightSensor__ClassifyLux_ExpectAndReturn(20u, LIGHT_LEVEL_DARK);
+    SensorHal_StartConversion_Expect(SENSOR_CHANNEL_LIGHT);
+
+    TEST_ASSERT_TRUE(LightSensor_Sample());
+    TEST_ASSERT_EQUAL(LIGHT_LEVEL_DARK, LightSensor_GetLightLevel());
+}
+
+void test_Sample_ClassifiesLuxAsBright(void)
+{
+    SensorHal_IsChannelReady_ExpectAndReturn(SENSOR_CHANNEL_LIGHT, true);
+    SensorHal_ReadChannel_ExpectAndReturn(SENSOR_CHANNEL_LIGHT, 4000u);
+    LightSensor__ConvertRawToLux_ExpectAndReturn(4000u, 97680u);
+    LightSensor__ClassifyLux_ExpectAndReturn(97680u, LIGHT_LEVEL_BRIGHT);
+    SensorHal_StartConversion_Expect(SENSOR_CHANNEL_LIGHT);
+
+    TEST_ASSERT_TRUE(LightSensor_Sample());
+    TEST_ASSERT_EQUAL(LIGHT_LEVEL_BRIGHT, LightSensor_GetLightLevel());
+}

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
+  constructor :c_extractor_code_text, :c_extractor_functions, :c_extractor_declarations, :c_extractor_preprocessing, :c_extractor_definitions, :configurator, :loginator
 
   attr_writer :chunk_size, :max_buffer_length
 
@@ -31,7 +31,7 @@ class CExtractor
     @definitions   = @c_extractor_definitions
 
     @chunk_size        = DEFAULT_CHUNK_SIZE
-    @max_buffer_length = DEFAULT_MAX_FUNCTION_LENGTH
+    @max_buffer_length = default_max_buffer_length
   end
 
   # Extract C module contents from a source file on disk.
@@ -58,26 +58,36 @@ class CExtractor
   # Parameters:
   #   content:           String containing C source code to extract from
   #   chunk_size:        (Optional) Size of chunks to read at a time (default: 16 KB)
-  #   max_buffer_length: (Optional) Maximum allowed function size (default: 5 MB)
-  #   max_line_length:   (Optional) Maximum allowed line length (default: 1000 chars)
+  #   max_buffer_length: (Optional) Maximum allowed feature size in characters. Defaults to
+  #                      whatever setup() already established (project configuration if
+  #                      available, otherwise the built-in default) rather than a literal
+  #                      value here, so an explicit-override-free call doesn't clobber that.
   #
   # Returns: CModule struct containing all features extracted.
   def from_string(
     content:,
     chunk_size:        DEFAULT_CHUNK_SIZE,
-    max_buffer_length: DEFAULT_MAX_FUNCTION_LENGTH,
-    max_line_length:   DEFAULT_MAX_LINE_LENGTH
+    max_buffer_length: nil
   )
     @chunk_size        = chunk_size
-    @max_buffer_length = max_buffer_length
-    @functions.max_line_length    = max_line_length
-    @declarations.max_line_length = max_line_length
+    @max_buffer_length = max_buffer_length unless max_buffer_length.nil?
 
     return extract_contents( StringIO.new( content ), nil )
   end
 
   private
 
+  # `:configurator` is absent for direct/test construction of this class (only Ceedling's
+  # DI container supplies it in production), so this falls back to the built-in default in
+  # that case rather than requiring every caller to know about project configuration.
+  # The configured value is a small integer multiplier of 1000 characters (project-file
+  # ergonomics -- `5000` reads more clearly than `5000000`), so it's scaled up here to the
+  # actual character count this class works in internally.
+  def default_max_buffer_length()
+    return DEFAULT_MAX_FUNCTION_LENGTH unless @configurator.respond_to?(:partials_max_extraction_length)
+    return @configurator.partials_max_extraction_length * 1000
+  end
+
   # Extracts all C code features from the given IO source.
   #
   # Parameters:
@@ -276,9 +286,25 @@ class CExtractor
       # Expand the buffer with the new chunk
       buffer << chunk
 
-      # Safety check -- don't let buffer grow indefinitely
+      # Safety check -- don't let buffer grow indefinitely. This is the single ceiling for every
+      # feature type (directives, typedefs, functions, variable declarations, etc.) -- individual
+      # extractors don't enforce their own separate, smaller limits, since any of them scanning
+      # to the end of an ever-growing buffer without finding a terminator is exactly this same
+      # condition and belongs to this one check.
+      #
+      # Which of the several extractors tried at this file position is active when this fires
+      # isn't reported: extract_contents tries each one in a fixed order at every position, and
+      # an extractor that rejects content outright (e.g. text not starting with '#' for a
+      # directive) rejects it the same way regardless of how much more the buffer grows, so the
+      # first extractor in that fixed order is always the one still running when the buffer
+      # finally crosses this ceiling -- naming it here would misattribute the failure to it
+      # rather than to whatever construct actually caused the overrun.
       if buffer.length > max_length
-        raise CeedlingException.new("Feature extraction exceeded maximum length of #{max_length} characters")
+        @loginator.log(
+          "Extraction starting at file position #{chunk_start_pos} exceeded maximum length of #{max_length} characters",
+          Verbosity::DEBUG
+        ) if @loginator
+        raise CeedlingException.new("Extraction exceeded maximum length of #{max_length} characters, starting at file position #{chunk_start_pos}")
       end
 
       # Create a new scanner for the current buffer

data/lib/ceedling/c_extractor/c_extractor_constants.rb

@@ -6,9 +6,6 @@
 # =========================================================================
 
 module CExtractorConstants
-  # 1000 character safety limit
-  DEFAULT_MAX_LINE_LENGTH = 1000
-
   # 16 KB -- enough for most functions
   DEFAULT_CHUNK_SIZE = (16 * 1024)
 

data/lib/ceedling/c_extractor/c_extractor_declarations.rb

@@ -16,12 +16,9 @@ class CExtractorDeclarations
 
   constructor :c_extractor_code_text
 
-  attr_writer :max_line_length
-
   def setup()
     # Aliases
-    @code_text       = @c_extractor_code_text
-    @max_line_length = DEFAULT_MAX_LINE_LENGTH
+    @code_text = @c_extractor_code_text
   end
 
   # Attempts to extract a complete variable declaration from the scanner
@@ -58,11 +55,14 @@ class CExtractorDeclarations
   #   On failure: Resets scanner position to starting position
   #
   # Safety:
-  #   Enforces max_line_length limit to prevent infinite loops on malformed input
+  #   A declaration with no terminating semicolon runs the scan to the end of
+  #   whatever buffer the caller (CExtractor#extract_next_feature) has grown so
+  #   far; that caller is the one place enforcing an overall length ceiling,
+  #   since only it knows how much more of the file remains to try growing into.
   def try_extract_variable(scanner)
     start_pos = scanner.pos
 
-    # Tracks paren, bracket, and brace depth simultaneously with inline string state machine and max_line_length guard — not suitable for collect_balanced()
+    # Tracks paren, bracket, and brace depth simultaneously with an inline string state machine — not suitable for collect_balanced()
     paren_depth = 0
     bracket_depth = 0
     brace_depth = 0
@@ -74,12 +74,6 @@ class CExtractorDeclarations
     until scanner.eos?
       char = scanner.peek(1)
 
-      # Safety check -- prevent infinite loops on malformed input
-      if (scanner.pos - start_pos) > @max_line_length
-        scanner.pos = start_pos
-        return [false, nil]
-      end
-
       # Handle string literals
       if in_string
         if char == '\\'
@@ -302,8 +296,8 @@ class CExtractorDeclarations
   #
   # Returns: CVariableDeclaration
   def parse_declaration(individual_text, original_text)
-    decorators      = extract_decorators(individual_text)
-    clean_text      = strip_decorators(individual_text, decorators)
+    decorators, remaining = extract_decorators(individual_text)
+    clean_text      = normalize_declaration_whitespace(remaining)
     # Strip compiler extensions for name/type/array_suffix extraction only;
     # clean_text (stored as .text) retains attributes for correct compilation.
     extraction_text = @code_text.strip_compiler_extensions(clean_text)
@@ -321,9 +315,17 @@ class CExtractorDeclarations
     )
   end
 
-  # Scan leading whole-word tokens against DECORATOR_KEYWORDS
+  # Storage-class specifiers and base-type qualifiers precede a C declaration's type as a
+  # contiguous run of keywords -- `static`, `extern`, and a `const`/`volatile` that qualifies
+  # the type itself all appear here (e.g. `static const int MAX;`). A qualifier bound to a
+  # pointer level instead, such as the second `const` in `char * const p;`, sits after the
+  # type and its `*` tokens rather than in this leading run, so it is grammatically part of
+  # the declarator, not a decorator. Peeling keywords off one at a time from the front, and
+  # stopping at the first non-keyword token, naturally separates the two: the same keyword
+  # (e.g. `const`) can appear once here and again later in the declarator without the two
+  # occurrences being confused with each other, since only the leading run is ever consumed.
   #
-  # Returns: Array<String> ordered decorator keywords found at start of text
+  # Returns: [Array<String> ordered decorator keywords found at start of text, String remaining text after that run]
   def extract_decorators(text)
     decorators = []
     remaining = text.strip
@@ -339,18 +341,17 @@ class CExtractorDeclarations
       end
       break unless matched
     end
-    decorators
+    [decorators, remaining]
   end
 
-  # Remove decorator keywords from text and normalize whitespace
+  # A declaration with its leading decorator run already removed (see extract_decorators)
+  # still carries whatever whitespace and line breaks appeared in the source between its
+  # remaining tokens. This collapses that whitespace to single spaces and guarantees a
+  # trailing semicolon, so `.text` is stable, single-line C ready to compile.
   #
-  # Returns: String with decorators removed, whitespace normalized, semicolon retained
-  def strip_decorators(text, decorators)
-    result = text.dup
-    decorators.each do |kw|
-      result.gsub!(/\b#{Regexp.escape(kw)}\b\s*/, '')
-    end
-    # Normalize whitespace but preserve semicolon
+  # Returns: String with whitespace normalized, semicolon retained
+  def normalize_declaration_whitespace(remaining)
+    result = remaining.dup
     result.gsub!(/\r\n|\r|\n|\t/, ' ')
     result.gsub!(/\s+/, ' ')
     result.strip!