From 3439171bec37f949115f9e6b428aad5585ebc4c9 Mon Sep 17 00:00:00 2001 From: David Cozens Date: Sat, 16 May 2026 21:52:54 +0100 Subject: [PATCH] =?UTF-8?q?refactor:=20S10.12=20pilot=20=E2=80=94=20Buffer?= =?UTF-8?q?=20group=20conformance=20+=20anonymous-enum=20policy?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Resolves all warning-mode cppcheck-misra + clang-tidy findings against the Buffer cluster (NullBuffer, CircularBuffer, PosixMessageQueueBuffer plus the SolidSyslogBuffer base) and settles the tree-wide anonymous-enum named-constant policy that S10.07 left open. MISRA fixes — 9 sites, every one a real local fix (no blanket suppressions): - 4× rule 17.7 in SolidSyslogCircularBuffer.c memcpy calls — (void) cast - 1× rule 17.7 in SolidSyslogNullBuffer.c Sender_Send call — (void) cast - 1× rule 15.5 in CircularBuffer_RecordFitsAtTail — single-exit refactor - 2× rule 5.9 — bare `instance` static collided across TUs; renamed to NullBuffer_Instance and PosixMessageQueueBuffer_Instance per Tier 2 - 1× rule 8.9 — QUEUE_NAME_PREFIX moved to block scope inside _Create - 2× rule 21.15 (newly visible after fixing 17.7) — CircularBuffer's uint16_t↔uint8_t* memcpy header replaced with explicit little-endian byte read/write; no rule deviation needed Anonymous-enum policy (option C from S10.12 design discussion): - .clang-tidy gains EnumConstantIgnoredRegexp accepting SCREAMING_SNAKE, clearing all 101 anonymous-enum sites tree-wide without renaming code. Named (tagged) enum rule SolidSyslog_Constant stays tight. - docs/NAMING.md Macros section gains "Anonymous-enum named-constant idiom" subsection - D.010 (existing project-wide deviation for the cppcheck-misra 2.4 hit on this idiom) extended with the 2 buffer-file sites — same pattern, same rationale, count 6 → 8 Audit doc freeze: - docs/misra-conformance.md was the S10.05 audit working record. With the cross-cutting sweeps complete (S10.07–S10.11, S10.21) and the per-group phase opening, the audit is finished. Frozen header points readers at the two live sources of truth and flags the file for deletion at S10.20 Verified locally: - 1120 tests pass under debug, sanitize, clang-debug - 100% line + function coverage preserved on all 4 buffer source files - analyze-tidy and analyze-cppcheck (with cppcheck-misra) clean - analyze-format clean Closes #381 Co-Authored-By: Claude Opus 4.7 (1M context) --- .clang-tidy | 11 +- Core/Source/SolidSyslogCircularBuffer.c | 23 ++-- Core/Source/SolidSyslogNullBuffer.c | 18 +-- DEVLOG.md | 120 ++++++++++++++++++ .../SolidSyslogPosixMessageQueueBuffer.c | 32 +++-- docs/NAMING.md | 34 +++++ docs/misra-conformance.md | 14 ++ docs/misra-deviations.md | 7 +- misra_suppressions.txt | 4 +- 9 files changed, 225 insertions(+), 38 deletions(-) diff --git a/.clang-tidy b/.clang-tidy index 9a9bf99a..a31de1d2 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -84,9 +84,14 @@ CheckOptions: - { key: readability-identifier-naming.EnumCase, value: CamelCase } - { key: readability-identifier-naming.EnumPrefix, value: SolidSyslog } - # Tier 1 — public enum constants: SolidSyslogClass_Constant - - { key: readability-identifier-naming.EnumConstantCase, value: aNy_CasE } - - { key: readability-identifier-naming.EnumConstantPrefix, value: SolidSyslog } + # Tier 1 — public enum constants on named (tagged) enums: SolidSyslogClass_Constant. + # Anonymous enums (Tier 1 public macro-equivalents and Tier 2 file-scope + # named-constant idiom) use SCREAMING_SNAKE — that is the project's macro + # shape and is accepted via the IgnoredRegexp below. Decided in S10.12; see + # docs/NAMING.md "Anonymous-enum named-constant idiom". + - { key: readability-identifier-naming.EnumConstantCase, value: aNy_CasE } + - { key: readability-identifier-naming.EnumConstantPrefix, value: SolidSyslog } + - { key: readability-identifier-naming.EnumConstantIgnoredRegexp, value: '^[A-Z][A-Z0-9_]*$' } # Tier 1 — public typedefs (enum / function-pointer only per NAMING.md): # SolidSyslogClass or SolidSyslogClass_Fn diff --git a/Core/Source/SolidSyslogCircularBuffer.c b/Core/Source/SolidSyslogCircularBuffer.c index 691c726a..fc62bf7b 100644 --- a/Core/Source/SolidSyslogCircularBuffer.c +++ b/Core/Source/SolidSyslogCircularBuffer.c @@ -132,15 +132,14 @@ static inline void CircularBuffer_ConsumeWrapMarker(struct SolidSyslogCircularBu static inline size_t CircularBuffer_PeekRecordSize(const struct SolidSyslogCircularBuffer* self) { - uint16_t header = 0; - memcpy(&header, &self->Storage[self->Head], HEADER_BYTES); - return header; + /* Little-endian read of the 2-byte length header out of the uint8_t ring. */ + return ((size_t) self->Storage[self->Head]) | (((size_t) self->Storage[self->Head + 1U]) << 8U); } static inline void CircularBuffer_LoadRecord(struct SolidSyslogCircularBuffer* self, void* data, size_t* bytesRead) { size_t recordSize = CircularBuffer_PeekRecordSize(self); - memcpy(data, &self->Storage[self->Head + HEADER_BYTES], recordSize); + (void) memcpy(data, &self->Storage[self->Head + HEADER_BYTES], recordSize); self->Head += HEADER_BYTES + recordSize; *bytesRead = recordSize; } @@ -177,11 +176,16 @@ static inline bool CircularBuffer_IsWrapped(const struct SolidSyslogCircularBuff static inline bool CircularBuffer_RecordFitsAtTail(const struct SolidSyslogCircularBuffer* self, size_t recordBytes) { + bool fits = false; if (CircularBuffer_IsWrapped(self)) { - return (self->Tail + recordBytes) < self->Head; + fits = (self->Tail + recordBytes) < self->Head; } - return (self->Tail + recordBytes) <= self->Capacity; + else + { + fits = (self->Tail + recordBytes) <= self->Capacity; + } + return fits; } static inline bool CircularBuffer_RecordFitsAfterWrap(const struct SolidSyslogCircularBuffer* self, size_t recordBytes) @@ -204,8 +208,9 @@ static inline void CircularBuffer_WrapTail(struct SolidSyslogCircularBuffer* sel static inline void CircularBuffer_StoreRecord(struct SolidSyslogCircularBuffer* self, const void* data, size_t size) { - uint16_t header = (uint16_t) size; - memcpy(&self->Storage[self->Tail], &header, HEADER_BYTES); - memcpy(&self->Storage[self->Tail + HEADER_BYTES], data, size); + /* Little-endian write of the 2-byte length header into the uint8_t ring. */ + self->Storage[self->Tail] = (uint8_t) (size & 0xFFU); + self->Storage[self->Tail + 1U] = (uint8_t) ((size >> 8U) & 0xFFU); + (void) memcpy(&self->Storage[self->Tail + HEADER_BYTES], data, size); self->Tail += HEADER_BYTES + size; } diff --git a/Core/Source/SolidSyslogNullBuffer.c b/Core/Source/SolidSyslogNullBuffer.c index d64a44db..cf71bc5a 100644 --- a/Core/Source/SolidSyslogNullBuffer.c +++ b/Core/Source/SolidSyslogNullBuffer.c @@ -17,21 +17,21 @@ struct SolidSyslogNullBuffer struct SolidSyslogSender* Sender; }; -static struct SolidSyslogNullBuffer instance; +static struct SolidSyslogNullBuffer NullBuffer_Instance; struct SolidSyslogBuffer* SolidSyslogNullBuffer_Create(struct SolidSyslogSender* sender) { - instance.Base.Write = NullBuffer_Write; - instance.Base.Read = NullBuffer_Read; - instance.Sender = sender; - return &instance.Base; + NullBuffer_Instance.Base.Write = NullBuffer_Write; + NullBuffer_Instance.Base.Read = NullBuffer_Read; + NullBuffer_Instance.Sender = sender; + return &NullBuffer_Instance.Base; } void SolidSyslogNullBuffer_Destroy(void) { - instance.Base.Write = NULL; - instance.Base.Read = NULL; - instance.Sender = NULL; + NullBuffer_Instance.Base.Write = NULL; + NullBuffer_Instance.Base.Read = NULL; + NullBuffer_Instance.Sender = NULL; } static bool NullBuffer_Read(struct SolidSyslogBuffer* base, void* data, size_t maxSize, size_t* bytesRead) @@ -46,7 +46,7 @@ static bool NullBuffer_Read(struct SolidSyslogBuffer* base, void* data, size_t m static void NullBuffer_Write(struct SolidSyslogBuffer* base, const void* data, size_t size) { struct SolidSyslogNullBuffer* self = NullBuffer_SelfFromBase(base); - SolidSyslogSender_Send(self->Sender, data, size); + (void) SolidSyslogSender_Send(self->Sender, data, size); } static inline struct SolidSyslogNullBuffer* NullBuffer_SelfFromBase(struct SolidSyslogBuffer* base) diff --git a/DEVLOG.md b/DEVLOG.md index 871122a9..3919dd69 100644 --- a/DEVLOG.md +++ b/DEVLOG.md @@ -1,5 +1,125 @@ # Dev Log +## 2026-05-16 — S10.12 Pilot — Buffer group conformance + anonymous-enum policy (#381) + +First per-group conformance story in E10. Cleared all warning-mode +findings raised by `analyze-tidy` and `analyze-cppcheck` against +`SolidSyslogBuffer.{c,h}`, `SolidSyslogBufferDefinition.h`, +`SolidSyslogNullBuffer.{c,h}`, `SolidSyslogCircularBuffer.{c,h}` and +`SolidSyslogPosixMessageQueueBuffer.{c,h}`, and resolved the +anonymous-enum named-constant idiom question that had been a loose +thread since S10.07. + +### MISRA fixes — every site reviewed per the "no blind suppressions" bar + +- 4× rule 17.7 (`memcpy` return discarded) in + `SolidSyslogCircularBuffer.c` — `(void)` cast. +- 1× rule 17.7 in `SolidSyslogNullBuffer.c` — + `SolidSyslogSender_Send()` returns `bool`; NullBuffer is the + deliver-and-forget path, `Buffer_Write` itself returns `void`, + so the result has no propagation route. `(void)` cast. +- 1× rule 15.5 single-exit in + `CircularBuffer_RecordFitsAtTail` — restructured to one local + an + if/else, matching the project's documented "Production code + (Tier 1) — Single return per function" rule. +- 2× rule 5.9 TU-local-static name uniqueness — bare `instance` + collided across TUs. Renamed to `NullBuffer_Instance` and + `PosixMessageQueueBuffer_Instance` per the `Class_` Tier 2 + convention from S10.08. +- 1× rule 8.9 (advisory) — `static const char QUEUE_NAME_PREFIX[]` + in `SolidSyslogPosixMessageQueueBuffer.c` was referenced only + inside `_Create`. Moved to a block-scope `static const` + (Tier 3 `queueNamePrefix`), preserving read-only allocation. +- 2× rule 21.15 (new — fixing 17.7 unmasked it) — `memcpy(&header, + uint8_t*)` / `memcpy(uint8_t*, &header)` failed pointer-type + compatibility. Refactored the 16-bit length header to explicit + little-endian byte reads/writes — no `memcpy` between + mismatched types, no deviation needed. + +### Anonymous-enum policy — tree-wide decision + +The `enum { NAME = value };` idiom (no tag) is the project's +type-safe `#define` replacement. 101 sites tree-wide were flagged +by clang-tidy `readability-identifier-naming.EnumConstantPrefix` +because SCREAMING_SNAKE doesn't start with the `SolidSyslog` +Tier 1 prefix. The named-tag-enum sweep in S10.07 left this +question open. + +- **Decision:** the anonymous-enum form is *macro-equivalent*, + not Tier 1 / Tier 2 enum-constant-shaped. Casing follows the + macro convention: `SOLIDSYSLOG_*` for public sites, bare + `SCREAMING_SNAKE` for file-scope sites. clang-tidy's tagged-enum + rule (`SolidSyslog_Constant`) stays tight. +- **Implementation:** added `EnumConstantIgnoredRegexp: + ^[A-Z][A-Z0-9_]*$` in `.clang-tidy`. One regex change clears + all 101 sites without renaming any code. +- **MISRA 2.4 already deviated:** D.010 covers the cppcheck-misra + "unused tag" 2.4 finding that the anonymous-enum idiom triggers. + The buffer-file sites are new instances of the same documented + pattern — added to the D.010 suppressions list (count 6 → 8). + Not a new deviation; same rationale. +- **Docs:** `docs/NAMING.md` Macros section gained an + "Anonymous-enum named-constant idiom" subsection making the + policy explicit. `docs/misra-deviations.md` D.010 picked up a + clarifying line on why the project uses the suppressions list + rather than inline `cppcheck-suppress`. + +### Audit doc freeze + +`docs/misra-conformance.md` was the S10.05 audit working +document. With the cross-cutting sweeps complete (S10.07–S10.11 +and S10.21) and the per-group phase open, the audit is finished. +Added a frozen-header note pointing readers at the two live +sources of truth (`misra-deviations.md` for rationale, +`misra_suppressions.txt` for per-site state) and flagging the +file for deletion at S10.20 when the gates flip from warning to +error. + +### Decisions + +- **Bit-shifting over a memcpy deviation for 21.15.** David's + no-blind-suppressions bar pushed the question to: real fix or + documented deviation? Bit-shifting is ~6 lines, explicit + endianness, no rule firing, no rule pretence — strictly better + than `(void*)`-casting around the rule. +- **`(void) SolidSyslogSender_Send(...)` over propagating the bool.** + The NullBuffer is the synchronous "buffer = pass-through to + sender" path; `Buffer_Write` is the only caller and returns + `void`. Nowhere for the `bool` to go. Added a one-line comment + recording the rationale at the call site. +- **D.010 suppression count bumped 6 → 8, not a new deviation.** + Extending an existing well-documented deviation to new instances + of the same pattern is *not* a blind suppression — the rationale + in the doc already covers exactly this shape (the buffer + anonymous enums declare `SOLIDSYSLOG_CIRCULARBUFFER_OVERHEAD` + and `HEADER_BYTES`, structurally identical to the existing + `SOLIDSYSLOG_UDP_DEFAULT_PORT` example in the deviation doc). +- **Pilot validates the workflow.** "Run gates → review each + finding → fix or deviate (with rationale) → re-run → DEVLOG" + is the recipe S10.13–S10.19 will follow. No per-group status + table introduced — the gate output is binary, doesn't need + bookkeeping. + +### Pre-existing findings out of scope + +- 1× rule 2.5 on `Core/Interface/SolidSyslogFormatter.h:24` + (`SOLIDSYSLOG_ESCAPED_MAX_SIZE` macro) — only fires when + cppcheck sees the header without `Formatter.c` in scope. + Full-tree CI run does not report it. Will be picked up under + the Formatter group story. + +### Deferred + +- The remaining 99 SCREAMING_SNAKE anonymous-enum sites tree-wide + do not need any change — the .clang-tidy regex change clears + them automatically. The corresponding 6 existing 2.4 D.010 + sites are unaffected; the 2 new buffer sites are added to the + suppressions list. + +### Open questions + +- None. + ## 2026-05-16 — S10.11 this-pointer convention (`self`/`base`) + `SelfFromBase`/`SelfFromStorage` helpers (#377) E10 cross-cutting sweep. Standardises the this-pointer parameter diff --git a/Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c b/Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c index 5106c315..5711857b 100644 --- a/Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c +++ b/Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c @@ -16,8 +16,6 @@ enum OWNER_READ_WRITE = 0x180U }; -static const char QUEUE_NAME_PREFIX[] = "/solidsyslog_"; - static bool PosixMessageQueueBuffer_Read(struct SolidSyslogBuffer* base, void* data, size_t maxSize, size_t* bytesRead); static void PosixMessageQueueBuffer_Write(struct SolidSyslogBuffer* base, const void* data, size_t size); @@ -33,39 +31,45 @@ struct SolidSyslogPosixMessageQueueBuffer size_t MaxMessageSize; }; -static struct SolidSyslogPosixMessageQueueBuffer instance; +static struct SolidSyslogPosixMessageQueueBuffer PosixMessageQueueBuffer_Instance; static inline const char* PosixMessageQueueBuffer_QueueName(void) { - return SolidSyslogFormatter_AsFormattedBuffer(SolidSyslogFormatter_FromStorage(instance.NameStorage)); + return SolidSyslogFormatter_AsFormattedBuffer( + SolidSyslogFormatter_FromStorage(PosixMessageQueueBuffer_Instance.NameStorage) + ); } // NOLINTNEXTLINE(bugprone-easily-swappable-parameters) -- distinct semantic meaning; struct wrapper would over-engineer struct SolidSyslogBuffer* SolidSyslogPosixMessageQueueBuffer_Create(size_t maxMessageSize, long maxMessages) { - instance = (struct SolidSyslogPosixMessageQueueBuffer) {0}; + static const char queueNamePrefix[] = "/solidsyslog_"; + + PosixMessageQueueBuffer_Instance = (struct SolidSyslogPosixMessageQueueBuffer) {0}; - struct SolidSyslogFormatter* name = SolidSyslogFormatter_Create(instance.NameStorage, MAX_NAME_SIZE); - SolidSyslogFormatter_BoundedString(name, QUEUE_NAME_PREFIX, sizeof(QUEUE_NAME_PREFIX) - 1U); + struct SolidSyslogFormatter* name = + SolidSyslogFormatter_Create(PosixMessageQueueBuffer_Instance.NameStorage, MAX_NAME_SIZE); + SolidSyslogFormatter_BoundedString(name, queueNamePrefix, sizeof(queueNamePrefix) - 1U); SolidSyslogPosixProcessId_Get(name); struct mq_attr attr = {0}; attr.mq_maxmsg = maxMessages; attr.mq_msgsize = (long) maxMessageSize; - instance.Mq = mq_open(PosixMessageQueueBuffer_QueueName(), O_CREAT | O_RDWR | O_NONBLOCK, OWNER_READ_WRITE, &attr); - instance.MaxMessageSize = maxMessageSize; - instance.Base.Write = PosixMessageQueueBuffer_Write; - instance.Base.Read = PosixMessageQueueBuffer_Read; + PosixMessageQueueBuffer_Instance.Mq = + mq_open(PosixMessageQueueBuffer_QueueName(), O_CREAT | O_RDWR | O_NONBLOCK, OWNER_READ_WRITE, &attr); + PosixMessageQueueBuffer_Instance.MaxMessageSize = maxMessageSize; + PosixMessageQueueBuffer_Instance.Base.Write = PosixMessageQueueBuffer_Write; + PosixMessageQueueBuffer_Instance.Base.Read = PosixMessageQueueBuffer_Read; - return &instance.Base; + return &PosixMessageQueueBuffer_Instance.Base; } void SolidSyslogPosixMessageQueueBuffer_Destroy(void) { - mq_close(instance.Mq); + mq_close(PosixMessageQueueBuffer_Instance.Mq); mq_unlink(PosixMessageQueueBuffer_QueueName()); - instance = (struct SolidSyslogPosixMessageQueueBuffer) {0}; + PosixMessageQueueBuffer_Instance = (struct SolidSyslogPosixMessageQueueBuffer) {0}; } static bool PosixMessageQueueBuffer_Read(struct SolidSyslogBuffer* base, void* data, size_t maxSize, size_t* bytesRead) diff --git a/docs/NAMING.md b/docs/NAMING.md index d52ff63d..11b2bfdf 100644 --- a/docs/NAMING.md +++ b/docs/NAMING.md @@ -541,6 +541,40 @@ pressure from rule 5.4.) **Exceptions:** CppUTest's `TEST`, `TEST_GROUP`, `CHECK_*`, `LONGS_EQUAL`, etc. are used unmodified — see Tests below. +### Anonymous-enum named-constant idiom + +`enum { NAME = value };` (an enum with no tag) is the project's +type-safe alternative to `#define` for integer constants. The form is +distinct from tagged enums (Tier 1 `SolidSyslog` tags with +`SolidSyslog_Constant` members) in both shape and purpose — an +anonymous enum is a macro replacement, not a public type. + +```c +/* Public, in a header — Tier 1 macro-equivalent */ +enum +{ + SOLIDSYSLOG_CIRCULARBUFFER_OVERHEAD = 7, + SOLIDSYSLOG_CIRCULARBUFFER_HEADER_BYTES = sizeof(uint16_t) +}; + +/* File-scope, in a .c — Tier 2 macro-equivalent */ +enum +{ + HEADER_BYTES = SOLIDSYSLOG_CIRCULARBUFFER_HEADER_BYTES +}; +``` + +Casing follows the **macro** convention, not the enum-constant +convention: `SOLIDSYSLOG_*` for public sites, bare `SCREAMING_SNAKE` +for file-scope sites. clang-tidy's `EnumConstantIgnoredRegexp` accepts +this shape so the rule for tagged-enum constants +(`SolidSyslog_Constant`) stays tight without forcing rename of +the macro-replacement form. + +MISRA rule 2.4 (unused tag declarations) cppcheck-fires on anonymous +enums even though they have no tag. The project-wide deviation **D.010** +covers all such sites — see `docs/misra-deviations.md#d010`. + --- ## Tests diff --git a/docs/misra-conformance.md b/docs/misra-conformance.md index b399e717..072c021e 100644 --- a/docs/misra-conformance.md +++ b/docs/misra-conformance.md @@ -1,5 +1,19 @@ # Conformance audit and backlog +> **Frozen — audit complete (S10.05–S10.11 + S10.21 landed, per-group +> phase began with S10.12).** This document is the working record of +> the E10 audit. With the cross-cutting sweeps done and per-group +> conformance underway, the audit phase is closed. The live truth is +> CI plus the two source-of-truth documents: +> +> - `docs/misra-deviations.md` — the deviation rationales and +> approvals. New per-site suppressions land here, not in this doc. +> - `misra_suppressions.txt` — the cppcheck-misra suppressions list. +> +> No further per-rule updates are expected here. Expect to delete +> this file at S10.20 when the gates flip from warning to error and +> the suppressions list becomes the single live record. + Working document tracking the naming and MISRA C:2012 violations currently surfaced by clang-tidy and cppcheck-misra against the SolidSyslog tree, with a per-rule proposed verdict that feeds the diff --git a/docs/misra-deviations.md b/docs/misra-deviations.md index efab8e99..3e3e0256 100644 --- a/docs/misra-deviations.md +++ b/docs/misra-deviations.md @@ -668,9 +668,12 @@ enum There are approximately 31 such declarations across `Core/` and `Platform/*/Source/`. cppcheck-misra surfaces a subset (currently -6) under rule 2.4 once the rule 5.7 suppressions (D.003) take +8) under rule 2.4 once the rule 5.7 suppressions (D.003) take effect; before then, the 5.7 check absorbs the same sites and -masks the 2.4 finding. +masks the 2.4 finding. Adding inline-suppress comments at every +site would add visual noise next to a project-wide intentional +idiom — listing them in `misra_suppressions.txt` under this +deviation keeps the source clean. ### Scope diff --git a/misra_suppressions.txt b/misra_suppressions.txt index 18984a2d..55ee4263 100644 --- a/misra_suppressions.txt +++ b/misra_suppressions.txt @@ -59,7 +59,7 @@ misra-c2012-11.3:Platform/Posix/Source/SolidSyslogAddressInternal.h:24 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixDatagram.c:76 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixFile.c:74 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixFile.c:91 -misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c:92 +misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixMessageQueueBuffer.c:96 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixMutex.c:37 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixMutex.c:50 misra-c2012-11.3:Platform/Posix/Source/SolidSyslogPosixTcpStream.c:95 @@ -181,10 +181,12 @@ misra-c2012-21.6:Platform/Windows/Source/SolidSyslogWindowsFile.c:8 # D.010 — Rule 2.4: anonymous enum used as named-constant container # See docs/misra-deviations.md#d010 misra-c2012-2.4:Core/Interface/SolidSyslogBlockStore.h:52 +misra-c2012-2.4:Core/Interface/SolidSyslogCircularBuffer.h:19 misra-c2012-2.4:Core/Interface/SolidSyslogSecurityPolicyDefinition.h:13 misra-c2012-2.4:Core/Interface/SolidSyslogTransport.h:5 misra-c2012-2.4:Core/Source/BlockSequence.c:6 misra-c2012-2.4:Core/Source/BlockSequence.c:92 +misra-c2012-2.4:Core/Source/SolidSyslogCircularBuffer.c:14 misra-c2012-2.4:Core/Source/SolidSyslogStreamSender.c:27 # D.011 — Rule 20.10: `#` stringification in _Static_assert polyfill